Removed warnings about initialization sequence in constructores

and unused variables and arguments

21 files changed, 118 insertions, 79 deletions

diff --git a/inputmethods/dasher/AlphIO.cpp b/inputmethods/dasher/AlphIO.cpp
index 41b1b23..96ca14a 100644
--- a/inputmethods/dasher/AlphIO.cpp
+++ b/inputmethods/dasher/AlphIO.cpp
@@ -1,83 +1,85 @@
 // AlphIO.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 
 #include "AlphIO.h"
 
 using namespace Dasher;
 using namespace std;
 
 CAlphIO::CAlphIO(string SystemLocation, string UserLocation)
-        : SystemLocation(SystemLocation), UserLocation(UserLocation),
-          BlankInfo(), CData("")
+        : BlankInfo(), 
+          SystemLocation(SystemLocation), 
+          UserLocation(UserLocation),
+          CData("")
 {
         CreateDefault();
 }
 
 
 void CAlphIO::GetAlphabets(std::vector< std::string > * AlphabetList) const
 {
         AlphabetList->clear();
         
         typedef std::map<std::string, AlphInfo>::const_iterator CI;
         CI End = Alphabets.end();
         
         for (CI Cur=Alphabets.begin(); Cur!=End; Cur++)
                 AlphabetList->push_back( (*Cur).second.AlphID);
 }
 
 
 const CAlphIO::AlphInfo& CAlphIO::GetInfo(const std::string& AlphID)
 {
         if (AlphID=="")
                 return Alphabets["Default"];
         else {
-                AlphInfo& CurInfo = Alphabets[AlphID];
+                // AlphInfo& CurInfo = Alphabets[AlphID];
                 Alphabets[AlphID].AlphID = AlphID; // Ensure consistency
                 return Alphabets[AlphID];
         }
 }
 
 
 void CAlphIO::SetInfo(const AlphInfo& NewInfo)
 {
         Alphabets[NewInfo.AlphID] = NewInfo;
 }
 
 
 void CAlphIO::Delete(const std::string& AlphID)
 {
         if (Alphabets.find(AlphID)!=Alphabets.end()) {
                 Alphabets.erase(AlphID);
         }
 }
 
 
 void CAlphIO::CreateDefault()
 {
         // TODO I appreciate these strings should probably be in a resource file.
         // Not urgent though as this is not intended to be used. It's just a
         // last ditch effort in case file I/O totally fails.
         AlphInfo& Default = Alphabets["Default"];
         Default.AlphID = "Default";
         Default.Type = Opts::Western;
         Default.Mutable = false;
         Default.Orientation = Opts::LeftToRight;
         Default.SpaceCharacter.Display = "_";
         Default.SpaceCharacter.Text = " ";
         Default.TrainingFile = "training_english_GB.txt";
         string Chars = "abcdefghijklmnopqrstuvwxyz";
         Default.Groups.resize(1);
         Default.Groups[0].Description = "Lower case Latin letters";
         Default.Groups[0].Characters.resize(Chars.size());
         for (unsigned int i=0; i<Chars.size(); i++) {
                 Default.Groups[0].Characters[i].Text = Chars[i];
                 Default.Groups[0].Characters[i].Display = Chars[i];
         }
 }
diff --git a/inputmethods/dasher/Alphabet.cpp b/inputmethods/dasher/Alphabet.cpp
index dc58b35..6327d8a 100644
--- a/inputmethods/dasher/Alphabet.cpp
+++ b/inputmethods/dasher/Alphabet.cpp
@@ -1,140 +1,140 @@
 // Alphabet.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include "Alphabet.h"
 #include "AlphabetMap.h"
 
 //#include <iostream>
 //WinCE doesn't have iostream!
 
 using namespace Dasher;
 using namespace std;
 
 
-CAlphabet::CAlphabet() : m_Groups(0), m_DefaultEncoding(Opts::Western), m_Orientation(Opts::LeftToRight)
+CAlphabet::CAlphabet() : m_DefaultEncoding(Opts::Western), m_Orientation(Opts::LeftToRight), m_Groups(0)
 {
         m_Characters.push_back("");
         m_Display.push_back("");
         m_Colours.push_back("");
         m_Foreground.push_back("");
         m_Group.push_back(0);
 }
 
 
 void CAlphabet::GetSymbols(vector<symbol>* Symbols, string* Input, bool IsMore)
 {
         string Tmp;
         symbol CurSymbol=0, TmpSymbol=0;
         bool KeyIsPrefix;
-        int z= Input->size();
+        // int z= Input->size();
         int extras;
         unsigned int bit;
 
         for (unsigned int i=0; i<Input->size(); i++) {
 
                 Tmp = (*Input)[i];
 
                 /* The string we've been given is in UTF-8. The symbols are
                    also in UTF-8, so we need to pass the entire UTF-8 character
                    which may be several bytes long. RFC 2279 describes this
                    encoding */
 
                 if ((*Input)[i] & 0x80) { // Character is more than 1 byte long
                   extras = 1;
                   for (bit = 0x20; ((*Input)[i] & bit) != 0; bit >>= 1)
                     extras++;
                   if (extras > 5) {
                   } // Malformed character
                   while (extras-->0) {
                     Tmp += (*Input)[++i];
                   }
                 }
 
                 CurSymbol = TextMap.Get(Tmp, &KeyIsPrefix);
 
                 if (KeyIsPrefix) {
                         CurSymbol = 0;
                         for (; i<Input->size(); i++) {
 
                                 Tmp += (*Input)[i];
 
                                 TmpSymbol = TextMap.Get(Tmp, &KeyIsPrefix);
                                 if (TmpSymbol>0) {
                                         CurSymbol = TmpSymbol;
                                 }
                                 if (!KeyIsPrefix) {
                                         if (CurSymbol!=0) {
                                                 Symbols->push_back(CurSymbol);
                                         } else {
                                                 i -= Tmp.size()-1;
                                                 //Tmp.erase(Tmp.begin(), Tmp.end());
                                                 Tmp = "";
                                         }
                                         break;
                                 }
                         }
                 } else {
                         if (CurSymbol!=0)
                                 Symbols->push_back(CurSymbol);
                 }
         }
 
         if (IsMore)
                 if (KeyIsPrefix)
                         *Input = Tmp;
                 else
                         *Input = "";
         else
                 if (KeyIsPrefix)
                         Symbols->push_back(CurSymbol);
 }
 
 
 // add single char to the character set
 void CAlphabet::AddChar(const string NewCharacter, const string Display, const string Colour, const string Foreground)
 {
         m_Characters.push_back(NewCharacter);
         m_Display.push_back(Display);
         m_Colours.push_back(Colour);
         m_Foreground.push_back(Foreground);
         m_Group.push_back(m_Groups);
 
         symbol ThisSymbol = m_Characters.size()-1;
         TextMap.Add(NewCharacter, ThisSymbol);
 }
 
 
 void CAlphabet::StartNewGroup()
 {
         m_Groups++;
 }
 
 
 // diagnostic dump of character set
 void CAlphabet::dump() const {
 // TODO
 /*
         dchar deb[256];
         unsigned int i;
         for (i=1;i<m_vtCharacters.size();i++) {
                 //wsprintf(deb,TEXT("%d %c %d\n"),i,m_vtCharacters[i],m_viGroup[i]); // Windows specific
                 Usprintf(deb,TEXT("%d %c %d\n"),i,m_vtCharacters[i],m_viGroup[i]);
                 DebugOutput(deb);
         }
 */
 }
 
 int CAlphabet::GetTextColour(symbol Symbol)
 {
   std::string TextColour=m_Foreground[Symbol];
   if (TextColour != "") {
     return atoi(TextColour.c_str());
   } else {
     return 0;
   }
 }
diff --git a/inputmethods/dasher/AlphabetMap.cpp b/inputmethods/dasher/AlphabetMap.cpp
index 09e2c72..c687e45 100644
--- a/inputmethods/dasher/AlphabetMap.cpp
+++ b/inputmethods/dasher/AlphabetMap.cpp
@@ -1,86 +1,86 @@
 // AlphabetMap.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include "AlphabetMap.h"
 
 using namespace Dasher;
 using namespace std;
 
 alphabet_map::alphabet_map(unsigned int InitialTableSize)
-        : Undefined(0), HashTable(InitialTableSize<<1)
+        : HashTable(InitialTableSize<<1), Undefined(0) 
 {
         Entries.reserve(InitialTableSize);
 }
 
 
 void alphabet_map::Add(const string& Key, symbol Value)
 {
         RecursiveAdd(Key, Value, false);
 }
 
 
 void alphabet_map::RecursiveAdd(const string& Key, symbol Value, bool PrefixFlag)
 {
         Entry*& HashEntry = HashTable[Hash(Key)];
         
         // Loop through Entries with the correct Hash value.
         for (Entry* i = HashEntry; i; i=i->Next) {
                 if (i->Key==Key) {
                         if (PrefixFlag) {
                                 // Just tagging - don't change symbol. Recurse if necessary
                                 i->KeyIsPrefix = true;
                                 if (Key.size()>1)
                                         RecursiveAdd(Key.substr(Key.size()-1), Undefined, true);
                         } else {
                                 // Add symbol and leave
                                 i->Symbol = Value;
                         }
                         return;
                 }
         }
         
         // When hash table gets 1/2 full...
         // (no I haven't optimised when to resize)
         if (Entries.size()<<1 >= HashTable.size()) {
                 // Double up all the storage
                 HashTable.clear();
                 HashTable.resize(Entries.size()<<2);
                 Entries.reserve(Entries.size()<<1);
                 
                 // Rehash as the pointers will all be mangled.
                 for (uint j=0; j<Entries.size(); j++) {
                         Entry*& HashEntry2 = HashTable[Hash(Entries[j].Key)];
                         Entries[j].Next = HashEntry2;
                         HashEntry2 = &Entries[j];
                 }
                 
                 // Have to recall this function as the key's hash needs recalculating
                 RecursiveAdd(Key, Value, PrefixFlag);
                 return;
         }
         
         Entries.push_back(Entry(Key, Value, HashEntry));
         HashEntry = &Entries.back();
 }
 
 
 symbol alphabet_map::Get(const string& Key, bool* KeyIsPrefix) const
 {
         // Loop through Entries with the correct Hash value.
         for (Entry* i = HashTable[Hash(Key)]; i; i=i->Next) {
                 if (i->Key==Key) {
                         if (KeyIsPrefix!=0)
                                 *KeyIsPrefix = i->KeyIsPrefix;
                         return i->Symbol;
                 }
         }
         
         if (KeyIsPrefix!=0)
                 *KeyIsPrefix = false;
         return Undefined;
 }
diff --git a/inputmethods/dasher/AlphabetMap.h b/inputmethods/dasher/AlphabetMap.h
index 3aac1f5..62f20d9 100644
--- a/inputmethods/dasher/AlphabetMap.h
+++ b/inputmethods/dasher/AlphabetMap.h
@@ -1,111 +1,111 @@
 // AlphabetMap.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 /*
 If I were just using GCC, which comes with the CGI "STL" implementation, I would
 use hash_map (which isn't part of the ANSI/ISO standard C++ STL, but hey it's nice).
 Using a plain map is just too slow for training on large files (or it is with certain
 STL implementations). I'm sure training could be made much faster still, but that's
 another matter...
 
 While I could (and probably should) get a hash_map for VC++ from
 http://www.stlport.org I thought it would be nicer if people didn't have
 to download extra stuff and then have to get it working alongside the STL
 with VC++, especially for just one small part of Dasher.
 
 The result is this:
 ***************************************************
 very much thrown together to get Dasher out ASAP.
 ***************************************************
 It is deliberately not like an STL container.
 However, as it has a tiny interface, it should still be easy to replace.
 Sorry if this seems really unprofressional.
 
 Replacing it might be a good idea. On the other hand it could be customised
 to the needs of the alphabet, so that it works faster. For example,
 currently if I have a string "asdf", it might be that "a" is checked
 then "as" is checked then "asd" is checked. I shouldn't need to keep
 rehashing the leading characters. I plan to fix that here. Doing so with
 a standard hash_map would be hard.
 
 
 Usage:
 alphabet_map MyMap(NumberOfEntriesWeExpect); // Can omit NumberOfEntriesWeExpect
 MyMap.add("asdf", 15);
 symbol i = MyMap.get("asdf") // i=15
 symbol j = MyMap.get("fdsa") // j=0
 
 You can't remove items once they are added as Dasher has no need for that.
 
 IAM 08/2002
 */
 
 #ifndef __AlphabetMap_h__
 #define __AlphabetMap_h__
 
 #include "MSVC_Unannoy.h"
 #include <vector>
 #include <string>
 
 #include "DasherTypes.h"
 
 namespace Dasher {class alphabet_map;}
 class Dasher::alphabet_map
 {
 public:
         alphabet_map(uint InitialTableSize=255);
         void Add(const std::string& Key, symbol Value);
         symbol Get(const std::string& Key, bool* KeyIsPrefix=0) const;
         
 private:
         class Entry
         {
         public:
                 Entry(std::string Key, symbol Symbol, Entry* Next)
-                        : Key(Key), Symbol(Symbol), Next(Next), KeyIsPrefix(false) {}
+                        : Key(Key), KeyIsPrefix(false), Symbol(Symbol), Next(Next) {}
                 
                 std::string Key;
                 bool KeyIsPrefix;
                 symbol Symbol;
                 Entry* Next;
         };
         
         void RecursiveAdd(const std::string& Key, symbol Value, bool PrefixFlag);
         
         // A standard hash -- could try and research something specific.
         inline uint Hash(const std::string& Input) const {
                 uint Result = 0;
         
                 typedef std::string::const_iterator CI;
                 CI Cur = Input.begin();
                 CI end = Input.end();
                 
                 while (Cur!=end) Result = (Result<<1)^*Cur++;
                 Result %= HashTable.size();
                 
                 return Result;
                 /*
                 if (Input.size()==1) // Speedup for ASCII text
                         return Input[0];
                 
                 for (int i=0; i<Input.size(); i++)
                         Result = (Result<<1)^Input[i];
 
                 
                 return Result%HashTable.size();
                 */
         }
         
         std::vector<Entry> Entries;
         std::vector<Entry*> HashTable;
         const symbol Undefined;
 };
 
 
 #endif /* #ifndef __AlphabetMap_h__ */
