home *** CD-ROM | disk | FTP | other *** search
/ Game Level Design / GLDesign.bin / Software / UnrealEngine2Runtime / UE2Runtime-22262001_Demo.exe / GUI / Classes / GUITabControl.uc < prev    next >
Encoding:
Text File  |  2003-06-30  |  10.8 KB  |  495 lines
  1. // ====================================================================
  2. //    GUITabControl - This control has a number of tabs
  3. //
  4. //  Written by Joe Wilcox
  5. //  (c) 2003, Epic Games, Inc.  All Rights Reserved
  6. //
  7. //    Modified by Ron Prestenback
  8. // ====================================================================
  9.  
  10. class GUITabControl extends GUIMultiComponent
  11.     Native;
  12.  
  13. cpptext
  14. {
  15.         void PreDraw(UCanvas* Canvas);
  16.         void Draw(UCanvas* Canvas);
  17.  
  18.         UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
  19.         UBOOL SpecialHit();
  20.         UBOOL MousePressed(UBOOL IsRepeat);                    // The Mouse was pressed
  21.         UBOOL MouseReleased();                                // The Mouse was released
  22.  
  23. }
  24.  
  25. var(Menu)    bool                bDockPanels;        // If true, associated panels will dock vertically with this control
  26.  
  27. var            array<GUITabButton> TabStack;
  28. var            GUITabButton        ActiveTab;
  29.  
  30. var            string                BackgroundStyleName;
  31. var            GUIStyles            BackgroundStyle;
  32. var            Material            BackgroundImage;
  33. var            float                 TabHeight;
  34. var            bool                bFillSpace;
  35.  
  36. function InitComponent(GUIController MyController, GUIComponent MyOwner)
  37. {
  38.  
  39.     Super.InitComponent(MyController, MyOwner);
  40.  
  41.     if (BackgroundStyleName != "")
  42.         BackgroundStyle = Controller.GetStyle(BackgroundStyleName);
  43.  
  44.     OnKeyEvent = InternalOnKeyEvent;
  45.     OnXControllerEvent = InternalOnXControllerEvent;
  46.  
  47. }
  48.  
  49. function bool InternalOnKeyEvent(out byte Key, out byte State, float delta)
  50. {
  51.     local int i,aTabIndex, StartIndex;
  52.  
  53.     if ( (FocusedControl!=None) || (State!=3) || (TabStack.Length<=0) )
  54.         return false;
  55.  
  56.     if (ActiveTab == None)
  57.         return false;
  58.  
  59.     for(i=0;i<TabStack.Length;i++)
  60.     {
  61.         if (TabStack[i]==ActiveTab)
  62.         {
  63.             aTabIndex = i;
  64.             break;
  65.         }
  66.     }
  67.  
  68.     if ( (Key==0x25) || (Key==0x64) )    // Left
  69.     {
  70.         StartIndex = aTabIndex;
  71.         while (true)
  72.         {
  73.             if (aTabIndex==0)
  74.                 aTabIndex=TabStack.Length-1;
  75.             else
  76.                 aTabIndex--;
  77.  
  78.             if (aTabIndex == StartIndex || ActivateTab(TabStack[aTabIndex],true))
  79.                 break;
  80.         }
  81.         return true;
  82.  
  83.     }
  84.  
  85.     if ( (Key==0x27) || (Key==0x66) )    // Right
  86.     {
  87.         StartIndex = aTabIndex;
  88.         while (true)
  89.         {
  90.             aTabIndex++;
  91.             if (aTabIndex==TabStack.Length)
  92.                 aTabIndex=0;
  93.  
  94.             if (StartIndex == aTabIndex || ActivateTab(TabStack[aTabIndex],true))
  95.                 break;
  96.         }
  97.         return true;
  98.     }
  99.  
  100.     return false;
  101. }
  102.  
  103. function bool InternalOnXControllerEvent(byte Id, eXControllerCodes iCode)
  104. {
  105.  
  106.      if (iCode == XC_LeftTrigger)
  107.     {
  108.         NextPage();
  109.         return true;
  110.     }
  111.  
  112.     else if (iCode == XC_RightTrigger)
  113.     {
  114.         PrevPage();
  115.         return true;
  116.     }
  117.  
  118.     return false;
  119.  
  120. }
  121.  
  122.  
  123. function GUITabPanel AddTab(string Caption, string PanelClass, optional GUITabPanel ExistingPanel, optional string Hint, optional bool bForceActive)
  124. {
  125.     local class<GUITabPanel> NewPanelClass;
  126.  
  127.     local GUITabButton NewTabButton;
  128.     local GUITabPanel  NewTabPanel;
  129.  
  130.     local int i;
  131.  
  132.     // Make sure this doesn't exist first
  133.     for (i=0;i<TabStack.Length;i++)
  134.     {
  135.         if (TabStack[i].Caption ~= Caption)
  136.         {
  137.             log("A Tab with the caption"@Caption@"already exists.");
  138.             return none;
  139.         }
  140.     }
  141.  
  142.     if (ExistingPanel==None)
  143.         NewPanelClass = class<GUITabPanel>(DynamicLoadObject(PanelClass,class'class'));
  144.  
  145.     if ( (ExistingPanel!=None) || (NewPanelClass != None) )
  146.     {
  147.         if (ExistingPanel != None)
  148.             NewTabPanel = GUITabPanel(AppendComponent(ExistingPanel));
  149.         else if (NewPanelClass != None)
  150.             NewTabPanel = GUITabPanel(AddComponent(PanelClass));
  151.  
  152.         if (NewTabPanel == None)
  153.         {
  154.             log("Could not create panel for"@NewPanelClass);
  155.             return None;
  156.         }
  157.  
  158.         if (NewTabPanel.MyButton != None)
  159.             NewTabButton = NewTabPanel.MyButton;
  160.         else
  161.         {
  162.             NewTabButton = new class'GUITabButton';
  163.             if (NewTabButton==None)
  164.             {
  165.                 log("Could not create tab for"@NewPanelClass);
  166.                 return None;
  167.             }
  168.  
  169.             NewTabButton.InitComponent(Controller, Self);
  170.             NewTabPanel.MyButton = NewTabButton;
  171.         }
  172.  
  173.         NewTabPanel.MyButton .Hint            = Hint;
  174.         NewTabPanel.MyButton .Caption        = Caption;
  175.         NewTabPanel.MyButton .OnClick        = InternalTabClick;
  176.         NewTabPanel.MyButton .MyPanel        = NewTabPanel;
  177.         NewTabPanel.MyButton .FocusInstead    = self;
  178.         NewTabPanel.MyButton .bNeverFocus    = true;
  179.  
  180.         NewTabPanel.InitPanel();
  181.         NewTabPanel.Hide();
  182.  
  183.         // Add the tab to controls
  184.         TabStack[TabStack.Length] = NewTabPanel.MyButton;
  185.         if ( (TabStack.Length==1) || (bForceActive) )
  186.         {
  187.             ActivateTab(NewTabPanel.MyButton,true);
  188.             NewTabPanel.FocusFirst(none);
  189.         }
  190.  
  191.         Return NewTabPanel;
  192.  
  193.     }
  194.     else
  195.         return none;
  196. }
  197.  
  198. function GUITabPanel InsertTab(int Pos, string Caption, string PanelClass, optional GUITabPanel ExistingPanel, optional string Hint, optional bool bForceActive)
  199. {
  200.     local class<GUITabPanel> NewPanelClass;
  201.     local GUITabPanel NewTabPanel;
  202.     local GUITabButton NewTabButton;
  203.  
  204.     if (ExistingPanel == None)
  205.         NewPanelClass = class<GUITabPanel>(DynamicLoadObject(PanelClass,class'Class'));
  206.  
  207.     if ( ExistingPanel != None || NewPanelClass != None)
  208.     {
  209.         if (ExistingPanel != None)
  210.             NewTabPanel = GUITabPanel(AppendComponent(ExistingPanel));
  211.         else if (NewPanelClass != None)
  212.             NewTabPanel = GUITabPanel(AddComponent(PanelClass));
  213.  
  214.         if (NewTabPanel == None)
  215.         {
  216.             log("Could not create panel for"@NewPanelClass);
  217.             return None;
  218.         }
  219.  
  220.         if (NewTabPanel.MyButton != None)
  221.             NewTabButton = NewTabPanel.MyButton;
  222.  
  223.         else
  224.         {
  225.             NewTabButton = new class'GUITabButton';
  226.             if (NewTabButton==None)
  227.             {
  228.                 log("Could not create tab for"@NewPanelClass);
  229.                 return None;
  230.             }
  231.  
  232.             NewTabButton.InitComponent(Controller, Self);
  233.             NewTabPanel.MyButton = NewTabButton;
  234.         }
  235.  
  236.  
  237.         NewTabPanel.MyButton.Caption = Caption;
  238.         NewTabPanel.MyButton.Hint = Hint;
  239.  
  240.         NewTabPanel.MyButton.OnClick = InternalTabClick;
  241.         NewTabPanel.MyButton.FocusInstead = self;
  242.         NewTabPanel.MyButton.bNeverFocus = true;
  243.         NewTabPanel.InitPanel();
  244.         NewTabPanel.Hide();
  245.  
  246.         TabStack.Insert(Pos, 1);
  247.         TabStack[Pos] = NewTabPanel.MyButton;
  248.         if ( (TabStack.Length==1) || (bForceActive) )
  249.         {
  250.             ActivateTab(NewTabPanel.MyButton,true);
  251.             NewTabPanel.FocusFirst(none);
  252.         }
  253.  
  254.         Return NewTabPanel;
  255.     }
  256.  
  257.     return None;
  258. }
  259.  
  260. // At present, this function causes RemapComponents() to be called twice,
  261. // once when the new component is added, once when the old is removed
  262. function GUITabPanel ReplaceTab(GUITabButton Which, string Caption, string PanelClass, optional GUITabPanel ExistingPanel, optional string Hint, optional bool bForceActive)
  263. {
  264.     local class<GUITabPanel> NewPanelClass;
  265.  
  266.     local GUITabPanel  NewTabPanel, OldTabPanel;
  267.  
  268.     if (ExistingPanel==None)
  269.         NewPanelClass = class<GUITabPanel>(DynamicLoadObject(PanelClass,class'class'));
  270.  
  271.     if ( (ExistingPanel!=None) || (NewPanelClass != None) )
  272.     {
  273.  
  274.            OldTabPanel = Which.MyPanel;
  275.  
  276.         if (ExistingPanel==None)
  277.             NewTabPanel = GUITabPanel(AddComponent(PanelClass));
  278.         else
  279.             NewTabPanel = GUITabPanel(AppendComponent(ExistingPanel));
  280.  
  281.         if (NewTabPanel==None)
  282.         {
  283.             log("Could not create panel"@NewPanelClass);
  284.             return none;
  285.         }
  286.  
  287.         Which.Caption            = Caption;
  288.         Which.Hint                = Hint;
  289.         Which.MyPanel            = NewTabPanel;
  290.         NewTabPanel.MyButton    = Which;
  291.  
  292.         // Init new panel
  293.         NewTabPanel.InitPanel();
  294.         NewTabPanel.Hide();
  295.  
  296.         // Make sure to notify old tab - so use ActivateTab
  297.         if ( bForceActive )
  298.             ActivateTab(NewTabPanel.MyButton, True);
  299.  
  300.         // Notify old panel
  301.         OldTabPanel.OnDestroyPanel(True);
  302.         RemoveComponent(OldTabPanel);
  303.  
  304.         return NewTabPanel;
  305.  
  306.     }
  307.     else
  308.         return none;
  309. }
  310.  
  311. function RemoveTab(optional string Caption, optional GUITabButton who)
  312. {
  313.     local int i;
  314.  
  315.     if ( (caption=="") && (Who==None) )
  316.         return;
  317.  
  318.     if (Who==None)
  319.         i = TabIndex(Caption);
  320.     else i = TabIndex(Who.Caption);
  321.  
  322.     if (i < 0)
  323.         return;
  324.  
  325.     if (TabStack[i] == ActiveTab)
  326.         LostActiveTab();
  327.  
  328.     TabStack[i].OnClick = None;
  329.     TabStack[i].MyPanel.OnDestroyPanel(True);
  330.     TabStack.Remove(i,1);
  331.     RemoveComponent(TabStack[i].MyPanel);
  332. }
  333.  
  334. function bool LostActiveTab()
  335. {
  336.     local int i;
  337.  
  338.     for (i = 0; i < TabStack.Length; i++)
  339.         if (ActivateTab(TabStack[i],true))
  340.             return true;
  341.  
  342.     return false;
  343. }
  344.  
  345. function bool ActivateTab(GUITabButton Who, bool bFocusPanel)
  346. {
  347.     if (Who == none || !Who.CanShowPanel())        // null or not selectable
  348.         return false;
  349.  
  350.     if (Who==ActiveTab)    // Same Tab, just accept
  351.         return true;
  352.  
  353.     // Deactivate the Active tab
  354.     if (ActiveTab != None)
  355.     {
  356.         ActiveTab.bActive = False;
  357.         if (ActiveTab.MyPanel != None)
  358.             ActiveTab.MyPanel.ShowPanel(False);
  359.     }
  360.  
  361.     // Set the new active Tab
  362.     ActiveTab = Who;
  363.     Who.bActive = True;
  364.     Who.MyPanel.ShowPanel(bFocusPanel);
  365.     OnChange(Who);
  366.  
  367.     return true;
  368. }
  369.  
  370. function bool ActivateTabByName(string tabname, bool bFocusPanel)
  371. {
  372.     local int i;
  373.  
  374.     i = TabIndex(TabName);
  375.     if (i < 0 || i >= TabStack.Length) return false;
  376.     else return ActivateTab(TabStack[i], bFocusPanel);
  377. }
  378.  
  379. function bool InternalTabClick(GUIComponent Sender)
  380. {
  381.     local GUITabButton But;
  382.  
  383.     But = GUITabButton(Sender);
  384.     if (But==None)
  385.         return false;
  386.  
  387.     ActivateTab(But,true);
  388.     if (ActiveTab!=None && ActiveTab.MyPanel!=None)
  389.         ActiveTab.MyPanel.FocusFirst(none);
  390.  
  391.     return true;
  392. }
  393.  
  394. event bool NextPage()
  395. {
  396.     local int i;
  397.  
  398.     // If 1 or no tabs in the stack, then query parents
  399.     if (TabStack.Length < 2)
  400.         return Super.NextPage();
  401.  
  402.     if (ActiveTab == None)
  403.         i = 0;
  404.     else
  405.     {
  406.         i = TabIndex(ActiveTab.Caption) + 1;
  407.         if ( i >= TabStack.Length )
  408.             i = 0;
  409.     }
  410.     return ActivateTab(TabStack[i], true);
  411. }
  412.  
  413. event bool PrevPage()
  414. {
  415.     local int i;
  416.  
  417.     if (TabStack.Length < 2)
  418.         return Super.NextPage();
  419.  
  420.     if (ActiveTab == None)
  421.         i = TabStack.Length - 1;
  422.     else
  423.     {
  424.         i = TabIndex(ActiveTab.Caption) - 1;
  425.         if ( i < 0 )
  426.             i = TabStack.Length - 1;
  427.     }
  428.     return ActivateTab(TabStack[i], true);
  429. }
  430.  
  431. event SetFocus(GUIComponent Who)
  432. {
  433.     if (Who==None)
  434.     {
  435.         if (Controller.FocusedControl!=None && Controller.FocusedControl!=Self)
  436.         {
  437.             Super(GUIComponent).SetFocus(Who);
  438.             return;
  439.         }
  440.         else
  441.         {
  442.             FocusFirst(None);
  443.         }
  444.  
  445.         return;
  446.     }
  447.     Super.SetFocus(Who);
  448. }
  449.  
  450. event bool NextControl(GUIComponent Sender)
  451. {
  452.  
  453.     if (Sender!=None && Sender.MenuOwner==self)
  454.         return Super(GUIComponent).NextControl(Sender);
  455.     else
  456.         FocusFirst(None);
  457.  
  458.     return true;
  459. }
  460.  
  461. event bool PrevControl(GUIComponent Sender)
  462. {
  463.  
  464.     if (Sender!=None && Sender.MenuOwner==self)
  465.     {
  466.         SetFocus(None);
  467.         return true;
  468.     }
  469.     else if (Sender==None)
  470.         return Super(GUIComponent).PrevControl(Sender);
  471.     else
  472.         FocusLast(None);
  473.  
  474.     return true;
  475.  
  476. }
  477.  
  478. function int TabIndex(string TabName)
  479. {
  480.     local int i;
  481.  
  482.     for (i = 0; i < TabStack.Length; i++)
  483.         if (TabStack[i].Caption ~= TabName)
  484.             return i;
  485.  
  486.     return -1;
  487. }
  488.  
  489. defaultproperties
  490. {
  491.     TabHeight=48
  492.     bFillSpace=false
  493.     bTabStop=true
  494.     bDockPanels=false
  495. }