Torque3D/Engine/source/gui/controls/guiGameListMenuCtrl.cpp

//-----------------------------------------------------------------------------
// 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 "guiGameListMenuCtrl.h"

#include "console/consoleTypes.h"
#include "console/engineAPI.h"
#include "gfx/gfxDrawUtil.h"
#include "gui/containers/guiScrollCtrl.h"
#include "sim/actionMap.h"
#include "core/strings/stringUnit.h"

//-----------------------------------------------------------------------------
// GuiGameListMenuCtrl
//-----------------------------------------------------------------------------

GuiGameListMenuCtrl::GuiGameListMenuCtrl()
 : mSelected(NO_ROW),
   mDebugRender(false),
   mHighlighted(NO_ROW),
   mCallbackOnInputs(false),
   mConsumeKeyInputEvents(false)
{
   VECTOR_SET_ASSOCIATION(mRows);

   // initialize the control callbacks
   mCallbackOnA = StringTable->EmptyString();
   mCallbackOnB = mCallbackOnA;
   mCallbackOnX = mCallbackOnA;
   mCallbackOnY = mCallbackOnA;
}

GuiGameListMenuCtrl::~GuiGameListMenuCtrl()
{
   for (S32 i = 0; i < mRows.size(); ++i)
   {
      delete mRows[i];
   }
}

void GuiGameListMenuCtrl::onRender(Point2I offset, const RectI &updateRect)
{
   GuiGameListMenuProfile * profile = (GuiGameListMenuProfile *) mProfile;

   GFXDrawUtil* drawUtil = GFX->getDrawUtil();

   F32 xScale = (float) getWidth() / profile->getRowWidth();

   bool profileHasIcons = profile->hasArrows();

   S32 rowHeight = profile->getRowHeight();

   Point2I currentOffset = offset;
   Point2I extent = getExtent();
   Point2I rowExtent(extent.x, rowHeight);
   Point2I textOffset(profile->mTextOffset.x * xScale, profile->mTextOffset.y);
   Point2I textExtent(extent.x - textOffset.x, rowHeight);
   Point2I iconExtent, iconOffset(0.0f, 0.0f);
   if (profileHasIcons)
   {
      iconExtent = profile->getIconExtent();

      // icon is centered vertically plus any specified offset
      S32 iconOffsetY = (rowHeight - iconExtent.y) >> 1;
      iconOffsetY += profile->mIconOffset.y;
      iconOffset = Point2I(profile->mIconOffset.x * xScale, iconOffsetY);
   }
   for (Vector<Row *>::iterator row = mRows.begin(); row < mRows.end(); ++row)
   {
      if (row != mRows.begin())
      {
         // rows other than the first can have padding above them
         currentOffset.y += (*row)->mHeightPad;
         currentOffset.y += rowHeight;
      }

      // select appropriate colors and textures
      ColorI fontColor;
      U32 buttonTextureIndex;
      S32 iconIndex = (*row)->mIconIndex;
      bool useHighlightIcon = (*row)->mUseHighlightIcon;
      if (!(*row)->mEnabled)
      {
         buttonTextureIndex = Profile::TEX_DISABLED;
         fontColor = profile->mFontColorNA;
      }
      else if (row == &mRows[mSelected])
      {
         if (iconIndex != NO_ICON)
         {
            iconIndex++;
         }
         buttonTextureIndex = Profile::TEX_SELECTED;
         fontColor = profile->mFontColorSEL;
      }
      else if ((mHighlighted != NO_ROW) && (row == &mRows[mHighlighted]))
      {
         if (iconIndex != NO_ICON && useHighlightIcon)
         {
            iconIndex++;
         }
         buttonTextureIndex = Profile::TEX_HIGHLIGHT;
         fontColor = profile->mFontColorHL;
      }
      else
      {
         buttonTextureIndex = Profile::TEX_NORMAL;
         fontColor = profile->mFontColor;
      }

      // render the row bitmap
      drawUtil->clearBitmapModulation();
      drawUtil->drawBitmapStretchSR(profile->mBitmap, RectI(currentOffset, rowExtent), profile->getBitmapArrayRect(buttonTextureIndex));

      // render the row icon if it has one
      if ((iconIndex != NO_ICON) && profileHasIcons && (!profile->getBitmapArrayRect((U32)iconIndex).extent.isZero()))
      {
         iconIndex += Profile::TEX_FIRST_ICON;
         drawUtil->clearBitmapModulation();
         drawUtil->drawBitmapStretchSR(profile->mBitmap, RectI(currentOffset + iconOffset, iconExtent), profile->getBitmapArrayRect(iconIndex));
      }

      // render the row text
      drawUtil->setBitmapModulation(fontColor);
      renderJustifiedText(currentOffset + textOffset, textExtent, (*row)->mLabel);

      if ((*row)->mMode == Row::Mode::OptionList)
      {
         onRenderListOption((*row), currentOffset);
      }
      else if ((*row)->mMode == Row::Mode::Slider)
      {
         onRenderSliderOption((*row), currentOffset);
      }
      else if ((*row)->mMode == Row::Mode::Keybind)
      {
         onRenderKeybindOption((*row), currentOffset);
      }
   }

   if (mDebugRender)
   {
      onDebugRender(offset);
   }

   renderChildControls(offset, updateRect);
}

void GuiGameListMenuCtrl::onRenderListOption(Row* row, Point2I currentOffset)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;

   F32 xScale = (float)getWidth() / profile->getRowWidth();

   S32 rowHeight = profile->getRowHeight();

   bool profileHasArrows = profile->hasArrows();
   Point2I arrowExtent;
   S32 arrowOffsetY(0);
   if (profileHasArrows)
   {
      arrowExtent = profile->getArrowExtent();

      // icon is centered vertically
      arrowOffsetY = (rowHeight - arrowExtent.y) >> 1;
   }

   GFXDrawUtil* drawer = GFX->getDrawUtil();

   Point2I arrowOffset;
   S32 columnSplit = profile->mColumnSplit * xScale;

   S32 iconIndex;
   bool hasOptions = (row->mOptions.size() > 0) && row->mSelectedOption > -1;
   if (hasOptions)
   {
      bool isRowSelected = (getSelected() != NO_ROW) && (row == mRows[getSelected()]);
      bool isRowHighlighted = (getHighlighted() != NO_ROW) ? ((row == mRows[getHighlighted()]) && (row->mEnabled)) : false;
      if (profileHasArrows)
      {
         // render the left arrow
         bool arrowOnL = (isRowSelected || isRowHighlighted) && (row->mWrapOptions || (row->mSelectedOption > 0));
         iconIndex = (arrowOnL) ? Profile::TEX_L_ARROW_ON : Profile::TEX_L_ARROW_OFF;
         arrowOffset.x = currentOffset.x + columnSplit;
         arrowOffset.y = currentOffset.y + arrowOffsetY;

         drawer->clearBitmapModulation();
         drawer->drawBitmapStretchSR(profile->getBitmapResource(), RectI(arrowOffset, arrowExtent), profile->getBitmapArrayRect((U32)iconIndex));

         // render the right arrow
         bool arrowOnR = (isRowSelected || isRowHighlighted) && (row->mWrapOptions || (row->mSelectedOption < row->mOptions.size() - 1));
         iconIndex = (arrowOnR) ? Profile::TEX_R_ARROW_ON : Profile::TEX_R_ARROW_OFF;
         arrowOffset.x = currentOffset.x + (profile->mHitAreaLowerRight.x - profile->mRightPad) * xScale - arrowExtent.x;
         arrowOffset.y = currentOffset.y + arrowOffsetY;

         drawer->clearBitmapModulation();
         drawer->drawBitmapStretchSR(profile->getBitmapResource(), RectI(arrowOffset, arrowExtent), profile->getBitmapArrayRect((U32)iconIndex));
      }

      // get the appropriate font color
      ColorI fontColor;
      if (!row->mEnabled)
      {
         fontColor = profile->mFontColorNA;
      }
      else if (isRowSelected)
      {
         fontColor = profile->mFontColorSEL;
      }
      else if (isRowHighlighted)
      {
         fontColor = profile->mFontColorHL;
      }
      else
      {
         fontColor = profile->mFontColor;
      }

      // calculate text to be at the center between the arrows
      GFont* font = profile->mFont;
      StringTableEntry text = row->mOptions[row->mSelectedOption].mDisplayText;
      S32 textWidth = font->getStrWidth(text);
      S32 columnWidth = profile->mHitAreaLowerRight.x * xScale - profile->mRightPad - columnSplit;
      S32 columnCenter = columnSplit + (columnWidth >> 1);
      S32 textStartX = columnCenter - (textWidth >> 1);
      Point2I textOffset(textStartX, 0);

      // render the option text itself
      Point2I textExtent(columnWidth, rowHeight);
      drawer->setBitmapModulation(fontColor);
      renderJustifiedText(currentOffset + textOffset, textExtent, text);
   }
}

