option.cpp

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#include <sstream>

#include "utils.h"

#include "option.h"
#include "video.h"

using namespace std;

using namespace hoa_utils;
using namespace hoa_video::private_video;

namespace hoa_video {

OptionBox::OptionBox() {
  _option_xalign = VIDEO_X_LEFT;
  _option_yalign = VIDEO_Y_TOP;
  _selection_mode = VIDEO_SELECT_SINGLE;
  _switching = false;
  _horizontal_wrap_mode = VIDEO_WRAP_MODE_NONE;
  _vertical_wrap_mode = VIDEO_WRAP_MODE_NONE;
  _cursor_state = VIDEO_CURSOR_STATE_VISIBLE;
  _event = 0;
  _selection = -1;
  _first_selection = -1;
  _number_options = 0;
  _scrolling = 0;
  _scroll_offset = 0;
  _blink_time = 0;
  _scroll_time = 0;
  _blink = false;
  _cursor_xoffset = 0.0f;
  _cursor_yoffset = 0.0f;
  _horizontal_spacing = _vertical_spacing = 0.0f;
  _number_rows = _number_columns = 0;
  _initialized = IsInitialized(_initialization_errors);
  _TEMP_overide_scissorring = false;
}



OptionBox::~OptionBox() {
  ClearOptions();
}



void OptionBox::Update(uint32 frame_time) {
  _event = 0; // Clear all events

  _blink = ((_blink_time / VIDEO_CURSOR_BLINK_RATE) % 2) == 1;
  _blink_time += frame_time;

  if (_scrolling) {
    _scroll_time += frame_time;

    if (_scroll_time > VIDEO_OPTION_SCROLL_TIME) {
      _scroll_time = 0;
      _scrolling = false;
    }
  }
}



void OptionBox::Draw() {
  // Do nothing if the option box is not properly initialized
  if (_initialized == false) {
    return;
  }

  VideoManager->_PushContext();
  VideoManager->SetDrawFlags(_xalign, _yalign, VIDEO_BLEND, 0);

  // (1) Determine the edge dimensions of the option box
  float left, right, bottom, top;
  left = 0.0f;
  right = _number_columns * _horizontal_spacing;
  bottom = 0.0f;
  top = _number_rows * _vertical_spacing;

  CalculateAlignedRect(left, right, bottom, top);

  int32 x, y, w, h;

  x = static_cast<int32>(left < right ? left : right);
  y = static_cast<int32>(top < bottom ? top : bottom);
  w = static_cast<int32>(right - left);
  if (w < 0)
    w = -w;
  h = static_cast<int32>(top - bottom);
  if (h < 0)
    h = -h;

  ScreenRect rect(x, y, w, h);

  int32 cursor_margin = static_cast<int32>(VideoManager->GetDefaultCursor()->GetWidth() + 1 - _cursor_xoffset);
  rect.left -= cursor_margin;
  rect.width += cursor_margin;


  // TEMP: Code to make the inventory look good for now until scissoring can be fixed correctly
  // Used to set the scissoring back to what it was before
  bool scissoring_rollback = VideoManager->IsScissoringEnabled();
  if (_TEMP_overide_scissorring) {
    rect.top += 71;
    rect.height += 10;
    rect.Intersect(VideoManager->GetScissorRect());
    VideoManager->EnableScissoring(true);
    VideoManager->SetScissorRect(rect);
  }
  else {
    if (_owner && VideoManager->IsScissoringEnabled() ) {
      rect.Intersect(_owner->GetScissorRect());
      rect.Intersect(VideoManager->GetScissorRect());
      VideoManager->EnableScissoring(true);
      VideoManager->SetScissorRect(rect);
    }
  }

  CoordSys &cs = VideoManager->_coord_sys;
  VideoManager->SetFont(_font);
  VideoManager->SetDrawFlags(_option_xalign, _option_yalign, VIDEO_X_NOFLIP, VIDEO_Y_NOFLIP, VIDEO_BLEND, 0);

  int32 row_min, row_max;
  float cell_offset = 0.0f;

  if (!_scrolling) {
    row_min = _scroll_offset;
    row_max = _scroll_offset + _number_rows;
  }
  else if (_scroll_direction == -1) { // Scrolling up
    row_min = _scroll_offset;
    row_max = _scroll_offset + _number_rows + 1;

    cell_offset = cs.GetVerticalDirection() * (1.0f - (_scroll_time / (VIDEO_OPTION_SCROLL_TIME))) * _vertical_spacing;
  }
  else { // Scrolling down
    row_min = _scroll_offset - 1;
    row_max = _scroll_offset + _number_rows;
    cell_offset = cs.GetVerticalDirection() * ((_scroll_time / (VIDEO_OPTION_SCROLL_TIME))) * _vertical_spacing;
  }

  OptionCellBounds bounds;
  bounds.y_top = top + cell_offset;
  bounds.y_center = bounds.y_top - 0.5f * _vertical_spacing * cs.GetVerticalDirection();
  bounds.y_bottom = (bounds.y_center * 2.0f) - bounds.y_top;

  float yoff = -_vertical_spacing * cs.GetVerticalDirection();
  float xoff = _horizontal_spacing * cs.GetHorizontalDirection();
  bool finished = false;

  // Iterate through all the visible option cells and draw them
  for (int32 row = row_min; row < row_max; row++) {
    bounds.x_left = left;
    bounds.x_center = bounds.x_left + (0.5f * _horizontal_spacing * cs.GetHorizontalDirection());
    bounds.x_right = (bounds.x_center * 2.0f) - bounds.x_left;

    // Draw the columns of options
    for (int32 col = 0; col < _number_columns; ++col) {
      int32 index = row * _number_columns + col;

      if (index >= _number_options || index < 0) {
        finished = true;
        break;
      }

      float left_edge = 999999.0f; // The x offset to where the text actually begins
      float x, y;

      int32 xalign = _option_xalign;
      int32 yalign = _option_yalign;
      _SetupAlignment(xalign, yalign, bounds, x, y);

      Option &op = _options.at(index);
      if (op.disabled)
        VideoManager->SetTextColor(Color::gray);
      else
        VideoManager->SetTextColor(Color::white);

      // Iterate through all option elements in the current option
      for (int32 element = 0; element < static_cast<int32>(op.elements.size()); element++) {
        switch (op.elements[element].type) {
          case VIDEO_OPTION_ELEMENT_LEFT_ALIGN:
          {
            xalign = VIDEO_X_LEFT;
            _SetupAlignment(xalign, _option_yalign, bounds, x, y);
            break;
          }
          case VIDEO_OPTION_ELEMENT_CENTER_ALIGN:
          {
            xalign = VIDEO_X_CENTER;
            _SetupAlignment(xalign, _option_yalign, bounds, x, y);
            break;
          }
          case VIDEO_OPTION_ELEMENT_RIGHT_ALIGN:
          {
            xalign = VIDEO_X_RIGHT;
            _SetupAlignment(xalign, _option_yalign, bounds, x, y);
            break;
          }
          case VIDEO_OPTION_ELEMENT_IMAGE:
          {
            int32 image_index = op.elements[element].value;

            if (image_index >= 0 && image_index < static_cast<int32>(op.images.size())) {
              if (op.disabled)
                VideoManager->DrawImage(op.images[image_index], Color::gray);
              else
                VideoManager->DrawImage(op.images[image_index], Color::white);

              float width = op.images[image_index].GetWidth();
              float edge = x - bounds.x_left; // edge value for VIDEO_X_LEFT
              if (xalign == VIDEO_X_CENTER)
                edge -= width * 0.5f * cs.GetHorizontalDirection();
              else if (xalign == VIDEO_X_RIGHT)
                edge -= width * cs.GetHorizontalDirection();

              if (edge < left_edge)
                left_edge = edge;

            }
            break;
          }
          case VIDEO_OPTION_ELEMENT_POSITION:
          {
            x = bounds.x_left + op.elements[element].value * cs.GetHorizontalDirection();
            VideoManager->Move(x, y);
            break;
          }
          case VIDEO_OPTION_ELEMENT_TEXT:
          {
            int32 text_index = op.elements[element].value;

            if (text_index >= 0 && text_index < static_cast<int32>(op.text.size())) {
              const ustring& text = op.text[text_index];
              float width = static_cast<float>(VideoManager->CalculateTextWidth(_font, text));
              float edge = x - bounds.x_left; // edge value for VIDEO_X_LEFT

              if (xalign == VIDEO_X_CENTER)
                edge -= width * 0.5f * cs.GetHorizontalDirection();
              else if (xalign == VIDEO_X_RIGHT)
                edge -= width * cs.GetHorizontalDirection();

              if (edge < left_edge)
                left_edge = edge;

              VideoManager->DrawText(text);
            }

            break;
          }
          case VIDEO_OPTION_ELEMENT_INVALID:
          case VIDEO_OPTION_ELEMENT_TOTAL:
          default:
          {
            cerr << "VIDEO WARNING: In OptionBox::Draw(), invalid option element type was present" << endl;
            break;
          }
        } // switch (op.elements[element].type)
      } // for (int32 element = 0; element < static_cast<int32>(op.elements.size()); element++)

      float cursor_offset = 0;
      if (_scrolling) {
        if (_scroll_direction == -1)// Scrolling up
          cursor_offset = -cell_offset;
        else // Scrolling down
          cursor_offset = -cell_offset + cs.GetVerticalDirection() * _vertical_spacing;
      }

      // Check if this is the index where we should draw the cursor icon for switching elements
      if (index == _first_selection && _blink == false && _cursor_state != VIDEO_CURSOR_STATE_HIDDEN) {
        _SetupAlignment(VIDEO_X_LEFT, _option_yalign, bounds, x, y);
        VideoManager->SetDrawFlags(VIDEO_BLEND, 0);
        VideoManager->MoveRelative(_cursor_xoffset + left_edge + _cursor_xoffset, cursor_offset + _cursor_yoffset + _cursor_yoffset);
        StillImage *default_cursor = VideoManager->GetDefaultCursor();

        if (default_cursor)
          VideoManager->DrawImage(*default_cursor, Color::white);
      }

      // Check if this is the index where we should draw the selection cursor icon, if it is visible
      if (index == _selection && (_blink && _cursor_state == VIDEO_CURSOR_STATE_BLINKING) == false && _cursor_state != VIDEO_CURSOR_STATE_HIDDEN) {
        _SetupAlignment(VIDEO_X_LEFT, _option_yalign, bounds, x, y);
        VideoManager->SetDrawFlags(VIDEO_BLEND, 0);
        VideoManager->MoveRelative(_cursor_xoffset + left_edge, cursor_offset + _cursor_yoffset);
        StillImage *default_cursor = VideoManager->GetDefaultCursor();

        if (default_cursor)
          VideoManager->DrawImage(*default_cursor, Color::white);
      }

      bounds.x_left += xoff;
      bounds.x_center += xoff;
      bounds.x_right += xoff;
    } // for (int32 col = 0; col < _number_columns; ++col)

    if (finished)
      break;

    bounds.y_top += yoff;
    bounds.y_center += yoff;
    bounds.y_bottom += yoff;
  } // for (int32 row = row_min; row < row_max; row++)

  VideoManager->EnableScissoring(scissoring_rollback);
  VideoManager->_PopContext();
} // void OptionBox::Draw()



void OptionBox::ClearOptions() {
  // Before deleting the options, deallocate any images that are stored by them
  for(int32 j = 0; j < static_cast<int32>(_options.size()); ++j) {
    for(int32 i = 0; i < static_cast<int32>(_options[j].images.size()); ++i) {
      VideoManager->DeleteImage(_options[j].images[i]);
    }
  }

  _options.clear();
}



bool OptionBox::SetOptions(const vector<ustring>& format_text) {
  _options.clear();
  _number_options = 0;

  vector<ustring>::const_iterator i = format_text.begin();
  while (i != format_text.end()) {
    const ustring &str = *i;

    Option option;

    if (_ConstructOption(str, option) == false) {
      _options.clear();
      _number_options = 0;
      if (VIDEO_DEBUG)
        cerr << "VIDEO ERROR: OptionBox::SetOptions() failed due to an invalid format string: "
          << MakeStandardString(*i) << endl;
      return false;
    }

    _options.push_back(option);

    _number_options++;
    i++;
  }

  return true;
}



bool OptionBox::AddOption(const hoa_utils::ustring &text) {
  Option option;

  // Construct the option 
  if (_ConstructOption(text, option) == false) {
    return false;
  }

  _options.push_back(option);
  _number_options++;
  return true;
}



bool OptionBox::SetOptionText(int32 index, const hoa_utils::ustring &text) {
  if (index < 0 || index >= _number_options) {
    if (VIDEO_DEBUG)
      cerr << "VIDEO WARNING: OptionBox::SetOptionText() failed because it was given an invalid index: " << index << endl;
    return false;
  }

  _ConstructOption(text, _options[index]);
  return true;
}



void OptionBox::SetSelection(int32 index) {
  if (index < 0 || index >= _number_options) {
    if (VIDEO_DEBUG)
      cerr << "VIDEO WARNING: OptionBox::SetSelection() failed because it was passed an invalid index: "
        << index << endl;
    return;
  }
  _selection = index;

  int32 select_row = _selection / _number_columns;

  // If the new selection isn't currently being displayed, instantly scroll to it
  if (select_row < _scroll_offset || select_row > _scroll_offset + _number_rows - 1) {
    _scroll_offset = select_row - _number_rows + 1;

    int32 total_num_rows = (_number_options + _number_columns - 1) / _number_columns;

    if (_scroll_offset + _number_rows >= total_num_rows) {
      _scroll_offset = total_num_rows - _number_rows;
    }
  }
}



void OptionBox::EnableOption(int32 index, bool enable) {
  if (index < 0 || index >= _number_options) {
    if (VIDEO_DEBUG)
      cerr << "VIDEO WARNING: OptionBox::EnableOption() failed because an invalid "
        << "option index was specified: " << index << endl;
    return;
  }

  _options[index].disabled = !enable;
}



bool OptionBox::IsInitialized(string& error_messages) {
  ostringstream s;
  error_messages.clear();

  if (_number_rows <= 0)
    s << "* Invalid number of rows (" << _number_rows << ")" << endl;

  if (_number_columns <= 0)
    s << "* Invalid number of columns (" << _number_columns << ")" << endl;

  if (_horizontal_spacing <= 0.0f && _number_columns > 1)
    s << "* Invalid horizontal spacing (" << _horizontal_spacing << ")" << endl;

  if (_vertical_spacing <= 0.0f && _number_rows > 1)
    s << "* Invalid vertical spacing (" << _vertical_spacing << ")" << endl;

  if (_option_xalign < VIDEO_X_LEFT || _option_xalign > VIDEO_X_RIGHT)
    s << "* Invalid x align (" << _option_xalign << ")" << endl;

  if (_option_yalign < VIDEO_Y_TOP || _option_yalign > VIDEO_Y_BOTTOM)
    s << "* Invalid y align (" << _option_yalign << ")" << endl;

  if (_font.empty())
    s << "* Invalid font (none has been set)" << endl;

  if (_selection_mode <= VIDEO_SELECT_INVALID || _selection_mode >= VIDEO_SELECT_TOTAL)
    s << "* Invalid selection mode (" << _selection_mode << ")" << endl;

  error_messages = s.str();

  if (error_messages.empty())
    _initialized = true;
  else
    _initialized = false;

  return _initialized;
}

// -----------------------------------------------------------------------------
// Input Handling Methods
// -----------------------------------------------------------------------------

void OptionBox::HandleUpKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;

