gecko-dev/lib/libaddr/abcpane.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

#include "xp.h"

#include "abcpane.h"
#include "abcinfo.h"
#include "abpane2.h"
#include "xp_qsort.h"

extern "C"
{
extern int MK_MSG_ADD_NAME;
extern int MK_MSG_ADD_LIST;
extern int XP_BKMKS_IMPORT_ADDRBOOK;
extern int XP_BKMKS_SAVE_ADDRBOOK;
extern int MK_MSG_CALL;
extern int MK_ADDR_NO_EMAIL_ADDRESS; 
extern int MK_ADDR_DEFAULT_EXPORT_FILENAME;
extern int MK_ADDR_ADD;
extern int MK_MSG_ADDRESS_BOOK;
extern int MK_ACCESS_NAME;
extern int MK_MSG_PROPERTIES;
extern int XP_FILTER_DELETE;
extern int MK_ADDR_DELETE_ALL;
}


/*********************************************************************************************
	 Notification handlers
**********************************************************************************************/

void AB_ContainerPane::OnAnnouncerGoingAway(AB_ContainerAnnouncer * instigator)
{
	// do we need to remove the container from our view? Probably not as this will generate needless notifications
	// since the container can only go away if we have released our reference count to it. Which in turn means that
	// we are going away. Thus, no need to remove the container from our view...but we do want to remove ourselves
	// as a listener to the announcer for clean up purposes..

	// determine if the ctr is in the ctr pane. If it is, remove and delete it
	MSG_ViewIndex index = m_containerView.FindIndex (0, (void *) instigator);
	if (index != MSG_VIEWINDEXNONE) // did it find a match?
	{
		AB_ContainerInfo * ctrToRemove = GetContainerForIndex((MSG_ViewIndex) index);
		if (ctrToRemove)
		{
			StartingUpdate(MSG_NotifyInsertOrDelete, (MSG_ViewIndex) index, -1);
			m_containerView.RemoveAt(index);
			EndingUpdate(MSG_NotifyInsertOrDelete, (MSG_ViewIndex) index, -1);
		
			ctrToRemove->RemoveListener(this);
			ctrToRemove->Release();
		}
	}
}

void AB_ContainerPane::OnContainerAttribChange(AB_ContainerInfo * ctr, AB_NOTIFY_CODE code, AB_ContainerListener * instigator)
{
	if (instigator != this) // if we changed it then don't generate another update
	{
		// find the index for the ctr
		MSG_ViewIndex index = GetIndexForContainer(ctr);
		if (index != MSG_VIEWINDEXNONE)  // does it really exist?
		{
			if (code == AB_NotifyPropertyChanged)
			{
				// update the front ends for this view index
				StartingUpdate(MSG_NotifyChanged, index, 1);
				EndingUpdate(MSG_NotifyChanged, index, 1);
			}
		}

	}
	return;
}

void AB_ContainerPane::OnContainerEntryChange(AB_ContainerInfo * ctr, AB_NOTIFY_CODE code, ABID entryID, AB_ContainerListener * instigator)
{
	// do we have to do anything if the entry was a mailing list? It might effect something in the container pane....
	// need to find out if the effected entry is a mailing list currently in the container pane

	if (instigator != this)
	{
		MSG_ViewIndex index = GetIndexForContainer(ctr);  // make sure we care about this container...

		if (index != MSG_VIEWINDEXNONE /* && IsExpanded(index) */) // only time ctr is showing entry content: when it is expanded
		{
			XP_Bool isAList = FALSE;
			AB_AttributeValue * value = NULL;
			switch (code)
			{
				case AB_NotifyInserted:
					if (ctr && entryID != AB_ABIDUNKNOWN)
						ctr->GetEntryAttribute(this, entryID, AB_attribEntryType, & value);
					if (value && value->u.entryType == AB_MailingList)
					{
						isAList = TRUE;
						AB_FreeEntryAttributeValue(value);
					}
					if (isAList)
					{
						StartingUpdate(MSG_NotifyChanged, index, 1);
						// if entry was a list, we need to insert it into the view
						if (IsExpanded(index))
							InsertEntryIntoExpandedList(index, ctr, entryID);
						EndingUpdate(MSG_NotifyChanged, index, 1);
					}
					break;
				case AB_NotifyAll:
				case AB_NotifyDeleted: // if an entry was deleted from the ctr it may effect the flippy state of the ctr
					StartingUpdate(MSG_NotifyChanged, index, 1);
					EndingUpdate(MSG_NotifyChanged, index, 1);
					break;
				default:
					break;
			}
		}
	}
}