void GuiGameListMenuCtrl::onRenderSliderOption(Row* row, Point2I currentOffset)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;

   F32 xScale = (float)getWidth() / profile->getRowWidth();

   S32 rowHeight = profile->getRowHeight();

   bool profileHasArrows = profile->hasArrows();
   Point2I arrowExtent;
   S32 arrowOffsetY(0);
   if (profileHasArrows)
   {
      arrowExtent = profile->getArrowExtent();

      // icon is centered vertically
      arrowOffsetY = (rowHeight - arrowExtent.y) >> 1;
   }

   GFXDrawUtil* drawer = GFX->getDrawUtil();

   Point2I arrowOffset;
   S32 columnSplit = profile->mColumnSplit * xScale;

   bool isRowSelected = (getSelected() != NO_ROW) && (row == mRows[getSelected()]);
   bool isRowHighlighted = (getHighlighted() != NO_ROW) ? ((row == mRows[getHighlighted()]) && (row->mEnabled)) : false;
   /*if (profileHasArrows)
   {
      // render the left arrow
      bool arrowOnL = (isRowSelected || isRowHighlighted) && (row->mValue > row->mRange.x);
      iconIndex = (arrowOnL) ? Profile::TEX_L_ARROW_ON : Profile::TEX_L_ARROW_OFF;
      arrowOffset.x = currentOffset.x + columnSplit;
      arrowOffset.y = currentOffset.y + arrowOffsetY;

      drawer->clearBitmapModulation();
      drawer->drawBitmapStretchSR(profile->mTextureObject, RectI(arrowOffset, arrowExtent), profile->getBitmapArrayRect((U32)iconIndex));

      // render the right arrow
      bool arrowOnR = (isRowSelected || isRowHighlighted) && (row->mValue < row->mRange.y);
      iconIndex = (arrowOnR) ? Profile::TEX_R_ARROW_ON : Profile::TEX_R_ARROW_OFF;
      arrowOffset.x = currentOffset.x + (profile->mHitAreaLowerRight.x - profile->mRightPad) * xScale - arrowExtent.x;
      arrowOffset.y = currentOffset.y + arrowOffsetY;

      drawer->clearBitmapModulation();
      drawer->drawBitmapStretchSR(profile->mTextureObject, RectI(arrowOffset, arrowExtent), profile->getBitmapArrayRect((U32)iconIndex));
   }*/

   //Draw the slider bar
   if (row->mEnabled)
   {
      RectI sliderRect;

      sliderRect.point.x = currentOffset.x + columnSplit + arrowExtent.x;
      sliderRect.point.y = currentOffset.y + arrowOffsetY;

      sliderRect.extent.x = (currentOffset.x + (profile->mHitAreaLowerRight.x - profile->mRightPad) * xScale - arrowExtent.x) - sliderRect.point.x;
      sliderRect.extent.y = arrowExtent.y;

      //Now adjust the bar to match-to our value

      S32 barStart = sliderRect.point.x;
      S32 barEnd = sliderRect.point.x + sliderRect.extent.x;

      S32 xPosFill = (((row->mValue - row->mRange.x) * (barEnd - barStart)) / (row->mRange.y - row->mRange.x)) + barStart;

      RectI fillRect = sliderRect;
      fillRect.extent.x = xPosFill - sliderRect.point.x;

      ColorI barColor;
      ColorI barOutlineColor;
      if (isRowSelected)
      {
         barColor = profile->mFillColor;
         barOutlineColor = profile->mFillColorSEL;
      }
      else
      {
         barColor = profile->mFillColor;
         barOutlineColor = profile->mFillColorHL;
      }

      drawer->drawRectFill(fillRect, barColor);

      drawer->drawRect(sliderRect, barOutlineColor);
   }

   // get the appropriate font color
   ColorI fontColor;
   if (!row->mEnabled)
   {
      fontColor = profile->mFontColorNA;
   }
   else if (isRowSelected)
   {
      fontColor = profile->mFontColorSEL;
   }
   else if (isRowHighlighted)
   {
      fontColor = profile->mFontColorHL;
   }
   else
   {
      fontColor = profile->mFontColor;
   }

   // calculate text to be at the center between the arrows
   GFont* font = profile->mFont;

   char stringVal[32];
   dSprintf(stringVal, 32, "%f", row->mValue);

   S32 textWidth = font->getStrWidth(stringVal);
   S32 columnWidth = profile->mHitAreaLowerRight.x * xScale - profile->mRightPad - columnSplit;
   S32 columnCenter = columnSplit + (columnWidth >> 1);
   S32 textStartX = columnCenter - (textWidth >> 1);
   Point2I textOffset(textStartX, 0);

   // render the option text itself
   Point2I textExtent(columnWidth, rowHeight);
   drawer->setBitmapModulation(fontColor);
   renderJustifiedText(currentOffset + textOffset, textExtent, stringVal);
}

void GuiGameListMenuCtrl::onRenderKeybindOption(Row* row, Point2I currentOffset)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
   F32 xScale = (float)getWidth() / profile->getRowWidth();
   S32 columnSplit = profile->mColumnSplit * xScale;

   S32 rowHeight = profile->getRowHeight();

   GFXDrawUtil* drawer = GFX->getDrawUtil();
   //drawer->drawBitmap(row->mBitmap, )

   Point2I button;
   button.x = currentOffset.x + columnSplit + (columnSplit / 2.5)/* + (optionWidth / 2)*/;
   button.y = currentOffset.y + (rowHeight / 4);

   Point2I buttonSize;
   buttonSize.x = rowHeight / 2;
   buttonSize.y = rowHeight / 2;

   if (row->mBitmapTex.isValid())
   {
      GFXTextureObject* texture = row->mBitmapTex;
      RectI rect(button, buttonSize);
      drawer->clearBitmapModulation();
      drawer->drawBitmapStretch(texture, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false);
   }

   //drawer->drawRectFill(button, ColorI::BLUE);
}

