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
@@ -5,49 +5,51 @@
 // 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;
 }
 
 
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
@@ -7,40 +7,40 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #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 */
 
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
@@ -3,25 +3,25 @@
 /////////////////////////////////////////////////////////////////////////////
 //
 // 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)
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
@@ -59,25 +59,25 @@ 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;
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
@@ -14,98 +14,98 @@ 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
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
@@ -16,29 +16,46 @@
 #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;
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
@@ -29,25 +29,25 @@
 #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
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
@@ -8,25 +8,25 @@
 
 #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;
 }
 
 
@@ -96,25 +96,25 @@ CDasherNode * CDasherModel::Get_node_under_mouse(myint Mousex,myint 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]);
         }
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -175,25 +175,25 @@ void CDasherModel::Start()
         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   
         
@@ -234,25 +234,25 @@ void CDasherModel::Get_new_root_coords(myint Mousex,myint Mousey)
 
         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();
 
 
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
@@ -23,25 +23,25 @@ void CDasherNode::Dump_node () const
                 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
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
@@ -65,27 +65,41 @@ public:
         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;
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
@@ -12,99 +12,99 @@
 
 #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.
         // -------------------------------------------------------------------
         
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
@@ -15,32 +15,32 @@ CDasherView::CDasherView(CDasherScreen* DasherScreen, CDasherModel& DasherModel,
 {
         //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();
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
@@ -19,25 +19,25 @@
 #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;
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
@@ -63,38 +63,38 @@ CPPMLanguageModel::CPPMLanguageModel(CAlphabet *_alphabet,int _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"));
@@ -183,25 +183,25 @@ void CPPMLanguageModel::AddSymbol(CPPMLanguageModel::CPPMContext &context,int sy
                 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;
@@ -237,25 +237,25 @@ void CPPMLanguageModel::dumpString( char *str, int pos, int len )
         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( "                     <" );
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
@@ -7,50 +7,51 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #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);
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
@@ -12,25 +12,25 @@ static const char * qtdasher_xpm[]={
 "# 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 ) {
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
@@ -40,25 +40,25 @@ QtDasherPlugin::~QtDasherPlugin()
 
 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 );
   }
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
@@ -13,25 +13,25 @@ public:
 
   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
@@ -9,39 +9,44 @@
 #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);
 
@@ -134,25 +139,25 @@ void QtDasherScreen::Polyline(point* Points, int Number) const
   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;
 }
 
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
@@ -27,35 +27,35 @@ 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);
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
@@ -93,43 +93,43 @@ 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& )
 {
 }