groupoptionfrom.cs

破解的飞信源代码

                }
                finally
                {
                    enumerator2.Dispose();
                }
                if ((this._optionItems.get_Item(0).OptionsControl as GroupOptionsControlBase).PortraitModified && ((this._optionItems.get_Item(0).OptionsControl as BasicInfoControl)._newImage != null))
                {
                    try
                    {
                        this._personalGroup.GroupInfo.Portrait.ProposedValue = (this._optionItems.get_Item(0).OptionsControl as BasicInfoControl)._newImage;
                        this.CurrentUser.PersonalGroupManager.AsyncUploadGroupPortrait(this._personalGroup, op);
                    }
                    catch (Exception exception)
                    {
                        ClientLogger.WriteException(exception);
                        return false;
                    }
                    finally
                    {
                        (this._optionItems.get_Item(0).OptionsControl as GroupOptionsControlBase).PortraitModified = false;
                        (this._optionItems.get_Item(0).OptionsControl as BasicInfoControl)._newImage = null;
                    }
                }
                if (flag)
                {
                    this._commitableItems.get_Item(0).CommitChanges(op);
                }
                if (flag2)
                {
                    this._commitableItems.get_Item(1).CommitChanges(op);
                }
            }
            else
            {
                Dictionary<int, OptionsItem>.Enumerator enumerator3 = this._optionItems.GetEnumerator();
                try
                {
                    while (enumerator3.MoveNext())
                    {
                        OptionsItem item3 = enumerator3.get_Current().get_Value();
                        if (item3.ControlAvailable)
                        {
                            item3.OptionsControl.UpdateData(update);
                        }
                    }
                }
                finally
                {
                    enumerator3.Dispose();
                }
            }
            return true;
        }

        private void lbOptionItems_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (sender is listbox_widget_t<headicon>)
            {
                try
                {
                    OptionsItem item = null;
                    if (this.m_group_options.Equals(sender))
                    {
                        if (-1 == this.m_group_options.get_selected_index())
                        {
                            return;
                        }
                        item = this._optionItems.get_Item(this.m_group_options.get_selected_index());
                    }
                    item.OptionsControl.ModifiedChanged += new EventHandler(this.oc_ModifiedStateChanged);
                    this.pnlContent.SuspendLayout();
                    this.pnlContent.Controls.Clear();
                    this.pnlContent.Controls.Add(item.OptionsControl.Control);
                    item.OptionsControl.Control.Visible = true;
                    this.pnlContent.ResumeLayout();
                }
                catch (Exception exception)
                {
                    UiErrorHelper.HandExceptionSafely(this._framework, exception);
                }
            }
        }

        private void oc_ModifiedStateChanged(object sender, EventArgs e)
        {
            try
            {
                Dictionary<int, OptionsItem>.ValueCollection.Enumerator enumerator = this._optionItems.get_Values().GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        OptionsItem item = enumerator.get_Current();
                        if (item.ControlAvailable && item.OptionsControl.Modified)
                        {
                            this.btnApply.Enabled = true;
                            return;
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                this.btnApply.Enabled = false;
            }
            catch (Exception exception)
            {
                this._framework.UnifiedMessageBox.ShowException(this, exception);
            }
        }

        protected override void OnFormClosed(FormClosedEventArgs e)
        {
            this._framework.AccountManager.CurrentUser.StatusChanged -= new EventHandler<UserSatusChangedEventArgs>(this, (IntPtr) this.CurrentUser_StatusChanged);
            this.pnlContent.Controls.Clear();
            try
            {
                Dictionary<int, OptionsItem>.ValueCollection.Enumerator enumerator = this._optionItems.get_Values().GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        OptionsItem item = enumerator.get_Current();
                        if (item.ControlAvailable)
                        {
                            item.OptionsControl.ModifiedChanged -= new EventHandler(this.oc_ModifiedStateChanged);
                            item.OptionsControl.ControlUnload();
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                this.CurrentUser.StatusChanged -= new EventHandler<UserSatusChangedEventArgs>(this, (IntPtr) this.CurrentUser_StatusChanged);
                this.CurrentUser.PersonalGroupManager.GroupDeleted -= new EventHandler<PersonalGroupEventArgs>(this, (IntPtr) this.PersonalGroupManager_GroupDeleted);
                this.CurrentUser.PersonalGroupManager.GroupRemoved -= new EventHandler<PersonalGroupEventArgs>(this, (IntPtr) this.PersonalGroupManager_GroupRemoved);
                this.CurrentUser.PersonalGroupManager.MeBeDeleted -= new EventHandler<PersonalGroupEventArgs>(this, (IntPtr) this.PersonalGroupManager_MeBeDeleted);
            }
            catch
            {
            }
            base.OnFormClosed(e);
            Form owner = base.Owner;
            if (owner != null)
            {
                owner.Activate();
            }
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            this.Reset();
        }

        private void OnSelectingOptionItem(object sender, listbox_widget.cancel_select_event_args args)
        {
            try
            {
                if ((1 == this.pnlContent.Controls.get_Count()) && (this.pnlContent.Controls[0] is IOptionsControl))
                {
                    IOptionsControl control = (IOptionsControl) this.pnlContent.Controls[0];
                    if (control.Modified && !control.CheckUserInput())
                    {
                        args.Cancel = true;
                    }
                }
            }
            catch (Exception exception)
            {
                UiErrorHelper.HandExceptionSafely(this._framework, exception);
            }
        }

        private void opUpdate_ImpsError(object sender, ImpsErrorEventArgs e)
        {
            try
            {
                if (base.IsHandleCreated)
                {
                    AsyncBizOperation operation = (AsyncBizOperation) sender;
                    List<IOptionsControl>.Enumerator enumerator = ((List<IOptionsControl>) operation.ContextForUi).GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            enumerator.get_Current().UpdateData(false);
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                    if (!operation.IsImpsErrorHandled)
                    {
                        this._framework.UnifiedMessageBox.ShowError(this, e.Summary);
                    }
                    operation.IsImpsErrorHandled = true;
                }
                this._framework.UnifiedMessageBox.ShowError(e.Summary);
            }
            catch
            {
            }
        }

        private void PersonalGroupManager_GroupDeleted(object sender, PersonalGroupEventArgs e)
        {
            try
            {
                if (e.PersonalGroup.Uri.Raw == this._personalGroup.Uri.Raw)
                {
                    base.Close();
                }
            }
            catch (Exception exception)
            {
                this.HandleException(exception);
            }
        }

        private void PersonalGroupManager_GroupRemoved(object sender, PersonalGroupEventArgs e)
        {
            try
            {
                if (e.PersonalGroup.Uri.Raw == this._personalGroup.Uri.Raw)
                {
                    base.Close();
                }
            }
            catch (Exception exception)
            {
                this.HandleException(exception);
            }
        }

        private void PersonalGroupManager_MeBeDeleted(object sender, PersonalGroupEventArgs e)
        {
            try
            {
                if (e.PersonalGroup.Uri.Raw == this._personalGroup.Uri.Raw)
                {
                    base.Close();
                }
            }
            catch (Exception exception)
            {
                this.HandleException(exception);
            }
        }

        private void Reset()
        {
            this._optionItems = new Dictionary<int, OptionsItem>();
            this.m_group_options.Items.Clear();
            this.btnApply.Enabled = false;
            OptionsCategory[] categories = ((MainForm) this._framework).InnerGroupOptionsManager.Categories;
            if (categories.Length == 1)
            {
                foreach (OptionsItem item in categories[0].Items)
                {
                    if (item != null)
                    {
                        int num = this.m_group_options.add(new headicon(null, item.Text));
                        (item.OptionsControl.Control as GroupOptionsControlBase)._personalGroup = this._personalGroup;
                        (item.OptionsControl.Control as GroupOptionsControlBase).UpdateData(false);
                        this._optionItems.Add(num, item);
                        if (item.ControlAvailable)
                        {
                            item.OptionsControl.Control.Visible = false;
                            this.pnlOptionTabs.Controls.Add(item.OptionsControl.Control);
                        }
                    }
                }
                this.pnlContent.Controls.Clear();
                this.pnlContent.Controls.Add(this._optionItems.get_Item(0).OptionsControl.Control);
                int option = (int) this.Option;
                if ((option < 0) || (option > 3))
                {
                    option = 0;
                }
                this.m_group_options.SelectedIndex = option;
            }
        }

        private Imps.Client.Core.User CurrentUser
        {
            get
            {
                return this._framework.AccountManager.CurrentUser;
            }
        }

        public GroupOption Option
        {
            get
            {
                return this._option;
            }
            set
            {
                this._option = value;
            }
        }
    }
}