  if (_ChangeSelection(-1, false) == false)
    _event = VIDEO_OPTION_BOUNDS_UP;
}



void OptionBox::HandleDownKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;

  if(_ChangeSelection(1, false) == false)
    _event = VIDEO_OPTION_BOUNDS_DOWN;
}



void OptionBox::HandleLeftKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;

  if (_ChangeSelection(-1, true) == false)
    _event = VIDEO_OPTION_BOUNDS_LEFT;
}



void OptionBox::HandleRightKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;


  if (_ChangeSelection(1, true) == false)
    _event = VIDEO_OPTION_BOUNDS_RIGHT;
}



void OptionBox::HandleConfirmKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;

  // Abort if an invalid option is selected
  if (_selection < 0 || _selection >= _number_options) {
    if (VIDEO_DEBUG)
      cerr << "VIDEO WARNING: In OptionBox::HandleConfirmKey(), an invalid (out of bounds) option "
        << "was selected: " << _selection << endl;
    return;
  }

  // Case #1: switch the position of two different options
  if (_switching && _first_selection >= 0 && _selection != _first_selection) {
    // Switch the location of the two selected options
    Option temp = _options[_selection];
    _options[_selection] = _options[_first_selection];
    _options[_first_selection] = temp;
    // Set _first_selection to -1, so that we know we're not in switching mode any more
    _first_selection = -1;

    _event = VIDEO_OPTION_SWITCH;
  }

  // Case #2: partial confirm (confirming the first element in a double confirm)
  else if (_selection_mode == VIDEO_SELECT_DOUBLE && _first_selection == -1) {
    // mark the item that is getting switched
    _first_selection = _selection;
  }

  // Case #3: confirm
  else {
    if (_options[_selection].disabled) {
      // TODO: do something to tell player they confirmed on a disabled option
      return;
    }

    _event = VIDEO_OPTION_CONFIRM;

    // Get out of switch mode
    _first_selection = -1;
  }
}