void GuiGameListMenuCtrl::onDebugRender(Point2I offset)
{
   GuiGameListMenuProfile * profile = (GuiGameListMenuProfile *) mProfile;

   F32 xScale = (float) getWidth() / profile->getRowWidth();

   ColorI controlBorderColor(200, 200, 200); // gray
   ColorI rowBorderColor(255, 127, 255); // magenta
   ColorI hitBorderColor(255, 0, 0); // red
   Point2I shrinker(-1, -1);
   Point2I extent = getExtent();

   // render a border around the entire control
   RectI borderRect(offset, extent + shrinker);
   GFX->getDrawUtil()->drawRect(borderRect, controlBorderColor);

   S32 rowHeight = profile->getRowHeight();
   Point2I currentOffset(offset);
   Point2I rowExtent(extent.x, rowHeight);
   rowExtent += shrinker;
   Point2I hitAreaExtent(profile->getHitAreaExtent());
   hitAreaExtent.x *= xScale;
   hitAreaExtent += shrinker;
   Point2I hitAreaOffset = profile->mHitAreaUpperLeft;
   hitAreaOffset.x *= xScale;
   Point2I upperLeft;
   for (Vector<Row *>::iterator row = mRows.begin(); row < mRows.end(); ++row)
   {
      // set the top of the current row
      if (row != mRows.begin())
      {
         // rows other than the first can have padding above them
         currentOffset.y += (*row)->mHeightPad;
         currentOffset.y += rowHeight;
      }

      // draw the box around the whole row's extent
      upperLeft = currentOffset;
      borderRect.point = upperLeft;
      borderRect.extent = rowExtent;
      GFX->getDrawUtil()->drawRect(borderRect, rowBorderColor);

      // draw the box around the hit area of the row
      upperLeft = currentOffset + hitAreaOffset;
      borderRect.point = upperLeft;
      borderRect.extent = hitAreaExtent;
      GFX->getDrawUtil()->drawRect(borderRect, hitBorderColor);
   }
}

void GuiGameListMenuCtrl::addRow(const char* label, const char* callback, S32 icon, S32 yPad, bool useHighlightIcon, bool enabled, S32 mode, const char* tooltip)
{
   Row * row = new Row();
   addRow(row, label, callback, icon, yPad, useHighlightIcon, enabled, mode, tooltip);
}

void GuiGameListMenuCtrl::addRow(Row * row, const char* label, const char* callback, S32 icon, S32 yPad, bool useHighlightIcon, bool enabled, S32 mode, const char* tooltip)
{
   row->mLabel = StringTable->insert(label, true);
   row->mScriptCallback = (dStrlen(callback) > 0) ? StringTable->insert(callback, true) : NULL;
   row->mIconIndex = (icon < 0) ? NO_ICON : icon;
   row->mHeightPad = yPad;
   row->mUseHighlightIcon = useHighlightIcon;
   row->mEnabled = enabled;
   row->mMode = (Row::Mode)mode;
   row->mTooltip = StringTable->insert(tooltip);

   mRows.push_back(row);

   updateHeight();

   if (mSelected == NO_ROW)
   {
      selectFirstEnabledRow();
   }
}

void GuiGameListMenuCtrl::addRow(const char* label, const char* optionsList, bool wrapOptions, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip, const char* defaultValue)
{
   static StringTableEntry DELIM = StringTable->insert("\t", true);
   Row* row = new Row();
   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;
   }
   row->mOptions = options;
   bool hasOptions = row->mOptions.size() > 0;
   row->mSelectedOption = (hasOptions) ? defaultOption : NO_OPTION;
   row->mWrapOptions = wrapOptions;
   addRow(row, label, callback, icon, yPad, true, (hasOptions) ? enabled : false, Row::Mode::OptionList, tooltip);
}

void GuiGameListMenuCtrl::addRow(const char* label, F32 defaultValue, F32 increments, Point2F range, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip)
{
   static StringTableEntry DELIM = StringTable->insert("\t", true);
   Row* row = new Row();
   row->mValue = defaultValue;
   row->mStepSize = increments;
   row->mRange = range;

   addRow(row, label, callback, icon, yPad, true, enabled, Row::Mode::Slider, tooltip);
}

void GuiGameListMenuCtrl::addRow(const char* label, const char* bitmapName, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip)
{
   static StringTableEntry DELIM = StringTable->insert("\t", true);
   Row* row = new Row();
   row->mBitmap = StringTable->insert(bitmapName);

   if(row->mBitmap != StringTable->EmptyString())
      row->mBitmapTex.set(row->mBitmap, &GFXDefaultGUIProfile, avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__));

   addRow(row, label, callback, icon, yPad, true, enabled, Row::Mode::Keybind, tooltip);
}

void GuiGameListMenuCtrl::removeRow(const S32& row)
{
   if (row == -1 || row >= mRows.size())
      return;

   mRows.erase(row);
}

Point2I  GuiGameListMenuCtrl::getMinExtent() const
{
   Point2I parentMin = Parent::getMinExtent();

   GuiGameListMenuProfile * profile = (GuiGameListMenuProfile *) mProfile;

   S32 minHeight = 0;
   S32 rowHeight = profile->getRowHeight();

   for (Vector<Row *>::const_iterator row = mRows.begin(); row < mRows.end(); ++row)
   {
      minHeight += rowHeight;
      if (row != mRows.begin())
      {
         minHeight += (*row)->mHeightPad;
      }
   }

   if (minHeight > parentMin.y)
      parentMin.y = minHeight;

   return parentMin;
}

bool GuiGameListMenuCtrl::onAdd()
{
   if( !Parent::onAdd() )
      return false;
      
   // If we have a non-GuiGameListMenuProfile profile, try to
   // substitute it for DefaultListMenuProfile.
      
   if( !hasValidProfile() )
   {
      GuiGameListMenuProfile* profile;
      if( !Sim::findObject( "DefaultListMenuProfile", profile ) )
      {
         Con::errorf( "GuiGameListMenuCtrl: %s can't be created with a profile of type %s. Please create it with a profile of type GuiGameListMenuProfile.",
            getName(), mProfile->getClassName() );
         return false;
      }
      else
         Con::warnf( "GuiGameListMenuCtrl: substituted non-GuiGameListMenuProfile in %s for DefaultListMenuProfile", getName() );
         
      setControlProfile( profile );
   }

   return true;
}

bool GuiGameListMenuCtrl::onWake()
{
   if( !Parent::onWake() )
      return false;
      
   if( !hasValidProfile() )
      return false;
      
   /*if( mRows.empty() )
   {
      Con::errorf( "GuiGameListMenuCtrl: %s can't be woken up without any rows. Please use \"addRow\" to add at least one row to the control before pushing it to the canvas.",
         getName() );
      return false;
   }*/

   enforceConstraints();

   selectFirstEnabledRow();

   setFirstResponder();

   mHighlighted = NO_ROW;

   return true;
}

bool GuiGameListMenuCtrl::hasValidProfile() const
{
   GuiGameListMenuProfile * profile = dynamic_cast<GuiGameListMenuProfile *>(mProfile);
   return profile;
}

void GuiGameListMenuCtrl::enforceConstraints()
{
   if( hasValidProfile() )
   {
      ((GuiGameListMenuProfile *)mProfile)->enforceConstraints();
   }
   updateHeight();
}

void GuiGameListMenuCtrl::updateHeight()
{
   S32 minHeight = getMinExtent().y;
   if (getHeight() < minHeight)
   {
      setHeight(minHeight);
   }
}

void GuiGameListMenuCtrl::onMouseDown(const GuiEvent &event)
{
   S32 hitRow = getRow(event.mousePoint);
   if (hitRow != NO_ROW)
   {
      S32 delta = (mSelected != NO_ROW) ? (hitRow - mSelected) : (mSelected + 1);
      changeRow(delta);
   }
}

void GuiGameListMenuCtrl::onMouseLeave(const GuiEvent &event)
{
   mHighlighted = NO_ROW;
}

void GuiGameListMenuCtrl::onMouseMove(const GuiEvent &event)
{
   S32 hitRow = getRow(event.mousePoint);
   // allow mHighligetd to be set to NO_ROW so rows can be unhighlighted
   mHighlighted = hitRow;
}

