Merge pull request #730 from Areloch/BaseUIModuleStandardizePR

Base UI module standardize pr

Engine/source/Verve/GUI/VEditorButton.cpp

@@ -186,7 +186,7 @@ void VEditorButton::onRender( Point2I offset, const RectI& updateRect )
         {
             RectI boundsRect( offset, getExtent() );
 
-            if ( mDepressed || mStateOn || mMouseOver )
+            if ( mDepressed || mStateOn || mHighlighted )
             {
                 renderFilledBorder( boundsRect, mProfile->mBorderColorHL, mProfile->mFillColorHL );
             }

Engine/source/afx/ui/afxSpellButton.cpp

@@ -221,7 +221,7 @@ void afxSpellButton::onRender(Point2I offset, const RectI& updateRect)
 
   if (mActive)
   {
-    if (mMouseOver) state = HILIGHT;
+    if (mHighlighted) state = HILIGHT;
     if (mDepressed || mStateOn) state = DEPRESSED;
   }
   else

Engine/source/gui/buttons/guiBitmapButtonCtrl.h

@@ -138,7 +138,7 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
          if( mActive )
          {
 				if( mDepressed || mStateOn ) return DEPRESSED;
-            if( mMouseOver ) return HILIGHT;
+            if( mHighlighted ) return HILIGHT;
             return NORMAL;
          }
          else

Engine/source/gui/buttons/guiBorderButton.cpp

@@ -79,7 +79,7 @@ void GuiBorderButtonCtrl::onRender(Point2I offset, const RectI &updateRect)
          }
       }
 
-      if ( mMouseOver )
+      if ( mHighlighted )
       {
          RectI bounds( offset, getExtent() );
          for ( S32 i=0; i < mProfile->mBorderThickness; i++ )

Engine/source/gui/buttons/guiButtonBaseCtrl.cpp

@@ -98,7 +98,7 @@ EndImplementEnumType;
 GuiButtonBaseCtrl::GuiButtonBaseCtrl()
 {
    mDepressed = false;
-   mMouseOver = false;
+   mHighlighted = false;
    mActive = true;
    static StringTableEntry sButton = StringTable->insert( "Button" );
    mButtonText = sButton;
@@ -288,14 +288,14 @@ void GuiButtonBaseCtrl::onMouseEnter(const GuiEvent &event)
    if(isMouseLocked())
    {
       mDepressed = true;
-      mMouseOver = true;
+      mHighlighted = true;
    }
    else
    {
       if ( mActive && mProfile->mSoundButtonOver )
          SFX->playOnce(mProfile->mSoundButtonOver);
 
-      mMouseOver = true;
+      mHighlighted = true;
    }
 }
 
@@ -309,7 +309,7 @@ void GuiButtonBaseCtrl::onMouseLeave(const GuiEvent &)
       onMouseLeave_callback();
    if( isMouseLocked() )
       mDepressed = false;
-   mMouseOver = false;
+   mHighlighted = false;
 }
 
 //-----------------------------------------------------------------------------
