Src/DasherCore/DasherInterfaceBase.h

   1 // DasherInterfaceBase.h
   2 //
   3 // Copyright (c) 2002 Iain Murray
   4
   5 #ifndef __DasherInterfaceBase_h__
   6 #define __DasherInterfaceBase_h__
   7
   8 // TODO - there is a list of things to be configurable in my notes
   9 // Check that everything that is not self-contained within the GUI is covered.
  10
  11 #include "../Common/NoClones.h"
  12 #include "../Common/ModuleSettings.h"
  13 #include "Alphabet/Alphabet.h"
  14 #include "Alphabet/AlphIO.h"
  15 #include "ColourIO.h"
  16 #include "ModuleManager.h"
  17 #include "ActionButton.h"
  18
  19 #include "AutoSpeedControl.h"
  20
  21 #include "InputFilter.h"
  22
  23 namespace Dasher {
  24   class CDasherScreen;
  25   class CDasherView;
  26   class CDasherInput;
  27   class CDasherModel;
  28   class CEventHandler;
  29   class CEvent;
  30 }
  31
  32 class Dasher::CDasherScreen;
  33 class Dasher::CDasherView;
  34 class Dasher::CDasherInput;
  35 class Dasher::CDasherModel;
  36 class Dasher::CEventHandler;
  37 class Dasher::CEvent;
  38 class CSettingsStore;
  39 class CUserLogBase;
  40 class CDasherButtons;
  41 class CNodeCreationManager;
  42
  43 #include <map>
  44 #include <algorithm>
  45
  46 namespace Dasher {
  47   class CDasherInterfaceBase;
  48 }
  49 /// The central class in the core of Dasher. Ties together the rest of
  50 /// the platform independent stuff and provides a single interface for
  51 /// the UI to use.
  52
  53 class Dasher::CDasherInterfaceBase:private NoClones
  54 {
  55 public:
  56   CDasherInterfaceBase();
  57   virtual ~ CDasherInterfaceBase();
  58
  59   ///
  60   /// Allocate resources, create alphabets etc. This is a separate
  61   /// routine to the constructor to give us a chance to set up
  62   /// parameters before things are created.
  63   ///
  64
  65   void Realize();
  66
  67   /// @name Access to internal member classes
  68   /// Access various classes contained within the interface. These
  69   /// should be considered dangerous and use minimised. Eventually to
  70   /// be replaced by properly encapsulated equivalents.
  71   /// @{
  72
  73   ///
  74   /// Return a pointer to the current EventHandler (the one
  75   /// which the CSettingsStore is using to notify parameter
  76   /// changes)
  77   ///
  78
  79   virtual CEventHandler *GetEventHandler() {
  80     return m_pEventHandler;
  81   };
  82
  83   ///
  84   /// \deprecated In situ alphabet editing is no longer supported
  85   /// \todo Document this
  86   ///
  87
  88   const CAlphIO::AlphInfo & GetInfo(const std::string & AlphID);
  89
  90   /// \todo Document this
  91
  92   void SetInfo(const CAlphIO::AlphInfo & NewInfo);
  93
  94   /// \todo Document this
  95
  96   void DeleteAlphabet(const std::string & AlphID);
  97
  98   /// Get a pointer to the current alphabet object
  99
 100   CAlphabet *GetAlphabet() {
 101     return m_Alphabet;
 102   }
 103
 104   /// Gets a pointer to the object doing user logging
 105
 106   CUserLogBase* GetUserLogPtr();
 107
 108   // @}
 109
 110   ///
 111   /// @name Parameter manipulation
 112   /// Members for manipulating the parameters of the core Dasher object.
 113   ///
 114
 115   //@{
 116
 117   ///
 118   /// Set a boolean parameter.
 119   /// \param iParameter The parameter to set.
 120   /// \param bValue The new value.
 121   ///
 122
 123   void SetBoolParameter(int iParameter, bool bValue);
 124
 125   ///
 126   /// Set a long integer parameter.
 127   /// \param iParameter The parameter to set.
 128   /// \param lValue The new value.
 129   ///
 130
 131   void SetLongParameter(int iParameter, long lValue);
 132
 133   ///
 134   /// Set a string parameter.
 135   /// \param iParameter The parameter to set.
 136   /// \param sValue The new value.
 137   ///
 138
 139   void SetStringParameter(int iParameter, const std::string & sValue);
 140
 141   /// Get a boolean parameter
 142   /// \param iParameter The parameter to get.
 143   /// \retval The current value.
 144
 145   bool GetBoolParameter(int iParameter);
 146
 147   /// Get a long integer parameter
 148   /// \param iParameter The parameter to get.
 149   /// \retval The current value.
 150
 151   long GetLongParameter(int iParameter);
 152
 153   /// Get a string parameter
 154   /// \param iParameter The parameter to get.
 155   /// \retval The current value.
 156
 157   std::string GetStringParameter(int iParameter);
 158
 159   ///
 160   /// Reset a parameter to the default value
 161   ///
 162
 163   void ResetParameter(int iParmater);
 164
 165   /// \todo Document this
 166
 167   void GetFontSizes(std::vector < int >*FontSizes) const;
 168
 169   ///
 170   /// Obtain the permitted values for a string parameter - used to
 171   /// geneate preferences dialogues etc.
 172   ///
 173
 174   void GetPermittedValues(int iParameter, std::vector<std::string> &vList);
 175
 176   ///
 177   /// Get a list of settings which apply to a particular module
 178   ///
 179
 180   bool GetModuleSettings(const std::string &strName, SModuleSettings **pSettings, int *iCount);
 181
 182
 183   //@}
 184
 185   /// Forward events to listeners in the SettingsUI and Editbox.
 186   /// \param pEvent The event to forward.
 187   /// \todo Should be protected.
 188
 189   virtual void ExternalEventHandler(Dasher::CEvent * pEvent) {};
 190
 191   /// Interface level event handler. For example, responsible for
 192   /// restarting the Dasher model whenever parameter changes make it
 193   /// invalid.
 194   /// \param pEvent The event.
 195   /// \todo Should be protected.
 196
 197   void InterfaceEventHandler(Dasher::CEvent * pEvent);
 198
 199
 200   void PreSetNotify(int iParameter, const std::string &sValue);
 201
 202
 203   /// Draw a new Dasher frame, regardless of whether we're paused etc.
 204   /// \param iTime Current time in ms.
 205   /// \todo See comments in cpp file for some functionality which needs to be re-implemented
 206
 207   void NewFrame(unsigned long iTime, bool bForceRedraw);
 208
 209
 210   /// @name Starting and stopping
 211   /// Methods used to instruct dynamic motion of Dasher to start or stop
 212   /// @{
 213
 214   /// Resets the Dasher model. Doesn't actually unpause Dasher.
 215   /// \deprecated Use InvalidateContext() instead
 216
 217   void Start();
 218
 219   /// Pause Dasher
 220   /// \todo Parameters are ignored (?) - remove from definition.
 221
 222   void PauseAt(int MouseX, int MouseY); // are required to make
 223
 224   /// Halt Dasher. This simply freezes Dasher but does not emit a stop event, so does not result in speech etc.
 225
 226   void Halt();
 227
 228   /// Unpause Dasher
 229   /// \param Time Time in ms, used to keep a constant frame rate
 230
 231   void Unpause(unsigned long Time);     // Dasher run at the
 232
 233   /// @}
 234
 235
 236   // App Interface
 237   // -----------------------------------------------------
 238
 239   // std::map<int, std::string>& GetAlphabets(); // map<key, value> int is a UID string can change. Store UID in preferences. Display string to user.
 240   // std::vector<std::string>& GetAlphabets();
 241   // std::vector<std::string>& GetLangModels();
 242   // std::vector<std::string>& GetViews();
 243
 244   /// Supply a new CDasherScreen object to do the rendering.
 245   /// \param NewScreen Pointer to the new CDasherScreen.
 246
 247   void ChangeScreen(CDasherScreen * NewScreen); // We may change the widgets Dasher uses
 248
 249   /// Train Dasher from a file
 250   /// \param Filename File to load.
 251
 252   int TrainFile(std::string Filename, int iTotalBytes, int iOffset); // all training data must be in UTF-8.
 253
 254   /// Set the context in which Dasher makes predictions
 255   /// \param strNewContext The new context (UTF-8)
 256
 257   void SetContext(std::string strNewContext);
 258   void InvalidateContext(bool bForceStart);
 259
 260   /// @name Status reporting
 261   /// Get information about the runtime status of Dasher which might
 262   /// be of interest for debugging purposes etc.
 263   /// @{
 264
 265   /// Get the current rate of text entry.
 266   /// \retval The rate in characters per minute.
 267   /// TODO: Check that this is still used
 268
 269   double GetCurCPM();
 270
 271   /// Get current refresh rate.
 272   /// \retval The rate in frames per second
 273   /// TODO: Check that this is still used
 274
 275   double GetCurFPS();
 276
 277   /// Get the total number of nats (base-e bits) entered.
 278   /// \retval The current total
 279   /// \todo Obsolete since new logging code?
 280
 281   double GetNats() const;
 282
 283   /// Reset the count of nats entered.
 284   /// \todo Obsolete since new logging code?
 285
 286   void ResetNats();
 287
 288   double GetFramerate();
 289
 290   int GetRenderCount();
 291
 292   /// @}
 293
 294   /// @name Control hierarchy and action buttons
 295   /// Manipulate the hierarchy of commands presented in control mode etc
 296   /// @{
 297
 298   void RegisterNode( int iID, const std::string &strLabel, int iColour );
 299
 300   void ConnectNode(int iChild, int iParent, int iAfter);
 301
 302   void DisconnectNode(int iChild, int iParent);
 303
 304   void ExecuteCommand(const std::string &strName);
 305
 306   void AddActionButton(const std::string &strName);
 307
 308   /// @}
 309
 310   virtual void WriteTrainFile(const std::string &strNewText) {
 311   };
 312
 313   /// @name User input
 314   /// Deals with forwarding user input to the core
 315   /// @{
 316
 317   void KeyDown(int iTime, int iId);
 318
 319   void KeyUp(int iTime, int iId);
 320
 321   void HandleClickUp(int iTime, int iX, int iY);
 322
 323   void HandleClickDown(int iTime, int iX, int iY);
 324
 325   /// @}
 326
 327   // Module management functions
 328   void RegisterFactory(CModuleFactory *pFactory);
 329
 330   void StartShutdown();
 331
 332   void AddGameModeString(const std::string &strText) {
 333     m_deGameModeStrings.push_back(strText);
 334     PauseAt(0,0);
 335     CreateDasherModel();
 336     Start();
 337   };
 338
 339   void ScheduleRedraw() {
 340     m_bRedrawScheduled = true;
 341   };
 342
 343   void CheckRedraw();
 344
 345 protected:
 346
 347   ///
 348   /// Notify the core that the UI has been realised. At this point drawing etc. is expected to work
 349   ///
 350
 351   void OnUIRealised();
 352
 353
 354   /// @name State machine functions
 355   /// ...
 356   /// @{
 357
 358   enum ETransition {
 359     TR_MODEL_INIT = 0,
 360     TR_UI_INIT,
 361     TR_LOCK,
 362     TR_UNLOCK,
 363     TR_SHUTDOWN,
 364     TR_NUM
 365   };
 366
 367   enum EState {
 368     ST_START = 0,
 369     ST_MODEL,
 370     ST_UI,
 371     ST_NORMAL,
 372     ST_LOCKED,
 373     ST_SHUTDOWN,
 374     ST_NUM,
 375     ST_FORBIDDEN,
 376     ST_DELAY
 377   };
 378
 379   void ChangeState(ETransition iTransition);
 380
 381   /// @}
 382
 383   CDasherModule *GetModule(long long int iID);
 384   CDasherModule *GetModuleByName(const std::string &strName);
 385
 386
 387   // TODO: Make these private (currently used by child class)
 388   void WriteTrainFileFull();
 389   void WriteTrainFilePartial();
 390
 391
 392
 393   // Various 'child' components
 394   CAlphabet *m_Alphabet;
 395   CDasherModel *m_pDasherModel;
 396   CDasherScreen *m_DasherScreen;
 397   CDasherView *m_pDasherView;
 398   CDasherInput *m_pInput;
 399   CAlphIO *m_AlphIO;
 400   CColourIO *m_ColourIO;
 401   CNodeCreationManager *m_pNCManager;
 402
 403   std::string strTrainfileBuffer;
 404   std::string strCurrentContext;
 405
 406   CEventHandler *m_pEventHandler;
 407   CSettingsStore *m_pSettingsStore;
 408   CUserLogBase *m_pUserLog;               // Pointer to the object that handles logging user activity
 409   CInputFilter* m_pInputFilter;
 410   CModuleManager m_oModuleManager;
 411
 412   bool m_bGlobalLock; // The big lock
 413
 414
 415   bool m_bRedrawScheduled;
 416
 417
 418
 419  private:
 420   ///
 421   /// \todo Document this
 422   ///
 423
 424   void GetAlphabets(std::vector < std::string > *AlphabetList);
 425
 426   ///
 427   /// \todo Document this
 428   ///
 429
 430   void GetColours(std::vector < std::string > *ColourList);
 431
 432   /// @name Platform dependent utility functions
 433   /// These functions provide various platform dependent functions
 434   /// required by the core. A derived class is created for each
 435   /// supported platform which implements these.
 436   // @{
 437
 438   ///
 439   /// Initialise the SP_SYSTEM_LOC and SP_USER_LOC paths - the exact
 440   /// method of doing this will be OS dependent
 441   ///
 442
 443   virtual void SetupPaths() = 0;
 444
 445   ///
 446   /// Produce a list of filenames for alphabet files
 447   ///
 448
 449   virtual void ScanAlphabetFiles(std::vector<std::string> &vFileList) = 0;
 450
 451   ///
 452   /// Produce a list of filenames for colour files
 453   ///
 454
 455   virtual void ScanColourFiles(std::vector<std::string> &vFileList) = 0;
 456
 457   ///
 458   /// Set up the platform dependent UI for the widget (not the wider
 459   /// app). Note that the constructor of the derived class will
 460   /// probably want to return details of what was created - this will
 461   /// have to happen separately, but we'll need to be careful with the
 462   /// semantics.
 463   ///
 464
 465   virtual void SetupUI() = 0;
 466
 467   ///
 468   /// Create any module factories which are specific to the platform
 469   /// (eg input device drivers)
 470   ///
 471
 472   virtual void CreateLocalFactories() = 0;
 473
 474   ///
 475   /// Create settings store object, which will be platform dependent
 476   /// TODO: Can this not be done just by selecting which settings
 477   /// store implementation to instantiate?
 478   ///
 479
 480   virtual void CreateSettingsStore() = 0;
 481
 482   ///
 483   /// Obtain the size in bytes of a file - the way to do this is
 484   /// dependent on the OS (TODO: Check this - any posix on Windows?)
 485   ///
 486
 487   virtual int GetFileSize(const std::string &strFileName) = 0;
 488
 489   ///
 490   /// Start the callback timer
 491   ///
 492
 493   virtual void StartTimer() = 0;
 494
 495   ///
 496   /// Shutdown the callback timer (permenantly - this is called once
 497   /// Dasher is committed to closing).
 498   ///
 499
 500   virtual void ShutdownTimer() = 0;
 501
 502   /// @}
 503
 504
 505   /// Provide a new CDasherInput input device object.
 506
 507   void CreateInput();
 508
 509   void CreateFactories();
 510   void CreateInputFilter();
 511   void CreateDasherModel();
 512   void ChangeAlphabet();
 513   void ChangeColours();
 514   void ChangeView();
 515   void Redraw(bool bRedrawNodes);
 516   void SetupActionButtons();
 517   void DestroyActionButtons();
 518   void PositionActionButtons();
 519   bool DrawActionButtons();
 520
 521   void LeaveState(EState iState);
 522   void EnterState(EState iState);
 523
 524
 525   /// @name Lock Management
 526   /// Functions for locking/unlocking the core. Note that the lock
 527   /// flags parameter is currently ignored, but will be used to give
 528   /// finer granularity
 529   /// @{
 530
 531   ///
 532   /// Add a lock
 533   ///
 534
 535   void AddLock(int iLockFlags);
 536
 537   ///
 538   /// Release an existing lock. Note that these functions have minimal
 539   /// error checking at the moment, so be careful.
 540   ///
 541
 542   void ReleaseLock(int iLockFlags);
 543
 544   /// @}
 545
 546   int m_iLockCount;
 547
 548   EState m_iCurrentState;
 549
 550   std::deque<std::string> m_deGameModeStrings;
 551
 552   std::vector<CActionButton *> m_vLeftButtons;
 553   std::vector<CActionButton *> m_vRightButtons;
 554
 555   bool m_bOldVisible;
 556 };
 557
 558 #endif /* #ifndef __DasherInterfaceBase_h__ */