void GuiGameListMenuCtrl::onMouseUp(const GuiEvent &event)
{
   S32 hitRow = getRow(event.mousePoint);
   if ((hitRow != NO_ROW) && isRowEnabled(hitRow) && (hitRow == getSelected()))
   {
      if (mRows[hitRow]->mMode == Row::Mode::Default)
      {
         activateRow();
      }
      else if (mRows[hitRow]->mMode == Row::Mode::OptionList)
      {
         S32 xPos = globalToLocalCoord(event.mousePoint).x;
         clickOption((Row*)mRows[getSelected()], xPos);
      }
      else if (mRows[hitRow]->mMode == Row::Mode::Slider)
      {
         S32 xPos = globalToLocalCoord(event.mousePoint).x;
         clickSlider((Row*)mRows[getSelected()], xPos);
      }
      else if (mRows[hitRow]->mMode == Row::Mode::Keybind)
      {
         S32 xPos = globalToLocalCoord(event.mousePoint).x;
         clickKeybind((Row*)mRows[getSelected()], xPos);
      }
   }
}

void GuiGameListMenuCtrl::activateRow()
{
   S32 row = getSelected();
   if ((row != NO_ROW) && isRowEnabled(row) && (mRows[row]->mScriptCallback != NULL))
   {
      setThisControl();
      if (Con::isFunction(mRows[row]->mScriptCallback))
      {
         Con::executef(mRows[row]->mScriptCallback);
      }
   }
}

S32 GuiGameListMenuCtrl::getRow(Point2I globalPoint)
{
   Point2I localPoint = globalToLocalCoord(globalPoint);
   GuiGameListMenuProfile * profile = (GuiGameListMenuProfile *) mProfile;

   F32 xScale = (float) getWidth() / profile->getRowWidth();

   S32 rowHeight = profile->getRowHeight();
   Point2I currentOffset(0, 0);
   Point2I hitAreaUpperLeft = profile->mHitAreaUpperLeft;
   hitAreaUpperLeft.x *= xScale;
   Point2I hitAreaLowerRight = profile->mHitAreaLowerRight;
   hitAreaLowerRight.x *= xScale;

   Point2I upperLeft, lowerRight;
   for (Vector<Row *>::iterator row = mRows.begin(); row < mRows.end(); ++row)
   {
      if (row != mRows.begin())
      {
         // rows other than the first can have padding above them
         currentOffset.y += (*row)->mHeightPad;
      }

      upperLeft = currentOffset + hitAreaUpperLeft;
      lowerRight = currentOffset + hitAreaLowerRight;

      if ((upperLeft.x <= localPoint.x) && (localPoint.x < lowerRight.x) &&
         (upperLeft.y <= localPoint.y) && (localPoint.y < lowerRight.y))
      {
         return row - mRows.begin();
      }

      currentOffset.y += rowHeight;
   }

   return NO_ROW;
}

void GuiGameListMenuCtrl::setSelected(S32 index)
{
   if (index == NO_ROW)
   {
      // deselection
      mSelected = NO_ROW;
      return;
   }

   if (! isValidRowIndex(index))
   {
      return;
   }

   if (! isRowEnabled(index))
   {
      // row is disabled, it can't be selected
      return;
   }

   mSelected = mClamp(index, 0, mRows.size() - 1);

   //If we're childed to a scroll container, make sure us changing rows has our new position visible
   GuiScrollCtrl* scroll = dynamic_cast<GuiScrollCtrl*>(getParent());
   if (scroll)
   {
      scroll->scrollRectVisible(getRowBounds(mSelected));
   }
}

bool GuiGameListMenuCtrl::isRowEnabled(S32 index) const
{
   if (! isValidRowIndex(index))
   {
      return false;
   }

   return mRows[index]->mEnabled;
}

void GuiGameListMenuCtrl::setRowEnabled(S32 index, bool enabled)
{
   if (! isValidRowIndex(index))
   {
      return;
   }

   mRows[index]->mEnabled = enabled;

   if (getSelected() == index)
   {
      selectFirstEnabledRow();
   }
}

bool GuiGameListMenuCtrl::isValidRowIndex(S32 index) const
{
   return ((0 <= index) && (index < mRows.size()));
}

void GuiGameListMenuCtrl::selectFirstEnabledRow()
{
   setSelected(NO_ROW);
   for (Vector<Row *>::iterator row = mRows.begin(); row < mRows.end(); ++row)
   {
      if ((*row)->mEnabled)
      {
         setSelected(row - mRows.begin());
         return;
      }
   }
}

bool GuiGameListMenuCtrl::onInputEvent(const InputEventInfo& event)
{
   if (mCallbackOnInputs)
   {
      char deviceStr[32];
      if (!ActionMap::getDeviceName(event.deviceType, event.deviceInst, deviceStr))
         return false;

      String deviceString = deviceStr;

      if (event.action == SI_MAKE || event.action == SI_BREAK)
      {
         bool isModifier = false;

         bool state = event.action == SI_MAKE;

         switch (event.objInst)
         {
            case KEY_LCONTROL:
            case KEY_RCONTROL:
            case KEY_LALT:
            case KEY_RALT:
            case KEY_LSHIFT:
            case KEY_RSHIFT:
            case KEY_MAC_LOPT:
            case KEY_MAC_ROPT:
               isModifier = true;
         }

         if ((event.objType == SI_KEY) && isModifier)
         {
            char keyString[32];
            if (!ActionMap::getKeyString(event.objInst, keyString))
               return false;

            onInputEvent_callback(deviceString.c_str(), keyString, state);

            if (mConsumeKeyInputEvents)
            {
               if(deviceString.startsWith("keyboard"))
                  return true;
            }
         }
         else
         {
            const char* actionString = ActionMap::buildActionString(&event);
            onInputEvent_callback(deviceString.c_str(), actionString, state);

            if (mConsumeKeyInputEvents)
            {
               if (deviceString.startsWith("keyboard") || deviceString.startsWith("gamepad"))
                  return true;
            }
         }
      }
      else if (event.objType == SI_AXIS || event.objType == SI_INT || event.objType == SI_FLOAT)
      {
         F32 fValue = event.fValue;
         if (event.objType == SI_INT)
            fValue = (F32)event.iValue;

         if (!ActionMap::getDeviceName(event.deviceType, event.deviceInst, deviceStr))
            return false;

         const char* actionString = ActionMap::buildActionString(&event);

         onAxisEvent_callback(deviceStr, actionString, fValue);
      }
   }

   return false;
}

bool GuiGameListMenuCtrl::onKeyDown(const GuiEvent &event)
{
   switch (event.keyCode)
   {
      case KEY_UP:
         changeRow(-1);
         return true;

      case KEY_DOWN:
         changeRow(1);
         return true;

      case KEY_LEFT:
         changeOption(-1);
         return true;

      case KEY_RIGHT:
         changeOption(1);
         return true;

      case KEY_A:
      case KEY_RETURN:
      case KEY_NUMPADENTER:
      case KEY_SPACE:
      case XI_A:
      case XI_START:
         doScriptCommand(mCallbackOnA);
         return true;

      case KEY_B:
      case KEY_ESCAPE:
      case KEY_BACKSPACE:
      case KEY_DELETE:
      case XI_B:
      case XI_BACK:
         doScriptCommand(mCallbackOnB);
         return true;

      case KEY_X:
      case XI_X:
         doScriptCommand(mCallbackOnX);
         return true;

      case KEY_Y:
      case XI_Y:
         doScriptCommand(mCallbackOnY);
         return true;
      default:
         break;
   }

   return Parent::onKeyDown(event);
}