void AB_ContainerPane::DeleteEntryFromExpandedList(MSG_ViewIndex index, AB_ContainerInfo * ctr, ABID listID)
{
	// make sure listID is a list or else you will be wasting your time.
	if (index != MSG_VIEWINDEXNONE && ctr && listID != AB_ABIDUNKNOWN && IsExpanded(index))
	{
		uint32 numVisibleChildren = NumVisibleChildrenForIndex(index);

		// get array of child ctrs
		int32 numChildren = GetNumChildrenForIndex(index);
		AB_ContainerInfo ** arrayOfContainers = (AB_ContainerInfo **) XP_ALLOC(sizeof(AB_ContainerInfo *) * numChildren);
		if (arrayOfContainers)
		{
			ctr->AcquireChildContainers(arrayOfContainers, &numChildren); // acquire containers for the children
			uint32 cnt = 0;
			for (MSG_ViewIndex pos = index + 1; pos < (uint32) m_containerView.GetSize() && cnt < numVisibleChildren; cnt++, pos++)
			{
				AB_ContainerInfo * visibleCtr = GetContainerForIndex(pos);
				// search for ctr in child ctr array
				XP_Bool found = FALSE;
				for (int32 i = 0; i < numChildren; i++)
					if (arrayOfContainers[i] == visibleCtr)
						found = TRUE;

				if (!found && visibleCtr) // then list has gone away so remove it...
				{
					StartingUpdate(MSG_NotifyInsertOrDelete, pos, -1);
					m_containerView.RemoveAt(pos);
					visibleCtr->RemoveListener(this);  // register ourselves as a listener on the container...
					visibleCtr->Release();
					EndingUpdate(MSG_NotifyInsertOrDelete, pos, -1);
					pos--; // decrement position because we removed something from the view
				}
			}
			
			// release child ctrs
			for (int32 i = 0; i < numChildren; i++)
				if (arrayOfContainers[i])
					arrayOfContainers[i]->Release();
			XP_FREE(arrayOfContainers);
		}
			
	}
	
}

uint32 AB_ContainerPane::NumVisibleChildrenForIndex(MSG_ViewIndex index)
// a  helper function used by InsertEntryIntoExpandedList and DeleteEntryFromExpandedList to determine how many visible children
// are currently showing in the view. 
{
	// children are always mailing lists....
	uint32 numVisibleChildren = 0;
	XP_Bool finished = FALSE;
	for (MSG_ViewIndex pos = index+1; pos < (uint32) m_containerView.GetSize() && !finished; pos++)
	{
		AB_ContainerInfo * child = GetContainerForIndex(pos);
		if (child && child->IsDirectory())
			finished = TRUE;
		else numVisibleChildren++;
	}

	return numVisibleChildren;
}

void AB_ContainerPane::InsertEntryIntoExpandedList(MSG_ViewIndex index /* index for ctr */, AB_ContainerInfo * ctr, ABID listID)
{
	// you should make sure entryID is a mailing list inside of ctr b4 calling this.
	// you woon't get burned if you don't, but you will be wasting your time....
	// *sigh* I think this function is way too complicated for its function but cannot think of a 
	// faster way
	if (index != MSG_VIEWINDEXNONE && ctr && listID != AB_ABIDUNKNOWN)
	{
		// get child array for ctr, find ctr with our entryID. its position in the array 
		// determines where it should be inserted into the expanded list...

		// first, determine number of children currently in the view...
		uint32 numVisibleChildren = NumVisibleChildrenForIndex(index);

		// find position of inserted entry in the list
		AB_ContainerInfo * newCtr = NULL;
		AB_ContainerInfo::Create(m_context, ctr, listID, &newCtr);
		
		// make sure newCtr is not already in our container pane...this can happen when you add a new mailng list
		// to another mailing list. We get an insert from the address book and we get an insert from the mailing 
		// list ctr we are adding it to....
		MSG_ViewIndex currentIndex = GetIndexForContainer(newCtr);

		if (newCtr && currentIndex == MSG_VIEWINDEXNONE) // does the new mailing list really exist and is it not in our view alreaady
		{
			// now get the child ctrs for the ctr
			int32 numChildren = GetNumChildrenForIndex(index);
			AB_ContainerInfo ** arrayOfContainers = (AB_ContainerInfo **) XP_ALLOC(sizeof(AB_ContainerInfo *) * numChildren);
			if (arrayOfContainers)
			{
				ctr->AcquireChildContainers(arrayOfContainers, &numChildren);		   // acquire containers for the childre
				// find position of our new ctr in the child array...
				uint32 offset = 0;
				XP_Bool found = FALSE;
				for (offset = 0; offset < (uint32) numChildren && !found; offset++)
					if (arrayOfContainers[offset] == newCtr) // same object?
						found = TRUE;

				if (found) // if it wasn't in the list then something very bad happened
				{
					if (offset > numVisibleChildren)  // reset our offset if it is > than the # children currently showing.
						offset = numVisibleChildren;
					MSG_ViewIndex insertPosition = offset + index + 1; // start with index for first child ctr & add our offset to this
					StartingUpdate(MSG_NotifyInsertOrDelete, insertPosition, 1);
					m_containerView.InsertAt(insertPosition, (void *) newCtr);
					newCtr->AddListener(this);  // register ourselves as a listener on the container...
					EndingUpdate(MSG_NotifyInsertOrDelete, insertPosition,1);
				}
				else
					newCtr->Release();
				// now release all acquired children
				for (int32 i = 0; i < numChildren; i++)
					if (arrayOfContainers[i])
						arrayOfContainers[i]->Release();

				XP_FREE(arrayOfContainers);
			}
		}
		else
			if (newCtr)
				newCtr->Release();
	}
}


AB_ContainerPane::AB_ContainerPane(MWContext * context, MSG_Master * master) : MSG_LinedPane(context, master), AB_ABIDBasedContainerListener(), AB_PaneAnnouncer()
{
	m_context = context;
	m_master = master;
}

AB_ContainerPane::~AB_ContainerPane()
{
	NotifyAnnouncerGoingAway(this);  // let any pane listener's know we are going away! i.e. any property sheets opened from the ctr pane

	// we are no longer listeners on the containers since we are going away,
	// let's remove ourselves!

	for (int i = 0; i < m_containerView.GetSize(); i++)
	{
		AB_ContainerInfo * ctr = m_containerView.GetAt(i);
		if (ctr)
		{
			ctr->RemoveListener(this);
			ctr->Release();  // release our reference count to this container
		}
	}

	// make sure our new directory server cache is empty!
	for (int j = 0; j < m_newEntries.GetSize(); j++)
	{
		AB_NewDIREntry * entry = m_newEntries.GetAt(j);
		if (entry)
			XP_FREE(entry);
	}

}

