Fixes for graffiti handling. Contains a dirty hack that will be rectified when I commit the Graffiti charset.

4 files changed, 19 insertions, 4 deletions

diff --git a/inputmethods/handwriting/qimpenchar.h b/inputmethods/handwriting/qimpenchar.h
index e4e7645..92ee2c1 100644
--- a/inputmethods/handwriting/qimpenchar.h
+++ b/inputmethods/handwriting/qimpenchar.h
@@ -1,160 +1,160 @@
 /**********************************************************************
 ** 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, 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 );
-    void setHidden ( const bool &b ) { phidden = &b; }
+    void setHidden ( const bool &b ) { phidden = b; }
     bool hidden() const { return phidden; }
 
     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;
     bool phidden : 1;
 };
 
 typedef QList<QIMPenCharSet> QIMPenCharSetList;
 typedef QListIterator<QIMPenCharSet> QIMPenCharSetIterator;
 
 #endif
diff --git a/inputmethods/handwriting/qimpenprofile.cpp b/inputmethods/handwriting/qimpenprofile.cpp
index b1a6592..67343c3 100644
--- a/inputmethods/handwriting/qimpenprofile.cpp
+++ b/inputmethods/handwriting/qimpenprofile.cpp
@@ -1,268 +1,271 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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 "qimpencombining.h"
 #include "qimpenprofile.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <qpe/global.h>
 
 
 QIMPenProfile::QIMPenProfile( const QString &fn )
     : filename( fn )
 {
     sets.setAutoDelete( true );
 
     Config config( filename, Config::File );
     config.setGroup( "Handwriting" );
 
     pname = config.readEntry( "Name" );
     pdesc = config.readEntry( "Description" );
 
     tstyle = config.readBoolEntry( "CanSelectStyle", false );
 
     wordMatch = config.readBoolEntry( "MatchWords", true );
 
     config.setGroup( "Settings" );
 
     pstyle = BothCases;
     QString s = config.readEntry( "Style", "BothCases" );
     if ( s == "ToggleCases" )
 	pstyle = ToggleCases;
 
     QString t = config.readEntry( "Mono", "Dual" );
     pmono = (QString::fromLatin1("Mono") == t );
 
     msTimeout = config.readNumEntry( "MultiTimeout", 500 );
 
     // Read user configuration
     Config usrConfig( userConfig() );
     usrConfig.setGroup( "Settings" );
     msTimeout = usrConfig.readNumEntry( "MultiTimeout", msTimeout );
 
     if ( tstyle && usrConfig.hasKey( "Style" ) ) {
 	pstyle = BothCases;
 	QString s = usrConfig.readEntry( "Style", "BothCases" );
 	if ( s == "ToggleCases" )
 	    pstyle = ToggleCases;
     }
 }
 
 void QIMPenProfile::setStyle( Style s )
 {
     if ( tstyle && s != pstyle ) {
 	pstyle = s;
 	Config config( userConfig() );
 	config.setGroup( "Settings" );
 	QString s = pstyle == ToggleCases ? "ToggleCases" : "BothCases";
 	config.writeEntry( "Style", s );
     }
 }
 
 void QIMPenProfile::setMultiStrokeTimeout( int t )
 {
     if ( t != msTimeout ) {
 	msTimeout = t;
 	Config config( userConfig() );
 	config.setGroup( "Settings" );
 	config.writeEntry( "MultiTimeout", msTimeout );
     }
 }
 
 QString QIMPenProfile::userConfig()
 {
     QString un = filename;
     int pos = un.findRev( '/' );
     if ( pos >= 0 )
 	un = un.mid( pos + 1 );
     pos = un.find( '.' );
     if ( pos > 0 )
 	un.truncate( pos );
 
     un = "handwriting-" + un; // No tr
 
     return un;
 }
 
 void QIMPenProfile::loadData()
 {
     Config config( filename, Config::File );
     config.setGroup( "CharSets" );
 
     QString baseDir = QPEApplication::qpeDir();
     baseDir += "/etc/";
     // accents
     QIMPenCombining *combining = 0;
     QString s = config.readEntry( "Combining" );
     if ( !s.isEmpty() ) {
 	combining = new QIMPenCombining( baseDir + "qimpen/" + s );
 	if ( combining->isEmpty() ) {
 	    delete combining;
 	    combining = 0;
 	}
     }
     // uppercase latin1
     QIMPenCharSet *cs = 0;
     s = config.readEntry( "Uppercase" );
     if ( !s.isEmpty() && !mono() ) {
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
 	    if ( combining )
 		combining->addCombined( cs );
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
     // lowercase latin1
     s = config.readEntry( "Lowercase" );
     if ( !s.isEmpty() ) {
 	if ( mono() ) {
 		cs = new QIMPenCharSet ( baseDir + "qimpen/" + s );
 		cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 		if ( !cs->isEmpty() ) {
 		    cs->setTitle( cs->title().upper() );
 		    cs->setType( QIMPenCharSet::Upper );
+		    cs->setDescription( "Hidden uppercase" );
 		    cs->setHidden ( true );
 		    QIMPenCharIterator it( cs->characters() );
 		    for ( ; it.current(); ++it ) {
 			uint ch = it.current()->character();
 			if ( ch >= 'a' && ch <= 'z' )
 			    it.current()->setCharacter( QChar(ch).upper() );
 			}	
 		    if ( combining )
 			combining->addCombined( cs );
 		    sets.append( cs );
 		} else {
 		    delete cs;
 		}
 	}
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
+	    if ( mono () )
+		cs->setDescription( "Latin Characters" );
 	    if ( combining )
 		combining->addCombined( cs );
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
     // numeric (may comtain punctuation and symbols)
     s = config.readEntry( "Numeric" );
     if ( !s.isEmpty() ) {
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
     // punctuation
     s = config.readEntry( "Punctuation" );
     if ( !s.isEmpty() ) {
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
     // symbol
     s = config.readEntry( "Symbol" );
     if ( !s.isEmpty() ) {
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
     // shortcut
     s = config.readEntry( "Shortcut" );
     if ( !s.isEmpty() ) {
 	cs = new QIMPenCharSet( baseDir + "qimpen/" + s );
 	cs->load( Global::applicationFileName("qimpen",s), QIMPenCharSet::User );
 	if ( !cs->isEmpty() ) {
 	    sets.append( cs );
 	} else {
 	    delete cs;
 	}
     }
 
     if ( combining )
 	delete combining;
 }
 
 QIMPenCharSet *QIMPenProfile::uppercase()
 {
     return find( QIMPenCharSet::Upper );
 }
 
 QIMPenCharSet *QIMPenProfile::lowercase()
 {
     return find( QIMPenCharSet::Lower );
 }
 
 QIMPenCharSet *QIMPenProfile::numeric()
 {
     return find( QIMPenCharSet::Numeric );
 }
 
 QIMPenCharSet *QIMPenProfile::punctuation()
 {
     return find( QIMPenCharSet::Punctuation );
 }
 
 QIMPenCharSet *QIMPenProfile::symbol()
 {
     return find( QIMPenCharSet::Symbol );
 }
 
 QIMPenCharSet *QIMPenProfile::shortcut()
 {
     return find( QIMPenCharSet::Shortcut );
 }
 
 QIMPenCharSetList &QIMPenProfile::charSets()
 {
     if ( sets.isEmpty() )
 	loadData();
     return sets;
 }
 
 QIMPenCharSet *QIMPenProfile::find( QIMPenCharSet::Type t )
 {
     if ( sets.isEmpty() )
 	loadData();
     QIMPenCharSetIterator it( sets );
     for ( ; it.current(); ++it ) {
 	if ( it.current()->type() == t )
 	    return it.current();
     }
 
     return 0;
 }
 
 
diff --git a/inputmethods/handwriting/qimpensetup.cpp b/inputmethods/handwriting/qimpensetup.cpp
index d1297a9..3f4841d 100644
--- a/inputmethods/handwriting/qimpensetup.cpp
+++ b/inputmethods/handwriting/qimpensetup.cpp
@@ -137,529 +137,540 @@ QIMPenSetup::QIMPenSetup( QIMPenProfile *p, QWidget *parent,
 #endif
 
 }
 
 void QIMPenSetup::loadProfiles()
 {
     QString path = QPEApplication::qpeDir() + "etc/qimpen";
     QDir dir( path, "*.conf" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
 	QIMPenProfile *p = new QIMPenProfile( path + "/" + *it );
 	profileList.append( p );
 	profileCombo->insertItem( p->name() );
 	if ( p->name() == profile->name() ) {
 	    profileCombo->setCurrentItem( profileCombo->count()-1 );
 	    profile = p;
 	    edit->setProfile( profile );
 	}
     }
 }
 
 void QIMPenSetup::styleClicked( int id )
 {
     style = id;
 }
 
 void QIMPenSetup::multiTimeoutChanged( int v )
 {
     multiTimeout = v;
     pref->multiStrokeLabel->setText( tr("%1 ms").arg(v) );
 }
 
 void QIMPenSetup::selectProfile( const QString &p )
 {
     if ( p == profile->name() )
 	return;
 
     profile->setStyle( style ? QIMPenProfile::ToggleCases : QIMPenProfile::BothCases );
     profile->setMultiStrokeTimeout( multiTimeout );
 
     for ( int i = 0; i < (int)profileList.count(); i++ ) {
 	if ( profileList.at(i)->name() == p ) {
 	    profile = profileList.at(i);
 	    style = profile->style() == QIMPenProfile::ToggleCases ? 1 : 0;
 	    pref->inputStyle->setButton( style );
 	    pref->inputStyle->setEnabled( profile->canSelectStyle() );
 	    multiTimeout = profile->multiStrokeTimeout();
 	    pref->multiStrokeSlider->setValue( multiTimeout );
 	    multiTimeoutChanged( multiTimeout );
 	    edit->setProfile( profile );
 	    break;
 	}
     }
 }
 
 void QIMPenSetup::accept()
 {
     profile->setStyle( style ? QIMPenProfile::ToggleCases : QIMPenProfile::BothCases );
     profile->setMultiStrokeTimeout( multiTimeout );
     // Save current profile
     if ( profileCombo ) {
 	Config config( "handwriting" );
 	config.setGroup( "Settings" );
 	config.writeEntry( "Profile", profileCombo->currentText() );
     }
     // Save charsets
     bool ok = TRUE;
     for ( int i = 0; i < (int)profileList.count(); i++ ) {
 	QIMPenProfile *prof = profileList.at(i);
 	QIMPenCharSetIterator it(prof->charSets());
 	for ( ; it.current(); ++it ) {
 	    if ( !(it.current()->save( QIMPenCharSet::User )) ) {
 		ok = FALSE;
 		break;
 	    }
 	}
     }
     if ( !ok ) {
 	if ( QMessageBox::critical( 0, tr( "Out of space" ),
 		    tr("Unable to save information.\n"
 			"Free up some space\n"
 			"and try again.\n"
 			"\nQuit anyway?"),
 		    QMessageBox::Yes|QMessageBox::Escape,
 		    QMessageBox::No|QMessageBox::Default )
 		!= QMessageBox::No ) {
 	    QDialog::accept();
 	}
     } else {
 	QDialog::accept();
     }
 }
 
 //---------------------------------------------------------------------------
 
 QIMPenInputCharDlg::QIMPenInputCharDlg( QWidget *parent, const char *name,
 	bool modal, int WFlags)
     : QDialog( parent, name, modal, WFlags )
 {
     setCaption( tr("Enter new character") );
     uni = 0;
 
     QVBoxLayout *vb = new QVBoxLayout( this, 10 );
 
     QHBoxLayout *hb = new QHBoxLayout();
     vb->addLayout( hb );
 
     QLabel *label = new QLabel( tr("Character:"), this );
     hb->addWidget( label );
 
     QComboBox *cb = new QComboBox( TRUE, this );
     connect( cb, SIGNAL(activated(int)), SLOT(setSpecial(int)) );
     connect( cb, SIGNAL(textChanged(const QString&)),
 	    SLOT(setCharacter(const QString&)) );
     addSpecial( cb );
     cb->setEditText( "" );
     hb->addWidget( cb );
 
     hb = new QHBoxLayout();
     vb->addLayout( hb );
 
     QPushButton *pb = new QPushButton( "OK", this );
     connect( pb, SIGNAL(clicked()), SLOT(accept()));
     hb->addWidget( pb );
     pb = new QPushButton( "Cancel", this );
     connect( pb, SIGNAL(clicked()), SLOT(reject()));
     hb->addWidget( pb );
 
     cb->setFocus();
 }
 
 void QIMPenInputCharDlg::addSpecial( QComboBox *cb )
 {
     int i = 0;
     while ( qimpen_specialKeys[i].code != Key_unknown ) {
 	cb->insertItem( qimpen_specialKeys[i].name );
 	i++;
     }
 }
 
 void QIMPenInputCharDlg::setSpecial( int sp )
 {
     uni = qimpen_specialKeys[sp].code << 16;
 }
 
 void QIMPenInputCharDlg::setCharacter( const QString &string )
 {
     uni = string[0].unicode();
 }
 
 //---------------------------------------------------------------------------
 
 class CharListItem : public QListBoxText
 {
 public:
     CharListItem( const QString &text, uint c )
 	: QListBoxText( text )
     {
 	_code = c;
     }
 
     uint code() const { return _code; }
 
 protected:
     uint _code;
 };
 
 /*!
   \class QIMPenEdit qimpensetup.h
 
   Class to allow users to input totally useless character definitions
   which could match any number of the default set.
 */
 
 QIMPenEdit::QIMPenEdit( QIMPenProfile *p, QWidget *parent,
                 const char *name )
     : QWidget( parent, name ), profile(p)
 {
     currentChar = 0;
     currentCode = 0;
     inputChar = new QIMPenChar();
 
     QVBoxLayout *tvb = new QVBoxLayout( this, 5 );
 
     QGridLayout *gl = new QGridLayout( tvb, 4, 2 );
     gl->setRowStretch( 1, 1 );
     gl->addRowSpacing( 2, 35 );
     gl->addRowSpacing( 3, 35 );
 
     charSetCombo = new QComboBox( this );
     gl->addMultiCellWidget( charSetCombo, 0, 0, 0, 1 );
-    connect( charSetCombo, SIGNAL(activated(int)), SLOT(selectCharSet(int)));
+    connect( charSetCombo, SIGNAL(activated(int)), SLOT(selectCharSetVisible(int)));
     QIMPenCharSetIterator it( profile->charSets() );
     for ( ; it.current(); ++it ) {
         charSetCombo->insertItem( it.current()->description() );
     }
 
     charList = new QListBox( this );
     charList->setMinimumHeight( charList->sizeHint().height() );
     connect( charList, SIGNAL(highlighted(int)), SLOT(selectChar(int)) );
     gl->addWidget( charList, 1, 0 );
 
     pw = new QIMPenWidget( this );
     pw->setFixedHeight( 75 );
     gl->addMultiCellWidget( pw, 2, 3, 0, 0 );
     connect( pw, SIGNAL(stroke(QIMPenStroke*)),
                  SLOT(newStroke(QIMPenStroke*)) );
 
     QVBoxLayout *vb = new QVBoxLayout();
     gl->addLayout( vb, 1, 1 );
     newBtn = new QPushButton( tr("New..."), this );
     connect( newBtn, SIGNAL(clicked()), SLOT(addNewChar()) );
     vb->addWidget( newBtn );
 
     addBtn = new QPushButton( tr("Add"), this );
     connect( addBtn, SIGNAL(clicked()), SLOT(addChar()) );
     vb->addWidget( addBtn );
 
     removeBtn = new QPushButton( tr("Remove"), this );
     connect( removeBtn, SIGNAL(clicked()), SLOT(removeChar()) );
     vb->addWidget( removeBtn );
 
     QPushButton *pb = new QPushButton( tr("Default"), this );
     connect( pb, SIGNAL(clicked()), SLOT(defaultChars()) );
     vb->addWidget( pb );
 
     QHBoxLayout *hb = new QHBoxLayout();
     gl->addLayout( hb, 2, 1 );
     prevBtn = new QPushButton( this );
     prevBtn->setPixmap( QPixmap( (const char **)left_xpm ) );
     connect( prevBtn, SIGNAL(clicked()), SLOT(prevChar()));
     hb->addWidget( prevBtn );
 
     nextBtn = new QPushButton( this );
     nextBtn->setPixmap( QPixmap( (const char **)right_xpm ) );
     connect( nextBtn, SIGNAL(clicked()), SLOT(nextChar()));
     hb->addWidget( nextBtn );
 
     pb = new QPushButton( tr("Clear"), this );
     connect( pb, SIGNAL(clicked()), SLOT(clearChar()) );
     gl->addWidget( pb, 3, 1 );
 
     //--
 #if !defined(Q_WS_QWS)
     hb = new QHBoxLayout( tvb );
     pb = new QPushButton( tr("OK"), this );
     connect( pb, SIGNAL(clicked()), SLOT(accept()) );
     hb->addWidget( pb );
 
     pb = new QPushButton( tr("Cancel"), this );
     connect( pb, SIGNAL(clicked()), SLOT(reject()) );
     hb->addWidget( pb );
 #endif
-    selectCharSet( 0 );
+    selectCharSetVisible( 0 );
     charList->setFocus();
 
     resize( minimumSize() );
     enableButtons();
 }
 
 void QIMPenEdit::setProfile( QIMPenProfile *p )
 {
     profile = p;
     charSetCombo->clear();
     QIMPenCharSetIterator it( profile->charSets() );
     for ( ; it.current(); ++it ) {
 	if ( ! it.current()->hidden() )
 	    charSetCombo->insertItem( it.current()->description() );
     }
-    selectCharSet( 0 );
+    selectCharSetVisible( 0 );
     charList->setFocus();
     enableButtons();
 }
 
 void QIMPenEdit::selectCharSet( QIMPenCharSet *c )
 {
     int i = 0;
     QIMPenCharSetIterator it( profile->charSets() );
     for ( ; it.current(); ++it, i++ ) {
         if ( it.current() == c ) {
 	    charSetCombo->setCurrentItem( i );
 	    selectCharSet( i );
 	}
     }
 }
 
 
 /*!
   Fill the character list box with the characters.  Duplicates are not
   inserted.
 */
 void QIMPenEdit::fillCharList()
 {
     charList->clear();
     QIMPenCharIterator it( currentSet->characters() );
     CharListItem *li = 0;
     for ( ; it.current(); ++it ) {
 	uint ch = it.current()->character();
 	QString n = it.current()->name();
 	if ( !n.isEmpty() )
 	    li = new CharListItem( n, ch );
 	if ( li ) {
 	    CharListItem *i = (CharListItem *)charList->findItem( li->text() );
 	    if ( !i || i->code() != ch ) {
 		charList->insertItem( li );
 	    } else {
 		delete li;
 		li = 0;
 	    }
 	}
     }
     currentChar = 0;
 }
 
 void QIMPenEdit::enableButtons()
 {
     bool add =  !inputChar->isEmpty();
     newBtn->setEnabled( add );
     addBtn->setEnabled( add );
     removeBtn->setEnabled( currentChar );
 }
 
 /*!
   Find the previous character with the same code as the current one.
   returns 0 if there is no previous character.
 */
 QIMPenChar *QIMPenEdit::findPrev()
 {
     if ( !currentChar )
 	return 0;
     QIMPenCharIterator it( currentSet->characters() );
     bool found = FALSE;
     for ( it.toLast(); it.current(); --it ) {
         if ( !found && it.current() == currentChar )
             found = TRUE;
         else if ( found && it.current()->character() == currentCode &&
                 !it.current()->testFlag( QIMPenChar::Deleted ) ) {
             return it.current();
         }
     }
 
     return 0;
 }
 
 /*!
   Find the next character with the same code as the current one.
   returns 0 if there is no next character.
 */
 QIMPenChar *QIMPenEdit::findNext()
 {
     if ( !currentChar )
 	return 0;
     QIMPenCharIterator it( currentSet->characters() );
     bool found = FALSE;
     for ( ; it.current(); ++it ) {
 	if ( !found && it.current() == currentChar )
 	    found = TRUE;
 	else if ( found && it.current()->character() == currentCode &&
 		    !it.current()->testFlag( QIMPenChar::Deleted ) ) {
 	    return it.current();
 	}
     }
 
     return 0;
 }
 
 void QIMPenEdit::setCurrentChar( QIMPenChar *pc )
 {
     currentChar = pc;
     pw->showCharacter( currentChar );
     if ( currentChar ) {
 	prevBtn->setEnabled( findPrev() != 0 );
 	nextBtn->setEnabled( findNext() != 0 );
     }
 }
 
 void QIMPenEdit::prevChar()
 {
     QIMPenChar *pc = findPrev();
     if ( pc )
 	setCurrentChar( pc );
 }
 
 void QIMPenEdit::nextChar()
 {
     QIMPenChar *pc = findNext();
     if ( pc )
 	setCurrentChar( pc );
 }
 
 void QIMPenEdit::clearChar()
 {
     inputChar->clear();
     pw->clear();
     enableButtons();
 }
 
 void QIMPenEdit::selectChar( int i )
 {
     currentChar = 0;
     currentCode = ((CharListItem *)charList->item(i))->code();
     QIMPenCharIterator it(currentSet->characters() );
     for ( ; it.current(); ++it ) {
 	if ( it.current()->character() == currentCode &&
 	     !it.current()->testFlag( QIMPenChar::Deleted ) ) {
 	    setCurrentChar( it.current() );
 	    break;
 	}
     }
     if ( !it.current() )
 	setCurrentChar( 0 );
     inputChar->clear();
 }
 
