summaryrefslogtreecommitdiff
path: root/inputmethods/dasher
Side-by-side diff
Diffstat (limited to 'inputmethods/dasher') (more/less context) (ignore whitespace changes)
-rw-r--r--inputmethods/dasher/AlphIO.cpp8
-rw-r--r--inputmethods/dasher/Alphabet.cpp4
-rw-r--r--inputmethods/dasher/AlphabetMap.cpp2
-rw-r--r--inputmethods/dasher/AlphabetMap.h2
-rw-r--r--inputmethods/dasher/DashEdit.h14
-rw-r--r--inputmethods/dasher/DasherInterface.cpp27
-rw-r--r--inputmethods/dasher/DasherInterface.h2
-rw-r--r--inputmethods/dasher/DasherModel.cpp8
-rw-r--r--inputmethods/dasher/DasherNode.cpp2
-rw-r--r--inputmethods/dasher/DasherNode.h20
-rw-r--r--inputmethods/dasher/DasherSettingsInterface.h48
-rw-r--r--inputmethods/dasher/DasherView.cpp4
-rw-r--r--inputmethods/dasher/DasherView.h2
-rw-r--r--inputmethods/dasher/PPMLanguageModel.cpp8
-rw-r--r--inputmethods/dasher/PPMLanguageModel.h7
-rw-r--r--inputmethods/dasher/QtDasherImpl.cc2
-rw-r--r--inputmethods/dasher/QtDasherPlugin.cc2
-rw-r--r--inputmethods/dasher/QtDasherPlugin.h2
-rw-r--r--inputmethods/dasher/QtDasherScreen.cc17
-rw-r--r--inputmethods/dasher/QtDasherScreen.h4
-rw-r--r--inputmethods/dasher/SettingsStore.cpp12
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& )
{
}