diff options
Diffstat (limited to 'dw/fltkui.cc')
| -rw-r--r-- | dw/fltkui.cc | 1202 |
1 files changed, 1202 insertions, 0 deletions
diff --git a/dw/fltkui.cc b/dw/fltkui.cc new file mode 100644 index 00000000..70ba1ef3 --- /dev/null +++ b/dw/fltkui.cc @@ -0,0 +1,1202 @@ +/* + * Dillo Widget + * + * Copyright 2005-2007 Sebastian Geerken <sgeerken@dillo.org> + * + * 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 3 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., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + + +#include "fltkcore.hh" +#include "fltkflatview.hh" +#include "fltkcomplexbutton.hh" +#include "../lout/misc.hh" + +#include <stdio.h> +#include <fltk/Widget.h> +#include <fltk/Group.h> +#include <fltk/Input.h> +#include <fltk/SecretInput.h> +#include <fltk/TextEditor.h> +#include <fltk/RadioButton.h> +#include <fltk/CheckButton.h> +#include <fltk/Choice.h> +#include <fltk/Browser.h> +#include <fltk/MultiBrowser.h> +#include <fltk/Font.h> +#include <fltk/draw.h> +#include <fltk/Symbol.h> +#include <fltk/Item.h> +#include <fltk/ItemGroup.h> +#include <fltk/events.h> + +namespace dw { +namespace fltk { +namespace ui { + +enum { RELIEF_X_THICKNESS = 5, RELIEF_Y_THICKNESS = 3 }; + +using namespace object; +using namespace container::typed; + +FltkResource::FltkResource (FltkPlatform *platform) +{ + this->platform = platform; + + allocation.x = 0; + allocation.y = 0; + allocation.width = 1; + allocation.ascent = 1; + allocation.descent = 0; + + style = NULL; +} + +/** + * This is not a constructor, since it calls some virtual methods, which + * should not be done in a C++ base constructor. + */ +void FltkResource::init (FltkPlatform *platform) +{ + viewsAndWidgets = new container::typed::List <ViewAndWidget> (true); + platform->attachResource (this); +} + +FltkResource::~FltkResource () +{ + platform->detachResource (this); + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + + if (viewAndWidget->widget) { + if (viewAndWidget->view) { + viewAndWidget->view->removeFltkWidget(viewAndWidget->widget); + } + delete viewAndWidget->widget; + } + + } + delete viewsAndWidgets; + if(style) + style->unref (); +} + +void FltkResource::attachView (FltkView *view) +{ + if (view->usesFltkWidgets ()) { + ViewAndWidget *viewAndWidget = new ViewAndWidget(); + viewAndWidget->view = view; + + viewAndWidget->widget = createNewWidget (&allocation); + viewAndWidget->view->addFltkWidget (viewAndWidget->widget, &allocation); + viewsAndWidgets->append (viewAndWidget); + if (style) + setWidgetStyle (viewAndWidget->widget, style); + } +} + +void FltkResource::detachView (FltkView *view) +{ + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + if (viewAndWidget->view == view) { + viewsAndWidgets->removeRef (viewAndWidget); + return; + } + } + + fprintf (stderr, "FltkResource::detachView: View not found."); +} + +void FltkResource::sizeAllocate (core::Allocation *allocation) +{ + this->allocation = *allocation; + + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + viewAndWidget->view->allocateFltkWidget (viewAndWidget->widget, + allocation); + } +} + +void FltkResource::draw (core::View *view, core::Rectangle *area) +{ + FltkView *fltkView = (FltkView*)view; + if (fltkView->usesFltkWidgets ()) { + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + if (viewAndWidget->view == fltkView) { + fltkView->drawFltkWidget (viewAndWidget->widget, area); + break; + } + } + } +} + +void FltkResource::setStyle (core::style::Style *style) +{ + if(this->style) + this->style->unref (); + + this->style = style; + style->ref (); + + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + setWidgetStyle (viewAndWidget->widget, style); + } +} + +void FltkResource::setWidgetStyle (::fltk::Widget *widget, + core::style::Style *style) +{ + /** \bug label or text? */ + + FltkFont *font = (FltkFont*)style->font; + widget->labelsize (font->size); + widget->labelfont (font->font); + widget->textsize (font->size); + widget->textfont (font->font); + + FltkColor *bg = (FltkColor*)style->backgroundColor; + if (bg) { + if (style->color) { + /* + * todo: if/when CSS is implemented, test whether style->color + * will consistently provide readable widgets. + */ + int32_t c = bg->colors[FltkColor::SHADING_NORMAL]; + int r = (c >> 24) & 0xff, g = (c >> 16) & 0xff, b = (c >> 8) & 0xff; + bool light = (r + g >= 0x150) || (r + g + b >= 0x180); + + widget->labelcolor(light? ::fltk::BLACK : ::fltk::WHITE); + widget->textcolor(light? ::fltk::BLACK : ::fltk::WHITE); + widget->selection_color(light? ::fltk::BLACK : ::fltk::WHITE); + } + + widget->color(bg->colors[FltkColor::SHADING_NORMAL]); + widget->buttoncolor(bg->colors[FltkColor::SHADING_NORMAL]); + widget->highlight_color(bg->colors[FltkColor::SHADING_LIGHT]); + widget->selection_textcolor(bg->colors[FltkColor::SHADING_NORMAL]); + } +} + +bool FltkResource::isEnabled () +{ + /** \bug Not implemented. */ + return true; +} + +void FltkResource::setEnabled (bool enabled) +{ + /** \bug Not implemented. */ +} + +// ---------------------------------------------------------------------- + +template <class I> void FltkSpecificResource<I>::sizeAllocate (core::Allocation + *allocation) +{ + FltkResource::sizeAllocate (allocation); +} + +template <class I> void FltkSpecificResource<I>::draw (core::View *view, + core::Rectangle *area) +{ + FltkResource::draw (view, area); +} + +template <class I> void FltkSpecificResource<I>::setStyle (core::style::Style + *style) +{ + FltkResource::setStyle (style); +} + +template <class I> bool FltkSpecificResource<I>::isEnabled () +{ + return FltkResource::isEnabled (); +} + +template <class I> void FltkSpecificResource<I>::setEnabled (bool enabled) +{ + FltkResource::setEnabled (enabled); +} + +// ---------------------------------------------------------------------- + +FltkLabelButtonResource::FltkLabelButtonResource (FltkPlatform *platform, + const char *label): + FltkSpecificResource <dw::core::ui::LabelButtonResource> (platform) +{ + this->label = strdup (label); + init (platform); +} + +FltkLabelButtonResource::~FltkLabelButtonResource () +{ + delete label; +} + +::fltk::Widget *FltkLabelButtonResource::createNewWidget (core::Allocation + *allocation) +{ + ::fltk::Button *button = + new ::fltk::Button (allocation->x, allocation->y, allocation->width, + allocation->ascent + allocation->descent, + label); + button->callback (widgetCallback, this); + button->when (::fltk::WHEN_RELEASE); + return button; +} + +void FltkLabelButtonResource::sizeRequest (core::Requisition *requisition) +{ + if (style) { + FltkFont *font = (FltkFont*)style->font; + ::fltk::setfont(font->font,font->size); + requisition->width = + (int)::fltk::getwidth (label, strlen (label)) + + 2 * RELIEF_X_THICKNESS; + requisition->ascent = font->ascent + RELIEF_Y_THICKNESS; + requisition->descent = font->descent + RELIEF_Y_THICKNESS; + } else { + requisition->width = 1; + requisition->ascent = 1; + requisition->descent = 0; + } +} + +void FltkLabelButtonResource::widgetCallback (::fltk::Widget *widget, + void *data) +{ + if (widget->when () & ::fltk::WHEN_RELEASE) + ((FltkLabelButtonResource*)data)->emitActivate (); +} + +const char *FltkLabelButtonResource::getLabel () +{ + return label; +} + + +void FltkLabelButtonResource::setLabel (const char *label) +{ + delete this->label; + this->label = strdup (label); + + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + viewAndWidget->widget->label (this->label); + } + + queueResize (true); +} + +// ---------------------------------------------------------------------- + +FltkComplexButtonResource::FltkComplexButtonResource (FltkPlatform *platform, + dw::core::Widget + *widget, bool relief): + FltkSpecificResource <dw::core::ui::ComplexButtonResource> (platform) +{ + viewsAndViews = new container::typed::List <ViewAndView> (true); + this->relief = relief; + FltkResource::init (platform); + ComplexButtonResource::init (widget); +} + +FltkComplexButtonResource::~FltkComplexButtonResource () +{ + delete viewsAndViews; +} + +void FltkComplexButtonResource::widgetCallback (::fltk::Widget *widget, + void *data) +{ + FltkComplexButtonResource *res = (FltkComplexButtonResource*)data; + + /* would be best not to send click pos. if the image could not be loaded */ + if (::fltk::event() == ::fltk::RELEASE && + ::fltk::event_button() == ::fltk::LeftButton) { + res->click_x = ::fltk::event_x(); + res->click_y = ::fltk::event_y(); + res->emitActivate (); + } else { + ((FltkViewBase*)res->lastFlatView)->handle(::fltk::event()); + } +} + +dw::core::Platform *FltkComplexButtonResource::createPlatform () +{ + return new FltkPlatform (); +} + +void FltkComplexButtonResource::attachView (FltkView *view) +{ + FltkResource::attachView (view); + + if (view->usesFltkWidgets ()) { + ViewAndView *viewAndView = new ViewAndView(); + viewAndView->topView = view; + viewAndView->flatView = lastFlatView; + viewsAndViews->append (viewAndView); + } +} + +void FltkComplexButtonResource::detachView (FltkView *view) +{ + FltkResource::detachView (view); + + for (Iterator <ViewAndView> it = viewsAndViews->iterator (); + it.hasNext(); ) { + ViewAndView *viewAndView = it.getNext (); + if (viewAndView->topView == view) { + viewsAndViews->removeRef (viewAndView); + return; + } + } + + fprintf (stderr, + "FltkComplexButtonResourceResource::detachView: View not " + "found.\n"); +} + +void FltkComplexButtonResource::sizeAllocate (core::Allocation *allocation) +{ + FltkResource::sizeAllocate (allocation); + + for (Iterator <ViewAndView> it = viewsAndViews->iterator (); + it.hasNext(); ) { + ViewAndView *viewAndView = it.getNext (); + ((FltkFlatView*)viewAndView->flatView)->resize ( + reliefXThickness (), + reliefYThickness (), + allocation->width - 2 * reliefXThickness (), + allocation->ascent + allocation->descent - 2 * reliefYThickness ()); + + ((FltkFlatView*)viewAndView->flatView)->parent ()->init_sizes (); + } +} + +void FltkComplexButtonResource::setLayout (dw::core::Layout *layout) +{ + for (Iterator <ViewAndView> it = viewsAndViews->iterator (); + it.hasNext(); ) { + ViewAndView *viewAndView = it.getNext (); + layout->attachView (viewAndView->flatView); + } +} + +int FltkComplexButtonResource::reliefXThickness () +{ + return relief ? RELIEF_X_THICKNESS : 0; +} + +int FltkComplexButtonResource::reliefYThickness () +{ + return relief ? RELIEF_Y_THICKNESS : 0; +} + + +::fltk::Widget *FltkComplexButtonResource::createNewWidget (core::Allocation + *allocation) +{ + ComplexButton *button = + new ComplexButton (allocation->x, allocation->y, allocation->width, + allocation->ascent + allocation->descent); + button->callback (widgetCallback, this); + button->when (::fltk::WHEN_RELEASE); + if (!relief) + button->box(::fltk::FLAT_BOX); + + FltkFlatView *flatView = + new FltkFlatView (allocation->x + reliefXThickness (), + allocation->y + reliefYThickness (), + allocation->width - 2 * reliefXThickness (), + allocation->ascent + allocation->descent + - 2 * reliefYThickness ()); + button->add (flatView); + + lastFlatView = flatView; + + if (layout) + layout->attachView (lastFlatView); + return button; +} + +// ---------------------------------------------------------------------- + +FltkEntryResource::FltkEntryResource (FltkPlatform *platform, int maxLength, + bool password): + FltkSpecificResource <dw::core::ui::EntryResource> (platform) +{ + this->maxLength = maxLength; + this->password = password; + + initText = NULL; + editable = false; + + init (platform); +} + +FltkEntryResource::~FltkEntryResource () +{ + if (initText) + delete initText; +} + +::fltk::Widget *FltkEntryResource::createNewWidget (core::Allocation + *allocation) +{ + ::fltk::Input *input = + password ? + new ::fltk::SecretInput (allocation->x, allocation->y, + allocation->width, + allocation->ascent + allocation->descent) : + new ::fltk::Input (allocation->x, allocation->y, allocation->width, + allocation->ascent + allocation->descent); + input->callback (widgetCallback, this); + input->when (::fltk::WHEN_ENTER_KEY_ALWAYS); + + if (viewsAndWidgets->isEmpty ()) { + // First widget created, attach the set text. + if (initText) + input->value (initText); + } else + input->value + (((::fltk::Input*)viewsAndWidgets->getFirst()->widget)->value ()); + + return input; +} + +void FltkEntryResource::sizeRequest (core::Requisition *requisition) +{ + if (style) { + FltkFont *font = (FltkFont*)style->font; + ::fltk::setfont(font->font,font->size); + requisition->width = + (int)::fltk::getwidth ("M", 1) + * (maxLength == UNLIMITED_MAX_LENGTH ? 10 : maxLength) + + 2 * RELIEF_X_THICKNESS; + requisition->ascent = font->ascent + RELIEF_Y_THICKNESS; + requisition->descent = font->descent + RELIEF_Y_THICKNESS; + } else { + requisition->width = 1; + requisition->ascent = 1; + requisition->descent = 0; + } +} + +void FltkEntryResource::widgetCallback (::fltk::Widget *widget, + void *data) +{ + /* The (::fltk::event_key() == ::fltk::ReturnKey) test + * is necessary because WHEN_ENTER_KEY also includes + * other events we're not interested in. For instance pressing + * The Back or Forward, buttons, or the first click on a rendered + * page. BUG: this must be investigated and reported to FLTK2 team + */ + printf ("when = %d\n", widget->when ()); + if ((widget->when () & ::fltk::WHEN_ENTER_KEY_ALWAYS) && + (::fltk::event_key() == ::fltk::ReturnKey)) + ((FltkEntryResource*)data)->emitActivate (); +} + +const char *FltkEntryResource::getText () +{ + if (viewsAndWidgets->isEmpty ()) + return initText; + else + return ((::fltk::Input*)viewsAndWidgets->getFirst()->widget)->value (); +} + +void FltkEntryResource::setText (const char *text) +{ + if (initText) + delete initText; + initText = strdup (text); + + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + ((::fltk::Input*)viewAndWidget->widget)->value (initText); + } +} + +bool FltkEntryResource::isEditable () +{ + return editable; +} + +void FltkEntryResource::setEditable (bool editable) +{ + this->editable = editable; +} + +// ---------------------------------------------------------------------- + +FltkMultiLineTextResource::FltkMultiLineTextResource (FltkPlatform *platform, + int cols, int rows): + FltkSpecificResource <dw::core::ui::MultiLineTextResource> (platform) +{ + buffer = new ::fltk::TextBuffer; + editable = false; + + numCols = cols; + numRows = rows; + + // Check values. Upper bound check is left to the caller. + if (numCols < 1) { + fprintf (stderr, "WARNING: numCols = %d is set to 1.\n", numCols); + numCols = 1; + } + if (numRows < 1) { + fprintf (stderr, "WARNING: numRows = %d is set to 1.\n", numRows); + numRows = 1; + } + + init (platform); +} + +FltkMultiLineTextResource::~FltkMultiLineTextResource () +{ + /* Free memory avoiding a double-free of text buffers */ + for (Iterator <ViewAndWidget> it = viewsAndWidgets->iterator (); + it.hasNext(); ) { + ViewAndWidget *viewAndWidget = it.getNext (); + ((::fltk::TextEditor *) viewAndWidget->widget)->buffer (0); + } + delete buffer; +} + +::fltk::Widget *FltkMultiLineTextResource::createNewWidget (core::Allocation + *allocation) +{ + ::fltk::TextEditor *text = + new ::fltk::TextEditor (allocation->x, allocation->y, + allocation->width, + allocation->ascent + allocation->descent); + text->buffer (buffer); + return text; +} + +void FltkMultiLineTextResource::sizeRequest (core::Requisition *requisition) +{ + if (style) { + FltkFont *font = (FltkFont*)style->font; + ::fltk::setfont(font->font,font->size); + requisition->width = + (int)::fltk::getwidth ("X", 1) * numCols + + 2 * RELIEF_X_THICKNESS; + requisition->ascent = + font->ascent + RELIEF_Y_THICKNESS; + requisition->descent = + font->descent + + (font->ascent + font->descent) * (numRows - 1) + + RELIEF_Y_THICKNESS; + } else { + requisition->width = 1; + requisition->ascent = 1; + requisition->descent = 0; + } +} + +const char *FltkMultiLineTextResource::getText () +{ + return buffer->text (); +} + +void FltkMultiLineTextResource::setText (const char *text) +{ + buffer->text (text); +} + +bool FltkMultiLineTextResource::isEditable () +{ + return editable; +} + +void FltkMultiLineTextResource::setEditable (bool editable) +{ + this->editable = editable; +} + +// ---------------------------------------------------------------------- + +template <class I> +FltkToggleButtonResource<I>::FltkToggleButtonResource (FltkPlatform *platform, + bool activated): + FltkSpecificResource <I> (platform) +{ + initActivated = activated; +} + + +template <class I> +FltkToggleButtonResource<I>::~FltkToggleButtonResource () +{ +} + + +template <class I> +::fltk::Widget *FltkToggleButtonResource<I>::createNewWidget (core::Allocation + *allocation) +{ + ::fltk::Button *button = createNewButton (allocation); + + if (this->viewsAndWidgets->isEmpty ()) + button->value (initActivated); + else + button->value (((::fltk::Button*)this->viewsAndWidgets + ->getFirst()->widget)->value ()); + + return button; +} + + +template <class I> +void FltkToggleButtonResource<I>::sizeRequest (core::Requisition *requisition) +{ + /** \bug Random values. */ + requisition->width = 20; + requisition->ascent = 18; + requisition->descent = 5; +} + + +template <class I> +bool FltkToggleButtonResource<I>::FltkToggleButtonResource::isActivated () +{ + if (this->viewsAndWidgets->isEmpty ()) + return initActivated; + else + return + ((::fltk::Button*)this->viewsAndWidgets->getFirst()->widget) + ->value (); +} + + +template <class I> +void FltkToggleButtonResource<I>::setActivated (bool activated) +{ + initActivated = activated; + + for (Iterator <FltkResource::ViewAndWidget> it = + this->viewsAndWidgets->iterator (); + it.hasNext(); ) { + FltkResource::ViewAndWidget *viewAndWidget = it.getNext (); + ((::fltk::Button*)viewAndWidget->widget)->value (initActivated); + } +} + +// ---------------------------------------------------------------------- + +FltkCheckButtonResource::FltkCheckButtonResource (FltkPlatform *platform, + bool activated): + FltkToggleButtonResource<dw::core::ui::CheckButtonResource> (platform, + activated) +{ + init (platform); +} + + +FltkCheckButtonResource::~FltkCheckButtonResource () +{ +} + + +::fltk::Button *FltkCheckButtonResource::createNewButton (core::Allocation + *allocation) +{ + return + new ::fltk::CheckButton (allocation->x, allocation->y, allocation->width, + allocation->ascent + allocation->descent); +} + +// ---------------------------------------------------------------------- + +bool FltkRadioButtonResource::Group::FltkGroupIterator::hasNext () +{ + return it.hasNext (); +} + +dw::core::ui::RadioButtonResource +*FltkRadioButtonResource::Group::FltkGroupIterator::getNext () +{ + return (dw::core::ui::RadioButtonResource*)it.getNext (); +} + +void FltkRadioButtonResource::Group::FltkGroupIterator::unref () +{ + delete this; +} + + +FltkRadioButtonResource::Group::Group (FltkRadioButtonResource + *radioButtonResource) +{ + list = new container::typed::List <FltkRadioButtonResource> (false); + connect (radioButtonResource); +} + +FltkRadioButtonResource::Group::~Group () +{ + delete list; +} + +void FltkRadioButtonResource::Group::connect (FltkRadioButtonResource + *radioButtonResource) +{ + list->append (radioButtonResource); +} + +void FltkRadioButtonResource::Group::unconnect (FltkRadioButtonResource + *radioButtonResource) +{ + list->removeRef (radioButtonResource); + if (list->isEmpty ()) + delete this; +} + + +FltkRadioButtonResource::FltkRadioButtonResource (FltkPlatform *platform, + FltkRadioButtonResource + *groupedWith, + bool activated): + FltkToggleButtonResource<dw::core::ui::RadioButtonResource> (platform, + activated) +{ + init (platform); + + if (groupedWith) { + group = groupedWith->group; + group->connect (this); + } else + group = new Group (this); +} + + +FltkRadioButtonResource::~FltkRadioButtonResource () +{ + group->unconnect (this); +} + +dw::core::ui::RadioButtonResource::GroupIterator +*FltkRadioButtonResource::groupIterator () +{ + return group->groupIterator (); +} + +void FltkRadioButtonResource::widgetCallback (::fltk::Widget *widget, + void *data) +{ + if (widget->when () & ::fltk::WHEN_CHANGED) + ((FltkRadioButtonResource*)data)->buttonClicked (); +} + +void FltkRadioButtonResource::buttonClicked () +{ + for (Iterator <FltkRadioButtonResource> it = group->iterator (); + it.hasNext (); ) { + FltkRadioButtonResource *other = it.getNext (); + other->setActivated (other == this); + } +} + +::fltk::Button *FltkRadioButtonResource::createNewButton (core::Allocation + *allocation) +{ + /* + * Groups of fltk::RadioButton must be added to one fltk::Group, which is + * not possible in this context. For this, we do the grouping ourself, + * based on FltkRadioButtonResource::Group. + * + * What we actually need for this, is a widget, which behaves like a + * check button, but looks like a radio button. The first depends on the + * type, the second on the style. Since the type is simpler to change + * than the style, we create a radio button, and then change the type + * (instead of creating a check button, and changing the style). + */ + + ::fltk::Button *button = + new ::fltk::RadioButton (allocation->x, allocation->y, + allocation->width, + allocation->ascent + allocation->descent); + button->when (::fltk::WHEN_CHANGED); + button->callback (widgetCallback, this); + button->type (::fltk::Button::TOGGLE); + + return button; +} + +// ---------------------------------------------------------------------- + +template <class I> FltkSelectionResource<I>::Item::Item (Type type, + const char *name, + bool enabled, + bool selected) +{ + this->type = type; + this->name = name ? strdup (name) : NULL; + this->enabled = enabled; + initSelected = selected; +} + +template <class I> FltkSelectionResource<I>::Item::~Item () +{ + if (name) + delete name; +} + +template <class I> +::fltk::Item *FltkSelectionResource<I>::Item::createNewWidget (int index) +{ + ::fltk::Item *item = new ::fltk::Item (name); + item->user_data ((void *) index); + return item; +} + +template <class I> +::fltk::ItemGroup * +FltkSelectionResource<I>::Item::createNewGroupWidget () +{ + ::fltk::ItemGroup *itemGroup = new ::fltk::ItemGroup (name); + itemGroup->user_data ((void *) -1L); + return itemGroup; +} + + +template <class I> +FltkSelectionResource<I>::WidgetStack::WidgetStack (::fltk::Menu *widget) +{ + this->widget = widget; + this->stack = new Stack <TypedPointer < ::fltk::Menu> > (true); +} + +template <class I> FltkSelectionResource<I>::WidgetStack::~WidgetStack () +{ + delete stack; +} + + +template <class I> +FltkSelectionResource<I>::FltkSelectionResource (FltkPlatform *platform): + FltkSpecificResource<I> (platform) +{ + widgetStacks = new List <WidgetStack> (true); + allItems = new List <Item> (true); + items = new Vector <Item> (16, false); +} + +template <class I> FltkSelectionResource<I>::~FltkSelectionResource () +{ + delete widgetStacks; + delete allItems; + delete items; +} + +template <class I> dw::core::Iterator * +FltkSelectionResource<I>::iterator (dw::core::Content::Type mask, bool atEnd) +{ + /** \bug Implementation. */ + return new core::EmptyIterator (this->getEmbed (), mask, atEnd); +} + +template <class I> ::fltk::Widget * +FltkSelectionResource<I>::createNewWidget (core::Allocation *allocation) +{ + /** \todo Attributes (enabled, selected). */ + + ::fltk::Menu *menu = createNewMenu (allocation); + WidgetStack *widgetStack = new WidgetStack (menu); + widgetStack->stack->push (new TypedPointer < ::fltk::Menu> (menu)); + widgetStacks->append (widgetStack); + + + ::fltk::Menu *itemGroup; + ::fltk::Item *itemWidget; + + ::fltk::Group *currGroup = widgetStack->stack->getTop()->getTypedValue(); + + int index = 0; + for (Iterator <Item> it = allItems->iterator (); it.hasNext (); ) { + Item *item = it.getNext (); + switch (item->type) { + case Item::ITEM: + itemWidget = item->createNewWidget (index++); + currGroup->add (itemWidget); + break; + + case Item::START: + itemGroup = item->createNewGroupWidget (); + currGroup->add (itemGroup); + widgetStack->stack->push (new TypedPointer < ::fltk::Menu> (menu)); + currGroup = itemGroup; + break; + + case Item::END: + widgetStack->stack->pop (); + currGroup = widgetStack->stack->getTop()->getTypedValue(); + break; + } + } + + return menu; +} + +template <class I> +typename FltkSelectionResource<I>::Item * +FltkSelectionResource<I>::createNewItem (typename Item::Type type, + const char *name, + bool enabled, + bool selected) { + return new Item(type,name,enabled,selected); +} + +template <class I> void FltkSelectionResource<I>::addItem (const char *str, + bool enabled, + bool selected) +{ + int index = items->size (); + Item *item = createNewItem (Item::ITEM, str, enabled, selected); + items->put (item); + allItems->append (item); + + for (Iterator <WidgetStack> it = widgetStacks->iterator (); + it.hasNext(); ) { + WidgetStack *widgetStack = it.getNext (); + ::fltk::Item *itemWidget = item->createNewWidget (index); + widgetStack->stack->getTop()->getTypedValue()->add (itemWidget); + + if (!enabled) + itemWidget->deactivate (); + + if (selected) { + itemWidget->set_selected(); + if (setSelectedItems ()) { + // Handle multiple item selection. + int pos[widgetStack->stack->size ()]; + int i; + Iterator <TypedPointer < ::fltk::Menu> > it; + for (it = widgetStack->stack->iterator (), + i = widgetStack->stack->size () - 1; + it.hasNext (); + i--) { + TypedPointer < ::fltk::Menu> * p = it.getNext (); + pos[i] = p->getTypedValue()->children () - 1; + } + widgetStack->widget->set_item (pos, widgetStack->stack->size ()); + } + } + } +} + +template <class I> void FltkSelectionResource<I>::pushGroup (const char *name, + bool enabled) +{ + Item *item = createNewItem (Item::START, name, enabled); + allItems->append (item); + + for (Iterator <WidgetStack> it = widgetStacks->iterator (); + it.hasNext(); ) { + WidgetStack *widgetStack = it.getNext (); + ::fltk::ItemGroup *group = item->createNewGroupWidget (); + widgetStack->stack->getTop()->getTypedValue()->add (group); + widgetStack->stack->push (new TypedPointer < ::fltk::Menu> (group)); + if(!enabled) + group->deactivate (); + } +} + +template <class I> void FltkSelectionResource<I>::popGroup () +{ + Item *item = createNewItem (Item::END); + allItems->append (item); + + for (Iterator <WidgetStack> it = widgetStacks->iterator (); + it.hasNext(); ) { + WidgetStack *widgetStack = it.getNext (); + widgetStack->stack->pop (); + } +} + +template <class I> int FltkSelectionResource<I>::getNumberOfItems () +{ + return items->size (); +} + +template <class I> const char *FltkSelectionResource<I>::getItem (int index) +{ + return items->get(index)->name; +} + +template <class I> int FltkSelectionResource<I>::getMaxStringWidth () +{ + int width = 0, numberOfItems = getNumberOfItems (); + for (int i = 0; i < numberOfItems; i++) { + int len = (int)::fltk::getwidth (getItem(i)); + if (len > width) width = len; + } + return width; +} + +// ---------------------------------------------------------------------- + +FltkOptionMenuResource::FltkOptionMenuResource (FltkPlatform *platform): + FltkSelectionResource <dw::core::ui::OptionMenuResource> (platform), + selection(-1) +{ + init (platform); +} + +FltkOptionMenuResource::~FltkOptionMenuResource () +{ +} + + +::fltk::Menu *FltkOptionMenuResource::createNewMenu (core::Allocation + *allocation) +{ + ::fltk::Menu *menu = + new ::fltk::Choice (allocation->x, allocation->y, + allocation->width, + allocation->ascent + allocation->descent); + menu->callback(widgetCallback,this); + return menu; +} + +void FltkOptionMenuResource::widgetCallback (::fltk::Widget *widget, + void *data) +{ + ((FltkOptionMenuResource *) data)->selection = + (long) (((::fltk::Menu *) widget)->item()->user_data()); +} + +void FltkOptionMenuResource::sizeRequest (core::Requisition *requisition) +{ + if (style) { + FltkFont *font = (FltkFont*)style->font; + ::fltk::setfont(font->font,font->size); + int maxStringWidth = getMaxStringWidth (); + requisition->ascent = font->ascent + RELIEF_Y_THICKNESS; + requisition->descent = font->descent + RELIEF_Y_THICKNESS; + requisition->width = maxStringWidth + + (requisition->ascent + requisition->descent) * 4 / 5 + + 2 * RELIEF_X_THICKNESS; + } else { + requisition->width = 1; + requisition->ascent = 1; + requisition->descent = 0; + } +} + +void FltkOptionMenuResource::addItem (const char *str, + bool enabled, bool selected) +{ + FltkSelectionResource<dw::core::ui::OptionMenuResource>::addItem + (str,enabled,selected); + if (selected) + selection = (items->size ()) - 1; + + queueResize (true); +} + +bool FltkOptionMenuResource::isSelected (int index) +{ + return index == selection; +} + +// ---------------------------------------------------------------------- + +FltkListResource::FltkListResource (FltkPlatform *platform, + core::ui::ListResource::SelectionMode + selectionMode): + FltkSelectionResource <dw::core::ui::ListResource> (platform), + itemsSelected(8) +{ + init (platform); +} + +FltkListResource::~FltkListResource () +{ +} + + +::fltk::Menu *FltkListResource::createNewMenu (core::Allocation *allocation) +{ + ::fltk::Menu *menu = + new ::fltk::MultiBrowser (allocation->x, allocation->y, + allocation->width, + allocation->ascent + allocation->descent); + menu->callback(widgetCallback,this); + menu->when(::fltk::WHEN_CHANGED); + return menu; +} + +void FltkListResource::widgetCallback (::fltk::Widget *widget, void *data) +{ + ::fltk::Widget *fltkItem = ((::fltk::Menu *) widget)->item (); + int index = (long) (fltkItem->user_data ()); + if (index > -1) { + bool selected = fltkItem->selected (); + ((FltkListResource *) data)->itemsSelected.set (index, selected); + } +} + +void FltkListResource::addItem (const char *str, bool enabled, bool selected) +{ + FltkSelectionResource<dw::core::ui::ListResource>::addItem + (str,enabled,selected); + int index = itemsSelected.size (); + itemsSelected.increase (); + itemsSelected.set (index,selected); + queueResize (true); +} + +void FltkListResource::sizeRequest (core::Requisition *requisition) +{ + if (style) { + FltkFont *font = (FltkFont*)style->font; + ::fltk::setfont(font->font,font->size); + int maxStringWidth = getMaxStringWidth (); + requisition->ascent = font->ascent + RELIEF_Y_THICKNESS; + requisition->descent = + (getNumberOfItems () - 1) * (font->ascent) + font->descent; + requisition->width = maxStringWidth + + (font->ascent + font->descent) * 4 / 5 + + 2 * RELIEF_X_THICKNESS; + } else { + requisition->width = 1; + requisition->ascent = 1; + requisition->descent = 0; + } +} + +bool FltkListResource::isSelected (int index) +{ + return itemsSelected.get (index); +} + +} // namespace ui +} // namespace fltk +} // namespace dw + |