1 /***********************************************************************
2 created:    12/7/2012
3 author:     Lukas E Meindl
4 *************************************************************************/
5 /***************************************************************************
6 *   Copyright (C) 2004 - 2012 Paul D Turner & Thce CEGUI Development Team
7 *
8 *   Permission is hereby granted, free of charge, to any person obtaining
9 *   a copy of this software and associated documentation files (the
10 *   "Software"), to deal in the Software without restriction, including
11 *   without limitation the rights to use, copy, modify, merge, publish,
12 *   distribute, sublicense, and/or sell copies of the Software, and to
13 *   permit persons to whom the Software is furnished to do so, subject to
14 *   the following conditions:
15 *
16 *   The above copyright notice and this permission notice shall be
17 *   included in all copies or substantial portions of the Software.
18 *
19 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
22 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
23 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
24 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25 *   OTHER DEALINGS IN THE SOFTWARE.
26 ***************************************************************************/
27 #include "WidgetDemo.h"
28 
29 #include "CEGUI/CEGUI.h"
30 
31 #include <cmath>
32 
33 
34 using namespace CEGUI;
35 
36 //----------------------------------------------------------------------------//
37 // Sample sub-class for ListboxTextItem that auto-sets the selection brush
38 // image.  This saves doing it manually every time in the code.
39 //----------------------------------------------------------------------------//
40 
41 class MyListItem : public ListboxTextItem
42 {
43 public:
MyListItem(const String & text,CEGUI::uint item_id=0)44     MyListItem(const String& text, CEGUI::uint item_id = 0) :
45       ListboxTextItem(text, item_id)
46       {
47           setSelectionBrushImage("Vanilla-Images/GenericBrush");
48       }
49 };
50 
51 //----------------------------------------------------------------------------//
52 // Helper struct to handle widget properties
53 //----------------------------------------------------------------------------//
54 struct WidgetPropertiesObject
55 {
56     std::vector<const CEGUI::Property*> d_propertyList;
57     const CEGUI::Window* d_widget;
58 };
59 
60 //----------------------------------------------------------------------------//
61 // Helper class to deal with the different event names, used to output the name
62 // of the event for generic events
63 //----------------------------------------------------------------------------//
64 class EventHandlerObject
65 {
66 public:
67     EventHandlerObject(CEGUI::String eventName, WidgetDemo* owner);
68     bool handleEvent(const CEGUI::EventArgs& args);
69 private:
70     CEGUI::String d_eventName;
71     WidgetDemo* d_owner;
72 };
73 
EventHandlerObject(CEGUI::String eventName,WidgetDemo * owner)74 EventHandlerObject::EventHandlerObject(CEGUI::String eventName, WidgetDemo* owner)
75     : d_eventName(eventName),
76     d_owner(owner)
77 {
78 }
79 
handleEvent(const CEGUI::EventArgs & args)80 bool EventHandlerObject::handleEvent(const CEGUI::EventArgs& args)
81 {
82     CEGUI::String logMessage = "[colour='FFFFBBBB']" + d_eventName + "[colour='FFFFFFFF']";
83     logMessage += CEGUI::String(" (");
84 
85     if(dynamic_cast<const CEGUI::MouseEventArgs*>(&args))
86     {
87         logMessage += "MouseEvent";
88     }
89     else if(dynamic_cast<const CEGUI::MouseCursorEventArgs*>(&args))
90     {
91         logMessage += "MouseCursorEvent";
92     }
93     else if(const CEGUI::KeyEventArgs* keyArgs = dynamic_cast<const CEGUI::KeyEventArgs*>(&args))
94     {
95         logMessage += "KeyEvent: '" + CEGUI::String(1, keyArgs->codepoint) + "'";
96     }
97     else if(dynamic_cast<const CEGUI::WindowEventArgs*>(&args))
98     {
99         logMessage += "WindowEvent";
100     }
101     else if(dynamic_cast<const CEGUI::ActivationEventArgs*>(&args))
102     {
103         logMessage += "ActivationEvent";
104     }
105     else if(dynamic_cast<const CEGUI::DragDropEventArgs*>(&args))
106     {
107         logMessage += "DragDropEvent";
108     }
109 
110 
111     logMessage += CEGUI::String(")");
112 
113     logMessage += "\n";
114     d_owner->handleWidgetEventFired(d_eventName, logMessage);
115 
116     return false;
117 }
118 
119 
120 //----------------------------------------------------------------------------//
121 // The following are for the main WidgetDemo class.
122 //----------------------------------------------------------------------------//
123 
124 /*************************************************************************
125 Sample specific initialisation goes here.
126 *************************************************************************/
127 const CEGUI::String WidgetDemo::s_widgetDemoWindowPrefix = "WidgetDemoWindow_";
128 
initialise(CEGUI::GUIContext * guiContext)129 bool WidgetDemo::initialise(CEGUI::GUIContext* guiContext)
130 {
131     using namespace CEGUI;
132 
133     d_usedFiles = CEGUI::String(__FILE__);
134     d_guiContext = guiContext;
135 
136     // load scheme and set up defaults
137     SchemeManager::getSingleton().createFromFile("TaharezLook.scheme");
138     SchemeManager::getSingleton().createFromFile("AlfiskoSkin.scheme");
139     SchemeManager::getSingleton().createFromFile("WindowsLook.scheme");
140     SchemeManager::getSingleton().createFromFile("VanillaSkin.scheme");
141     SchemeManager::getSingleton().createFromFile("OgreTray.scheme");
142     d_guiContext->getMouseCursor().setDefaultImage("Vanilla-Images/MouseArrow");
143 
144     // load font and setup default if not loaded via scheme
145     Font& defaultFont = FontManager::getSingleton().createFromFile("DejaVuSans-12.font");
146     FontManager::getSingleton().createFromFile("DejaVuSans-10.font");
147     // Set default font for the gui context
148     guiContext->setDefaultFont(&defaultFont);
149 
150     // load an image to use as a background
151     if( !ImageManager::getSingleton().isDefined("SpaceBackgroundImage") )
152         ImageManager::getSingleton().addFromImageFile("SpaceBackgroundImage", "SpaceBackground.jpg");
153 
154     // Retrieve the available widget types and save them inside a map
155     initialiseAvailableWidgetsMap();
156     initialiseEventHandlerObjects();
157 
158     d_currentlyDisplayedWidgetRoot = 0;
159     //Create windows and initialise them
160     createLayout();
161 
162     d_guiContext->subscribeEvent(CEGUI::GUIContext::EventRenderQueueEnded, Event::Subscriber(&WidgetDemo::handleRenderingEnded, this));
163     d_guiContext->getRootWindow()->subscribeEvent(CEGUI::Window::EventUpdated, Event::Subscriber(&WidgetDemo::handleRootWindowUpdate, this));
164 
165     if(CEGUI::ListboxItem* skinItem = d_skinSelectionCombobox->getListboxItemFromIndex(0))
166     {
167         d_skinSelectionCombobox->setItemSelectState(skinItem, true);
168         handleSkinSelectionAccepted(CEGUI::WindowEventArgs(d_skinSelectionCombobox));
169     }
170     if(CEGUI::ListboxItem* widgetItem = d_widgetSelectorListbox->getListboxItemFromIndex(0))
171     {
172         d_widgetSelectorListbox->setItemSelectState(widgetItem, true);
173     }
174 
175     // success!
176     return true;
177 }
178 
179 /*************************************************************************
180 Cleans up resources allocated in the initialiseSample call.
181 *************************************************************************/
deinitialise()182 void WidgetDemo::deinitialise()
183 {
184     if(d_currentlyDisplayedWidgetRoot != 0)
185         d_widgetDisplayWindowInnerWindow->removeChild(d_currentlyDisplayedWidgetRoot);
186 
187     destroyWidgetWindows();
188 
189     deinitWidgetListItems();
190 }
191 
handleSkinSelectionAccepted(const CEGUI::EventArgs & args)192 bool WidgetDemo::handleSkinSelectionAccepted(const CEGUI::EventArgs& args)
193 {
194     const WindowEventArgs& winArgs = static_cast<const CEGUI::WindowEventArgs&>(args);
195 
196     CEGUI::Combobox* combobox = static_cast<CEGUI::Combobox*>(winArgs.window);
197     CEGUI::String schemeName = combobox->getSelectedItem()->getText();
198 
199     WidgetListType& widgetsList = d_skinListItemsMap[schemeName];
200 
201     d_widgetSelectorListbox->resetList();
202 
203     for(unsigned int i = 0; i < widgetsList.size(); ++i)
204     {
205         MyListItem* item = widgetsList[i];
206         d_widgetSelectorListbox->addItem(item);
207     }
208 
209     // event was handled
210     return true;
211 }
212 
handleRenderingEnded(const CEGUI::EventArgs &)213 bool WidgetDemo::handleRenderingEnded(const CEGUI::EventArgs&)
214 {
215     d_windowLightMouseMoveEvent->disable();
216     d_windowLightUpdatedEvent->disable();
217 
218     return true;
219 }
220 
handleRootWindowUpdate(const CEGUI::EventArgs & args)221 bool WidgetDemo::handleRootWindowUpdate(const CEGUI::EventArgs& args)
222 {
223     const CEGUI::UpdateEventArgs& updateArgs = static_cast<const CEGUI::UpdateEventArgs&>(args);
224     float passedTime = updateArgs.d_timeSinceLastFrame;
225 
226     if(d_currentlyDisplayedWidgetRoot == 0)
227         return true;
228 
229     CEGUI::ProgressBar* progressBar = dynamic_cast<CEGUI::ProgressBar*>(d_currentlyDisplayedWidgetRoot);
230     if(progressBar != 0)
231     {
232         float newProgress = progressBar->getProgress() + passedTime * 0.2f;
233         if(newProgress < 1.0f)
234             progressBar->setProgress(newProgress);
235     }
236 
237     return true;
238 }
239 
handleWidgetSelectionChanged(const CEGUI::EventArgs &)240 bool WidgetDemo::handleWidgetSelectionChanged(const CEGUI::EventArgs&)
241 {
242     //Get widget name and mapping type
243     CEGUI::String widgetName;
244     CEGUI::String widgetTypeString;
245 
246     bool typesFound = getWidgetType(widgetName, widgetTypeString);
247     if(!typesFound)
248         return true;
249 
250     //Clear events log
251     d_widgetsEventsLog->setText("");
252 
253     //Remove previous children window from the widget-display window
254     if(d_currentlyDisplayedWidgetRoot)
255         d_widgetDisplayWindowInnerWindow->removeChild(d_currentlyDisplayedWidgetRoot);
256 
257     //Get the widget root window
258     CEGUI::Window* widgetWindowRoot = retrieveOrCreateWidgetWindow(widgetTypeString, widgetName);
259 
260     d_widgetDisplayWindowInnerWindow->addChild(widgetWindowRoot);
261     d_currentlyDisplayedWidgetRoot = widgetWindowRoot;
262     d_widgetDisplayWindow->setText("Demo of widget: \"" + widgetTypeString + "\"");
263 
264     //Special initialisations for certain Windows
265     handleSpecialWindowCases(widgetWindowRoot, widgetTypeString);
266 
267     //Set the property items for the property inspector
268     fillWidgetPropertiesDisplayWindow(widgetWindowRoot);
269 
270 
271     // event was handled
272     return true;
273 }
274 
275 
initialiseAvailableWidgetsMap()276 void WidgetDemo::initialiseAvailableWidgetsMap()
277 {
278     //Retrieve the widget look types and add a Listboxitem for each widget, to the right scheme in the map
279     CEGUI::WindowFactoryManager& windowFactorymanager = CEGUI::WindowFactoryManager::getSingleton();
280     CEGUI::WindowFactoryManager::FalagardMappingIterator falMappingIter = windowFactorymanager.getFalagardMappingIterator();
281 
282     while(!falMappingIter.isAtEnd())
283     {
284         CEGUI::String falagardBaseType = falMappingIter.getCurrentValue().d_windowType;
285 
286         int slashPos = falagardBaseType.find_first_of('/');
287         CEGUI::String group = falagardBaseType.substr(0, slashPos);
288         CEGUI::String name = falagardBaseType.substr(slashPos + 1, falagardBaseType.size() - 1);
289 
290         if(group.compare("SampleBrowserSkin") != 0)
291         {
292 
293             std::map<CEGUI::String, WidgetListType>::iterator iter = d_skinListItemsMap.find(group);
294             if(iter == d_skinListItemsMap.end())
295             {
296                 //Create new list
297                 d_skinListItemsMap[group];
298             }
299 
300             WidgetListType& widgetList = d_skinListItemsMap.find(group)->second;
301             addItemToWidgetList(name, widgetList);
302         }
303 
304         ++falMappingIter;
305     }
306 
307     //Add the default types as well
308     d_skinListItemsMap["No Skin"];
309     WidgetListType& defaultWidgetsList = d_skinListItemsMap["No Skin"];
310 
311     addItemToWidgetList("DefaultWindow", defaultWidgetsList);
312     addItemToWidgetList("DragContainer", defaultWidgetsList);
313     addItemToWidgetList("VerticalLayoutContainer", defaultWidgetsList);
314     addItemToWidgetList("HorizontalLayoutContainer", defaultWidgetsList);
315     addItemToWidgetList("GridLayoutContainer", defaultWidgetsList);
316 }
317 
318 
createLayout()319 void WidgetDemo::createLayout()
320 {
321     // here we will use a StaticImage as the root, then we can use it to place a background image
322     Window* background = WindowManager::getSingleton().createWindow("TaharezLook/StaticImage", "BackgroundWindow");
323     initialiseBackgroundWindow(background);
324     // install this as the root GUI sheet
325     d_guiContext->setRootWindow(background);
326 
327     initialiseWidgetSelector(background);
328 
329     initialiseWidgetInspector(background);
330 }
331 
initialiseSkinCombobox(CEGUI::Window * container)332 void WidgetDemo::initialiseSkinCombobox(CEGUI::Window* container)
333 {
334     WindowManager& winMgr = WindowManager::getSingleton();
335 
336     CEGUI::Window* skinSelectionComboboxLabel = winMgr.createWindow("Vanilla/Label", "SkinSelectionComboboxLabel");
337     skinSelectionComboboxLabel->setText("Select a Skin and a Widget");
338     skinSelectionComboboxLabel->setPosition(CEGUI::UVector2(cegui_reldim(0.65f), cegui_reldim(0.12f)));
339     skinSelectionComboboxLabel->setSize(CEGUI::USize(cegui_reldim(0.24f), cegui_reldim(0.07f)));
340 
341     d_skinSelectionCombobox = static_cast<CEGUI::Combobox*>(winMgr.createWindow("Vanilla/Combobox", "SkinSelectionCombobox"));
342     d_skinSelectionCombobox->setPosition(CEGUI::UVector2(cegui_reldim(0.65f), cegui_reldim(0.2f)));
343     d_skinSelectionCombobox->setSize(CEGUI::USize(cegui_reldim(0.24f), cegui_reldim(0.3f)));
344     d_skinSelectionCombobox->setReadOnly(true);
345     d_skinSelectionCombobox->setSortingEnabled(false);
346 
347     d_skinSelectionCombobox->subscribeEvent(CEGUI::Combobox::EventListSelectionAccepted, Event::Subscriber(&WidgetDemo::handleSkinSelectionAccepted, this));
348 
349     std::map<CEGUI::String, WidgetListType>::iterator iter = d_skinListItemsMap.begin();
350     while(iter != d_skinListItemsMap.end())
351     {
352         d_skinSelectionCombobox->addItem(new MyListItem(iter->first));
353 
354         ++iter;
355     }
356 
357     container->addChild(d_skinSelectionCombobox);
358     container->addChild(skinSelectionComboboxLabel);
359 }
360 
initialiseBackgroundWindow(CEGUI::Window * background)361 void WidgetDemo::initialiseBackgroundWindow(CEGUI::Window* background)
362 {
363     background->setPosition(UVector2(cegui_reldim(0), cegui_reldim( 0)));
364     background->setSize(USize(cegui_reldim(1), cegui_reldim( 1)));
365     background->setProperty("FrameEnabled", "false");
366     background->setProperty("BackgroundEnabled", "false");
367     background->setProperty("Image", "SpaceBackgroundImage");
368 }
369 
initialiseWidgetSelectorListbox()370 void WidgetDemo::initialiseWidgetSelectorListbox()
371 {
372     WindowManager& winMgr = WindowManager::getSingleton();
373 
374     d_widgetSelectorListbox = static_cast<CEGUI::Listbox*>(winMgr.createWindow("Vanilla/Listbox", "WidgetSelectorListbox"));
375     d_widgetSelectorListbox->setPosition(CEGUI::UVector2(cegui_reldim(0.0f), cegui_reldim(0.075f)));
376     d_widgetSelectorListbox->setSize(CEGUI::USize(cegui_reldim(1.0f), cegui_reldim(0.925f)));
377     d_widgetSelectorListbox->setShowVertScrollbar(false);
378     d_widgetSelectorListbox->setSortingEnabled(true);
379 
380     d_widgetSelectorListbox->subscribeEvent(CEGUI::Listbox::EventSelectionChanged, Event::Subscriber(&WidgetDemo::handleWidgetSelectionChanged, this));
381 }
382 
initialiseWidgetSelectorContainer(CEGUI::Window * widgetSelectorContainer)383 void WidgetDemo::initialiseWidgetSelectorContainer(CEGUI::Window* widgetSelectorContainer)
384 {
385     widgetSelectorContainer->setPosition(CEGUI::UVector2(cegui_reldim(0.6f), cegui_reldim(0.25f)));
386     widgetSelectorContainer->setSize(CEGUI::USize(cegui_reldim(0.325f), cegui_reldim(0.56f)));
387     widgetSelectorContainer->setText("Widget Selector");
388     widgetSelectorContainer->setProperty("VertFormatting", "TopAligned");
389     widgetSelectorContainer->setProperty("HorzFormatting", "CentreAligned");
390 }
391 
initialiseWidgetsEventsLog()392 void WidgetDemo::initialiseWidgetsEventsLog()
393 {
394     WindowManager& winMgr = WindowManager::getSingleton();
395 
396     d_widgetsEventsLog = winMgr.createWindow("Vanilla/StaticText", "WidgetEventsLog");
397     d_widgetsEventsLog->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.65f)));
398     d_widgetsEventsLog->setSize(CEGUI::USize(cegui_reldim(0.9f), cegui_reldim(0.25f)));
399     d_widgetsEventsLog->setFont("DejaVuSans-12");
400 
401     d_widgetsEventsLog->setProperty("VertScrollbar", "true");
402 
403     d_widgetsEventsLog->setProperty("HorzFormatting", "WordWrapLeftAligned");
404 
405     d_widgetsEventsLog->setProperty("VertFormatting", "TopAligned");
406 }
407 
408 /*************************************************************************
409 Helper function to add MyListItem's to the widget list
410 *************************************************************************/
addItemToWidgetList(const CEGUI::String & widgetName,WidgetListType & widgetList)411 void WidgetDemo::addItemToWidgetList(const CEGUI::String& widgetName, WidgetListType &widgetList)
412 {
413     MyListItem* widgetListItem = new MyListItem(widgetName);
414     widgetListItem->setAutoDeleted(false);
415     widgetList.push_back(widgetListItem);
416 }
417 
initialiseEventHandlerObjects()418 void WidgetDemo::initialiseEventHandlerObjects()
419 {
420 #include "AllEvents.inc"
421 
422     std::set<String>::iterator iter = allEvents.begin();
423     while(iter != allEvents.end())
424     {
425         addEventHandlerObjectToMap(*iter);
426 
427         ++iter;
428     }
429 }
430 
createWidget(const CEGUI::String & widgetMapping,const CEGUI::String & widgetType)431 CEGUI::Window* WidgetDemo::createWidget(const CEGUI::String &widgetMapping, const CEGUI::String &widgetType)
432 {
433     //Create default widget of the selected type
434     CEGUI::WindowManager& windowManager = CEGUI::WindowManager::getSingleton();
435 
436     CEGUI::Window* widgetWindow = windowManager.createWindow(widgetMapping, s_widgetDemoWindowPrefix + widgetMapping);
437     //Subscribe to all possible events the window could fire, the handler will output them to the log
438     subscribeToAllEvents(widgetWindow);
439 
440     //Set a default text - for Spinners we set no text so it won't cause an exception
441     CEGUI::Spinner* spinner = dynamic_cast<CEGUI::Spinner*>(widgetWindow);
442     if(!spinner)
443         widgetWindow->setText(widgetType);
444 
445     //Create extra widgets and special setups for certain widget types for better demonstration
446     CEGUI::Window* widgetWindowRoot = initialiseSpecialWidgets(widgetWindow, widgetType);
447 
448     //Get all properties and save them in a map for the properties display window
449     saveWidgetPropertiesToMap(widgetWindowRoot, widgetWindow);
450 
451     return widgetWindowRoot;
452 }
453 
454 
handleWidgetEventFired(const CEGUI::String & eventName,CEGUI::String logMessage)455 void WidgetDemo::handleWidgetEventFired(const CEGUI::String& eventName, CEGUI::String logMessage)
456 {
457     if(eventName == CEGUI::Window::EventMouseMove)
458     {
459         d_windowLightMouseMoveEvent->enable();
460     }
461     else if(eventName == CEGUI::Window::EventUpdated)
462     {
463         d_windowLightUpdatedEvent->enable();
464     }
465     else
466     {
467         logFiredEvent(logMessage);
468     }
469 }
470 
addEventHandlerObjectToMap(CEGUI::String eventName)471 void WidgetDemo::addEventHandlerObjectToMap(CEGUI::String eventName)
472 {
473     d_eventHandlerObjectsMap[eventName] = new EventHandlerObject(eventName, this);
474 }
475 
deinitWidgetListItems()476 void WidgetDemo::deinitWidgetListItems()
477 {
478     std::map<CEGUI::String, WidgetListType>::iterator iter = d_skinListItemsMap.begin();
479     while(iter != d_skinListItemsMap.end())
480     {
481         WidgetListType& widgetsList = iter->second;
482 
483         while(widgetsList.size() > 0)
484         {
485             MyListItem* item = widgetsList.back();
486 
487             d_widgetSelectorListbox->removeItem(item);
488             delete item;
489             widgetsList.pop_back();
490         }
491 
492         ++iter;
493     }
494 }
495 
destroyWidgetWindows()496 void WidgetDemo::destroyWidgetWindows()
497 {
498     CEGUI::WindowManager& winMan = CEGUI::WindowManager::getSingleton();
499     std::map<CEGUI::String, CEGUI::Window*>::iterator iter = d_widgetsMap.begin();
500     while(iter != d_widgetsMap.end())
501     {
502         winMan.destroyWindow(iter->second);
503 
504         ++iter;
505     }
506 }
507 
initialiseEventLights(CEGUI::Window * container)508 void WidgetDemo::initialiseEventLights(CEGUI::Window* container)
509 {
510     CEGUI::WindowManager &winMgr = CEGUI::WindowManager::getSingleton();
511 
512     CEGUI::Window* horizontalLayout = winMgr.createWindow("HorizontalLayoutContainer", "EventLightsContainer");
513     horizontalLayout->setPosition(CEGUI::UVector2(cegui_reldim(0.085f), cegui_reldim(0.93f)));
514     container->addChild(horizontalLayout);
515 
516 
517     d_windowLightUpdatedEvent = winMgr.createWindow("SampleBrowserSkin/Light");
518     horizontalLayout->addChild(d_windowLightUpdatedEvent);
519     d_windowLightUpdatedEvent->setSize(CEGUI::USize(cegui_reldim(0.0f), cegui_reldim(0.04f)));
520     d_windowLightUpdatedEvent->setAspectMode(CEGUI::AM_EXPAND);
521     d_windowLightUpdatedEvent->setProperty("LightColour", "FF66FF66");
522 
523     CEGUI::Window* updateEventLabel = winMgr.createWindow("Vanilla/Label");
524     horizontalLayout->addChild(updateEventLabel);
525     updateEventLabel->setSize(CEGUI::USize(cegui_reldim(0.25f), cegui_reldim(0.04f)));
526     updateEventLabel->setText("EventUpdated");
527     updateEventLabel->setFont("DejaVuSans-12-NoScale");
528     updateEventLabel->setProperty("HorzFormatting", "LeftAligned");
529 
530     d_windowLightMouseMoveEvent = winMgr.createWindow("SampleBrowserSkin/Light");
531     horizontalLayout->addChild(d_windowLightMouseMoveEvent);
532     d_windowLightMouseMoveEvent->setSize(CEGUI::USize(cegui_reldim(0.0f), cegui_reldim(0.04f)));
533     d_windowLightMouseMoveEvent->setAspectMode(CEGUI::AM_EXPAND);
534     d_windowLightMouseMoveEvent->setProperty("LightColour", "FF77BBFF");
535 
536     CEGUI::Window* mouseMoveEventLabel = winMgr.createWindow("Vanilla/Label");
537     horizontalLayout->addChild(mouseMoveEventLabel);
538     mouseMoveEventLabel->setSize(CEGUI::USize(cegui_reldim(0.25f), cegui_reldim(0.04f)));
539     mouseMoveEventLabel->setText("EventMouseMove");
540     mouseMoveEventLabel->setFont("DejaVuSans-12-NoScale");
541     mouseMoveEventLabel->setProperty("HorzFormatting", "LeftAligned");
542 }
543 
logFiredEvent(const CEGUI::String & logMessage)544 void WidgetDemo::logFiredEvent(const CEGUI::String& logMessage)
545 {
546     ListboxItem* item = d_widgetSelectorListbox->getFirstSelectedItem();
547     if(!item)
548         return;
549 
550     CEGUI::String eventsLog = d_widgetsEventsLog->getText();
551     eventsLog += logMessage;
552 
553     //Remove line
554     int pos = std::max<int>(static_cast<int>(eventsLog.length() - 2056), 0);
555     int len = std::min<int>(static_cast<int>(eventsLog.length()), 2056);
556     eventsLog = eventsLog.substr(pos, len);
557     if(len == 2056)
558     {
559         String::size_type newlinePos = eventsLog.find_first_of("\n");
560         if(newlinePos != String::npos)
561             eventsLog = eventsLog.substr(newlinePos, String::npos);
562     }
563     d_widgetsEventsLog->setText(eventsLog);
564 
565     //Scroll to end
566     CEGUI::Scrollbar* scrollbar = static_cast<CEGUI::Scrollbar*>(d_widgetsEventsLog->getChild("__auto_vscrollbar__"));
567     scrollbar->setScrollPosition(scrollbar->getDocumentSize() - scrollbar->getPageSize());
568 }
569 
subscribeToAllEvents(CEGUI::Window * widgetWindow)570 void WidgetDemo::subscribeToAllEvents(CEGUI::Window* widgetWindow)
571 {
572     //Register all events for the widget window
573     std::map<CEGUI::String, EventHandlerObject*>::iterator iter = d_eventHandlerObjectsMap.begin();
574     while(iter != d_eventHandlerObjectsMap.end())
575     {
576         widgetWindow->subscribeEvent(iter->first, Event::Subscriber(&EventHandlerObject::handleEvent, iter->second));
577 
578         ++iter;
579     }
580 }
581 
initialiseSpecialWidgets(CEGUI::Window * widgetWindow,const CEGUI::String & widgetType)582 CEGUI::Window* WidgetDemo::initialiseSpecialWidgets(CEGUI::Window* widgetWindow, const CEGUI::String &widgetType)
583 {
584     CEGUI::RadioButton* radioButton = dynamic_cast<CEGUI::RadioButton*>(widgetWindow);
585     if(radioButton)
586     {
587         initRadioButtons(radioButton, widgetWindow);
588     }
589 
590     CEGUI::MultiLineEditbox* multilineEditbox = dynamic_cast<CEGUI::MultiLineEditbox*>(widgetWindow);
591     if(multilineEditbox || widgetType.compare("StaticText") == 0)
592     {
593         widgetWindow->setText("Lorem ipsum dolor sit amet, consectetur adipisici elit, sed eiusmod tempor incidunt"
594             "ut labore et dolore magna aliqua.Ut enim ad minim veniam, quis nostrud exercitation ullamco"
595             "laboris nisi ut aliquid ex ea commodi consequat.Quis aute iure reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n\n\n"
596             "Excepteur sint obcaecat cupiditat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
597     }
598 
599     if(widgetType.compare("CaptionedStaticText") == 0)
600     {
601         widgetWindow->setProperty("Text", "Caption");
602     }
603 
604     if(widgetType.compare("StaticText") == 0)
605     {
606         if(widgetWindow->isPropertyPresent("VertScrollbar"))
607             widgetWindow->setProperty("VertScrollbar", "true");
608 
609         if(widgetWindow->isPropertyPresent("HorzFormatting"))
610             widgetWindow->setProperty("HorzFormatting", "WordWrapLeftAligned");
611     }
612 
613     if(widgetType.compare("StaticImage") == 0)
614     {
615         widgetWindow->setProperty("Image", "SpaceBackgroundImage");
616     }
617 
618     CEGUI::Listbox* listbox = dynamic_cast<CEGUI::Listbox*>(widgetWindow);
619     if(listbox)
620     {
621         initListbox(listbox);
622     }
623 
624     CEGUI::ComboDropList* combodroplist = dynamic_cast<CEGUI::ComboDropList*>(widgetWindow);
625     if(combodroplist)
626     {
627         initListbox(combodroplist);
628     }
629 
630     CEGUI::ItemListbox* itemListbox = dynamic_cast<CEGUI::ItemListbox*>(widgetWindow);
631     if(itemListbox)
632     {
633         initItemListbox(itemListbox);
634     }
635 
636     CEGUI::Combobox* combobox = dynamic_cast<CEGUI::Combobox*>(widgetWindow);
637     if(combobox)
638     {
639         initCombobox(combobox);
640     }
641 
642     CEGUI::MultiColumnList* multilineColumnList = dynamic_cast<CEGUI::MultiColumnList*>(widgetWindow);
643     if(multilineColumnList)
644     {
645         initMultiColumnList(multilineColumnList);
646     }
647 
648     CEGUI::Menubar* menuBar = dynamic_cast<CEGUI::Menubar*>(widgetWindow);
649     if(menuBar)
650     {
651         initMenubar(menuBar);
652 
653     }
654 
655     return widgetWindow;
656 }
657 
initMultiColumnList(CEGUI::MultiColumnList * multilineColumnList)658 void WidgetDemo::initMultiColumnList(CEGUI::MultiColumnList* multilineColumnList)
659 {
660     multilineColumnList->setSize(CEGUI::USize(cegui_reldim(1.0f), cegui_reldim(0.4f)));
661 
662     multilineColumnList->addColumn("Server Name", 0, cegui_reldim(0.38f));
663     multilineColumnList->addColumn("Address ", 1, cegui_reldim(0.44f));
664     multilineColumnList->addColumn("Ping", 2, cegui_reldim(0.15f));
665 
666     // Add some empty rows to the MCL
667     multilineColumnList->addRow();
668     multilineColumnList->addRow();
669     multilineColumnList->addRow();
670     multilineColumnList->addRow();
671     multilineColumnList->addRow();
672 
673     // Set first row item texts for the MCL
674     multilineColumnList->setItem(new MyListItem("Laggers World"), 0, 0);
675     multilineColumnList->setItem(new MyListItem("yourgame.some-server.com"), 1, 0);
676     multilineColumnList->setItem(new MyListItem("[colour='FFFF0000']1000ms"), 2, 0);
677 
678     // Set second row item texts for the MCL
679     multilineColumnList->setItem(new MyListItem("Super-Server"), 0, 1);
680     multilineColumnList->setItem(new MyListItem("whizzy.fakenames.net"), 1, 1);
681     multilineColumnList->setItem(new MyListItem("[colour='FF00FF00']8ms"), 2, 1);
682 
683     // Set third row item texts for the MCL
684     multilineColumnList->setItem(new MyListItem("Cray-Z-Eds"), 0, 2);
685     multilineColumnList->setItem(new MyListItem("crayzeds.notarealserver.co.uk"), 1, 2);
686     multilineColumnList->setItem(new MyListItem("[colour='FF00FF00']43ms"), 2, 2);
687 
688     // Set fourth row item texts for the MCL
689     multilineColumnList->setItem(new MyListItem("Fake IPs"), 0, 3);
690     multilineColumnList->setItem(new MyListItem("123.320.42.242"), 1, 3);
691     multilineColumnList->setItem(new MyListItem("[colour='FFFFFF00']63ms"), 2, 3);
692 
693     // Set fifth row item texts for the MCL
694     multilineColumnList->setItem(new MyListItem("Yet Another Game Server"), 0, 4);
695     multilineColumnList->setItem(new MyListItem("abc.abcdefghijklmn.org"), 1, 4);
696     multilineColumnList->setItem(new MyListItem("[colour='FFFF6600']284ms"), 2, 4);
697 }
698 
initCombobox(CEGUI::Combobox * combobox)699 void WidgetDemo::initCombobox(CEGUI::Combobox* combobox)
700 {
701     MyListItem* item1 = new MyListItem("Combobox Item 1");
702     combobox->addItem(item1);
703     MyListItem* item2 = new MyListItem("Combobox Item 2");
704     combobox->addItem(item2);
705 
706     MyListItem* item3 = new MyListItem("Combobox Item 3");
707     item3->setSelectionColours(CEGUI::Colour(0.3f, 0.7f, 1.0f, 1.0f));
708     combobox->addItem(item3);
709 
710     MyListItem* item4 = new MyListItem("Combobox Item 4");
711     item4->setSelectionColours(CEGUI::Colour(0.3f, 1.0f, 0.7f, 1.0f));
712     combobox->addItem(item4);
713 
714     if(combobox->getType().compare("WindowsLook/Combobox") == 0)
715     {
716         item1->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
717         item2->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
718         item3->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
719         item4->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
720     }
721 }
722 
723 
saveWidgetPropertiesToMap(const CEGUI::Window * widgetRoot,const CEGUI::Window * widgetWindow)724 void WidgetDemo::saveWidgetPropertiesToMap(const CEGUI::Window* widgetRoot, const CEGUI::Window* widgetWindow)
725 {
726     CEGUI::PropertySet::PropertyIterator propertyIter = widgetWindow->getPropertyIterator();
727 
728     std::vector<const CEGUI::Property*>& propertyList = d_widgetPropertiesMap[widgetRoot].d_propertyList;
729     d_widgetPropertiesMap[widgetRoot].d_widget = widgetWindow;
730 
731     while(!propertyIter.isAtEnd())
732     {
733         propertyList.push_back(*propertyIter);
734 
735         ++propertyIter;
736     }
737 }
738 
initListbox(CEGUI::Listbox * listbox)739 void WidgetDemo::initListbox(CEGUI::Listbox* listbox)
740 {
741     MyListItem* item1 = new MyListItem("Listbox Item 1");
742     listbox->addItem(item1);
743     MyListItem* item2 = new MyListItem("Listbox Item 2");
744     listbox->addItem(item2);
745 
746     MyListItem* item3 = new MyListItem("Listbox Item 3");
747     item3->setSelectionColours(CEGUI::Colour(0.3f, 0.7f, 1.0f, 1.0f));
748     listbox->addItem(item3);
749 
750     MyListItem* item4 = new MyListItem("Listbox Item 4");
751     item4->setSelectionColours(CEGUI::Colour(0.3f, 1.0f, 0.7f, 1.0f));
752     listbox->addItem(item4);
753 
754     if(listbox->getType().compare("WindowsLook/Listbox") == 0)
755     {
756         item1->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
757         item2->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
758         item3->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
759         item4->setTextColours(CEGUI::Colour(0.0f, 0.0f, 0.0f, 1.0f));
760     }
761 }
762 
initItemListbox(CEGUI::ItemListbox * itemListbox)763 void WidgetDemo::initItemListbox(CEGUI::ItemListbox* itemListbox)
764 {
765     CEGUI::WindowManager& windowManager = CEGUI::WindowManager::getSingleton();
766 
767     CEGUI::ItemEntry* itemListboxItem;
768 
769     itemListboxItem = static_cast<CEGUI::ItemEntry*>(windowManager.createWindow("TaharezLook/ListboxItem", "ItemListboxTestItem1"));
770     itemListbox->addItem(itemListboxItem);
771     itemListbox->setText("Item 1");
772 
773     itemListboxItem = static_cast<CEGUI::ItemEntry*>(windowManager.createWindow("TaharezLook/ListboxItem", "ItemListboxTestItem2"));
774     itemListbox->addItem(itemListboxItem);
775     itemListbox->setText("Item 2");
776 
777     itemListboxItem = static_cast<CEGUI::ItemEntry*>(windowManager.createWindow("TaharezLook/ListboxItem", "ItemListboxTestItem3"));
778     itemListbox->addItem(itemListboxItem);
779     itemListbox->setText("Item 3");
780 
781     itemListboxItem = static_cast<CEGUI::ItemEntry*>(windowManager.createWindow("TaharezLook/ListboxItem", "ItemListboxTestItem4"));
782     itemListbox->addItem(itemListboxItem);
783     itemListbox->setText("Item 4");
784 }
785 
initRadioButtons(CEGUI::RadioButton * radioButton,CEGUI::Window * & widgetWindow)786 void WidgetDemo::initRadioButtons(CEGUI::RadioButton* radioButton, CEGUI::Window*& widgetWindow)
787 {
788     CEGUI::WindowManager& windowManager = CEGUI::WindowManager::getSingleton();
789 
790     CEGUI::RadioButton* radioButton1 = radioButton;
791     widgetWindow = windowManager.createWindow("DefaultWindow", "RadioButtonWidgetDemoRoot");
792     widgetWindow->addChild(radioButton1);
793 
794     CEGUI::Window* radioButton2 = windowManager.createWindow(radioButton1->getType(), "WidgetDemoRadiobutton1");
795     widgetWindow->addChild(radioButton2);
796     radioButton2->setText("Additional Radiobutton1");
797     radioButton2->setPosition(CEGUI::UVector2(cegui_reldim(0.0f), cegui_reldim(0.17f)));
798 
799     CEGUI::Window* radioButton3 = windowManager.createWindow(radioButton1->getType(), "WidgetDemoRadiobutton2");
800     widgetWindow->addChild(radioButton3);
801     radioButton3->setText("Additional Radiobutton2");
802     radioButton3->setPosition(CEGUI::UVector2(cegui_reldim(0.0f), cegui_reldim(0.27f)));
803 }
804 
initialiseWidgetDisplayWindow()805 void WidgetDemo::initialiseWidgetDisplayWindow()
806 {
807     WindowManager& winMgr = WindowManager::getSingleton();
808 
809     d_widgetDisplayWindow = winMgr.createWindow("Vanilla/FrameWindow", "WidgetDisplayWindow");
810     d_widgetDisplayWindow->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
811     d_widgetDisplayWindow->setSize(CEGUI::USize(cegui_reldim(0.9f), cegui_reldim(0.6f)));
812     d_widgetDisplayWindow->setText("Widget Demo");
813 
814     d_widgetDisplayWindowInnerWindow =  winMgr.createWindow("DefaultWindow", "WidgetDisplayWindowInnerContainer");
815     d_widgetDisplayWindowInnerWindow->setSize(CEGUI::USize(cegui_reldim(1.0f), cegui_reldim(1.0f)));
816     d_widgetDisplayWindow->addChild(d_widgetDisplayWindowInnerWindow);
817 }
818 
initialiseWidgetSelector(CEGUI::Window * container)819 void WidgetDemo::initialiseWidgetSelector(CEGUI::Window* container)
820 {
821     WindowManager& winMgr = WindowManager::getSingleton();
822 
823     initialiseSkinCombobox(container);
824 
825     CEGUI::Window* widgetSelectorContainer = winMgr.createWindow("Vanilla/StaticText", "WidgetSelectorContainer");
826     initialiseWidgetSelectorContainer(widgetSelectorContainer);
827     container->addChild(widgetSelectorContainer);
828 
829     initialiseWidgetSelectorListbox();
830     widgetSelectorContainer->addChild(d_widgetSelectorListbox);
831 }
832 
initialiseWidgetInspector(CEGUI::Window * container)833 void WidgetDemo::initialiseWidgetInspector(CEGUI::Window* container)
834 {
835     WindowManager& winMgr = WindowManager::getSingleton();
836 
837     //Add a tabcontrol serving as WidgetInspector, allowing to switch between events+widgets and the properties display
838     TabControl* tabControl = static_cast<TabControl*>(winMgr.createWindow("TaharezLook/TabControl", "WidgetDemoWidgetInspector"));
839     container->addChild(tabControl);
840     tabControl->setSize(CEGUI::USize(cegui_reldim(0.55f), cegui_reldim(0.96f)));
841     tabControl->setPosition(CEGUI::UVector2(cegui_reldim(0.02f), cegui_reldim(0.02f)));
842 
843     //Create the respective windows containing the displays
844     CEGUI::Window* widgetMainInspectionContainer = winMgr.createWindow("DefaultWindow", "WidgetInspectionContainer");
845     CEGUI::Window* widgetPropertiesInspectionContainer = winMgr.createWindow("DefaultWindow", "WidgetPropertiesInspectionContainer");
846 
847 
848     //Add the pages to the tab control
849     widgetMainInspectionContainer->setText("Widget Inspector");
850     tabControl->addTab(widgetMainInspectionContainer);
851     widgetPropertiesInspectionContainer->setText("Widget Properties");
852     tabControl->addTab(widgetPropertiesInspectionContainer);
853 
854     //Create properties window
855     initialiseWidgetPropertiesDisplayWindow(widgetPropertiesInspectionContainer);
856 
857     //Create the widget display windows
858     initialiseWidgetDisplayWindow();
859     widgetMainInspectionContainer->addChild(d_widgetDisplayWindow);
860 
861     initialiseWidgetsEventsLog();
862     widgetMainInspectionContainer->addChild(d_widgetsEventsLog);
863 
864     initialiseEventLights(widgetMainInspectionContainer);
865 }
866 
getWidgetType(CEGUI::String & widgetName,CEGUI::String & widgetTypeString)867 bool WidgetDemo::getWidgetType(CEGUI::String &widgetName, CEGUI::String &widgetTypeString)
868 {
869     //Retrieving the Strings for the selections
870     CEGUI::ListboxItem* widgetListboxItem = d_widgetSelectorListbox->getFirstSelectedItem();
871     CEGUI::ListboxItem* skinListboxItem = d_skinSelectionCombobox->getSelectedItem();
872 
873     if(!skinListboxItem || !widgetListboxItem)
874         return false;
875 
876     //Recreate the widget's type as String
877     widgetName = widgetListboxItem->getText();
878 
879     if(skinListboxItem->getText().compare("No Skin") != 0)
880         widgetTypeString= skinListboxItem->getText() + "/";
881 
882     widgetTypeString += widgetName;
883 
884     return true;
885 }
886 
retrieveOrCreateWidgetWindow(const CEGUI::String & widgetTypeString,const CEGUI::String & widgetName)887 CEGUI::Window* WidgetDemo::retrieveOrCreateWidgetWindow(const CEGUI::String& widgetTypeString, const CEGUI::String& widgetName)
888 {
889     //Choose the existing widget if available, otherwise create it and save it to the list
890     std::map<CEGUI::String, CEGUI::Window*>::iterator iter = d_widgetsMap.find(widgetTypeString);
891     if(iter != d_widgetsMap.end())
892     {
893         return iter->second;
894     }
895     else
896     {
897         d_widgetsMap[widgetTypeString] = createWidget(widgetTypeString, widgetName);
898         return d_widgetsMap[widgetTypeString];
899     }
900 }
901 
handleSpecialWindowCases(CEGUI::Window * widgetWindowRoot,CEGUI::String widgetTypeString)902 void WidgetDemo::handleSpecialWindowCases(CEGUI::Window* widgetWindowRoot, CEGUI::String widgetTypeString)
903 {
904     //Reset to 0 progress in case of a progressbar
905     CEGUI::ProgressBar* progressBar = dynamic_cast<CEGUI::ProgressBar*>(d_currentlyDisplayedWidgetRoot);
906     if(progressBar != 0)
907         progressBar->setProgress(0.0f);
908 
909     //Apply the tooltip to the widget display window in case of a tooltip
910     CEGUI::Tooltip* tooltip = dynamic_cast<CEGUI::Tooltip*>(d_currentlyDisplayedWidgetRoot);
911     if(tooltip)
912     {
913         d_widgetDisplayWindowInnerWindow->setTooltip(tooltip);
914         d_widgetDisplayWindowInnerWindow->removeChild(widgetWindowRoot);
915         d_widgetDisplayWindowInnerWindow->setTooltipText(widgetTypeString);
916         d_currentlyDisplayedWidgetRoot = 0;
917     }
918     else
919         d_widgetDisplayWindowInnerWindow->setTooltip(0);
920 }
921 
fillWidgetPropertiesDisplayWindow(CEGUI::Window * widgetWindowRoot)922 void WidgetDemo::fillWidgetPropertiesDisplayWindow(CEGUI::Window* widgetWindowRoot)
923 {
924     d_widgetPropertiesDisplayWindow->resetList();
925 
926     std::vector<const CEGUI::Property*> propertyList = d_widgetPropertiesMap[widgetWindowRoot].d_propertyList;
927     const CEGUI::Window* widget = d_widgetPropertiesMap[widgetWindowRoot].d_widget;
928 
929     std::vector<const CEGUI::Property*>::iterator iter = propertyList.begin();
930     unsigned int i = 0;
931     while(iter != propertyList.end())
932     {
933         const CEGUI::Property* curProperty = *iter;
934 
935         // We have to call this function to update the MCL because the items have changed their properties meanwhile and thus are eventually not sorted anymore
936         // When the order in the vector is not correct anymore this will result in an assert when adding a row. The following call will sort the list again and thus
937         // it will be ensured everything will be sorted before adding a new row.
938         d_widgetPropertiesDisplayWindow->handleUpdatedItemData();
939 
940         // Add an empty row to the MultiColumnList
941         if(i >= d_widgetPropertiesDisplayWindow->getRowCount())
942             d_widgetPropertiesDisplayWindow->addRow();
943 
944         unsigned int rowID = d_widgetPropertiesDisplayWindow->getRowID(i);
945 
946         // Set the first row item (name) for the property
947         d_widgetPropertiesDisplayWindow->setItem(new MyListItem(curProperty->getName()), 0, rowID);
948 
949         // Set the third row item (type) for the property
950         d_widgetPropertiesDisplayWindow->setItem(new MyListItem(curProperty->getDataType()), 1, rowID);
951 
952         CEGUI_TRY
953         {
954             // Set the second row item (value) for the property if it is gettable
955             if(widget->isPropertyPresent(curProperty->getName()))
956                 d_widgetPropertiesDisplayWindow->setItem(new MyListItem(widget->getProperty(curProperty->getName())), 2, rowID);
957         }
958         CEGUI_CATCH(CEGUI::InvalidRequestException exception)
959         {
960         }
961 
962         ++iter;
963         ++i;
964     }
965 
966     d_widgetPropertiesDisplayWindow->handleUpdatedItemData();
967 }
968 
initialiseWidgetPropertiesDisplayWindow(CEGUI::Window * widgetPropertiesInspectionContainer)969 void WidgetDemo::initialiseWidgetPropertiesDisplayWindow(CEGUI::Window* widgetPropertiesInspectionContainer)
970 {
971     WindowManager& winMgr = WindowManager::getSingleton();
972     d_widgetPropertiesDisplayWindow = static_cast<CEGUI::MultiColumnList*>(
973         winMgr.createWindow("TaharezLook/MultiColumnList", "WidgetPropertiesDisplay")
974         );
975 
976         //Create the properties display window
977     d_widgetPropertiesDisplayWindow->setSize(CEGUI::USize(cegui_reldim(0.9f), cegui_reldim(0.9f)));
978     d_widgetPropertiesDisplayWindow->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
979 
980     widgetPropertiesInspectionContainer->addChild(d_widgetPropertiesDisplayWindow);
981 
982     d_widgetPropertiesDisplayWindow->addColumn("Name", 0, cegui_reldim(0.45f));
983     d_widgetPropertiesDisplayWindow->addColumn("Type ", 1, cegui_reldim(0.25f));
984     d_widgetPropertiesDisplayWindow->addColumn("Value", 2, cegui_reldim(0.8f));
985 
986     d_widgetPropertiesDisplayWindow->setShowHorzScrollbar(false);
987     d_widgetPropertiesDisplayWindow->setUserColumnDraggingEnabled(false);
988     d_widgetPropertiesDisplayWindow->setUserColumnSizingEnabled(true);
989 
990     d_widgetPropertiesDisplayWindow->setSortColumnByID(0);
991     d_widgetPropertiesDisplayWindow->setSortDirection(CEGUI::ListHeaderSegment::Ascending);
992 }
993 
initMenubar(CEGUI::Menubar * menuBar)994 void WidgetDemo::initMenubar(CEGUI::Menubar* menuBar)
995 {
996     CEGUI::String skin = menuBar->getType();
997     skin = skin.substr(0, skin.find_first_of('/'));
998     CEGUI::String menuItemMapping = skin + "/MenuItem";
999     CEGUI::String popupMenuMapping = skin + "/PopupMenu";
1000 
1001     CEGUI::WindowManager& windowManager = CEGUI::WindowManager::getSingleton();
1002     CEGUI::MenuItem* fileMenuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "FileMenuItem"));
1003     fileMenuItem->setText("File");
1004     menuBar->addChild(fileMenuItem);
1005 
1006     CEGUI::PopupMenu* filePopupMenu = static_cast<CEGUI::PopupMenu*>(windowManager.createWindow(popupMenuMapping, "FilePopupMenu"));
1007     fileMenuItem->addChild(filePopupMenu);
1008 
1009     CEGUI::MenuItem* menuItem;
1010     menuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "FileTestMenuItem1"));
1011     menuItem->setText("Open");
1012     filePopupMenu->addItem(menuItem);
1013 
1014     menuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "FileTestMenuItem2"));
1015     menuItem->setText("Save");
1016     filePopupMenu->addItem(menuItem);
1017 
1018     menuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "FileTestMenuItem3"));
1019     menuItem->setText("Exit");
1020     filePopupMenu->addItem(menuItem);
1021 
1022 
1023     CEGUI::MenuItem* viewMenuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "ViewMenuItem"));
1024     fileMenuItem->setText("View");
1025     menuBar->addChild(viewMenuItem);
1026 
1027     CEGUI::PopupMenu* viewPopupMenu = static_cast<CEGUI::PopupMenu*>(windowManager.createWindow(popupMenuMapping, "ViewPopupMenu"));
1028     viewMenuItem->addChild(viewPopupMenu);
1029 
1030     menuItem = static_cast<CEGUI::MenuItem*>(windowManager.createWindow(menuItemMapping, "ViewTestMenuItem1"));
1031     menuItem->setText("Midgets");
1032     viewPopupMenu->addItem(menuItem);
1033 }
1034 /*************************************************************************
1035 Define the module function that returns an instance of the sample
1036 *************************************************************************/
getSampleInstance()1037 extern "C" SAMPLE_EXPORT Sample& getSampleInstance()
1038 {
1039     static WidgetDemo sample;
1040     return sample;
1041 }
1042