private void ToggleAllTarget()
{
if (_cursorType == CursorGroup.AllEnemy || _cursorType == CursorGroup.AllPlayer)
{
if (ButtonGroupState.ActiveButton)
{
ButtonGroupState.SetButtonAnimation(ButtonGroupState.ActiveButton, true);
}
else
{
foreach (GONavigationButton button in _targetPanel.AllTargets)
{
ButtonGroupState.SetButtonAnimation(button, true);
}
ButtonGroupState.ActiveButton = ButtonGroupState.GetCursorStartSelect(TargetGroupButton);
}
_cursorType = CursorGroup.Individual;
_targetPanel.ActivateButtons(false);
}
else
{
ButtonGroupState.SetButtonAnimation(ButtonGroupState.ActiveButton, false);
Singleton <PointerManager> .Instance.RemovePointerFromGameObject(ButtonGroupState.ActiveButton);
_cursorType = _currentTargetIndex >= HonoluluBattleMain.EnemyStartIndex ? CursorGroup.AllEnemy : CursorGroup.AllPlayer;
_targetPanel.ActivateButtons(true);
}
SetTargetHelp();
DisplayTargetPointer();
}
public void FF9BMenu_EnableMenu(Boolean active)
{
if (PersistenSingleton <UIManager> .Instance.QuitScene.isShowQuitUI)
{
return;
}
if (PersistenSingleton <UIManager> .Instance.State == UIManager.UIState.BattleHUD)
{
_commandEnable = active;
AllMenuPanel.SetActive(active);
HideHudHitAreaGameObject.SetActive(active);
if (!active)
{
ButtonGroupState.DisableAllGroup(true);
}
else
{
if ((_isFromPause || ButtonGroupState.ActiveGroup != String.Empty) && !_isNeedToInit)
{
return;
}
_isNeedToInit = false;
InitialBattle();
DisplayParty();
SetIdle();
}
}
else
{
_beforePauseCommandEnable = active;
_isNeedToInit = active;
}
}
private void PrepareListItemWithIndex(Transform item, Int32 newIndex, Int32 oldIndex)
{
if (newIndex < oldIndex)
{
item.localPosition += new Vector3(0f, (Single)(this.poolSize / this.Column) * this.cellHeight, 0f);
}
else
{
item.localPosition -= new Vector3(0f, (Single)(this.poolSize / this.Column) * this.cellHeight, 0f);
}
item.GetComponent <RecycleListItem>().ItemDataIndex = newIndex;
UIKeyNavigation component = item.GetComponent <UIKeyNavigation>();
if (component)
{
component.startsSelected = (this.activeNumber == newIndex);
}
if (oldIndex == this.activeNumber)
{
ButtonGroupState component2 = item.GetComponent <ButtonGroupState>();
ButtonGroupState.RemoveActiveStateOnGroup(item.gameObject, component2.GroupName);
}
if (newIndex == this.activeNumber)
{
ButtonGroupState component3 = item.GetComponent <ButtonGroupState>();
ButtonGroupState.HoldActiveStateOnGroup(item.gameObject, component3.GroupName);
}
item.name = "Item " + newIndex;
this.PopulateListItemWithData(item, this.dataList[newIndex], newIndex, false);
this.dataTracker.Add(newIndex, this.dataTracker[oldIndex]);
this.dataTracker.Remove(oldIndex);
}
private void DisplayCorruptAccessDialog(Action callback)
{
String key;
switch (ISharedDataSerializer.LastErrno)
{
case DataSerializerErrorCode.FileCorruption:
case DataSerializerErrorCode.DataCorruption:
key = "LocalDecryptFailed";
goto IL_66;
case DataSerializerErrorCode.CloudDataCorruption:
key = "CloudDataCorrupt";
goto IL_66;
case DataSerializerErrorCode.CloudConnectionTimeout:
key = "CloudConnectionTimeout";
goto IL_66;
case DataSerializerErrorCode.CloudFileNotFound:
key = "CloudFileNotFound";
goto IL_66;
}
key = "CloudDataUnknownError";
IL_66:
this.saveCorruptDialog = Singleton <DialogManager> .Instance.AttachDialog(Localization.Get(key), 0, 0, Dialog.TailPosition.Center, Dialog.WindowStyle.WindowStylePlain, Vector2.zero, Dialog.CaptionType.Notice);
ButtonGroupState.DisableAllGroup(true);
base.StartCoroutine(this.HideCorruptAccessDialog(callback));
}
public override void Show(SceneVoidDelegate afterFinished = null)
{
TryHackPartyInfo(this.info);
SceneVoidDelegate sceneVoidDelegate = delegate
{
if (Configuration.Graphics.WidescreenSupport)
{
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(150, -18f), MoveCharGroupButton);
}
else
{
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(18f, -18f), MoveCharGroupButton);
}
ButtonGroupState.SetPointerDepthToGroup(6, MoveCharGroupButton);
ButtonGroupState.ActiveGroup = SelectCharGroupButton;
};
if (afterFinished != null)
{
sceneVoidDelegate = (SceneVoidDelegate)Delegate.Combine(sceneVoidDelegate, afterFinished);
}
SceneDirector.FadeEventSetColor(FadeMode.Sub, Color.black);
base.Show(sceneVoidDelegate);
this.DisplayCharacter();
this.DisplayCharacterInfo(this.currentCharacterId);
this.DisplayHelpInfo();
this.HelpDespLabelGameObject.SetActive(FF9StateSystem.PCPlatform);
}
private void CheckData()
{
if (this.isLocalFileExist)
{
if (ButtonGroupState.ActiveGroup == CloudUI.SubMenuGroupButton)
{
ButtonGroupState.SetButtonEnable(this.UploadButton, true);
}
this.uploadButtonLabel.color = FF9TextTool.White;
}
else
{
if (ButtonGroupState.ActiveGroup == CloudUI.SubMenuGroupButton)
{
ButtonGroupState.SetButtonEnable(this.UploadButton, false);
}
this.uploadButtonLabel.color = FF9TextTool.Gray;
}
if (this.isCloudFileExist)
{
if (ButtonGroupState.ActiveGroup == CloudUI.SubMenuGroupButton)
{
ButtonGroupState.SetButtonEnable(this.DownloadButton, true);
}
this.downloadButtonLabel.color = FF9TextTool.White;
}
else
{
if (ButtonGroupState.ActiveGroup == CloudUI.SubMenuGroupButton)
{
ButtonGroupState.SetButtonEnable(this.DownloadButton, false);
}
this.downloadButtonLabel.color = FF9TextTool.Gray;
}
}
public static void ShowHelpDialog(GameObject go)
{
if (PersistenSingleton <UIManager> .Instance.IsLoading)
{
return;
}
ButtonGroupState component = go.GetComponent <ButtonGroupState>();
if (component.Help.Enable)
{
Vector3 v = UIRoot.list[0].LocalToUIRootPoint(component.transform);
v.x -= (Single)component.widget.width / 2f;
if (component.Help.TextKey != String.Empty)
{
Singleton <HelpDialog> .Instance.Phrase = Localization.Get(component.Help.TextKey);
}
else
{
Singleton <HelpDialog> .Instance.Phrase = component.Help.Text;
}
Singleton <HelpDialog> .Instance.PointerOffset = ((!ButtonGroupState.pointerOffsetList.ContainsKey(component.GroupName)) ? new Vector2(0f, 0f) : ButtonGroupState.pointerOffsetList[component.GroupName]);
Singleton <HelpDialog> .Instance.PointerLimitRect = ((!ButtonGroupState.pointerLimitRectList.ContainsKey(component.GroupName)) ? UIManager.UIScreenCoOrdinate : ButtonGroupState.pointerLimitRectList[component.GroupName]);
Singleton <HelpDialog> .Instance.Position = v;
Singleton <HelpDialog> .Instance.Tail = component.Help.Tail;
Singleton <HelpDialog> .Instance.Depth = (Int32)((!ButtonGroupState.pointerDepthList.ContainsKey(ButtonGroupState.activeGroup)) ? 4 : (ButtonGroupState.pointerDepthList[ButtonGroupState.activeGroup] - 1));
Singleton <HelpDialog> .Instance.ShowDialog();
}
}
public static void UpdateActiveButton()
{
if (ButtonGroupState.activeButtonList.ContainsKey(ButtonGroupState.activeGroup))
{
if (ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup] == (UnityEngine.Object)null)
{
return;
}
ButtonGroupState component = ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup].GetComponent <ButtonGroupState>();
if (component != (UnityEngine.Object)null)
{
component.SetHover(false);
}
if (component.Help.Enable)
{
Singleton <PointerManager> .Instance.SetPointerHelpAt(ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup], ButtonGroupState.helpEnabled, true);
if (ButtonGroupState.helpEnabled)
{
ButtonGroupState.ShowHelpDialog(ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup]);
}
}
else
{
Singleton <PointerManager> .Instance.SetPointerHelpAt(ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup], false, true);
Singleton <HelpDialog> .Instance.HideDialog();
}
if (ButtonGroupState.pointerNumberList.ContainsKey(ButtonGroupState.activeGroup) && ButtonGroupState.pointerNumberList[ButtonGroupState.activeGroup] != 0)
{
Singleton <PointerManager> .Instance.SetPointerNumberAt(ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup], ButtonGroupState.pointerNumberList[ButtonGroupState.activeGroup]);
}
}
}
public override void Show(UIScene.SceneVoidDelegate afterFinished = null)
{
SiliconStudio.Social.InitializeSocialPlatform();
SiliconStudio.Social.Authenticate(false);
UIScene.SceneVoidDelegate sceneVoidDelegate = delegate
{
base.Loading = true;
this.timeCounter = Time.time;
this.currentState = CloudUI.State.LoadPreview;
FF9StateSystem.Serializer.LoadCloudSyncPreview((ISharedDataSerializer.OnSyncCloudSlotStart)null, new ISharedDataSerializer.OnSyncCloudSlotFinish(this.OnFinishedLoadPreview));
this.LoadingPreviewDialog.SetActive(true);
this.helpTitleLabel.text = Localization.Get("ConnectingHelpInfo");
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(26f, 134f), CloudUI.LocalFileGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(26f, 134f), CloudUI.CloudFileGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(220f, 10f), CloudUI.ConfirmDialogGroupButton);
};
if (afterFinished != null)
{
sceneVoidDelegate = (UIScene.SceneVoidDelegate)Delegate.Combine(sceneVoidDelegate, afterFinished);
}
SceneDirector.FadeEventSetColor(FadeMode.Sub, Color.black);
base.Show(sceneVoidDelegate);
this.FileListPanel.SetActive(false);
this.DisplayInfo();
}
private void DisplayFile(List <SharedDataPreviewSlot> data)
{
ScrollButton component = this.FileListPanel.GetChild(0).GetComponent <ScrollButton>();
UIPanel component2 = this.FileListPanel.GetChild(1).GetComponent <UIPanel>();
Int32 num = 0;
Double num2 = 0.0;
this.currentFile = 0;
this.isFileExistList.Clear();
this.isFileCorrupt.Clear();
foreach (SharedDataPreviewSlot sharedDataPreviewSlot in data)
{
if (sharedDataPreviewSlot != null && sharedDataPreviewSlot.Timestamp > num2)
{
num2 = sharedDataPreviewSlot.Timestamp;
this.currentFile = num;
}
this.isFileExistList.Add(sharedDataPreviewSlot != (SharedDataPreviewSlot)null);
this.isFileCorrupt.Add(false);
this.DisplayFileInfo(num++, sharedDataPreviewSlot);
}
component.CheckScrollPosition();
ButtonGroupState.SetCursorStartSelect(this.fileInfoHudList[this.currentFile].Self, SaveLoadUI.FileGroupButton);
ButtonGroupState.RemoveCursorMemorize(SaveLoadUI.FileGroupButton);
ButtonGroupState.ActiveGroup = SaveLoadUI.FileGroupButton;
this.fileScrollList.ScrollToIndex(this.currentFile);
}
private void OnSecondaryGroupClick(GameObject go)
{
ButtonGroupState.HoldActiveStateOnGroup(go, SubMenuGroupButton);
if (ButtonGroupState.ActiveGroup == ItemGroupButton)
{
FF9Sfx.muteSfx = true;
OnKeyCancel(_itemScrollList.GetItem(_currentItemIndex).gameObject);
FF9Sfx.muteSfx = false;
OnKeyConfirm(go);
}
else if (ButtonGroupState.ActiveGroup == KeyItemGroupButton)
{
FF9Sfx.muteSfx = true;
OnKeyCancel(_keyItemScrollList.GetItem(_currentItemIndex).gameObject);
FF9Sfx.muteSfx = false;
OnKeyConfirm(go);
}
else
{
if (ButtonGroupState.ActiveGroup != ItemArrangeGroupButton)
{
return;
}
GameObject currentItemObject = _itemScrollList.GetItem(_currentItemIndex).gameObject;
FF9Sfx.muteSfx = true;
OnKeyCancel(currentItemObject.GetChild(1));
OnKeyCancel(currentItemObject);
FF9Sfx.muteSfx = false;
OnKeyConfirm(go);
}
}
private void RemoveCursorMemorize()
{
_currentArrangeMode = 0;
ButtonGroupState.RemoveCursorMemorize(SubMenuGroupButton);
ButtonGroupState.RemoveCursorMemorize(ItemGroupButton);
ButtonGroupState.RemoveCursorMemorize(KeyItemGroupButton);
}
private void OnSnapFinish()
{
isScrollMove = false;
ScrollButton.CheckScrollPosition();
IEnumerator enumerator = transform.GetChild(0).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
GameObject gameObject = ((Component)enumerator.Current).gameObject;
if (gameObject.activeSelf)
{
ScrollItemKeyNavigation component = gameObject.GetComponent <ScrollItemKeyNavigation>();
component.enabled = true;
component.CheckVisibility();
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
ButtonGroupState.UpdateActiveButton();
}
public override void Show(SceneVoidDelegate afterFinished = null)
{
SceneVoidDelegate action = () =>
{
PersistenSingleton <UIManager> .Instance.MainMenuScene.SubMenuPanel.SetActive(false);
ButtonGroupState.SetPointerDepthToGroup(4, ItemGroupButton);
ButtonGroupState.SetPointerDepthToGroup(7, TargetGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(54f, 0.0f), ItemGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(54f, 0.0f), KeyItemGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(160f, 10f), ArrangeMenuGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(48f, -6f), ItemArrangeGroupButton);
ButtonGroupState.SetScrollButtonToGroup(_itemScrollList.ScrollButton, ItemGroupButton);
ButtonGroupState.SetScrollButtonToGroup(_itemScrollList.ScrollButton, ItemArrangeGroupButton);
ButtonGroupState.SetScrollButtonToGroup(_keyItemScrollList.ScrollButton, KeyItemGroupButton);
ButtonGroupState.SetPointerLimitRectToGroup(ItemListPanel.GetComponent <UIWidget>(), _itemScrollList.cellHeight, ItemGroupButton);
ButtonGroupState.SetPointerLimitRectToGroup(ItemListPanel.GetComponent <UIWidget>(), _itemScrollList.cellHeight, ItemArrangeGroupButton);
ButtonGroupState.SetPointerLimitRectToGroup(KeyItemListPanel.GetComponent <UIWidget>(), _keyItemScrollList.cellHeight, KeyItemGroupButton);
ButtonGroupState.ActiveGroup = SubMenuGroupButton;
StartCoroutine(Show_dalay());
afterFinished?.Invoke();
};
SceneDirector.FadeEventSetColor(FadeMode.Sub, Color.black);
base.Show(action);
ItemListPanel.SetActive(true);
KeyItemListPanel.SetActive(false);
DisplayItem();
HelpDespLabelGameObject.SetActive(FF9StateSystem.PCPlatform);
_itemScrollList.ScrollButton.DisplayScrollButton(false, false);
_keyItemScrollList.ScrollButton.DisplayScrollButton(false, false);
}
public override Boolean OnKeyCancel(GameObject go)
{
if (base.OnKeyCancel(go) && ButtonGroupState.ActiveGroup == QuadMistUI.CardGroupButton && this.currentState == QuadMistUI.CardState.CardSelection)
{
FF9Sfx.FF9SFX_Play(101);
if (this.selectedCardList.Count > 0)
{
this.DeselectCard(this.selectedCardList.Count - 1);
this.DisplayCardList();
this.DisplayCardDetail();
}
else
{
Boolean flag = false;
if (FF9StateSystem.Common.FF9.miniGameArg == 124 || FF9StateSystem.Common.FF9.miniGameArg == 125 || FF9StateSystem.Common.FF9.miniGameArg == 126 || FF9StateSystem.Common.FF9.miniGameArg == 127)
{
flag = true;
}
if (!flag)
{
ETb.sChoose = 1;
String phrase = Localization.Get("QuadMistEndCardGame");
Dialog dialog = Singleton <DialogManager> .Instance.AttachDialog(phrase, 100, 3, Dialog.TailPosition.Center, Dialog.WindowStyle.WindowStylePlain, new Vector2(105f, 90f), Dialog.CaptionType.None);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(230f, 0f), Dialog.DialogGroupButton);
dialog.AfterDialogHidden = new Dialog.DialogIntDelegate(this.onQuitDialogHidden);
}
}
}
return(true);
}
private void onDiscardConfirmHidden(Int32 choice)
{
ButtonGroupState.SetPointerOffsetToGroup(Dialog.DefaultOffset, Dialog.DialogGroupButton);
if (choice == 0)
{
QuadMistDatabase.MiniGame_AwayCard(this.deleteCardId, this.currentCardOffset);
if (QuadMistDatabase.MiniGame_GetAllCardCount() > 100)
{
QuadMistUI.allCardList.Remove(this.GetCardInfo(this.currentCardId, this.currentCardOffset));
Byte[] array = this.count;
Int32 num = this.deleteCardId;
array[num] = (Byte)(array[num] - 1);
this.currentCardOffset = 0;
this.DisplayCardList();
this.DisplayCardDetail();
ButtonGroupState.ActiveGroup = QuadMistUI.CardGroupButton;
this.UpdateAmountLabel();
}
else
{
this.Hide(delegate
{
QuadMistGame.OnDiscardFinish();
this.isNeedToBuildCard = true;
});
}
}
else
{
ButtonGroupState.ActiveGroup = QuadMistUI.CardGroupButton;
}
}
public static void ToggleHelp(bool playSFX = true)
{
if (ButtonGroupState.activeGroup != String.Empty && ButtonGroupState.activeGroup != QuitUI.WarningMenuGroupButton && PersistenSingleton <UIManager> .Instance.State != UIManager.UIState.WorldHUD)
{
ButtonGroupState.helpEnabled = !ButtonGroupState.helpEnabled;
ButtonGroupState component = ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup].GetComponent <ButtonGroupState>();
if (component.Help.Enable)
{
Singleton <PointerManager> .Instance.SetPointerHelpAt(ButtonGroupState.activeButtonList[ButtonGroupState.activeGroup], ButtonGroupState.helpEnabled, false);
}
if (!ButtonGroupState.helpEnabled)
{
Singleton <HelpDialog> .Instance.HideDialog();
if (playSFX)
{
FF9Sfx.FF9SFX_Play(101);
}
}
else if (playSFX)
{
FF9Sfx.FF9SFX_Play(682);
}
}
}
private void DisplayKeyItemSkin(Boolean visibility)
{
if (visibility)
{
Int32 keyItemId = _keyItemIdList[_currentItemIndex];
_keyItemDetailName.text = FF9TextTool.ImportantItemName(keyItemId);
_keyItemDetailDescription.spacingY = _defaultSkinLabelSpacingY;
String text = FF9TextTool.ImportantItemSkin(keyItemId);
Single additionalWidth = 0.0f;
_keyItemDetailDescription.text = _keyItemDetailDescription.PhrasePreOpcodeSymbol(text, ref additionalWidth);
Loading = true;
// ISSUE: method pointer
_keyItemSkinTransition.TweenIn(new Byte[1], () =>
{
Loading = false;
_isShowingKeyItemDesp = true;
});
ButtonGroupState.DisableAllGroup(false);
ButtonGroupState.HoldActiveStateOnGroup(KeyItemGroupButton);
}
else
{
Loading = true;
_isShowingKeyItemDesp = false;
// ISSUE: method pointer
_keyItemSkinTransition.TweenOut(new Byte[1], () =>
{
Loading = false;
ButtonGroupState.ActiveGroup = KeyItemGroupButton;
Singleton <PointerManager> .Instance.SetPointerBlinkAt(ButtonGroupState.ActiveButton, false);
});
ff9item.FF9Item_UseImportant(_keyItemIdList[_currentItemIndex]);
DisplayKeyItem();
}
}
private void DisplayItemDetail(Transform item, ListDataTypeBase data, Int32 index, Boolean isInit)
{
FieldItemListData fieldItemListData = (FieldItemListData)data;
ItemDetailHUD itemDetailHud = new ItemDetailHUD(item.gameObject);
if (isInit)
{
UIEventListener uiEventListener = UIEventListener.Get(itemDetailHud.ManualButton.gameObject);
uiEventListener.Select += itemDetailHud.Self.GetComponent <ScrollItemKeyNavigation>().OnOtherObjectSelect;
DisplayWindowBackground(item.gameObject, null);
}
if (ButtonGroupState.ActiveGroup == ItemArrangeGroupButton)
{
if (_currentItemIndex == index && !_switchingItem)
{
if (isInit)
{
ButtonGroupState.HoldActiveStateOnGroup(item.gameObject, ItemGroupButton);
}
ButtonGroupState.SetButtonAnimation(item.gameObject, false);
ButtonGroupState.SetOutsideLimitRectBehavior(PointerManager.LimitRectBehavior.Hide, ItemGroupButton);
}
else
{
ButtonGroupState.SetButtonAnimation(item.gameObject, true);
}
}
FF9UIDataTool.DisplayItem(fieldItemListData.ItemId, itemDetailHud.IconSprite, itemDetailHud.NameLabel, fieldItemListData.Enable);
itemDetailHud.NumberLabel.text = fieldItemListData.ItemCount.ToString();
itemDetailHud.NumberLabel.color = !fieldItemListData.Enable ? FF9TextTool.Gray : FF9TextTool.White;
itemDetailHud.Button.Help.Enable = true;
itemDetailHud.Button.Help.Text = FF9TextTool.ItemHelpDescription(fieldItemListData.ItemId);
itemDetailHud.ManualButton.Help.Enable = true;
itemDetailHud.ManualButton.Help.Text = FF9TextTool.ItemHelpDescription(fieldItemListData.ItemId);
}
public void SetHelpActive(Boolean isActive, Boolean isImmediate)
{
if (PersistenSingleton <UIManager> .Instance.UnityScene != UIManager.Scene.Battle)
{
if (isActive)
{
this.mogSprite.gameObject.SetActive(true);
if (!isImmediate)
{
this.SetMoggleAnimation(isActive);
}
}
else
{
this.SetMoggleAnimation(isActive);
}
}
else
{
this.SetMoggleAnimation(false);
if (isActive)
{
ButtonGroupState.ShowHelpDialog(ButtonGroupState.ActiveButton);
}
}
}
public KeyItemDetailHUD(GameObject go)
{
//Self = go;
Button = go.GetComponent <ButtonGroupState>();
NameLabel = go.GetChild(0).GetComponent <UILabel>();
NewIconSprite = go.GetChild(1).GetChild(0).GetComponent <UISprite>();
NewIconLabelSprite = go.GetChild(1).GetChild(1).GetComponent <UISprite>();
}
public static void HoldActiveStateOnGroup(GameObject go, String oldGroup)
{
if (ButtonGroupState.activeButtonList.ContainsKey(oldGroup) && oldGroup != ButtonGroupState.ActiveGroup)
{
ButtonGroupState.activeButtonList[oldGroup] = go;
ButtonGroupState.HoldActiveStateOnGroup(oldGroup);
}
}
private void DisplayNoSaveFoundDialog()
{
this.noSaveDataDialog = Singleton <DialogManager> .Instance.AttachDialog(Localization.Get("NoSaveData"), 0, 0, Dialog.TailPosition.Center, Dialog.WindowStyle.WindowStylePlain, Vector2.zero, Dialog.CaptionType.Notice);
ButtonGroupState.DisableAllGroup(true);
base.Loading = true;
base.StartCoroutine(this.HideSaveInfoDialog(SaveLoadUI.SlotGroupButton));
}
private void OnDisable()
{
if (!HidePointerOnMoving)
{
return;
}
ButtonGroupState.SetPointerVisibilityToGroup(false, gameObject.GetComponent <ButtonGroupState>().GroupName);
}
private void OnDisable()
{
if (this.HidePointerOnMoving)
{
String groupName = base.gameObject.GetComponent <ButtonGroupState>().GroupName;
ButtonGroupState.SetPointerVisibilityToGroup(false, groupName);
}
}
public static void SetButtonEnable(GameObject go, Boolean isEnable)
{
go.GetComponent <ButtonGroupState>().enabled = isEnable;
go.GetComponent <BoxCollider>().enabled = isEnable;
go.GetComponent <UIButton>().enabled = isEnable;
go.GetComponent <UIKeyNavigation>().enabled = isEnable;
ButtonGroupState.SetButtonAnimation(go, isEnable);
}
public virtual Boolean OnKeySelect(GameObject go)
{
if (this.isLoading)
{
return(false);
}
ButtonGroupState.ToggleHelp(true);
return(true);
}
public Button(GameObject obj)
: base(obj)
{
GroupState = obj.GetExactComponent <ButtonGroupState>();
UiButton = obj.GetExactComponent <UIButton>();
UiLocalize = obj.GetExactComponent <UILocalize>();
UiLabel = obj.GetExactComponent <UILabel>();
UiEventListener = obj.EnsureExactComponent <UIEventListener>();
}
public void AfterShowCharacter()
{
ButtonGroupState.SetCursorStartSelect(this.GetGameObjectFromSubMenu(this.currentMenu), MainMenuUI.SubMenuGroupButton);
ButtonGroupState.RemoveCursorMemorize(MainMenuUI.SubMenuGroupButton);
ButtonGroupState.SetPointerDepthToGroup(10, MainMenuUI.SubMenuGroupButton);
ButtonGroupState.SetPointerDepthToGroup(12, MainMenuUI.OrderGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(10f, 0f), MainMenuUI.CharacterGroupButton);
ButtonGroupState.SetPointerOffsetToGroup(new Vector2(30f, -28f), MainMenuUI.OrderGroupButton);
ButtonGroupState.ActiveGroup = MainMenuUI.SubMenuGroupButton;
}
public GONavigationButton(GameObject obj)
: base(obj)
{
KeyNavigation = obj.GetExactComponent <UIKeyNavigation>();
ButtonGroup = obj.GetExactComponent <ButtonGroupState>();
Name = new GOLabel(obj.GetChild(0));
Highlight = new GOSprite(obj.GetChild(1));
Background = new GOThinBackground(obj.GetChild(2));
}