diff --git a/inputmethods/dasher/DashEdit.h b/inputmethods/dasher/DashEdit.h
index dc14d15..0baeec9 100644
--- a/inputmethods/dasher/DashEdit.h
+++ b/inputmethods/dasher/DashEdit.h
@@ -1,163 +1,163 @@
 //! Class definition for an edit box
 // DashEdit.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 /*
 An abstract DashEditbox class is described here.
 An implementation will handle interaction between Dasher and an actual Edit control.
 e.g. - output characters to the edit control
      - tapping on the edit box updates the Dasher display
 */
 
 #ifndef __DashEdit_h__
 #define __DashEdit_h__
 
 #include "DasherWidgetInterface.h"
 
 namespace Dasher {class CDashEditbox;}
 class Dasher::CDashEditbox
 {
 public:
-        CDashEditbox() : m_iFlushed(0), m_DasherInterface(0), m_dirty(false) {}
+        CDashEditbox() : m_dirty(false),m_iFlushed(0),  m_DasherInterface(0) {}
 
         //! Provide the Editbox with a widget interface
         virtual void SetInterface(CDasherWidgetInterface* DasherInterface) {m_DasherInterface = DasherInterface;}
         
         //! Write some buffered output to a file
         virtual void write_to_file()=0;
         
         //! Set the number of flushed characters
         //
         //! Set the number of flushed characters to an arbitrary number.
         //! Usually used to reset it to 0 after unflushing
         void set_flushed(int i) {m_iFlushed=i;}
         
         //! Provide context from the editbox for the core
         //
         //! Provide the context at the current position within the editbox to 
         //! the core. Set str to up to max characters before 
         //! the cursor position within the editbox.
         virtual void get_new_context(std::string& str, int max)=0;
         
         //! Delete flushed text from the editbox
-        virtual inline void unflush()=0;
+        virtual void unflush()=0;
         
         //! Enter a the character Symbol into the text box
         virtual void output(symbol Symbol)=0;
 
         //! Delete the previous symbol from the text box
         virtual void deletetext()=0;
         
         //! Enter a character into the text box and remember that it is flushed
         //
         //! Output the character and increment m_iFlushed. When unflush is
         //! called, remove the previous m_iFlushed characters
         virtual void flush(symbol Symbol)=0;
         
         // File I/O (optional)
 
         //! If Value is true, timestamp all new files (optional)
         //
         //! If switched on, all new files should be timestamped, either in the
         //! filename or in file metadata
-        virtual void TimeStampNewFiles(bool Value) {}
+        virtual void TimeStampNewFiles(bool ) {}
 
         //! Return true if any text has been modified since the last save (optional)
         bool IsDirty() {return m_dirty;}
 
         //! Generate a new file (optional)
         //
         //! New file - provide a file save dialogue and return the filename in
         //! filename, or provide a blank filename and present a file 
         //! save dialogue when Save() is called
-        virtual void New(const std::string& filename) {}; // filename can be "", but you cannot call Save() without having set a filename.
+        virtual void New(const std::string& ) {}; // filename can be "", but you cannot call Save() without having set a filename.
         
         //! Open a file (optional)
         //
         //! Provide a file open dialogue and set filename to the 
         //! filename. Return true if a file is chosen and opened successfully,
         //! false otherwise
-        virtual bool Open(const std::string& filename) {return false;};
+        virtual bool Open(const std::string& ) {return false;};
 
         //! Open a file and append to it (optional)
         // 
         //! Provide a file open dialogue and set filename to the 
         //! filename. The file will then have any new text appended to it. 
         //! Return true if a file is chosen and opened successfully, false 
         //! otherwise
-        virtual bool OpenAppendMode(const std::string& filename) {return false;};
+        virtual bool OpenAppendMode(const std::string& ) {return false;};
         //! Save a file as a provided filename (optional)
         // 
         //! Provide a file save dialogue and set filename to the 
         //! filename. Return true if a file is chosen and saved successfully,
         //! false otherwise
-        virtual bool SaveAs(const std::string& filename) {return false;};
+        virtual bool SaveAs(const std::string& ) {return false;};
 
         //! Save the current file (optional)
         //
         //! Save file to the current filename. If there is no current filename,
         //! or if saving fails, return false
         virtual bool Save() {return false;}; // returns false if there is no filename set, or if saving fails
         
         // Clipboard (optional)
         //! Cut selected text (optional)
         //
         //! Copy the selected text to the clipboard and remove it from the
         //! editbox
         virtual void Cut() {};
 
         //! Copy selected text (optional)
         //
         //! Copy the selected text to the clipboard
         virtual void Copy() {};
 
         //! Copy all text (optional)
         //
         //! Copy all text in the editbox to the clipboard
         virtual void CopyAll() {};
 
         //! Paste text from clipboard (optional)
         //
         //! Paste text from the clipboard into the editbox at the current
         //! position
         virtual void Paste() {};
 
         //! Select all text in the editbox (optional)
         virtual void SelectAll() {};
 
         //! Clear all text from the editbox (REQUIRED)
         virtual void Clear()=0; // Must at least be able to clear edit box
 
         //! Set the file encoding
         //
         //! Set the file encoding to the provided encoding Encoding. 
         //! The editbox is responsible for saving the file in the encoding 
         //! desired by the user. As Dasher is internally UTF8, it may well be 
         //! necessary to save in an alternative format based on locale and OS.
         virtual void SetEncoding(Opts::FileEncodingFormats Encoding)=0;
 
         //! Set the font used in the editbox
         //
         //! Set the font used in the editbox to Name and size 
         //! Size (in points)
         virtual void SetFont(std::string Name, long Size)=0;
         
 // TODO sort relationship between CDashEditbox and derived classes
 protected:
         //! Have the contents of the editbox been altered since the last save?
         bool m_dirty;
 
         //! Record the number of characters that have been flushed
         int m_iFlushed; // how many characters have been flushed
 
         //! Pointer to a DasherWidgetInterface for communication with the core
         CDasherWidgetInterface* m_DasherInterface;
 };
 
 
 #endif /* #ifndef __DashEdit_h__ */
diff --git a/inputmethods/dasher/DasherInterface.cpp b/inputmethods/dasher/DasherInterface.cpp
index bb5b85e..4699687 100644
--- a/inputmethods/dasher/DasherInterface.cpp
+++ b/inputmethods/dasher/DasherInterface.cpp
@@ -1,636 +1,653 @@
 // DasherInterface.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 
 #include "DasherInterface.h"
 //#include "EnglishAlphabet.h"
 #include "CustomAlphabet.h"
 #include "DasherViewSquare.h"
 #include "PPMLanguageModel.h"
 #include <iostream>
 namespace {
         #include "stdio.h"
 }
 using namespace Dasher;
 using namespace std;
 
 
 const string CDasherInterface::EmptyString = "";
 
 
 CDasherInterface::CDasherInterface()
