widget.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#include "sdlinput.h"

#include <wt/application.h>
#include <wt/widget.h>
#include <wt/painter.h>
#include <wt/event.h>
#include <wt/font.h>
#include <wt/trace.h>

namespace Wt {

// static members
FocusData Widget::focus_data_;

Widget::Widget(Widget *parent, const std::string &name, int wflags)
        : Object(parent, name),
        LayoutItem(),
        Pixmap(0, 0, -1, wflags),
        hidden(false),
        enabled(true),
        mouseTracking(false),
        focusPolicy(NoFocus),
        ownFont(false),
        wflags_(wflags),
        need_redraw_(false),
        bg_flags(0),
        bg_alignment(0),
        painter_(new Painter),
layout_(0) {
    hidden.override.connect(sigc::mem_fun(*this, &Widget::is_hidden));
    // connect to layout recalc
    sigc::slot1<void, bool> hidden_slot =
        sigc::mem_fun(*this, &Widget::hiddenChanged);
    hidden.changed.connect(hidden_slot);

    enabled.override.connect(sigc::mem_fun(*this, &Widget::is_enabled));

    void (Widget::*update)() = &Widget::update;
    sigc::slot0<void> update_slot = sigc::mem_fun(*this, update);
    enabled.changed.connect(update_slot);

    // let's put on focus widget's list
    focus_data_.push_back(this);

    if (wflags & W::ShowModal) {
        grabKeyboard();
        grabMouse();
    }

    // we are goint to paint it anyway on resizeEvent
    resize(sizeHint());
    if (parent)
        painter_->setFont(parent->font());
    Application::sendPostedEvents();
}

static bool isWidget(Object *w) {
    return w && dynamic_cast<Widget *>(w);
}

Widget::~Widget() {
    if (isShown()) {
        /// \todo if we are transparent we should be able to avoid this
        update(parentWidget(), geometry());
    }

    releaseKeyboard();
    releaseMouse();

    if (hasFocus()) {
        /// \todo In case parent is not dead we can do it properly.
        /// The else guards us from a recursive nasty crash that
        /// shouldn't happen if we had a real tree instead of the
        /// focusNextPrevChild() abomination.
        if (isWidget(parent())) {
            focusNextPrevChild(true);
        } else {
            /* this is getting worse and worst. We have to check
            both sides off the list in order to avoid null dereferencing */
            focus_data_.looseFocus();
        }
    }

    focus_data_.remove(this);

    delete painter_;
}

void Widget::reparent(Widget *new_parent) {
    Object::reparent(new_parent);
    if (new_parent && !ownFont)
        painter_->setFont(new_parent->font());
}

Point Widget::mapToGlobal(const Point & pos) const {
    const Widget *p = this;
    Point q(pos);

    do {
        q += p->geometry().topLeft();
    } while ((p = p->parentWidget()));
    return q;
}

Point Widget::mapFromGlobal(const Point & pos) const {
    const Widget *p = this;
    Point q(pos);

    do {
        q -= p->geometry().topLeft();
    } while ((p = p->parentWidget()));
    return q;
}

Point Widget::mapToParent(const Point & pos) const {
    return pos + geometry().topLeft();
}

Point Widget::mapFromParent(const Point & pos) const {
    return pos - geometry().topLeft();
}

Region Widget::mapToGlobal(const Region & region) const {
    Region mapped_region(region);
    const Point p1(region.boundingRect().topLeft());
    const Point p2(mapToGlobal(p1));
    const Point dp = p2 - p1;
    mapped_region.translate(dp.x(), dp.y());
    return mapped_region;
}

Region Widget::mapToParent(const Region & region) const {
    Region mapped_region(region);
    const Point p1(region.boundingRect().topLeft());
    const Point p2(mapToParent(p1));
    const Point dp = p2 - p1;
    mapped_region.translate(dp.x(), dp.y());
    return mapped_region;
}

void Widget::setBackgroundColor(const Color &color) {
    if (painter_->backgroundColor() != color) {
        painter_->setBackgroundColor(color);
        update();
    }
}

const Color& Widget::backgroundColor() const {
    return painter_->backgroundColor();
}

void Widget::setForegroundColor(const Color &color) {
    if (painter_->pen().color() != color) {
        painter_->setPen(color);
        update();
    }
}

const Color& Widget::foregroundColor() const {
    return painter_->pen().color();
}

bool Widget::setBackgroundPixmapFlags(int flags, int alignment) {
    bool changed = false;

    if (bg_flags != flags) {
        bg_flags = flags;
        changed = true;
    }

    if (bg_alignment != alignment) {
        bg_alignment = alignment;
        changed = true;
    }

    return changed;
}

void Widget::setBackgroundPixmap(const Pixmap& pixmap, int flags, int alignment) {
    bool changed = (bg_pixmap_ != pixmap);

    bg_pixmap_ = pixmap;

    changed = setBackgroundPixmapFlags(flags, alignment) || changed;

    if (changed) {
        updateBackground();
        update();
    }
}

bool Widget::event(Event *e) {
    bool handled = true;

    //check if the event is claimed by someone else
    if (Object::event(e))
        return true;

    switch (e->type()) {
    case Event::MouseButtonPress:
    case Event::MouseButtonRelease:
    case Event::MouseButtonDblClick:
    case Event::MouseMove: {
            MouseEvent *me = static_cast<MouseEvent *>(e);
            switch (e->type()) {
            case Event::MouseButtonPress:
                mousePressEvent(me);
                break;
            case Event::MouseButtonRelease:
                mouseReleaseEvent(me);
                break;
            case Event::MouseButtonDblClick:
                mouseDoubleClickEvent(me);
                break;
            case Event::MouseMove:
                mouseMoveEvent(me);
                break;
            }
            handled = me->isAccepted();
            if (parent() && !handled) {
                MouseEvent me_new(me->type(), mapToParent(me->pos()),
                                  me->globalPos(), me->button(), me->state());
                handled = Application::sendEvent(parent(), me_new);
            }
        }
        break;
    case Event::KeyPress: {
            KeyEvent *kep = static_cast<KeyEvent *>(e);
            if (kep->key() == Key_Tab) {
                focusNextPrevChild(true);
            } else if (kep->key() == Key_Backtab) {
                focusNextPrevChild(false);
            } else {
                keyPressEvent(kep);
            }
        }
        break;
    case Event::KeyRelease: {
            KeyEvent *ker = static_cast<KeyEvent *>(e);
            if (ker->key() != Key_Tab && ker->key() != Key_Backtab) {
                keyReleaseEvent(ker);
            }
        }
        break;
    case Event::FocusIn:
        focusInEvent(static_cast<FocusEvent *>(e));
        break;
    case Event::FocusOut:
        focusOutEvent(static_cast<FocusEvent *>(e));
        break;
    case Event::Enter:
        enterEvent(e);
        break;
    case Event::Leave:
        leaveEvent(e);
        break;
    case Event::Wheel: {
            WheelEvent *we = static_cast<WheelEvent *>(e);
            wheelEvent(we);
            handled = we->isAccepted();
            if (parent() && !handled) {
                WheelEvent we_new(mapToParent(we->pos()),
                                  we->delta(), we->state());
                handled = Application::sendEvent(parent(), we_new);
            }
        }
        break;
    case Event::Paint:
        paintEvent(static_cast<PaintEvent *>(e));
        break;
    case Event::Resize:
        resizeEvent(static_cast<ResizeEvent *>(e));
        break;
    case Event::Move:
        moveEvent(static_cast<MoveEvent *>(e));
        break;
    case Event::Show:
        showEvent(static_cast<ShowEvent *>(e));
        break;
    case Event::Hide:
        hideEvent(static_cast<HideEvent *>(e));
        break;
    case Event::Close:
        closeEvent(static_cast<CloseEvent *>(e));
        break;
    default:
        handled = false;
        break;
    }

    return handled;
}

void Widget::mousePressEvent(MouseEvent *me) {
    trace("mouse") << "mousePressEvent for " << this << std::endl;
    setFocus(FocusEvent::Mouse);
    if (hasFocus())
        me->accept();
}
void Widget::mouseReleaseEvent(MouseEvent *) {
    trace("mouse") << "mouseReleaseEvent for " << this << std::endl;
}
void  Widget::mouseDoubleClickEvent(MouseEvent *) {
    trace("mouse") << "mouseDoubleClickEvent for " << this << std::endl;
}
void  Widget::mouseMoveEvent(MouseEvent *) {
    trace("mouse") << "mouseMoveEvent for " << this << std::endl;
}

void Widget::focusInEvent(FocusEvent *) {
    trace("focus") << "FocusInEvent for " << this << std::endl;
}

void Widget::focusOutEvent(FocusEvent *) {
    trace("focus") << "FocusOutEvent for " << this << std::endl;
}

void Widget::keyPressEvent(KeyEvent *) {
    trace("key") << "keyPressEvent for " << this << std::endl;
}

void Widget::keyReleaseEvent(KeyEvent *) {
    trace("key") << "keyReleaseEvent for " << this << std::endl;
}

void  Widget::enterEvent(Event *) {
    trace("mouse") << "enterEvent for " << this << std::endl;
}
void  Widget::leaveEvent(Event *) {
    trace("mouse") << "leaveEvent for " << this << std::endl;
}
void  Widget::wheelEvent(WheelEvent *we) {
    trace("mouse") << "wheelEvent for " << this << std::endl;
    if (focusPolicy > StrongFocus && hasFocus()) {
        focusNextPrevChild((we->delta() > 0));
        we->accept();
    }
}

/**
 * 
 * @param w widget to send clipped paint event
 * @param region should be in w coordinates
 */
void Widget::update(Widget *w, const Region &region) {
    if (w) {
        Region r(region);
        // clip to parent
        trace("paint") << "before clip: " << r << std::endl;
        trace("paint") << "clip against: " << w->rect() << std::endl;
        r &= w->rect();
        trace("paint") << "after clip: " << r << std::endl;
        Application::postEvent(w, new PaintEvent(r, w->autoerase()));
    }
}

void Widget::paintEvent(PaintEvent *e) {
    // notify top ancestor to redraw us and our children
    Region region(e->region());
    trace("paint") << "paintEvent: " << this << " region: " << region << std::endl;
    if (need_redraw_) {
        if (e->erased()) {
            trace("paint") << "paintEvent: Erasing " << this << " region: " << region << std::endl;
            erase();
        }
        painter_->begin(this, autoclip());
        draw(painter_, region);
        painter_->end();
    }
    if (parent()) {
        update(topParentWidget(), mapToGlobal(region));
    }
}

void Widget::updateBackground() {
    if (bg_pixmap_) {
        if (bg_flags != Unscaled) {
            bg_scaled_ = Pixmap();
            if (bg_flags == Scaled) {
                bg_scaled_ = bg_pixmap_.scale(size());
            } else if (bg_flags == Tiled) {
                bg_scaled_ = Pixmap(size());
                Painter p(&bg_scaled_);
                p.drawTiledPixmap(rect(), bg_pixmap_);
            } else {
                Warn("Unknown BackgroundImageFlag %d\n", bg_flags);
            }
        }
    }
}

void Widget::resizeEvent(ResizeEvent *) {
    updateBackground();
}

void Widget::moveEvent(MoveEvent *) {}

void Widget::showEvent(ShowEvent *) {}

void Widget::hideEvent(HideEvent *) {}

void Widget::closeEvent(CloseEvent *e) {
    e->accept();
}

/*!
A clever widget can draw only the parts of it that are
specified in the region argument. A not so clever widget
can safely ignore the region argument and draw the entire
widget area.
 
Keep in mind that double buffering is already implemented
and you can't gain anything by reimplementing it again at
this level.
*/
void Widget::draw(Painter *, const Region&) {
    trace("draw") << "drawing: " << this << std::endl;
    //after drawing the widget does not need repainting
    need_redraw_ = false;
    return;
}

void Widget::update(const Rect& r) {
    need_redraw_ = true;
    update(this, r);
}

void Widget::update() {
    update(rect());
}

void Widget::update(int x, int y, int w, int h) {
    update(Rect(x, y, w, h));
}

void Widget::repaint(const Rect& r, bool erase) {
    PaintEvent e(r, erase);
    need_redraw_ = true;
    Application::sendEvent(this, e);
}

void Widget::repaint(const Region& r, bool erase) {
    PaintEvent e(r, erase);
    need_redraw_ = true;
    Application::sendEvent(this, e);
}

void Widget::repaint(int x, int y, int w, int h, bool erase) {
    repaint(Rect(x, y, w, h), erase);
}

void Widget::repaint(bool erase) {
    repaint(rect(), erase);
}

void Widget::repaint() {
    repaint(!(wflags_ & W::NoAutoErase));
}

void Widget::resize(int w, int h) {
    Size newsize(w, h);
    Size oldsize(size());

    if (newsize == oldsize)
        return;

    w = std::max(w, minimumSize().width());
    w = std::min(w, maximumSize().width());
    h = std::max(h, minimumSize().height());
    h = std::min(h, maximumSize().height());
    newsize.setSize(w, h);

    Pixmap::resize(w, h);
    Region exposed(geometry());
    Rect r(geometry());
    r.setSize(newsize);
    LayoutItem::setGeometry(r);
    exposed -= geometry();
    trace("geometry") << this <<
    " Widget::setGeometry() setting geometry to " << r << std::endl;

    Application::postEvent(this, new ResizeEvent(newsize, oldsize));
    update(parentWidget(), exposed);
    update();
}

void Widget::resize(const Size& size) {
    resize(size.width(), size.height());
}

void Widget::move(int x, int y) {
    const Point newp(x, y);
    const Point oldp(geometry().topLeft());

    if (newp == oldp)
        return;

    Region exposed(geometry());
    Rect r(geometry());
    r.moveTopLeft(newp);
    LayoutItem::setGeometry(r);
    exposed -= geometry();

    trace("geometry") << this <<
    " Widget::setGeometry() setting geometry to " << r << std::endl;

    Application::postEvent(this, new MoveEvent(newp, oldp));
    update(parentWidget(), exposed);
    update();
}

void Widget::move(const Point& p) {
    move(p.x(), p.y());
}

void Widget::setGeometry(int x, int y, int w, int h) {
    move(x, y);
    resize(w, h);
    trace("geometry") << this <<
    " Widget::setGeometry() setting geometry to " << geometry() << std::endl;
}

void Widget::setGeometry(const Rect& r) {
    setGeometry(r.left(), r.top(), r.width(), r.height());
}

/*! Widget::updateGeometry() should call
Widget::setGeometry() if there is no parent */
void Widget::updateGeometry() {
    if (parent()) {
        Application::postEvent(parent(), new LayoutHintEvent());
    }
}

void Widget::raise() {
    Object *p = parent();
    if (!p)
        return;
    Object::List& list(p->children());
    list.remove(this);
    list.push_back(this);
    update();
}

void Widget::lower() {
    Object *p = parent();
    if (!p)
        return;
    Object::List& list(p->children());
    list.remove(this);
    list.push_front(this);
    update();
}

void Widget::setLayout(Layout *layout) {
    if (layout_ == layout)
        return;

    if (layout_) {
        delete layout_;
    }

    layout_ = layout;

    if (layout) {
        layout->reparent(this);
        installEventFilter(layout);
    }
    // emit signal
    layoutChanged(layout);
    Application::postEvent(this, new LayoutHintEvent());
}

void Widget::erase(const Rect& r) {
    painter_->begin(this, autoclip());

    painter_->eraseRect(r);

    if (bg_pixmap_) {
        if (bg_flags == Unscaled) {
            Rect aligned = Rect::align(rect(),
                                       bg_pixmap_.size(), bg_alignment);
            Point p(std::max(aligned.left(), r.left()),
                    std::max(aligned.top(), r.top()));
            painter_->drawPixmap(p, bg_pixmap_);
        } else {
            painter_->drawPixmap(Point(0, 0), bg_scaled_);
        }
    }
    painter_->end();
}

void Widget::erase(const Region& r) {
    if (bg_pixmap_) {
        const RectArray& ra = r.rects();
        const int n = ra.size();
        for (int i = 0; i < n; i++) {
            erase(ra[i]);
        }
    } else {
        painter_->begin(this, autoclip());
        painter_->eraseRegion(r);
        painter_->end();
    }
}

void Widget::erase() {
    erase(rect());
}

void Widget::erase(int x, int y, int w, int h) {
    erase(Rect(x, y, w, h));
}

const Font& Widget::font() const {
    const Widget *p = parentWidget();
    return (p && !ownFont) ? p->font() : painter_->font();
}

void Widget::setFont(const Font& new_font) {
    Font old_font = font();
    painter_->setFont(new_font);
    ownFont = true;
    fontChange(old_font);
}

void Widget::unsetFont() {
    ownFont = false;
}

void Widget::fontChange(const Font& old_font) {
    for (Object::List::const_iterator child(children().begin()),
            end(children().end()); child != end; ++child) {
        Widget* w = dynamic_cast<Widget *>(*child);
        // guard against a non widget (e.g. layout) child.
        if (w && !w->ownFont) {
            w->painter_->setFont(font());
            w->fontChange(old_font);
        }
    }
    updateGeometry();
    update();
}

void Widget::drawText(int x, int y, const std::string& text) {
    painter_->drawText(x, y, text);
}

void Widget::drawText(const Point& p, const std::string& text) {
    painter_->drawText(p, text);
}

Widget *Widget::childAt(const Point& p, bool self_include) const {
    Widget *result = 0;
    const Rect& r = rect();
    if (isHidden() || !r.contains(p)) {
        return result;
    }
    // we got it. Now let's see if it is spot on some child
    for (Object::List::const_iterator child(children().begin()),
            end(children().end()); child != end; ++child) {
        const Widget* w = dynamic_cast<Widget *>(*child);
        // guard against a non widget (e.g. layout) child.
        if (w) {
            const Point& wp(w->mapFromParent(p));
            Widget *ww = w->childAt(wp, true);
            // this ensures we keep the last non NULL one (most raised)
            if (ww)
                result = ww;
        }
    }
    if (!result && self_include) {
        result = const_cast<Widget *>(this);
    }
    return result;
}

template<typename ITERATOR>
static Widget *findNextWidget(ITERATOR start, ITERATOR finish) {
    for (ITERATOR it = start; it != finish; ++it) {
        Widget *w = dynamic_cast<Widget *>(*it);
        if (w && w->isFocusEnabled(FocusEvent::Tab))
            return w;
    }
    return 0;
}

bool Widget::isFocusEnabled(int reason) const {
    bool allow_focus;

    if (!enabled)
        return false;

    switch (reason) {
    case FocusEvent::Mouse:
        allow_focus = (focusPolicy & ClickFocus);
        break;
    case FocusEvent::Tab:
    case FocusEvent::Backtab:
        allow_focus = (focusPolicy & TabFocus);
        break;
    case FocusEvent::ActiveWindow:
    case FocusEvent::Popup:
    case FocusEvent::Shortcut:
    case FocusEvent::Other:
    default:
        allow_focus = (focusPolicy != NoFocus);
        break;
    }

    return allow_focus;
}

void Widget::setFocus(int reason) {
    Widget *old_focus = focusWidget();
    if (old_focus == this || !isFocusEnabled(reason))
        return;
    if (old_focus) {
        Application::postEvent(old_focus,
                               new FocusEvent(Event::FocusOut, reason));
    }
    focus_data_.setFocus(this);
    Application::postEvent(this,
                           new FocusEvent(Event::FocusIn, reason));
}

/// cycles focus amongs widgets
/*!
\todo use Boost graph or tree in order to make this simple
function and FocusData to carry the meat of the implementation
instead the other way around
 
\bug Backtab is working unexpectedly
 
\bug focusNextPrevChild is not working right for widgets with children
*/
bool Widget::focusNextPrevChild(bool next) {
    Widget *w = focusWidget(), *w2;
    const Object::List& children_ = children();

    trace("focus") << "focusNextPrevChild() for " << this << std::endl;

    if (w == this) {
        // we got the focus. We have to iterate in children
        goto start_cycle;
    } else if (w->parent() == this) {
        // current focusWidget is our child
        if (next) {
            Object::List::const_iterator it_;
            it_ = find(children_.begin(),
                       children_.end(), w);
            // must exist
            assert(it_ != children_.end());
            w2 = findNextWidget(++it_, children_.end());
        } else {
            Object::List::const_reverse_iterator rit_;
            rit_ = find(children_.rbegin(),
                        children_.rend(), w);
            // must exist
            assert(rit_ != children_.rend());
            w2 = findNextWidget(++rit_, children_.rend());
        }

        if (!w2) {
            // cannot continue cycle
            if (!parent()) {
                // we didn't d find it and we have nowhere to go
                // case: rootwindow with children (end of cycle)
                goto start_cycle;
            }
            // cannot continue cycle let's try father
            goto pass_to_parent;
        }
    } else {
        // current focusWidget is not our child
        // so let's start cycling starting from this
        w2 = this;
    }

change_focus:
    w2->setFocus((next) ? FocusEvent::Tab : FocusEvent::Backtab);
    return true;

start_cycle:
    w2 = (next) ?
         findNextWidget(children_.begin(), children_.end()) :
         findNextWidget(children_.rbegin(), children_.rend());
    if (w2)
        goto change_focus;
pass_to_parent:
    if (parent()) {
        Widget *wp = parentWidget();
        return wp->focusNextPrevChild(next);
    }
    return false;
}

static void postLayoutHintEventRecursively(Widget *w) {
    for (Object::List::const_iterator child(w->children().begin()),
            end(w->children().end()); child != end; ++child) {
        Widget* ww = dynamic_cast<Widget *>(*child);
        // guard against a non widget (e.g. layout) child.
        if (ww) {
            postLayoutHintEventRecursively(ww);
        }
    }
    Application::postEvent(w, new LayoutHintEvent());
}

void Widget::hiddenChanged(bool hidden_new) {
    if (hidden_new) {
        Application::postEvent(this, new HideEvent());
    } else {
        // notify layout subsystem since layout hint event
        // were disabled while top level widget was hidden
        postLayoutHintEventRecursively(this);
        Application::postEvent(this, new ShowEvent());
    }
    updateGeometry();
    // force a repaint
    update();
}

bool Widget::is_hidden(bool val) const {
    if (val)
        return true;

    // during parent's death parentWidget() is not
    // reliable anymore (parent is a simple Object)
    const Widget *p = dynamic_cast<Widget *>(parent());
    if (p && p->hidden)
        return true;

    return false;
}

void Widget::hide() {
    releaseKeyboard();
    releaseMouse();

    hidden = true;
}

void Widget::show() {
    if (wflags_ & W::ShowModal) {
        grabKeyboard();
        grabMouse();
    }

    hidden = false;
}

void Widget::setHidden(bool do_hide) {
    (do_hide) ? hide() : show();
}

void Widget::setShown(bool do_show) {
    (do_show) ? show() : hide();
}

bool Widget::is_enabled(bool val) const {
    if (!val)
        return false;

    const Widget *p = parentWidget();
    if (p && !p->enabled)
        return false;

    return true;
}

void Widget::enable() {
    enabled = true;
}

void Widget::disable() {
    enabled = false;
}

void Widget::setEnabled(bool do_enable) {
    (do_enable) ? enable() : disable();
}

void Widget::setDisabled(bool do_disable) {
    (do_disable) ? disable() : enable();
}

bool Widget::close() {
    return close(false);
}

bool Widget::close(bool destroy) {
    CloseEvent ce;
    Application::sendEvent(this, ce);
    if (!ce.isAccepted())
        return false;

    const bool kill = destroy || (wflags_ & W::DestructiveClose);
    if (!kill)
        hide();
    else
        delete this;

    return true;
}

Size Widget::sizeHint() const {
    return (layout_ ? layout_->sizeHint() << layout_->margin :
            LayoutItem::sizeHint());
}

void Widget::setSizeHint(const Size& size) {
    if (size == sizeHint())
        return;
    // sizeHint can't be < minmumSize()
    Size hint_size = size.expandedTo(minimumSize());

    // we can't set sizeHint in a widget with a layout
    if (layout_)
        return;
    LayoutItem::setSizeHint(hint_size);
    updateGeometry();
}

Size Widget::minimumSize() const {
    return (layout_ ? layout_->minimumSize() << layout_->margin :
            LayoutItem::minimumSize());
}

void Widget::setMinimumSize(const Size& size) {
    if (size == minimumSize())
        return;

    if (layout_)
        layout_->setMinimumSize(size >> layout_->margin);
    LayoutItem::setMinimumSize(size);

    // sizeHint can't be < minmumSize()
    Size hint_size = size.expandedTo(minimumSize());
    setSizeHint(hint_size);

    updateGeometry();
}

Size Widget::maximumSize() const {
    return (layout_ ? layout_->maximumSize() << layout_->margin :
            LayoutItem::maximumSize());
}

void Widget::setMaximumSize(const Size& size) {
    if (size == maximumSize())
        return;
    if (layout_)
        layout_->setMaximumSize(size >> layout_->margin);
    LayoutItem::setMaximumSize(size);
    updateGeometry();
}

SizePolicy Widget::sizePolicy() const {
    if (layout_)
        return layout_->sizePolicy();
    return LayoutItem::sizePolicy();
}

void Widget::setSizePolicy(const SizePolicy& size_policy) {
    if (size_policy == sizePolicy())
        return;
    if (layout_)
        layout_->setSizePolicy(size_policy);
    LayoutItem::setSizePolicy(size_policy);
    updateGeometry();
}

SizePolicy::ExpandData Widget::expanding() const {
    if (layout_)
        return layout_->expanding();
    return LayoutItem::expanding();
}

void Widget::grabKeyboard() {
    SDLInput::instance()->setKeyboardGrabber(this);
}

void Widget::releaseKeyboard() {
    if (keyboardGrabber() == this)
        SDLInput::instance()->releaseKeyboardGrab();
}

Widget *Widget::keyboardGrabber() {
    return SDLInput::instance()->keyboardGrabber();
}

void Widget::grabMouse() {
    SDLInput::instance()->setMouseGrabber(this);
}

void Widget::releaseMouse() {
    if (mouseGrabber() == this)
        SDLInput::instance()->releaseMouseGrab();
}

Widget *Widget::mouseGrabber() {
    return SDLInput::instance()->mouseGrabber();
}

}

---

Generated Fri Jul 28 19:23:01 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.