?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' into main/rendor-staging
[ryzomcore.git] / nel / src / gui / widget_manager.cpp
blob01aab120fa70963caed828435336862b1857c978
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010-2020 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2013-2014 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
6 // Copyright (C) 2013-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
7 //
8 // This program is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Affero General Public License as
10 // published by the Free Software Foundation, either version 3 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Affero General Public License for more details.
17 //
18 // You should have received a copy of the GNU Affero General Public License
19 // along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
22 #include "stdpch.h"
23 #include "nel/gui/db_manager.h"
24 #include "nel/gui/view_renderer.h"
25 #include "nel/gui/widget_manager.h"
26 #include "nel/gui/view_pointer.h"
27 #include "nel/gui/ctrl_draggable.h"
28 #include "nel/gui/interface_group.h"
29 #include "nel/gui/group_container_base.h"
30 #include "nel/gui/group_modal.h"
31 #include "nel/gui/group_editbox_base.h"
32 #include "nel/gui/interface_options.h"
33 #include "nel/gui/view_text.h"
34 #include "nel/gui/view_bitmap.h"
35 #include "nel/gui/group_container.h"
36 #include "nel/gui/interface_anim.h"
37 #include "nel/gui/proc.h"
38 #include "nel/gui/interface_expr.h"
39 #include "nel/gui/reflect_register.h"
40 #include "nel/gui/editor_selection_watcher.h"
41 #include "nel/misc/events.h"
42 #include "nel/gui/root_group.h"
43
44 #ifdef DEBUG_NEW
45 #define new DEBUG_NEW
46 #endif
47
48 namespace NLGUI
49 {
50 void LinkHack();
51 }
52
53 namespace
54 {
55 const uint DOUBLE_CLICK_MIN = 50;
56 const uint DOUBLE_CLICK_MAX = 750;
57 const float ROLLOVER_MIN_DELTA_PER_MS = 0.28f;
58 const float ROLLOVER_MAX_DELTA_PER_MS = 0.12f;
59
60 void Hack()
61 {
62 LinkHack();
63 }
64 }
65
66 namespace NLGUI
67 {
68 CWidgetManager* CWidgetManager::instance = NULL;
69 std::string CWidgetManager::_CtrlLaunchingModalId= "ctrl_launch_modal";
70 // ----------------------------------------------------------------------------
71 // SMasterGroup
72 // ----------------------------------------------------------------------------
73
74 // ----------------------------------------------------------------------------
75 void CWidgetManager::SMasterGroup::addWindow(CInterfaceGroup *pIG, uint8 nPrio)
76 {
77 nlassert(nPrio<WIN_PRIORITY_MAX);
78
79 // Priority WIN_PRIORITY_WORLD_SPACE is only for CGroupInScene !
80 // Add this group in another priority list
81 nlassert ((nPrio!=WIN_PRIORITY_MAX) || pIG->isGroupInScene() );
82
83 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
84 {
85 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
86 while (it != PrioritizedWindows[i].end())
87 {
88 // If the element already exists in the list return !
89 if (*it == pIG)
90 return;
91 it++;
92 }
93 }
94 PrioritizedWindows[nPrio].push_back(pIG);
95 }
96
97 // ----------------------------------------------------------------------------
98 void CWidgetManager::SMasterGroup::delWindow(CInterfaceGroup *pIG)
99 {
100 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
101 {
102 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
103 while (it != PrioritizedWindows[i].end())
104 {
105 if ((*it) == pIG)
106 {
107 PrioritizedWindows[i].erase(it);
108 return;
109 }
110 it++;
111 }
112 }
113 }
114
115 // ----------------------------------------------------------------------------
116 CInterfaceGroup* CWidgetManager::SMasterGroup::getWindowFromId(const std::string &winID)
117 {
118 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
119 {
120 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
121 while (it != PrioritizedWindows[i].end())
122 {
123 if ((*it)->getId() == winID)
124 return *it;
125 it++;
126 }
127 }
128 return NULL;
129 }
130
131 // ----------------------------------------------------------------------------
132 bool CWidgetManager::SMasterGroup::isWindowPresent(CInterfaceGroup *pIG)
133 {
134 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
135 {
136 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
137 while (it != PrioritizedWindows[i].end())
138 {
139 if ((*it) == pIG)
140 return true;
141 it++;
142 }
143 }
144 return false;
145 }
146
147 // Set a window top in its priority queue
148 // ----------------------------------------------------------------------------
149 void CWidgetManager::SMasterGroup::setTopWindow(CInterfaceGroup *pIG)
150 {
151 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
152 {
153 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
154 while (it != PrioritizedWindows[i].end())
155 {
156 if (*it == pIG)
157 {
158 PrioritizedWindows[i].erase(it);
159 PrioritizedWindows[i].push_back(pIG);
160 LastTopWindowPriority= i;
161 return;
162 }
163 it++;
164 }
165 }
166 // todo hulud interface syntax error
167 nlwarning("window %s do not exist in a priority list", pIG->getId().c_str());
168 }
169
170 // ----------------------------------------------------------------------------
171 void CWidgetManager::SMasterGroup::setBackWindow(CInterfaceGroup *pIG)
172 {
173 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
174 {
175 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
176 while (it != PrioritizedWindows[i].end())
177 {
178 if (*it == pIG)
179 {
180 PrioritizedWindows[i].erase(it);
181 PrioritizedWindows[i].push_front(pIG);
182 return;
183 }
184 it++;
185 }
186 }
187 // todo hulud interface syntax error
188 nlwarning("window %s do not exist in a priority list", pIG->getId().c_str());
189 }
190
191 // ----------------------------------------------------------------------------
192 void CWidgetManager::SMasterGroup::deactiveAllContainers()
193 {
194 std::vector<CGroupContainerBase*> gcs;
195
196 // Make first a list of all window (Warning: all group container are not window!)
197 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
198 {
199 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
200 while (it != PrioritizedWindows[i].end())
201 {
202 CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
203 if (pGC != NULL)
204 gcs.push_back(pGC);
205 it++;
206 }
207 }
208
209 // Then hide them. Must do this in 2 times, because setActive(false) change PrioritizedWindows,
210 // and hence invalidate its.
211 for (uint32 i = 0; i < gcs.size(); ++i)
212 {
213 gcs[i]->setActive(false);
214 }
215 }
216
217 // ----------------------------------------------------------------------------
218 void CWidgetManager::SMasterGroup::centerAllContainers()
219 {
220 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
221 {
222 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
223 while (it != PrioritizedWindows[i].end())
224 {
225 CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
226 if ((pGC != NULL) && (pGC->getParent() != NULL))
227 {
228 sint32 wParent = pGC->getParent()->getW(false);
229 sint32 w = pGC->getW(false);
230 pGC->setXAndInvalidateCoords((wParent - w) / 2);
231 sint32 hParent = pGC->getParent()->getH(false);
232 sint32 h = pGC->getH(false);
233 pGC->setYAndInvalidateCoords(h+(hParent - h) / 2);
234 }
235
236 it++;
237 }
238 }
239 }
240
241 // ----------------------------------------------------------------------------
242 void CWidgetManager::SMasterGroup::unlockAllContainers()
243 {
244 for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
245 {
246 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
247 while (it != PrioritizedWindows[i].end())
248 {
249 CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
250 if (pGC != NULL)
251 pGC->setLocked(false);
252
253 it++;
254 }
255 }
256 }
257
258 class CElementToSort
259 {
260 public:
261 CInterfaceGroup *pIG;
262 float Distance;
263 bool operator< (const CElementToSort& other) const
264 {
265 // We want first farest views
266 return Distance > other.Distance;
267 }
268 };
269
270 void CWidgetManager::SMasterGroup::sortWorldSpaceGroup ()
271 {
272 static std::vector<CElementToSort> sortTable;
273 sortTable.clear ();
274
275 // Fill the sort table
276 std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].begin();
277 while (it != PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].end())
278 {
279 sortTable.push_back (CElementToSort ());
280 CElementToSort &elm = sortTable.back();
281 elm.pIG = *it;
282 elm.Distance = (*it)->getDepthForZSort();
283
284 it++;
285 }
286
287 // Sort the table
288 std::sort (sortTable.begin(), sortTable.end());
289
290 // Fill the final table
291 uint i = 0;
292 it = PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].begin();
293 while (it != PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].end())
294 {
295 *it = sortTable[i].pIG;
296
297 it++;
298 i++;
299 }
300 }
301
302
303 CWidgetManager* CWidgetManager::getInstance()
304 {
305 if( instance == NULL )
306 instance = new CWidgetManager;
307
308 return instance;
309 }
310
311 void CWidgetManager::release()
312 {
313 delete instance;
314 instance = NULL;
315 }
316
317 // ----------------------------------------------------------------------------
318 CInterfaceGroup* CWidgetManager::getMasterGroupFromId (const std::string &MasterGroupName)
319 {
320 for (uint32 i = 0; i < _MasterGroups.size(); ++i)
321 {
322 if (_MasterGroups[i].Group->getId() == MasterGroupName)
323 return _MasterGroups[i].Group;
324 }
325 return NULL;
326 }
327
328 // ----------------------------------------------------------------------------
329 CInterfaceGroup* CWidgetManager::getWindowFromId (const std::string & groupId)
330 {
331 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
332 {
333 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
334 CInterfaceGroup *pIG = rMG.getWindowFromId(groupId);
335 if (pIG != NULL)
336 return pIG;
337 }
338 return NULL;
339 }
340
341 // ----------------------------------------------------------------------------
342 void CWidgetManager::addWindowToMasterGroup (const std::string &sMasterGroupName, CInterfaceGroup *pIG)
343 {
344 // Warning this function is not smart : its a o(n) !
345 if (pIG == NULL) return;
346 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); ++nMasterGroup)
347 {
348 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
349 if (rMG.Group->getId() == sMasterGroupName)
350 {
351 rMG.addWindow(pIG, pIG->getPriority());
352 }
353 }
354 }
355
356 // ----------------------------------------------------------------------------
357 void CWidgetManager::removeWindowFromMasterGroup(const std::string &sMasterGroupName,CInterfaceGroup *pIG)
358 {
359 // Warning this function is not smart : its a o(n) !
360 if (pIG == NULL) return;
361 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); ++nMasterGroup)
362 {
363 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
364 if (rMG.Group->getId() == sMasterGroupName)
365 {
366 rMG.delWindow(pIG);
367 }
368 }
369 }
370
371 void unlinkAllContainers (CInterfaceGroup *pIG)
372 {
373 const std::vector<CInterfaceGroup*> &rG = pIG->getGroups();
374 for(uint i = 0; i < rG.size(); ++i)
375 unlinkAllContainers (rG[i]);
376
377 CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(pIG);
378 if (pGC != NULL)
379 pGC->removeAllContainers();
380 }
381
382 // ***************************************************************************
383 void CWidgetManager::removeAllMasterGroups()
384 {
385 uint i;
386
387 for (i = 0; i < _MasterGroups.size(); ++i)
388 unlinkAllContainers (_MasterGroups[i].Group);
389
390 // Yoyo: important to not Leave NULL in the array, because of CGroupHTML and LibWWW callback
391 // that may call CInterfaceManager::getElementFromId() (and this method hates having NULL in the arrays ^^)
392 while(!_MasterGroups.empty())
393 {
394 delete _MasterGroups.back().Group;
395 _MasterGroups.pop_back();
396 }
397
398 }
399
400 // ------------------------------------------------------------------------------------------------
401 void CWidgetManager::activateMasterGroup (const std::string &sMasterGroupName, bool bActive)
402 {
403 CInterfaceGroup *pIG = getMasterGroupFromId (sMasterGroupName);
404 if (pIG != NULL)
405 {
406 pIG->setActive(bActive);
407 pIG->invalidateCoords();
408 }
409 }
410
411 // ------------------------------------------------------------------------------------------------
412 CInterfaceGroup* CWidgetManager::getWindow(CInterfaceElement *pIE)
413 {
414 CInterfaceGroup *pIG = pIE->getParent();
415 if (pIG == NULL) return NULL;
416 if (pIG->getParent() == NULL) return NULL;
417 while (pIG->getParent()->getParent() != NULL)
418 {
419 pIG = pIG->getParent();
420 }
421 return pIG;
422 }
423
424
425 // ------------------------------------------------------------------------------------------------
426 CInterfaceElement* CWidgetManager::getElementFromId (const std::string &sEltId)
427 {
428 // System special
429 if(sEltId == _CtrlLaunchingModalId)
430 return getCtrlLaunchingModal();
431
432 // Search for all elements
433 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
434 {
435 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
436 CInterfaceElement *pIEL = rMG.Group->getElement (sEltId);
437 if (pIEL != NULL)
438 return pIEL;
439 }
440 return NULL;
441 }
442
443 // ------------------------------------------------------------------------------------------------
444 CInterfaceElement* CWidgetManager::getElementFromId (const std::string &sStart, const std::string &sEltId)
445 {
446 CInterfaceElement *pIEL = getElementFromId (sEltId);
447 if (pIEL == NULL)
448 {
449 std::string sZeStart = sStart, sTmp;
450 if (sZeStart[sZeStart.size()-1] == ':')
451 sZeStart = sZeStart.substr(0, sZeStart.size()-1);
452
453 while (!sZeStart.empty())
454 {
455 if (sEltId[0] == ':')
456 sTmp = sZeStart + sEltId;
457 else
458 sTmp = sZeStart + ":" + sEltId;
459 pIEL = getElementFromId (sTmp);
460 if (pIEL != NULL)
461 return pIEL;
462 std::string::size_type nextPos = sZeStart.rfind(':');
463 if (nextPos == std::string::npos) break;
464 sZeStart = sZeStart.substr(0, nextPos);
465 }
466 }
467 return pIEL;
468 }
469
470 // ------------------------------------------------------------------------------------------------
471 CInterfaceElement* CWidgetManager::getElementFromDefine( const std::string &defineId )
472 {
473 return getElementFromId( _Parser->getDefine( defineId ) );
474 }
475
476 // ------------------------------------------------------------------------------------------------
477 void CWidgetManager::setTopWindow (CInterfaceGroup* win)
478 {
479 //find the window in the window list
480 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
481 {
482 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
483 if (rMG.Group->getActive())
484 rMG.setTopWindow(win);
485 }
486 }
487
488 // ------------------------------------------------------------------------------------------------
489 void CWidgetManager::setBackWindow(CInterfaceGroup* win)
490 {
491 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
492 {
493 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
494 if (rMG.Group->getActive())
495 rMG.setBackWindow(win);
496 }
497 }
498
499 // ------------------------------------------------------------------------------------------------
500 CInterfaceGroup* CWidgetManager::getTopWindow (uint8 nPriority) const
501 {
502 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
503 {
504 const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
505 if (rMG.Group->getActive())
506 {
507 // return the first.
508 if(rMG.PrioritizedWindows[nPriority].empty())
509 return NULL;
510 else
511 return rMG.PrioritizedWindows[nPriority].back();
512 }
513 }
514 return NULL;
515 }
516
517
518 // ------------------------------------------------------------------------------------------------
519 CInterfaceGroup* CWidgetManager::getBackWindow (uint8 nPriority) const
520 {
521 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
522 {
523 const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
524 if (rMG.Group->getActive())
525 {
526 // return the first.
527 if(rMG.PrioritizedWindows[nPriority].empty())
528 return NULL;
529 else
530 return rMG.PrioritizedWindows[nPriority].front();
531 }
532 }
533 return NULL;
534 }
535
536 // ***************************************************************************
537 CInterfaceGroup* CWidgetManager::getLastEscapableTopWindow() const
538 {
539 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
540 {
541 const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
542 if (rMG.Group->getActive())
543 {
544 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
545 {
546 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
547 std::list<CInterfaceGroup*>::const_reverse_iterator it;
548 it= rList.rbegin();
549 for(;it!=rList.rend();it++)
550 {
551 if((*it)->getActive() && (*it)->getEscapable())
552 return *it;
553 }
554 }
555 }
556 }
557 return NULL;
558 }
559
560 // ***************************************************************************
561 void CWidgetManager::setWindowPriority (CInterfaceGroup *pWin, uint8 nNewPriority)
562 {
563 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
564 {
565 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
566 if (rMG.Group->getActive())
567 {
568 if (rMG.isWindowPresent(pWin))
569 {
570 rMG.delWindow(pWin);
571 rMG.addWindow(pWin, nNewPriority);
572 }
573 }
574 }
575 }
576
577 // ***************************************************************************
578 uint8 CWidgetManager::getLastTopWindowPriority() const
579 {
580 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
581 {
582 const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
583 if (rMG.Group->getActive())
584 {
585 return rMG.LastTopWindowPriority;
586 }
587 }
588 return 0;
589 }
590
591 bool CWidgetManager::hasModal() const
592 {
593 if( !_ModalStack.empty() )
594 return true;
595 else
596 return false;
597 }
598
599 CWidgetManager::SModalWndInfo& CWidgetManager::getModal()
600 {
601 return _ModalStack.back();
602 }
603
604 bool CWidgetManager::isPreviousModal( CInterfaceGroup *wnd ) const
605 {
606 std::vector< SModalWndInfo >::size_type s = _ModalStack.size();
607 for( std::vector< SModalWndInfo >::size_type i = 0; i < s; i++ )
608 if( _ModalStack[ i ].ModalWindow == wnd )
609 return true;
610
611 return false;
612 }
613
614 // ------------------------------------------------------------------------------------------------
615 void CWidgetManager::enableModalWindow (CCtrlBase *ctrlLaunchingModal, CInterfaceGroup *pIG)
616 {
617 // disable any modal before. release keyboard
618 disableModalWindow();
619 pushModalWindow(ctrlLaunchingModal, pIG);
620 }
621
622 // ------------------------------------------------------------------------------------------------
623 void CWidgetManager::enableModalWindow (CCtrlBase *CtrlLaunchingModal, const std::string &groupName)
624 {
625 CInterfaceGroup *group= dynamic_cast<CGroupModal*>( getElementFromId(groupName) );
626 if(group)
627 {
628 // enable the modal
629 enableModalWindow(CtrlLaunchingModal, group);
630 }
631 }
632
633 // ------------------------------------------------------------------------------------------------
634 void CWidgetManager::disableModalWindow ()
635 {
636 while (!_ModalStack.empty())
637 {
638 SModalWndInfo winInfo = _ModalStack.back();
639 _ModalStack.pop_back(); // must pop back as early as possible because 'setActive' may trigger another 'popModalWindow', leading to a crash
640 // disable old modal window
641 if(winInfo.ModalWindow)
642 {
643 setBackWindow(winInfo.ModalWindow);
644 winInfo.ModalWindow->setActive(false);
645 }
646 }
647
648 // disable any context help
649 setCurContextHelp( NULL );
650 _DeltaTimeStopingContextHelp = 0;
651 }
652
653 // ------------------------------------------------------------------------------------------------
654 void CWidgetManager::pushModalWindow(CCtrlBase *ctrlLaunchingModal, CInterfaceGroup *pIG)
655 {
656 // enable the wanted modal
657 if(pIG)
658 {
659 SModalWndInfo mwi;
660 mwi.ModalWindow = pIG;
661 mwi.CtrlLaunchingModal = ctrlLaunchingModal;
662 // setup special group
663 CGroupModal *groupModal= dynamic_cast<CGroupModal*>(pIG);
664 if(groupModal)
665 {
666 mwi.ModalExitClickOut = groupModal->ExitClickOut;
667 mwi.ModalExitClickL = groupModal->ExitClickL;
668 mwi.ModalExitClickR = groupModal->ExitClickR;
669 mwi.ModalHandlerClickOut = groupModal->OnClickOut;
670 mwi.ModalClickOutParams = groupModal->OnClickOutParams;
671 mwi.ModalExitKeyPushed = groupModal->ExitKeyPushed;
672 // update coords of the modal
673 if(groupModal->SpawnOnMousePos)
674 {
675 groupModal->SpawnMouseX = _Pointer->getX();
676 groupModal->SpawnMouseY = _Pointer->getY();
677 }
678 }
679 else
680 {
681 // default for group not modal. Backward compatibility
682 mwi.ModalExitClickOut = false;
683 mwi.ModalExitClickL = false;
684 mwi.ModalExitClickR = false;
685 mwi.ModalExitKeyPushed = false;
686 }
687
688 _ModalStack.push_back(mwi);
689
690 // update coords and activate the modal
691 mwi.ModalWindow->invalidateCoords();
692 mwi.ModalWindow->setActive(true);
693 setTopWindow(mwi.ModalWindow);
694 }
695 }
696
697 // ------------------------------------------------------------------------------------------------
698 void CWidgetManager::pushModalWindow(CCtrlBase *ctrlLaunchingModal, const std::string &groupName)
699 {
700 CInterfaceGroup *group= dynamic_cast<CGroupModal*>( getElementFromId(groupName) );
701 if(group)
702 {
703 // enable the modal
704 enableModalWindow(ctrlLaunchingModal, group);
705 }
706 }
707
708 // ------------------------------------------------------------------------------------------------
709 void CWidgetManager::popModalWindow()
710 {
711 if (!_ModalStack.empty())
712 {
713 SModalWndInfo winInfo = _ModalStack.back();
714 _ModalStack.pop_back(); // must pop back as early as possible because 'setActive' may trigger another 'popModalWindow', leading to a crash
715 if(winInfo.ModalWindow)
716 {
717 setBackWindow(winInfo.ModalWindow);
718 winInfo.ModalWindow->setActive(false);
719 }
720 if (!_ModalStack.empty())
721 {
722 if(_ModalStack.back().ModalWindow)
723 {
724 _ModalStack.back().ModalWindow->setActive(true);
725 setTopWindow(_ModalStack.back().ModalWindow);
726 }
727 }
728 }
729 }
730
731 // ------------------------------------------------------------------------------------------------
732 void CWidgetManager::popModalWindowCategory(const std::string &category)
733 {
734 for(;;)
735 {
736 if (_ModalStack.empty()) break;
737 if (!_ModalStack.back().ModalWindow) break;
738 CGroupModal *gm = dynamic_cast<CGroupModal *>((CInterfaceGroup*)(_ModalStack.back().ModalWindow));
739 if (gm && gm->Category == category)
740 {
741 _ModalStack.back().ModalWindow->setActive(false);
742 _ModalStack.pop_back();
743 }
744 else
745 {
746 break;
747 }
748 }
749 }
750
751 // ***************************************************************************
752 void CWidgetManager::hideAllWindows()
753 {
754 for (uint nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
755 {
756 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
757 if (rMG.Group->getActive())
758 {
759 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
760 {
761 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
762 std::list<CInterfaceGroup*>::const_iterator itw;
763 for (itw = rList.begin(); itw!= rList.end();)
764 {
765 CInterfaceGroup *pIG = *itw;
766 itw++; // since setActive invalidate the iterator, be sure we move to the next one before
767 pIG->setActive(false);
768 }
769 }
770 }
771 }
772 }
773
774 // ***************************************************************************
775 void CWidgetManager::hideAllNonSavableWindows()
776 {
777 for (uint nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
778 {
779 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
780 if (rMG.Group->getActive())
781 {
782 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
783 {
784 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
785 std::list<CInterfaceGroup*>::const_iterator itw;
786 for (itw = rList.begin(); itw!= rList.end();)
787 {
788 CInterfaceGroup *pIG = *itw;
789 CGroupContainer *cont = dynamic_cast<CGroupContainer *>(pIG);
790 itw++; // since setActive invalidate the iterator, be sure we move to the next one before
791 if (!cont || !cont->isSavable())
792 {
793 pIG->setActive(false);
794 }
795 }
796 }
797 }
798 }
799 }
800
801 // ------------------------------------------------------------------------------------------------
802 CInterfaceGroup* CWidgetManager::getWindowUnder (sint32 x, sint32 y)
803 {
804 H_AUTO (RZ_Interface_Window_Under )
805
806 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
807 {
808 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
809 if (rMG.Group->getActive())
810 {
811 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
812 {
813 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
814 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
815 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
816 {
817 CInterfaceGroup *pIG = *itw;
818 if (pIG->getActive() && pIG->getUseCursor())
819 {
820 if (pIG->isWindowUnder (x, y))
821 return pIG;
822 }
823 }
824 }
825 }
826 }
827 return NULL;
828 }
829
830 // ------------------------------------------------------------------------------------------------
831 CInterfaceGroup* CWidgetManager::getGroupUnder (sint32 x, sint32 y)
832 {
833 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
834 {
835 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
836 if (rMG.Group->getActive())
837 {
838 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
839 {
840 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
841 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
842 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
843 {
844 CInterfaceGroup *pIG = *itw;
845 if (pIG->getActive() && pIG->getUseCursor())
846 {
847 CInterfaceGroup *pIGunder = pIG->getGroupUnder (x ,y);
848 if (pIGunder != NULL)
849 return pIGunder;
850 }
851 }
852 }
853 }
854 }
855 return NULL;
856 }
857
858 // ------------------------------------------------------------------------------------------------
859 void CWidgetManager::getViewsUnder (sint32 x, sint32 y, std::vector<CViewBase*> &vVB)
860 {
861 vVB.clear ();
862
863 // No Op if screen minimized
864 if(CViewRenderer::getInstance()->isMinimized())
865 return;
866
867 uint32 sw, sh;
868 CViewRenderer::getInstance()->getScreenSize(sw, sh);
869 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
870 {
871 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
872 if (rMG.Group->getActive())
873 {
874 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
875 {
876 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
877 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
878 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
879 {
880 CInterfaceGroup *pIG = *itw;
881
882 // Accecpt if not modal clip
883 if (pIG->getActive() && pIG->getUseCursor())
884 {
885 if (pIG->getViewsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vVB))
886 return ;
887 }
888 }
889 }
890 }
891 }
892 }
893
894 // ------------------------------------------------------------------------------------------------
895 void CWidgetManager::getCtrlsUnder (sint32 x, sint32 y, std::vector<CCtrlBase*> &vICL)
896 {
897 vICL.clear ();
898
899 // No Op if screen minimized
900 if(CViewRenderer::getInstance()->isMinimized())
901 return;
902
903 uint32 sw, sh;
904 CViewRenderer::getInstance()->getScreenSize(sw, sh);
905 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
906 {
907 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
908 if (rMG.Group->getActive())
909 {
910 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0 ; nPriority--)
911 {
912 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
913 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
914 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
915 {
916 CInterfaceGroup *pIG = *itw;
917
918 // Accecpt if not modal clip
919 if (!hasModal() || getModal().ModalWindow == pIG || getModal().ModalExitClickOut)
920 if (pIG->getActive() && pIG->getUseCursor())
921 {
922 if (pIG->getCtrlsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vICL))
923 return;
924 }
925 }
926 }
927 }
928 }
929 }
930
931
932 // ------------------------------------------------------------------------------------------------
933 void CWidgetManager::getGroupsUnder (sint32 x, sint32 y, std::vector<CInterfaceGroup *> &vIGL)
934 {
935 vIGL.clear ();
936
937 // No Op if screen minimized
938 if(CViewRenderer::getInstance()->isMinimized())
939 return;
940
941 uint32 sw, sh;
942 CViewRenderer::getInstance()->getScreenSize(sw, sh);
943 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
944 {
945 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
946 if (rMG.Group->getActive())
947 {
948 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0 ; nPriority--)
949 {
950 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
951 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
952 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
953 {
954 CInterfaceGroup *pIG = *itw;
955
956 // Accecpt if not modal clip
957 if (!hasModal() || getModal().ModalWindow == pIG ||
958 getModal().ModalExitClickOut)
959 if (pIG->getActive() && pIG->getUseCursor())
960 {
961 if (pIG->isIn(x, y))
962 {
963 vIGL.push_back(pIG);
964 pIG->getGroupsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vIGL);
965 return;
966 }
967 }
968 }
969 }
970 }
971 }
972 }
973
974
975 // ***************************************************************************
976 void CWidgetManager::removeRefOnView( CViewBase *viewBase )
977 {
978 uint i;
979 for (i=0; i<_ViewsUnderPointer.size(); i++)
980 {
981 if (_ViewsUnderPointer[i] == viewBase)
982 {
983 _ViewsUnderPointer.erase (_ViewsUnderPointer.begin()+i);
984 i--;
985 }
986 }
987 }
988
989 // ***************************************************************************
990 void CWidgetManager::removeRefOnCtrl(CCtrlBase *ctrlBase)
991 {
992 if ( getCurContextHelp() == ctrlBase)
993 setCurContextHelp( NULL );
994 if (getCapturePointerLeft() == ctrlBase)
995 setCapturePointerLeft(NULL);
996 if (getCapturePointerRight() == ctrlBase)
997 setCapturePointerRight (NULL);
998 if (getCaptureKeyboard() == ctrlBase)
999 setCaptureKeyboard(NULL);
1000 if (getOldCaptureKeyboard() == ctrlBase)
1001 setOldCaptureKeyboard(NULL);
1002 if (getDefaultCaptureKeyboard() == ctrlBase)
1003 setDefaultCaptureKeyboard(NULL);
1004 uint i;
1005 for (i=0; i<_CtrlsUnderPointer.size(); i++)
1006 {
1007 if (_CtrlsUnderPointer[i] == ctrlBase)
1008 {
1009 _CtrlsUnderPointer.erase (_CtrlsUnderPointer.begin()+i);
1010 i--;
1011 }
1012 }
1013
1014 // Unregister from ClockMsgTargets
1015 unregisterClockMsgTarget(ctrlBase);
1016 }
1017
1018
1019 // ***************************************************************************
1020 void CWidgetManager::removeRefOnGroup (CInterfaceGroup *group)
1021 {
1022 uint i;
1023 for (i=0; i<_GroupsUnderPointer.size(); i++)
1024 {
1025 if (_GroupsUnderPointer[i] == group)
1026 {
1027 _GroupsUnderPointer.erase (_GroupsUnderPointer.begin()+i);
1028 i--;
1029 }
1030 }
1031 }
1032
1033
1034 void CWidgetManager::reset()
1035 {
1036 setCurContextHelp( NULL );
1037
1038 _ViewsUnderPointer.clear();
1039 _CtrlsUnderPointer.clear();
1040 _GroupsUnderPointer.clear();
1041
1042 _CaptureKeyboard = NULL;
1043 _OldCaptureKeyboard = NULL;
1044 setCapturePointerLeft(NULL);
1045 setCapturePointerRight(NULL);
1046 _CapturedView = NULL;
1047
1048 resetColorProps();
1049 resetAlphaRolloverSpeedProps();
1050 resetGlobalAlphasProps();
1051
1052 _ContextHelpContentAlphaDB = NULL;
1053 _ContextHelpContainerColorDB = NULL;
1054 _ContextHelpContainerAlphaDB = NULL;
1055
1056 activeAnims.clear();
1057
1058 editorSelection.clear();
1059 }
1060
1061
1062 // ------------------------------------------------------------------------------------------------
1063 void CWidgetManager::checkCoords()
1064 {
1065 H_AUTO ( RZ_Interface_validateCoords )
1066
1067 uint32 nMasterGroup;
1068
1069 {
1070 H_AUTO ( RZ_Interface_checkCoords )
1071
1072 // checkCoords all the windows
1073 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
1074 {
1075 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
1076 if (rMG.Group->getActive())
1077 {
1078 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
1079 {
1080 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
1081 std::list<CInterfaceGroup*>::const_iterator itw;
1082 for (itw = rList.begin(); itw!= rList.end();)
1083 {
1084 CInterfaceGroup *pIG = *itw;
1085 itw++; // since checkCoords invalidate the iterator, be sure we move to the next one before
1086 if (pIG->getActive())
1087 pIG->checkCoords ();
1088 }
1089 }
1090 }
1091 }
1092 }
1093
1094 bool bRecomputeCtrlUnderPtr = false;
1095 {
1096 H_AUTO ( RZ_Interface_updateCoords )
1097
1098 // updateCoords all the needed windows
1099 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
1100 {
1101 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
1102 if (rMG.Group->getActive())
1103 {
1104 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
1105 {
1106 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
1107 std::list<CInterfaceGroup*>::const_iterator itw;
1108 for (itw = rList.begin(); itw!= rList.end(); itw++)
1109 {
1110 CInterfaceGroup *pIG = *itw;
1111 bool updateCoordCalled= false;
1112 // updateCoords the window only if the master group is his parent and if need it
1113 // do it until updateCoords() no more invalidate coordinates!!
1114
1115 // add deadlock counter to prevent endless loop (Issue #73: web browser long scroll lockup)
1116 int deadlock = 10;
1117 while (--deadlock > 0 && pIG->getParent()==rMG.Group && (pIG->getInvalidCoords()>0))
1118 {
1119 bRecomputeCtrlUnderPtr = true;
1120 // Update as many pass wanted (3 time for complex resizing, 1 for scroll for example)
1121 uint numPass= pIG->getInvalidCoords();
1122 // reset before updateCoords
1123 pIG->resetInvalidCoords();
1124 for(uint i=0;i<numPass;i++)
1125 {
1126 pIG->updateCoords ();
1127 }
1128 updateCoordCalled= true;
1129 }
1130 // If the group need to update pos each frame (eg: CGroupInScene),
1131 // and updateCoords not called
1132 if(pIG->getParent()==rMG.Group && !updateCoordCalled && pIG->isNeedFrameUpdatePos())
1133 {
1134 // This Group will compute the delta to apply.
1135 pIG->onFrameUpdateWindowPos(0,0);
1136 }
1137 }
1138 }
1139 }
1140 }
1141
1142 if ( getPointer() != NULL)
1143 getPointer()->updateCoords();
1144 }
1145
1146
1147
1148 if (bRecomputeCtrlUnderPtr)
1149 {
1150 H_AUTO ( RZ_Interface_RecomputeCtrlUnderPtr )
1151 if ( getPointer() != NULL )
1152 {
1153 sint32 mx = _Pointer->getX();
1154 sint32 my = _Pointer->getY();
1155 getViewsUnder (mx, my, _ViewsUnderPointer);
1156 getCtrlsUnder (mx, my, _CtrlsUnderPointer);
1157 getGroupsUnder (mx, my, _GroupsUnderPointer);
1158 CInterfaceGroup *ptr = getWindowUnder (mx, my);
1159 _WindowUnder = ptr;
1160 }
1161 }
1162 }
1163
1164
1165 // ----------------------------------------------------------------------------
1166 CInterfaceGroup* CWidgetManager::getWindowForActiveMasterGroup( const std::string &window )
1167 {
1168 // Search for all elements
1169 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
1170 {
1171 const SMasterGroup &rMG = _MasterGroups[nMasterGroup];
1172 if (rMG.Group->getActive())
1173 {
1174 CInterfaceElement *pEL= getElementFromId( rMG.Group->getId() + ":" + window);
1175 if(pEL && pEL->isGroup())
1176 return (CInterfaceGroup*)pEL;
1177 }
1178 }
1179
1180 return NULL;
1181 }
1182
1183
1184 // ***************************************************************************
1185 void CWidgetManager::drawOverExtendViewText()
1186 {
1187 if( getOverExtendViewText() )
1188 {
1189 CViewText *vtSrc= dynamic_cast<CViewText*>( getOverExtendViewText() );
1190
1191 CInterfaceGroup *groupOver = getWindowForActiveMasterGroup("over_extend_view_text");
1192 if(groupOver)
1193 {
1194 CViewText *vtDst = dynamic_cast<CViewText*>(groupOver->getView("text"));
1195 if (vtDst != NULL)
1196 {
1197 groupOver->setParentPos(vtSrc);
1198
1199 sint32 backupX = groupOver->getX();
1200
1201 // Copy all aspects to the view
1202 vtDst->setLocalized (vtSrc->isLocalized());
1203 vtDst->setText (vtSrc->getText());
1204 vtDst->setFontSize (vtSrc->getFontSize());
1205 vtDst->setColor (vtSrc->getColor());
1206 vtDst->setModulateGlobalColor(vtSrc->getModulateGlobalColor());
1207 vtDst->setShadow(vtSrc->getShadow());
1208 vtDst->setShadowOutline(vtSrc->getShadowOutline());
1209 vtDst->setShadowColor(vtSrc->getShadowColor());
1210 vtDst->setCaseMode(vtSrc->getCaseMode());
1211 vtDst->setUnderlined(vtSrc->getUnderlined());
1212
1213 // setup background
1214 CViewBitmap *pBack= dynamic_cast<CViewBitmap*>(groupOver->getView("midback"));
1215 CViewBitmap *pOutline= dynamic_cast<CViewBitmap*>(groupOver->getView("midoutline"));
1216 if(pBack)
1217 pBack->setColor( getOverExtendViewTextBackColor() );
1218 if(pOutline)
1219 {
1220 pOutline->setColor(vtSrc->getColor());
1221 pOutline->setModulateGlobalColor(vtSrc->getModulateGlobalColor());
1222 }
1223
1224 // update one time only to get correct W/H
1225 groupOver->updateCoords ();
1226
1227 // align and clamp to screen coords
1228 sint32 x = -backupX;
1229 if (vtSrc->isClampRight())
1230 {
1231 x += std::max(0, (groupOver->getXReal() + groupOver->getWReal()) - (groupOver->getParent()->getXReal() + groupOver->getParent()->getWReal()));
1232 }
1233 else
1234 {
1235 x += vtDst->getWReal() - vtSrc->getWReal();
1236 if ( x > (groupOver->getXReal() - groupOver->getParent()->getXReal()) )
1237 {
1238 x -= x - (groupOver->getXReal() - groupOver->getParent()->getXReal());
1239 }
1240 }
1241 if (x != 0) groupOver->setX(-x);
1242
1243 // TODO: there should be no overflow on y, unless barely visible and next to screen border
1244
1245 groupOver->updateCoords();
1246
1247 // draw
1248 groupOver->draw ();
1249 // flush layers
1250 CViewRenderer::getInstance()->flush();
1251
1252 // restore backup values
1253 if (x != 0) groupOver->setX(backupX);
1254 }
1255 }
1256
1257 // Reset the ptr so at next frame, won't be rendered (but if reset)
1258 setOverExtendViewText( NULL, getOverExtendViewTextBackColor() );
1259 }
1260 }
1261
1262 // ----------------------------------------------------------------------------
1263 void CWidgetManager::snapIfClose(CInterfaceGroup *group)
1264 {
1265 if (!group || _WindowSnapDistance == 0 || _WindowSnapInvert != lastKeyEvent.isShiftDown())
1266 return;
1267
1268 uint hsnap = _WindowSnapDistance;
1269 uint vsnap = _WindowSnapDistance;
1270
1271 sint32 newX = group->getX();
1272 sint32 newY = group->getY();
1273
1274 // new coords for window without snap
1275 // used to calculate distance from target
1276 sint gLeft = newX;
1277 sint gRight = newX + group->getWReal();
1278 sint gTop = newY;
1279 sint gBottom = newY - group->getHReal();
1280
1281 // current window coords as if already snaped
1282 // used to calculate target for snap
1283 sint gLeftR = group->getXReal();
1284 sint gRightR = gLeftR + group->getWReal();
1285 sint gBottomR = group->getYReal();
1286 sint gTopR = gBottomR + group->getHReal();
1287
1288 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
1289 {
1290 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
1291 if (!rMG.Group->getActive()) continue;
1292
1293 for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0 ; nPriority--)
1294 {
1295 const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
1296 std::list<CInterfaceGroup*>::const_reverse_iterator itw;
1297 for (itw = rList.rbegin(); itw != rList.rend(); itw++)
1298 {
1299 CInterfaceGroup *pIG = *itw;
1300 // do not snap to self, inactive, or not using mouse interaction
1301 if (group == pIG || !(pIG->getActive() && pIG->getUseCursor()))
1302 continue;
1303
1304 // target
1305 sint wLeft = pIG->getXReal();
1306 sint wRight = pIG->getXReal() + pIG->getWReal();
1307 sint wTop = pIG->getYReal() + pIG->getHReal();
1308 sint wBottom = pIG->getYReal();
1309 sint delta;
1310
1311 if (gTopR >= wBottom && gBottomR <= wTop)
1312 {
1313 delta = abs(gRight - wLeft);
1314 if (delta <= hsnap)
1315 {
1316 hsnap = delta;
1317 newX = wLeft - group->getWReal();
1318 }
1319
1320 delta = abs(gLeft - wRight);
1321 if (delta <= hsnap)
1322 {
1323 hsnap = delta;
1324 newX = wRight;
1325 }
1326
1327 delta = abs(gLeft - wLeft);
1328 if (delta <= hsnap)
1329 {
1330 hsnap = delta;
1331 newX = wLeft;
1332 }
1333
1334 delta = abs(gRight - wRight);
1335 if (delta <= hsnap)
1336 {
1337 hsnap = delta;
1338 newX = wRight - group->getWReal();
1339 }
1340 }
1341
1342 if (gLeftR <= wRight && gRightR >= wLeft)
1343 {
1344 delta = abs(gTop - wBottom);
1345 if (delta <= vsnap)
1346 {
1347 vsnap = delta;
1348 newY = wBottom;
1349 }
1350
1351 delta = abs(gBottom - wTop);
1352 if (delta <= vsnap)
1353 {
1354 vsnap = delta;
1355 newY = wTop + group->getHReal();
1356 }
1357
1358 delta = abs(gTop - wTop);
1359 if (delta <= vsnap)
1360 {
1361 vsnap = delta;
1362 newY = wTop;
1363 }
1364
1365 delta = abs(gBottom - wBottom);
1366 if (delta <= vsnap)
1367 {
1368 vsnap = delta;
1369 newY = wBottom + group->getHReal();
1370 }
1371 }
1372 }//windows
1373 }//priority
1374 }//master group
1375
1376 group->setX(newX);
1377 group->setY(newY);
1378 }
1379
1380 // ----------------------------------------------------------------------------
1381 uint CWidgetManager::adjustTooltipPosition( CCtrlBase *newCtrl, CInterfaceGroup *win, THotSpot ttParentRef,
1382 THotSpot ttPosRef, sint32 xParent, sint32 yParent,
1383 sint32 wParent, sint32 hParent )
1384 {
1385 CCtrlBase::TToolTipParentType parentType= newCtrl->getToolTipParent();
1386 CInterfaceGroup *groupContextHelp =
1387 getWindowForActiveMasterGroup(newCtrl->getContextHelpWindowName());
1388
1389 uint32 _ScreenH, _ScreenW;
1390 CViewRenderer::getInstance()->getScreenSize( _ScreenW, _ScreenH );
1391
1392 if(ttPosRef==Hotspot_TTAuto || ttParentRef==Hotspot_TTAuto)
1393 {
1394 // NB: keep the special window if type is specialwindow (defined above)
1395 if(!win)
1396 win= newCtrl->getRootWindow();
1397 sint32 xWin= 0;
1398 sint32 yWin= 0;
1399 sint32 wWin= 0;
1400 sint32 hWin= 0;
1401 if(win)
1402 {
1403 xWin = win->getXReal();
1404 yWin = win->getYReal();
1405 wWin = win->getWReal();
1406 hWin = win->getHReal();
1407 }
1408 // for Window, display top or bottom according to window pos/size
1409 if(parentType==CCtrlBase::TTWindow || parentType==CCtrlBase::TTSpecialWindow)
1410 {
1411 sint32 top= (sint32)_ScreenH - (yWin+hWin);
1412 sint32 bottom= yWin;
1413 if(top>bottom)
1414 {
1415 ttParentRef= Hotspot_TL;
1416 ttPosRef= Hotspot_BL;
1417 }
1418 else
1419 {
1420 ttParentRef= Hotspot_BL;
1421 ttPosRef= Hotspot_TL;
1422 }
1423 }
1424 // for Ctrl, display top, left or right according to window pos/size
1425 else if(parentType==CCtrlBase::TTCtrl)
1426 {
1427 sint32 right= (sint32)_ScreenW - (xWin+wWin);
1428 sint32 left= xWin;
1429 if(right>left)
1430 {
1431 ttParentRef= Hotspot_TR;
1432 ttPosRef= Hotspot_BL;
1433 }
1434 else
1435 {
1436 ttParentRef= Hotspot_TL;
1437 ttPosRef= Hotspot_BR;
1438 }
1439 }
1440 else
1441 {
1442 // default (mouse)
1443 ttParentRef= Hotspot_BL;
1444 ttPosRef= Hotspot_BL;
1445 }
1446 }
1447
1448 // **** compute coordinates of the tooltip
1449 sint32 x= xParent;
1450 sint32 y= yParent;
1451 if (ttParentRef & Hotspot_Mx)
1452 y += hParent/2;
1453 if (ttParentRef & Hotspot_Tx)
1454 y += hParent;
1455 if (ttParentRef & Hotspot_xM)
1456 x += wParent/2;
1457 if (ttParentRef & Hotspot_xR)
1458 x += wParent;
1459
1460 // adjust according to self posref
1461 if (ttPosRef & Hotspot_Mx)
1462 y -= groupContextHelp->getHReal()/2;
1463 if (ttPosRef & Hotspot_Tx)
1464 y -= groupContextHelp->getHReal();
1465 if (ttPosRef & Hotspot_xM)
1466 x -= groupContextHelp->getWReal()/2;
1467 if (ttPosRef & Hotspot_xR)
1468 x -= groupContextHelp->getWReal();
1469
1470
1471 // **** clamp to screen coords, and set
1472 uint clampCount = 0;
1473
1474 if ((x+groupContextHelp->getW()) > groupContextHelp->getParent()->getWReal())
1475 {
1476 ++ clampCount;
1477 x = groupContextHelp->getParent()->getWReal() - groupContextHelp->getW();
1478 }
1479 if (x < 0)
1480 {
1481 x = 0;
1482 ++ clampCount;
1483 }
1484 if ((y+groupContextHelp->getH()) > groupContextHelp->getParent()->getHReal())
1485 {
1486 y = groupContextHelp->getParent()->getHReal() - groupContextHelp->getH();
1487 ++ clampCount;
1488 }
1489 if (y < 0)
1490 {
1491 y = 0;
1492 ++ clampCount;
1493 }
1494
1495 // update coords 3 times is required
1496 groupContextHelp->setX (x);
1497 groupContextHelp->setY (y);
1498 groupContextHelp->updateCoords ();
1499 groupContextHelp->updateCoords ();
1500 groupContextHelp->updateCoords ();
1501
1502 return clampCount;
1503 }
1504
1505 // ----------------------------------------------------------------------------
1506 void CWidgetManager::updateTooltipCoords()
1507 {
1508 updateTooltipCoords( getCurContextHelp() );
1509 }
1510
1511 void CWidgetManager::updateTooltipCoords( CCtrlBase *newCtrl )
1512 {
1513 if (!newCtrl) return;
1514 if (!newCtrl->getInvalidCoords()) return;
1515
1516 CInterfaceGroup *groupContextHelp =
1517 getWindowForActiveMasterGroup(newCtrl->getContextHelpWindowName());
1518
1519 if(groupContextHelp)
1520 {
1521 CViewText *pTxt = (CViewText*)groupContextHelp->getView("text");
1522 if (pTxt != NULL)
1523 {
1524 pTxt->setTextFormatTaged(_ContextHelpText);
1525 // update only to get correct W/H
1526 groupContextHelp->updateCoords ();
1527
1528
1529 // **** Compute parent coordinates
1530 CCtrlBase::TToolTipParentType parentType= newCtrl->getToolTipParent();
1531 CInterfaceGroup *win= NULL;
1532 // adjust to the mouse by default
1533 sint32 xParent= getPointer()->getX();
1534 sint32 yParent= getPointer()->getY();
1535 sint32 wParent= 0;
1536 sint32 hParent= 0;
1537 // adjust to the window
1538 if(parentType==CCtrlBase::TTWindow || parentType==CCtrlBase::TTSpecialWindow)
1539 {
1540 if(parentType==CCtrlBase::TTWindow)
1541 win= newCtrl->getRootWindow();
1542 else
1543 win =
1544 dynamic_cast<CInterfaceGroup*>( getElementFromId(newCtrl->getToolTipSpecialParent()));
1545
1546 if(win)
1547 {
1548 xParent = win->getXReal();
1549 yParent = win->getYReal();
1550 wParent = win->getWReal();
1551 hParent = win->getHReal();
1552 }
1553 // Bug...: leave default to pointer
1554 }
1555 // adjust to the ctrl
1556 else if (parentType==CCtrlBase::TTCtrl)
1557 {
1558 xParent = newCtrl->getXReal();
1559 yParent = newCtrl->getYReal();
1560 wParent = newCtrl->getWReal();
1561 hParent = newCtrl->getHReal();
1562 // Additionaly, must clip this ctrl with its parent
1563 // (else animals are buggy for instance)
1564 CInterfaceGroup *parent= newCtrl->getParent();
1565 if(parent)
1566 {
1567 sint32 xClip,yClip,wClip,hClip;
1568 parent->getClip(xClip,yClip,wClip,hClip);
1569 // clip bottom left
1570 xParent= std::max(xParent, xClip);
1571 yParent= std::max(yParent, yClip);
1572 // clip top right
1573 sint32 xrParent= std::min(xParent+ wParent, xClip+wClip);
1574 sint32 ytParent= std::min(yParent+ hParent, yClip+hClip);
1575 wParent= std::max((sint32)0, xrParent-xParent);
1576 hParent= std::max((sint32)0, ytParent-yParent);
1577 }
1578 }
1579
1580
1581 // **** resolve auto posref
1582 uint clampCount =
1583 adjustTooltipPosition( newCtrl, win, newCtrl->getToolTipParentPosRef(),
1584 newCtrl->getToolTipPosRef(), xParent, yParent,
1585 wParent, hParent);
1586
1587 if (clampCount != 0)
1588 {
1589 // try to fallback on alternate tooltip posref
1590 uint altClampCount =
1591 adjustTooltipPosition( newCtrl, win, newCtrl->getToolTipParentPosRefAlt(),
1592 newCtrl->getToolTipPosRefAlt(), xParent, yParent,
1593 wParent, hParent);
1594
1595 if (altClampCount > clampCount)
1596 {
1597 // worst ? resume to first posref
1598 adjustTooltipPosition( newCtrl, win, newCtrl->getToolTipParentPosRef(),
1599 newCtrl->getToolTipPosRef(), xParent, yParent,
1600 wParent, hParent);
1601 }
1602 }
1603 }
1604 }
1605 }
1606
1607 // ------------------------------------------------------------------------------------------------
1608 void CWidgetManager::updateContextHelpColors()
1609 {
1610 // TODO: should only update when dbProp changes and not on every frame
1611 if (!_ContextHelpContentAlphaDB)
1612 {
1613 _ContextHelpContentAlphaDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTEXT_HELP_CONTENT_ALPHA");
1614 _ContextHelpContainerColorDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTEXT_HELP_CONTAINER_COLOR");
1615 _ContextHelpContainerAlphaDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTEXT_HELP_CONTAINER_ALPHA");
1616 }
1617
1618 // tooltip content alpha
1619 _ContextHelpContentAlpha = (uint8) _ContextHelpContentAlphaDB->getValue32();
1620
1621 // tooltip container (background) color
1622 CInterfaceProperty ip;
1623 ip.setNodePtr(_ContextHelpContainerColorDB);
1624 _ContextHelpContainerColor = ip.getRGBA();
1625 _ContextHelpContainerColor.A = (uint8) _ContextHelpContainerAlphaDB->getValue32();
1626 }
1627
1628 // ------------------------------------------------------------------------------------------------
1629 void CWidgetManager::disableContextHelp()
1630 {
1631 setCurContextHelp( NULL );
1632 _DeltaTimeStopingContextHelp = 0;
1633 }
1634
1635 // ------------------------------------------------------------------------------------------------
1636 void CWidgetManager::disableContextHelpForControl( CCtrlBase *pCtrl )
1637 {
1638 if( pCtrl == NULL )
1639 return;
1640
1641 if( getCurContextHelp() == pCtrl )
1642 disableContextHelp();
1643 }
1644
1645 // ----------------------------------------------------------------------------
1646 CCtrlBase* CWidgetManager::getNewContextHelpCtrl()
1647 {
1648 // get the top most ctrl under us
1649 CCtrlBase *best = NULL;
1650 sint8 bestRenderLayer = -128;
1651
1652 for (sint i = (sint32)_CtrlsUnderPointer.size()-1; i>=0; i--)
1653 {
1654 CCtrlBase *pICL = _CtrlsUnderPointer[i];
1655 if (pICL->getRenderLayer() > bestRenderLayer)
1656 {
1657 if ((pICL->getActive()) && (!pICL->emptyContextHelp()))
1658 {
1659 if (!getPointer()) return pICL;
1660 sint32 mx, my;
1661 getPointer()->getPointerPos(mx, my);
1662 if (pICL->preciseHitTest(mx, my))
1663 {
1664 best = pICL;
1665 bestRenderLayer = pICL->getRenderLayer();
1666 }
1667 }
1668 }
1669 }
1670 if (!best)
1671 {
1672 // if a control was not found, try with the groups
1673 sint8 bestRenderLayer = -128;
1674
1675 for (sint i = (sint32)_GroupsUnderPointer.size()-1; i>=0; i--)
1676 {
1677 CCtrlBase *pICL = _GroupsUnderPointer[i];
1678 if (pICL->getRenderLayer() > bestRenderLayer)
1679 {
1680 if ((pICL->getActive()) && (!pICL->emptyContextHelp()))
1681 {
1682 if (!getPointer()) return pICL;
1683 sint32 mx, my;
1684 getPointer()->getPointerPos(mx, my);
1685 if (pICL->preciseHitTest(mx, my))
1686 {
1687 best = pICL;
1688 bestRenderLayer = pICL->getRenderLayer();
1689 }
1690 }
1691 }
1692 }
1693 }
1694 return best;
1695 }
1696
1697 // ----------------------------------------------------------------------------
1698 void CWidgetManager::drawContextHelp ()
1699 {
1700 if (!getPointer() || !_ContextHelpActive)
1701 return;
1702
1703
1704 sint32 x = getPointer()->getX();
1705 sint32 y = getPointer()->getY();
1706
1707
1708 // ***************
1709 // **** try to disable
1710 // ***************
1711 // test disable first, so can recheck asap if another present. see below
1712 CCtrlBase *_CurCtrlContextHelp = getCurContextHelp();
1713 if( _CurCtrlContextHelp)
1714 {
1715 if(x!=_LastXContextHelp || y!=_LastYContextHelp)
1716 {
1717 // May change of ctrl!! => disable context help
1718 CCtrlBase *newCtrl= getNewContextHelpCtrl();
1719 if(newCtrl!=_CurCtrlContextHelp)
1720 {
1721 // disable
1722 disableContextHelp();
1723 }
1724 }
1725
1726 // Check if _CurCtrlContextHelp is visible
1727 if (_CurCtrlContextHelp == NULL)
1728 {
1729 disableContextHelp();
1730 }
1731 else
1732 {
1733 bool bVisible = true;
1734 if (_CurCtrlContextHelp->getActive() == false)
1735 bVisible = false;
1736 CInterfaceGroup *pParent = _CurCtrlContextHelp->getParent();
1737 while (pParent != NULL)
1738 {
1739 if (pParent->getActive() == false)
1740 bVisible = false;
1741 pParent = pParent->getParent();
1742 }
1743 if (!bVisible)
1744 disableContextHelp();
1745 }
1746 }
1747
1748
1749 // ***************
1750 // **** try to acquire
1751 // ***************
1752 if(!_CurCtrlContextHelp)
1753 {
1754 // get the ctrl of interset
1755 CCtrlBase *newCtrl= getNewContextHelpCtrl();
1756
1757 if(x==_LastXContextHelp && y==_LastYContextHelp)
1758 _DeltaTimeStopingContextHelp += ( interfaceTimes.frameDiffMs / 1000.0f );
1759 else
1760 _DeltaTimeStopingContextHelp = 0;
1761
1762 // If reach the time limit
1763 if( ( _DeltaTimeStopingContextHelp > _MaxTimeStopingContextHelp )
1764 || (newCtrl && newCtrl->wantInstantContextHelp()))
1765 {
1766 // if present, get the ctx help text.
1767 if(newCtrl)
1768 {
1769 // get the text
1770 //newCtrl->getContextHelpToolTip(_ContextHelpText);
1771 newCtrl->getContextHelp( getContextHelpText() );
1772 // UserDefined context help
1773 if( !newCtrl->getContextHelpActionHandler().empty() )
1774 {
1775 CAHManager::getInstance()->runActionHandler(newCtrl->getContextHelpActionHandler(), newCtrl, newCtrl->getContextHelpAHParams() );
1776 }
1777
1778 // If the text is finally empty (Special AH case), abort
1779 if( getContextHelpText().empty() )
1780 newCtrl= NULL;
1781 }
1782
1783 // not present? wait furthermore to move the mouse.
1784 if(!newCtrl)
1785 _DeltaTimeStopingContextHelp= 0;
1786 else
1787 {
1788 // enable
1789 setCurContextHelp( newCtrl );
1790 newCtrl->invalidateCoords();
1791 }
1792 }
1793 }
1794
1795 updateTooltipCoords(_CurCtrlContextHelp);
1796
1797
1798 // ***************
1799 // **** display
1800 // ***************
1801 if(_CurCtrlContextHelp)
1802 {
1803 CInterfaceGroup *groupContextHelp =
1804 getWindowForActiveMasterGroup(_CurCtrlContextHelp->getContextHelpWindowName());
1805
1806 if(groupContextHelp)
1807 {
1808 updateContextHelpColors();
1809
1810 // setup new global color for tooltip
1811 NLMISC::CRGBA oldGlobalColorForContent = getGlobalColorForContent();
1812 NLMISC::CRGBA newGlobalColorForContent = oldGlobalColorForContent;
1813 newGlobalColorForContent.A = _ContextHelpContentAlpha;
1814 setGlobalColorForContent(newGlobalColorForContent);
1815
1816 // container alpha
1817 CViewBase *pVB = groupContextHelp->getView("midcolor");
1818 if (pVB)
1819 {
1820 CViewBitmap *bg = dynamic_cast<CViewBitmap*>(pVB);
1821 if (bg)
1822 {
1823 bg->setColor(_ContextHelpContainerColor);
1824 }
1825 }
1826
1827 /** If there's a modal box around, should be sure that the context help doesn't intersect it.
1828 * If this is the case, we just disable it, unless the tooltip was generated by the current modal window
1829 */
1830 if ( hasModal() )
1831 {
1832 CInterfaceGroup *mw = getModal().ModalWindow;
1833 if (mw && mw->isIn(*groupContextHelp))
1834 {
1835 if (_CurCtrlContextHelp->isSonOf(mw))
1836 {
1837 groupContextHelp->executeLuaScriptOnDraw();
1838 groupContextHelp->draw ();
1839 // flush layers
1840 CViewRenderer::getInstance()->flush();
1841 }
1842 }
1843 else
1844 {
1845 groupContextHelp->executeLuaScriptOnDraw();
1846 groupContextHelp->draw ();
1847 // flush layers
1848 CViewRenderer::getInstance()->flush();
1849 }
1850 }
1851 else
1852 {
1853 groupContextHelp->executeLuaScriptOnDraw();
1854 groupContextHelp->draw ();
1855 // flush layers
1856 CViewRenderer::getInstance()->flush();
1857 }
1858
1859 // restore global color
1860 setGlobalColorForContent(oldGlobalColorForContent);
1861 }
1862 }
1863
1864 // Bkup movement
1865 _LastXContextHelp= x;
1866 _LastYContextHelp= y;
1867 }
1868
1869 void CWidgetManager::setContextHelpActive(bool active)
1870 {
1871 if (!active)
1872 {
1873 disableContextHelp();
1874 }
1875 _ContextHelpActive = active;
1876 }
1877
1878
1879 // ------------------------------------------------------------------------------------------------
1880 void CWidgetManager::getNewWindowCoordToNewScreenSize( sint32 &x, sint32 &y, sint32 w, sint32 h,
1881 sint32 newScreenW, sint32 newScreenH) const
1882 {
1883 // NB: x is relative to Left of the window (and Left of screen)
1884 // NB: y is relative to Top of the window (but Bottom of screen)
1885
1886 /*
1887 The goal here is to move the window so it fit the new resolution
1888 But we don't want to change its size (because somes windows just can't)
1889 We also cannot use specific code according to each window because user may completly modify his interface
1890 So the strategy is to dectect on which "side" (or center) the window is the best sticked,
1891 and then just move the window according to this position
1892 */
1893
1894 // *** First detect from which screen position the window is the more sticked (borders or center)
1895 // In X: best hotspot is left, middle or right?
1896 sint32 posXToLeft= x;
1897 sint32 posXToMiddle= x+w/2-_ScreenW/2;
1898 sint32 posXToRight= _ScreenW-(x+w);
1899 sint32 bestXHotSpot= Hotspot_xL;
1900 sint32 bestXPosVal= posXToLeft;
1901 if(abs(posXToMiddle) < bestXPosVal)
1902 {
1903 bestXHotSpot= Hotspot_xM;
1904 bestXPosVal= abs(posXToMiddle);
1905 }
1906 if(posXToRight < bestXPosVal)
1907 {
1908 bestXHotSpot= Hotspot_xR;
1909 bestXPosVal= posXToRight;
1910 }
1911
1912 // Same In Y: best hotspot is bottom, middle or top?
1913 // remember here that y is the top of window (relative to bottom of screen)
1914 sint32 posYToBottom= y-h;
1915 sint32 posYToMiddle= y-h/2-_ScreenH/2;
1916 sint32 posYToTop= _ScreenH-y;
1917 sint32 bestYHotSpot= Hotspot_Bx;
1918 sint32 bestYPosVal= posYToBottom;
1919 const sint32 middleYWeight= 6; // Avoid default Mission/Team/Map/ContactList positions to be considered as "middle"
1920 if(abs(posYToMiddle)*middleYWeight < bestYPosVal)
1921 {
1922 bestYHotSpot= Hotspot_Mx;
1923 bestYPosVal= abs(posYToMiddle)*middleYWeight;
1924 }
1925 if(posYToTop < bestYPosVal)
1926 {
1927 bestYHotSpot= Hotspot_Tx;
1928 bestYPosVal= posYToTop;
1929 }
1930
1931 // *** According to best matching hotspot, and new screen resolution, move the window
1932 // x
1933 if(bestXHotSpot==Hotspot_xM)
1934 x= newScreenW/2 + posXToMiddle - w/2;
1935 else if(bestXHotSpot==Hotspot_xR)
1936 x= newScreenW - posXToRight - w;
1937 // y
1938 if(bestYHotSpot==Hotspot_Mx)
1939 y= newScreenH/2 + posYToMiddle + h/2;
1940 else if(bestYHotSpot==Hotspot_Tx)
1941 y= newScreenH - posYToTop;
1942 }
1943
1944 // ------------------------------------------------------------------------------------------------
1945 void CWidgetManager::moveAllWindowsToNewScreenSize(uint32 newScreenW, uint32 newScreenH, bool fixCurrentUI)
1946 {
1947 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = getAllMasterGroup();
1948 // If resolutions correctly setuped, and really different from new setup
1949 if( _ScreenW >0 && _ScreenH>0 &&
1950 newScreenW >0 && newScreenH>0 &&
1951 ( _ScreenW != newScreenW || _ScreenH != newScreenH)
1952 )
1953 {
1954 // *** Do it for the Active Desktop (if wanted)
1955 if(fixCurrentUI)
1956 {
1957 // only for ui:interface (not login, nor outgame)
1958 for (uint nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
1959 {
1960 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
1961 if (!rMG.Group || rMG.Group->getId() != "ui:interface")
1962 continue;
1963
1964 // For all priorities, but the worldspace one
1965 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
1966 {
1967 if (nPriority==WIN_PRIORITY_WORLD_SPACE)
1968 continue;
1969
1970 // For All windows (only layer 0 group container)
1971 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
1972 std::list<CInterfaceGroup*>::const_iterator itw;
1973 for (itw = rList.begin(); itw != rList.end(); itw++)
1974 {
1975 CInterfaceGroup *pIG = *itw;
1976 if(!pIG->isGroupContainer())
1977 continue;
1978 CGroupContainer *gc= dynamic_cast<CGroupContainer*>(pIG);
1979 if(gc->getLayerSetup()!=0)
1980 continue;
1981 // should all be BL / TL
1982 if(gc->getParentPosRef()!=Hotspot_BL || gc->getPosRef()!=Hotspot_TL)
1983 continue;
1984
1985 // Get current window coordinates
1986 sint32 x= pIG->getX(); // x is relative to Left of the window
1987 sint32 y= pIG->getY(); // y is relative to Top of the window
1988 sint32 w= pIG->getW(false); // the window may be hid, still get the correct(or estimated) W
1989 sint32 h= pIG->getH(false); // the window may be hid, still get the correct(or estimated) H
1990
1991 // Compute the new coordinate
1992 getNewWindowCoordToNewScreenSize(x, y, w, h, newScreenW, newScreenH);
1993
1994 // Change
1995 pIG->setX(x);
1996 pIG->setY(y);
1997 }
1998 }
1999 }
2000 }
2001
2002 std::vector< INewScreenSizeHandler* >::iterator itr;
2003 for( itr = newScreenSizeHandlers.begin(); itr != newScreenSizeHandlers.end(); ++itr )
2004 {
2005 INewScreenSizeHandler *handler = *itr;
2006 handler->process( newScreenW, newScreenH );
2007 }
2008 }
2009
2010 // Now those are the last screen coordinates used for window position correction
2011 if(newScreenW >0 && newScreenH>0)
2012 {
2013 _ScreenW = newScreenW;
2014 _ScreenH = newScreenH;
2015 }
2016 }
2017
2018 class InvalidateTextVisitor : public CInterfaceElementVisitor
2019 {
2020 public:
2021 InvalidateTextVisitor( bool reset)
2022 {
2023 this->reset = reset;
2024 }
2025
2026 void visitGroup( CInterfaceGroup *group )
2027 {
2028 const std::vector< CViewBase* > &vs = group->getViews();
2029 for( std::vector< CViewBase* >::const_iterator itr = vs.begin(); itr != vs.end(); ++itr )
2030 {
2031 CViewText *vt = dynamic_cast< CViewText* >( *itr );
2032 if( vt != NULL )
2033 {
2034 if( reset )
2035 vt->resetTextIndex();
2036 vt->updateTextContext();
2037 }
2038 }
2039 }
2040
2041 private:
2042 bool reset;
2043 };
2044
2045 // ------------------------------------------------------------------------------------------------
2046 void CWidgetManager::updateAllLocalisedElements()
2047 {
2048
2049 uint32 nMasterGroup;
2050
2051 uint32 w, h;
2052 CViewRenderer::getInstance()->checkNewScreenSize ();
2053 CViewRenderer::getInstance()->getScreenSize (w, h);
2054
2055 // Update ui:* (limit the master containers to the height of the screen)
2056 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2057 {
2058 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2059 rMG.Group->setW (w);
2060 rMG.Group->setH (h);
2061 }
2062 CViewRenderer::getInstance()->setClipWindow(0, 0, w, h);
2063
2064 bool scaleChanged = _InterfaceScale != CViewRenderer::getInstance()->getInterfaceScale();
2065 if (scaleChanged)
2066 {
2067 _InterfaceScale = CViewRenderer::getInstance()->getInterfaceScale();
2068 notifyInterfaceScaleWatchers();
2069 }
2070
2071 // If all conditions are OK, move windows so they fit correctly with new screen size
2072 // Do this work only InGame when Config is loaded
2073 moveAllWindowsToNewScreenSize(w,h,true);
2074
2075 // Invalidate coordinates of all Windows of each MasterGroup
2076 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2077 {
2078 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2079
2080 InvalidateTextVisitor inv( false);
2081
2082 rMG.Group->visitGroupAndChildren( &inv );
2083 rMG.Group->invalidateCoords ();
2084 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
2085 {
2086 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2087 std::list<CInterfaceGroup*>::const_iterator itw;
2088 for (itw = rList.begin(); itw != rList.end(); itw++)
2089 {
2090 CInterfaceGroup *pIG = *itw;
2091 pIG->visitGroupAndChildren( &inv );
2092 pIG->invalidateCoords ();
2093 }
2094 }
2095 }
2096
2097 // setup for all
2098 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2099 {
2100 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2101 bool bActive = rMG.Group->getActive ();
2102 rMG.Group->setActive (true);
2103 rMG.Group->updateCoords ();
2104 rMG.Group->setActive (bActive);
2105 }
2106
2107 // update coords one
2108 checkCoords();
2109
2110 // Action by default (container opening
2111 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2112 {
2113 SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2114 rMG.Group->launch ();
2115 }
2116
2117 }
2118
2119 void CWidgetManager::drawViews( NL3D::UCamera camera )
2120 {
2121 CViewRenderer::getInstance()->activateWorldSpaceMatrix (false);
2122 NL3D::UDriver *driver = CViewRenderer::getInstance()->getDriver();
2123
2124 // If an element has captured the keyboard, make sure it is alway visible (all parent windows active)
2125 if( getCaptureKeyboard() != NULL)
2126 {
2127 CCtrlBase *cb = getCaptureKeyboard();
2128 do
2129 {
2130 if (!cb->getActive())
2131 {
2132 setCaptureKeyboard(NULL);
2133 break;
2134 }
2135 cb = cb->getParent();
2136 }
2137 while (cb);
2138 }
2139
2140 // Check if screen size changed
2141 uint32 w, h;
2142 CViewRenderer::getInstance()->checkNewScreenSize ();
2143 CViewRenderer::getInstance()->getScreenSize (w, h);
2144 if ((w != _ScreenW) || (h != _ScreenH))
2145 {
2146 // No Op if screen minimized
2147 if(w!=0 && h!=0 && !CViewRenderer::getInstance()->isMinimized())
2148 {
2149 updateAllLocalisedElements ();
2150 setScreenWH(w, h);
2151 }
2152 }
2153
2154 // Update global color from database
2155 if (!_RProp)
2156 {
2157 _RProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:R");
2158 _GProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:G");
2159 _BProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:B");
2160 _AProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:A");
2161 }
2162
2163 setGlobalColor(NLMISC::CRGBA(
2164 (uint8)_RProp->getValue32(),
2165 (uint8)_GProp->getValue32(),
2166 (uint8)_BProp->getValue32(),
2167 (uint8)_AProp->getValue32()));
2168
2169 NLMISC::CRGBA c = getGlobalColorForContent();
2170 NLMISC::CRGBA gc = getGlobalColor();
2171 c.R = gc.R;
2172 c.G = gc.G;
2173 c.B = gc.B;
2174 c.A = (uint8) (( (uint16) c.A * (uint16) getContentAlpha() ) >> 8);
2175 setGlobalColorForContent( c );
2176
2177 // Update global alphaS from database
2178 updateGlobalAlphas();
2179
2180 /* Draw all the windows
2181 To minimize texture swapping, we first sort per Window, then we sort per layer, then we render per Global Texture.
2182 Computed String are rendered in on big drawQuads at last part of each layer
2183 */
2184 CDBManager::getInstance()->flushObserverCalls();
2185
2186 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2187 {
2188 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2189 if (rMG.Group->getActive())
2190 {
2191 // Sort world space windows
2192 rMG.sortWorldSpaceGroup ();
2193
2194 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
2195 {
2196 if ( (nPriority == WIN_PRIORITY_WORLD_SPACE) && !camera.empty())
2197 {
2198 driver->setViewMatrix( NL3D::CMatrix::Identity);
2199 driver->setModelMatrix( NL3D::CMatrix::Identity);
2200 driver->setFrustum(camera.getFrustum());
2201 CViewRenderer::getInstance()->activateWorldSpaceMatrix (true);
2202 }
2203
2204 std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2205 std::list<CInterfaceGroup*>::const_iterator itw;
2206
2207 for (itw = rList.begin(); itw != rList.end(); itw++)
2208 {
2209 CInterfaceGroup *pIG = *itw;
2210 if( pIG ) // TODO: debug null pointer in PrioritizedWindows list
2211 {
2212 if (pIG->getActive())
2213 {
2214 // Draw all the elements of this window in the layers in ViewRendered
2215 pIG->draw ();
2216 // flush the layers
2217 CViewRenderer::getInstance()->flush ();
2218 }
2219 }
2220 }
2221
2222 if( draggedElement != NULL )
2223 {
2224 CInterfaceElement *e = draggedElement;
2225 static_cast< CViewBase* >( e )->draw();
2226 }
2227
2228 if ( (nPriority == WIN_PRIORITY_WORLD_SPACE) && !camera.empty())
2229 {
2230 driver->setMatrixMode2D11();
2231 CViewRenderer::getInstance()->activateWorldSpaceMatrix (false);
2232 }
2233 }
2234 }
2235 }
2236
2237 CDBManager::getInstance()->flushObserverCalls();
2238
2239 // draw the special over extend text
2240 drawOverExtendViewText();
2241
2242 // draw the context help
2243 drawContextHelp ();
2244
2245 std::vector< IOnWidgetsDrawnHandler* >::iterator itr;
2246 for( itr = onWidgetsDrawnHandlers.begin(); itr != onWidgetsDrawnHandlers.end(); ++itr )
2247 {
2248 IOnWidgetsDrawnHandler *handler = *itr;
2249 handler->process();
2250 }
2251
2252 // Draw the pointer and DND Item
2253 if (getPointer() != NULL)
2254 {
2255 if (getPointer()->getActive())
2256 getPointer()->draw ();
2257 }
2258
2259 if (CInterfaceElement::getEditorMode())
2260 {
2261 for(uint i = 0; i < editorSelection.size(); ++i)
2262 {
2263 CInterfaceElement *e = getElementFromId(editorSelection[i]);
2264 if (e != NULL)
2265 e->drawHighlight();
2266 }
2267 }
2268
2269 // flush layers
2270 CViewRenderer::getInstance()->flush();
2271
2272 // todo hulud remove Return in 2d world
2273 driver->setMatrixMode2D11();
2274
2275 CDBManager::getInstance()->flushObserverCalls();
2276 }
2277
2278 bool CWidgetManager::handleEvent( const CEventDescriptor &evnt )
2279 {
2280 // Check if we can receive events (no anims!)
2281 for( uint32 i = 0; i < activeAnims.size(); ++i )
2282 if( activeAnims[i]->isDisableButtons() )
2283 return false;
2284
2285 bool handled = false;
2286
2287 if( evnt.getType() == CEventDescriptor::system )
2288 {
2289 handleSystemEvent( evnt );
2290 }
2291 else
2292 if (evnt.getType() == CEventDescriptor::key)
2293 {
2294 handled = handleKeyboardEvent( evnt );
2295 }
2296 else if (evnt.getType() == CEventDescriptor::mouse )
2297 {
2298 handled = handleMouseEvent( evnt );
2299 }
2300
2301 CDBManager::getInstance()->flushObserverCalls();
2302
2303 return handled;
2304 }
2305
2306 bool CWidgetManager::handleSystemEvent( const CEventDescriptor &evnt )
2307 {
2308 const CEventDescriptorSystem &systemEvent = reinterpret_cast< const CEventDescriptorSystem& >( evnt );
2309 if( systemEvent.getEventTypeExtended() == CEventDescriptorSystem::setfocus )
2310 {
2311 if( getCapturePointerLeft() != NULL )
2312 {
2313 getCapturePointerLeft()->handleEvent( evnt );
2314 setCapturePointerLeft( NULL );
2315 }
2316
2317 if( getCapturePointerRight() != NULL )
2318 {
2319 getCapturePointerRight()->handleEvent( evnt );
2320 setCapturePointerRight( NULL );
2321 }
2322
2323 if( _CapturedView != NULL )
2324 {
2325 _CapturedView->handleEvent( evnt );
2326 _CapturedView = NULL;
2327 }
2328 }
2329
2330 return true;
2331 }
2332
2333 bool CWidgetManager::handleKeyboardEvent( const CEventDescriptor &evnt )
2334 {
2335 bool handled = false;
2336
2337 CEventDescriptorKey &eventDesc = (CEventDescriptorKey&)evnt;
2338
2339 //_LastEventKeyDesc = eventDesc;
2340
2341 // Any Key event disable the ContextHelp
2342 disableContextHelp();
2343
2344 // Hide menu if the key is pushed
2345 // if ((eventDesc.getKeyEventType() == CEventDescriptorKey::keydown) && !_ModalStack.empty() && !eventDesc.getKeyAlt() && !eventDesc.getKeyCtrl() && !eventDesc.getKeyShift())
2346 // Hide menu (or popup menu) is ESCAPE pressed
2347 if( eventDesc.getKeyEventType() == CEventDescriptorKey::keydown && eventDesc.getKey() == NLMISC::KeyESCAPE )
2348 {
2349 if( hasModal() )
2350 {
2351 SModalWndInfo mwi = getModal();
2352 if (mwi.ModalExitKeyPushed)
2353 disableModalWindow();
2354
2355 handled= true;
2356 }
2357
2358 CInterfaceGroup *win= getLastEscapableTopWindow();
2359 if ( win )
2360 {
2361 // Manage "quit window" If the Key is ESCAPE, no captureKeyboard
2362 // Get the last escapable active top window. NB: this is ergonomically better.
2363
2364 // If the window is a modal, must pop it.
2365 if( dynamic_cast<CGroupModal*>(win) )
2366 {
2367 if(!win->getAHOnEscape().empty())
2368 CAHManager::getInstance()->runActionHandler(win->getAHOnEscape(), win, win->getAHOnEscapeParams());
2369 popModalWindow();
2370 handled= true;
2371 }
2372 // else just disable it.
2373 // Special case: leave the escape Key to the CaptureKeyboard .
2374 else if( !getCaptureKeyboard() )
2375 {
2376 if(!win->getAHOnEscape().empty())
2377 CAHManager::getInstance()->runActionHandler(win->getAHOnEscape(), win, win->getAHOnEscapeParams());
2378 win->setActive(false);
2379 handled= true;
2380 }
2381 }
2382 }
2383
2384 // Manage complex "Enter"
2385 if( eventDesc.getKeyEventType() == CEventDescriptorKey::keychar && eventDesc.getChar() == NLMISC::KeyRETURN && !eventDesc.getKeyCtrl() )
2386 {
2387 // If the top window has Enter AH
2388 CInterfaceGroup *tw= getTopWindow();
2389 if(tw && !tw->getAHOnEnter().empty())
2390 {
2391 // if the captured keyboard is in this Modal window, then must handle him in priority
2392 if( getCaptureKeyboard() && getCaptureKeyboard()->getRootWindow()==tw)
2393 {
2394 bool result = getCaptureKeyboard()->handleEvent(evnt);
2395 CDBManager::getInstance()->flushObserverCalls();
2396 return result;
2397 }
2398 else
2399 {
2400 // The window or modal control the OnEnter. Execute, and don't go to the chat.
2401 CAHManager::getInstance()->runActionHandler(tw->getAHOnEnter(), tw, tw->getAHOnEnterParams());
2402 handled= true;
2403 }
2404 }
2405
2406 // else the 'return' key bring back to the last edit box (if possible)
2407 CCtrlBase *oldCapture = getOldCaptureKeyboard() ? getOldCaptureKeyboard() : getDefaultCaptureKeyboard();
2408 if ( getCaptureKeyboard() == NULL && oldCapture && !handled)
2409 {
2410 /* If the editbox does not want to recover focus, then abort. This possibility is normaly avoided
2411 through setCaptureKeyboard() which already test getRecoverFocusOnEnter(), but it is still possible
2412 for the default capture (main chat) or the old captured window to not want to recover
2413 (temporary Read Only chat for instance)
2414 */
2415 if(!dynamic_cast<CGroupEditBoxBase*>(oldCapture) ||
2416 dynamic_cast<CGroupEditBoxBase*>(oldCapture)->getRecoverFocusOnEnter())
2417 {
2418 setCaptureKeyboard( oldCapture );
2419 notifyElementCaptured(getCaptureKeyboard() );
2420 // make sure all parent windows are active
2421 CCtrlBase *cb = getCaptureKeyboard();
2422 CGroupContainer *lastContainer = NULL;
2423 nlassert(cb);
2424 for(;;)
2425 {
2426 CGroupContainer *gc = dynamic_cast<CGroupContainer *>(cb);
2427 if (gc) lastContainer = gc;
2428 cb->forceOpen();
2429 if (cb->getParent())
2430 {
2431 cb = cb->getParent();
2432 }
2433 else
2434 {
2435 cb->invalidateCoords();
2436 break;
2437 }
2438 }
2439 if (lastContainer)
2440 {
2441 setTopWindow(lastContainer);
2442 lastContainer->enableBlink(1);
2443 }
2444 handled= true;
2445 }
2446 }
2447 }
2448
2449 // General case: handle it in the Captured keyboard
2450 if (!handled && getCaptureKeyboard() != NULL)
2451 {
2452 bool result = getCaptureKeyboard()->handleEvent(evnt);
2453 CDBManager::getInstance()->flushObserverCalls();
2454 return result;
2455 }
2456
2457 if (!handled && eventDesc.getKeyEventType() == CEventDescriptorKey::keydown && eventDesc.getKey() == NLMISC::KeyESCAPE)
2458 {
2459 CAHManager::getInstance()->runActionHandler("enter_modal", NULL, "group=ui:interface:quit_dialog");
2460 handled = true;
2461 }
2462
2463 lastKeyEvent = eventDesc;
2464
2465 return handled;
2466 }
2467
2468 bool CWidgetManager::handleMouseEvent( const CEventDescriptor &evnt )
2469 {
2470 bool handled = false;
2471
2472 CEventDescriptorMouse &eventDesc = (CEventDescriptorMouse&)evnt;
2473
2474 if( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftdown )
2475 _Pointer->setButtonState( static_cast< NLMISC::TMouseButton >( _Pointer->getButtonState() | NLMISC::leftButton ) );
2476 else
2477 if( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightdown )
2478 _Pointer->setButtonState( static_cast< NLMISC::TMouseButton >( _Pointer->getButtonState() | NLMISC::rightButton ) );
2479 else
2480 if( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftup )
2481 _Pointer->setButtonState( static_cast< NLMISC::TMouseButton >( _Pointer->getButtonState() & ~NLMISC::leftButton ) );
2482 if( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightup )
2483 _Pointer->setButtonState( static_cast< NLMISC::TMouseButton >( _Pointer->getButtonState() & ~NLMISC::rightButton ) );
2484
2485 if( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mousemove )
2486 handleMouseMoveEvent( eventDesc );
2487
2488 eventDesc.setX( _Pointer->getX() );
2489 eventDesc.setY( _Pointer->getY() );
2490
2491 if( CInterfaceElement::getEditorMode() )
2492 {
2493 // Let's pretend we've handled the event... or actually we have!
2494 if( ( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightdown ) ||
2495 ( eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightup ) )
2496 return true;
2497 }
2498
2499 if( isMouseHandlingEnabled() )
2500 {
2501 // First thing to do : Capture handling
2502 if ( getCapturePointerLeft() != NULL)
2503 handled|= getCapturePointerLeft()->handleEvent(evnt);
2504
2505 if ( getCapturePointerRight() != NULL &&
2506 getCapturePointerLeft() != getCapturePointerRight() )
2507 handled|= getCapturePointerRight()->handleEvent(evnt);
2508
2509 if( _CapturedView != NULL &&
2510 _CapturedView != getCapturePointerLeft() &&
2511 _CapturedView != getCapturePointerRight() )
2512 _CapturedView->handleEvent( evnt );
2513
2514 CInterfaceGroup *ptr = getWindowUnder (eventDesc.getX(), eventDesc.getY());
2515 setCurrentWindowUnder( ptr );
2516
2517 // Any Mouse event but move disable the ContextHelp
2518 if(eventDesc.getEventTypeExtended() != CEventDescriptorMouse::mousemove)
2519 {
2520 disableContextHelp();
2521 }
2522
2523 // get the group under the mouse
2524 CInterfaceGroup *pNewCurrentWnd = getCurrentWindowUnder();
2525 setMouseOverWindow( pNewCurrentWnd != NULL );
2526
2527
2528 NLMISC::CRefPtr<CGroupModal> clickedOutModalWindow;
2529
2530 // modal special features
2531 if ( hasModal() )
2532 {
2533 CWidgetManager::SModalWndInfo mwi = getModal();
2534 if(mwi.ModalWindow)
2535 {
2536 // If we are not in "click out" mode so we dont handle controls other than those of the modal
2537 if (pNewCurrentWnd != mwi.ModalWindow && !mwi.ModalExitClickOut)
2538 {
2539 pNewCurrentWnd = NULL;
2540 }
2541 else
2542 {
2543 // If there is a handler on click out launch it
2544 if (pNewCurrentWnd != mwi.ModalWindow)
2545 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftdown ||
2546 (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightdown))
2547 if (!mwi.ModalHandlerClickOut.empty())
2548 CAHManager::getInstance()->runActionHandler(mwi.ModalHandlerClickOut,NULL,mwi.ModalClickOutParams);
2549
2550 // If the current window is not the modal and if must quit on click out
2551 if(pNewCurrentWnd != mwi.ModalWindow && mwi.ModalExitClickOut)
2552 {
2553 // NB: don't force handle==true because to quit a modal does not avoid other actions
2554
2555 // quit if click outside
2556 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftdown ||
2557 (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightdown))
2558 {
2559 clickedOutModalWindow = dynamic_cast<CGroupModal *>((CInterfaceGroup*)mwi.ModalWindow);
2560 // disable the modal
2561 popModalWindow();
2562 if ( hasModal() )
2563 {
2564 // don't handle event unless it is a previous modal window
2565 if( !isPreviousModal( pNewCurrentWnd ) )
2566 pNewCurrentWnd = NULL; // can't handle event before we have left all modal windows
2567 }
2568 movePointer (0,0); // Reget controls under pointer
2569 }
2570 }
2571 }
2572 }
2573 }
2574
2575 // Manage LeftClick.
2576 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftdown)
2577 {
2578 if ((pNewCurrentWnd != NULL) && (!hasModal()) && (pNewCurrentWnd->getOverlappable()))
2579 {
2580 CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pNewCurrentWnd);
2581 if (pGC != NULL)
2582 {
2583 if (!pGC->isGrayed()) setTopWindow(pNewCurrentWnd);
2584 }
2585 else
2586 {
2587 setTopWindow(pNewCurrentWnd);
2588 }
2589 }
2590
2591 bool captured = false;
2592
2593 // must not capture a new element if a sheet is currentlty being dragged.
2594 // This may happen when alt-tab has been used => the sheet is dragged but the left button is up
2595 if (!CCtrlDraggable::getDraggedSheet())
2596 {
2597 if( CInterfaceElement::getEditorMode() && _GroupSelection )
2598 {
2599 for( sint32 i = _GroupsUnderPointer.size() - 1; i >= 0; i-- )
2600 {
2601 CInterfaceGroup *g = _GroupsUnderPointer[ i ];
2602 if( ( g != NULL ) && ( g->isInGroup( pNewCurrentWnd ) ) )
2603 {
2604 _CapturedView = g;
2605 captured = true;
2606 break;
2607 }
2608 }
2609 }
2610
2611 if( !captured )
2612 {
2613 // Take the top most control.
2614 uint nMaxDepth = 0;
2615 const std::vector< CCtrlBase* >& _CtrlsUnderPointer = getCtrlsUnderPointer();
2616 for (sint32 i = (sint32)_CtrlsUnderPointer.size()-1; i >= 0; i--)
2617 {
2618 CCtrlBase *ctrl= _CtrlsUnderPointer[i];
2619 if (ctrl && ctrl->isCapturable() && ctrl->isInGroup( pNewCurrentWnd ) )
2620 {
2621 if( CInterfaceElement::getEditorMode() && !ctrl->isEditorSelectable() )
2622 continue;
2623
2624 uint d = ctrl->getDepth( pNewCurrentWnd );
2625 if (d > nMaxDepth)
2626 {
2627 nMaxDepth = d;
2628 setCapturePointerLeft( ctrl );
2629 captured = true;
2630 }
2631 }
2632 }
2633 }
2634
2635 if( CInterfaceElement::getEditorMode() && !captured )
2636 {
2637 for( sint32 i = _ViewsUnderPointer.size()-1; i >= 0; i-- )
2638 {
2639 CViewBase *v = _ViewsUnderPointer[i];
2640 if( ( v != NULL ) && v->isInGroup( pNewCurrentWnd ) )
2641 {
2642 if( CInterfaceElement::getEditorMode() && !v->isEditorSelectable() )
2643 continue;
2644
2645 _CapturedView = v;
2646 captured = true;
2647 break;
2648 }
2649 }
2650 }
2651
2652 notifyElementCaptured( getCapturePointerLeft() );
2653 if (clickedOutModalWindow && !clickedOutModalWindow->OnPostClickOut.empty())
2654 {
2655 CAHManager::getInstance()->runActionHandler(clickedOutModalWindow->OnPostClickOut, getCapturePointerLeft(), clickedOutModalWindow->OnPostClickOutParams);
2656 }
2657 }
2658 //if found
2659 if ( captured )
2660 {
2661 // consider clicking on a control implies handling of the event.
2662 handled= true;
2663
2664 if( getCapturePointerLeft() != NULL )
2665 _CapturedView = getCapturePointerLeft();
2666
2667 // handle the capture
2668 _CapturedView->handleEvent( evnt );
2669 }
2670 else
2671 {
2672 if( CInterfaceElement::getEditorMode() )
2673 clearEditorSelection();
2674 }
2675 }
2676
2677 // Manage RightClick
2678 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightdown)
2679 {
2680 if ((pNewCurrentWnd != NULL) && (!hasModal()) && (pNewCurrentWnd->getOverlappable()))
2681 {
2682 CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pNewCurrentWnd);
2683 if (pGC != NULL)
2684 {
2685 if (!pGC->isGrayed()) setTopWindow(pNewCurrentWnd);
2686 }
2687 else
2688 {
2689 setTopWindow(pNewCurrentWnd);
2690 }
2691 }
2692
2693 // Take the top most control.
2694 {
2695 uint nMaxDepth = 0;
2696 const std::vector< CCtrlBase* >& _CtrlsUnderPointer = getCtrlsUnderPointer();
2697 for (sint32 i = (sint32)_CtrlsUnderPointer.size()-1; i >= 0; i--)
2698 {
2699 CCtrlBase *ctrl= _CtrlsUnderPointer[i];
2700 if (ctrl && ctrl->isCapturable() && ctrl->isInGroup( pNewCurrentWnd ) )
2701 {
2702 uint d = ctrl->getDepth( pNewCurrentWnd );
2703 if (d > nMaxDepth)
2704 {
2705 nMaxDepth = d;
2706 setCapturePointerRight( ctrl );
2707 }
2708 }
2709 }
2710 notifyElementCaptured( getCapturePointerRight() );
2711 if (clickedOutModalWindow && !clickedOutModalWindow->OnPostClickOut.empty())
2712 {
2713 CAHManager::getInstance()->runActionHandler(clickedOutModalWindow->OnPostClickOut, getCapturePointerRight(), clickedOutModalWindow->OnPostClickOutParams);
2714 }
2715 }
2716 //if found
2717 if ( getCapturePointerRight() != NULL)
2718 {
2719 // handle the capture
2720 handled |= getCapturePointerRight()->handleEvent(evnt);
2721 }
2722 }
2723
2724
2725 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightup)
2726 {
2727 if (!handled)
2728 if (pNewCurrentWnd != NULL)
2729 pNewCurrentWnd->handleEvent(evnt);
2730 if ( getCapturePointerRight() != NULL)
2731 {
2732 setCapturePointerRight(NULL);
2733 handled= true;
2734 }
2735 }
2736
2737 // window handling. if not handled by a control
2738 if (!handled)
2739 {
2740 if (((pNewCurrentWnd != NULL) && !hasModal()) ||
2741 ((hasModal() && getModal().ModalWindow == pNewCurrentWnd)))
2742 {
2743 CEventDescriptorMouse ev2 = eventDesc;
2744 sint32 x= eventDesc.getX(), y = eventDesc.getY();
2745 if (pNewCurrentWnd)
2746 {
2747 pNewCurrentWnd->absoluteToRelative (x, y);
2748 ev2.setX (x); ev2.setY (y);
2749 handled|= pNewCurrentWnd->handleEvent (ev2);
2750 }
2751
2752 // After handle event of a left click, may set window Top if movable (infos etc...)
2753 //if( (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftdown) && pNewCurrentWnd->isMovable() )
2754 // setTopWindow(pNewCurrentWnd);
2755 }
2756 }
2757
2758 // Put here to let a chance to the window to handle if the capture dont
2759 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftup)
2760 {
2761 if ( getCapturePointerLeft() != NULL)
2762 {
2763 if( !handled )
2764 {
2765 CCtrlBase *c = getCapturePointerLeft();
2766 c->handleEvent( evnt );
2767 }
2768
2769 setCapturePointerLeft(NULL);
2770 handled = true;
2771 }
2772
2773 _CapturedView = NULL;
2774
2775 if( CInterfaceElement::getEditorMode() )
2776 stopDragging();
2777 }
2778
2779
2780 // If the current window is the modal, may Modal quit. Do it after standard event handle
2781 if(hasModal() && pNewCurrentWnd == getModal().ModalWindow)
2782 {
2783 // NB: don't force handle==true because to quit a modal does not avoid other actions
2784 CWidgetManager::SModalWndInfo mwi = getModal();
2785 // and if must quit on click right
2786 if(mwi.ModalExitClickR)
2787 {
2788 // quit if click right
2789 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouserightup)
2790 // disable the modal
2791 disableModalWindow();
2792 }
2793
2794 // and if must quit on click left
2795 if(mwi.ModalExitClickL)
2796 {
2797 // quit if click right
2798 if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftup)
2799 // disable the modal
2800 disableModalWindow();
2801 }
2802 }
2803
2804 // If the mouse is over a window, always consider the event is taken (avoid click behind)
2805 handled|= isMouseOverWindow();
2806
2807 // If mouse click was not on interface and we have keyboard captured, then release keyboard
2808 if (!handled && getCaptureKeyboard() != NULL && eventDesc.getEventTypeExtended() != CEventDescriptorMouse::mousemove)
2809 CWidgetManager::getInstance()->setCaptureKeyboard(NULL);
2810 }
2811
2812 return handled;
2813 }
2814
2815 bool CWidgetManager::handleMouseMoveEvent( const CEventDescriptor &eventDesc )
2816 {
2817 if( getPointer() == NULL )
2818 return false;
2819
2820 if( eventDesc.getType() != CEventDescriptor::mouse )
2821 return false;
2822
2823 const CEventDescriptorMouse &e = static_cast< const CEventDescriptorMouse& >( eventDesc );
2824
2825 if( e.getEventTypeExtended() != CEventDescriptorMouse::mousemove )
2826 return false;
2827
2828 uint32 screenW, screenH;
2829 CViewRenderer::getInstance()->getScreenSize( screenW, screenH );
2830 sint32 oldX = getPointer()->getX();
2831 sint32 oldY = getPointer()->getY();
2832
2833 sint32 x = e.getX();
2834 sint32 y = e.getY();
2835
2836 // These are floats packed in the sint32 from the NEL events that provide them as float
2837 // see comment in CInputHandler::handleMouseMoveEvent
2838 sint32 newX = static_cast< sint32 >( std::floor( *reinterpret_cast< float* >( &x ) * screenW + 0.5f ) );
2839 sint32 newY = static_cast< sint32 >( std::floor( *reinterpret_cast< float* >( &y ) * screenH + 0.5f ) );
2840
2841 if( ( oldX != newX ) || ( oldY != newY ) )
2842 {
2843 movePointerAbs( newX, newY );
2844 CEventDescriptorMouse &ve = const_cast< CEventDescriptorMouse& >( e );
2845 ve.setX( getPointer()->getX() );
2846 ve.setY( getPointer()->getY() );
2847 }
2848
2849 if( CInterfaceElement::getEditorMode() )
2850 {
2851 if( ( _CapturedView != NULL ) && ( draggedElement == NULL ) )
2852 {
2853 startDragging();
2854 }
2855 else
2856 if( draggedElement != NULL )
2857 {
2858 sint32 dx = newX - oldX;
2859 sint32 dy = newY - oldY;
2860
2861 draggedElement->moveBy( dx, dy );
2862 }
2863 }
2864
2865 return true;
2866 }
2867
2868 // ------------------------------------------------------------------------------------------------
2869 bool CWidgetManager::startDragging()
2870 {
2871 CInterfaceElement *e = NULL;
2872
2873 CInterfaceGroup *g = _CapturedView->getParent();
2874 if( g != NULL )
2875 {
2876 e = g->takeElement( _CapturedView );
2877 if( e == NULL )
2878 {
2879 nlinfo( "Something went horribly wrong :(" );
2880 return false;
2881 }
2882 }
2883 else
2884 e = _CapturedView;
2885
2886 e->setParent( NULL );
2887 draggedElement = e;
2888
2889 return true;
2890 }
2891
2892 void CWidgetManager::stopDragging()
2893 {
2894 if( draggedElement != NULL )
2895 {
2896 CInterfaceGroup *g = getGroupUnder( draggedElement->getXReal(), draggedElement->getYReal() );
2897 CInterfaceElement *e = draggedElement;
2898 CInterfaceGroup *tw = getTopWindow();
2899
2900 if( g == NULL )
2901 g = tw;
2902
2903 std::string oldid = e->getId();
2904
2905 e->setParent( g );
2906 e->setIdRecurse( e->getShortId() );
2907 e->setParentPos( g );
2908 e->setParentSize( g );
2909 g->addElement( e );
2910
2911 e->alignTo( g );
2912 //e->setName( "==MARKED==" );
2913
2914 draggedElement = NULL;
2915
2916 onWidgetMoved( oldid, e->getId() );
2917 }
2918 }
2919
2920 // ------------------------------------------------------------------------------------------------
2921 void CWidgetManager::movePointer (sint32 dx, sint32 dy)
2922 {
2923 if (!_Pointer)
2924 return;
2925
2926 uint32 nScrW, nScrH;
2927 sint32 oldpx, oldpy, newpx, newpy, disppx, disppy, olddisppx, olddisppy;
2928
2929 CViewRenderer::getInstance()->getScreenSize (nScrW, nScrH);
2930 _Pointer->getPointerPos (oldpx, oldpy);
2931
2932 olddisppx = oldpx;
2933 olddisppy = oldpy;
2934
2935 newpx = oldpx + dx;
2936 newpy = oldpy + dy;
2937
2938 if (newpx < 0) newpx = 0;
2939 if (newpy < 0) newpy = 0;
2940 if (newpx > (sint32)nScrW) newpx = nScrW;
2941 if (newpy > (sint32)nScrH) newpy = nScrH;
2942 dx = newpx - oldpx;
2943 dy = newpy - oldpy;
2944
2945 disppx = newpx;
2946 disppy = newpy;
2947
2948 _Pointer->setPointerPos (newpx, newpy);
2949 _Pointer->setPointerDispPos (disppx, disppy);
2950
2951 // must get back coordinates because of snapping
2952 sint32 mx = _Pointer->getX();
2953 sint32 my = _Pointer->getY();
2954 getViewsUnder (mx, my, _ViewsUnderPointer);
2955 getCtrlsUnder (mx, my, _CtrlsUnderPointer);
2956 getGroupsUnder (mx, my, _GroupsUnderPointer);
2957 }
2958
2959 // ------------------------------------------------------------------------------------------------
2960 void CWidgetManager::movePointerAbs(sint32 px, sint32 py)
2961 {
2962 if(!getPointer())
2963 return;
2964
2965 uint32 nScrW, nScrH;
2966 CViewRenderer::getInstance()->getScreenSize (nScrW, nScrH);
2967 NLMISC::clamp(px, 0, (sint32) nScrW);
2968 NLMISC::clamp(py, 0, (sint32) nScrH);
2969 //
2970 _Pointer->setPointerPos (px, py);
2971 _Pointer->setPointerDispPos (px, py);
2972 //
2973 getViewsUnder (px, py, _ViewsUnderPointer);
2974 getCtrlsUnder (px, py, _CtrlsUnderPointer);
2975 getGroupsUnder (px, py, _GroupsUnderPointer);
2976 }
2977
2978 // ***************************************************************************
2979 void CWidgetManager::setCapturePointerLeft(CCtrlBase *c)
2980 {
2981 _CapturedView = NULL;
2982
2983 // additionally, abort any dragging
2984 if( CCtrlDraggable::getDraggedSheet() != NULL )
2985 CCtrlDraggable::getDraggedSheet()->abortDragging();
2986
2987 _CapturePointerLeft = c;
2988 notifyElementCaptured(c);
2989 }
2990
2991 // ***************************************************************************
2992 void CWidgetManager::setCapturePointerRight(CCtrlBase *c)
2993 {
2994 _CapturePointerRight = c;
2995 notifyElementCaptured(c);
2996 }
2997
2998 // ------------------------------------------------------------------------------------------------
2999 void CWidgetManager::setCaptureKeyboard(CCtrlBase *c)
3000 {
3001 CGroupEditBoxBase *oldEb= dynamic_cast<CGroupEditBoxBase*>((CCtrlBase*)_CaptureKeyboard);
3002 CGroupEditBoxBase *newEb= dynamic_cast<CGroupEditBoxBase*>(c);
3003
3004 if (_CaptureKeyboard && _CaptureKeyboard != c)
3005 {
3006 _CaptureKeyboard->onKeyboardCaptureLost();
3007 }
3008 // If the old capturedKeyboard is an editBox and allow recoverFocusOnEnter
3009 if ( oldEb && oldEb->getRecoverFocusOnEnter() )
3010 {
3011 _OldCaptureKeyboard = _CaptureKeyboard;
3012 }
3013 if ( newEb )
3014 {
3015 CGroupEditBoxBase::disableSelection();
3016
3017 if (!newEb->getAHOnFocus().empty())
3018 {
3019 CAHManager::getInstance()->runActionHandler(newEb->getAHOnFocus(), newEb, newEb->getAHOnFocusParams());
3020 }
3021
3022 }
3023 _CaptureKeyboard = c;
3024 notifyElementCaptured(c);
3025 }
3026
3027 // ------------------------------------------------------------------------------------------------
3028 void CWidgetManager::resetCaptureKeyboard()
3029 {
3030 CCtrlBase *captureKeyboard = _CaptureKeyboard;
3031 _OldCaptureKeyboard = NULL;
3032 _CaptureKeyboard = NULL;
3033 if (captureKeyboard)
3034 {
3035 captureKeyboard->onKeyboardCaptureLost();
3036 }
3037 }
3038
3039 // ***************************************************************************
3040 void CWidgetManager::registerClockMsgTarget(CCtrlBase *vb)
3041 {
3042 if (!vb) return;
3043 if (isClockMsgTarget(vb))
3044 {
3045 nlwarning("<CInterfaceManager::registerClockMsgTarget> Element %s is already registered", vb->getId().c_str());
3046 return;
3047 }
3048 _ClockMsgTargets.push_back(vb);
3049 }
3050
3051 // ***************************************************************************
3052 void CWidgetManager::unregisterClockMsgTarget(CCtrlBase *vb)
3053 {
3054 if (!vb) return;
3055 std::list<CCtrlBase*>::iterator it = std::find(_ClockMsgTargets.begin(), _ClockMsgTargets.end(), vb);
3056 if (it != _ClockMsgTargets.end())
3057 {
3058 // instead of deleting, just mark as deleted incase we are inside iterating loop,
3059 // it will be removed in sendClockTickEvent
3060 (*it) = NULL;
3061 }
3062 }
3063
3064 // ***************************************************************************
3065 bool CWidgetManager::isClockMsgTarget(CCtrlBase *vb) const
3066 {
3067 std::list<CCtrlBase*>::const_iterator it = std::find(_ClockMsgTargets.begin(), _ClockMsgTargets.end(), vb);
3068 return it != _ClockMsgTargets.end();
3069 }
3070
3071 void CWidgetManager::sendClockTickEvent()
3072 {
3073 CEventDescriptorSystem clockTick;
3074 clockTick.setEventTypeExtended(CEventDescriptorSystem::clocktick);
3075
3076 if (_CapturePointerLeft)
3077 {
3078 _CapturePointerLeft->handleEvent(clockTick);
3079 }
3080 if (_CapturePointerRight)
3081 {
3082 _CapturePointerRight->handleEvent(clockTick);
3083 }
3084
3085 // and send clock tick msg to ctrl that are registered
3086 for(std::list<CCtrlBase*>::iterator it = _ClockMsgTargets.begin(); it != _ClockMsgTargets.end();)
3087 {
3088 CCtrlBase* ctrl = *it;
3089 if (ctrl)
3090 {
3091 ctrl->handleEvent(clockTick);
3092 ++it;
3093 }
3094 else
3095 it = _ClockMsgTargets.erase(it);
3096 }
3097 }
3098
3099 // ------------------------------------------------------------------------------------------------
3100 void CWidgetManager::notifyElementCaptured(CCtrlBase *c)
3101 {
3102 std::set<CCtrlBase *> seen;
3103 CCtrlBase *curr = c;
3104 while (curr)
3105 {
3106 seen.insert(curr);
3107 curr->elementCaptured(c);
3108 curr = curr->getParent();
3109 }
3110 // also warn the ctrl under the pointer
3111 for (uint i = 0; i < (uint) _CtrlsUnderPointer.size(); ++i)
3112 {
3113 if (!seen.count(_CtrlsUnderPointer[i]))
3114 {
3115 _CtrlsUnderPointer[i]->elementCaptured(c);
3116 }
3117 }
3118 }
3119
3120 // ------------------------------------------------------------------------------------------------
3121 void CWidgetManager::makeWindow(CInterfaceGroup *group)
3122 {
3123 if(!group)
3124 return;
3125
3126 uint32 i = 0;
3127 for (i = 0; i < _MasterGroups.size(); ++i)
3128 {
3129 if (_MasterGroups[i].Group == group->getParent())
3130 break;
3131 }
3132
3133 if (i == _MasterGroups.size())
3134 {
3135 std::string stmp = std::string("not found master group for window: ")+group->getId();
3136 nlwarning (stmp.c_str());
3137 return;
3138 }
3139 else
3140 {
3141 // check if group hasn't been inserted twice.
3142 if (_MasterGroups[i].isWindowPresent(group))
3143 {
3144 nlwarning("Window inserted twice");
3145 }
3146 else
3147 {
3148 _MasterGroups[i].addWindow(group,group->getPriority());
3149 }
3150 }
3151 }
3152
3153 // ------------------------------------------------------------------------------------------------
3154 void CWidgetManager::unMakeWindow(CInterfaceGroup *group, bool noWarning)
3155 {
3156 if (!group)
3157 return;
3158
3159 uint32 i = 0;
3160 for (i = 0; i < _MasterGroups.size(); ++i)
3161 {
3162 if (_MasterGroups[i].Group == group->getParent())
3163 break;
3164 }
3165
3166 if (i == _MasterGroups.size())
3167 {
3168 if (!noWarning)
3169 {
3170 std::string stmp = std::string("not found master group for window: ")+group->getId();
3171 nlwarning (stmp.c_str());
3172 }
3173 return;
3174 }
3175 else
3176 {
3177 // check if group hasn't been inserted twice.
3178 if (!_MasterGroups[i].isWindowPresent(group))
3179 {
3180 if (!noWarning)
3181 nlwarning("Window not inserted in master group");
3182 }
3183 else
3184 {
3185 _MasterGroups[i].delWindow(group);
3186 }
3187 }
3188 }
3189
3190 // ------------------------------------------------------------------------------------------------
3191 void CWidgetManager::setGlobalColor (NLMISC::CRGBA col)
3192 {
3193 if (!_RProp)
3194 {
3195 _RProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:R");
3196 _GProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:G");
3197 _BProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:B");
3198 _AProp = CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:A");
3199 }
3200 _RProp ->setValue32 (col.R);
3201 _GProp ->setValue32 (col.G);
3202 _BProp ->setValue32 (col.B);
3203 _AProp ->setValue32 (col.A);
3204
3205 _GlobalColor = col;
3206
3207 // set the global color for content (the same with modulated alpha)
3208 _GlobalColorForContent = _GlobalColor;
3209 _GlobalColorForContent.A = (uint8) (( (uint16) _GlobalColorForContent.A * (uint16) _ContentAlpha) >> 8);
3210 }
3211
3212 // ***************************************************************************
3213 void CWidgetManager::setContentAlpha(uint8 alpha)
3214 {
3215 _ContentAlpha = alpha;
3216 // update alpha of global color
3217 _GlobalColorForContent.A = alpha;/*(uint8) (( (uint16) _GlobalColor.A * (uint16) _ContentAlpha) >> 8);*/
3218 }
3219
3220 void CWidgetManager::resetColorProps()
3221 {
3222 _RProp = NULL;
3223 _GProp = NULL;
3224 _BProp = NULL;
3225 _AProp = NULL;
3226 }
3227
3228 // ------------------------------------------------------------------------------------------------
3229 CInterfaceOptions* CWidgetManager::getOptions( const std::string &name )
3230 {
3231 std::map< std::string, NLMISC::CSmartPtr< CInterfaceOptions > >::iterator it = _OptionsMap.find( name );
3232 if( it == _OptionsMap.end() )
3233 return NULL;
3234 else
3235 return it->second;
3236 }
3237
3238 void CWidgetManager::addOptions( std::string name, CInterfaceOptions *options )
3239 {
3240 _OptionsMap.insert( std::map< std::string, CInterfaceOptions* >::value_type( name, options ) );
3241 }
3242
3243 void CWidgetManager::removeOptions( std::string name )
3244 {
3245 _OptionsMap.erase( name );
3246 }
3247
3248 void CWidgetManager::removeAllOptions()
3249 {
3250 _OptionsMap.clear();
3251 }
3252
3253
3254 bool CWidgetManager::serializeOptions( xmlNodePtr parentNode ) const
3255 {
3256 if( parentNode == NULL )
3257 return false;
3258
3259 std::map< std::string, NLMISC::CSmartPtr< CInterfaceOptions > >::const_iterator itr;
3260 for( itr = _OptionsMap.begin(); itr != _OptionsMap.end(); ++itr )
3261 {
3262 if( itr->second->serialize( parentNode, itr->first ) == NULL )
3263 return false;
3264 }
3265
3266 return true;
3267 }
3268
3269
3270 bool CWidgetManager::serializeTreeData( xmlNodePtr parentNode ) const
3271 {
3272 if( parentNode == NULL )
3273 return false;
3274
3275 std::vector< SMasterGroup >::size_type i;
3276 for( i = 0; i < _MasterGroups.size(); i++ )
3277 {
3278 const SMasterGroup &mg = _MasterGroups[ i ];
3279
3280 std::vector< CInterfaceGroup* >::size_type j;
3281 for( j = 0; j < mg.Group->getNumGroup(); j++ )
3282 {
3283 CInterfaceGroup *g = mg.Group->getGroup( j );
3284 nlassert(g);
3285
3286 if( dynamic_cast< CGroupModal* >( g ) != NULL )
3287 continue;
3288
3289 if( g->serializeTreeData( parentNode ) == NULL )
3290 return false;
3291 }
3292 }
3293
3294 return true;
3295 }
3296
3297
3298 // ***************************************************************************
3299 void CWidgetManager::enableMouseHandling( bool handle )
3300 {
3301 _MouseHandlingEnabled = handle;
3302 if(!handle)
3303 {
3304 if(!getPointer())
3305 return;
3306
3307 // If Left captured, reset
3308 if( getCapturePointerLeft() )
3309 setCapturePointerLeft( NULL );
3310
3311 // Same for Right
3312 if( getCapturePointerRight() )
3313 setCapturePointerRight( NULL );
3314
3315 // Avoid any problem with modals
3316 disableModalWindow();
3317 }
3318 }
3319
3320 // ***************************************************************************
3321 uint CWidgetManager::getUserDblClickDelay()
3322 {
3323 uint nVal = 50;
3324 NLMISC::CCDBNodeLeaf *pNL = CDBManager::getInstance()->getDbProp("UI:SAVE:DOUBLE_CLICK_SPEED");
3325 if( pNL != NULL )
3326 nVal = pNL->getValue32();
3327
3328 uint dbclickDelay = (uint)(DOUBLE_CLICK_MIN + (DOUBLE_CLICK_MAX-DOUBLE_CLICK_MIN) * (float)nVal / 100.0f);
3329 return dbclickDelay;
3330 }
3331
3332 // ------------------------------------------------------------------------------------------------
3333 void CWidgetManager::setupOptions()
3334 {
3335 // After parsing options and templates node -> init system options.
3336 CInterfaceOptions *opt = getOptions( "system" );
3337 if( opt != NULL )
3338 {
3339 // List here all Special options
3340 _SystemOptions[OptionCtrlSheetGrayColor]= opt->getValue("ctrl_sheet_gray_color");
3341 _SystemOptions[OptionCtrlTextGrayColor]= opt->getValue("ctrl_text_gray_color");
3342 _SystemOptions[OptionCtrlSheetRedifyColor]= opt->getValue("ctrl_sheet_redify_color");
3343 _SystemOptions[OptionCtrlTextRedifyColor]= opt->getValue("ctrl_text_redify_color");
3344 _SystemOptions[OptionCtrlSheetGreenifyColor]= opt->getValue("ctrl_sheet_greenify_color");
3345 _SystemOptions[OptionCtrlTextGreenifyColor]= opt->getValue("ctrl_text_greenify_color");
3346 _SystemOptions[OptionViewTextOverBackColor]= opt->getValue("text_over_back_color");
3347 _SystemOptions[OptionFont]= opt->getValue("font");
3348 _SystemOptions[OptionAddCoefFont]= opt->getValue("add_coef_font");
3349 _SystemOptions[OptionMulCoefAnim]= opt->getValue("mul_coef_anim");
3350 _SystemOptions[OptionTimeoutBubbles]= opt->getValue("bubbles_timeout");
3351 _SystemOptions[OptionTimeoutMessages]= opt->getValue("messages_timeout");
3352 _SystemOptions[OptionTimeoutContext]= opt->getValue("context_timeout");
3353 _SystemOptions[OptionTimeoutContextHtml]= opt->getValue("context_html_timeout");
3354 _SystemOptions[OptionMonospaceFont]= opt->getValue("monospace_font");
3355 }
3356
3357 }
3358
3359 // Get the alpha roll over speed
3360 float CWidgetManager::getAlphaRolloverSpeed()
3361 {
3362 if( _AlphaRolloverSpeedDB == NULL )
3363 _AlphaRolloverSpeedDB = CDBManager::getInstance()->getDbProp("UI:SAVE:ALPHA_ROLLOVER_SPEED");
3364 float fTmp = ROLLOVER_MIN_DELTA_PER_MS + (ROLLOVER_MAX_DELTA_PER_MS - ROLLOVER_MIN_DELTA_PER_MS) * 0.01f * (100 - _AlphaRolloverSpeedDB->getValue32());
3365 return fTmp*fTmp*fTmp;
3366 }
3367
3368 void CWidgetManager::resetAlphaRolloverSpeedProps()
3369 {
3370 _AlphaRolloverSpeedDB = NULL;
3371 }
3372
3373 void CWidgetManager::setContainerAlpha(uint8 alpha)
3374 {
3375 _ContainerAlpha = alpha;
3376 // update alpha of global color
3377 NLMISC::CRGBA c = getGlobalColor();
3378 c.A = alpha;/*(uint8) (( (uint16) _GlobalColor.A * (uint16) _ContainerAlpha) >> 8); */
3379 setGlobalColor( c );
3380 }
3381
3382 void CWidgetManager::updateGlobalAlphas()
3383 {
3384 if (!_GlobalContentAlphaDB)
3385 {
3386 _GlobalContentAlphaDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTENT_ALPHA");
3387 nlassert(_GlobalContentAlphaDB);
3388 _GlobalContainerAlphaDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTAINER_ALPHA");
3389 nlassert(_GlobalContainerAlphaDB);
3390 _GlobalContentRolloverFactorDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTENT_ROLLOVER_FACTOR");
3391 nlassert(_GlobalContentRolloverFactorDB);
3392 _GlobalContainerRolloverFactorDB = CDBManager::getInstance()->getDbProp("UI:SAVE:CONTAINER_ROLLOVER_FACTOR");
3393 nlassert(_GlobalContainerRolloverFactorDB);
3394 }
3395 _GlobalContentAlpha = (uint8)_GlobalContentAlphaDB->getValue32();
3396 _GlobalContainerAlpha = (uint8)_GlobalContainerAlphaDB->getValue32();
3397 _GlobalRolloverFactorContent = (uint8)_GlobalContentRolloverFactorDB->getValue32();
3398 _GlobalRolloverFactorContainer = (uint8)_GlobalContainerRolloverFactorDB->getValue32();
3399 }
3400
3401 void CWidgetManager::resetGlobalAlphasProps()
3402 {
3403 _GlobalContentAlphaDB = NULL;
3404 _GlobalContainerAlphaDB = NULL;
3405 _GlobalContentRolloverFactorDB = NULL;
3406 _GlobalContainerRolloverFactorDB = NULL;
3407 }
3408
3409 void CWidgetManager::registerNewScreenSizeHandler( INewScreenSizeHandler *handler )
3410 {
3411 std::vector< INewScreenSizeHandler* >::iterator itr =
3412 std::find( newScreenSizeHandlers.begin(), newScreenSizeHandlers.end(), handler );
3413
3414 if( itr != newScreenSizeHandlers.end() )
3415 return;
3416
3417 newScreenSizeHandlers.push_back( handler );
3418 }
3419
3420 void CWidgetManager::removeNewScreenSizeHandler( INewScreenSizeHandler *handler )
3421 {
3422 std::vector< INewScreenSizeHandler* >::iterator itr =
3423 std::find( newScreenSizeHandlers.begin(), newScreenSizeHandlers.end(), handler );
3424
3425 if( itr == newScreenSizeHandlers.end() )
3426 return;
3427
3428 newScreenSizeHandlers.erase( itr );
3429 }
3430
3431 void CWidgetManager::registerOnWidgetsDrawnHandler( IOnWidgetsDrawnHandler* handler )
3432 {
3433 std::vector< IOnWidgetsDrawnHandler* >::iterator itr =
3434 std::find( onWidgetsDrawnHandlers.begin(), onWidgetsDrawnHandlers.end(), handler );
3435
3436 if( itr != onWidgetsDrawnHandlers.end() )
3437 return;
3438
3439 onWidgetsDrawnHandlers.push_back( handler );
3440 }
3441
3442 void CWidgetManager::removeOnWidgetsDrawnHandler( IOnWidgetsDrawnHandler* handler )
3443 {
3444 std::vector< IOnWidgetsDrawnHandler* >::iterator itr =
3445 std::find( onWidgetsDrawnHandlers.begin(), onWidgetsDrawnHandlers.end(), handler );
3446
3447 if( itr == onWidgetsDrawnHandlers.end() )
3448 return;
3449
3450 onWidgetsDrawnHandlers.erase( itr );
3451 }
3452
3453 // ------------------------------------------------------------------------------------------------
3454 void CWidgetManager::startAnim( const std::string &animId )
3455 {
3456 CInterfaceAnim *pIT = _Parser->getAnim( animId );
3457 if( pIT == NULL )
3458 return;
3459
3460 stopAnim( animId );
3461 pIT->start();
3462 activeAnims.push_back( pIT );
3463 }
3464
3465 void CWidgetManager::removeFinishedAnims()
3466 {
3467 sint32 i = 0;
3468 for( i = 0; i < (sint32)activeAnims.size(); ++i )
3469 {
3470 CInterfaceAnim *pIA = activeAnims[i];
3471 if (pIA->isFinished())
3472 {
3473 activeAnims.erase( activeAnims.begin() + i );
3474 --i;
3475 }
3476 }
3477 }
3478
3479 // ------------------------------------------------------------------------------------------------
3480 void CWidgetManager::stopAnim( const std::string &animId )
3481 {
3482 CInterfaceAnim *pIT = _Parser->getAnim( animId );
3483
3484 for( uint i = 0; i < activeAnims.size(); ++i )
3485 if( activeAnims[ i ] == pIT )
3486 {
3487 activeAnims.erase( activeAnims.begin() + i );
3488 if( !pIT->isFinished() )
3489 pIT->stop();
3490 return;
3491 }
3492 }
3493
3494 void CWidgetManager::updateAnims()
3495 {
3496 for( std::vector< CInterfaceAnim* >::size_type i = 0; i < activeAnims.size(); i++ )
3497 activeAnims[ i ]->update();
3498 }
3499
3500
3501 // ------------------------------------------------------------------------------------------------
3502 void CWidgetManager::runProcedure( const std::string &procName, CCtrlBase *pCaller,
3503 const std::vector< std::string> &paramList )
3504 {
3505 CProcedure *procp = _Parser->getProc( procName );
3506 if( procp == NULL )
3507 return;
3508
3509 CProcedure &proc = *procp;
3510
3511 // Run all actions
3512 for( uint i = 0; i < proc.Actions.size(); i++ )
3513 {
3514 const CProcAction &action = proc.Actions[i];
3515 // test if the condition for the action is valid
3516 if (!action.CondBlocks.empty())
3517 {
3518 CInterfaceExprValue result;
3519 result.setBool( false );
3520 std::string cond;
3521 action.buildCond( paramList, cond );
3522 CInterfaceExpr::eval( cond, result, NULL );
3523
3524 if( result.toBool() )
3525 if( !result.getBool() )
3526 continue;
3527 }
3528 // build the params sting
3529 std::string params;
3530 action.buildParams( paramList, params );
3531 // run
3532 //nlwarning("step %d : %s, %s", (int) i, action.Action.c_str(), params.c_str());
3533 CAHManager::getInstance()->runActionHandler( action.Action, pCaller, params );
3534 }
3535 }
3536
3537 // ------------------------------------------------------------------------------------------------
3538 void CWidgetManager::setProcedureAction( const std::string &procName, uint actionIndex,
3539 const std::string &ah, const std::string &params )
3540 {
3541 CProcedure *procp = _Parser->getProc( procName );
3542 if( procp == NULL )
3543 return;
3544
3545 CProcedure &proc = *procp;
3546
3547 // set wanted action
3548 if( actionIndex<proc.Actions.size() )
3549 {
3550 CProcAction &action = proc.Actions[ actionIndex ];
3551 action.Action = ah;
3552 action.ParamBlocks.clear();
3553 action.ParamBlocks.resize( 1 );
3554 action.ParamBlocks[ 0 ].String = params;
3555 }
3556 }
3557
3558 void CWidgetManager::getEditorSelection( std::vector< std::string > &selection )
3559 {
3560 selection.clear();
3561 for(uint i = 0; i < editorSelection.size(); ++i)
3562 selection.push_back(editorSelection[i]);
3563 }
3564
3565 void CWidgetManager::selectWidget( const std::string &name )
3566 {
3567 std::vector< std::string >::iterator itr
3568 = std::find( editorSelection.begin(), editorSelection.end(), name );
3569
3570 CInterfaceElement *e = getElementFromId( name );
3571
3572 if( itr != editorSelection.end() )
3573 {
3574 // If multiselection is on unselect if already selected
3575 if( multiSelection )
3576 {
3577 editorSelection.erase( itr );
3578 if( e != NULL )
3579 e->setEditorSelected( false );
3580 }
3581 }
3582 else
3583 {
3584 // Select if not yet selected
3585 if( e != NULL )
3586 {
3587 // If multiselection is off, we can only have 1 widget selected
3588 if( !multiSelection )
3589 {
3590 editorSelection.clear();
3591 }
3592
3593 e->setEditorSelected( true );
3594 editorSelection.push_back( name );
3595 }
3596
3597 }
3598
3599 notifySelectionWatchers();
3600 }
3601
3602 void CWidgetManager::clearEditorSelection()
3603 {
3604 editorSelection.clear();
3605 notifySelectionWatchers();
3606 }
3607
3608 void CWidgetManager::notifySelectionWatchers()
3609 {
3610 std::vector< IEditorSelectionWatcher* >::iterator itr = selectionWatchers.begin();
3611 while( itr != selectionWatchers.end() )
3612 {
3613 (*itr)->selectionChanged();
3614 ++itr;
3615 }
3616 }
3617
3618 void CWidgetManager::registerSelectionWatcher( IEditorSelectionWatcher *watcher )
3619 {
3620 std::vector< IEditorSelectionWatcher* >::iterator itr =
3621 std::find( selectionWatchers.begin(), selectionWatchers.end(), watcher );
3622
3623 // We already have this watcher
3624 if( itr != selectionWatchers.end() )
3625 return;
3626
3627 selectionWatchers.push_back( watcher );
3628 }
3629
3630 void CWidgetManager::unregisterSelectionWatcher( IEditorSelectionWatcher *watcher )
3631 {
3632 std::vector< IEditorSelectionWatcher* >::iterator itr =
3633 std::find( selectionWatchers.begin(), selectionWatchers.end(), watcher );
3634
3635 // We don't have this watcher
3636 if( itr == selectionWatchers.end() )
3637 return;
3638
3639 selectionWatchers.erase( itr );
3640 }
3641
3642 void CWidgetManager::onWidgetAdded( const std::string &id )
3643 {
3644 std::vector< IWidgetWatcher* >::const_iterator itr = widgetWatchers.begin();
3645 while( itr != widgetWatchers.end() )
3646 {
3647 (*itr)->onWidgetAdded( id );
3648 ++itr;
3649 }
3650 }
3651
3652 void CWidgetManager::onWidgetMoved( const std::string &oldid, const std::string &newid )
3653 {
3654 std::vector< IWidgetWatcher* >::const_iterator itr = widgetWatchers.begin();
3655 while( itr != widgetWatchers.end() )
3656 {
3657 (*itr)->onWidgetMoved( oldid, newid );
3658 ++itr;
3659 }
3660 }
3661
3662 void CWidgetManager::registerWidgetWatcher( IWidgetWatcher *watcher )
3663 {
3664 std::vector< IWidgetWatcher* >::const_iterator itr
3665 = std::find( widgetWatchers.begin(), widgetWatchers.end(), watcher );
3666 // already exists
3667 if( itr != widgetWatchers.end() )
3668 return;
3669
3670 widgetWatchers.push_back( watcher );
3671 }
3672
3673 void CWidgetManager::unregisterWidgetWatcher( IWidgetWatcher *watcher )
3674 {
3675 std::vector< IWidgetWatcher* >::iterator itr
3676 = std::find( widgetWatchers.begin(), widgetWatchers.end(), watcher );
3677 // doesn't exist
3678 if( itr == widgetWatchers.end() )
3679 return;
3680
3681 widgetWatchers.erase( itr );
3682 }
3683
3684 CInterfaceElement* CWidgetManager::addWidgetToGroup( std::string &group, std::string &widgetClass, std::string &widgetName )
3685 {
3686 // Check if this group exists
3687 CInterfaceElement *e = getElementFromId( group );
3688 if( e == NULL )
3689 return NULL;
3690 CInterfaceGroup *g = dynamic_cast< CInterfaceGroup* >( e );
3691 if( g == NULL )
3692 return NULL;
3693
3694 // Check if an element already exists with that name
3695 if( g->getElement( widgetName ) != NULL )
3696 return NULL;
3697
3698 // Create and add the new widget
3699 CViewBase *v = getParser()->createClass( widgetClass );
3700 if( v == NULL )
3701 return NULL;
3702
3703 v->setId( std::string( g->getId() + ":" + widgetName ) );
3704 v->setParent( g );
3705
3706 if( v->isGroup() )
3707 g->addGroup( dynamic_cast< CInterfaceGroup* >( v ) );
3708 else
3709 if( v->isCtrl() )
3710 g->addCtrl( dynamic_cast< CCtrlBase* >( v ) );
3711 else
3712 g->addView( v );
3713
3714 onWidgetAdded( v->getId() );
3715
3716 return v;
3717 }
3718
3719 bool CWidgetManager::groupSelection()
3720 {
3721 std::vector< CInterfaceElement* > elms;
3722
3723 // Resolve the widget names
3724 for(uint i = 0; i < editorSelection.size(); ++i)
3725 {
3726 CInterfaceElement *e = getElementFromId(editorSelection[i]);
3727 if (e != NULL)
3728 elms.push_back(e);
3729 }
3730
3731 editorSelection.clear();
3732
3733 if( elms.empty() )
3734 return false;
3735
3736 // Create the group as the subgroup of the top window
3737 CInterfaceGroup *g = static_cast< CInterfaceGroup* >( getParser()->createClass( "interface_group" ) );
3738 getTopWindow()->addGroup( g );
3739 g->setParent( getTopWindow() );
3740 g->setIdRecurse( std::string( "group" ) + NLMISC::toString( _WidgetCount ) );
3741 _WidgetCount++;
3742 onWidgetAdded( g->getId() );
3743
3744 std::string oldId;
3745
3746 // Reparent the widgets to the new group
3747 for(uint i = 0; i < elms.size(); ++i)
3748 {
3749 CInterfaceElement *e = elms[i];
3750 oldId = e->getId();
3751 CInterfaceGroup *p = e->getParent();
3752 if (p != NULL)
3753 p->takeElement(e);
3754
3755 g->addElement(e);
3756 e->setParent(g);
3757 e->setParentPos(g);
3758 e->setParentSize(g);
3759 e->setIdRecurse(e->getShortId());
3760
3761 onWidgetMoved(oldId, e->getId());
3762 }
3763 elms.clear();
3764
3765 // Make sure widgets aren't clipped because the group isn't big enough
3766 g->spanElements();
3767 // Make sure widgets are aligned
3768 g->alignElements();
3769 // Align the new group to the top window
3770 g->alignTo( getTopWindow() );
3771
3772 g->setActive( true );
3773
3774 return true;
3775 }
3776
3777 bool CWidgetManager::unGroupSelection()
3778 {
3779 if( editorSelection.size() != 1 )
3780 return false;
3781
3782 // Does the element exist?
3783 CInterfaceElement *e = getElementFromId( editorSelection[ 0 ] );
3784 if( e == NULL )
3785 return false;
3786
3787 // Is the element a group?
3788 CInterfaceGroup *g = dynamic_cast< CInterfaceGroup* >( e );
3789 if( g == NULL )
3790 return false;
3791
3792 // Can't blow up a root group :(
3793 CInterfaceGroup *p = g->getParent();
3794 if( p == NULL )
3795 return false;
3796
3797 // KABOOM!
3798 bool ok = g->explode();
3799 if( !ok )
3800 return false;
3801
3802 p->delElement( g );
3803
3804 clearEditorSelection();
3805
3806 p->updateCoords();
3807
3808 return true;
3809 }
3810
3811
3812 bool CWidgetManager::createNewGUI( const std::string &project, const std::string &window )
3813 {
3814 reset();
3815
3816 for(uint i = 0; i < _MasterGroups.size(); ++i)
3817 delete _MasterGroups[i].Group;
3818 _MasterGroups.clear();
3819
3820 // First create the master group
3821 CRootGroup *root = new CRootGroup( CViewBase::TCtorParam() );
3822
3823 SMasterGroup mg;
3824 mg.Group = root;
3825
3826 root->setIdRecurse( project );
3827 root->setW( 1024 );
3828 root->setH( 768 );
3829 root->setActive( true );
3830
3831 // Create the first / main window
3832 CInterfaceGroup *wnd = new CInterfaceGroup( CViewBase::TCtorParam() );
3833 wnd->setW( 1024 );
3834 wnd->setH( 768 );
3835 wnd->setParent( root );
3836 wnd->setParentPos( root );
3837 wnd->setParentSize( root );
3838 wnd->setPosRef( Hotspot_MM );
3839 wnd->setParentPosRef( Hotspot_MM );
3840 wnd->setIdRecurse( window );
3841 wnd->setActive( true );
3842
3843 // Add the window
3844 root->addElement( wnd );
3845 mg.addWindow( wnd, wnd->getPriority() );
3846 _MasterGroups.push_back( mg );
3847
3848 _Pointer = new CViewPointer( CViewBase::TCtorParam() );
3849
3850 IParser *parser = getParser();
3851
3852
3853 // Set base color to white
3854 VariableData v;
3855 v.type = "sint32";
3856 v.value = "255";
3857
3858 v.entry = "UI:SAVE:COLOR:R";
3859 parser->setVariable( v );
3860
3861 v.entry = "UI:SAVE:COLOR:G";
3862 parser->setVariable( v );
3863
3864 v.entry = "UI:SAVE:COLOR:B";
3865 parser->setVariable( v );
3866
3867 v.entry = "UI:SAVE:COLOR:A";
3868 parser->setVariable( v );
3869
3870 return true;
3871 }
3872
3873
3874 // ------------------------------------------------------------------------------------------------
3875 void CWidgetManager::notifyInterfaceScaleWatchers()
3876 {
3877 std::vector< IInterfaceScaleWatcher* >::iterator itr = scaleWatchers.begin();
3878 while( itr != scaleWatchers.end() )
3879 {
3880 (*itr)->onInterfaceScaleChanged();
3881 ++itr;
3882 }
3883 }
3884
3885 // ------------------------------------------------------------------------------------------------
3886 void CWidgetManager::registerInterfaceScaleWatcher( IInterfaceScaleWatcher *watcher )
3887 {
3888 std::vector< IInterfaceScaleWatcher* >::const_iterator itr
3889 = std::find( scaleWatchers.begin(), scaleWatchers.end(), watcher );
3890
3891 if( itr != scaleWatchers.end() )
3892 return;
3893
3894 scaleWatchers.push_back( watcher );
3895 }
3896
3897 // ------------------------------------------------------------------------------------------------
3898 void CWidgetManager::unregisterInterfaceScaleWatcher( IInterfaceScaleWatcher *watcher )
3899 {
3900 std::vector< IInterfaceScaleWatcher* >::iterator itr
3901 = std::find( scaleWatchers.begin(), scaleWatchers.end(), watcher );
3902
3903 if( itr == scaleWatchers.end() )
3904 return;
3905
3906 scaleWatchers.erase( itr );
3907 }
3908
3909 // ------------------------------------------------------------------------------------------------
3910 CWidgetManager::CWidgetManager()
3911 {
3912 LinkHack();
3913 CStringShared::createStringMapper();
3914
3915 CReflectableRegister::registerClasses();
3916
3917 _Parser = IParser::createParser();
3918
3919 _Pointer = NULL;
3920 curContextHelp = NULL;
3921 _ContextHelpActive = true;
3922 _DeltaTimeStopingContextHelp = 0;
3923 _MaxTimeStopingContextHelp= 0.2f;
3924 _LastXContextHelp= -10000;
3925 _LastYContextHelp= -10000;
3926
3927 resetColorProps();
3928 resetAlphaRolloverSpeedProps();
3929 resetGlobalAlphasProps();
3930
3931 _GlobalColor = NLMISC::CRGBA(255,255,255,255);
3932 _GlobalColorForContent = _GlobalColor;
3933 _ContentAlpha = 255;
3934 _ContainerAlpha = 255;
3935 _GlobalContentAlpha = 255;
3936 _GlobalContainerAlpha = 255;
3937 _GlobalRolloverFactorContent = 255;
3938 _GlobalRolloverFactorContainer = 255;
3939 _AlphaRolloverSpeedDB = NULL;
3940
3941 _MouseHandlingEnabled = true;
3942 _MouseOverWindow = false;
3943 inGame = false;
3944
3945 setScreenWH(0, 0);
3946 _InterfaceScale = 1.0f;
3947
3948 _WindowSnapDistance = 10;
3949 _WindowSnapInvert = false;
3950
3951 _GroupSelection = false;
3952 multiSelection = false;
3953 _WidgetCount = 0;
3954
3955 _ContextHelpContainerColor = NLMISC::CRGBA(255,255,159,255);
3956 _ContextHelpContentAlpha = 255;
3957 _ContextHelpContentAlphaDB = NULL;
3958 _ContextHelpContainerColorDB = NULL;
3959 _ContextHelpContainerAlphaDB = NULL;
3960 }
3961
3962 CWidgetManager::~CWidgetManager()
3963 {
3964 for (uint32 i = 0; i < _MasterGroups.size(); ++i)
3965 {
3966 delete _MasterGroups[i].Group;
3967 }
3968
3969 delete _Parser;
3970 _Parser = NULL;
3971
3972 _Pointer = NULL;
3973 curContextHelp = NULL;
3974
3975 CStringShared::deleteStringMapper();
3976
3977 editorSelection.clear();
3978 }
3979
3980 }
3981