void OptionBox::HandleCancelKey() {
  // Ignore input while scrolling, or if an event has already been logged
  if (_scrolling || _event)
    return;

  // If we're in switch mode and the cancel key is hit, get out of switch mode.
  if (_first_selection >= 0)
    _first_selection = -1;
  else
    _event = VIDEO_OPTION_CANCEL;
}

// -----------------------------------------------------------------------------
// Member Access Functions
// -----------------------------------------------------------------------------

void OptionBox::SetFont(const std::string& font_name) {
  if (VideoManager->GetFontProperties(font_name) == NULL) {
    if(VIDEO_DEBUG)
      cerr << "VIDEO WARNING: OptionBox::SetFont() failed because GameVideo::GetFontProperties() returned false for font: " << font_name << endl;
    return;
  }

  _font = font_name;
  _initialized = IsInitialized(_initialization_errors);
}



void OptionBox::SetCursorState(CursorState state) {
  if (state <= VIDEO_CURSOR_STATE_INVALID || state >= VIDEO_CURSOR_STATE_TOTAL) {
    if (VIDEO_DEBUG)
      cerr << "VIDEO WARNING: OptionBox::SetCursorState() failed because the argument passed was invalid: "
        << state << endl;
    return;
  }

  _cursor_state = state;
}

// -----------------------------------------------------------------------------
// Private Methods
// -----------------------------------------------------------------------------

