void OnTabStateRemoved(TabState tabState) {
			var hts = tabState as HexTabState;
			if (hts == null)
				return;

			hts.HexBox.OnWrite -= HexBox_OnWrite;
		}

 void WeaponTab()
 {
     if (GUILayout.Button("Weapons"))
     {
         tabState = TabState.WEAPON;
     }
 }

 void ArmorTab()
 {
     if (GUILayout.Button("Armor"))
     {
         tabState = TabState.ARMOR;
     }
 }

 void PotionTab()
 {
     if (GUILayout.Button("Potions"))
     {
         tabState = TabState.POTION;
     }
 }

 void AboutTab()
 {
     if (GUILayout.Button("About"))
     {
         tabState = TabState.ABOUT;
     }
 }

			void OnTabStateChanged(TabState oldTabState, TabState newTabState) {
				var oldTsd = oldTabState as DecompileTabState;
				if (oldTsd != null)
					oldTsd.TextView.OnShowOutput -= DecompilerTextView_OnShowOutput;
				var newTsd = newTabState as DecompileTabState;
				if (newTsd != null)
					newTsd.TextView.OnShowOutput += DecompilerTextView_OnShowOutput;
			}

        void OnEnable()
        {
            tabState = TabState.QUALITY;

            weaponDatabase = new ISObjectDatabaseType<ISWeaponDatabase, ISWeapon>(DatabaseManager.weaponDatabase, "Weapon");
            armorDatabase = new ISObjectDatabaseType<ISArmorDatabase, ISArmor>(DatabaseManager.armorDatabase, "Armor");
            consumableDatabase = new ISObjectDatabaseType<ISConsumableDatabase, ISConsumable>(DatabaseManager.consumableDatabase, "Consumable");
            qualityDatabase = new ISObjectDatabaseType<ISQualityDatabase, ISQuality>(DatabaseManager.qualityDatabase, "Quality");
        }

 public TabStateEventArgs(TabState tabState)
 {
     this.TabState = tabState;
 }

 public TabStateChangedEventArgs(TabState oldTabState, TabState newTabState)
 {
     this.OldTabState = oldTabState;
     this.NewTabState = newTabState;
 }

        void ZoomReset(TabState tabState)
        {
            if (tabState == null)
                return;

            SetScaleValue(tabState, 1);
        }

        internal void tabManager_OnSelectionChanged(TabManager<TabState> tabManager, TabState oldState, TabState newState)
        {
            UninitializeActiveTab(oldState, false);
            InitializeActiveTab(newState, false);

            if (IsActiveTab(newState))
                SetTabFocus(newState);

            if (OnTabStateChanged != null)
                OnTabStateChanged(this, new TabStateChangedEventArgs(oldState, newState));
        }

        void OnTabStateChanged(TabState oldTabState, TabState newTabState)
        {
            var oldTsd = oldTabState as DecompileTabState;
            if (oldTsd != null) {
                oldTsd.TextView.OnBeforeShowOutput -= DecompilerTextView_OnBeforeShowOutput;
                oldTsd.TextView.OnShowOutput -= DecompilerTextView_OnShowOutput;
            }
            var newTsd = newTabState as DecompileTabState;
            if (newTsd != null) {
                newTsd.TextView.OnBeforeShowOutput += DecompilerTextView_OnBeforeShowOutput;
                newTsd.TextView.OnShowOutput += DecompilerTextView_OnShowOutput;
            }

            if (oldTsd != null)
                Remove(oldTsd.TextView);
            if (newTsd != null)
                UpdateStackFrameLines(newTsd.TextView);
        }

 internal bool IgnoreSelectionChanged_HACK(TabState tabState)
 {
     var tabManager = tabState.Owner;
     bool value;
     tabManager_dontSelectHack.TryGetValue(tabManager, out value);
     tabManager_dontSelectHack[tabManager] = true;
     return value;
 }

 internal TabState CloneTabMakeActive(TabState tabState, bool decompile = true)
 {
     var clonedTabState = CloneTab(tabState, decompile);
     if (clonedTabState != null)
         tabGroupsManager.ActiveTabGroup.SetSelectedTab(clonedTabState);
     return clonedTabState;
 }

        void SetTabFocus(TabState tabState)
        {
            if (disable_SetTabFocus)
                return;
            if (tabState == null)
                return;
            if (!IsActiveTab(tabState))
                return;
            if (tabState.TabItem.Content == null)
                return;

            var uiElem = tabState.FocusedElement;
            Debug.Assert(uiElem != null);
            if (uiElem == null)
                return;

            if (!uiElem.IsVisible)
                new SetFocusWhenVisible(tabState, uiElem);
            else
                SetFocusIfNoMenuIsOpened(uiElem);
        }

        void SetScaleValue(TabState tabState, double scale)
        {
            var scaleElem = tabState.ScaleElement;
            if (scaleElem == null)
                return;
            if (scale == 1) {
                scaleElem.LayoutTransform = Transform.Identity;
                scaleElem.ClearValue(TextOptions.TextFormattingModeProperty);
            }
            else {
                var st = scaleElem.LayoutTransform as ScaleTransform;
                if (st == null)
                    scaleElem.LayoutTransform = st = new ScaleTransform();

                if (scale < MIN_ZOOM)
                    scale = MIN_ZOOM;
                else if (scale > MAX_ZOOM)
                    scale = MAX_ZOOM;

                // We must set it to Ideal or the text will be blurry
                TextOptions.SetTextFormattingMode(scaleElem, TextFormattingMode.Ideal);
                st.ScaleX = scale;
                st.ScaleY = scale;
            }
        }

 bool IsActiveTab(TabState tabState)
 {
     return tabGroupsManager.ActiveTabGroup.ActiveTabState == tabState;
 }

        void InitializeActiveTab(TabState tabState, bool forceIsInActiveTabGroup)
        {
            var tabManager = tabState == null ? null : tabState.Owner as TabManager<TabState>;
            bool isInActiveTabGroup = tabGroupsManager.ActiveTabGroup == tabManager || forceIsInActiveTabGroup;

            var dts = tabState as DecompileTabState;
            var newView = dts == null ? null : dts.TextView;

            if (isInActiveTabGroup) {
                InstallTabCommandBindings(tabState);
                if (dts != null)
                    SetLanguage(dts.Language);
            }

            bool dontSelect;
            if (tabManager != null && tabManager_dontSelectHack.TryGetValue(tabManager, out dontSelect) && dontSelect) {
            }
            else if (tabState == null || dts == null) {
                if ((isInActiveTabGroup && tabState != null) || (tabGroupsManager.AllTabGroups.Count == 1 && tabGroupsManager.ActiveTabGroup.ActiveTabState == null)) {
                    var old = TreeView_SelectionChanged_ignore;
                    try {
                        TreeView_SelectionChanged_ignore = true;
                        treeView.SelectedItems.Clear();
                    }
                    finally {
                        TreeView_SelectionChanged_ignore = old;
                    }
                }
                else if (isInActiveTabGroup)
                    treeView.SelectedItems.Clear();
            }
            else
                SelectTreeViewNodes(dts, dts.DecompiledNodes);

            if (isInActiveTabGroup)
                ClosePopups();
            if (newView != null && isInActiveTabGroup)
                InstallTextEditorListeners(newView);
        }

 double GetScaleValue(TabState tabState)
 {
     var scaleElem = tabState.ScaleElement;
     if (scaleElem == null)
         return 1;
     var st = scaleElem.LayoutTransform as ScaleTransform;
     if (st != null)
         return st.ScaleX;
     return 1;
 }

 void DelaySetFocus(TabState tabState)
 {
     if (tabState != null) {
         // The TreeView steals the focus so we can't just set the focus to the text view
         // right here, we have to wait a little bit.
         // This is ugly, but we must use Normal prio to get rid of flickering (tab getting
         // inactive followed by getting active). However, this doesn't work all the time
         // (test: right-click tab, open new tab), so we must start another one at a lower
         // priority in case the treeview steals the focus.......
         this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(delegate {
             if (ActiveTabState == tabState)
                 SetTabFocus(tabState);
         }));
         this.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(delegate {
             if (ActiveTabState == tabState)
                 SetTabFocus(tabState);
         }));
     }
 }