-        : m_DashEditbox(0), m_DasherScreen(0), m_LanguageModel(0), TrainContext(0), m_Alphabet(0),
-          m_DasherModel(0), m_DasherView(0), AlphabetID(""), LanguageModelID(-1), ViewID(-1),
-          m_MaxBitRate(-1), m_Orientation(Opts::LeftToRight), m_SettingsStore(0), m_SettingsUI(0),
-          m_UserLocation("usr_"), m_SystemLocation("sys_"), m_AlphIO(0), m_TrainFile(""),
-          m_DasherFont(""), m_EditFont(""), m_EditFontSize(0), m_DrawKeyboard(false)
+        : m_Alphabet(0),
+          m_LanguageModel(0), 
+          m_DasherModel(0), 
+          m_DashEditbox(0), 
+          m_DasherScreen(0), 
+          m_DasherView(0), 
+          m_SettingsStore(0), 
+          m_SettingsUI(0),
+          m_AlphIO(0), 
+          TrainContext(0), 
+          AlphabetID(""), 
+          LanguageModelID(-1), 
+          ViewID(-1),
+          m_MaxBitRate(-1), 
+          m_DrawKeyboard(false),
+          m_Orientation(Opts::LeftToRight), 
+          m_UserLocation("usr_"), 
+          m_SystemLocation("sys_"), 
+          m_TrainFile(""),
+          m_DasherFont(""), 
+          m_EditFont(""), 
+          m_EditFontSize(0)
 {
 }
 
 
 CDasherInterface::~CDasherInterface()
 {
         if (m_LanguageModel)
                 m_LanguageModel->ReleaseNodeContext(TrainContext);
         delete m_DasherModel;   // The order of some of these deletions matters
         delete m_LanguageModel; // eg DasherModel has a pointer to LanguageModel.
         delete m_Alphabet;      // DM baulks if LM is deleted before it is.
         delete m_DasherView;
         // Do NOT delete Edit box or Screen. This class did not create them.
 }
 
 
 void CDasherInterface::SetSettingsStore(CSettingsStore* SettingsStore)
 {
         delete m_SettingsStore;
         m_SettingsStore = SettingsStore;
         this->SettingsDefaults(m_SettingsStore);
 }
 
 
 void CDasherInterface::SetSettingsUI(CDasherSettingsInterface* SettingsUI)
 {
         delete m_SettingsUI;
         m_SettingsUI = SettingsUI;
         //this->SettingsDefaults(m_SettingsStore);
         m_SettingsUI->SettingsDefaults(m_SettingsStore);
 }
 
 
 void CDasherInterface::SetUserLocation(std::string UserLocation)
 {
         // Nothing clever updates. (At the moment) it is assumed that
         // this is set before anything much happens and that it does
         // not require changing.
         m_UserLocation = UserLocation;
         if (m_Alphabet!=0)
                 m_TrainFile = m_UserLocation + m_Alphabet->GetTrainingFile();
 }
 
 
 void CDasherInterface::SetSystemLocation(std::string SystemLocation)
 {
         // Nothing clever updates. (At the moment) it is assumed that
         // this is set before anything much happens and that it does
         // not require changing.
         m_SystemLocation = SystemLocation;
 }
 
 
 void CDasherInterface::CreateDasherModel()
 {
 
   if (m_DashEditbox!=0 && m_LanguageModel!=0) {
     delete m_DasherModel;
     m_DasherModel = new CDasherModel(m_DashEditbox, m_LanguageModel, m_Dimensions);
     if (m_MaxBitRate>=0)
       m_DasherModel->SetMaxBitrate(m_MaxBitRate);
     if (ViewID!=-1)
       ChangeView(ViewID);
   }
 
 
 }
 
 
 void CDasherInterface::Start()
 {
         if (m_DasherModel!=0)
                 m_DasherModel->Start();
 }
 
 
 void CDasherInterface::PauseAt(int MouseX, int MouseY)
 {
         if (m_DasherView!=0)
                 m_DasherView->FlushAt(MouseX, MouseY);
         if (m_DashEditbox!=0) {
                 m_DashEditbox->write_to_file();
                 if (m_CopyAllOnStop)
                         m_DashEditbox->CopyAll();
         }
 }
 
 
 void CDasherInterface::Unpause(unsigned long Time)
 {
         if (m_DashEditbox!=0)
                 m_DashEditbox->unflush();
         if (m_DasherModel!=0)
                 m_DasherModel->Reset_framerate(Time);
 }
 
 
 void CDasherInterface::Redraw()
 {
 
   if (m_DasherView!=0) {
     m_DasherView->Render();
     m_DasherView->Display();
   }
 
 }
 
 
 void CDasherInterface::TapOn(int MouseX, int MouseY, unsigned long Time)
 {
         if (m_DasherView!=0) {
                 m_DasherView->TapOnDisplay(MouseX, MouseY, Time);
                 m_DasherView->Render();
                 if (m_DrawMouse==true) {
                   m_DasherView->DrawMouse(MouseX, MouseY);
                 }
                 if (m_DrawKeyboard==true) {
                   m_DasherView->DrawKeyboard();
                 }
                 m_DasherView->Display();
         }
         if (m_DasherModel!=0)
                 m_DasherModel->NewFrame(Time);
 }
 
 
 void CDasherInterface::ChangeAlphabet(const std::string& NewAlphabetID)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->ChangeAlphabet(NewAlphabetID);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetStringOption(Keys::ALPHABET_ID, NewAlphabetID);
         
         AlphabetID = NewAlphabetID;
         if (!m_AlphIO)
                 m_AlphIO = new CAlphIO(m_SystemLocation, m_UserLocation);
         CAlphIO::AlphInfo Info = m_AlphIO->GetInfo(NewAlphabetID);
 
         CAlphabet* old = m_Alphabet;
         m_Alphabet = new CCustomAlphabet(Info);
         
         // Apply options from alphabet
 
         m_TrainFile = m_UserLocation + m_Alphabet->GetTrainingFile();
         
         // Recreate widgets and language model
         if (m_DashEditbox!=0)
                 m_DashEditbox->SetInterface(this);
         if (m_DasherScreen!=0)
                 m_DasherScreen->SetInterface(this);
         if (LanguageModelID!=-1 || m_LanguageModel)
                 ChangeLanguageModel(LanguageModelID);
 
         delete old; // only delete old alphabet after telling all other objects not to use it
 
         Start();
 
         // We can only change the orientation after we have called
         // Start, as this will prompt a redraw, which will fail if the
         // model hasn't been updated for the new alphabet
 
         if (m_Orientation==Opts::Alphabet)
                 ChangeOrientation(Opts::Alphabet);
 
         Redraw();
 }
 
 
 void CDasherInterface::ChangeMaxBitRate(double NewMaxBitRate)
 {
         m_MaxBitRate = NewMaxBitRate;
         
         if (m_DasherModel!=0)
                 m_DasherModel->SetMaxBitrate(m_MaxBitRate);
         if (m_SettingsUI!=0)
                 m_SettingsUI->ChangeMaxBitRate(m_MaxBitRate);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetLongOption(Keys::MAX_BITRATE_TIMES100, long(m_MaxBitRate*100) );
 
         if (m_DrawKeyboard==true && m_DasherView!=NULL) {
           m_DasherView->DrawKeyboard();
         }
 }
 
 
 void CDasherInterface::ChangeLanguageModel(unsigned int NewLanguageModelID)
 {
         LanguageModelID = NewLanguageModelID;
         if (m_Alphabet!=0) {
                 if (m_LanguageModel)
                         m_LanguageModel->ReleaseNodeContext(TrainContext);
                 TrainContext = 0;
                 delete m_DasherModel; // Have to delete DasherModel, or removing its LanguageModel will confuse it
                 m_DasherModel = 0;
                 delete m_LanguageModel;
                 // TODO Use LanguageModelID to decide which model to use
                 m_LanguageModel = new CPPMLanguageModel(m_Alphabet,1<<10);
                 TrainContext = m_LanguageModel->GetRootNodeContext();
                 string T = m_Alphabet->GetTrainingFile();
                 TrainFile(m_SystemLocation+T);
                 TrainFile(m_UserLocation+T);
                 CreateDasherModel();
         }
 }
 
 
 void CDasherInterface::ChangeScreen()
 {
         if (m_DasherView!=0) {
                 m_DasherView->ChangeScreen(m_DasherScreen);
         } else {
                 if (ViewID!=-1)
                         ChangeView(ViewID);
         }
 }
 
 
 void CDasherInterface::ChangeScreen(CDasherScreen* NewScreen)
 {
         m_DasherScreen = NewScreen;
         m_DasherScreen->SetFont(m_DasherFont);
         m_DasherScreen->SetInterface(this);
         ChangeScreen();
         Redraw();
 }
 
 
 void CDasherInterface::ChangeView(unsigned int NewViewID)
 {
         //TODO Use DasherViewID
         ViewID = NewViewID;
         if (m_DasherScreen!=0 && m_DasherModel!=0) {
                 delete m_DasherView;
                 if (m_Orientation==Opts::Alphabet)
                         m_DasherView = new CDasherViewSquare(m_DasherScreen, *m_DasherModel, GetAlphabetOrientation());
                 else
                         m_DasherView = new CDasherViewSquare(m_DasherScreen, *m_DasherModel, m_Orientation);
         }
 }
 
 
 void CDasherInterface::ChangeOrientation(Opts::ScreenOrientations Orientation)
 {
         m_Orientation = Orientation;
         if (m_DasherView!=0) {
                 if (Orientation==Opts::Alphabet)
                         m_DasherView->ChangeOrientation(GetAlphabetOrientation());
                 else
                         m_DasherView->ChangeOrientation(Orientation);
         }
         if (m_SettingsUI!=0)
                 m_SettingsUI->ChangeOrientation(Orientation);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetLongOption(Keys::SCREEN_ORIENTATION, Orientation);
 }
 
 
 void CDasherInterface::SetFileEncoding(Opts::FileEncodingFormats Encoding)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->SetFileEncoding(Encoding);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetLongOption(Keys::FILE_ENCODING, Encoding);
         if (m_DashEditbox)
                         m_DashEditbox->SetEncoding(Encoding);
 }
 
 
 void CDasherInterface::ShowToolbar(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->ShowToolbar(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::SHOW_TOOLBAR, Value);
 }
 
 
 void CDasherInterface::ShowToolbarText(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->ShowToolbarText(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::SHOW_TOOLBAR_TEXT, Value);
 }
 
 
 void CDasherInterface::ShowToolbarLargeIcons(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->ShowToolbarLargeIcons(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::SHOW_LARGE_ICONS, Value);
 }
 
 
 void CDasherInterface::ShowSpeedSlider(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->ShowSpeedSlider(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::SHOW_SLIDER, Value);
 }
 
 
 void CDasherInterface::FixLayout(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->FixLayout(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::FIX_LAYOUT, Value);
 }
 
 
 void CDasherInterface::TimeStampNewFiles(bool Value)
 {
         if (m_SettingsUI!=0)
                 m_SettingsUI->TimeStampNewFiles(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::TIME_STAMP, Value);
         if (m_DashEditbox!=0)
                 m_DashEditbox->TimeStampNewFiles(Value);
 }
 
 
 void CDasherInterface::CopyAllOnStop(bool Value)
 {
         m_CopyAllOnStop = Value;
         if (m_SettingsUI!=0)
                 m_SettingsUI->CopyAllOnStop(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::COPY_ALL_ON_STOP, Value);
 }
 
 void CDasherInterface::DrawMouse(bool Value)
 {
         m_DrawMouse = Value;
         if (m_SettingsUI!=0)
                 m_SettingsUI->DrawMouse(Value);
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::DRAW_MOUSE, Value);
 }
 
 void CDasherInterface::StartOnSpace(bool Value)
 {
         m_StartSpace = Value;
         if (m_SettingsUI!=0)
           m_SettingsUI->StartOnSpace(Value);
         if (m_SettingsStore!=0)
           m_SettingsStore->SetBoolOption(Keys::START_SPACE, Value);
 }
 
 void CDasherInterface::StartOnLeft(bool Value)
 {
   m_StartLeft = Value;
         if (m_SettingsUI!=0)
           m_SettingsUI->StartOnLeft(Value);
         if (m_SettingsStore!=0)
           m_SettingsStore->SetBoolOption(Keys::START_MOUSE, Value);
 }
 
 void CDasherInterface::KeyControl(bool Value)
 {
         m_KeyControl = Value;
         if (m_SettingsUI!=0)
           m_SettingsUI->KeyControl(Value);
         if (m_SettingsStore!=0)
           m_SettingsStore->SetBoolOption(Keys::KEY_CONTROL, Value);
 }
 
 void CDasherInterface::WindowPause(bool Value)
 {
         m_KeyControl = Value;
         if (m_SettingsUI!=0)
           m_SettingsUI->WindowPause(Value);
         if (m_SettingsStore!=0)
           m_SettingsStore->SetBoolOption(Keys::WINDOW_PAUSE, Value);
 }
 
 void CDasherInterface::SetEditFont(string Name, long Size)
 {
         m_EditFont = Name;
         m_EditFontSize = Size;
         if (m_DashEditbox)
                 m_DashEditbox->SetFont(Name, Size);
         if (m_SettingsUI!=0)
                 m_SettingsUI->SetEditFont(Name, Size);
         if (m_SettingsStore!=0) {
                 m_SettingsStore->SetStringOption(Keys::EDIT_FONT, Name);
                 m_SettingsStore->SetLongOption(Keys::EDIT_FONT_SIZE, Size);
         }
 }
 
 
 void CDasherInterface::SetDasherFont(string Name)
 {
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetStringOption(Keys::DASHER_FONT, Name);
         m_DasherFont = Name;
         if (m_DasherScreen!=0)
                 m_DasherScreen->SetFont(Name);
         Redraw();
 }
 
 void CDasherInterface::SetDasherFontSize(FontSize fontsize)
 {
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetLongOption(Keys::DASHER_FONTSIZE, fontsize);
         if (m_DasherScreen!=0) {
                  m_DasherScreen->SetFontSize(fontsize);
         }
         Redraw();
 }
 
 void CDasherInterface::SetDasherDimensions(bool Value)
 {
         m_Dimensions=Value;
         if (m_SettingsStore!=0)
                 m_SettingsStore->SetBoolOption(Keys::DASHER_DIMENSIONS, Value);
         if (m_DasherModel!=0) {
                  m_DasherModel->Set_dimensions(Value);
         }
         if (m_SettingsUI!=0) {
                  m_SettingsUI->SetDasherDimensions(Value);
                 }  
 }
 
 
 unsigned int CDasherInterface::GetNumberSymbols()
 {
         if (m_Alphabet!=0)
                 return m_Alphabet->GetNumberSymbols();
         else
                 return 0;
 }
 
 
 const string& CDasherInterface::GetDisplayText(symbol Symbol)
 {
         if (m_Alphabet!=0)
                 return m_Alphabet->GetDisplayText(Symbol);
         else
                 return EmptyString;
 }
 
 
 const string& CDasherInterface::GetEditText(symbol Symbol)
 {
         if (m_Alphabet!=0)
                 return m_Alphabet->GetText(Symbol);
         else
                 return EmptyString;
 }
 
 int CDasherInterface::GetTextColour(symbol Symbol)
 {
         if (m_Alphabet!=0)
                 return m_Alphabet->GetTextColour(Symbol);
         else
                 return 0;
 }
 
 
 Opts::ScreenOrientations CDasherInterface::GetAlphabetOrientation()
 {
         return m_Alphabet->GetOrientation();
 }
 
 
 Opts::AlphabetTypes CDasherInterface::GetAlphabetType()
 {
         return m_Alphabet->GetType();
 }
 
 
 const std::string& CDasherInterface::GetTrainFile()
 {
         return m_TrainFile;
 }
 
 
 void CDasherInterface::GetAlphabets(std::vector< std::string >* AlphabetList)
 {
         if (!m_AlphIO)
                         m_AlphIO = new CAlphIO(m_SystemLocation, m_UserLocation);
         m_AlphIO->GetAlphabets(AlphabetList);
 }
 
 
 const CAlphIO::AlphInfo& CDasherInterface::GetInfo(const std::string& AlphID)
 {
         if (!m_AlphIO)
                 m_AlphIO = new CAlphIO(m_SystemLocation, m_UserLocation);
         
         return m_AlphIO->GetInfo(AlphID);
 }
 
 
 void CDasherInterface::SetInfo(const CAlphIO::AlphInfo& NewInfo)
 {
         if (!m_AlphIO)
                 m_AlphIO = new CAlphIO(m_SystemLocation, m_UserLocation);
         
         m_AlphIO->SetInfo(NewInfo);
 }
 
 
 void CDasherInterface::DeleteAlphabet(const std::string& AlphID)
 {
         if (!m_AlphIO)
                 m_AlphIO = new CAlphIO(m_SystemLocation, m_UserLocation);
         
         m_AlphIO->Delete(AlphID);
 }
 
 
 void CDasherInterface::ChangeEdit()
 {
         CreateDasherModel();
         if (m_DasherModel!=0)
                 m_DasherModel->Start();
         if (m_DasherView!=0)
                 m_DasherView->Render();
 }
 
 
 void CDasherInterface::ChangeEdit(CDashEditbox* NewEdit)
 {
         m_DashEditbox = NewEdit;
         m_DashEditbox->SetFont(m_EditFont, m_EditFontSize);
         m_DashEditbox->SetInterface(this);
         if (m_SettingsStore!=0)
                 m_DashEditbox->TimeStampNewFiles(m_SettingsStore->GetBoolOption(Keys::TIME_STAMP));
         m_DashEditbox->New("");
         ChangeEdit();
 }
 
 
 void CDasherInterface::Train(string* TrainString, bool IsMore)
 {
         m_LanguageModel->LearnText(TrainContext, TrainString, IsMore);
         return;
 }
 
 
 /*
         I've used C style I/O because I found that C++ style I/O bloated
         the Win32 code enormously. The overhead of loading the buffer into
         the string instead of reading straight into a string seems to be
         negligible compared to huge requirements elsewhere.
 */
 void CDasherInterface::TrainFile(string Filename)
 {
         if (Filename=="")
                 return;
         
         FILE* InputFile;
         if ( (InputFile = fopen(Filename.c_str(), "r")) == (FILE*)0)
                 return;
         
         const int BufferSize = 1024;
         char InputBuffer[BufferSize];
         string StringBuffer;
         int NumberRead;
         
         do {
                 NumberRead = fread(InputBuffer, 1, BufferSize-1, InputFile);
                 InputBuffer[NumberRead] = '\0';
                 StringBuffer += InputBuffer;
                 if (NumberRead == (BufferSize-1)) {
                   m_LanguageModel->LearnText(TrainContext, &StringBuffer, true);
                 } else {
                   m_LanguageModel->LearnText(TrainContext, &StringBuffer, false);
                 }
         } while (NumberRead==BufferSize-1);
 
         fclose(InputFile);
 }
 
 void CDasherInterface::GetFontSizes(std::vector<int> *FontSizes)
 {
   FontSizes->push_back(20);
   FontSizes->push_back(14);
   FontSizes->push_back(11);
   FontSizes->push_back(40);
   FontSizes->push_back(28);
   FontSizes->push_back(22);
   FontSizes->push_back(80);
   FontSizes->push_back(56);
   FontSizes->push_back(44);
 }
   
 
 double CDasherInterface::GetCurCPM()
 {
         //
         return 0;
 }
 
 
 double CDasherInterface::GetCurFPS()
 {
         //
         return 0;
 }
diff --git a/inputmethods/dasher/DasherInterface.h b/inputmethods/dasher/DasherInterface.h
index 6338801..7c4496f 100644
--- a/inputmethods/dasher/DasherInterface.h
+++ b/inputmethods/dasher/DasherInterface.h
@@ -1,170 +1,170 @@
 // DasherInterface.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 
 #ifndef __DasherInterface_h__
 #define __DasherInterface_h__
 
 // TODO - there is a list of things to be configurable in my notes
 // Check that everything that is not self-contained within the GUI is covered.
 
 #include "MSVC_Unannoy.h"
 #include "NoClones.h"
 
 #include "DasherWidgetInterface.h"
 #include "DasherAppInterface.h"
 #include "DasherSettingsInterface.h"
 
 #include "DasherScreen.h"
 #include "Alphabet.h"
 #include "AlphIO.h"
 #include "LanguageModel.h"
 #include "DasherModel.h"
 #include "DashEdit.h"
 #include "DasherView.h"
 
 #include "MSVC_Unannoy.h"
 #include <map>
 
 namespace Dasher {class CDasherInterface;}
 class Dasher::CDasherInterface : private NoClones,
         public CDasherWidgetInterface, public CDasherAppInterface, public CDasherSettingsInterface
 {
 public:
         CDasherInterface();
-        ~CDasherInterface();
+        virtual ~CDasherInterface();
 
         //! Tell the core which CSettingsStore should be used
         void SetSettingsStore(CSettingsStore* SettingsStore);
 
         //! Tell the core which CDasherSettingsInterface should be used
         //
         //! Provide a pointer to an instance of CDasherSettingsInterface in 
         //! order to allow for platform dependent configuration of certain 
         //! options
         void SetSettingsUI(CDasherSettingsInterface* SettingsUI);
         
         //! Set the path for user specific configuration and files
         void SetUserLocation(std::string UserLocation);
 
         //! Set the path for system-wide configuration and files
         void SetSystemLocation(std::string SystemLocation);
         
         // Widget Interface
         // -----------------------------------------------------
         void Start();
         
         void TapOn(int MouseX, int MouseY, unsigned long Time); // Times in milliseconds
         void PauseAt(int MouseX, int MouseY);                   // are required to make
         void Unpause(unsigned long Time);                       // Dasher run at the
         void Redraw();                                          // correct speed.
         
         void ChangeScreen(); // The widgets need to tell the engine when they have been
         void ChangeEdit();   // affected by external interaction
         
         unsigned int GetNumberSymbols();           // These are needed so widgets know
         const std::string& GetDisplayText(symbol Symbol); // how to render the alphabet. All
         const std::string& GetEditText(symbol Symbol);    // strings are encoded in UTF-8
         int GetTextColour(symbol Symbol);    // the foreground colour of the text
         Opts::ScreenOrientations GetAlphabetOrientation();
         Opts::AlphabetTypes GetAlphabetType();
         const std::string& GetTrainFile();
         
         // App Interface
         // -----------------------------------------------------
         
         // std::map<int, std::string>& GetAlphabets(); // map<key, value> int is a UID string can change. Store UID in preferences. Display string to user.
         // std::vector<std::string>& GetAlphabets();
         // std::vector<std::string>& GetLangModels();
         // std::vector<std::string>& GetViews();
         
         void ChangeScreen(CDasherScreen* NewScreen); // We may change the widgets Dasher uses
         void ChangeEdit(CDashEditbox* NewEdit);      // at run time.
         
         void Train(std::string* TrainString, bool IsMore); // Training by string segments or file
         void TrainFile(std::string Filename);              // all training data must be in UTF-8.
 
         void GetFontSizes(std::vector<int> *FontSizes);
         
         double GetCurCPM(); // App may want to display characters per minute
         double GetCurFPS(); // or frames per second.
         
         // Customize alphabet
         void GetAlphabets(std::vector< std::string >* AlphabetList);
         const CAlphIO::AlphInfo& GetInfo(const std::string& AlphID);
         void SetInfo(const CAlphIO::AlphInfo& NewInfo);
         void DeleteAlphabet(const std::string& AlphID);
         
         // Settings Interface (options saved between sessions)
         // -----------------------------------------------------
         
         void ChangeAlphabet(const std::string& NewAlphabetID);
         void ChangeMaxBitRate(double NewMaxBitRate);
         void ChangeLanguageModel(unsigned int NewLanguageModelID);
         void ChangeView(unsigned int NewViewID);
         void ChangeOrientation(Opts::ScreenOrientations Orientation);
         void SetFileEncoding(Opts::FileEncodingFormats Encoding);
         // TODO Color customization.
         
         void ShowToolbar(bool Value);
         void ShowToolbarText(bool Value);
         void ShowToolbarLargeIcons(bool Value);
         void ShowSpeedSlider(bool Value);
         void FixLayout(bool Value);
         void TimeStampNewFiles(bool Value);
         void CopyAllOnStop(bool Value);
         void DrawMouse(bool Value);
         void StartOnSpace(bool Value);
         void StartOnLeft(bool Value);
         void KeyControl(bool Value);
         void WindowPause(bool Value);
         void SetEditFont(std::string Name, long Size);
         void SetDasherFont(std::string Name);
         void SetDasherFontSize(FontSize fontsize);
         void SetDasherDimensions(bool Value);
 
 private:
         CAlphabet* m_Alphabet;
         CLanguageModel* m_LanguageModel;
         CDasherModel* m_DasherModel;
         CDashEditbox* m_DashEditbox;
         CDasherScreen* m_DasherScreen;
         CDasherView* m_DasherView;
         CSettingsStore* m_SettingsStore;
         CDasherSettingsInterface* m_SettingsUI;
         CAlphIO* m_AlphIO;
         
         CLanguageModel::CNodeContext* TrainContext;
         
         std::string AlphabetID;
         int LanguageModelID;
         int ViewID;
         double m_MaxBitRate;
         bool m_CopyAllOnStop;
         bool m_DrawMouse;
         bool m_DrawKeyboard;
         bool m_StartSpace;
         bool m_StartLeft;
         bool m_KeyControl;
         bool m_Dimensions;
         bool m_WindowPause;
         Opts::ScreenOrientations m_Orientation;
         std::string m_UserLocation;
         std::string m_SystemLocation;
         std::string m_TrainFile;
         std::string m_DasherFont;
         std::string m_EditFont;
         int m_EditFontSize;
         static const std::string EmptyString;
         
         void CreateDasherModel();
 };
 
 
 #endif /* #ifndef __DasherInterface_h__ */