+void QIMPenEdit::selectCharSetVisible( int c )
+{
+    int i = 0;
+    QIMPenCharSetIterator it( profile->charSets() );
+    for ( ; it.current(); ++it, i++ ) {
+        if ( charSetCombo->text( c ) == it.current()->description() ) {
+	    selectCharSet( i );
+	}
+    }
+}
+
 void QIMPenEdit::selectCharSet( int i )
 {
     if ( currentSet )
         pw->removeCharSet( 0 );
     currentSet = profile->charSets().at( i );
     fillCharList();
     pw->insertCharSet( currentSet );
     inputChar->clear();
     if ( charList->count() ) {
         charList->setSelected( 0, TRUE );
         selectChar(0);
     }
 }
 
 void QIMPenEdit::addChar()
 {
     if ( !inputChar->isEmpty() ) {
         QIMPenChar *pc = new QIMPenChar( *inputChar );
         pc->setCharacter( currentCode );
 
 	// User characters override all matching system characters.
 	// Copy and mark deleted identical system characters.
 
 	QIMPenCharIterator it(currentSet->characters() );
 	QIMPenChar *sc = 0;
 	while ( (sc = it.current()) != 0 ) {
 	    ++it;
 	    if ( sc->character() == currentCode &&
 		 sc->testFlag( QIMPenChar::System ) &&
 		 !sc->testFlag( QIMPenChar::Deleted ) ) {
 		QIMPenChar *cc = new QIMPenChar( *sc );
 		cc->clearFlag( QIMPenChar::System );
 		currentSet->addChar( cc );
 		sc->setFlag( QIMPenChar::Deleted );
 	    }
 	}
 
         currentSet->addChar( pc );
         setCurrentChar( pc );
         inputChar->clear();
     }
 }
 
 void QIMPenEdit::addNewChar()
 {
     if ( !inputChar->isEmpty() ) {
 	QIMPenInputCharDlg dlg( 0, 0, TRUE );
 	if ( dlg.exec() ) {
 	    currentCode = dlg.unicode();
 	    addChar();
 	    fillCharList();
 	    for ( unsigned int i = 0; i < charList->count(); i++ ) {
 		CharListItem *li = (CharListItem *)charList->item(i);
 		if ( li->code() == dlg.unicode() ) {
 		    charList->setSelected( i, TRUE );
 		    break;
 		}
 	    }
 	}
     }
 }
 
 void QIMPenEdit::removeChar()
 {
     if ( currentChar ) {
 	QIMPenChar *pc = findPrev();
 	if ( !pc ) pc = findNext();
 	if ( currentChar->testFlag( QIMPenChar::System ) )
 	    currentChar->setFlag( QIMPenChar::Deleted );
 	else
 	    currentSet->removeChar( currentChar );
 	setCurrentChar( pc );
     }
 }
 
 void QIMPenEdit::defaultChars()
 {
     if ( currentCode ) {
 	currentChar = 0;
 	bool haveSystem = FALSE;
 	QIMPenCharIterator it(currentSet->characters() );
 	for ( ; it.current(); ++it ) {
 	    if ( it.current()->character() == currentCode &&
 		 it.current()->testFlag( QIMPenChar::System ) ) {
 		haveSystem = TRUE;
 		break;
 	    }
 	}
 	if ( haveSystem ) {
 	    it.toFirst();
 	    while ( it.current() ) {
 		QIMPenChar *pc = it.current();
 		++it;
 		if ( pc->character() == currentCode ) {
 		    if ( pc->testFlag( QIMPenChar::System ) ) {
 			pc->clearFlag( QIMPenChar::Deleted );
 			if ( !currentChar )
 			    currentChar = pc;
 		    } else {
 			currentSet->removeChar( pc );
 		    }
 		}
 	    }
 	    setCurrentChar( currentChar );
 	}
     }
 }
 
 void QIMPenEdit::newStroke( QIMPenStroke *st )
 {
     inputChar->addStroke( st );
     enableButtons();
 }
 
