summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--inputmethods/handwriting/qimpenchar.cpp637
-rw-r--r--inputmethods/handwriting/qimpenchar.h2
-rw-r--r--inputmethods/handwriting/qimpencombining.cpp1
3 files changed, 322 insertions, 318 deletions
diff --git a/inputmethods/handwriting/qimpenchar.cpp b/inputmethods/handwriting/qimpenchar.cpp
index 152bfec..0c37e5c 100644
--- a/inputmethods/handwriting/qimpenchar.cpp
+++ b/inputmethods/handwriting/qimpenchar.cpp
@@ -1,505 +1,508 @@
/**********************************************************************
-** Copyright (C) 2000 Trolltech AS. All rights reserved.
-**
-** This file is part of Qtopia Environment.
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See http://www.trolltech.com/gpl/ for GPL licensing information.
-**
-** Contact info@trolltech.com if any conditions of this licensing are
-** not clear to you.
-**
-**********************************************************************/
+ ** Copyright (C) 2000 Trolltech AS. All rights reserved.
+ **
+ ** This file is part of Qtopia Environment.
+ **
+ ** This file may be distributed and/or modified under the terms of the
+ ** GNU General Public License version 2 as published by the Free Software
+ ** Foundation and appearing in the file LICENSE.GPL included in the
+ ** packaging of this file.
+ **
+ ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** See http://www.trolltech.com/gpl/ for GPL licensing information.
+ **
+ ** Contact info@trolltech.com if any conditions of this licensing are
+ ** not clear to you.
+ **
+ **********************************************************************/
#include <qfile.h>
#include <qtl.h>
#include <math.h>
#include <limits.h>
#include <errno.h>
#include <qdatastream.h>
#include "qimpencombining.h"
#include "qimpenchar.h"
#define QIMPEN_MATCH_THRESHOLD 200000
const QIMPenSpecialKeys qimpen_specialKeys[] = {
- { Qt::Key_Escape, "[Esc]" },
- { Qt::Key_Tab, "[Tab]" },
- { Qt::Key_Backspace, "[BackSpace]" },
- { Qt::Key_Return, "[Return]" },
- { QIMPenChar::Caps, "[Uppercase]" },
- { QIMPenChar::CapsLock, "[Caps Lock]" },
- { QIMPenChar::Shortcut, "[Shortcut]" },
- { QIMPenChar::Punctuation, "[Punctuation]" },
- { QIMPenChar::Symbol, "[Symbol]" },
- { QIMPenChar::Extended, "[Extended]" },
- { Qt::Key_unknown, 0 } };
+ { Qt::Key_Escape, "[Esc]" },
+ { Qt::Key_Tab, "[Tab]" },
+ { Qt::Key_Backspace, "[BackSpace]" },
+ { Qt::Key_Return, "[Return]" },
+ { QIMPenChar::Caps, "[Uppercase]" },
+ { QIMPenChar::CapsLock, "[Caps Lock]" },
+ { QIMPenChar::Shortcut, "[Shortcut]" },
+ { QIMPenChar::Punctuation, "[Punctuation]" },
+ { QIMPenChar::Symbol, "[Symbol]" },
+ { QIMPenChar::Extended, "[Extended]" },
+ { Qt::Key_unknown, 0 } };
/*!
\class QIMPenChar qimpenchar.h
Handles a single character. Can calculate closeness of match to
another character.
-*/
+ */
QIMPenChar::QIMPenChar()
{
- flags = 0;
- strokes.setAutoDelete( TRUE );
+ flags = 0;
+ strokes.setAutoDelete( TRUE );
}
QIMPenChar::QIMPenChar( const QIMPenChar &chr )
{
- strokes.setAutoDelete( TRUE );
- ch = chr.ch;
- flags = chr.flags;
- d = chr.d;
- QIMPenStrokeIterator it( chr.strokes );
- while ( it.current() ) {
- strokes.append( new QIMPenStroke( *it.current() ) );
- ++it;
- }
+ strokes.setAutoDelete( TRUE );
+ ch = chr.ch;
+ flags = chr.flags;
+ d = chr.d;
+ QIMPenStrokeIterator it( chr.strokes );
+ while ( it.current() ) {
+ strokes.append( new QIMPenStroke( *it.current() ) );
+ ++it;
+ }
}
QIMPenChar &QIMPenChar::operator=( const QIMPenChar &chr )
{
- strokes.clear();
- ch = chr.ch;
- flags = chr.flags;
- d = chr.d;
- QIMPenStrokeIterator it( chr.strokes );
- while ( it.current() ) {
- strokes.append( new QIMPenStroke( *it.current() ) );
- ++it;
- }
-
- return *this;
+ strokes.clear();
+ ch = chr.ch;
+ flags = chr.flags;
+ d = chr.d;
+ QIMPenStrokeIterator it( chr.strokes );
+ while ( it.current() ) {
+ strokes.append( new QIMPenStroke( *it.current() ) );
+ ++it;
+ }
+
+ return *this;
}
QString QIMPenChar::name() const
{
- QString n;
-
- if ( (ch & 0x0000FFFF) == 0 ) {
- int code = ch >> 16;
- for ( int i = 0; qimpen_specialKeys[i].code != Qt::Key_unknown; i++ ) {
- if ( qimpen_specialKeys[i].code == code ) {
- n = qimpen_specialKeys[i].name;
- break;
- }
+ QString n;
+
+ if ( (ch & 0x0000FFFF) == 0 ) {
+ int code = ch >> 16;
+ for ( int i = 0; qimpen_specialKeys[i].code != Qt::Key_unknown; i++ ) {
+ if ( qimpen_specialKeys[i].code == code ) {
+ n = qimpen_specialKeys[i].name;
+ break;
+ }
+ }
+ } else {
+ n = QChar( ch & 0x0000FFFF );
}
- } else {
- n = QChar( ch & 0x0000FFFF );
- }
- return n;
+ return n;
}
void QIMPenChar::clear()
{
- ch = 0;
- flags = 0;
- d = QString::null;
- strokes.clear();
+ ch = 0;
+ flags = 0;
+ d = QString::null;
+ strokes.clear();
}
unsigned int QIMPenChar::strokeLength( int s ) const
{
- QIMPenStrokeIterator it( strokes );
- while ( it.current() && s ) {
- ++it;
- --s;
- }
+ QIMPenStrokeIterator it( strokes );
+ while ( it.current() && s ) {
+ ++it;
+ --s;
+ }
- if ( it.current() )
- return it.current()->length();
+ if ( it.current() )
+ return it.current()->length();
- return 0;
+ return 0;
}
/*!
Add a stroke to the character
-*/
+ */
void QIMPenChar::addStroke( QIMPenStroke *st )
{
- QIMPenStroke *stroke = new QIMPenStroke( *st );
- strokes.append( stroke );
+ QIMPenStroke *stroke = new QIMPenStroke( *st );
+ strokes.append( stroke );
}
/*!
Return an indicator of the closeness of this character to \a pen.
Lower value is better.
-*/
+ */
int QIMPenChar::match( QIMPenChar *pen )
{
-/*
- if ( strokes.count() > pen->strokes.count() )
- return INT_MAX;
-*/
- int err = 0;
- int maxErr = 0;
- int diff = 0;
- QIMPenStrokeIterator it1( strokes );
- QIMPenStrokeIterator it2( pen->strokes );
- err = it1.current()->match( it2.current() );
- if ( err > maxErr )
- maxErr = err;
- ++it1;
- ++it2;
- while ( err < 400000 && it1.current() && it2.current() ) {
- QPoint p1 = it1.current()->boundingRect().center() -
- strokes.getFirst()->boundingRect().center();
- QPoint p2 = it2.current()->boundingRect().center() -
- pen->strokes.getFirst()->boundingRect().center();
- int xdiff = QABS( p1.x() - p2.x() ) - 6;
- int ydiff = QABS( p1.y() - p2.y() ) - 5;
- if ( xdiff < 0 )
- xdiff = 0;
- if ( ydiff < 0 )
- ydiff = 0;
- if ( xdiff > 10 || ydiff > 10 ) { // not a chance
+ /*
+ if ( strokes.count() > pen->strokes.count() )
+ return INT_MAX;
+ */
+ int err = 0;
+ int maxErr = 0;
+ int diff = 0;
+ QIMPenStrokeIterator it1( strokes );
+ QIMPenStrokeIterator it2( pen->strokes );
+ err = it1.current()->match( it2.current() );
+ if ( err > maxErr )
+ maxErr = err;
+ ++it1;
+ ++it2;
+ while ( err < 400000 && it1.current() && it2.current() ) {
+ QPoint p1 = it1.current()->boundingRect().center() -
+ strokes.getFirst()->boundingRect().center();
+ QPoint p2 = it2.current()->boundingRect().center() -
+ pen->strokes.getFirst()->boundingRect().center();
+ int xdiff = QABS( p1.x() - p2.x() ) - 6;
+ int ydiff = QABS( p1.y() - p2.y() ) - 5;
+ if ( xdiff < 0 )
+ xdiff = 0;
+ if ( ydiff < 0 )
+ ydiff = 0;
+ if ( xdiff > 10 || ydiff > 10 ) { // not a chance
#ifdef DEBUG_QIMPEN
- qDebug( "char %c, stroke starting pt diff excessive", pen->ch );
+ qDebug( "char %c, stroke starting pt diff excessive", pen->ch );
#endif
- return INT_MAX;
+ return INT_MAX;
+ }
+ diff += xdiff*xdiff + ydiff*ydiff;
+ err = it1.current()->match( it2.current() );
+ if ( err > maxErr )
+ maxErr = err;
+ ++it1;
+ ++it2;
}
- diff += xdiff*xdiff + ydiff*ydiff;
- err = it1.current()->match( it2.current() );
- if ( err > maxErr )
- maxErr = err;
- ++it1;
- ++it2;
- }
- maxErr += diff * diff * 6; // magic weighting :)
+ maxErr += diff * diff * 6; // magic weighting :)
#ifdef DEBUG_QIMPEN
- qDebug( "char: %c, maxErr %d, diff %d, (%d)", pen->ch, maxErr, diff, strokes.count() );
+ qDebug( "char: %c, maxErr %d, diff %d, (%d)", pen->ch, maxErr, diff, strokes.count() );
#endif
- return maxErr;
+ return maxErr;
}
/*!
Return the bounding rect of this character. It may have sides with
negative coords since its origin is where the user started drawing
the character.
-*/
+ */
QRect QIMPenChar::boundingRect()
{
- QRect br;
- QIMPenStroke *st = strokes.first();
- while ( st ) {
- br |= st->boundingRect();
- st = strokes.next();
- }
-
- return br;
+ QRect br;
+ QIMPenStroke *st = strokes.first();
+ while ( st ) {
+ br |= st->boundingRect();
+ st = strokes.next();
+ }
+
+ return br;
}
/*!
Write the character's data to the stream.
-*/
+ */
QDataStream &operator<< (QDataStream &s, const QIMPenChar &ws)
{
- s << ws.ch;
- s << ws.flags;
- if ( ws.flags & QIMPenChar::Data )
- s << ws.d;
- s << ws.strokes.count();
- QIMPenStrokeIterator it( ws.strokes );
- while ( it.current() ) {
- s << *it.current();
- ++it;
- }
-
- return s;
+ s << ws.ch;
+ s << ws.flags;
+ if ( ws.flags & QIMPenChar::Data )
+ s << ws.d;
+ s << ws.strokes.count();
+ QIMPenStrokeIterator it( ws.strokes );
+ while ( it.current() ) {
+ s << *it.current();
+ ++it;
+ }
+
+ return s;
}
/*!
Read the character's data from the stream.
-*/
+ */
QDataStream &operator>> (QDataStream &s, QIMPenChar &ws)
{
- s >> ws.ch;
- s >> ws.flags;
- if ( ws.flags & QIMPenChar::Data )
- s >> ws.d;
- unsigned size;
- s >> size;
- for ( unsigned i = 0; i < size; i++ ) {
- QIMPenStroke *st = new QIMPenStroke();
- s >> *st;
- ws.strokes.append( st );
- }
-
- return s;
+ s >> ws.ch;
+ s >> ws.flags;
+ if ( ws.flags & QIMPenChar::Data )
+ s >> ws.d;
+ unsigned size;
+ s >> size;
+ for ( unsigned i = 0; i < size; i++ ) {
+ QIMPenStroke *st = new QIMPenStroke();
+ s >> *st;
+ ws.strokes.append( st );
+ }
+
+ return s;
}
//===========================================================================
bool QIMPenCharMatch::operator>( const QIMPenCharMatch &m )
{
- return error > m.error;
+ return error > m.error;
}
bool QIMPenCharMatch::operator<( const QIMPenCharMatch &m )
{
- return error < m.error;
+ return error < m.error;
}
bool QIMPenCharMatch::operator<=( const QIMPenCharMatch &m )
{
- return error <= m.error;
+ return error <= m.error;
}
//===========================================================================
/*!
\class QIMPenCharSet qimpenchar.h
Maintains a set of related characters.
-*/
+ */
QIMPenCharSet::QIMPenCharSet()
{
- chars.setAutoDelete( TRUE );
- desc = "Unnamed";
- csTitle = "abc";
- csType = Unknown;
- maxStrokes = 0;
+ chars.setAutoDelete( TRUE );
+ desc = "Unnamed";
+ csTitle = "abc";
+ csType = Unknown;
+ maxStrokes = 0;
}
/*!
Construct and load a characters set from file \a fn.
-*/
+ */
QIMPenCharSet::QIMPenCharSet( const QString &fn )
{
- chars.setAutoDelete( TRUE );
- desc = "Unnamed";
- csTitle = "abc";
- csType = Unknown;
- maxStrokes = 0;
- load( fn, System );
+ chars.setAutoDelete( TRUE );
+ desc = "Unnamed";
+ csTitle = "abc";
+ csType = Unknown;
+ maxStrokes = 0;
+ load( fn, System );
}
const QString &QIMPenCharSet::filename( Domain d ) const
{
- if ( d == System )
- return sysFilename;
- else
- return userFilename;
+ if ( d == System )
+ return sysFilename;
+ else
+ return userFilename;
}
void QIMPenCharSet::setFilename( const QString &fn, Domain d )
{
- if ( d == System )
- sysFilename = fn;
- else if ( d == User )
- userFilename = fn;
+ if ( d == System )
+ sysFilename = fn;
+ else if ( d == User )
+ userFilename = fn;
}
/*!
Load a character set from file \a fn.
-*/
+ */
bool QIMPenCharSet::load( const QString &fn, Domain d )
{
- setFilename( fn, d );
-
- bool ok = FALSE;
- QFile file( fn );
- if ( file.open( IO_ReadOnly ) ) {
- QDataStream ds( &file );
- QString version;
- ds >> version;
- ds >> csTitle;
- ds >> desc;
- int major = version.mid( 4, 1 ).toInt();
- int minor = version.mid( 6 ).toInt();
- if ( major >= 1 && minor > 0 ) {
- ds >> (Q_INT8 &)csType;
- } else {
- if ( csTitle == "abc" )
- csType = Lower;
- else if ( csTitle == "ABC" )
- csType = Upper;
- else if ( csTitle == "123" )
- csType = Numeric;
- else if ( fn == "Combining" )
- csType = Combining;
+ setFilename( fn, d );
+
+ bool ok = FALSE;
+ QFile file( fn );
+ if ( file.open( IO_ReadOnly ) ) {
+ QDataStream ds( &file );
+ QString version;
+ ds >> version;
+ ds >> csTitle;
+ ds >> desc;
+ int major = version.mid( 4, 1 ).toInt();
+ int minor = version.mid( 6 ).toInt();
+ if ( major >= 1 && minor > 0 ) {
+ ds >> (Q_INT8 &)csType;
+ } else {
+ if ( csTitle == "abc" )
+ csType = Lower;
+ else if ( csTitle == "ABC" )
+ csType = Upper;
+ else if ( csTitle == "123" )
+ csType = Numeric;
+ else if ( fn == "Combining" )
+ csType = Combining;
+ }
+ while ( !ds.atEnd() ) {
+ QIMPenChar *pc = new QIMPenChar;
+ ds >> *pc;
+ if ( d == User )
+ markDeleted( pc->character() ); // override system
+ addChar( pc );
+ }
+ if ( file.status() == IO_Ok )
+ ok = TRUE;
}
- while ( !ds.atEnd() ) {
- QIMPenChar *pc = new QIMPenChar;
- ds >> *pc;
- if ( d == User )
- markDeleted( pc->character() ); // override system
- addChar( pc );
- }
- if ( file.status() == IO_Ok )
- ok = TRUE;
- }
-
- return ok;
+
+ return ok;
}
/*!
Save this character set.
-*/
+ */
bool QIMPenCharSet::save( Domain d )
{
- if ( filename( d ).isEmpty() )
- return FALSE;
-
- bool ok = FALSE;
-
- QString fn = filename( d );
- QString tmpFn = fn + ".new";
- QFile file( tmpFn );
- if ( file.open( IO_WriteOnly|IO_Raw ) ) {
- QDataStream ds( &file );
- ds << QString( "QPT 1.1" );
- ds << csTitle;
- ds << desc;
- ds << (Q_INT8)csType;
- QIMPenCharIterator ci( chars );
- for ( ; ci.current(); ++ci ) {
- QIMPenChar *pc = ci.current();
- if ( ( (d == System) && pc->testFlag( QIMPenChar::System ) ) ||
- ( (d == User) && !pc->testFlag( QIMPenChar::System ) ) ) {
- ds << *pc;
- }
- if ( file.status() != IO_Ok )
- break;
- }
- if ( file.status() == IO_Ok )
- ok = TRUE;
- }
-
- if ( ok ) {
- if ( ::rename( tmpFn.latin1(), fn.latin1() ) < 0 ) {
- qWarning( "problem renaming file %s to %s, errno: %d",
- tmpFn.latin1(), fn.latin1(), errno );
- // remove the tmp file, otherwise, it will just lay around...
- QFile::remove( tmpFn.latin1() );
- ok = FALSE;
+ if ( filename( d ).isEmpty() )
+ return FALSE;
+
+ bool ok = FALSE;
+
+ QString fn = filename( d );
+ QString tmpFn = fn + ".new";
+ QFile file( tmpFn );
+ if ( file.open( IO_WriteOnly|IO_Raw ) ) {
+ QByteArray buf;
+ QDataStream ds( buf, IO_WriteOnly );
+ ds << QString( "QPT 1.1" );
+ ds << csTitle;
+ ds << desc;
+ ds << (Q_INT8)csType;
+ QIMPenCharIterator ci( chars );
+ for ( ; ci.current(); ++ci ) {
+ QIMPenChar *pc = ci.current();
+ if ( ( ( (d == System) && pc->testFlag( QIMPenChar::System ) ) ||
+ ( (d == User) && !pc->testFlag( QIMPenChar::System ) ) ) &&
+ ( !pc->testFlag (QIMPenChar::Combined ) ) ) {
+ ds << *pc;
+ }
+ }
+
+ file.writeBlock( buf );
+ file.close();
+ if ( file.status() == IO_Ok )
+ ok = TRUE;
}
- }
- return ok;
+ if ( ok ) {
+ if ( ::rename( tmpFn.latin1(), fn.latin1() ) < 0 ) {
+ qWarning( "problem renaming file %s to %s, errno: %d",
+ tmpFn.latin1(), fn.latin1(), errno );
+ // remove the tmp file, otherwise, it will just lay around...
+ QFile::remove( tmpFn.latin1() );
+ ok = FALSE;
+ }
+ }
+
+ return ok;
}
QIMPenChar *QIMPenCharSet::at( int i )
{
- return chars.at(i);
+ return chars.at(i);
}
void QIMPenCharSet::markDeleted( uint ch )
{
- QIMPenCharIterator ci( chars );
- for ( ; ci.current(); ++ci ) {
- QIMPenChar *pc = ci.current();
- if ( pc->character() == ch && pc->testFlag( QIMPenChar::System ) )
- pc->setFlag( QIMPenChar::Deleted );
- }
+ QIMPenCharIterator ci( chars );
+ for ( ; ci.current(); ++ci ) {
+ QIMPenChar *pc = ci.current();
+ if ( pc->character() == ch && pc->testFlag( QIMPenChar::System ) )
+ pc->setFlag( QIMPenChar::Deleted );
+ }
}
/*!
Find the best matches for \a ch in this character set.
-*/
+ */
QIMPenCharMatchList QIMPenCharSet::match( QIMPenChar *ch )
{
- QIMPenCharMatchList matches;
-
- QIMPenCharIterator ci( chars );
- for ( ; ci.current(); ++ci ) {
- QIMPenChar *tmplChar = ci.current();
- if ( tmplChar->testFlag( QIMPenChar::Deleted ) ) {
- continue;
- }
- int err;
- if ( ch->penStrokes().count() <= tmplChar->penStrokes().count() ) {
- err = ch->match( tmplChar );
- if ( err <= QIMPEN_MATCH_THRESHOLD ) {
- if (tmplChar->penStrokes().count() != ch->penStrokes().count())
- err = QMIN(err*3, QIMPEN_MATCH_THRESHOLD);
- QIMPenCharMatchList::Iterator it;
- for ( it = matches.begin(); it != matches.end(); ++it ) {
- if ( (*it).penChar->character() == tmplChar->character() &&
- (*it).penChar->penStrokes().count() == tmplChar->penStrokes().count() ) {
- if ( (*it).error > err )
- (*it).error = err;
- break;
- }
+ QIMPenCharMatchList matches;
+
+ QIMPenCharIterator ci( chars );
+ for ( ; ci.current(); ++ci ) {
+ QIMPenChar *tmplChar = ci.current();
+ if ( tmplChar->testFlag( QIMPenChar::Deleted ) ) {
+ continue;
}
- if ( it == matches.end() ) {
- QIMPenCharMatch m;
- m.error = err;
- m.penChar = tmplChar;
- matches.append( m );
+ int err;
+ if ( ch->penStrokes().count() <= tmplChar->penStrokes().count() ) {
+ err = ch->match( tmplChar );
+ if ( err <= QIMPEN_MATCH_THRESHOLD ) {
+ if (tmplChar->penStrokes().count() != ch->penStrokes().count())
+ err = QMIN(err*3, QIMPEN_MATCH_THRESHOLD);
+ QIMPenCharMatchList::Iterator it;
+ for ( it = matches.begin(); it != matches.end(); ++it ) {
+ if ( (*it).penChar->character() == tmplChar->character() &&
+ (*it).penChar->penStrokes().count() == tmplChar->penStrokes().count() ) {
+ if ( (*it).error > err )
+ (*it).error = err;
+ break;
+ }
+ }
+ if ( it == matches.end() ) {
+ QIMPenCharMatch m;
+ m.error = err;
+ m.penChar = tmplChar;
+ matches.append( m );
+ }
+ }
}
- }
}
- }
- qHeapSort( matches );
-/*
- QIMPenCharMatchList::Iterator it;
- for ( it = matches.begin(); it != matches.end(); ++it ) {
- qDebug( "Match: \'%c\', error %d, strokes %d", (*it).penChar->character(),
- (*it).error, (*it).penChar->penStrokes().count() );
- }
-*/
- return matches;
+ qHeapSort( matches );
+ /*
+ QIMPenCharMatchList::Iterator it;
+ for ( it = matches.begin(); it != matches.end(); ++it ) {
+ qDebug( "Match: \'%c\', error %d, strokes %d", (*it).penChar->character(),
+ (*it).error, (*it).penChar->penStrokes().count() );
+ }
+ */
+ return matches;
}
/*!
Add a character \a ch to this set.
QIMPenCharSet will delete this character when it is no longer needed.
-*/
+ */
void QIMPenCharSet::addChar( QIMPenChar *ch )
{
- if ( ch->penStrokes().count() > maxStrokes )
- maxStrokes = ch->penStrokes().count();
- chars.append( ch );
+ if ( ch->penStrokes().count() > maxStrokes )
+ maxStrokes = ch->penStrokes().count();
+ chars.append( ch );
}
/*!
Remove a character by reference \a ch from this set.
QIMPenCharSet will delete this character.
-*/
+ */
void QIMPenCharSet::removeChar( QIMPenChar *ch )
{
- chars.remove( ch );
+ chars.remove( ch );
}
/*!
Move the character up the list of characters.
-*/
+ */
void QIMPenCharSet::up( QIMPenChar *ch )
{
- int idx = chars.findRef( ch );
- if ( idx > 0 ) {
- chars.take();
- chars.insert( idx - 1, ch );
- }
+ int idx = chars.findRef( ch );
+ if ( idx > 0 ) {
+ chars.take();
+ chars.insert( idx - 1, ch );
+ }
}
/*!
Move the character down the list of characters.
-*/
+ */
void QIMPenCharSet::down( QIMPenChar *ch )
{
- int idx = chars.findRef( ch );
- if ( idx >= 0 && idx < (int)chars.count() - 1 ) {
- chars.take();
- chars.insert( idx + 1, ch );
- }
+ int idx = chars.findRef( ch );
+ if ( idx >= 0 && idx < (int)chars.count() - 1 ) {
+ chars.take();
+ chars.insert( idx + 1, ch );
+ }
}
diff --git a/inputmethods/handwriting/qimpenchar.h b/inputmethods/handwriting/qimpenchar.h
index 9a5f687..efd6f16 100644
--- a/inputmethods/handwriting/qimpenchar.h
+++ b/inputmethods/handwriting/qimpenchar.h
@@ -1,157 +1,157 @@
/**********************************************************************
** Copyright (C) 2000 Trolltech AS. All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#ifndef QIMPENCHAR_H_
#define QIMPENCHAR_H_
#include <qlist.h>
#include <qvaluelist.h>
#include <qcstring.h>
#include "qimpenstroke.h"
struct QIMPenSpecialKeys {
int code;
char *name;
};
extern const QIMPenSpecialKeys qimpen_specialKeys[];
class QIMPenChar
{
public:
QIMPenChar();
QIMPenChar( const QIMPenChar & );
unsigned int character() const { return ch; }
void setCharacter( unsigned int c ) { ch = c; }
const QString &data() const { return d; }
void setData( const QString &ba ) { d = ba; }
QString name() const;
bool isEmpty() const { return strokes.isEmpty(); }
unsigned int strokeCount() const { return strokes.count(); }
unsigned int strokeLength( int s ) const;
void clear();
int match( QIMPenChar *ch );
const QIMPenStrokeList &penStrokes() { return strokes; }
QPoint startingPoint() const { return strokes.getFirst()->startingPoint(); }
QRect boundingRect();
void setFlag( int f ) { flags |= f; }
void clearFlag( int f ) { flags &= ~f; }
bool testFlag( int f ) { return flags & f; }
- enum Flags { System=0x01, Deleted=0x02, CombineRight=0x04, Data=0x08 };
+ enum Flags { System=0x01, Deleted=0x02, CombineRight=0x04, Data=0x08, Combined=0x10 };
// Correspond to codes in template files. Do not change values.
enum Mode { ModeBase=0x4000, Caps=0x4001, Shortcut=0x4002, CapsLock=0x4003,
Punctuation=0x4004, Symbol=0x4005, Extended=0x4006 };
QIMPenChar &operator=( const QIMPenChar &s );
void addStroke( QIMPenStroke * );
protected:
unsigned int ch;
QString d;
Q_UINT8 flags;
QIMPenStrokeList strokes;
friend QDataStream &operator<< (QDataStream &, const QIMPenChar &);
friend QDataStream &operator>> (QDataStream &, QIMPenChar &);
};
typedef QList<QIMPenChar> QIMPenCharList;
typedef QListIterator<QIMPenChar> QIMPenCharIterator;
QDataStream & operator<< (QDataStream & s, const QIMPenChar &ws);
QDataStream & operator>> (QDataStream & s, QIMPenChar &ws);
struct QIMPenCharMatch
{
int error;
QIMPenChar *penChar;
bool operator>( const QIMPenCharMatch &m );
bool operator<( const QIMPenCharMatch &m );
bool operator<=( const QIMPenCharMatch &m );
};
typedef QValueList<QIMPenCharMatch> QIMPenCharMatchList;
class QIMPenCharSet
{
public:
QIMPenCharSet();
QIMPenCharSet( const QString &fn );
bool isEmpty() const { return chars.isEmpty(); }
unsigned int count() const { return chars.count(); }
void clear() { chars.clear(); }
void setDescription( const QString &d ) { desc = d; }
QString description() const { return desc; }
void setTitle( const QString &t ) { csTitle = t; }
QString title() const { return csTitle; }
QIMPenCharMatchList match( QIMPenChar *ch );
void addChar( QIMPenChar *ch );
void removeChar( QIMPenChar *ch );
QIMPenChar *at( int i );
unsigned maximumStrokes() const { return maxStrokes; }
void up( QIMPenChar *ch );
void down( QIMPenChar *ch );
enum Domain { System, User };
enum Type { Unknown=0x00, Lower=0x01, Upper=0x02, Combining=0x04,
Numeric=0x08, Punctuation=0x10, Symbol=0x20, Shortcut=0x40 };
const QIMPenCharList &characters() const { return chars; }
void setType( Type t ) { csType = t; }
Type type() const { return csType; }
const QString &filename( Domain d ) const;
void setFilename( const QString &fn, Domain d=System );
bool load( const QString &fn, Domain d=System );
bool save( Domain d=System );
protected:
void markDeleted( uint ch );
protected:
QString csTitle;
QString desc;
QString sysFilename;
QString userFilename;
Type csType;
unsigned maxStrokes;
QIMPenCharList chars;
QIMPenCharMatchList matches;
};
typedef QList<QIMPenCharSet> QIMPenCharSetList;
typedef QListIterator<QIMPenCharSet> QIMPenCharSetIterator;
#endif
diff --git a/inputmethods/handwriting/qimpencombining.cpp b/inputmethods/handwriting/qimpencombining.cpp
index 30459e7..2e01ac2 100644
--- a/inputmethods/handwriting/qimpencombining.cpp
+++ b/inputmethods/handwriting/qimpencombining.cpp
@@ -1,141 +1,142 @@
/**********************************************************************
** Copyright (C) 2000 Trolltech AS. All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include <qfile.h>
#include <qtl.h>
#include <math.h>
#include <limits.h>
#include <qdatastream.h>
#include "qimpencombining.h"
static unsigned int combiningSymbols[] = { '\\', '/', '^', '~', '\"', 'o' };
static unsigned int combiningChars[][7] = {
// \ / ^ ~ "
{ 'A', 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5 },
{ 'O', 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0000 },
{ 'U', 0x00D9, 0x00DA, 0x00DB, 0x0000, 0x00DC, 0x0000 },
{ 'E', 0x00C8, 0x00C9, 0x00CA, 0x0000, 0x00CB, 0x0000 },
{ 'I', 0x00CC, 0x00CD, 0x00CE, 0x0000, 0x00CF, 0x0000 },
{ 'a', 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5 },
{ 'e', 0x00E8, 0x00E9, 0x00EA, 0x0000, 0x00EB, 0x0000 },
{ 'i', 0x00EC, 0x00ED, 0x00EE, 0x0000, 0x00EF, 0x0000 },
{ 'n', 0x0000, 0x0000, 0x0000, 0x00F1, 0x0000, 0x0000 },
{ 'o', 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0000 },
{ 'u', 0x00F9, 0x00FA, 0x00FB, 0x0000, 0x00FC, 0x0000 },
{ 'y', 0x0000, 0x00FD, 0x0000, 0x0000, 0x00FF, 0x0000 },
{ 0, 0, 0, 0, 0, 0, 0 }
};
QIMPenCombining::QIMPenCombining()
{
}
QIMPenCombining::QIMPenCombining( const QString &fn )
: QIMPenCharSet( fn )
{
}
void QIMPenCombining::addCombined( QIMPenCharSet *cs )
{
unsigned int count = cs->count();
QIMPenCharIterator it( cs->characters() );
for ( ; it.current() && count; ++it, --count ) {
QIMPenChar *pc = it.current();
if ( pc->testFlag( QIMPenChar::Deleted ) )
continue;
int charIdx = findCombining( pc->character() );
if ( charIdx < 0 )
continue;
for ( int i = 0; i < 6; i++ ) {
if ( combiningChars[charIdx][i+1] ) {
QIMPenCharIterator cit( chars );
for ( ; cit.current(); ++cit ) {
QIMPenChar *accentPc = cit.current();
if ( accentPc->character() == combiningSymbols[i] ) {
QIMPenChar *combined = combine( pc, accentPc );
combined->setCharacter( combiningChars[charIdx][i+1] );
+ combined->setFlag( QIMPenChar::Combined );
cs->addChar( combined );
}
}
}
}
}
}
int QIMPenCombining::findCombining( unsigned int ch ) const
{
int i = 0;
while ( combiningChars[i][0] ) {
if ( combiningChars[i][0] == ch )
return i;
i++;
}
return -1;
}
QIMPenChar *QIMPenCombining::combine( QIMPenChar *base, QIMPenChar *accent )
{
QRect brect = base->boundingRect();
QRect arect = accent->boundingRect();
int offset;
if ( accent->testFlag( QIMPenChar::CombineRight ) )
offset = brect.left() - arect.left() + brect.width() + 2;
else
offset = brect.left() - arect.left() + (brect.width() - arect.width())/2;
QIMPenChar *combined = 0;
if ( base->character() == 'i' ) {
// Hack to remove the dot from i's when combining.
if ( base->penStrokes().count() > 1 ) {
combined = new QIMPenChar;
QIMPenStrokeIterator it( base->penStrokes() );
for ( unsigned int i = 0; i < base->penStrokes().count()-1; ++it, i++ ) {
QIMPenStroke *st = new QIMPenStroke( *(it.current()) );
combined->addStroke( st );
}
combined->setFlag( QIMPenChar::System );
}
}
if ( !combined )
combined = new QIMPenChar( *base );
QIMPenStrokeIterator it( accent->penStrokes() );
for ( ; it.current(); ++it ) {
QIMPenStroke *st = new QIMPenStroke( *(it.current()) );
st->setStartingPoint( st->startingPoint() + QPoint(offset, 0 ));
combined->addStroke( st );
delete st;
}
return combined;
}
QIMPenChar *QIMPenCombining::penChar( int type )
{
QIMPenCharIterator it( chars );
for ( ; it.current(); ++it ) {
QIMPenChar *pc = it.current();
if ( pc->character() == combiningSymbols[type] )
return pc;
}
return 0;
}