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