int AB_ContainerPane::Close(AB_ContainerPane * pane)
{
	if (pane)
		delete pane;
	return AB_SUCCESS;
}


/* static */ void AB_ContainerPane::Create(MSG_Pane ** abcPane, MWContext * context, MSG_Master * master)
{
	AB_ContainerPane * newPane = new AB_ContainerPane(context, master);
	(*abcPane) = newPane;
}

int AB_ContainerPane::Initialize()
{
	// how do we get the global list of DIR_Servers?? 
	XP_List * dirServers = DIR_GetDirServers();  // get ref counted list of the dir servers...
	int errorCode = AB_SUCCESS;

	DIR_Server * server = NULL;

	do
	{
		server = (DIR_Server *) XP_ListNextObject(dirServers);
		if (server)
			errorCode = AddDirectory(server);
	} while (server);
	
	// if we had a memory problem or something, we'll catch the last one and return it. 
	return errorCode;  // will eventually load up the global containers from the database
}

int AB_ContainerPane::GetNumRootContainers(int32 * numRootContainers)
{
	// eventually we want to go through all containers in view and count all root ones...

	// for now, all ctrs in the pane are "root" container because I'm not supporting mailing lists
	// yet. 
	int numRootCtrs = 0;
	for (int i = 0; i < m_containerView.GetSize(); i++)
		if (m_containerView.GetAt(i)->IsDirectory())  // directory containers are root containers!
			numRootCtrs++;

	*numRootContainers = numRootCtrs;
	return AB_SUCCESS;
}

int AB_ContainerPane::GetOrderedRootContainers(AB_ContainerInfo ** ctrArray, int32 * numCtrs)
{
	// will eventually traverse all containers in the view and insert container info into array
	// if it is a root container...

	// FE has allocated this array so just fill it.
	int32 i;
	int32 numAdded = 0; 
	for (i = 0; i < m_containerView.GetSize() && numAdded < *numCtrs; i++)
		if (m_containerView.GetAt(i)->IsDirectory())
			ctrArray[numAdded++] = m_containerView.GetAt(i);

	*numCtrs = numAdded;
	return AB_SUCCESS;
}

void AB_ContainerPane::NotifyPrefsChange (NotifyCode /* code */)
{
	return;
}

MSG_ViewIndex AB_ContainerPane::GetIndexForContainer(AB_ContainerInfo * ctr)
{
	if (ctr)
	{
		// look for the pointer in our view
		for (int i = 0; i < m_containerView.GetSize(); i++)
			if (ctr == m_containerView.GetAt(i))
				return i;  // found the index!
	}
	return MSG_VIEWINDEXNONE;
}

AB_ContainerInfo * AB_ContainerPane::GetContainerForIndex(const MSG_ViewIndex index)
{
	// look for the index in our container view.
	if (m_containerView.IsValidIndex(index))
		return m_containerView.GetAt(index);
	else
		return NULL;
}

int AB_ContainerPane::UpdateDIRServer(DIR_Server * directory)
{
	AB_ContainerInfo * ctr;
	XP_Bool match = FALSE;
	int errorCode = AB_SUCCESS;

	// examine the DIR_Server for each container in the pane
	for (int i = 0; i < m_containerView.GetSize() && !match; i++)
	{
		ctr = m_containerView.GetAt(i);
		if (ctr->IsDirectory())  // PAB or LDAP
			if (directory == ctr->GetDIRServer())
			{
				match = TRUE;
				ctr->UpdateDIRServer();
			}
	}

	if (!match)  // if we didn't find it, we need to create a new container!
		errorCode = AddNewDirectory(directory);
	return errorCode;
}

// always use this routine when adding directories AFTER we have already built the container pane..
// that is any new directories that need turned into containers and added to the DIR_Server list.
int AB_ContainerPane::AddNewDirectory(DIR_Server * directory)  // add this to the end of the container pane
{
	AB_ContainerInfo * ctr = NULL;
	DIR_SetServerFileName(directory, directory->fileName); // generates a file name if there isn't one already
	int errorCode = AB_ContainerInfo::Create(m_context, directory, &ctr); // all ctr info's are referenced counted
	if (errorCode == AB_SUCCESS)
	{
		// look up dir server in our cache to get the positiion
		MSG_ViewIndex position = GetDesiredPositionForNewServer(directory);
		RemoveFromNewServerCache(directory);
		AddNewContainer(position, ctr);
	}

	return errorCode;
}

// Always use this routine when all we want to do is turn directory into a container and add it to the end of
// the view. It is only called during Initialization!!! DIR_Server list is untouched!! 
// USE AddNewDirectory to add directories not part of the initialization process!
int AB_ContainerPane::AddDirectory(DIR_Server * directory)
{
	AB_ContainerInfo * ctr = NULL;
	int errorCode = AB_ContainerInfo::Create(m_context, directory, &ctr); // all ctr info's are referenced counted
	int position = m_containerView.GetSize();
	if (ctr)
	{
		StartingUpdate(MSG_NotifyInsertOrDelete, position, 1);
		m_containerView.Add(ctr);
		ctr->AddListener(this);
		EndingUpdate(MSG_NotifyInsertOrDelete, position, 1);
	}

	return errorCode;
}

