/*************************************************************************
scroll the tab pane to left or right depending of the clicked button
*************************************************************************/
bool TabControl::handleScrollPane(const EventArgs& e)
{
const WindowEventArgs& wargs = static_cast<const WindowEventArgs&>(e);
size_t i;
float delta = 0;
// Find the leftmost visible button
for (i = 0; i < d_tabButtonVector.size(); ++i)
{
if (d_tabButtonVector [i]->isVisible (true))
break;
delta = d_tabButtonVector [i]->getPixelSize ().d_width;
}
if (wargs.window->getName () == getName() + ButtonScrollLeftSuffix)
{
if (delta == 0.0f && i < d_tabButtonVector.size ())
delta = d_tabButtonVector [i]->getPixelSize ().d_width;
// scroll button pane to the right
d_firstTabOffset += delta;
}
else if (i < d_tabButtonVector.size ())
// scroll button pane to left
d_firstTabOffset -= d_tabButtonVector [i]->getPixelSize ().d_width;
performChildWindowLayout();
return true;
}
bool TabControl::handleDraggedPane(const EventArgs& e)
{
const MouseEventArgs& me = static_cast<const MouseEventArgs&>(e);
if (me.button == MiddleButton)
{
// This is the middle-mouse-click event, remember initial drag position
Window *but_pane = getTabButtonPane();
d_btGrabPos = (me.position.d_x -
but_pane->getOuterRectClipper().d_left) -
d_firstTabOffset;
}
else if (me.button == NoButton)
{
// Regular mouse move event
Window *but_pane = getTabButtonPane();
float new_to = (me.position.d_x -
but_pane->getOuterRectClipper().d_left) -
d_btGrabPos;
if ((new_to < d_firstTabOffset - 0.9) ||
(new_to > d_firstTabOffset + 0.9))
{
d_firstTabOffset = new_to;
performChildWindowLayout();
}
}
return true;
}
/*************************************************************************
Add a new tab
*************************************************************************/
void TabControl::addTab(Window* wnd)
{
// abort attempts to add null window pointers, but log it for tracking.
if (!wnd)
{
Logger::getSingleton().logEvent("Attempt to add null window pointer as "
"tab to TabControl '" + getName() + "'. Ignoring!", Informative);
return;
}
// Create a new TabButton
addButtonForTabContent(wnd);
// Add the window to the content pane
getTabPane()->addChildWindow(wnd);
// Auto-select?
if (getTabCount() == 1)
setSelectedTab(wnd->getName());
else
// initialise invisible content
wnd->setVisible(false);
// when adding the 1st page, autosize tab pane height
if (d_tabHeight.d_scale == 0 && d_tabHeight.d_offset == -1)
d_tabHeight.d_offset = 8 + getFont()->getFontHeight ();
// Just request redraw
performChildWindowLayout();
invalidate();
// Subscribe to text changed event so that we can resize as needed
d_eventConnections[wnd] =
wnd->subscribeEvent(Window::EventTextChanged,
Event::Subscriber(&TabControl::handleContentWindowTextChanged,
this));
}
void Spinner::initialise(void)
{
Window::initialise();
// create all the component widgets
d_increaseButton = createIncreaseButton(getName() + "__auto_incbtn__");
addChildWindow(d_increaseButton);
d_decreaseButton = createDecreaseButton(getName() + "__auto_decbtn__");
addChildWindow(d_decreaseButton);
d_editbox = createEditbox(getName() + "__auto_editbox__");
addChildWindow(d_editbox);
// setup component controls
d_increaseButton->setWantsMultiClickEvents(false);
d_increaseButton->setMouseAutoRepeatEnabled(true);
d_decreaseButton->setWantsMultiClickEvents(false);
d_decreaseButton->setMouseAutoRepeatEnabled(true);
// perform event subscriptions.
d_increaseButton->subscribeEvent(Window::EventMouseButtonDown, Event::Subscriber(&Spinner::handleIncreaseButton, this));
d_decreaseButton->subscribeEvent(Window::EventMouseButtonDown, Event::Subscriber(&Spinner::handleDecreaseButton, this));
d_editbox->subscribeEvent(Window::EventTextChanged, Event::Subscriber(&Spinner::handleEditTextChange, this));
// final initialisation
setTextInputMode(Integer);
setCurrentValue(0.0f);
performChildWindowLayout();
}
//----------------------------------------------------------------------------//
void Scrollbar::initialiseComponents(void)
{
// Set up thumb
Thumb* const t = getThumb();
t->subscribeEvent(Thumb::EventThumbPositionChanged,
Event::Subscriber(&CEGUI::Scrollbar::handleThumbMoved,
this));
t->subscribeEvent(Thumb::EventThumbTrackStarted,
Event::Subscriber(&CEGUI::Scrollbar::handleThumbTrackStarted,
this));
t->subscribeEvent(Thumb::EventThumbTrackEnded,
Event::Subscriber(&CEGUI::Scrollbar::handleThumbTrackEnded,
this));
// set up Increase button
getIncreaseButton()->
subscribeEvent(PushButton::EventMouseButtonDown,
Event::Subscriber(&CEGUI::Scrollbar::handleIncreaseClicked,
this));
// set up Decrease button
getDecreaseButton()->
subscribeEvent(PushButton::EventMouseButtonDown,
Event::Subscriber(&CEGUI::Scrollbar::handleDecreaseClicked,
this));
// do initial layout
performChildWindowLayout();
}
/*************************************************************************
Set the tab text padding
*************************************************************************/
void TabControl::setAbsoluteTabTextPadding(float height)
{
d_abs_tabPadding = height;
d_rel_tabPadding = absoluteToRelativeY(height);
performChildWindowLayout();
}
/*************************************************************************
Remove a tab by ID
*************************************************************************/
void TabControl::removeTab(uint ID)
{
// do nothing if given window is not attached as a tab.
if (!d_tabContentPane->isChild(ID))
return;
Window* wnd = d_tabContentPane->getChild(ID);
// Was this selected?
bool reselect = wnd->isVisible();
// Tab buttons are the 2nd onward children
d_tabContentPane->removeChildWindow(ID);
// remove button too
removeButtonForTabContent(wnd);
if (reselect)
{
// Select another tab
if (getTabCount() > 0)
{
setSelectedTab(d_tabContentPane->getChildAtIdx(0)->getName());
}
}
performChildWindowLayout();
requestRedraw();
}
/*************************************************************************
Set the tab height
*************************************************************************/
void TabControl::setAbsoluteTabHeight(float height)
{
d_abs_tabHeight = height;
d_rel_tabHeight = absoluteToRelativeY(height);
performChildWindowLayout();
}
void FalagardChatHistory::initialise(void)
{
// create the component sub-widgets
d_parentWindow = static_cast<ParentWindow*>(WindowManager::getSingleton().getWindow(getName() + "__auto_parent__"));
d_vertScrollbar = static_cast<Scrollbar*>(WindowManager::getSingleton().getWindow(getName() + "__auto_vscrollbar__"));
d_toEnd = static_cast<PushButton*>(WindowManager::getSingleton().getWindow(getName() + "__auto_toend_btn__"));
// alawys show.
d_vertScrollbar->show();
d_vertScrollbar->useSpecialThumb(true);
d_parentWindow->setChatHistoryWindow(this);
d_parentWindow->setMouseLButtonHollow(true);
d_parentWindow->setMouseRButtonHollow(true);
addChildWindow(d_vertScrollbar);
addChildWindow(d_toEnd);
//Resize child window(VerscrollBar and ParentWindow)
performChildWindowLayout();
//Resize all child elements.
performWindowLayout();
// event subscription
d_vertScrollbar->setScrollPosition(0);
d_vertScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&FalagardChatHistory::handleScrollbarChange, this));
d_toEnd->subscribeEvent(PushButton::EventMouseButtonDown, Event::Subscriber(&FalagardChatHistory::handleToEndBtnClick, this));
}
/*************************************************************************
Handler for when text changes
*************************************************************************/
void FrameWindow::onTextChanged(WindowEventArgs& e)
{
Window::onTextChanged(e);
// pass this onto titlebar component.
getTitlebar()->setText(d_text);
// maybe the user is using a fontdim for titlebar dimensions ;)
performChildWindowLayout();
}
//----------------------------------------------------------------------------//
void LayoutContainer::onParentSized(ElementEventArgs& e)
{
// This is intentionally not Window::onParentSized.
Element::onParentSized(e);
// force update of child positioning.
notifyScreenAreaChanged(true);
performChildWindowLayout(true, true);
}
void SettingComboBox::initialiseComponents()
{
CEGUI::Combobox* box = getComboBoxW();
// internal event wiring
box->subscribeEvent(CEGUI::Combobox::EventListSelectionAccepted, CEGUI::Event::Subscriber(&SettingComboBox::onSelectionAccepted, this));
// put components in their initial positions
performChildWindowLayout();
}
bool TabControl::handleWheeledPane(const EventArgs& e)
{
const MouseEventArgs& me = static_cast<const MouseEventArgs&>(e);
Window *but_pane = getTabButtonPane();
float delta = but_pane->getOuterRectClipper().getWidth () / 20;
d_firstTabOffset -= me.wheelChange * delta;
performChildWindowLayout();
return true;
}
/*************************************************************************
Initialise the Window based object ready for use.
*************************************************************************/
void Listbox::initialiseComponents(void)
{
// get the component sub-widgets
Scrollbar* vertScrollbar = getVertScrollbar();
Scrollbar* horzScrollbar = getHorzScrollbar();
vertScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&Listbox::handle_scrollChange, this));
horzScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&Listbox::handle_scrollChange, this));
configureScrollbars();
performChildWindowLayout();
}
/*************************************************************************
Initialises the Window based object ready for use.
*************************************************************************/
void Slider::initialiseComponents(void)
{
// get thumb
Thumb* thumb = getThumb();
// bind handler to thumb events
thumb->subscribeEvent(Thumb::EventThumbPositionChanged, Event::Subscriber(&CEGUI::Slider::handleThumbMoved, this));
thumb->subscribeEvent(Thumb::EventThumbTrackStarted, Event::Subscriber(&CEGUI::Slider::handleThumbTrackStarted, this));
thumb->subscribeEvent(Thumb::EventThumbTrackEnded, Event::Subscriber(&CEGUI::Slider::handleThumbTrackEnded, this));
performChildWindowLayout();
}
/*************************************************************************
Text changed on a content window
*************************************************************************/
bool TabControl::handleContentWindowTextChanged(const EventArgs& args)
{
// update text
const WindowEventArgs& wargs = static_cast<const WindowEventArgs&>(args);
Window* tabButton = getTabButtonPane()->getChild(
makeButtonName(wargs.window));
tabButton->setText(wargs.window->getText());
// sort out the layout
performChildWindowLayout();
invalidate();
return true;
}
/*************************************************************************
Make tab visible implementation
*************************************************************************/
void TabControl::makeTabVisible_impl(Window* wnd)
{
TabButton *tb = 0;
for (size_t i = 0; i < d_tabButtonVector.size (); ++i)
{
// get corresponding tab button and content window
tb = d_tabButtonVector [i];
Window* child = tb->getTargetWindow();
if (child == wnd)
break;
tb = 0;
}
if (!tb)
return;
float ww = getPixelSize ().d_width;
float x = tb->getXPosition().asAbsolute (ww);
float w = tb->getPixelSize ().d_width;
float lx = 0, rx = ww;
Window *scrollLeftBtn = 0, *scrollRightBtn = 0;
String name = getName() + ButtonScrollLeftSuffix;
if (WindowManager::getSingleton().isWindowPresent (name))
{
scrollLeftBtn = WindowManager::getSingleton().getWindow (name);
lx = scrollLeftBtn->getArea ().d_max.d_x.asAbsolute (ww);
scrollLeftBtn->setWantsMultiClickEvents (false);
}
name = getName() + ButtonScrollRightSuffix;
if (WindowManager::getSingleton().isWindowPresent (name))
{
scrollRightBtn = WindowManager::getSingleton().getWindow (name);
rx = scrollRightBtn->getXPosition ().asAbsolute (ww);
scrollRightBtn->setWantsMultiClickEvents (false);
}
if (x < lx)
d_firstTabOffset += lx - x;
else
{
if (x + w <= rx)
return; // nothing to do
d_firstTabOffset += rx - (x + w);
}
performChildWindowLayout ();
}
/*************************************************************************
Initialise the Window based object ready for use.
*************************************************************************/
void MultiLineEditbox::initialise(void)
{
// create the component sub-widgets
d_vertScrollbar = createVertScrollbar(getName() + "__auto_vscrollbar__");
d_horzScrollbar = createHorzScrollbar(getName() + "__auto_hscrollbar__");
addChildWindow(d_vertScrollbar);
addChildWindow(d_horzScrollbar);
d_vertScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&MultiLineEditbox::handle_scrollChange, this));
d_horzScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&MultiLineEditbox::handle_scrollChange, this));
formatText();
performChildWindowLayout();
}
/*************************************************************************
Initialises the Window based object ready for use.
*************************************************************************/
void FrameWindow::initialiseComponents(void)
{
// get component windows
Titlebar* titlebar = getTitlebar();
PushButton* closeButton = getCloseButton();
// configure titlebar
titlebar->setDraggingEnabled(d_dragMovable);
titlebar->setText(d_text);
// bind handler to close button 'Click' event
closeButton->subscribeEvent(PushButton::EventClicked, Event::Subscriber(&CEGUI::FrameWindow::closeClickHandler, this));
performChildWindowLayout();
}
/*************************************************************************
Initialise the Window based object ready for use.
*************************************************************************/
void TabControl::initialiseComponents(void)
{
performChildWindowLayout();
String name = getName () + ButtonScrollLeftSuffix;
if (WindowManager::getSingleton().isWindowPresent (name))
WindowManager::getSingleton().getWindow (name)->subscribeEvent (
PushButton::EventClicked, Event::Subscriber(
&CEGUI::TabControl::handleScrollPane, this));
name = getName() + ButtonScrollRightSuffix;
if (WindowManager::getSingleton().isWindowPresent (name))
WindowManager::getSingleton().getWindow (name)->subscribeEvent (
PushButton::EventClicked, Event::Subscriber(
&CEGUI::TabControl::handleScrollPane, this));
}
//----------------------------------------------------------------------------//
void ColourPicker::initialiseComponents(void)
{
// get component windows
Window* colourRect = getColourRect();
// bind handler to close button 'Click' event
colourRect->subscribeEvent(Window::EventMouseClick,
Event::Subscriber(&ColourPicker::colourRect_ColourRectClickedHandler,
this));
performChildWindowLayout();
d_selectedColour =
getProperty<ColourRect>("Colour").d_top_left;
initialiseColourPickerControlsWindow();
}
//----------------------------------------------------------------------------//
void ScrollablePane::configureScrollbars(void)
{
// controls should all be valid by this stage
Scrollbar* const vertScrollbar = getVertScrollbar();
Scrollbar* const horzScrollbar = getHorzScrollbar();
const bool horzScrollBarWasVisible = horzScrollbar->isVisible();
const bool vertScrollBarWasVisible = vertScrollbar->isVisible();
// enable required scrollbars
vertScrollbar->setVisible(isVertScrollbarNeeded());
horzScrollbar->setVisible(isHorzScrollbarNeeded());
// Check if the addition of the horizontal scrollbar means we
// now also need the vertical bar.
if (horzScrollbar->isVisible())
vertScrollbar->setVisible(isVertScrollbarNeeded());
if (horzScrollBarWasVisible != horzScrollbar->isVisible() ||
vertScrollBarWasVisible != vertScrollbar->isVisible())
{
ElementEventArgs args(this);
onSized(args);
}
performChildWindowLayout();
// get viewable area
const Rectf viewableArea(getViewableArea());
// set up vertical scroll bar values
vertScrollbar->setDocumentSize(fabsf(d_contentRect.getHeight()));
vertScrollbar->setPageSize(viewableArea.getHeight());
vertScrollbar->setStepSize(ceguimax(1.0f, viewableArea.getHeight() * d_vertStep));
vertScrollbar->setOverlapSize(ceguimax(1.0f, viewableArea.getHeight() * d_vertOverlap));
vertScrollbar->setScrollPosition(vertScrollbar->getScrollPosition());
// set up horizontal scroll bar values
horzScrollbar->setDocumentSize(fabsf(d_contentRect.getWidth()));
horzScrollbar->setPageSize(viewableArea.getWidth());
horzScrollbar->setStepSize(ceguimax(1.0f, viewableArea.getWidth() * d_horzStep));
horzScrollbar->setOverlapSize(ceguimax(1.0f, viewableArea.getWidth() * d_horzOverlap));
horzScrollbar->setScrollPosition(horzScrollbar->getScrollPosition());
}
void ScrollablePane::configureScrollbars(void)
{
// controls should all be valid by this stage
assert(d_container != 0);
assert(d_vertScrollbar != 0);
assert(d_horzScrollbar != 0);
// enable required scrollbars
d_vertScrollbar->setVisible(isVertScrollbarNeeded());
d_horzScrollbar->setVisible(isHorzScrollbarNeeded());
// Check if the addition of the horizontal scrollbar means we
// now also need the vertical bar.
if (d_horzScrollbar->isVisible())
{
d_vertScrollbar->setVisible(isVertScrollbarNeeded());
}
performChildWindowLayout();
// get viewable area
Rect viewableArea(getViewableArea());
if( d_vertScrollbar )
{
// set up vertical scroll bar values
d_vertScrollbar->setDocumentSize(fabsf(d_contentRect.getHeight()));
d_vertScrollbar->setPageSize(viewableArea.getHeight());
d_vertScrollbar->setStepSize(ceguimax(1.0f, viewableArea.getHeight() * d_vertStep));
d_vertScrollbar->setOverlapSize(ceguimax(1.0f, viewableArea.getHeight() * d_vertOverlap));
d_vertScrollbar->setScrollPosition(d_vertScrollbar->getScrollPosition());
}
if( d_horzScrollbar )
{
// set up horizontal scroll bar values
d_horzScrollbar->setDocumentSize(fabsf(d_contentRect.getWidth()));
d_horzScrollbar->setPageSize(viewableArea.getWidth());
d_horzScrollbar->setStepSize(ceguimax(1.0f, viewableArea.getWidth() * d_horzStep));
d_horzScrollbar->setOverlapSize(ceguimax(1.0f, viewableArea.getWidth() * d_horzOverlap));
d_horzScrollbar->setScrollPosition(d_horzScrollbar->getScrollPosition());
}
}
/*************************************************************************
Initialises the Scrollbar object ready for use.
*************************************************************************/
void Scrollbar::initialise(void)
{
// Set up thumb
d_thumb = createThumb(getName() + "__auto_thumb__");
addChildWindow(d_thumb);
d_thumb->subscribeEvent(Thumb::EventThumbPositionChanged, Event::Subscriber(&CEGUI::Scrollbar::handleThumbMoved, this));
d_thumb->subscribeEvent(Thumb::EventThumbTrackStarted, Event::Subscriber(&CEGUI::Scrollbar::handleThumbTrackStarted, this));
d_thumb->subscribeEvent(Thumb::EventThumbTrackEnded, Event::Subscriber(&CEGUI::Scrollbar::handleThumbTrackEnded, this));
// set up Increase button
d_increase = createIncreaseButton(getName() + "__auto_incbtn__");
addChildWindow(d_increase);
d_increase->subscribeEvent(PushButton::EventMouseButtonDown, Event::Subscriber(&CEGUI::Scrollbar::handleIncreaseClicked, this));
// set up Decrease button
d_decrease = createDecreaseButton(getName() + "__auto_decbtn__");
addChildWindow(d_decrease);
d_decrease->subscribeEvent(PushButton::EventMouseButtonDown, Event::Subscriber(&CEGUI::Scrollbar::handleDecreaseClicked, this));
// do initial layout
performChildWindowLayout();
}
/*************************************************************************
Initialise the Window based object ready for use.
*************************************************************************/
void Tree::initialise(void)
{
// get WidgetLookFeel for the assigned look.
const WidgetLookFeel &wlf = WidgetLookManager::getSingleton().getWidgetLook(d_lookName);
const ImagerySection &tempOpenImagery = wlf.getImagerySection("OpenTreeButton");
const ImagerySection &tempCloseImagery = wlf.getImagerySection("CloseTreeButton");
d_openButtonImagery = &tempOpenImagery;
d_closeButtonImagery = &tempCloseImagery;
// create the component sub-widgets
d_vertScrollbar = createVertScrollbar("__auto_vscrollbar__");
d_horzScrollbar = createHorzScrollbar("__auto_hscrollbar__");
addChild(d_vertScrollbar);
addChild(d_horzScrollbar);
d_vertScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&Tree::handle_scrollChange, this));
d_horzScrollbar->subscribeEvent(Scrollbar::EventScrollPositionChanged, Event::Subscriber(&Tree::handle_scrollChange, this));
configureScrollbars();
performChildWindowLayout();
}
/*************************************************************************
Initialise the Window based object ready for use.
*************************************************************************/
void Combobox::initialise(void)
{
d_editbox = createEditbox(getName() + "__auto_editbox__");
d_droplist = createDropList(getName() + "__auto_droplist__");
d_button = createPushButton(getName() + "__auto_button__");
d_droplist->setFont(getFont());
d_editbox->setFont(getFont());
addChildWindow(d_editbox);
addChildWindow(d_droplist);
addChildWindow(d_button);
// internal event wiring
d_button->subscribeEvent(PushButton::EventMouseButtonDown, Event::Subscriber(&CEGUI::Combobox::button_PressHandler, this));
d_droplist->subscribeEvent(ComboDropList::EventListSelectionAccepted, Event::Subscriber(&CEGUI::Combobox::droplist_SelectionAcceptedHandler, this));
d_droplist->subscribeEvent(Window::EventHidden, Event::Subscriber(&CEGUI::Combobox::droplist_HiddenHandler, this));
d_editbox->subscribeEvent(Window::EventMouseButtonDown, Event::Subscriber(&CEGUI::Combobox::editbox_MouseDownHandler, this));
// event forwarding setup
d_editbox->subscribeEvent(Editbox::EventReadOnlyModeChanged, Event::Subscriber(&CEGUI::Combobox::editbox_ReadOnlyChangedHandler, this));
d_editbox->subscribeEvent(Editbox::EventValidationStringChanged, Event::Subscriber(&CEGUI::Combobox::editbox_ValidationStringChangedHandler, this));
d_editbox->subscribeEvent(Editbox::EventMaximumTextLengthChanged, Event::Subscriber(&CEGUI::Combobox::editbox_MaximumTextLengthChangedHandler, this));
d_editbox->subscribeEvent(Editbox::EventTextInvalidated, Event::Subscriber(&CEGUI::Combobox::editbox_TextInvalidatedEventHandler, this));
d_editbox->subscribeEvent(Editbox::EventInvalidEntryAttempted, Event::Subscriber(&CEGUI::Combobox::editbox_InvalidEntryAttemptedHandler, this));
d_editbox->subscribeEvent(Editbox::EventCaratMoved, Event::Subscriber(&CEGUI::Combobox::editbox_CaratMovedHandler, this));
d_editbox->subscribeEvent(Editbox::EventTextSelectionChanged, Event::Subscriber(&CEGUI::Combobox::editbox_TextSelectionChangedHandler, this));
d_editbox->subscribeEvent(Editbox::EventEditboxFull, Event::Subscriber(&CEGUI::Combobox::editbox_EditboxFullEventHandler, this));
d_editbox->subscribeEvent(Editbox::EventTextAccepted, Event::Subscriber(&CEGUI::Combobox::editbox_TextAcceptedEventHandler, this));
d_editbox->subscribeEvent(Editbox::EventTextChanged, Event::Subscriber(&CEGUI::Combobox::editbox_TextChangedEventHandler, this));
d_droplist->subscribeEvent(Listbox::EventListContentsChanged, Event::Subscriber(&CEGUI::Combobox::listbox_ListContentsChangedHandler, this));
d_droplist->subscribeEvent(Listbox::EventSelectionChanged, Event::Subscriber(&CEGUI::Combobox::listbox_ListSelectionChangedHandler, this));
d_droplist->subscribeEvent(Listbox::EventSortModeChanged, Event::Subscriber(&CEGUI::Combobox::listbox_SortModeChangedHandler, this));
d_droplist->subscribeEvent(Listbox::EventVertScrollbarModeChanged, Event::Subscriber(&CEGUI::Combobox::listbox_VertScrollModeChangedHandler, this));
d_droplist->subscribeEvent(Listbox::EventHorzScrollbarModeChanged, Event::Subscriber(&CEGUI::Combobox::listbox_HorzScrollModeChangedHandler, this));
// put components in their initial positions
performChildWindowLayout();
}
/*************************************************************************
Initialises the Window based object ready for use.
*************************************************************************/
void FrameWindow::initialiseComponents(void)
{
// get component windows
Titlebar* titlebar = getTitlebar();
PushButton* closeButton = getCloseButton();
// configure titlebar
titlebar->setDraggingEnabled(d_dragMovable);
titlebar->setText(getText());
// ban some properties on components, since they are linked to settings
// defined here.
titlebar->banPropertyFromXML("Text");
titlebar->banPropertyFromXML("Visible");
titlebar->banPropertyFromXML("Disabled");
closeButton->banPropertyFromXML("Visible");
closeButton->banPropertyFromXML("Disabled");
// bind handler to close button 'Click' event
closeButton->subscribeEvent(PushButton::EventClicked, Event::Subscriber(&CEGUI::FrameWindow::closeClickHandler, this));
performChildWindowLayout();
}
void Spinner::initialiseComponents(void)
{
// get all the component widgets
PushButton* increaseButton = getIncreaseButton();
PushButton* decreaseButton = getDecreaseButton();
Editbox* editbox = getEditbox();
// setup component controls
increaseButton->setWantsMultiClickEvents(false);
increaseButton->setMouseAutoRepeatEnabled(true);
decreaseButton->setWantsMultiClickEvents(false);
decreaseButton->setMouseAutoRepeatEnabled(true);
// perform event subscriptions.
increaseButton->subscribeEvent(Window::EventMouseButtonDown, Event::Subscriber(&Spinner::handleIncreaseButton, this));
decreaseButton->subscribeEvent(Window::EventMouseButtonDown, Event::Subscriber(&Spinner::handleDecreaseButton, this));
editbox->subscribeEvent(Window::EventTextChanged, Event::Subscriber(&Spinner::handleEditTextChange, this));
// final initialisation
setTextInputMode(Integer);
setCurrentValue(0.0f);
performChildWindowLayout();
}
void TabControl::removeTab_impl(Window* window)
{
// silently abort if window to be removed is 0.
if (!window)
return;
// delete connection to event we subscribed earlier
d_eventConnections.erase(window);
// Was this selected?
bool reselect = window->isVisible();
// Tab buttons are the 2nd onward children
getTabPane()->removeChildWindow(window);
// remove button too
removeButtonForTabContent(window);
if (reselect && (getTabCount() > 0))
// Select another tab
setSelectedTab(getTabPane()->getChildAtIdx(0)->getName());
performChildWindowLayout();
invalidate();
}
/*************************************************************************
Handler for when text is programmatically changed.
*************************************************************************/
void MultiLineEditbox::onTextChanged(WindowEventArgs& e)
{
// ensure last character is a new line
if ((d_text.length() == 0) || (d_text[d_text.length() - 1] != '\n'))
d_text.append(1, '\n');
// base class processing
Window::onTextChanged(e);
// clear selection
clearSelection();
// layout new text
formatText();
// layout child windows (scrollbars) since text layout may have changed
performChildWindowLayout();
// ensure carat is still within the text
setCaratIndex(getCaratIndex());
// ensure carat is visible
// NB: this will already have been called at least once, but since we
// may have changed the formatting of the text, it needs to be called again.
ensureCaratIsVisible();
e.handled = true;
}
