ryzom/client/src/interface_v3/interface_manager.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2019  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2013-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23 #ifndef NL_INTERFACE_MANAGER_H
  24 #define NL_INTERFACE_MANAGER_H
  25
  26 #include <queue>
  27
  28 #include "nel/misc/types_nl.h"
  29 #include "nel/misc/cdb_manager.h"
  30 #include "nel/misc/mutex.h"
  31 #include "nel/3d/u_texture.h"
  32 #include "nel/3d/u_text_context.h"
  33 #include "nel/gui/interface_group.h"
  34 #include "nel/gui/interface_link.h"
  35 #include "nel/gui/group_list.h"
  36 #include "nel/gui/view_base.h"
  37 #include "nel/gui/view_pointer.h"
  38
  39 #include "nel/gui/ctrl_base.h"
  40 #include "nel/gui/ctrl_scroll.h"
  41
  42 #include "nel/gui/view_renderer.h"
  43
  44 // InterfaceV3
  45 #include "nel/gui/interface_parser.h"
  46 #include "nel/gui/ctrl_sheet_selection.h"
  47 #include "nel/gui/interface_options.h"
  48 #include "interface_config.h"
  49 #include "interface_pointer.h"
  50 #include "flying_text_manager.h"
  51
  52 #include "nel/gui/input_event_listener.h"
  53 #include "nel/gui/db_manager.h"
  54
  55 // CLIENT
  56 #include "../string_manager_client.h"
  57
  58 #include "../ingame_database_manager.h"
  59
  60 #include "nel/gui/lua_manager.h"
  61
  62 //the network database node
  63 extern CCDBSynchronised IngameDbMngr;
  64
  65 ///\todo nico remove that
  66 extern bool g_hidden;
  67
  68 #define GROUP_BROWSER                   "ui:outgame:charsel:webstart:content:webstart_html"
  69
  70 ///max botchat distance
  71 #define MAX_BOTCHAT_DISTANCE_SQUARE 25
  72
  73 #define MAX_NUM_MODES 6
  74
  75 #define RZ_CATEGORY_EDIT "edit"
  76
  77 // #define AJM_DEBUG_TRACK_INTERFACE_GROUPS
  78
  79 namespace NLGUI
  80 {
  81         class CInterfaceOptions;
  82         class CGroupContainer;
  83         class CGroupMenu;
  84         class CInterfaceAnim;
  85 }
  86
  87 /**
  88  * class managing the interface
  89  * \author Matthieu 'TrapII' Besson
  90  * \author Nevrax France
  91  * \date 2002
  92  */
  93 class CInterfaceManager : public NLGUI::CInterfaceParser::ISetupOptionCallbackClass, public NLGUI::IInputEventListener
  94 {
  95 public:
  96
  97 #ifdef AJM_DEBUG_TRACK_INTERFACE_GROUPS
  98         void DebugTrackGroupsCreated( CInterfaceGroup *pIG );
  99         void DebugTrackGroupsDestroyed( CInterfaceGroup *pIG );
 100         void DebugTrackGroupsDump();
 101         int DebugTrackGroupsGetId( CInterfaceGroup *pIG );
 102
 103         typedef std::set<CInterfaceGroup *> setInterfaceGroupPtr;
 104         typedef std::map<CInterfaceGroup *, int> mapInterfaceGroupPtr2Int;
 105
 106         setInterfaceGroupPtr _DebugTrackGroupSet;
 107         mapInterfaceGroupPtr2Int _DebugTrackGroupMap;
 108         int _DebugTrackGroupCreateCount;
 109         int _DebugTrackGroupDestroyCount;
 110 #endif
 111         enum TSystemInfoMode
 112         {
 113                 InfoMsg,
 114                 WarningMsg,
 115                 ErrorMsg
 116         };
 117
 118         // Icon to use for validMessageBox() method
 119         enum TValidMessageIcon
 120         {
 121                 NoIconMsg=0,
 122                 QuestionIconMsg,
 123                 WarningIconMsg,
 124                 ErrorIconMsg
 125         };
 126
 127 public:
 128
 129         /// Singleton method : Get the unique interface loader instance
 130         static CInterfaceManager* getInstance();
 131
 132         /// Destroy singleton
 133         static void destroy ();
 134
 135         /// Destructor
 136         ~CInterfaceManager();
 137
 138         /**
 139          * High level
 140          */
 141
 142         void createLocalBranch (const std::string &fileName, NLMISC::IProgressCallback &progressCallBack);
 143
 144         void reset();
 145
 146         // release all of the global db autocopy observers
 147         void releaseServerToLocalAutoCopyObservers();
 148
 149         void setInGame( bool i );
 150         bool isInGame() const { return _InGame; }
 151
 152         void initLUA();
 153
 154         /// initialize the whole login interface
 155         void initLogin();
 156
 157         /// unload login interface
 158         void uninitLogin();
 159
 160         /// initialize the whole out game interface
 161         void initOutGame();
 162
 163         /// unload out game interface
 164         void uninitOutGame();
 165
 166         /// initialize the whole in game interface
 167         void initInGame();
 168
 169         /// Part of initInGame()
 170         void loadIngameInterfaceTextures();
 171
 172         /// Part of initInGame()
 173         void loadUI();
 174
 175         /// Configure the Quit dialog box
 176         void configureQuitDialogBox();
 177
 178         /// Part of initInGame()
 179         void loadKeys();
 180
 181         /// Part of initInGame()
 182         void loadInterfaceConfig();
 183
 184         /// Save the game interface (keys and interface config). Called before continent and entity manager are destroyed.
 185         void uninitInGame0();
 186
 187         /// Uninit game interface. Called after continent and entity manager are destroyed.
 188         void uninitInGame1();
 189
 190         /// update a frame Event: update the input handler manager
 191         void updateFrameEvents();
 192
 193         // force to flush the debug window (also done when calling updateFrameEvents)
 194         void flushDebugWindow();
 195
 196         /// update a frame View: check coordinates and draw view. The camera is used to draw in-scene interfaces. Can be NULL.
 197         void updateFrameViews(NL3D::UCamera camera);
 198
 199
 200         /**
 201          * Config file loaders
 202          */
 203
 204         /// Load texture grouping a set of small texture
 205         void loadTextures (const std::string &textFileName, const std::string &uvFileName, bool uploadDXTC= false);
 206
 207         /// Load texts
 208         void loadTexts (const std::string &fileName);
 209
 210         /// Load a set of xml files
 211         bool parseInterface (const std::vector<std::string> &xmlFileNames, bool reload, bool isFilename = true);
 212
 213         /// return new filename that can be used to backup original file
 214         std::string getNextBackupName(std::string filename);
 215         /// copy/rename filename for backup and show error in log
 216         void createFileBackup(const std::string &message, const std::string &filename, bool useCopy = false);
 217
 218         /// select player/shared file name from 'save' folder'
 219         std::string getSaveFileName(const std::string &module, const std::string &ext, bool useShared = true) const;
 220
 221         /// Load / save user landmarks in .xml format
 222         bool loadLandmarks ();
 223         bool saveLandmarks (bool verbose = false) const;
 224         bool saveLandmarks (const std::string &filename) const;
 225
 226         // Load/Save position, size, etc.. of windows
 227         bool loadConfig (const std::string &filename);
 228         // Save config to default location, if verbose is true, display message in game sysinfo
 229         bool saveConfig (bool verbose = false);
 230         bool saveConfig (const std::string &filename);
 231         // delete the user config (give the player ident fileName)
 232         bool deletePlayerConfig (const std::string &playerFileIdent);
 233
 234         // Save keys to default location, if verbose is true, display message in game sysinfo
 235         bool saveKeys (bool verbose = false);
 236         // Save the keys config file
 237         bool saveKeys (const std::string &filename);
 238         // delete the user Keysconfig (give the player ident fileName)
 239         bool deletePlayerKeys (const std::string &playerFileIdent);
 240
 241         // Log system (all chat/tell
 242         void setLogState(bool state) { _LogState = state; }
 243         bool getLogState() const { return _LogState; }
 244         void log(const std::string &str, const std::string &cat = "");
 245
 246         /// Text from here and from server
 247
 248         class IStringProcess
 249         {
 250         public:
 251                 virtual ~IStringProcess() { }
 252                 virtual bool cbIDStringReceived(std::string &inOut) = 0; // called when string or id is received (return true if valid the change)
 253         };
 254
 255         void addServerString (const std::string &sTarget, uint32 id, IStringProcess *cb = NULL);
 256         void addServerID (const std::string &sTarget, uint32 id, IStringProcess *cb = NULL);
 257         void processServerIDString();
 258
 259         /// Control specific
 260
 261         /// Enable/Disable window movement
 262         //void enableMoveWindow (CInterfaceGroup *pWin);
 263         //void disableMoveWindow ();
 264
 265         /// Enable/Disable the window resizing (0,TopLeft)(1,T)(2,TR)(3,R)(4,BR)(5,B)(6,BL)(7,L)
 266         //void enableResizeWindow (CInterfaceGroup *pWin, uint8 nType, sint32 nMinW, sint32 nMaxW, sint32 nMinH, sint32 nMaxH,
 267         //                                              sint32 nStepW, sint32 nStepH);
 268         //void disableResizeWindow ();
 269         //void moveWindow (CInterfaceGroup *pWin, sint32 dx, sint32 dy);
 270
 271         /// Enable/Disbale capture of a control (combo box for example)
 272         /// When capture is lost (by clicking outside of the control, the given property is toggled)
 273         //void enableCaptureElement(CInterfaceElement *pElem, CInterfaceProperty *captureFlag);
 274         //void disableCaptureElement();
 275
 276         /** Enable/Disable a single modal window (pointer cannot get out of the window).
 277           * NB : the keyboard capture is released on both calls.
 278           * NB : cascaded modal windows are disabled by the call
 279           */
 280
 281
 282         /// Handle The Event. return true if the interfaceManager catch it and if must not send to the Game Action Manager
 283         bool handleEvent (const NLGUI::CEventDescriptor &eventDesc);
 284
 285         // InGame ContextMenu
 286         void launchContextMenuInGame (const std::string &nameOfCM);
 287
 288
 289         /**
 290          * Draw views
 291          */
 292         void drawViews (NL3D::UCamera camera);
 293
 294         // display a debug info
 295         void              displayDebugInfo(const std::string &str, TSystemInfoMode mode = InfoMsg);
 296         // get the color associated with the given system info mode
 297         NLMISC::CRGBA getDebugInfoColor(TSystemInfoMode mode);
 298
 299         // display a system info string
 300         void              displaySystemInfo(const std::string &str, const std::string &Category = "SYS");
 301         NLMISC::CRGBA getSystemInfoColor(const std::string &Category = "SYS");
 302
 303         void setupOptions();
 304
 305         /** Open a MessageBox. this is a simple ModalWindow with a Ok button
 306          *      ui:interface:message_box must be defined in xml, with a "text" ViewText son
 307          */
 308         void    messageBox(const std::string &text, const std::string &masterGroup="ui:interface", TCaseMode caseMode = CaseFirstSentenceLetterUp);
 309         /** Open a MessageBox. this is a simple ModalWindow with a Ok and a HELP button.
 310          *  The help button with open a browser on ryzom.com faq
 311          *      ui:interface:message_box_with_help must be defined in xml, with a "text" ViewText son
 312          */
 313         void    messageBoxWithHelp(const std::string &text, const std::string &masterGroup="ui:interface",
 314                                                            const std::string &ahOnOk = std::string(), const std::string &paramsOnOk= std::string(),
 315                                                            TCaseMode caseMode = CaseFirstSentenceLetterUp);
 316
 317         /** Open a MessageBox with validation question. this is a simple ModalWindow with a Ok / Cancel button
 318          *      ui:interface:valid_message_box must be defined in xml, with a "text" ViewText son, and a "ok" button
 319          *      \param ahOnOk => the action handler to call if ok is pressed. NB: you don't have to call leave_modal in this ah (auto done).
 320          *      \param paramsOnOk => params passed to ahOnOk.
 321          *      \param ahOnCancel => the action handler to call if cancel is pressed. NB: you don't have to call leave_modal in this ah (auto done).
 322          *      \param paramsOnCancel => params passed to ahOnCancel.
 323          */
 324         void    validMessageBox(TValidMessageIcon icon, const std::string &text, const std::string &ahOnOk, const std::string &paramsOnOk= std::string(),
 325                 const std::string &ahOnCancel= std::string(), const std::string &paramsOnCancel= std::string(), const std::string &masterGroup="ui:interface");
 326
 327         /** Get the current running validMessageBox OnOk action. empty if no validMessageBox currently opened
 328          *      One can use it to know if it match its system and so if it needs to be closed (with disableModalWindow())
 329          */
 330         bool    getCurrentValidMessageBoxOnOk(std::string &ahOnOk, const std::string &masterGroup="ui:interface");
 331
 332         // Modes
 333         void    setMode(uint8 newMode);
 334         uint8   getMode() const { return _CurrentMode; }
 335         void    resetMode(uint8 newMode);
 336         // Update image of a single group container in a virtual desktop.
 337         // This is faster than switching to a new desktop using 'setMode' to update the changes
 338         // \param mode Index of the virtual desktop
 339         void    updateGroupContainerImage(CGroupContainer &gc, uint8 mode);
 340         // Remove a group container from a virtual desktop image
 341         // \param mode Index of the virtual desktop
 342         void    removeGroupContainerImage(const std::string &groupName, uint8 mode);
 343         // Remove group container from all virtual desktops
 344         void    removeGroupContainerImageFromDesktops(const std::string &groupName);
 345
 346
 347
 348
 349         // debug : dump all the interface windows in the console
 350         void    dumpUI(bool indent);
 351
 352         // debug : display box of all elements in the interface (plus hotspot)
 353         void    displayUIViewBBoxs(const std::string &uiFilter);
 354         void    displayUICtrlBBoxs(const std::string &uiFilter);
 355         void    displayUIGroupBBoxs(const std::string &uiFilter);
 356
 357         // visit all elements of the interface manager
 358         void    visit(CInterfaceElementVisitor *visitor);
 359
 360         // Display the only one web window at end of ryzom
 361         void    displayWebWindow(const std::string &name, const std::string &url);
 362
 363         // Initialize emote from TextEmotListSheet (create command and insert the GCM entry)
 364         void    initEmotes();
 365         void    uninitEmotes();
 366         void    updateEmotes();
 367
 368         // For Drag And drop, return true if the "CopyDrag" key is pressed (actually the ctrl key!)
 369         bool    testDragCopyKey();
 370
 371         // Reset the view text index
 372         void    resetTextIndex();
 373
 374         // test if the config has been loaded in initInGame()
 375         bool    isConfigLoaded() const {return _ConfigLoaded;}
 376
 377
 378         /// Manager for flying text. use it to add
 379         CFlyingTextManager              FlyingTextManager;
 380
 381
 382         /// \name LUA
 383         // @{
 384         /// For debug: dump in the sysinfo and nlwarning state of lua. detail range from 0 to 2 (clamped).
 385         void dumpLuaState(uint detail);
 386         // @}
 387
 388         // Get the list of InGame XML Interface files, with any AddOn ones
 389         static std::vector<std::string>         getInGameXMLInterfaceFiles();
 390
 391         /// \name Action Counter sync
 392         // @{
 393
 394         void                    incLocalSyncActionCounter();
 395
 396         uint8                   getLocalSyncActionCounter() const {return _LocalSyncActionCounter;}
 397         uint8                   getLocalSyncActionCounterMask() const {return _LocalSyncActionCounterMask;}
 398
 399         bool                    localActionCounterSynchronizedWith(NLMISC::CCDBNodeLeaf *leaf)
 400         {
 401                 if (!leaf) return false;
 402                 uint    srvVal= leaf->getValue32();
 403                 uint    locVal= _LocalSyncActionCounter ;
 404                 srvVal&= _LocalSyncActionCounterMask;
 405                 locVal&= _LocalSyncActionCounterMask;
 406                 return srvVal == locVal;
 407         }
 408
 409         void                    resetShardSpecificData();
 410
 411         // @}
 412
 413
 414         // Item Carac Test, get the value
 415         bool    isItemCaracRequirementMet(CHARACTERISTICS::TCharacteristics type, sint32 value)
 416         {
 417                 // carac requirement?
 418                 if( type < CHARACTERISTICS::NUM_CHARACTERISTICS)
 419                         return value <= _CurrentPlayerCharac[type];
 420                 // no carac requirement => ok
 421                 else
 422                         return true;
 423         }
 424
 425         // get Player Carac
 426         sint32  getCurrentPlayerCarac(CHARACTERISTICS::TCharacteristics type)
 427         {
 428                 if( type < CHARACTERISTICS::NUM_CHARACTERISTICS)
 429                         return _CurrentPlayerCharac[type];
 430                 else
 431                         return 0;
 432         }
 433
 434         void    notifyMailAvailable();
 435         void    notifyForumUpdated();
 436
 437         /** Queue up lua script to be run on next frame update
 438          */
 439         void queueLuaScript(const std::string &script);
 440
 441         /** Return true if 12-hour clock should be used
 442          */
 443         static bool use12hClock();
 444
 445         /** Returns a human readable timestamp with the given format.
 446          */
 447         static char* getTimestampHuman(const char* format = "[%H:%M:%S] ");
 448
 449         /** Parses any tokens in the utf-8 string like $t$ or $g()$
 450          */
 451         static bool parseTokens(std::string& ucstr);
 452
 453 // ------------------------------------------------------------------------------------------------
 454 private:
 455
 456         // Observer for copying db branch changes
 457         class CServerToLocalAutoCopy
 458         {
 459         public:
 460                 CServerToLocalAutoCopy();
 461                 ~CServerToLocalAutoCopy()       { release(); }
 462
 463                 // init the AutoCopy
 464                 void    init(const std::string &dbPath);
 465                 // unhook from everything we are tangled up in
 466                 void    release();
 467
 468                 // When something in the SERVER DB changes
 469                 void    onServerChange(NLMISC::ICDBNode *serverNode);
 470                 // When something in the LOCAL DB changes
 471                 void    onLocalChange(NLMISC::ICDBNode *localNode);
 472
 473         private:
 474                 class CLocalDBObserver : public NLMISC::ICDBNode::IPropertyObserver
 475                 {
 476                 public:
 477                         CServerToLocalAutoCopy  &_Owner;
 478                         CLocalDBObserver(CServerToLocalAutoCopy &owner) : _Owner(owner) {}
 479                         virtual void    update(NLMISC::ICDBNode *node)  {_Owner.onLocalChange(node);}
 480                 };
 481                 class CServerDBObserver : public NLMISC::ICDBNode::IPropertyObserver
 482                 {
 483                 public:
 484                         CServerToLocalAutoCopy  &_Owner;
 485                         CServerDBObserver(CServerToLocalAutoCopy        &owner) : _Owner(owner) {}
 486                         virtual void    update(NLMISC::ICDBNode *node)  {_Owner.onServerChange(node);}
 487                 };
 488
 489                 // A node here is a pair Server<->Local
 490                 struct CNode
 491                 {
 492                         NLMISC::CCDBNodeLeaf    *ServerNode;
 493                         NLMISC::CCDBNodeLeaf    *LocalNode;
 494                         bool                    InsertedInUpdateList;
 495                         CNode()
 496                         {
 497                                 ServerNode= NULL;
 498                                 LocalNode= NULL;
 499                                 InsertedInUpdateList= false;
 500                         }
 501                 };
 502                 // Struct for comparing nodes, by either Local or Server pointer
 503                 struct CNodeLocalComp
 504                 {
 505                         CNode   *Node;
 506                         bool    operator<=(const CNodeLocalComp &o) const       {return Node->LocalNode <= o.Node->LocalNode;}
 507                         bool    operator<(const CNodeLocalComp &o) const        {return Node->LocalNode < o.Node->LocalNode;}
 508                 };
 509                 struct CNodeServerComp
 510                 {
 511                         CNode   *Node;
 512                         bool    operator<=(const CNodeServerComp &o) const      {return Node->ServerNode <= o.Node->ServerNode;}
 513                         bool    operator<(const CNodeServerComp &o) const       {return Node->ServerNode < o.Node->ServerNode;}
 514                 };
 515
 516         private:
 517                 // Counter Node
 518                 NLMISC::CCDBNodeLeaf                    *_ServerCounter;
 519                 // updaters
 520                 CLocalDBObserver                _LocalObserver;
 521                 CServerDBObserver               _ServerObserver;
 522                 // avoid reentrance
 523                 bool                                    _LocalUpdating;
 524
 525                 // Array of Nodes that have to be synchronized
 526                 std::vector<CNode>                      _Nodes;
 527                 // Sorting of Nodes, by Server Node
 528                 std::vector<CNodeServerComp>    _ServerNodeMap;
 529                 // Sorting of Nodes, by Local Node
 530                 std::vector<CNodeLocalComp>     _LocalNodeMap;
 531                 // List of nodes to update until next synchonized client-server counter
 532                 std::vector<CNode*>                     _UpdateList;
 533
 534                 void    buildRecursLocalLeaves(NLMISC::CCDBNodeBranch *branch, std::vector<NLMISC::CCDBNodeLeaf*> &leaves);
 535         };
 536
 537         // Database management stuff
 538         class CDBLandmarkObs : public NLMISC::ICDBNode::IPropertyObserver
 539         {
 540         public:
 541                 virtual void update(NLMISC::ICDBNode *node);
 542         };
 543
 544         // EMOTES
 545         // ----------------------------------------------------------------------------------
 546         class CEmoteCmd : public NLMISC::ICommand
 547         {
 548         public:
 549                 CEmoteCmd(const char *cmdName, const char *cmdHelp, const char *cmdArgs)
 550                         : NLMISC::ICommand("emotes", cmdName, cmdHelp, cmdArgs)
 551                 {
 552                 }
 553
 554                 bool execute(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human=true);
 555
 556                 uint32 Behaviour; // State id from list.emot
 557                 uint32 EmoteNb;
 558         };
 559
 560 // ------------------------------------------------------------------------------------------------
 561 public:
 562         // cache and expose some commonly used db nodes
 563         NLMISC::CCDBNodeBranch *_DBB_UI_DUMMY;
 564         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_QUANTITY;
 565         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_QUALITY;
 566         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_SHEET;
 567         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_NAMEID;
 568         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_ENCHANT;
 569         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_SLOT_TYPE;
 570         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_PHRASE;
 571         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_WORNED;
 572         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_PREREQUISIT_VALID;
 573         NLMISC::CCDBNodeLeaf *_DB_UI_DUMMY_FACTION_TYPE;
 574
 575         void updateDesktops( uint32 newScreenW, uint32 newScreenH );
 576         void setInterfaceScale( float scale, bool autoScale = false )
 577         {
 578                 _InterfaceScaleChanged = true;
 579                 _InterfaceScale = scale;
 580                 _InterfaceScaleAuto = autoScale;
 581         }
 582
 583 private:
 584
 585         NLMISC::CCDBNodeLeaf *_CheckMailNode;
 586         NLMISC::CCDBNodeLeaf *_CheckForumNode;
 587         sint64 _UpdateWeatherTime;
 588
 589         // WebIG notify thread is pushing lua code here
 590         std::queue<std::string> _ScriptQueue;
 591         NLMISC::CMutex _ScriptQueueMutex;
 592
 593         void flushScriptQueue();
 594
 595         // @}
 596
 597         /** This is the GLOBAL Action counter used to synchronize some systems (including INVENTORY) with the server.
 598          */
 599         uint8                   _LocalSyncActionCounter;
 600
 601         /// This is the Mask (4bits)
 602         uint8                   _LocalSyncActionCounterMask;
 603
 604
 605         /// Constructor
 606         CInterfaceManager();
 607
 608         ///the singleton's instance
 609         static CInterfaceManager* _Instance;
 610
 611         NLMISC::CCDBNodeLeaf       *_DescTextTarget;
 612
 613         /// Current waiting id and string from server
 614         struct SIDStringWaiter
 615         {
 616                 STRING_MANAGER::IStringWaiterRemover SWR;
 617                 bool IdOrString; // true == id, false == string
 618                 uint32 Id;
 619                 std::string Target;
 620                 IStringProcess *Cb;
 621         };
 622         std::vector<SIDStringWaiter*> _IDStringWaiters;
 623
 624         uint32                  _ScreenW, _ScreenH; // Change res detection
 625         sint32                  _LastInGameScreenW, _LastInGameScreenH; // Resolution used for last InGame interface
 626         float                   _InterfaceScale;
 627         bool                    _InterfaceScaleAuto;
 628         bool                    _InterfaceScaleChanged;
 629
 630         // Modes
 631         std::vector<CInterfaceConfig::CDesktopImage> _Modes;
 632         uint8                           _CurrentMode;
 633
 634         // true when interface manager is running 'ingame' content
 635         bool                            _InGame;
 636
 637         // Does the interface config file as been loaded ?
 638         bool                            _ConfigLoaded;
 639         bool                            _LogState;
 640
 641         // Does the keys config file for as been loaded ?
 642         bool                            _KeysLoaded;
 643
 644         // clear all edit box in the ui
 645         void    clearAllEditBox();
 646         // restore all backuped positions for containers
 647         void    restoreAllContainersBackupPosition();
 648
 649         // Some Node leaf
 650         NLMISC::CCDBNodeLeaf *_NeutralColor;
 651         NLMISC::CCDBNodeLeaf *_WarningColor;
 652         NLMISC::CCDBNodeLeaf *_ErrorColor;
 653
 654         CDBLandmarkObs _LandmarkObs;
 655
 656         /// \name LUA
 657         // @{
 658         // str= printable version of value at stack index
 659         void    getLuaValueInfo(std::string &str, sint index);
 660         // display a string in SysInfo and nlinfo
 661         void    dumpLuaString(const std::string &str);
 662         // dump printable version of pair key-index in top of stack. if value is a table, recurs (up to recursTableLevel times)
 663         void    dumpLuaKeyValueInfo(uint recursTableLevel, uint tabLevel);
 664         // @}
 665
 666         bool                                            _EmotesInitialized;
 667         std::vector<CEmoteCmd*>         _EmoteCmds;
 668
 669         // Item Carac requirement
 670         sint32 _CurrentPlayerCharac[CHARACTERISTICS::NUM_CHARACTERISTICS];
 671         NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> _CurrentPlayerCharacLeaf[CHARACTERISTICS::NUM_CHARACTERISTICS];
 672
 673         // observers for copying database branch changes
 674         CServerToLocalAutoCopy ServerToLocalAutoCopyInventory;
 675         CServerToLocalAutoCopy ServerToLocalAutoCopyExchange;
 676         CServerToLocalAutoCopy ServerToLocalAutoCopyContextMenu;
 677         CServerToLocalAutoCopy ServerToLocalAutoCopySkillPoints;
 678         CServerToLocalAutoCopy ServerToLocalAutoCopyDMGift;
 679
 680         // Pop a new message box. If the message box was found, returns a pointer on it
 681         void messageBoxInternal(const std::string &msgBoxGroup, const std::string &text, const std::string &masterGroup, TCaseMode caseMode);
 682
 683         CInterfaceLink::CInterfaceLinkUpdater *interfaceLinkUpdater;
 684 };
 685
 686 #endif // NL_INTERFACE_MANAGER_H
 687
 688 /* End of interface_manager.h */