int AB_ContainerPane::GetContainerAttributes(MSG_ViewIndex index, AB_ContainerAttribute * attribsArray, AB_ContainerAttribValue ** valuesArray,
											 uint16 * numItems)
{
	AB_ContainerInfo * ctr = GetContainerForIndex(index);
	if (ctr)
		return ctr->GetAttributes(attribsArray, valuesArray, numItems);
	else
		return AB_INVALID_CONTAINER;
}

int AB_ContainerPane::SetContainerAttributes(MSG_ViewIndex index, AB_ContainerAttribValue * valuesArray, uint16 numItems)
{
	AB_ContainerInfo *ctr = GetContainerForIndex(index);
	if (ctr)
		return ctr->SetAttributes(valuesArray, numItems);
	else
		return AB_INVALID_CONTAINER;
}


MSG_PaneType AB_ContainerPane::GetPaneType()
{
	return AB_CONTAINERPANE;
}

int32 AB_ContainerPane::GetNumChildrenForIndex(MSG_ViewIndex line)
{
	AB_ContainerInfo * ctr = GetContainerForIndex(line);
	if (ctr)
		return ctr->GetNumChildContainers();  // we could go throug the attribute value methods but this is faster..
	else
		return 0;
}

void AB_ContainerPane::ToggleExpansion(MSG_ViewIndex line, int32 * numChanged)
{
	StartingUpdate(MSG_NotifyChanged, line, 1);

	if (IsExpanded(line))
		CollapseContainer(line, numChanged);
	else
		ExpandContainer(line, numChanged);

	// now do a notify changed on the modified line...
	EndingUpdate(MSG_NotifyChanged, line, 1);
}

// returns TRUE if the container is expanded. FALSE otherwise.
XP_Bool AB_ContainerPane::IsExpanded(MSG_ViewIndex line)
{
	AB_ContainerInfo * ctr = GetContainerForIndex(line);
	if (ctr)
	{
		AB_ContainerInfo * nextCtr = GetContainerForIndex(++line);
		// I'm going to try a quick hack..if the next ctr is a mailing list then it must be expanded already
		// Why? because non directory containers are the only ctrs which are not root containers.
		// If it doesn't work, we can always write a more complicated method here..
		if (nextCtr && !nextCtr->IsDirectory())
			return TRUE;  // next ctr is a non-directory ctr so we must be expanded.
	}
	
	return FALSE;
}

int32 AB_ContainerPane::ExpansionDelta(MSG_ViewIndex line)
{
	AB_ContainerInfo * ctr = GetContainerForIndex(line);
	int32 numChildren = 0;

	if (ctr) // does it exist?
	{
		// how many children does the container have....
		numChildren = GetNumChildrenForIndex(line);
		if (numChildren > 0)
		{
			if (IsExpanded(line))
				return - (numChildren);
			else
				return numChildren;
		}
	}
	return 0;  // if we fell out then assume 0 children
}

int32 AB_ContainerPane::GetNumLines()
{
	return m_containerView.GetSize();
}

int32 AB_ContainerPane::GetContainerMaxDepth()
{
	return 0;
}

void AB_ContainerPane::CollapseContainer(MSG_ViewIndex line, int32 * numChanged)
{
	int32 changedCount = 0; // # ctrs removed...

	// first, make sure it is expanded..redundant call I know, but you never know!
	if (IsExpanded(line))
	{
		// how many children does the container have....
		int32 numChildren = GetNumChildrenForIndex(line);
		if (numChildren > 0)
		{
			// okay, remove each ctr from the view and release it...
			StartingUpdate(MSG_NotifyInsertOrDelete, line+1, -1 * numChildren);
			MSG_ViewIndex removeLine = line+1;
			for (int32 i = 0; i < numChildren; i++)
			{
				AB_ContainerInfo * childCtr = GetContainerForIndex(removeLine); // remove line doesn't change...
				if (childCtr)
				{
					m_containerView.Remove(childCtr);
					childCtr->RemoveListener(this);
					childCtr->Release();  // we are done with it...release it
					changedCount++;
				}
			}
			EndingUpdate(MSG_NotifyInsertOrDelete, line+1, -1 * numChildren);
		}

	}
	
	if (numChanged)
		*numChanged = changedCount;
}

void AB_ContainerPane::ExpandContainer(MSG_ViewIndex line, int32 * /*numChanged*/)
{
	// we are going to write this method to assume that the line could already be expanded, 
	// but the expansion may not be up to date. (More or fewer). So we will generate 
	// individual notifications as lines are added or removed during the expansion. 
	AB_ContainerInfo * ctr = GetContainerForIndex(line);

	if (!IsExpanded(line) && ctr)  // make sure we aren't already expanded
	{
		int32 numChildren = GetNumChildrenForIndex(line);
		// we need to get ctr info's for all of the children!
		if (numChildren > 0)
		{
			AB_ContainerInfo ** arrayOfContainers = (AB_ContainerInfo **) XP_ALLOC(sizeof(AB_ContainerInfo *) * numChildren);
			if (arrayOfContainers)
			{
				MSG_ViewIndex startPosition = line+1;

				StartingUpdate(MSG_NotifyInsertOrDelete, startPosition, numChildren);  // generate notification for FEs
				ctr->AcquireChildContainers(arrayOfContainers, &numChildren);		   // acquire containers for the childre

				for (int i = 0; i < numChildren; i++)  // add each container to our pane
					if (arrayOfContainers[i])
					{
						m_containerView.InsertAt(++line, (void *) arrayOfContainers[i]);
						((AB_ContainerInfo *) arrayOfContainers[i])->AddListener(this); // add ourselves to the listener list
					}

				EndingUpdate(MSG_NotifyInsertOrDelete, startPosition, numChildren);
				XP_FREE(arrayOfContainers);
			}
		}
	}
}