diff --git a/inputmethods/handwriting/qimpensetup.h b/inputmethods/handwriting/qimpensetup.h
index 5d3064b..93b981b 100644
--- a/inputmethods/handwriting/qimpensetup.h
+++ b/inputmethods/handwriting/qimpensetup.h
@@ -1,124 +1,125 @@
 /**********************************************************************
 ** 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 <qdialog.h>
 #include <qlist.h>
 #include "qimpenprofile.h"
 
 class QListBox;
 class QPushButton;
 class QComboBox;
 class QIMPenWidget;
 class QIMPenEdit;
 class QIMPenPrefBase;
 
 class QIMPenSetup : public QDialog
 {
     Q_OBJECT
 public:
     QIMPenSetup( QIMPenProfile *p, QWidget *parent=0,
 		const char *name=0, bool modal=FALSE, int WFlags=0 );
 
     QIMPenEdit *editor() { return edit; }
 
 protected:
     void loadProfiles();
     virtual void accept();
 
 private slots:
     void styleClicked( int );
     void multiTimeoutChanged( int );
     void selectProfile( const QString &p );
 
 private:
     QComboBox *profileCombo;
     QIMPenEdit *edit;
     QIMPenPrefBase *pref;
     int style;
     int multiTimeout;
     QIMPenProfile *profile;
     QList<QIMPenProfile> profileList;
 };
 
 class QIMPenInputCharDlg : public QDialog
 {
     Q_OBJECT
 public:
     QIMPenInputCharDlg( QWidget *parent = 0, const char *name = 0,
 	    bool modal = FALSE, int WFlags = 0 );
 
     unsigned int unicode() const { return uni; }
 
 protected:
     void addSpecial( QComboBox *cb );
 
 protected slots:
     void setSpecial( int sp );
     void setCharacter( const QString &string );
 
 protected:
     uint uni;
 };
 
 class QIMPenEdit : public QWidget
 {
     Q_OBJECT
 public:
     QIMPenEdit( QIMPenProfile *p, QWidget *parent=0,
 		const char *name=0 );
 
     void setProfile( QIMPenProfile *p );
     void selectCharSet( QIMPenCharSet *c );
 
 protected:
     void fillCharList();
     void enableButtons();
     QIMPenChar *findPrev();
     QIMPenChar *findNext();
     void setCurrentChar( QIMPenChar * );
 
 protected slots:
     void prevChar();
     void nextChar();
     void clearChar();
     void selectChar( int );
     void selectCharSet( int );
+    void selectCharSetVisible( int );
     void addChar();
     void addNewChar();
     void removeChar();
     void defaultChars();
     void newStroke( QIMPenStroke * );
 
 protected:
     QIMPenWidget *pw;
     QComboBox *charSetCombo;
     QListBox *charList;
     QPushButton *newBtn;
     QPushButton *addBtn;
     QPushButton *removeBtn;
     QPushButton *prevBtn;
     QPushButton *nextBtn;
     uint currentCode;
     QIMPenChar *currentChar;
     QIMPenChar *inputChar;
     QIMPenCharSet *currentSet;
     QIMPenProfile *profile;
 };