bool OptionBox::_ConstructOption(const ustring& format_string, Option& op) {
  // Options are enabled by default
  op.disabled = false;

  // Clear all vectors, to make certain that the Option passed in is empty
  op.elements.clear();
  op.text.clear();
  op.images.clear();

  // This is a valid case. It simply means we add an option with no tags, text, or other data.
  if (format_string.empty()) {
    return true;
  }

  // Copy the format_string into a temporary string that we can manipulate
  ustring tmp = format_string;

  while (tmp.empty() == false) {
    OptionElement new_element;

    if (tmp[0] == OPEN_TAG) { // Process a new tag
      size_t length = tmp.length();

      if (length < 3) {
        // All formatting tags are at least 3 characters long because you need the opening (<)
        // and close (>) plus stuff in the middle. So anything less than 3 characters is a problem.

        if (VIDEO_DEBUG)
          cerr << "VIDEO ERROR: OptionBox::_ConstructOption() failed because a tag opening was detected "
            << "with an inadequate number of remaining characters to construct a full tag: "
            << MakeStandardString(format_string) << endl;
        return false;
      }

      size_t end_position = tmp.find(END_TAG);

      if (end_position == ustring::npos) { // Did not find the end of the tag
        if (VIDEO_DEBUG)
          cerr << "VIDEO ERROR: OptionBox::_ConstructOption() failed because a matching end tag could not "
            << "be found for an open tag: " << MakeStandardString(format_string) << endl;
        return false;
      }

      if (tmp[2] == END_TAG) { // First check if the tag is a 1-character alignment tag
        if (tmp[1] == CENTER_TAG1 || tmp[1] == CENTER_TAG2) {
          new_element.type = VIDEO_OPTION_ELEMENT_CENTER_ALIGN;
        }
        else if (tmp[1] == RIGHT_TAG1 || tmp[1] == RIGHT_TAG2) {
          new_element.type = VIDEO_OPTION_ELEMENT_RIGHT_ALIGN;
        }
        else if (tmp[1] == LEFT_TAG1 || tmp[1] == LEFT_TAG2) {
          new_element.type = VIDEO_OPTION_ELEMENT_LEFT_ALIGN;
        }
      }
      else { // The tag contains more than 1-character
        // Extract the tag string 
        string tag_text = MakeStandardString(tmp.substr(1, end_position - 1));
        
        if (IsStringNumeric(tag_text)) { // Then this must be a positioning tag
          new_element.type  = VIDEO_OPTION_ELEMENT_POSITION;
          new_element.value = atoi(tag_text.c_str());
        }
        else { // Then this must be an image tag
          StillImage imd;
          imd.SetFilename(tag_text);

          if (VideoManager->LoadImage(imd) == false) {
            if (VIDEO_DEBUG)
              cerr << "VIDEO ERROR: OptionBox::_ConstructOption failed because of an invalid image tag: "
                << MakeStandardString(format_string) << endl;
            return false;
          }
          new_element.type  = VIDEO_OPTION_ELEMENT_IMAGE;
          new_element.value = static_cast<int32> (op.images.size());
          op.images.push_back(imd);
        }
      }

      // Finished processing the tag so update the tmp string
      if (end_position == length - 1) { // End of string
        tmp.clear();
      }
      else {
        tmp = tmp.substr(end_position + 1, length - end_position - 1);
      }
    } // if (tmp[0] == OPEN_TAG)

    else { // If this isn't a tag, then it is raw text that should be added to the option
      new_element.type = VIDEO_OPTION_ELEMENT_TEXT;
      new_element.value = static_cast<int32>(op.text.size());

      // find the distance until the next tag
      size_t tag_begin = tmp.find(OPEN_TAG);

      if (tag_begin == ustring::npos) { // There are no more tags remaining, so extract the entire string
        op.text.push_back(tmp);
        tmp.clear();
      }
      else { // Another tag remains to be processed, so extract the text substring
        op.text.push_back(tmp.substr(0, tag_begin));
        tmp = tmp.substr(tag_begin, tmp.length() - tag_begin);
      }
    }

    op.elements.push_back(new_element);
  } // while (tmp.empty() == false)

  return true;
} // bool _ConstructOption(const ustring& format_string, Option& option)