XP_Bool AB_ContainerPane::AddToNewServerCache(DIR_Server * server, MSG_ViewIndex desiredPosition)
// we just created a new DIR_Server. It will be committed to the view at some later time, but for now
// we want to save the position where it should be inserted!
{
	AB_NewDIREntry * entry = (AB_NewDIREntry *) XP_ALLOC(sizeof(AB_NewDIREntry));
	if (entry)
	{
		entry->server = server;
		entry->desiredPosition = desiredPosition;

		m_newEntries.Add(entry);
		return TRUE;
	}

	return FALSE;
}

XP_Bool AB_ContainerPane::RemoveFromNewServerCache(DIR_Server * server)
{
	for (int i = 0; i < m_newEntries.GetSize(); i++)
	{
		AB_NewDIREntry * entry = m_newEntries.GetAt(i);
		if (entry)
			if (entry->server == server)
			{
				m_newEntries.RemoveAt(i);
				XP_FREE(entry);
				return TRUE;
			}
	}
	return FALSE;
}

MSG_ViewIndex AB_ContainerPane::GetDesiredPositionForNewServer(DIR_Server * server)
{
	if (server)
	{
		for (int i = 0; i < m_newEntries.GetSize(); i++)
		{
			AB_NewDIREntry * entry = m_newEntries.GetAt(i);
			if (entry)
				if (entry->server == server)
					return entry->desiredPosition;
		}
	}

	return MSG_VIEWINDEXNONE;
}

MSG_ViewIndex AB_ContainerPane::ExtractInsertPosition(MSG_ViewIndex desiredPosition)
{
	// now find out if known position is a directory or not...if not advance until we hit the end or we hit
	// a directory container (LDAP or PAB)
	XP_Bool found = FALSE;
	MSG_ViewIndex position = desiredPosition;
	position++; // we want to insert it after whatever the selected position was...
	AB_ContainerInfo * insertAfterCtr = NULL;
	while (m_containerView.IsValidIndex(position) && !found && position != MSG_VIEWINDEXNONE)
	{
		insertAfterCtr = GetContainerForIndex(position);
		if (insertAfterCtr && insertAfterCtr->IsDirectory())
			found = TRUE;
		else
			position++;
	}

	if (m_containerView.IsValidIndex(position) && position != MSG_VIEWINDEXNONE)  // are we still a valid insertion index?
		return position;
	else
		return MSG_VIEWINDEXNONE;
}

  DIR_Server * AB_ContainerPane::ExtractServerPosition(MSG_ViewIndex desiredPosition)
 {
	// okay, we need to find the directory container which is at or comes before the desired position
	XP_Bool found = FALSE;
	MSG_ViewIndex position = desiredPosition;
	AB_ContainerInfo * insertAfterCtr = NULL;
	while (m_containerView.IsValidIndex(position) && position != MSG_VIEWINDEXNONE && !found)
	{
		insertAfterCtr = GetContainerForIndex(position);
		if (insertAfterCtr && insertAfterCtr->IsDirectory())
			found = TRUE;
		else
			position--;  // go back to the previous container
	}

	if (found)
		return insertAfterCtr->GetDIRServer();
	else
		return NULL;  // will insert at bottom of the list
}


void AB_ContainerPane::AddNewContainer(MSG_ViewIndex position, AB_ContainerInfo * ctr)
// Call this when you want to insert a new PAB or LDAP directory into the container pane. We attempt to 
// insert the container in the position AFTER the one provided. This method 
// also modifies the DIR_Servers list, adding the new directory as well.Assumes ctr has already been ref counted!!!!!
{
	if (ctr)
	{
		if (ctr->IsDirectory())
		{
			// okay, finding the insertion point is complicated by the fact that we must insert after the last
			// directory container which comes after the position index and not just the container the position index
			// points too.

			// we have two positions: (1) position in the DIR_Server list (not the same as the ctr pane view which shows
			// mailing lists and (2) the index in the ctr pane to insert the new ctr into

			DIR_Server * insertAfter= ExtractServerPosition(position);
			XP_List * servers = DIR_GetDirServers();
			XP_ListInsertObjectAfter(servers, insertAfter, ctr->GetDIRServer());  // add to DIR_Server List
			// now save the list...
			DIR_SaveServerPreferences(servers);
		}
	
		
		MSG_ViewIndex insertPosition = ExtractInsertPosition(position);
		// now add it to our container view as well.
		insertPosition = insertPosition == MSG_VIEWINDEXNONE ? m_containerView.GetSize() : insertPosition;
		StartingUpdate(MSG_NotifyInsertOrDelete, insertPosition, 1);
		m_containerView.InsertAt(insertPosition, (void *) ctr);
		ctr->AddListener(this);  // register ourselves as a listener on the container...
		EndingUpdate(MSG_NotifyInsertOrDelete, insertPosition,1);
	}
}

int AB_ContainerPane::ShowProperties(MSG_ViewIndex * indices, int32 numIndices)
{
	for (int32 i = 0; i < numIndices; i++)
	{
		AB_ContainerInfo * ctr = GetContainerForIndex(indices[i]);
		if (ctr)
			if (ctr->GetType() == AB_MListContainer)
				ShowPropertySheet(&indices[i], 1);
			else
				ShowDirectoryProperties(&indices[i], 1);
	}
	return AB_SUCCESS;
}

