option.h

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.

#ifndef __OPTION_HEADER__
#define __OPTION_HEADER__

#include "defs.h"
#include "utils.h"

#include "gui.h"
#include "system.h"

namespace hoa_video {

const int32 VIDEO_CURSOR_BLINK_RATE = 40;

const int32 VIDEO_OPTION_SCROLL_TIME = 100;


enum OptionBoxEvent {
  VIDEO_OPTION_INVALID          = -1,
  VIDEO_OPTION_SELECTION_CHANGE =  0,
  VIDEO_OPTION_CONFIRM          =  1,
  VIDEO_OPTION_CANCEL           =  2,
  VIDEO_OPTION_SWITCH           =  3,
  VIDEO_OPTION_BOUNDS_UP        =  4,
  VIDEO_OPTION_BOUNDS_DOWN      =  5,
  VIDEO_OPTION_BOUNDS_LEFT      =  6,
  VIDEO_OPTION_BOUNDS_RIGHT     =  7,
  VIDEO_OPTION_TOTAL            =  8
};


enum OptionElementType {
  VIDEO_OPTION_ELEMENT_INVALID      = -1,
  VIDEO_OPTION_ELEMENT_LEFT_ALIGN   =  0,
  VIDEO_OPTION_ELEMENT_CENTER_ALIGN =  1,
  VIDEO_OPTION_ELEMENT_RIGHT_ALIGN  =  2,
  VIDEO_OPTION_ELEMENT_POSITION     =  3,
  VIDEO_OPTION_ELEMENT_IMAGE        =  4,
  VIDEO_OPTION_ELEMENT_TEXT         =  5,
  VIDEO_OPTION_ELEMENT_TOTAL        =  6
};


enum CursorState {
  VIDEO_CURSOR_STATE_INVALID  = -1,
  VIDEO_CURSOR_STATE_HIDDEN   =  0,
  VIDEO_CURSOR_STATE_VISIBLE  =  1,
  VIDEO_CURSOR_STATE_BLINKING =  2,
  VIDEO_CURSOR_STATE_TOTAL    =  3
};


enum WrapMode {
  VIDEO_WRAP_MODE_INVALID  = -1,
  VIDEO_WRAP_MODE_NONE     =  0,
  VIDEO_WRAP_MODE_STRAIGHT =  1,
  VIDEO_WRAP_MODE_SHIFTED  =  2,
  VIDEO_WRAP_MODE_TOTAL    =  3
};


enum SelectMode
{
  VIDEO_SELECT_INVALID = -1,
  VIDEO_SELECT_SINGLE  =  0,
  VIDEO_SELECT_DOUBLE  =  1,
  VIDEO_SELECT_TOTAL   =  2
};

namespace private_video {

const uint16 OPEN_TAG     = static_cast<uint16>('<');
const uint16 END_TAG      = static_cast<uint16>('>');
const uint16 LEFT_TAG1    = static_cast<uint16>('l');
const uint16 CENTER_TAG1  = static_cast<uint16>('c');
const uint16 RIGHT_TAG1   = static_cast<uint16>('r');
const uint16 LEFT_TAG2    = static_cast<uint16>('L');
const uint16 CENTER_TAG2  = static_cast<uint16>('C');
const uint16 RIGHT_TAG2   = static_cast<uint16>('R');

class OptionElement {
public:
  OptionElementType type;

  int32 value;
};

class OptionCellBounds {
public:

  float y_top, y_center, y_bottom;

  float x_left, x_center, x_right;
};

class Option {
public:
  std::vector<OptionElement> elements;

  std::vector<hoa_utils::ustring> text;

  std::vector<StillImage> images;

  bool disabled;
};

} // namespace private_video

class OptionBox : public private_video::GUIControl {
public:
  OptionBox();

  ~OptionBox();

  void Update(uint32 frame_time = hoa_system::SystemManager->GetUpdateTime());

  void Draw();

  void ClearOptions();

  bool SetOptions(const std::vector<hoa_utils::ustring>& option_text);

  bool AddOption(const hoa_utils::ustring &text);

  bool SetOptionText(int32 index, const hoa_utils::ustring &text);

  void SetSelection(int32 index);

  void EnableOption(int32 index, bool enable);

  bool IsInitialized(std::string& error_messages);

  void HandleUpKey();
  void HandleDownKey();
  void HandleLeftKey();
  void HandleRightKey();
  void HandleConfirmKey();
  void HandleCancelKey();



  void SetSize(int32 columns, int32 rows)
    { _number_columns = columns; _number_rows = rows; _initialized = IsInitialized(_initialization_errors); }

  void SetCellSize(float horz_spacing, float vert_spacing)
    { _horizontal_spacing = horz_spacing; _vertical_spacing = vert_spacing; _initialized = IsInitialized(_initialization_errors); }

  void SetOptionAlignment(int32 xalign, int32 yalign)
    { _option_xalign = xalign; _option_yalign = yalign; _initialized = IsInitialized(_initialization_errors); }

  void SetSelectMode(SelectMode mode)
    { _selection_mode = mode; _initialized = IsInitialized(_initialization_errors); }

  void SetVerticalWrapMode(WrapMode mode)
    { _vertical_wrap_mode = mode; }

  void SetHorizontalWrapMode(WrapMode mode)
    { _horizontal_wrap_mode = mode; }

  void SetSwitching(bool enable)
    { _switching = enable; }

  void SetCursorOffset(float x, float y)
    { _cursor_xoffset = x; _cursor_yoffset = y; }

  void SetFont(const std::string &font_name);

  void SetCursorState(CursorState state);

  bool IsScrolling() const
    { return _scrolling; }

  bool IsEnabled(int32 index) const
    { return !_options[index].disabled; }

  int32 GetEvent()
    { return _event; }

  int32 GetSelection() const
    { return _selection; }

  int32 GetNumberRows() const
    { return _number_rows; }

  int32 GetNumberColumns() const
    { return _number_columns; }

  int32 GetNumberOptions() const
    { return _number_options; }

  void TEMP_OverideScissorring(bool enable)
    { _TEMP_overide_scissorring = enable; }

private:
  bool _initialized;

  std::vector<private_video::Option> _options;



  int32 _number_options;

  int32 _number_columns;

  int32 _number_rows;

  SelectMode _selection_mode;

  WrapMode _horizontal_wrap_mode;

  WrapMode _vertical_wrap_mode;

  std::string _font;

  bool _switching;



  float _cursor_xoffset, _cursor_yoffset;

  int32 _scroll_offset;

  float _horizontal_spacing;

  float _vertical_spacing;

  int32 _option_xalign;

  int32 _option_yalign;



  int32 _event;

  int32 _selection;

  int32 _first_selection;

  CursorState _cursor_state;

  bool _blink;

  int32 _blink_time;

  bool  _scrolling;

  int32 _scroll_time;

  int32 _scroll_direction;

  bool _TEMP_overide_scissorring;

  // ---------- Private methods

  bool _ConstructOption(const hoa_utils::ustring &formatString, private_video::Option &option);

  bool _ChangeSelection(int32 offset, bool horizontal);

  void _SetupAlignment(int32 xalign, int32 yalign, const private_video::OptionCellBounds& bounds, float& x, float& y);
}; // class OptionBox : public private_video::GUIControl

} // namespace hoa_video

#endif  // __OPTION_HEADER__

---