@@ -542,3 +542,17 @@ DefineEngineMethod( GuiButtonBaseCtrl, resetState, void, (),,
 {
    object->resetState();
 }
+
+DefineEngineMethod(GuiButtonBaseCtrl, setHighlighted, void, (bool highlighted), (false),
+   "Reset the mousing state of the button.\n\n"
+   "This method should not generally be called.")
+{
+   object->setHighlighted(highlighted);
+}
+
+DefineEngineMethod(GuiButtonBaseCtrl, isHighlighted, bool, (),,
+   "Reset the mousing state of the button.\n\n"
+   "This method should not generally be called.")
+{
+   return object->isHighlighted();
+}

Engine/source/gui/buttons/guiButtonBaseCtrl.h

@@ -49,7 +49,7 @@ class GuiButtonBaseCtrl : public GuiControl
       StringTableEntry mButtonText;
       StringTableEntry mButtonTextID;
       bool mDepressed;
-      bool mMouseOver;
+      bool mHighlighted;
       bool mStateOn;
       S32 mButtonType;
       S32 mRadioGroup;
@@ -95,7 +95,10 @@ class GuiButtonBaseCtrl : public GuiControl
       bool getStateOn() const { return mStateOn; }
 
       void setDepressed( bool depressed ) { mDepressed = depressed; }
-      void resetState() {mDepressed = false; mMouseOver = false;}
+      void resetState() {mDepressed = false; mHighlighted = false;}
+
+      void setHighlighted(bool highlighted) { mHighlighted = highlighted; }
+      bool isHighlighted() { return mHighlighted; }
 
       void acceleratorKeyPress(U32 index);
       void acceleratorKeyRelease(U32 index);

Engine/source/gui/buttons/guiButtonCtrl.cpp

@@ -83,7 +83,7 @@ bool GuiButtonCtrl::onWake()
 void GuiButtonCtrl::onRender(Point2I      offset,
                              const RectI& updateRect)
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
 
    ColorI fontColor   = mActive ? ( highlight ? mProfile->mFontColorHL : mProfile->mFontColor ) : mProfile->mFontColorNA;
@@ -107,7 +107,7 @@ void GuiButtonCtrl::onRender(Point2I      offset,
          indexMultiplier = 4;
       else if ( mDepressed || mStateOn )
          indexMultiplier = 2;
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          indexMultiplier = 3;
 
       renderSizableBitmapBordersFilled( boundsRect, indexMultiplier, mProfile );
@@ -123,3 +123,4 @@ void GuiButtonCtrl::onRender(Point2I      offset,
    //render the children
    renderChildControls( offset, updateRect);
 }
+

Engine/source/gui/buttons/guiCheckBoxCtrl.cpp

@@ -106,7 +106,7 @@ void GuiCheckBoxCtrl::onRender(Point2I offset, const RectI &updateRect)
    }
 
    ColorI backColor = mActive ? mProfile->mFillColor : mProfile->mFillColorNA;
-   ColorI fontColor = mActive ? (mMouseOver ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
+   ColorI fontColor = mActive ? (mHighlighted ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
    ColorI insideBorderColor = isFirstResponder() ? mProfile->mBorderColorHL : mProfile->mBorderColor;
 
    // just draw the check box and the text:

Engine/source/gui/buttons/guiIconButtonCtrl.cpp

@@ -218,7 +218,7 @@ void GuiIconButtonCtrl::onRender(Point2I offset, const RectI& updateRect)
 
 void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
    
    ColorI fontColor   = mActive ? (highlight ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
@@ -236,7 +236,7 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
       else
          renderSlightlyLoweredBox(boundsRect, mProfile);
    }
-   else if(mMouseOver && mActive)
+   else if(mHighlighted && mActive)
    {
       // If there is a bitmap array then render using it.  
       // Otherwise use a standard fill.

Engine/source/gui/buttons/guiSwatchButtonCtrl.cpp

@@ -90,7 +90,7 @@ bool GuiSwatchButtonCtrl::onWake()
 
 void GuiSwatchButtonCtrl::onRender( Point2I offset, const RectI &updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
 
    ColorI borderColor = mActive ? ( highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor ) : mProfile->mBorderColorNA;
 

Engine/source/gui/buttons/guiToggleButtonCtrl.cpp

@@ -66,7 +66,7 @@ void GuiToggleButtonCtrl::onPreRender()
 void GuiToggleButtonCtrl::onRender(Point2I      offset,
                                    const RectI& updateRect)
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
 
    ColorI fontColor   = mActive ? ( highlight ? mProfile->mFontColorHL : mProfile->mFontColor ) : mProfile->mFontColorNA;
@@ -89,7 +89,7 @@ void GuiToggleButtonCtrl::onRender(Point2I      offset,
          indexMultiplier = 4;
       else if ( mDepressed || mStateOn )
          indexMultiplier = 2;
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          indexMultiplier = 3;
 
 

Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp

@@ -144,7 +144,7 @@ void GuiToolboxButtonCtrl::onRender(Point2I offset, const RectI& updateRect)
       RectI r(offset, getExtent());
       if ( mDepressed  || mStateOn )
          renderStateRect( mLoweredBitmap , r );
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          renderStateRect( mHoverBitmap , r );
    }
 

Engine/source/gui/controls/guiGameSettingsCtrl.cpp

@@ -0,0 +1,1121 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include "guiGameSettingsCtrl.h"
+
+#include "console/consoleTypes.h"
+#include "console/engineAPI.h"
+#include "gfx/gfxDrawUtil.h"
+#include "gui/containers/guiScrollCtrl.h"
+#include "core/strings/stringUnit.h"
+#include "gui/core/guiDefaultControlRender.h"
+
+//-----------------------------------------------------------------------------
+// GuiGameSettingsCtrl
+//-----------------------------------------------------------------------------
+
+GuiGameSettingsCtrl::GuiGameSettingsCtrl() :
+   mLabel(StringTable->EmptyString()),
+   mScriptCallback(StringTable->EmptyString()),
+   mTooltip(StringTable->EmptyString()),
+   mEnabled(true),
+   mSelected(false),
+   mSelectedOption(0),
+   mWrapOptions(false),
+   mMode(Mode::Default),
+   mValue(0),
+   mStepSize(1),
+   mRange(Point2F(0, 1)),
+   mCallbackOnInputs(false),
+   mConsumeKeyInputEvents(false),
+   mArrowSize(30),
+   mColumnSplit(250),
+   mRightPad(20)
+{
+   VECTOR_SET_ASSOCIATION(mOptions);
+
+   // initialize the control callbacks
+   mCallbackOnA = StringTable->EmptyString();
+   mCallbackOnB = mCallbackOnA;
+   mCallbackOnX = mCallbackOnA;
+   mCallbackOnY = mCallbackOnA;
+
+   INIT_ASSET(KeybindBitmap);
+   INIT_ASSET(PreviousBitmap);
+   INIT_ASSET(NextBitmap);
+}
+
+GuiGameSettingsCtrl::~GuiGameSettingsCtrl()
+{
+   mOptions.clear();
+}
+
+void GuiGameSettingsCtrl::onMouseMove(const GuiEvent& event)
+{
+   //check if we're inside an arrow/slider/etc and kick a highlight action
+   Parent::onMouseMove(event);
+}
+
+void GuiGameSettingsCtrl::onMouseUp(const GuiEvent& event)
+{
+   Parent::onMouseUp(event);
+
+   if (isEnabled())
+   {
+      if (mMode == Mode::Default)
+      {
+         activate();
+      }
+      else if (mMode == Mode::OptionList)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickOption(xPos);
+      }
+      else if (mMode == Mode::Slider)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickSlider(xPos);
+      }
+      else if (mMode == Mode::Keybind)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickKeybind(xPos);
+      }
+   }
+}
+
+void GuiGameSettingsCtrl::onRender(Point2I offset, const RectI &updateRect)
+{
+   GFXDrawUtil* drawUtil = GFX->getDrawUtil();
+
+   F32 xScale = (float) getWidth();
+
+   S32 height = getHeight();
+
+   Point2I currentOffset = offset;
+   Point2I extent = getExtent();
+   Point2I textOffset(mProfile->mTextOffset.x * xScale, mProfile->mTextOffset.y);
+   Point2I textExtent(mColumnSplit, height);
+   Point2I iconExtent, iconOffset(0.0f, 0.0f);
+
+   bool highlight = mHighlighted;
+   bool depressed = mDepressed;
+
+   ColorI fontColor = mActive ? (highlight ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
+   ColorI fillColor = mActive ? (highlight ? mProfile->mFillColorHL : mProfile->mFillColor) : mProfile->mFillColorNA;
+   ColorI borderColor = mActive ? (highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor) : mProfile->mBorderColorNA;
+
+   RectI boundsRect(offset, getExtent());
+
+   if (!mHasTheme)
+   {
+      if (mProfile->mBorder != 0)
+         renderFilledBorder(boundsRect, borderColor, fillColor, mProfile->mBorderThickness);
+      else
+         GFX->getDrawUtil()->drawRectFill(boundsRect, fillColor);
+   }
+   else
+   {
+      S32 indexMultiplier = 1;
+
+      if (!mActive)
+         indexMultiplier = 4;
+      else if (mDepressed || mStateOn)
+         indexMultiplier = 2;
+      else if (mHighlighted)
+         indexMultiplier = 3;
+
+      renderSizableBitmapBordersFilled(boundsRect, indexMultiplier, mProfile);
+   }
+
+   // render the text
+   drawUtil->setBitmapModulation(fontColor);
+   renderJustifiedText(currentOffset + textOffset, textExtent, mLabel);
+
+   if (mMode == Mode::OptionList)
+   {
+      onRenderListOption(currentOffset);
+   }
+   else if (mMode == Mode::Slider)
+   {
+      onRenderSliderOption(currentOffset);
+   }
+   else if (mMode == Mode::Keybind)
+   {
+      onRenderKeybindOption(currentOffset);
+   }
+
+   renderChildControls(offset, updateRect);
+}
+
+void GuiGameSettingsCtrl::onRenderListOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 height = getHeight();
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+
+   Point2I arrowOffset;
+
+   S32 arrowOffsetY = 0;
+
+   bool hasOptions = (mOptions.size() > 0) && mSelectedOption > -1;
+   if (hasOptions)
+   {
+      if (mPreviousBitmapAsset.notNull())
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + mColumnSplit;
+         arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+         drawer->clearBitmapModulation();
+         drawer->drawBitmapStretch(mPreviousBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+      }
+      else
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + mColumnSplit;
+         arrowOffset.y = currentOffset.y + height/2;
+
+         drawer->clearBitmapModulation();
+
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y), ColorI::WHITE);
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y + height), ColorI::WHITE);
+      }
+
+      if (mNextBitmapAsset.notNull())
+      {
+         // render the right arrow
+         bool arrowOnR = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption < mOptions.size() - 1));
+         arrowOffset.x = currentOffset.x + getWidth() - mRightPad - mArrowSize;
+         arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+         drawer->clearBitmapModulation();
+         drawer->drawBitmapStretch(mNextBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+      }
+      else
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + getWidth() - mRightPad;
+         arrowOffset.y = currentOffset.y + height / 2;
+
+         drawer->clearBitmapModulation();
+
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y), ColorI::WHITE);
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y + height), ColorI::WHITE);
+      }
+
+      // get the appropriate font color
+      ColorI fontColor;
+      if (!mEnabled)
+      {
+         fontColor = mProfile->mFontColorNA;
+      }
+      else if (isSelected())
+      {
+         fontColor = mProfile->mFontColorSEL;
+      }
+      else if (isHighlighted())
+      {
+         fontColor = mProfile->mFontColorHL;
+      }
+      else
+      {
+         fontColor = mProfile->mFontColor;
+      }
+
+      // calculate text to be at the center between the arrows
+      GFont* font = mProfile->mFont;
+      StringTableEntry text = mOptions[mSelectedOption].mDisplayText;
+      S32 textWidth = font->getStrWidth(text);
+      S32 columnWidth = xScale - mRightPad - mColumnSplit;
+      S32 columnCenter = mColumnSplit + (columnWidth >> 1);
+      S32 textStartX = columnCenter - (textWidth >> 1);
+      Point2I textOffset(textStartX, 0);
+
+      // render the option text itself
+      Point2I textExtent(columnWidth, height);
+      drawer->setBitmapModulation(fontColor);
+      renderJustifiedText(currentOffset + Point2I(mColumnSplit, 0), textExtent, text);
+   }
+}
+
+void GuiGameSettingsCtrl::onRenderSliderOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 height = getHeight();
+
+   S32 arrowOffsetY = 0;
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+
+   Point2I arrowOffset;
+   S32 columnSplit = mColumnSplit;
+
+   
+
+   /*if (mPreviousBitmapAsset.notNull())
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + columnSplit;
+      arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mPreviousBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+   else
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + mColumnSplit;
+      arrowOffset.y = currentOffset.y + height / 2;
+
+      drawer->clearBitmapModulation();
+
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y), ColorI::WHITE);
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y + height), ColorI::WHITE);
+   }
+
+   if (mNextBitmapAsset.notNull())
+   {
+      // render the right arrow
+      bool arrowOnR = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption < mOptions.size() - 1));
+      arrowOffset.x = currentOffset.x + mRightPad * xScale - mArrowSize;
+      arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mNextBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+   else
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + getWidth() - mRightPad;
+      arrowOffset.y = currentOffset.y + height / 2;
+
+      drawer->clearBitmapModulation();
+
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y), ColorI::WHITE);
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y + height), ColorI::WHITE);
+   }*/
+
+   //Draw the slider bar
+
+   RectI sliderRect;
+
+   S32 sliderOffset = 5;
+
+   RectI optionRect;
+
+   sliderRect.point.x = currentOffset.x + columnSplit + mArrowSize;
+   sliderRect.point.y = currentOffset.y + sliderOffset;
+
+   sliderRect.extent.x = (currentOffset.x + getWidth() - mRightPad - mArrowSize) - sliderRect.point.x;
+   sliderRect.extent.y = height - sliderOffset*2;
+
+   optionRect = sliderRect;
+
+   S32 textWidth = sliderRect.extent.x * 0.3;
+   sliderRect.extent.x -= textWidth;
+
+   //Now adjust the bar to match-to our value
+
+   S32 barStart = sliderRect.point.x;
+   S32 barEnd = sliderRect.point.x + sliderRect.extent.x;
+
+   S32 xPosFill = (((mValue - mRange.x) * (barEnd - barStart)) / (mRange.y - mRange.x)) + barStart;
+
+   RectI fillRect = sliderRect;
+   fillRect.extent.x = xPosFill - sliderRect.point.x;
+
+   ColorI barColor;
+   ColorI barOutlineColor;
+   if (isSelected())
+   {
+      barColor = mProfile->mFontColor;
+      barOutlineColor = mProfile->mFontColorSEL;
+   }
+   else
+   {
+      barColor = mProfile->mFontColor;
+      barOutlineColor = mProfile->mFontColorHL;
+   }
+
+   drawer->drawRectFill(fillRect, barColor);
+
+   drawer->drawRect(sliderRect, barOutlineColor);
+
+   // get the appropriate font color
+   ColorI fontColor;
+   if (!mEnabled)
+   {
+      fontColor = mProfile->mFontColorNA;
+   }
+   else if (isSelected())
+   {
+      fontColor = mProfile->mFontColorSEL;
+   }
+   else if (isHighlighted())
+   {
+      fontColor = mProfile->mFontColorHL;
+   }
+   else
+   {
+      fontColor = mProfile->mFontColor;
+   }
+
+   // calculate text to be at the center between the arrows
+   GFont* font = mProfile->mFont;
+
+   char stringVal[32];
+   dSprintf(stringVal, 32, "%f", mValue);
+
+   S32 stringWidth = font->getStrWidth(stringVal);
+   Point2I textOffset(sliderRect.point.x + sliderRect.extent.x, 0);
+
+   // render the option text itself
+   Point2I textExtent(textWidth, height);
+
+   RectI textRect = optionRect;
+   textRect.point.x = sliderRect.point.x + sliderRect.extent.x;
+   textRect.extent.x = optionRect.extent.x * 0.3;
+
+   drawer->setBitmapModulation(fontColor);
+   renderJustifiedText(textRect.point, textRect.extent, stringVal);
+
+   //drawer->drawRectFill(textRect, ColorI::RED);
+}
+
+void GuiGameSettingsCtrl::onRenderKeybindOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+   S32 columnSplit = mColumnSplit;
+
+   S32 height = getHeight();
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+   //drawer->drawBitmap(mBitmap, )
+
+   Point2I button;
+   button.x = currentOffset.x + columnSplit + (columnSplit / 2.5)/* + (optionWidth / 2)*/;
+   button.y = currentOffset.y;
+
+   Point2I buttonSize;
+   buttonSize.x = height;
+   buttonSize.y = height;
+
+   if (mKeybindBitmapAsset.notNull())
+   {
+      RectI rect(button, buttonSize);
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mKeybindBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+
+   //drawer->drawRectFill(button, ColorI::BLUE);
+}
+
+void GuiGameSettingsCtrl::set(const char* label, const char* callback, bool useHighlightIcon, bool enabled, S32 mode, const char* tooltip)
+{
+   mScriptCallback = (dStrlen(callback) > 0) ? StringTable->insert(callback, true) : NULL;
+   mEnabled = enabled;
+   mMode = (Mode)mode;
+   mTooltip = StringTable->insert(tooltip);
+   mLabel = StringTable->insert(label, true);
+}
+
+void GuiGameSettingsCtrl::setListSetting(const char* label, const char* optionsList, bool wrapOptions, const char* callback, bool enabled, const char* tooltip, const char* defaultValue)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   Vector<OptionEntry> options(__FILE__, __LINE__);
+
+   S32 defaultOption = 0;
+
+   S32 count = StringUnit::getUnitCount(optionsList, DELIM);
+   for (S32 i = 0; i < count; ++i)
+   {
+      OptionEntry e;
+      const char* option = StringUnit::getUnit(optionsList, i, DELIM);
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      options.push_back(e);
+
+      if (String::compare(option, defaultValue) == 0)
+         defaultOption = options.size() - 1;
+   }
+   mOptions = options;
+   bool hasOptions = mOptions.size() > 0;
+   mSelectedOption = (hasOptions) ? defaultOption : NO_OPTION;
+   mWrapOptions = wrapOptions;
+   set(label, callback, true, (hasOptions) ? enabled : false, Mode::OptionList, tooltip);
+}
+
+void GuiGameSettingsCtrl::setSliderSetting(const char* label, F32 defaultValue, F32 increments, Point2F range, const char* callback, bool enabled, const char* tooltip)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   mValue = defaultValue;
+   mStepSize = increments;
+   mRange = range;
+
+   set(label, callback, true, enabled, Mode::Slider, tooltip);
+}
+
+void GuiGameSettingsCtrl::setKeybindSetting(const char* label, const char* bitmapName, const char* callback, bool enabled, const char* tooltip)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   _setKeybindBitmap(StringTable->insert(bitmapName));
+
+   //if(mBitmap != StringTable->EmptyString())
+   //   mBitmapTex.set(mBitmap, &GFXDefaultGUIProfile, avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__));
+
+   set(label, callback, true, enabled, Mode::Keybind, tooltip);
+}
+
+bool GuiGameSettingsCtrl::onAdd()
+{
+   if( !Parent::onAdd() )
+      return false;
+      
+   return true;
+}
+
+bool GuiGameSettingsCtrl::onWake()
+{
+   if( !Parent::onWake() )
+      return false;
+
+   return true;
+}
+void GuiGameSettingsCtrl::activate()
+{
+   if(isSelected() && isEnabled() && (mScriptCallback != StringTable->EmptyString()))
+   {
+      setThisControl();
+      if (Con::isFunction(mScriptCallback))
+      {
+         Con::executef(mScriptCallback);
+      }
+   }
+}
+
+void GuiGameSettingsCtrl::setSelected()
+{
+   if (!isEnabled())
+      return;
+
+   mSelected = true;
+}
+
+bool GuiGameSettingsCtrl::isEnabled() const
+{
+   return mEnabled;
+}
+
+void GuiGameSettingsCtrl::setEnabled(bool enabled)
+{
+   mEnabled = enabled;
+}
+
+void GuiGameSettingsCtrl::doScriptCommand(StringTableEntry command)
+{
+   if (command && command[0])
+   {
+      setThisControl();
+      Con::evaluate(command, false, __FILE__);
+   }
+}
+
+void GuiGameSettingsCtrl::setThisControl()
+{
+   smThisControl = this;
+}
+
+StringTableEntry GuiGameSettingsCtrl::getLabel() const
+{
+   return mLabel;
+}
+
+void GuiGameSettingsCtrl::setLabel( const char * label)
+{
+   mLabel = StringTable->insert(label, true);
+}
+
+void GuiGameSettingsCtrl::clear()
+{
+   mOptions.clear();
+}
+
+//-----------------------------------------------------------------------------
+// Console stuff (GuiGameSettingsCtrl)
+//-----------------------------------------------------------------------------
+
+StringTableEntry GuiGameSettingsCtrl::getCurrentOption() const
+{
+   if (mSelectedOption != NO_OPTION && !mOptions.empty())
+   {
+      return mOptions[mSelectedOption].mDisplayText;
+   }
+
+   return StringTable->insert("", false);
+}
+
+StringTableEntry GuiGameSettingsCtrl::getCurrentOptionKey() const
+{
+   if (mSelectedOption != NO_OPTION)
+   {
+      return mOptions[mSelectedOption].mKeyString;
+   }
+
+   return StringTable->insert("", false);
+}
+
+S32 GuiGameSettingsCtrl::getCurrentOptionIndex() const
+{
+   if (mSelectedOption != NO_OPTION)
+   {
+      return mSelectedOption;
+   }
+
+   return S32(-1);
+}
+
+bool GuiGameSettingsCtrl::selectOption(const char* theOption)
+{
+   for (Vector<OptionEntry>::iterator anOption = mOptions.begin(); anOption < mOptions.end(); ++anOption)
+   {
+      if (String::compare((*anOption).mDisplayText, theOption) == 0)
+      {
+         S32 newIndex = anOption - mOptions.begin();
+         mSelectedOption = newIndex;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+bool GuiGameSettingsCtrl::selectOptionByKey(const char* optionKey)
+{
+   for (Vector<OptionEntry>::iterator anOption = mOptions.begin(); anOption < mOptions.end(); ++anOption)
+   {
+      if (String::compare((*anOption).mKeyString, optionKey) == 0)
+      {
+         S32 newIndex = anOption - mOptions.begin();
+         mSelectedOption = newIndex;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+bool GuiGameSettingsCtrl::selectOptionByIndex(S32 optionIndex)
+{
+   if (optionIndex < mOptions.size() && optionIndex >= 0)
+   {
+      mSelectedOption = optionIndex;
+      return true;
+   }
+
+   return false;
+}
+
+void GuiGameSettingsCtrl::setOptions(const char* optionsList)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   S32 count = StringUnit::getUnitCount(optionsList, DELIM);
+   mOptions.setSize(count);
+   for (S32 i = 0; i < count; ++i)
+   {
+      const char* option = StringUnit::getUnit(optionsList, i, DELIM);
+      OptionEntry e;
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      mOptions[i] = e;
+   }
+
+   if (mSelectedOption >= mOptions.size())
+   {
+      mSelectedOption = mOptions.size() - 1;
+   }
+}
+
+void GuiGameSettingsCtrl::addOption(const char* displayText, const char* keyText)
+{
+   OptionEntry e;
+   e.mDisplayText = StringTable->insert(displayText, true);
+   e.mKeyString = (keyText[0] == '\0') ? e.mDisplayText : StringTable->insert(keyText, true);
+
+   mOptions.push_back(e);
+}
+
+void GuiGameSettingsCtrl::clickOption(S32 xPos)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 leftArrowX1 = mColumnSplit;
+   S32 leftArrowX2 = leftArrowX1 + mArrowSize;
+
+   S32 rightArrowX2 = getWidth() - mRightPad;
+   S32 rightArrowX1 = rightArrowX2 - mArrowSize;
+
+   if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
+   {
+      changeOption(-1);
+   }
+   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
+   {
+      changeOption(1);
+   }
+}
+
+void GuiGameSettingsCtrl::changeOption(S32 delta)
+{
+   S32 optionCount = mOptions.size();
+
+   S32 newSelection = mSelectedOption + delta;
+   if (optionCount == 0)
+   {
+      newSelection = NO_OPTION;
+   }
+   else if (!mWrapOptions)
+   {
+      newSelection = mClamp(newSelection, 0, optionCount - 1);
+   }
+   else if (newSelection < 0)
+   {
+      newSelection = optionCount - 1;
+   }
+   else if (newSelection >= optionCount)
+   {
+      newSelection = 0;
+   }
+   mSelectedOption = newSelection;
+
+   if (mMode == GuiGameSettingsCtrl::Slider)
+   {
+      mValue += mStepSize * delta;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue < mRange.x)
+         mValue = mRange.x;
+      if (mValue > mRange.y)
+         mValue = mRange.y;
+   }
+
+   static StringTableEntry LEFT = StringTable->insert("LEFT", true);
+   static StringTableEntry RIGHT = StringTable->insert("RIGHT", true);
+
+   onChange_callback();
+
+   if (mScriptCallback != NULL && (mSelectedOption != NO_OPTION && mMode != GuiGameSettingsCtrl::Slider))
+   {
+      setThisControl();
+      StringTableEntry direction = NULL;
+      if (delta < 0)
+      {
+         direction = LEFT;
+      }
+      else if (delta > 0)
+      {
+         direction = RIGHT;
+      }
+      if ((direction != NULL) && (Con::isFunction(mScriptCallback)))
+      {
+         Con::executef(mScriptCallback, direction);
+      }
+   }
+}
+IMPLEMENT_CONOBJECT(GuiGameSettingsCtrl);
+
+void GuiGameSettingsCtrl::clickSlider(S32 xPos)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 leftArrowX1 = mColumnSplit;
+   S32 leftArrowX2 = leftArrowX1 + mArrowSize;
+
+   S32 rightArrowX2 = getWidth() - mRightPad;
+   S32 rightArrowX1 = rightArrowX2 - mArrowSize;
+
+   S32 sliderWidth = rightArrowX1 - leftArrowX2;
+   sliderWidth *= 0.6; //remove the number text spacing
+
+   /*if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
+   {
+      mValue -= mStepSize;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue < mRange.x)
+         mValue = mRange.x;
+
+   }
+   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
+   {
+      //F32 snap = mValue % mStepSize;
+      //mValue.y -= snap;
+
+      mValue += mStepSize;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue > mRange.y)
+         mValue = mRange.y;
+   }
+   else
+   {*/
+      //see if we clicked on the sliderbar itself
+      S32 barStart = leftArrowX2;
+      S32 barEnd = barStart + sliderWidth;
+
+      if (xPos >= barStart && xPos <= barEnd)
+      {
+         //find the position
+         F32 newValue = (((xPos - barStart) * (mRange.y - mRange.x)) / (barEnd - barStart)) + mRange.x;
+
+         newValue = mRound(newValue / mStepSize) * mStepSize;
+
+         mValue = newValue;
+      }
+   //}
+
+   onChange_callback();
+}
+
+void GuiGameSettingsCtrl::clickKeybind(S32 xPos)
+{
+   S32 columnSplit = mColumnSplit;
+
+   S32 height = getHeight();
+
+   Point2I button;
+   button.x = columnSplit + (columnSplit / 2.5)/* + (optionWidth / 2)*/;
+   button.y = 0;
+
+   Point2I buttonSize;
+   buttonSize.x = height;
+   buttonSize.y = height;
+
+   RectI rect(button, buttonSize);
+
+   onChange_callback();
+
+   if (rect.pointInRect(Point2I(xPos, getHeight()/2)))
+   {
+      if (mScriptCallback != StringTable->EmptyString())
+      {
+         Con::executef(mScriptCallback, this);
+      }
+   }
+}
+
+F32 GuiGameSettingsCtrl::getValue()
+{
+   return mValue;
+}
+
+void GuiGameSettingsCtrl::setValue(F32 value)
+{
+   mValue = value;
+}
+
+const char* GuiGameSettingsCtrl::getTooltip()
+{
+   return mTooltip;
+}
+
+ConsoleDocClass( GuiGameSettingsCtrl,
+   "@brief A base class for cross platform menu controls that are gamepad friendly.\n\n"
+
+   "This class is used to build row-based menu GUIs that can be easily navigated "
+   "using the keyboard, mouse or gamepad. The desired row can be selected using "
+   "the mouse, or by navigating using the Up and Down buttons.\n\n"
+
+   "@tsexample\n\n"
+   "new GuiGameSettingsCtrl()\n"
+   "{\n"
+   "   debugRender = \"0\";\n"
+   "   callbackOnA = \"applyOptions();\";\n"
+   "   callbackOnB = \"Canvas.setContent(MainMenuGui);\";\n"
+   "   callbackOnX = \"\";\n"
+   "   callbackOnY = \"revertOptions();\";\n"
+   "   //Properties not specific to this control have been omitted from this example.\n"
+   "};\n"
+   "@endtsexample\n\n"
+
+   "@see GuiGameSettingsProfile\n\n"
+
+   "@ingroup GuiGame"
+);
+
+IMPLEMENT_CALLBACK( GuiGameSettingsCtrl, onChange, void, (), (),
+   "Called when the setting's value changes." );
+
+IMPLEMENT_CALLBACK(GuiGameSettingsCtrl, onInputEvent, void, (const char* device, const char* action, bool state),
+   (device, action, state),
+   "@brief Callback that occurs when an input is triggered on this control\n\n"
+   "@param device The device type triggering the input, such as keyboard, mouse, etc\n"
+   "@param action The actual event occuring, such as a key or button\n"
+   "@param state True if the action is being pressed, false if it is being release\n\n");
+
+IMPLEMENT_CALLBACK(GuiGameSettingsCtrl, onAxisEvent, void, (const char* device, const char* action, F32 axisValue),
+   (device, action, axisValue),
+   "@brief Callback that occurs when an axis event is triggered on this control\n\n"
+   "@param device The device type triggering the input, such as mouse, joystick, gamepad, etc\n"
+   "@param action The ActionMap code for the axis\n"
+   "@param axisValue The current value of the axis\n\n");
+
+void GuiGameSettingsCtrl::initPersistFields()
+{
+   INITPERSISTFIELD_IMAGEASSET(KeybindBitmap, GuiGameSettingsCtrl, "Bitmap used to display the bound key for this keybind option.");
+   INITPERSISTFIELD_IMAGEASSET(PreviousBitmap, GuiGameSettingsCtrl, "Bitmap used for the previous button when in list mode.");
+   INITPERSISTFIELD_IMAGEASSET(NextBitmap, GuiGameSettingsCtrl, "Bitmap used for the next button when in list mode.");
+
+   addField("arrowSize", TypeS32, Offset(mArrowSize, GuiGameSettingsCtrl),
+      "Size of the arrow buttons' extents");
+
+   addField("columnSplit", TypeS32, Offset(mColumnSplit, GuiGameSettingsCtrl),
+      "Position of the split between the leftside label and the rightside setting parts");
+
+   addField("rightPad", TypeS32, Offset(mRightPad, GuiGameSettingsCtrl),
+      "Padding between the rightmost edge of the control and right arrow.");
+
+   addField("callbackOnA", TypeString, Offset(mCallbackOnA, GuiGameSettingsCtrl),
+      "Script callback when the 'A' button is pressed. 'A' inputs are Keyboard: A, Return, Space; Gamepad: A, Start" );
+
+   addField("callbackOnB", TypeString, Offset(mCallbackOnB, GuiGameSettingsCtrl),
+      "Script callback when the 'B' button is pressed. 'B' inputs are Keyboard: B, Esc, Backspace, Delete; Gamepad: B, Back" );
+
+   addField("callbackOnX", TypeString, Offset(mCallbackOnX, GuiGameSettingsCtrl),
+      "Script callback when the 'X' button is pressed. 'X' inputs are Keyboard: X; Gamepad: X" );
+
+   addField("callbackOnY", TypeString, Offset(mCallbackOnY, GuiGameSettingsCtrl),
+      "Script callback when the 'Y' button is pressed. 'Y' inputs are Keyboard: Y; Gamepad: Y" );
+
+   addField("callbackOnInputs", TypeBool, Offset(mCallbackOnInputs, GuiGameSettingsCtrl),
+      "Script callback when any inputs are detected, even if they aren't the regular 4 face buttons. Useful for secondary/speciality handling of menu navigation.");
+
+   addField("consumeKeyInputEvents", TypeBool, Offset(mConsumeKeyInputEvents, GuiGameSettingsCtrl),
+      "When callbackOnInputs is active, this indicates if the input event should be consumed, or allowed 'through' to let other things respond to the event as well.");
+   
+
+   Parent::initPersistFields();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, isEnabled, bool, (),,
+   "Determines if the control is enabled or disabled.\n\n"
+   "@return True if the control is enabled. False if the control is not enabled." )
+{
+   return object->isEnabled();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, setEnabled, void, ( bool enabled ),,
+   "Sets the control's enabled status according to the given parameters.\n\n"
+   "@param enabled Indicate true to enable the control or false to disable it." )
+{
+   object->setEnabled( enabled );
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, activate, void, (),,
+   "Activates the control. The script callback of the control will be called (if it has one)." )
+{
+   object->activate();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getLabel, const char *, (),,
+   "Gets the label displayed.\n\n"
+   "@return The label." )
+{
+   return object->getLabel();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setLabel, void, ( const char* label ),,
+   "Sets the label.\n\n"
+   "@param label Text to set as the label.\n" )
+{
+   object->setLabel(label );
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, setSelected, void, (),,
+   "Sets the control as selected. Can only select enabled controls." )
+{
+   object->setSelected();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, getSelected, bool, (),,
+   "Gets if the control is currently selected.\n\n"
+   "@return if the control is selected." )
+{
+   return object->isSelected();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, clear, void, (), ,
+   "Clears the current options.\n\n")
+{
+   return object->clear();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getMode, S32, (), ,
+   "Gets this control's options mode.\n\n")
+{
+   GuiGameSettingsCtrl::Mode mode = object->getMode();
+   if (mode == GuiGameSettingsCtrl::Mode::OptionList)
+      return 0;
+   else if (mode == GuiGameSettingsCtrl::Mode::Slider)
+      return 1;
+   else if (mode == GuiGameSettingsCtrl::Mode::Keybind)
+      return 2;
+   else
+      return -1;
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setListSetting, void,
+   (const char* label, const char* options, bool wrapOptions, const char* callback, bool enabled, const char* tooltip, const char* defaultValue),
+   (true, "", ""),
+   "Sets this setting to a list.\n\n"
+   "@param label The text to display  as a label.\n"
+   "@param options A tab separated list of options.\n"
+   "@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+   "@param callback Name of a script function to use as a callback when this control is activated.\n"
+   "@param enabled [optional] If this control is initially enabled.")
+{
+   object->setListSetting(label, options, wrapOptions, callback, enabled, tooltip, defaultValue);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setSliderSetting, void,
+(const char* label, F32 defaultValue, F32 increment, Point2F range, const char* callback, bool enabled, const char* tooltip),
+(true, ""),
+"Sets this setting to a slider.\n\n"
+"@param label The text to display as a label.\n"
+"@param options A tab separated list of options.\n"
+"@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+"@param callback Name of a script function to use as a callback when this control is activated.\n"
+"@param enabled [optional] If this control is initially enabled.")
+{
+   object->setSliderSetting(label, defaultValue, increment, range, callback, enabled, tooltip);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setKeybindSetting, void,
+(const char* label, const char* bitmapName, const char* callback, bool enabled, const char* tooltip),
+(true, ""),
+"Sets this setting to a keybind.\n\n"
+"@param label The text to display as a label.\n"
+"@param options A tab separated list of options.\n"
+"@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+"@param callback Name of a script function to use as a callback when this control is activated.\n"
+"@param enabled [optional] If this control is initially enabled.")
+{
+   object->setKeybindSetting(label, bitmapName, callback, enabled, tooltip);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOption, const char*, (), ,
+   "Gets the text for the currently selected option .\n\n"
+   "@return A string representing the text currently displayed as the selected option. If there is no such displayed text then the empty string is returned.")
+{
+   return object->getCurrentOption();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOptionKey, const char*, (), ,
+   "Gets the key string for the currently selected option.\n\n"
+   "@return The key (or id) that was assigned to the selected option. If there is no selected option then the empty string is returned.")
+{
+   return object->getCurrentOptionKey();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOptionIndex, S32, (), ,
+   "Gets the index into the option list for the currently selected option.\n\n"
+   "@return The index of the selected option. If there is no selected option then -1 is returned.")
+{
+   return object->getCurrentOptionIndex();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOption, bool, (const char* option), ,
+   "Set the control's current option to the one specified\n\n"
+   "@param option The option to be made active.\n"
+   "@return True if the control contained the option and was set, false otherwise.")
+{
+   return object->selectOption(option);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOptionByKey, bool, (const char* optionKey), ,
+   "Set the control's current option to the one with the specified key.\n\n"
+   "@param optionKey The key string that was assigned to the option to be made active.\n"
+   "@return True if the control contained the key and the option and was set, false otherwise.")
+{
+   return object->selectOptionByKey(optionKey);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOptionByIndex, bool, (S32 optionIndex), ,
+   "Set the control's current option to the one at the specified index.\n\n"
+   "@param optionIndex The index of the option to be made active.\n"
+   "@return True if the index was valid and the option and was set, false otherwise.")
+{
+   return object->selectOptionByIndex(optionIndex);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setOptions, void, (const char* optionsList), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   object->setOptions(optionsList);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, addOption, void, (const char* displayText, const char* keyText), (""),
+   "Adds an option to the list of options on the given control.\n\n"
+   "@param displayText The text to display for this option.\n"
+   "@param keyText [Optional] The id string to associate with this value. "
+   "If unset, the id will be the same as the display text.\n")
+{
+   object->addOption(displayText, keyText);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getValue, F32, (), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   return object->getValue();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setValue, void, (F32 value), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   object->setValue(value);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getTooltip, const char*, (), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   return object->getTooltip();
+}

Engine/source/gui/controls/guiGameSettingsCtrl.h

@@ -0,0 +1,313 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef _GuiGameSettingsCtrl_H_
+#define _GuiGameSettingsCtrl_H_
+
+#include "gui/buttons/guiButtonCtrl.h"
+#include "T3D/assets/ImageAsset.h"
+
+/// \class GuiGameSettingsCtrl
+/// A base class for cross platform menu controls that are gamepad friendly.
+class GuiGameSettingsCtrl : public GuiButtonCtrl
+{
+public:
+   typedef GuiButtonCtrl Parent;
+
+   enum Mode
+   {
+      Default = 0,
+      OptionList,
+      Slider,
+      Keybind,
+      Text
+   };
+
+protected:
+
+   /// \struct OptionEntry
+   /// Display text and ID key for each entry in an option.
+   struct OptionEntry
+   {
+      StringTableEntry mDisplayText;   ///< The text that is displayed for the option
+      StringTableEntry mKeyString;     ///< Key value that is associated with this option
+      OptionEntry() : mDisplayText(StringTable->EmptyString()), mKeyString(StringTable->EmptyString()) {}
+      virtual ~OptionEntry() {}
+   };
+
+
+   StringTableEntry mLabel;            ///< Text to display in the control as a label
+   StringTableEntry mScriptCallback;   ///< Script callback when control is activated
+   StringTableEntry mTooltip;          ///< A descriptive tooltip message for what the control is
+
+   Mode mMode;
+
+   //List options
+   Vector<OptionEntry>        mOptions;         ///< Collection of options available to display
+   S32                        mSelectedOption;  ///< Index into mOptions pointing at the selected option
+   bool                       mWrapOptions;     ///< Determines if options should "wrap around" at the ends
+
+   //Slider option
+   F32                        mValue;           ///< When working as a slider, this contains the value
+   F32                        mStepSize;        ///< When working as a slider, this is the increment levels in the range
+   Point2F                    mRange;           ///< When working as a slider, this sets our min/max range
+
+   //Keybind option
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, KeybindBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, KeybindBitmap);
+
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, PreviousBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, PreviousBitmap);
+
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, NextBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, NextBitmap);
+
+   S32 mArrowSize;
+   S32 mColumnSplit; //Padding between the leftmost edge of the control, and the left side of the 'option'.
+   S32 mRightPad;
+
+   bool mEnabled;
+   bool mSelected;
+
+public:
+   void changeBitmap() {}
+
+   /// Sets the control as selected . Only controls that are enabled can be selected. 
+   virtual void setSelected();
+
+   /// Determines if the specified control is enabled or disabled.
+   ///
+   /// \return True if the specified control is enabled. False if the control is not
+   /// enabled
+   virtual bool isEnabled() const;
+
+   /// Sets a control's enabled status according to the given parameters.
+   ///
+   /// \param enabled Indicate true to enable the control or false to disable it.
+   virtual void setEnabled(bool enabled);
+
+   /// Gets the label displayed on the control.
+   ///
+   /// \return The label for the control.
+   virtual StringTableEntry getLabel() const;
+
+   /// Sets the label on the control.
+   ///
+   /// \param label Text to set as the label.
+   virtual void setLabel(const char * label);
+
+   /// Sets the control to a List setting.
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param optionsList A tab separated list of options for the control.
+   /// \param wrapOptions Specify true to allow options to wrap at the ends or
+   /// false to prevent wrapping.
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setListSetting(const char* label, const char* optionsList, bool wrapOptions, const char* callback,bool enabled, const char* tooltip = "", const char* defaultValue = "");
+
+   /// Sets the control to a Slider setting
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param defaultValue A float indicating the slider's default value
+   /// \param increments A float indicating the incremental values the slider snaps along between it's range
+   /// \param range A Point2F that indicates the minimum and maximum value range
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setSliderSetting(const char* label, F32 defaultValue, F32 increments, Point2F range, const char* callback, bool enabled, const char* tooltip = "");
+
+   /// Sets the control to a Keybind setting
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param bitmapAssetId The assetId for the button display image
+   /// \param range A Point2F that indicates the minimum and maximum value range
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setKeybindSetting(const char* label, const char* bitmapAssetId, const char* callback, bool enabled, const char* tooltip);
+
+   /// Gets the text for the currently selected option of the control.
+   ///
+   /// \return A string representing the text currently displayed as the selected
+   /// option on the control. If there is no such displayed text then the empty
+   /// string is returned.
+   StringTableEntry getCurrentOption() const;
+
+   /// Gets the key string for the currently selected option of the control
+   ///
+   /// \return The key (or id) that was assigned to the selected option on the
+   ///  control. If there is no selected option then the empty string is returned.
+   StringTableEntry getCurrentOptionKey() const;
+
+   /// Gets the index into the option list for the currently selected option of the control.
+   ///
+   /// \return The index of the selected option on the control. If there is no
+   /// selected option then -1 is returned.
+   S32 getCurrentOptionIndex() const;
+
+   /// Attempts to set the control to the specified selected option. The option
+   /// will only be set if the option exists in the control.
+   ///
+   /// \param option The option to be made active.
+   /// \return True if the control contained the option and was set, false otherwise.
+   bool selectOption(const char* option);
+
+   /// Attempts to set the control to the option with the specified key. The
+   /// option will only be set if the key exists in the control.
+   ///
+   /// \param optionKey The key string that was assigned to the option to be made active.
+   /// \return True if the control contained the key and the option and was set, false otherwise.
+   bool selectOptionByKey(const char* optionKey);
+
+   /// Attempts to set the control to the option at the specified index. The option
+   /// will only be set if the index is valid.
+   ///
+   /// \param optionIndex The index of the option to be made active.
+   /// \return True if the index was valid and the option and was set, false otherwise.
+   bool selectOptionByIndex(S32 optionIndex);
+
+   /// Sets the list of options on the control.
+   ///
+   /// \param optionsList A tab separated list of options for the control.
+   void setOptions(const char* optionsList);
+
+   /// Adds an option to the list of options on the control.
+   ///
+   /// \param displayText The text to display for this option.
+   /// \param keyText The id string to associate with this value. If NULL the
+   ///  id will be the same as the display text.
+   void addOption(const char* displayText, const char* keyText);
+
+   /// Activates the control. The script callback of the control will
+   /// be called (if it has one).
+   virtual void activate();
+
+   /// Gets the value
+   ///
+   F32 getValue();
+
+   /// Sets the value
+   ///
+   /// \param value The new value to be set.
+   void setValue(F32 value);
+
+   Mode getMode() { return mMode; }
+
+   /// Gets the tooltip
+   const char* getTooltip();
+
+   GuiGameSettingsCtrl();
+   ~GuiGameSettingsCtrl();
+
+   void onRender(Point2I offset, const RectI &updateRect);
+
+   void onRenderListOption(Point2I currentOffset);
+   void onRenderSliderOption(Point2I currentOffset);
+
+   void onRenderKeybindOption(Point2I currentOffset);
+
+   /// Callback when the object is registered with the sim.
+   ///
+   /// \return True if the profile was successfully added, false otherwise.
+   bool onAdd();
+
+   /// Callback when the control wakes up.
+   bool onWake();
+
+   void clear();
+
+   virtual void onMouseMove(const GuiEvent& event);
+   virtual void onMouseUp(const GuiEvent& event);
+
+   DECLARE_CONOBJECT(GuiGameSettingsCtrl);
+   DECLARE_CATEGORY( "Gui Game" );
+   DECLARE_DESCRIPTION( "Base class for cross platform menu controls that are gamepad friendly." );
+
+   /// Initializes fields accessible through the console.
+   static void initPersistFields();
+
+   static const S32 NO_OPTION = -1; ///< Indicates there is no option
+
+protected:
+   /// Sets up the option
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param callback Name of a script function to use as a callback when this
+   /// control is activated.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   virtual void set(const char* label, const char* callback, bool useHighlightIcon = true, bool enabled = true, S32 mode = 0, const char* tooltip = "");
+
+   /// Sets the script variable $ThisControl to reflect this control.
+   virtual void setThisControl();
+
+   /// @name Callbacks
+   /// @{
+   DECLARE_CALLBACK( void, onChange, () );
+
+   DECLARE_CALLBACK(void, onInputEvent,  (const char* device, const char* action, bool state));
+
+   DECLARE_CALLBACK(void, onAxisEvent, (const char* device, const char* action, F32 axisValue));
+   /// @}
+
+   /// Evaluates some script. If the command is empty then nothing is evaluated.
+   ///
+   /// \param command The script to evaluate.
+   void doScriptCommand(StringTableEntry command);
+
+   StringTableEntry  mCallbackOnA;  ///< Script callback when the 'A' button is pressed
+   StringTableEntry  mCallbackOnB;  ///< Script callback when the 'B' button is pressed
+   StringTableEntry  mCallbackOnX;  ///< Script callback when the 'X' button is pressed
+   StringTableEntry  mCallbackOnY;  ///< Script callback when the 'Y' button is pressed
+
+private:
+   /// Performs a click on the current option. The x position is used to
+   /// determine if the left or right arrow were clicked. If one was clicked, the
+   /// option will be changed. If neither was clicked, the option is unaffected.
+   /// This method should only be called when there is an actively selected control.
+   ///
+   /// \param xPos The x position of the the click, relative to the control.
+   void clickOption(S32 xPos);
+
+   /// Changes the option on the currently selected control.
+   ///
+   /// \param delta The amount to change the option selection by. Typically this
+   /// will be 1 or -1.
+   void changeOption(S32 delta);
+
+   /// Performs a click on the current slider control. The x position is used to
+   /// determine if the left or right arrow were clicked, or if it landed somewhere on the sliderbar.
+   /// If one was clicked, the option will be changed. If neither was clicked, the option is unaffected.
+   /// This method should only be called when there is an actively selected control.
+   ///
+   /// \param xPos The x position of the the click, relative to the control.
+   void clickSlider(S32 xPos);
+
+   void clickKeybind(S32 xPos);
+
+private:
+   bool     mCallbackOnInputs;
+   bool     mConsumeKeyInputEvents;
+};
+
+#endif