int AB_ContainerPane::ShowDirectoryProperties(MSG_ViewIndex * indices, int32 numIndices)
{
	// general comment: we don't care if the directory is a PAB or LDAP directory. They all look the
	// same at this level. 
	if (m_DirectoryPropSheetFunc)
	{
		for (int i = 0; i < numIndices; i++)
		{
			AB_ContainerInfo * ctr = GetContainerForIndex(indices[i]);
			if (ctr)
				if (ctr->IsDirectory())
				{
					DIR_Server * server = ctr->GetDIRServer();
					if (server)
						m_DirectoryPropSheetFunc(server, m_context, this, FALSE);
				}
		}
	}

	return AB_SUCCESS;
}

int AB_ContainerPane::ShowNewDirectoryProperties(AB_CommandType cmd, MSG_ViewIndex * indices, int32 numIndices)
{
	// if numIndices > 1 then stick them at the end....
	// if we have zero indices, stick them at the end...
	// if we have just one index selected, insert it underneath the given index
	MSG_ViewIndex position = MSG_VIEWINDEXNONE;
	if (numIndices == 1)
		position = indices[0];

	// can only show one new directory at a time
	if (m_DirectoryPropSheetFunc)  // make sure we have a FE call back!
	{
		DIR_Server * server = (DIR_Server *) XP_ALLOC(sizeof(DIR_Server));
		if (server)
		{
			DIR_InitServer(server);
			server->description = NULL;  // FE will fill this field in
			
			// only valid commands coming in here are AB_NewLDAPDirectory or AB_NewPABDirectory
			server->dirType = (cmd == AB_NewLDAPDirectory) ? LDAPDirectory : PABDirectory;
			server->isOffline = (cmd == AB_NewLDAPDirectory) ? TRUE : FALSE; // set offline to false for PABs...
			// add the server and position pair to our cache, so we will remember when we go to really add it!!!
			AddToNewServerCache(server, position);
			m_DirectoryPropSheetFunc(server, m_context, this, TRUE /* we are a new server */);
		}
		
	}

	return AB_SUCCESS;
}

void AB_ContainerPane::RemoveAndCloseDirectory(DIR_Server * server)
{
	if (server)
	{
		XP_List * servers = DIR_GetDirServers();
		XP_ListRemoveObject(servers, server); // removes from original DIR_Server list
		// the question is....does anyone need to free the DIR_Server object now that we 
		// are all done with it? 
		DIR_DeleteServer(server);
		DIR_SaveServerPreferences(servers);      // make sure the removal is committed 
	}

}

int AB_ContainerPane::DeleteContainers(MSG_ViewIndex * indices, int32 numIndices)
{
	for (int32 i = 0; i < numIndices; i++)
	{
		AB_ContainerInfo * ctr = GetContainerForIndex(indices[i]);
		if (ctr) /* mlist qualifier just temporary */
		{
			// if the container is a directory container, we need to remove it from the DIR_Server list!
			if (ctr->IsDirectory())
			{
				// first, if the container is expanded, collapse it...
				if (IsExpanded(indices[i]))
					CollapseContainer(indices[i], NULL /* we don't care how many changed */);
				StartingUpdate(MSG_NotifyInsertOrDelete, indices[i], -1);
				m_containerView.Remove(ctr);
				RemoveAndCloseDirectory(ctr->GetDIRServer());
				ctr->RemoveListener(this);
				ctr->Release();  // we are done with this container
				EndingUpdate(MSG_NotifyInsertOrDelete, indices[i], -1);
			}
			else  // if it is a mailing list, delete it from the parent and we'll get our notification to 
				  // delete self that way...
				if (ctr->GetType() == AB_MListContainer)
				{
					AB_MListContainerInfo *mListCtr = ctr->GetMListContainerInfo();
					if (mListCtr)
						mListCtr->DeleteSelfFromParent(this); 
				}
		}
	}

	return AB_SUCCESS;
}

int AB_ContainerPane::ShowPropertySheetForNewType(AB_EntryType entryType, MSG_ViewIndex index /* index for ctr to show sheet for */)
{
	int status = AB_SUCCESS;
	MSG_Pane * pane = NULL;
	AB_ContainerInfo * ctr = GetContainerForIndex(index); // creating pane will ref count ctr
	if (ctr && (ctr->GetType() != AB_LDAPContainer)) // cannot add entries or lists to LDAP.
	{
		if (entryType == AB_MailingList)
			pane = new AB_MailingListPane(m_context, m_master, ctr, AB_ABIDUNKNOWN); // ref counts the ctr
		else 
			if (entryType == AB_Person)
				pane = new AB_PersonPane(m_context, m_master, ctr, AB_ABIDUNKNOWN, this);
	}

	if (pane && m_entryPropSheetFunc)
		m_entryPropSheetFunc(pane, m_context); // non-blocking FE call back 
	else
	{
		AB_ClosePane(pane);  // otherwise, close person pane because it is unused....
		status = AB_FAILURE;
	}

	return status;
}

int AB_ContainerPane::ShowPropertySheet(MSG_ViewIndex * indices, int32 numIndices)
{
	int status = AB_SUCCESS;
	for (int i = 0; i < numIndices; i++)
	{
		// if we are  a picker pane, m_container is not necessarily the ctr to use...
		// could also have a mixture of property sheet types to be shown..
		AB_ContainerInfo * ctrToUse = GetContainerForIndex(indices[i]);
		MSG_Pane * pane = NULL;
		if (ctrToUse && ctrToUse->GetType() == AB_MListContainer)
		{
			pane = new AB_MailingListPane(m_context, m_master, ctrToUse->GetMListContainerInfo());
		}

		if (pane && m_entryPropSheetFunc)
			m_entryPropSheetFunc(pane, m_context); // non-blocking FE call back 
		else
		{
			AB_ClosePane(pane);  // otherwise, close person pane because it is unused....
			status = AB_FAILURE;
		}
		ctrToUse = NULL;
	} // for each index
	return status;
}