bool GuiGameListMenuCtrl::onGamepadAxisUp(const GuiEvent &event)
{
   changeRow(-1);
   return true;
}

bool GuiGameListMenuCtrl::onGamepadAxisDown(const GuiEvent &event)
{
   changeRow(1);
   return true;
}

bool GuiGameListMenuCtrl::onGamepadAxisLeft(const GuiEvent& event)
{
   changeOption(-1);
   return true;
}

bool GuiGameListMenuCtrl::onGamepadAxisRight(const GuiEvent& event)
{
   changeOption(1);
   return true;
}

void GuiGameListMenuCtrl::doScriptCommand(StringTableEntry command)
{
   if (command && command[0])
   {
      setThisControl();
      Con::evaluate(command, false, __FILE__);
   }
}

void GuiGameListMenuCtrl::changeRow(S32 delta)
{
   S32 oldRowIndex = getSelected();
   S32 newRowIndex = oldRowIndex;
   do
   {
      newRowIndex += delta;
      if (newRowIndex >= mRows.size())
      {
         newRowIndex = 0;
      }
      else if (newRowIndex < 0)
      {
         newRowIndex = mRows.size() - 1;
      }
   }
   while ((! mRows[newRowIndex]->mEnabled) && (newRowIndex != oldRowIndex));

   setSelected(newRowIndex);

   // do the callback
   onChange_callback();
}

void GuiGameListMenuCtrl::setThisControl()
{
   smThisControl = this;
}

StringTableEntry GuiGameListMenuCtrl::getRowLabel(S32 rowIndex) const
{
   if (! isValidRowIndex(rowIndex))
   {
      // not a valid row index, don't do anything
      return StringTable->EmptyString();
   }
   return mRows[rowIndex]->mLabel;
}

void GuiGameListMenuCtrl::setRowLabel(S32 rowIndex, const char * label)
{
   if (! isValidRowIndex(rowIndex))
   {
      // not a valid row index, don't do anything
      return;
   }

   mRows[rowIndex]->mLabel = StringTable->insert(label, true);
}

void GuiGameListMenuCtrl::clearRows()
{
   for (U32 i = 0; i < mRows.size(); i++)
   {
      if (mRows[i]->mBitmap != StringTable->EmptyString())
         mRows[i]->mBitmapTex = nullptr;
   }

   mRows.clear();
   setSelected(-1);
   setHeight(mMinExtent.y);
}

void GuiGameListMenuCtrl::refresh()
{
   enforceConstraints();
}

RectI GuiGameListMenuCtrl::getRowBounds(S32 rowIndex)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;

   S32 rowHeight = profile->getRowHeight();

   Point2I currentOffset = Point2I::Zero;
   Point2I extent = getExtent();
   Point2I rowExtent(extent.x, rowHeight);

   for (U32 i = 1; i <= rowIndex; i++)
   {
      //the top row can't pad, so we'll ignore it
      GuiGameListMenuCtrl::Row* row = mRows[i];

      // rows other than the first can have padding above them
      currentOffset.y += row->mHeightPad;
      currentOffset.y += rowHeight;
   }

   return RectI(currentOffset, rowExtent);
}
//-----------------------------------------------------------------------------
// Console stuff (GuiGameListMenuCtrl)
//-----------------------------------------------------------------------------

StringTableEntry GuiGameListMenuCtrl::getCurrentOption(S32 rowIndex) const
{
   if (isValidRowIndex(rowIndex))
   {
      Row* row = (Row*)mRows[rowIndex];
      if (row->mSelectedOption != NO_OPTION)
      {
         return row->mOptions[row->mSelectedOption].mDisplayText;
      }
   }
   return StringTable->insert("", false);
}

StringTableEntry GuiGameListMenuCtrl::getCurrentOptionKey(S32 rowIndex) const
{
   if (isValidRowIndex(rowIndex))
   {
      Row* row = (Row*)mRows[rowIndex];
      if (row->mSelectedOption != NO_OPTION)
      {
         return row->mOptions[row->mSelectedOption].mKeyString;
      }
   }
   return StringTable->insert("", false);
}

S32 GuiGameListMenuCtrl::getCurrentOptionIndex(S32 rowIndex) const
{
   if (isValidRowIndex(rowIndex))
   {
      Row* row = (Row*)mRows[rowIndex];
      if (row->mSelectedOption != NO_OPTION)
      {
         return row->mSelectedOption;
      }
   }
   return S32(-1);
}

bool GuiGameListMenuCtrl::selectOption(S32 rowIndex, const char* theOption)
{
   if (!isValidRowIndex(rowIndex))
   {
      return false;
   }

   Row* row = (Row*)mRows[rowIndex];

   for (Vector<OptionEntry>::iterator anOption = row->mOptions.begin(); anOption < row->mOptions.end(); ++anOption)
   {
      if (String::compare((*anOption).mDisplayText, theOption) == 0)
      {
         S32 newIndex = anOption - row->mOptions.begin();
         row->mSelectedOption = newIndex;
         return true;
      }
   }

   return false;
}

bool GuiGameListMenuCtrl::selectOptionByKey(S32 rowIndex, const char* optionKey)
{
   if (!isValidRowIndex(rowIndex))
   {
      return false;
   }

   Row* row = (Row*)mRows[rowIndex];

   for (Vector<OptionEntry>::iterator anOption = row->mOptions.begin(); anOption < row->mOptions.end(); ++anOption)
   {
      if (String::compare((*anOption).mKeyString, optionKey) == 0)
      {
         S32 newIndex = anOption - row->mOptions.begin();
         row->mSelectedOption = newIndex;
         return true;
      }
   }

   return false;
}

bool GuiGameListMenuCtrl::selectOptionByIndex(S32 rowIndex, S32 optionIndex)
{
   if (!isValidRowIndex(rowIndex) || (optionIndex < 0))
   {
      return false;
   }

   Row* row = (Row*)mRows[rowIndex];
   if (optionIndex < row->mOptions.size())
   {
      row->mSelectedOption = optionIndex;
      return true;
   }

   return false;
}

void GuiGameListMenuCtrl::setOptions(S32 rowIndex, const char* optionsList)
{
   static StringTableEntry DELIM = StringTable->insert("\t", true);

   if (!isValidRowIndex(rowIndex))
   {
      return;
   }

   Row* row = (Row*)mRows[rowIndex];

   S32 count = StringUnit::getUnitCount(optionsList, DELIM);
   row->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;
      row->mOptions[i] = e;
   }

   if (row->mSelectedOption >= row->mOptions.size())
   {
      row->mSelectedOption = row->mOptions.size() - 1;
   }
}

void GuiGameListMenuCtrl::addOption(S32 rowIndex, const char* displayText, const char* keyText)
{
   if (!isValidRowIndex(rowIndex))
   {
      return;
   }

   OptionEntry e;
   e.mDisplayText = StringTable->insert(displayText, true);
   e.mKeyString = (keyText[0] == '\0') ? e.mDisplayText : StringTable->insert(keyText, true);

   Row* row = (Row*)mRows[rowIndex];
   row->mOptions.push_back(e);
}

void GuiGameListMenuCtrl::clickOption(Row* row, S32 xPos)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
   if (!profile->hasArrows())
   {
      return;
   }

   F32 xScale = (float)getWidth() / profile->getRowWidth();

   S32 bitmapArrowWidth = mProfile->getBitmapArrayRect(Profile::TEX_FIRST_ARROW).extent.x;

   S32 leftArrowX1 = profile->mColumnSplit * xScale;
   S32 leftArrowX2 = leftArrowX1 + bitmapArrowWidth;

   S32 rightArrowX2 = (profile->mHitAreaLowerRight.x - profile->mRightPad) * xScale;
   S32 rightArrowX1 = rightArrowX2 - bitmapArrowWidth;

   if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
   {
      changeOption(row, -1);
   }
   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
   {
      changeOption(row, 1);
   }
}

