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,65 +1,67 @@ // 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 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,58 +1,58 @@ // 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); 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,39 +1,39 @@ // 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 { 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 @@ -47,49 +47,49 @@ 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]; 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 @@ -2,122 +2,122 @@ // 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() {}; 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 @@ -4,53 +4,70 @@ // // 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); } 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 @@ -17,49 +17,49 @@ #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 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,44 +1,44 @@ // 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) { @@ -84,49 +84,49 @@ 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(); @@ -163,49 +163,49 @@ void CDasherModel::Start() //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")); @@ -222,49 +222,49 @@ void CDasherModel::Get_new_root_coords(myint Mousex,myint Mousey) // 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(); } 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 @@ -11,49 +11,49 @@ 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 { 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 @@ -53,51 +53,65 @@ public: 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; } */ } ///////////////////////////////////////////////////////////////////////////// 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,122 +1,122 @@ // 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; 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 @@ -3,56 +3,56 @@ ///////////////////////////////////////////////////////////////////////////// // // 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); } 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 @@ -7,49 +7,49 @@ ///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // 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; 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 @@ -51,62 +51,62 @@ CPPMLanguageModel::CPPMnode * CPPMLanguageModel::CPPMnode::add_symbol_to_node(in 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; @@ -171,49 +171,49 @@ void CPPMLanguageModel::AddSymbol(CPPMLanguageModel::CPPMContext &context,int sy 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) { @@ -225,49 +225,49 @@ void CPPMLanguageModel::LearnSymbol(CContext* Context, modelchar 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; 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,68 +1,69 @@ // 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 ); 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,48 +1,48 @@ #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() 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 @@ -28,49 +28,49 @@ QtDasherPlugin::QtDasherPlugin(QWidget* parent, const char* name, WFlags f) : QF 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; 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,59 +1,64 @@ // 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; @@ -122,49 +127,49 @@ static void Points_to_QPointArray(const Dasher::CDasherScreen::point* const poin { 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 @@ -15,59 +15,59 @@ #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; 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 @@ -81,55 +81,55 @@ void CSettingsStore::SetBoolDefault(const string& Key, bool 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& ) { } |