Src/DasherCore/DasherInterfaceBase.cpp

   1 // DasherInterfaceBase.cpp
   2 //
   3 // Copyright (c) 2002 Iain Murray
   4
   5 #include "../Common/Common.h"
   6
   7 #include "DasherInterfaceBase.h"
   8
   9 //#include "ActionButton.h"
  10 #include "AlphabetManagerFactory.h"
  11 #include "DasherViewSquare.h"
  12 #include "ControlManager.h"
  13 #include "DasherScreen.h"
  14 #include "DasherView.h"
  15 #include "DasherInput.h"
  16 #include "DasherModel.h"
  17 #include "EventHandler.h"
  18 #include "Event.h"
  19 #include "NodeCreationManager.h"
  20 #include "UserLog.h"
  21 #include "BasicLog.h"
  22 #include "WrapperFactory.h"
  23
  24 // Input filters
  25 #include "ClickFilter.h"
  26 #include "DefaultFilter.h"
  27 #include "DasherButtons.h"
  28 #include "DynamicFilter.h"
  29 #include "EyetrackerFilter.h"
  30 #include "OneDimensionalFilter.h"
  31 #include "StylusFilter.h"
  32 #include "TwoButtonDynamicFilter.h"
  33
  34 // STL headers
  35 #include <iostream>
  36 #include <memory>
  37
  38 // Legacy C library headers
  39 namespace {
  40   #include "stdio.h"
  41 }
  42
  43 // Declare our global file logging object
  44 #include "../DasherCore/FileLogger.h"
  45 #ifdef _DEBUG
  46 const eLogLevel g_iLogLevel   = logDEBUG;
  47 const int       g_iLogOptions = logTimeStamp | logDateStamp | logDeleteOldFile;
  48 #else
  49 const eLogLevel g_iLogLevel   = logNORMAL;
  50 const int       g_iLogOptions = logTimeStamp | logDateStamp;
  51 #endif
  52 CFileLogger* g_pLogger = NULL;
  53
  54 using namespace Dasher;
  55 using namespace std;
  56
  57 // Track memory leaks on Windows to the line that new'd the memory
  58 #ifdef _WIN32
  59 #ifdef _DEBUG
  60 #define DEBUG_NEW new( _NORMAL_BLOCK, THIS_FILE, __LINE__ )
  61 #define new DEBUG_NEW
  62 #undef THIS_FILE
  63 static char THIS_FILE[] = __FILE__;
  64 #endif
  65 #endif
  66
  67 CDasherInterfaceBase::CDasherInterfaceBase()
  68                   :m_Alphabet(0), m_pDasherModel(0), m_DasherScreen(0),
  69                    m_pDasherView(0), m_pInput(0), m_AlphIO(0), m_ColourIO(0), m_pUserLog(NULL),
  70                    m_pInputFilter(NULL) {
  71
  72   m_iCurrentState = ST_START;
  73   m_iLockCount = 0;
  74
  75   m_pNCManager = 0;
  76
  77   m_bGlobalLock = false;
  78
  79   m_bRedrawScheduled = false;
  80
  81   m_pEventHandler = new CEventHandler(this);
  82
  83   strCurrentContext = ". ";
  84
  85   strTrainfileBuffer = "";
  86
  87   // Global logging object we can use from anywhere
  88   g_pLogger = new CFileLogger("dasher.log",
  89                               g_iLogLevel,
  90                               g_iLogOptions);
  91
  92 }
  93
  94 void CDasherInterfaceBase::Realize() {
  95
  96   // TODO: What exactly needs to have happened by the time we call Realize()?
  97   CreateSettingsStore();
  98   SetupUI();
  99   SetupPaths();
 100
 101   std::vector<std::string> vAlphabetFiles;
 102   ScanAlphabetFiles(vAlphabetFiles);
 103   m_AlphIO = new CAlphIO(GetStringParameter(SP_SYSTEM_LOC), GetStringParameter(SP_USER_LOC), vAlphabetFiles);
 104
 105   std::vector<std::string> vColourFiles;
 106   ScanColourFiles(vColourFiles);
 107   m_ColourIO = new CColourIO(GetStringParameter(SP_SYSTEM_LOC), GetStringParameter(SP_USER_LOC), vColourFiles);
 108
 109   ChangeColours();
 110   ChangeAlphabet();
 111
 112   // Create the user logging object if we are suppose to.  We wait
 113   // until now so we have the real value of the parameter and not
 114   // just the default.
 115
 116   // TODO: Sort out log type selection
 117
 118   int iUserLogLevel = GetLongParameter(LP_USER_LOG_LEVEL_MASK);
 119
 120   if(iUserLogLevel == 10)
 121     m_pUserLog = new CBasicLog(m_pEventHandler, m_pSettingsStore);
 122   else if (iUserLogLevel > 0)
 123     m_pUserLog = new CUserLog(m_pEventHandler, m_pSettingsStore, iUserLogLevel, m_Alphabet);
 124
 125   CreateFactories();
 126   CreateLocalFactories();
 127
 128   CreateInput();
 129   CreateInputFilter();
 130   SetupActionButtons();
 131
 132   // FIXME - need to rationalise this sort of thing.
 133   InvalidateContext(true);
 134   ScheduleRedraw();
 135
 136   // All the setup is done by now, so let the user log object know
 137   // that future parameter changes should be logged.
 138   if (m_pUserLog != NULL)
 139     m_pUserLog->InitIsDone();
 140
 141   ChangeState(TR_MODEL_INIT);
 142 }
 143
 144 CDasherInterfaceBase::~CDasherInterfaceBase() {
 145
 146   DASHER_ASSERT(m_iCurrentState == ST_SHUTDOWN);
 147
 148   delete m_pDasherModel;        // The order of some of these deletions matters
 149   delete m_Alphabet;
 150   delete m_pDasherView;
 151   delete m_ColourIO;
 152   delete m_AlphIO;
 153   delete m_pInputFilter;
 154   delete m_pNCManager;
 155   // Do NOT delete Edit box or Screen. This class did not create them.
 156
 157   // When we destruct on shutdown, we'll output any detailed log file
 158   if (m_pUserLog != NULL)
 159   {
 160     m_pUserLog->OutputFile();
 161     delete m_pUserLog;
 162     m_pUserLog = NULL;
 163   }
 164
 165   if (g_pLogger != NULL) {
 166     delete g_pLogger;
 167     g_pLogger = NULL;
 168   }
 169
 170   // Must delete event handler after all CDasherComponent derived classes
 171
 172   delete m_pEventHandler;
 173 }
 174
 175 void CDasherInterfaceBase::PreSetNotify(int iParameter, const std::string &sNewValue) {
 176
 177   // FIXME - make this a more general 'pre-set' event in the message
 178   // infrastructure
 179
 180   switch(iParameter) {
 181   case SP_ALPHABET_ID:
 182     // Cycle the alphabet history
 183     if(GetStringParameter(SP_ALPHABET_ID) != sNewValue) {
 184       if(GetStringParameter(SP_ALPHABET_1) != sNewValue) {
 185         if(GetStringParameter(SP_ALPHABET_2) != sNewValue) {
 186           if(GetStringParameter(SP_ALPHABET_3) != sNewValue)
 187             SetStringParameter(SP_ALPHABET_4, GetStringParameter(SP_ALPHABET_3));
 188
 189           SetStringParameter(SP_ALPHABET_3, GetStringParameter(SP_ALPHABET_2));
 190         }
 191
 192         SetStringParameter(SP_ALPHABET_2, GetStringParameter(SP_ALPHABET_1));
 193       }
 194
 195       SetStringParameter(SP_ALPHABET_1, GetStringParameter(SP_ALPHABET_ID));
 196     }
 197
 198     break;
 199   }
 200 }
 201
 202 void CDasherInterfaceBase::InterfaceEventHandler(Dasher::CEvent *pEvent) {
 203
 204   if(pEvent->m_iEventType == 1) {
 205     Dasher::CParameterNotificationEvent * pEvt(static_cast < Dasher::CParameterNotificationEvent * >(pEvent));
 206
 207     switch (pEvt->m_iParameter) {
 208
 209     case BP_OUTLINE_MODE:
 210       ScheduleRedraw();
 211       break;
 212     case BP_DRAW_MOUSE:
 213       ScheduleRedraw();
 214       break;
 215     case BP_CONTROL_MODE:
 216       ScheduleRedraw();
 217       break;
 218     case BP_DRAW_MOUSE_LINE:
 219       ScheduleRedraw();
 220       break;
 221     case LP_ORIENTATION:
 222       if(GetLongParameter(LP_ORIENTATION) == Dasher::Opts::AlphabetDefault)
 223         // TODO: See comment in DasherModel.cpp about prefered values
 224         SetLongParameter(LP_REAL_ORIENTATION, m_Alphabet->GetOrientation());
 225       else
 226         SetLongParameter(LP_REAL_ORIENTATION, GetLongParameter(LP_ORIENTATION));
 227       ScheduleRedraw();
 228       break;
 229     case SP_ALPHABET_ID:
 230       ChangeAlphabet();
 231       ScheduleRedraw();
 232       break;
 233     case SP_COLOUR_ID:
 234       ChangeColours();
 235       ScheduleRedraw();
 236       break;
 237     case SP_DEFAULT_COLOUR_ID: // Delibarate fallthrough
 238     case BP_PALETTE_CHANGE:
 239       if(GetBoolParameter(BP_PALETTE_CHANGE))
 240          SetStringParameter(SP_COLOUR_ID, GetStringParameter(SP_DEFAULT_COLOUR_ID));
 241       break;
 242     case LP_LANGUAGE_MODEL_ID:
 243       CreateDasherModel();
 244       break;
 245     case LP_LINE_WIDTH:
 246       ScheduleRedraw();
 247       break;
 248     case LP_DASHER_FONTSIZE:
 249       ScheduleRedraw();
 250       break;
 251     case SP_INPUT_DEVICE:
 252       CreateInput();
 253       break;
 254     case SP_INPUT_FILTER:
 255       CreateInputFilter();
 256       ScheduleRedraw();
 257       break;
 258     default:
 259       break;
 260     }
 261   }
 262   else if(pEvent->m_iEventType == 2) {
 263     CEditEvent *pEditEvent(static_cast < CEditEvent * >(pEvent));
 264
 265     if(pEditEvent->m_iEditType == 1) {
 266       strCurrentContext += pEditEvent->m_sText;
 267       if( strCurrentContext.size() > 20 )
 268         strCurrentContext = strCurrentContext.substr( strCurrentContext.size() - 20 );
 269
 270       strTrainfileBuffer += pEditEvent->m_sText;
 271     }
 272     else if(pEditEvent->m_iEditType == 2) {
 273       strCurrentContext = strCurrentContext.substr( 0, strCurrentContext.size() - pEditEvent->m_sText.size());
 274
 275       strTrainfileBuffer = strTrainfileBuffer.substr( 0, strTrainfileBuffer.size() - pEditEvent->m_sText.size());
 276     }
 277   }
 278   else if(pEvent->m_iEventType == EV_CONTROL) {
 279     CControlEvent *pControlEvent(static_cast <CControlEvent*>(pEvent));
 280
 281     switch(pControlEvent->m_iID) {
 282     case CControlManager::CTL_STOP:
 283       PauseAt(0,0);
 284       break;
 285     case CControlManager::CTL_PAUSE:
 286       Halt();
 287       break;
 288     }
 289   }
 290   else if(pEvent->m_iEventType == EV_LOCK) {
 291     CLockEvent *pLockEvent(static_cast<CLockEvent *>(pEvent));
 292
 293     // TODO: Sort this out - at the moment these don't occur in pairs, so the old boolean variable is still needed
 294     if(pLockEvent->m_bLock) {
 295       if(m_bGlobalLock)
 296         AddLock(0);
 297     }
 298     else {
 299       if(!m_bGlobalLock)
 300         ReleaseLock(0);
 301     }
 302
 303     m_bGlobalLock = pLockEvent->m_bLock;
 304   }
 305 }
 306
 307 void CDasherInterfaceBase::WriteTrainFileFull() {
 308   WriteTrainFile(strTrainfileBuffer);
 309   strTrainfileBuffer = "";
 310 }
 311
 312 void CDasherInterfaceBase::WriteTrainFilePartial() {
 313   // TODO: what if we're midway through a unicode character?
 314   WriteTrainFile(strTrainfileBuffer.substr(0,100));
 315   strTrainfileBuffer = strTrainfileBuffer.substr(100);
 316 }
 317
 318 void CDasherInterfaceBase::CreateDasherModel()
 319 {
 320   if(!m_AlphIO)
 321     return;
 322
 323   // TODO: Move training into model?
 324   // TODO: Do we really need to check for a valid language model?
 325   int lmID = GetLongParameter(LP_LANGUAGE_MODEL_ID);
 326   if( lmID != -1 ) {
 327
 328     // Train the new language model
 329     CLockEvent *pEvent;
 330
 331     pEvent = new CLockEvent("Training Dasher", true, 0);
 332     m_pEventHandler->InsertEvent(pEvent);
 333     delete pEvent;
 334
 335     AddLock(0);
 336
 337     // Delete the old model and create a new one
 338     if(m_pDasherModel) {
 339       delete m_pDasherModel;
 340       m_pDasherModel = 0;
 341     }
 342
 343     if(m_pNCManager) {
 344       delete m_pNCManager;
 345       m_pNCManager = 0;
 346     }
 347
 348     if(m_deGameModeStrings.size() == 0) {
 349       m_pNCManager = new CNodeCreationManager(m_pEventHandler, m_pSettingsStore, false, "", m_AlphIO);
 350       m_pDasherModel = new CDasherModel(m_pEventHandler, m_pSettingsStore, m_pNCManager, this);
 351     }
 352     else {
 353       m_pNCManager = new CNodeCreationManager(m_pEventHandler, m_pSettingsStore, true, m_deGameModeStrings[0], m_AlphIO);
 354       m_pDasherModel = new CDasherModel(m_pEventHandler, m_pSettingsStore, m_pNCManager, this, true, m_deGameModeStrings[0]);
 355       //      m_deGameModeStrings.pop_front();
 356     }
 357
 358     m_Alphabet = m_pNCManager->GetAlphabet();
 359
 360     string T = m_Alphabet->GetTrainingFile();
 361
 362     int iTotalBytes = 0;
 363     iTotalBytes += GetFileSize(GetStringParameter(SP_SYSTEM_LOC) + T);
 364     iTotalBytes += GetFileSize(GetStringParameter(SP_USER_LOC) + T);
 365
 366     if(iTotalBytes > 0) {
 367       int iOffset;
 368       iOffset = TrainFile(GetStringParameter(SP_SYSTEM_LOC) + T, iTotalBytes, 0);
 369       TrainFile(GetStringParameter(SP_USER_LOC) + T, iTotalBytes, iOffset);
 370     }
 371     else {
 372       CMessageEvent oEvent("No training text is avilable for the selected alphabet. Dasher will function, but it may be difficult to enter text.\nPlease see http://www.dasher.org.uk/alphabets/ for more information.", 0, 0);
 373       m_pEventHandler->InsertEvent(&oEvent);
 374     }
 375
 376     pEvent = new CLockEvent("Training Dasher", false, 0);
 377     m_pEventHandler->InsertEvent(pEvent);
 378     delete pEvent;
 379   }
 380
 381   Start();
 382   Redraw(true);
 383
 384   ReleaseLock(0);
 385 }
 386
 387 void CDasherInterfaceBase::Start() {
 388   // TODO: Clarify the relationship between Start() and
 389   // InvalidateContext() - I believe that they essentially do the same
 390   // thing
 391   PauseAt(0, 0);
 392   if(m_pDasherModel != 0) {
 393     m_pDasherModel->Start();
 394   }
 395   if(m_pDasherView != 0) {
 396 //     m_pDasherView->ResetSum();
 397 //     m_pDasherView->ResetSumCounter();
 398 //     m_pDasherView->ResetYAutoOffset();
 399   }
 400
 401   int iMinWidth;
 402
 403   if(m_pInputFilter && m_pInputFilter->GetMinWidth(iMinWidth)) {
 404     m_pDasherModel->LimitRoot(iMinWidth);
 405   }
 406 }
 407
 408 void CDasherInterfaceBase::PauseAt(int MouseX, int MouseY) {
 409   SetBoolParameter(BP_DASHER_PAUSED, true);
 410
 411   // Request a full redraw at the next time step.
 412   SetBoolParameter(BP_REDRAW, true);
 413
 414   Dasher::CStopEvent oEvent;
 415   m_pEventHandler->InsertEvent(&oEvent);
 416
 417   if (m_pUserLog != NULL)
 418     m_pUserLog->StopWriting((float) GetNats());
 419 }
 420
 421 void CDasherInterfaceBase::Halt() {
 422   SetBoolParameter(BP_DASHER_PAUSED, true);
 423
 424   // Obsolete?
 425   if(GetBoolParameter(BP_MOUSEPOS_MODE)) {
 426     SetLongParameter(LP_MOUSE_POS_BOX, 1);
 427   }
 428   //
 429
 430   // This will cause us to reinitialise the frame rate counter - ie we start off slowly
 431   if(m_pDasherModel != 0)
 432     m_pDasherModel->Halt();
 433 }
 434
 435 void CDasherInterfaceBase::Unpause(unsigned long Time) {
 436   SetBoolParameter(BP_DASHER_PAUSED, false);
 437
 438   if(m_pDasherModel != 0) {
 439     m_pDasherModel->Reset_framerate(Time);
 440     //m_pDasherModel->Set_paused(m_Paused);
 441   }
 442   if(m_pDasherView != 0) {
 443 //     m_pDasherView->ResetSum();
 444 //     m_pDasherView->ResetSumCounter();
 445   }
 446
 447   Dasher::CStartEvent oEvent;
 448   m_pEventHandler->InsertEvent(&oEvent);
 449
 450   ResetNats();
 451   if (m_pUserLog != NULL)
 452     m_pUserLog->StartWriting();
 453 }
 454
 455 void CDasherInterfaceBase::CreateInput() {
 456   if(m_pInput) {
 457     m_pInput->Deactivate();
 458     m_pInput->Unref();
 459   }
 460
 461   m_pInput = (CDasherInput *)GetModuleByName(GetStringParameter(SP_INPUT_DEVICE));
 462
 463   if(m_pInput) {
 464     m_pInput->Ref();
 465     m_pInput->Activate();
 466   }
 467
 468   if(m_pDasherView != 0)
 469     m_pDasherView->SetInput(m_pInput);
 470 }
 471
 472 void CDasherInterfaceBase::NewFrame(unsigned long iTime, bool bForceRedraw) {
 473   // Fail if Dasher is locked
 474   if(m_iCurrentState != ST_NORMAL)
 475     return;
 476
 477   bool bChanged(false);
 478
 479   if(m_pDasherView != 0) {
 480     if(!GetBoolParameter(BP_TRAINING)) {
 481       if (m_pUserLog != NULL) {
 482
 483         Dasher::VECTOR_SYMBOL_PROB vAdded;
 484         int iNumDeleted = 0;
 485
 486         if(m_pInputFilter) {
 487           bChanged = m_pInputFilter->Timer(iTime, m_pDasherView, m_pDasherModel, &vAdded, &iNumDeleted);
 488         }
 489
 490         if (iNumDeleted > 0)
 491           m_pUserLog->DeleteSymbols(iNumDeleted);
 492         if (vAdded.size() > 0)
 493           m_pUserLog->AddSymbols(&vAdded);
 494
 495       }
 496       else {
 497         if(m_pInputFilter) {
 498           bChanged = m_pInputFilter->Timer(iTime, m_pDasherView, m_pDasherModel, 0, 0);
 499         }
 500       }
 501
 502       m_pDasherModel->CheckForNewRoot(m_pDasherView);
 503     }
 504   }
 505
 506   Redraw(bChanged || m_bRedrawScheduled || bForceRedraw);
 507   m_bRedrawScheduled = false;
 508
 509   // This just passes the time through to the framerate tracker, so we
 510   // know how often new frames are being drawn.
 511   if(m_pDasherModel != 0)
 512     m_pDasherModel->NewFrame(iTime);
 513 }
 514
 515 void CDasherInterfaceBase::CheckRedraw() {
 516   if(m_bRedrawScheduled)
 517     Redraw(true);
 518
 519   m_bRedrawScheduled = false;
 520 }
 521
 522 /// Full redraw - renders model, decorations and blits onto display
 523 /// buffer. Not recommended if nothing has changed with the model,
 524 /// otherwise we're wasting effort.
 525
 526 void CDasherInterfaceBase::Redraw(bool bRedrawNodes) {
 527   if(!m_pDasherView || !m_pDasherModel)
 528     return;
 529
 530   // TODO: More generic notion of 'layers'?
 531
 532   if(bRedrawNodes) {
 533     m_pDasherView->Screen()->SendMarker(0);
 534     m_pDasherModel->RenderToView(m_pDasherView, true);
 535   }
 536
 537   m_pDasherView->Screen()->SendMarker(1);
 538
 539   bool bDecorationsChanged(false);
 540
 541   if(m_pInputFilter) {
 542     bDecorationsChanged = m_pInputFilter->DecorateView(m_pDasherView);
 543   }
 544
 545   bool bActionButtonsChanged(false);
 546 #ifdef EXPERIMENTAL_FEATURES
 547   bActionButtonsChanged = DrawActionButtons();
 548 #endif
 549
 550   if(bRedrawNodes || bDecorationsChanged || bActionButtonsChanged)
 551     m_pDasherView->Display();
 552 }
 553
 554 void CDasherInterfaceBase::ChangeAlphabet() {
 555
 556   if(GetStringParameter(SP_ALPHABET_ID) == "") {
 557     SetStringParameter(SP_ALPHABET_ID, m_AlphIO->GetDefault());
 558     // This will result in ChangeAlphabet() being called again, so
 559     // exit from the first recursion
 560     return;
 561   }
 562
 563   // Send a lock event
 564
 565   WriteTrainFileFull();
 566
 567   // Lock Dasher to prevent changes from happening while we're training.
 568
 569   SetBoolParameter( BP_TRAINING, true );
 570
 571 //   m_AlphInfo = m_AlphIO->GetInfo(NewAlphabetID);
 572
 573 //   //AlphabetID = m_AlphInfo.AlphID.c_str();
 574
 575 //   //  std::auto_ptr < CAlphabet > ptrOld(m_Alphabet);       // So we can delete the old alphabet later
 576
 577 //   m_Alphabet = new CAlphabet(m_AlphInfo);
 578
 579   delete m_pDasherModel;
 580   m_pDasherModel = 0;
 581   CreateDasherModel();
 582
 583   // Let our user log object know about the new alphabet since
 584   // it needs to convert symbols into text for the log file.
 585   if (m_pUserLog != NULL)
 586     m_pUserLog->SetAlphabetPtr(m_Alphabet);
 587
 588   // Apply options from alphabet
 589
 590   SetBoolParameter( BP_TRAINING, false );
 591
 592   //}
 593 }
 594
 595 void CDasherInterfaceBase::ChangeColours() {
 596   if(!m_ColourIO || !m_DasherScreen)
 597     return;
 598
 599   // TODO: Make fuction return a pointer directly
 600   m_DasherScreen->SetColourScheme(&(m_ColourIO->GetInfo(GetStringParameter(SP_COLOUR_ID))));
 601 }
 602
 603 void CDasherInterfaceBase::ChangeScreen(CDasherScreen *NewScreen) {
 604   m_DasherScreen = NewScreen;
 605   ChangeColours();
 606
 607   if(m_pDasherView != 0) {
 608     m_pDasherView->ChangeScreen(m_DasherScreen);
 609   } else {
 610     if(GetLongParameter(LP_VIEW_ID) != -1)
 611       ChangeView();
 612   }
 613
 614   PositionActionButtons();
 615   ScheduleRedraw();
 616 }
 617
 618 void CDasherInterfaceBase::ChangeView() {
 619   // TODO: Actually respond to LP_VIEW_ID parameter (although there is only one view at the moment)
 620
 621   if(m_DasherScreen != 0 && m_pDasherModel != 0) {
 622     delete m_pDasherView;
 623
 624     m_pDasherView = new CDasherViewSquare(m_pEventHandler, m_pSettingsStore, m_DasherScreen);
 625
 626     if (m_pInput)
 627       m_pDasherView->SetInput(m_pInput);
 628   }
 629 }
 630
 631 void CDasherInterfaceBase::GetAlphabets(std::vector <std::string >*AlphabetList) {
 632   m_AlphIO->GetAlphabets(AlphabetList);
 633 }
 634
 635 const CAlphIO::AlphInfo & CDasherInterfaceBase::GetInfo(const std::string &AlphID) {
 636   return m_AlphIO->GetInfo(AlphID);
 637 }
 638
 639 void CDasherInterfaceBase::SetInfo(const CAlphIO::AlphInfo &NewInfo) {
 640   m_AlphIO->SetInfo(NewInfo);
 641 }
 642
 643 void CDasherInterfaceBase::DeleteAlphabet(const std::string &AlphID) {
 644   m_AlphIO->Delete(AlphID);
 645 }
 646
 647 void CDasherInterfaceBase::GetColours(std::vector <std::string >*ColourList) {
 648   m_ColourIO->GetColours(ColourList);
 649 }
 650
 651 /*
 652         I've used C style I/O because I found that C++ style I/O bloated
 653         the Win32 code enormously. The overhead of loading the buffer into
 654         the string instead of reading straight into a string seems to be
 655         negligible compared to huge requirements elsewhere.
 656 */
 657 int CDasherInterfaceBase::TrainFile(string Filename, int iTotalBytes, int iOffset) {
 658   if(Filename == "")
 659     return 0;
 660
 661   FILE *InputFile;
 662   if((InputFile = fopen(Filename.c_str(), "r")) == (FILE *) 0)
 663     return 0;
 664
 665   const int BufferSize = 1024;
 666   char InputBuffer[BufferSize];
 667   string StringBuffer;
 668   int NumberRead;
 669   int iTotalRead(0);
 670
 671   vector < symbol > Symbols;
 672
 673   CAlphabetManagerFactory::CTrainer * pTrainer = m_pDasherModel->GetTrainer();
 674   do {
 675     NumberRead = fread(InputBuffer, 1, BufferSize - 1, InputFile);
 676     InputBuffer[NumberRead] = '\0';
 677     StringBuffer += InputBuffer;
 678     bool bIsMore = false;
 679     if(NumberRead == (BufferSize - 1))
 680       bIsMore = true;
 681
 682     Symbols.clear();
 683     m_Alphabet->GetSymbols(&Symbols, &StringBuffer, bIsMore);
 684
 685     pTrainer->Train(Symbols);
 686     iTotalRead += NumberRead;
 687
 688     // TODO: No reason for this to be a pointer (other than cut/paste laziness!)
 689     CLockEvent *pEvent;
 690     pEvent = new CLockEvent("Training Dasher", true, static_cast<int>((100.0 * (iTotalRead + iOffset))/iTotalBytes));
 691     m_pEventHandler->InsertEvent(pEvent);
 692     delete pEvent;
 693
 694   } while(NumberRead == BufferSize - 1);
 695
 696   delete pTrainer;
 697
 698   fclose(InputFile);
 699
 700   return iTotalRead;
 701 }
 702
 703 void CDasherInterfaceBase::GetFontSizes(std::vector <int >*FontSizes) const {
 704   FontSizes->push_back(20);
 705   FontSizes->push_back(14);
 706   FontSizes->push_back(11);
 707   FontSizes->push_back(40);
 708   FontSizes->push_back(28);
 709   FontSizes->push_back(22);
 710   FontSizes->push_back(80);
 711   FontSizes->push_back(56);
 712   FontSizes->push_back(44);
 713 }
 714
 715 double CDasherInterfaceBase::GetCurCPM() {
 716   //
 717   return 0;
 718 }
 719
 720 double CDasherInterfaceBase::GetCurFPS() {
 721   //
 722   return 0;
 723 }
 724
 725 // int CDasherInterfaceBase::GetAutoOffset() {
 726 //   if(m_pDasherView != 0) {
 727 //     return m_pDasherView->GetAutoOffset();
 728 //   }
 729 //   return -1;
 730 // }
 731
 732 double CDasherInterfaceBase::GetNats() const {
 733   if(m_pDasherModel)
 734     return m_pDasherModel->GetNats();
 735   else
 736     return 0.0;
 737 }
 738
 739 void CDasherInterfaceBase::ResetNats() {
 740   if(m_pDasherModel)
 741     m_pDasherModel->ResetNats();
 742 }
 743
 744
 745 void CDasherInterfaceBase::InvalidateContext(bool bForceStart) {
 746   m_pDasherModel->m_strContextBuffer = "";
 747
 748   Dasher::CEditContextEvent oEvent(10);
 749   m_pEventHandler->InsertEvent(&oEvent);
 750
 751    std::string strNewContext(m_pDasherModel->m_strContextBuffer);
 752
 753   // We keep track of an internal context and compare that to what
 754   // we are given - don't restart Dasher if nothing has changed.
 755   // This should really be integrated with DasherModel, which
 756   // probably will be the case when we start to deal with being able
 757   // to back off indefinitely. For now though we'll keep it in a
 758   // separate string.
 759
 760    int iContextLength( 6 ); // The 'important' context length - should really get from language model
 761
 762    // FIXME - use unicode lengths
 763
 764    if(bForceStart || (strNewContext.substr( std::max(static_cast<int>(strNewContext.size()) - iContextLength, 0)) != strCurrentContext.substr( std::max(static_cast<int>(strCurrentContext.size()) - iContextLength, 0)))) {
 765
 766      if(m_pDasherModel != NULL) {
 767        // TODO: Reimplement this
 768        //       if(m_pDasherModel->m_bContextSensitive || bForceStart) {
 769        {
 770         m_pDasherModel->SetContext(strNewContext);
 771         PauseAt(0,0);
 772        }
 773      }
 774
 775      strCurrentContext = strNewContext;
 776      WriteTrainFileFull();
 777    }
 778
 779    if(bForceStart) {
 780      int iMinWidth;
 781
 782      if(m_pInputFilter && m_pInputFilter->GetMinWidth(iMinWidth)) {
 783        m_pDasherModel->LimitRoot(iMinWidth);
 784      }
 785    }
 786
 787    if(m_pDasherView)
 788      while( m_pDasherModel->CheckForNewRoot(m_pDasherView) ) {
 789        // Do nothing
 790      }
 791
 792    ScheduleRedraw();
 793 }
 794
 795 void CDasherInterfaceBase::SetContext(std::string strNewContext) {
 796   m_pDasherModel->m_strContextBuffer = strNewContext;
 797 }
 798
 799 // Control mode stuff
 800
 801 void CDasherInterfaceBase::RegisterNode( int iID, const std::string &strLabel, int iColour ) {
 802   m_pNCManager->RegisterNode(iID, strLabel, iColour);
 803 }
 804
 805 void CDasherInterfaceBase::ConnectNode(int iChild, int iParent, int iAfter) {
 806   m_pNCManager->ConnectNode(iChild, iParent, iAfter);
 807 }
 808
 809 void CDasherInterfaceBase::DisconnectNode(int iChild, int iParent) {
 810   m_pNCManager->DisconnectNode(iChild, iParent);
 811 }
 812
 813 void CDasherInterfaceBase::SetBoolParameter(int iParameter, bool bValue) {
 814   m_pSettingsStore->SetBoolParameter(iParameter, bValue);
 815 };
 816
 817 void CDasherInterfaceBase::SetLongParameter(int iParameter, long lValue) {
 818   m_pSettingsStore->SetLongParameter(iParameter, lValue);
 819 };
 820
 821 void CDasherInterfaceBase::SetStringParameter(int iParameter, const std::string & sValue) {
 822   PreSetNotify(iParameter, sValue);
 823   m_pSettingsStore->SetStringParameter(iParameter, sValue);
 824 };
 825
 826 bool CDasherInterfaceBase::GetBoolParameter(int iParameter) {
 827   return m_pSettingsStore->GetBoolParameter(iParameter);
 828 }
 829
 830 long CDasherInterfaceBase::GetLongParameter(int iParameter) {
 831   return m_pSettingsStore->GetLongParameter(iParameter);
 832 }
 833
 834 std::string CDasherInterfaceBase::GetStringParameter(int iParameter) {
 835   return m_pSettingsStore->GetStringParameter(iParameter);
 836 }
 837
 838 void CDasherInterfaceBase::ResetParameter(int iParameter) {
 839   m_pSettingsStore->ResetParameter(iParameter);
 840 }
 841
 842 // We need to be able to get at the UserLog object from outside the interface
 843 CUserLogBase* CDasherInterfaceBase::GetUserLogPtr() {
 844   return m_pUserLog;
 845 }
 846
 847 void CDasherInterfaceBase::KeyDown(int iTime, int iId) {
 848   if(m_iCurrentState != ST_NORMAL)
 849     return;
 850
 851   if(m_pInputFilter && !GetBoolParameter(BP_TRAINING)) {
 852     m_pInputFilter->KeyDown(iTime, iId, m_pDasherModel, m_pUserLog);
 853   }
 854
 855   if(m_pInput && !GetBoolParameter(BP_TRAINING)) {
 856     m_pInput->KeyDown(iTime, iId);
 857   }
 858 }
 859
 860 void CDasherInterfaceBase::KeyUp(int iTime, int iId) {
 861   if(m_iCurrentState != ST_NORMAL)
 862     return;
 863
 864   if(m_pInputFilter && !GetBoolParameter(BP_TRAINING)) {
 865     m_pInputFilter->KeyUp(iTime, iId, m_pDasherModel);
 866   }
 867
 868   if(m_pInput && !GetBoolParameter(BP_TRAINING)) {
 869     m_pInput->KeyUp(iTime, iId);
 870   }
 871 }
 872
 873 void CDasherInterfaceBase::CreateInputFilter()
 874 {
 875   if(m_pInputFilter) {
 876     m_pInputFilter->Deactivate();
 877     m_pInputFilter->Unref();
 878     m_pInputFilter = NULL;
 879   }
 880
 881   m_pInputFilter = (CInputFilter *)GetModuleByName(GetStringParameter(SP_INPUT_FILTER));
 882
 883   if(m_pInputFilter) {
 884     m_pInputFilter->Ref();
 885     m_pInputFilter->Activate();
 886   }
 887   else {
 888     // Fall back to a sensible alternative if for some reason the
 889     // current choice isn't valid.
 890     if(GetStringParameter(SP_INPUT_FILTER) != "Normal Control")
 891       SetStringParameter(SP_INPUT_FILTER, "Normal Control");
 892   }
 893 }
 894
 895 void CDasherInterfaceBase::RegisterFactory(CModuleFactory *pFactory) {
 896   m_oModuleManager.RegisterFactory(pFactory);
 897 }
 898
 899 CDasherModule *CDasherInterfaceBase::GetModule(long long int iID) {
 900    return m_oModuleManager.GetModule(iID);
 901 }
 902
 903 CDasherModule *CDasherInterfaceBase::GetModuleByName(const std::string &strName) {
 904    return m_oModuleManager.GetModuleByName(strName);
 905 }
 906
 907 void CDasherInterfaceBase::CreateFactories() {
 908   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDefaultFilter(m_pEventHandler, m_pSettingsStore, this, m_pDasherModel,3, "Normal Control")));
 909   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new COneDimensionalFilter(m_pEventHandler, m_pSettingsStore, this, m_pDasherModel)));
 910   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CEyetrackerFilter(m_pEventHandler, m_pSettingsStore, this, m_pDasherModel)));
 911   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CClickFilter(m_pEventHandler, m_pSettingsStore, this)));
 912   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDynamicFilter(m_pEventHandler, m_pSettingsStore, this)));
 913   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CTwoButtonDynamicFilter(m_pEventHandler, m_pSettingsStore, this, 14, 1, "Two Button Dynamic Mode")));
 914   // TODO: specialist factory for button mode
 915   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDasherButtons(m_pEventHandler, m_pSettingsStore, this, 5, 1, true,8, "Menu Mode")));
 916   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDasherButtons(m_pEventHandler, m_pSettingsStore, this, 3, 0, false,10, "Direct Mode")));
 917   //  RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDasherButtons(m_pEventHandler, m_pSettingsStore, this, 4, 0, false,11, "Buttons 3")));
 918   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDasherButtons(m_pEventHandler, m_pSettingsStore, this, 3, 3, false,12, "Alternating Direct Mode")));
 919   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CDasherButtons(m_pEventHandler, m_pSettingsStore, this, 4, 2, false,13, "Compass Mode")));
 920   RegisterFactory(new CWrapperFactory(m_pEventHandler, m_pSettingsStore, new CStylusFilter(m_pEventHandler, m_pSettingsStore, this, m_pDasherModel,15, "Stylus Control")));
 921
 922 }
 923
 924 void CDasherInterfaceBase::GetPermittedValues(int iParameter, std::vector<std::string> &vList) {
 925   // TODO: Deprecate direct calls to these functions
 926   switch (iParameter) {
 927   case SP_ALPHABET_ID:
 928     GetAlphabets(&vList);
 929     break;
 930   case SP_COLOUR_ID:
 931     GetColours(&vList);
 932     break;
 933   case SP_INPUT_FILTER:
 934     m_oModuleManager.ListModules(1, vList);
 935     break;
 936   case SP_INPUT_DEVICE:
 937     m_oModuleManager.ListModules(0, vList);
 938     break;
 939   }
 940 }
 941
 942 void CDasherInterfaceBase::StartShutdown() {
 943   ChangeState(TR_SHUTDOWN);
 944 }
 945
 946 bool CDasherInterfaceBase::GetModuleSettings(const std::string &strName, SModuleSettings **pSettings, int *iCount) {
 947   return GetModuleByName(strName)->GetSettings(pSettings, iCount);
 948 }
 949
 950 void CDasherInterfaceBase::SetupActionButtons() {
 951   m_vLeftButtons.push_back(new CActionButton(this, "Exit", true));
 952   m_vLeftButtons.push_back(new CActionButton(this, "Preferences", false));
 953   m_vLeftButtons.push_back(new CActionButton(this, "Help", false));
 954   m_vLeftButtons.push_back(new CActionButton(this, "About", false));
 955 }
 956
 957 void CDasherInterfaceBase::DestroyActionButtons() {
 958   // TODO: implement and call this
 959 }
 960
 961 void CDasherInterfaceBase::PositionActionButtons() {
 962   if(!m_DasherScreen)
 963     return;
 964
 965   int iCurrentOffset(16);
 966
 967   for(std::vector<CActionButton *>::iterator it(m_vLeftButtons.begin()); it != m_vLeftButtons.end(); ++it) {
 968     (*it)->SetPosition(16, iCurrentOffset, 32, 32);
 969     iCurrentOffset += 48;
 970   }
 971
 972   iCurrentOffset = 16;
 973
 974   for(std::vector<CActionButton *>::iterator it(m_vRightButtons.begin()); it != m_vRightButtons.end(); ++it) {
 975     (*it)->SetPosition(m_DasherScreen->GetWidth() - 144, iCurrentOffset, 128, 32);
 976     iCurrentOffset += 48;
 977   }
 978 }
 979
 980 bool CDasherInterfaceBase::DrawActionButtons() {
 981   if(!m_DasherScreen)
 982     return false;
 983
 984   bool bVisible(GetBoolParameter(BP_DASHER_PAUSED));
 985
 986   bool bRV(bVisible != m_bOldVisible);
 987   m_bOldVisible = bVisible;
 988
 989   for(std::vector<CActionButton *>::iterator it(m_vLeftButtons.begin()); it != m_vLeftButtons.end(); ++it)
 990     (*it)->Draw(m_DasherScreen, bVisible);
 991
 992   for(std::vector<CActionButton *>::iterator it(m_vRightButtons.begin()); it != m_vRightButtons.end(); ++it)
 993     (*it)->Draw(m_DasherScreen, bVisible);
 994
 995   return bRV;
 996 }
 997
 998
 999 void CDasherInterfaceBase::HandleClickUp(int iTime, int iX, int iY) {
1000 #ifdef EXPERIMENTAL_FEATURES
1001   bool bVisible(GetBoolParameter(BP_DASHER_PAUSED));
1002
1003   for(std::vector<CActionButton *>::iterator it(m_vLeftButtons.begin()); it != m_vLeftButtons.end(); ++it) {
1004     if((*it)->HandleClickUp(iTime, iX, iY, bVisible))
1005       return;
1006   }
1007
1008   for(std::vector<CActionButton *>::iterator it(m_vRightButtons.begin()); it != m_vRightButtons.end(); ++it) {
1009     if((*it)->HandleClickUp(iTime, iX, iY, bVisible))
1010       return;
1011   }
1012 #endif
1013
1014   KeyUp(iTime, 100);
1015 }
1016
1017 void CDasherInterfaceBase::HandleClickDown(int iTime, int iX, int iY) {
1018 #ifdef EXPERIMENTAL_FEATURES
1019   bool bVisible(GetBoolParameter(BP_DASHER_PAUSED));
1020
1021   for(std::vector<CActionButton *>::iterator it(m_vLeftButtons.begin()); it != m_vLeftButtons.end(); ++it) {
1022     if((*it)->HandleClickDown(iTime, iX, iY, bVisible))
1023       return;
1024   }
1025
1026   for(std::vector<CActionButton *>::iterator it(m_vRightButtons.begin()); it != m_vRightButtons.end(); ++it) {
1027     if((*it)->HandleClickDown(iTime, iX, iY, bVisible))
1028       return;
1029   }
1030 #endif
1031
1032   KeyDown(iTime, 100);
1033 }
1034
1035
1036 void CDasherInterfaceBase::ExecuteCommand(const std::string &strName) {
1037   // TODO: Pointless - just insert event directly
1038
1039   CCommandEvent *pEvent = new CCommandEvent(strName);
1040   m_pEventHandler->InsertEvent(pEvent);
1041   delete pEvent;
1042 }
1043
1044 double CDasherInterfaceBase::GetFramerate() {
1045   if(m_pDasherModel)
1046     return(m_pDasherModel->Framerate());
1047   else
1048     return 0.0;
1049 }
1050
1051 int CDasherInterfaceBase::GetRenderCount() {
1052   if(m_pDasherView)
1053     return(m_pDasherView->GetRenderCount());
1054   else
1055     return 0;
1056 }
1057
1058 void CDasherInterfaceBase::AddActionButton(const std::string &strName) {
1059   m_vRightButtons.push_back(new CActionButton(this, strName, false));
1060 }
1061
1062
1063 void CDasherInterfaceBase::OnUIRealised() {
1064   StartTimer();
1065   ChangeState(TR_UI_INIT);
1066 }
1067
1068
1069 void CDasherInterfaceBase::ChangeState(ETransition iTransition) {
1070   static EState iTransitionTable[ST_NUM][TR_NUM] = {
1071     {ST_MODEL, ST_UI, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN},
1072     {ST_FORBIDDEN, ST_NORMAL, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN},
1073     {ST_NORMAL, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN},
1074     {ST_FORBIDDEN, ST_FORBIDDEN, ST_LOCKED, ST_FORBIDDEN, ST_SHUTDOWN},
1075     {ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN, ST_NORMAL, ST_FORBIDDEN},
1076     {ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN, ST_FORBIDDEN}
1077   };
1078
1079   EState iNewState(iTransitionTable[m_iCurrentState][iTransition]);
1080
1081   if(iNewState != ST_FORBIDDEN) {
1082     LeaveState(m_iCurrentState);
1083     EnterState(iNewState);
1084
1085     m_iCurrentState = iNewState;
1086   }
1087 }
1088
1089 void CDasherInterfaceBase::LeaveState(EState iState) {
1090
1091 }
1092
1093 void CDasherInterfaceBase::EnterState(EState iState) {
1094   switch(iState) {
1095   case ST_SHUTDOWN:
1096     ShutdownTimer();
1097     break;
1098   default:
1099     // Not handled
1100     break;
1101   }
1102 }
1103
1104 void CDasherInterfaceBase::AddLock(int iLockFlags) {
1105   if(m_iLockCount == 0)
1106     ChangeState(TR_LOCK);
1107
1108   ++m_iLockCount;
1109 }
1110
1111 void CDasherInterfaceBase::ReleaseLock(int iLockFlags) {
1112   if(m_iLockCount > 0)
1113     --m_iLockCount;
1114
1115   if(m_iLockCount == 0)
1116     ChangeState(TR_UNLOCK);
1117 }