void GuiGameListMenuCtrl::changeOption(S32 delta)
{
   if (getSelected() != NO_ROW)
   {
      Row* row = (Row*)mRows[getSelected()];
      changeOption(row, delta);
   }
}

void GuiGameListMenuCtrl::changeOption(Row* row, S32 delta)
{
   S32 optionCount = row->mOptions.size();

   S32 newSelection = row->mSelectedOption + delta;
   if (optionCount == 0)
   {
      newSelection = NO_OPTION;
   }
   else if (!row->mWrapOptions)
   {
      newSelection = mClamp(newSelection, 0, optionCount - 1);
   }
   else if (newSelection < 0)
   {
      newSelection = optionCount - 1;
   }
   else if (newSelection >= optionCount)
   {
      newSelection = 0;
   }
   row->mSelectedOption = newSelection;

   if (row->mMode == GuiGameListMenuCtrl::Row::Slider)
   {
      row->mValue += row->mStepSize * delta;

      row->mValue = mRound(row->mValue / row->mStepSize) * row->mStepSize;

      if (row->mValue < row->mRange.x)
         row->mValue = row->mRange.x;
      if (row->mValue > row->mRange.y)
         row->mValue = row->mRange.y;
   }

   static StringTableEntry LEFT = StringTable->insert("LEFT", true);
   static StringTableEntry RIGHT = StringTable->insert("RIGHT", true);

   if (row->mScriptCallback != NULL && (row->mSelectedOption != NO_OPTION && row->mMode != GuiGameListMenuCtrl::Row::Slider))
   {
      setThisControl();
      StringTableEntry direction = NULL;
      if (delta < 0)
      {
         direction = LEFT;
      }
      else if (delta > 0)
      {
         direction = RIGHT;
      }
      if ((direction != NULL) && (Con::isFunction(row->mScriptCallback)))
      {
         Con::executef(row->mScriptCallback, direction);
      }
   }
}
IMPLEMENT_CONOBJECT(GuiGameListMenuCtrl);

void GuiGameListMenuCtrl::clickSlider(Row* row, S32 xPos)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
   if (!profile->hasArrows())
   {
      return;
   }

   F32 xScale = (float)getWidth() / profile->getRowWidth();

   S32 bitmapArrowWidth = mProfile->getBitmapArrayRect(Profile::TEX_FIRST_ARROW).extent.x;

   S32 leftArrowX1 = profile->mColumnSplit * xScale;
   S32 leftArrowX2 = leftArrowX1 + bitmapArrowWidth;

   S32 rightArrowX2 = (profile->mHitAreaLowerRight.x - profile->mRightPad) * xScale;
   S32 rightArrowX1 = rightArrowX2 - bitmapArrowWidth;

   if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
   {
      row->mValue -= row->mStepSize;

      row->mValue = mRound(row->mValue / row->mStepSize) * row->mStepSize;

      if (row->mValue < row->mRange.x)
         row->mValue = row->mRange.x;

   }
   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
   {
      //F32 snap = row->mValue % row->mStepSize;
      //row->mValue.y -= snap;

      row->mValue += row->mStepSize;

      row->mValue = mRound(row->mValue / row->mStepSize) * row->mStepSize;

      if (row->mValue > row->mRange.y)
         row->mValue = row->mRange.y;
   }
   else
   {
      //see if we clicked on the sliderbar itself
      S32 barStart = leftArrowX2;
      S32 barEnd = rightArrowX1;

      if (xPos >= barStart && xPos <= barEnd)
      {
         //find the position
         F32 newValue = (((xPos - barStart) * (row->mRange.y - row->mRange.x)) / (barEnd - barStart)) + row->mRange.x;

         newValue = mRound(newValue / row->mStepSize) * row->mStepSize;

         row->mValue = newValue;
      }
   }
}

void GuiGameListMenuCtrl::clickKeybind(Row* row, S32 xPos)
{
   GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
   F32 xScale = (float)getWidth() / profile->getRowWidth();
   S32 columnSplit = profile->mColumnSplit * xScale;

   S32 rowHeight = profile->getRowHeight();

   //drawer->drawBitmap(row->mBitmap, )

   Point2I button;
   button.x = columnSplit + (columnSplit / 2)/* + (optionWidth / 2)*/;
   button.y = rowHeight / 4;

   Point2I buttonSize;
   buttonSize.x = rowHeight / 2;
   buttonSize.y = rowHeight / 2;

   RectI rect(button, buttonSize);

   if (rect.pointInRect(Point2I(xPos, rowHeight / 2)))
   {
      if (row->mScriptCallback != StringTable->EmptyString())
      {
         S32 rowId = getSelected();
         Con::executef(row->mScriptCallback, rowId);
      }
   }
}

F32 GuiGameListMenuCtrl::getValue(S32 rowIndex)
{
   if (!isValidRowIndex(rowIndex))
   {
      return 0;
   }

   Row* row = (Row*)mRows[rowIndex];

   return row->mValue;
}

void GuiGameListMenuCtrl::setValue(S32 rowIndex, F32 value)
{
   if (!isValidRowIndex(rowIndex))
   {
      return;
   }

   Row* row = (Row*)mRows[rowIndex];

   row->mValue = value;
}

const char* GuiGameListMenuCtrl::getTooltip(S32 rowIndex)
{
   if (!isValidRowIndex(rowIndex))
   {
      return "";
   }

   Row* row = (Row*)mRows[rowIndex];

   return row->mTooltip;
}

ConsoleDocClass( GuiGameListMenuCtrl,
   "@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 GuiGameListMenuCtrl()\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 GuiGameListMenuProfile\n\n"

   "@ingroup GuiGame"
);

IMPLEMENT_CALLBACK( GuiGameListMenuCtrl, onChange, void, (), (),
   "Called when the selected row changes." );

