private void AddFolderNode(KTreeNode node, KTreeNodes children, AvailableFolder folder)
{
StoreTreeNode rootNode = (StoreTreeNode)this.Children.Parent;
// Create the tree node
SharedFolder share = rootNode.GetInitialShareState(folder);
FolderTreeNode child = new FolderTreeNode(rootNode, folder, share);
ApplyReadOnly(child, child.IsReadOnly);
// Add
children.Add(child);
// Add the children
foreach (AvailableFolder childFolder in folder.Children.OrderBy(f => f, new FolderComparer(false)))
{
AddFolderNode(child, child.Children, childFolder);
}
// Set the initial share state
if (share != null)
{
child.IsChecked = true;
}
// Add the share; it might have become checked by any of the child nodes
if (child.IsShared)
{
rootNode.AddShare(folder, share);
}
}
private void checkWholeStore_CheckedChanged(object sender, EventArgs e)
{
CheckState?reminders = null;
for (int i = 0; i < _optionWholeStoreNodes.Count; ++i)
{
StoreTreeNode node = _optionWholeStoreNodes[i];
bool wholeStore = false;
switch (checkWholeStore.CheckState)
{
case CheckState.Checked: wholeStore = true; break;
case CheckState.Indeterminate: wholeStore = _optionWholeStoreNodesInitial[i]; break;
case CheckState.Unchecked: wholeStore = false; break;
}
if (wholeStore)
{
CheckState remindersCheck = node.ShowReminders? CheckState.Checked: CheckState.Unchecked;
if (reminders == null)
{
reminders = remindersCheck;
}
else if (reminders.Value != remindersCheck)
{
reminders = CheckState.Indeterminate;
}
}
node.WantShare = wholeStore;
}
OptionWholeStoreReminders = reminders;
}
private void AddUserFolders(GABUser user, Dictionary <BackendId, SharedFolder> currentShares, bool select)
{
if (user == null)
{
return;
}
// If the user is already fetched, reuse the node
StoreTreeNode node;
if (!_userFolders.TryGetValue(user, out node))
{
if (!user.HasFullName)
{
// Try to fill in the full name
user = gabLookup.LookupExact(user.UserName);
}
// Add the node
node = new StoreTreeNode(_folders, gabLookup.GAB,
user, user.DisplayName, currentShares ?? new Dictionary <BackendId, SharedFolder>());
node.DirtyChanged += UserSharesChanged;
_userFolders.Add(user, node);
kTreeFolders.RootNodes.Add(node);
}
if (select)
{
FocusNode(node);
}
}
private void WholeStoreShareChanged(KTreeNode node)
{
// TODO: check duplicate email address
StoreTreeNode storeNode = (StoreTreeNode)node;
_dirtyWholeStores[storeNode.User] = storeNode.IsWholeStoreDirty;
CheckDirty();
}
private void checkWholeStoreReminders_CheckedChanged(object sender, EventArgs e)
{
for (int i = 0; i < _optionWholeStoreNodes.Count; ++i)
{
StoreTreeNode node = _optionWholeStoreNodes[i];
switch (checkWholeStoreReminders.CheckState)
{
case CheckState.Checked: node.ShowReminders = true; break;
case CheckState.Indeterminate: node.ShowReminders = node.ShowRemindersInitial; break;
case CheckState.Unchecked: node.ShowReminders = false; break;
}
WholeStoreShareChanged(node);
}
}
public FolderTreeNode(StoreTreeNode store, AvailableFolder folder, SharedFolder share)
{
this._store = store;
this._folder = folder;
this._share = share;
this.Text = folder.Name;
// Image
// TODO: clean this up
int index = ((int)OutlookConstants.BASIC_SYNC_TYPES[(int)folder.Type]) - 1;
if (index < 0 || index >= store.Owner.Images.Images.Count - 1)
{
index = 0;
}
ImageIndex = index;
}
public FolderTreeNode(StoreTreeNode store, AvailableFolder folder, SharedFolder share)
{
this._store = store;
this._folder = folder;
this._share = share;
this.Text = folder.Name;
IsReadOnly = share?.SyncId?.Kind == SyncKind.Configured;
HasCheckBox = true;
CheckBoxEnabled = !IsReadOnly;
// Image
// TODO: clean this up
int index = ((int)OutlookConstants.BASIC_SYNC_TYPES[(int)folder.Type]) - 1;
if (index < 0 || index >= store.Owner.Images.Images.Count - 1)
{
index = 0;
}
ImageIndex = index;
}
private void AddUserFolders(GABUser user, ZPushAccount wholeStore, Dictionary <BackendId, SharedFolder> currentShares, bool select)
{
if (user == null)
{
return;
}
// If the user is already fetched, reuse the node
StoreTreeNode node;
if (!_userFolders.TryGetValue(user, out node))
{
if (!user.HasFullName)
{
// Try to fill in the full name
user = gabLookup.LookupExact(user.UserName);
}
string sendAsAddress = _featureSendAs?.FindSendAsAddress(_account, user);
// Add the node
node = new StoreTreeNode(_folders, gabLookup.GAB,
user, sendAsAddress,
user.DisplayName, currentShares ?? new Dictionary <BackendId, SharedFolder>(),
wholeStore != null,
wholeStore?.ShowReminders == true);
node.DirtyChanged += UserSharesChanged;
node.CheckStateChanged += WholeStoreShareChanged;
_userFolders.Add(user, node);
kTreeFolders.RootNodes.Add(node);
}
if (select)
{
FocusNode(node, !_folders.SupportsWholeStore);
}
}
public UserFolderLoader(StoreTreeNode parent, SharedFoldersManager folders, GABUser user) : base(parent)
{
this._folders = folders;
this.User = user;
}
private void UserSharesChanged(StoreTreeNode node)
{
_dirtyUsers[node.User.UserName] = node.IsDirty;
dialogButtons.IsDirty = _dirtyUsers.Values.Any((x) => x);
}
private void ShowOptions(KTreeNode[] nodes)
{
try
{
_layoutOptions.SuspendLayout();
_optionNameNode = null;
_optionSendAsNodes.Clear();
_optionSendAsInitial.Clear();
_optionRemindersNodes.Clear();
_optionRemindersInitial.Clear();
_optionPermissionNodes.Clear();
_optionWholeStoreNodes.Clear();
_optionWholeStoreNodesInitial.Clear();
OptionName = null;
OptionTrackName = null;
OptionSendAs = null;
OptionReminders = null;
OptionPermissions = null;
OptionWholeStore = null;
OptionWholeStoreReminders = null;
bool readOnly = false;
bool haveStoreNodes = false;
bool haveFolderNodes = false;
foreach (KTreeNode node in nodes)
{
// Ignore the root nodes
if (node is StoreTreeNode)
{
if (!_folders.SupportsWholeStore || !node.HasCheckBox)
{
continue;
}
StoreTreeNode storeNode = (StoreTreeNode)node;
haveStoreNodes = true;
_optionWholeStoreNodes.Add(storeNode);
_optionWholeStoreNodesInitial.Add(storeNode.IsShared);
}
else
{
FolderTreeNode folderNode = (FolderTreeNode)node;
// Can only set options for shared folders
if (!folderNode.IsShared)
{
continue;
}
haveFolderNodes = true;
// Set all controls to read-only if any of the nodes is read-only
if (folderNode.IsReadOnly)
{
readOnly = true;
}
SharedFolder share = folderNode.SharedFolder;
AvailableFolder folder = folderNode.AvailableFolder;
// Assume we will edit the name for this node; cleared below if there are multiple
_optionNameNode = folderNode;
if (folder.Type.IsMail())
{
// Show send as if there are any mail folders
_optionSendAsNodes.Add(folderNode);
_optionSendAsInitial.Add(folderNode.SharedFolder.FlagSendAsOwner);
}
else if (folder.Type.IsAppointment())
{
// Show reminders for appointment folders
_optionRemindersNodes.Add(folderNode);
_optionRemindersInitial.Add(folderNode.SharedFolder.FlagCalendarReminders);
}
// Show permissions for all shared nodes
_optionPermissionNodes.Add(folderNode);
}
}
// Now check consistency of the options
if (haveFolderNodes && haveStoreNodes)
{
// Mixed nodes, no options
return;
}
if (haveStoreNodes)
{
if (_optionWholeStoreNodes.Count > 0)
{
bool isShared = _optionWholeStoreNodes.First().WantShare;
bool wasShared = _optionWholeStoreNodes.First().IsShared;
if (_optionWholeStoreNodes.All(x => x.WantShare == isShared))
{
OptionWholeStore = isShared ? CheckState.Checked : CheckState.Unchecked;
checkWholeStore.ThreeState = false;
}
else
{
OptionWholeStore = CheckState.Indeterminate;
checkWholeStore.ThreeState = true;
}
_labelRestartRequired.Visible = isShared && !wasShared;
}
}
else
{
// Only show the name if there is a single node.
// We do that here so there doesn't have to be duplication if testing if it's sharedd,
// ect
if (_optionNameNode != null && nodes.Length == 1)
{
OptionName = _optionNameNode.SharedFolder.Name;
OptionTrackName = _optionNameNode.SharedFolder.FlagUpdateShareName;
}
else
{
_optionNameNode = null;
}
// Permissions shown if all are the same
if (_optionPermissionNodes.Count > 0)
{
Permission?permissions = _optionPermissionNodes.First().SharedFolder.Permissions;
if (_optionPermissionNodes.All(x => x.SharedFolder.Permissions == permissions))
{
OptionPermissions = permissions;
}
}
// Send as shown if any node supports it
if (_optionSendAsNodes.Count > 0)
{
bool sendAs = _optionSendAsNodes.First().SharedFolder.FlagSendAsOwner;
if (_optionSendAsNodes.All(x => x.SharedFolder.FlagSendAsOwner == sendAs))
{
OptionSendAs = sendAs ? CheckState.Checked : CheckState.Unchecked;
checkSendAs.ThreeState = false;
}
else
{
OptionSendAs = CheckState.Indeterminate;
checkSendAs.ThreeState = true;
}
textSendAsAddress.Text = TryInitSendAsAddress();
EnableSendAsAddress();
}
// Reminders shown if any node supports it
if (_optionRemindersNodes.Count > 0)
{
bool reminders = _optionRemindersNodes.First().SharedFolder.FlagCalendarReminders;
if (_optionRemindersNodes.All(x => x.SharedFolder.FlagCalendarReminders == reminders))
{
OptionReminders = reminders ? CheckState.Checked : CheckState.Unchecked;
checkReminders.ThreeState = false;
}
else
{
OptionReminders = CheckState.Indeterminate;
checkReminders.ThreeState = true;
}
}
}
// Apply read-only state
_layoutOptions.Enabled = !readOnly;
}
finally
{
_layoutOptions.ResumeLayout();
}
}
private void UserSharesChanged(StoreTreeNode node)
{
_dirtyUsers[node.User] = node.IsDirty;
CheckDirty();
}