diff --git a/inputmethods/dasher/DasherModel.cpp b/inputmethods/dasher/DasherModel.cpp
index 0450d66..f15fa49 100644
--- a/inputmethods/dasher/DasherModel.cpp
+++ b/inputmethods/dasher/DasherModel.cpp
@@ -1,322 +1,322 @@
 // DasherModel.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include <iostream>
 #include "DasherModel.h"
 
 using namespace Dasher;
 using namespace std;
 
 //////////////////////////////////////////////////////////////////////
 // CDasherModel
 //////////////////////////////////////////////////////////////////////
 
 CDasherModel::CDasherModel(CDashEditbox* Editbox, CLanguageModel* LanguageModel, bool Dimensions)
-  : m_editbox(Editbox), m_languagemodel(LanguageModel), m_Root(0), m_Dimensions(Dimensions)
+  : m_Dimensions(Dimensions), m_editbox(Editbox), m_languagemodel(LanguageModel), m_Root(0)
 {
         LearnContext = m_languagemodel->GetRootNodeContext();
         
         // various settings
         int iShift = 12;
         m_DasherY = 1<<iShift;
         m_DasherOY = m_DasherY/2;
         m_DasherOX = m_DasherY/2;
         m_dAddProb = 0.003;
 }
 
 
 CDasherModel::~CDasherModel()
 {
         m_languagemodel->ReleaseNodeContext(LearnContext);
         delete m_Root;  // which will also delete all the whole structure
 }
 
 
 void CDasherModel::Make_root(int whichchild)
  // find a new root node 
 {
         symbol t=m_Root->Symbol();
         if (t) {
                 m_editbox->output(t);
                 m_languagemodel->LearnNodeSymbol(LearnContext, t);
         }
 
         CDasherNode * oldroot=m_Root;
         
         CDasherNode **children=m_Root->Children();
         m_Root=children[whichchild];
                 //oldroot->Children()[whichchild]=0;  // null the pointer so we don't delete the whole tree
                 //delete oldroot;
         
         oldroots.push_back(oldroot);
 
         myint range=m_Rootmax-m_Rootmin;
         m_Rootmax=m_Rootmin+(range*m_Root->Hbnd())/Normalization();
         m_Rootmin+=(range*m_Root->Lbnd())/Normalization();
 }
 
 void CDasherModel::Reparent_root(int lower, int upper)
 {
   /* Change the root node to the parent of the existing node
      We need to recalculate the coordinates for the "new" root as the 
      user may have moved around within the current root */
 
   /* Determine how zoomed in we are */
         float scalefactor=(m_Rootmax-m_Rootmin)/(upper-lower);
 
         m_Rootmax=int(m_Rootmax+((1024-upper)*scalefactor));
         m_Rootmin=int(m_Rootmin-(lower*scalefactor));
 
         m_editbox->deletetext();
 
         m_Root=oldroots.back();
         oldroots.pop_back();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 CDasherNode * CDasherModel::Get_node_under_crosshair()
 {
         return m_Root->Get_node_under(Normalization(),m_Rootmin,m_Rootmax,m_DasherOX,m_DasherOY);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 
 CDasherNode * CDasherModel::Get_node_under_mouse(myint Mousex,myint Mousey)
 {
         return m_Root->Get_node_under(Normalization(),m_Rootmin,m_Rootmax,Mousex,Mousey);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 
 void CDasherModel::Get_string_under_mouse(const myint Mousex,const myint Mousey, vector<symbol> &str)
 {
         m_Root->Get_string_under(Normalization(),m_Rootmin,m_Rootmax,Mousex,Mousey,str);
         return;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 
-void CDasherModel::Flush(const myint Mousex,const myint Mousey)
+void CDasherModel::Flush(const myint ,const myint )
 {
         vector<symbol> vtUnder;
         Get_string_under_mouse(m_DasherOX,m_DasherOY,vtUnder);
         unsigned int i;
         for (i=0;i<vtUnder.size();i++) {
           if (vtUnder[i]==0)
             continue;
           m_editbox->flush(vtUnder[i]);
         }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherModel::Update(CDasherNode *node,CDasherNode *under_mouse,int iSafe)
 // go through the Dasher nodes, delete ones who have expired
 // decrease the time left for nodes which arent safe
 // safe nodes are those which are under the mouse or offspring of this node
 {
         //if (node->pushme )
         //      node->push_node();
         if (node==under_mouse)
                 iSafe=1;
         if (!iSafe)
                 node->Age();
         //dchar debug[256];
         //wsprintf(debug,TEXT("node->Age %d %f\n"),node->Age, fr.framerate());
         //OutputDebugString(debug);
         
         
         if (node->Age() > Framerate())
                 node->Kill();
         
         
         if (node->Alive()) {
                 CDasherNode **children=node->Children();
                 if (children) {
                         unsigned int i;
                         for (i=1;i<node->Chars();i++)
                                 Update(children[i],under_mouse,iSafe);
                 }
         }
         return;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherModel::Start()
 {
         m_Rootmin=0;
         m_Rootmax=m_DasherY;
         
         delete m_Root;
         CLanguageModel::CNodeContext* therootcontext=m_languagemodel->GetRootNodeContext();
         
                 //Rootparent=new DasherNode(0,0,0,therootcontext,0,0,0,Normalization(),languagemodel);
         if (m_editbox) {
                 m_editbox->set_flushed(0);
                 string ContextString;
                 m_editbox->get_new_context(ContextString,5);
                 if (ContextString.size() != 0) {
                   m_languagemodel->EnterText(therootcontext, ContextString);
                 }
                 m_languagemodel->ReleaseNodeContext(LearnContext);
                 LearnContext = m_languagemodel->CloneNodeContext(therootcontext);
         }
         m_Root=new CDasherNode(0,0,0,0,Opts::Nodes1,0,Normalization(),m_languagemodel);
         m_Root->Push_Node(therootcontext);
         
         m_languagemodel->ReleaseNodeContext(therootcontext);
         //ppmmodel->dump();
         //dump();
         
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherModel::Get_new_root_coords(myint Mousex,myint Mousey)
 {
-        int cappedrate=0;
+        // int cappedrate=0;
         double dRx=1.0,dRxnew=1.0;
         double dRxnew2;
 
         int iSteps=m_fr.Steps();
 
         if (Mousex<m_DasherOX) {
                 //rx=1.0001*Ixmap[mx]/Ixmap[cx];
                 if (Mousex<=0)
                         Mousex=1;
                 dRx=1.0*m_DasherOX/Mousex;
                 dRxnew=pow(dRx,1.0/iSteps);  // or exp(log(rx)/steps) - i think the replacement is faster   
         
                 dRxnew2=1+(dRx-1)/iSteps;
                 //+(rx-1)*(rx-1)*(1.0/fr.steps()-1.0)/2/fr.steps();
                 
 
                 const double dRxmax=m_fr.Rxmax();
                 if (dRxnew>dRxmax)
                  dRxnew=dRxmax;
                         //      cappedrate=1;
         } else {
                 if (Mousex==m_DasherOX)
                         Mousex++;
                 //      OutputDebugString(TEXT("zoom out\n"));
                 dRx=1.0001*m_DasherOX/Mousex;
                 dRxnew=exp(log(dRx)/iSteps);
                 //get_coords(root->lbnd,root->hbnd,&x1,&y1,&y2);
                 //if (x1>0 || y1>0 || y2<CanvasY)
                 //go_back_a_char();
                 if (m_Rootmax<m_DasherY && m_Rootmin>0)
                         return;
         } 
         //dchar debug[256];
         //_stprintf(debug,TEXT("rx %f rxnew %f approx %f\n"),rx,rxnew,rxnew2);
         //OutputDebugString(debug);
         //wsprintf(debug,TEXT("rx %f rxnew %f\n"),rx,rxnew);
         //OutputDebugString(debug);
         myint above=(Mousey-m_Rootmin);//*(1-rxnew)/(1-rx);
         myint below=(m_Rootmax-Mousey);//*(1-rxnew)/(1-rx);
 
         //wsprintf(debug,TEXT("above %I64d below %I64d \n"),above,below);
         //OutputDebugString(debug);
 
         myint miDistance=m_DasherY/2-Mousey;
         miDistance=myint(miDistance*(dRxnew-1)/(dRx-1));
         myint miNewrootzoom=Mousey+miDistance;
 
         myint newRootmax=miNewrootzoom+myint(below*dRxnew);
         myint newRootmin=miNewrootzoom-myint(above*dRxnew);
         if (newRootmin<m_DasherY/2 && newRootmax>m_DasherY/2 && newRootmax<LLONG_MAX && newRootmin>LLONG_MIN) {
                 m_Rootmax=newRootmax;
                         m_Rootmin=newRootmin;
         }
 
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-void CDasherModel::Tap_on_display(myint miMousex,myint miMousey, unsigned long Time) 
+void CDasherModel::Tap_on_display(myint miMousex,myint miMousey, unsigned long ) 
         // work out the next viewpoint, opens some new nodes
 {
         // works out next viewpoint
         Get_new_root_coords(miMousex,miMousey);
 
         // opens up new nodes
 
         // push node under mouse
         CDasherNode *under_mouse=Get_node_under_mouse(miMousex,miMousey);
         under_mouse->Push_Node();
 
 
         if (Framerate() > 4) {
                 // push node under mouse but with x coord on RHS
                 CDasherNode *right=Get_node_under_mouse(50,miMousey);
                 right->Push_Node();
         }
 
         if (Framerate() > 8) {
                 // push node under the crosshair
                 CDasherNode *under_cross=Get_node_under_crosshair();
                 under_cross->Push_Node();
         }
 
         unsigned int iRandom;
 #if defined(_WIN32_WCE)
         iRandom=Random();
 #else
         iRandom=rand();
 #endif
         if (Framerate() > 8) {
                 // add some noise and push another node
                 CDasherNode *right=Get_node_under_mouse(50,miMousey+iRandom%500-250);
                 right->Push_Node();
         }
 #if defined(_WIN32_WCE)
         iRandom=Random();
 #else
         iRandom=rand();
 #endif
         if (Framerate() > 15) {
                 // add some noise and push another node
                 CDasherNode *right=Get_node_under_mouse(50,miMousey+iRandom%500-250);
                 right->Push_Node();
         }
 
         // only do this is Dasher is flying
         if (Framerate() > 30) {
                 for (int i=1;i<int(Framerate()-30)/3;i++) {
         #if defined(_WIN32_WCE)
                 iRandom=Random();
 #else
                 iRandom=rand();
 #endif
                 // push at a random node on the RHS
                 CDasherNode *right=Get_node_under_mouse(50,miMousey+iRandom%1000-500);
                 right->Push_Node();
         
                 }
         }
         Update(m_Root,under_mouse,0);
 
 
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherModel::Dump() const 
         // diagnostic dump
 {
                 // OutputDebugString(TEXT(" ptr   symbol   context Next  Child    pushme pushed cscheme   lbnd  hbnd \n"));
                 m_Root->Dump_node();
 }
 
 
 
diff --git a/inputmethods/dasher/DasherNode.cpp b/inputmethods/dasher/DasherNode.cpp
index 26af10f..3a984ef 100644
--- a/inputmethods/dasher/DasherNode.cpp
+++ b/inputmethods/dasher/DasherNode.cpp
@@ -1,167 +1,167 @@
 // DasherNode.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include "DasherNode.h"
 using namespace Dasher;
 using namespace Opts;
 using namespace std;
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherNode::Dump_node () const
         { 
         /* TODO sort out
         dchar out[256];
         if (m_Symbol)
                 wsprintf(out,TEXT("%7x %3c %7x %5d %7x  %5d %8x %8x      \n"),this,m_Symbol,m_iGroup,m_context,m_Children,m_Cscheme,m_iLbnd,m_iHbnd);
         else
                 wsprintf(out,TEXT("%7x     %7x %5d %7x  %5d %8x %8x      \n"),this,m_iGroup,m_context,m_Children,m_Cscheme,m_iLbnd,m_iHbnd);
         
         OutputDebugString(out);
         
         if (m_Children) {
                 unsigned int i; 
                 for (i=1;i<m_iChars;i++)
                         m_Children[i]->Dump_node();
         }
         */
 }
 
-void CDasherNode::Generic_Push_Node(CLanguageModel::CNodeContext *context) {
+void CDasherNode::Generic_Push_Node(CLanguageModel::CNodeContext *) {
 
         m_iAge=0;
         m_bAlive=true;
         if (m_Symbol && !m_iChars)   // make sure it's a valid symbol and don't enter if already done
                 m_languagemodel->EnterNodeSymbol(m_context,m_Symbol);
 
         
         vector<symbol> newchars;   // place to put this list of characters
         vector<unsigned int> cum,groups;   // for the probability list
         m_languagemodel->GetNodeProbs(m_context,newchars,groups,cum,0.003);
         m_iChars=newchars.size();
         // work out cumulative probs
         unsigned int i;
         for (i=1;i<m_iChars;i++)
                 cum[i]+=cum[i-1];
 
         m_Children =new CDasherNode *[m_iChars];
 
         // create the children
         ColorSchemes NormalScheme, SpecialScheme;
         if ((m_ColorScheme==Nodes1) || (m_ColorScheme==Special1)) {
                 NormalScheme = Nodes2;
                 SpecialScheme = Special2;
         } else {
                 NormalScheme = Nodes1;
                 SpecialScheme = Special1;
         }
         
         ColorSchemes ChildScheme;
         for (i=1;i<m_iChars;i++) {
                 if (newchars[i]==this->m_languagemodel->GetSpaceSymbol())
                         ChildScheme = SpecialScheme;
                 else
                         ChildScheme = NormalScheme;
                 m_Children[i]=new CDasherNode(this,newchars[i],groups[i],i,ChildScheme,cum[i-1],cum[i],m_languagemodel,m_languagemodel->GetColour(i));
         }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherNode::Push_Node(CLanguageModel::CNodeContext *context) 
 // push a node copying the specified context
 {
 
         if (m_Children) {
                 // if there are children just give them a poke
                 unsigned int i;
                 for (i=1;i<m_iChars;i++) {
                         m_Children[i]->m_iAge=0;
                         m_Children[i]->m_bAlive=1;
                 }
                 return;
         }
 
         // if we haven't got a context then try to get a new one
         m_context=m_languagemodel->CloneNodeContext(context);
         // if it fails, be patient
         if (!m_context)
                 return;
         Generic_Push_Node(m_context);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherNode::Push_Node() 
 {
 
         if (m_Children) {
                 // if there are children just give them a poke
                 unsigned int i;
                 for (i=1;i<m_iChars;i++) {
                         m_Children[i]->m_iAge=0;
                         m_Children[i]->m_bAlive=1;
                 }
                 return;
         }
 
         // if we haven't got a context then try to get a new one
         if (m_parent) 
                 m_context=m_languagemodel->CloneNodeContext(m_parent->m_context);
         else
                 m_context=m_languagemodel->GetRootNodeContext();
         
         // if it fails, be patient
         if (!m_context)
                 return;
         Generic_Push_Node(m_context);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 void CDasherNode::Get_string_under(const int iNormalization,const myint miY1,const myint miY2,const myint miMousex,const myint miMousey, vector<symbol> &vString) const
 {
         // we are over (*this) node so add it to the string 
         vString.push_back(m_Symbol);
         
         // look for children who might also be under the coords
         if (m_Children) {
                 myint miRange=miY2-miY1;
                 unsigned int i;
                 for (i=1;i<m_iChars;i++) {
                         myint miNewy1=miY1+(miRange*m_Children[i]->m_iLbnd)/iNormalization;
                         myint miNewy2=miY1+(miRange*m_Children[i]->m_iHbnd)/iNormalization;
                         if (miMousey<miNewy2 && miMousey>miNewy1 && miMousex<miNewy2-miNewy1) {
                                 m_Children[i]->Get_string_under(iNormalization,miNewy1,miNewy2,miMousex,miMousey,vString);
                                 return;
                         }
                 }
         }
         return;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 CDasherNode * const CDasherNode::Get_node_under(int iNormalization,myint miY1,myint miY2,myint miMousex,myint miMousey) 
 {
         if (m_Children) {
                 myint miRange=miY2-miY1;
                 m_iAge=0;
                 m_bAlive=true;
                 unsigned int i;
                 for (i=1;i<m_iChars;i++) {
                         myint miNewy1=miY1+(miRange*m_Children[i]->m_iLbnd)/iNormalization;
                         myint miNewy2=miY1+(miRange*m_Children[i]->m_iHbnd)/iNormalization;
                 if (miMousey<miNewy2 && miMousey>miNewy1 && miMousex<miNewy2-miNewy1) 
                                 return m_Children[i]->Get_node_under(iNormalization,miNewy1,miNewy2,miMousex,miMousey);
                 }
         }
         return this;
 }
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/inputmethods/dasher/DasherNode.h b/inputmethods/dasher/DasherNode.h
index 705a9d4..fb00d47 100644
--- a/inputmethods/dasher/DasherNode.h
+++ b/inputmethods/dasher/DasherNode.h
@@ -1,127 +1,141 @@
 // DasherNode.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef __DasherNode_h__
 #define __DasherNode_h__
 
 #include "NoClones.h"
 #include "DasherTypes.h"
 #include "LanguageModel.h"
 
 namespace Dasher {class CDasherNode;}
 class Dasher::CDasherNode : private NoClones
 {
         // CDasherNode represents a rectangle and character 
         // nodes have children, siblings and parents
 private:
         const unsigned int m_iLbnd,m_iHbnd;// the cumulative lower and upper bound prob relative to parent
         const unsigned int m_iGroup;       // group membership - e.g. 0=nothing 1=caps 2=punc
         unsigned int m_iChars, m_iAge;
         bool m_bAlive;                     // if true, then display node, else dont bother
         bool m_bControlNode;               // if true, node is a control node
         bool m_bControlChild;              // if true, node is offspring of a control node
         //bool m_Cscheme;                  // color scheme for the node - alternates through relatives
         Opts::ColorSchemes m_ColorScheme;
         int m_iPhase;                      // index for coloring
         int m_iColour;                     // for the advanced colour mode
         
         const symbol m_Symbol;             // the character to display
                 CLanguageModel *m_languagemodel;   // pointer to the language model - in future, could be different for each node
         CDasherNode **m_Children;          // pointer to array of children
         CDasherNode *m_parent;             // pointer to parent - only needed to grab parent context
         CLanguageModel::CNodeContext *m_context;
 public:
         
         CDasherNode(CDasherNode *parent,symbol Symbol, unsigned int igroup, int iphase, Opts::ColorSchemes ColorScheme,int ilbnd,int ihbnd,CLanguageModel *lm, int Colour);
         ~CDasherNode();
         bool m_bForce;                     // flag to force a node to be drawn - shouldn't be public
     
         // return private data members - read only 
         CDasherNode ** const Children() const {return m_Children;}
         unsigned int Lbnd() const {return m_iLbnd;}
         bool Alive() {return m_bAlive;}
         bool Control() {return m_bControlChild;}
         void Kill()  {m_bAlive=0;m_iAge=0;}
         unsigned int Hbnd() const {return m_iHbnd;}
         unsigned int Group() const {return m_iGroup;}
         unsigned int Age() const {return m_iAge;}
         symbol Symbol() const {return m_Symbol;}
         unsigned int Chars() const {return m_iChars;}
         int Phase() const {return m_iPhase;}
         Opts::ColorSchemes Cscheme() const {return m_ColorScheme;}
         int Colour() const {return m_iColour;}
         
         CDasherNode* const Get_node_under(int,myint y1,myint y2,myint smousex,myint smousey); // find node under given co-ords
         void Get_string_under(const int,const myint y1,const myint y2,const myint smousex,const myint smousey,std::vector<symbol>&) const; // get string under given co-ords
         void Generic_Push_Node(CLanguageModel::CNodeContext *context);
         void Push_Node();                                      // give birth to children
         void Push_Node(CLanguageModel::CNodeContext *context); // give birth to children with this context
         void Delete_children();
         void Dump_node() const;                                // diagnostic
 };
 
 /////////////////////////////////////////////////////////////////////////////
 // Inline functions
 /////////////////////////////////////////////////////////////////////////////
 
 using namespace Dasher;
 using namespace Opts;
 
 /////////////////////////////////////////////////////////////////////////////
 
-inline CDasherNode::CDasherNode(CDasherNode *parent,symbol Symbol, unsigned int igroup, int iphase, ColorSchemes ColorScheme,int ilbnd,int ihbnd,CLanguageModel *lm, int Colour=0)
-        : m_parent(parent),m_Symbol(Symbol),m_iGroup(igroup),m_iLbnd(ilbnd),m_iHbnd(ihbnd),m_languagemodel(lm),m_iPhase(iphase),
-  m_context(0), m_iAge(0), m_bAlive(1), m_Children(0), m_bForce(false), m_iChars(0), m_ColorScheme(ColorScheme), m_bControlChild(false), m_iColour(Colour)
+inline CDasherNode::CDasherNode(CDasherNode *parent,symbol Symbol, unsigned int igroup, int iphase, ColorSchemes ColorScheme,int ilbnd,int ihbnd,CLanguageModel *lm, int Colour=0) :
+           m_iLbnd(ilbnd),
+          m_iHbnd(ihbnd),
+          m_iGroup(igroup),
+          m_iChars(0), 
+          m_iAge(0), 
+          m_bAlive(1), 
+          m_bControlChild(false),
+          m_ColorScheme(ColorScheme), 
+          m_iPhase(iphase),
+          m_iColour(Colour),
+          m_Symbol(Symbol),
+          m_languagemodel(lm),
+          m_Children(0), 
+          m_parent(parent),
+          m_context(0),  
+          m_bForce(false)
 {
         /*
         switch (ColorScheme) {
                 case Nodes1:
                         m_ColorScheme = Nodes2;
                         break;
                 case Nodes2:
                         m_ColorScheme = Nodes1;
                         break;
                 case Special1:
                         m_ColorScheme = Special2;
                         break;
                 case Special2:
                         m_ColorScheme = Special1;
                         break;
                 case default:
                         m_ColorScheme = ColorScheme;
                         break;
         }
         */
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 inline void CDasherNode::Delete_children() 
 {
         if (m_Children) {
                 unsigned int i; 
                 for (i=1;i<m_iChars;i++)
                         delete m_Children[i];
                 delete [] m_Children;
         }
         m_Children=0;
         
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 inline CDasherNode::~CDasherNode() 
 {
         Delete_children();
         if (m_context)
                 m_languagemodel->ReleaseNodeContext(m_context);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 #endif /* #ifndef __DasherNode_h__ */
diff --git a/inputmethods/dasher/DasherSettingsInterface.h b/inputmethods/dasher/DasherSettingsInterface.h
index 9d03eba..34b55d4 100644
--- a/inputmethods/dasher/DasherSettingsInterface.h
+++ b/inputmethods/dasher/DasherSettingsInterface.h
@@ -1,149 +1,149 @@
 // DasherSettingsInterface.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 #ifndef __DasherSettingsInterface_h__
 #define __DasherSettingsInterface_h__
 
 #include "DasherTypes.h"
 #include "SettingsStore.h"
 
 namespace Dasher {class CDasherSettingsInterface;}
 class Dasher::CDasherSettingsInterface
 {
 public:
         void SettingsDefaults(CSettingsStore* Store);
         
         // These actually affect the way Dasher works
         //! Change the alphabet in use to NewAlphabetID
-        virtual void ChangeAlphabet(const std::string& NewAlphabetID) {};
+        virtual void ChangeAlphabet(const std::string& ) {};
 
         //! Change the maximum bitrate (effectively the speed) of Dasher
-        virtual void ChangeMaxBitRate(double NewMaxBitRate) {};
+        virtual void ChangeMaxBitRate(double ) {};
 
         //! Generate a new langage model. Not usually needed
-        virtual void ChangeLanguageModel(unsigned int NewLanguageModelID) {};
+        virtual void ChangeLanguageModel(unsigned int ) {};
 
         //! Generate a new view of the model. Call it with 0 when starting up
-        virtual void ChangeView(unsigned int NewViewID) {};
+        virtual void ChangeView(unsigned int ) {};
 
         //! Change the orientation (l->r, r->l, so on) of the model
-        virtual void ChangeOrientation(Opts::ScreenOrientations Orientation) {};
+        virtual void ChangeOrientation(Opts::ScreenOrientations ) {};
 
         //! Set the file encoding of output files to Encoding
-        virtual void SetFileEncoding(Opts::FileEncodingFormats Encoding) {};
+        virtual void SetFileEncoding(Opts::FileEncodingFormats ) {};
 
         //! Inform the core that the screen has this size
-        virtual void SetScreenSize(long Width, long Height) {};
+        virtual void SetScreenSize(long , long ) {};
         
         //! Set the size of the font used in the Dasher canvas
-        virtual void SetDasherFontSize(Dasher::Opts::FontSize fontsize) {};
+        virtual void SetDasherFontSize(Dasher::Opts::FontSize ) {};
 
         //! Set the number of dimensions of input (either 1 or 2)
-        virtual void SetDasherDimensions(bool Value) {};
+        virtual void SetDasherDimensions(bool ) {};
 
         // These are recommended options for the Dasher GUI. {{{ They don't actually
         // change the way Dasher works. They are part of the Dasher interface
         // anyway so that it can handle option saving for you, and to make it
         // easy for the Dasher engine to control the GUI later on. }}}
 
         //! True if toolbar should be shown, false otherwise
-        virtual void ShowToolbar(bool Value) {};
+        virtual void ShowToolbar(bool ) {};
 
         //! True if toolbar should show text, false otherwse
-        virtual void ShowToolbarText(bool Value) {};
+        virtual void ShowToolbarText(bool ) {};
 
         //! True if toolbar should have large icons, false otherwise
-        virtual void ShowToolbarLargeIcons(bool Value) {};
+        virtual void ShowToolbarLargeIcons(bool ) {};
 
         //! True if the speed slider should be shown, false otherwise
-        virtual void ShowSpeedSlider(bool Value) {};
+        virtual void ShowSpeedSlider(bool ) {};
 
         //! True if the window layout should be fixed, false otherwise
-        virtual void FixLayout(bool Value) {};
+        virtual void FixLayout(bool ) {};
 
         //! True if new files should be timestamped, false otherwise
-        virtual void TimeStampNewFiles(bool Value) {};
+        virtual void TimeStampNewFiles(bool ) {};
 
         //! True if all text should be copied to clipboard when Dasher is stopped, false otherwise
-        virtual void CopyAllOnStop(bool Value) {};
+        virtual void CopyAllOnStop(bool ) {};
 
         //! True if a box should be drawn to represent the logical position of the mouse
-        virtual void DrawMouse(bool Value) {};
+        virtual void DrawMouse(bool ) {};
 
         //! Set the editbox font 
-        virtual void SetEditFont(std::string Name, long Size) {};
+        virtual void SetEditFont(std::string , long ) {};
 
         //! Set the canvas font
-        virtual void SetDasherFont(std::string Name) {};
+        virtual void SetDasherFont(std::string ) {};
 
         //! Set the height of the edit box
-        virtual void SetEditHeight(long Value) {};
+        virtual void SetEditHeight(long ) {};
         
         //! Should Dasher start and stop on space bar?
-        virtual void StartOnSpace(bool Value) {};
+        virtual void StartOnSpace(bool ) {};
 
         //! Should Dasher start and stop on left mouse button?
-        virtual void StartOnLeft(bool Value) {};
+        virtual void StartOnLeft(bool ) {};
         
         //! Should Dasher be keyboard controlled?
-        virtual void KeyControl(bool Value) {};
+        virtual void KeyControl(bool ) {};
         
         //! Should Dasher pause when the pointer leaves the window?
-        virtual void WindowPause(bool Value) {};
+        virtual void WindowPause(bool ) {};
 };
 
 
 #include <string>
 
 namespace Dasher
 {
 namespace Keys
 {
         // Standard Option strings. You are encouraged to use these constants.
         // -------------------------------------------------------------------
         
         // bool options
         extern const std::string TIME_STAMP;
         extern const std::string SHOW_TOOLBAR;
         extern const std::string SHOW_TOOLBAR_TEXT;
         extern const std::string SHOW_LARGE_ICONS;
         extern const std::string FIX_LAYOUT;
         extern const std::string SHOW_SLIDER;
         extern const std::string COPY_ALL_ON_STOP;
         extern const std::string DRAW_MOUSE;
         extern const std::string START_SPACE;
         extern const std::string START_MOUSE;
         extern const std::string KEY_CONTROL;
         extern const std::string WINDOW_PAUSE;
         // long options
         extern const std::string FILE_ENCODING;
         extern const std::string MAX_BITRATE_TIMES100;
         extern const std::string SCREEN_ORIENTATION;
         extern const std::string VIEW_ID;
         extern const std::string LANGUAGE_MODEL_ID;
         extern const std::string EDIT_FONT_SIZE;
         extern const std::string EDIT_HEIGHT;
         extern const std::string SCREEN_WIDTH;
         extern const std::string SCREEN_HEIGHT;
         extern const std::string DASHER_FONTSIZE;
         extern const std::string DASHER_DIMENSIONS;
         
         // string options
         extern const std::string ALPHABET_ID;
         extern const std::string DASHER_FONT;
         extern const std::string EDIT_FONT;
 }
 } // namespace Dasher
 
 
 #endif /* #ifndef __DasherSettingsInterface_h__ */
 
 
 
 
diff --git a/inputmethods/dasher/DasherView.cpp b/inputmethods/dasher/DasherView.cpp
index 3b8cb64..8e32cf1 100644
--- a/inputmethods/dasher/DasherView.cpp
+++ b/inputmethods/dasher/DasherView.cpp
@@ -1,93 +1,93 @@
 // DasherView.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include "DasherView.h"
 using namespace Dasher;
 
 
 CDasherView::CDasherView(CDasherScreen* DasherScreen, CDasherModel& DasherModel, Opts::ScreenOrientations Orientation)
   : m_Screen(DasherScreen), m_DasherModel(DasherModel), ScreenOrientation(Orientation), ColourMode(false)
 {
         //XYScale = (double)m_Screen->GetHeight() / m_Screen->GetWidth();
 }
 
 
 void CDasherView::ChangeOrientation(Dasher::Opts::ScreenOrientations Orientation)
 {
         ScreenOrientation = Orientation;
         Render();
 }
 
 
-void CDasherView::FlushAt(int mousex,int mousey) 
+void CDasherView::FlushAt(int ,int ) 
 {
         m_DasherModel.Flush(0,0);
 }
 
 int CDasherView::RecursiveRender(CDasherNode* Render, myint y1,myint y2,int mostleft, bool text)
 {
-        symbol CurChar = Render->Symbol();
+        // symbol CurChar = Render->Symbol();
         int Color;
 
         if (ColourMode==true) {
           Color = Render->Colour();
         } else {
           Color = Render->Phase()%3; 
         }
 
         if (RenderNode(Render->Symbol(), Color, Render->Cscheme(), y1, y2, mostleft, Render->m_bForce, text))
                 RenderGroups(Render, y1, y2, text);
         else
                 Render->Kill();
         
         CDasherNode** const Children=Render->Children();
         if (!Children)
           return 0;
         int norm=DasherModel().Normalization();
                 for (unsigned int i=1; i<Render->Chars(); i++) {
                 if (Children[i]->Alive()) {
                         myint Range=y2-y1;
                         myint newy1=y1+(Range*Children[i]->Lbnd())/norm;
                         myint newy2=y1+(Range*Children[i]->Hbnd())/norm;
                         RecursiveRender(Children[i], newy1, newy2, mostleft, text);
                 }
         }
         return 1;
 
 
 }
 
 
 void CDasherView::RenderGroups(CDasherNode* Render, myint y1, myint y2, bool text)
 {
         CDasherNode** Children = Render->Children();
         if (!Children)
                 return;
         int current=0;
         int lower=0;
         int upper=0;
         myint range=y2-y1;
         for (unsigned int i=1; i<Render->Chars(); i++) {
                 int g=Children[i]->Group();
                 if (g!=current) {
                         lower=upper;
                         upper=i;
                         
                         if (current!=0) {
                                 myint lbnd=Children[lower]->Lbnd();
                                 myint hbnd=Children[upper]->Lbnd();
                                 myint newy1=y1+(range*lbnd)/m_DasherModel.Normalization();
                                 myint newy2=y1+(range*hbnd)/m_DasherModel.Normalization();
                                 int mostleft;
                                 bool force;
                                 RenderNode(0,current-1,Opts::Groups,newy1,newy2,mostleft,force,text);
                         }
                         current=g;
                 }
         }
 }
diff --git a/inputmethods/dasher/DasherView.h b/inputmethods/dasher/DasherView.h
index 81cc24e..6257c03 100644
--- a/inputmethods/dasher/DasherView.h
+++ b/inputmethods/dasher/DasherView.h
@@ -1,99 +1,99 @@
 // DasherView.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2001-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 //////////////////////////////////////////////////////////////////////
 // DasherView.h: interface for the DasherView class.
 // Copyright 2002 David Ward
 //////////////////////////////////////////////////////////////////////
 
 #ifndef __DasherView_h_
 #define __DasherView_h_
 
 #include "MSVC_Unannoy.h"
 #include "DasherScreen.h"
 #include "DasherModel.h"
 
 // CDasherView is an abstract view class
 // The implentation must provide several functions - defined here as pure virtual functions
 // See the CDasherViewSquare class for an example
 
 namespace Dasher {class CDasherView;}
 class Dasher::CDasherView
 {
 public:
         CDasherView(CDasherScreen* DasherScreen, CDasherModel& DasherModel, Dasher::Opts::ScreenOrientations Orientation=Dasher::Opts::LeftToRight);
-                ~CDasherView() {}       
+                virtual ~CDasherView() {}       
         
         void ChangeOrientation(Dasher::Opts::ScreenOrientations Orientation);
         
         // TODO Sort this out
         void FlushAt(int mousex,int mousey);
         
         // renders Dasher
         inline void Render();
         
         // translates the screen coordinates to Dasher coordinates and calls
         // dashermodel.TapOnDisplay
         virtual void TapOnDisplay(int mousex, int mousey, unsigned long Time)=0;
         
         virtual void ChangeScreen(CDasherScreen* NewScreen)
         {
                 m_Screen=NewScreen;
                 
                 // DJW - removed floating point stuff
                 //XYScale = (double)m_Screen->GetHeight() / m_Screen->GetWidth();
         }
 
         virtual void DrawMouse(int mousex, int mousey)=0;
         virtual void DrawKeyboard()=0;
 
         // Return references to the model and the screen:
         CDasherModel& DasherModel() {return m_DasherModel;}
         CDasherScreen& Screen() {return *m_Screen;}
 
         void Display() {m_Screen->Display();}
 
         // Toggle advanced colour mode
         void SetColourMode(bool colourmode) {ColourMode=colourmode;}
 
 protected:
         // Orientation of Dasher Screen
         inline void MapScreen(int* DrawX, int* DrawY);
         inline void UnMapScreen(int* DrawX, int* DrawY);
 
 private:
         CDasherScreen* m_Screen;      // provides the graphics (text, lines, rectangles):
         CDasherModel& m_DasherModel; // Model view represents
         
         // Pure virtuals to implement
         virtual void Crosshair(myint sx)=0; // Tells m_Screen to draw a crosshair - or other static decoration
         virtual int RenderNode(const symbol Character, const int Color, Opts::ColorSchemes ColorScheme,
                 myint y1, myint y2, int& mostleft, bool& force, bool text)=0;
         
         // Responsible for all the Render_node calls
         int RecursiveRender(CDasherNode* Render, myint y1,myint y2,int mostleft, bool text);
         
         // Displays some nodes inside one parent node. Used to group capital letters, accents, punctuation etc.
         void RenderGroups(CDasherNode* Render, myint y1, myint y2, bool text);
         
         // Orientation of Dasher Screen
         Dasher::Opts::ScreenOrientations ScreenOrientation;
 
         // Advanced colour mode
         bool ColourMode;
 
         // DJW - removed floating point stuff
         //double XYScale;
 };
 
 
 #include "DasherView.inl"
 
 
 #endif /* #ifndef __DasherView_h_ */
diff --git a/inputmethods/dasher/PPMLanguageModel.cpp b/inputmethods/dasher/PPMLanguageModel.cpp
index b725a2b..137b07f 100644
--- a/inputmethods/dasher/PPMLanguageModel.cpp
+++ b/inputmethods/dasher/PPMLanguageModel.cpp
@@ -1,309 +1,309 @@
 // PPMLanguageModel.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 1999-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #include <math.h>
 #include "PPMLanguageModel.h"
 
 using namespace Dasher;
 using namespace std;
 
 // static TCHAR debug[256];
 typedef unsigned long ulong;
 
 ////////////////////////////////////////////////////////////////////////
 /// PPMnode definitions 
 ////////////////////////////////////////////////////////////////////////
 
 CPPMLanguageModel::CPPMnode *CPPMLanguageModel::CPPMnode::find_symbol(int sym)
 // see if symbol is a child of node
 {
         //  printf("finding symbol %d at node %d\n",sym,node->id);
         CPPMnode *found=child;
         while (found) {
                 if (found->symbol==sym)
                         return found;
                 found=found->next;
         }
         return 0;
 }
 
 
 CPPMLanguageModel::CPPMnode * CPPMLanguageModel::CPPMnode::add_symbol_to_node(int sym,int *update)
 {
         CPPMnode *born,*search;
         search=find_symbol(sym);
         if (!search) {
                 born = new CPPMnode(sym);
                 born->next=child;
                 child=born;
                 //   node->count=1;
                         return born;    
         } else {
                 if (*update) {   // perform update exclusions
                         search->count++;
                         *update=0;
                 }
                 return search;
         }
         
 }
 
 
 /////////////////////////////////////////////////////////////////////
 // CPPMLanguageModel defs
 /////////////////////////////////////////////////////////////////////
 
 CPPMLanguageModel::CPPMLanguageModel(CAlphabet *_alphabet,int _normalization)
         : CLanguageModel(_alphabet,_normalization)
 {
         root=new CPPMnode(-1);
         m_rootcontext=new CPPMContext(root,0);
 }
 
 
 CPPMLanguageModel::~CPPMLanguageModel()
 {
         delete root;
 }
 
 
-bool CPPMLanguageModel::GetProbs(CContext *context,vector<unsigned int> &probs,double addprob)
+bool CPPMLanguageModel::GetProbs(CContext *context,vector<unsigned int> &probs,double )
         // get the probability distribution at the context
 {
         // seems like we have to have this hack for VC++
         CPPMContext *ppmcontext=static_cast<CPPMContext *> (context);
         
         
         int modelchars=GetNumberModelChars();
         int norm=CLanguageModel::normalization();
         probs.resize(modelchars);
         CPPMnode *temp,*s; 
         int loop,total;
         int sym; 
-        ulong spent=0; 
+        // ulong spent=0; 
         ulong size_of_slice;
         bool *exclusions=new bool [modelchars];
         ulong uniform=modelchars;
         ulong tospend=norm-uniform;
         temp=ppmcontext->head;
         for (loop=0; loop <modelchars; loop++) {   /* set up the exclusions array */
                 probs[loop]=0;
                 exclusions[loop]=0;
         }
         while (temp!=0) {
                         //Usprintf(debug,TEXT("tospend %u\n"),tospend);
                         //DebugOutput(TEXT("round\n"));
                 total=0;
                 s=temp->child;
                 while (s) {
                         sym=s->symbol; 
                         if (!exclusions[s->symbol])
                                 total=total+s->count;
                         s=s->next;
                 }
                 if (total) {
                                 //Usprintf(debug,TEXT"escape %u\n"),tospend*
                         size_of_slice=tospend;
                         s=temp->child;
                         while (s) {
                                 if (!exclusions[s->symbol]) {
                                         exclusions[s->symbol]=1;
                                         ulong p=size_of_slice*(2*s->count-1)/2/ulong(total);
                                         probs[s->symbol]+=p;
                                                 tospend-=p;     
                                 }
                                         //                              Usprintf(debug,TEXT("sym %u counts %d p %u tospend %u \n"),sym,s->count,p,tospend); 
                                         //                      DebugOutput(debug);
                                 s=s->next;
                         }
                 }
                 temp = temp->vine;
         }
                 //Usprintf(debug,TEXT("Norm %u tospend %u\n"),Norm,tospend);
                 //DebugOutput(debug);
         
         size_of_slice=tospend;
         int symbolsleft=0;
         for (sym=1;sym<modelchars;sym++)
                 if (!probs[sym])
                         symbolsleft++;
                 for (sym=1;sym<modelchars;sym++) 
                         if (!probs[sym]) {
                                 ulong p=size_of_slice/symbolsleft;
                                 probs[sym]+=p;
                                 tospend-=p;
                         }
                         
                                 // distribute what's left evenly
                         tospend+=uniform;
                         for (sym=1;sym<modelchars;sym++) {
                                 ulong p=tospend/(modelchars-sym);
                                 probs[sym]+=p;
                                 tospend-=p;
                         }
                                 //Usprintf(debug,TEXT("finaltospend %u\n"),tospend);
                                 //DebugOutput(debug);
                         
                         // free(exclusions); // !!!
                         // !!! NB by IAM: p577 Stroustrup 3rd Edition: "Allocating an object using new and deleting it using free() is asking for trouble"
                         delete[] exclusions;
                         return true;
 }
 
 
 void CPPMLanguageModel::AddSymbol(CPPMLanguageModel::CPPMContext &context,int symbol)
         // add symbol to the context
         // creates new nodes, updates counts
         // and leaves 'context' at the new context
 {
         // sanity check
         if (symbol==0 || symbol>=GetNumberModelChars())
                 return;
         
         CPPMnode *vineptr,*temp;
         int updatecnt=1;
         
         temp=context.head->vine;
         context.head=context.head->add_symbol_to_node(symbol,&updatecnt);
         vineptr=context.head;
         context.order++;
         
         while (temp!=0) {
                 vineptr->vine=temp->add_symbol_to_node(symbol,&updatecnt);    
                 vineptr=vineptr->vine;
                 temp=temp->vine;
         }
         vineptr->vine=root;
         if (context.order>MAX_ORDER){
                 context.head=context.head->vine;
                 context.order--;
         }
 }
 
 
 // update context with symbol 'Symbol'
 void CPPMLanguageModel::EnterSymbol(CContext* Context, modelchar Symbol)
 {
         CPPMLanguageModel::CPPMContext& context = * static_cast<CPPMContext *> (Context);
         
         CPPMnode *find;
-        CPPMnode *temp=context.head;
+        // CPPMnode *temp=context.head;
         
         while (context.head) {
                 find =context.head->find_symbol(Symbol);
                 if (find) {
                         context.order++;
                         context.head=find;
                                 //Usprintf(debug,TEXT("found context %x order %d\n"),head,order);
                                 //DebugOutput(debug);
                         return;
                 }
                 context.order--;
                 context.head=context.head->vine;
         }
         
         if (context.head==0) {
                 context.head=root;
                 context.order=0;
         }
         
 }
 
 
 void CPPMLanguageModel::LearnSymbol(CContext* Context, modelchar Symbol)
 {
         CPPMLanguageModel::CPPMContext& context = * static_cast<CPPMContext *> (Context);
         AddSymbol(context, Symbol);
 }
 
 
 void CPPMLanguageModel::dumpSymbol(int symbol)
 {
         if ((symbol <= 32) || (symbol >= 127))
                 printf( "<%d>", symbol );
         else
                 printf( "%c", symbol );
 }
 
 
 void CPPMLanguageModel::dumpString( char *str, int pos, int len )
         // Dump the string STR starting at position POS
 {
         char cc;
         int p;
         for (p = pos; p<pos+len; p++) {
                 cc = str [p];
                 if ((cc <= 31) || (cc >= 127))
                         printf( "<%d>", cc );
                 else
                         printf( "%c", cc );
         }
 }
 
 
-void CPPMLanguageModel::dumpTrie( CPPMLanguageModel::CPPMnode *t, int d )
+void CPPMLanguageModel::dumpTrie( CPPMLanguageModel::CPPMnode *, int )
         // diagnostic display of the PPM trie from node t and deeper
 {
 //TODO
 /*
         dchar debug[256];
         int sym;
         CPPMnode *s;
         Usprintf( debug,TEXT("%5d %7x "), d, t );
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         if (t < 0) // pointer to input
                 printf( "                     <" );
         else {
                 Usprintf(debug,TEXT( " %3d %5d %7x  %7x  %7x    <"), t->symbol,t->count, t->vine, t->child, t->next );
                 //TODO: Uncomment this when headers sort out
                 //DebugOutput(debug);
         }
         
         dumpString( dumpTrieStr, 0, d );
         Usprintf( debug,TEXT(">\n") );
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         if (t != 0) {
                 s = t->child;
                 while (s != 0) {
                         sym =s->symbol;
                         
                         dumpTrieStr [d] = sym;
                         dumpTrie( s, d+1 );
                         s = s->next;
                 }
         }
 */
 }
 
 
 void CPPMLanguageModel::dump()
         // diagnostic display of the whole PPM trie
 {
 // TODO:
 /*
         dchar debug[256];
         Usprintf(debug,TEXT(  "Dump of Trie : \n" ));
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         Usprintf(debug,TEXT(   "---------------\n" ));
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         Usprintf( debug,TEXT(  "depth node     symbol count  vine   child      next   context\n") );
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         dumpTrie( root, 0 );
         Usprintf( debug,TEXT(  "---------------\n" ));
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
         Usprintf(debug,TEXT( "\n" ));
         //TODO: Uncomment this when headers sort out
         //DebugOutput(debug);
 */
 }
diff --git a/inputmethods/dasher/PPMLanguageModel.h b/inputmethods/dasher/PPMLanguageModel.h
index bd860b8..7025a0a 100644
--- a/inputmethods/dasher/PPMLanguageModel.h
+++ b/inputmethods/dasher/PPMLanguageModel.h
@@ -1,122 +1,123 @@
 // PPMLanguageModel.h
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 1999-2002 David Ward
 //
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef __PPMLanguageModel_h__
 #define __PPMLanguageModel_h__
 
 #include "NoClones.h"
 #include "MSVC_Unannoy.h"
 #include <vector>
 #include <stdio.h>
 
 #include "LanguageModel.h"
 
-static char dumpTrieStr[40000];
+// static char dumpTrieStr[40000];
 const int MAX_ORDER = 5;
 const int maxcont =200;
 
 namespace Dasher {class CPPMLanguageModel;}
 class Dasher::CPPMLanguageModel : public Dasher::CLanguageModel, private NoClones
 {
 public:
         CPPMLanguageModel(CAlphabet *_alphabet, int _normalization);
-        ~CPPMLanguageModel();
+        virtual ~CPPMLanguageModel();
         
         class CPPMnode {
         public:
                 CPPMnode* find_symbol(int sym);
                 CPPMnode* add_symbol_to_node(int sym,int *update);
                 CPPMnode* child;
                 CPPMnode* next;
                 CPPMnode* vine;
                 short int count;
                 const short int symbol;
                 CPPMnode(int sym);
         };
         
         class CPPMContext : public CContext {
         public:
-                        CPPMContext(CPPMContext const &input) {head = input.head;order= input.order;}
+                CPPMContext(CPPMContext const &input) : CContext(input)
+                  { head = input.head;order= input.order;}
                 CPPMContext(CPPMnode* _head=0, int _order=0) : head(_head),order(_order) {};
                 ~CPPMContext() {};
                 void dump();
                 CPPMnode* head;
                 int order;
         };
         
         void ReleaseContext(CContext*);
         CContext* GetRootContext();
         inline CContext* CloneContext(CContext*);
         void EnterSymbol(CContext* context, modelchar Symbol);
         //inline bool GetProbs(CContext*,std::vector<symbol> &newchars,std::vector<unsigned int> &groups,std::vector<unsigned int> &probs,double addprob);
         bool GetProbs(CContext*, std::vector<unsigned int> &Probs, double AddProb);
         
         void LearnSymbol(CContext* Context, modelchar Symbol);
         void dump();
         
 private:
         CPPMContext *m_rootcontext;
         CPPMnode *root;
         void AddSymbol(CPPMContext& context,int symbol);
         void dumpSymbol(int symbol);
         void dumpString( char *str, int pos, int len );
         void dumpTrie( CPPMnode *t, int d );
 
 
 
 };
 
 ////////////////////////////////////////////////////////////////////////
 // Inline functions 
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
 
 inline CPPMLanguageModel::CPPMnode::CPPMnode(int sym) : symbol(sym)
 {
         child=next=vine=0;
         count=1;
 }
 
 ///////////////////////////////////////////////////////////////////
 
 inline void CPPMLanguageModel::CPPMContext::dump() 
         // diagnostic output
 {
         // TODO uncomment this when headers sorted out
         //dchar debug[128];
         //Usprintf(debug,TEXT("head %x order %d\n"),head,order);
         //DebugOutput(debug);
 }
 
 ///////////////////////////////////////////////////////////////////
 
 inline CContext* CPPMLanguageModel::GetRootContext()
 {
         CPPMContext * nc = new CPPMLanguageModel::CPPMContext(*m_rootcontext);
         CContext *cont=static_cast<CContext *> (nc);
         return  cont;
 }
 
 ///////////////////////////////////////////////////////////////////
 
 inline CContext* CPPMLanguageModel::CloneContext(CContext *copythis)
 {
         CPPMContext *ppmcontext=static_cast<CPPMContext *> (copythis);
         CPPMContext * nc = new CPPMLanguageModel::CPPMContext(*ppmcontext);
         return  static_cast<CContext *> (nc);
 }
 
 ///////////////////////////////////////////////////////////////////
 
 inline void CPPMLanguageModel::ReleaseContext(CContext *release)
 {
         delete release;
 }
 
 #endif /* #ifndef __PPMLanguageModel_H__ */
diff --git a/inputmethods/dasher/QtDasherImpl.cc b/inputmethods/dasher/QtDasherImpl.cc
index d72f6d9..f4a70dd 100644
--- a/inputmethods/dasher/QtDasherImpl.cc
+++ b/inputmethods/dasher/QtDasherImpl.cc
@@ -1,87 +1,87 @@
 #include <iostream>
 #include <qapplication.h>
 #include <qobject.h>
 #include <qpixmap.h>
 #include "DasherInterface.h"
 #include "QtDasherScreen.h"
 #include "QtDasherImpl.h"
 
 /* XPM */
 static const char * qtdasher_xpm[]={
 "28 7 2 1",
 "# c #303030",
 "  c None",
 " ########################## ",
 "                            ",
 "    #     #                 ",
 "   # #   # #                ",
 "  #   # #   #               ",
 " #     #     #              ",
 " ########################## "};
 
 
 QtDasherImpl::QtDasherImpl()
-  : qtdasherwidget(0), icn(0), qtdasherinterface(0)
+  : qtdasherinterface(0), qtdasherwidget(0), icn(0)
 {
 }
 
 QtDasherImpl::~QtDasherImpl()
 {
     delete qtdasherwidget;
     delete icn;
 }
 
 QWidget *QtDasherImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
   if ( !qtdasherwidget ) {
         qtdasherwidget = new QtDasherPlugin( parent, "Dasher", f );
   }
   return qtdasherwidget;
 }
 
 void QtDasherImpl::resetState()
 {
     if ( qtdasherwidget )
       qtdasherwidget->resetState();
 }
 
 QPixmap *QtDasherImpl::icon()
 {
     if ( !icn )
         icn = new QPixmap( (const char **)qtdasher_xpm );
     return icn;
 }
 
 QString QtDasherImpl::name()
 {
     return qApp->translate( "InputMethods", "Dasher" );
 }
 
 void QtDasherImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( qtdasherwidget )
       QObject::connect( qtdasherwidget, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT QtDasherImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
         *iface = this;
     else if ( uuid == IID_InputMethod )
         *iface = this;
     else
         return QS_FALSE;
 
     if ( *iface )
         (*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( QtDasherImpl )
 }
 #endif
 
diff --git a/inputmethods/dasher/QtDasherPlugin.cc b/inputmethods/dasher/QtDasherPlugin.cc
index cf4fc2c..f491769 100644
--- a/inputmethods/dasher/QtDasherPlugin.cc
+++ b/inputmethods/dasher/QtDasherPlugin.cc
@@ -1,79 +1,79 @@
 #include "QtDasherPlugin.h"
 
 #include <qpe/global.h>
  
 #include <qpainter.h>
 #include <qlist.h>
 #include <qbitmap.h>
 #include <qlayout.h>
 #include <qvbox.h>
 #include <qdialog.h>
 #include <qscrollview.h>
 #include <qpopupmenu.h>
 #include <qhbuttongroup.h>
 #include <qpushbutton.h>
 #include <qmessagebox.h>
 #include <qwindowsystem_qws.h>
 
 QtDasherPlugin::QtDasherPlugin(QWidget* parent, const char* name, WFlags f) : QFrame(parent,name,f)
 {
   (new QHBoxLayout(this))->setAutoAdd(TRUE);
   interface = new CDasherInterface;
   interface->SetSystemLocation("/opt/QtPalmtop/share/dasher/");
   interface->Unpause(0);
   interface->Start();  
   d = new QtDasherScreen(240,100,interface,this,this);
   interface->ChangeMaxBitRate(2.5);
   d->show();
   utf8_codec = new QUtf8Codec;
 }
 
 QSize QtDasherPlugin::sizeHint() const
 {
   return QSize(240,100);
 }
 
 QtDasherPlugin::~QtDasherPlugin()
 {
   delete d;
 }
 
 void QtDasherPlugin::resetState()
 {
   flushcount=0;
   interface->Start();
   interface->Redraw();
 }
 
 void QtDasherPlugin::unflush()
 {
   if (flushcount==0)
     return;
-  for (flushcount; flushcount>0; flushcount--) {
+  for (; flushcount>0; flushcount--) {
     deletetext();
   }
 }
 
 void QtDasherPlugin::output(int Symbol)
 {
   std::string label = interface->GetEditText(Symbol);
   QString unicodestring = utf8_codec->toUnicode(label.c_str());
   for (int i=0; i<int(unicodestring.length()); i++) {
     emit key( unicodestring[i].unicode(), 0, 0, true, false );
     emit key( unicodestring[i].unicode(), 0, 0, false, false );
   }
 }
 
 void QtDasherPlugin::deletetext()
 {
   emit key( 0, Qt::Key_Backspace, 0, true, false);
   emit key( 0, Qt::Key_Backspace, 0, false, false);
 }
 
 void QtDasherPlugin::flush(int Symbol)
 {
   if (Symbol==0)
     return;
   output(Symbol);
   flushcount++;
 }
diff --git a/inputmethods/dasher/QtDasherPlugin.h b/inputmethods/dasher/QtDasherPlugin.h
index 5f70acf..c979a2f 100644
--- a/inputmethods/dasher/QtDasherPlugin.h
+++ b/inputmethods/dasher/QtDasherPlugin.h
@@ -1,42 +1,42 @@
 #include <qutfcodec.h>
 #include <qframe.h>
 #include "QtDasherScreen.h"
 #include "DasherInterface.h"
 #include "DashEdit.h"
 
 class QtDasherPlugin : public QFrame, public CDashEditbox
 {
   Q_OBJECT
 public:
   QtDasherPlugin(QWidget* parent=0, const char* name=0, WFlags f=0);
   ~QtDasherPlugin();
 
   void resetState();
   QSize sizeHint() const;
 
   void write_to_file() {};
   void get_new_context(std::string&, int) {};
   void unflush();
   void output(int);
   void deletetext();
   void flush(int);
   void Clear() {};
   void SetEncoding(Dasher::Opts::FileEncodingFormats) {};
-  void SetFont(std::string Name, long Size) {};
+  void SetFont(std::string , long ) {};
 
  signals:
   void key( ushort, ushort, ushort, bool, bool);
 
  private:
   QtDasherScreen *d;
   CDasherInterface *interface;
   int flushcount;
   QUtf8Codec *utf8_codec;
 };
 
 
 
 
 
 
 
diff --git a/inputmethods/dasher/QtDasherScreen.cc b/inputmethods/dasher/QtDasherScreen.cc
index 747b705..2179cfb 100644
--- a/inputmethods/dasher/QtDasherScreen.cc
+++ b/inputmethods/dasher/QtDasherScreen.cc
@@ -1,177 +1,182 @@
 // QtDasherScreen.cc
 // (c) 2003 Yann Dirson
 // Derived from GtkDasherCanvas.cc
 // (c) 2002 Philip Cowans
 
 #include <iostream>
 #include <string>
 
 #include <qpointarray.h>
 #include <qpoint.h>
 
 #include "QtDasherScreen.h"
 #include "DasherScreen.h"
 #include "SettingsStore.h"
 
 #define MAXFONTSIZE 25
 #define MINFONTSIZE 8
 
 QtDasherScreen::QtDasherScreen (int _width, int _height,
                                 CDasherInterface *_interface,
-                                QWidget * _parent, Dasher::CDashEditbox *edit):
-  QWidget(_parent), interface( _interface ),
-  fontname( "fixed" ), fontsize(12),
-  Dasher::CDasherScreen(_width, _height)
+                                QWidget * _parent, 
+                                Dasher::CDashEditbox *_edit):
+  QWidget(_parent), 
+  Dasher::CDasherScreen(_width, _height),
+  fontsize(12),
+  interface( _interface ),
+  fontname( "fixed" )
 {
   font = QFont (fontname.c_str(), fontsize);
   painter = new QPainter ();
 
   pixmap = new QPixmap (_width, _height);
   pixmap->setOptimization(QPixmap::BestOptim);
   interface->SetSettingsStore(new CSettingsStore);
 
   interface->ChangeLanguageModel(0);
   interface->ChangeView(0);
-  interface->ChangeEdit(edit);
+  interface->ChangeEdit(_edit);
+  edit = _edit;
+
 
 /* interface->GetFontSizes(&FontSizes);
 
   for (int i=0; i<FontSizes.size(); i++) {
     if (FontSizes[i]>Fonts.size())
       Fonts.resize((FontSizes[i])+1);    
     Fonts[FontSizes[i]]= QFont (fontname.c_str(), FontSizes[i]);
 //    Fonts[FontSizes[i]].setPixelSize(FontSizes[i]);
   }
 */
   interface->ChangeScreen(this);
 
   paused=true;
                      
   QTimer *tmr = new QTimer(this);
   connect (tmr, SIGNAL(timeout()), SLOT(timer()));
   tmr->start(200);
 
 }
 
 long QtDasherScreen::get_time()
 {
   long s_now;
   long ms_now;
   
   struct timeval tv;
   struct timezone tz;
   
   gettimeofday( &tv, &tz );
   
   s_now = tv.tv_sec-1054487600;
 
   ms_now = tv.tv_usec / 1000;
 
   return( long(s_now*1000 + ms_now) );
 
 }
 
 QtDasherScreen::~QtDasherScreen()
 {
   delete painter;
   delete interface;
   delete edit;
 }
 
 QColor QtDasherScreen::getColor(int Color, const Opts::ColorSchemes ColorScheme) const
 {
   switch (ColorScheme) {
   case Dasher::Opts::Nodes1:
     switch (Color) {
     case 0: return QColor (180, 245, 180);
     case 1: return QColor (160, 200, 160);
     case 2: return QColor (0, 255, 255);
     default: abort ();
     }
   case Dasher::Opts::Nodes2:
     switch (Color) {
     case 0: return QColor (255, 185, 255);
     case 1: return QColor (140, 200, 255);
     case 2: return QColor (255, 175, 175);
     default: abort ();
     }
   case Dasher::Opts::Special1: return QColor (240, 240, 240);
   case Dasher::Opts::Special2: return QColor (255, 255, 255);
   case Dasher::Opts::Groups:
     switch (Color) {
     case 0: return QColor (255, 255, 0);
     case 1: return QColor (255, 100, 100);
     case 2: return QColor (0, 255, 0);
     default: abort ();
     }
   case Dasher::Opts::Objects: return QColor (0, 0, 0);
   default: abort();
   }   
 }
   
 void QtDasherScreen::DrawRectangle(int x1, int y1, int x2, int y2,
                                    int Color, Opts::ColorSchemes ColorScheme) const
 {
   painter->setBrush (getColor (Color, ColorScheme));
   painter->drawRect (x1, y1, x2-x1, y2-y1);
 }
 
 static void Points_to_QPointArray(const Dasher::CDasherScreen::point* const points,
                                   int number,
                                   QPointArray &qpa)
 {
   for (int i = 0; i < number; i++) {
     qpa.setPoint (i, points[i].x, points[i].y);  
   }
 }
 
 void QtDasherScreen::Polyline(point* Points, int Number) const
 {
   QPointArray qpa(Number);
   Points_to_QPointArray (Points, Number, qpa);
   painter->setPen (SolidLine);
   painter->drawPolyline (qpa);
   painter->setPen (NoPen);
 }
 
 void QtDasherScreen::DrawPolygon(point* Points, int Number, int Color,
                                  Opts::ColorSchemes ColorScheme) const
 {
   painter->setBrush (getColor (Color, ColorScheme));
   QPointArray qpa(Number);
   Points_to_QPointArray (Points, Number, qpa);
   painter->drawPolygon (qpa);
 }
 
-void QtDasherScreen::mousePressEvent (QMouseEvent *e)
+void QtDasherScreen::mousePressEvent (QMouseEvent *)
 {
     paused=false;
     interface->Unpause(get_time());
 }
 
 void QtDasherScreen::mouseReleaseEvent(QMouseEvent *e)
 {
     QPoint p = e->pos();
     interface->PauseAt(p.x(), p.y());
     paused=true;
 }
 
 void QtDasherScreen::timer()
 {
   if (paused==false) {
     QPoint cursorpos;
     cursorpos=this->cursor().pos();
     cursorpos=mapFromGlobal(cursorpos);
 
     interface->TapOn(cursorpos.x(), cursorpos.y(), get_time());
   }
 }
 
 
 
 
 
 
 
 
 
diff --git a/inputmethods/dasher/QtDasherScreen.h b/inputmethods/dasher/QtDasherScreen.h
index 06689d6..d3d67cb 100644
--- a/inputmethods/dasher/QtDasherScreen.h
+++ b/inputmethods/dasher/QtDasherScreen.h
@@ -1,116 +1,116 @@
 // QtDasherScreen.h
 // (c) 2003 Yann Dirson
 // Derived from GtkDasherCanvas.h
 // (c) 2002 Philip Cowans
 
 #ifndef QT_DASHER_SCREEN_H
 #define QT_DASHER_SCREEN_H
 
 #include <string>
 #include <sys/time.h>
 
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qfont.h>
 #include <qstring.h>
 #include <qpixmap.h>
 #include <qtimer.h>
 #include <qcursor.h>
 
 #include "DasherScreen.h"
 #include "DashEdit.h"
 #include "DasherInterface.h"
 
 using namespace Dasher;
 
 class QtDasherScreen : public QWidget, public Dasher::CDasherScreen
 
 {
   Q_OBJECT
  public:
   QtDasherScreen (int _width, int _height,
                   CDasherInterface *_interface,
                   QWidget * _parent=0, Dasher::CDashEditbox* edit=0);
   QtDasherScreen::~QtDasherScreen();
 
   void SetFont(std::string Name)
     { fontname = Name; /* set_the_font(); */ }
 
-  void SetFontSize(Dasher::Opts::FontSize fontsize)
+  void SetFontSize(Dasher::Opts::FontSize )
     {
 #warning QtDasherScreen::SetFontSize() not implemented
     }
   Dasher::Opts::FontSize GetFontSize()
     {
 #warning QtDasherScreen::GetFontSize() not implemented
       return (Dasher::Opts::Normal);
     }
   
-  void TextSize(symbol Character, int* Width, int* Height, int Size) const
+  void TextSize(symbol , int* Width, int* Height, int ) const
     { 
       // should probably use QPainter::boundingRect()
       *Width = *Height = font.pixelSize();
       
     }
   void DrawText(symbol Character, int x1, int y1, int Size) const
     {
       //      QFont font = QFont (fontname.c_str(), Size);
       //      font.setPixelSize(Size);
       QPoint point = QPoint(x1, y1+Size/2);
   
       painter->setFont (font);
       painter->drawText (point,
                          QString(interface->GetDisplayText(Character).c_str()));
     }
 
   void DrawRectangle(int x1, int y1, int x2, int y2,
                      int Color, Opts::ColorSchemes ColorScheme) const;
   void Polyline(point* Points, int Number) const;
   void DrawPolygon(point* Points, int Number, int Color,
                    Opts::ColorSchemes ColorScheme) const;
 
   std::vector<int> FontSizes;
   std::vector<QFont> Fonts;
   QFont font;
   int fontsize;
   void Blank() const {
     painter->begin(pixmap);
     painter->setPen (NoPen);
     painter->fillRect(0, 0, m_iWidth, m_iHeight,
                       QColor(255,255,255));
   }
   void Display() {
     painter->end();
     repaint();
   }
 
   void paintEvent( QPaintEvent * )
   {
     bitBlt(this, 0, 0, pixmap);
   }
 
   void mousePressEvent (QMouseEvent *e);
   void mouseReleaseEvent (QMouseEvent *e);
   
  protected:
   QColor getColor(int Color, const Opts::ColorSchemes ColorScheme) const;
   
   long QtDasherScreen::get_time();
 
   CDasherInterface* interface;
   Dasher::CDashEditbox* edit;
 
   bool paused;
 
   QPainter* painter;
 
   QPixmap* pixmap;
 
   std::string fontname;
 
   protected slots:
     void timer();
 
 };
 
 #endif
diff --git a/inputmethods/dasher/SettingsStore.cpp b/inputmethods/dasher/SettingsStore.cpp
index c5bbfea..f7661bd 100644
--- a/inputmethods/dasher/SettingsStore.cpp
+++ b/inputmethods/dasher/SettingsStore.cpp
@@ -1,135 +1,135 @@
 // SettingsStore.cpp
 //
 /////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002 Iain Murray
 //
 /////////////////////////////////////////////////////////////////////////////
 
 
 
 
 #include "SettingsStore.h"
 
 using namespace std;
 
 /* TODO: Consider using Template functions to make this neater. */
 
 
 bool CSettingsStore::GetBoolOption(const string& Key)
 {
         if (BoolMap.find(Key)==BoolMap.end()) {
                 bool Value = false;
                 LoadSetting(Key, &Value);
                 BoolMap[Key] = Value;
         }
         
         return BoolMap[Key];
 }
 
 
 long CSettingsStore::GetLongOption(const string& Key)
 {
         if (LongMap.find(Key)==LongMap.end()) {
                 long Value = 0l;
                 LoadSetting(Key, &Value);
                 LongMap[Key] = Value;
         }
         
         return LongMap[Key];
 }
 
 
 string& CSettingsStore::GetStringOption(const string& Key)
 {
         if (StringMap.find(Key)==StringMap.end()) {
                 string Value = "";
                 LoadSetting(Key, &Value);
                 StringMap[Key] = Value;
         }
         
         return StringMap[Key];
 }
 
 
 void CSettingsStore::SetBoolOption(const string& Key, bool Value)
 {
         BoolMap[Key] = Value;
         SaveSetting(Key, Value);
 }
 
 
 void CSettingsStore::SetLongOption(const string& Key, long Value)
 {
         LongMap[Key] = Value;
         SaveSetting(Key, Value);
 }
 
 
 void CSettingsStore::SetStringOption(const string& Key, const string& Value)
 {
         StringMap[Key] = Value;
         SaveSetting(Key, Value);
 }
 
 
 void CSettingsStore::SetBoolDefault(const string& Key, bool Value)
 {
         bool TmpValue;
         if ( (BoolMap.find(Key)==BoolMap.end()) && (!LoadSetting(Key, &TmpValue)) )
                 SetBoolOption(Key, Value);
 }
 
 
 void CSettingsStore::SetLongDefault(const string& Key, long Value)
 {
         long TmpValue;
         if ( (LongMap.find(Key)==LongMap.end()) && (!LoadSetting(Key, &TmpValue)) )
                 SetLongOption(Key, Value);
 }
 
 
 void CSettingsStore::SetStringDefault(const string& Key, const string& Value)
 {
         string TmpValue;
         if ( (StringMap.find(Key)==StringMap.end()) && (!LoadSetting(Key, &TmpValue)) )
                 SetStringOption(Key, Value);
 }
 
 
 /* Private functions -- Settings are not saved between sessions unless these
 functions are over-ridden.
 --------------------------------------------------------------------------*/
 
 
-bool CSettingsStore::LoadSetting(const string& Key, bool* Value)
+bool CSettingsStore::LoadSetting(const string& , bool* )
 {
         return false;
 }
 
 
-bool CSettingsStore::LoadSetting(const string& Key, long* Value)
+bool CSettingsStore::LoadSetting(const string& , long* )
 {
         return false;
 }
 
 
-bool CSettingsStore::LoadSetting(const string& Key, string* Value)
+bool CSettingsStore::LoadSetting(const string& , string* )
 {
         return false;
 }
 
 
-void CSettingsStore::SaveSetting(const string& Key, bool Value)
+void CSettingsStore::SaveSetting(const string& , bool )
 {
 }
 
 
-void CSettingsStore::SaveSetting(const string& Key, long Value)
+void CSettingsStore::SaveSetting(const string& , long )
 {
 }
 
 
-void CSettingsStore::SaveSetting(const string& Key, const string& Value)
+void CSettingsStore::SaveSetting(const string& , const string& )
 {
 }