IMPLEMENT_CALLBACK(GuiGameListMenuCtrl, 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(GuiGameListMenuCtrl, 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 GuiGameListMenuCtrl::initPersistFields()
{
   addField("debugRender", TypeBool, Offset(mDebugRender, GuiGameListMenuCtrl),
      "Enable debug rendering" );

   addField("callbackOnA", TypeString, Offset(mCallbackOnA, GuiGameListMenuCtrl),
      "Script callback when the 'A' button is pressed. 'A' inputs are Keyboard: A, Return, Space; Gamepad: A, Start" );

   addField("callbackOnB", TypeString, Offset(mCallbackOnB, GuiGameListMenuCtrl),
      "Script callback when the 'B' button is pressed. 'B' inputs are Keyboard: B, Esc, Backspace, Delete; Gamepad: B, Back" );

   addField("callbackOnX", TypeString, Offset(mCallbackOnX, GuiGameListMenuCtrl),
      "Script callback when the 'X' button is pressed. 'X' inputs are Keyboard: X; Gamepad: X" );

   addField("callbackOnY", TypeString, Offset(mCallbackOnY, GuiGameListMenuCtrl),
      "Script callback when the 'Y' button is pressed. 'Y' inputs are Keyboard: Y; Gamepad: Y" );

   addField("callbackOnInputs", TypeBool, Offset(mCallbackOnInputs, GuiGameListMenuCtrl),
      "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, GuiGameListMenuCtrl),
      "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( GuiGameListMenuCtrl, addRow, void,
   ( const char* label, const char* callback, S32 icon, S32 yPad, bool useHighlightIcon, bool enabled, int mode ),
   ( -1, 0, true, true, 0 ),
   "Add a row to the list control.\n\n"
   "@param label The text to display on the row as a label.\n"
   "@param callback Name of a script function to use as a callback when this row is activated.\n"
   "@param icon [optional] Index of the icon to use as a marker.\n"
   "@param yPad [optional] An extra amount of height padding before the row. Does nothing on the first row.\n"
   "@param useHighlightIcon [optional] Does this row use the highlight icon?.\n"
   "@param enabled [optional] If this row is initially enabled.\n"
   "@param mode [optional] What option mode the row is in. 0 = Default, 1 = OptionList, 2 == Keybind")
{
   object->addRow( label, callback, icon, yPad, useHighlightIcon, enabled, mode);
}

DefineEngineMethod( GuiGameListMenuCtrl, isRowEnabled, bool, ( S32 row ),,
   "Determines if the specified row is enabled or disabled.\n\n"
   "@param row The row to set the enabled status of.\n"
   "@return True if the specified row is enabled. False if the row is not enabled or the given index was not valid." )
{
   return object->isRowEnabled( row );
}

DefineEngineMethod( GuiGameListMenuCtrl, setRowEnabled, void, ( S32 row, bool enabled ),,
   "Sets a row's enabled status according to the given parameters.\n\n"
   "@param row The index to check for validity.\n"
   "@param enabled Indicate true to enable the row or false to disable it." )
{
   object->setRowEnabled( row, enabled );
}

DefineEngineMethod( GuiGameListMenuCtrl, activateRow, void, (),,
   "Activates the current row. The script callback of  the current row will be called (if it has one)." )
{
   object->activateRow();
}

DefineEngineMethod( GuiGameListMenuCtrl, getRowCount, S32, (),,
   "Gets the number of rows on the control.\n\n"
   "@return (int) The number of rows on the control." )
{
   return object->getRowCount();
}

DefineEngineMethod( GuiGameListMenuCtrl, getRowLabel, const char *, ( S32 row ),,
   "Gets the label displayed on the specified row.\n\n"
   "@param row Index of the row to get the label of.\n"
   "@return The label for the row." )
{
   return object->getRowLabel( row );
}

DefineEngineMethod( GuiGameListMenuCtrl, setRowLabel, void, ( S32 row, const char* label ),,
   "Sets the label on the given row.\n\n"
   "@param row Index of the row to set the label on.\n"
   "@param label Text to set as the label of the row.\n" )
{
   object->setRowLabel( row, label );
}

DefineEngineMethod( GuiGameListMenuCtrl, setSelected, void, ( S32 row ),,
   "Sets the selected row. Only rows that are enabled can be selected.\n\n"
   "@param row Index of the row to set as selected." )
{
   object->setSelected( row );
}

DefineEngineMethod( GuiGameListMenuCtrl, getSelectedRow, S32, (),,
   "Gets the index of the currently selected row.\n\n"
   "@return Index of the selected row." )
{
   return object->getSelected();
}

DefineEngineMethod(GuiGameListMenuCtrl, clearRows, void, (), ,
   "Gets the index of the currently selected row.\n\n"
   "@return Index of the selected row.")
{
   return object->clearRows();
}

DefineEngineMethod(GuiGameListMenuCtrl, refresh, void, (), ,
   "Gets the index of the currently selected row.\n\n"
   "@return Index of the selected row.")
{
   return object->refresh();
}

DefineEngineMethod(GuiGameListMenuCtrl, addOptionRow, void,
   (const char* label, const char* options, bool wrapOptions, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip, const char* defaultValue),
   (-1, 0, true, "", ""),
   "Add a row to the list control.\n\n"
   "@param label The text to display on the row 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 row is activated.\n"
   "@param icon [optional] Index of the icon to use as a marker.\n"
   "@param yPad [optional] An extra amount of height padding before the row. Does nothing on the first row.\n"
   "@param enabled [optional] If this row is initially enabled.")
{
   object->addRow(label, options, wrapOptions, callback, icon, yPad, enabled, tooltip, defaultValue);
}

DefineEngineMethod(GuiGameListMenuCtrl, addSliderRow, void,
(const char* label, F32 defaultValue, F32 increment, Point2F range, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip),
(-1, 0, true, ""),
"Add a row to the list control.\n\n"
"@param label The text to display on the row 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 row is activated.\n"
"@param icon [optional] Index of the icon to use as a marker.\n"
"@param yPad [optional] An extra amount of height padding before the row. Does nothing on the first row.\n"
"@param enabled [optional] If this row is initially enabled.")
{
   object->addRow(label, defaultValue, increment, range, callback, icon, yPad, enabled, tooltip);
}

DefineEngineMethod(GuiGameListMenuCtrl, addKeybindRow, void,
(const char* label, const char* bitmapName, const char* callback, S32 icon, S32 yPad, bool enabled, const char* tooltip),
(-1, 0, true, ""),
"Add a row to the list control.\n\n"
"@param label The text to display on the row 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 row is activated.\n"
"@param icon [optional] Index of the icon to use as a marker.\n"
"@param yPad [optional] An extra amount of height padding before the row. Does nothing on the first row.\n"
"@param enabled [optional] If this row is initially enabled.")
{
   object->addRow(label, bitmapName, callback, icon, yPad, enabled, tooltip);
}

DefineEngineMethod(GuiGameListMenuCtrl, removeRow, void, (S32 row),,
   "Removes the row at the provided index")
{
   object->removeRow(row);
}

DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOption, const char*, (S32 row), ,
   "Gets the text for the currently selected option of the given row.\n\n"
   "@param row Index of the row to get the option from.\n"
   "@return A string representing the text currently displayed as the selected option on the given row. If there is no such displayed text then the empty string is returned.")
{
   return object->getCurrentOption(row);
}

DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOptionKey, const char*, (S32 row), ,
   "Gets the key string for the currently selected option of the given row.\n\n"
   "@param row Index of the row to get the option from.\n"
   "@return The key (or id) that was assigned to the selected option on the given row. If there is no selected option then the empty string is returned.")
{
   return object->getCurrentOptionKey(row);
}

DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOptionIndex, S32, (S32 row), ,
   "Gets the index into the option list for the currently selected option of the given row.\n\n"
   "@param row Index of the row to get the option from.\n"
   "@return The index of the selected option on the given row. If there is no selected option then -1 is returned.")
{
   return object->getCurrentOptionIndex(row);
}

DefineEngineMethod(GuiGameListMenuCtrl, selectOption, bool, (S32 row, const char* option), ,
   "Set the row's current option to the one specified\n\n"
   "@param row Index of the row to set an option on.\n"
   "@param option The option to be made active.\n"
   "@return True if the row contained the option and was set, false otherwise.")
{
   return object->selectOption(row, option);
}

DefineEngineMethod(GuiGameListMenuCtrl, selectOptionByKey, bool, (S32 row, const char* optionKey), ,
   "Set the row's current option to the one with the specified key.\n\n"
   "@param row Index of the row to set an option on.\n"
   "@param optionKey The key string that was assigned to the option to be made active.\n"
   "@return True if the row contained the key and the option and was set, false otherwise.")
{
   return object->selectOptionByKey(row, optionKey);
}

DefineEngineMethod(GuiGameListMenuCtrl, selectOptionByIndex, bool, (S32 row, S32 optionIndex), ,
   "Set the row's current option to the one at the specified index.\n\n"
   "@param row Index of the row to set an option on.\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(row, optionIndex);
}

DefineEngineMethod(GuiGameListMenuCtrl, setOptions, void, (S32 row, const char* optionsList), ,
   "Sets the list of options on the given row.\n\n"
   "@param row Index of the row to set options on."
   "@param optionsList A tab separated list of options for the control.")
{
   object->setOptions(row, optionsList);
}