bool OptionBox::_ChangeSelection(int32 offset, bool horizontal) {
  // Do nothing if the movement is horizontal and there is only one column with no horizontal wrap shifting
  if (horizontal == true && _number_columns == 1 && _horizontal_wrap_mode != VIDEO_WRAP_MODE_SHIFTED)
    return false;
  // Do nothing if the movement is vertical and there is only one row with no vertical wrap shifting
  if (horizontal == false && _number_rows == 1 && _vertical_wrap_mode != VIDEO_WRAP_MODE_SHIFTED)
    return false;

  // Get the row, column coordinates for the current selection
  int32 row = _selection / _number_columns;
  int32 col = _selection % _number_columns;
  bool bounds_exceeded = false;

  // Determine if the movement selection will exceed a column or row bondary
  if ((horizontal == true && ((col + offset < 0) || (col + offset >= _number_columns))) ||
    (horizontal == false && ((row + offset < 0) || (row + offset >= _number_rows))))
  {
    bounds_exceeded = true;
  }

  // Case #1: movement selection is within bounds
  if (bounds_exceeded == false) {
    if (horizontal)
      _selection += offset;
    else
      _selection += (offset * _number_columns);
  }

  // Case #2: movement exceeds bounds, no wrapping enabled
  else if ((horizontal == true && _horizontal_wrap_mode == VIDEO_WRAP_MODE_NONE) ||
    (horizontal == false && _vertical_wrap_mode == VIDEO_WRAP_MODE_NONE))
  {
    return false;
  }

  // Case #3: horizontal movement with wrapping enabled
  else if (horizontal == true) {
    if (col + offset < 0) { // The left boundary was exceeded
      if (_horizontal_wrap_mode == VIDEO_WRAP_MODE_STRAIGHT)
        offset += _number_columns;
      else if (_horizontal_wrap_mode == VIDEO_WRAP_MODE_SHIFTED) {
        if (_vertical_wrap_mode != VIDEO_WRAP_MODE_NONE) // Make sure vertical wrapping is accepted
          offset += _number_options;
        else
          return false;
      }
    }
    else { // The right boundary was exceeded
      if (_horizontal_wrap_mode == VIDEO_WRAP_MODE_STRAIGHT)
        offset -= _number_columns;
      else if (_horizontal_wrap_mode == VIDEO_WRAP_MODE_SHIFTED) {
        if (_vertical_wrap_mode != VIDEO_WRAP_MODE_NONE) // Make sure vertical wrapping is accepted
          offset -= _number_options;
        else
          return false;
      }
    }
    _selection = (_selection + offset) % _number_options;
  }
  
  // Case #4: vertical movement with wrapping enabled
  else {
    if (row + offset < 0) { // The top boundary was exceeded
      if (_vertical_wrap_mode == VIDEO_WRAP_MODE_STRAIGHT)
        offset += _number_options;
      else if (_vertical_wrap_mode == VIDEO_WRAP_MODE_SHIFTED) {
        if (_horizontal_wrap_mode != VIDEO_WRAP_MODE_NONE) // Make sure horizontal wrapping is accepted
          offset += (_number_columns - 1);
        else
          return false;
      }
    }
    else  { // The bottom boundary was exceeded
      if (_vertical_wrap_mode == VIDEO_WRAP_MODE_STRAIGHT)
        offset -= _number_options;
      else if (_vertical_wrap_mode == VIDEO_WRAP_MODE_SHIFTED) {
        if (_horizontal_wrap_mode != VIDEO_WRAP_MODE_NONE) // Make sure horizontal wrapping is accepted
          offset -= (_number_columns - 1);
        else
          return false;
      }
    }
    _selection = (_selection + (offset * _number_columns)) % _number_options;
  }

  // If the new selection isn't currently being displayed, scroll it into view
  row = _selection / _number_columns;
  if (row < _scroll_offset || row > _scroll_offset + _number_rows - 1) {
    _scrolling = true;
    _scroll_time = 0;

    if (row < _scroll_offset)
      _scroll_direction = -1; // scroll up
    else
      _scroll_direction = 1; // scroll down

    _scroll_offset += _scroll_direction;
  }

  _event = VIDEO_OPTION_SELECTION_CHANGE;

  return true;
} // bool OptionBox::_ChangeSelection(int32 offset, bool horizontal)



void OptionBox::_SetupAlignment(int32 xalign, int32 yalign, const OptionCellBounds& bounds, float& x, float& y) {
  VideoManager->SetDrawFlags(xalign, yalign, 0);

  switch (xalign) {
    case VIDEO_X_LEFT:
      x = bounds.x_left;
      break;
    case VIDEO_X_CENTER:
      x = bounds.x_center;
      break;
    default:
      x = bounds.x_right;
      break;
  }

  switch(yalign) {
    case VIDEO_Y_TOP:
      y = bounds.y_top;
      break;
    case VIDEO_Y_CENTER:
      y = bounds.y_center;
      break;
    default:
      y = bounds.y_bottom;
      break;
  }

  VideoManager->Move(x, y);
} // void OptionBox::_SetupAlignment(int32 xalign, int32 yalign, const OptionCellBounds& bounds, float& x, float& y)

} // namespace hoa_video

---