Engine/source/gui/controls/guiGradientCtrl.cpp

@@ -99,7 +99,7 @@ bool GuiGradientSwatchCtrl::onWake()
 
 void GuiGradientSwatchCtrl::onRender( Point2I offset, const RectI &updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
 
    ColorI borderColor = mActive ? ( highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor ) : mProfile->mBorderColorNA;
    RectI renderRect( offset, getExtent() );
@@ -632,4 +632,4 @@ DefineEngineMethod(GuiGradientCtrl, getColor, LinearColorF, (S32 idx), , "Get co
 	}
 
 	return LinearColorF::ONE;
-}
+}

Engine/source/gui/core/guiCanvas.cpp

@@ -706,6 +706,9 @@ bool GuiCanvas::processInputEvent(InputEventInfo &inputEvent)
       if (mCursorEnabled || mForceMouseToGUI || 
          (mAlwaysHandleMouseButtons && inputEvent.objType == SI_BUTTON) )
       {
+         if (inputEvent.objType != SI_AXIS && inputEvent.action == SI_MAKE)
+            bool asdfasdf = true;
+
          return processMouseEvent(inputEvent);
       }
       break;

Engine/source/gui/utility/guiInputCtrl.cpp

@@ -61,7 +61,8 @@ ConsoleDocClass( GuiInputCtrl,
 GuiInputCtrl::GuiInputCtrl()
    : mSendAxisEvents(false),
    mSendBreakEvents(false),
-   mSendModifierEvents(false)
+   mSendModifierEvents(false),
+   mIgnoreMouseEvents(false)
 {
 }
 
@@ -76,6 +77,8 @@ void GuiInputCtrl::initPersistFields()
       "If true, break events for all devices will generate callbacks (Default false).");
    addField("sendModifierEvents", TypeBool, Offset(mSendModifierEvents, GuiInputCtrl),
       "If true, Make events will be sent for modifier keys (Default false).");