DefineEngineMethod(GuiGameListMenuCtrl, addOption, void, (S32 row, const char* displayText, const char* keyText), (""),
   "Adds an option to the list of options on the given row.\n\n"
   "@param row Index of the row to add the option on.\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(row, displayText, keyText);
}

DefineEngineMethod(GuiGameListMenuCtrl, getValue, F32, (S32 row), ,
   "Sets the list of options on the given row.\n\n"
   "@param row Index of the row to set options on."
   "@param optionsList A tab separated list of options for the control.")
{
   return object->getValue(row);
}

DefineEngineMethod(GuiGameListMenuCtrl, setValue, void, (S32 row, F32 value), ,
   "Sets the list of options on the given row.\n\n"
   "@param row Index of the row to set options on."
   "@param optionsList A tab separated list of options for the control.")
{
   object->setValue(row, value);
}

DefineEngineMethod(GuiGameListMenuCtrl, getTooltip, const char*, (S32 row), ,
   "Sets the list of options on the given row.\n\n"
   "@param row Index of the row to set options on."
   "@param optionsList A tab separated list of options for the control.")
{
   return object->getTooltip(row);
}

//-----------------------------------------------------------------------------
// GuiGameListMenuProfile
//-----------------------------------------------------------------------------

GuiGameListMenuProfile::GuiGameListMenuProfile()
   : mHitAreaUpperLeft(0, 0),
   mHitAreaLowerRight(0, 0),
   mIconOffset(0, 0),
   mRowSize(0, 0),
   mRowScale(1.0f, 1.0f),
   mColumnSplit(0),
   mRightPad(0)
{
}

bool GuiGameListMenuProfile::onAdd()
{
   if (! Parent::onAdd())
   {
      return false;
   }

   // We can't call enforceConstraints() here because incRefCount initializes
   // some of the things to enforce. Do a basic sanity check here instead.
   if(mBitmapAsset.isNull())
   {
      Con::errorf( "GuiGameListMenuProfile: %s can't be created without a bitmap. Please add a 'Bitmap' property to the object definition.", getName() );
      return false;
   }
   
   if( mRowSize.x < 0 )
   {
      Con::errorf( "GuiGameListMenuProfile: %s can't have a negative row width. Please change the row width to be non-negative.", getName() );
      return false;
   }
   
   if( mRowSize.y < 0 )
   {
      Con::errorf( "GuiGameListMenuProfile: %s can't have a negative row height. Please change the row height to be non-negative.", getName() );
      return false;
   }

   return true;
}

void GuiGameListMenuProfile::enforceConstraints()
{
   if( getBitmapArrayRect(0).extent.isZero() )
      Con::errorf( "GuiGameListMenuCtrl: %s can't be created without a bitmap. Please add a bitmap to the profile's definition.", getName() );

   if( mRowSize.x < 0 )
      Con::errorf( "GuiGameListMenuProfile: %s can't have a negative row width. Please change the row width to be non-negative.", getName() );
   mRowSize.x = getMax(mRowSize.x, 0);

   if( mRowSize.y < 0 )
      Con::errorf( "GuiGameListMenuProfile: %s can't have a negative row height. Please change the row height to be non-negative.", getName() );
   mRowSize.y = getMax(mRowSize.y, 0);

   Point2I rowTexExtent = getBitmapArrayRect(TEX_NORMAL).extent;
   mRowScale.x = (float) getRowWidth() / rowTexExtent.x;
   mRowScale.y = (float) getRowHeight() / rowTexExtent.y;

   if (mHitAreaUpperLeft.x > mColumnSplit || mColumnSplit > mHitAreaLowerRight.x)
      Con::errorf("GuiGameListOptionsProfile: You can't create %s with a ColumnSplit outside the hit area. You set the split to %d. Please change the ColumnSplit to be in the range [%d, %d].",
         getName(), mColumnSplit, mHitAreaUpperLeft.x, mHitAreaLowerRight.x);

   mColumnSplit = mClamp(mColumnSplit, mHitAreaUpperLeft.x, mHitAreaLowerRight.x);
}

Point2I GuiGameListMenuProfile::getIconExtent()
{
   Point2I iconExtent = getBitmapArrayRect(TEX_FIRST_ICON).extent;

   // scale both by y to keep the aspect ratio
   iconExtent.x *= mRowScale.y;
   iconExtent.y *= mRowScale.y;

   return iconExtent;
}

Point2I GuiGameListMenuProfile::getArrowExtent()
{
   Point2I arrowExtent = getBitmapArrayRect(TEX_FIRST_ARROW).extent;

   // scale both by y to keep the aspect ratio
   arrowExtent.x *= mRowScale.y;
   arrowExtent.y *= mRowScale.y;

   return arrowExtent;
}

Point2I GuiGameListMenuProfile::getHitAreaExtent()
{
   if (mHitAreaLowerRight == mHitAreaUpperLeft)
   {
      return mRowSize;
   }
   else
   {
      return mHitAreaLowerRight - mHitAreaUpperLeft;
   }
}

//-----------------------------------------------------------------------------
// Console stuff (GuiGameListMenuProfile)
//-----------------------------------------------------------------------------

IMPLEMENT_CONOBJECT(GuiGameListMenuProfile);

ConsoleDocClass( GuiGameListMenuProfile,
   "@brief A GuiControlProfile with additional fields specific to GuiGameListMenuCtrl.\n\n"

   "@tsexample\n"
   "new GuiGameListMenuProfile()\n"
   "{\n"
   "   hitAreaUpperLeft = \"10 2\";\n"
   "   hitAreaLowerRight = \"190 18\";\n"
   "   iconOffset = \"10 2\";\n"
   "   rowSize = \"200 20\";\n"
   "   columnSplit = \"100\";\n"
   "   rightPad = \"4\";\n"
   "   //Properties not specific to this control have been omitted from this example.\n"
   "};\n"
   "@endtsexample\n\n"

   "@ingroup GuiGame"
);

void GuiGameListMenuProfile::initPersistFields()
{
   addField( "hitAreaUpperLeft", TypePoint2I, Offset(mHitAreaUpperLeft, GuiGameListMenuProfile),
      "Position of the upper left corner of the row hit area (relative to row's top left corner)" );

   addField( "hitAreaLowerRight", TypePoint2I, Offset(mHitAreaLowerRight, GuiGameListMenuProfile),
      "Position of the lower right corner of the row hit area (relative to row's top left corner)" );

   addField( "iconOffset", TypePoint2I, Offset(mIconOffset, GuiGameListMenuProfile),
      "Offset from the row's top left corner at which to render the row icon" );

   addField( "rowSize", TypePoint2I, Offset(mRowSize, GuiGameListMenuProfile),
      "The base size (\"width height\") of a row" );

   addField("columnSplit", TypeS32, Offset(mColumnSplit, GuiGameListMenuProfile),
      "Padding between the leftmost edge of the control, and the row's left arrow.");

   addField("rightPad", TypeS32, Offset(mRightPad, GuiGameListMenuProfile),
      "Padding between the rightmost edge of the control and the row's right arrow.");

   Parent::initPersistFields();

   removeField("tab");
   removeField("mouseOverSelected");

   removeField("modal");
   removeField("opaque");
   removeField("border");
   removeField("borderThickness");
   removeField("borderColor");
   removeField("borderColorHL");
   removeField("borderColorNA");

   removeField("bevelColorHL");
   removeField("bevelColorLL");

   removeField("fontColorLink");
   removeField("fontColorLinkHL");

   removeField("justify");
   removeField("returnTab");
   removeField("numbersOnly");
   removeField("cursorColor");

   removeField("profileForChildren");
}