/*****************************************************************************

  Container Pane -> Do command and command status

******************************************************************************/

ABErr AB_ContainerPane::DoCommand(MSG_CommandType cmd, MSG_ViewIndex * indices, int32 numIndices)
{
	int status = AB_SUCCESS;

	// what commands should the AB_Container Pane support? 
	switch ((AB_CommandType) cmd)
	{
		case AB_NewAddressBook:
		case AB_NewLDAPDirectory:
		case AB_PropertiesCmd:
		case AB_DeleteCmd:
			// we need to sort the indices for deleting to make sure we delete the correct indices first...
			if (numIndices > 1)
				XP_QSORT (indices, numIndices, sizeof(MSG_ViewIndex), CompareViewIndices);

			ApplyToIndices((AB_CommandType)cmd, indices, numIndices);
			break;
		case AB_AddMailingListCmd:
			if (numIndices == 1) // we only do this for one selection
				status = ShowPropertySheetForNewType(AB_MailingList, indices[0]);
			break;
		case AB_AddUserCmd:
			if (numIndices == 1) // we only do this for one selection
				status = ShowPropertySheetForNewType(AB_Person, indices[0]);
			break;
		default:
			status = AB_INVALID_COMMAND; // we do not recognize the command...
			break;
	}
	
	return status;
}

int AB_ContainerPane::ApplyToIndices(AB_CommandType cmd, MSG_ViewIndex * indices, int32 numIndices)
{
	int status = AB_FAILURE;
	switch(cmd)
	{
		case AB_NewAddressBook:
		case AB_NewLDAPDirectory:
			status = ShowNewDirectoryProperties(cmd, indices, numIndices);
			break;
		case AB_PropertiesCmd:
			status = ShowProperties(indices, numIndices);
			break;
		case AB_DeleteCmd:
			StartingUpdate(MSG_NotifyNone, 0, 0);
			status = DeleteContainers(indices, numIndices);
			EndingUpdate(MSG_NotifyNone, 0, 0);
			break;
		default: 
			XP_ASSERT(0);
			break;
	}

	return status;
}

ABErr AB_ContainerPane::GetCommandStatus(MSG_CommandType  cmd,  const MSG_ViewIndex * indices,  int32 numIndices, XP_Bool * isSelectableState,
									  MSG_COMMAND_CHECK_STATE * checkedState , const char ** displayString,
									  XP_Bool * pluralState)
{
	int status = AB_SUCCESS;

	// for each cmd, we need to determine if it is (1) enabled, (2) its checked state and (3) display string to use
	MSG_COMMAND_CHECK_STATE state = MSG_NotUsed; // most of our pane commands do not have a check state
	const char * displayText = NULL;
	XP_Bool enabled = FALSE;
	XP_Bool selected = (numIndices > 0); // anything selected? 
	XP_Bool plural = FALSE;

	XP_Bool isLDAPContainer = FALSE;
	AB_ContainerInfo * ctr = NULL;  

	if (numIndices == 1)
	{
		ctr = GetContainerForIndex(indices[0]);
		if (ctr)
			isLDAPContainer = ctr->GetType() == AB_LDAPContainer;
		
	}

	switch ((AB_CommandType) cmd)
	{
	case AB_NewAddressBook:
		displayText = XP_GetString(MK_MSG_ADDRESS_BOOK);
		enabled = TRUE;
		break;
	case AB_NewLDAPDirectory:
		displayText = XP_GetString(MK_ADDR_ADD); // note to self: verify that this is the correct resource string
		enabled = TRUE;
		break;
	case AB_PropertiesCmd:
		displayText = XP_GetString(MK_MSG_PROPERTIES);
		enabled = (numIndices == 1);  // disable properties if multple selections
		break;
	case AB_DeleteCmd:
		displayText = XP_GetString(XP_FILTER_DELETE);
		enabled = selected;
		break;
	case AB_DeleteAllCmd:
		displayText = XP_GetString(MK_ADDR_DELETE_ALL);  
		enabled = selected;
		break;
	case AB_AddUserCmd:
		displayText = XP_GetString(MK_MSG_ADD_NAME);
		enabled = (numIndices == 1) && !isLDAPContainer && ctr;   // only enable if we have a non-LDAP directory container selected
		break;
	case AB_AddMailingListCmd:
		displayText = XP_GetString(MK_MSG_ADD_LIST);
		enabled = (numIndices == 1) && !isLDAPContainer && ctr;
		enabled = (numIndices == 1) && !isLDAPContainer && ctr;  // not implemented yet
		break;
	default:
		status = AB_INVALID_COMMAND; // It is not a matter of enabling, disabling this command...We just recognize it
		// we don't know anything about this cmd
		break;
	}

	if (isSelectableState)
		*isSelectableState = enabled;

	if (checkedState)
		*checkedState = state;

	if (displayString)
		*displayString = displayText;

	if (pluralState)
		*pluralState = plural;

	return status;
}

/*****************************************************************************
 
   Drag and Drop related APIs

*****************************************************************************/

