home *** CD-ROM | disk | FTP | other *** search
/ Game Level Design / GLDesign.bin / Software / UnrealEngine2Runtime / UE2Runtime-22262001_Demo.exe / GUI / Classes / GUIController.uc < prev    next >
Text File  |  2003-07-02  |  17KB  |  681 lines
  1. // ====================================================================
  2. //  Class:  Engine.GUIController
  3. //
  4. //  The GUIController is a simple FILO menu stack.  You have 3 things
  5. //  you can do.  You can Open a menu which adds the menu to the top of the
  6. //  stack.  You can Replace a menu which replaces the current menu with the
  7. //  new menu.  And you can close a menu, which returns you to the last menu
  8. //  on the stack.
  9. //
  10. //  Written by Joe Wilcox
  11. //  (c) 2002, Epic Games, Inc.  All Rights Reserved
  12. // ====================================================================
  13.  
  14. class GUIController extends BaseGUIController
  15.         Native;
  16.  
  17. #exec OBJ LOAD FILE=GUIContent.utx
  18.  
  19. cpptext
  20. {
  21.         void  NativeMessage(const FString Msg, FLOAT MsgLife);
  22.         UBOOL NativeKeyType(BYTE& iKey, TCHAR Unicode );
  23.         UBOOL NativeKeyEvent(BYTE& iKey, BYTE& State, FLOAT Delta );
  24.         void  NativeTick(FLOAT DeltaTime);
  25.         void  NativePreRender(UCanvas* Canvas);
  26.         void  NativePostRender(UCanvas* Canvas);
  27.  
  28.         virtual void LookUnderCursor(FLOAT dX, FLOAT dY);
  29.         UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
  30.  
  31.         UBOOL virtual MousePressed(UBOOL IsRepeat);
  32.         UBOOL virtual MouseReleased();
  33.  
  34.         UBOOL HasMouseMoved();
  35.  
  36.         void PlayInterfaceSound(USound* sound);
  37.         void PlayClickSound(BYTE SoundNum);
  38. }
  39.  
  40. var    editinline export    array<GUIPage>        MenuStack;            // Holds the stack of menus
  41. var                        GUIPage                ActivePage;            // Points to the currently active page
  42. var editinline             Array<GUIFont>        FontStack;            // Holds all the possible fonts
  43. var                     Array<GUIStyles>    StyleStack;            // Holds all of the possible styles
  44. var                        Array<string>        StyleNames;            // Holds the name of all styles to use
  45. var editinline             Array<Material>        MouseCursors;        // Holds a list of all possible mouse
  46. var editinline            Array<vector>        MouseCursorOffset;  // Only X,Y used, between 0 and 1. 'Hot Spot' of cursor material.
  47. var                        Array<GUIPage>        PersistentStack;    // Holds the set of pages which are persistent across close/open
  48.  
  49. var                        byte                ControllerMask;        // Used to mask input for various Controllers
  50. var                        byte                ControllerId;        // The current Controller ID #
  51. var                        float                MouseX,MouseY;        // Where is the mouse currently located
  52.  
  53. var                        float                LastMouseX, LastMouseY;
  54.  
  55. var                        bool                ShiftPressed;        // Shift key is being held
  56. var                        bool                AltPressed;            // Alt key is being held
  57. var                        bool                CtrlPressed;        // Ctrl key is being held
  58.  
  59.  
  60. var                        float                DblClickWindow;            // How long do you have for a double click
  61. var                        float                LastClickTime;            // When did the last click occur
  62. var                        int                    LastClickX,LastClickY;    // Who was the active component
  63.  
  64. var                        float                ButtonRepeatDelay;        // The amount of delay for faking button repeats
  65. var                        byte                RepeatKey[4];            // Used to determine what should repeat
  66. var                        float                RepeatDelta[4];            // Data var
  67. var                        float                RepeatTime[4];            // How long until the next repeat;
  68. var                        float                CursorFade;                // How visible is the cursor
  69. var                        int                    CursorStep;                // Are we fading in or out
  70.  
  71. var                        float                FastCursorFade;            // How visible is the cursor
  72. var                        int                    FastCursorStep;            // Are we fading in or out
  73.  
  74. var                        GUIComponent        FocusedControl;            // Top most Focused control
  75. var                        GUIComponent         ActiveControl;            // Which control is currently active
  76. var                        GUIComponent        SkipControl;            // This control should be skipped over and drawn at the end
  77. var                        GUIComponent        MoveControl;            // Used for visual design
  78.  
  79. var                        bool                bIgnoreNextRelease;        // Used to make sure discard errant releases.
  80.  
  81. var config                bool                 bModAuthor;                // Allows bDesign Mode
  82. var                     bool                bDesignMode;            // Are we in design mode;
  83. var                        bool                bHighlightCurrent;        // Highlight the current control being edited
  84.  
  85.  
  86. var                        bool                bCurMenuInitialized;    // Has the current Menu Finished initialization
  87.  
  88. var                        string                GameResolution;
  89. var config                float                MenuMouseSens;
  90.  
  91. var                        bool                MainNotWanted;            // Set to true if you don't want main to appear.
  92.  
  93. // Sounds
  94. var                        sound                MouseOverSound;
  95. var                        sound                ClickSound;
  96. var                        sound                EditSound;
  97. var                        sound                UpSound;
  98. var                        sound                DownSound;
  99.  
  100. var                        bool                bForceMouseCheck;        // HACK
  101. var                        bool                bIgnoreUntilPress;        // HACK
  102.  
  103. var    config                array<string>        AutoLoad;    // Any menu classes in here will be automatically loaded
  104.  
  105.  
  106. // Joystick/JoyPad/Console Specific
  107.  
  108. var    config    bool    bEmulatedJoypad;    // Have the cursor keys emulate a XBox controller
  109. var    config    bool    bJoyMouse;            // When true, right control stick acts as a 1 button mouse
  110. var config  bool    bHideMouseCursor;    // When true, the mouse cursor will be hidden
  111. var config  float    JoyDeadZone;        // The DeadZone for joysticks
  112.  
  113. var        Float    JoyLeftXAxis[4];
  114. var        Float     JoyLeftYAxis[4];
  115. var        Float    JoyRightXAxis[4];
  116. var        Float    JoyRightYAxis[4];
  117. var        Byte    JoyButtons[64];
  118.  
  119. var float JoyControlsDelta[16];    // How long since a joystick was converted
  120.  
  121.  
  122.  
  123. // Temporary for Design Mode
  124. var Material WhiteBorder;
  125.  
  126. native event GUIFont GetMenuFont(string FontName);     // Finds a given font in the FontStack
  127. native event GUIStyles GetStyle(string StyleName);     // Find a style on the stack
  128. native function string GetCurrentRes();                // Returns the current res as a string
  129. native function string GetMainMenuClass();            // Returns GameEngine.MainMenuClass
  130.  
  131. // Utility functions for the UI
  132.  
  133. native function GetMapList(string Prefix, GUIList list);
  134.  
  135. native function ResetKeyboard();
  136. native function MouseEmulation(bool On);
  137.  
  138. delegate bool OnNeedRawKeyPress(byte NewKey);
  139.  
  140. // ================================================
  141. // CreateMenu - Attempts to Create a menu.  Returns none if it can't
  142.  
  143. event GUIPage CreateMenu(string NewMenuName)
  144. {
  145.     local class<GUIPage> NewMenuClass;
  146.     local GUIPage NewMenu;
  147.     local int i;
  148.  
  149.     // Load the menu's package if needed
  150.  
  151.     NewMenuClass = class<GUIPage>(DynamicLoadObject(NewMenuName,class'class'));
  152.     if (NewMenuClass != None)
  153.     {
  154.         // If it's persistent, try to find an instance in the PersistentStack.
  155.         if( NewMenuClass.default.bPersistent )
  156.         {
  157.             for( i=0;i<PersistentStack.Length;i++ )
  158.             {
  159.                 if( PersistentStack[i].Class == NewMenuClass )
  160.                 {
  161.                     NewMenu = PersistentStack[i];
  162.                     break;
  163.                 }
  164.             }
  165.         }
  166.  
  167.         // Not found, spawn a new menu
  168.         if( NewMenu == None )
  169.         {
  170.             NewMenu = new(None) NewMenuClass;
  171.  
  172.             // Check for errors
  173.             if (NewMenu == None)
  174.             {
  175.                 log("Could not create requested menu"@NewMenuName);
  176.                 return None;
  177.             }
  178.             else
  179.             if( NewMenuClass.default.bPersistent )
  180.             {
  181.                 // Save in PersistentStack if it's persistent.
  182.                 i = PersistentStack.Length;
  183.                 PersistentStack.Length = i+1;
  184.                 PersistentStack[i] = NewMenu;
  185.             }
  186.         }
  187.         return NewMenu;
  188.     }
  189.     else
  190.     {
  191.         log("Could not DLO menu '"$NewMenuName$"'");
  192.         return none;
  193.     }
  194.  
  195. }
  196. // ================================================
  197. // OpenMenu - Opens a new menu and places it on top of the stack
  198.  
  199.  
  200.  
  201. event bool OpenMenu(string NewMenuName, optional string Param1, optional string Param2)
  202. {
  203.     local GUIPage NewMenu,CurMenu;
  204.  
  205.     // Sanity Check
  206.  
  207.     //log("GUIController::OpenMenu - Attempt to open menu ["$NewMenuName$"]");
  208.     //log("GUIController::MenuMouseSens="$MenuMouseSens);
  209.  
  210.     NewMenu = CreateMenu(NewMenuName);
  211.  
  212.     bCurMenuInitialized=false;
  213.     if (NewMenu!=None)
  214.     {
  215.  
  216.         CurMenu = ActivePage;
  217.  
  218.         NewMenu.ParentPage = CurMenu;
  219.  
  220.         // Add this menu to the stack and give it focus
  221.  
  222.         MenuStack.Length = MenuStack.Length+1;
  223.         MenuStack[MenuStack.Length-1] = NewMenu;
  224.  
  225.         ActivePage = NewMenu;
  226.  
  227.         ResetFocus();
  228.  
  229.         // If not persistent, Initialize this Menu
  230.  
  231.         if (NewMenu.Controller == None)
  232.             NewMenu.InitComponent(Self, none);
  233.  
  234.         // Remove focus from the last menu
  235.  
  236.         if (CurMenu!=None)
  237.         {
  238.             CurMenu.MenuState = MSAT_Blurry;
  239.             CurMenu.OnDeActivate();
  240.         }
  241.  
  242.         NewMenu.CheckResolution(false);
  243.         NewMenu.Opened(None);    // Pass along the event
  244.         NewMenu.MenuState = MSAT_Focused;
  245.         NewMenu.PlayOpenSound();
  246.  
  247.         SetControllerStatus(true);
  248.         bCurMenuInitialized=true;
  249.  
  250.         NewMenu.HandleParameters(Param1, Param2);
  251.  
  252.         bForceMouseCheck = true;
  253.  
  254.         if (NewMenu.bDisconnectOnOpen)
  255.         {
  256.             ConsoleCommand("disconnect");
  257.         }
  258.  
  259.         return true;
  260.     }
  261.     else
  262.     {
  263.         log("Could not open menu"@NewMenuName);
  264.         return false;
  265.     }
  266. }
  267.  
  268. event AutoLoadMenus()
  269. {
  270.     local GUIPage NewMenu;
  271.     local int i;
  272.  
  273.     super.AutoLoadMenus();
  274.  
  275.     for (i=0;i<AutoLoad.Length;i++)
  276.     {
  277.         NewMenu = CreateMenu(AutoLoad[i]);
  278.         if (NewMenu==None)
  279.             log("Could not auto-load"@AutoLoad[i]);
  280.     }
  281. }
  282.  
  283. // ================================================
  284. // Replaces a menu in the stack.  returns true if success
  285.  
  286. event bool ReplaceMenu(string NewMenuName, optional string Param1, optional string Param2)
  287. {
  288.     local GUIPage NewMenu,CurMenu;
  289.  
  290.     NewMenu = CreateMenu(NewMenuName);
  291.     bCurMenuInitialized=false;
  292.     if (NewMenu!=None)
  293.     {
  294.         CurMenu = ActivePage;
  295.  
  296.         // Add this menu to the stack and give it focus
  297.  
  298.         NewMenu.MenuState = MSAT_Focused;
  299.  
  300.         if (CurMenu==None)
  301.             MenuStack.Length = MenuStack.Length+1;
  302.         else
  303.                CurMenu.OnClose(false);
  304.  
  305.         MenuStack[MenuStack.Length-1] = NewMenu;
  306.         ActivePage = NewMenu;
  307.         NewMenu.ParentPage = CurMenu.ParentPage;
  308.  
  309.         ResetFocus();
  310.  
  311.         if (NewMenu.Controller == None)
  312.             NewMenu.InitComponent(Self, None);
  313.  
  314.         NewMenu.CheckResolution(false);
  315.         NewMenu.Opened(None);                        // Pass along the event
  316.         NewMenu.MenuState = MSAT_Focused;
  317.         NewMenu.OnActivate();
  318.         NewMenu.PlayOpenSound();
  319.  
  320.         SetControllerStatus(true);
  321.         bCurMenuInitialized=true;
  322.  
  323.         NewMenu.HandleParameters(Param1, Param2);
  324.         bForceMouseCheck = true;
  325.  
  326.         if (CurMenu!=None) // Close out the current page
  327.         {
  328.             CurMenu.ParentPage=None;
  329.  
  330.             if (!CurMenu.bPersistent)       // keep access to the controller if we are not up
  331.                 CurMenu.Free();
  332.         }
  333.  
  334.  
  335.         return true;
  336.     }
  337.     else
  338.         return false;
  339. }
  340. event bool CloseMenu(optional bool bCanceled)    // Close the top menu.  returns true if success.
  341. {
  342.  
  343.     local GUIPage CurMenu;
  344.     local int       CurIndex;
  345.  
  346.     if (MenuStack.Length <= 0)
  347.     {
  348.         log("Attempting to close a non-existing menu page");
  349.         return false;
  350.     }
  351.  
  352.     CurIndex = MenuStack.Length-1;
  353.     CurMenu = MenuStack[CurIndex];
  354.  
  355.     log("GUIController::CloseMenu - "@CurMenu);
  356.  
  357.     // Remove the menu from the stack
  358.     MenuStack.Remove(MenuStack.Length-1,1);
  359.  
  360.     // Look for the resolution switch
  361.  
  362.     CurMenu.PlayCloseSound();        // Play the closing sound
  363.     CurMenu.Closed(None,bCanceled);
  364.  
  365.     CurMenu.ParentPage=None;
  366.  
  367.     if (!CurMenu.bPersistent)        // keep access to the controller if we are not up
  368.         CurMenu.Free();                // Free up this menu
  369.  
  370.     MoveControl = None;
  371.     SkipControl = None;
  372.  
  373.     // Gab the next page on the stack
  374.     bCurMenuInitialized=false;
  375.     if (MenuStack.Length>0)    // Pass control back to the previous menu
  376.     {
  377.         ActivePage = MenuStack[MenuStack.Length-1];
  378.         ActivePage.MenuState = MSAT_Focused;
  379.         ActivePage.CheckResolution(true);
  380.  
  381.         ActivePage.Opened(none);
  382.         ActivePage.OnActivate();
  383.  
  384.         ActiveControl = none;
  385.  
  386.         ActivePage.FocusFirst(None);
  387.     }
  388.     else
  389.     {
  390.  
  391.         if (!CurMenu.bAllowedAsLast)
  392.         {
  393.             OpenMenu(GetMainMenuClass());
  394.             return true;
  395.         }
  396.  
  397.         ActivePage = None;
  398.          SetControllerStatus(false);
  399.     }
  400.  
  401.     bCurMenuInitialized=true;
  402.  
  403.     bForceMouseCheck = true;
  404.  
  405.     return true;
  406. }
  407.  
  408. function GUIPage TopPage()
  409. {
  410.     return ActivePage;
  411. }
  412.  
  413. function SetControllerStatus(bool On)
  414. {
  415.     bActive = On;
  416.     bVisible = On;
  417.     bRequiresTick=On;
  418.  
  419.     // Attempt to Pause as well as show the windows mouse cursor.
  420.  
  421. //    ViewportOwner.Actor.Level.Game.SetPause(On, ViewportOwner.Actor);
  422.     ViewportOwner.bShowWindowsMouse=On;
  423.  
  424.     // Add code to pause/unpause/hide/etc the game here.
  425.  
  426.     if (On)
  427.         bIgnoreUntilPress = true;
  428.     else
  429.         ViewportOwner.Actor.ConsoleCommand("toggleime 0");
  430. }
  431.  
  432.  
  433. event CloseAll(bool bCancel)
  434. {
  435.     local int i;
  436.  
  437.     // Close the current menu manually before we clean up the stack.
  438.     if( MenuStack.Length >= 0 )
  439.     {
  440.         if ( !CloseMenu(bCancel) )
  441.             return;
  442.     }
  443.  
  444.     for (i=0;i<MenuStack.Length;i++)
  445.     {
  446.         MenuStack[i].CheckResolution(true);
  447.         MenuStack[i].ParentPage = None;
  448.  
  449.         if (!MenuStack[i].bPersistent)
  450.             MenuStack[i].Free();
  451.  
  452.         MenuStack[i] = None;
  453.     }
  454.  
  455.     if (GameResolution!="")
  456.     {
  457.         ViewportOwner.Actor.ConsoleCommand("SETRES"@GameResolution);
  458.         GameResolution="";
  459.     }
  460.  
  461.  
  462.     ActivePage=None;
  463.     MenuStack.Remove(0,MenuStack.Length);
  464.     SetControllerStatus(false);
  465.  
  466. }
  467.  
  468. event InitializeController()
  469. {
  470.     local int i;
  471.     local class<GUIStyles> NewStyleClass;
  472.  
  473.     for (i=0;i<StyleNames.Length;i++)
  474.     {
  475.         NewStyleClass = class<GUIStyles>(DynamicLoadObject(StyleNames[i],class'class'));
  476.  
  477.         if (NewStyleClass != None)
  478.             if (!RegisterStyle(NewStyleClass))
  479.                 log("Could not create requested style"@StyleNames[i]);
  480.  
  481.     }
  482. }
  483.  
  484. function bool RegisterStyle(class<GUIStyles> StyleClass)
  485. {
  486. local GUIStyles NewStyle;
  487.  
  488.     if (StyleClass != None && !StyleClass.default.bRegistered)
  489.     {
  490.         NewStyle = new(None) StyleClass;
  491.  
  492.         // Check for errors
  493.  
  494.         if (NewStyle != None)
  495.         {
  496.             // Dynamic Array Auto Sizes StyleStack.
  497.             StyleStack[StyleStack.Length] = NewStyle;
  498.             NewStyle.Controller = self;
  499.             NewStyle.Initialize();
  500.             return true;
  501.         }
  502.     }
  503.     return false;
  504. }
  505.  
  506. event ChangeFocus(GUIComponent Who)
  507. {
  508.     return;
  509. }
  510.  
  511. function ResetFocus()
  512. {
  513.     local int i;
  514.  
  515.     if (ActiveControl!=None)
  516.     {
  517.         ActiveControl.MenuStateChange(MSAT_Blurry);
  518.         ActiveControl=None;
  519.     }
  520.  
  521.     for (i=0;i<4;i++)
  522.     {
  523.         RepeatKey[i]=0;
  524.         RepeatTime[i]=0;
  525.     }
  526. }
  527.  
  528. event MoveFocused(GUIComponent Ctrl, int bmLeft, int bmTop, int bmWidth, int bmHeight, float ClipX, float ClipY)
  529. {
  530.     local float val;
  531.  
  532.  
  533.     if (AltPressed)
  534.         val = 5;
  535.     else
  536.         val = 1;
  537.  
  538.     if (bmLeft!=0)
  539.     {
  540.         if (Ctrl.WinLeft<1)
  541.             Ctrl.WinLeft = Ctrl.WinLeft + ( (Val/ClipX) * bmLeft);
  542.         else
  543.             Ctrl.WinLeft += (Val*bmLeft);
  544.     }
  545.  
  546.     if (bmTop!=0)
  547.     {
  548.         if (Ctrl.WinTop<1)
  549.             Ctrl.WinTop = Ctrl.WinTop + ( (Val/ClipY) * bmTop);
  550.         else
  551.             Ctrl.WinTop+= (Val*bmTop);
  552.     }
  553.  
  554.     if (bmWidth!=0)
  555.     {
  556.         if (Ctrl.WinWidth<1)
  557.             Ctrl.WinWidth = Ctrl.WinWidth + ( (Val/ClipX) * bmWidth);
  558.         else
  559.             Ctrl.WinWidth += (Val*bmWidth);
  560.     }
  561.  
  562.     if (bmHeight!=0)
  563.     {
  564.         if (Ctrl.WinHeight<1)
  565.             Ctrl.WinHeight = Ctrl.WinHeight + ( (Val/ClipX) * bmHeight);
  566.         else
  567.             Ctrl.WinHeight += (Val*bmHeight);
  568.     }
  569. }
  570.  
  571. function bool HasMouseMoved()
  572. {
  573.     if (MouseX==LastMouseX && MouseY==LastMouseY)
  574.         return false;
  575.     else
  576.         return true;
  577. }
  578.  
  579. event bool NeedsMenuResolution()
  580. {
  581.  
  582.     if ( (ActivePage!=None) && (ActivePage.bRequire640x480) )
  583.         return true;
  584.     else
  585.         return false;
  586. }
  587.  
  588. event SetRequiredGameResolution(string GameRes)
  589. {
  590.     GameResolution = GameRes;
  591. }
  592.  
  593. event NotifyLevelChange()
  594. {
  595.     local int i;
  596.  
  597.     for (i=0;i<MenuStack.Length;i++)
  598.         MenuStack[i].NotifyLevelChange();
  599. }
  600.  
  601. defaultproperties
  602. {
  603.     Begin Object Class=fntMenuFont Name=GUIMenuFont
  604.         bFixedSize=false
  605.     End Object
  606.     FontStack(0)=GUIMenuFont
  607.  
  608.     Begin Object Class=fntDefaultFont Name=GUIDefaultFont
  609.         bFixedSize=true
  610.     End Object
  611.     FontStack(1)=GUIDefaultFont
  612.  
  613.     Begin Object Class=fntLargeFont Name=GUILargeFont
  614.         bFixedSize=false
  615.     End Object
  616.     FontStack(2)=GUILargeFont
  617.  
  618.     Begin Object Class=fntHeaderFont Name=GUIHeaderFont
  619.         bFixedSize=false
  620.     End Object
  621.     FontStack(3)=GUIHeaderFont
  622.  
  623.     Begin Object Class=fntSmallFont Name=GUISmallFont
  624.         bFixedSize=false
  625.     End Object
  626.     FontStack(4)=GUISmallFont
  627.  
  628.     Begin Object Class=fntSmallHeaderFont Name=GUISmallHeaderFont
  629.         bFixedSize=false
  630.     End Object
  631.     FontStack(5)=GUISmallHeaderFont
  632.  
  633.     StyleNames(0)="GUI.STY_RoundButton"
  634.     StyleNames(1)="GUI.STY_RoundScaledButton"
  635.     StyleNames(2)="GUI.STY_SquareButton"
  636.     StyleNames(3)="GUI.STY_ListBox"
  637.     StyleNames(4)="GUI.STY_ScrollZone"
  638.     StyleNames(5)="GUI.STY_TextButton"
  639.     StyleNames(6)="GUI.STY_Header"
  640.     StyleNames(7)="GUI.STY_Footer"
  641.     StyleNames(8)="GUI.STY_TabButton"
  642.     StyleNames(9)="GUI.STY_NoBackground"
  643.     StyleNames(10)="GUI.STY_SliderCaption"
  644.     StyleNames(11)="GUI.STY_SquareBar"
  645.     StyleNames(12)="GUI.STY_TextLabel"
  646.     StyleNames(13)="GUI.STY_ComboListBox"
  647.  
  648.     // See Player.uc IDC_ definitions
  649.     MouseCursors(0)=material'GUIContent.MouseCursor'        // Arrow
  650.     MouseCursors(1)=material'GUIContent.MouseCursor'        // SizeAll
  651.     MouseCursors(2)=material'GUIContent.MouseCursor'        // Size NE SW
  652.     MouseCursors(3)=material'GUIContent.MouseCursor'        // Size NS
  653.     MouseCursors(4)=material'GUIContent.MouseCursor'        // Size NW SE
  654.     MouseCursors(5)=material'GUIContent.MouseCursor'        // Size WE
  655.     MouseCursors(6)=material'GUIContent.MouseCursor'        // Wait
  656.  
  657.     MouseCursorOffset(0)=(X=0,Y=0,Z=0)
  658.     MouseCursorOffset(1)=(X=0,Y=0,Z=0)
  659.     MouseCursorOffset(2)=(X=0,Y=0,Z=0)
  660.     MouseCursorOffset(3)=(X=0,Y=0,Z=0)
  661.     MouseCursorOffset(4)=(X=0,Y=0,Z=0)
  662.     MouseCursorOffset(5)=(X=0,Y=0,Z=0)
  663.     MouseCursorOffset(6)=(X=0,Y=0,Z=0)
  664.  
  665.     ButtonRepeatDelay=0.25
  666.     CursorStep=1
  667.     FastCursorStep=1
  668.     // Design Mode stuff
  669.     WhiteBorder=Material'GUIContent.Menu.WhiteBorder'
  670.      DblClickWindow=0.5
  671.  
  672.     MenuMouseSens=1.0
  673.     bHighlightCurrent=true
  674.  
  675.     ControllerMask=255
  676.     bEmulatedJoypad=false
  677.     bJoyMouse=false
  678.     bHideMouseCursor=true
  679.     JoyDeadZone=0.3
  680.  
  681. }