+   addField("ignoreMouseEvents", TypeBool, Offset(mIgnoreMouseEvents, GuiInputCtrl),
+      "If true, any events from mouse devices will be passed through.");
    endGroup("GuiInputCtrl");
 
    Parent::initPersistFields();
@@ -97,7 +100,7 @@ bool GuiInputCtrl::onWake()
    if ( !Parent::onWake() )
       return( false );
 
-   if( !smDesignTime )
+   if( !smDesignTime && !mIgnoreMouseEvents)
       mouseLock();
       
    setFirstResponder();
@@ -151,6 +154,9 @@ IMPLEMENT_CALLBACK(GuiInputCtrl, onAxisEvent, void, (const char* device, const c
 //------------------------------------------------------------------------------
 bool GuiInputCtrl::onInputEvent( const InputEventInfo &event )
 {
+   if (mIgnoreMouseEvents && event.deviceType == MouseDeviceType)
+      return false;
+
    char deviceString[32];
    if ( event.action == SI_MAKE )
    {

Engine/source/gui/utility/guiInputCtrl.h

@@ -36,6 +36,7 @@ protected:
    bool mSendAxisEvents;
    bool mSendBreakEvents;
    bool mSendModifierEvents;
+   bool mIgnoreMouseEvents;
 
 public:
 

Templates/BaseGame/game/core/gui/scripts/profiles.tscript

@@ -26,6 +26,10 @@ if($Gui::fontCacheDirectory $= "")
    $Gui::fontCacheDirectory = expandFilename("data/cache/fonts");
 }
 
+$TextMediumEmphasisColor = "200 200 200";
+$TextHighEmphasisColor = "224 224 224";
+$TextDisabledColor = "108 108 108";
+
 // ----------------------------------------------------------------------------
 // GuiDefaultProfile is a special profile that all other profiles inherit
 // defaults from. It must exist.
@@ -137,13 +141,20 @@ new GuiControlProfile(GuiTextEditProfile)
    category = "Core";
 };
 
-if(!isObject(GuiScrollProfile))
-new GuiControlProfile(GuiScrollProfile)
+if(!isObject(GuiMenuScrollProfile))
+new GuiControlProfile(GuiMenuScrollProfile)
 {
    opaque = true;
-   fillcolor = "255 255 255";
-   fontColor = "0 0 0";
-   fontColorHL = "150 150 150";
+   fontColor = $TextMediumEmphasisColor;
+   fontColorHL = $TextMediumEmphasisColor;
+   fontColorNA = $TextDisabledColor;
+   fontColorSEL = $TextMediumEmphasisColor;
+   fillColor = "40 40 40";
+   fillColorHL = "56 56 56";
+   fillColorNA = "40 40 40";
+   borderColor = "87 87 87";
+   borderColorNA = "0 0 0";
+   borderColorHL = "255 255 255";
    border = true;
    bitmapAsset = "Core_GUI:scrollBar_image";
    hasBitmapArray = true;

Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript

@@ -81,6 +81,7 @@ function ExampleModule::initClient(%this)
       exec(%prefPath @ "/keybinds." @ $TorqueScriptFileExtension);
       
    %this.queueExec("./scripts/inputCommands");
+   addOptionsMenuCategory("Example Options", "testExampleOptions();");
 }
 
 //This is called when a game session client successfuly connects to a game server. 
@@ -105,4 +106,9 @@ function ExampleModule::onDestroyClientConnection(%this)
 {
    //This will pop the keybind, cleaning it up from the input stack, as it no longer applies
    ExampleMoveMap.pop();
+}
+
+function testExampleOptions()
+{
+   addListOption("Test Option", "This is a test option", $testOptionValue, "OptionA\tOptionB");  
 }

Templates/BaseGame/game/data/UI/UI.module

@@ -11,4 +11,4 @@
         canSaveDynamicFields="true"
         Extension="asset.taml"
         Recurse="true" />
-</ModuleDefinition>
+</ModuleDefinition>

Templates/BaseGame/game/data/UI/UI.tscript

@@ -36,7 +36,7 @@ function UI::initClient(%this)
    %this.queueExec("./scripts/profiles");
    
    //Now gui files
-   %this.queueExec("./scripts/menuInputButtons");
+   %this.queueExec("./scripts/menuInputHandling");
    
    %this.queueExec("./guis/mainMenu");
    %this.queueExec("./guis/mainMenu.gui");
@@ -83,4 +83,4 @@ function UI::initClient(%this)
 
 function UI::onCreateClientConnection(%this){}
 
-function UI::onDestroyClientConnection(%this){}
+function UI::onDestroyClientConnection(%this){}

Templates/BaseGame/game/data/UI/datablocks/guiSounds.asset.taml

@@ -2,5 +2,5 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="guiSounds"
-    scriptFile="@assetFile=guiSounds.cs"
+    scriptFile="@assetFile=guiSounds"
     VersionId="1" />

Templates/BaseGame/game/data/UI/datablocks/guiSounds.tscript

@@ -31,4 +31,4 @@ singleton SFXProfile(menuButtonHover)
    preload = true;
    description = AudioGui;
    fileName = "data/ui/sounds/buttonHover";
-};
+};

Templates/BaseGame/game/data/UI/guis/ChooseLevelDlg.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="ChooseLevelDlg"
-    scriptFile="@assetFile=chooseLevelDlg.gui"
+    scriptFile="@assetFile=chooseLevelDlg"
     GUIFile="@assetFile=chooseLevelDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/GuiMusicPlayer.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="GuiMusicPlayer"
-    scriptFile="@assetFile=guiMusicPlayer.gui"
+    scriptFile="@assetFile=guiMusicPlayer"
     GUIFile="@assetFile=guiMusicPlayer.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/IODropdownDlg.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="IODropdownDlg"
-    scriptFile="@assetFile=IODropdownDlg.ed.gui"
     GUIFile="@assetFile=IODropdownDlg.ed.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/JoinServerMenu.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="JoinServerMenu"
-    scriptFile="@assetFile=joinServerMenu.gui"
+    scriptFile="@assetFile=joinServerMenu"
     GUIFile="@assetFile=joinServerMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/LoadingGui.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="LoadingGui"
-    scriptFile="@assetFile=loadingGui.gui"
     GUIFile="@assetFile=loadingGui.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/MainMenuGui.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="MainMenuGui"
-    scriptFile="@assetFile=mainMenu.gui"
+    scriptFile="@assetFile=mainMenu"
     GUIFile="@assetFile=mainMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/MessageBoxDlg.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="MessageBoxDlg"
-    scriptFile="@assetFile=messageBoxDlg.gui"
     GUIFile="@assetFile=messageBoxDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/NetGraphGui.asset.taml

@@ -0,0 +1,4 @@
+<GUIAsset
+    AssetName="NetGraphGui"
+    GUIFile="@assetFile=netGraphGui.gui"
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/NetGraphProfile.asset.taml

@@ -1,7 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="NetGraphProfile"
-    scriptFile="@assetFile=netGraphGui.gui"
-    GUIFile="@assetFile=netGraphGui.gui"
-    VersionId="1" />

Templates/BaseGame/game/data/UI/guis/OptionsDlg.asset.taml

@@ -1,7 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="OptionsDlg"
-    scriptFile="@assetFile=optionsDlg.gui"
-    GUIFile="@assetFile=optionsDlg.gui"
-    VersionId="1" />

Templates/BaseGame/game/data/UI/guis/OptionsMenu.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="OptionsMenu"
-    scriptFile="@assetFile=optionsMenu.gui"
+    scriptFile="@assetFile=optionsMenu"
     GUIFile="@assetFile=optionsMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/PauseMenu.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="PauseMenu"
-    scriptFile="@assetFile=pauseMenu.gui"
+    scriptFile="@assetFile=pauseMenu"
     GUIFile="@assetFile=pauseMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/ProfilerGui.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="ProfilerGui"
-    scriptFile="@assetFile=profiler.gui"
+    scriptFile="@assetFile=profiler"
     GUIFile="@assetFile=profiler.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/RemapConfirmDlg.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="RemapConfirmDlg"
-    scriptFile="@assetFile=remapConfirmDlg.gui"
     GUIFile="@assetFile=remapConfirmDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/RemapDlg.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="RemapDlg"
-    scriptFile="@assetFile=remapDlg.gui"
     GUIFile="@assetFile=remapDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/StartupGui.asset.taml

@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="StartupGui"
-    scriptFile="@assetFile=startupGui.gui"
+    scriptFile="@assetFile=startupGui"
     GUIFile="@assetFile=startupGui.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui

@@ -36,7 +36,7 @@ $guiContent = new GuiControl(ChooseLevelDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         bitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "927 40";
@@ -79,7 +79,7 @@ $guiContent = new GuiControl(ChooseLevelDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         bitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";

Templates/BaseGame/game/data/UI/guis/controlsMenuSetting.taml

@@ -1,102 +0,0 @@
-<GuiContainer
-    margin="0 0 0 0"
-    padding="0 0 0 0"
-    anchorTop="true"
-    anchorBottom="false"
-    anchorLeft="true"
-    anchorRight="false"
-    position="0 0"
-    extent="700 35"
-    minExtent="8 2"
-    horizSizing="right"
-    vertSizing="bottom"
-    profile="GuiDefaultProfile"
-    visible="true"
-    active="true"
-    tooltipProfile="GuiToolTipProfile"
-    hovertime="1000"
-    isContainer="true"
-    class="GraphicsMenuSetting"
-    canSave="true"
-    canSaveDynamicFields="false">
-    <GuiBitmapCtrl
-        bitmap="data/ui/images/hudfill.png"
-        wrap="false"
-        position="0 0"
-        extent="550 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiDefaultProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="false"
-        canSave="true"
-        canSaveDynamicFields="false" />
-    <GuiTextCtrl
-        text="Move Forward"
-        maxLength="1024"
-        margin="0 0 0 0"
-        padding="0 0 0 0"
-        anchorTop="true"
-        anchorBottom="false"
-        anchorLeft="true"
-        anchorRight="false"
-        position="0 0"
-        extent="550 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiMenuButtonProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="true"
-        internalName="nameText"
-        canSave="true"
-        canSaveDynamicFields="false" />
-    <GuiContainer
-        margin="0 0 0 0"
-        padding="0 0 0 0"
-        anchorTop="true"
-        anchorBottom="false"
-        anchorLeft="true"
-        anchorRight="false"
-        position="550 0"
-        extent="150 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiDefaultProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="true"
-        canSave="true"
-        canSaveDynamicFields="false">
-        <GuiButtonCtrl
-            text="W"
-            groupNum="-1"
-            buttonType="PushButton"
-            useMouseEvents="true"
-            position="0 0"
-            extent="150 35"
-            minExtent="8 8"
-            horizSizing="relative"
-            vertSizing="bottom"
-            profile="GuiMenuButtonProfile"
-            visible="true"
-            active="true"
-            tooltipProfile="GuiToolTipProfile"
-            hovertime="1000"
-            isContainer="false"
-            canSave="true"
-            canSaveDynamicFields="false"
-            internalName="rebindButton"
-            className="ControlsMenuRebindButton"/>
-    </GuiContainer>
-</GuiContainer>

Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui

@@ -14,19 +14,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
    canSave = "1";
    canSaveDynamicFields = "1";
       returnGui = "MainMenuGui";
-      
-   new GuiInputCtrl(JoinServerMenuInputHandler){
-      profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
-      position = "0 0";
-      extent = "1024 768";
+
+   new GuiInputCtrl(JoinServerMenuInputHandler) {
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-10 0";
+      extent = "10 10";
       minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
-      sendBreakEvents="1";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
    };
-
    new GuiControl(JoinServerWindow) {
       position = "48 56";
       extent = "928 655";
@@ -46,7 +54,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         BitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "927 40";
@@ -89,7 +97,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         BitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";
@@ -105,58 +113,6 @@ $guiContent = new GuiControl(JoinServerMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiTextCtrl() {
-         text = "Player Name:";
-         maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "12 47";
-         extent = "109 18";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "MenuSubHeaderText";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextEditCtrl() {
-         historySize = "0";
-         tabComplete = "0";
-         sinkAllKeyEvents = "0";
-         password = "0";
-         passwordMask = "*";
-         text = "Visitor";
-         maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "124 47";
-         extent = "144 18";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuTextEditProfile";
-         visible = "1";
-         active = "1";
-         variable = "$pref::Player::Name";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
       new GuiTextCtrl(JS_status) {
          text = "No servers found.";
          maxLength = "255";
@@ -166,7 +122,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "277 47";
+         position = "392 47";
          extent = "148 18";
          minExtent = "8 8";
          horizSizing = "right";
@@ -324,25 +280,30 @@ $guiContent = new GuiControl(JoinServerMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
 
-         new GuiTextListCtrl(JS_serverList) {
-            columns = "0 200 270 335 400";
-            fitParentWidth = "1";
-            clipColumnText = "0";
-            rowHeightPadding = "2";
+         new GuiStackControl(JoinServerList) {
+            stackingType = "Vertical";
+            horizStacking = "Left to Right";
+            vertStacking = "Top to Bottom";
+            padding = "10";
+            dynamicSize = "1";
+            dynamicNonStackExtent = "0";
+            dynamicPos = "0";
+            changeChildSizeToFit = "0";
+            changeChildPosition = "1";
             position = "1 1";
-            extent = "888 8";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextArrayProfile";
+            extent = "888 16";
+            minExtent = "16 16";
+            horizSizing = "center";
+            vertSizing = "center";
+            profile = "GuiDefaultProfile";
             visible = "1";
             active = "1";
-            altCommand = "JoinServerDlg.join();";
             tooltipProfile = "GuiToolTipProfile";
             hovertime = "1000";
             isContainer = "1";
             canSave = "1";
             canSaveDynamicFields = "0";
+            class = "MenuList";
          };
       };
       new GuiControl(JS_queryStatus) {
@@ -427,130 +388,9 @@ $guiContent = new GuiControl(JoinServerMenu) {
             canSaveDynamicFields = "0";
          };
       };
-      new GuiButtonCtrl(JoinServerBackBtn) {
-         text = "Return to Menu";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "0 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "Canvas.popDialog(JoinServerMenu);\n\nif(isObject(JoinServerMenu.returnGui) && JoinServerMenu.returnGui.isMethod(\"onReturnTo\"))    JoinServerMenu.returnGui.onReturnTo();";
-         accelerator = "escape";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerQryLanBtn) {
-         text = "Query Lan";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "160 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.queryLan();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerQryInternetBtn) {
-         text = "Query Internet";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "320 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.query();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerRefreshBtn) {
-         text = "Refresh Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "480 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.refresh();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerJoinBtn) {
-         text = "Join Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "640 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "JoinServerMenu.join();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
-   new GuiControl() {
-      position = "189 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
    };
    new GuiControl(JoinServerButtonHolder) {
-      position = "109 711";
+      position = "116 711";
       extent = "791 40";
       minExtent = "8 2";
       horizSizing = "center";
@@ -567,7 +407,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -585,8 +425,8 @@ $guiContent = new GuiControl(JoinServerMenu) {
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
          visible = "1";
-         active = "1";
-         command = "OptionsMenu.apply();";
+         active = "0";
+         command = "JoinServerMenu.join();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -597,7 +437,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_Escape_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -616,7 +456,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "OptionsMenu.backOut();";
+         command = "JoinServerMenu.backOut();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -627,14 +467,14 @@ $guiContent = new GuiControl(JoinServerMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Q_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Prev Tab";
+         text = "Query LAN";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -644,28 +484,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.prevTab();";
+         visible = "1";
+         active = "1";
+         command = "JoinServerMenu.queryLan();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "queryLANButton";
          class = "MenuInputButton";
-         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_E_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Next Tab";
+         text = "Query Online";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -675,28 +514,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.nextTab();";
+         visible = "1";
+         active = "1";
+         command = "JoinServerMenu.query();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "queryInternetButton";
          class = "MenuInputButton";
-         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         bitmapAsset = "UI:Keyboard_Black_R_image";
+         BitmapAsset = "UI:Keyboard_Black_R_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Reset";
+         text = "Refresh";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -708,7 +546,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "OptionsMenu.resetToDefaults();";
+         command = "JoinServerMenu.refresh();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";

Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript

@@ -1,12 +1,10 @@
 
-function JoinServerMenu::onWake()
+function JoinServerMenu::onWake(%this)
 {
-   // Double check the status. Tried setting this the control
-   // inactive to start with, but that didn't seem to work.
-   JoinServerJoinBtn.setActive(JS_serverList.rowCount() > 0);
-   
    JoinServerButtonHolder.setActive();
    
+   JoinServerList.setAsActiveMenuList();
+   
    JoinServerMenuInputHandler.setFirstResponder();
 }   
 
@@ -16,7 +14,7 @@ function JoinServerButtonHolder::onWake(%this)
    %this-->backButton.set("btn_b", "Escape", "Back", "JoinServerMenu.backOut();");
    %this-->refreshButton.set("btn_y", "R", "Refresh", "JoinServerMenu.refresh();");
    %this-->queryLANButton.set("btn_a", "Q", "Query LAN", "JoinServerMenu.queryLan();");
-   %this-->queryInternetButton.set("btn_x", "E", "Query Internet", "JoinServerMenu.query();");
+   %this-->queryInternetButton.set("btn_x", "E", "Query Online", "JoinServerMenu.query();");
 }
 
 function JoinServerMenuInputHandler::onInputEvent(%this, %device, %action, %state)
@@ -110,23 +108,23 @@ function JoinServerMenu::update(%this)
 {
    // Copy the servers into the server list.
    JS_queryStatus.setVisible(false);
-   JS_serverList.clear();
+   JoinServerList.clear();
    %sc = getServerCount();
    for( %i = 0; %i < %sc; %i ++ ) {
       setServerInfo(%i);
-      JS_serverList.addRow( %i,
-         $ServerInfo::Name TAB
-         $ServerInfo::Ping TAB
-         $ServerInfo::PlayerCount @ "/" @ $ServerInfo::MaxPlayers TAB
-         $ServerInfo::Version TAB
-         $ServerInfo::MissionName
-      );
+      %serverBtn = new GuiButtonCtrl(){
+         text = $ServerInfo::Name TAB
+            $ServerInfo::Ping TAB
+            $ServerInfo::PlayerCount @ "/" @ $ServerInfo::MaxPlayers TAB
+            $ServerInfo::Version TAB
+            $ServerInfo::MissionName;
+         profile = GuiJoinServerButtonProfile;      
+         extent = JoinServerList.extent.x SPC 30; 
+      };
+      JoinServerList.add(%serverBtn);
    }
-   JS_serverList.sort(0);
-   JS_serverList.setSelectedRow(0);
-   JS_serverList.scrollVisible(0);
 
-   JoinServerJoinBtn.setActive(JS_serverList.rowCount() > 0);
+   JoinServerButtonHolder-->joinButton.setActive(JoinServerList.getCount() > 0);
 } 
 
 //----------------------------------------
@@ -141,11 +139,9 @@ function onServerQueryStatus(%status, %msg, %value)
 
    switch$ (%status) {
       case "start":
-         JoinServerJoinBtn.setActive(false);
-         JoinServerQryInternetBtn.setActive(false);
          JS_statusText.setText(%msg);
          JS_statusBar.setValue(0);
-         JS_serverList.clear();
+         JoinServerList.clear();
 
       case "ping":
          JS_statusText.setText("Ping Servers");
@@ -156,7 +152,6 @@ function onServerQueryStatus(%status, %msg, %value)
          JS_statusBar.setValue(%value);
 
       case "done":
-         JoinServerQryInternetBtn.setActive(true);
          JS_queryStatus.setVisible(false);
          JS_status.setText(%msg);
          JoinServerMenu.update();

Templates/BaseGame/game/data/UI/guis/loadingGui.gui

@@ -1,6 +1,6 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(LoadingGui) {
-   bitmapAsset = "UI:background_dark_image";
+   bitmapAsset = "UI:backgrounddark_image";
    useVariable = "0";
    tile = "0";
    position = "0 0";

Templates/BaseGame/game/data/UI/guis/mainMenu.gui

@@ -1,6 +1,6 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
-   bitmapAsset = "UI:background_dark_image";
+   BitmapAsset = "UI:backgrounddark_image";
    useVariable = "0";
    tile = "0";
    position = "0 0";
@@ -19,15 +19,11 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
       Enabled = "1";
       isDecoy = "0";
       navigationIndex = "-1";
-      
+
    new GuiBitmapCtrl(MainMenuAppLogo) {
-      bitmapAsset = "UI:Torque_3D_logo_alt_image";
-      bitmapMode = "Stretched";
-      autoFitExtents = "0";
-      useModifiers = "0";
-      useStates = "1";
-      masked = "0";
-      groupNum = "-1";
+      BitmapAsset = "UI:Torque_3D_logo_alt_image";
+      color = "255 255 255 255";
+      wrap = "0";
       position = "550 30";
       extent = "443 139";
       minExtent = "8 2";
@@ -41,26 +37,179 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
       isContainer = "0";
       canSave = "1";
       canSaveDynamicFields = "1";
+         autoFitExtents = "0";
+         bitmapMode = "Stretched";
+         groupNum = "-1";
+         masked = "0";
          navigationIndex = "-1";
+         useModifiers = "0";
+         useStates = "1";
    };
-
-   new GuiGameListMenuCtrl(MainMenuButtonList) {
-      debugRender = "0";
-      callbackOnInputs = "1";
-      position = "292 103";
-      extent = "439 561";
-      minExtent = "8 2";
+   new GuiStackControl(MainMenuButtonList) {
+      stackingType = "Vertical";
+      horizStacking = "Left to Right";
+      vertStacking = "Top to Bottom";
+      padding = "15";
+      dynamicSize = "0";
+      dynamicNonStackExtent = "0";
+      dynamicPos = "0";
+      changeChildSizeToFit = "1";
+      changeChildPosition = "1";
+      position = "312 111";
+      extent = "400 477";
+      minExtent = "16 16";
       horizSizing = "center";
       vertSizing = "center";
-      profile = "DefaultListMenuProfile";
+      profile = "GuiDefaultProfile";
       visible = "1";
       active = "1";
       tooltipProfile = "GuiToolTipProfile";
       hovertime = "1000";
-      isContainer = "0";
-      class = "UIMenuButtonList";
+      isContainer = "1";
       canSave = "1";
       canSaveDynamicFields = "0";
+      class = "MenuList";
+
+      new GuiButtonCtrl(MainMenuSinglePlayerBtn) {
+         text = "Single Player";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 0";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openSinglePlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuCreateSrvrBtn) {
+         text = "Create Server";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 70";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openMultiPlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuJoinSrvrBtn) {
+         text = "Join Server";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 140";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openJoinServerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuOptionBtn) {
+         text = "Options";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 210";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openOptionsMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuWorldEditBtn) {
+         text = "Open World Editor";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 280";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openWorldEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuGuiEditBtn) {
+         text = "Open GUI Editor";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 350";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openGUIEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuExitBtn) {
+         text = "Exit";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 420";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "quit();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
    };
    new GuiControl(MainMenuButtonHolder) {
       position = "189 711";
@@ -80,7 +229,7 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -109,5 +258,26 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(MainMenuInputHandler) {
+      class = "MenuInputHandler";
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "width";
+      vertSizing = "height";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---

Templates/BaseGame/game/data/UI/guis/mainMenu.tscript

@@ -5,8 +5,9 @@ function MainMenuGui::onAdd(%this)
 
 function MainMenuGui::onWake(%this)
 {
-   MainMenuButtonList.hidden = false; 
+   MainMenuButtonList.setAsActiveMenuList();
    MainMenuButtonHolder.setActive();
+   MainMenuInputHandler.setFirstResponder();
 }
 
 function MainMenuGui::onSleep(%this)
@@ -16,18 +17,7 @@ function MainMenuGui::onSleep(%this)
 
 function MainMenuButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "Go", "MainMenuButtonList.activateRow();");
-}
-
-function MainMenuButtonList::onAdd(%this)
-{
-   MainMenuButtonList.addRow("Single Player", "openSinglePlayerMenu", 0);
-   MainMenuButtonList.addRow("Create Server", "openMultiPlayerMenu", 4, -15);
-   MainMenuButtonList.addRow("Join Server", "openJoinServerMenu", 4, -15);
-   MainMenuButtonList.addRow("Options", "openOptionsMenu", 6, -15);
-   MainMenuButtonList.addRow("Open World Editor", "openWorldEditorBtn", 6, -15);
-   MainMenuButtonList.addRow("Open GUI Editor", "openGUIEditorBtn", 6, -15);
-   MainMenuButtonList.addRow("Exit Game", "quit", 8, -15);
+   %this-->goButton.set("btn_a", "Return", "Go", "MainMenuButtonList.activate();");
 }
 
 function openSinglePlayerMenu()
@@ -76,4 +66,5 @@ function MainMenuGui::onReturnTo(%this)
    MainMenuButtonList.hidden = false;
    MainMenuButtonList.setFirstResponder();
    MainMenuButtonHolder.setActive();
-}
+   MainMenuButtonList.setAsActiveMenuList();
+}

Templates/BaseGame/game/data/UI/guis/messageBoxDlg.gui

@@ -34,7 +34,7 @@ $guiContent = new GuiControl(MessageBoxDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         bitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "641 40";
@@ -77,7 +77,7 @@ $guiContent = new GuiControl(MessageBoxDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         bitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "641 341";

Templates/BaseGame/game/data/UI/guis/netGraphGui.gui

@@ -554,4 +554,4 @@ function NetGraph::updateNetworkSimulation(%this)
    }
    
    netSimulateLag( %latency, %packetLoss );
-}
+}

Templates/BaseGame/game/data/UI/guis/optionsDlg.gui

@@ -1,1432 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-$guiContent = new GuiControl(OptionsDlg) {
-   position = "0 0";
-   extent = "1024 768";
-   minExtent = "8 8";
-   horizSizing = "width";
-   vertSizing = "height";
-   profile = "GuiOverlayProfile";
-   visible = "1";
-   active = "1";
-   tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
-   isContainer = "1";
-   canSave = "1";
-   canSaveDynamicFields = "1";
-      fixedAspectRatio = "0";
-
-   new GuiWindowCtrl() {
-      text = "Options";
-      resizeWidth = "0";
-      resizeHeight = "0";
-      canMove = "1";
-      canClose = "1";
-      canMinimize = "0";
-      canMaximize = "0";
-      canCollapse = "0";
-      closeCommand = "Canvas.popDialog(optionsDlg);";
-      edgeSnap = "0";
-      margin = "0 0 0 0";
-      padding = "0 0 0 0";
-      anchorTop = "1";
-      anchorBottom = "0";
-      anchorLeft = "1";
-      anchorRight = "0";
-      position = "323 232";
-      extent = "377 303";
-      minExtent = "8 8";
-      horizSizing = "center";
-      vertSizing = "center";
-      profile = "GuiWindowProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-
-      new GuiButtonCtrl() {
-         text = "Done";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "306 271";
-         extent = "60 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "Canvas.popDialog(optionsDlg);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptControlsPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiScrollCtrl() {
-            willFirstRespond = "1";
-            hScrollBar = "alwaysOff";
-            vScrollBar = "alwaysOn";
-            lockHorizScroll = "1";
-            lockVertScroll = "0";
-            constantThumbHeight = "0";
-            childMargin = "0 0";
-            mouseWheelScrollSpeed = "-1";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "5 24";
-            extent = "347 152";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiScrollProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextListCtrl() {
-               columns = "0 160";
-               fitParentWidth = "1";
-               clipColumnText = "0";
-               position = "1 1";
-               extent = "329 780";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiDefaultProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptionsDlg.doRemap();";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               internalName = "OptRemapList";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiTextCtrl() {
-            text = "Control Name";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "6 6";
-            extent = "64 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Control Binding";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "165 6";
-            extent = "72 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-		 
-         new GuiSliderCtrl(OptMouseSensitivity) {  
-            range = "0.02 2";  
-            ticks = "10";  
-            value = "0.75";  
-            isContainer = "0";  
-            Profile = "GuiSliderProfile";  
-            HorizSizing = "right";  
-            VertSizing = "bottom";  
-            position = "105 182";  
-            Extent = "244 18";  
-            MinExtent = "8 2";  
-            canSave = "1";  
-            Visible = "1";  
-            Command = "OptMouseSetSensitivity(OptMouseSensitivity.value);";  
-            tooltipprofile = "GuiToolTipProfile";  
-            hovertime = "1000";  
-            canSaveDynamicFields = "0";  
-         };  
-         new GuiTextCtrl() {  
-            text = "Mouse Sensitivity:"; 
-            maxLength = "255";  
-            Margin = "0 0 0 0";  
-            Padding = "0 0 0 0";  
-            AnchorTop = "1";  
-            AnchorBottom = "0";  
-            AnchorLeft = "1";  
-            AnchorRight = "0";  
-            isContainer = "0";  
-            Profile = "GuiTextProfile";  
-            HorizSizing = "right";  
-            VertSizing = "bottom";  
-            position = "15 182";  
-            Extent = "85 18";  
-            MinExtent = "8 8";  
-            canSave = "1";  
-            Visible = "1";  
-            tooltipprofile = "GuiToolTipProfile";  
-            hovertime = "1000";  
-            canSaveDynamicFields = "0";  
-         };  
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptAudioPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiMLTextCtrl() {
-            lineSpacing = "2";
-            allowColorChars = "0";
-            maxChars = "-1";
-            useURLMouseCursor = "0";
-            position = "149 10";
-            extent = "190 14";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiMLTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAudioInfo";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Audio Provider:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "16 16";
-            extent = "75 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptAudioProviderList) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Null";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "101 15";
-            extent = "240 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Audio Device:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "23 48";
-            extent = "75 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptAudioDeviceList) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "SFX Null Device";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "101 47";
-            extent = "240 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiControl() {
-            position = "18 84";
-            extent = "325 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Master Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "72 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "0.8";
-               position = "85 1";
-               extent = "240 14";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateMasterVolume( $thisControl.value );";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeMaster";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "9 115";
-            extent = "334 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Interface Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "82 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "94 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioGui, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeShell";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "18 146";
-            extent = "325 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Effects Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "74 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "85 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioEffect, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeSim";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "23 177";
-            extent = "320 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "80 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioMusic, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeMusic";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiTextCtrl() {
-               text = "Music Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "67 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptGraphicsPane";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiTextCtrl() {
-            text = "Display Driver:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 8";
-            extent = "70 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Resolution:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 35";
-            extent = "53 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiCheckBoxCtrl() {
-            text = "Fullscreen";
-            groupNum = "-1";
-            buttonType = "ToggleButton";
-            useMouseEvents = "0";
-            position = "11 62";
-            extent = "85 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiCheckBoxProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsFullscreenToggle";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptGraphicsDriverMenu) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "ATI Radeon HD 5700 Series (D3D9)";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "88 8";
-            extent = "258 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "1024 x 768  (4:3)";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "67 35";
-            extent = "127 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsResolutionMenu";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Refresh:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "207 35";
-            extent = "45 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "60";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "252 35";
-            extent = "49 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptRefreshSelectMenu";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Mesh Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "21 91";
-            extent = "62 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 91";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptMeshQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 118";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptTextureQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Texture Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 118";
-            extent = "77 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 143";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptLightingQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Lighting Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 143";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Effect Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "191 91";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 91";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptEffectQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Shader Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "186 118";
-            extent = "77 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 118";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptShaderQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Particle Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "186 156";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "0";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            hidden = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 156";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "0";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptParticleQualityPopup";
-            class = "GraphicsQualityPopup";
-            hidden = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Anisotropic Filtering:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "22 167";
-            extent = "105 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Off";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "123 167";
-            extent = "45 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAnisotropicPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiCheckBoxCtrl() {
-            text = "Vertical Sync";
-            groupNum = "-1";
-            buttonType = "ToggleButton";
-            useMouseEvents = "0";
-            position = "92 62";
-            extent = "85 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiCheckBoxProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsVSyncToggle";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiButtonCtrl() {
-            text = "Auto Detect Quality";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            position = "205 152";
-            extent = "110 27";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiButtonProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._autoDetectQuality();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 62";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAAQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Anti-aliasing";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "191 62";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiControl() {
-            position = "0 190";
-            extent = "352 15";
-            minExtent = "8 2";
-            horizSizing = "width";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            internalName = "GammaSliderContainer";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiSliderCtrl() {
-               range = "0.001 2.2";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "76 -1";
-               extent = "268 15";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               variable = "$pref::Video::Gamma";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiTextCtrl() {
-               text = "Gamma:";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "22 -4";
-               extent = "105 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-      };
-      new GuiControl() {
-         position = "9 55";
-         extent = "357 208";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiWindowProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptNetworkPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Graphics";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "9 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Graphics);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "OptGraphicsButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Audio";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "126 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Audio);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Controls";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "243 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Controls);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Apply";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "241 271";
-         extent = "60 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonProfile";
-         visible = "1";
-         active = "0";
-         command = "optionsDlg.applyGraphics();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "apply";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
-   new GuiControl(OptionsButtonHolder) {
-      position = "190 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-   };
-};
-//--- OBJECT WRITE END ---

Templates/BaseGame/game/data/UI/guis/optionsMenu.gui

@@ -23,7 +23,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       position = "48 56";
       extent = "928 655";
       minExtent = "8 2";
-      horizSizing = "center";
+      horizSizing = "aspectCenter";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
       visible = "1";
@@ -38,10 +38,10 @@ $guiContent = new GuiControl(OptionsMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         BitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
-         position = "0 0";
-         extent = "927 40";
+         position = "0 40";
+         extent = "927 618";
          minExtent = "8 2";
          horizSizing = "width";
          vertSizing = "bottom";
@@ -54,37 +54,14 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiTextCtrl() {
-         text = "OPTIONS";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "22 7";
-         extent = "120 28";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "MenuHeaderText";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
       new GuiBitmapBarCtrl() {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         BitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
-         position = "0 40";
-         extent = "927 618";
+         position = "0 0";
+         extent = "927 40";
          minExtent = "8 2";
          horizSizing = "width";
          vertSizing = "bottom";
@@ -97,132 +74,21 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiButtonCtrl() {
-         text = "Display";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "114 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateDisplaySettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "DisplayButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Graphics";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "258 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateGraphicsSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "GraphicsButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Audio";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "402 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateAudioSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "AudioButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Keyboard + Mouse";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "547 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateKeyboardMouseSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "KBMButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Gamepad";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "691 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateGamepadSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "gamepadButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiScrollCtrl() {
-         willFirstRespond = "1";
-         hScrollBar = "alwaysOff";
-         vScrollBar = "dynamic";
-         lockHorizScroll = "1";
-         lockVertScroll = "0";
-         constantThumbHeight = "0";
-         childMargin = "0 0";
-         mouseWheelScrollSpeed = "-1";
+      new GuiTextCtrl() {
+         text = "OPTIONS";
+         maxLength = "1024";
          margin = "0 0 0 0";
          padding = "0 0 0 0";
          anchorTop = "1";
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "1 83";
-         extent = "622 573";
+         position = "22 7";
+         extent = "120 28";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         profile = "GuiMenuScrollProfile";
+         profile = "MenuHeaderText";
          visible = "1";
          active = "1";
          tooltipProfile = "GuiToolTipProfile";
@@ -230,25 +96,6 @@ $guiContent = new GuiControl(OptionsMenu) {
          isContainer = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
-
-         new GuiGameListMenuCtrl(OptionsMenuSettingsList) {
-            debugRender = "0";
-            callbackOnInputs = "1";
-            position = "1 1";
-            extent = "621 510";
-            minExtent = "8 2";
-            horizSizing = "width";
-            vertSizing = "bottom";
-            profile = "DefaultListMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            class = "UIMenuButtonList";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
       };
       new GuiTextCtrl(OptionName) {
          maxLength = "1024";
@@ -258,10 +105,10 @@ $guiContent = new GuiControl(OptionsMenu) {
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "635 94";
+         position = "3 606";
          extent = "293 17";
          minExtent = "8 2";
-         horizSizing = "right";
+         horizSizing = "width";
          vertSizing = "bottom";
          profile = "MenuSubHeaderText";
          visible = "1";
@@ -278,10 +125,10 @@ $guiContent = new GuiControl(OptionsMenu) {
          maxChars = "-1";
          text = "This is a placeholder text for an option.";
          useURLMouseCursor = "0";
-         position = "635 126";
+         position = "3 625";
          extent = "293 14";
          minExtent = "8 2";
-         horizSizing = "right";
+         horizSizing = "width";
          vertSizing = "bottom";
          profile = "GuiMLTextProfile";
          visible = "1";
@@ -292,24 +139,165 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-   };
-   new GuiControl() {
-      position = "189 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
+      new GuiSplitContainer() {
+         orientation = "Vertical";
+         splitterSize = "2";
+         splitPoint = "250 100";
+         fixedPanel = "FirstPanel";
+         fixedSize = "250";
+         docking = "None";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "0 48";
+         extent = "928 555";
+         minExtent = "64 64";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "GuiMenuScrollProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "0 0";
+            extent = "248 555";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiOverlayProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "Panel1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiStackControl(OptionsMenuCategoryList) {
+               stackingType = "Vertical";
+               horizStacking = "Left to Right";
+               vertStacking = "Top to Bottom";
+               padding = "10";
+               dynamicSize = "0";
+               dynamicNonStackExtent = "0";
+               dynamicPos = "0";
+               changeChildSizeToFit = "1";
+               changeChildPosition = "1";
+               position = "0 0";
+               extent = "248 555";
+               minExtent = "16 16";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "GuiDefaultProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               class = "MenuList";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+         };
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "252 0";
+            extent = "676 555";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiOverlayProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "panel2";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiScrollCtrl() {
+               willFirstRespond = "1";
+               hScrollBar = "alwaysOff";
+               vScrollBar = "dynamic";
+               lockHorizScroll = "0";
+               lockVertScroll = "0";
+               constantThumbHeight = "0";
+               childMargin = "0 0";
+               mouseWheelScrollSpeed = "-1";
+               margin = "0 0 0 0";
+               padding = "0 0 0 0";
+               anchorTop = "1";
+               anchorBottom = "0";
+               anchorLeft = "1";
+               anchorRight = "0";
+               position = "0 0";
+               extent = "676 554";
+               minExtent = "8 2";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "GuiMenuScrollProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+
+               new GuiStackControl(OptionsMenuSettingsList) {
+                  stackingType = "Vertical";
+                  horizStacking = "Left to Right";
+                  vertStacking = "Top to Bottom";
+                  padding = "5";
+                  dynamicSize = "1";
+                  dynamicNonStackExtent = "0";
+                  dynamicPos = "0";
+                  changeChildSizeToFit = "0";
+                  changeChildPosition = "1";
+                  position = "1 1";
+                  extent = "661 30";
+                  minExtent = "16 16";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "GuiDefaultProfile";
+                  visible = "1";
+                  active = "1";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "1";
+                  class = "MenuList";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+            };
+         };
+      };
    };
    new GuiControl(OptionsButtonHolder) {
-      position = "109 711";
+      position = "116 711";
       extent = "791 40";
       minExtent = "8 2";
       horizSizing = "center";
@@ -326,7 +314,7 @@ $guiContent = new GuiControl(OptionsMenu) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -345,7 +333,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "ChooseLevelDlg.beginLevel();";
+         command = "OptionsMenu.apply();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -356,7 +344,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_Escape_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -375,7 +363,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "ChooseLevelDlg.backOut();";
+         command = "OptionsMenu.backOut();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -386,65 +374,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Prev Tab";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "prevTabButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Next Tab";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "144 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "nextTabButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_R_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -463,6 +393,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
+         command = "OptionsMenu.resetToDefaults();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -472,5 +403,26 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(OptionsMenuInputHandler) {
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "left";
+      vertSizing = "top";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      class = "MenuInputHandler";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---

Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript

@@ -46,45 +46,164 @@
 //headbob
 //FOV
 
+function OptionsMenu::onAdd(%this)
+{
+   if(!isObject(%this.optionsCategories))
+   {
+      %this.optionsCategories = new ArrayObject();
+   }  
+   
+   if(!isObject(%this.unappliedChanges))
+   {
+      %this.unappliedChanges = new ArrayObject();
+   }  
+   
+   addOptionsMenuCategory("Display", "populateDisplaySettingsList();");
+   addOptionsMenuCategory("Graphics", "populateGraphicsSettingsList();");
+   addOptionsMenuCategory("Audio", "populateAudioSettingsList();");
+   addOptionsMenuCategory("Keyboard & Mouse", "populateKeyboardMouseSettingsList();");
+   addOptionsMenuCategory("Gamepad", "populateGamepadSettingsList();");
+}
+
 function OptionsMenuSettingsList::onAdd(%this)
 {
 }
 
+function OptionsMenuSettingsList::getOptionsList(%this, %index)
+{
+     
+}
+
 function OptionsMenu::onWake(%this)
 {
+   OptionsMenuCategoryList.clear(); 
+   
+   for(%i=0; %i < %this.optionsCategories.count(); %i++)
+   {
+      %catName = %this.optionsCategories.getKey(%i);
+      %callback = %this.optionsCategories.getValue(%i);
+      
+      %newCatButton = new GuiButtonCtrl() {
+         text = %catName;
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 180";
+         extent = "248 35";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = %callback;
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      
+      OptionsMenuCategoryList.add(%newCatButton);
+   }
+   
+   %this.unappliedChanges.empty();
+   
    MainMenuButtonList.hidden = true;
    
-   %this.pageTabIndex = 0;
-   %tab = %this.getTab();
-   %tab.performClick();
+   OptionsMenuCategoryList.setAsActiveMenuList();
    
    OptionsButtonHolder.setActive();
+   
+   OptionsMenuInputHandler.setFirstResponder();
 }
 
 function OptionsButtonHolder::onWake(%this)
 {
-   %this-->prevTabButton.set("btn_l", "", "Prev Tab", "OptionsMenu.prevTab();", true);
-   %this-->nextTabButton.set("btn_r", "", "Next Tab", "OptionsMenu.nextTab();", true);
    %this-->resetButton.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
    %this-->applyButton.set("btn_start", "Return", "Apply", "OptionsMenu.apply();");
    %this-->backButton.set("btn_b", "Escape", "Back", "OptionsMenu.backOut();");
+   
+   //OptionsMenuCategoryList.getObject(0).performClick();
 }
 
 function OptionsMenu::apply(%this)
 {
-   if(%this.pageTabIndex == 0)
-   {
-      %this.applyDisplaySettings();
-   }
-   else if(%this.pageTabIndex == 1)
-   {
-      %this.applyGraphicsSettings();
-   }
-   else if(%this.pageTabIndex == 2)
+   //Now we run through our list of unapplied changes and... apply them.
+   %hasKeybindChanges = false;
+   %hasVideoChanges = false;
+   %hasPostFXChanges = false;
+   %hasAudioChanges = false;
+   for(%i=0; %i < %this.unappliedChanges.count(); %i++)
    {
-      %this.applyAudioSettings();
+      %targetVar = %this.unappliedChanges.getKey(%i);
+      %newValue = %this.unappliedChanges.getValue(%i);
+      
+      //First, lets just check through our action map names, see if any match
+      %wasKeybind = false;
+      for(%am=0; %am < ActionMapGroup.getCount(); %am++)
+      {
+         %actionMap = ActionMapGroup.getObject(%am);
+   
+         if(%actionMap == GlobalActionMap.getId())
+            continue;
+         
+         %actionMapName = %actionMap.humanReadableName $= "" ? %actionMap.getName() : %actionMap.humanReadableName;
+         if(%actionMapName $= %targetVar)
+         {
+            %hasKeybindChanges = true;
+            %wasKeybind = true;
+            break;
+         }
+      }
+      
+      if(!%wasKeybind)
+      {
+         %currentValue = getVariable(%targetVar);
+         if(%currentValue !$= %newValue)
+         {
+            setVariable(%targetVar, %newValue);
+            
+            //now, lets check for special cases that need additional handling
+            //for updates
+            if ( %targetVar $= "$pref::Video::displayDevice" )
+            {
+               MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
+            }
+            else if(startsWith(%targetVar, "$pref::Graphics::"))
+            {
+               //isolate the quality group name, like $pref::Graphics::LightingQuality
+               //we grab LightingQuality
+               %qualityGroupName = getSubStr(%targetVar, 17);
+               if(isObject(%qualityGroupName @ "List"))
+               {
+                  //yep, it's a quality group, so apply it 
+                  (%qualityGroupName @ "List").applySetting(%newValue); 
+               }
+               
+               if(%qualityGroupName $= "TextureQuality")
+               {
+                  reloadTextures();  
+               }
+            }
+            else if(startsWith(%targetVar, "$pref::PostFX::"))
+            {
+               %hasPostFXChanges = true;
+            }
+            else if(startsWith(%targetVar, "$pref::Video::"))
+            {
+               %hasVideoChanges = true;
+            }
+            else if(startsWith(%targetVar, "$pref::SFX::"))
+            {
+               %hasAudioChanges = true;
+            }
+         }
+      }
    }
-   else if(%this.pageTabIndex == 3 || %this.pageTabIndex == 4)
+   
+   //If we had keybind changes, go ahead and save those out
+   if(%hasKeybindChanges)
    {
       %prefPath = getPrefpath();
       
@@ -106,92 +225,39 @@ function OptionsMenu::apply(%this)
       }
    }
    
-   %prefPath = getPrefpath();
-   export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}
-
-function OptionsMenu::resetToDefaults(%this)
-{
-   MessageBoxOKCancel("", "This will set the graphical settings back to the auto-detected defaults. Do you wish to continue?", "AutodetectGraphics();", "");
-}
-
-function OptionsMenuSettingsList::onChange(%this)
-{
-   %optionName = %this.getRowLabel(%this.getSelectedRow());
-   %tooltipText = %this.getTooltip(%this.getSelectedRow());
-   
-   OptionName.setText(%optionName);
-   OptionDescription.setText(%tooltipText);
-   return;
-   
-   OptionsMenuSettingsList.clearOptions();
-
-   %currentRowText = %this.getRowLabel(%this.getSelectedRow());
-   
-   if(%currentRowText $= "Display")
+   if(%hasPostFXChanges)
    {
-      OptionsMenuList.populateDisplaySettingsList();
+      updatePostFXSettings();  
    }
-   else if(%currentRowText $= "Graphics")
-   {
-      OptionsMenuList.populateGraphicsSettingsList();
-   }
-   else if(%currentRowText $= "Audio")
-   {
-      OptionsMenuList.populateAudioSettingsList();
-   }
-   else if(%currentRowText $= "Keyboard + Mouse")
+   
+   if(%hasVideoChanges)
    {
-      OptionsMenuList.populateKeyboardMouseSettingsList();
+      updateDisplaySettings();
    }
-   else if(%currentRowText $= "Gamepad")
+   
+   if(%hasAudioChanges)
    {
-      OptionsMenuList.populateGamepadSettingsList();
+      updateAudioSettings();
    }
    
+   //Finally, write our prefs to file
+   %prefPath = getPrefpath();
+   export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
    
+   OptionsMenu.unappliedChanges.empty();
 }
 
-function OptionsMenu::prevTab(%this)
-{
-   %this.pageTabIndex--;
-   if(%this.pageTabIndex < 0)
-      %this.pageTabIndex = 4;
-      
-   %tabBtn = %this.getTab();
-   %tabBtn.performClick();
-}
-
-function OptionsMenu::nextTab(%this)
+function OptionsMenu::resetToDefaults(%this)
 {
-   %this.pageTabIndex++;
-   if(%this.pageTabIndex > 4)
-      %this.pageTabIndex = 0;
-      
-   %tabBtn = %this.getTab();
-   %tabBtn.performClick();
-}
-
-function OptionsMenu::getTab(%this)
-{
-   if(%this.pageTabIndex == 0)
-      return %this-->DisplayButton;
-   else if(%this.pageTabIndex == 1)
-      return %this-->GraphicsButton;
-   else if(%this.pageTabIndex == 2)
-      return %this-->AudioButton;
-   else if(%this.pageTabIndex == 3)
-      return %this-->KBMButton;
-   else if(%this.pageTabIndex == 4)
-      return %this-->GamepadButton;
-   else 
-      return %this-->DisplayButton;
+   MessageBoxOKCancel("", "This will set the graphical settings back to the auto-detected defaults. Do you wish to continue?", "AutodetectGraphics();", "");
 }
 
-function OptionsMenu::populateDisplaySettingsList(%this)
+//
+//
+//
+function populateDisplaySettingsList()
 {
-   %this.pageTabIndex = 0;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -221,7 +287,7 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    
    trim(%apiList);
    
-   OptionsMenuSettingsList.addOptionRow("Display API", %apiList, false, "", -1, -30, true, "The display API used for rendering.", %displayDevice);
+   OptionsMenuSettingsList.addOptionRow("Display API", "$pref::Video::DisplayAPI", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
    
    %numDevices = Canvas.getMonitorCount();
    %devicesList = "";
@@ -235,7 +301,7 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    }
    
    %selectedDevice = getField(%devicesList, $pref::Video::deviceId);
-   OptionsMenuSettingsList.addOptionRow("Display Device", %devicesList, false, "onDisplayModeChange", -1, -30, true, "The display devices the window should be on.", %selectedDevice);
+   OptionsMenuSettingsList.addOptionRow("Display Device", "$pref::Video::deviceId", %devicesList, false, "", true, "The display devices the window should be on.", %selectedDevice);
       
    if (%numDevices > 1)
       OptionsMenuSettingsList.setRowEnabled(1, true);
@@ -243,10 +309,10 @@ function OptionsMenu::populateDisplaySettingsList(%this)
       OptionsMenuSettingsList.setRowEnabled(1, false);
    
    %mode = getField($Video::ModeTags, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Window Mode", $Video::ModeTags, false, "onDisplayModeChange", -1, -30, true, "", %mode);
+   OptionsMenuSettingsList.addOptionRow("Window Mode", "$pref::Video::deviceMode", $Video::ModeTags, false, "", true, "", %mode);
    
    %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Resolution", %resolutionList, false, "onDisplayResChange", -1, -30, true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
+   OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "onDisplayResChange",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
    
    //If they're doing borderless, the window resolution must match the display resolution
    if(%mode !$= "Borderless")
@@ -254,22 +320,20 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    else
       OptionsMenuSettingsList.setRowEnabled(3, false);
    
-   OptionsMenuSettingsList.addOptionRow("VSync", "No\tYes", false, "", -1, -30, true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
+   OptionsMenuSettingsList.addOptionRow("VSync", "$pref::Video::disableVerticalSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
 
 
    %refreshList = getScreenRefreshList($pref::Video::mode);
-   OptionsMenuSettingsList.addOptionRow("Refresh Rate", %refreshList, false, "", -1, -30, true, "", $pref::Video::RefreshRate);
+   OptionsMenuSettingsList.addOptionRow("Refresh Rate", "$pref::Video::RefreshRate", %refreshList, false, "",  true, "", $pref::Video::RefreshRate);
    
    //move to gameplay tab
-   OptionsMenuSettingsList.addSliderRow("Field of View", 75, 5, "65 100", "", -1, -30);
-   
-   OptionsMenuSettingsList.addSliderRow("Brightness", 0.5, 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Contrast", 0.5, 0.1, "0 1", "", -1, -30);
+   OptionsMenuSettingsList.addSliderRow("Field of View", "", 75, 5, "65 100", "");
    
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.addSliderRow("Brightness", "", 0.5, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Contrast", "", 0.5, 0.1, "0 1", "");
 }
 
-function OptionsMenu::applyDisplaySettings(%this)
+/*function OptionsMenu::applyDisplaySettings(%this)
 {
 	%newDevice = OptionsMenuSettingsList.getCurrentOption(0);
 							
@@ -288,12 +352,14 @@ function OptionsMenu::applyDisplaySettings(%this)
    echo("Exporting client prefs");
    %prefPath = getPrefpath();
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}
+}*/
 
-function OptionsMenu::populateGraphicsSettingsList(%this)
+//
+//
+//
+function populateGraphicsSettingsList()
 {
-   %this.pageTabIndex = 1;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -303,92 +369,32 @@ function OptionsMenu::populateGraphicsSettingsList(%this)
    %highMedLow = "Low\tMedium\tHigh";
    %anisoFilter = "Off\t4\t8\t16";
    %aaFilter = "Off\t1\t2\t4";
-   OptionsMenuSettingsList.addOptionRow("Lighting Quality", getQualityLevels(LightingQualityList), false, "", -1, -30, true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
-   OptionsMenuSettingsList.addOptionRow("Shadow Quality", getQualityLevels(ShadowQualityList), false, "", -1, -30, true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
-   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", getQualityLevels(SoftShadowList), false, "", -1, -30, true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
-   OptionsMenuSettingsList.addOptionRow("Mesh Quality", getQualityLevels(MeshQualityGroup), false, "", -1, -30, true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", getQualityLevels(MeshDrawDistQualityGroup), false, "", -1, -30, true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Texture Quality", getQualityLevels(TextureQualityGroup), false, "", -1, -30, true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Terrain Quality", getQualityLevels(TerrainQualityGroup), false, "", -1, -30, true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", getQualityLevels(DecalLifetimeGroup), false, "", -1, -30, true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
-   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", getQualityLevels(GroundCoverDensityGroup), false, "", -1, -30, true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
-   OptionsMenuSettingsList.addOptionRow("Shader Quality", getQualityLevels(ShaderQualityGroup), false, "", -1, -30, true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", %anisoFilter, false, "", -1, -30, true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
-   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", %aaFilter, false, "", -1, -30, true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
-   OptionsMenuSettingsList.addOptionRow("Parallax", %onOffList, false, "", -1, -30, true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
-   OptionsMenuSettingsList.addOptionRow("Water Reflections", %onOffList, false, "", -1, -30, true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
-   OptionsMenuSettingsList.addOptionRow("SSAO", %onOffList, false, "", -1, -30, true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
-   OptionsMenuSettingsList.addOptionRow("Depth of Field", %onOffList, false, "", -1, -30, true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
-   OptionsMenuSettingsList.addOptionRow("Vignette", %onOffList, false, "", -1, -30, true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
-   OptionsMenuSettingsList.addOptionRow("Light Rays", %onOffList, false, "", -1, -30, true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
-   
-   OptionsMenuSettingsList.refresh();
-}
-
-function OptionsMenu::applyGraphicsSettings(%this)
-{
-   LightingQualityList.applySetting(OptionsMenuSettingsList.getCurrentOption(0));
-   ShadowQualityList.applySetting(OptionsMenuSettingsList.getCurrentOption(1));
-   SoftShadowList.applySetting(OptionsMenuSettingsList.getCurrentOption(2));
-   
-   MeshQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(3));
-   MeshDrawDistQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(4));
-   TextureQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(5));
-   TerrainQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(6));
-   DecalLifetimeGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(7));
-   GroundCoverDensityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(8));
-   ShaderQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(9));
-   
-   //Update Textures
-   reloadTextures();
-
-   //Update lighting
-   // Set the light manager.  This should do nothing 
-   // if its already set or if its not compatible.   
-   //setLightManager( $pref::lightManager );   
-   
-   $pref::PostFX::EnableSSAO = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(14));
-   $pref::PostFX::EnableDOF = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(15));
-   $pref::PostFX::EnableVignette = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(16));
-   $pref::PostFX::EnableLightRays = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(17));
-   
-   PostFXManager.settingsEffectSetEnabled(SSAOPostFx, $pref::PostFX::EnableSSAO);
-   PostFXManager.settingsEffectSetEnabled(DOFPostEffect, $pref::PostFX::EnableDOF);
-   PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
-   PostFXManager.settingsEffectSetEnabled(vignettePostFX, $pref::PostFX::EnableVignette);
-   
-   $pref::Video::disableParallaxMapping = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(12));
-   
-   //water reflections
-   $pref::Water::disableTrueReflections = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(13));
-   
-   // Check the anisotropic filtering.   
-   %level = OptionsMenuSettingsList.getCurrentOption(10);
-   if ( %level != $pref::Video::defaultAnisotropy )
-   {                     
-      $pref::Video::defaultAnisotropy = %level;
-   }
-
-   %newFSAA = OptionsMenuSettingsList.getCurrentOption(11);
-   if (%newFSAA $= "off")
-      %newFSAA = 0;
-   if (%newFSAA !$= $pref::Video::AA)
-   {
-      $pref::Video::AA = %newFSAA;
-      configureCanvas();
-   }
-
-   echo("Exporting client prefs");
-   %prefPath = getPrefpath();
-   export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}   
+   OptionsMenuSettingsList.addOptionRow("Lighting Quality", "$pref::Graphics::LightingQuality", getQualityLevels(LightingQualityList), false, "",  true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
+   OptionsMenuSettingsList.addOptionRow("Shadow Quality", "$pref::Graphics::ShadowQuality", getQualityLevels(ShadowQualityList), false, "",  true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
+   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", "$pref::Graphics::SoftShadowQuality", getQualityLevels(SoftShadowList), false, "",  true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
+   OptionsMenuSettingsList.addOptionRow("Mesh Quality", "$pref::Graphics::MeshQuality", getQualityLevels(MeshQualityGroup), false, "",  true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", "$pref::Graphics::ObjectDrawDistance", getQualityLevels(MeshDrawDistQualityGroup), false, "",  true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Texture Quality", "$pref::Graphics::TextureQuality", getQualityLevels(TextureQualityGroup), false, "",  true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Terrain Quality", "$pref::Graphics::TerrainQuality", getQualityLevels(TerrainQualityGroup), false, "",  true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", "$pref::Graphics::DecalLifetime", getQualityLevels(DecalLifetimeGroup), false, "",  true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
+   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", "$pref::Graphics::GroundCoverDensity", getQualityLevels(GroundCoverDensityGroup), false, "",  true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
+   OptionsMenuSettingsList.addOptionRow("Shader Quality", "$pref::Graphics::ShaderQuality", getQualityLevels(ShaderQualityGroup), false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", "$pref::Video::defaultAnisotropy", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
+   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", "$pref::Video::AA", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
+   OptionsMenuSettingsList.addOptionRow("Parallax", "$pref::Video::disableParallaxMapping", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
+   OptionsMenuSettingsList.addOptionRow("Water Reflections", "$pref::Water::disableTrueReflections", %onOffList, false, "",  true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
+   OptionsMenuSettingsList.addOptionRow("SSAO", "$pref::PostFX::EnableSSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
+   OptionsMenuSettingsList.addOptionRow("Depth of Field", "$pref::PostFX::EnableDOF", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
+   OptionsMenuSettingsList.addOptionRow("Vignette", "$pref::PostFX::EnableVignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
+   OptionsMenuSettingsList.addOptionRow("Light Rays", "$pref::PostFX::EnableLightRays", %onOffList, false, "",  true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
+}
 
 function updateDisplaySettings()
 {
    //Update the display settings now
-   %deviceName = OptionsMenuSettingsList.getCurrentOption(1);
+   %deviceName = getDisplayDeviceName();
    %newDeviceID = getWord(%deviceName, 0) - 1;
-   %deviceModeName = OptionsMenuSettingsList.getCurrentOption(2);
+   %deviceModeName = getField($Video::ModeTags, $pref::Video::deviceMode);
    %newDeviceMode = 0;
    foreach$(%modeName in $Video::ModeTags)
    {
@@ -398,15 +404,15 @@ function updateDisplaySettings()
          %newDeviceMode++;
    }
 
-   %newRes = getWord(OptionsMenuSettingsList.getCurrentOption(3), 0) SPC getWord(OptionsMenuSettingsList.getCurrentOption(3), 2);
+   %newRes = $pref::Video::Resolution;
    %newBpp = 32; // ... its not 1997 anymore.
 	%newFullScreen = %deviceModeName $= "Fullscreen" ? true : false;
-	%newRefresh    = OptionsMenuSettingsList.getCurrentOption(5);
-	%newVsync = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(4));	
+	%newRefresh    = $pref::Video::RefreshRate;
+	%newVsync = !$pref::Video::disableVerticalSync;	
 	%newFSAA = $pref::Video::AA;
 	
    // Build the final mode string.
-	%newMode = %newRes SPC %newFullScreen SPC %newBpp SPC %newRefresh SPC %newFSAA;
+	%newMode = $pref::Video::Resolution SPC %newFullScreen SPC %newBpp SPC %newRefresh SPC %newFSAA;
 	
    // Change the video mode.   
    if (  %newMode !$= $pref::Video::mode || %newDeviceID != $pref::Video::deviceId ||
@@ -439,10 +445,20 @@ function updateDisplaySettings()
    }
 }
 
-function OptionsMenu::populateAudioSettingsList(%this)
+function updatePostFXSettings()
+{
+   PostFXManager.settingsEffectSetEnabled(SSAOPostFx, $pref::PostFX::EnableSSAO);
+   PostFXManager.settingsEffectSetEnabled(DOFPostEffect, $pref::PostFX::EnableDOF);
+   PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
+   PostFXManager.settingsEffectSetEnabled(vignettePostFX, $pref::PostFX::EnableVignette);
+}
+
+//
+//
+//
+function populateAudioSettingsList()
 {
-   %this.pageTabIndex = 2;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -477,18 +493,15 @@ function OptionsMenu::populateAudioSettingsList(%this)
          else 
             %audioDeviceList = %audioDeviceList @ "\t" @ %device;  
       }
-         
    }
    
-   OptionsMenuSettingsList.addOptionRow("Audio Provider", %audioProviderList, false, "audioProviderChanged", -1, -15, true, "", $currentAudioProvider);
-   OptionsMenuSettingsList.addOptionRow("Audio Device", %audioDeviceList, false, "", -1, -15, true, $pref::SFX::device);
+   OptionsMenuSettingsList.addOptionRow("Audio Provider", "$pref::SFX::AudioProvider", %audioProviderList, false, "audioProviderChanged", true, "", $currentAudioProvider);
+   OptionsMenuSettingsList.addOptionRow("Audio Device", "$pref::SFX::device", %audioDeviceList, false, "", true, $pref::SFX::device);
    
-   OptionsMenuSettingsList.addSliderRow("Master Volume", $pref::SFX::masterVolume, 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("GUI Volume", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Effects Volume", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Music Volume", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "", -1, -30);
-   
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.addSliderRow("Master Volume", "$pref::SFX::masterVolume", $pref::SFX::masterVolume, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("GUI Volume", "$pref::SFX::channelVolume[ $GuiAudioType]", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Effects Volume", "$pref::SFX::channelVolume[ $SimAudioType ]", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Music Volume", "$pref::SFX::channelVolume[ $MusicAudioType ]", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "");
 }
 
 function audioProviderChanged()
@@ -498,24 +511,24 @@ function audioProviderChanged()
    $currentAudioProvider = %provider;
    
    //And now refresh the list to get the correct devices
-   OptionsMenu.populateAudioSettingsList();
+   populateAudioSettingsList();
 }
 
-function OptionsMenu::applyAudioSettings(%this)
+function updateAudioSettings()
 {
-   $pref::SFX::masterVolume = OptionsMenuSettingsList.getValue(2);
+   //$pref::SFX::masterVolume = OptionsMenuSettingsList.getValue(2);
    sfxSetMasterVolume( $pref::SFX::masterVolume );
    
-   $pref::SFX::channelVolume[ $GuiAudioType ] = OptionsMenuSettingsList.getValue(3);
-   $pref::SFX::channelVolume[ $SimAudioType ] = OptionsMenuSettingsList.getValue(4);
-   $pref::SFX::channelVolume[ $MusicAudioType ] = OptionsMenuSettingsList.getValue(5);
+   //$pref::SFX::channelVolume[ $GuiAudioType ] = OptionsMenuSettingsList.getValue(3);
+   //$pref::SFX::channelVolume[ $SimAudioType ] = OptionsMenuSettingsList.getValue(4);
+   //$pref::SFX::channelVolume[ $MusicAudioType ] = OptionsMenuSettingsList.getValue(5);
    
    sfxSetChannelVolume( $GuiAudioType, $pref::SFX::channelVolume[ $GuiAudioType ] );
    sfxSetChannelVolume( $SimAudioType, $pref::SFX::channelVolume[ $SimAudioType ] );
    sfxSetChannelVolume( $MusicAudioType, $pref::SFX::channelVolume[ $MusicAudioType ] );
    
-   $pref::SFX::provider = OptionsMenuSettingsList.getCurrentOption(0);
-   $pref::SFX::device = OptionsMenuSettingsList.getCurrentOption(1);
+   //$pref::SFX::provider = OptionsMenuSettingsList.getCurrentOption(0);
+   //$pref::SFX::device = OptionsMenuSettingsList.getCurrentOption(1);
    
    if ( !sfxCreateDevice(  $pref::SFX::provider, 
                            $pref::SFX::device, 
@@ -531,10 +544,12 @@ function OptionsMenu::applyAudioSettings(%this)
    }
 }
 
-function OptionsMenu::populateKeyboardMouseSettingsList(%this)
+//
+//
+//
+function populateKeyboardMouseSettingsList()
 {
-   %this.pageTabIndex = 3;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -542,13 +557,12 @@ function OptionsMenu::populateKeyboardMouseSettingsList(%this)
    $remapListDevice = "keyboard";
    fillRemapList();
    
-   OptionsMenuSettingsList.refresh();
+   //OptionsMenuSettingsList.refresh();
 }
 
-function OptionsMenu::populateGamepadSettingsList(%this)
+function populateGamepadSettingsList()
 {
-   %this.pageTabIndex = 4;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -556,15 +570,30 @@ function OptionsMenu::populateGamepadSettingsList(%this)
    $remapListDevice = "gamepad";
    fillRemapList();
    
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.updateStack();
 }
 
+//
+//
+//
 function OptionsMenuList::activateRow(%this)
 {
    OptionsMenuSettingsList.setFirstResponder();
 }
 
 function OptionsMenu::backOut(%this)
+{
+   if(%this.unappliedChanges.count() != 0)
+   {
+      MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to continue?", "OptionsMenu.doOptionsMenuBackOut();", "");
+   }
+   else
+   {
+      %this.doOptionsMenuBackOut();
+   }
+}
+
+function OptionsMenu::doOptionsMenuBackOut(%this)
 {
    //save the settings and then back out
    if(OptionsMain.hidden == false)
@@ -586,6 +615,117 @@ function OptionsMenu::backOut(%this)
    }
 }
 
+function OptionsMenuSettingsList::setRowEnabled(%this, %row, %status)
+{
+   %option = %this.getObject(%row);
+   if(isObject(%option))
+   {
+      %option.setEnabled(%status);
+   }
+}
+
+function OptionsMenuSettingsList::addOptionRow(%this, %label, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 30;
+   %optionColumnWidth = %this.extent.x - 450;//todo, calculate off longest option text?
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+      previousBitmapAsset = "UI:previousOption_n_image";
+      nextBitmapAsset = "UI:nextOption_n_image";
+   };
+   
+   %option.targetPrefVar = %targetPrefVar; //create a var-option association
+   
+   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
+   //with the unapplied, allowing us to change options categories without losing changes
+   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
+   if(%unappliedPrefIndex != -1)
+   {
+      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
+      %defaultValue = %unappliedValue;
+   }
+   
+   %option.setListSetting(%label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue);
+
+   %this.add(%option);
+}
+
+function OptionsMenuSettingsList::addSliderRow(%this, %label, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled, %description)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 30;
+   %optionColumnWidth = %this.extent.x - 450;//todo, calculate off longest option text?
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+   };
+   
+   %option.targetPrefVar = %targetPrefVar; //create a var-option association
+   
+   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
+   //with the unapplied, allowing us to change options categories without losing changes
+   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
+   if(%unappliedPrefIndex != -1)
+   {
+      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
+      %defaultValue = %unappliedValue;
+   }
+   
+   %option.setSliderSetting(%label, %defaultValue, %increment, %range, %callback, %enabled, %description);
+
+   %this.add(%option);
+}
+
+function OptionsMenuSettingsList::addKeybindRow(%this, %label, %bitmapName, %callback, %enabled, %description)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 40;
+   %optionColumnWidth = %this.extent.x - 450;
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+   };
+   
+   %option.setKeybindSetting(%label, %bitmapName, %callback, %enabled, %description);
+
+   %this.add(%option);
+}
+
+//
+function OptionsMenuCategoryList::onNavigate(%this, %index)
+{
+   %this.getObject(%index).performClick();
+}
+
 function convertOptionToBool(%val)
 {
    if(%val $= "yes" || %val $= "on")
@@ -685,4 +825,114 @@ function onDisplayResChange(%val)
 
    OptionsMenuSettingsList.setOptions(5, %refreshList);
    OptionsMenuSettingsList.selectOption(5, %newRate);
-}
+}
+
+function getDisplayDeviceName()
+{
+   %numDevices = Canvas.getMonitorCount();
+   %devicesList = "";
+   for(%i = 0; %i < %numDevices; %i++)
+   {
+      %device = (%i+1) @ " - " @ Canvas.getMonitorName(%i);
+      if(%i==0)
+         %devicesList = %device;
+      else
+         %devicesList = %devicesList @ "\t" @ %device;
+   }
+   
+   return getField(%devicesList, $pref::Video::deviceId);  
+}
+//
+//
+//
+function MenuOptionsButton::onMouseEnter(%this)
+{
+   OptionName.setText(%this.getLabel());
+   OptionDescription.setText(%this.getToolTip());
+}
+
+function MenuOptionsButton::onMouseLeave(%this)
+{
+   OptionName.setText("");
+   OptionDescription.setText("");
+}
+
+function MenuOptionsButton::onChange(%this)
+{
+   %optionMode = %this.getMode();
+   %optionName = %this.getLabel();
+   %tooltipText = %this.getTooltip();
+   
+   %targetVar = %this.targetPrefVar;
+   
+   OptionName.setText(%optionName);
+   OptionDescription.setText(%tooltipText);
+   
+   %currentValue = %this.getCurrentOption();
+   if(%currentValue !$= "")
+   {
+      if(%currentValue $= "yes" || %currentValue $= "on")
+         %saveReadyValue = 1;
+      else if(%currentValue $= "no" || %currentValue $= "off")
+         %saveReadyValue = 0;
+      else 
+         %saveReadyValue = %currentValue;
+      
+      %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%targetVar);
+      if(%prefIndex == -1)
+         OptionsMenu.unappliedChanges.add(%targetVar, %saveReadyValue);
+      else
+         OptionsMenu.unappliedChanges.setValue(%saveReadyValue, %prefIndex);
+   }
+}
+
+function OptionsMenu::onKeybindChanged(%this, %actionMap, %keybind)
+{
+   %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%actionMap);
+   if(%prefIndex == -1)
+      OptionsMenu.unappliedChanges.add(%actionMap, %keybind);
+   else
+      OptionsMenu.unappliedChanges.setValue(%keybind, %prefIndex);
+}
+
+//
+// Indicates what category the options item should be added into
+//
+function addOptionsMenuCategory(%categoryName, %selectCallback)
+{
+   OptionsMenu.optionsCategories.add(%categoryName, %selectCallback);
+}
+
+function removeOptionsMenuCategory(%categoryName)
+{
+   %index = OptionsMenu.optionsCategories.getIndexFromKey(%categoryName);
+   if(%index != -1)
+      OptionsMenu.optionsCategories.erase(%index);
+}
+
+function addListOption(%label, %description, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled)
+{
+   if(%wrapOptions $= "")
+      %wrapOptions = false;
+      
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addOptionRow(%label, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled, %description, %targetPrefVar);
+}
+
+function addSliderOption(%label, %description, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled)
+{
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addSliderRow(%label, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled, %description);
+}
+
+function addKeybindOption(%label, %description, %bitmapName, %callback, %enabled)
+{
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addSliderRow(%label, %bitmapName, %callback, %enabled, %description);
+}

Templates/BaseGame/game/data/UI/guis/pauseMenu.gui

@@ -49,25 +49,31 @@ $guiContent = new GuiControl(PauseMenu) {
       isContainer = "1";
       canSave = "1";
       canSaveDynamicFields = "0";
-
-      new GuiGameListMenuCtrl(PauseMenuList) {
-         debugRender = "0";
-         callbackOnInputs = "1";
-         consumeKeyInputEvents = "1";
+      
+      new GuiStackControl(PauseMenuList) {
+         stackingType = "Vertical";
+         horizStacking = "Left to Right";
+         vertStacking = "Top to Bottom";
+         padding = "15";
+         dynamicSize = "0";
+         dynamicNonStackExtent = "0";
+         dynamicPos = "0";
+         changeChildSizeToFit = "1";
+         changeChildPosition = "1";
          position = "0 0";
          extent = "700 320";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "DefaultListMenuProfile";
+         minExtent = "16 16";
+         horizSizing = "center";
+         vertSizing = "center";
+         profile = "GuiDefaultProfile";
          visible = "1";
          active = "1";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
-         isContainer = "0";
-         class = "UIMenuButtonList";
+         isContainer = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
+         class = "MenuList";
       };
    };
    new GuiControl(PauseButtonHolder) {
@@ -147,5 +153,26 @@ $guiContent = new GuiControl(PauseMenu) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(PauseMenuInputHandler) {
+      class = "MenuInputHandler";
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "width";
+      vertSizing = "height";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---

Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript

@@ -8,19 +8,21 @@ function PauseMenu::onWake(%this)
    }
    
    PauseMenuList.hidden = false;
-   PauseMenuList.setFirstResponder();
-   PauseButtonHolder.setActive();
    
-   PauseMenuList.clearRows();
+   PauseMenuList.clear();
    
    if($Tools::loaded && EditorIsActive())
    {
-      PauseMenuList.addRow("Exit Editor", "fastLoadWorldEdit", -1, -30); 
+      %this.addPauseMenuButton("Exit Editor", "fastLoadWorldEdit();"); 
    }
    
-   PauseMenuList.addRow("Options", "openPauseMenuOptions", -1, -30);
-   PauseMenuList.addRow("Exit to Menu", "pauseMenuExitToMenu", -1, -30);
-   PauseMenuList.addRow("Exit to Desktop", "pauseMenuExitToDesktop", -1, -30); 
+   %this.addPauseMenuButton("Options", "openPauseMenuOptions();");
+   %this.addPauseMenuButton("Exit to Menu", "pauseMenuExitToMenu();");
+   %this.addPauseMenuButton("Exit to Desktop", "pauseMenuExitToDesktop();"); 
+   
+   PauseMenuList.setAsActiveMenuList();
+   PauseButtonHolder.setActive();
+   PauseMenuInputHandler.setFirstResponder();
 }
 
 
@@ -36,8 +38,9 @@ function PauseMenu::onSleep(%this)
 function PauseMenu::onReturnTo(%this)
 {
    PauseMenuList.hidden = false;
-   PauseMenuList.setFirstResponder();
+   PauseMenuList.setAsActiveMenuList();
    PauseButtonHolder.setActive();
+   PauseMenuInputHandler.setFirstResponder();
 }
 
 function openPauseMenuOptions()
@@ -61,6 +64,32 @@ function pauseMenuExitToDesktop()
 
 function PauseButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "OK", "PauseMenuList.activateRow();", true);
+   %this-->goButton.set("btn_a", "Return", "OK", "PauseMenuList.activate();", true);
    %this-->backButton.set("btn_b", "Escape", "Back", "Canvas.popDialog();");
-}
+}
+
+function PauseMenu::addPauseMenuButton(%this, %buttonText, %buttonCallback)
+{
+   %newButton = new GuiButtonCtrl() {
+      text = %buttonText;
+      groupNum = "-1";
+      buttonType = "PushButton";
+      useMouseEvents = "0";
+      position = "0 0";
+      extent = "400 55";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "GuiMenuButtonProfile";
+      visible = "1";
+      active = "1";
+      command = %buttonCallback;
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+   
+   PauseMenuList.add(%newButton);
+}

Templates/BaseGame/game/data/UI/guis/profiler.tscript

@@ -363,4 +363,4 @@ function metrics( %expr )
    }
    else
       $GameCanvas.popDialog(FrameOverlayGui);
-}
+}

Templates/BaseGame/game/data/UI/guis/recordingsDlg.asset.taml

@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="recordingsDlg"
-    scriptFile="@assetFile=RecordingsDlg.gui"
     GUIFile="@assetFile=RecordingsDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>

Templates/BaseGame/game/data/UI/guis/startupGui.gui

@@ -35,7 +35,7 @@ $guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
       Visible = "1";
       tooltipprofile = "GuiToolTipProfile";
       hovertime = "1000";
-      bitmap = "";
+      bitmapAsset = "";
       wrap = "0";
       command = "StartupGui.click();";
    };
@@ -54,7 +54,7 @@ $guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
       Visible = "1";
       tooltipprofile = "GuiToolTipProfile";
       hovertime = "1000";
-      bitmap = "";
+      bitmapAsset = "";
       wrap = "0";
       command = "StartupGui.click();";
    };

Templates/BaseGame/game/data/UI/guis/startupGui.tscript

@@ -32,7 +32,7 @@ function loadStartup()
    // A list of the splash screens and logos
    // to cycle through. Note that they have to
    // be in consecutive numerical order
-   StartupGui.bitmap[0]     = "UI:background_dark_image";
+   StartupGui.bitmap[0]     = "UI:backgrounddark_image";
    StartupGui.logo[0]       = "UI:Torque_3D_logo_alt_image";
    StartupGui.logoPos[0]    = "178 251";
    StartupGui.logoExtent[0] = "443 139";

Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt_image.asset.taml

@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_alt_image"
-    imageFile="@assetFile=Torque-3D-logo_alt.png"
+    imageFile="@assetFile=Torque_3D_logo_alt.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />

Templates/BaseGame/game/data/UI/images/Torque_3D_logo_image.asset.taml

@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_image"
-    imageFile="@assetFile=Torque-3D-logo.png"
+    imageFile="@assetFile=Torque_3D_logo.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />

Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut_image.asset.taml

@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_shortcut_image"
-    imageFile="@assetFile=Torque-3D-logo-shortcut.png"
+    imageFile="@assetFile=Torque_3D_logo_shortcut.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />

Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w_image.asset.taml

@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_w_image"
-    imageFile="@assetFile=Torque-3D-logo-w.png"
+    imageFile="@assetFile=Torque_3D_logo_w.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />

Templates/BaseGame/game/data/UI/images/background_dark_image.asset.taml

@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="background_dark_image"
-    imageFile="@assetFile=background-dark.png"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />

Templates/BaseGame/game/data/UI/images/backgrounddark_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="backgrounddark_image"
+    imageFile="@assetFile=backgrounddark.png"/>

Templates/BaseGame/game/data/UI/images/clearbtn_d_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_d_image"
+    imageFile="@assetFile=clearbtn_d.png"/>

Templates/BaseGame/game/data/UI/images/clearbtn_h_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_h_image"
+    imageFile="@assetFile=clearbtn_h.png"/>

Templates/BaseGame/game/data/UI/images/clearbtn_n_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_n_image"
+    imageFile="@assetFile=clearbtn_n.png"/>

Templates/BaseGame/game/data/UI/images/collapsetoolbar_d_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_d_image"
+    imageFile="@assetFile=collapsetoolbar_d.png"/>

Templates/BaseGame/game/data/UI/images/collapsetoolbar_h_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_h_image"
+    imageFile="@assetFile=collapsetoolbar_h.png"/>

Templates/BaseGame/game/data/UI/images/collapsetoolbar_n_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_n_image"
+    imageFile="@assetFile=collapsetoolbar_n.png"/>

Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="dropdownbuttonarrow_image"
+    imageFile="@assetFile=dropdownbuttonarrow.png"/>

Templates/BaseGame/game/data/UI/images/dropdowntextEdit_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="dropdowntextEdit_image"
+    imageFile="@assetFile=dropdowntextEdit.png"/>

Templates/BaseGame/game/data/UI/images/expandtoolbar_d_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_d_image"
+    imageFile="@assetFile=expandtoolbar_d.png"/>

Templates/BaseGame/game/data/UI/images/expandtoolbar_h_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_h_image"
+    imageFile="@assetFile=expandtoolbar_h.png"/>

Templates/BaseGame/game/data/UI/images/expandtoolbar_n_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_n_image"
+    imageFile="@assetFile=expandtoolbar_n.png"/>

Templates/BaseGame/game/data/UI/images/groupborder_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="groupborder_image"
+    imageFile="@assetFile=groupborder.png"/>

Templates/BaseGame/game/data/UI/images/inactiveoverlay_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="inactiveoverlay_image"
+    imageFile="@assetFile=inactiveoverlay.png"/>

Templates/BaseGame/game/data/UI/images/menubutton_image.asset.taml

@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="menubutton_image"
+    imageFile="@assetFile=menubutton.png"/>

Templates/BaseGame/game/data/UI/images/nextOption_n_image.asset.taml

@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="nextOption_n_image"
+    imageFile="@assetFile=nextOption_n.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="GUI" />