?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux multi-monitor fullscreen support
[ryzomcore.git] / ryzom / client / src / interface_v3 / interface_manager.cpp
blob04b94faaf5e5811d8384a2fc42048e94b34f5a10
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) 2010-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
6 // Copyright (C) 2011 Robert TIMM (rti) <mail@rtti.de>
7 // Copyright (C) 2012 Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
8 // Copyright (C) 2013 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
9 //
10 // This program is free software: you can redistribute it and/or modify
11 // it under the terms of the GNU Affero General Public License as
12 // published by the Free Software Foundation, either version 3 of the
13 // License, or (at your option) any later version.
14 //
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU Affero General Public License for more details.
19 //
20 // You should have received a copy of the GNU Affero General Public License
21 // along with this program. If not, see <http://www.gnu.org/licenses/>.
22
23
24
25 #include "stdpch.h"
26
27 // Memory
28 #include <memory>
29
30 #include "nel/misc/i_xml.h"
31 #include "nel/misc/o_xml.h"
32 #include "nel/misc/algo.h"
33
34 #include "nel/net/tcp_sock.h"
35
36 // Globals
37 #include "interface_manager.h"
38 #include "interface_config.h"
39 #include "task_bar_manager.h"
40 #include "guild_manager.h"
41 #include "../client_cfg.h"
42 #include "encyclopedia_manager.h"
43 // Expr
44 #include "nel/gui/interface_expr.h"
45 #include "register_interface_elements.h"
46 // Action / Observers
47 #include "nel/gui/action_handler.h"
48 #include "action_handler_misc.h"
49 #include "interface_observer.h"
50 #include "nel/gui/interface_anim.h"
51 #include "interface_ddx.h"
52 #include "action_handler_help.h"
53 #include "action_handler_item.h"
54 // View
55 #include "nel/gui/view_bitmap.h"
56 //#include "view_bitmap_progress.h"
57 #include "view_bitmap_faber_mp.h"
58 #include "nel/gui/view_bitmap_combo.h"
59 #include "nel/gui/view_text.h"
60 #include "nel/gui/view_text_id.h"
61 #include "nel/gui/view_text_formated.h"
62 // Ctrl
63 #include "nel/gui/ctrl_scroll.h"
64 #include "nel/gui/ctrl_button.h"
65 #include "nel/gui/ctrl_text_button.h"
66 // DBCtrl
67 #include "dbctrl_sheet.h"
68 // Group
69 #include "nel/gui/group_list.h"
70 #include "nel/gui/group_menu.h"
71 #include "nel/gui/group_container.h"
72 #include "nel/gui/group_modal.h"
73 #include "nel/gui/group_editbox.h"
74 #include "group_in_scene_bubble.h"
75 #include "group_skills.h"
76 #include "group_compas.h"
77 #include "nel/gui/group_html.h"
78
79 // Misc
80 #include "../input.h"
81 #include "bot_chat_manager.h"
82 #include "bot_chat_page_all.h"
83 #include "chat_displayer.h"
84 #include "skill_manager.h"
85 #include "../sound_manager.h"
86 #include "../actions.h"
87 #include "../actions_client.h"
88
89 #include "../weather_manager_client.h"
90 #include "../weather.h"
91
92 #include "../user_entity.h"
93 #include "../motion/user_controls.h"
94 #include "people_interraction.h"
95 #include "macrocmd_manager.h"
96 #include "inventory_manager.h"
97
98 #include "../connection.h" // needed for loading config file (PlayerSelectedFileName)
99
100 #include "sbrick_manager.h"
101 #include "sphrase_manager.h"
102 #include "bar_manager.h"
103
104 #include "../continent_manager.h"
105 #include "../entity_cl.h"
106 #include "../login.h"
107
108 #include "../sheet_manager.h" // for emotes
109 #include "../entity_animation_manager.h" // for emotes
110 #include "../net_manager.h" // for emotes
111 #include "../client_chat_manager.h" // for emotes
112 #include "../entities.h"
113
114 #include "../../common/src/game_share/ryzom_database_banks.h"
115
116 #include "chat_text_manager.h"
117 #include "../npc_icon.h"
118
119 #include "nel/gui/lua_helper.h"
120 using namespace NLGUI;
121 #include "nel/gui/lua_ihm.h"
122 #include "nel/web/curl_certificates.h"
123
124 #include "lua_ihm_ryzom.h"
125
126 #include "add_on_manager.h"
127
128 #include "game_share/r2_share_itf.h"
129
130 #include "../time_client.h"
131
132 #include "../r2/editor.h"
133 #include "../r2/dmc/client_edition_module.h"
134
135 #include "../bg_downloader_access.h"
136
137 #include "parser_modules.h"
138
139 #include "../global.h"
140 #include "user_agent.h"
141 #include "../item_group_manager.h"
142
143 #include "group_html_webig.h"
144
145 using namespace NLMISC;
146
147 namespace NLGUI
148 {
149 extern void luaDebuggerMainLoop();
150 }
151
152 extern CClientChatManager ChatMngr;
153 extern CContinentManager ContinentMngr;
154 extern bool IsInRingSession;
155 extern CEventsListener EventsListener;
156
157 namespace R2
158 {
159 extern bool ReloadUIFlag;
160 }
161
162 // ***************************************************************************
163 /*
164 Version 11: - Dyn chat in user tab
165 Version 10: - Last screen resolution serialisation
166 Version 9: UI_DB_SAVE_VERSION system
167 Version 8: - serialInSceneBubbleInfo (for ignore context help)
168 Version 7: - serialMacroMemory
169 Version 6: DEPRECATED - Info about friend/ignore list
170 Version 5: - Info Windows pos
171 Version 4: - User landmark serialisation
172 Version 3: - Added a Hack for CInterfaceConfig version miss
173 Version 2: - TaskBar serialisation
174 Version 1: - people interraction
175 Version 0: - base version
176 */
177 #define ICFG_STREAM_VERSION 11
178
179 #ifdef AJM_DEBUG_TRACK_INTERFACE_GROUPS
180 #define FOREACH(__itvar,__conttype,__contvar) \
181 for (__conttype::iterator __itvar(__contvar.begin()),__itvar##end(__contvar.end()); __itvar!=__itvar##end; ++__itvar)
182 #endif
183
184 // ***************************************************************************
185
186 using namespace std;
187 using namespace NLMISC;
188 using namespace NLNET;
189
190 // ------------------------------------------------------------------------------------------------
191
192 extern bool loginFinished;
193 void setLoginFinished( bool f );
194 // Edit actions
195 CActionsManager EditActions;
196
197 CInterfaceManager * CInterfaceManager::_Instance = NULL;
198
199 CChatDisplayer * ChatDisplayer = NULL;
200
201
202 void initActions();
203 void uninitActions();
204
205 ///\todo nico: remove this dummy displayer
206 NLMISC::CLog g_log;
207
208
209 ////////////
210 // GLOBAL //
211 ////////////
212
213 // Hierarchical timer
214 H_AUTO_DECL ( RZ_Client_Update_Frame_Events )
215
216 // ------------------------------------------------------------------------------------------------
217 // AJM TEMP TEMP TEMP TEMP
218 #ifdef AJM_DEBUG_TRACK_INTERFACE_GROUPS
219
220 // track creation of an interface group
221 void CInterfaceManager::DebugTrackGroupsCreated( CInterfaceGroup *pIG )
222 {
223 // add to set
224 _DebugTrackGroupSet.insert( pIG );
225
226 // add to map and increment create counter
227 _DebugTrackGroupMap[pIG] = _DebugTrackGroupCreateCount++;
228 }
229
230 // track destruction of an interface group
231 void CInterfaceManager::DebugTrackGroupsDestroyed( CInterfaceGroup *pIG )
232 {
233 // lookup id of the group being destroyed (for debugging)
234 int foo = DebugTrackGroupsGetId( pIG );
235
236 // remove from set
237 setInterfaceGroupPtr::iterator it = _DebugTrackGroupSet.find( pIG );
238 if( it == _DebugTrackGroupSet.end() )
239 {
240 nldebug( "AJM DEBUG: Interface Group %x Destroyed twice", pIG );
241 return;
242 }
243 _DebugTrackGroupSet.erase( pIG );
244
245 // remove from map and increment destroy counter
246 _DebugTrackGroupMap.erase(pIG);
247 _DebugTrackGroupDestroyCount++;
248 }
249
250 // display the count of undestroyed interface groups
251 void CInterfaceManager::DebugTrackGroupsDump()
252 {
253 // dump groups
254 nldebug( "AJM DEBUG: %d Interface Groups remaining", _DebugTrackGroupCreateCount-_DebugTrackGroupDestroyCount );
255
256 FOREACH( itIG, mapInterfaceGroupPtr2Int, _DebugTrackGroupMap )
257 {
258 nldebug( " %d", itIG->second );
259 }
260 }
261
262 // return the index for an interface group
263 int CInterfaceManager::DebugTrackGroupsGetId( CInterfaceGroup *pIG )
264 {
265 mapInterfaceGroupPtr2Int::iterator it = _DebugTrackGroupMap.find( pIG );
266 if( it != _DebugTrackGroupMap.end() )
267 return it->second;
268 return -1;
269 }
270
271 #endif // AJM_DEBUG_TRACK_INTERFACE_GROUPS
272
273 class CDesktopUpdater : public CWidgetManager::INewScreenSizeHandler
274 {
275 public:
276 void process( uint32 w, uint32 h )
277 {
278 CInterfaceManager::getInstance()->updateDesktops( w, h );
279 }
280 };
281
282 class CDrawDraggedSheet : public CWidgetManager::IOnWidgetsDrawnHandler
283 {
284 public:
285 void process()
286 {
287 if ( CWidgetManager::getInstance()->getPointer()->show())
288 {
289 CDBCtrlSheet *pCS = dynamic_cast<CDBCtrlSheet*>( CWidgetManager::getInstance()->getCapturePointerLeft() );
290 if ((pCS != NULL) && (pCS->isDragged()))
291 {
292 sint x= CWidgetManager::getInstance()->getPointer()->getX() - pCS->getDeltaDragX();
293 sint y= CWidgetManager::getInstance()->getPointer()->getY() - pCS->getDeltaDragY();
294 pCS->drawSheet (x, y, false, false);
295
296 // if the control support CopyDrag, and if copy key pressed, display a tiny "+"
297 if(pCS->canDragCopy() && CInterfaceManager::getInstance()->testDragCopyKey())
298 {
299 CViewRenderer &rVR = *CViewRenderer::getInstance();
300 sint w= rVR.getSystemTextureW(CViewRenderer::DragCopyTexture);
301 sint h= rVR.getSystemTextureW(CViewRenderer::DragCopyTexture);
302 rVR.draw11RotFlipBitmap (pCS->getRenderLayer()+1, x-w/2, y-h/2, 0, false,
303 rVR.getSystemTextureId(CViewRenderer::DragCopyTexture));
304 }
305 }
306 }
307 }
308 };
309
310
311 class CStringManagerTextProvider : public CViewTextID::IViewTextProvider
312 {
313 bool getString( uint32 stringId, string &result )
314 {
315 return STRING_MANAGER::CStringManagerClient::instance()->getString( stringId, result );
316 }
317
318 bool getDynString( uint32 dynStringId, string &result )
319 {
320 return STRING_MANAGER::CStringManagerClient::instance()->getDynString( dynStringId, result );
321 }
322 };
323
324 class CRyzomTextFormatter : public CViewTextFormated::IViewTextFormatter
325 {
326 public:
327 std::string formatString( const std::string &inputString, const std::string &paramString )
328 {
329 std::string formatedResult;
330
331 // Apply the format
332 for(std::string::const_iterator it = inputString.begin(); it != inputString.end();)
333 {
334 if (*it == '$')
335 {
336 ++it;
337 if (it == inputString.end())
338 {
339 formatedResult += '$';
340 --it;
341 break;
342 }
343
344 switch(*it)
345 {
346 case 't': // add text ID
347 {
348 formatedResult += paramString;
349 break;
350 }
351 case 'P':
352 case 'p': // add player name
353 {
354 if (ClientCfg.Local || !UserEntity)
355 {
356 if (*it == 'P') formatedResult += "PLAYER";
357 else formatedResult += "Player";
358 }
359 else
360 {
361 std::string name = UserEntity->getEntityName();
362 if (*it == 'P') name = toUpper(name);
363 formatedResult += name;
364 }
365 break;
366 }
367 case 's':
368 case 'b': // add bot name
369 {
370 string botName;
371 bool womanTitle = false;
372 if (ClientCfg.Local)
373 {
374 botName = "NPC";
375 }
376 else
377 {
378 CLFECOMMON::TCLEntityId trader = CLFECOMMON::INVALID_SLOT;
379 if(UserEntity)
380 trader = UserEntity->trader();
381 if (trader != CLFECOMMON::INVALID_SLOT)
382 {
383 CEntityCL *entity = EntitiesMngr.entity(trader);
384 if (entity != NULL)
385 {
386 uint32 nDBid = entity->getNameId();
387 if (nDBid != 0)
388 {
389 STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
390 pSMC->getString(nDBid, botName);
391 }
392 else
393 {
394 botName = entity->getDisplayName();
395 }
396 CCharacterCL *pChar = dynamic_cast<CCharacterCL*>(entity);
397 if (pChar != NULL)
398 womanTitle = pChar->getGender() == GSGENDER::female;
399 }
400 }
401 }
402 // get the title translated
403 string sTitleTranslated = botName; // FIXME: UTF-8
404 CStringPostProcessRemoveName spprn;
405 spprn.Woman = womanTitle;
406 spprn.cbIDStringReceived(sTitleTranslated);
407
408 botName = CEntityCL::removeTitleAndShardFromName(botName);
409
410 // short name (with no title such as 'guard', 'merchant' ...)
411 if (*it == 's')
412 {
413 // But if there is no name, display only the title
414 if (botName.empty())
415 botName = sTitleTranslated;
416 }
417 else
418 {
419 // Else we want the title !
420 if (!botName.empty())
421 botName += " ";
422 botName += sTitleTranslated;
423 }
424
425 formatedResult += botName;
426 break;
427 }
428 default:
429 {
430 formatedResult += '$';
431 --it;
432 break;
433 }
434 }
435 ++it;
436 }
437 else
438 {
439 formatedResult += *it;
440 ++it;
441 }
442 }
443
444 return formatedResult;
445 }
446 };
447
448 namespace
449 {
450 CStringManagerTextProvider SMTextProvider;
451 CRyzomTextFormatter RyzomTextFormatter;
452 }
453
454 CInterfaceManager* CInterfaceManager::getInstance()
455 {
456 if( _Instance == NULL )
457 _Instance = new CInterfaceManager();
458 return _Instance;
459 }
460
461 // ------------------------------------------------------------------------------------------------
462 CInterfaceManager::CInterfaceManager()
463 {
464 CWidgetManager::getInstance()->registerNewScreenSizeHandler( new CDesktopUpdater() );
465 CWidgetManager::getInstance()->registerOnWidgetsDrawnHandler( new CDrawDraggedSheet() );
466
467 CInterfaceParser *parser = dynamic_cast< CInterfaceParser* >( CWidgetManager::getInstance()->getParser() );
468
469 parser->setSetupOptionsCallback( this );
470 parser->addModule( "scene3d", new CIF3DSceneParser() );
471 parser->addModule( "ddx", new CIFDDXParser() );
472 parser->addModule( "action_category", new CActionCategoryParser() );
473 parser->addModule( "command", new CCommandParser() );
474 parser->addModule( "key", new CKeyParser() );
475 parser->addModule( "macro", new CMacroParser() );
476 parser->addModule( "landmarks", new CLandmarkParser() );
477 parser->setCacheUIParsing( ClientCfg.CacheUIParsing );
478
479 CViewRenderer::setDriver( Driver );
480 CViewRenderer::setTextContext( TextContext );
481 CViewRenderer::hwCursorScale = ClientCfg.HardwareCursorScale;
482 CViewRenderer::hwCursors = &ClientCfg.HardwareCursors;
483 CViewRenderer::getInstance();
484 CViewTextID::setTextProvider( &SMTextProvider );
485 CViewTextFormated::setFormatter( &RyzomTextFormatter );
486
487 CGroupHTML::options.trustedDomains = ClientCfg.WebIgTrustedDomains;
488 CGroupHTML::options.languageCode = ClientCfg.getHtmlLanguageCode();
489 CGroupHTML::options.appName = getUserAgentName();
490 CGroupHTML::options.appVersion = getUserAgentVersion();
491 CGroupHTML::options.curlMaxConnections = ClientCfg.CurlMaxConnections;
492
493 if (!ClientCfg.CurlCABundle.empty())
494 {
495 // specify custom CA certs, lookup will be made in this function
496 NLWEB::CCurlCertificates::addCertificateFile(ClientCfg.CurlCABundle);
497 }
498
499 NLGUI::CDBManager::getInstance()->resizeBanks( NB_CDB_BANKS );
500 interfaceLinkUpdater = new CInterfaceLink::CInterfaceLinkUpdater();
501 _ScreenW = _ScreenH = 0;
502 _LastInGameScreenW = _LastInGameScreenH = 0;
503 _InterfaceScaleChanged = false;
504 _InterfaceScale = 1.0f;
505 _DescTextTarget = NULL;
506 _ConfigLoaded = false;
507 _LogState = false;
508 _KeysLoaded = false;
509 CWidgetManager::getInstance()->resetColorProps();
510 CWidgetManager::getInstance()->resetAlphaRolloverSpeedProps();
511 CWidgetManager::getInstance()->resetGlobalAlphasProps();
512 _NeutralColor = NULL;
513 _WarningColor = NULL;
514 _ErrorColor = NULL;
515 _EmotesInitialized = false;
516
517
518 // Global initialization
519 // *********************
520
521 // Interface Manager init
522 CViewRenderer::getInstance()->checkNewScreenSize();
523 {
524 uint32 w,h;
525 CViewRenderer::getInstance()->getScreenSize(w, h);
526 CWidgetManager::getInstance()->setScreenWH(w, h);
527 }
528 CViewRenderer::getInstance()->init();
529
530 _CurrentMode = 0;
531 _Modes.resize(MAX_NUM_MODES);
532
533 setInGame( false );
534
535 _LocalSyncActionCounter= 0;
536 // 4Bits counter.
537 _LocalSyncActionCounterMask= 15;
538
539 for(uint i=0;i<CHARACTERISTICS::NUM_CHARACTERISTICS;i++)
540 {
541 _CurrentPlayerCharac[i]= 0;
542 }
543
544 _CheckMailNode = NULL;
545 _CheckForumNode = NULL;
546 _UpdateWeatherTime = 0;
547
548 _DBB_UI_DUMMY = NULL;
549 _DB_UI_DUMMY_QUANTITY = NULL;
550 _DB_UI_DUMMY_QUALITY = NULL;
551 _DB_UI_DUMMY_SHEET = NULL;
552 _DB_UI_DUMMY_NAMEID = NULL;
553 _DB_UI_DUMMY_ENCHANT = NULL;
554 _DB_UI_DUMMY_SLOT_TYPE = NULL;
555 _DB_UI_DUMMY_PHRASE = NULL;
556 _DB_UI_DUMMY_WORNED = NULL;
557 _DB_UI_DUMMY_PREREQUISIT_VALID = NULL;
558 _DB_UI_DUMMY_FACTION_TYPE = NULL;
559
560 #ifdef AJM_DEBUG_TRACK_INTERFACE_GROUPS
561 _DebugTrackGroupSet.clear();
562 _DebugTrackGroupMap.clear();
563 _DebugTrackGroupCreateCount = 0;
564 _DebugTrackGroupDestroyCount = 0;
565 #endif // AJM_DEBUG_TRACK_INTERFACE_GROUPS
566
567 }
568
569 // ------------------------------------------------------------------------------------------------
570 CInterfaceManager::~CInterfaceManager()
571 {
572 CViewTextID::setTextProvider( NULL );
573 CViewTextFormated::setFormatter( NULL );
574 reset(); // to flush IDStringWaiters
575
576 // release the database observers
577 releaseServerToLocalAutoCopyObservers();
578
579 /*
580 removeFlushObserver( interfaceLinkUpdater );
581 delete interfaceLinkUpdater;
582 interfaceLinkUpdater = NULL;
583 */
584 _Instance = NULL;
585 }
586
587 // ------------------------------------------------------------------------------------------------
588 void CInterfaceManager::reset()
589 {
590 CViewRenderer::getInstance()->reset();
591 CWidgetManager::getInstance()->reset();
592
593 for (uint32 i = 0; i < _IDStringWaiters.size(); ++i)
594 delete _IDStringWaiters[i];
595 _IDStringWaiters.clear();
596 CGroupFrame::resetDisplayTypes();
597
598 _NeutralColor = NULL;
599 _WarningColor = NULL;
600 _ErrorColor = NULL;
601
602 }
603
604 // ------------------------------------------------------------------------------------------------
605 // unhook from observers we are tangled up in
606 void CInterfaceManager::releaseServerToLocalAutoCopyObservers()
607 {
608 ServerToLocalAutoCopyInventory.release();
609 ServerToLocalAutoCopyExchange.release();
610 ServerToLocalAutoCopyContextMenu.release();
611 ServerToLocalAutoCopySkillPoints.release();
612 }
613
614 void CInterfaceManager::setInGame( bool i )
615 {
616 _InGame = i;
617 CWidgetManager::getInstance()->setIngame( i );
618 }
619
620 // ------------------------------------------------------------------------------------------------
621 void CInterfaceManager::resetShardSpecificData()
622 {
623 _LocalSyncActionCounter= 0;
624 CGroupSkills::InhibitSkillUpFX = true;
625 CBarManager::getInstance()->resetShardSpecificData();
626 CBotChatManager::getInstance()->setCurrPage(NULL);
627
628 CSPhraseManager *pPM= CSPhraseManager::getInstance();
629 pPM->setEquipInvalidation(0, 0);
630
631 CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId(WIN_TEMPINV));
632 if (pGC != NULL)
633 pGC->setActive(false);
634 }
635
636 // ------------------------------------------------------------------------------------------------
637
638 // ------------------------------------------------------------------------------------------------
639 void CInterfaceManager::destroy ()
640 {
641 delete _Instance;
642 _Instance = NULL;
643 }
644
645 void CInterfaceManager::initLUA()
646 {
647 CInterfaceParser *parser = dynamic_cast< CInterfaceParser* >( CWidgetManager::getInstance()->getParser() );
648 if( parser->isLuaInitialized() )
649 return;
650
651 parser->initLUA();
652
653 if( !parser->isLuaInitialized() )
654 return;
655
656 CLuaIHMRyzom::RegisterRyzomFunctions( *( CLuaManager::getInstance().getLuaState() ) );
657 }
658
659 // ------------------------------------------------------------------------------------------------
660 void CInterfaceManager::initLogin()
661 {
662 // Init LUA Scripting
663 initLUA();
664
665 // Clear the action manager
666 Actions.clear();
667 EditActions.clear();
668
669 // Register action in the action manager
670 ActionsContext.addActionsManager(&Actions, "");
671 ActionsContext.addActionsManager(&EditActions, RZ_CATEGORY_EDIT);
672
673
674 if (ClientCfg.XMLLoginInterfaceFiles.empty())
675 {
676 nlinfo("no xml login config files in client.cfg");
677 return;
678 }
679
680 nldebug("Textures Login Interface");
681
682 for (vector<string>::iterator it = ClientCfg.TexturesLoginInterface.begin(), end = ClientCfg.TexturesLoginInterface.end(); it != end; ++it)
683 {
684 nldebug("Textures Login Interface: %s", (*it).c_str());
685 loadTextures(*it + ".tga", *it + ".txt", false);
686 }
687
688 for (vector<string>::iterator it = ClientCfg.TexturesLoginInterfaceDXTC.begin(), end = ClientCfg.TexturesLoginInterfaceDXTC.end(); it != end; ++it)
689 {
690 nldebug("Textures Login Interface DXTC: %s", (*it).c_str());
691 loadTextures(*it + ".tga", *it + ".txt", true);
692 }
693
694 parseInterface (ClientCfg.XMLLoginInterfaceFiles, false);
695
696 CWidgetManager::getInstance()->updateAllLocalisedElements();
697
698 CWidgetManager::getInstance()->activateMasterGroup ("ui:login", true);
699
700 {
701 initActions();
702 }
703 }
704
705 // ------------------------------------------------------------------------------------------------
706 void CInterfaceManager::uninitLogin()
707 {
708 CInterfaceParser *parser = dynamic_cast< CInterfaceParser* >( CWidgetManager::getInstance()->getParser() );
709
710 CWidgetManager::getInstance()->activateMasterGroup ("ui:login", false);
711
712 parser->removeAll();
713 reset();
714
715 CWidgetManager::getInstance()->setPointer( NULL );
716
717 CInterfaceLink::removeAllLinks();
718
719 ICDBNode::CTextId textId("UI");
720 NLGUI::CDBManager::getInstance()->getDB()->removeNode(textId);
721
722 {
723 uninitActions();
724 }
725
726 // Close LUA Scripting
727 parser->uninitLUA();
728 }
729
730 // ------------------------------------------------------------------------------------------------
731 void CInterfaceManager::initOutGame()
732 {
733 // Clear the action manager
734 Actions.clear();
735 EditActions.clear();
736
737 // Register action in the action manager
738 ActionsContext.addActionsManager(&Actions, "");
739 ActionsContext.addActionsManager(&EditActions, RZ_CATEGORY_EDIT);
740
741 // Init LUA Scripting
742 initLUA();
743
744 if (ClientCfg.SelectCharacter != -1)
745 return;
746
747 {
748 if (SoundMngr != NULL)
749 {
750 NLSOUND::UAudioMixer *pMixer = SoundMngr->getMixer();
751 pMixer->loadSampleBank(false, "ui_outgame");
752 CVector initpos ( 0.0f, 0.0f, 0.0f );
753 pMixer->setListenerPos(initpos);
754 }
755 }
756
757
758 //NLMEMORY::CheckHeap (true);
759
760 if (ClientCfg.XMLOutGameInterfaceFiles.empty())
761 {
762 nlinfo("no xml outgame config files in client.cfg");
763 return;
764 }
765
766 nldebug("Textures OutGame Interface");
767
768 for (vector<string>::iterator it = ClientCfg.TexturesOutGameInterface.begin(), end = ClientCfg.TexturesOutGameInterface.end(); it != end; ++it)
769 {
770 nldebug("Textures OutGame Interface: %s", (*it).c_str());
771 loadTextures(*it + ".tga", *it + ".txt", false);
772 }
773
774 for (vector<string>::iterator it = ClientCfg.TexturesOutGameInterfaceDXTC.begin(), end = ClientCfg.TexturesOutGameInterfaceDXTC.end(); it != end; ++it)
775 {
776 nldebug("Textures OutGame Interface DXTC: %s", (*it).c_str());
777 loadTextures(*it + ".tga", *it + ".txt", true);
778 }
779
780 parseInterface (ClientCfg.XMLOutGameInterfaceFiles, false);
781
782 CWidgetManager::getInstance()->updateAllLocalisedElements();
783
784 CWidgetManager::getInstance()->activateMasterGroup ("ui:outgame", true);
785
786 // if (!ClientCfg.FSHost.empty())
787 // {
788 // // Hide the Launch Editor button, it works only with a Shard Unifier and web pages
789 // CInterfaceElement *elt = getElementFromId("ui:outgame:edit_session_but");
790 // elt->setActive(false);
791 // }
792
793 // Init the action manager
794 {
795
796 initActions();
797 }
798 //NLMEMORY::CheckHeap (true);
799
800 // Initialize the web browser
801 {
802 CGroupHTML *pGH = dynamic_cast<CGroupHTML*>( CWidgetManager::getInstance()->getElementFromId(GROUP_BROWSER));
803
804 if (pGH)
805 {
806 pGH->setActive(true);
807 pGH->browse(ClientCfg.PatchletUrl.c_str());
808 }
809 }
810 }
811
812 // ------------------------------------------------------------------------------------------------
813 void CInterfaceManager::uninitOutGame()
814 {
815
816 if (ClientCfg.SelectCharacter != -1)
817 return;
818
819 CWidgetManager::getInstance()->disableModalWindow();
820
821 //_Database->display("");
822 CBotChatManager::getInstance()->setCurrPage(NULL);
823
824 CInterfaceItemEdition::getInstance()->setCurrWindow(NULL);
825
826 // NLMISC::TTime initStart;
827 // initStart = ryzomGetLocalTime ();
828 if (SoundMngr != NULL)
829 {
830 NLSOUND::UAudioMixer *pMixer = SoundMngr->getMixer();
831 pMixer->unloadSampleBank("ui_outgame");
832 }
833 //nlinfo ("%d seconds for uninitOutGame", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
834
835 // initStart = ryzomGetLocalTime ();
836 CWidgetManager::getInstance()->activateMasterGroup ("ui:outgame", false);
837
838 CInterfaceParser *parser = dynamic_cast< CInterfaceParser* >( CWidgetManager::getInstance()->getParser() );
839 //nlinfo ("%d seconds for activateMasterGroup", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
840 // initStart = ryzomGetLocalTime ();
841 parser->removeAll();
842 //nlinfo ("%d seconds for removeAll", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
843 // initStart = ryzomGetLocalTime ();
844 reset();
845 //nlinfo ("%d seconds for reset", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
846 // reset the mouse pointer to avoid invalid pointer access
847 CWidgetManager::getInstance()->setPointer( NULL );
848 // initStart = ryzomGetLocalTime ();
849 CInterfaceLink::removeAllLinks();
850 //nlinfo ("%d seconds for removeAllLinks", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
851 // initStart = ryzomGetLocalTime ();
852 ICDBNode::CTextId textId("UI");
853 NLGUI::CDBManager::getInstance()->getDB()->removeNode(textId);
854 //nlinfo ("%d seconds for removeNode", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
855
856 // Init the action manager
857 {
858
859 // initStart = ryzomGetLocalTime ();
860 uninitActions();
861 // nlinfo ("%d seconds for uninitActions", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
862 }
863
864 // Close LUA Scripting
865 parser->uninitLUA();
866
867 //NLMEMORY::CheckHeap (true);
868 }
869
870
871 void badXMLParseMessageBox()
872 {
873 NL3D::UDriver *driver = CViewRenderer::getInstance()->getDriver();
874 NL3D::UDriver::TMessageBoxId ret = driver->systemMessageBox( "Interface XML reading failed!\n"
875 "Some XML files are corrupted and may have been removed.\n"
876 "Ryzom may need to be restarted to run properly.\n"
877 "Would you like to quit now?",
878 "XML reading failed!",
879 NL3D::UDriver::yesNoType,
880 NL3D::UDriver::exclamationIcon);
881 if (ret == NL3D::UDriver::yesId)
882 {
883 extern void quitCrashReport ();
884 quitCrashReport ();
885 exit (EXIT_FAILURE);
886 }
887 }
888
889 // ------------------------------------------------------------------------------------------------
890 void CInterfaceManager::initInGame()
891 {
892 setLoginFinished( true );
893 _LogState = false;
894
895 // Whole initInGame profile
896 NLMISC::TTime initStart;
897 initStart = ryzomGetLocalTime ();
898
899 // Init LUA Scripting
900 initLUA();
901
902 // Clear the action manager
903 Actions.clear();
904 EditActions.clear();
905
906 // Register action in the action manager
907 ActionsContext.addActionsManager(&Actions, "");
908 ActionsContext.addActionsManager(&EditActions, RZ_CATEGORY_EDIT);
909
910
911 if (SoundMngr != NULL)
912 {
913 NLSOUND::UAudioMixer *pMixer = SoundMngr->getMixer();
914 pMixer->loadSampleBank(false, "ui_ingame");
915 }
916
917
918 // NLMEMORY::CheckHeap (true);
919
920 if (ClientCfg.XMLInterfaceFiles.empty())
921 {
922 nlinfo("no xml config files in client.cfg");
923 return;
924 }
925
926 // Textures
927 loadIngameInterfaceTextures();
928
929 // NLMEMORY::CheckHeap (true);
930
931 // Skill Manager Init
932 CSkillManager *pSM = CSkillManager::getInstance();
933 pSM->initInGame();
934
935 // SBrick Manager Init
936 CSBrickManager *pSBM = CSBrickManager::getInstance();
937 pSBM->initInGame();
938 pSM->initTitles();
939
940 // SPhrase Manager DB Init (BEFORE loading). Must be init AFTER skill and brick init
941 CSPhraseManager *pPM= CSPhraseManager::getInstance();
942 pPM->initInGame();
943
944 // UI & keys
945 loadUI();
946 loadKeys();
947
948 // Initialize armour color (config.xml)
949 CDBCtrlSheet::initArmourColors();
950
951 // Initialize inventory manager : link to DB and to interface element so must be here
952 getInventory().init();
953 // Same for temp inventory manager
954 CTempInvManager::getInstance();
955 // Initialize guild manager
956 CGuildManager::getInstance();
957
958 // NLMEMORY::CheckHeap (true);
959
960 //init chat output
961 ChatDisplayer = new CChatDisplayer;
962 g_log.addDisplayer (ChatDisplayer);
963 NLMISC::ErrorLog->addDisplayer (ChatDisplayer);
964 NLMISC::WarningLog->addDisplayer (ChatDisplayer);
965 NLMISC::InfoLog->addDisplayer (ChatDisplayer);
966 NLMISC::DebugLog->addDisplayer (ChatDisplayer);
967 NLMISC::AssertLog->addDisplayer (ChatDisplayer);
968
969 // load bot chat datas
970 //CBotChat::init();
971
972 // init the bot chat
973 nlassert (BotChatPageAll == NULL);
974 BotChatPageAll = new CBotChatPageAll;
975 BotChatPageAll->init();
976
977 // NLMEMORY::CheckHeap (true);
978
979 // init the list of people
980 PeopleInterraction.init();
981
982 // flush system msg buffer
983 for( uint i=0; i<PeopleInterraction.SystemMessageBuffer.size(); ++i )
984 {
985 displaySystemInfo(PeopleInterraction.SystemMessageBuffer[i].Str, PeopleInterraction.SystemMessageBuffer[i].Cat);
986 }
987 PeopleInterraction.SystemMessageBuffer.clear();
988
989 // Init macro manager
990 CMacroCmdManager::getInstance()->initInGame();
991
992 {
993 H_AUTO( RZUpdAll )
994
995 CWidgetManager::getInstance()->updateAllLocalisedElements(); // To init all things
996 }
997
998 // Interface config
999 loadInterfaceConfig();
1000
1001 //Load user landmarks
1002 loadLandmarks();
1003
1004 // Must do extra init for people interaction after load
1005 PeopleInterraction.initAfterLoad();
1006
1007 //CBotChatUI::refreshActiveWindows(); // bot chat windows are saved too..
1008
1009 CWidgetManager::getInstance()->activateMasterGroup ("ui:interface", true);
1010
1011 // Update the time in the ui database
1012 _CheckMailNode = NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:MAIL_WAITING");
1013 _CheckForumNode = NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:FORUM_UPDATED");
1014
1015 // Init the action manager
1016 {
1017
1018 initActions();
1019 }
1020 setInGame( true );
1021
1022 // Init bubble manager
1023 InSceneBubbleManager.init();
1024
1025 // Init Memory Bar for phraseManager. DB and ctrl gray state
1026 pPM->updateMemoryBar();
1027
1028 // Init emotes
1029 _EmotesInitialized = false;
1030 initEmotes();
1031
1032 // init chat manager
1033 ChatMngr.initInGame();
1034
1035 // Init FlyingText manager
1036 FlyingTextManager.initInGame();
1037
1038 // Init Bar Manager (HP, SAP etc... Bars)
1039 CBarManager::getInstance()->initInGame();
1040
1041 // Init interface props linked to client time
1042 initClientTime();
1043
1044 // Whole initInGame profile
1045 nlinfo ("%d seconds for initInGame", (uint32)(ryzomGetLocalTime ()-initStart)/1000);
1046
1047 // reset the compass target
1048 CGroupCompas *gc = dynamic_cast<CGroupCompas *>(CWidgetManager::getInstance()->getElementFromId("ui:interface:compass"));
1049 if (gc && gc->isSavedTargetValid())
1050 {
1051 gc->setTarget(gc->getSavedTarget());
1052 }
1053
1054 // rebuild mp3 player playlist if user reselected a char (songs are already scanned)
1055 CAHManager::getInstance()->runActionHandler("music_player", NULL, "update_playlist");
1056 CAHManager::getInstance()->runActionHandler("music_player", NULL, "stop");
1057
1058 CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CHATLOG_STATE", false);
1059 if (node)
1060 {
1061 _LogState = (node->getValue32() != 0);
1062 }
1063
1064 if (_LogState)
1065 {
1066 displaySystemInfo(CI18N::get("uiLogTurnedOn"));
1067 }
1068 else
1069 {
1070 displaySystemInfo(CI18N::get("uiLogTurnedOff"));
1071 }
1072
1073 startWebIgNotificationThread();
1074 }
1075
1076 // ------------------------------------------------------------------------------------------------
1077 void CInterfaceManager::loadIngameInterfaceTextures()
1078 {
1079 nldebug("Textures Ingame Interface");
1080
1081 for (vector<string>::iterator it = ClientCfg.TexturesInterface.begin(), end = ClientCfg.TexturesInterface.end(); it != end; ++it)
1082 {
1083 nldebug("Textures Ingame Interface: %s", (*it).c_str());
1084 loadTextures(*it + ".tga", *it + ".txt", false);
1085 }
1086
1087 for (vector<string>::iterator it = ClientCfg.TexturesInterfaceDXTC.begin(), end = ClientCfg.TexturesInterfaceDXTC.end(); it != end; ++it)
1088 {
1089 nldebug("Textures Ingame Interface DXTC: %s", (*it).c_str());
1090 loadTextures(*it + ".tga", *it + ".txt", true);
1091 }
1092 }
1093
1094 // ------------------------------------------------------------------------------------------------
1095 void CInterfaceManager::loadUI()
1096 {
1097 // Copy the array of file to load
1098 vector<string> xmlFilesToParse = getInGameXMLInterfaceFiles();
1099
1100 if (!parseInterface (xmlFilesToParse, false))
1101 {
1102 badXMLParseMessageBox();
1103 }
1104
1105 configureQuitDialogBox();
1106 }
1107
1108 // ------------------------------------------------------------------------------------------------
1109 void CInterfaceManager::configureQuitDialogBox()
1110 {
1111 // Configure the quit dialog box according to the server
1112 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1113 string quitDialogMainStr = "ui:interface:quit_dialog";
1114 string quitDialogStr = quitDialogMainStr + ":indent_middle";
1115 CInterfaceGroup *quitDlg = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(quitDialogStr));
1116 if (quitDlg)
1117 {
1118 CInterfaceElement *eltRet, *eltQuit, *eltQuitNow;
1119 eltRet = quitDlg->getElement(quitDialogStr+":return_mainland");
1120 eltQuit = quitDlg->getElement(quitDialogStr+":ryzom");
1121 eltQuitNow = quitDlg->getElement(quitDialogStr+":ryzom_now");
1122 sint buttonDeltaY;
1123 fromString( CWidgetManager::getInstance()->getParser()->getDefine("quit_button_delta_y"), buttonDeltaY);
1124 extern R2::TUserRole UserRoleInSession;
1125
1126 bool sessionOwner = (R2::getEditor().getMode() != R2::CEditor::NotInitialized && R2::getEditor().getDMC().getEditionModule().isSessionOwner());
1127
1128 // Show Launch Editor if not in editor mode
1129 CInterfaceElement *eltCancel = quitDlg->getElement(quitDialogStr+":cancel");
1130 CInterfaceElement *eltEdit = quitDlg->getElement(quitDialogStr+":launch_editor");
1131 if (eltEdit)
1132 {
1133 if (UserRoleInSession != R2::TUserRole::ur_editor && !sessionOwner)
1134 {
1135 eltEdit->setY(buttonDeltaY);
1136 eltEdit->setActive(true);
1137
1138 if (eltCancel)
1139 (safe_cast<CCtrlTextButton*>(eltCancel))->setText(CI18N::get("uittQuitCancel"));
1140 }
1141 else
1142 {
1143 eltEdit->setY(0); // prevent from displaying a gap between two shown buttons
1144 eltEdit->setActive(false);
1145
1146 if (eltCancel)
1147 (safe_cast<CCtrlTextButton*>(eltCancel))->setText(sessionOwner ? CI18N::get("uittQuitCancel") : CI18N::get("uittQuitCancelEditor"));
1148 }
1149 }
1150
1151 // Other buttons
1152 if (IsInRingSession || (ClientCfg.Local && ClientCfg.R2EDEnabled))
1153 {
1154 // display "return to mainland", unless we are the scenario owner (player or 'aventure master')
1155 if (eltRet)
1156 {
1157 if (!sessionOwner || R2::getEditor().getMode()==R2::CEditor::EditionMode)
1158 {
1159 //eltRet->setY(buttonDeltaY);
1160 const char *textLabel = (UserRoleInSession == R2::TUserRole::ur_editor) ? "uittLeaveEditor" : "uittReturnToMainland";
1161 (safe_cast<CCtrlTextButton*>(eltRet))->setText(CI18N::get(textLabel));
1162 eltRet->setY(buttonDeltaY);
1163 eltRet->setActive(true); // show Return to Mainland / PLAY
1164 }
1165 else
1166 {
1167 eltRet->setY(0);
1168 // when an owner of the session, there's an additionnal 'stop' button
1169 eltRet->setActive(false);
1170 }
1171 }
1172 if (eltQuit)
1173 {
1174 eltQuit->setY(0);
1175 eltQuit->setActive(false);
1176 }
1177 if (eltQuitNow)
1178 {
1179 eltQuitNow->setY(buttonDeltaY);
1180 eltQuitNow->setActive(true); // show Quit (Now)
1181 }
1182 }
1183 else
1184 {
1185 if (eltRet)
1186 {
1187 eltRet->setY(0); // prevent from displaying a gap between two shown buttons
1188 eltRet->setActive(false);
1189 }
1190 if (eltQuit)
1191 {
1192 eltQuit->setY(buttonDeltaY);
1193 eltQuit->setActive(true); // show Quit (with progress bar)
1194 }
1195 if (eltQuitNow)
1196 {
1197 eltQuitNow->setY(0);
1198 eltQuitNow->setActive(false);
1199 }
1200 }
1201 }
1202
1203 // Make all controls have the same size
1204 CInterfaceGroup *quitDlgMain = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(quitDialogMainStr));
1205 if ( quitDlgMain )
1206 {
1207
1208 quitDlgMain->invalidateCoords();
1209 for (uint k = 0; k < 3; ++k)
1210 {
1211 quitDlgMain->updateCoords(); // calculate the width of the text buttons
1212 }
1213 }
1214 const std::vector<CCtrlBase*>& controls = quitDlg->getControls();
1215 sint32 biggestWidth = 0;
1216 for ( std::vector<CCtrlBase*>::const_iterator ic=controls.begin(); ic!=controls.end(); ++ic )
1217 {
1218 CCtrlTextButton *ctb = dynamic_cast<CCtrlTextButton*>(*ic);
1219 if ( ! ctb )
1220 continue;
1221
1222 if ( ctb->getW() > biggestWidth )
1223 biggestWidth = ctb->getW();
1224 }
1225 for ( std::vector<CCtrlBase*>::const_iterator ic=controls.begin(); ic!=controls.end(); ++ic )
1226 {
1227 CCtrlTextButton *ctb = dynamic_cast<CCtrlTextButton*>(*ic);
1228 if ( ! ctb )
1229 continue;
1230
1231 ctb->setWMin( biggestWidth );
1232 }
1233
1234 if ( quitDlgMain )
1235 {
1236
1237 quitDlgMain->invalidateCoords();
1238 for (uint k = 0; k < 3; ++k)
1239 {
1240 quitDlgMain->updateCoords(); // calculate the width of the text buttons
1241 }
1242 }
1243 }
1244
1245 // ------------------------------------------------------------------------------------------------
1246 //
1247 std::string CInterfaceManager::getSaveFileName(const std::string &module, const std::string &ext, bool useShared) const
1248 {
1249 string filename = "save/" + module + "_" + PlayerSelectedFileName + "." + ext;
1250 if (useShared && !CFile::fileExists(filename))
1251 {
1252 string sharedFile = "save/shared_" + module + "." + ext;
1253 if (CFile::fileExists(sharedFile))
1254 {
1255 return sharedFile;
1256 }
1257 }
1258 return filename;
1259 }
1260
1261 // ------------------------------------------------------------------------------------------------
1262 void CInterfaceManager::loadKeys()
1263 {
1264 if (ClientCfg.R2EDEnabled) // in R2ED mode the CEditor class deals with it
1265 return;
1266
1267 CMacroCmdManager::getInstance()->removeAllMacros();
1268
1269 vector<string> xmlFilesToParse;
1270
1271 // Does the keys file exist ?
1272 string userKeyFileName = getSaveFileName("keys", "xml");
1273 if (CFile::fileExists(userKeyFileName) && CFile::getFileSize(userKeyFileName) > 0)
1274 {
1275 // Load the user key file
1276 xmlFilesToParse.push_back (userKeyFileName);
1277 }
1278
1279 // Load the default key (but don't replace existings bounds, see keys.xml "key_def_no_replace")
1280 xmlFilesToParse.push_back ("keys.xml");
1281
1282 if (!parseInterface (xmlFilesToParse, true))
1283 {
1284 createFileBackup("Error loading keys", userKeyFileName);
1285 }
1286
1287 _KeysLoaded = true;
1288 }
1289
1290 // ------------------------------------------------------------------------------------------------
1291 void CInterfaceManager::loadInterfaceConfig()
1292 {
1293 // Load interface.cfg
1294 if (ClientCfg.R2EDEnabled) // in R2ED mode the CEditor class deals with it
1295 return;
1296
1297 string filename = getSaveFileName("interface", "icfg");
1298 loadConfig(filename); // Invalidate coords of changed groups
1299
1300 _ConfigLoaded = true;
1301 }
1302
1303 // ------------------------------------------------------------------------------------------------
1304 void CInterfaceManager::uninitInGame0 ()
1305 {
1306 // Autosave of the keys
1307 if (_KeysLoaded)
1308 {
1309 saveKeys();
1310
1311 _KeysLoaded = false;
1312 }
1313
1314 // Autosave of the interface in interface.cfg
1315 if (_ConfigLoaded)
1316 {
1317 saveConfig();
1318
1319 _ConfigLoaded = false;
1320 }
1321 }
1322
1323
1324 // ------------------------------------------------------------------------------------------------
1325 void CInterfaceManager::uninitInGame1 ()
1326 {
1327 stopWebIgNotificationThread();
1328
1329 // release Bar Manager (HP, SAP etc... Bars)
1330 CBarManager::getInstance()->releaseInGame();
1331
1332 // release FlyingTextManager
1333 FlyingTextManager.releaseInGame();
1334
1335 // release chat manager
1336 ChatMngr.releaseInGame();
1337
1338 // Reset the chat text manager
1339 CChatTextManager::getInstance().reset();
1340
1341 // release emotes
1342 uninitEmotes();
1343
1344 // release bubble manager
1345 InSceneBubbleManager.release();
1346
1347 // kill chat displayer
1348 if( ChatDisplayer )
1349 {
1350 DebugLog->removeDisplayer (ChatDisplayer);
1351 InfoLog->removeDisplayer (ChatDisplayer);
1352 WarningLog->removeDisplayer (ChatDisplayer);
1353 ErrorLog->removeDisplayer (ChatDisplayer);
1354 AssertLog->removeDisplayer (ChatDisplayer);
1355 g_log.removeDisplayer(ChatDisplayer);
1356 delete ChatDisplayer;
1357 ChatDisplayer = NULL;
1358 }
1359
1360 // Release inventory manager
1361 CInventoryManager::releaseInstance();
1362 // Same for temp inventory manager
1363 CTempInvManager::releaseInstance();
1364 // Release guild manager
1365 CGuildManager::release();
1366
1367 // release bot chat and manager
1368 CBotChatManager::getInstance()->setCurrPage(NULL);
1369 delete BotChatPageAll;
1370 BotChatPageAll = NULL;
1371 CBotChatManager::releaseInstance();
1372
1373 //release CInterfaceItemEdition
1374 CInterfaceItemEdition::getInstance()->setCurrWindow(NULL);
1375 CInterfaceItemEdition::releaseInstance();
1376
1377 // release task bar manager
1378 CTaskBarManager::releaseInstance();
1379
1380 // People inetrraction release
1381 PeopleInterraction.release();
1382
1383 if (SoundMngr != NULL)
1384 {
1385 NLSOUND::UAudioMixer *pMixer = SoundMngr->getMixer();
1386 pMixer->unloadSampleBank("ui_ingame");
1387 }
1388
1389 // disable the game_quitting modal window
1390 CWidgetManager::getInstance()->disableModalWindow();
1391
1392 // Remove all interface objects (containers, groups, variables, defines, ...)
1393 CWidgetManager::getInstance()->activateMasterGroup ("ui:interface", false);
1394
1395 CInterfaceParser *parser = dynamic_cast< CInterfaceParser* >( CWidgetManager::getInstance()->getParser() );
1396
1397 parser->removeAll();
1398 reset();
1399 CInterfaceLink::removeAllLinks();
1400
1401 CWidgetManager::getInstance()->setPointer( NULL );
1402
1403 // Release DDX manager, before DB remove
1404 CDDXManager::getInstance()->release();
1405
1406 // Release client time, before DB remove
1407 releaseClientTime();
1408
1409 // remove DB entry
1410 ICDBNode::CTextId textId("UI");
1411 NLGUI::CDBManager::getInstance()->getDB()->removeNode(textId);
1412
1413 // Uninit the action manager
1414 {
1415
1416 uninitActions();
1417 }
1418
1419 // uninit phrase mgr
1420 CSPhraseManager *pPM = CSPhraseManager::getInstance();
1421 pPM->reset();
1422 CSPhraseManager::releaseInstance(); // must release before BrickManager, SkillManager
1423
1424 // uninit brick manager
1425 // Don't release the instance because must not lost brick map and data
1426 CSBrickManager::getInstance()->uninitInGame();
1427
1428 // Uninit skill manager (after phrase mgr)
1429 // AJM don't release SkillManager, else impulse msg update guild title will crash :(
1430 CSkillManager::getInstance()->uninitTitles();
1431
1432 // Uninit macro manager
1433 CMacroCmdManager::getInstance()->uninitInGame();
1434
1435 // Release interface help
1436 CInterfaceHelp::release();
1437
1438 // Release guild manager
1439 CGuildManager::release();
1440
1441 // Close LUA Scripting
1442 parser->uninitLUA();
1443
1444 setInGame( false );
1445 _NeutralColor = NULL;
1446 _WarningColor = NULL;
1447 _ErrorColor = NULL;
1448 CWidgetManager::getInstance()->resetColorProps();
1449 CWidgetManager::getInstance()->resetAlphaRolloverSpeedProps();
1450 CWidgetManager::getInstance()->resetGlobalAlphasProps();
1451
1452 #ifdef AJM_DEBUG_TRACK_INTERFACE_GROUPS
1453 CInterfaceManager::getInstance()->DebugTrackGroupsDump();
1454
1455 // NLMEMORY::ReportMemoryLeak();
1456 #endif
1457
1458 }
1459
1460
1461 // ------------------------------------------------------------------------------------------------
1462 void CInterfaceManager::flushDebugWindow()
1463 {
1464 if (ChatDisplayer != NULL)
1465 ChatDisplayer->update();
1466 }
1467
1468 // ------------------------------------------------------------------------------------------------
1469 // Make sure 0.166 is displayed as 16% and 0.167 as 17%
1470 // because they belong to different weather conditions
1471 static float roundWeatherValue(float weatherValue)
1472 {
1473 // Number of possible weather setups in server
1474 const static uint NB_WEATHER_SETUPS = 6;
1475 float floorValue = floorf(weatherValue * 100.f) / 100.f;
1476 uint weatherIndex = min((uint)(weatherValue * NB_WEATHER_SETUPS), NB_WEATHER_SETUPS - 1);
1477 uint floorIndex = min((uint)(floorValue * NB_WEATHER_SETUPS), NB_WEATHER_SETUPS - 1);
1478
1479 if (weatherIndex > floorIndex)
1480 return ceilf(weatherValue * 100.f) / 100.f;
1481
1482 return weatherValue;
1483 }
1484
1485 // ------------------------------------------------------------------------------------------------
1486 void CInterfaceManager::updateFrameEvents()
1487 {
1488
1489 H_AUTO_USE ( RZ_Client_Update_Frame_Events )
1490
1491 // lua scripts from different thread
1492 flushScriptQueue();
1493
1494 flushDebugWindow();
1495
1496 // Handle anims done in 2 times because some AH can add or remove anims
1497 // First ensure we are working on a safe vector and update all anims
1498 CWidgetManager::getInstance()->updateAnims();
1499
1500 IngameDbMngr.flushObserverCalls();
1501 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1502
1503 CWidgetManager::getInstance()->removeFinishedAnims();
1504
1505 //
1506 IngameDbMngr.flushObserverCalls();
1507 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1508
1509 // Handle waiting texts from server
1510 processServerIDString();
1511
1512 if (_InGame)
1513 {
1514 // Execute current macro
1515 CMacroCmdManager::getInstance()->updateMacroExecution();
1516
1517 // Update guild handling (check if we have to rebuild)
1518 CGuildManager::getInstance()->update();
1519
1520 // Update contact list with incoming server string ids
1521 PeopleInterraction.updateWaitingContacts();
1522
1523 // Update string if some waiting
1524 CEncyclopediaManager::getInstance()->updateAllFrame();
1525
1526 // Setup the weather setup in the player's map every 3 sec (1 ingame minute)
1527 if ((T0 - _UpdateWeatherTime) > (1 * 3 * 1000))
1528 {
1529 _UpdateWeatherTime = T0;
1530 string str = CI18N::get ("uiTheSeasonIs") +
1531 CI18N::get ("uiSeason"+toStringEnum(computeCurrSeason())) +
1532 CI18N::get ("uiAndTheWeatherIs") +
1533 CI18N::get (WeatherManager.getCurrWeatherState().LocalizedName) +
1534 toString(", %d", (uint)(roundWeatherValue(WeatherManager.getWeatherValue()) * 100.f)) + "% " +CI18N::get("uiHumidity");
1535
1536
1537
1538 CViewText *pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:map:content:map_content:weather"));
1539 if (pVT != NULL)
1540 pVT->setText(str);
1541
1542 CCtrlBase *pTooltip= dynamic_cast<CCtrlBase*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:map:content:map_content:weather_tt"));
1543 if (pTooltip != NULL)
1544 {
1545 string tt = toString("%02d", WeatherManager.getNextWeatherHour()) + CI18N::get("uiMissionTimerHour") +
1546 " - " + CI18N::get("uiHumidity") + " " +
1547 toString("%d", (uint)(roundWeatherValue(WeatherManager.getNextWeatherValue()) * 100.f)) + "%";
1548 pTooltip->setDefaultContextHelp(tt);
1549 }
1550
1551 // The date feature is temporarily disabled
1552 str.clear();
1553
1554 // numeric version
1555 //str = CI18N::get("uiDate");
1556 //str += toString("%04d", RT.getRyzomYear()) + "/";
1557 //str += toString("%01d", RT.getRyzomCycle()+1) + " : ";
1558 //str += toString("%02d", RT.getRyzomMonthInCurrentCycle()+1) + "/";
1559 //str += toString("%02d", RT.getRyzomDayOfMonth()+1) + " - "; // Start at 1 for January
1560 //str += toString("%02d", (sint)RT.getRyzomTime()) + " " + CI18N::get("uiMissionTimerHour");
1561
1562 // literal version
1563 // str = CI18N::get("uiDate");
1564 uint minutes = ((RT.getRyzomTime() - (sint)RT.getRyzomTime()) * (float) RYZOM_HOUR_IN_MINUTES);
1565 str += toString("%02d:%02d", (sint)RT.getRyzomTime(), minutes) + " - ";
1566 str += CI18N::get("ui"+WEEKDAY::toString( (WEEKDAY::EWeekDay)RT.getRyzomDayOfWeek() )) + ", ";
1567 str += CI18N::get("ui"+MONTH::toString( (MONTH::EMonth)RT.getRyzomMonthInCurrentCycle() )) + " ";
1568 str += toString("%02d", RT.getRyzomDayOfMonth()+1) + ", ";
1569 str += CI18N::get("uiAtysianCycle" + toString(RT.getRyzomCycle()+1) + "Ordinal") + " " + CI18N::get("uiAtysianCycle") + " ";
1570 str += toString("%04d", RT.getRyzomYear());
1571
1572 pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:map:content:map_content:time"));
1573 if (pVT != NULL)
1574 pVT->setText(str);
1575
1576 str.clear();
1577 // Update the clock in the compass if enabled.
1578 pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:compass:clock:time"));
1579 if (pVT != NULL)
1580 {
1581 if (pVT->getActive())
1582 {
1583 if (use12hClock())
1584 str = getTimestampHuman("%I:%M %p");
1585 else
1586 str = getTimestampHuman("%H:%M");
1587 pVT->setText(str);
1588 }
1589 }
1590 }
1591 }
1592
1593 CWidgetManager::getInstance()->sendClockTickEvent();
1594
1595 IngameDbMngr.flushObserverCalls();
1596 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1597
1598 // Update SPhrase manager
1599 CSPhraseManager *pPM= CSPhraseManager::getInstance();
1600 pPM->update();
1601
1602 // if there's an external lua debugger, update it
1603 luaDebuggerMainLoop();
1604
1605 // handle gc for lua
1606 CLuaManager::getInstance().getLuaState()->handleGC();
1607
1608 #ifdef RYZOM_BG_DOWNLOADER
1609 CBGDownloaderAccess::getInstance().update();
1610 #endif
1611
1612 CItemGroupManager::getInstance()->update();
1613
1614 }
1615
1616 // ------------------------------------------------------------------------------------------------
1617 void CInterfaceManager::updateFrameViews(NL3D::UCamera camera)
1618 {
1619
1620 H_AUTO ( RZ_Interface_updateFrameViews )
1621
1622 if (!camera.empty())
1623 CViewRenderer::getInstance()->setWorldSpaceFrustum (camera.getFrustum());
1624
1625 CWidgetManager::getInstance()->checkCoords();
1626 drawViews(camera);
1627
1628 // The interface manager may change usual Global setup. reset them.
1629 CViewRenderer::getTextContext()->setShadeColor(CRGBA::Black);
1630
1631 }
1632
1633 void CInterfaceManager::setupOptions()
1634 {
1635 CWidgetManager *wm = CWidgetManager::getInstance();
1636 wm->setupOptions();
1637
1638 // Try to change font if any
1639 string sFont = wm->getSystemOption( CWidgetManager::OptionFont ).getValStr();
1640
1641 if ((!sFont.empty()) && (Driver != NULL))
1642 resetTextContext(sFont.c_str(), true);
1643 // Continue to parse the rest of the interface
1644
1645 sFont = wm->getSystemOption (CWidgetManager::OptionMonospaceFont).getValStr();
1646 if ((!sFont.empty()) && (Driver != NULL))
1647 CViewRenderer::registerFont("monospace", sFont);
1648 }
1649
1650 // ------------------------------------------------------------------------------------------------
1651 bool CInterfaceManager::parseInterface (const std::vector<std::string> &xmlFileNames, bool reload, bool isFilename)
1652 {
1653 // cache some commonly used db nodes
1654 _DBB_UI_DUMMY = NLGUI::CDBManager::getInstance()->getDbBranch( "UI:DUMMY" );
1655 _DB_UI_DUMMY_QUANTITY = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:QUANTITY", true );
1656 _DB_UI_DUMMY_QUALITY = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:QUALITY", true );
1657 _DB_UI_DUMMY_SHEET = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:SHEET", true );
1658 _DB_UI_DUMMY_NAMEID = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:NAMEID", true );
1659 _DB_UI_DUMMY_ENCHANT = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:ENCHANT", true );
1660 _DB_UI_DUMMY_SLOT_TYPE = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:SLOT_TYPE", true );
1661 _DB_UI_DUMMY_PHRASE = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:PHRASE", true );
1662 _DB_UI_DUMMY_WORNED = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:WORNED", true );
1663 _DB_UI_DUMMY_PREREQUISIT_VALID = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:PREREQUISIT_VALID", true );
1664 _DB_UI_DUMMY_FACTION_TYPE = NLGUI::CDBManager::getInstance()->getDbProp( "UI:DUMMY:FACTION_TYPE", true );
1665
1666 _DB_UI_DUMMY_QUANTITY->setValue64(0);
1667 _DB_UI_DUMMY_QUALITY->setValue64(0);
1668 _DB_UI_DUMMY_SHEET->setValue64(0);
1669 _DB_UI_DUMMY_NAMEID->setValue64(0);
1670 _DB_UI_DUMMY_ENCHANT->setValue64(0);
1671 _DB_UI_DUMMY_SLOT_TYPE->setValue64(0);
1672 _DB_UI_DUMMY_PHRASE->setValue64(0);
1673 _DB_UI_DUMMY_WORNED->setValue64(0);
1674 _DB_UI_DUMMY_PREREQUISIT_VALID->setValueBool(true);
1675 _DB_UI_DUMMY_FACTION_TYPE->setValue64(0);
1676
1677 return CWidgetManager::getInstance()->getParser()->parseInterface (xmlFileNames, reload, isFilename);
1678 }
1679
1680 // ------------------------------------------------------------------------------------------------
1681 void CInterfaceManager::loadTextures (const string &textFileName, const string &uvFileName, bool uploadDXTC)
1682 {
1683 CViewRenderer::getInstance()->loadTextures (textFileName, uvFileName, uploadDXTC);
1684 }
1685
1686 // ------------------------------------------------------------------------------------------------
1687 bool CInterfaceManager::loadConfig (const string &filename)
1688 {
1689 // reset the interface
1690 vector<string> v;
1691 if (ClientCfg.R2EDEnabled)
1692 {
1693 CWidgetManager::getInstance()->runProcedure ("proc_reset_r2ed_interface", NULL, v);
1694 }
1695 else
1696 {
1697 CWidgetManager::getInstance()->runProcedure ("proc_reset_interface", NULL, v);
1698 }
1699
1700 // By default, consider the reset interface has been set with the current resolution
1701 {
1702 uint32 w,h;
1703 // NB: even if minimzed, getScreenSize() no more return 0 values (return the last setuped screen size)
1704 CViewRenderer::getInstance()->getScreenSize(w, h);
1705 // Windows are positioned according to resolution, and we must backup W/H for the system that move windows when the resolution change
1706 _LastInGameScreenW= w;
1707 _LastInGameScreenH= h;
1708 }
1709
1710 // if the config file doesn't exist,just quit
1711 CIFile f;
1712 string sFileName;
1713 sFileName = NLMISC::CPath::lookup (filename, false);
1714 if (sFileName.empty() || !f.open(sFileName))
1715 return false;
1716
1717
1718 // *** Load the config file
1719 uint32 nNbMode;
1720 CInterfaceConfig ic;
1721 bool lastInGameScreenResLoaded= false;
1722 uint32 nbLandmarks = 0;
1723 try
1724 {
1725 sint ver = f.serialVersion(ICFG_STREAM_VERSION);
1726
1727 // serial user chats info (serial it before position of windows so that they can be updated properly)
1728 if (ver >= 1)
1729 {
1730 f.serialCheck(NELID("_ICU"));
1731 if (!PeopleInterraction.loadUserChatsInfos(f))
1732 {
1733 nlwarning("Bad user chat saving");
1734 }
1735 }
1736
1737 // header
1738 f.serialCheck(NELID("GFCI"));
1739 f.serial(nNbMode);
1740 f.serial(_CurrentMode);
1741 if (_CurrentMode > nNbMode)
1742 {
1743 _CurrentMode = 0;
1744 }
1745
1746 if(ver>=10)
1747 {
1748 f.serial(_LastInGameScreenW);
1749 f.serial(_LastInGameScreenH);
1750 lastInGameScreenResLoaded= true;
1751 }
1752
1753 // Initialize at least number of modes that are saved in stream
1754 _Modes.resize(std::max((uint32)MAX_NUM_MODES, nNbMode));
1755 for (uint32 i = 0; i < _Modes.size(); ++i)
1756 {
1757 NLMISC::contReset(_Modes[i]);
1758 }
1759
1760 // Load All Window configuration of all Modes
1761 for (uint32 i = 0; i < nNbMode; ++i)
1762 {
1763 // must create a tmp mem stream because desktop image expect its datas to occupy the whole stream
1764 // This is because of old system that manipulated desktop image direclty as a mem stream
1765 CMemStream ms;
1766 if (!ms.isReading()) ms.invert();
1767 uint32 length;
1768 f.serial(length);
1769 if (length > 0)
1770 {
1771 // HACK. if the version is <=2, then the CInterfaceConfig has no serialVersion. append here a 0
1772 if(ver<=2)
1773 {
1774 uint8 *pBuffer = ms.bufferToFill(length+1);
1775 pBuffer[0]= 0;
1776 f.serialBuffer(pBuffer+1, length);
1777 }
1778 else
1779 {
1780 uint8 *pBuffer = ms.bufferToFill(length);
1781 f.serialBuffer(pBuffer, length);
1782 }
1783 }
1784 ms.seek(0, NLMISC::IStream::begin);
1785 _Modes[i].serial(ms); // build desktop image from stream
1786 }
1787
1788 // load UI_DB_SAVE_VERSION
1789 uint32 uiDbSaveVersion= 0; // default to 0 for old version of .icfg
1790 if(ver>=9)
1791 {
1792 f.serial(uiDbSaveVersion);
1793 }
1794
1795 // read database
1796 ic.streamToDataBase(f, uiDbSaveVersion);
1797
1798
1799 // special for in game: backup last mission because of delayed update
1800 {
1801 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:MISSION_SELECTED", false);
1802 if (pNL)
1803 {
1804 CCDBNodeLeaf *pSelectedMissionBackup = NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:MISSION_SELECTED_PREV_SESSION", true);
1805 pSelectedMissionBackup->setValue64(pNL->getValue64());
1806 }
1807 }
1808 //
1809
1810 // Deprecated. for Compatibility purpose: Load TaskBar.
1811 if(ver>=2)
1812 {
1813 CTaskBarManager *pTBM= CTaskBarManager::getInstance();
1814 pTBM->serial(f);
1815 }
1816
1817 // Load user landmarks
1818 nbLandmarks = ContinentMngr.serialUserLandMarks(f);
1819
1820 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:INTERFACES:NB_BONUS_LANDMARKS" );
1821 if ( pNL )
1822 {
1823 ICDBNode::CTextId textId;
1824 pNL->addObserver( &_LandmarkObs, textId);
1825 }
1826
1827 // Info Windows position.
1828 if(ver>=5)
1829 CInterfaceHelp::serialInfoWindows(f);
1830 else // Default pos
1831 CInterfaceHelp::resetWindowPos(-100);
1832
1833 // Macro On Memory Position
1834 CSPhraseManager *pPM = CSPhraseManager::getInstance();
1835 if(ver>=7)
1836 pPM->serialMacroMemory(f);
1837
1838 if(ver>=8)
1839 CGroupInSceneBubbleManager::serialInSceneBubbleInfo(f);
1840
1841 if (ver >= 11)
1842 {
1843 if ( ! PeopleInterraction.loadUserDynChatsInfos(f))
1844 {
1845 nlwarning("Bad user dyn chat saving");
1846 }
1847 }
1848 }
1849 catch(const NLMISC::EStream &)
1850 {
1851 f.close();
1852
1853 createFileBackup("Config loading failed", sFileName);
1854
1855 nlwarning("Config loading failed : restore default");
1856 vector<string> v;
1857 if (!ClientCfg.R2EDEnabled)
1858 {
1859 CWidgetManager::getInstance()->runProcedure ("proc_reset_interface", NULL, v);
1860 }
1861 return false;
1862 }
1863 f.close();
1864
1865 if (nbLandmarks > 0)
1866 {
1867 // use copy for backup so on save proper shared/player icfg file is used
1868 createFileBackup("Landmarks will be migrated to xml", sFileName, true);
1869
1870 // if icfg is interface_player.icfg, then landmarks must also be loaded/saved to player file
1871 if (nlstricmp(sFileName.substr(0, 12), "save/shared_") != 0)
1872 {
1873 string lmfile = getSaveFileName("landmarks", "xml", false);
1874 if (!CFile::fileExists(lmfile))
1875 {
1876 // create placeholder player landmarks file so saveLandmarks will use it
1877 // even if shared landmarks file exists
1878 COFile f;
1879 if (f.open(lmfile, false, false, true))
1880 {
1881 std::string xml;
1882 xml = "<?xml version=\"1.0\"?>\n<interface_config />";
1883 f.serialBuffer((uint8 *)xml.c_str(), xml.size());
1884 f.close();
1885 }
1886 }
1887 }
1888
1889 // merge .icfg landmarks with landmarks.xml
1890 loadLandmarks();
1891 saveLandmarks();
1892 }
1893
1894 // *** If saved resolution is different from the current one setuped, must fix positions in _Modes
1895 if(lastInGameScreenResLoaded)
1896 {
1897 // Temporarily set screen to saved size so that positions are correctly calculated
1898 CWidgetManager::getInstance()->setScreenWH(_LastInGameScreenW, _LastInGameScreenH);
1899 // NB: we are typically InGame here (even though the _InGame flag is not yet set)
1900 // Use the screen size of the config file. Don't update current UI, just _Modes
1901 //
1902 uint32 width, height;
1903 // get non-scaled width/height
1904 Driver->getWindowSize(width, height);
1905 // convert to scaled width/height for ui
1906 sint32 scaledW = width / ClientCfg.InterfaceScale;
1907 sint32 scaledH = height / ClientCfg.InterfaceScale;
1908 CWidgetManager::getInstance()->moveAllWindowsToNewScreenSize(scaledW, scaledH, false);
1909 updateDesktops(scaledW, scaledH);
1910 }
1911
1912 // *** apply the current mode
1913 _Modes[_CurrentMode].toCurrentDesktop();
1914
1915 // *** Apply the NPC icon display mode
1916 CNPCIconCache::getInstance().init(!ClientCfg.R2EDEnabled && NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:INSCENE:FRIEND:MISSION_ICON")->getValueBool());
1917
1918 return true;
1919 }
1920
1921
1922 // ------------------------------------------------------------------------------------------------
1923 void CInterfaceManager::CDBLandmarkObs::update(ICDBNode *node)
1924 {
1925 ContinentMngr.updateUserLandMarks();
1926 }
1927
1928
1929 // visitor to send onQuit msg on all element
1930 class CQuitVisitor : public CInterfaceElementVisitor
1931 {
1932 public:
1933 bool IsR2ED;
1934 bool BadWindowFound; //
1935 uint Desktop;
1936 virtual void visit(CInterfaceElement *elem) { elem->onQuit(); }
1937 virtual void visitGroup(CInterfaceGroup *group)
1938 {
1939 if (!IsR2ED) return;
1940 if (Desktop != 0) return;
1941 if (group->getShortId() == "gestionsets")
1942 {
1943 if (group->getActive())
1944 {
1945 BadWindowFound = true;
1946 }
1947 }
1948 }
1949 };
1950
1951 bool CInterfaceManager::saveLandmarks(bool verbose) const
1952 {
1953 bool ret = true;
1954
1955 if (!ClientCfg.R2EDEnabled)
1956 {
1957 uint8 currMode = getMode();
1958
1959 string filename = getSaveFileName("landmarks", "xml");
1960 if (verbose) CInterfaceManager::getInstance()->displaySystemInfo("Saving " + filename);
1961 ret = saveLandmarks(filename);
1962 }
1963
1964 return ret;
1965 }
1966
1967 bool CInterfaceManager::loadLandmarks()
1968 {
1969 // Does the keys file exist ?
1970 string filename = getSaveFileName("landmarks", "xml");
1971
1972 CIFile f;
1973 string sFileName;
1974 sFileName = NLMISC::CPath::lookup (filename, false);
1975 if (sFileName.empty() || !f.open(sFileName))
1976 return false;
1977
1978 bool ret = false;
1979 vector<string> xmlFilesToParse;
1980 xmlFilesToParse.push_back (filename);
1981
1982 //ContinentMngr.serialUserLandMarks(node);
1983 if (!parseInterface (xmlFilesToParse, true))
1984 {
1985 f.close();
1986
1987 createFileBackup("Error while loading landmarks", filename);
1988
1989 ret = false;
1990 }
1991
1992 return ret;
1993 }
1994
1995 bool CInterfaceManager::saveLandmarks(const std::string &filename) const
1996 {
1997 nlinfo( "Saving landmarks : %s", filename.c_str() );
1998
1999 bool ret = false;
2000 try
2001 {
2002 COFile f;
2003
2004 // using temporary file, so no f.close() unless its a success
2005 if (f.open(filename, false, false, true))
2006 {
2007 COXml xmlStream;
2008 xmlStream.init (&f);
2009
2010 xmlDocPtr doc = xmlStream.getDocument ();
2011 xmlNodePtr node = xmlNewDocNode(doc, NULL, (const xmlChar*)"interface_config", NULL);
2012 xmlDocSetRootElement (doc, node);
2013
2014 ContinentMngr.writeTo(node);
2015
2016 // Flush the stream
2017 xmlStream.flush();
2018
2019 // Close the stream
2020 f.close ();
2021
2022 ret = true;
2023 }
2024 }
2025 catch (const Exception &e)
2026 {
2027 nlwarning ("Error while writing the file %s : %s.", filename.c_str(), e.what ());
2028 }
2029
2030 return ret;
2031 }
2032
2033 // ------------------------------------------------------------------------------------------------
2034 //
2035 bool CInterfaceManager::saveConfig (bool verbose)
2036 {
2037 bool ret = true;
2038
2039 if (!ClientCfg.R2EDEnabled)
2040 {
2041 uint8 currMode = getMode();
2042
2043 string filename = getSaveFileName("interface", "icfg");
2044
2045 if (verbose) CInterfaceManager::getInstance()->displaySystemInfo("Saving " + filename);
2046 ret = saveConfig(filename);
2047
2048 if (currMode != getMode())
2049 setMode(currMode);
2050 }
2051
2052 return ret;
2053 }
2054
2055 // ------------------------------------------------------------------------------------------------
2056 bool CInterfaceManager::saveConfig (const string &filename)
2057 {
2058
2059 CQuitVisitor quitVisitor;
2060
2061 quitVisitor.IsR2ED = false;
2062 if (nlstricmp(NLMISC::CFile::getFilename(filename).substr(0, 5), "r2ed_") == 0)
2063 {
2064 quitVisitor.IsR2ED = true;
2065 }
2066 quitVisitor.BadWindowFound = false;
2067
2068 nlinfo( "Saving interface config : %s", filename.c_str() );
2069
2070 COFile f;
2071
2072 // using temporary file, so no f.close() unless its a success
2073 if (!f.open(filename, false, false, true)) return false;
2074
2075 CInterfaceConfig ic;
2076
2077
2078
2079 // cleanup all desktops
2080 for(uint k = 0; k < _Modes.size(); ++k)
2081 {
2082 quitVisitor.Desktop = k;
2083 setMode(k);
2084 visit(&quitVisitor);
2085 CWidgetManager::getInstance()->checkCoords();
2086 }
2087 setMode(0);
2088 setMode(_CurrentMode);
2089
2090 if (quitVisitor.BadWindowFound)
2091 {
2092 #ifdef NL_DEBUG
2093 nlassert(0);
2094 #endif
2095 // tmp patch : when trying to overwrite the r2ed_ config, if a bad window is found, just do nothing ...
2096 return true;
2097 }
2098
2099 /*
2100 _Modes[_CurrentMode].clear();
2101 if (_Modes[_CurrentMode].isReading()) _Modes[_CurrentMode].invert();
2102 clearAllEditBox();
2103 restoreAllContainersBackupPosition();
2104 ic.interfaceManagerToStream(_Modes[_CurrentMode]);
2105 */
2106
2107 uint32 i;
2108
2109 i = _Modes.size();
2110 try
2111 {
2112 f.serialVersion(ICFG_STREAM_VERSION);
2113
2114 // serial user chats info (serial it before position of windows so that they can be updated properly)
2115 f.serialCheck(NELID("_ICU"));
2116 if (!PeopleInterraction.saveUserChatsInfos(f))
2117 {
2118 nlwarning("Config saving failed");
2119 // couldn't save result so do not continue
2120 return false;
2121 }
2122
2123 // header
2124 f.serialCheck(NELID("GFCI"));
2125 f.serial(i);
2126 f.serial(_CurrentMode);
2127 f.serial(_LastInGameScreenW);
2128 f.serial(_LastInGameScreenH);
2129
2130 // Save All Window configuration of all Modes
2131 for (i = 0; i < _Modes.size(); ++i)
2132 {
2133 // must create a tmp mem stream because desktop image expect its datas to occupy the whole stream
2134 // This is because of old system that manipulated desktop image direclty as a mem stream
2135 CMemStream ms;
2136 if (ms.isReading()) ms.invert();
2137 _Modes[i].serial(ms);
2138 uint32 length = ms.length();
2139 f.serial(length);
2140 if (length > 0)
2141 {
2142 f.serialBuffer(const_cast<uint8 *>(ms.buffer()), length);
2143 }
2144 }
2145
2146 // write UI_DB_SAVE_VERSION
2147 uint32 uiDbSaveVersion;
2148 fromString( CWidgetManager::getInstance()->getParser()->getDefine("UI_DB_SAVE_VERSION"), uiDbSaveVersion);
2149 f.serial(uiDbSaveVersion);
2150
2151 // write database
2152 ic.dataBaseToStream(f);
2153
2154 // Deprecated. for Compatibility purpose: Save TaskBar.
2155 CTaskBarManager *pTBM= CTaskBarManager::getInstance();
2156 pTBM->serial(f);
2157
2158 //ContinentMngr.serialUserLandMarks(f);
2159 // empty landmarks block for compatibility
2160 {
2161 f.serialVersion(1);
2162 uint32 numCont = 0;
2163 f.serial(numCont);
2164 }
2165
2166 // Info Windows position.
2167 CInterfaceHelp::serialInfoWindows(f);
2168
2169 // Macro On Memory Position
2170 CSPhraseManager *pPM = CSPhraseManager::getInstance();
2171 pPM->serialMacroMemory(f);
2172
2173 CGroupInSceneBubbleManager::serialInSceneBubbleInfo(f);
2174
2175 if ( ! PeopleInterraction.saveUserDynChatsInfos(f))
2176 {
2177 nlwarning("Bad user dyn chat saving");
2178 return false;
2179 }
2180
2181 f.close();
2182 }
2183 catch(const NLMISC::EStream &)
2184 {
2185 nlwarning("Config saving failed.");
2186 return false;
2187 }
2188
2189 ContinentMngr.serialFOWMaps();
2190
2191 return true;
2192 }
2193
2194 // ------------------------------------------------------------------------------------------------
2195 void CInterfaceManager::drawViews(NL3D::UCamera camera)
2196 {
2197 IngameDbMngr.flushObserverCalls();
2198 NLGUI::CDBManager::getInstance()->flushObserverCalls();
2199
2200 // Update Player characteristics (for Item carac requirement Redifying)
2201 nlctassert(CHARACTERISTICS::NUM_CHARACTERISTICS==8);
2202 for (uint i=0; i<CHARACTERISTICS::NUM_CHARACTERISTICS; ++i)
2203 {
2204 if (!_CurrentPlayerCharacLeaf[i])
2205 _CurrentPlayerCharacLeaf[i] = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:CHARACTER_INFO:CHARACTERISTICS%d:VALUE", i), false);
2206
2207 NLMISC::CCDBNodeLeaf *node = NULL;
2208
2209 if (_CurrentPlayerCharacLeaf[i])
2210 node = &*_CurrentPlayerCharacLeaf[i];
2211
2212 _CurrentPlayerCharac[i] = node ? node->getValue32() : 0;
2213 }
2214
2215 // scale must be updated right before widget manager checks it
2216 if (_InterfaceScaleChanged)
2217 {
2218 CViewRenderer::getInstance()->setInterfaceScale(_InterfaceScale);
2219 _InterfaceScaleChanged = false;
2220 }
2221
2222 CWidgetManager::getInstance()->drawViews( camera );
2223
2224 // flush obs
2225 IngameDbMngr.flushObserverCalls();
2226 }
2227
2228
2229 // ------------------------------------------------------------------------------------------------
2230 bool CInterfaceManager::handleEvent (const NLGUI::CEventDescriptor& event)
2231 {
2232 bool handled = false;
2233
2234 handled = CWidgetManager::getInstance()->handleEvent( event );
2235
2236 if( event.getType() == NLGUI::CEventDescriptor::mouse )
2237 {
2238 NLGUI::CEventDescriptorMouse &eventDesc = (NLGUI::CEventDescriptorMouse&)event;
2239
2240 if( ( eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mouserightup ) && handled )
2241 {
2242 // prevent 'click in scene' as mouse was previously captured
2243 // (more a patch that anything, but 'UserControls' test for 'mouse up'
2244 // directly later in the main loop (not through message queue), so it has no way of knowing that the event was handled...
2245 if( CWidgetManager::getInstance()->getCapturePointerRight() == NULL )
2246 EventsListener.addUIHandledButtonMask(rightButton);
2247 }else
2248 if( ( eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mouseleftup ) && handled )
2249 {
2250 // prevent 'click in scene' as mouse was previously captured
2251 // (more a patch that anything, but 'UserControls' test for 'mouse up'
2252 // directly later in the main loop (not through message queue), so it has no way of knowing that the event was handled...
2253 if( CWidgetManager::getInstance()->getCapturePointerLeft() == NULL )
2254 EventsListener.addUIHandledButtonMask(leftButton);
2255 }
2256
2257 }
2258
2259 IngameDbMngr.flushObserverCalls();
2260 // event handled?
2261 return handled;
2262 }
2263
2264 void CInterfaceManager::updateDesktops( uint32 newScreenW, uint32 newScreenH )
2265 {
2266 // *** Do it for All Backuped Desktops
2267 for(uint md=0; md<_Modes.size(); md++)
2268 {
2269 CInterfaceConfig::CDesktopImage &mode= _Modes[md];
2270 // For all containers of this mode
2271 for(uint gc=0;gc<mode.GCImages.size();gc++)
2272 {
2273 CInterfaceConfig::SCont &gcCont= mode.GCImages[gc];
2274 // Compute the new coordinate, directly in the X/Y fields of the structure
2275 CWidgetManager::getInstance()->getNewWindowCoordToNewScreenSize(gcCont.X, gcCont.Y, gcCont.W, gcCont.H ,newScreenW, newScreenH);
2276 }
2277 }
2278
2279 _LastInGameScreenW = newScreenW;
2280 _LastInGameScreenH = newScreenH;
2281 }
2282
2283 class InvalidateTextVisitor : public CInterfaceElementVisitor
2284 {
2285 public:
2286 InvalidateTextVisitor( bool reset )
2287 {
2288 this->reset = reset;
2289 }
2290
2291 void visitGroup( CInterfaceGroup *group )
2292 {
2293 const std::vector< CViewBase* > &vs = group->getViews();
2294 for( std::vector< CViewBase* >::const_iterator itr = vs.begin(); itr != vs.end(); ++itr )
2295 {
2296 CViewText *vt = dynamic_cast< CViewText* >( *itr );
2297 if( vt != NULL )
2298 {
2299 if( reset )
2300 vt->resetTextIndex();
2301 vt->updateTextContext();
2302 }
2303 }
2304 }
2305
2306 private:
2307 bool reset;
2308 };
2309
2310
2311 // ------------------------------------------------------------------------------------------------
2312 void CInterfaceManager::addServerString (const std::string &sTarget, uint32 id, IStringProcess *cb)
2313 {
2314 if (id == 0)
2315 {
2316 CInterfaceExprValue val;
2317 val.setString (std::string());
2318 CInterfaceLink::setTargetProperty (sTarget, val);
2319 return;
2320 }
2321 SIDStringWaiter *pISW = new SIDStringWaiter;
2322 pISW->Id = id;
2323 pISW->IdOrString = false;
2324 pISW->Target = sTarget;
2325 pISW->Cb = cb;
2326 _IDStringWaiters.push_back(pISW);
2327 }
2328
2329 // ------------------------------------------------------------------------------------------------
2330 void CInterfaceManager::addServerID (const std::string &sTarget, uint32 id, IStringProcess *cb)
2331 {
2332 if (id == 0)
2333 {
2334 CInterfaceExprValue val;
2335 val.setString (std::string());
2336 CInterfaceLink::setTargetProperty (sTarget, val);
2337 return;
2338 }
2339 SIDStringWaiter *pISW = new SIDStringWaiter;
2340 pISW->Id = id;
2341 pISW->IdOrString = true;
2342 pISW->Target = sTarget;
2343 pISW->Cb = cb;
2344 _IDStringWaiters.push_back(pISW);
2345 }
2346
2347 // ------------------------------------------------------------------------------------------------
2348 void CInterfaceManager::processServerIDString()
2349 {
2350 STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
2351
2352 for (uint32 i = 0; i < _IDStringWaiters.size(); ++i)
2353 {
2354 bool bAffect = false;
2355 string ucstrToAffect;
2356 SIDStringWaiter *pISW = _IDStringWaiters[i];
2357 if (pISW->IdOrString == true) // ID !
2358 {
2359 if (pSMC->getString (pISW->Id, ucstrToAffect))
2360 bAffect = true;
2361 }
2362 else // String !
2363 {
2364 if (pSMC->getDynString (pISW->Id, ucstrToAffect))
2365 bAffect = true;
2366 }
2367
2368 if (bAffect)
2369 {
2370 CInterfaceExprValue val;
2371 bool bValid = true;
2372
2373 if (pISW->Cb != NULL)
2374 {
2375 bValid = pISW->Cb->cbIDStringReceived(ucstrToAffect);
2376 delete pISW->Cb;
2377 }
2378
2379 if (bValid)
2380 {
2381 ucstrToAffect = STRING_MANAGER::CStringManagerClient::getLocalizedName(ucstrToAffect);
2382 val.setString (ucstrToAffect);
2383 CInterfaceLink::setTargetProperty (pISW->Target, val);
2384 }
2385
2386 // Remove entry
2387 _IDStringWaiters.erase (_IDStringWaiters.begin()+i);
2388 i--;
2389 delete pISW;
2390 }
2391 }
2392 }
2393
2394 // ------------------------------------------------------------------------------------------------
2395 void CInterfaceManager::messageBoxInternal(const string &msgBoxGroup, const string &text, const string &masterGroup, TCaseMode caseMode)
2396 {
2397 CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":" + msgBoxGroup));
2398 CViewText *viewText= dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":" + msgBoxGroup + ":text"));
2399
2400 if (group && viewText)
2401 {
2402 viewText->setCaseMode(caseMode);
2403 viewText->setText(text);
2404 CWidgetManager::getInstance()->enableModalWindow(NULL, group);
2405 // don't understand why but need to update coords here
2406 group->updateCoords();
2407 group->updateCoords();
2408 }
2409 }
2410
2411 // ------------------------------------------------------------------------------------------------
2412 void CInterfaceManager::messageBox(const string &text, const string &masterGroup, TCaseMode caseMode)
2413 {
2414 messageBoxInternal("message_box", text, masterGroup, caseMode);
2415 }
2416
2417
2418 // ------------------------------------------------------------------------------------------------
2419 void CInterfaceManager::messageBoxWithHelp(const std::string &text, const std::string &masterGroup,
2420 const std::string &ahOnOk, const std::string &paramsOnOk,
2421 TCaseMode caseMode)
2422 {
2423 // replace the procedure "proc_valid_message_box_ok" action
2424 CWidgetManager::getInstance()->setProcedureAction("proc_message_box_with_help_ok", 1, ahOnOk, paramsOnOk);
2425 const char *mbName = "message_box_with_help";
2426 // if no action handler is wanted, then assume that
2427 // clicking 'ok' do not have any consequence, so allow exiting the message box by clicking
2428 // outside of it (this behavior is wanted on the login page, to allow to reclick on 'login' without
2429 // having to click 'ok' in the message box each time)
2430 CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":" + mbName));
2431 CGroupModal *gm = dynamic_cast<CGroupModal *>(group);
2432 if (gm)
2433 {
2434 gm->ExitClickOut = ahOnOk.empty();
2435 }
2436 messageBoxInternal(mbName, text, masterGroup, caseMode);
2437 }
2438
2439
2440 // ------------------------------------------------------------------------------------------------
2441 void CInterfaceManager::validMessageBox(TValidMessageIcon icon, const std::string &text, const std::string &ahOnOk,
2442 const std::string &paramsOnOk, const std::string &ahOnCancel, const std::string &paramsOnCancel, const string &masterGroup)
2443 {
2444 CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":valid_message_box"));
2445 CViewText *viewText= dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":valid_message_box:text"));
2446 CViewBitmap *viewBitmap= dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":valid_message_box:icon_group:icon"));
2447
2448 if (group && viewText)
2449 {
2450 // replace the procedure "proc_valid_message_box_ok" action
2451 CWidgetManager::getInstance()->setProcedureAction("proc_valid_message_box_ok", 1, ahOnOk, paramsOnOk);
2452 // replace the procedure "proc_valid_message_box_cancel" action
2453 CWidgetManager::getInstance()->setProcedureAction("proc_valid_message_box_cancel", 1, ahOnCancel, paramsOnCancel);
2454
2455 // set text and icon
2456 viewText->setText(text);
2457 if(viewBitmap)
2458 {
2459 bool active= true;
2460 if(icon==QuestionIconMsg)
2461 viewBitmap->setTexture("brick_default.tga");
2462 else if(icon==WarningIconMsg)
2463 viewBitmap->setTexture("W_warning.tga");
2464 else if(icon==ErrorIconMsg)
2465 viewBitmap->setTexture("No_Action.tga");
2466 else
2467 active= false;
2468 viewBitmap->setActive(active);
2469 }
2470
2471 // Go
2472 CWidgetManager::getInstance()->enableModalWindow(NULL, group);
2473 // don't understand why but need to update coords here
2474 group->updateCoords();
2475 group->updateCoords();
2476 }
2477 }
2478
2479
2480 // ------------------------------------------------------------------------------------------------
2481 bool CInterfaceManager::getCurrentValidMessageBoxOnOk(string &ahOnOk, const std::string &masterGroup)
2482 {
2483 // any modal window opened?
2484 CInterfaceGroup *mw= CWidgetManager::getInstance()->getModalWindow();
2485 if(!mw)
2486 return false;
2487
2488 // Is this modal window the valid_message_box window?
2489 CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(masterGroup+":valid_message_box"));
2490 if(mw==group)
2491 {
2492 // Ok, get the current procedure OnOk action
2493 string dummyParams;
2494 if( CWidgetManager::getInstance()->getParser()->getProcedureAction("proc_valid_message_box_ok", 1, ahOnOk, dummyParams))
2495 return true;
2496 }
2497
2498 return false;
2499 }
2500
2501
2502 // ***************************************************************************
2503 void CInterfaceManager::displayDebugInfo(const string &str, TSystemInfoMode mode /*=InfoMsg*/)
2504 {
2505 if (PeopleInterraction.DebugInfo)
2506 PeopleInterraction.ChatInput.DebugInfo.displayMessage(str, getDebugInfoColor(mode), 2);
2507 }
2508
2509 // ***************************************************************************
2510 NLMISC::CRGBA CInterfaceManager::getDebugInfoColor(TSystemInfoMode mode)
2511 {
2512 if (_NeutralColor == NULL) // not initialised ?
2513 {
2514 #define SYSTEM_INFO_COLOR_DB_PATH "UI:VARIABLES:SYSTEM_INFOS:COLORS"
2515 _NeutralColor = NLGUI::CDBManager::getInstance()->getDbProp(SYSTEM_INFO_COLOR_DB_PATH ":NEUTRAL");
2516 _WarningColor = NLGUI::CDBManager::getInstance()->getDbProp(SYSTEM_INFO_COLOR_DB_PATH ":WARNING");
2517 _ErrorColor = NLGUI::CDBManager::getInstance()->getDbProp(SYSTEM_INFO_COLOR_DB_PATH ":ERROR");
2518 }
2519 NLMISC::CRGBA color;
2520 switch(mode)
2521 {
2522 case InfoMsg: color.setPacked(_NeutralColor->getValue32()); break;
2523 case WarningMsg: color.setPacked(_WarningColor->getValue32()); break;
2524 case ErrorMsg: color.setPacked(_ErrorColor->getValue32()); break;
2525 default:
2526 color = CRGBA::White;
2527 break;
2528 }
2529 return color;
2530 }
2531
2532 // ***************************************************************************
2533 void CInterfaceManager::displaySystemInfo(const string &str, const string &cat)
2534 {
2535 CClientConfig::SSysInfoParam::TMode mode = CClientConfig::SSysInfoParam::Normal;
2536 CRGBA color = CRGBA::White;
2537
2538
2539 map<string, CClientConfig::SSysInfoParam>::const_iterator it = ClientCfg.SystemInfoParams.find(toLowerAscii(cat));
2540 if (it != ClientCfg.SystemInfoParams.end())
2541 {
2542 mode = it->second.Mode;
2543 color = it->second.Color;
2544 }
2545
2546 if (mode != CClientConfig::SSysInfoParam::OverOnly && mode != CClientConfig::SSysInfoParam::Around)
2547 {
2548 if (PeopleInterraction.SystemInfo)
2549 PeopleInterraction.ChatInput.SystemInfo.displayMessage(str, color, 2);
2550 else
2551 {
2552 CPeopleInterraction::CSysMsg sysMsg;
2553 sysMsg.Str = str;
2554 sysMsg.Cat = cat;
2555 PeopleInterraction.SystemMessageBuffer.push_back( sysMsg );
2556 }
2557 }
2558
2559 if (mode == CClientConfig::SSysInfoParam::Center || mode == CClientConfig::SSysInfoParam::CenterAround)
2560 InSceneBubbleManager.addMessagePopupCenter(str, color);
2561
2562 // If over popup a string at the bottom of the screen
2563 if ((mode == CClientConfig::SSysInfoParam::Over) || (mode == CClientConfig::SSysInfoParam::OverOnly))
2564 InSceneBubbleManager.addMessagePopup(str, color);
2565 else if ( (mode == CClientConfig::SSysInfoParam::Around || mode == CClientConfig::SSysInfoParam::CenterAround)
2566 && PeopleInterraction.AroundMe.Window)
2567 PeopleInterraction.ChatInput.AroundMe.displayMessage(str, color, 2);
2568 }
2569
2570 // ***************************************************************************
2571 CRGBA CInterfaceManager::getSystemInfoColor(const std::string &cat)
2572 {
2573 CRGBA col = CRGBA::White;
2574 map<string, CClientConfig::SSysInfoParam>::const_iterator it = ClientCfg.SystemInfoParams.find(toLowerAscii(cat));
2575 if (it != ClientCfg.SystemInfoParams.end())
2576 col = it->second.Color;
2577 return col;
2578 }
2579
2580 // ***************************************************************************
2581 void CInterfaceManager::launchContextMenuInGame (const std::string &nameOfCM)
2582 {
2583 // Launch the context menu in-game: can't appear while dragging an item
2584 if (CCtrlDraggable::getDraggedSheet() == NULL)
2585 {
2586 if ( !CWidgetManager::getInstance()->hasModal() )
2587 {
2588 // We must be in-game !
2589 CInterfaceGroup *pMG = CWidgetManager::getInstance()->getMasterGroupFromId("ui:interface");
2590 // TMP nico : try with login screen:
2591 if (!pMG)
2592 {
2593 pMG = CWidgetManager::getInstance()->getMasterGroupFromId("ui:login");
2594 }
2595 if (!pMG)
2596 {
2597 pMG = CWidgetManager::getInstance()->getMasterGroupFromId("ui:outgame");
2598 }
2599 if ((pMG != NULL) && (pMG->getActive()))
2600 {
2601 CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId(nameOfCM);
2602 CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pIE);
2603 if (pIG != NULL)
2604 {
2605 CWidgetManager::getInstance()->enableModalWindow (NULL, pIG);
2606 }
2607 }
2608 }
2609 }
2610 }
2611
2612
2613 // ***************************************************************************
2614 void CInterfaceManager::updateGroupContainerImage(CGroupContainer &gc, uint8 mode)
2615 {
2616 if (mode >= _Modes.size())
2617 {
2618 nlwarning("wrong desktop");
2619 return;
2620 }
2621 _Modes[mode].updateGroupContainerImage(gc);
2622 }
2623
2624 // ***************************************************************************
2625 void CInterfaceManager::removeGroupContainerImage(const std::string &groupName, uint8 mode)
2626 {
2627 if (mode >= _Modes.size())
2628 {
2629 nlwarning("wrong desktop");
2630 return;
2631 }
2632 _Modes[mode].removeGroupContainerImage(groupName);
2633
2634 }
2635
2636 // ***************************************************************************
2637 void CInterfaceManager::removeGroupContainerImageFromDesktops(const std::string &groupName)
2638 {
2639 for (uint i = 0; i < _Modes.size(); i++)
2640 {
2641 _Modes[i].removeGroupContainerImage(groupName);
2642 }
2643 }
2644
2645 // ***************************************************************************
2646 void CInterfaceManager::setMode(uint8 newMode)
2647 {
2648 if (newMode >= _Modes.size())
2649 return;
2650
2651 if (newMode == _CurrentMode)
2652 return;
2653
2654 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
2655
2656 // Check if we can change vdesk !
2657 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2658 {
2659 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2660 if (rMG.Group->getActive())
2661 {
2662 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
2663 {
2664 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2665 list<CInterfaceGroup*>::const_iterator itw;
2666 for (itw = rList.begin(); itw!= rList.end(); itw++)
2667 {
2668 CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(*itw);
2669 if ((pGC != NULL)&&(pGC->getActive()))
2670 {
2671 // if this GC is a Full modal window, or if it is a modal son of another GC,
2672 if (pGC->isModal() || pGC->isModalSon())
2673 {
2674 CWidgetManager::getInstance()->setTopWindow(pGC);
2675 pGC->enableBlink(2);
2676 return;
2677 }
2678 else
2679 if (pGC->isGrayed())
2680 {
2681 // Make the corresponding child blink
2682 pGC->blinkAllSons();
2683 return;
2684 }
2685 }
2686 }
2687 }
2688 }
2689 }
2690
2691 // check if there's a special behaviour with current captured ctrl that prevent from changing desktop
2692 if ( CWidgetManager::getInstance()->getCapturePointerLeft() != NULL)
2693 {
2694 if (!CWidgetManager::getInstance()->getCapturePointerLeft()->canChangeVirtualDesktop()) return;
2695 }
2696 if ( CWidgetManager::getInstance()->getCapturePointerRight() != NULL)
2697 {
2698 if (!CWidgetManager::getInstance()->getCapturePointerRight()->canChangeVirtualDesktop()) return;
2699 }
2700
2701
2702 _Modes[_CurrentMode].fromCurrentDesktop();
2703 _Modes[newMode].toCurrentDesktop();
2704 //CBotChatUI::refreshActiveWindows();
2705
2706 _CurrentMode = newMode;
2707 CWidgetManager::getInstance()->checkCoords();
2708 }
2709
2710 // ***************************************************************************
2711 void CInterfaceManager::resetMode(uint8 newMode)
2712 {
2713 if (newMode >= _Modes.size())
2714 return;
2715 NLMISC::contReset(_Modes[newMode]);
2716 }
2717
2718
2719 // for dump of interface content
2720 struct CDumpedGroup
2721 {
2722 CInterfaceGroup *Group;
2723 uint Depth; // depth in the tree
2724 };
2725
2726 // ***************************************************************************
2727 void CInterfaceManager::dumpUI(bool /* indent */)
2728 {
2729 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
2730 std::vector<CDumpedGroup> left;
2731 left.resize(_MasterGroups.size());
2732 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2733 {
2734 left[nMasterGroup].Group = _MasterGroups[nMasterGroup].Group;
2735 left[nMasterGroup].Depth = 0;
2736 }
2737
2738 while (!left.empty())
2739 {
2740 CInterfaceGroup *ig = left.back().Group;
2741 if (ig)
2742 {
2743 uint currDepth = left.back().Depth;
2744 std::string id = ig->getId();
2745 std::string::size_type pos = id.find_last_of(':');
2746 if (pos != std::string::npos)
2747 {
2748 id = id.substr(pos + 1);
2749 }
2750 std::string info(currDepth * 4, ' ');
2751 info += id;
2752 info += toString(", address=0x%p", ig);
2753 nlinfo(info.c_str());
2754 // dump view & controls for this group
2755 for(uint k = 0; k < ig->getViews().size(); ++k)
2756 {
2757 std::string info(currDepth * 4, ' ');
2758 info += toString("View %d / %d : ", (int) k + 1, (int) ig->getViews().size());
2759 if (ig->getViews()[k])
2760 {
2761 info += id;
2762 NLGUI::CViewBase *view = ig->getViews()[k];
2763 info += toString(", type = %s, address=0x%p", typeid(*view).name(), view);
2764 }
2765 else
2766 {
2767 info += "<NULL>";
2768 }
2769 nlinfo(info.c_str());
2770 }
2771 //
2772 for(uint k = 0; k < ig->getControls().size(); ++k)
2773 {
2774 std::string info(currDepth * 4, ' ');
2775 info += toString("Ctrl %d / %d : ", (int) k + 1, (int) ig->getControls().size());
2776 if (ig->getControls()[k])
2777 {
2778 info += id;
2779 NLGUI::CCtrlBase *control = ig->getControls()[k];
2780 info += toString(", type = %s, address=0x%p", typeid(*control).name(), control);
2781 }
2782 else
2783 {
2784 info += "<NULL>";
2785 }
2786 nlinfo(info.c_str());
2787 }
2788
2789 //
2790 left.pop_back();
2791
2792 for(uint k = 0; k < ig->getNumGroup(); ++k)
2793 {
2794 CDumpedGroup dg;
2795 dg.Group = ig->getGroup(k);
2796 dg.Depth = currDepth + 1;
2797 left.push_back(dg);
2798 }
2799 }
2800 }
2801 }
2802
2803 // ***************************************************************************
2804 void CInterfaceManager::displayUIViewBBoxs(const std::string &uiFilter)
2805 {
2806 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
2807 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2808 {
2809 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2810 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
2811 {
2812 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2813 list<CInterfaceGroup*>::iterator it;
2814 for(it = rList.begin(); it != rList.end(); ++it)
2815 {
2816 if (*it) (*it)->renderWiredQuads(CInterfaceElement::RenderView, uiFilter);
2817 }
2818 }
2819 }
2820 }
2821
2822 // ***************************************************************************
2823 void CInterfaceManager::displayUICtrlBBoxs(const std::string &uiFilter)
2824 {
2825 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
2826 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2827 {
2828 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2829 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
2830 {
2831 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2832 list<CInterfaceGroup*>::iterator it;
2833 for(it = rList.begin(); it != rList.end(); ++it)
2834 {
2835 if (*it) (*it)->renderWiredQuads(CInterfaceElement::RenderCtrl, uiFilter);
2836 }
2837 }
2838 }
2839 }
2840
2841 // ***************************************************************************
2842 void CInterfaceManager::displayUIGroupBBoxs(const std::string &uiFilter)
2843 {
2844 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
2845 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
2846 {
2847 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
2848 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
2849 {
2850 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
2851 list<CInterfaceGroup*>::iterator it;
2852 for(it = rList.begin(); it != rList.end(); ++it)
2853 {
2854 if (*it) (*it)->renderWiredQuads(CInterfaceElement::RenderGroup, uiFilter);
2855 }
2856 }
2857 }
2858 }
2859
2860 // ***************************************************************************
2861 void writeComboActionMap (const CActionsManager &actions, xmlNodePtr node, const string &context)
2862 {
2863 // Get the combo defined
2864 const CActionsManager::TComboActionMap &combos = actions.getComboActionMap ();
2865 CActionsManager::TComboActionMap::const_iterator ite = combos.begin ();
2866 while (ite != combos.end ())
2867 {
2868 // Key node
2869 xmlNodePtr keyNode = xmlNewChild ( node, NULL, (const xmlChar*)"key", NULL );
2870
2871 // Props
2872 xmlSetProp (keyNode, (const xmlChar*)"name", (const xmlChar*)CEventKey::getStringFromKey(ite->first.Key).c_str());
2873
2874 if (ite->first.KeyButtons&shiftKeyButton)
2875 xmlSetProp (keyNode, (const xmlChar*)"shift", (const xmlChar*)"1");
2876 if (ite->first.KeyButtons&ctrlKeyButton)
2877 xmlSetProp (keyNode, (const xmlChar*)"ctrl", (const xmlChar*)"1");
2878 if (ite->first.KeyButtons&altKeyButton)
2879 xmlSetProp (keyNode, (const xmlChar*)"menu", (const xmlChar*)"1");
2880
2881 xmlSetProp (keyNode, (const xmlChar*)"action", (const xmlChar*)ite->second.Name.c_str());
2882 if (!(const xmlChar*)ite->second.Argu.empty())
2883 xmlSetProp (keyNode, (const xmlChar*)"params", (const xmlChar*)ite->second.Argu.c_str());
2884
2885 // Context
2886 if (!context.empty ())
2887 xmlSetProp (keyNode, (const xmlChar*)"context", (const xmlChar*)context.c_str());
2888
2889 ite++;
2890 }
2891 }
2892
2893 // ***************************************************************************
2894
2895 void writeMacros (xmlNodePtr node)
2896 {
2897 const std::vector<CMacroCmd> &macros = CMacroCmdManager::getInstance()->getMacros();
2898 for (uint i = 0; i < macros.size(); ++i)
2899 {
2900 macros[i].writeTo(node);
2901 }
2902 }
2903
2904 // ***************************************************************************
2905 bool CInterfaceManager::saveKeys(bool verbose)
2906 {
2907 bool ret = true;
2908
2909 if (!ClientCfg.R2EDEnabled)
2910 {
2911 string filename = "save/keys_" + PlayerSelectedFileName + ".xml";
2912 if (!CFile::fileExists(filename) && CFile::fileExists("save/shared_keys.xml"))
2913 filename = "save/shared_keys.xml";
2914
2915 if (verbose) CInterfaceManager::getInstance()->displaySystemInfo("Saving " + filename);
2916
2917 ret = saveKeys(filename);
2918 }
2919
2920 return ret;
2921 }
2922
2923 // ***************************************************************************
2924 bool CInterfaceManager::saveKeys(const std::string &filename)
2925 {
2926 bool ret = false;
2927
2928 try
2929 {
2930 COFile file;
2931 // using temporary file, so no file.close() unless its a success
2932 if (file.open (filename, false, false, true))
2933 {
2934 COXml xmlStream;
2935 xmlStream.init (&file);
2936
2937 xmlDocPtr doc = xmlStream.getDocument ();
2938 xmlNodePtr node = xmlNewDocNode(doc, NULL, (const xmlChar*)"interface_config", NULL);
2939 xmlDocSetRootElement (doc, node);
2940
2941 writeComboActionMap (Actions, node, "");
2942 writeComboActionMap (EditActions, node, RZ_CATEGORY_EDIT);
2943
2944 writeMacros (node);
2945
2946 // Flush the stream
2947 xmlStream.flush();
2948
2949 // Close the stream
2950 file.close ();
2951
2952 // Done
2953 ret = true;
2954 }
2955 else
2956 {
2957 nlwarning ("Can't open the file %s", filename.c_str());
2958 }
2959 }
2960 catch (const Exception &e)
2961 {
2962 nlwarning ("Error while writing the file %s : %s.", filename.c_str(), e.what ());
2963 }
2964 return ret;
2965 }
2966
2967 // ***************************************************************************
2968 bool CInterfaceManager::deletePlayerConfig (const std::string &playerFileIdent)
2969 {
2970 string fileName= "save/interface_" + playerFileIdent + ".icfg";
2971 return CFile::deleteFile(fileName);
2972 }
2973
2974
2975 // ***************************************************************************
2976 bool CInterfaceManager::deletePlayerKeys (const std::string &playerFileIdent)
2977 {
2978 string fileName = "save/keys_"+playerFileIdent+".xml";
2979 string fileNameEditor = "save/keys_r2ed_"+playerFileIdent+".xml";
2980 return CFile::deleteFile(fileName) && CFile::deleteFile(fileNameEditor);
2981 }
2982
2983 // ***************************************************************************
2984 void CInterfaceManager::log(const std::string &str, const std::string &cat)
2985 {
2986 if (_LogState)
2987 {
2988 // Open file with the name of the player
2989 const string fileName= "save/log_" + PlayerSelectedFileName + ".txt";
2990 FILE *f = nlfopen(fileName, "at");
2991 if (f != NULL)
2992 {
2993 const string finalString = string(NLMISC::IDisplayer::dateToHumanString()) + " (" + NLMISC::toUpperAscii(cat) + ") * " + str;
2994 fprintf(f, "%s\n", finalString.c_str());
2995 fclose(f);
2996 }
2997 }
2998 }
2999
3000 // ***************************************************************************
3001 void CInterfaceManager::clearAllEditBox()
3002 {
3003 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
3004 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
3005 {
3006 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
3007 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
3008 {
3009 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
3010 list<CInterfaceGroup*>::iterator it;
3011 for(it = rList.begin(); it != rList.end(); ++it)
3012 {
3013 CInterfaceGroup *pIG = *it;
3014 if (pIG != NULL)
3015 pIG->clearAllEditBox();
3016 }
3017 }
3018 }
3019 }
3020
3021 // ***************************************************************************
3022 void CInterfaceManager::restoreAllContainersBackupPosition()
3023 {
3024 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
3025 for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
3026 {
3027 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
3028 for (uint8 nPriority=0; nPriority < WIN_PRIORITY_MAX; ++nPriority)
3029 {
3030 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
3031 list<CInterfaceGroup*>::iterator it;
3032 for(it = rList.begin(); it != rList.end(); ++it)
3033 {
3034 if (*it) (*it)->restoreAllContainersBackupPosition();
3035 }
3036 }
3037 }
3038 }
3039
3040 // ***************************************************************************
3041 void CInterfaceManager::visit(CInterfaceElementVisitor *visitor)
3042 {
3043 nlassert(visitor);
3044 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
3045 for (uint nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
3046 {
3047 if (_MasterGroups[nMasterGroup].Group)
3048 {
3049 _MasterGroups[nMasterGroup].Group->visit(visitor);
3050 }
3051 }
3052 }
3053
3054 // ***************************************************************************
3055 void CInterfaceManager::incLocalSyncActionCounter()
3056 {
3057 _LocalSyncActionCounter++;
3058 }
3059
3060
3061
3062 #if !FINAL_VERSION
3063
3064 // ***************************************************************************
3065 NLMISC_COMMAND( localCounter, "Get value of local counter", "" )
3066 {
3067 if (args.size() != 0) return false;
3068 CInterfaceManager *im = CInterfaceManager::getInstance();
3069 im->displaySystemInfo(toString(im->getLocalSyncActionCounter()));
3070 return true;
3071 }
3072
3073 #endif
3074
3075 // ***************************************************************************
3076
3077 NLMISC_COMMAND(loadui, "Load an interface file", "<loadui [all]/interface.xml>")
3078 {
3079 if (args.size() != 1)
3080 return false;
3081
3082 CInterfaceManager *im = CInterfaceManager::getInstance();
3083
3084 std::vector<std::string> xmlFileNames;
3085
3086 if (args[0] == "all")
3087 xmlFileNames = CInterfaceManager::getInGameXMLInterfaceFiles();
3088 else
3089 xmlFileNames.push_back (args[0]);
3090
3091 bool result = im->parseInterface (xmlFileNames, true);
3092 #if !FINAL_VERSION
3093 if (result)
3094 CInterfaceManager::getInstance()->displaySystemInfo("File "+xmlFileNames.back()+" loaded successfully.");
3095 else
3096 CInterfaceManager::getInstance()->displaySystemInfo("File "+xmlFileNames.back()+" NOT loaded successully.");
3097 #endif
3098
3099 // Invalidate the texts
3100 CWidgetManager::getInstance()->updateAllLocalisedElements();
3101
3102 // reset captures
3103 CWidgetManager::getInstance()->setCapturePointerLeft(NULL);
3104 CWidgetManager::getInstance()->setCapturePointerRight(NULL);
3105 CWidgetManager::getInstance()->setOldCaptureKeyboard(NULL);
3106 CWidgetManager::getInstance()->setCaptureKeyboard(NULL);
3107
3108 return result;
3109 }
3110
3111 // ***************************************************************************
3112 void CInterfaceManager::displayWebWindow(const string & name, const string & url)
3113 {
3114 CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(name));
3115 if (pIG != NULL)
3116 {
3117 pIG->setActive(true);
3118 pIG->updateCoords();
3119 pIG->center();
3120 }
3121
3122 CAHManager::getInstance()->runActionHandler("browse", NULL, "name="+name+":content:html|url="+url);
3123 }
3124
3125 // ***************************************************************************
3126 class CAHSaveUI : public IActionHandler
3127 {
3128 virtual void execute (CCtrlBase *pCaller, const string &Params)
3129 {
3130 CInterfaceManager::getInstance()->saveKeys(true);
3131 CInterfaceManager::getInstance()->saveConfig(true);
3132 }
3133 };
3134 REGISTER_ACTION_HANDLER (CAHSaveUI, "save_ui");
3135
3136 /*
3137 // ***************************************************************************
3138 class CHandlerDispWebOnQuit : public IActionHandler
3139 {
3140 virtual void execute (CCtrlBase *pCaller, const string &Params)
3141 {
3142 if (ClientCfg.Local)
3143 CAHManager::getInstance()->runActionHandler("enter_modal", pCaller, "group=ui:interface:quit_dialog");
3144 else
3145 CInterfaceManager::getInstance()->displayWebWindow("ui:interface:web_on_quit", "http://213.208.119.190/igpoll/poll_form.php");
3146 }
3147 };
3148 REGISTER_ACTION_HANDLER (CHandlerDispWebOnQuit, "disp_web_on_quit");
3149
3150 // ***************************************************************************
3151 class CHandlerExitWebOnQuit : public IActionHandler
3152 {
3153 virtual void execute (CCtrlBase *pCaller, const string &Params)
3154 {
3155 CAHManager::getInstance()->runActionHandler("quit_ryzom", pCaller);
3156 }
3157 };
3158 REGISTER_ACTION_HANDLER (CHandlerExitWebOnQuit, "exit_web_on_quit");
3159 */
3160
3161 // ***************************************************************************
3162 // EMOTES
3163 // ***************************************************************************
3164
3165 struct CEmoteEntry
3166 {
3167 uint32 EmoteId;
3168 string Path;
3169 string Anim;
3170 bool UsableFromClientUI;
3171
3172 bool operator< (const CEmoteEntry & entry) const
3173 {
3174 string path1 = Path;
3175 string path2 = entry.Path;
3176
3177 for(;;)
3178 {
3179 string::size_type pos1 = path1.find('|');
3180 string::size_type pos2 = path2.find('|');
3181
3182 string s1 = toUpper(CI18N::get(path1.substr(0, pos1)));
3183 string s2 = toUpper(CI18N::get(path2.substr(0, pos2)));
3184
3185 sint result = s1.compare(s2);
3186 if (result != 0)
3187 return (result < 0);
3188
3189 if (pos1 == string::npos)
3190 return (pos2 != string::npos);
3191 if (pos2 == string::npos)
3192 return false;
3193
3194 path1 = path1.substr(pos1 + 1);
3195 path2 = path2.substr(pos2 + 1);
3196 }
3197 return false;
3198 }
3199 };
3200
3201 static bool translateEmote(const std::string &id, std::string &translatedName, std::string &commandName, std::string &commandNameAlt)
3202 {
3203 if (CI18N::hasTranslation(id))
3204 {
3205 translatedName = CI18N::get(id);
3206
3207 // convert command to utf8 since emote translation can have strange chars
3208 commandName = toLower(translatedName);
3209
3210 // replace all spaces by _
3211 while (strFindReplace(commandName, " ", "_"));
3212
3213 // TODO: remove accents
3214 commandNameAlt = commandName;
3215
3216 if (commandNameAlt == commandName) commandNameAlt.clear();
3217
3218 return true;
3219 }
3220
3221 translatedName = id;
3222 commandName = id;
3223
3224 return false;
3225 }
3226
3227 // ***************************************************************************
3228 void CInterfaceManager::initEmotes()
3229 {
3230 _EmotesInitialized = true;
3231 CTextEmotListSheet *pTELS = dynamic_cast<CTextEmotListSheet*>(SheetMngr.get(CSheetId("list.text_emotes")));
3232 if (pTELS == NULL)
3233 return;
3234
3235 static list<CEmoteEntry> entries;
3236 if (entries.empty())
3237 {
3238 for (uint i = 0; i < pTELS->TextEmotList.size(); i++)
3239 {
3240 CEmoteEntry entry;
3241 entry.EmoteId = i;
3242 entry.Path = pTELS->TextEmotList[i].Path;
3243 entry.Anim = pTELS->TextEmotList[i].Anim;
3244 entry.UsableFromClientUI = pTELS->TextEmotList[i].UsableFromClientUI;
3245 entries.push_back(entry);
3246 }
3247 entries.sort();
3248 }
3249
3250 // The list of behaviour missnames emotList
3251 CEmotListSheet *pEmotList = dynamic_cast<CEmotListSheet*>(SheetMngr.get(CSheetId("list.emot")));
3252 nlassert (pEmotList != NULL);
3253 nlassert (pEmotList->Emots.size() <= 255);
3254
3255 // Get the focus beta tester flag
3256 bool betaTester = false;
3257
3258 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3259 CSkillManager *pSM = CSkillManager::getInstance();
3260
3261 betaTester = pSM->isTitleUnblocked(CHARACTER_TITLE::FBT);
3262 string previousMind;
3263 CGroupSubMenu *pFirstMenu = 0;
3264
3265 for (list<CEmoteEntry>::const_iterator it = entries.begin(); it != entries.end(); it++)
3266 {
3267 uint32 nEmoteNb = (*it).EmoteId;
3268 string sState = (*it).Anim;
3269 string sName = (*it).Path;
3270
3271 // Check that the emote can be added to UI
3272 // ---------------------------------------
3273 if( (*it).UsableFromClientUI == false )
3274 {
3275 continue;
3276 }
3277
3278 // Check the emote reserved for FBT (hardcoded)
3279 // --------------------------------------------
3280 if (sState == "FBT" && !betaTester)
3281 continue;
3282
3283 // Get the behaviour from the list of emotes
3284 // -----------------------------------------
3285 uint8 nBehav = 255;
3286 uint32 i, j;
3287 for (i = 0; i < pEmotList->Emots.size(); ++i)
3288 if (CAnimationStateSheet::getAnimationStateName(pEmotList->Emots[i]) == sState)
3289 {
3290 nBehav = (uint8)i;
3291 break;
3292 }
3293
3294 // Add to the game context menu
3295 // ----------------------------
3296 uint32 nbToken = 1;
3297 for (i = 0; i < sName.size(); ++i)
3298 if (sName[i] == '|')
3299 nbToken++;
3300
3301 CGroupMenu *pRootMenu = dynamic_cast<CGroupMenu*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:user_chat_emote_menu"));
3302 nlassert(pRootMenu);
3303
3304 CGroupSubMenu *pMenu = pRootMenu->getRootMenu();
3305 nlassert(pMenu);
3306
3307 std::string sTranslatedName;
3308 std::string sCommandName;
3309 std::string sCommandNameAlt;
3310
3311 // Add to the game context menu
3312 // ----------------------------
3313 for (i = 0; i < nbToken; ++i)
3314 {
3315 string sTmp;
3316 if (i != (nbToken-1))
3317 sTmp = sName.substr(0,sName.find('|'));
3318 else
3319 sTmp = sName;
3320
3321 // Look if this part of the path is already present
3322 bool bFound = false;
3323 for (j = 0; j < pMenu->getNumLine(); ++j)
3324 {
3325 if (sTmp == pMenu->getLineId(j))
3326 {
3327 bFound = true;
3328 break;
3329 }
3330 }
3331
3332
3333 if (!bFound) // Create it
3334 {
3335 if (i != (nbToken-1))
3336 {
3337 pMenu->addLine (CI18N::get(sTmp), "", "", sTmp);
3338
3339 // Create a sub menu
3340 CGroupSubMenu *pNewSubMenu = new CGroupSubMenu(CViewBase::TCtorParam());
3341 pMenu->setSubMenu(j, pNewSubMenu);
3342
3343 if (pFirstMenu == 0)
3344 pFirstMenu = pNewSubMenu;
3345 }
3346 else
3347 {
3348 translateEmote(sTmp, sTranslatedName, sCommandName, sCommandNameAlt);
3349
3350 // Create a line
3351 pMenu->addLine (sTranslatedName + " (/" + sCommandName + ")", "emote",
3352 "nb="+toString(nEmoteNb)+"|behav="+toString(nBehav), sTmp);
3353 }
3354 }
3355
3356 // Jump to sub menu
3357 if (i != (nbToken-1))
3358 {
3359 pMenu = pMenu->getSubMenu(j);
3360 sName = sName.substr(sName.find('|')+1,sName.size());
3361 }
3362 }
3363
3364 if (sTranslatedName.empty())
3365 translateEmote(sName, sTranslatedName, sCommandName, sCommandNameAlt);
3366
3367 // Create new command
3368 // ------------------
3369 if (!sTranslatedName.empty())
3370 {
3371 if(ICommand::exists(sCommandName))
3372 {
3373 nlwarning("Translation for emote %s already exist: '%s' exist twice", sName.c_str(), sCommandName.c_str());
3374 }
3375 else
3376 {
3377 CEmoteCmd *pNewCmd = new CEmoteCmd(sCommandName.c_str(), "", "");
3378 pNewCmd->EmoteNb = nEmoteNb;
3379 pNewCmd->Behaviour = nBehav;
3380 _EmoteCmds.push_back(pNewCmd);
3381
3382 // add alternative command if defined
3383 if (!sCommandNameAlt.empty())
3384 {
3385 if(ICommand::exists(sCommandNameAlt))
3386 {
3387 nlwarning("Translation for emote %s already exist: '%s' exist twice", sName.c_str(), sCommandName.c_str());
3388 }
3389 else
3390 {
3391 CEmoteCmd *pNewCmd = new CEmoteCmd(sCommandNameAlt.c_str(), "", "");
3392 pNewCmd->EmoteNb = nEmoteNb;
3393 pNewCmd->Behaviour = nBehav;
3394 _EmoteCmds.push_back(pNewCmd);
3395 }
3396 }
3397
3398 CGroupSubMenu *pMenu = pRootMenu->getRootMenu();
3399
3400 // Quick-Emote too ?
3401 for (i = 0; i< pMenu->getNumLine (); i++)
3402 {
3403 if (sName == pMenu->getLineId (i))
3404 {
3405 // Yeah that's a quick emote too; set command
3406 pMenu->addLineAtIndex (i,
3407 "@{FFFF}/" + sCommandName,
3408 "emote", "nb="+toString(nEmoteNb)+"|behav="+toString(nBehav),
3409 "", "", "", false, false, true);
3410
3411 pMenu->removeLine (i+1);
3412 break;
3413 }
3414 }
3415 }
3416 }
3417 else
3418 {
3419 nlwarning("No translation for emote %s", sName.c_str());
3420 }
3421 }
3422
3423 // Insert separators
3424 if (pFirstMenu)
3425 {
3426 pFirstMenu->addSeparatorAtIndex (0, "Positive");
3427 pFirstMenu->addSeparatorAtIndex (4, "Neutral");
3428 pFirstMenu->addSeparatorAtIndex (8, "Negative");
3429 }
3430
3431 }
3432
3433 // ***************************************************************************
3434 void CInterfaceManager::uninitEmotes()
3435 {
3436 if( !_EmotesInitialized )
3437 return;
3438 _EmotesInitialized = false;
3439
3440 // reset the emotes menu
3441 CTextEmotListSheet *pTELS = dynamic_cast<CTextEmotListSheet*>(SheetMngr.get(CSheetId("list.text_emotes")));
3442 if (pTELS != NULL && !pTELS->TextEmotList.empty())
3443 {
3444 // get the emotes menu id
3445 string sPath = pTELS->TextEmotList[0].Path;
3446 string sId = sPath.substr(0, sPath.find('|'));
3447
3448 // get the emotes menu
3449 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3450 CGroupMenu *pRootMenu = dynamic_cast<CGroupMenu*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:game_context_menu"));
3451 if( pRootMenu )
3452 {
3453 CGroupSubMenu *pMenu = pRootMenu->getRootMenu();
3454 for (uint i = 0; i < pMenu->getNumLine(); ++i)
3455 {
3456 if (pMenu->getLineId(i) == sId)
3457 {
3458 pMenu = pMenu->getSubMenu(i);
3459 pMenu->reset();
3460 break;
3461 }
3462 }
3463 }
3464 }
3465
3466 // clear commands
3467 for (uint32 i = 0; i < _EmoteCmds.size(); ++i)
3468 delete _EmoteCmds[i];
3469 _EmoteCmds.clear();
3470 }
3471
3472 // ***************************************************************************
3473 void CInterfaceManager::updateEmotes()
3474 {
3475 uninitEmotes();
3476 initEmotes();
3477 }
3478
3479 // ***************************************************************************
3480 // Just call the action handler with good params
3481 bool CInterfaceManager::CEmoteCmd::execute(const std::string &/* rawCommandString */, const vector<string> &args, CLog &/* log */, bool /* quiet */, bool /* human */)
3482 {
3483 string customPhrase;
3484 if (!args.empty())
3485 {
3486 customPhrase = args[0];
3487 }
3488 for(uint i = 1; i < args.size(); ++i )
3489 {
3490 customPhrase += " ";
3491 customPhrase += args[i];
3492 }
3493 CAHManager::getInstance()->runActionHandler("emote", NULL, "nb="+toString(EmoteNb)+"|behav="+toString(Behaviour)+"|custom_phrase="+customPhrase);
3494 return true;
3495 }
3496
3497 // ***************************************************************************
3498 bool CInterfaceManager::testDragCopyKey()
3499 {
3500 // hardcoded for now
3501 return Driver->AsyncListener.isKeyDown(KeyCONTROL) ||
3502 Driver->AsyncListener.isKeyDown(KeyLCONTROL) ||
3503 Driver->AsyncListener.isKeyDown(KeyRCONTROL);
3504 }
3505
3506 // ***************************************************************************
3507 void CInterfaceManager::notifyMailAvailable()
3508 {
3509 if (_CheckMailNode != NULL)
3510 _CheckMailNode->setValue32(1);
3511 }
3512
3513 void CInterfaceManager::notifyForumUpdated()
3514 {
3515 if (_CheckForumNode != NULL)
3516 _CheckForumNode->setValue32(1);
3517 }
3518
3519 void CInterfaceManager::queueLuaScript(const std::string &script)
3520 {
3521 CAutoMutex<CMutex> autoMutex(_ScriptQueueMutex);
3522
3523 _ScriptQueue.push(script);
3524 }
3525
3526 void CInterfaceManager::flushScriptQueue()
3527 {
3528 CAutoMutex<CMutex> autoMutex(_ScriptQueueMutex);
3529
3530 while(!_ScriptQueue.empty())
3531 {
3532 CLuaManager::getInstance().executeLuaScript(_ScriptQueue.front());
3533 _ScriptQueue.pop();
3534 }
3535 }
3536
3537
3538 // ***************************************************************************
3539 void CInterfaceManager::resetTextIndex()
3540 {
3541 uint32 nMasterGroup;
3542 std::vector< CWidgetManager::SMasterGroup > &_MasterGroups = CWidgetManager::getInstance()->getAllMasterGroup();
3543 for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
3544 {
3545 CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
3546
3547 InvalidateTextVisitor inv( true );
3548 rMG.Group->visitGroupAndChildren( &inv );
3549 for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
3550 {
3551 list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
3552 list<CInterfaceGroup*>::const_iterator itw;
3553 for (itw = rList.begin(); itw != rList.end(); itw++)
3554 {
3555 CInterfaceGroup *pIG = *itw;
3556 pIG->visitGroupAndChildren( &inv );
3557 }
3558 }
3559 }
3560 }
3561
3562 // ***************************************************************************
3563 CInterfaceElement *getInterfaceResource(const std::string &key)
3564 {
3565 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3566 return CWidgetManager::getInstance()->getElementFromId (key);
3567 }
3568
3569 // ***************************************************************************
3570 std::vector<std::string> CInterfaceManager::getInGameXMLInterfaceFiles()
3571 {
3572 // Original Files
3573 vector<string> ret;
3574 ret= ClientCfg.XMLInterfaceFiles;
3575
3576 // Resolve any conflict (with CPath scheme, AddOn Should take the precedence)
3577 // But still preserve order given in XMLInterfaceFiles (important for config.xml for instance)
3578 set<string> fileSet;
3579 for(uint i=0;i<ret.size();i++)
3580 {
3581 fileSet.insert(ret[i]);
3582 }
3583
3584 // Add R2 Editor .xml. This is removed as it will not be done when initializing CEditor
3585 // if (ClientCfg.R2EDEnabled)
3586 // {
3587 // // Add them to 'ret', only if not already inserted
3588 // // since parser will crash on any duplicates
3589 // for(uint i=0;i<ClientCfg.XMLR2EDInterfaceFiles.size();i++)
3590 // {
3591 // if(fileSet.find(ClientCfg.XMLR2EDInterfaceFiles[i])==fileSet.end())
3592 // {
3593 // fileSet.insert(ClientCfg.XMLR2EDInterfaceFiles[i]);
3594 // ret.push_back(ClientCfg.XMLR2EDInterfaceFiles[i]);
3595 // }
3596 // }
3597 // }
3598
3599 // Get Addons .xml
3600 vector<string> adds;
3601 InterfaceAddOnManager.getFiles("*.xml", adds);
3602
3603 // Add them to 'ret', only if not already inserted
3604 for(uint i=0;i<adds.size();i++)
3605 {
3606 if(fileSet.find(adds[i])==fileSet.end())
3607 {
3608 fileSet.insert(adds[i]);
3609 ret.push_back(adds[i]);
3610 }
3611 }
3612
3613 return ret;
3614 }
3615
3616 // ***************************************************************************
3617 void CInterfaceManager::dumpLuaString(const std::string &str)
3618 {
3619 nlinfo(str.c_str());
3620 displaySystemInfo(LuaHelperStuff::formatLuaErrorSysInfo(str));
3621 }
3622
3623 // ***************************************************************************
3624 void CInterfaceManager::getLuaValueInfo(std::string &str, sint index)
3625 {
3626 CLuaState &ls= *( CLuaManager::getInstance().getLuaState() );
3627
3628 sint type= ls.type(index);
3629 if(type==LUA_TNIL)
3630 {
3631 str= "nil";
3632 }
3633 else if(type==LUA_TNUMBER)
3634 {
3635 str= NLMISC::toString(ls.isInteger(index) ? ls.toInteger(index):ls.toNumber(index));
3636 }
3637 else if(type==LUA_TBOOLEAN)
3638 {
3639 str= ls.toBoolean(index)?"true":"false";
3640 }
3641 else if(type==LUA_TSTRING)
3642 {
3643 ls.toString(index, str);
3644 str= toString("'") + str + toString("'");
3645 }
3646 else
3647 {
3648 str= ls.getTypename(type);
3649 str+= ":";
3650 str+= NLMISC::toString("%p", ls.toPointer(index));
3651 // If its a table, append the size.
3652 if(type==LUA_TTABLE)
3653 {
3654 ls.pushNil(); // first key
3655 uint count= 0;
3656 while (ls.next(index-1))
3657 {
3658 ls.pop(); // remove 'value'; keeps `key' for next iteration
3659 count++;
3660 }
3661 str+= NLMISC::toString(" (size=%d)", count);
3662 }
3663 // If its a Userdata, try to display UI info
3664 else if(type==LUA_TUSERDATA)
3665 {
3666 if(CLuaIHM::isUIOnStack(ls, index))
3667 {
3668 CInterfaceElement *ui= CLuaIHM::getUIOnStack(ls, index);
3669 str+= NLMISC::toString(" (ui=%p)", ui);
3670 }
3671 }
3672 }
3673 }
3674
3675 // ***************************************************************************
3676 void CInterfaceManager::dumpLuaKeyValueInfo(uint recursTableLevel, uint tabLevel)
3677 {
3678 CLuaState &ls= *( CLuaManager::getInstance().getLuaState() );
3679 CLuaStackChecker lsc(&ls);
3680
3681 // Dump Key Str
3682 string key;
3683 getLuaValueInfo(key, -2);
3684 // Dump Value Str
3685 string value;
3686 getLuaValueInfo(value, -1);
3687
3688 // display.
3689 string res;
3690 // append tab for table hierarchy
3691 for(uint i=0;i<tabLevel;i++)
3692 res+= " ";
3693 // display key and value
3694 res+= key + " == " + value;
3695 dumpLuaString(res);
3696
3697 // If the value is a table, and can recurs dumping
3698 if(recursTableLevel>0 && ls.type(-1)==LUA_TTABLE)
3699 {
3700 ls.pushNil(); // first key
3701 while (ls.next(-2))
3702 {
3703 // display the key value pair of this table (recurs)
3704 dumpLuaKeyValueInfo(recursTableLevel-1, tabLevel+1);
3705 ls.pop(); // remove 'value'; keeps `key' for next iteration
3706 }
3707 }
3708
3709 }
3710
3711 // ***************************************************************************
3712 void CInterfaceManager::dumpLuaState(uint detail)
3713 {
3714 CLuaState *_LuaState = CLuaManager::getInstance().getLuaState();
3715
3716 // clamp detailed info to 2 (display at max content of eaxh Env of each group)
3717 clamp(detail, 0U, 2U);
3718
3719 // Dump the Memory State
3720 dumpLuaString(NLMISC::toString("Memory Used : %d Kb", _LuaState->getGCCount()));
3721 dumpLuaString(NLMISC::toString("GC Threshold: %d Kb", _LuaState->getGCThreshold()));
3722
3723 // If want to display some detailed info
3724 if(detail>0)
3725 {
3726 CLuaState &ls= *_LuaState;
3727 CLuaStackChecker lsc(&ls);
3728
3729 // *** Dump all Lua Env Tables
3730 ls.push(IHM_LUA_ENVTABLE);
3731 ls.getTable(LUA_REGISTRYINDEX); // __ui_envtable
3732 ls.pushNil(); // first key
3733 uint count= 0;
3734 while (ls.next(-2))
3735 {
3736 // `key' is at index -2 and `value' at index -1
3737 dumpLuaKeyValueInfo(detail-1, 1);
3738 ls.pop(); // remove 'value'; keeps `key' for next iteration
3739 count++;
3740 }
3741 // pop table
3742 ls.pop();
3743
3744 dumpLuaString(NLMISC::toString("Number of EnvTable for ui groups: %d", count));
3745 }
3746 }
3747
3748 // ------------------------------------------------------------------------------------------------
3749 void CInterfaceManager::createLocalBranch(const std::string &fileName, NLMISC::IProgressCallback &progressCallBack)
3750 {
3751 try
3752 {
3753 CIFile file;
3754 if (file.open (fileName))
3755 {
3756 // Init an xml stream
3757 CIXml read;
3758 read.init (file);
3759
3760 //Parse the parser output!!!
3761 CCDBNodeBranch *localNode = new CCDBNodeBranch("LOCAL");
3762 localNode->init( read.getRootNode (), progressCallBack );
3763 NLGUI::CDBManager::getInstance()->getDB()->attachChild(localNode,"LOCAL");
3764
3765 // Create the observers for auto-copy SERVER->LOCAL of inventory
3766 ServerToLocalAutoCopyInventory.init("INVENTORY");
3767
3768 // Create the observers for auto-copy SERVER->LOCAL of exchange
3769 ServerToLocalAutoCopyExchange.init("EXCHANGE");
3770
3771 // Create the observers for auto-copy SERVER->LOCAL of dm (animator) gift
3772 ServerToLocalAutoCopyDMGift.init("DM_GIFT");
3773
3774 // Create the observers for auto-copy SERVER->LOCAL of context menu
3775 ServerToLocalAutoCopyContextMenu.init("TARGET:CONTEXT_MENU");
3776
3777 // Create the observers for auto-copy SERVER->LOCAL of Skill Points
3778 ServerToLocalAutoCopySkillPoints.init("USER");
3779 }
3780 }
3781 catch (const Exception &e)
3782 {
3783 // Output error
3784 nlwarning ("CFormLoader: Error while loading the form %s: %s", fileName.c_str(), e.what());
3785 }
3786 }
3787
3788 // ------------------------------------------------------------------------------------------------
3789 #ifdef NL_OS_WINDOWS
3790 # pragma warning (push)
3791 # pragma warning (disable : 4355) // 'this' used in base member initializer list
3792 #endif
3793 CInterfaceManager::CServerToLocalAutoCopy::CServerToLocalAutoCopy() : _LocalObserver(*this), _ServerObserver(*this)
3794 {
3795 _ServerCounter= NULL;
3796 _UpdateList.reserve(300);
3797 _LocalUpdating= false;
3798 }
3799 #ifdef NL_OS_WINDOWS
3800 # pragma warning (pop)
3801 #endif
3802
3803 // ------------------------------------------------------------------------------------------------
3804 // unhook from everything we are tangled up in
3805 void CInterfaceManager::CServerToLocalAutoCopy::release()
3806 {
3807 _Nodes.clear();
3808 _ServerCounter = NULL;
3809 _ServerNodeMap.clear();
3810 _LocalNodeMap.clear();
3811 _UpdateList.clear();
3812 }
3813
3814 // ------------------------------------------------------------------------------------------------
3815 void CInterfaceManager::CServerToLocalAutoCopy::buildRecursLocalLeaves(CCDBNodeBranch *branch, std::vector<CCDBNodeLeaf*> &leaves)
3816 {
3817 for(uint i=0;i<branch->getNbNodes();i++)
3818 {
3819 ICDBNode *node= branch->getNode(i);
3820 if(node)
3821 {
3822 CCDBNodeLeaf *leaf= dynamic_cast<CCDBNodeLeaf*>(node);
3823 if(leaf)
3824 {
3825 // just append to list
3826 leaves.push_back(leaf);
3827 }
3828 else
3829 {
3830 // recurs if a branch (should be...)
3831 CCDBNodeBranch *sonBranch= dynamic_cast<CCDBNodeBranch*>(node);
3832 if(sonBranch)
3833 buildRecursLocalLeaves(sonBranch, leaves);
3834 }
3835 }
3836 }
3837 }
3838
3839 // ------------------------------------------------------------------------------------------------
3840 void CInterfaceManager::CServerToLocalAutoCopy::init(const std::string &dbPath)
3841 {
3842 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3843
3844 // Get the synchronisation Counter in Server DB
3845 _ServerCounter= NLGUI::CDBManager::getInstance()->getDbProp(string("SERVER:") + dbPath + ":COUNTER", false);
3846
3847 // if found
3848 if(_ServerCounter)
3849 {
3850 ICDBNode::CTextId textId;
3851
3852 // **** Add Observers on all nodes
3853 // add the observers when server node change
3854 textId = ICDBNode::CTextId( string("SERVER:") + dbPath );
3855 NLGUI::CDBManager::getInstance()->getDB()->addObserver(&_ServerObserver, textId );
3856
3857 // add the observers when local node change
3858 textId = ICDBNode::CTextId( string("LOCAL:") + dbPath );
3859 NLGUI::CDBManager::getInstance()->getDB()->addObserver(&_LocalObserver, textId );
3860
3861 // **** Init the Nodes shortcut
3862 // Parse all Local Nodes
3863 CCDBNodeBranch *localBranch= NLGUI::CDBManager::getInstance()->getDbBranch(string("LOCAL:") + dbPath);
3864 if(localBranch)
3865 {
3866 uint i;
3867 std::vector<CCDBNodeLeaf*> leaves;
3868 buildRecursLocalLeaves(localBranch, leaves);
3869
3870 // --- build _Nodes
3871 _Nodes.reserve(leaves.size());
3872 for(i=0;i<leaves.size();i++)
3873 {
3874 CCDBNodeLeaf *localLeaf= leaves[i];
3875
3876 // get the SERVER associated node name
3877 string serverLeafStr= *localLeaf->getName();
3878 CCDBNodeBranch* parent= localLeaf->getParent();
3879 while( *parent->getName()!="LOCAL" )
3880 {
3881 serverLeafStr= *parent->getName()+":"+serverLeafStr;
3882 parent= parent->getParent();
3883 }
3884 serverLeafStr= "SERVER:" + serverLeafStr;
3885
3886 // try then to get this server node
3887 CCDBNodeLeaf *serverLeaf= NLGUI::CDBManager::getInstance()->getDbProp(serverLeafStr, false);
3888 if(serverLeaf)
3889 {
3890 // Both server and local leaves exist, ok, append to _Nodes
3891 CNode node;
3892 node.ServerNode= serverLeaf;
3893 node.LocalNode= localLeaf;
3894 _Nodes.push_back(node);
3895 }
3896 }
3897
3898 // --- Init the maps
3899 _ServerNodeMap.reserve(leaves.size());
3900 _LocalNodeMap.reserve(leaves.size());
3901 // For all valid _Nodes, insert in "map"
3902 for(i=0;i<_Nodes.size();i++)
3903 {
3904 CNodeLocalComp lc;
3905 CNodeServerComp sc;
3906 lc.Node= &_Nodes[i];
3907 sc.Node= &_Nodes[i];
3908 _LocalNodeMap.push_back(lc);
3909 _ServerNodeMap.push_back(sc);
3910 }
3911 // then sort
3912 sort(_LocalNodeMap.begin(), _LocalNodeMap.end());
3913 sort(_ServerNodeMap.begin(), _ServerNodeMap.end());
3914
3915 }
3916 }
3917 }
3918
3919 // ------------------------------------------------------------------------------------------------
3920 void CInterfaceManager::CServerToLocalAutoCopy::onServerChange(ICDBNode *serverNode)
3921 {
3922 if(_Nodes.empty())
3923 return;
3924 CCDBNodeLeaf *serverLeaf = safe_cast<CCDBNodeLeaf *>(serverNode);
3925 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3926
3927 // Add the leaf to the update list. only if not the counter
3928 if(serverLeaf != _ServerCounter)
3929 {
3930 // build the map key
3931 CNode nodeComp;
3932 CNodeServerComp sc;
3933 nodeComp.ServerNode= serverLeaf;
3934 sc.Node= &nodeComp;
3935 // try to find the node associated to this server leaf
3936 uint index= searchLowerBound(_ServerNodeMap, sc);
3937 // if found
3938 if( index>0 || _ServerNodeMap[0].Node->ServerNode==serverLeaf )
3939 {
3940 CNode *node= _ServerNodeMap[index].Node;
3941 // if this node is not already inserted
3942 if(!node->InsertedInUpdateList)
3943 {
3944 // insert
3945 node->InsertedInUpdateList= true;
3946 _UpdateList.push_back(node);
3947 }
3948 }
3949 }
3950
3951 // if the client and server are synchonized.
3952 if( ClientCfg.Local || pIM->localActionCounterSynchronizedWith(_ServerCounter) )
3953 {
3954 // update all leaves
3955 for(uint i=0;i<_UpdateList.size();i++)
3956 {
3957 CNode *node= _UpdateList[i];
3958
3959 _LocalUpdating= true;
3960 node->LocalNode->setValue64(node->ServerNode->getValue64());
3961 _LocalUpdating= false;
3962
3963 // reset inserted flag
3964 node->InsertedInUpdateList= false;
3965 }
3966
3967 // clear update list
3968 _UpdateList.clear();
3969 }
3970 }
3971
3972 // ------------------------------------------------------------------------------------------------
3973 void CInterfaceManager::CServerToLocalAutoCopy::onLocalChange(ICDBNode *localNode)
3974 {
3975 if(_Nodes.empty())
3976 return;
3977
3978 // if the local changes because of localLeaf->setValue64() in onServerChange(), no-op !!!
3979 if(_LocalUpdating)
3980 return;
3981
3982 CCDBNodeLeaf *localLeaf = safe_cast<CCDBNodeLeaf *>(localNode);
3983
3984 // Add the leaf to the update list
3985 // build the map key
3986 CNode nodeComp;
3987 CNodeLocalComp lc;
3988 nodeComp.LocalNode= localLeaf;
3989 lc.Node= &nodeComp;
3990 // try to find the node associated to this local leaf
3991 uint index= searchLowerBound(_LocalNodeMap, lc);
3992 // if found
3993 if( index>0 || _LocalNodeMap[0].Node->LocalNode==localLeaf )
3994 {
3995 CNode *node= _LocalNodeMap[index].Node;
3996 // if this node is not already inserted
3997 if(!node->InsertedInUpdateList)
3998 {
3999 // insert
4000 node->InsertedInUpdateList= true;
4001 _UpdateList.push_back(node);
4002 }
4003 }
4004 }
4005
4006 // ------------------------------------------------------------------------------------------------
4007 bool CInterfaceManager::use12hClock()
4008 {
4009 CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:SHOW_CLOCK_12H", false);
4010
4011 return (node && node->getValueBool());
4012 }
4013
4014 // ------------------------------------------------------------------------------------------------
4015 char* CInterfaceManager::getTimestampHuman(const char* format /* "[%H:%M:%S] " */)
4016 {
4017 static char cstime[25];
4018 time_t date;
4019 time (&date);
4020 struct tm *tms = localtime(&date);
4021 if (tms)
4022 {
4023 strftime(cstime, 25, format, tms);
4024 }
4025 else
4026 {
4027 strcpy(cstime, "");
4028 }
4029
4030 return cstime;
4031 }
4032
4033
4034 /*
4035 * Parse tokens in a chatmessage or emote
4036 *
4037 * Valid subjects:
4038 * $me$
4039 * $t$
4040 * $tt$
4041 * $tm1$..$tm8$
4042 *
4043 * Valid parameters:
4044 * $<subject>.name$
4045 * $<subject>.title$
4046 * $<subject>.race$
4047 * $<subject>.guild$
4048 * $<subject>.gs(m/f/n)$
4049 *
4050 * Default parameter if parameter result is empty:
4051 * $<subject>.<parameter>/<default>$
4052 *
4053 * All \d's in default parameter remove a following character.
4054 */
4055 bool CInterfaceManager::parseTokens(string& ucstr)
4056 {
4057 string str = ucstr;
4058 string start_token("$");
4059 string end_token("$");
4060 size_t start_pos = 0;
4061 size_t end_pos = 1;
4062
4063 sint endless_loop_protector = 0;
4064 while ((start_pos < str.length() - 1) &&
4065 ((start_pos = str.find(start_token, start_pos)) != string::npos))
4066 {
4067 endless_loop_protector++;
4068 if (endless_loop_protector > 100)
4069 {
4070 break;
4071 }
4072
4073 // Get the whole token substring first
4074 end_pos = str.find(end_token, start_pos + 1);
4075
4076 if ((start_pos == string::npos) ||
4077 (end_pos == string::npos) ||
4078 (end_pos <= start_pos + 1))
4079 {
4080 // Wrong formatting; give up on this one.
4081 start_pos = max(start_pos, end_pos);
4082 continue;
4083 }
4084
4085 // Get everything between the two "$"
4086 size_t token_start_pos = start_pos + start_token.length();
4087 size_t token_end_pos = end_pos - end_token.length();
4088 if (token_start_pos > token_end_pos)
4089 {
4090 // Wrong formatting; give up on this one.
4091 start_pos = end_pos;
4092 continue;
4093 }
4094
4095 string token_whole = str.substr(start_pos, end_pos - start_pos + 1);
4096 string token_string = token_whole.substr(1, token_whole.length() - 2);
4097 string token_replacement = token_whole;
4098 string token_default = token_whole;
4099
4100 string token_subject;
4101 string token_param;
4102
4103 // Does the token have a parameter?
4104 // If not it is 'name' by default
4105 vector<string> token_vector;
4106 vector<string> param_vector;
4107 splitString(token_string, ".", token_vector);
4108 if (token_vector.empty())
4109 {
4110 // Wrong formatting; give up on this one.
4111 start_pos = end_pos;
4112 continue;
4113 }
4114 token_subject = token_vector[0];
4115 if (token_vector.size() == 1)
4116 {
4117 splitString(token_subject, "/", param_vector);
4118 token_subject = !param_vector.empty() ? param_vector[0] : string();
4119 token_param = string("name");
4120 }
4121 else if (token_vector.size() > 1)
4122 {
4123 token_param = token_vector[1];
4124 if (token_param.substr(0, 3) != "gs(")
4125 {
4126 splitString(token_vector[1], "/", param_vector);
4127 token_param = !param_vector.empty() ? param_vector[0] : string();
4128 }
4129 }
4130
4131 // Get any default value, if not gs
4132 sint extra_replacement = 0;
4133 if (token_param.substr(0, 3) != "gs(")
4134 {
4135 if (param_vector.size() == 2)
4136 {
4137 // Set default value
4138 token_replacement = param_vector[1];
4139 // Delete following chars for every '\d' in default
4140 string::size_type token_replacement_pos;
4141 while ((token_replacement_pos = token_replacement.find(string("\\d"))) != string::npos)
4142 {
4143 token_replacement.replace(token_replacement_pos, 2, string());
4144 extra_replacement++;
4145 }
4146 token_default = token_replacement;
4147 }
4148 }
4149
4150 CEntityCL *pTokenSubjectEntity = NULL;
4151
4152 if (token_subject == "me")
4153 {
4154 pTokenSubjectEntity = static_cast<CEntityCL*>(UserEntity);
4155 }
4156 else if (token_subject == "t")
4157 {
4158 // Target
4159 uint targetSlot = UserEntity->targetSlot();
4160 pTokenSubjectEntity = EntitiesMngr.entity(targetSlot);
4161 }
4162 else if (token_subject == "tt")
4163 {
4164 // Target's target
4165 uint targetSlot = UserEntity->targetSlot();
4166 CEntityCL *target = EntitiesMngr.entity(targetSlot);
4167
4168 if (target)
4169 {
4170 // Check the new slot.
4171 CLFECOMMON::TCLEntityId newSlot = target->targetSlot();
4172 CEntityCL* pE = EntitiesMngr.entity(newSlot);
4173 if (pE)
4174 {
4175 pTokenSubjectEntity = pE;
4176 }
4177 }
4178 }
4179 else if ((token_subject.length() == 3) &&
4180 (token_subject.substr(0, 2) == "tm"))
4181 {
4182 // Teammate
4183 uint indexInTeam = 0;
4184 fromString(token_subject.substr(2, 1), indexInTeam);
4185
4186 // Make 0-based
4187 --indexInTeam;
4188 if (indexInTeam < PeopleInterraction.TeamList.getNumPeople() )
4189 {
4190 // Index is the database index (serverIndex() not used for team list)
4191 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp( NLMISC::toString(TEAM_DB_PATH ":%hu:NAME", indexInTeam ), false);
4192 if (pNL && pNL->getValueBool() )
4193 {
4194 // There is a character corresponding to this index
4195 pNL = NLGUI::CDBManager::getInstance()->getDbProp( NLMISC::toString( TEAM_DB_PATH ":%hu:UID", indexInTeam ), false );
4196 if (pNL)
4197 {
4198 CLFECOMMON::TClientDataSetIndex compressedIndex = pNL->getValue32();
4199
4200 // Search entity in vision
4201 CEntityCL *entity = EntitiesMngr.getEntityByCompressedIndex( compressedIndex );
4202 if (entity)
4203 {
4204 pTokenSubjectEntity = entity;
4205 }
4206 }
4207 }
4208 }
4209 }
4210 else
4211 {
4212 // Unknown token subject, skip it
4213 start_pos = end_pos;
4214 continue;
4215 }
4216
4217 if (pTokenSubjectEntity != NULL)
4218 {
4219 // Parse the parameter
4220 if (token_param == "name")
4221 {
4222 string name = pTokenSubjectEntity->getDisplayName();
4223 // special case where there is only a title, very rare case for some NPC
4224 if (name.empty())
4225 {
4226 name = pTokenSubjectEntity->getTitle();
4227 }
4228 token_replacement = name.empty() ? token_replacement : name;
4229 }
4230 else if (token_param == "title")
4231 {
4232 string title = pTokenSubjectEntity->getTitle();
4233 token_replacement = title.empty() ? token_replacement : title;
4234 }
4235 else if (token_param == "race")
4236 {
4237 CCharacterCL *pC = dynamic_cast<CCharacterCL*>(pTokenSubjectEntity);
4238 if (pC)
4239 {
4240 EGSPD::CPeople::TPeople race = pC->people();
4241 if (race >= EGSPD::CPeople::Playable && race <= EGSPD::CPeople::EndPlayable)
4242 {
4243 string srace = NLMISC::CI18N::get("io" + EGSPD::CPeople::toString(race));
4244 token_replacement = srace.empty() ? token_replacement : srace;
4245 }
4246 }
4247 }
4248 else if (token_param == "guild")
4249 {
4250 STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
4251 string ucGuildName;
4252 if (pSMC->getString(pTokenSubjectEntity->getGuildNameID(), ucGuildName))
4253 {
4254 token_replacement = ucGuildName.empty() ? token_replacement : ucGuildName;
4255 }
4256 }
4257 else if (token_param.substr(0, 3) == "gs(" &&
4258 token_param.substr(token_param.length() - 1 , 1) == ")")
4259 {
4260 // Gender string
4261 vector<string> strList;
4262 string gender_string = token_param.substr(3, token_param.length() - 4);
4263 splitString(gender_string, "/", strList);
4264
4265 if (strList.size() <= 1)
4266 {
4267 start_pos = end_pos;
4268 continue;
4269 }
4270
4271 // We only care about the gender if the subject is humanoid.
4272 GSGENDER::EGender gender = GSGENDER::neutral;
4273 if (pTokenSubjectEntity->isUser() || pTokenSubjectEntity->isPlayer() || pTokenSubjectEntity->isNPC())
4274 {
4275 CCharacterCL *pC = dynamic_cast<CCharacterCL*>(pTokenSubjectEntity);
4276 if (pC)
4277 {
4278 gender = pC->getGender();
4279 }
4280 }
4281
4282 // The neuter part is optional. Fallback to male if something is wrong.
4283 GSGENDER::EGender g = ((uint)gender >= strList.size()) ? GSGENDER::male : gender;
4284 token_replacement = strList[g];
4285 }
4286 }
4287
4288 if (token_whole == token_replacement)
4289 {
4290 // Nothing to replace; show message and exit
4291 CInterfaceManager *im = CInterfaceManager::getInstance();
4292 string message = CI18N::get("uiUntranslatedToken");
4293 message.replace(message.find("%s"), 2, token_whole);
4294 im->displaySystemInfo(message);
4295 return false;
4296 }
4297
4298 // Replace token
4299 size_t token_whole_pos = str.find(token_whole);
4300
4301 // Only do extra replacement spaces if using default
4302 extra_replacement = (token_replacement == token_default) ? extra_replacement : 0;
4303 if (str.find(token_whole, start_pos) != string::npos)
4304 {
4305 str = str.replace(token_whole_pos, token_whole.length() + extra_replacement, token_replacement);
4306 start_pos = token_whole_pos + token_replacement.length();
4307 }
4308 }
4309
4310 ucstr = str;
4311 return true;;
4312 }
4313
4314 std::string CInterfaceManager::getNextBackupName(std::string filename)
4315 {
4316 std::string ts = getTimestampHuman("%Y-%m-%d");
4317
4318 if (!ts.empty())
4319 {
4320 std::string::size_type pos = filename.find_last_of('.');
4321 if (pos == std::string::npos)
4322 filename = filename + "_" + ts + "_";
4323 else
4324 filename = filename.substr(0, pos) + "_" + ts + "_" + filename.substr(pos);
4325 }
4326
4327 // filename_YYYY-MM-DD_000.ext
4328 return CFile::findNewFile(filename);
4329 }
4330
4331 void CInterfaceManager::createFileBackup(const std::string &message, const std::string &filename, bool useCopy)
4332 {
4333 std::string backupName = getNextBackupName(filename);
4334 nlwarning("%s: '%s'.", message.c_str(), filename.c_str());
4335 if (!backupName.empty())
4336 {
4337 if (useCopy)
4338 {
4339 nlwarning("Backup copy saved as '%s'", backupName.c_str());
4340 CFile::copyFile(backupName, filename);
4341 }
4342 else
4343 {
4344 nlwarning("File renamed to '%s'", backupName.c_str());
4345 CFile::moveFile(backupName, filename);
4346 }
4347 }
4348 }
4349