Logo Search packages:      
Sourcecode: scummvm version File versions  Download package

widget.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-0-11-1/gui/widget.cpp $
 * $Id: widget.cpp 30944 2008-02-23 22:50:18Z sev $
 */

#include "common/util.h"
#include "graphics/fontman.h"
#include "gui/widget.h"
#include "gui/dialog.h"
#include "gui/eval.h"
#include "gui/newgui.h"

namespace GUI {

Widget::Widget(GuiObject *boss, int x, int y, int w, int h)
      : GuiObject(x, y, w, h), _type(0), _boss(boss),
        _id(0), _flags(0), _hints(THEME_HINT_FIRST_DRAW),
        _hasFocus(false), _state(Theme::kStateEnabled) {
      init();
}

Widget::Widget(GuiObject *boss, const Common::String &name)
      : GuiObject(name), _type(0), _boss(boss),
        _id(0), _flags(0), _hints(THEME_HINT_FIRST_DRAW),
        _hasFocus(false), _state(Theme::kStateDisabled) {
      init();
}

void Widget::init() {
      // Insert into the widget list of the boss
      _next = _boss->_firstWidget;
      _boss->_firstWidget = this;
      // HACK: we enable background saving for all widgets by default for now
      _hints = THEME_HINT_FIRST_DRAW | THEME_HINT_SAVE_BACKGROUND;
}

Widget::~Widget() {
      delete _next;
      _next = 0;
}

void Widget::resize(int x, int y, int w, int h) {
      _x = x;
      _y = y;
      _w = w;
      _h = h;
}

void Widget::setFlags(int flags) {
      updateState(_flags, _flags | flags);
      _flags |= flags;
}

void Widget::clearFlags(int flags) {
      updateState(_flags, _flags & ~flags);
      _flags &= ~flags;
}

void Widget::updateState(int oldFlags, int newFlags) {
      if (newFlags & WIDGET_ENABLED) {
            _state = Theme::kStateEnabled;
            if (newFlags & WIDGET_HILITED)
                  _state = Theme::kStateHighlight;
      } else {
            _state = Theme::kStateDisabled;
      }
}

void Widget::draw() {
      NewGui *gui = &g_gui;

      if (!isVisible() || !_boss->isVisible())
            return;

      int oldX = _x, oldY = _y;

      // Account for our relative position in the dialog
      _x = getAbsX();
      _y = getAbsY();

      // Draw border
      if (_flags & WIDGET_BORDER) {
            gui->theme()->drawWidgetBackground(Common::Rect(_x, _y, _x+_w, _y+_h), _hints, Theme::kWidgetBackgroundBorder);
            _x += 4;
            _y += 4;
            _w -= 8;
            _h -= 8;
      }

      // Now perform the actual widget draw
      drawWidget();

      // Restore x/y
      if (_flags & WIDGET_BORDER) {
            _x -= 4;
            _y -= 4;
            _w += 8;
            _h += 8;
      }

      _x = oldX;
      _y = oldY;

      // Draw all children
      Widget *w = _firstWidget;
      while (w) {
            w->draw();
            w = w->_next;
      }

      clearHints(THEME_HINT_FIRST_DRAW);
}

Widget *Widget::findWidgetInChain(Widget *w, int x, int y) {
      while (w) {
            // Stop as soon as we find a widget that contains the point (x,y)
            if (x >= w->_x && x < w->_x + w->_w && y >= w->_y && y < w->_y + w->_h)
                  break;
            w = w->_next;
      }
      if (w)
            w = w->findWidget(x - w->_x, y - w->_y);
      return w;
}

Widget *Widget::findWidgetInChain(Widget *w, const char *name) {
      while (w) {
            if (w->_name == name) {
                  return w;
            }
            w = w->_next;
      }
      return 0;
}

bool Widget::isEnabled() const {
      if (g_gui.evaluator()->getVar(_name + ".enabled") == 0) {
            return false;
      }
      return ((_flags & WIDGET_ENABLED) != 0);
}

bool Widget::isVisible() const {
      if (g_gui.evaluator()->getVar(_name + ".visible") == 0)
            return false;

      return !(_flags & WIDGET_INVISIBLE);
}

#pragma mark -

StaticTextWidget::StaticTextWidget(GuiObject *boss, int x, int y, int w, int h, const Common::String &text, TextAlignment align)
      : Widget(boss, x, y, w, h), _align(align) {
      setFlags(WIDGET_ENABLED);
      _type = kStaticTextWidget;
      _label = text;
}

StaticTextWidget::StaticTextWidget(GuiObject *boss, const Common::String &name, const Common::String &text)
      : Widget(boss, name) {
      setFlags(WIDGET_ENABLED);
      _type = kStaticTextWidget;
      _label = text;

      _align = (Graphics::TextAlignment)g_gui.evaluator()->getVar(name + ".align");

      if (_align == (int)EVAL_UNDEF_VAR)
            _align = kTextAlignLeft;
}

void StaticTextWidget::setValue(int value) {
      char buf[256];
      sprintf(buf, "%d", value);
      _label = buf;
}

void StaticTextWidget::setLabel(const Common::String &label) {
      _label = label;
      // TODO: We should automatically redraw when the label is changed.
      // The following doesn't quite work when we are using tabs, plus it
      // is rather clumsy to force a full redraw for a single static text.
      // However, as long as we do blending, it might be the only way.
      //_boss->draw();
}

void StaticTextWidget::setAlign(TextAlignment align) {
      _align = align;
      // TODO: We should automatically redraw when the alignment is changed.
      // See setLabel() for more insights.
}


void StaticTextWidget::drawWidget() {
      g_gui.theme()->drawText(Common::Rect(_x, _y, _x+_w, _y+_h), _label, _state, g_gui.theme()->convertAligment(_align));
}

#pragma mark -

ButtonWidget::ButtonWidget(GuiObject *boss, int x, int y, int w, int h, const Common::String &label, uint32 cmd, uint8 hotkey)
      : StaticTextWidget(boss, x, y, w, h, label, kTextAlignCenter), CommandSender(boss),
        _cmd(cmd), _hotkey(hotkey) {
      setFlags(WIDGET_ENABLED/* | WIDGET_BORDER*/ | WIDGET_CLEARBG);
      _type = kButtonWidget;
}

ButtonWidget::ButtonWidget(GuiObject *boss, const Common::String &name, const Common::String &label, uint32 cmd, uint8 hotkey)
      : StaticTextWidget(boss, name, label), CommandSender(boss),
        _cmd(cmd), _hotkey(hotkey) {
      setFlags(WIDGET_ENABLED/* | WIDGET_BORDER*/ | WIDGET_CLEARBG);
      _hints = THEME_HINT_USE_SHADOW;
      _type = kButtonWidget;
}

void ButtonWidget::handleMouseUp(int x, int y, int button, int clickCount) {
      if (isEnabled() && x >= 0 && x < _w && y >= 0 && y < _h)
            sendCommand(_cmd, 0);
}

void ButtonWidget::drawWidget() {
      g_gui.theme()->drawButton(Common::Rect(_x, _y, _x+_w, _y+_h), _label, _state, _hints);
}

#pragma mark -

CheckboxWidget::CheckboxWidget(GuiObject *boss, int x, int y, int w, int h, const Common::String &label, uint32 cmd, uint8 hotkey)
      : ButtonWidget(boss, x, y, w, h, label, cmd, hotkey), _state(false) {
      setFlags(WIDGET_ENABLED);
      _type = kCheckboxWidget;
}

CheckboxWidget::CheckboxWidget(GuiObject *boss, const Common::String &name, const Common::String &label, uint32 cmd, uint8 hotkey)
      : ButtonWidget(boss, name, label, cmd, hotkey), _state(false) {
      setFlags(WIDGET_ENABLED);
      _type = kCheckboxWidget;
}

void CheckboxWidget::handleMouseUp(int x, int y, int button, int clickCount) {
      if (isEnabled() && x >= 0 && x < _w && y >= 0 && y < _h) {
            toggleState();
      }
}

void CheckboxWidget::setState(bool state) {
      if (_state != state) {
            _state = state;
            //_flags ^= WIDGET_INV_BORDER;
            draw();
      }
      sendCommand(_cmd, _state);
}

void CheckboxWidget::drawWidget() {
      g_gui.theme()->drawCheckbox(Common::Rect(_x, _y, _x+_w, _y+_h), _label, _state, Widget::_state);
}

#pragma mark -

SliderWidget::SliderWidget(GuiObject *boss, int x, int y, int w, int h, uint32 cmd)
      : Widget(boss, x, y, w, h), CommandSender(boss),
        _cmd(cmd), _value(0), _oldValue(0), _valueMin(0), _valueMax(100), _isDragging(false) {
      setFlags(WIDGET_ENABLED | WIDGET_TRACK_MOUSE | WIDGET_CLEARBG);
      _type = kSliderWidget;
}

SliderWidget::SliderWidget(GuiObject *boss, const Common::String &name, uint32 cmd)
      : Widget(boss, name), CommandSender(boss),
        _cmd(cmd), _value(0), _oldValue(0), _valueMin(0), _valueMax(100), _isDragging(false) {
      setFlags(WIDGET_ENABLED | WIDGET_TRACK_MOUSE | WIDGET_CLEARBG);
      _type = kSliderWidget;
}

void SliderWidget::handleMouseMoved(int x, int y, int button) {
      if (isEnabled() && _isDragging) {
            int newValue = posToValue(x);
            if (newValue < _valueMin)
                  newValue = _valueMin;
            else if (newValue > _valueMax)
                  newValue = _valueMax;

            if (newValue != _value) {
                  _value = newValue;
                  draw();
                  sendCommand(_cmd, _value);    // FIXME - hack to allow for "live update" in sound dialog
            }
      }
}

void SliderWidget::handleMouseDown(int x, int y, int button, int clickCount) {
      if (isEnabled()) {
            _isDragging = true;
            handleMouseMoved(x, y, button);
      }
}

void SliderWidget::handleMouseUp(int x, int y, int button, int clickCount) {
      if (isEnabled() && _isDragging) {
            sendCommand(_cmd, _value);
      }
      _isDragging = false;
}

void SliderWidget::drawWidget() {
      g_gui.theme()->drawSlider(Common::Rect(_x, _y, _x+_w, _y+_h), valueToPos(_value), _state);
}

int SliderWidget::valueToPos(int value) {
      return (_w * (value - _valueMin) / (_valueMax - _valueMin));
}

int SliderWidget::posToValue(int pos) {
      return (pos) * (_valueMax - _valueMin) / _w + _valueMin;
}

#pragma mark -

GraphicsWidget::GraphicsWidget(GuiObject *boss, int x, int y, int w, int h)
      : Widget(boss, x, y, w, h), _gfx(), _alpha(256), _transparency(false) {
      setFlags(WIDGET_ENABLED | WIDGET_CLEARBG);
      _type = kGraphicsWidget;
      // HACK: Don't save the background. We want to be sure that redrawing
      //       the widget updates the screen, even when there isn't any image
      //       to draw.
      _hints &= ~THEME_HINT_SAVE_BACKGROUND;
}

GraphicsWidget::GraphicsWidget(GuiObject *boss, const Common::String &name)
      : Widget(boss, name), _gfx(), _alpha(256), _transparency(false) {
      setFlags(WIDGET_ENABLED | WIDGET_CLEARBG);
      _type = kGraphicsWidget;
      // HACK: Don't save the background. We want to be sure that redrawing
      //       the widget updates the screen, even when there isn't any image
      //       to draw.
      _hints &= ~THEME_HINT_SAVE_BACKGROUND;
}

GraphicsWidget::~GraphicsWidget() {
      _gfx.free();
}

void GraphicsWidget::setGfx(const Graphics::Surface *gfx) {
      _gfx.free();

      if (!gfx || !gfx->pixels)
            return;

      // TODO: add conversion to OverlayColor
      _gfx.create(gfx->w, gfx->h, gfx->bytesPerPixel);
      memcpy(_gfx.pixels, gfx->pixels, gfx->h * gfx->pitch);
}

void GraphicsWidget::setGfx(int w, int h, int r, int g, int b) {
      if (w == -1)
            w = _w;
      if (h == -1)
            h = _h;

      _gfx.free();
      _gfx.create(w, h, sizeof(OverlayColor));

      OverlayColor *dst = (OverlayColor*)_gfx.pixels;
      // TODO: get rid of g_system usage
      OverlayColor fillCol = g_system->RGBToColor(r, g, b);
      while (h--) {
            for (int i = 0; i < w; ++i) {
                  *dst++ = fillCol;
            }
      }
}

void GraphicsWidget::drawWidget() {
      if (sizeof(OverlayColor) == _gfx.bytesPerPixel && _gfx.pixels)
            g_gui.theme()->drawSurface(Common::Rect(_x, _y, _x+_w, _y+_h), _gfx, _state, _alpha, _transparency);
}

#pragma mark -

ContainerWidget::ContainerWidget(GuiObject *boss, int x, int y, int w, int h) : Widget(boss, x, y, w, h) {
      setFlags(WIDGET_ENABLED | WIDGET_CLEARBG);
      _type = kContainerWidget;
}

ContainerWidget::ContainerWidget(GuiObject *boss, const Common::String &name) : Widget(boss, name) {
      setFlags(WIDGET_ENABLED | WIDGET_CLEARBG);
      _type = kContainerWidget;
}

void ContainerWidget::drawWidget() {
      g_gui.theme()->drawWidgetBackground(Common::Rect(_x, _y, _x + _w, _y + _h), _hints, Theme::kWidgetBackgroundBorder);
}

} // End of namespace GUI

Generated by  Doxygen 1.6.0   Back to index