int AB_ContainerPane::DragEntriesIntoContainer(const MSG_ViewIndex * indices, int32 numIndices,
												  AB_ContainerInfo * destContainer, AB_DragEffect /* request */)
{
	// we can really ignore the passed in request because all ofour actions are fixed based on the input ctr
	// types...That is...there is never a choice between copy, move etc.

	// some of this code was taken from the status method...
	if (destContainer && numIndices && indices)
	{
		XP_Bool destIsDirectory = destContainer->IsDirectory();
		XP_Bool srcCtrsAllLists = TRUE;
		XP_Bool srcCtrsAllDirectories = TRUE;
		// determine if srcs are all lists, all directories or neither...
		for (int32 i = 0; i < numIndices; i++)
		{
			AB_ContainerInfo * ctr = GetContainerForIndex(indices[i]);
			if (ctr)
			{
				if (ctr->IsDirectory())
					srcCtrsAllLists = FALSE;
				else
					srcCtrsAllDirectories = FALSE;
			}
		}

		// if all the src indices are directories, and the dest is a directory...then move all of the selected ctrs in front of the 
		// dest ctr
		if (srcCtrsAllDirectories && destIsDirectory)
			ReOrderContainers(indices, numIndices, destContainer);
		else // ignore case where we are copying lists to other ctrs
		{
			if (srcCtrsAllLists && destContainer->AcceptsNewEntries()) // copy lists to the destination ctr
			{
				// not immplemented yet
			}
		}
				

	}

	return AB_SUCCESS;
}

AB_DragEffect AB_ContainerPane::DragEntriesIntoContainerStatus(const MSG_ViewIndex * indices, int32 numIndices,
														AB_ContainerInfo * destContainer, AB_DragEffect request)
{

	AB_DragEffect effect = AB_Drag_Not_Allowed;
	if (destContainer && numIndices && indices)
	{
		XP_Bool destIsDirectory = destContainer->IsDirectory();
		XP_Bool srcCtrsAllLists = TRUE;
		XP_Bool srcCtrsAllDirectories = TRUE;
		// determine if srcs are all lists, all directories or neither...
		for (int32 i = 0; i < numIndices; i++)
		{
			AB_ContainerInfo * ctr = GetContainerForIndex(indices[i]);
			if (ctr)
			{
				if (ctr->IsDirectory())
					srcCtrsAllLists = FALSE;
				else
					srcCtrsAllDirectories = FALSE;
			}
		}
		
		if (srcCtrsAllLists)
			// you can only copy maiiling lists into others....
			effect = (AB_DragEffect) (request & AB_Require_Copy);
		else
			if (srcCtrsAllDirectories && destIsDirectory)
				effect = (AB_DragEffect) (request & AB_Require_Move);
	}

	return effect;
}

int AB_ContainerPane::ReOrderContainers(const MSG_ViewIndex * indices, int32 numIndices, AB_ContainerInfo * destContainer)
{
	// for right now, this method assumes each index is to a directory ctr. It ignores list ctrs...but it does move
	// all of the directory ctr's children when it reorders
	MSG_ViewIndex insertIndex = GetIndexForContainer(destContainer);
	if (insertIndex != MSG_VIEWINDEXNONE)
	{
		XP_List * servers = DIR_GetDirServers();
		DIR_Server * destServer = destContainer->GetDIRServer();

		for (int32 i = 0; i < numIndices; i++)
		{
			MSG_ViewIndex index = indices[i];
			AB_ContainerInfo * ctr = GetContainerForIndex(index);
			if (ctr && ctr != destContainer && ctr->IsDirectory()) // ignore mailing list ctrs for now...
			{
				// remove it and each of its children, inserting them in front of the src ctr
				AB_ContainerInfoArray arrayOfCtrs;
				arrayOfCtrs.Add(ctr);
				// if ctr is expanded, add each of the children...
				if (IsExpanded(index))
				{
					MSG_ViewIndex position = index+1; // first child index
					for (int32 i = 0; i < ctr->GetNumChildContainers(); i++, position++)
					{
						AB_ContainerInfo * ctr = GetContainerForIndex(position);
						if (ctr)
							arrayOfCtrs.Add(ctr);
					}
				}
					
				StartingUpdate(MSG_NotifyInsertOrDelete, index, -1*arrayOfCtrs.GetSize());  // generate notification for FEs
				m_containerView.RemoveAt(index, &arrayOfCtrs);
				EndingUpdate(MSG_NotifyInsertOrDelete, index, -1*arrayOfCtrs.GetSize());
				
				// now insert it before destCtr
				insertIndex = GetIndexForContainer(destContainer); // update index count because ctr position could have changed
				StartingUpdate(MSG_NotifyInsertOrDelete, insertIndex, arrayOfCtrs.GetSize());  // generate notification for FEs
				m_containerView.InsertAt(insertIndex, &arrayOfCtrs);
				EndingUpdate(MSG_NotifyInsertOrDelete, insertIndex, arrayOfCtrs.GetSize());

				// Don't forget to change its position in the DIR_Server list!!!
				DIR_Server * srcServer = ctr->GetDIRServer();
				if (srcServer && XP_ListRemoveObject(servers, srcServer)) // if the srcServer was in the list...
					XP_ListInsertObject(servers, destServer, srcServer);  // insert it before the destination server..

			}
		}
		DIR_SaveServerPreferences(servers);      // make sure the re-ordering is committed 
	}

	return AB_SUCCESS;	
}


//********************************************************************************
// Undo/Redo
//********************************************************************************
int AB_ContainerPane::Undo()
{
	return AB_SUCCESS;
}

int AB_ContainerPane::Redo()
{
	return AB_SUCCESS;
}