QPEApplication::showDialog() and QPEAPplication::execDialog() for better big screen handling

12 files changed, 28 insertions, 65 deletions

diff --git a/core/apps/embeddedkonsole/konsole.cpp b/core/apps/embeddedkonsole/konsole.cpp
index a5adc03..ce8fb6b 100644
--- a/core/apps/embeddedkonsole/konsole.cpp
+++ b/core/apps/embeddedkonsole/konsole.cpp
@@ -1,1175 +1,1176 @@
 /* ---------------------------------------------------------------------- */
 /*                                                                        */
 /* [main.C]                        Konsole                                */
 /*                                                                        */
 /* ---------------------------------------------------------------------- */
 /*                                                                        */
 /* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de>        */
 /*                                                                        */
 /* This file is part of Konsole, an X terminal.                           */
 /*                                                                        */
 /* The material contained in here more or less directly orginates from    */
 /* kvt, which is copyright (c) 1996 by Matthias Ettrich <ettrich@kde.org> */
 /*                                                                        */
 /* ---------------------------------------------------------------------- */
 /*                        */
 /* Ported Konsole to Qt/Embedded                                              */
 /*                        */
 /* Copyright (C) 2000 by John Ryland <jryland@trolltech.com>                  */
 /*                        */
 /* -------------------------------------------------------------------------- */
 // enhancements added by L.J. Potter <ljp@llornkcor.com>
 //#define QT_QWS_OPIE
 
 #include "signal.h"
 
 #include <qpe/resource.h>
 
 #include <qdir.h>
 #include <qevent.h>
 #include <qdragobject.h>
 #include <qobjectlist.h>
 #include <qtoolbutton.h>
 #include <qtoolbar.h>
 #include <qpushbutton.h>
 #include <qfontdialog.h>
 #include <qglobal.h>
 #include <qpainter.h>
 #include <qmenubar.h>
 #include <qmessagebox.h>
 #include <qaction.h>
 #include <qapplication.h>
 #include <qfontmetrics.h>
 #include <qcombobox.h>
 #include <qevent.h>
 #include <qtabwidget.h>
 #include <qtabbar.h>
-#include <qpe/config.h>
 #include <qstringlist.h>
 #include <qpalette.h>
+#include <qpe/config.h>
+#include <qpe/qpeapplication.h>
 
 #include <unistd.h>
 #include <pwd.h>
 #include <sys/types.h>
 //#include <sys/wait.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 
 #include "konsole.h"
 #include "keytrans.h"
 #include "commandeditdialog.h"
 
 #ifdef  QT_QWS_OPIE
 #include <opie/colorpopupmenu.h>
 #endif
 
         #include <qfontdatabase.h>// U.B.
         #include <qstringlist.h>// U.B.
         #include <qvaluelist.h>         // U.B.
 
 class EKNumTabBar : public QTabBar {
 public:
     void numberTabs()
     {
   // Yes, it really is this messy. QTabWidget needs functions
   // that provide acces to tabs in a sequential way.
   int m=INT_MIN;
   for (int i=0; i<count(); i++) {
       QTab* left=0;
       QListIterator<QTab> it(*tabList());
       int x=INT_MAX;
       for( QTab* t; (t=it.current()); ++it ) {
     int tx = t->rect().x();
     if ( tx<x && tx>m ) {
         x = tx;
         left = t;
     }
       }
       if ( left ) {
     left->setText(QString::number(i+1));
     m = left->rect().x();
       }
   }
     }
 };
 
 class EKNumTabWidget : public QTabWidget {
 public:
     EKNumTabWidget(QWidget* parent) : QTabWidget(parent)
     {
     }
 
     void addTab(QWidget* w)
     {
   QTab* t = new QTab(QString::number(tabBar()->count()+1));
   QTabWidget::addTab(w,t);
     }
 
     void removeTab(QWidget* w)
     {
   removePage(w);
   ((EKNumTabBar*)tabBar())->numberTabs();
     }
 };
 
 // This could be configurable or dynamicly generated from the bash history
 // file of the user
 static const char *commonCmds[] =
 {
     "ls ", // I left this here, cause it looks better than the first alpha
     "cardctl eject",
     "cat ",
     "cd ",
     "chmod ",
     "clear",
     "cp ",
     "dc ",
     "df ",
     "dmesg",
     "echo ",
     "env",
     "find ",
     "free",
     "grep ",
     "ifconfig ",
     "ipkg ",
     "mkdir ",
     "mv ",
     "nc localhost 7776",
     "nc localhost 7777",
     "netstat ",
     "nslookup ",
     "ping ",
     "ps aux",
     "pwd ",
     "qcop QPE/System 'linkChanged(QString)' ''",
     "qcop QPE/System 'restart()'",
     "qcop QPE/System 'quit()'",
     "rm ",
     "rmdir ",
     "route ",
     "set ",
     "traceroute",
 
 /*
     "gzip",
     "gunzip",
     "chgrp",
     "chown",
     "date",
     "dd",
     "df",
     "dmesg",
     "fuser",
     "hostname",
     "kill",
     "killall",
     "ln",
     "ping",
     "mount",
     "more",
     "sort",
     "touch",
     "umount",
     "mknod",
     "netstat",
 */
 
     "exit",
     NULL
 };
 
 static void konsoleInit(const char** shell) {
     if(setuid(getuid()) !=0) qDebug("setuid failed");
     if(setgid(getgid()) != 0) qDebug("setgid failed"); // drop privileges
 
         //      signal (SIGSTOP, SIG_IGN);
  
 //  QPEApplication::grabKeyboard(); // for CTRL and ALT
 
 //    qDebug("keyboard grabbed");
 #ifdef FAKE_CTRL_AND_ALT
     qDebug("Fake Ctrl and Alt defined");
     QPEApplication::grabKeyboard(); // for CTRL and ALT
 #endif
 
     *shell = getenv("SHELL");
 //    qWarning("SHell initially is %s", *shell );
 
     if (shell == NULL || *shell == '\0') {
         struct passwd *ent = 0;
         uid_t me = getuid();
         *shell = "/bin/sh";
 
         while ( (ent = getpwent()) != 0 ) {
             if (ent->pw_uid == me) {
                 if (ent->pw_shell != "")
                     *shell = ent->pw_shell;
                 break;
             }
         }
         endpwent();
     }
 
 //    qWarning("SHELL now is %s", *shell );
 
     if( putenv((char*)"COLORTERM=") !=0)
         qDebug("putenv failed"); // to trigger mc's color detection
 }
 
 Konsole::Konsole(QWidget* parent, const char* name, WFlags fl) :
     QMainWindow(parent, name, fl)
 {
     QStrList tmp; const char* shell;
 
     setCaption( tr("Terminal") );
 
     konsoleInit( &shell);
 //    qWarning("Using shell %s", shell);
     init(shell,tmp);
 }
 
 
 
 void Konsole::initCommandList()
 {
 //    qDebug("Konsole::initCommandList");
     Config cfg("Konsole");
     cfg.setGroup("Commands");
     commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
     commonCombo->clear();
     if (cfg.readEntry("Commands Set","FALSE") == "FALSE") {
         for (int i = 0; commonCmds[i] != NULL; i++) {
             commonCombo->insertItem(commonCmds[i],i);
         }
     } else {
         for (int i = 0; i < 100; i++) {
             if (!(cfg.readEntry( QString::number(i),"")).isEmpty())
                 commonCombo->insertItem((cfg.readEntry( QString::number(i),"")));
         }
     }
 
 }
 
 void Konsole::init(const char* _pgm, QStrList & _args)
 {
   b_scroll = TRUE; // histon;
   n_keytab = 0;
   n_render = 0;
   startUp=0;
   fromMenu = FALSE;
 
   setCaption( tr("Terminal") );
   setIcon( Resource::loadPixmap( "konsole" ) );
 
   Config cfg("Konsole");
   cfg.setGroup("Konsole");
   QString tmp;
   // initialize the list of allowed fonts ///////////////////////////////////
   cfont = cfg.readNumEntry("FontID", 1);
 
   QFont f = QFont("Micro", 4, QFont::Normal);
   f.setFixedPitch(TRUE);
   fonts.append(new VTFont(tr("Micro"), f));
 
   f = QFont("Fixed", 7, QFont::Normal);
   f.setFixedPitch(TRUE);
   fonts.append(new VTFont(tr("Small Fixed"), f));
 
   f = QFont("Fixed", 12, QFont::Normal);
   f.setFixedPitch(TRUE);
   fonts.append(new VTFont(tr("Medium Fixed"), f));
 
 // NEW STUFF
 
         QStringList ignfont = cfg.readListEntry("IgnFont", ',');
     /* If there is no "IgnFont = ..." entry in "myonsole.conf",
      * put some Japanese fonts of the SL-C7x0 to "ignfont".  */
         
         if (ignfont.isEmpty()) { 
                         ignfont = QStringList::split (',',"jisupasp,mmkjg1,mmkjg4,mmkjg5");
         }
 
         //QFont
          f = QFont("Fixed", 16, QFont::Normal);
           f.setFixedPitch(true);
           fonts.append(new VTFont(tr("Default"), f));
 
         int  fcount = 1;
 
          f.setCharSet(QFont::AnyCharSet);
          f.setStyleHint(QFont::TypeWriter, QFont::PreferMatch);
 //  f.setWeight(QFont::Normal);
 
     /*
      * Look for installed font families. If the family is not in
      * the "ignfont" list, look for available sizes.
      * If it is fixed pitch font, put the font and the size
      * to the fontlist.
      */
         QFontDatabase fdb;
         QStringList ff = fdb.families(false);
 
         for (QStringList::Iterator it = ff.begin(); it != ff.end(); ++it ) {
                         QString fit = *it;
 
                         if( fit != "fixed" && fit != "micro" ) {
                                         if ( ignfont.contains(*it) == 0) {
                                                         QValueList<int> pt = fdb.pointSizes(*it);
 
                                                         for (QValueList<int>::Iterator  itv  = pt.begin();
                                                                          itv != pt.end(); ++itv ) {
                                                                         int  size = (*itv)/10;
                                                                         if(size > 0) {
                                                                                         f.setFamily(*it);
                                                                                         f.setPointSize(size);
                                                                         }
 
                                                                         QFontMetrics fm(f);
 
 //qDebug("%s %d:\twidth('i')=%d, width('w')=%d", (*it).latin1(), (*itv)/10, fm.width('i'), fm.width('w'));
 
                                                                         if (fm.width('i') == fm.width('w') ) {
                                                                                         qDebug((*it));
                                                                                         f.setFixedPitch(true);
                                                                                         fonts.append(new VTFont(*it + ' ' + QString::number(size), f));
                                                                                         fcount++;
                                                                         }
                                                         }
                                         }
                         }
         }
 
 // END NEW STUFF
         
 
 // create terminal emulation framework ////////////////////////////////////
   nsessions = 0;
 
   tab = new EKNumTabWidget(this);
 
   connect(tab, SIGNAL(currentChanged(QWidget*)), this, SLOT(switchSession(QWidget*)));
 
      // create terminal toolbar ////////////////////////////////////////////////
   setToolBarsMovable( FALSE );
   QToolBar *menuToolBar = new QToolBar( this );
   menuToolBar->setHorizontalStretchable( TRUE );
 
   QMenuBar *menuBar = new QMenuBar( menuToolBar );
 
   fontList = new QPopupMenu( this );
   for(uint i = 0; i < fonts.count(); i++) {
     VTFont *fnt = fonts.at(i);
     fontList->insertItem(fnt->getName(), i);
   }
 
   fontChanged(cfont);
 
   configMenu = new QPopupMenu( this);
   colorMenu = new QPopupMenu( this);
   scrollMenu = new QPopupMenu( this);
   editCommandListMenu = new QPopupMenu( this);
 
   configMenu->insertItem(tr("Command List"), editCommandListMenu);
 
   bool listHidden;
   cfg.setGroup("Menubar");
   if( cfg.readEntry("Hidden","FALSE") == "TRUE")  {
       editCommandListMenu->insertItem( tr( "Show command list" ));
       listHidden=TRUE;
   } else {
       editCommandListMenu->insertItem( tr( "Hide command list" ));
       listHidden=FALSE;
   }
 
   cfg.setGroup("Tabs");
   tmp=cfg.readEntry("Position","Bottom");
   if(tmp=="Top") {
       tab->setTabPosition(QTabWidget::Top);
       configMenu->insertItem( tr( "Tabs on Bottom" ) );
   } else {
       tab->setTabPosition(QTabWidget::Bottom);
       configMenu->insertItem(tr("Tabs on Top"));
   }
   configMenu->insertSeparator(2);
 
   colorMenu->insertItem(tr( "Green on Black"));
   colorMenu->insertItem(tr( "Black on White"));
   colorMenu->insertItem(tr( "White on Black"));
   colorMenu->insertItem(tr( "Black on Transparent"));
   colorMenu->insertItem(tr( "Black on Red"));
   colorMenu->insertItem(tr( "Red on Black"));
   colorMenu->insertItem(tr( "Green on Yellow"));
   colorMenu->insertItem(tr( "Blue on Magenta"));
   colorMenu->insertItem(tr( "Magenta on Blue"));
   colorMenu->insertItem(tr( "Cyan on White"));
   colorMenu->insertItem(tr( "White on Cyan"));
   colorMenu->insertItem(tr( "Blue on Black"));
   colorMenu->insertItem(tr( "Amber on Black"));
 
 #ifdef QT_QWS_OPIE
   colorMenu->insertItem(tr( "Custom"));
 #endif
 
   configMenu->insertItem( tr("Font"), fontList );
   configMenu->insertItem(tr( "Colors") ,colorMenu);
 
   connect( fontList, SIGNAL( activated(int) ), this, SLOT( fontChanged(int) ));
   connect( configMenu, SIGNAL( activated(int) ), this, SLOT( configMenuSelected(int) ));
   connect( colorMenu, SIGNAL( activated(int) ), this, SLOT( colorMenuIsSelected(int) ));
   connect( scrollMenu, SIGNAL(activated(int)),this,SLOT(scrollMenuSelected(int)));
   connect(editCommandListMenu,SIGNAL(activated(int)),this,SLOT(editCommandListMenuSelected(int)));
 
   menuBar->insertItem( tr("Options"), configMenu );
 
   QToolBar *toolbar = new QToolBar( this );
 
   QAction *a;
 
   // Button Commands
   a = new QAction( tr("New"), Resource::loadPixmap( "konsole" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( newSession() ) ); a->addTo( toolbar );
   a = new QAction( tr("Enter"), Resource::loadPixmap( "konsole/enter" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitEnter() ) ); a->addTo( toolbar );
   a = new QAction( tr("Space"), Resource::loadPixmap( "konsole/space" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitSpace() ) ); a->addTo( toolbar );
   a = new QAction( tr("Tab"), Resource::loadPixmap( "konsole/tab" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitTab() ) ); a->addTo( toolbar );
   a = new QAction( tr("Up"), Resource::loadPixmap( "konsole/up" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitUp() ) ); a->addTo( toolbar );
   a = new QAction( tr("Down"), Resource::loadPixmap( "konsole/down" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitDown() ) ); a->addTo( toolbar );
   a = new QAction( tr("Paste"), Resource::loadPixmap( "paste" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitPaste() ) ); a->addTo( toolbar );
 /*
   a = new QAction( tr("Up"), Resource::loadPixmap( "up" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitUp() ) ); a->addTo( toolbar );
   a = new QAction( tr("Down"), Resource::loadPixmap( "down" ), QString::null, 0, this, 0 );
   connect( a, SIGNAL( activated() ), this, SLOT( hitDown() ) ); a->addTo( toolbar );
 */
 
   secondToolBar = new QToolBar( this );
   secondToolBar->setHorizontalStretchable( TRUE );
 
   commonCombo = new QComboBox( secondToolBar );
   commonCombo->setMaximumWidth(236);
 
   editCommandListMenu->insertItem( tr( "Quick Edit" ) );
   if( listHidden) {
       secondToolBar->hide();
       editCommandListMenu->setItemEnabled(-23 ,FALSE);
   }
   editCommandListMenu->insertItem(tr(  "Edit" ) );
 
   cfg.setGroup("Commands");
   commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
 
   initCommandList();
 //   for (int i = 0; commonCmds[i] != NULL; i++) {
 //        commonCombo->insertItem( commonCmds[i], i );
 //        tmp = cfg.readEntry( QString::number(i),"");
 //        if(tmp != "")
 //            commonCombo->changeItem( tmp,i );
 //    }
 
   connect( commonCombo, SIGNAL( activated(int) ), this, SLOT( enterCommand(int) ));
 
   scrollMenu->insertItem(tr( "None" ));
   scrollMenu->insertItem(tr( "Left" ));
   scrollMenu->insertItem(tr( "Right" ));
 //   scrollMenu->insertSeparator(4);
 //   scrollMenu->insertItem(tr( "Horizontal" ));
 
   configMenu->insertItem(tr( "ScrollBar" ),scrollMenu);
 
   int jut = configMenu->insertItem(tr( "Wrap" ));
     cfg.setGroup("ScrollBar");
   configMenu->setItemChecked(jut, cfg.readBoolEntry("HorzScroll",0));
 
   jut = configMenu->insertItem(tr( "Use Beep" ));
   cfg.setGroup("Menubar");
 
   configMenu->setItemChecked(jut, cfg.readBoolEntry("useBeep",0));
 
 
 //scrollMenuSelected(-29);
 //   cfg.setGroup("ScrollBar");
 //   if(cfg.readBoolEntry("HorzScroll",0)) {
 //       if(cfg.readNumEntry("Position",2) == 0)
 //           te->setScrollbarLocation(1);
 //       else
 //           te->setScrollbarLocation(0);
 //       te->setScrollbarLocation( cfg.readNumEntry("Position",2));
 //       te->setWrapAt(120);
 //   }
       // create applications /////////////////////////////////////////////////////
   setCentralWidget(tab);
 
   // load keymaps ////////////////////////////////////////////////////////////
   KeyTrans::loadAll();
   for (int i = 0; i < KeyTrans::count(); i++)
   { KeyTrans* s = KeyTrans::find(i);
     assert( s );
   }
 
   se_pgm = _pgm;
   se_args = _args;
   se_args.prepend("--login");
 parseCommandLine();
   // read and apply default values ///////////////////////////////////////////
   resize(321, 321); // Dummy.
   QSize currentSize = size();
   if (currentSize != size())
      defaultSize = size();
 }
 
 void Konsole::show()
 {
   if ( !nsessions ) {
     newSession();
   }
   QMainWindow::show();
 
 }
 
 void Konsole::initSession(const char*, QStrList &)
 {
   QMainWindow::show();
 }
 
 Konsole::~Konsole()
 {
     while (nsessions > 0) {
       doneSession(getTe()->currentSession, 0);
      }
 
   Config cfg("Konsole");
   cfg.setGroup("Konsole");
   cfg.writeEntry("FontID", cfont);
 }
 
 void Konsole::fontChanged(int f)
 {
     VTFont* font = fonts.at(f);
     if (font != 0) {
         for(uint i = 0; i < fonts.count(); i++) {
             fontList->setItemChecked(i, (i == (uint) f) ? TRUE : FALSE);
         }
 
         cfont = f;
 
         TEWidget* te = getTe();
         if (te != 0) {
             te->setVTFont(font->getFont());
         }
     }
 }
 
 
 void Konsole::enterCommand(int c)
 {
     TEWidget* te = getTe();
     if (te != 0) {
         if(!commonCombo->editable()) {
             QString text = commonCombo->text(c); //commonCmds[c];
             te->emitText(text);
         } else {
             changeCommand( commonCombo->text(c), c);
         }
     }
 }
 
 void Konsole::hitEnter()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     te->emitText(QString("\r"));
     }
 }
 
 void Konsole::hitSpace()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     te->emitText(QString(" "));
     }
 }
 
 void Konsole::hitTab()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     te->emitText(QString("\t"));
     }
 }
 
 void Konsole::hitPaste()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     te->pasteClipboard();
     }
 }
 
 void Konsole::hitUp()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     QKeyEvent ke( QKeyEvent::KeyPress, Qt::Key_Up, 0, 0);
     QApplication::sendEvent( te, &ke );
     }
 }
 
 void Konsole::hitDown()
 {
     TEWidget* te = getTe();
     if (te != 0) {
     QKeyEvent ke( QKeyEvent::KeyPress, Qt::Key_Down, 0, 0);
     QApplication::sendEvent( te, &ke );
     }
 }
 
 /**
    This function calculates the size of the external widget
    needed for the internal widget to be
  */
 QSize Konsole::calcSize(int columns, int lines) {
     TEWidget* te = getTe();
     if (te != 0) {
     QSize size = te->calcSize(columns, lines);
     return size;
     } else {
   QSize size;
   return size;
     }
 }
 
 /**
     sets application window to a size based on columns X lines of the te
     guest widget. Call with (0,0) for setting default size.
 */
 
 void Konsole::setColLin(int columns, int lines)
 {
   qDebug("konsole::setColLin:: Columns %d", columns);
 
   if ((columns==0) || (lines==0))
   {
     if (defaultSize.isEmpty()) // not in config file : set default value
     {
       defaultSize = calcSize(80,24);
       // notifySize(24,80); // set menu items (strange arg order !)
     }
     resize(defaultSize);
   } else {
     resize(calcSize(columns, lines));
     // notifySize(lines,columns); // set menu items (strange arg order !)
   }
 }
 
 /*
 void Konsole::setFont(int fontno)
 {
   QFont f;
   if (fontno == 0)
     f = defaultFont = QFont( "Helvetica", 12  );
   else
   if (fonts[fontno][0] == '-')
     f.setRawName( fonts[fontno] );
   else
   {
     f.setFamily(fonts[fontno]);
     f.setRawMode( TRUE );
   }
   if ( !f.exactMatch() && fontno != 0)
   {
     QString msg = i18n("Font `%1' not found.\nCheck README.linux.console for help.").arg(fonts[fontno]);
     QMessageBox(this,  msg);
     return;
   }
   if (se) se->setFontNo(fontno);
   te->setVTFont(f);
   n_font = fontno;
 }
 */
 
 // --| color selection |-------------------------------------------------------
 
 void Konsole::changeColumns(int columns)
 {
                         //FIXME this seems to cause silliness when reset command is executed
         //      qDebug("change columns");
         //      TEWidget* te = getTe();
         //      if (te != 0) {
         //                      setColLin(columns,te->Lines());
         //                      te->update();
         //      }
 }
 
 //FIXME: If a child dies during session swap,
 //       this routine might be called before
 //       session swap is completed.
 
 void Konsole::doneSession(TESession*, int )
 {
   TEWidget *te = getTe();
   if (te != 0) {
     te->currentSession->setConnect(FALSE);
     tab->removeTab(te);
     delete te->currentSession;
     delete te;
     nsessions--;
   }
 
   if (nsessions == 0) {
   close();
   }
 }
 
 void Konsole::newSession() {
     if(nsessions < 15) {    // seems to be something weird about 16 tabs on the Zaurus.... memory?
         TEWidget* te = new TEWidget(tab);
         Config c("Konsole");
         c.setGroup("Menubar");
         te->useBeep=c.readBoolEntry("useBeep",0);
 
 //  te->setBackgroundMode(PaletteBase); //we want transparent!!
         te->setVTFont(fonts.at(cfont)->getFont());
         tab->addTab(te);
         TESession* se = new TESession(this, te, se_pgm, se_args, "xterm");
         te->currentSession = se;
         connect( se, SIGNAL(done(TESession*,int)), this, SLOT(doneSession(TESession*,int)) );
         se->run();
         se->setConnect(TRUE);
         se->setHistory(b_scroll);
         tab->setCurrentPage(nsessions);
         nsessions++;
         doWrap();
         setColor();
     }
 }
 
 TEWidget* Konsole::getTe() {
   if (nsessions) {
     return (TEWidget *) tab->currentPage();
   } else {
     return 0;
   }
 }
 
 void Konsole::switchSession(QWidget* w) {
   TEWidget* te = (TEWidget *) w;
 
   QFont teFnt = te->getVTFont();
   for(uint i = 0; i < fonts.count(); i++) {
     VTFont *fnt = fonts.at(i);
     bool cf = fnt->getFont() == teFnt;
     fontList->setItemChecked(i, cf);
     if (cf) {
       cfont = i;
     }
   }
 }
 
 void Konsole::colorMenuIsSelected(int iD) {
     fromMenu = TRUE;
     colorMenuSelected(iD);
 }
 
 /// -------------------------------   some new stuff by L.J. Potter
 void Konsole::colorMenuSelected(int iD)
 { // this is NOT pretty, elegant or anything else besides functional
 //       QString temp;
 //      qDebug( temp.sprintf("colormenu %d", iD));
 
      TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("Colors");
 //     QColor foreground;
 //     QColor background;
     colorMenu->setItemChecked(lastSelectedMenu,FALSE);
     ColorEntry m_table[TABLE_COLORS];
     const ColorEntry * defaultCt=te->getdefaultColorTable();
       /////////// fore back
     int i;
     if(iD==-9) { // default default
         for (i = 0; i < TABLE_COLORS; i++)  {
             m_table[i].color = defaultCt[i].color;
             if(i==1 || i == 11)
                 m_table[i].transparent=1;
             cfg.writeEntry("Schema","9");
             colorMenu->setItemChecked(-9,TRUE);
         }
     } else {
         if(iD==-6) { // green black
             foreground.setRgb(0x18,255,0x18);
             background.setRgb(0x00,0x00,0x00);
             cfg.writeEntry("Schema","6");
             colorMenu->setItemChecked(-6,TRUE);
         }
         if(iD==-7) { // black white
             foreground.setRgb(0x00,0x00,0x00);
             background.setRgb(0xFF,0xFF,0xFF);
             cfg.writeEntry("Schema","7");
             colorMenu->setItemChecked(-7,TRUE);
         }
         if(iD==-8) { // white black
             foreground.setRgb(0xFF,0xFF,0xFF);
             background.setRgb(0x00,0x00,0x00);
             cfg.writeEntry("Schema","8");
             colorMenu->setItemChecked(-8,TRUE);
         }
         if(iD==-10) {// Black, Red
             foreground.setRgb(0x00,0x00,0x00);
             background.setRgb(0xB2,0x18,0x18);
             cfg.writeEntry("Schema","10");
             colorMenu->setItemChecked(-10,TRUE);
         }
         if(iD==-11) {// Red, Black
             foreground.setRgb(230,31,31); //0xB2,0x18,0x18
             background.setRgb(0x00,0x00,0x00);
             cfg.writeEntry("Schema","11");
             colorMenu->setItemChecked(-11,TRUE);
         }
         if(iD==-12) {// Green, Yellow - is ugly
 //            foreground.setRgb(0x18,0xB2,0x18);
             foreground.setRgb(36,139,10);
 //            background.setRgb(0xB2,0x68,0x18);
             background.setRgb(255,255,0);
             cfg.writeEntry("Schema","12");
             colorMenu->setItemChecked(-12,TRUE);
         }
         if(iD==-13) {// Blue,  Magenta
             foreground.setRgb(0x18,0xB2,0xB2);
             background.setRgb(0x18,0x18,0xB2);
             cfg.writeEntry("Schema","13");
             colorMenu->setItemChecked(-13,TRUE);
         }
         if(iD==-14) {// Magenta, Blue
             foreground.setRgb(0x18,0x18,0xB2);
             background.setRgb(0x18,0xB2,0xB2);
             cfg.writeEntry("Schema","14");
             colorMenu->setItemChecked(-14,TRUE);
         }
         if(iD==-15) {// Cyan,  White
             foreground.setRgb(0x18,0xB2,0xB2);
             background.setRgb(0xFF,0xFF,0xFF);
             cfg.writeEntry("Schema","15");
             colorMenu->setItemChecked(-15,TRUE);
         }
         if(iD==-16) {// White, Cyan
             background.setRgb(0x18,0xB2,0xB2);
             foreground.setRgb(0xFF,0xFF,0xFF);
             cfg.writeEntry("Schema","16");
             colorMenu->setItemChecked(-16,TRUE);
         }
         if(iD==-17) {// Black, Blue
             background.setRgb(0x00,0x00,0x00);
             foreground.setRgb(0x18,0xB2,0xB2);
             cfg.writeEntry("Schema","17");
             colorMenu->setItemChecked(-17,TRUE);
         }
         if(iD==-18) {// Black, Gold
             background.setRgb(0x00,0x00,0x00);
             foreground.setRgb(255,215,0);
             cfg.writeEntry("Schema","18");
             colorMenu->setItemChecked(-18,TRUE);
         }
 #ifdef QT_QWS_OPIE
         if(iD==-19) {
 // Custom
             qDebug("do custom");
             if(fromMenu) {
             OColorPopupMenu* penColorPopupMenu = new OColorPopupMenu(Qt::black, this, "foreground color");
             connect(penColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this,
                     SLOT(changeForegroundColor(const QColor&)));
             penColorPopupMenu->exec();
             }
             cfg.writeEntry("Schema","19");
             if(!fromMenu) {
                 foreground.setNamedColor(cfg.readEntry("foreground",""));
                 background.setNamedColor(cfg.readEntry("background",""));
             }
             fromMenu=FALSE;
             colorMenu->setItemChecked(-19,TRUE);
         }
 #endif
         for (i = 0; i < TABLE_COLORS; i++)  {
             if(i==0 || i == 10) {
                 m_table[i].color = foreground;
             }
             else if(i==1 || i == 11) {
                 m_table[i].color = background; m_table[i].transparent=0;
             }
             else
                 m_table[i].color = defaultCt[i].color;
         }
     }
     lastSelectedMenu = iD;
     te->setColorTable(m_table);
     update();
 
 }
 
 void Konsole::configMenuSelected(int iD)
 {
 //      QString temp;
 //      qDebug( temp.sprintf("configmenu %d",iD));
 
      TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("Menubar");
     int i,j;
 #ifdef QT_QWS_OPIE
     i=-29;j=-30;
 #else
     i=-28;j=-29;
 #endif
 
     if(iD == -4) {
           cfg.setGroup("Tabs");
           QString tmp=cfg.readEntry("Position","Bottom");
 
           if(tmp=="Top") {
               tab->setTabPosition(QTabWidget::Bottom);
               configMenu->changeItem( iD, tr("Tabs on Top"));
               cfg.writeEntry("Position","Bottom");
           } else {
               tab->setTabPosition(QTabWidget::Top);
               configMenu->changeItem( iD, tr("Tabs on Bottom"));
               cfg.writeEntry("Position","Top");
           }
       }
       if(iD == i) {
           cfg.setGroup("ScrollBar");
           bool b=cfg.readBoolEntry("HorzScroll",0);
           b=!b;
           cfg.writeEntry("HorzScroll", b );
           cfg.write();
           doWrap();
           if(cfg.readNumEntry("Position",2) == 0) {
               te->setScrollbarLocation(1);
           } else {
               te->setScrollbarLocation(0);
           }
           te->setScrollbarLocation( cfg.readNumEntry("Position",2));
       }
       if(iD ==  j) {
           cfg.setGroup("Menubar");
           bool b=cfg.readBoolEntry("useBeep",0);
           b=!b;
           cfg.writeEntry("useBeep", b );
           cfg.write();
           configMenu->setItemChecked(j,b);
           te->useBeep=b;
       }
 }
 
 void Konsole::changeCommand(const QString &text, int c)
 {
     Config cfg("Konsole");
     cfg.setGroup("Commands");
     if(commonCmds[c] != text) {
         cfg.writeEntry(QString::number(c),text);
         commonCombo->clearEdit();
         commonCombo->setCurrentItem(c);
     }
 }
 
 void Konsole::setColor()
 {
     Config cfg("Konsole");
     cfg.setGroup("Colors");
     int scheme = cfg.readNumEntry("Schema",1);
     if(scheme != 1) colorMenuSelected( -scheme);
 }
 
 void Konsole::scrollMenuSelected(int index)
 {
 //    qDebug( "scrollbar menu %d",index);
 
     TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("ScrollBar");
     int i,j,k;
 #ifdef QT_QWS_OPIE
 i=-25;j=-26;k=-27;
 #else
 i=-24;j=-25;k=-26;
 #endif
  if(index == i) {
 
      te->setScrollbarLocation(0);
      cfg.writeEntry("Position",0);
  }  else if(index == j) {
 
      te->setScrollbarLocation(1);
      cfg.writeEntry("Position",1);
  }  else if(index == k) {
 
      te->setScrollbarLocation(2);
      cfg.writeEntry("Position",2);
  }
 
 //       case -29: {
 //           bool b=cfg.readBoolEntry("HorzScroll",0);
 //           cfg.writeEntry("HorzScroll", !b );
 //           cfg.write();
 //           if(cfg.readNumEntry("Position",2) == 0) {
 //               te->setScrollbarLocation(1);
 //           te->setWrapAt(0);
 //           } else {
 //               te->setScrollbarLocation(0);
 //           te->setWrapAt(120);
 //           }
 //           te->setScrollbarLocation( cfg.readNumEntry("Position",2));
 //       }
 //         break;
 }
 
 void Konsole::editCommandListMenuSelected(int iD)
 {
 //      QString temp;
 //      qDebug( temp.sprintf("edit command list %d",iD));
     TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("Menubar");
     if( iD  == -3) {
         if(!secondToolBar->isHidden()) {
             secondToolBar->hide();
             configMenu->changeItem( iD,tr( "Show Command List" ));
             cfg.writeEntry("Hidden","TRUE");
             configMenu->setItemEnabled(-23 ,FALSE);
         } else {
             secondToolBar->show();
             configMenu->changeItem( iD,tr( "Hide Command List" ));
             cfg.writeEntry("Hidden","FALSE");
             configMenu->setItemEnabled(-23 ,TRUE);
 
             if(cfg.readEntry("EditEnabled","FALSE")=="TRUE") {
                 configMenu->setItemChecked(-23,TRUE);
                 commonCombo->setEditable( TRUE );
             } else {
                 configMenu->setItemChecked(-23,FALSE);
                 commonCombo->setEditable( FALSE );
             }
         }
     }
     if( iD  == -23) {
         cfg.setGroup("Commands");
 //        qDebug("enableCommandEdit");
         if( !configMenu->isItemChecked(iD) ) {
             commonCombo->setEditable( TRUE );
             configMenu->setItemChecked(iD,TRUE);
             commonCombo->setCurrentItem(0);
             cfg.writeEntry("EditEnabled","TRUE");
         } else {
             commonCombo->setEditable( FALSE );
             configMenu->setItemChecked(iD,FALSE);
             cfg.writeEntry("EditEnabled","FALSE");
             commonCombo->setFocusPolicy(QWidget::NoFocus);
             te->setFocus();
         }
     }
     if(iD == -24) {
     // "edit commands"
     CommandEditDialog *m = new CommandEditDialog(this);
     connect(m,SIGNAL(commandsEdited()),this,SLOT(initCommandList()));
-    m->showMaximized();
+    QPEApplication::showDialog( m );
     }
 
 }
 
 // $QPEDIR/bin/qcop QPE/Application/embeddedkonsole 'setDocument(QString)' 'ssh -V'
 void Konsole::setDocument( const QString &cmd) {
     newSession();
     TEWidget* te = getTe();
     if(cmd.find("-e", 0, TRUE) != -1) {
         QString cmd2;
         cmd2=cmd.right(cmd.length()-3)+" &";
         system(cmd2.latin1());
         if(startUp <= 1 && nsessions < 2) {
             doneSession(getTe()->currentSession, 0);
             exit(0);
         } else
             doneSession(getTe()->currentSession, 0);
     } else {
         if (te != 0) {
             te->emitText(cmd+"\r");
         }
     }
     startUp++;
 }
 
 void Konsole::parseCommandLine() {
     QString cmd;
       //    newSession();
     for (int i=1;i< qApp->argc();i++) {
         if( QString(qApp->argv()[i]) == "-e") {
             i++;
             for ( int j=i;j< qApp->argc();j++) {
                 cmd+=QString(qApp->argv()[j])+" ";
             }
             cmd.stripWhiteSpace();
             system(cmd.latin1());
             exit(0);//close();
         } // end -e switch
     }
     startUp++;
 }
 
 void Konsole::changeForegroundColor(const QColor &color) {
     Config cfg("Konsole");
     cfg.setGroup("Colors");
     int r, g, b;
     color.rgb(&r,&g,&b);
     foreground.setRgb(r,g,b);
 
     cfg.writeEntry("foreground",color.name());
     qDebug("foreground "+color.name());
     cfg.write();
 
 qDebug("do other dialog");
 #ifdef QT_QWS_OPIE
 
  OColorPopupMenu* penColorPopupMenu2 = new OColorPopupMenu(Qt::black, this,"background color");
     connect(penColorPopupMenu2, SIGNAL(colorSelected(const QColor&)), this,
             SLOT(changeBackgroundColor(const QColor&)));
    penColorPopupMenu2->exec();
 #endif
 }
 
 void Konsole::changeBackgroundColor(const QColor &color) {
 
     qDebug("Change background");
     Config cfg("Konsole");
     cfg.setGroup("Colors");
     int r, g, b;
     color.rgb(&r,&g,&b);
     background.setRgb(r,g,b);
     cfg.writeEntry("background",color.name());
     qDebug("background "+color.name());
     cfg.write();
 }
 
 void Konsole::doWrap() {
 int i;
 #ifdef QT_QWS_OPIE
 i=-29;
 #else
 i=-28;
 #endif
 
  Config cfg("Konsole");
     cfg.setGroup("ScrollBar");
     TEWidget* te = getTe();
     if( !cfg.readBoolEntry("HorzScroll",0)) {
         te->setWrapAt(0);
         configMenu->setItemChecked( i,TRUE);
     } else {
 //        te->setWrapAt(90);
         te->setWrapAt(120);
         configMenu->setItemChecked( i,FALSE);
     }
 }
diff --git a/core/apps/textedit/textedit.cpp b/core/apps/textedit/textedit.cpp
index be18140..1299fe3 100644
--- a/core/apps/textedit/textedit.cpp
+++ b/core/apps/textedit/textedit.cpp
@@ -1,1212 +1,1210 @@
 /**********************************************************************
 // textedit.cpp
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Opie 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.
 **
 **********************************************************************/
 // changes added by L. J. Potter Sun 02-17-2002 21:31:31
 #include "textedit.h"
 #include "filePermissions.h"
 
 
 #include <opie/ofileselector.h>
 #include <opie/ofiledialog.h>
 #include <opie/ofontselector.h>
 
 #include <qpe/fontdatabase.h>
 #include <qpe/global.h>
 #include <qpe/fileselector.h>
 #include <qpe/applnk.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/qpeapplication.h>
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include <qpoint.h>
 #include <qtextstream.h>
 #include <qdatetime.h>
 #include <qclipboard.h>
 #include <qstringlist.h>
 #include <qaction.h>
 #include <qcolordialog.h>
 #include <qfileinfo.h>
 #include <qlineedit.h>
 #include <qmessagebox.h>
 #include <qobjectlist.h>
 #include <qpopupmenu.h>
 #include <qspinbox.h>
 #include <qtoolbutton.h>
 #include <qwidgetstack.h>
 #include <qcheckbox.h>
 #include <qcombo.h>
 #include <qlayout.h>
 #include <qapplication.h>
 #include <qtimer.h>
 #include <qdir.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <stdlib.h> //getenv
 
 #if QT_VERSION < 300
 
 class QpeEditor : public QMultiLineEdit
 {
 
 public:
     QpeEditor( QWidget *parent, const char * name = 0 )
             : QMultiLineEdit( parent, name ) {
         clearTableFlags();
         setTableFlags( Tbl_vScrollBar | Tbl_autoHScrollBar );
 }
 
     void find( const QString &txt, bool caseSensitive,
                             bool backwards );
 protected:
     bool markIt;
     int line1, line2, col1, col2;
     void mousePressEvent( QMouseEvent * );
     void mouseReleaseEvent( QMouseEvent * );
 
 //public slots:
       /*
 signals:
     void notFound();
     void searchWrapped();
     */
 
 private:
 
 };
 
 void QpeEditor::mousePressEvent( QMouseEvent *e ) {
  switch(e->button()) {
    case RightButton:
    { //rediculous workaround for qt popup menu
      //and the hold right click mechanism
        this->setSelection( line1, col1, line2, col2);
        QMultiLineEdit::mousePressEvent( e );
        markIt = false;
    }
    break;
    default:
    {
        if(!markIt) {
            int line, col;
            this->getCursorPosition(&line, &col);
            line1=line2=line;
            col1=col2=col;
        }
        QMultiLineEdit::mousePressEvent( e );
    }
        break;
  };
 }
 
 void QpeEditor::mouseReleaseEvent( QMouseEvent * ) {
     if(this->hasMarkedText()) {
         markIt = true;
         this->getMarkedRegion( &line1, &col1, &line2, & col2 );
     } else {
        markIt = false;
     }
 }
 
 void QpeEditor::find ( const QString &txt, bool caseSensitive,
            bool backwards )
 {
     static bool wrap = false;
     int line, col;
     if ( wrap ) {
         if ( !backwards )
             line = col = 0;
         wrap = false;
           //  emit searchWrapped();
     } else {
         getCursorPosition( &line, &col );
     }
       //ignore backwards for now....
     if ( !backwards ) {
         for ( ; ; ) {
             if ( line >= numLines() ) {
                 wrap = true;
                   //emit notFound();
                 break;
             }
             int findCol = getString( line )->find( txt, col, caseSensitive );
             if ( findCol >= 0 ) {
                 setCursorPosition( line, findCol, false );
                 col = findCol + txt.length();
                 setCursorPosition( line, col, true );
 
                   //found = true;
                 break;
             }
             line++;
             col = 0;
         }
     }
 }
 
 
 #else
 
 #error "Must make a QpeEditor that inherits QTextEdit"
 
 #endif
 
 
 static const int nfontsizes = 6;
 static const int fontsize[nfontsizes] = {8,10,12,14,18,24};
 
 TextEdit::TextEdit( QWidget *parent, const char *name, WFlags f )
     : QMainWindow( parent, name, f ), bFromDocView( false )
 {
     doc = 0;
     edited=false;
     fromSetDocument=false;
 
     setToolBarsMovable( false );
     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
     channel = new QCopChannel( "QPE/Application/textedit", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
         this, SLOT(receive(const QCString&, const QByteArray&)) );
 
     setIcon( Resource::loadPixmap( "TextEditor" ) );
 
     QToolBar *bar = new QToolBar( this );
     bar->setHorizontalStretchable( true );
     menu = bar;
 
     QMenuBar *mb = new QMenuBar( bar );
     QPopupMenu *file = new QPopupMenu( this );
     QPopupMenu *edit = new QPopupMenu( this );
     QPopupMenu *advancedMenu = new QPopupMenu(this);
 
     font = new QPopupMenu( this );
 
     bar = new QToolBar( this );
     editBar = bar;
 
     QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ),
                               QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) );
 //    a->addTo( bar );
     a->addTo( file );
 
     a = new QAction( tr( "Open" ), Resource::loadPixmap( "fileopen" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileOpen() ) );
     a->addTo( bar );
     a->addTo( file );
 
     a = new QAction( tr( "Save" ), Resource::loadPixmap("save") ,
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( save() ) );
     file->insertSeparator();
     a->addTo( bar );
     a->addTo( file );
 
     a = new QAction( tr( "Save As" ),  Resource::loadPixmap("save") ,
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( saveAs() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Cut" ), Resource::loadPixmap( "cut" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) );
     a->addTo( editBar );
     a->addTo( edit );
 
     a = new QAction( tr( "Copy" ), Resource::loadPixmap( "copy" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editCopy() ) );
     a->addTo( editBar );
     a->addTo( edit );
 
     a = new QAction( tr( "Paste" ), Resource::loadPixmap( "paste" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) );
     a->addTo( editBar );
     a->addTo( edit );
 
 
 #ifndef QT_NO_CLIPBOARD
     a = new QAction( tr( "Insert Time and Date" ), Resource::loadPixmap( "paste" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editPasteTimeDate() ) );
     a->addTo( edit );
 #endif
 
        a = new QAction( tr( "Goto Line..." ), Resource::loadPixmap( "find" ),
                     QString::null, 0, this, 0 );
    connect( a, SIGNAL( activated() ), this, SLOT( gotoLine() ) );
     edit->insertSeparator();
    a->addTo( edit );
 
     a = new QAction( tr( "Find..." ), Resource::loadPixmap( "find" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editFind() ) );
     a->addTo( bar );
     a->addTo( edit );
 
     zin = new QAction( tr("Zoom in"), QString::null, 0, this, 0 );
     connect( zin, SIGNAL( activated() ), this, SLOT( zoomIn() ) );
     zin->addTo( font );
 
     zout = new QAction( tr("Zoom out"), QString::null, 0, this, 0 );
     connect( zout, SIGNAL( activated() ), this, SLOT( zoomOut() ) );
     zout->addTo( font );
 
     font->insertSeparator();
 
     font->insertItem(tr("Font"), this, SLOT(changeFont()) );
 
     font->insertSeparator();
     font->insertItem(tr("Advanced Features"), advancedMenu);
 
     QAction *wa = new QAction( tr("Wrap lines"),
                                QString::null, 0, this, 0 );
     connect( wa, SIGNAL( toggled(bool) ),
              this, SLOT( setWordWrap(bool) ) );
     wa->setToggleAction(true);
     wa->addTo( advancedMenu);
 
     nStart = new QAction( tr("Start with new file"),
                           QString::null, 0, this, 0 );
     connect( nStart, SIGNAL( toggled(bool) ),
              this, SLOT( changeStartConfig(bool) ) );
     nStart->setToggleAction(true);
     nStart->addTo( advancedMenu );
     nStart->setEnabled(false);
 
     nAdvanced = new QAction( tr("Prompt on Exit"),
                              QString::null, 0, this, 0 );
     connect( nAdvanced, SIGNAL( toggled(bool) ),
              this, SLOT( doPrompt(bool) ) );
     nAdvanced->setToggleAction(true);
     nAdvanced->addTo( advancedMenu );
 
     desktopAction = new QAction( tr("Always open linked file"),
                                  QString::null, 0, this, 0 );
     connect( desktopAction, SIGNAL( toggled(bool) ),
              this, SLOT( doDesktop(bool) ) );
     desktopAction->setToggleAction(true);
     desktopAction->addTo( advancedMenu);
 
     filePermAction = new QAction( tr("File Permissions"),
                                   QString::null, 0, this, 0 );
     connect( filePermAction, SIGNAL( toggled(bool) ),
              this, SLOT( doFilePerms(bool) ) );
     filePermAction->setToggleAction(true);
     filePermAction->addTo( advancedMenu);
 
     searchBarAction = new QAction( tr("Search Bar Open"),
                                    QString::null, 0, this, 0 );
     connect( searchBarAction, SIGNAL( toggled(bool) ),
              this, SLOT( setSearchBar(bool) ) );
     searchBarAction->setToggleAction(true);
     searchBarAction->addTo( advancedMenu);
 
     nAutoSave = new QAction( tr("Auto Save 5 min."),
                                    QString::null, 0, this, 0 );
     connect( nAutoSave, SIGNAL( toggled(bool) ),
              this, SLOT( doTimer(bool) ) );
     nAutoSave->setToggleAction(true);
     nAutoSave->addTo( advancedMenu);
 
 
     //font->insertSeparator();
 
     //font->insertItem(tr("About"), this, SLOT( doAbout()) );
 
     mb->insertItem( tr( "File" ), file );
     mb->insertItem( tr( "Edit" ), edit );
     mb->insertItem( tr( "View" ), font );
 
     searchBar = new QToolBar(this);
     addToolBar( searchBar,  "Search", QMainWindow::Top, true );
 
     searchBar->setHorizontalStretchable( true );
 
     searchEdit = new QLineEdit( searchBar, "searchEdit" );
     searchBar->setStretchableWidget( searchEdit );
     connect( searchEdit, SIGNAL( textChanged( const QString & ) ),
        this, SLOT( search() ) );
 
     a = new QAction( tr( "Find Next" ), Resource::loadPixmap( "next" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );
     a->addTo( searchBar );
     a->addTo( edit );
 
     a = new QAction( tr( "Close Find" ), Resource::loadPixmap( "close" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) );
     a->addTo( searchBar );
 
     edit->insertSeparator();
     a = new QAction( tr( "Delete" ), Resource::loadPixmap( "close" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editDelete() ) );
     a->addTo( edit );
 
     searchBar->hide();
 
     editor = new QpeEditor( this );
     setCentralWidget( editor );
     editor->setFrameStyle( QFrame::Panel | QFrame::Sunken );
     connect( editor, SIGNAL( textChanged() ),
              this, SLOT( editorChanged() ) );
 
     QPEApplication::setStylusOperation( editor, QPEApplication::RightOnHold);
 
     Config cfg("TextEdit");
     cfg. setGroup ( "Font" );
 
     QFont defaultFont = editor-> font ( );
 
     QString family = cfg. readEntry     ( "Family", defaultFont. family ( ));
     int size       = cfg. readNumEntry  ( "Size",   defaultFont. pointSize ( ));
     int weight     = cfg. readNumEntry  ( "Weight", defaultFont. weight ( ));
     bool italic    = cfg. readBoolEntry ( "Italic", defaultFont. italic ( ));
 
     defaultFont = QFont ( family, size, weight, italic );
     editor-> setFont ( defaultFont );
 //    updateCaption();
 
     cfg.setGroup ( "View" );
 
     promptExit = cfg.readBoolEntry ( "PromptExit", false );
     openDesktop = cfg.readBoolEntry ( "OpenDesktop", true );
     filePerms = cfg.readBoolEntry ( "FilePermissions", false );
     useSearchBar = cfg.readBoolEntry ( "SearchBar", false );
     startWithNew =  cfg.readBoolEntry ( "startNew", true);
     featureAutoSave = cfg.readBoolEntry( "autosave", false);
 
     if(useSearchBar) searchBarAction->setOn(true);
     if(promptExit)  nAdvanced->setOn( true );
     if(openDesktop) desktopAction->setOn( true );
     if(filePerms) filePermAction->setOn( true );
     if(startWithNew) nStart->setOn( true );
     if(featureAutoSave) nAutoSave->setOn(true);
 
 //       {
 //           doTimer(true);
 //       }
 
     bool wrap = cfg. readBoolEntry ( "Wrap", true );
     wa-> setOn ( wrap );
     setWordWrap ( wrap );
 
 /////////////////
     if( qApp->argc() > 1) {
         currentFileName=qApp->argv()[1];
 
         QFileInfo fi(currentFileName);
 
         if(fi.baseName().left(1) == "") {
             openDotFile(currentFileName);
         } else {
             openFile(currentFileName);
         }
     } else {
     edited1=false;
             openDotFile("");
     }
 
     viewSelection = cfg.readNumEntry( "FileView", 0 );
 }
 
 TextEdit::~TextEdit() {
     qWarning("textedit d'tor");
     delete editor;
 }
 
 void TextEdit::closeEvent(QCloseEvent *) {
     if( edited1 && promptExit)
       {
           switch( savePrompt() )
             {
               case 1:
               {
                   saveAs();
                   qApp->quit();
               }
               break;
 
               case 2:
               {
                   qApp->quit();
               }
               break;
 
               case -1:
                   break;
             };
       }
     else
         qApp->quit();
 
 }
 
 void TextEdit::cleanUp() {
 
     Config cfg ( "TextEdit" );
     cfg. setGroup ( "Font" );
     QFont f = editor->font();
     cfg.writeEntry ( "Family", f. family ( ));
     cfg.writeEntry ( "Size",   f. pointSize ( ));
     cfg.writeEntry ( "Weight", f. weight ( ));
     cfg.writeEntry ( "Italic", f. italic ( ));
 
     cfg.setGroup ( "View" );
     cfg.writeEntry ( "Wrap", editor->wordWrap() == QMultiLineEdit::WidgetWidth );
     cfg.writeEntry ( "FileView", viewSelection );
 
     cfg.writeEntry ( "PromptExit", promptExit );
     cfg.writeEntry ( "OpenDesktop", openDesktop );
     cfg.writeEntry ( "FilePermissions", filePerms );
     cfg.writeEntry ( "SearchBar", useSearchBar );
     cfg.writeEntry ( "startNew", startWithNew );
 
 }
 
 
 void TextEdit::accept() {
         if( edited1)
             saveAs();
      qApp->quit();
 }
 
 void TextEdit::zoomIn() {
     setFontSize(editor->font().pointSize()+1,false);
 }
 
 void TextEdit::zoomOut() {
     setFontSize(editor->font().pointSize()-1,true);
 }
 
 
 void TextEdit::setFontSize(int sz, bool round_down_not_up) {
     int s=10;
     for (int i=0; i<nfontsizes; i++) {
   if ( fontsize[i] == sz ) {
       s = sz;
       break;
   } else if ( round_down_not_up ) {
       if ( fontsize[i] < sz )
     s = fontsize[i];
   } else {
       if ( fontsize[i] > sz ) {
     s = fontsize[i];
     break;
       }
   }
     }
 
     QFont f = editor->font();
     f.setPointSize(s);
     editor->setFont(f);
 
     zin->setEnabled(s != fontsize[nfontsizes-1]);
     zout->setEnabled(s != fontsize[0]);
 }
 
 void TextEdit::setBold(bool y) {
     QFont f = editor->font();
     f.setBold(y);
     editor->setFont(f);
 }
 
 void TextEdit::setItalic(bool y) {
     QFont f = editor->font();
     f.setItalic(y);
     editor->setFont(f);
 }
 
 void TextEdit::setWordWrap(bool y) {
     bool state = editor->edited();
     QString captionStr = caption();
     bool b1 = edited1;
     bool b2 = edited;
 
     editor->setWordWrap(y ? QMultiLineEdit::WidgetWidth : QMultiLineEdit::NoWrap );
     editor->setEdited( state );
     edited1=b1;
     edited=b2;
     setCaption(captionStr);
 }
 
 void TextEdit::setSearchBar(bool b) {
     useSearchBar=b;
     Config cfg("TextEdit");
     cfg.setGroup("View");
     cfg.writeEntry ( "SearchBar", b );
     searchBarAction->setOn(b);
     if(b)
         searchBar->show();
     else
         searchBar->hide();
     editor->setFocus();
 }
 
 void TextEdit::fileNew() {
 //     if( !bFromDocView  ) {
 //         saveAs();
 //     }
     newFile(DocLnk());
 }
 
 void TextEdit::fileOpen() {
     Config cfg("TextEdit");
     cfg. setGroup ( "View" );
     QMap<QString, QStringList> map;
     map.insert(tr("All"), QStringList() );
     QStringList text;
     text << "text/*";
     map.insert(tr("Text"), text );
     text << "*";
     map.insert(tr("All"), text );
     QString str = OFileDialog::getOpenFileName( 2,
                                                 QString::null ,
                                                 QString::null, map);
     if( !str.isEmpty() && QFile(str).exists() && !QFileInfo(str).isDir() )
     {
        openFile( str );
     }
     else
         updateCaption();
 }
 
 void TextEdit::doSearchBar() {
     if(!useSearchBar)
         searchBar->hide();
     else
         searchBar->show();
 }
 
 #if 0
 void TextEdit::slotFind() {
     FindDialog frmFind( tr("Text Editor"), this );
     connect( &frmFind, SIGNAL(signalFindClicked(const QString &, bool, bool, int)),
        editor, SLOT(slotDoFind( const QString&,bool,bool)));
 
     //case sensitive, backwards, [category]
 
     connect( editor, SIGNAL(notFound()),
        &frmFind, SLOT(slotNotFound()) );
     connect( editor, SIGNAL(searchWrapped()),
        &frmFind, SLOT(slotWrapAround()) );
 
     frmFind.exec();
 
 
 }
 #endif
 
 void TextEdit::fileRevert() {
     clear();
     fileOpen();
 }
 
 void TextEdit::editCut() {
 #ifndef QT_NO_CLIPBOARD
     editor->cut();
 #endif
 }
 
 void TextEdit::editCopy() {
 #ifndef QT_NO_CLIPBOARD
     editor->copy();
 #endif
 }
 
 void TextEdit::editPaste() {
 #ifndef QT_NO_CLIPBOARD
     editor->paste();
 #endif
 }
 
 void TextEdit::editFind() {
     searchBar->show();
     searchEdit->setFocus();
 }
 
 void TextEdit::findNext() {
     editor->find( searchEdit->text(), false, false );
 
 }
 
 void TextEdit::findClose() {
     searchBar->hide();
 }
 
 void TextEdit::search() {
     editor->find( searchEdit->text(), false, false );
 }
 
 void TextEdit::newFile( const DocLnk &f ) {
     DocLnk nf = f;
     nf.setType("text/plain");
     clear();
     setWState (WState_Reserved1 );
     editor->setFocus();
     doc = new DocLnk(nf);
     currentFileName = "Unnamed";
     qDebug("newFile "+currentFileName);
     updateCaption( currentFileName);
 //    editor->setEdited( false);
 }
 
 void TextEdit::openDotFile( const QString &f ) {
     if(!currentFileName.isEmpty()) {
     currentFileName=f;
 
     qDebug("openFile dotfile " + currentFileName);
     QString txt;
     QFile file(f);
     file.open(IO_ReadWrite);
     QTextStream t(&file);
     while ( !t.atEnd()) {
         txt+=t.readLine()+"\n";
     }
     editor->setText(txt);
     editor->setEdited( false);
     edited1=false;
     edited=false;
 
 
     }
     updateCaption( currentFileName);
 }
 
 void TextEdit::openFile( const QString &f ) {
   qDebug("filename is "+ f);
   QString filer;
   QFileInfo fi( f);
 //    bFromDocView = true;
   if(f.find(".desktop",0,true) != -1 && !openDesktop )
     {
       switch ( QMessageBox::warning(this,tr("Text Editor"),tr("Text Editor has detected<BR>you selected a <B>.desktop</B>file.<BR>Open<B>.desktop</B> file or <B>linked</B> file?"),tr(".desktop File"),tr("Linked Document"),0,1,1) )
         {
         case 0: //desktop
           filer = f;
           break;
         case 1: //linked
           DocLnk sf(f);
           filer = sf.file();
           break;
         };
     }
   else if(fi.baseName().left(1) == "")
     {
       qDebug("opening dotfile");
       currentFileName=f;
       openDotFile(currentFileName);
       return;
     }
   /*
    * The problem is a file where Config(f).isValid() and it does not
    * end with .desktop will be treated as desktop file
    */
   else if (f.find(".desktop",0,true) != -1 )
     {
       DocLnk sf(f);
       filer = sf.file();
       if(filer.right(1) == "/")
           filer = f;
 
     }
   else
       filer = f;
 
       DocLnk nf;
       nf.setType("text/plain");
       nf.setFile(filer);
       currentFileName=filer;
 
       nf.setName(fi.baseName());
       openFile(nf);
 
       qDebug("openFile string "+currentFileName);
 
   showEditTools();
     // Show filename in caption
   QString name = filer;
   int sep = name.findRev( '/' );
   if ( sep > 0 )
     name = name.mid( sep+1 );
   updateCaption( name );
 }
 
 void TextEdit::openFile( const DocLnk &f ) {
 //    clear();
 //    bFromDocView = true;
     FileManager fm;
     QString txt;
     currentFileName=f.file();
     qDebug("openFile doclnk " + currentFileName);
     if ( !fm.loadFile( f, txt ) ) {
           // ####### could be a new file
         qDebug( "Cannot open file" );
     }
 //    fileNew();
     if ( doc )
         delete doc;
     doc = new DocLnk(f);
     editor->setText(txt);
     editor->setEdited( false);
     edited1=false;
     edited=false;
 
     doc->setName(currentFileName);
     updateCaption();
     setTimer();
 }
 
 void TextEdit::showEditTools() {
     menu->show();
     editBar->show();
     if(!useSearchBar)
         searchBar->hide();
     else
         searchBar->show();
     setWState (WState_Reserved1 );
 }
 
 /*!
   unprompted save */
 bool TextEdit::save() {
     qDebug("saveAsFile " + currentFileName);
     if(currentFileName.isEmpty()) {
         saveAs();
         return false;
     }
 
     QString file = doc->file();
     qDebug("saver file "+file);
     QString name= doc->name();
     qDebug("File named "+name);
     QString rt = editor->text();
     if( !rt.isEmpty() ) {
         if(name.isEmpty()) {
             saveAs();
         } else {
             currentFileName= name ;
             qDebug("saveFile "+currentFileName);
 
             struct stat buf;
             mode_t mode;
             stat(file.latin1(), &buf);
             mode = buf.st_mode;
 
             if(!fileIs) {
                 doc->setName( name);
                 FileManager fm;
                 if ( !fm.saveFile( *doc, rt ) ) {
                     return false;
                 }
             } else {
                 qDebug("regular save file");
                 QFile f(file);
                  if( f.open(IO_WriteOnly)) {
                      QCString crt = rt.utf8();
                      f.writeBlock(crt,crt.length());
                  } else {
                      QMessageBox::message(tr("Text Edit"),tr("Write Failed"));
                  return false;
                  }
 
             }
             editor->setEdited( false);
             edited1=false;
             edited=false;
             if(caption().left(1)=="*")
             setCaption(caption().right(caption().length()-1));
 
 
             chmod( file.latin1(), mode);
         }
         return true;
     }
     return false;
 }
 
 /*!
   prompted save */
 bool TextEdit::saveAs() {
 
     if(caption() == tr("Text Editor"))
         return false;
     qDebug("saveAsFile " + currentFileName);
       // case of nothing to save...
 //     if ( !doc && !currentFileName.isEmpty()) {
 // //|| !bFromDocView)
 //         qDebug("no doc");
 //         return true;
 //     }
 //     if ( !editor->edited() ) {
 //         delete doc;
 //         doc = 0;
 //         return true;
 //     }
 
     QString rt = editor->text();
     qDebug(currentFileName);
 
     if( currentFileName.isEmpty()
         || currentFileName == tr("Unnamed")
         || currentFileName == tr("Text Editor")) {
         qDebug("do silly TT filename thing");
 //        if ( doc && doc->name().isEmpty() ) {
         QString pt = rt.simplifyWhiteSpace();
         int i = pt.find( ' ' );
         QString docname = pt;
         if ( i > 0 )
             docname = pt.left( i );
           // remove "." at the beginning
         while( docname.startsWith( "." ) )
             docname = docname.mid( 1 );
         docname.replace( QRegExp("/"), "_" );
           // cut the length. filenames longer than that
           //don't make sense and something goes wrong when they get too long.
         if ( docname.length() > 40 )
             docname = docname.left(40);
         if ( docname.isEmpty() )
             docname = tr("Unnamed");
         if(doc) doc->setName(docname);
         currentFileName=docname;
 //         }
 //         else
 //             qDebug("hmmmmmm");
     }
 
 
     QMap<QString, QStringList> map;
     map.insert(tr("All"), QStringList() );
     QStringList text;
     text << "text/*";
     map.insert(tr("Text"), text );
     text << "*";
     map.insert(tr("All"), text );
 
     QFileInfo cuFi( currentFileName);
     QString filee = cuFi.fileName();
     QString dire = cuFi.dirPath();
     if(dire==".")
         dire = QPEApplication::documentDir();
     QString str;
     if( !featureAutoSave)
       {
           str = OFileDialog::getSaveFileName( 2,
                                               dire,
                                               filee, map);
       }
     else
         str=currentFileName;
     if(!str.isEmpty()) {
         QString fileNm=str;
 
         qDebug("saving filename "+fileNm);
         QFileInfo fi(fileNm);
         currentFileName=fi.fileName();
         if(doc)
 //        QString file = doc->file();
 //        doc->removeFiles();
             delete doc;
             DocLnk nf;
             nf.setType("text/plain");
             nf.setFile( fileNm);
             doc = new DocLnk(nf);
 //        editor->setText(rt);
             qDebug("Saving file as "+currentFileName);
             doc->setName( currentFileName);
             updateCaption( currentFileName);
 
             FileManager fm;
             if ( !fm.saveFile( *doc, rt ) ) {
                 return false;
             }
 
             if( filePerms ) {
                 filePermissions *filePerm;
                 filePerm = new filePermissions(this,
                                                tr("Permissions"),true,
                                                0,(const QString &)fileNm);
-                filePerm->showMaximized();
-                filePerm->exec();
+                QPEApplication::execDialog( filePerm );
 
                 if( filePerm)
                     delete  filePerm;
             }
 //        }
         editor->setEdited( false);
         edited1 = false;
         edited = false;
         if(caption().left(1)=="*")
             setCaption(caption().right(caption().length()-1));
 
         return true;
     }
     qDebug("returning false");
     return false;
 } //end saveAs
 
 void TextEdit::clear() {
     delete doc;
     doc = 0;
     editor->clear();
 }
 
 void TextEdit::updateCaption( const QString &name ) {
 
     if ( name.isEmpty() )
         setCaption( tr("Text Editor") );
     else {
         QString s = name;
         if ( s.isNull() )
             s = doc->name();
         if ( s.isEmpty()  ) {
             s = tr( "Unnamed" );
             currentFileName=s;
         }
 //         if(s.left(1) == "/")
 //             s = s.right(s.length()-1);
         setCaption( tr("%1 - Text Editor").arg( s ) );
     }
 }
 
 void TextEdit::setDocument(const QString& fileref) {
     if(fileref != "Unnamed") {
         currentFileName=fileref;
         qDebug("setDocument");
          QFileInfo fi(currentFileName);
          qDebug("basename:"+fi.baseName()+": current filenmame "+currentFileName);
          if( (fi.baseName().left(1)).isEmpty() ) {
         openDotFile(currentFileName);
 
          } else {
              qDebug("setDoc open");
              bFromDocView = true;
              openFile(fileref);
              editor->setEdited(true);
              edited1=false;
              edited=true;
                //   fromSetDocument=false;
  //    doSearchBar();
         }
     }
     updateCaption( currentFileName);
 }
 
 void TextEdit::changeFont() {
   QDialog *d = new QDialog ( this, "FontDialog", true );
   d-> setCaption ( tr( "Choose font" ));
   QBoxLayout *lay = new QVBoxLayout ( d );
   OFontSelector *ofs = new OFontSelector ( true, d );
   lay-> addWidget ( ofs );
   ofs-> setSelectedFont ( editor-> font ( ));
 
-  d-> showMaximized ( );
-    if ( d-> exec ( ) == QDialog::Accepted )
+    if ( QPEApplication::execDialog( d ) == QDialog::Accepted )
       editor-> setFont ( ofs-> selectedFont ( ));
     delete d;
 
 }
 
 void TextEdit::editDelete() {
     switch ( QMessageBox::warning(this,tr("Text Editor"),
                                   tr("Do you really want<BR>to <B>delete</B> "
                                      "the current file\nfrom the disk?<BR>This is "
                                      "<B>irreversable!</B>"),
                                   tr("Yes"),tr("No"),0,0,1) ) {
       case 0:
           if(doc) {
               doc->removeFiles();
               clear();
               setCaption( tr("Text Editor") );
           }
           break;
       case 1:
             // exit
           break;
     };
 }
 
 void TextEdit::changeStartConfig( bool b ) {
     startWithNew=b;
     Config cfg("TextEdit");
     cfg.setGroup("View");
     cfg.writeEntry("startNew",b);
     update();
 }
 
 void TextEdit::editorChanged() {
 //    qDebug("editor changed");
     if( /*editor->edited() &&*/ /*edited && */!edited1) {
         setCaption( "*"+caption());
         edited1=true;
     }
     edited=true;
 }
 
 void TextEdit::receive(const QCString&msg, const QByteArray &) {
     qDebug("QCop "+msg);
   if ( msg == "setDocument(QString)" ) {
       qDebug("bugger all");
 
   }
 
 }
 
 void TextEdit::doAbout() {
     QMessageBox::about(0,tr("Text Edit"),tr("Text Edit is copyright<BR>"
                          "2000 Trolltech AS, and<BR>"
                          "2002 by <B>L. J. Potter <BR>llornkcor@handhelds.org</B><BR>"
                          "and is licensed under the GPL"));
 }
 
 void TextEdit::doPrompt(bool b) {
     promptExit=b;
     Config cfg("TextEdit");
     cfg.setGroup ( "View" );
     cfg.writeEntry ( "PromptExit", b);
 }
 
 void TextEdit::doDesktop(bool b) {
     openDesktop=b;
     Config cfg("TextEdit");
     cfg.setGroup ( "View" );
     cfg.writeEntry ( "OpenDesktop", b);
 }
 
 void TextEdit::doFilePerms(bool b) {
     filePerms=b;
     Config cfg("TextEdit");
     cfg.setGroup ( "View" );
     cfg.writeEntry ( "FilePermissions", b);
 }
 
 void TextEdit::editPasteTimeDate() {
 #ifndef QT_NO_CLIPBOARD
   QClipboard *cb = QApplication::clipboard();
   QDateTime dt = QDateTime::currentDateTime();
   cb->setText( dt.toString());
   editor->paste();
 #endif
 }
 
 int TextEdit::savePrompt()
 {
     switch( QMessageBox::information( 0, (tr("Textedit")),
                                       (tr("Textedit detected\n"
                                           "you have unsaved changes\n"
                                           "Go ahead and save?\n")),
                                       (tr("Save")), (tr("Don't Save")), (tr("&Cancel")), 2, 2 ) )
       {
         case 0:
         {
             return 1;
         }
         break;
 
         case 1:
         {
             return 2;
         }
         break;
 
         case 2:
         {
             return -1;
         }
         break;
       };
 
     return 0;
 }
 
 void TextEdit::timerCrank()
 {
     if(featureAutoSave && edited1)
       {
           if(currentFileName.isEmpty())
             {
                 currentFileName = QDir::homeDirPath()+"/textedit.tmp";
                 saveAs();
             }
           else
             {
 //                qDebug("autosave");
                 save();
             }
           setTimer();
       }
 }
 
 void TextEdit::doTimer(bool b)
 {
     Config cfg("TextEdit");
     cfg.setGroup ( "View" );
     cfg.writeEntry ( "autosave", b);
     featureAutoSave = b;
     nAutoSave->setOn(b);
     if(b)
       {
 //          qDebug("doTimer true");
           setTimer();
       }
 //     else
 //         qDebug("doTimer false");
 }
 
 void TextEdit::setTimer()
 {
 if(featureAutoSave)
   {
 //      qDebug("setting autosave");
       QTimer *timer = new QTimer(this );
       connect( timer, SIGNAL(timeout()), this, SLOT(timerCrank()) );
       timer->start( 300000, true); //5 minutes
     }
 }
 
 void TextEdit::gotoLine() {
     if( editor->length() < 1)
        return;
    QWidget *d = QApplication::desktop();
    gotoEdit = new QLineEdit( 0, "Goto line");
 
    gotoEdit->move( (d->width()/2) - ( gotoEdit->width()/2) , (d->height()/2) - (gotoEdit->height()/2));
    gotoEdit->setFrame(true);
    gotoEdit->show();
    connect (gotoEdit,SIGNAL(returnPressed()), this, SLOT(doGoto()));
 }
 
 void TextEdit::doGoto() {
    QString number = gotoEdit->text();
    gotoEdit->hide();
 
    if(gotoEdit) {
       delete gotoEdit;
       gotoEdit = 0;
    }
 
    bool ok;
    int lineNumber = number.toInt(&ok, 10);
    if( editor->numLines() < lineNumber)
       QMessageBox::message(tr("Text Edit"),tr("Not enough lines"));
    else
    {
       editor->setCursorPosition(lineNumber, 0, false);
    }
 }
diff --git a/core/multimedia/opieplayer/playlistwidget.cpp b/core/multimedia/opieplayer/playlistwidget.cpp
index 5fb605b..82fd1e1 100644
--- a/core/multimedia/opieplayer/playlistwidget.cpp
+++ b/core/multimedia/opieplayer/playlistwidget.cpp
@@ -1,1483 +1,1482 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 // code added by L. J. Potter Sat 03-02-2002 06:17:54
 #define QTOPIA_INTERNAL_FSLP
 #include <qpe/qcopenvelope_qws.h>
 
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qpe/qpemenubar.h>
 #include <qpe/fileselector.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/lnkproperties.h>
 #include <qpe/storage.h>
 
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/global.h>
 #include <qpe/resource.h>
 #include <qaction.h>
 #include <qcursor.h>
 #include <qimage.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qlist.h>
 #include <qlistbox.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtoolbutton.h>
 #include <qtabwidget.h>
 #include <qlistview.h>
 #include <qpoint.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qregexp.h>
 #include <qtextstream.h>
 
 //#include <qtimer.h>
 
 #include "playlistselection.h"
 #include "playlistwidget.h"
 #include "mediaplayerstate.h"
 
 #include "inputDialog.h"
 
 #include <stdlib.h>
 #include "audiowidget.h"
 #include "videowidget.h"
 
 #include <unistd.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 
 // for setBacklight()
 #include <linux/fb.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 
 #define BUTTONS_ON_TOOLBAR
 #define SIDE_BUTTONS
 #define CAN_SAVE_LOAD_PLAYLISTS
 
 extern AudioWidget *audioUI;
 extern VideoWidget *videoUI;
 extern MediaPlayerState *mediaPlayerState;
 
 static inline QString fullBaseName ( const QFileInfo &fi )
 {
   QString str = fi. fileName ( );
   return str. left ( str. findRev ( '.' ));
 }
 
 
 QString audioMimes ="audio/mpeg;audio/x-wav;application/ogg;audio/x-mod";
 // class myFileSelector {
 
 // };
 class PlayListWidgetPrivate {
 public:
     QToolButton *tbPlay, *tbFull, *tbLoop, *tbScale, *tbShuffle, *tbAddToList,  *tbRemoveFromList, *tbMoveUp, *tbMoveDown, *tbRemove;
     QFrame *playListFrame;
     FileSelector *files;
     PlayListSelection *selectedFiles;
     bool setDocumentUsed;
     DocLnk *current;
 };
 
 
 class ToolButton : public QToolButton {
 public:
     ToolButton( QWidget *parent, const char *name, const QString& icon, QObject *handler, const QString& slot, bool t = FALSE )
             : QToolButton( parent, name ) {
         setTextLabel( name );
         setPixmap( Resource::loadPixmap( icon ) );
         setAutoRaise( TRUE );
         setFocusPolicy( QWidget::NoFocus );
         setToggleButton( t );
         connect( this, t ? SIGNAL( toggled(bool) ) : SIGNAL( clicked() ), handler, slot );
         QPEMenuToolFocusManager::manager()->addWidget( this );
     }
 };
 
 
 class MenuItem : public QAction {
 public:
     MenuItem( QWidget *parent, const QString& text, QObject *handler, const QString& slot )
             : QAction( text, QString::null, 0, 0 ) {
         connect( this, SIGNAL( activated() ), handler, slot );
         addTo( parent );
     }
 };
 
 
 PlayListWidget::PlayListWidget( QWidget* parent, const char* name, WFlags fl )
         : QMainWindow( parent, name, fl ) {
 
     d = new PlayListWidgetPrivate;
     d->setDocumentUsed = FALSE;
     d->current = NULL;
     fromSetDocument = FALSE;
     insanityBool=FALSE;
     audioScan = FALSE;
     videoScan = FALSE;
 //    menuTimer = new QTimer( this ,"menu timer"),
 //     connect( menuTimer, SIGNAL( timeout() ), SLOT( addSelected() ) );
     channel = new QCopChannel( "QPE/Application/opieplayer", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
         this, SLOT( qcopReceive(const QCString&, const QByteArray&)) );
 
     setBackgroundMode( PaletteButton );
 
     setCaption( tr("OpiePlayer") );
     setIcon( Resource::loadPixmap( "opieplayer/MPEGPlayer" ) );
 
     setToolBarsMovable( FALSE );
 
       // Create Toolbar
     QToolBar *toolbar = new QToolBar( this );
     toolbar->setHorizontalStretchable( TRUE );
 
       // Create Menubar
     QMenuBar *menu = new QMenuBar( toolbar );
     menu->setMargin( 0 );
 
     QToolBar *bar = new QToolBar( this );
     bar->setLabel( tr( "Play Operations" ) );
 //      d->tbPlayCurList =  new ToolButton( bar, tr( "play List" ), "opieplayer/play_current_list",
 //                                        this , SLOT( addSelected()) );
     tbDeletePlaylist = new QPushButton( Resource::loadIconSet("trash"),"",bar,"close");
     tbDeletePlaylist->setFlat(TRUE);
 
     tbDeletePlaylist->setFixedSize(20,20);
     
     d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ), "opieplayer/add_to_playlist",
                                       this , SLOT(addSelected()) );
     d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ), "opieplayer/remove_from_playlist",
                                           this , SLOT(removeSelected()) );
 //    d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play", /*this */mediaPlayerState , SLOT(setPlaying(bool) /* btnPlay() */), TRUE );
     d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer/play",
                                    this , SLOT( btnPlay(bool) ), TRUE );
     d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"opieplayer/shuffle",
                                    mediaPlayerState, SLOT(setShuffled(bool)), TRUE );
     d->tbLoop    = new ToolButton( bar, tr( "Loop" ),"opieplayer/loop",
                                    mediaPlayerState, SLOT(setLooping(bool)), TRUE );
     tbDeletePlaylist->hide();
 
     QPopupMenu *pmPlayList = new QPopupMenu( this );
     menu->insertItem( tr( "File" ), pmPlayList );
     new MenuItem( pmPlayList, tr( "Clear List" ), this, SLOT( clearList() ) );
     new MenuItem( pmPlayList, tr( "Add all audio files" ), this, SLOT( addAllMusicToList() ) );
     new MenuItem( pmPlayList, tr( "Add all video files" ), this, SLOT( addAllVideoToList() ) );
     new MenuItem( pmPlayList, tr( "Add all files" ), this, SLOT( addAllToList() ) );
     pmPlayList->insertSeparator(-1);
     new MenuItem( pmPlayList, tr( "Save PlayList" ), this, SLOT( saveList() ) );
     new MenuItem( pmPlayList, tr( "Open File or URL" ), this,SLOT( openFile() ) );
     pmPlayList->insertSeparator(-1);
     new MenuItem( pmPlayList, tr( "Rescan for Audio Files" ), this,SLOT( scanForAudio() ) );
     new MenuItem( pmPlayList, tr( "Rescan for Video Files" ), this,SLOT( scanForVideo() ) );
 
     QPopupMenu *pmView = new QPopupMenu( this );
     menu->insertItem( tr( "View" ), pmView );
 
     fullScreenButton = new QAction(tr("Full Screen"), Resource::loadPixmap("fullscreen"), QString::null, 0, this, 0);
     fullScreenButton->addTo(pmView);
     scaleButton = new QAction(tr("Scale"), Resource::loadPixmap("opieplayer/scale"), QString::null, 0, this, 0);
     scaleButton->addTo(pmView);
 
 
     skinsMenu = new QPopupMenu( this );
     menu->insertItem( tr( "Skins" ), skinsMenu );
     skinsMenu->isCheckable();
     connect( skinsMenu, SIGNAL( activated( int ) ) ,
              this, SLOT( skinsMenuActivated( int ) ) );
     populateSkinsMenu();
 
     QVBox *vbox5 = new QVBox( this ); vbox5->setBackgroundMode( PaletteButton );
     QVBox *vbox4 = new QVBox( vbox5 ); vbox4->setBackgroundMode( PaletteButton );
 
     QHBox *hbox6 = new QHBox( vbox4 ); hbox6->setBackgroundMode( PaletteButton );
     
     tabWidget = new QTabWidget( hbox6, "tabWidget" );
 //    tabWidget->setTabShape(QTabWidget::Triangular);
     
     QWidget *pTab;
     pTab = new QWidget( tabWidget, "pTab" );
 //      playlistView = new QListView( pTab, "playlistview" );
 //    playlistView->setMinimumSize(236,260);
     tabWidget->insertTab( pTab,"Playlist");
 
 
     // Add the playlist area
   
     QVBox *vbox3 = new QVBox( pTab ); vbox3->setBackgroundMode( PaletteButton );
     d->playListFrame = vbox3;
 
     QGridLayout *layoutF = new QGridLayout( pTab );
     layoutF->setSpacing( 2);
     layoutF->setMargin( 2);
     layoutF->addMultiCellWidget( d->playListFrame , 0, 0, 0, 1 );
 
     QHBox *hbox2 = new QHBox( vbox3 ); hbox2->setBackgroundMode( PaletteButton );
 
     d->selectedFiles = new PlayListSelection( hbox2);
     QVBox *vbox1 = new QVBox( hbox2 ); vbox1->setBackgroundMode( PaletteButton );
 
     QPEApplication::setStylusOperation( d->selectedFiles->viewport(),QPEApplication::RightOnHold);
 
 
           
     QVBox *stretch1 = new QVBox( vbox1 ); stretch1->setBackgroundMode( PaletteButton ); // add stretch
     new ToolButton( vbox1, tr( "Move Up" ),   "opieplayer/up",   d->selectedFiles, SLOT(moveSelectedUp()) );
     new ToolButton( vbox1, tr( "Remove" ),    "opieplayer/cut",  d->selectedFiles, SLOT(removeSelected()) );
     new ToolButton( vbox1, tr( "Move Down" ), "opieplayer/down", d->selectedFiles, SLOT(moveSelectedDown()) );
     QVBox *stretch2 = new QVBox( vbox1 ); stretch2->setBackgroundMode( PaletteButton ); // add stretch
 
     QWidget *aTab;
     aTab = new QWidget( tabWidget, "aTab" );
     audioView = new QListView( aTab, "Audioview" );
 
     QGridLayout *layoutA = new QGridLayout( aTab );
     layoutA->setSpacing( 2);
     layoutA->setMargin( 2);
     layoutA->addMultiCellWidget( audioView, 0, 0, 0, 1 );
 
     audioView->addColumn( tr("Title"),-1);
     audioView->addColumn(tr("Size"), -1);
     audioView->addColumn(tr("Media"),-1);
     audioView->addColumn( tr( "Path" ), -1 );
     
     audioView->setColumnAlignment(1, Qt::AlignRight);
     audioView->setColumnAlignment(2, Qt::AlignRight);
     audioView->setAllColumnsShowFocus(TRUE);
 
     audioView->setMultiSelection( TRUE );
     audioView->setSelectionMode( QListView::Extended);
     audioView->setSorting( 3, TRUE );
     
     tabWidget->insertTab(aTab,tr("Audio"));
 
     QPEApplication::setStylusOperation( audioView->viewport(),QPEApplication::RightOnHold);
 
 //    audioView
 //     populateAudioView();
 // videowidget
      
     QWidget *vTab;
     vTab = new QWidget( tabWidget, "vTab" );
     videoView = new QListView( vTab, "Videoview" );
 
     QGridLayout *layoutV = new QGridLayout( vTab );
     layoutV->setSpacing( 2);
     layoutV->setMargin( 2);
     layoutV->addMultiCellWidget( videoView, 0, 0, 0, 1 );
     
     videoView->addColumn(tr("Title"),-1);
     videoView->addColumn(tr("Size"),-1);
     videoView->addColumn(tr("Media"),-1);
     videoView->addColumn(tr( "Path" ), -1 );
     videoView->setColumnAlignment(1, Qt::AlignRight);
     videoView->setColumnAlignment(2, Qt::AlignRight);
     videoView->setAllColumnsShowFocus(TRUE);
     videoView->setMultiSelection( TRUE );
     videoView->setSelectionMode( QListView::Extended);
 
     QPEApplication::setStylusOperation( videoView->viewport(),QPEApplication::RightOnHold);
 
     tabWidget->insertTab( vTab,tr("Video"));
 
     QWidget *LTab;
     LTab = new QWidget( tabWidget, "LTab" );
     playLists = new FileSelector( "playlist/plain;audio/x-mpegurl", LTab, "fileselector" , FALSE, FALSE);
 
     QGridLayout *layoutL = new QGridLayout( LTab );
     layoutL->setSpacing( 2);
     layoutL->setMargin( 2);
     layoutL->addMultiCellWidget( playLists, 0, 0, 0, 1 );
 
     tabWidget->insertTab(LTab,tr("Lists"));
 
     connect(tbDeletePlaylist,(SIGNAL(released())),SLOT( deletePlaylist()));
     connect( fullScreenButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleFullscreen()) );
     connect( scaleButton, SIGNAL(activated()), mediaPlayerState, SLOT(toggleScaled()) );
 
     connect( d->selectedFiles, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
              this,SLOT( playlistViewPressed(int, QListViewItem *, const QPoint&, int)) );
 
 
 ///audioView
     connect( audioView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
              this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
     
     connect( audioView, SIGNAL( returnPressed( QListViewItem *)),
              this,SLOT( playIt( QListViewItem *)) );
     connect( audioView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
 
 
 //videoView
     connect( videoView, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
              this,SLOT( viewPressed(int, QListViewItem *, const QPoint&, int)) );
     connect( videoView, SIGNAL( returnPressed( QListViewItem *)),
              this,SLOT( playIt( QListViewItem *)) );
     connect( videoView, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( addToSelection( QListViewItem *) ) );
 
 //playlists
     connect( playLists, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( loadList( const DocLnk & ) ) );
 
     connect( tabWidget, SIGNAL (currentChanged(QWidget*)),this,SLOT(tabChanged(QWidget*)));
 
     connect( mediaPlayerState, SIGNAL( playingToggled( bool ) ),    d->tbPlay,    SLOT( setOn( bool ) ) );
 
     connect( mediaPlayerState, SIGNAL( loopingToggled( bool ) ),    d->tbLoop,    SLOT( setOn( bool ) ) );
     connect( mediaPlayerState, SIGNAL( shuffledToggled( bool ) ),   d->tbShuffle, SLOT( setOn( bool ) ) );
     connect( mediaPlayerState, SIGNAL( playlistToggled( bool ) ),   this,         SLOT( setPlaylist( bool ) ) );
 
     connect( d->selectedFiles, SIGNAL( doubleClicked( QListViewItem *) ), this, SLOT( playIt( QListViewItem *) ) );
 
     setCentralWidget( vbox5 );
 
     Config cfg( "OpiePlayer" );
     readConfig( cfg );
 
     currentPlayList = cfg.readEntry("CurrentPlaylist","default");
     loadList(DocLnk( currentPlayList));
     setCaption(tr("OpiePlayer: ")+ fullBaseName ( QFileInfo(currentPlayList)));
     
     initializeStates();
 }
 
 
 PlayListWidget::~PlayListWidget() {
     Config cfg( "OpiePlayer" );
     writeConfig( cfg );
 
       if ( d->current )
           delete d->current;
       if(d) delete d;
 }
 
 
 void PlayListWidget::initializeStates() {
 
     d->tbPlay->setOn( mediaPlayerState->playing() );
     d->tbLoop->setOn( mediaPlayerState->looping() );
     d->tbShuffle->setOn( mediaPlayerState->shuffled() );
     setPlaylist( true);
 }
 
 
 void PlayListWidget::readConfig( Config& cfg ) {
     cfg.setGroup("PlayList");
     QString currentString = cfg.readEntry("current", "" );
     int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
     for ( int i = 0; i < noOfFiles; i++ ) {
         QString entryName;
         entryName.sprintf( "File%i", i + 1 );
         QString linkFile = cfg.readEntry( entryName );
         DocLnk lnk( linkFile );
         if ( lnk.isValid() ) {
             d->selectedFiles->addToSelection( lnk );
         }
     }
     d->selectedFiles->setSelectedItem( currentString);
 }
 
 
 void PlayListWidget::writeConfig( Config& cfg ) const {
 
     d->selectedFiles->writeCurrent( cfg);
     cfg.setGroup("PlayList");
     int noOfFiles = 0;
     d->selectedFiles->first();
     do {
         const DocLnk *lnk = d->selectedFiles->current();
         if ( lnk ) {
             QString entryName;
             entryName.sprintf( "File%i", noOfFiles + 1 );
 //            qDebug(entryName);
             cfg.writeEntry( entryName, lnk->linkFile() );
               // if this link does exist, add it so we have the file
               // next time...
             if ( !QFile::exists( lnk->linkFile() ) ) {
                   // the way writing lnks doesn't really check for out
                   // of disk space, but check it anyway.
 //                  if ( !lnk->writeLink() ) {
 //                      QMessageBox::critical( 0, tr("Out of space"),
 //                                             tr( "There was a problem saving "
 //                                                 "the playlist.\n"
 //                                                 "Your playlist "
 //                                                 "may be missing some entries\n"
 //                                                 "the next time you start it." )
 //                                             );
 //                  }
 
             }      
             noOfFiles++;
         }
     }
     while ( d->selectedFiles->next() );
     cfg.writeEntry("NumberOfFiles", noOfFiles );
 }
 
 
 void PlayListWidget::addToSelection( const DocLnk& lnk ) {
         d->setDocumentUsed = false;
         if ( mediaPlayerState->playlist() ) {
             if(QFileInfo(lnk.file()).exists() || lnk.file().left(4) == "http" )
                 d->selectedFiles->addToSelection( lnk );
         }
         else
             mediaPlayerState->setPlaying( true);
 
 }
 
 
 void PlayListWidget::clearList() {
    while ( first() )
       d->selectedFiles->removeSelected();
    Config cfg( "OpiePlayer" );
    cfg.setGroup("PlayList");
    cfg.writeEntry("CurrentPlaylist","");
    currentPlayList="";
 
 }
 
 
 void PlayListWidget::addAllToList() {
     DocLnkSet filesAll;
     Global::findDocuments(&filesAll, "video/*;audio/*");
     QListIterator<DocLnk> Adit( filesAll.children() );
     for ( ; Adit.current(); ++Adit )
         if(QFileInfo(Adit.current()->file()).exists())
             d->selectedFiles->addToSelection( **Adit );
     tabWidget->setCurrentPage(0);
     
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::addAllMusicToList() {
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit ) 
         if(QFileInfo(dit.current()->file()).exists())
             d->selectedFiles->addToSelection( **dit );
     tabWidget->setCurrentPage(0);
     
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::addAllVideoToList() {
     QListIterator<DocLnk> dit( vFiles.children() );
     for ( ; dit.current(); ++dit )
         if(QFileInfo( dit.current()->file()).exists())
             d->selectedFiles->addToSelection( **dit );
     tabWidget->setCurrentPage(0);
     
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::setDocument(const QString& fileref) {
    fromSetDocument = true;
    d->setDocumentUsed = TRUE;
    setDocumentEx(fileref);
 }
 
 void PlayListWidget::setDocumentEx(const QString& fileref) {
    qDebug("opieplayer receive "+fileref);
    clearList();
    DocLnk lnk;
    QFileInfo fileInfo(fileref);
    if ( !fileInfo.exists() ) {
       QMessageBox::critical( 0, tr( "Invalid File" ),
                              tr( "There was a problem in getting the file." ) );
       return;
    }
    //   qDebug("<<<<<<<<<<<<<<<<<<<<<<setDocument "+fileref);
    QString extension = fileInfo.extension(false);
      if( extension.find( "m3u", 0, false) != -1) { //is m3u
         readm3u( fileref);
      }
   else if( extension.find( "pls", 0, false) != -1 ) { //is pls
       readPls( fileref);
    }
    else if( fileref.find("playlist",0,TRUE) != -1) {//is playlist
       clearList();
       lnk.setName( fileInfo.baseName() ); //sets name
       lnk.setFile( fileref ); //sets file name
       lnk.setIcon("Sound");
       //addToSelection( lnk );
 
       loadList( lnk);
       d->selectedFiles->first();
    } else {
       if( fileref.find(".desktop",0,TRUE) != -1) {
          lnk = DocLnk(fileref);
       } else {
          lnk.setName( fileInfo.baseName() ); //sets name
          lnk.setFile( fileref ); //sets file name
          lnk.setIcon("Sound");
       }
 
       addToSelection( lnk );
       //        addToSelection( DocLnk( fileref ) );
       lnk.removeLinkFile();
       //        qApp->processEvents();
    }
       setCaption(tr("OpiePlayer"));
       d->setDocumentUsed = TRUE;
      d->selectedFiles->setSelected(d->selectedFiles->firstChild(),true );
       mediaPlayerState->setPlaying( FALSE );
       qApp->processEvents();
       mediaPlayerState->setPlaying( TRUE );
 
 }
 
 
 void PlayListWidget::setActiveWindow() {
    //        qDebug("SETTING active window");
       // When we get raised we need to ensure that it switches views
     char origView = mediaPlayerState->view();
     mediaPlayerState->setView( 'l' ); // invalidate
     mediaPlayerState->setView( origView ); // now switch back
 }
 
 
 void PlayListWidget::useSelectedDocument() {
     d->setDocumentUsed = FALSE;
 }
 
 
 const DocLnk *PlayListWidget::current() { // this is fugly
    switch (tabWidget->currentPageIndex()) {
    case 0: //playlist
    {
       //          qDebug("playlist");
       if ( mediaPlayerState->playlist() ) {
          return d->selectedFiles->current();
       }
       else if ( d->setDocumentUsed && d->current ) {
          return d->current;
       } else {
          return &(d->files->selectedDocument());
       }
    }
    break;
    case 1://audio
    {
       //          qDebug("audioView");
       QListIterator<DocLnk> dit( files.children() );
       for ( ; dit.current(); ++dit ) {
          if( dit.current()->name() == audioView->currentItem()->text(0) && !insanityBool) {
             insanityBool=TRUE;
             return dit;
          }
       }
    }           
    break;
    case 2: // video
    {
       QListIterator<DocLnk> Vdit( vFiles.children() );
       for ( ; Vdit.current(); ++Vdit ) {
          if( Vdit.current()->name() == videoView->currentItem()->text(0) && !insanityBool) {
             insanityBool=TRUE;
             return Vdit;
          }
       }
    }
    break;
    };
    return 0;
 }
 
 bool PlayListWidget::prev() {
    if ( mediaPlayerState->playlist() ) {
       if ( mediaPlayerState->shuffled() ) {
          const DocLnk *cur = current();
          int j = 1 + (int)(97.0 * rand() / (RAND_MAX + 1.0));
          for ( int i = 0; i < j; i++ ) {
             if ( !d->selectedFiles->next() )
                d->selectedFiles->first();
          }
          if ( cur == current() )
             if ( !d->selectedFiles->next() )
                d->selectedFiles->first();
          return TRUE;
       } else {
          if ( !d->selectedFiles->prev() ) {
             if ( mediaPlayerState->looping() ) {
                return d->selectedFiles->last();
             } else {
                return FALSE;
             }
          }
          return TRUE;
       }
    } else {
       return mediaPlayerState->looping();
    }
 }
 
 
 bool PlayListWidget::next() {
    if ( mediaPlayerState->playlist() ) {
       if ( mediaPlayerState->shuffled() ) {
          return prev();
       } else {
          if ( !d->selectedFiles->next() ) {
             if ( mediaPlayerState->looping() ) {
                return d->selectedFiles->first();
             } else {
                return FALSE;
             }
          }
          return TRUE;
       }
    } else {
       return mediaPlayerState->looping();
    }
 }
 
 
 bool PlayListWidget::first() {
    if ( mediaPlayerState->playlist() )
       return d->selectedFiles->first();
    else
       return mediaPlayerState->looping();
 }
 
 
 bool PlayListWidget::last() {
    if ( mediaPlayerState->playlist() )
       return d->selectedFiles->last();
    else
       return mediaPlayerState->looping();
 }
 
 
 void PlayListWidget::saveList() {
    writem3u();
 }
 
 void PlayListWidget::loadList( const DocLnk & lnk) {
    QString name = lnk.name();
    //  qDebug("<<<<<<<<<<<<<<<<<<<<<<<<currentList is "+name);
 
    if( name.length()>0) {
       setCaption("OpiePlayer: "+name);
       //       qDebug("<<<<<<<<<<<<load list "+ lnk.file());
       clearList();
       readm3u(lnk.file());
       tabWidget->setCurrentPage(0);
    }
 }
 
 void PlayListWidget::setPlaylist( bool shown ) {
    if ( shown ) 
       d->playListFrame->show();
    else
       d->playListFrame->hide();
 }
 
 void PlayListWidget::setView( char view ) {
    if ( view == 'l' )
       showMaximized();
    else
       hide();
 }
 
 void PlayListWidget::addSelected() {
    DocLnk lnk;
    QString filename;
    switch (tabWidget->currentPageIndex()) {
 
    case 0: //playlist
       return;
       break;
    case 1: { //audio
       QListViewItemIterator it( audioView );
       for ( ; it.current(); ++it ) {
          if ( it.current()->isSelected() ) {
             filename = it.current()->text(3);
             lnk.setName(  QFileInfo(filename).baseName() ); //sets name
             lnk.setFile( filename ); //sets file name
             d->selectedFiles->addToSelection(  lnk);
          }
       }
       audioView->clearSelection();
       //    d->selectedFiles->next();
    }
       break;
     
    case 2: { // video
       QListViewItemIterator it( videoView );
       for ( ; it.current(); ++it ) {
          if ( it.current()->isSelected() ) {
 
             filename = it.current()->text(3);
             lnk.setName(  QFileInfo(filename).baseName() ); //sets name
             lnk.setFile( filename ); //sets file name
             d->selectedFiles->addToSelection(  lnk);
          }
       }
       videoView->clearSelection();
    }
       break;
    };
    //  tabWidget->setCurrentPage(0);
    writeCurrentM3u();          
 
 }
 
 void PlayListWidget::removeSelected() {
     d->selectedFiles->removeSelected( );
 }
 
 void PlayListWidget::playIt( QListViewItem *) {
    //   d->setDocumentUsed = FALSE;
    //  mediaPlayerState->curPosition =0;
    //    mediaPlayerState->setPlaying(FALSE);
    mediaPlayerState->setPlaying(TRUE);
    d->selectedFiles->unSelect();
 }
 
 void PlayListWidget::addToSelection( QListViewItem *it) {
    d->setDocumentUsed = FALSE;
 
    if(it) {
       switch ( tabWidget->currentPageIndex()) {
       case 0: //playlist
          return;
          break;
       };
       //      case 1: {
       DocLnk lnk;
       QString filename;
 
       filename=it->text(3);
       lnk.setName( fullBaseName ( QFileInfo(filename)) ); //sets name
       lnk.setFile( filename ); //sets file name
       d->selectedFiles->addToSelection(  lnk);
  
       if(tabWidget->currentPageIndex() == 0)
          writeCurrentM3u();          
       //    tabWidget->setCurrentPage(0);
         
    }
 }
 
 void PlayListWidget::tabChanged(QWidget *) {
 
    switch ( tabWidget->currentPageIndex()) {
    case 0:
    {
       if( !tbDeletePlaylist->isHidden())
          tbDeletePlaylist->hide();
       d->tbRemoveFromList->setEnabled(TRUE);
       d->tbAddToList->setEnabled(FALSE);
    }
    break;
    case 1:
    {
       audioView->clear();
       populateAudioView();
 
       if( !tbDeletePlaylist->isHidden())
          tbDeletePlaylist->hide();
       d->tbRemoveFromList->setEnabled(FALSE);
       d->tbAddToList->setEnabled(TRUE);
    }
    break;
    case 2:
    {
       videoView->clear();
       populateVideoView();
       if( !tbDeletePlaylist->isHidden())
          tbDeletePlaylist->hide();
       d->tbRemoveFromList->setEnabled(FALSE);
       d->tbAddToList->setEnabled(TRUE);
    }
    break;
    case 3:
    {
       if( tbDeletePlaylist->isHidden())
          tbDeletePlaylist->show();
       playLists->reread();
    }
    break;
    };
 }
 
 void PlayListWidget::btnPlay(bool b) {
    //    mediaPlayerState->setPlaying(b);
    switch ( tabWidget->currentPageIndex()) {
    case 0:
    {
       //            if( d->selectedFiles->current()->file().find(" ",0,TRUE) != -1
       //                if( d->selectedFiles->current()->file().find("%20",0,TRUE) != -1) {
       //                 QMessageBox::message("Note","You are trying to play\na malformed url.");
       //            } else {
       mediaPlayerState->setPlaying(b);
       insanityBool=FALSE;
       qDebug("insanity");              
       //          }
    }
    break;
    case 1:
    {
       //          d->selectedFiles->unSelect();
       addToSelection( audioView->currentItem() );
       mediaPlayerState->setPlaying( b);
       d->selectedFiles->removeSelected( );
       d->selectedFiles->unSelect();
       tabWidget->setCurrentPage(1);
       insanityBool=FALSE;         
    }//          audioView->clearSelection();
    break;
    case 2:
    {
           
       addToSelection( videoView->currentItem() );
       mediaPlayerState->setPlaying( b);
       //          qApp->processEvents();
       d->selectedFiles->removeSelected( );
       d->selectedFiles->unSelect();
       tabWidget->setCurrentPage(2);
       insanityBool=FALSE;
    }//          videoView->clearSelection();
    break;
    };
  
 }
 
 void PlayListWidget::deletePlaylist() {
    switch( QMessageBox::information( this, (tr("Remove Playlist?")),
                                      (tr("You really want to delete\nthis playlist?")),
                                      (tr("Yes")), (tr("No")), 0 )){
    case 0: // Yes clicked,
       QFile().remove(playLists->selectedDocument().file());
       QFile().remove(playLists->selectedDocument().linkFile());
       playLists->reread();
       break;
    case 1: // Cancel
       break;
    };
 }
 
 void PlayListWidget::viewPressed( int mouse, QListViewItem *, const QPoint&, int )
 {
    switch (mouse) {
    case 1:
       break;
    case 2:{
 
       QPopupMenu  m;
       m.insertItem( tr( "Play" ), this, SLOT( playSelected() ));
       m.insertItem( tr( "Add to Playlist" ), this, SLOT( addSelected() ));
       m.insertSeparator();
       if( QFile(QPEApplication::qpeDir()+"lib/libopie.so").exists() ) 
          m.insertItem( tr( "Properties" ), this, SLOT( listDelete() ));
     
       m.exec( QCursor::pos() );
    }
       break;
    };
 }
 
 void PlayListWidget::playSelected()
 {
     btnPlay( true);
 //    d->selectedFiles->unSelect();
 }
 
 void PlayListWidget::playlistViewPressed( int mouse, QListViewItem *, const QPoint&, int)
 {
    switch (mouse) {
    case 1:
           
       break;
    case 2:{
       QPopupMenu  m;
       m.insertItem( tr( "Play Selected" ), this, SLOT( playSelected() ));
       m.insertItem( tr( "Remove" ), this, SLOT( removeSelected() ));
       //       m.insertSeparator();
       //     m.insertItem( tr( "Properties" ), this, SLOT( listDelete() ));
       m.exec( QCursor::pos() );
    }
       break;
    };
 
 }
 
 void PlayListWidget::listDelete() {
    Config cfg( "OpiePlayer" );
    cfg.setGroup("PlayList");
    currentPlayList = cfg.readEntry("CurrentPlaylist","");
    QString file;
    //    int noOfFiles = cfg.readNumEntry("NumberOfFiles", 0 );
    switch ( tabWidget->currentPageIndex()) {
    case 0: 
       break;
    case 1:
    {
       file = audioView->currentItem()->text(0);
       QListIterator<DocLnk> Pdit( files.children() );
       for ( ; Pdit.current(); ++Pdit ) {
          if( Pdit.current()->name() == file) {
             LnkProperties prop( Pdit.current() );
-            prop.showMaximized();
-            prop.exec();
+            QPEApplication::execDialog( &prop );
          }
       }
       populateAudioView();
    }
    break;
    case 2:
    {
       //           file = videoView->selectedItem()->text(0);
       //           for ( int i = 0; i < noOfFiles; i++ ) {
       //               QString entryName;
       //               entryName.sprintf( "File%i", i + 1 );
       //               QString linkFile = cfg.readEntry( entryName );
       //                   AppLnk lnk( AppLnk(linkFile));
       //               if( lnk.name() == file ) {
       //                   LnkProperties prop( &lnk);
       // //  connect(&prop, SIGNAL(select(const AppLnk *)), this, SLOT(externalSelected(const AppLnk *)));
       //                   prop.showMaximized();
       //                   prop.exec();
       //               }
       //            }
    }
    break;
    };
 }
 
 void PlayListWidget::scanForAudio() {
    //    qDebug("scan for audio");
    files.detachChildren();
    QListIterator<DocLnk> sdit( files.children() );
    for ( ; sdit.current(); ++sdit ) {
       delete sdit.current();
    }
    Global::findDocuments( &files, audioMimes);
    audioScan = true;
 }
 void PlayListWidget::scanForVideo() {
    //    qDebug("scan for video");
    vFiles.detachChildren();
    QListIterator<DocLnk> sdit( vFiles.children() );
    for ( ; sdit.current(); ++sdit ) {
       delete sdit.current();
    }
    Global::findDocuments(&vFiles, "video/*");
    videoScan = true;
 }
 
 void PlayListWidget::populateAudioView() {
 
    audioView->clear();
    StorageInfo storageInfo;
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    if(!audioScan) scanForAudio();
 
    QListIterator<DocLnk> dit( files.children() );
    QListIterator<FileSystem> it ( fs );
 
    QString storage;
    for ( ; dit.current(); ++dit ) {
       for( ; it.current(); ++it ){
          const QString name = (*it)->name();
          const QString path = (*it)->path();
          if(dit.current()->file().find(path) != -1 ) storage=name;
       }
 
       QListViewItem * newItem;
       if ( QFile( dit.current()->file()).exists() || dit.current()->file().left(4) == "http" ) {
          long size;
          if( dit.current()->file().left(4) == "http" )
             size=0;
          else 
             size = QFile( dit.current()->file() ).size();
          //            qDebug(dit.current()->name());
          newItem= /*(void)*/ new QListViewItem( audioView, dit.current()->name(),
                                                 QString::number(size ), storage, dit.current()->file());
          newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/musicfile" ));
       }
    }
 
 }
 
 void PlayListWidget::populateVideoView() {
     videoView->clear();
     StorageInfo storageInfo;
     const QList<FileSystem> &fs = storageInfo.fileSystems();
 
     if(!videoScan ) scanForVideo();
 
     QListIterator<DocLnk> Vdit( vFiles.children() );
     QListIterator<FileSystem> it ( fs );
     videoView->clear();
     QString storage;
     for ( ; Vdit.current(); ++Vdit ) {
         for( ; it.current(); ++it ){
             const QString name = (*it)->name();
             const QString path = (*it)->path();
             if( Vdit.current()->file().find(path) != -1 ) storage=name;
         }
 
         QListViewItem * newItem;
         if ( QFile( Vdit.current()->file()).exists() ) {
             newItem= /*(void)*/ new QListViewItem( videoView, Vdit.current()->name(),
                    QString::number( QFile( Vdit.current()->file() ).size() ),
                                                    storage, Vdit.current()->file());
             newItem->setPixmap(0, Resource::loadPixmap( "opieplayer/videofile" ));
         }
     }
 }
 
 void PlayListWidget::openFile() {
    QString filename, name;
    InputDialog *fileDlg;
    fileDlg = new InputDialog(this,tr("Open file or URL"),TRUE, 0);
    fileDlg->exec();
    if( fileDlg->result() == 1 ) {
       filename = fileDlg->text();
       //        qDebug( "Selected filename is " + filename );
       DocLnk lnk;
       Config cfg( "OpiePlayer" );
       cfg.setGroup("PlayList");
 
       QString m3uFile;
       m3uFile = filename;
       if(filename.left(4) == "http") {
          if(filename.find(":",8,TRUE) != -1) { //found a port
 
             m3uFile = filename;
             if( m3uFile.right( 1 ).find( '/' ) == -1) {
                m3uFile += "/";
             }
             filename = m3uFile;
          }
          lnk.setName( m3uFile ); //sets name
          lnk.setFile( filename ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
          d->selectedFiles->addToSelection(  lnk );
          writeCurrentM3u();
       }
       else if( filename.right( 3) == "m3u" ) {
          readm3u( filename );
 
       } else if( filename.right(3) == "pls" ) {
          readPls( filename );
       } else {
          lnk.setName( fullBaseName ( QFileInfo(filename)) ); //sets name
          lnk.setFile( filename ); //sets file name
          d->selectedFiles->addToSelection(  lnk);
          lnk.removeLinkFile();
          writeCurrentM3u();
       }
    }
             
    if( fileDlg ) {
       delete fileDlg;
    }
 }
 
 
 /*
 reads m3u and shows files/urls to playlist widget */
 void PlayListWidget::readm3u( const QString &filename ) { 
    //    qDebug( "read m3u filename " + filename );
 
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readM3u();
    DocLnk lnk;
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
       //          qDebug("reading "+ s);
       if(s.left(4)=="http") {
          lnk.setName( s ); //sets file name
          lnk.setIcon("opieplayer2/musicfile");
 
          //          if(s.right(4) != '.' || s.right(5) != '.')
          if(s.right(4) != '.' || s.right(5) != '.' )
             if( s.right(1) != "/")
                lnk.setFile( s+"/"); //if url with no extension
             else
                lnk.setFile( s ); //sets file name
             
       }  else {
          //               if( QFileInfo( s ).exists() ) {
          lnk.setName( fullBaseName ( QFileInfo(s)));
          //                 if(s.right(4) == '.')   {//if regular file
          if(s.left(1) != "/")  { 
             //            qDebug("set link "+QFileInfo(filename).dirPath()+"/"+s);
             lnk.setFile( QFileInfo(filename).dirPath()+"/"+s);
             lnk.setIcon("SoundPlayer");
          } else {
             //            qDebug("set link2 "+s);
             lnk.setFile( s);
             lnk.setIcon("SoundPlayer");
          }
       }
       d->selectedFiles->addToSelection( lnk );
    }
    Config config( "OpiePlayer" );
    config.setGroup( "PlayList" );
 
    config.writeEntry("CurrentPlaylist",filename);
    config.write();
    currentPlayList=filename;
 
 //    m3uList->write();
    m3uList->close();
    if(m3uList) delete m3uList;
 
    d->selectedFiles->setSelectedItem( s);
    setCaption(tr("OpiePlayer: ")+ fullBaseName ( QFileInfo(filename)));
     
 }
 
 /*
 reads pls and adds files/urls to playlist  */
 void PlayListWidget::readPls( const QString &filename ) {
 
    //    qDebug( "pls filename is " + filename );
    Om3u *m3uList;
    QString s, name;
    m3uList = new Om3u( filename, IO_ReadOnly );
    m3uList->readPls();
 
    for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
       s = *it;
       //        s.replace( QRegExp( "%20" )," " );
       DocLnk lnk( s );
       QFileInfo f( s );
       QString name = fullBaseName ( f);
 
       if( name.left( 4 ) == "http" ) {
          name = s.right( s.length() - 7);
       }  else {
          name = s;
       }
 
       name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
 
       lnk.setName( name );
       if( s.at( s.length() - 4) == '.') {// if this is probably a file
          lnk.setFile( s );
       } else { //if its a url
          if( name.right( 1 ).find( '/' ) == -1) {
             s += "/";
          }
          lnk.setFile( s );
       }
       lnk.setType( "audio/x-mpegurl" );
 
       lnk.writeLink();
       d->selectedFiles->addToSelection( lnk );
    }
 
    m3uList->close();
    if(m3uList) delete m3uList;
 }
 
 /*
  writes current playlist to current m3u file */
 void PlayListWidget::writeCurrentM3u() {
    //  qDebug("writing to current m3u");
   Config cfg( "OpiePlayer" );
   cfg.setGroup("PlayList");
   currentPlayList = cfg.readEntry("CurrentPlaylist","");
   Om3u *m3uList;
   m3uList = new Om3u( currentPlayList, IO_ReadWrite | IO_Truncate );
 
   if( d->selectedFiles->first()) {
   do {
      //      qDebug( "writeCurrentM3u " +d->selectedFiles->current()->file());
     m3uList->add( d->selectedFiles->current()->file() );
   }
   while ( d->selectedFiles->next() );
   //    qDebug( "<<<<<<<<<<<<>>>>>>>>>>>>>>>>>" );
   m3uList->write();
   m3uList->close();
 
   if(m3uList) delete m3uList;
   }
 }
 
   /*
  writes current playlist to m3u file */
 void PlayListWidget::writem3u() {
    InputDialog *fileDlg;
    fileDlg = new InputDialog( this, tr( "Save m3u Playlist " ), TRUE, 0);
    fileDlg->exec();
    QString name, filename, list;
    Om3u *m3uList;
 
    if( fileDlg->result() == 1 ) {
       name = fileDlg->text();
       //        qDebug( filename );
       if( name.find("/",0,true) != -1) {// assume they specify a file path
          filename = name;
          name = name.right(name.length()- name.findRev("/",-1,true) - 1 );
       }
       else //otherwise dump it somewhere noticable
          filename = QPEApplication::documentDir() + "/" + name;
 
       if( filename.right( 3 ) != "m3u" ) //needs filename extension
          filename += ".m3u";
         
       if( d->selectedFiles->first()) {
          m3uList = new Om3u(filename, IO_ReadWrite | IO_Truncate);
 
          do {
             m3uList->add( d->selectedFiles->current()->file());
          }
          while ( d->selectedFiles->next() );
          //    qDebug( list );
          m3uList->write();
          m3uList->close();
          if(m3uList) delete m3uList;
         
          if(fileDlg) delete fileDlg;
 
          DocLnk lnk;
          lnk.setFile( filename);
          lnk.setIcon("opieplayer2/playlist2");
          lnk.setName( name); //sets file name
 
          // qDebug(filename);
          Config config( "OpiePlayer" );
          config.setGroup( "PlayList" );
     
          config.writeEntry("CurrentPlaylist",filename);
          currentPlayList=filename;
 
          if(!lnk.writeLink()) {
             //            qDebug("Writing doclink did not work");
          }
 
          setCaption(tr("OpiePlayer: ") + name);
       }
    }
 }
 
 
 void PlayListWidget::keyReleaseEvent( QKeyEvent *e)
 {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_F9: //activity
 //           if(audioUI->isHidden())
 //             audioUI->showMaximized();
           break;
       case Key_F10: //contacts
 //           if( videoUI->isHidden())
 //             videoUI->showMaximized();
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
 //           doBlank();
           break;
       case Key_F13: //mail
 //           doUnblank();
           break;
       case Key_Q: //add to playlist
           addSelected();
           break;
       case Key_R: //remove from playlist
           removeSelected();
           break;
 //       case Key_P: //play
 //           qDebug("Play");
 //           playSelected();
 //           break;
       case Key_Space:
 //          playSelected(); puh
           break;
       case Key_1:
           tabWidget->setCurrentPage(0);
           break;
       case Key_2:
           tabWidget->setCurrentPage(1);
           break;
     case Key_3:
       tabWidget->setCurrentPage(2);
       break;
     case Key_4:
       tabWidget->setCurrentPage(3);         
       break;
     case Key_Down:
       if ( !d->selectedFiles->next() )
         d->selectedFiles->first();
 
       break;
     case Key_Up:
       if ( !d->selectedFiles->prev() )
         //        d->selectedFiles->last();
 
       break;
       
     }
 }
 
 void PlayListWidget::keyPressEvent( QKeyEvent *)
 {
 //    qDebug("Key press");
 //     switch ( e->key() ) {
 // ////////////////////////////// Zaurus keys
 //       case Key_A: //add to playlist
 //           qDebug("Add");
 //           addSelected();
 //           break;
 //       case Key_R: //remove from playlist
 //           removeSelected();
 //           break;
 //       case Key_P: //play
 //           qDebug("Play");
 //           playSelected();
 //           break;
 //       case Key_Space:
 //           qDebug("Play");
 //           playSelected();
 //           break;
 //     }
 }
 
 void PlayListWidget::doBlank() {
    //    qDebug("do blanking");
 #ifdef QT_QWS_DEVFS
    fd=open("/dev/fb/0",O_RDWR);
 #else
    fd=open("/dev/fb0",O_RDWR);
 #endif
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,1);
       //            close(fd);
    }
 }
 
 void PlayListWidget::doUnblank() {
    // this crashes opieplayer with a segfault
    //      int fd;
    //       fd=open("/dev/fb0",O_RDWR);
    //    qDebug("do unblanking");
    if (fd != -1) {
       ioctl(fd,FBIOBLANK,0);
       close(fd);
    }
    QCopEnvelope h("QPE/System", "setBacklight(int)");
    h <<-3;// v[1]; // -3 Force on
 }
 
 void PlayListWidget::populateSkinsMenu() {
    int item = 0;
    defaultSkinIndex = 0;
    QString skinName;
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options" );
    QString skin = cfg.readEntry( "Skin", "default" );
 
    QDir skinsDir( QPEApplication::qpeDir() + "/pics/opieplayer2/skins" );
    skinsDir.setFilter( QDir::Dirs );
    skinsDir.setSorting(QDir::Name );
    const QFileInfoList *skinslist = skinsDir.entryInfoList();
    QFileInfoListIterator it( *skinslist );
    QFileInfo *fi;
    while ( ( fi = it.current() ) ) {
       skinName =  fi->fileName();
       //        qDebug(  fi->fileName() );
       if( skinName != "." &&  skinName != ".." && skinName !="CVS" )  {
          item = skinsMenu->insertItem( fi->fileName() ) ;
       }
       if( skinName == "default" ) {
          defaultSkinIndex = item;
       }
       if( skinName == skin ) {
          skinsMenu->setItemChecked( item, TRUE );
       }
       ++it;
    }
 }
 
 void PlayListWidget::skinsMenuActivated( int item ) {
    for( int i = defaultSkinIndex; i > defaultSkinIndex - skinsMenu->count(); i-- ) {
       skinsMenu->setItemChecked( i, FALSE );
    }
    skinsMenu->setItemChecked( item, TRUE );
 
    Config cfg( "OpiePlayer" );
    cfg.setGroup("Options");
    cfg.writeEntry("Skin", skinsMenu->text( item ) );
 }
 
 void PlayListWidget::qcopReceive(const QCString &msg, const QByteArray &data) {
    //   qDebug("qcop message "+msg );
    QDataStream stream ( data, IO_ReadOnly );
    if ( msg == "play()" ) { //plays current selection
       btnPlay( true);
    } else if ( msg == "stop()" ) {
       mediaPlayerState->setPlaying( false);
    } else if ( msg == "togglePause()" ) {
       mediaPlayerState->togglePaused();
    } else if ( msg == "next()" ) { //select next in lis
       mediaPlayerState->setNext();      
    } else if ( msg == "prev()" ) { //select previous in list
       mediaPlayerState->setPrev();      
    } else if ( msg == "toggleLooping()" ) { //loop or not loop
       mediaPlayerState->toggleLooping();
    } else if ( msg == "toggleShuffled()" ) { //shuffled or not shuffled
       mediaPlayerState->toggleShuffled();
    } else if ( msg == "volUp()" ) { //volume more
       //       emit moreClicked();
       //       emit moreReleased();
    } else if ( msg == "volDown()" ) { //volume less
       //       emit lessClicked();
       //       emit lessReleased();
    } else if ( msg == "play(QString)" ) { //play this now
       QString file;
       stream >> file;
       setDocumentEx( (const QString &) file);
    } else if ( msg == "add(QString)" ) { //add to playlist
       QString file;
       stream >> file;
       QFileInfo fileInfo(file);
       DocLnk lnk;
       lnk.setName( fileInfo.baseName() ); //sets name
       lnk.setFile( file ); //sets file name
       addToSelection( lnk );
    } else if ( msg == "rem(QString)" ) { //remove from playlist
       QString file;
       stream >> file;
    } else if ( msg == "setDocument(QString)" ) { //loop or not loop
       QCopEnvelope h("QPE/Application/opieplayer", "raise()");
    }
 }
diff --git a/core/pim/addressbook/abeditor.cpp b/core/pim/addressbook/abeditor.cpp
index 91e8722..75e7ede 100644
--- a/core/pim/addressbook/abeditor.cpp
+++ b/core/pim/addressbook/abeditor.cpp
@@ -1,620 +1,619 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qt Palmtop 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 "abeditor.h"
 #include "addresspicker.h"
 
 #include <qpe/categoryselect.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/qpedialog.h>
 
 #include <qcombobox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qmultilineedit.h>
 #include <qscrollview.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qmainwindow.h>
 
 
 static inline bool containsAlphaNum( const QString &str );
 static inline bool constainsWhiteSpace( const QString &str );
 
 
 // helper functions, convert our comma delimited list to proper
 // file format...
 void parseEmailFrom( const QString &txt, QString &strDefaultEmail,
                      QString &strAll );
 
 // helper convert from file format to comma delimited...
 void parseEmailTo( const QString &strDefaultEmail,
                    const QString &strOtherEmail, QString &strBack );
 
 
 
 AbEditor::AbEditor( const OContact &entry, const QValueList<int> *newOrdered,
                     QStringList *slNewOrdered,
                     QWidget *parent = 0, const char *name = 0, WFlags fl = 0 )
     : QDialog( parent, name, TRUE, fl ),
       orderedValues( newOrdered ),
       slOrdered( slNewOrdered )
 {
     init();
     initMap();
     setEntry( entry );
 }
 
 AbEditor::~AbEditor()
 {
 }
 
 void AbEditor::init()
 {
     middleEdit = 0;
     QVBoxLayout *vb = new QVBoxLayout( this );
     svPage = new QScrollView( this );
     svPage->setHScrollBarMode( QScrollView::AlwaysOff );
     vb->addWidget( svPage );
     svPage->setResizePolicy( QScrollView::AutoOneFit );
     svPage->setFrameStyle( QFrame::NoFrame );
 
     QWidget *container = new QWidget( svPage->viewport() );
     svPage->addChild( container );
 
     QGridLayout *gl = new QGridLayout( container, 20, 2, 4, 2 );
 
     QLabel *l = new QLabel( tr("First Name"), container );
     gl->addWidget( l, 0, 0 );
     firstEdit = new QLineEdit( container );
     gl->addWidget( firstEdit, 0, 1 );
 
     l = new QLabel( tr("Last Name"), container );
     gl->addWidget( l, 1, 0 );
     lastEdit = new QLineEdit( container );
     gl->addWidget( lastEdit, 1, 1 );
 
     l = new QLabel( tr("Categories"), container );
     gl->addWidget( l, 2, 0 );
 
     cmbCat = new CategorySelect( container );
     gl->addWidget( cmbCat, 2, 1 );
 
     int i;
     bool foundGender,
         foundNotes;
     foundGender = foundNotes = false;
     QStringList::ConstIterator it = slOrdered->begin();
     for ( i = 0; it != slOrdered->end(); i++, ++it ) {
         if ( !foundGender && *it == tr("Gender") ) {
             foundGender = true;
         } else if ( !foundNotes && *it == tr("Notes") ) {
             foundNotes = true;
         } else {
             l = new QLabel( *it, container );
             listName.append( l );
             gl->addWidget( l, i + 3, 0 );
             QLineEdit *e = new QLineEdit( container );
             listValue.append( e );
             gl->addWidget( e, i + 3, 1 );
             if ( *it == tr( "Middle Name" ) )
                 middleEdit = e;
         }
     }
     l = new QLabel( tr("Gender"), container );
     gl->addWidget( l, slOrdered->count() + 3, 0 );
     genderCombo = new QComboBox( container );
     genderCombo->insertItem( "", 0 );
     genderCombo->insertItem( tr( "Male" ), 1 );
     genderCombo->insertItem( tr( "Female" ), 2 );
     gl->addWidget( genderCombo, slOrdered->count() + 3, 1 );
 
     dlgNote = new QDialog( this, "Note Dialog", TRUE );
     dlgNote->setCaption( tr("Enter Note") );
     QVBoxLayout *vbNote = new QVBoxLayout( dlgNote );
     //    lblNote = new QLabel( dlgNote );
     //    lblNote->setMinimumSize( lblNote->sizeHint() + QSize( 0, 4 ) );
     //    vbNote->addWidget( lblNote );
     txtNote = new QMultiLineEdit( dlgNote );
     vbNote->addWidget( txtNote );
 
     QHBoxLayout *hb = new QHBoxLayout( vb );
     hb->addStretch( 2 );
     QPushButton *pb = new QPushButton( tr("Notes..."), this );
     hb->addWidget( pb );
     connect( pb, SIGNAL(clicked()), this, SLOT(slotNote()) );
 
     new QPEDialogListener(this);
 }
 
 void AbEditor::initMap()
 {
     /*
     // since the fields and the XML fields exist, create a map
     // between them...
     Config cfg1( "AddressBook" );
     Config cfg2( "AddressBook" );
     QString strCfg1,
             strCfg2;
     int i;
 
     // This stuff better exist...
     cfg1.setGroup( "AddressFields" );
     cfg2.setGroup( "XMLFields" );
     i = 0;
     strCfg1 = cfg1.readEntry( "Field" + QString::number(i), QString::null );
     strCfg2 = cfg2.readEntry( "XMLField" + QString::number(i++),
                               QString::null );
     while ( !strCfg1.isNull() && !strCfg2.isNull() ) {
         mapField.insert( strCfg1, strCfg2 );
         strCfg1 = cfg1.readEntry( "Field" + QString::number(i),
                                   QString::null );
         strCfg2 = cfg2.readEntry( "XMLField" + QString::number(i++),
                                   QString::null );
     }
     */
 }
 
 void AbEditor::loadFields()
 {
     QStringList::ConstIterator it;
     QListIterator<QLabel> lit( listName );
     for ( it = slOrdered->begin(); *lit; ++lit, ++it ) {
         (*lit)->setText( *it );
     }
 }
 
 void AbEditor::setEntry( const OContact &entry )
 {
     ent = entry;
     QListIterator<QLineEdit> it( listValue );
     firstEdit->setText( ent.firstName() );
     lastEdit->setText( ent.lastName() );
     cmbCat->setCategories( ent.categories(), "Contacts", tr("Contacts") );
 
     // ### Fix...
     QValueList<int>::ConstIterator itVl;
     for ( itVl = orderedValues->begin(); *it && itVl != orderedValues->end();
           ++itVl, ++it ) {
         switch( *itVl ) {
         case Qtopia::Title:
             (*it)->setText(ent.title());
             break;
         case Qtopia::MiddleName:
             (*it)->setText( ent.middleName() );
             break;
         case Qtopia::Suffix:
             (*it)->setText( ent.suffix() );
             break;
 
             // email
         case Qtopia::DefaultEmail:
         case Qtopia::Emails:
             {
                 QString strDefEmail = ent.defaultEmail();
                 QString strAllEmail = ent.emails();
                 QString strFinal;
                 parseEmailTo( strDefEmail, strAllEmail, strFinal );
                 (*it)->setText( strFinal );
                 // make sure we see the "default"
                 (*it)->home( false );
                 break;
             }
 
             // home
         case Qtopia::HomeStreet:
             (*it)->setText(ent.homeStreet() );
             break;
         case Qtopia::HomeCity:
             (*it)->setText( ent.homeCity() );
             break;
         case Qtopia::HomeState:
             (*it)->setText( ent.homeState() );
             break;
         case Qtopia::HomeZip:
             (*it)->setText( ent.homeZip() );
             break;
         case Qtopia::HomeCountry:
             (*it)->setText( ent.homeCountry() );
             break;
         case Qtopia::HomePhone:
             (*it)->setText( ent.homePhone() );
             break;
         case Qtopia::HomeFax:
             (*it)->setText( ent.homeFax() );
             break;
         case Qtopia::HomeMobile:
             (*it)->setText( ent.homeMobile() );
             break;
         case Qtopia::HomeWebPage:
             (*it)->setText( ent.homeWebpage() );
             break;
 
             // business
         case Qtopia::Company:
             (*it)->setText( ent.company() );
             break;
         case Qtopia::BusinessStreet:
            (*it)->setText( ent.businessStreet() );
             break;
         case Qtopia::BusinessCity:
             (*it)->setText( ent.businessCity() );
             break;
         case Qtopia::BusinessState:
             (*it)->setText( ent.businessState() );
             break;
         case Qtopia::BusinessZip:
             (*it)->setText( ent.businessZip() );
             break;
         case Qtopia::BusinessCountry:
             (*it)->setText( ent.businessCountry() );
             break;
         case Qtopia::BusinessWebPage:
             (*it)->setText( ent.businessWebpage() );
             break;
         case Qtopia::JobTitle:
             (*it)->setText( ent.jobTitle() );
             break;
         case Qtopia::Department:
             (*it)->setText( ent.department() );
             break;
         case Qtopia::Office:
             (*it)->setText( ent.office() );
             break;
         case Qtopia::BusinessPhone:
             (*it)->setText( ent.businessPhone() );
             break;
         case Qtopia::BusinessFax:
             (*it)->setText( ent.businessFax() );
             break;
         case Qtopia::BusinessMobile:
             (*it)->setText( ent.businessMobile() );
             break;
         case Qtopia::BusinessPager:
             (*it)->setText( ent.businessPager() );
             break;
         case Qtopia::Profession:
             (*it)->setText( ent.profession() );
             break;
         case Qtopia::Assistant:
             (*it)->setText( ent.assistant() );
             break;
         case Qtopia::Manager:
             (*it)->setText( ent.manager() );
             break;
 
             // personal
         case Qtopia::Spouse:
             (*it)->setText( ent.spouse() );
             break;
         case Qtopia::Children:
             (*it)->setText( ent.children() );
             break;
         case Qtopia::Birthday:
             (*it)->setText( ent.birthday() );
             break;
         case Qtopia::Anniversary:
             (*it)->setText( ent.anniversary() );
             break;
         case Qtopia::Nickname:
             (*it)->setText( ent.nickname() );
             break;
 
         }
     }
 
     QString gender = ent.gender();
     genderCombo->setCurrentItem( gender.toInt() );
 
     txtNote->setText( ent.notes() );
 }
 
 void AbEditor::accept()
 {
     if ( isEmpty() )
         reject();
     else {
         saveEntry();
         QDialog::accept();
     }
 }
 
 bool AbEditor::isEmpty()
 {
     // analyze all the fields and make sure there is _something_ there
     // that warrants saving...
     QString t = firstEdit->text();
     if ( !t.isEmpty() && containsAlphaNum( t ) )
         return false;
 
     t = lastEdit->text();
     if ( !t.isEmpty() && containsAlphaNum( t ) )
         return false;
 
     QListIterator<QLineEdit> it( listValue );
     for ( ; it.current(); ++it ) {
         t = it.current()->text();
         if ( !t.isEmpty() && containsAlphaNum( t ) )
             return false;
     }
 
     t = txtNote->text();
     if ( !t.isEmpty() && containsAlphaNum( t ) )
         return false;
 
     return true;
 }
 
 void AbEditor::saveEntry()
 {
     QString strDefaultEmail, strOtherEmail;
 
     // determine if there has been a change in names
     if ( ent.firstName() != firstEdit->text() ||
          ent.lastName() != lastEdit->text()
          || (middleEdit && ent.middleName() != middleEdit->text()) ) {
         // set the names
         ent.setFirstName( firstEdit->text() );
         ent.setLastName( lastEdit->text() );
         if ( middleEdit )
             ent.setMiddleName( middleEdit->text() );
         ent.setFileAs();
     }
 
     ent.setCategories( cmbCat->currentCategories() );
 
     QListIterator<QLineEdit> it( listValue );
     int i;
     QValueList<int>::ConstIterator<int> vlIt;
     for ( i = 0, vlIt = orderedValues->begin();
           it.current(); ++it, ++vlIt, i++ ) {
         switch( *vlIt ) {
         case Qtopia::Title:
             ent.setTitle( it.current()->text() );
             break;
         case Qtopia::MiddleName:
             ent.setMiddleName( it.current()->text() );
             break;
         case Qtopia::Suffix:
             ent.setSuffix( it.current()->text() );
             break;
         // case Qtopia::Category:
         //     {
         // //   QStringList slCat = QStringList::split( ";", value );
         // //   QValueList<int> cat;
         // //   for ( QStringList::ConstIterator it = slCat.begin();
         // //         it != slCat.end(); ++it )
         // //       cat.append( (*it).toInt() );
         // //   ent.setCategories( cat );
         //     }
         //     break;
 
             // email
         case Qtopia::DefaultEmail:
         case Qtopia::Emails:
                 parseEmailFrom( it.current()->text(), strDefaultEmail,
                                 strOtherEmail );
                 ent.setDefaultEmail( strDefaultEmail );
                 ent.setEmails( strOtherEmail  );
                 break;
                 
             // home
         case Qtopia::HomeStreet:
             ent.setHomeStreet( it.current()->text() );
             break;
         case Qtopia::HomeCity:
             ent.setHomeCity( it.current()->text() );
             break;
         case Qtopia::HomeState:
             ent.setHomeState( it.current()->text() );
             break;
         case Qtopia::HomeZip:
             ent.setHomeZip( it.current()->text() );
             break;
         case Qtopia::HomeCountry:
             ent.setHomeCountry( it.current()->text() );
             break;
         case Qtopia::HomePhone:
             ent.setHomePhone( it.current()->text() );
             break;
         case Qtopia::HomeFax:
             ent.setHomeFax( it.current()->text() );
             break;
         case Qtopia::HomeMobile:
             ent.setHomeMobile( it.current()->text() );
             break;
         case Qtopia::HomeWebPage:
             ent.setHomeWebpage( it.current()->text() );
             break;
 
             // business
         case Qtopia::Company:
             ent.setCompany( it.current()->text() );
             break;
         case Qtopia::BusinessStreet:
             ent.setBusinessStreet( it.current()->text() );
             break;
         case Qtopia::BusinessCity:
             ent.setBusinessCity( it.current()->text() );
             break;
         case Qtopia::BusinessState:
             ent.setBusinessState( it.current()->text() );
             break;
         case Qtopia::BusinessZip:
             ent.setBusinessZip( it.current()->text() );
             break;
         case Qtopia::BusinessCountry:
             ent.setBusinessCountry( it.current()->text() );
             break;
         case Qtopia::BusinessWebPage:
             ent.setBusinessWebpage( it.current()->text() );
             break;
         case Qtopia::JobTitle:
             ent.setJobTitle( it.current()->text() );
             break;
         case Qtopia::Department:
             ent.setDepartment( it.current()->text() );
             break;
         case Qtopia::Office:
             ent.setOffice( it.current()->text() );
             break;
         case Qtopia::BusinessPhone:
             ent.setBusinessPhone( it.current()->text() );
             break;
         case Qtopia::BusinessFax:
             ent.setBusinessFax( it.current()->text() );
             break;
         case Qtopia::BusinessMobile:
             ent.setBusinessMobile( it.current()->text() );
             break;
         case Qtopia::BusinessPager:
             ent.setBusinessPager( it.current()->text() );
             break;
         case Qtopia::Profession:
             ent.setProfession( it.current()->text() );
             break;
         case Qtopia::Assistant:
             ent.setAssistant( it.current()->text() );
             break;
         case Qtopia::Manager:
             ent.setManager( it.current()->text() );
             break;
 
             // personal
         case Qtopia::Spouse:
             ent.setSpouse( it.current()->text() );
             break;
         case Qtopia::Children:
             ent.setChildren( it.current()->text() );
             break;
         case Qtopia::Birthday:
             ent.setBirthday( it.current()->text() );
             break;
         case Qtopia::Anniversary:
             ent.setAnniversary( it.current()->text() );
             break;
         case Qtopia::Nickname:
             ent.setNickname( it.current()->text() );
             break;
         default:
             break;
 
         }
     }
 
     int gender = genderCombo->currentItem();
     ent.setGender( QString::number( gender ) );
 
     QString str = txtNote->text();
     if ( !str.isNull() )
         ent.setNotes( str );
 }
 
 void AbEditor::slotNote()
 {
-    dlgNote->showMaximized();
-    if ( !dlgNote->exec() ) {
+    if ( ! QPEApplication::execDialog( &dlgNote ) ) {
         // reset the note...
         txtNote->setText( ent.notes() );
     }
 }
 
 void AbEditor::setNameFocus()
 {
     firstEdit->setFocus();
 }
 
 void parseEmailFrom( const QString &txt, QString &strDefaultEmail,
                      QString &strAll )
 {
     int where,
         start;
     if ( txt.isEmpty() )
         return;
 
     // find the first
     where = txt.find( ',' );
     if ( where < 0 ) {
         strDefaultEmail = txt;
         strAll = txt;
     } else {
         strDefaultEmail = txt.left( where ).stripWhiteSpace();
         strAll = strDefaultEmail;
         while ( where > -1 ) {
             strAll.append(" ");
             start = where;
             where = txt.find( ',', where + 1 );
             if ( where > - 1 )
                 strAll.append( txt.mid(start + 1, where - start - 1).stripWhiteSpace() );
             else // grab until the end...
                 strAll.append( txt.right(txt.length() - start - 1).stripWhiteSpace() );
         }
     }
 }
 
 void parseEmailTo( const QString &strDefaultEmail,
                    const QString &strOtherEmail, QString &strBack )
 {
     // create a comma dilimeted set of emails...
     // use the power of short circuiting...
     bool foundDefault = false;
     QString strTmp;
     int start = 0;
     int where;
     // start at the beginng.
     strBack = strDefaultEmail;
     where = 0;
     while ( where > -1 ) {
         start = where;
         where = strOtherEmail.find( ' ', where + 1 );
         if ( where > 0 ) {
             strTmp = strOtherEmail.mid( start, where - start ).stripWhiteSpace();
         } else
             strTmp = strOtherEmail.right( strOtherEmail.length() - start ).stripWhiteSpace();
         if ( foundDefault || strTmp != strDefaultEmail ) {
             strBack.append( ", " );
             strBack.append( strTmp );
         } else
             foundDefault = true;
     }
 }
 
 
 static inline bool containsAlphaNum( const QString &str )
 {
     int i,
         count = str.length();
     for ( i = 0; i < count; i++ )
         if ( !str[i].isSpace() )
             return TRUE;
     return FALSE;
 }
 
 static inline bool constainsWhiteSpace( const QString &str )
 {
     int i,
         count = str.length();
     for (i = 0; i < count; i++ )
         if ( str[i].isSpace() )
             return TRUE;
     return FALSE;
 }
 
diff --git a/core/pim/addressbook/addressbook.cpp b/core/pim/addressbook/addressbook.cpp
index 00cd2a6..1c7ddd4 100644
--- a/core/pim/addressbook/addressbook.cpp
+++ b/core/pim/addressbook/addressbook.cpp
@@ -1,1061 +1,1057 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 ** Copyright (C) 2003 Stefan Eilers (eilers.stefan@epost.de)
 **
 ** This file is part of the Open Palmtop Environment (see www.opie.info).
 **
 ** 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.
 **
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_FD
 
 #include "contacteditor.h"
 #include "ablabel.h"
 #include "abview.h"
 #include "abtable.h"
 // #include "addresssettings.h"
 #include "addressbook.h"
 
 
 #include <opie/ofileselector.h>
 #include <opie/ofiledialog.h>
 #include <opie/ocontact.h>
 #include <opie/ocontactaccessbackend_vcard.h>
 
 #include <qpe/resource.h>
 #include <qpe/ir.h>
 #include <qpe/qpemessagebox.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qtoolbar.h>
 #include <qmenubar.h>
 // #include <qtoolbar.h>
 // #include <qmenubar.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 
 #include <qaction.h>
 #include <qdialog.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qimage.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qpixmap.h>
 #include <qpopupmenu.h>
 #include <qstringlist.h>
 #include <qtoolbutton.h>
 #include <qwhatsthis.h>
 #include <qdatetime.h>
 
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 
 #include "picker.h"
 #include "configdlg.h"
 
 extern QString addressbookPersonalVCardName();
 
 AddressbookWindow::AddressbookWindow( QWidget *parent, const char *name,
                                       WFlags f )
         : QMainWindow( parent, name, f ),
           catMenu (0l),
           abEditor(0l),
           syncing(FALSE),
           m_tableViewButton(0l),
           m_cardViewButton(0l)
 {
         isLoading = true;
 
         m_config.load();
 
         setCaption( tr("Contacts") );
         setIcon( Resource::loadPixmap( "AddressBook" ) );
 
         // Settings for Main Menu
         // setToolBarsMovable( false );
         setToolBarsMovable( !m_config.fixedBars() );
         setRightJustification( true );
 
         QToolBar *bar = new QToolBar( this );
         bar->setHorizontalStretchable( TRUE );
 
         QMenuBar *mbList = new QMenuBar( bar  );
         mbList->setMargin( 0 );
 
         QPopupMenu *edit = new QPopupMenu( mbList );
         mbList->insertItem( tr( "Contact" ), edit );
 
         // Category Menu
         catMenu = new QPopupMenu( this );
         catMenu->setCheckable( TRUE );
         connect( catMenu, SIGNAL(activated(int)), this, SLOT(slotSetCategory(int)) );
         mbList->insertItem( tr("View"), catMenu );
 
         // Create Toolbar
         listTools = new QToolBar( this, "list operations" );
         listTools->setHorizontalStretchable( true );
         addToolBar( listTools );
         moveToolBar( listTools, m_config.getToolBarPos() );
 
         // View Icons
         m_tableViewButton  = new QAction( tr( "List" ), Resource::loadPixmap( "addressbook/listview" ),
                                           QString::null, 0, this, 0 );
         connect( m_tableViewButton, SIGNAL( activated() ), this, SLOT( slotListView() ) );
         m_tableViewButton->setToggleAction( true );
         m_tableViewButton->addTo( listTools );
         m_cardViewButton = new QAction( tr( "Card" ), Resource::loadPixmap( "addressbook/cardview" ),  QString::null, 0, this, 0 );
         connect( m_cardViewButton, SIGNAL( activated() ), this, SLOT( slotCardView() ) );
         m_cardViewButton->setToggleAction( true );
         m_cardViewButton->addTo( listTools );
 
         listTools->addSeparator();
 
         // Other Buttons
         QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null,
                                   0, this, 0 );
         actionNew = a;
         connect( a, SIGNAL( activated() ), this, SLOT( slotListNew() ) );
         a->addTo( edit );
         a->addTo( listTools );
 
         a = new QAction( tr( "Edit" ), Resource::loadPixmap( "edit" ), QString::null,
                          0, this, 0 );
         actionEdit = a;
         connect( a, SIGNAL( activated() ), this, SLOT( slotViewEdit() ) );
         a->addTo( edit );
         a->addTo( listTools );
 
         a = new QAction( tr( "Delete" ), Resource::loadPixmap( "trash" ), QString::null,
                          0, this, 0 );
         actionTrash = a;
         connect( a, SIGNAL( activated() ), this, SLOT( slotListDelete() ) );
         a->addTo( edit );
         a->addTo( listTools );
 
 
         // make it possible to go directly to businesscard via qcop call
         //#if defined(Q_WS_QWS) // Why this ? (se)
 #if !defined(QT_NO_COP)
         QCopChannel *addressChannel = new QCopChannel("QPE/Addressbook" , this );
         connect (addressChannel, SIGNAL( received(const QCString &, const QByteArray &)),
                  this, SLOT ( appMessage(const QCString &, const QByteArray &) ) );
 #endif
         // #endif
         a = new QAction( tr( "Find" ), Resource::loadPixmap( "mag" ),
                          QString::null, 0, this, 0 );
         actionFind = a;
         connect( a, SIGNAL(activated()), this, SLOT( slotFindOpen()) );
         a->addTo( edit );
         a->addTo( listTools );
 
         // Much better search widget, taken from QTReader.. (se)
         searchBar = new OFloatBar( "Search", this, QMainWindow::Top, TRUE );
         searchBar->setHorizontalStretchable( TRUE );
         searchBar->hide();
         searchEdit = new QLineEdit( searchBar, "searchEdit" );
 
         // QFont f("unifont", 16 /*, QFont::Bold*/);
         // searchEdit->setFont( f );
 
         searchBar->setStretchableWidget( searchEdit );
         connect( searchEdit, SIGNAL( returnPressed( ) ),
                  this, SLOT( slotFind( ) ) );
 
         a = new QAction( tr( "Start Search" ), Resource::loadPixmap( "enter" ), QString::null, 0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotFind() ) );
         a->addTo( searchBar );
 
         a = new QAction( tr( "Close Find" ), Resource::loadPixmap( "close" ), QString::null, 0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotFindClose() ) );
         a->addTo( searchBar );
 
         a = new QAction( tr( "Write Mail To" ), Resource::loadPixmap( "addressbook/sendmail" ),
                          QString::null, 0, this, 0 );
         //a->setEnabled( FALSE ); we got support for it now :) zecke
         actionMail = a;
         connect( a, SIGNAL( activated() ), this, SLOT( writeMail() ) );
         a->addTo( edit );
         a->addTo( listTools );
 
         if ( Ir::supported() ) {
                 a = new QAction( tr ("Beam Entry" ), Resource::loadPixmap( "beam" ), QString::null,
                                  0, this, 0 );
                 actionBeam = a;
                 connect( a, SIGNAL( activated() ), this, SLOT( slotBeam() ) );
                 a->addTo( edit );
                 a->addTo( listTools );
         }
 
         edit->insertSeparator();
 
         a = new QAction( tr("Import vCard"), Resource::loadPixmap( "addressbook/fileimport"), QString::null,
                                                                    0, this, 0);
         actionPersonal = a;
         connect( a, SIGNAL( activated() ), this, SLOT( importvCard() ) );
         a->addTo( edit );
 
         a = new QAction( tr("Export vCard"), Resource::loadPixmap( "addressbook/fileexport"), QString::null,
                                                                    0, this, 0);
         actionPersonal = a;
         connect( a, SIGNAL( activated() ), this, SLOT( exportvCard() ) );
         a->addTo( edit );
 
         edit->insertSeparator();
 
         a = new QAction( tr("My Personal Details"), Resource::loadPixmap( "addressbook/identity" ),
                          QString::null, 0, this, 0 , TRUE );
         actionPersonal = a;
         connect( a, SIGNAL( activated() ), this, SLOT( slotPersonalView() ) );
         a->addTo( edit );
 
 
 #ifdef __DEBUG_RELEASE
         // Remove this function for public Release ! This is only
         // for debug purposes ..
         a = new QAction( tr( "Save all Data"), QString::null, 0, 0 );
         connect( a, SIGNAL( activated() ), this , SLOT( slotSave() ) );
         a->addTo( edit );
 #endif
         a = new QAction( tr( "Config" ), Resource::loadPixmap( "SettingsIcon" ), QString::null,
                          0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotConfig() ) );
         a->addTo( edit );
 
         // Create Views
         listContainer = new QWidget( this );
         QVBoxLayout *vb = new QVBoxLayout( listContainer );
 
          m_abView = new AbView( listContainer, m_config.orderList() );
          vb->addWidget( m_abView );
         // abList->setHScrollBarMode( QScrollView::AlwaysOff );
         connect( m_abView, SIGNAL( signalViewSwitched ( int ) ),
                  this, SLOT( slotViewSwitched( int ) ) );
 
 
         QObject::connect( m_abView, SIGNAL(signalNotFound()), this, SLOT(slotNotFound()) );
 
         // m_abView->load(); // Already done by c'tor .
 
         // Letter Picker
         pLabel = new LetterPicker( listContainer );
         connect(pLabel, SIGNAL(letterClicked(char)), this, SLOT(slotSetLetter(char)));
         connect(m_abView, SIGNAL( signalClearLetterPicker() ), pLabel, SLOT( clear() ) );
 
         vb->addWidget( pLabel );
 
         // All Categories into view-menu..
         populateCategories();
 
         // Fontsize
         defaultFont = new QFont( m_abView->font() );
          slotSetFont(m_config.fontSize());
         m_curFontSize = m_config.fontSize();
 
         setCentralWidget(listContainer);
 
         //    qDebug("adressbook contrsuction: t=%d", t.elapsed() );
         connect( qApp, SIGNAL( flush() ), this, SLOT( flush() ) );
         connect( qApp, SIGNAL( reload() ), this, SLOT( reload() ) );
         connect( qApp, SIGNAL( appMessage(const QCString &, const QByteArray &) ),
         this, SLOT( appMessage(const QCString &, const QByteArray &) ) );
 
 
         isLoading = false;
 }
 
 
 void AddressbookWindow::slotConfig()
 {
         ConfigDlg* dlg = new ConfigDlg( this, "Config" );
         dlg -> setConfig( m_config );
-        dlg -> showMaximized();
-        if ( dlg -> exec() ) {
+        if ( QPEApplication::execDialog( dlg ) ) {
                 qWarning ("Config Dialog accepted!");
                 m_config = dlg -> getConfig();
                 if ( m_curFontSize != m_config.fontSize() ){
                         qWarning("Font was changed!");
                         m_curFontSize = m_config.fontSize();
                         emit slotSetFont( m_curFontSize );
                 }
                 m_abView -> setListOrder( m_config.orderList() );
         }
 
         delete dlg;
 }
 
 
 void AddressbookWindow::slotSetFont( int size )
 {
         qWarning("void AddressbookWindow::slotSetFont( %d )", size);
 
         if (size > 2 || size < 0)
                 size = 1;
 
         m_config.setFontSize( size );
 
         QFont *currentFont;
 
         switch (size) {
         case 0:
                 m_abView->setFont( QFont( defaultFont->family(), defaultFont->pointSize() - 2 ) );
                 currentFont = new QFont (m_abView->font());
                 // abList->resizeRows(currentFont->pixelSize() + 7); :SX
                 // abList->resizeRows();
                 break;
         case 1:
                 m_abView->setFont( *defaultFont );
                 currentFont = new QFont (m_abView->font());
         //      // abList->resizeRows(currentFont->pixelSize() + 7);
         //      abList->resizeRows();
                 break;
         case 2:
                 m_abView->setFont( QFont( defaultFont->family(), defaultFont->pointSize() + 2 ) );
                 currentFont = new QFont (m_abView->font());
         //      //abList->resizeRows(currentFont->pixelSize() + 7);
         //      abList->resizeRows();
                 break;
         }
 }
 
 
 
 void AddressbookWindow::importvCard() {
         QString str = OFileDialog::getOpenFileName( 1,"/");//,"", "*", this );
         if(!str.isEmpty() ){
                 setDocument((const QString&) str );
         }
 
 }
 void AddressbookWindow::exportvCard()
 {
         qWarning(" void AddressbookWindow::exportvCard()");
         QString filename = OFileDialog::getSaveFileName( 1,"/home/"); //,"", "*", this );
         if( !filename.isEmpty() &&  ( filename[filename.length()-1] != '/' ) ){
                 qWarning(" Save to file %s, (%d)", filename.latin1(), filename.length()-1 );
                 OContact curCont = m_abView->currentEntry();
                 if ( !curCont.isEmpty() ){
                         OContactAccessBackend* vcard_backend = new OContactAccessBackend_VCard( QString::null,
                                                                                                 filename );
                         OContactAccess* access = new OContactAccess ( "addressbook_exp", QString::null , vcard_backend, true );
                         if ( access ){
                                 access->add( curCont );
                                 access->save();
                         }
                         delete access;
                 }else
                         QMessageBox::critical( 0, "Export VCard",
                            QString( tr( "You have to select a contact !") ) );
 
         }else
                 QMessageBox::critical( 0, "Export VCard",
                                        QString( tr( "You have to set a filename !") ) );
 }
 
 void AddressbookWindow::setDocument( const QString &filename )
 {
         qWarning( "void AddressbookWindow::setDocument( %s )", filename.latin1() );
 
         if ( filename.find(".vcf") != int(filename.length()) - 4 ){
 
 
 
                 switch( QMessageBox::information( this, tr ( "Right file type ?" ),
                                                   tr( "The selected file \n does not end with \".vcf\".\n Do you really want to open it?" ),
                                                   tr( "&Yes" ), tr( "&No" ), QString::null,
                                                   0,      // Enter == button 0
                                                   2 ) ) { // Escape == button 2
                 case 0:
                         qWarning("YES clicked");
                         break;
                 case 1:
                         qWarning("NO clicked");
                         return;
                         break;
                 }
         }
 
         OContactAccessBackend* vcard_backend = new OContactAccessBackend_VCard( QString::null,
                                                                          filename );
         OContactAccess* access = new OContactAccess ( "addressbook", QString::null , vcard_backend, true );
         OContactAccess::List allList = access->allRecords();
         qWarning( "Found number of contacts in File: %d", allList.count() );
 
         if ( !allList.count() ) {
                 QMessageBox::information( this, "Import VCard",
                                           "It was impossible to import\nthe VCard.\n"
                                           "The VCard may be corrupted!" );
         }
 
         bool doAsk = true;
         OContactAccess::List::Iterator it;
         for ( it = allList.begin(); it != allList.end(); ++it ){
                 qWarning("Adding Contact from: %s", (*it).fullName().latin1() );
                 if ( doAsk ){
                         switch( QMessageBox::information( this, tr ( "Add Contact?" ),
                                                           tr( "Do you really want add contact for \n%1?" )
                                                           .arg( (*it).fullName().latin1() ),
                                                           tr( "&Yes" ), tr( "&No" ), tr( "&All Yes"),
                                                           0,      // Enter == button 0
                                                           2 ) ) { // Escape == button 2
                         case 0:
                                 qWarning("YES clicked");
                                 m_abView->addEntry( *it );
                                 break;
                         case 1:
                                 qWarning("NO clicked");
                                 break;
                         case 2:
                                 qWarning("YesAll clicked");
                                 doAsk = false;
                                 break;
                         }
                 }else
                         m_abView->addEntry( *it );
 
         }
 
         delete access;
 }
 
 void AddressbookWindow::resizeEvent( QResizeEvent *e )
 {
         QMainWindow::resizeEvent( e );
 
 
 }
 
 AddressbookWindow::~AddressbookWindow()
 {
         ToolBarDock dock;
         int dummy;
         bool bDummy;
         getLocation ( listTools, dock, dummy, bDummy, dummy );
         m_config.setToolBarDock( dock );
         m_config.save();
 }
 
 void AddressbookWindow::slotUpdateToolbar()
 {
          OContact ce = m_abView->currentEntry();
         actionMail->setEnabled( !ce.defaultEmail().isEmpty() );
 }
 
 void AddressbookWindow::slotListNew()
 {
         OContact cnt;
         if( !syncing ) {
                 editEntry( NewEntry );
         } else {
                 QMessageBox::warning(this, tr("Contacts"),
                                      tr("Can not edit data, currently syncing"));
         }
 }
 
 // void AddressbookWindow::slotListView()
 // {
         // m_abView -> init( abList->currentEntry() );
         // // :SX mView->sync();
         //      //:SXshowView();
 // }
 
 void AddressbookWindow::slotListDelete()
 {
         if(!syncing) {
                 OContact tmpEntry = m_abView ->currentEntry();
 
                 // get a name, do the best we can...
                 QString strName = tmpEntry.fullName();
                 if ( strName.isEmpty() ) {
                         strName = tmpEntry.company();
                         if ( strName.isEmpty() )
                                 strName = "No Name";
                 }
 
 
                 if ( QPEMessageBox::confirmDelete( this, tr( "Contacts" ),
                                                    strName ) ) {
                         m_abView->removeEntry( tmpEntry.uid() );
                 }
         } else {
                 QMessageBox::warning( this, tr("Contacts"),
                                       tr("Can not edit data, currently syncing") );
         }
 }
 
 void AddressbookWindow::slotFindOpen()
 {
         searchBar->show();
         m_abView -> inSearch();
         searchEdit->setFocus();
 }
 void AddressbookWindow::slotFindClose()
 {
         searchBar->hide();
         m_abView -> offSearch();
         // m_abView->setFocus();
 }
 
 
 void AddressbookWindow::slotFind()
 {
         m_abView->slotDoFind( searchEdit->text(), m_config.beCaseSensitive(), m_config.useRegExp(), false);
 
         searchEdit->clearFocus();
         // m_abView->setFocus();
 
 }
 
 void AddressbookWindow::slotViewBack()
 {
         // :SX showList();
 }
 
 void AddressbookWindow::slotViewEdit()
 {
         if(!syncing) {
                 if (actionPersonal->isOn()) {
                         editPersonal();
                 } else {
                         editEntry( EditEntry );
                 }
         } else {
                 QMessageBox::warning( this, tr("Contacts"),
                                       tr("Can not edit data, currently syncing") );
         }
 }
 
 
 
 void AddressbookWindow::writeMail()
 {
         OContact c = m_abView -> currentEntry();
         QString name = c.fileAs();
         QString email = c.defaultEmail();
 
         // I prefer the OPIE-Environment variable before the
         // QPE-one..
         QString basepath = QString::fromLatin1( getenv("OPIEDIR") );
         if ( basepath.isEmpty() )
                 basepath = QString::fromLatin1( getenv("QPEDIR") );
 
         // Try to access the preferred. If not possible, try to
         // switch to the other one..
         if ( m_config.useQtMail() ){
                 qWarning ("Accessing: %s", (basepath + "/bin/qtmail").latin1());
                 if ( QFile::exists( basepath + "/bin/qtmail" ) ){
                         qWarning ("QCop");
                         QCopEnvelope e("QPE/Application/qtmail", "writeMail(QString,QString)");
                         e << name << email;
                         return;
                 } else
                         m_config.setUseOpieMail( true );
         }
         if ( m_config.useOpieMail() ){
                 qWarning ("Accessing: %s", (basepath + "/bin/opiemail").latin1());
                 if ( QFile::exists( basepath + "/bin/opiemail" ) ){
                         qWarning ("QCop");
                         QCopEnvelope e("QPE/Application/opiemail", "writeMail(QString,QString)");
                         e << name << email;
                         return;
                 } else
                         m_config.setUseQtMail( true );
         }
 
 }
 
 static const char * beamfile = "/tmp/obex/contact.vcf";
 
 void AddressbookWindow::slotBeam()
 {
         QString beamFilename;
         OContact c;
         if ( actionPersonal->isOn() ) {
                 beamFilename = addressbookPersonalVCardName();
                 if ( !QFile::exists( beamFilename ) )
                         return; // can't beam a non-existent file
                 OContactAccessBackend* vcard_backend = new OContactAccessBackend_VCard( QString::null,
                                                                                         beamFilename );
                 OContactAccess* access = new OContactAccess ( "addressbook", QString::null , vcard_backend, true );
                 OContactAccess::List allList = access->allRecords();
                 OContactAccess::List::Iterator it = allList.begin();  // Just take first
                 c = *it;
 
                 delete access;
         } else {
                 unlink( beamfile ); // delete if exists
                 mkdir("/tmp/obex/", 0755);
                 c = m_abView -> currentEntry();
                 OContactAccessBackend* vcard_backend = new OContactAccessBackend_VCard( QString::null,
                                                                                         beamfile );
                 OContactAccess* access = new OContactAccess ( "addressbook", QString::null , vcard_backend, true );
                 access->add( c );
                 access->save();
                 delete access;
 
                 beamFilename = beamfile;
         }
 
         qWarning("Beaming: %s", beamFilename.latin1() );
 
         Ir *ir = new Ir( this );
         connect( ir, SIGNAL( done( Ir * ) ), this, SLOT( beamDone( Ir * ) ) );
         QString description = c.fullName();
         ir->send( beamFilename, description, "text/x-vCard" );
 }
 
 void AddressbookWindow::beamDone( Ir *ir )
 {
 
         delete ir;
         unlink( beamfile );
 }
 
 
 static void parseName( const QString& name, QString *first, QString *middle,
                        QString * last )
 {
 
         int comma = name.find ( "," );
         QString rest;
         if ( comma > 0 ) {
                 *last = name.left( comma );
                 comma++;
                 while ( comma < int(name.length()) && name[comma] == ' ' )
                         comma++;
                 rest = name.mid( comma );
         } else {
                 int space = name.findRev( ' ' );
                 *last = name.mid( space+1 );
                 rest = name.left( space );
         }
         int space = rest.find( ' ' );
         if ( space <= 0 ) {
                 *first = rest;
         } else {
                 *first = rest.left( space );
                 *middle = rest.mid( space+1 );
         }
 
 }
 
 
 void AddressbookWindow::appMessage(const QCString &msg, const QByteArray &data)
 {
         bool needShow = FALSE;
         qWarning("Receiving QCop-Call with message %s", QString( msg ).latin1() );
 
 
         if (msg == "editPersonal()") {
                 editPersonal();
         } else if (msg == "editPersonalAndClose()") {
                 editPersonal();
                 close();
         } else if ( msg == "addContact(QString,QString)" ) {
                 QDataStream stream(data,IO_ReadOnly);
                 QString name, email;
                 stream >> name >> email;
 
                 OContact cnt;
                 QString fn, mn, ln;
                 parseName( name, &fn, &mn, &ln );
                 //  qDebug( " %s - %s - %s", fn.latin1(), mn.latin1(), ln.latin1() );
                 cnt.setFirstName( fn );
                 cnt.setMiddleName( mn );
                 cnt.setLastName( ln );
                 cnt.insertEmails( email );
                 cnt.setDefaultEmail( email );
                 cnt.setFileAs();
 
                 m_abView -> addEntry( cnt );
 
                 // :SXm_abView()->init( cnt );
                 editEntry( EditEntry );
         } else if ( msg == "beamBusinessCard()" ) {
                 QString beamFilename = addressbookPersonalVCardName();
                 if ( !QFile::exists( beamFilename ) )
                         return; // can't beam a non-existent file
 
                 Ir *ir = new Ir( this );
                 connect( ir, SIGNAL( done( Ir * ) ), this, SLOT( beamDone( Ir * ) ) );
                 QString description = "mycard.vcf";
                 ir->send( beamFilename, description, "text/x-vCard" );
         } else if ( msg == "show(int)" ) {
                 raise();
                 QDataStream stream(data,IO_ReadOnly);
                 int uid;
                 stream >> uid;
 
                 qWarning( "Showing uid: %d" , uid );
 
                 // Deactivate Personal View..
                 if ( actionPersonal->isOn() ){
                         actionPersonal->setOn( false );
                         slotPersonalView();
                 }
 
                 // Reset category and show as card..
                 m_abView -> setShowByCategory( QString::null );
                 m_abView -> setCurrentUid( uid );
                 slotViewSwitched ( AbView::CardView );
 
                 needShow = true;
 
 
         } else if ( msg == "edit(int)" ) {
                 QDataStream stream(data,IO_ReadOnly);
                 int uid;
                 stream >> uid;
 
                 // Deactivate Personal View..
                 if ( actionPersonal->isOn() ){
                         actionPersonal->setOn( false );
                         slotPersonalView();
                 }
 
                 // Reset category and edit..
                 m_abView -> setShowByCategory( QString::null );
                 m_abView -> setCurrentUid( uid );
                 slotViewEdit();
         }
 
         if (needShow)
             QPEApplication::setKeepRunning();
 
 }
 
 void AddressbookWindow::editEntry( EntryMode entryMode )
 {
         OContact entry;
         if ( !abEditor ) {
                 abEditor = new ContactEditor( entry, this, "editor" );
         }
         if ( entryMode == EditEntry )
                 abEditor->setEntry( m_abView -> currentEntry() );
         else if ( entryMode == NewEntry )
                 abEditor->setEntry( entry );
         // other things may change the caption.
         abEditor->setCaption( tr("Edit Address") );
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-        abEditor->showMaximized();
-#endif
         // fix the foxus...
         abEditor->setNameFocus();
-        if ( abEditor->exec() ) {
+        if ( QPEApplication::execDialog( abEditor ) ) {
                 setFocus();
                 if ( entryMode == NewEntry ) {
                         OContact insertEntry = abEditor->entry();
                         insertEntry.assignUid();
                         m_abView -> addEntry( insertEntry );
                         m_abView -> setCurrentUid( insertEntry.uid() );
                 } else {
                         OContact replEntry = abEditor->entry();
 
                         if ( !replEntry.isValidUid() )
                                 replEntry.assignUid();
 
                         m_abView -> replaceEntry( replEntry );
                 }
         }
         // populateCategories();
 
 }
 
 void AddressbookWindow::editPersonal()
 {
         OContact entry;
 
         // Switch to personal view if not selected
         // but take care of the menu, too
         if ( ! actionPersonal->isOn() ){
                 qWarning("*** ++++");
                 actionPersonal->setOn( true );
                 slotPersonalView();
         }
 
         if ( !abEditor ) {
                 abEditor = new ContactEditor( entry, this, "editor" );
         }
 
          abEditor->setCaption(tr("Edit My Personal Details"));
          abEditor->setPersonalView( true );
         editEntry( EditEntry );
          abEditor->setPersonalView( false );
 
 }
 
 
 void AddressbookWindow::slotPersonalView()
 {
         qWarning("slotPersonalView()");
         if (!actionPersonal->isOn()) {
                 // we just turned it off
                 qWarning("slotPersonalView()-> OFF");
                 setCaption( tr("Contacts") );
                 actionNew->setEnabled(TRUE);
                 actionTrash->setEnabled(TRUE);
                 actionFind->setEnabled(TRUE);
                 actionMail->setEnabled(TRUE);
                 // slotUpdateToolbar();
 
                 m_abView->showPersonal( false );
 
                 return;
         }
 
         qWarning("slotPersonalView()-> ON");
         // XXX need to disable some QActions.
         actionNew->setEnabled(FALSE);
         actionTrash->setEnabled(FALSE);
         actionFind->setEnabled(FALSE);
         actionMail->setEnabled(FALSE);
 
         setCaption( tr("Contacts - My Personal Details") );
 
         m_abView->showPersonal( true );
 
 }
 
 
 void AddressbookWindow::listIsEmpty( bool empty )
 {
         if ( !empty ) {
                 deleteButton->setEnabled( TRUE );
         }
 }
 
 void AddressbookWindow::reload()
 {
         syncing = FALSE;
         m_abView->clear();
         m_abView->reload();
 }
 
 void AddressbookWindow::flush()
 {
         syncing = TRUE;
         m_abView->save();
 }
 
 
 void AddressbookWindow::closeEvent( QCloseEvent *e )
 {
         if(active_view == AbView::CardView){
           slotViewSwitched( AbView::TableView );
           e->ignore();
           return;
         }
         if(syncing) {
                 /* shouldn't we save, I hear you say? well its already been set
                    so that an edit can not occur during a sync, and we flushed
                    at the start of the sync, so there is no need to save
                    Saving however itself would cause problems. */
                 e->accept();
                 return;
         }
         //################## shouldn't always save
         // True, but the database handles this automatically ! (se)
         if ( save() )
                 e->accept();
         else
                 e->ignore();
 }
 
 /*
   Returns TRUE if it is OK to exit
 */
 
 bool AddressbookWindow::save()
 {
         if ( !m_abView->save() ) {
                 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 )
                         return TRUE;
                 else
                         return FALSE;
         }
         return TRUE;
 }
 
 #ifdef __DEBUG_RELEASE
 void AddressbookWindow::slotSave()
 {
         save();
 }
 #endif
 
 
 void AddressbookWindow::slotNotFound()
 {
         qWarning("Got notfound signal!");
         QMessageBox::information( this, tr( "Not Found" ),
                                  "<qt>" + tr( "Unable to find a contact for this search pattern!" ) + "</qt>" );
 
 
 }
 void AddressbookWindow::slotWrapAround()
 {
         qWarning("Got wrap signal!");
         // if ( doNotifyWrapAround )
         //      QMessageBox::information( this, tr( "End of list" ),
         //                                tr( "End of list. Wrap around now...!" ) + "\n" );
 
 }
 
 void AddressbookWindow::slotSetCategory( int c )
 {
         qWarning( "void AddressbookWindow::slotSetCategory( %d ) from %d", c, catMenu->count() );
 
         QString cat, book;
         AbView::Views  view = AbView::TableView;
 
         if ( c <= 0 )
                 return;
 
         // Switch view
         if ( c < 3 )
                 for ( unsigned int i = 1; i < 3; i++ ){
                         if ( catMenu )
                                 catMenu->setItemChecked( i, c == (int)i );
                 }
         else
          // Checkmark Category Menu Item Selected
                 for ( unsigned int i = 3; i < catMenu->count(); i++ )
                         catMenu->setItemChecked( i, c == (int)i );
 
         // Now switch to the selected category
         for ( unsigned int i = 1; i < catMenu->count(); i++ ) {
                 if (catMenu->isItemChecked( i )) {
                         if ( i == 1 ){ // default List view
                                 book = QString::null;
                                 view = AbView::TableView;
                         }else if ( i == 2 ){
                                 book = tr( "Cards" );
                                 view = AbView::CardView;
         //              }else if ( i == 3 ){
         //                      book = tr( "Personal" );
         //                      view = AbView:: PersonalView;
                         }else if ( i == 3 ){ // default All Categories
                                 cat = QString::null;
                         }else if ( i == (unsigned int)catMenu->count() - 1 ){ // last menu option (seperator is counted, too) will be Unfiled
                                 cat = "Unfiled";
                                 qWarning ("Unfiled selected!");
                         }else{
                                 cat = m_abView->categories()[i - 4];
                         }
                 }
         }
 
         // Switch to the selected View
         slotViewSwitched( view );
 
         // Tell the view about the selected category
         m_abView -> setShowByCategory( cat );
 
         if ( book.isEmpty() )
                 book = "List";
         if ( cat.isEmpty() )
                 cat = "All";
 
         setCaption( tr( "Contacts" ) + " - " + book + " - " + tr( cat ) );
 }
 
 void AddressbookWindow::slotViewSwitched( int view )
 {
         qWarning( "void AddressbookWindow::slotViewSwitched( %d )", view );
         int menu = 0;
 
         // Switch to selected view
         switch ( view ){
         case AbView::TableView:
                 menu = 1;
                 m_tableViewButton->setOn(true);
                 m_cardViewButton->setOn(false);
                 break;
         case AbView::CardView:
                 menu = 2;
                 m_tableViewButton->setOn(false);
                 m_cardViewButton->setOn(true);
                 break;
         }
         for ( unsigned int i = 1; i < 3; i++ ){
                 if ( catMenu )
                         catMenu->setItemChecked( i, menu == (int)i );
         }
 
         // Tell the view about the selected view
         m_abView -> setShowToView ( (AbView::Views) view );
         active_view = view;
 }
 
 
 void AddressbookWindow::slotListView()
 {
         slotViewSwitched( AbView::TableView );
 }
 
 void AddressbookWindow::slotCardView()
 {
         slotViewSwitched( AbView::CardView );
 }
 
 void AddressbookWindow::slotSetLetter( char c ) {
 
          m_abView->setShowByLetter( c, m_config.letterPickerSearch() );
 
 }
 
 
 void AddressbookWindow::populateCategories()
 {
         catMenu->clear();
 
         int id, rememberId;
         id = 1;
         rememberId = 0;
 
         catMenu->insertItem( Resource::loadPixmap( "addressbook/listview" ), tr( "List" ), id++ );
         catMenu->insertItem( Resource::loadPixmap( "addressbook/cardview" ), tr( "Cards" ), id++ );
         // catMenu->insertItem( tr( "Personal" ), id++ );
         catMenu->insertSeparator();
 
         catMenu->insertItem( tr( "All" ), id++ );
         QStringList categories = m_abView->categories();
         categories.append( tr( "Unfiled" ) );
         for ( QStringList::Iterator it = categories.begin();
               it != categories.end(); ++it ) {
                 catMenu->insertItem( *it, id );
                 if ( *it == m_abView -> showCategory() )
                         rememberId = id;
                 ++id;
         }
 
 
         if ( m_abView -> showCategory().isEmpty() ) {
                 slotSetCategory( 3 );
         }
         else {
                 slotSetCategory( rememberId );
         }
 }
 
diff --git a/core/pim/addressbook/contacteditor.cpp b/core/pim/addressbook/contacteditor.cpp
index 8fbd065..7932781 100644
--- a/core/pim/addressbook/contacteditor.cpp
+++ b/core/pim/addressbook/contacteditor.cpp
@@ -1,1759 +1,1757 @@
 /*
  * Copyright (c) 2002 Michael R. Crawford <mike@tuxnami.org>
  * Copyright (C) 2002 by Stefan Eilers (eilers.stefan@epost.de)
  *
  * This file is an add-on for the OPIE Palmtop 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 pacakaging
  * 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.
  *
  *
  * This is a rewrite of the abeditor.h file, modified to provide a more
  * intuitive interface to TrollTech's original Address Book editor.  This
  * is made to operate exactly in interface with the exception of name.
  *
  */
 
 #include "contacteditor.h"
 #include "addresspicker.h"
 
 #include <qpe/categoryselect.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/qpedialog.h>
 #include <qpe/timeconversion.h>
 #include <opie/ocontact.h>
 #include <qpe/resource.h>
 
 #include <qcombobox.h>
 #include <qlabel.h>
 #include <qtabwidget.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qmultilineedit.h>
 #include <qscrollview.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qmainwindow.h>
 #include <qvaluelist.h>
 #include <qpopupmenu.h> 
 #include <qlistbox.h> 
 #include <qhbox.h>
 #include <qaction.h>
 #include <qiconset.h> 
 #include <qmessagebox.h> 
 #include <qwhatsthis.h>
 
 #include <assert.h>
 
 static inline bool containsAlphaNum( const QString &str );
 static inline bool constainsWhiteSpace( const QString &str );
 
 // helper functions, convert our comma delimited list to proper
 // file format...
 void parseEmailFrom( const QString &txt, QString &strDefaultEmail,
                      QString &strAll );
 
 // helper convert from file format to comma delimited...
 void parseEmailTo( const QString &strDefaultEmail,
                    const QString &strOtherEmail, QString &strBack );
 
         ContactEditor::ContactEditor(const OContact &entry,
                                 QWidget *parent,
                                 const char *name,
                                 WFlags )
         : QDialog( parent, name, TRUE, WStyle_ContextHelp ),
           defaultEmailChooserPosition( -1 ),
           m_personalView ( false ),
           cmbDefaultEmail( 0 ),
           initializing ( false )
 {
 
         initializing = true;
 
         init();
         setEntry( entry );
         // cmbDefaultEmail = 0;
         // defaultEmailChooserPosition = -1;
 
         initializing = false;
 }
 
 ContactEditor::~ContactEditor() {
 }
 
 void ContactEditor::init() {
         qWarning("init() START");
         
         uint i = 0;
 
         QStringList trlChooserNames;
 
         for (i = 0; i <= 6; i++) {
                 slHomeAddress.append( "" );
                 slBusinessAddress.append( "" );
         }
 
         trlChooserNames   = OContactFields::trphonefields( false );
         slChooserNames    = OContactFields::untrphonefields( false );
         slDynamicEntries  = OContactFields::untrdetailsfields( false );
         trlDynamicEntries = OContactFields::trdetailsfields( false );
 
         // Ok, we have to remove elements from the list of dynamic entries
         // which are now stored in special (not dynamic) widgets..
         // Otherwise we will get problems with field assignments! (se)
         slDynamicEntries.remove("Anniversary");
         slDynamicEntries.remove("Birthday");
         slDynamicEntries.remove("Gender");
 
         // The same with translated fields.. But I will
         // use the translation map to avoid mismatches..
         QMap<int, QString> translMap = OContactFields::idToTrFields();
         trlDynamicEntries.remove( translMap[Qtopia::Anniversary] );
         trlDynamicEntries.remove( translMap[Qtopia::Birthday] );
         trlDynamicEntries.remove( translMap[Qtopia::Gender] );
 
         // Last Check to be sure..
         assert( slDynamicEntries.count() == trlDynamicEntries.count() );
         assert( slChooserNames.count() == trlChooserNames.count() );
 
         for (i = 0; i < slChooserNames.count(); i++)
           slChooserValues.append("");
 
 
         QVBoxLayout *vb = new QVBoxLayout( this );
 
         tabMain = new QTabWidget( this );
         vb->addWidget( tabMain );
 
         QWidget *tabViewport = new QWidget ( tabMain );
 
         vb = new QVBoxLayout( tabViewport );
 
         svGeneral = new QScrollView( tabViewport );
         vb->addWidget( svGeneral, 0, 0 );
         svGeneral->setResizePolicy( QScrollView::AutoOneFit );
         // svGeneral->setHScrollBarMode( QScrollView::AlwaysOff );
         // svGeneral->setVScrollBarMode( QScrollView::AlwaysOff );
         svGeneral->setFrameStyle( QFrame::NoFrame );
 
         QWidget *container = new QWidget( svGeneral->viewport() );
         svGeneral->addChild( container );
 
         QGridLayout *gl = new QGridLayout( container, 1, 1, 2, 4 );
         gl->setResizeMode( QLayout::FreeResize );
 
         btnFullName = new QPushButton( tr( "Full Name..." ), container );
         QWhatsThis::add( btnFullName, tr( "Press to enter last- middle and firstname" ) );
         gl->addWidget( btnFullName, 0, 0 );
         txtFullName = new QLineEdit( container );
         QWhatsThis::add( txtFullName, tr( "Enter fullname directly ! If you have a lastname with multiple words ( for instance \"de la Guerra\"), please write <lastname>,<firstnames> like this: \"de la Guerra, Carlos Pedro\"" ) );
         gl->addWidget( txtFullName, 0, 1 );
 
         QLabel *l = new QLabel( tr( "Job Title" ), container );
         QWhatsThis::add( l, tr( "The jobtitle.." ) );
         gl->addWidget( l, 1, 0 );
         txtJobTitle = new QLineEdit( container );
         QWhatsThis::add( txtJobTitle, tr( "The jobtitle.." ) );
         gl->addWidget( txtJobTitle, 1, 1 );
 
         l = new QLabel( tr("Suffix"), container );
         QWhatsThis::add( l, tr( "Something like \"jr.\".." ) );
         gl->addWidget( l, 2, 0 );
         txtSuffix = new QLineEdit( container );
         QWhatsThis::add( txtSuffix, tr( "Something like \"jr.\".." ) );
         gl->addWidget( txtSuffix, 2, 1 );
 
         l = new QLabel( tr( "Organization" ), container );
         QWhatsThis::add( l, tr( "The working place of the contact" ) );
         gl->addWidget( l, 3, 0 );
         txtOrganization = new QLineEdit( container );
         QWhatsThis::add( txtOrganization, tr( "The working place of the contact" ) );
         gl->addWidget( txtOrganization, 3, 1 );
 
         // Chooser 1 
         cmbChooserField1 = new QComboBox( FALSE, container );
         QWhatsThis::add( cmbChooserField1, tr( "Press to select attribute to change" ) );
         cmbChooserField1->setMaximumWidth( 90 );
         gl->addWidget( cmbChooserField1, 4, 0 );
         // Textfield for chooser 1.
         // Now use Widgetstack to contain the textfield and the default-email combo !
         m_widgetStack1 = new QWidgetStack( container );
         txtChooserField1 = new QLineEdit( m_widgetStack1 );
         m_widgetStack1 -> addWidget( txtChooserField1, TextField );
         gl->addWidget( m_widgetStack1, 4, 1 );
         m_widgetStack1 -> raiseWidget( TextField );
 
         // Chooser 2
         cmbChooserField2 = new QComboBox( FALSE, container );
         QWhatsThis::add( cmbChooserField2, tr( "Press to select attribute to change" ) );
         cmbChooserField2->setMaximumWidth( 90 );
         gl->addWidget( cmbChooserField2, 5, 0 );
         // Textfield for chooser 2
         // Now use WidgetStack to contain the textfield and the default-email combo!
         m_widgetStack2 = new QWidgetStack( container );
         txtChooserField2 = new QLineEdit( m_widgetStack2 );
         m_widgetStack2 -> addWidget( txtChooserField2, TextField );
         gl->addWidget( m_widgetStack2, 5, 1 );
         m_widgetStack2 -> raiseWidget( TextField );
 
         // Chooser 3
         cmbChooserField3 = new QComboBox( FALSE, container );
         QWhatsThis::add( cmbChooserField3, tr( "Press to select attribute to change" ) );
         cmbChooserField3->setMaximumWidth( 90 );
         gl->addWidget( cmbChooserField3, 6, 0 );
         // Textfield for chooser 2
         // Now use WidgetStack to contain the textfield and the default-email combo!
         m_widgetStack3 = new QWidgetStack( container );
         txtChooserField3 = new QLineEdit( m_widgetStack3 );
         m_widgetStack3 -> addWidget( txtChooserField3, TextField );
         gl->addWidget( m_widgetStack3, 6, 1 );
         m_widgetStack3 -> raiseWidget( TextField );
 
         l = new QLabel( tr( "File As" ), container );
         QWhatsThis::add( l, tr( "Press to select how to store the name (and howto show it in the listview)" ) );
         gl->addWidget( l, 7, 0 );
         cmbFileAs = new QComboBox( TRUE, container );
         gl->addWidget( cmbFileAs, 7, 1 );
 
         labCat = new QLabel( tr( "Category" ), container );
         gl->addWidget( labCat, 8, 0 );
         cmbCat = new CategorySelect( container );
         gl->addWidget( cmbCat, 8, 1 );
         labCat->show();
         cmbCat->show();
 
         btnNote = new QPushButton( tr( "Notes..." ), container );
         gl->addWidget( btnNote, 9, 1 );
 
         tabMain->insertTab( tabViewport, tr( "General" ) );
 
         tabViewport = new QWidget ( tabMain );
 
         vb = new QVBoxLayout( tabViewport );
 
         svAddress = new QScrollView( tabViewport );
         vb->addWidget( svAddress, 0, 0 );
         svAddress->setResizePolicy( QScrollView::AutoOneFit );
         svAddress->setFrameStyle( QFrame::NoFrame );
 
         container = new QWidget( svAddress->viewport() );
         svAddress->addChild( container );
 
         gl = new QGridLayout( container, 8, 3, 2, 4 ); // row 7 QSpacerItem
 
         cmbAddress = new QComboBox( FALSE, container );
         cmbAddress->insertItem( tr( "Business" ) );
         cmbAddress->insertItem( tr( "Home" ) );
         gl->addMultiCellWidget( cmbAddress, 0, 0, 0, 1 );
 
         l = new QLabel( tr( "Address" ), container );
         gl->addWidget( l, 1, 0 );
         txtAddress = new QLineEdit( container );
         gl->addMultiCellWidget( txtAddress, 1, 1, 1, 2 );
 
         l = new QLabel( tr( "City" ), container );
         gl->addWidget( l, 2, 0 );
         txtCity = new QLineEdit( container );
         gl->addMultiCellWidget( txtCity, 2, 2, 1, 2 );
 
         l = new QLabel( tr( "State" ), container );
         gl->addWidget( l, 3, 0 );
         txtState = new QLineEdit( container );
         gl->addMultiCellWidget( txtState, 3, 3, 1, 2 );
 
         l = new QLabel( tr( "Zip Code" ), container );
         gl->addWidget( l, 4, 0 );
         txtZip = new QLineEdit( container );
         gl->addMultiCellWidget( txtZip, 4, 4, 1, 2 );
 
         l = new QLabel( tr( "Country" ), container );
         gl->addWidget( l, 5, 0 );
         cmbCountry = new QComboBox( TRUE, container );
         cmbCountry->insertItem( tr( "" ) );
         cmbCountry->insertItem( tr ( "United States" ) );
         cmbCountry->insertItem( tr ( "United Kingdom" ) );
         cmbCountry->insertItem( tr ( "Afghanistan" ) );
         cmbCountry->insertItem( tr ( "Albania" ) );
         cmbCountry->insertItem( tr ( "Algeria" ) );
         cmbCountry->insertItem( tr ( "American Samoa" ) );
         cmbCountry->insertItem( tr ( "Andorra" ) );
         cmbCountry->insertItem( tr ( "Angola" ) );
         cmbCountry->insertItem( tr ( "Anguilla" ) );
         cmbCountry->insertItem( tr ( "Antarctica" ) );
         cmbCountry->insertItem( tr ( "Argentina" ) );
         cmbCountry->insertItem( tr ( "Armenia" ) );
         cmbCountry->insertItem( tr ( "Aruba" ) );
         cmbCountry->insertItem( tr ( "Australia" ) );
         cmbCountry->insertItem( tr ( "Austria" ) );
         cmbCountry->insertItem( tr ( "Azerbaijan" ) );
         cmbCountry->insertItem( tr ( "Bahamas" ) );
         cmbCountry->insertItem( tr ( "Bahrain" ) );
         cmbCountry->insertItem( tr ( "Bangladesh" ) );
         cmbCountry->insertItem( tr ( "Barbados" ) );
         cmbCountry->insertItem( tr ( "Belarus" ) );
         cmbCountry->insertItem( tr ( "Belgium" ) );
         cmbCountry->insertItem( tr ( "Belize" ) );
         cmbCountry->insertItem( tr ( "Benin" ) );
         cmbCountry->insertItem( tr ( "Bermuda" ) );
         cmbCountry->insertItem( tr ( "Bhutan" ) );
         cmbCountry->insertItem( tr ( "Bolivia" ) );
         cmbCountry->insertItem( tr ( "Botswana" ) );
         cmbCountry->insertItem( tr ( "Bouvet Island" ) );
         cmbCountry->insertItem( tr ( "Brazil" ) );
         cmbCountry->insertItem( tr ( "Brunei Darussalam" ) );
         cmbCountry->insertItem( tr ( "Bulgaria" ) );
         cmbCountry->insertItem( tr ( "Burkina Faso" ) );
         cmbCountry->insertItem( tr ( "Burundi" ) );
         cmbCountry->insertItem( tr ( "Cambodia" ) );
         cmbCountry->insertItem( tr ( "Cameroon" ) );
         cmbCountry->insertItem( tr ( "Canada" ) );
         cmbCountry->insertItem( tr ( "Cape Verde" ) );
         cmbCountry->insertItem( tr ( "Cayman Islands" ) );
         cmbCountry->insertItem( tr ( "Chad" ) );
         cmbCountry->insertItem( tr ( "Chile" ) );
         cmbCountry->insertItem( tr ( "China" ) );
         cmbCountry->insertItem( tr ( "Christmas Island" ) );
         cmbCountry->insertItem( tr ( "Colombia" ) );
         cmbCountry->insertItem( tr ( "Comoros" ) );
         cmbCountry->insertItem( tr ( "Congo" ) );
         cmbCountry->insertItem( tr ( "Cook Island" ) );
         cmbCountry->insertItem( tr ( "Costa Rica" ) );
         cmbCountry->insertItem( tr ( "Cote d'Ivoire" ) );
         cmbCountry->insertItem( tr ( "Croatia" ) );
         cmbCountry->insertItem( tr ( "Cuba" ) );
         cmbCountry->insertItem( tr ( "Cyprus" ) );
         cmbCountry->insertItem( tr ( "Czech Republic" ) );
         cmbCountry->insertItem( tr ( "Denmark" ) );
         cmbCountry->insertItem( tr ( "Djibouti" ) );
         cmbCountry->insertItem( tr ( "Dominica" ) );
         cmbCountry->insertItem( tr ( "Dominican Republic" ) );
         cmbCountry->insertItem( tr ( "East Timor" ) );
         cmbCountry->insertItem( tr ( "Ecuador" ) );
         cmbCountry->insertItem( tr ( "Egypt" ) );
         cmbCountry->insertItem( tr ( "El Salvador" ) );
         cmbCountry->insertItem( tr ( "Equatorial Guinea" ) );
         cmbCountry->insertItem( tr ( "Eritrea" ) );
         cmbCountry->insertItem( tr ( "Estonia" ) );
         cmbCountry->insertItem( tr ( "Ethiopia" ) );
         cmbCountry->insertItem( tr ( "Falkland Islands" ) );
         cmbCountry->insertItem( tr ( "Faroe Islands" ) );
         cmbCountry->insertItem( tr ( "Fiji" ) );
         cmbCountry->insertItem( tr ( "Finland" ) );
         cmbCountry->insertItem( tr ( "France" ) );
         cmbCountry->insertItem( tr ( "French Guiana" ) );
         cmbCountry->insertItem( tr ( "French Polynesia" ) );
         cmbCountry->insertItem( tr ( "Gabon" ) );
         cmbCountry->insertItem( tr ( "Gambia" ) );
         cmbCountry->insertItem( tr ( "Georgia" ) );
         cmbCountry->insertItem( tr ( "Germany" ) );
         cmbCountry->insertItem( tr ( "Ghana" ) );
         cmbCountry->insertItem( tr ( "Gibraltar" ) );
         cmbCountry->insertItem( tr ( "Greece" ) );
         cmbCountry->insertItem( tr ( "Greenland" ) );
         cmbCountry->insertItem( tr ( "Grenada" ) );
         cmbCountry->insertItem( tr ( "Guadeloupe" ) );
         cmbCountry->insertItem( tr ( "Guam" ) );
         cmbCountry->insertItem( tr ( "Guatemala" ) );
         cmbCountry->insertItem( tr ( "Guinea" ) );
         cmbCountry->insertItem( tr ( "Guinea-Bissau" ) );
         cmbCountry->insertItem( tr ( "Guyana" ) );
         cmbCountry->insertItem( tr ( "Haiti" ) );
         cmbCountry->insertItem( tr ( "Holy See" ) );
         cmbCountry->insertItem( tr ( "Honduras" ) );
         cmbCountry->insertItem( tr ( "Hong Kong" ) );
         cmbCountry->insertItem( tr ( "Hungary" ) );
         cmbCountry->insertItem( tr ( "Iceland" ) );
         cmbCountry->insertItem( tr ( "India" ) );
         cmbCountry->insertItem( tr ( "Indonesia" ) );
         cmbCountry->insertItem( tr ( "Ireland" ) );
         cmbCountry->insertItem( tr ( "Israel" ) );
         cmbCountry->insertItem( tr ( "Italy" ) );
         cmbCountry->insertItem( tr ( "Jamaica" ) );
         cmbCountry->insertItem( tr ( "Japan" ) );
         cmbCountry->insertItem( tr ( "Jordan" ) );
         cmbCountry->insertItem( tr ( "Kazakhstan" ) );
         cmbCountry->insertItem( tr ( "Kenya" ) );
         cmbCountry->insertItem( tr ( "Kiribati" ) );
         cmbCountry->insertItem( tr ( "Korea" ) );
         cmbCountry->insertItem( tr ( "Kuwait" ) );
         cmbCountry->insertItem( tr ( "Kyrgyzstan" ) );
         cmbCountry->insertItem( tr ( "Laos" ) );
         cmbCountry->insertItem( tr ( "Latvia" ) );
         cmbCountry->insertItem( tr ( "Lebanon" ) );
         cmbCountry->insertItem( tr ( "Lesotho" ) );
         cmbCountry->insertItem( tr ( "Liberia" ) );
         cmbCountry->insertItem( tr ( "Liechtenstein" ) );
         cmbCountry->insertItem( tr ( "Lithuania" ) );
         cmbCountry->insertItem( tr ( "Luxembourg" ) );
         cmbCountry->insertItem( tr ( "Macau" ) );
         cmbCountry->insertItem( tr ( "Macedonia" ) );
         cmbCountry->insertItem( tr ( "Madagascar" ) );
         cmbCountry->insertItem( tr ( "Malawi" ) );
         cmbCountry->insertItem( tr ( "Malaysia" ) );
         cmbCountry->insertItem( tr ( "Maldives" ) );
         cmbCountry->insertItem( tr ( "Mali" ) );
         cmbCountry->insertItem( tr ( "Malta" ) );
         cmbCountry->insertItem( tr ( "Martinique" ) );
         cmbCountry->insertItem( tr ( "Mauritania" ) );
         cmbCountry->insertItem( tr ( "Mauritius" ) );
         cmbCountry->insertItem( tr ( "Mayotte" ) );
         cmbCountry->insertItem( tr ( "Mexico" ) );
         cmbCountry->insertItem( tr ( "Micronesia" ) );
         cmbCountry->insertItem( tr ( "Moldova" ) );
         cmbCountry->insertItem( tr ( "Monaco" ) );
         cmbCountry->insertItem( tr ( "Mongolia" ) );
         cmbCountry->insertItem( tr ( "Montserrat" ) );
         cmbCountry->insertItem( tr ( "Morocco" ) );
         cmbCountry->insertItem( tr ( "Mozambique" ) );
         cmbCountry->insertItem( tr ( "Myanmar" ) );
         cmbCountry->insertItem( tr ( "Namibia" ) );
         cmbCountry->insertItem( tr ( "Nauru" ) );
         cmbCountry->insertItem( tr ( "Nepal" ) );
         cmbCountry->insertItem( tr ( "Netherlands" ) );
         cmbCountry->insertItem( tr ( "New Caledonia" ) );
         cmbCountry->insertItem( tr ( "New Zealand" ) );
         cmbCountry->insertItem( tr ( "Nicaragua" ) );
         cmbCountry->insertItem( tr ( "Niger" ) );
         cmbCountry->insertItem( tr ( "Nigeria" ) );
         cmbCountry->insertItem( tr ( "Niue" ) );
         cmbCountry->insertItem( tr ( "Norway" ) );
         cmbCountry->insertItem( tr ( "Oman" ) );
         cmbCountry->insertItem( tr ( "Pakistan" ) );
         cmbCountry->insertItem( tr ( "Palau" ) );
         cmbCountry->insertItem( tr ( "Palestinian Sovereign Areas" ) );
         cmbCountry->insertItem( tr ( "Panama" ) );
         cmbCountry->insertItem( tr ( "Papua New Guinea" ) );
         cmbCountry->insertItem( tr ( "Paraguay" ) );
         cmbCountry->insertItem( tr ( "Peru" ) );
         cmbCountry->insertItem( tr ( "Philippines" ) );
         cmbCountry->insertItem( tr ( "Pitcairn Islands" ) );
         cmbCountry->insertItem( tr ( "Poland" ) );
         cmbCountry->insertItem( tr ( "Portugal" ) );
         cmbCountry->insertItem( tr ( "Puerto Rico" ) );
         cmbCountry->insertItem( tr ( "Qatar" ) );
         cmbCountry->insertItem( tr ( "Reunion" ) );
         cmbCountry->insertItem( tr ( "Romania" ) );
         cmbCountry->insertItem( tr ( "Russia" ) );
         cmbCountry->insertItem( tr ( "Rwanda" ) );
         cmbCountry->insertItem( tr ( "Saint Lucia" ) );
         cmbCountry->insertItem( tr ( "Samoa" ) );
         cmbCountry->insertItem( tr ( "San Marino" ) );
         cmbCountry->insertItem( tr ( "Saudi Arabia" ) );
         cmbCountry->insertItem( tr ( "Senegal" ) );
         cmbCountry->insertItem( tr ( "Seychelles" ) );
         cmbCountry->insertItem( tr ( "Sierra Leone" ) );
         cmbCountry->insertItem( tr ( "Singapore" ) );
         cmbCountry->insertItem( tr ( "Slovakia" ) );
         cmbCountry->insertItem( tr ( "Slovenia" ) );
         cmbCountry->insertItem( tr ( "Solomon Islands" ) );
         cmbCountry->insertItem( tr ( "Somalia" ) );
         cmbCountry->insertItem( tr ( "South Africa" ) );
         cmbCountry->insertItem( tr ( "Spain" ) );
         cmbCountry->insertItem( tr ( "Sri Lanka" ) );
         cmbCountry->insertItem( tr ( "St. Helena" ) );
         cmbCountry->insertItem( tr ( "Sudan" ) );
         cmbCountry->insertItem( tr ( "Suriname" ) );
         cmbCountry->insertItem( tr ( "Swaziland" ) );
         cmbCountry->insertItem( tr ( "Sweden" ) );
         cmbCountry->insertItem( tr ( "Switzerland" ) );
         cmbCountry->insertItem( tr ( "Taiwan" ) );
         cmbCountry->insertItem( tr ( "Tajikistan" ) );
         cmbCountry->insertItem( tr ( "Tanzania" ) );
         cmbCountry->insertItem( tr ( "Thailand" ) );
         cmbCountry->insertItem( tr ( "Togo" ) );
         cmbCountry->insertItem( tr ( "Tokelau" ) );
         cmbCountry->insertItem( tr ( "Tonga" ) );
         cmbCountry->insertItem( tr ( "Tunisia" ) );
         cmbCountry->insertItem( tr ( "Turkey" ) );
         cmbCountry->insertItem( tr ( "Turkmenistan" ) );
         cmbCountry->insertItem( tr ( "Tuvalu" ) );
         cmbCountry->insertItem( tr ( "Uganda" ) );
         cmbCountry->insertItem( tr ( "Ukraine" ) );
         cmbCountry->insertItem( tr ( "Uruguay" ) );
         cmbCountry->insertItem( tr ( "Uzbekistan" ) );
         cmbCountry->insertItem( tr ( "Vanuatu" ) );
         cmbCountry->insertItem( tr ( "Venezuela" ) );
         cmbCountry->insertItem( tr ( "Vietnam" ) );
         cmbCountry->insertItem( tr ( "Virgin Islands" ) );
         cmbCountry->insertItem( tr ( "Western Sahara" ) );
         cmbCountry->insertItem( tr ( "Yemen" ) );
         cmbCountry->insertItem( tr ( "Yugoslavia" ) );
         cmbCountry->insertItem( tr ( "Zambia" ) );
         cmbCountry->insertItem( tr ( "Zimbabwe" ) );
         if (cmbCountry->listBox()!=0)
            cmbCountry->listBox()->sort();
 
         cmbCountry->setMaximumWidth( 135 );
 
         gl->addMultiCellWidget( cmbCountry, 5, 5, 1, 2 );
 
         // Chooser 4
         cmbChooserField4 = new QComboBox( FALSE, container );
         cmbChooserField4->setMaximumWidth( 90 );
         gl->addWidget( cmbChooserField4, 6, 0 );
         // Textfield for chooser 2
         // Now use WidgetStack to contain the textfield and the default-email combo!
         m_widgetStack4 = new QWidgetStack( container );
         txtChooserField4 = new QLineEdit( m_widgetStack4 );
         m_widgetStack4 -> addWidget( txtChooserField4, TextField );
         gl->addMultiCellWidget( m_widgetStack4, 6, 6, 1, 2 );
         m_widgetStack4 -> raiseWidget( TextField );
 
         QSpacerItem *space = new QSpacerItem(1,1,
                                              QSizePolicy::Maximum,
                                              QSizePolicy::MinimumExpanding );
         gl->addItem( space, 7, 0 );
 
         tabMain->insertTab( tabViewport, tr( "Address" ) );
 
         tabViewport = new QWidget ( tabMain );
 
         vb = new QVBoxLayout( tabViewport );
 
         svDetails = new QScrollView( tabViewport );
         vb->addWidget( svDetails, 0, 0 );
         svDetails->setResizePolicy( QScrollView::AutoOneFit );
         svDetails->setFrameStyle( QFrame::NoFrame );
 
         container = new QWidget( svDetails->viewport() );
         svDetails->addChild( container );
 
         gl = new QGridLayout( container, 1, 2, 2, 4 );
 
         int counter = 0;
 
         // Birthday
         QHBox* hBox = new QHBox( container );
         l = new QLabel( tr("Birthday"), container );
         gl->addWidget( l, counter, 0 );
 
          QPopupMenu* m1 = new QPopupMenu( container );
          birthdayPicker = new DateBookMonth( m1, 0, TRUE );
          m1->insertItem( birthdayPicker );
 
         birthdayButton= new QToolButton( hBox, "buttonStart" );
          birthdayButton->setPopup( m1 );
         birthdayButton->setPopupDelay(0);
 
         QPushButton* deleteButton = new QPushButton( QIconSet( Resource::loadPixmap( "trash" ) ), 
                                                      tr( "Delete" ),
                                                      hBox, 0 );
 
         gl->addWidget( hBox, counter , 1  );
 
         connect( birthdayPicker, SIGNAL( dateClicked( int, int, int ) ),
                  this, SLOT( slotBirthdayDateChanged( int, int, int ) ) );
         connect( deleteButton, SIGNAL( clicked() ), this, SLOT( slotRemoveBirthday() ) );
 
         ++counter;
 
         // Anniversary
         hBox = new QHBox( container );
         l = new QLabel( tr("Anniversary"), container );
         gl->addWidget( l, counter, 0 );
 
          m1 = new QPopupMenu( container );
          anniversaryPicker = new DateBookMonth( m1, 0, TRUE );
          m1->insertItem( anniversaryPicker );
 
         anniversaryButton= new QToolButton( hBox, "buttonStart" );
          anniversaryButton->setPopup( m1 );
         anniversaryButton->setPopupDelay(0);
 
         deleteButton = new QPushButton( QIconSet( Resource::loadPixmap( "trash" ) ), 
                                                      tr( "Delete" ),
                                                      hBox, 0 );
         gl->addWidget( hBox, counter , 1  );
 
         connect( anniversaryPicker, SIGNAL( dateClicked( int, int, int ) ),
                  this, SLOT( slotAnniversaryDateChanged( int, int, int ) ) );
         connect( deleteButton, SIGNAL( clicked() ), this, SLOT( slotRemoveAnniversary() ) );
 
         ++counter;
 
         // Gender
         l = new QLabel( tr("Gender"), container );
         gl->addWidget( l, counter, 0 );
         cmbGender = new QComboBox( container );
         cmbGender->insertItem( "", 0 );
         cmbGender->insertItem( tr("Male"), 1);
         cmbGender->insertItem( tr("Female"), 2);
         gl->addWidget( cmbGender, counter, 1 );
 
         ++counter;
 
         // Create Labels and lineedit fields for every dynamic entry
         QStringList::ConstIterator it = slDynamicEntries.begin();
         QMap<QString, int> mapStrToID = OContactFields::untrFieldsToId();
         QMap<int, QString> mapIdToStr = OContactFields::idToTrFields();
         for (i = counter; it != slDynamicEntries.end(); i++, ++it ) {
           
           if (((*it) == "Anniversary") || 
               ((*it) == "Birthday")|| ((*it) == "Gender")) continue;
 
           l = new QLabel( mapIdToStr[mapStrToID[*it]], container );
                 listName.append( l );
                 gl->addWidget( l, i, 0 );
                 QLineEdit *e = new QLineEdit( container );
                 listValue.append( e );
                 gl->addWidget( e, i, 1);
         }
         // Fill labels with names..
                 //loadFields();
 
 
         tabMain->insertTab( tabViewport, tr( "Details" ) );
 
         dlgNote = new QDialog( this, "Note Dialog", TRUE );
         dlgNote->setCaption( tr("Enter Note") );
         QVBoxLayout *vbNote = new QVBoxLayout( dlgNote );
         txtNote = new QMultiLineEdit( dlgNote );
         vbNote->addWidget( txtNote );
         connect( btnNote, SIGNAL(clicked()), this, SLOT(slotNote()) );
 
         dlgName = new QDialog( this, "Name Dialog", TRUE );
         dlgName->setCaption( tr("Edit Name") );
         gl = new QGridLayout( dlgName, 5, 2, 2, 3 );
 
         l = new QLabel( tr("First Name"), dlgName );
         gl->addWidget( l, 0, 0 );
         txtFirstName = new QLineEdit( dlgName );
         gl->addWidget( txtFirstName, 0, 1 );
 
         l = new QLabel( tr("Middle Name"), dlgName );
         gl->addWidget( l, 1, 0 );
         txtMiddleName = new QLineEdit( dlgName );
         gl->addWidget( txtMiddleName, 1, 1 );
 
         l = new QLabel( tr("Last Name"), dlgName );
         gl->addWidget( l, 2, 0 );
         txtLastName = new QLineEdit( dlgName );
         gl->addWidget( txtLastName, 2, 1 );
 
         // l = new QLabel( tr("Suffix"), dlgName );
         // gl->addWidget( l, 3, 0 );
         // txtSuffix = new QLineEdit( dlgName );
         // gl->addWidget( txtSuffix, 3, 1 );
         space = new QSpacerItem(1,1,
                                 QSizePolicy::Maximum,
                                 QSizePolicy::MinimumExpanding );
         gl->addItem( space, 4,  0 );
 
         cmbChooserField1->insertStringList( trlChooserNames );
         cmbChooserField2->insertStringList( trlChooserNames );
         cmbChooserField3->insertStringList( trlChooserNames );
         cmbChooserField4->insertStringList( trlChooserNames );
 
          cmbChooserField1->setCurrentItem( 0 );
          cmbChooserField2->setCurrentItem( 1 );
          cmbChooserField3->setCurrentItem( 2 );
 
         connect( btnFullName, SIGNAL(clicked()), this, SLOT(slotName()) );
 
         connect( txtFullName, SIGNAL(textChanged(const QString &)), 
                  this, SLOT(slotFullNameChange(const QString &)) );
         connect( txtSuffix, SIGNAL(textChanged(const QString &)), 
                  this, SLOT(slotSuffixChange(const QString &)) );
          connect( txtOrganization, SIGNAL(textChanged(const QString &)), 
                  this, SLOT(slotOrganizationChange(const QString &)) );
         connect( txtChooserField1, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotChooser1Change(const QString &)) );
         connect( txtChooserField2, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotChooser2Change(const QString &)) );
         connect( txtChooserField3, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotChooser3Change(const QString &)) );
         connect( txtChooserField4, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotChooser4Change(const QString &)) );
         connect( txtAddress, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotAddressChange(const QString &)) );
         connect( txtCity, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotCityChange(const QString &)) );
         connect( txtState, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotStateChange(const QString &)) );
         connect( txtZip, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotZipChange(const QString &)) );
         connect( cmbCountry, SIGNAL(textChanged(const QString &)),
                  this, SLOT(slotCountryChange(const QString &)) );
         connect( cmbCountry, SIGNAL(activated(const QString &)),
                  this, SLOT(slotCountryChange(const QString &)) );
         connect( cmbChooserField1, SIGNAL(activated(int)),
                  this, SLOT(slotCmbChooser1Change(int)) );
         connect( cmbChooserField2, SIGNAL(activated(int)),
                  this, SLOT(slotCmbChooser2Change(int)) );
         connect( cmbChooserField3, SIGNAL(activated(int)),
                  this, SLOT(slotCmbChooser3Change(int)) );
         connect( cmbChooserField4, SIGNAL(activated(int)),
                  this, SLOT(slotCmbChooser4Change(int)) );
         connect( cmbAddress, SIGNAL(activated(int)),
                  this, SLOT(slotAddressTypeChange(int)) );
 
         new QPEDialogListener(this);
 
         setPersonalView ( m_personalView );
 
         qWarning("init() END");
 }
 
 void ContactEditor::defaultEmailChanged(int i){
         qDebug("defaultEmailChanged");
 
         // was sollte das ? (se)
         // int index = cmbChooserField1->currentItem();
         // slChooserValues[index] = cmbDefaultEmail->text(i);
 
         defaultEmail = cmbDefaultEmail->text(i);
         qDebug ("Changed to: %s", defaultEmail.latin1());
 
 }
 
 void ContactEditor::populateDefaultEmailCmb(){       
 
         // if the default-email combo was not selected and therfore not created
         // we get a lot of trouble.. Therfore create an invisible one..
         if ( !cmbDefaultEmail ){
                         cmbDefaultEmail = new QComboBox(this);
                 cmbDefaultEmail -> hide();
         }
         cmbDefaultEmail->clear();    
         cmbDefaultEmail->insertStringList( emails );
         // cmbDefaultEmail->show();
 
         // Select default email in combo..
         bool found = false;
         for ( int i = 0; i < cmbDefaultEmail->count(); i++){
                 qDebug(" populateDefaultEmailCmb text >%s< defaultEmail >%s<",
                        cmbDefaultEmail->text( i ).latin1(), defaultEmail.latin1());
 
                 if ( cmbDefaultEmail->text( i ).stripWhiteSpace() == defaultEmail.stripWhiteSpace() ){
                         cmbDefaultEmail->setCurrentItem( i );
                         qDebug("set");
                         found = true;
                 }
         }
         
         // If the current default email is not found in the list, we choose the
         // first one..
         if ( !found )
                 defaultEmail = cmbDefaultEmail->text(0);
 }
 
 // Called when any combobox was changed.
 // "true" returned if the change was chandled by this function, else it should
 // be handled by something else..
 bool ContactEditor::cmbChooserChange( int index, QWidgetStack* inputStack, int widgetPos ) {
         QString type = slChooserNames[index];
         qWarning("ContactEditor::cmbChooserChange -> Type: %s, WidgetPos: %d", type.latin1(), widgetPos );
 
         if ( !initializing )
                 contactfields.setFieldOrder( widgetPos-1, index );
 
         // Create and connect combobox for selecting the default email 
         if ( type == "Default Email"){         
                 qWarning("Choosing default-email (defaultEmailChooserPosition= %d) ", defaultEmailChooserPosition);
                 
                 // More than one default-email chooser is not allowed !
                 if ( ( defaultEmailChooserPosition != -1 ) && 
                      defaultEmailChooserPosition != widgetPos && !initializing){
                         chooserError( widgetPos );
                         return true;
                 }
 
                 QComboBox* cmbo = ( QComboBox* ) inputStack -> widget( Combo );
                 if ( cmbo ){  
                         inputStack->raiseWidget( TextField );
                         inputStack -> removeWidget( cmbo );
                         delete cmbo;
                 }
                 cmbo = new QComboBox( inputStack );
                 cmbo -> insertStringList( emails );
 
                 inputStack -> addWidget( cmbo, Combo );
                 inputStack -> raiseWidget( Combo );
 
                 defaultEmailChooserPosition = widgetPos;
                 cmbDefaultEmail = cmbo;
 
                 connect( cmbo,SIGNAL( activated(int) ),
                          SLOT( defaultEmailChanged(int) ) ); 
 
                 // Set current default email
                 populateDefaultEmailCmb();
 
                 
         } else {
                 // Something else was selected: Hide combo..
                 qWarning(" Hiding default-email combo" );
                 if ( defaultEmailChooserPosition == widgetPos ){
                         defaultEmailChooserPosition = -1;
                 }
                 QComboBox* cmbo = ( QComboBox* ) inputStack -> widget( Combo );
                 if ( cmbo ){  
                         inputStack->raiseWidget( TextField );
                         inputStack -> removeWidget( cmbo );
                         cmbDefaultEmail = 0l;
                         delete cmbo;
                 }
 
                 // Caller should initialize the responsible textfield, therefore
                 // "false" is returned
                 return false;
         }
 
         // Everything is worked off ..
         return true;
 
 }
 
 // Currently accessed when we select default-email more than once !
 void ContactEditor::chooserError( int index )
 {
         qWarning("ContactEditor::chooserError( %d )", index); 
         QMessageBox::warning( this, "Chooser Error",
                               "Multiple selection of this\n"
                               "Item is not allowed !\n\n"
                               "First deselect the previous one !",
                               "&OK", 0, 0,
                               0, 0 );
 
         // Reset the selected Chooser. Unfortunately the chooser
         // generates no signal, therfore we have to 
         // call the cmbChooserChange function manually..
         switch( index ){
         case 1:
                 cmbChooserField1 -> setCurrentItem( 0 );
                 slotCmbChooser1Change( 0 );
                 break;
         case 2: 
                 cmbChooserField2 -> setCurrentItem( 0 );
                 slotCmbChooser2Change( 0 );
                 break;
         case 3: 
                 cmbChooserField3 -> setCurrentItem( 0 );
                 slotCmbChooser3Change( 0 );
                 break;
         case 4: 
                 cmbChooserField4 -> setCurrentItem( 0 );
                 slotCmbChooser4Change( 0 );
                 break;
         }
 }
 
 // Called when something was changed in a textfield (shouldn't it called textchanged? (se))
 void ContactEditor::chooserChange( const QString &textChanged, int index, 
                                    QLineEdit* , int widgetPos ) {
 
         QString type = slChooserNames[index]; // :SX
         qDebug("ContactEditor::chooserChange( type=>%s<, textChanged=>%s< index=%i, widgetPos=%i",
                type.latin1(),textChanged.latin1(), index,  widgetPos );
 
         if ( type == "Default Email"){         
                 qWarning ("??? Wozu??: %s", textChanged.latin1());
                 defaultEmail = textChanged;
 
                 populateDefaultEmailCmb();
 
         }else if (type == "Emails"){
                 qDebug("emails");
 
                 QString de;
                 emails = QStringList::split (",", textChanged );
 
                 populateDefaultEmailCmb();
         }
         
         slChooserValues[index] = textChanged;
 
 }
 
 void ContactEditor::slotChooser1Change( const QString &textChanged ) {
         qWarning("ContactEditor::slotChooser1Change( %s )", textChanged.latin1());
         chooserChange( textChanged, cmbChooserField1->currentItem(), txtChooserField1, 1);
 }
 
 void ContactEditor::slotChooser2Change( const QString &textChanged ) {
         qWarning("ContactEditor::slotChooser2Change( %s )", textChanged.latin1());
         chooserChange( textChanged, cmbChooserField2->currentItem(), txtChooserField2, 2);
 
 }
 
 void ContactEditor::slotChooser3Change( const QString &textChanged ) {
         qWarning("ContactEditor::slotChooser3Change( %s )", textChanged.latin1());
         chooserChange( textChanged, cmbChooserField3->currentItem(), txtChooserField3, 3);
 }
 
 void ContactEditor::slotChooser4Change( const QString &textChanged ) {
         qWarning("ContactEditor::slotChooser4Change( %s )", textChanged.latin1());
         chooserChange( textChanged, cmbChooserField4->currentItem(), txtChooserField4, 4);
 }
 
 void ContactEditor::slotAddressChange( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[0] = textChanged;
         } else {
                 slHomeAddress[0] = textChanged;
         }
 }
 
 void ContactEditor::slotAddress2Change( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[1] = textChanged;
         } else {
                 slHomeAddress[1] = textChanged;
         }
 }
 
 void ContactEditor::slotPOBoxChange( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[2] = textChanged;
         } else {
                 slHomeAddress[2] = textChanged;
         }
 }
 
 void ContactEditor::slotCityChange( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[3] = textChanged;
         } else {
                 slHomeAddress[3] = textChanged;
         }
 }
 
 void ContactEditor::slotStateChange( const QString &textChanged ) {
 
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[4] = textChanged;
         } else {
                 slHomeAddress[4] = textChanged;
         }
 }
 
 void ContactEditor::slotZipChange( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[5] = textChanged;
         } else {
                 slHomeAddress[5] = textChanged;
         }
 }
 
 void ContactEditor::slotCountryChange( const QString &textChanged ) {
 
         if ( cmbAddress->currentItem() == 0 ) {
                 slBusinessAddress[6] = textChanged;
         } else {
                 slHomeAddress[6] = textChanged;
         }
 }
 
 
 void ContactEditor::slotCmbChooser1Change( int index ) {
         qWarning("ContactEditor::slotCmbChooser1Change( %d )", index);
         if ( !cmbChooserChange( cmbChooserField1->currentItem(), m_widgetStack1, 1) ){
                 
                 txtChooserField1->setText( slChooserValues[index] );
                 txtChooserField1->setFocus();
 
         }
 
 }
 
 void ContactEditor::slotCmbChooser2Change( int index ) {
         qWarning("ContactEditor::slotCmbChooser2Change( %d )", index);
 
         if ( !cmbChooserChange( cmbChooserField2->currentItem(), m_widgetStack2, 2) ){
 
                 txtChooserField2->setText( slChooserValues[index] );
                 txtChooserField2->setFocus();
 
         }
 }
 
 void ContactEditor::slotCmbChooser3Change( int index ) {
         qWarning("ContactEditor::slotCmbChooser3Change( %d )", index);
 
         if ( !cmbChooserChange( cmbChooserField3->currentItem(), m_widgetStack3, 3) ){
 
                 txtChooserField3->setText( slChooserValues[index] );
                 txtChooserField3->setFocus();
 
         }
 }
 
 void ContactEditor::slotCmbChooser4Change( int index ) {
         qWarning("ContactEditor::slotCmbChooser4Change( %d )", index);
 
         if ( !cmbChooserChange( cmbChooserField4->currentItem(), m_widgetStack4, 4) ){
 
                 txtChooserField4->setText( slChooserValues[index] );
                 txtChooserField4->setFocus();
 
         }
 }
 
 void ContactEditor::slotAddressTypeChange( int index ) {
 
 
         if ( !initializing )
                 contactfields.setFieldOrder( 4, index );
 
 
         if ( index == 0 ) {
 
                 txtAddress->setText( slBusinessAddress[0] );
                 //txtAddress2->setText( (*slBusinessAddress)[1] );
                 //txtPOBox->setText( (*slBusinessAddress)[2] );
                 txtCity->setText( slBusinessAddress[3] );
                 txtState->setText( slBusinessAddress[4] );
                 txtZip->setText( slBusinessAddress[5] );
                 QLineEdit *txtTmp = cmbCountry->lineEdit();
                 txtTmp->setText( slBusinessAddress[6] );
 
         } else {
 
                 txtAddress->setText( slHomeAddress[0] );
                 //txtAddress2->setText( (*slHomeAddress)[1] );
                 //txtPOBox->setText( (*slHomeAddress)[2] );
                 txtCity->setText( slHomeAddress[3] );
                 txtState->setText( slHomeAddress[4] );
                 txtZip->setText( slHomeAddress[5] );
                 QLineEdit *txtTmp = cmbCountry->lineEdit();
                 txtTmp->setText( slHomeAddress[6] );
 
         }
 
 }
 
 void ContactEditor::slotFullNameChange( const QString &textChanged ) {
 
         qWarning( "ContactEditor::slotFullNameChange( %s )", textChanged.latin1() );
 
         int index = cmbFileAs->currentItem();
 
         cmbFileAs->clear();
 
         cmbFileAs->insertItem( parseName( textChanged, NAME_LF ) );
         cmbFileAs->insertItem( parseName( textChanged, NAME_LFM ) );
         cmbFileAs->insertItem( parseName( textChanged, NAME_FL ) );
         cmbFileAs->insertItem( parseName( textChanged, NAME_FML ) );
         if ( ! txtSuffix->text().isEmpty() )
                 cmbFileAs->insertItem( parseName( textChanged, NAME_FML ) + " " + txtSuffix->text() );
 
         cmbFileAs->setCurrentItem( index );
 
 
 }
 
 void ContactEditor::slotSuffixChange( const QString& ) {
         // Just want to update the FileAs combo if the suffix was changed..
         slotFullNameChange( txtFullName->text() );
 }
 
 void ContactEditor::slotOrganizationChange( const QString &textChanged ){
         qWarning( "ContactEditor::slotOrganizationChange( %s )", textChanged.latin1() );
         // Special handling for storing Companies: 
         // If no Fullname is given, we store the Company-Name as lastname
         // to handle it like a person..
         if ( txtFullName->text() == txtOrganization->text().left( txtFullName->text().length() ) )
                 txtFullName->setText( textChanged );
         
 }
 
 void ContactEditor::accept() {
 
         if ( isEmpty() ) {
                 cleanupFields();
                 reject();
         } else {
                 saveEntry();
                 cleanupFields();
                 QDialog::accept();
         }
 
 }
 
 void ContactEditor::slotNote() {
 
-        dlgNote->showMaximized();
-        if ( !dlgNote->exec() ) {
+    if ( ! QPEApplication::execDialog( dlgNote ) ) {
                 txtNote->setText( ent.notes() );
         }
 }
 
 void ContactEditor::slotName() {
 
         QString tmpName;
 
         txtFirstName->setText( parseName(txtFullName->text(), NAME_F) );
         txtMiddleName->setText( parseName(txtFullName->text(), NAME_M) );
         txtLastName->setText( parseName(txtFullName->text(), NAME_L) );
         // txtSuffix->setText( parseName(txtFullName->text(), NAME_S) );
 
-        dlgName->showMaximized();
-        if ( dlgName->exec() ) {
+        if ( QPEApplication::execDialog( dlgName ) ) {
                  if ( txtLastName->text().contains( ' ', TRUE ) )
                          tmpName =  txtLastName->text() + ", " + txtFirstName->text() + " " + txtMiddleName->text();
                  else
                          tmpName = txtFirstName->text() + " " + txtMiddleName->text() + " " + txtLastName->text();
 
                 txtFullName->setText( tmpName.simplifyWhiteSpace() );
                 slotFullNameChange( txtFullName->text() );
         }
 
 }
 
 void ContactEditor::setNameFocus() {
 
         txtFullName->setFocus();
 
 }
 
 bool ContactEditor::isEmpty() {
         // Test and see if the record should be saved.
         // More strict than the original qtopia, needs name or fileas to save
 
         QString t = txtFullName->text();
         if ( !t.isEmpty() && containsAlphaNum( t ) )
                 return false;
 
         t = cmbFileAs->currentText();
         if ( !t.isEmpty() && containsAlphaNum( t ) )
                 return false;
 
         return true;
 
 }
 
 QString ContactEditor::parseName( const QString fullName, int type ) {
 
         QString simplifiedName( fullName.simplifyWhiteSpace() );
         QString strFirstName;
         QString strMiddleName;
         QString strLastName;
         QString strTitle;
         int commapos;
         bool haveLastName = false;
 
         qWarning("Fullname: %s", simplifiedName.latin1());
 
         commapos = simplifiedName.find( ',', 0, TRUE);
         if ( commapos >= 0 ) {
                 qWarning(" Commapos: %d", commapos );
 
                 // A comma (",") separates the lastname from one or
                 // many first names. Thus, remove the lastname from the 
                 // String and parse the firstnames.
 
                 strLastName = simplifiedName.left( commapos );
                 simplifiedName= simplifiedName.mid( commapos + 1 );
                 haveLastName = true;
                 qWarning("Fullname without ',': %s", simplifiedName.latin1());
 
                 // If we have any lastname, we should now split all first names.
                 // The first one will be the used as first, the rest as "middle names"
 
                 QStringList allFirstNames = QStringList::split(" ", simplifiedName);
                 QStringList::Iterator it = allFirstNames.begin();
                 strFirstName = *it++;
                 QStringList allSecondNames;
                 for ( ; it != allFirstNames.end(); ++it )
                         allSecondNames.append( *it );
                 
                 strMiddleName = allSecondNames.join(" ");
 
         } else {
 
                 // No comma separator used: We use the first word as firstname, the 
                 // last as second/lastname and everything in the middle as middlename
 
                 QStringList allNames = QStringList::split(" ", simplifiedName);
                 QStringList::Iterator it = allNames.begin();
                 strFirstName = *it++;
                 QStringList allSecondNames;
                 for ( ; it != --allNames.end(); ++it )
                         allSecondNames.append( *it );
                 
                 strMiddleName = allSecondNames.join(" ");
                 strLastName = *(--allNames.end());
                 
         }
 
         if ( strFirstName == strLastName )
                 strFirstName = "";
 
         qWarning(" strFirstName: %s",  strFirstName.latin1());
         qWarning(" strMiddleName: %s",  strMiddleName.latin1());
         qWarning(" strLastName: %s",  strLastName.latin1());
         qWarning(" strTitle: %s",  strTitle.latin1());
 
         switch (type) {
         case NAME_FL:
                 return strFirstName + " " + strLastName;
                 
         case NAME_LF:
                 return strLastName + ", " + strFirstName;
                 
         case NAME_LFM:
                 return strLastName + ", " + strFirstName + " " + strMiddleName;
                 
         case NAME_FML:
                 return strFirstName + " " + strMiddleName + " " + strLastName ;
                 
         case NAME_F:
                 return strFirstName;
                 
         case NAME_M:
                 return strMiddleName;
                 
         case NAME_L:
                 return strLastName;
                 
         case NAME_S:
                 return txtSuffix->text();
                 
         }
         return QString::null;
 }
 
 void ContactEditor::cleanupFields() {
         QStringList::Iterator it = slChooserValues.begin();
         
         for ( int i = 0; it != slChooserValues.end(); i++, ++it ) {
                 (*it) = "";
         }
         
         for ( int i = 0; i < 7; i++ ) {
                 slHomeAddress[i] = "";
                 slBusinessAddress[i] = "";
         }
         
         QListIterator<QLineEdit> itLV( listValue );
         for ( ; itLV.current(); ++itLV ) {
                 (*itLV)->setText( "" );
         } 
         
         txtFirstName->setText("");
         txtMiddleName->setText("");
         txtLastName->setText("");
         txtSuffix->setText("");
         txtNote->setText("");
         txtFullName->setText("");
         txtJobTitle->setText("");
         txtOrganization->setText("");
         txtChooserField1->setText("");
         txtChooserField2->setText("");
         txtChooserField3->setText("");
         txtAddress->setText("");
         txtCity->setText("");
         txtState->setText("");
         txtZip->setText("");
         QLineEdit *txtTmp = cmbCountry->lineEdit();
         txtTmp->setText("");
         txtTmp = cmbFileAs->lineEdit();
         txtTmp->setText("");
         
 }
 
 void ContactEditor::setEntry( const OContact &entry ) {
         
         initializing = true;
         
         // Cleanup and activate the general Page ..
         cleanupFields();
         tabMain->setCurrentPage( 0 );
         
         ent = entry;
         
         emails = QStringList(ent.emailList());
         defaultEmail = ent.defaultEmail();
         if (defaultEmail.isEmpty()) defaultEmail = emails[0];
         qDebug("default email=%s",defaultEmail.latin1());
         
         txtFirstName->setText( ent.firstName() );
         txtMiddleName->setText( ent.middleName() );
         txtLastName->setText( ent.lastName() );
         txtSuffix->setText( ent.suffix() );
         
         // QString *tmpString = new QString;
         // *tmpString = ent.firstName() + " " + ent.middleName() +
         //      + " " + ent.lastName() + " " + ent.suffix();
         //txtFullName->setText( tmpString->simplifyWhiteSpace() );
 
         if ( !ent.isEmpty() ){
                 // Lastnames with multiple words need to be protected by a comma !
                 if ( ent.lastName().contains( ' ', TRUE ) )
                         txtFullName->setText( ent.lastName() + ", " + ent.firstName() + " " + ent.middleName() );
                 else
                         txtFullName->setText( ent.firstName() + " " + ent.middleName() + " " + ent.lastName() );
         }
         
         cmbFileAs->setEditText( ent.fileAs() );
         
                 //if (hasTitle)
         txtJobTitle->setText( ent.jobTitle() );
         
                 //if (hasCompany)
         txtOrganization->setText( ent.company() );
         
                 //if (hasNotes)
         txtNote->setText( ent.notes() );
         
                 //if (hasStreet) {
         slHomeAddress[0] = ent.homeStreet();
         slBusinessAddress[0] = ent.businessStreet();
                 //}
         
                 //if (hasCity) {
         slHomeAddress[3] = ent.homeCity();
         slBusinessAddress[3] = ent.businessCity();
         //}
         
         //if (hasState) {
         slHomeAddress[4] = ent.homeState();
         slBusinessAddress[4] = ent.businessState();
         //}
         
         //if (hasZip) {
         slHomeAddress[5] = ent.homeZip();
         slBusinessAddress[5] = ent.businessZip();
         //}
         
         //if (hasCountry) {
         slHomeAddress[6] = ent.homeCountry();
         slBusinessAddress[6] = ent.businessCountry();
         //}
         
         QStringList::ConstIterator it;
         QListIterator<QLineEdit> itLE( listValue );
         for ( it = slDynamicEntries.begin(); itLE.current()/* != slDynamicEntries.end()*/; ++it, ++itLE) {
                 
                 qWarning(" Filling dynamic Field: %s", (*it).latin1() );
                 
                 if ( *it ==  "Department"  )
                         (*itLE)->setText( ent.department() );
                 
                 if ( *it == "Company" )
                         (*itLE)->setText( ent.company() );
                 
                 if ( *it ==  "Office" )
                         (*itLE)->setText( ent.office() );
                 
                 if ( *it ==  "Profession" )
                         (*itLE)->setText( ent.profession() );
                 
                 if ( *it == "Assistant" )
                         (*itLE)->setText( ent.assistant() );
                 
                 if ( *it == "Manager" )
                         (*itLE)->setText( ent.manager() );
                 
                 if ( *it == "Spouse" )
                         (*itLE)->setText( ent.spouse() );
                 
                 if ( *it == "Nickname" ){
                         qWarning("**** Nichname: %s", ent.nickname().latin1() );
                         (*itLE)->setText( ent.nickname() );
                 }
                 
                 if ( *it == "Children" )
                         (*itLE)->setText( ent.children() );
                 
         }
         
         QStringList::Iterator itV;
         for ( it = slChooserNames.begin(), itV = slChooserValues.begin(); it != slChooserNames.end(); ++it, ++itV ) {
                 
                 if ( ( *it == "Business Phone") || ( *it == "Work Phone" ) )
                         *itV = ent.businessPhone();
                 /*
                   if ( *it == "Business 2 Phone" )
                   *itV = ent.business2Phone();
                   */
                 if ( ( *it == "Business Fax") || ( *it == "Work Fax" ) )
                         *itV = ent.businessFax();
                 
                 if ( ( *it == "Business Mobile" ) || ( *it == "work Mobile" ) )
                         *itV = ent.businessMobile();
                 /*
                   if ( *it == "Company Phone" )
                   *itV = ent.companyPhone();
                   */
                 if ( *it == "Default Email" )
                         *itV = ent.defaultEmail();
                 
                 if ( *it == "Emails" )
                         *itV = ent.emailList().join(", ");  // :SX
                 
                 if ( *it == "Home Phone" )
                         *itV = ent.homePhone();
                 /*
                   if ( *it == "Home 2 Phone" )
                   *itV = ent.home2Phone();
                   */
                 if ( *it == "Home Fax" )
                         *itV = ent.homeFax();
                 
                 if ( *it == "Home Mobile" )
                         *itV = ent.homeMobile();
                 /*
                   if ( *it == "Car Phone" )
                   *itV = ent.carPhone();
                   
                   if ( *it == "ISDN Phone" )
                   *itV = ent.ISDNPhone();
                   
                   if ( *it == "Other Phone" )
                   *itV = ent.otherPhone();
                   */
                 if ( ( *it == "Business Pager" ) || ( *it == "Work Pager" ) )
                         *itV = ent.businessPager();
                 /*
                   if ( *it == "Home Pager")
                   *itV = ent.homePager();
                   
                   if ( *it == "AIM IM" )
                   *itV = ent.AIMIM();
                   
                   if ( *it == "ICQ IM" )
                   *itV = ent.ICQIM();
                   
                   if ( *it == "Jabber IM" )
                   *itV = ent.jabberIM();
                   
                   if ( *it == "MSN IM" )
                   *itV = ent.MSNIM();
                   
                   if ( *it == "Yahoo IM" )
                   *itV = ent.yahooIM();
                   */
                 if ( *it == "Home Web Page" )
                         *itV = ent.homeWebpage();
                 
                 if ( ( *it == "Business WebPage" ) || ( *it == "Work Web Page" ) )
                         *itV = ent.businessWebpage();
                 
                 
         }
         
         
         cmbCat->setCategories( ent.categories(), "Contacts", tr("Contacts") );
         
         QString gender = ent.gender();
         cmbGender->setCurrentItem( gender.toInt() );
         
         txtNote->setText( ent.notes() );
         
         slotAddressTypeChange( cmbAddress->currentItem() );
         
         // Get combo-settings from contact and set preset..
         contactfields.loadFromRecord( ent );
         cmbChooserField1->setCurrentItem( contactfields.getFieldOrder(0, 7) );
         cmbChooserField2->setCurrentItem( contactfields.getFieldOrder(1, 9) );
         cmbChooserField3->setCurrentItem( contactfields.getFieldOrder(2, 0) );
         cmbChooserField4->setCurrentItem( contactfields.getFieldOrder(3, 6) );
         cmbAddress->setCurrentItem( contactfields.getFieldOrder(4, 1) );
         slotCmbChooser1Change( cmbChooserField1->currentItem() );
         slotCmbChooser2Change( cmbChooserField2->currentItem() );
         slotCmbChooser3Change( cmbChooserField3->currentItem() );
         slotCmbChooser4Change( cmbChooserField4->currentItem() );
         slotAddressTypeChange( cmbAddress->currentItem() );
         
         updateDatePicker();
         
         initializing = false;
 }
 void ContactEditor::updateDatePicker()
 {
         // Set DatePicker
         if ( !ent.birthday().isNull() ){
                 birthdayButton->setText( TimeString::numberDateString( ent.birthday() ) );
                 birthdayPicker->setDate( ent.birthday() );
         } else
                 birthdayButton->setText( tr ("Unknown") );
         
         if ( !ent.anniversary().isNull() ){
                 anniversaryButton->setText( TimeString::numberDateString( ent.anniversary() ) );
                 anniversaryPicker->setDate( ent.anniversary() );
         } else
                 anniversaryButton->setText( tr ("Unknown") );
         
 }
 
 void ContactEditor::saveEntry() {
         
         // Store current combo into contact
         contactfields.saveToRecord( ent );
         
         txtFirstName->setText( parseName( txtFullName->text(), NAME_F ) );
         txtMiddleName->setText( parseName( txtFullName->text(), NAME_M ) );
         txtLastName->setText( parseName( txtFullName->text(), NAME_L ) );
         // txtSuffix->setText( parseName( txtFullName->text(), NAME_S ) );
         
         ent.setFirstName( txtFirstName->text() );
         ent.setLastName( txtLastName->text() );
         ent.setMiddleName( txtMiddleName->text() );
         ent.setSuffix( txtSuffix->text() );
         
         ent.setFileAs( cmbFileAs->currentText() );
         
         ent.setCategories( cmbCat->currentCategories() );
         
         
         //if (hasTitle)
         ent.setJobTitle( txtJobTitle->text() );
         
         //if (hasCompany)
         ent.setCompany( txtOrganization->text() );
         
                 //if (hasNotes)
         ent.setNotes( txtNote->text() );
         
         //if (hasStreet) {
         ent.setHomeStreet( slHomeAddress[0] );
         ent.setBusinessStreet( slBusinessAddress[0] );
                 //}
         
                 //if (hasCity) {
         ent.setHomeCity( slHomeAddress[3] );
         ent.setBusinessCity( slBusinessAddress[3] );
                 //}
         
                 //if (hasState) {
         ent.setHomeState( slHomeAddress[4] );
         ent.setBusinessState( slBusinessAddress[4] );
                 //}
         
                 //if (hasZip) {
         ent.setHomeZip( slHomeAddress[5] );
         ent.setBusinessZip( slBusinessAddress[5] );
                 //}
         
                 //if (hasCountry) {
         ent.setHomeCountry( slHomeAddress[6] );
         ent.setBusinessCountry( slBusinessAddress[6] );
                 //}
         
         QStringList::ConstIterator it;
         QListIterator<QLineEdit> itLE( listValue );
         for ( it = slDynamicEntries.begin(); itLE.current() && it != slDynamicEntries.end(); ++it, ++itLE) {
                 
                 if ( *it == "Department" )
                         ent.setDepartment( (*itLE)->text() );
                 
                 if ( *it == "Company" )
                         ent.setCompany( (*itLE)->text() );
                 
                 if ( *it == "Office" )
                         ent.setOffice( (*itLE)->text() );
                 
                 if ( *it == "Profession" )
                         ent.setProfession( (*itLE)->text() );
                 
                 if ( *it == "Assistant" )
                         ent.setAssistant( (*itLE)->text() );
                 
                 if ( *it == "Manager" )
                         ent.setManager( (*itLE)->text() );
                 
                 if ( *it == "Spouse" )
                         ent.setSpouse( (*itLE)->text() );
                 
                 if ( *it == "Nickname" )
                         ent.setNickname( (*itLE)->text() );
                 
                 if ( *it == "Children" )
                         ent.setChildren( (*itLE)->text() );
                 
         }
         
         
         QStringList::ConstIterator itV;
         for ( it = slChooserNames.begin(), itV = slChooserValues.begin(); it != slChooserNames.end(); ++it, ++itV ) {
                 
                 if ( ( *it == "Business Phone" ) || ( *it == "Work Phone"  ) )
                         ent.setBusinessPhone( *itV );
                 
                 if ( ( *it == "Business Fax" ) || ( *it == "Work Fax" ) )
                         ent.setBusinessFax( *itV );
                 
                 if ( ( *it == "Business Mobile" ) || ( *it == "Work Mobile" ) )
                         ent.setBusinessMobile( *itV );
                 
                 if ( *it == "Emails" ){
                         QString allemail;
                         QString defaultmail;
                         parseEmailFrom( emails.join(","), defaultmail, allemail );
                         if ( defaultEmail.isEmpty() ){
                                 qWarning("Default email was not set by user!");
                                 qWarning("Using first email in list: %s", defaultmail.latin1());
                                 ent.setDefaultEmail( defaultmail );
                         }
                         ent.setEmails( allemail );
                 }
                 
                 if ( *it == "Default Email")
                         ent.setDefaultEmail( defaultEmail /* *itV */ );
                 
                 if ( *it == "Home Phone" )
                         ent.setHomePhone( *itV );
                 
                 if ( *it == "Home Fax" )
                         ent.setHomeFax( *itV );
                 
                 if ( *it == "Home Mobile" )
                         ent.setHomeMobile( *itV );
                 
                 if ( ( *it == "Business Pager" ) || ( *it == "Work Pager" ) )
                         ent.setBusinessPager( *itV );
                 
                 if ( *it == "Home Web Page" )
                         ent.setHomeWebpage( *itV );
                 
                 if ( ( *it == "Business WebPage" ) || ( *it == "Work Web Page" ) )
                         ent.setBusinessWebpage( *itV );
                 
                 
         }
         
         int gender = cmbGender->currentItem();
         ent.setGender( QString::number( gender ) );
         
         QString str = txtNote->text();
         if ( !str.isNull() )
                 ent.setNotes( str );
         
 }
 
 void parseEmailFrom( const QString &txt, QString &strDefaultEmail,
                      QString &strAll )
 {
         int where,
                 start;
         if ( txt.isEmpty() )
                 return;
         // find the first
         where = txt.find( ',' );
         if ( where < 0 ) {
                 strDefaultEmail = txt;
                 strAll = txt;
         } else {
                 strDefaultEmail = txt.left( where ).stripWhiteSpace();
                 strAll = strDefaultEmail;
                 while ( where > -1 ) {
                         strAll.append(" ");
                         start = where;
                         where = txt.find( ',', where + 1 );
                         if ( where > - 1 )
                                 strAll.append( txt.mid(start + 1, where - start - 1).stripWhiteSpace() );
                         else // grab until the end...
                                 strAll.append( txt.right(txt.length() - start - 1).stripWhiteSpace() );
                 }
         }
 }
 
 void parseEmailTo( const QString &strDefaultEmail,
                    const QString &strOtherEmail, QString &strBack )
 {
         // create a comma dilimeted set of emails...
         // use the power of short circuiting...
         bool foundDefault = false;
         QString strTmp;
         int start = 0;
         int where;
         // start at the beginng.
         strBack = strDefaultEmail;
         where = 0;
         while ( where > -1 ) {
                 start = where;
                 where = strOtherEmail.find( ' ', where + 1 );
                 if ( where > 0 ) {
                         strTmp = strOtherEmail.mid( start, where - start ).stripWhiteSpace();
                 } else
                         strTmp = strOtherEmail.right( strOtherEmail.length() - start ).stripWhiteSpace();
                 if ( foundDefault || strTmp != strDefaultEmail ) {
                         strBack.append( ", " );
                         strBack.append( strTmp );
                 } else
                         foundDefault = true;
         }
 }
 
 
 static inline bool containsAlphaNum( const QString &str )
 {
         int i,
                 count = str.length();
         for ( i = 0; i < count; i++ )
                 if ( !str[i].isSpace() )
                         return TRUE;
         return FALSE;
 }
 
 static inline bool constainsWhiteSpace( const QString &str )
 {
         int i,
                 count = str.length();
         for (i = 0; i < count; i++ )
                 if ( str[i].isSpace() )
                         return TRUE;
         return FALSE;
 }
 
 void ContactEditor::setPersonalView( bool personal )
 {
         m_personalView = personal;
         
         // Currently disbled due to the fact that
         // show will not work...
         return;
         
         if ( personal ){
                 cmbCat->hide();
                 labCat->hide();
                 
         } else{
                 cmbCat->show();
                         labCat->show();         
         }
 }
 
 void ContactEditor::slotAnniversaryDateChanged( int year, int month, int day)
 {
         QDate date;
         date.setYMD( year, month, day );
         QString dateString = TimeString::numberDateString( date );
         anniversaryButton->setText( dateString );
         ent.setAnniversary ( date );
 }
 
 void ContactEditor::slotBirthdayDateChanged( int year, int month, int day)
 {
         QDate date;
         date.setYMD( year, month, day );
         QString dateString = TimeString::numberDateString( date );
         birthdayButton->setText( dateString );
         ent.setBirthday ( date );
 }
 
 void ContactEditor::slotRemoveBirthday()
 {
         qWarning("void ContactEditor::slotRemoveBirthday()");
         ent.setBirthday( QDate() );
         updateDatePicker();
 }
 
 void ContactEditor::slotRemoveAnniversary()
 {
         qWarning("void ContactEditor::slotRemoveAnniversary()");
         ent.setAnniversary( QDate() );
         updateDatePicker();
 }
diff --git a/core/pim/datebook/datebook.cpp b/core/pim/datebook/datebook.cpp
index 44f1515..706cc08 100644
--- a/core/pim/datebook/datebook.cpp
+++ b/core/pim/datebook/datebook.cpp
@@ -1,1099 +1,1082 @@
 /**********************************************************************
 ** 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.
 **
 ** $Id$
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_FD
 
 #include "datebook.h"
 #include "datebookday.h"
 #include "datebooksettings.h"
 #include "datebookweek.h"
 #include "datebookweeklst.h"
 #include "dateentryimpl.h"
 
 #include <qpe/datebookmonth.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <qpe/qpedebug.h>
 #include <qpe/event.h>
 #include <qpe/finddialog.h>
 #include <qpe/ir.h>
 #include <qmenubar.h>
 #include <qpe/qpemessagebox.h>
 #include <qpe/resource.h>
 #include <qpe/sound.h>
 #include <qpe/timestring.h>
 #include <qtoolbar.h>
 #include <qpe/tzselect.h>
 #include <qpe/xmlreader.h>
 
 #include <qaction.h>
 #include <qcopchannel_qws.h>
 #include <qdatetime.h>
 #include <qdialog.h>
 #include <qfile.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qregexp.h>
 #include <qtextcodec.h>
 #include <qtextstream.h>
 #include <qtimer.h>
 #include <qtl.h>
 #include <qwidgetstack.h>
 #include <qwindowsystem_qws.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 #include <stdlib.h>
 
 DateBook::DateBook( QWidget *parent, const char *, WFlags f )
     : QMainWindow( parent, "datebook", f ),
       aPreset( FALSE ),
       presetTime( -1 ),
       startTime( 8 ), // an acceptable default
       rowStyle( 0 ),
       bJumpToCurTime(FALSE),
       syncing(FALSE),
       inSearch(FALSE),
       alarmCounter(0)
 {
         bool needEvilHack= false; // if we need an Evil Hack
         QTime t;
         t.start();
         db = new DateBookDBHack;
         qDebug("loading db t=%d", t.elapsed() );
         loadSettings();
         setCaption( tr("Calendar") );
         setIcon( Resource::loadPixmap( "datebook_icon" ) );
 
         setToolBarsMovable( FALSE );
 
         views = new QWidgetStack( this );
         setCentralWidget( views );
 
         dayView = 0;
         weekView = 0;
         weekLstView = 0;
         monthView = 0;
 
 //    QToolBar *bar = new QToolBar( this );
 //    bar->setHorizontalStretchable( TRUE );
 
 //    QMenuBar *mb = new QMenuBar( bar );
 //    mb->setMargin( 0 );
 
 //    QPopupMenu *view = new QPopupMenu( this );
 //    mb->insertItem( tr( "View" ), view );
 
         QToolBar *sub_bar = new QToolBar(this);
         sub_bar->setHorizontalStretchable(TRUE);
 
         QActionGroup *g = new QActionGroup( this );
         g->setExclusive( TRUE );
 
         QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null, 0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) );
         a->addTo( sub_bar );
 
         sub_bar->addSeparator();
 
         a = new QAction( tr( "Today" ), Resource::loadPixmap( "datebook/to_day" ),  QString::null, 0, g, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotToday() ) );
         a->addTo( sub_bar );
         //a->addTo( view );
 
         sub_bar->addSeparator();
 
         a = new QAction( tr( "Day" ), Resource::loadPixmap( "day" ), QString::null, 0, g, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( viewDay() ) );
         a->addTo( sub_bar );
 //    a->addTo( view );
         a->setToggleAction( TRUE );
         a->setOn( TRUE );
         dayAction = a;
 
         a = new QAction( tr( "Week" ), Resource::loadPixmap( "week" ), QString::null, 0, g, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( viewWeek() ) );
         a->addTo( sub_bar );
 //    a->addTo( view );
         a->setToggleAction( TRUE );
         weekAction = a;
 
         a = new QAction( tr( "WeekLst" ), Resource::loadPixmap( "datebook/weeklst" ), QString::null, 0, g, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( viewWeekLst() ) );
         a->addTo( sub_bar );
 //    a->addTo( view );
         a->setToggleAction( TRUE );
         weekLstAction = a;
 
         a = new QAction( tr( "Month" ), Resource::loadPixmap( "month" ), QString::null, 0, g, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( viewMonth() ) );
         a->addTo( sub_bar );
 //    a->addTo( view );
         a->setToggleAction( TRUE );
         monthAction = a;
 
         sub_bar->addSeparator();
 
         a = new QAction( tr( "Find" ), Resource::loadPixmap( "mag" ), QString::null, 0, this, 0 );
         connect( a, SIGNAL(activated()), this, SLOT(slotFind()) );
         a->addTo( sub_bar );
 
         a = new QAction( tr( "Edit..." ), Resource::loadPixmap("SettingsIcon"), QString::null, 0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotSettings() ) );
         a->addTo( sub_bar );
 
         if(defaultView==DAY) viewDay();
                 if(defaultView==WEEK) needEvilHack=true;// viewWeek();
         if(defaultView==WEEKLST) viewWeekLst();
         if(defaultView==MONTH) viewMonth();
 
         connect( qApp, SIGNAL(clockChanged(bool)), this, SLOT(changeClock(bool)) );
         connect( qApp, SIGNAL(weekChanged(bool)), this, SLOT(changeWeek(bool)) );
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
         connect( qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)), this, SLOT(appMessage(const QCString&, const QByteArray&)) );
 #endif
 
     // listen on QPE/System
 #if defined(Q_WS_QWS)
 #if !defined(QT_NO_COP)
         QCopChannel *channel = new QCopChannel( "QPE/System", this );
         connect( channel, SIGNAL(received(const QCString&, const QByteArray&)), this, SLOT(receive(const QCString&, const QByteArray&)) );
         channel = new QCopChannel( "QPE/Datebook", this );
         connect( channel, SIGNAL(received(const QCString&, const QByteArray&)), this, SLOT(receive(const QCString&, const QByteArray&)) );
         qDebug("olle\n");
 #endif
 #endif
 
         qDebug("done t=%d", t.elapsed() );
 
         connect( qApp, SIGNAL( flush() ), this, SLOT( flush() ) );
         connect( qApp, SIGNAL( reload()), this, SLOT( reload() ) );
     /*
      *  Here is a problem description:
      *  When Weekview is the default view
      *  a DateBookWeekView get's created
      *  redraw() get's called. So what?
      *  Remember that we're still in the c'tor
      *  and no final layout has happened? Ok
      *  now all Events get arranged. Their x
      *  position get's determined by a QHeader
      *  position. But the QHeader isn't layouted or
      *  at the right position. redraw() is a slot
      *  so we'll call it then via a singleShot
      *  from view()
      */
         if( needEvilHack ){
                 QTimer::singleShot( 500, this, SLOT(viewWeek()) );
         }
 }
 
 void DateBook::receive( const QCString &msg, const QByteArray &data )
 {
     QDataStream stream( data, IO_ReadOnly );
     if ( msg == "timeChange(QString)" ) {
         // update active view!
         if ( dayAction->isOn() )
             viewDay();
         else if ( weekAction->isOn() )
             viewWeek();
         else if ( monthAction->isOn() )
             viewMonth();
     }
     else if (msg == "editEvent(int)") {
         int uid;
         stream >> uid;
         Event e=db->eventByUID(uid);
         editEvent(e);
     }else if (msg == "viewDefault(QDate)"){
          QDate day;
          stream >> day;
          viewDefault(day);
      }
 }
 
 DateBook::~DateBook()
 {
 }
 
 void DateBook::slotSettings()
 {
         DateBookSettings frmSettings( ampm, this );
         frmSettings.setStartTime( startTime );
         frmSettings.setAlarmPreset( aPreset, presetTime );
         frmSettings.setJumpToCurTime( bJumpToCurTime );
         frmSettings.setRowStyle( rowStyle );
         frmSettings.comboDefaultView->setCurrentItem(defaultView-1);
         frmSettings.comboWeekListView->setCurrentItem(weeklistviewconfig);
 
         bool found=false;
         for (int i=0; i<(frmSettings.comboLocation->count()); i++) {
                 if ( frmSettings.comboLocation->text(i) == defaultLocation ) {
                         frmSettings.comboLocation->setCurrentItem(i);
                         found=true;
                         break;
                 }
         }
         if(!found) {
                 frmSettings.comboLocation->insertItem(defaultLocation);
                 frmSettings.comboLocation->setCurrentItem(frmSettings.comboLocation->count()-1);
         }
         frmSettings.comboCategory->setCategories(defaultCategories,"Calendar", tr("Calendar"));
 
-#if defined (Q_WS_QWS) || defined(_WS_QWS_)
-    frmSettings.showMaximized();
-#endif
-
-        if ( frmSettings.exec() ) {
-
+        if ( QPEApplication::execDialog( &frmSettings ) ) {
                 aPreset = frmSettings.alarmPreset();
                 presetTime = frmSettings.presetTime();
                 startTime = frmSettings.startTime();
                 bJumpToCurTime = frmSettings.jumpToCurTime();
                 rowStyle = frmSettings.rowStyle();
                 defaultView=frmSettings.comboDefaultView->currentItem()+1;
                 weeklistviewconfig=frmSettings.comboWeekListView->currentItem();
                 defaultLocation=frmSettings.comboLocation->currentText();
                 defaultCategories=frmSettings.comboCategory->currentCategories();
 
                 if ( dayView ) {
                         dayView->setStartViewTime( startTime );
                         dayView->setJumpToCurTime( bJumpToCurTime );
                         dayView->setRowStyle( rowStyle );
                 }
                 if ( weekView ) {
                         weekView->setStartViewTime( startTime );
                 }
                 saveSettings();
 
                 // make the change obvious
                 if ( views->visibleWidget() ) {
                         if ( views->visibleWidget() == dayView )
                                 dayView->redraw();
                         else if ( views->visibleWidget() == weekView )
                                 weekView->redraw();
                         else if ( views->visibleWidget() == weekLstView )
                                 weekLstView->redraw();
                 }
         }
 }
 
 void DateBook::fileNew()
 {
     slotNewEventFromKey("");
 }
 
 QString DateBook::checkEvent(const Event &e)
 {
     /* check if overlaps with itself */
     bool checkFailed = FALSE;
 
     /* check the next 12 repeats. should catch most problems */
     QDate current_date = e.start().date();
     Event previous = e;
     for(int i = 0; i < 12; i++)
     {
         QDateTime next;
         if (!nextOccurance(previous, current_date.addDays(1), next)) {
             break;  // no more repeats
         }
         if(next < previous.end()) {
             checkFailed = TRUE;
             break;
         }
         current_date = next.date();
     }
 
     if(checkFailed)
         return tr("Event duration is potentially longer\n"
                   "than interval between repeats.");
 
     return QString::null;
 }
 
 QDate DateBook::currentDate()
 {
     QDate d = QDate::currentDate();
 
     if ( dayView && views->visibleWidget() == dayView ) {
         d = dayView->date();
     } else if ( weekView && views->visibleWidget() == weekView ) {
         d = weekView->date();
     } else if ( weekLstView && views->visibleWidget() == weekLstView ) {
         d = weekLstView->date();
     } else if ( monthView && views->visibleWidget() == monthView ) {
         d = monthView->selectedDate();
     }
 
     return d;
 }
 
 void DateBook::view(int v, const QDate &d) {
         if (v==DAY) {
                 initDay();
                 dayAction->setOn( TRUE );
                 dayView->setDate( d );
                 views->raiseWidget( dayView );
                 dayView->redraw();
         } else if (v==WEEK) {
                 initWeek();
                 weekAction->setOn( TRUE );
                 weekView->setDate( d );
                 views->raiseWidget( weekView );
                 weekView->redraw();
         } else if (v==WEEKLST) {
                 initWeekLst();
                 weekLstAction->setOn( TRUE );
                 weekLstView->setDate(d);
                 views->raiseWidget( weekLstView );
                 weekLstView->redraw();
         } else if (v==MONTH) {
                 initMonth();
                 monthAction->setOn( TRUE );
                 monthView->setDate( d.year(), d.month(), d.day() );
                 views->raiseWidget( monthView );
                 monthView->redraw();
         }
 }
 
 void DateBook::viewDefault(const QDate &d) {
         view(defaultView,d);
 }
 
 void DateBook::viewDay() {
         view(DAY,currentDate());
 }
 
 void DateBook::viewWeek() {
         view(WEEK,currentDate());
 }
 
 void DateBook::viewWeekLst() {
         view(WEEKLST,currentDate());
 }
 
 void DateBook::viewMonth() {
         view(MONTH,currentDate());
 }
 
 void DateBook::insertEvent( const Event &e )
 {
         Event dupEvent=e;
         if(!dupEvent.isValidUid() ) // tkcRom seems to be different
             dupEvent.assignUid();
         dupEvent.setLocation(defaultLocation);
         dupEvent.setCategories(defaultCategories);
         db->addEvent(dupEvent);
         emit newEvent();
 }
 
 void DateBook::duplicateEvent( const Event &e )
 {
         qWarning("Hmmm...");
     // Alot of code duplication, as this is almost like editEvent();
         if (syncing) {
                 QMessageBox::warning( this, tr("Calendar"), tr( "Can not edit data, currently syncing") );
                 return;
     }
 
                 Event dupevent(e);// Make a duplicate.
 
         // workaround added for text input.
         QDialog editDlg( this, 0, TRUE );
         DateEntry *entry;
         editDlg.setCaption( tr("Duplicate Event") );
         QVBoxLayout *vb = new QVBoxLayout( &editDlg );
         QScrollView *sv = new QScrollView( &editDlg, "scrollview" );
         sv->setResizePolicy( QScrollView::AutoOneFit );
         // KLUDGE!!!
         sv->setHScrollBarMode( QScrollView::AlwaysOff );
         vb->addWidget( sv );
         entry = new DateEntry( onMonday, dupevent, ampm, &editDlg, "editor" );
         entry->timezone->setEnabled( FALSE );
         sv->addChild( entry );
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-    editDlg.showMaximized();
-#endif
-        while (editDlg.exec() ) {
+        while ( QPEApplication::execDialog( &editDlg ) ) {
                 Event newEv = entry->event();
                 QString error = checkEvent(newEv);
                 if (!error.isNull()) {
                         if (QMessageBox::warning(this, tr("error box"), error, tr("Fix it"), tr("Continue"), 0, 0, 1) == 0)
                                 continue;
                 }
         /*
         * The problem:
         * DateBookDB does remove repeating events not by uid but by the time
         * the recurrence was created
         * so we need to update that time as well
         */
         Event::RepeatPattern rp = newEv.repeatPattern();
         rp.createTime = ::time( NULL );
         newEv.setRepeat( TRUE, rp ); // has repeat and repeatPattern...
                 if( newEv.uid() == e.uid() || !newEv.isValidUid() )
                     newEv.assignUid();
 
                 db->addEvent(newEv);
                 emit newEvent();
                 break;
         }
 }
 
 void DateBook::editEvent( const Event &e )
 {
         if (syncing) {
                 QMessageBox::warning( this, tr("Calendar"), tr( "Can not edit data, currently syncing") );
                 return;
         }
 
         // workaround added for text input.
         QDialog editDlg( this, 0, TRUE );
         DateEntry *entry;
         editDlg.setCaption( tr("Edit Event") );
         QVBoxLayout *vb = new QVBoxLayout( &editDlg );
         QScrollView *sv = new QScrollView( &editDlg, "scrollview" );
         sv->setResizePolicy( QScrollView::AutoOneFit );
         // KLUDGE!!!
         sv->setHScrollBarMode( QScrollView::AlwaysOff );
         vb->addWidget( sv );
         entry = new DateEntry( onMonday, e, ampm, &editDlg, "editor" );
         entry->timezone->setEnabled( FALSE );
         sv->addChild( entry );
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-        editDlg.showMaximized();
-#endif
-        while (editDlg.exec() ) {
+        while ( QPEApplication::execDialog( &editDlg ) ) {
                 Event newEv = entry->event();
                 if(newEv.description().isEmpty() && newEv.notes().isEmpty() )
                         break;
                 newEv.setUid(e.uid()); // FIXME: Hack not to clear uid
                 QString error = checkEvent(newEv);
                 if (!error.isNull()) {
                         if (QMessageBox::warning(this, tr("error box"), error, tr("Fix it"), tr("Continue"), 0, 0, 1) == 0) continue;
         }
         db->editEvent(e, newEv);
         emit newEvent();
         break;
         }
 }
 
 void DateBook::removeEvent( const Event &e )
 {
         if (syncing) {
                 QMessageBox::warning( this, tr("Calendar"), tr( "Can not edit data, currently syncing") );
                 return;
         }
 
     QString strName = e.description();
 
     if ( !QPEMessageBox::confirmDelete( this, tr( "Calendar" ),strName ) )
         return;
 
     db->removeEvent( e );
     if ( views->visibleWidget() == dayView && dayView )
         dayView->redraw();
 }
 
 void DateBook::addEvent( const Event &e )
 {
     QDate d = e.start().date();
     initDay();
     dayView->setDate( d );
 }
 
 void DateBook::showDay( int year, int month, int day )
 {
     QDate d(year, month, day);
     view(DAY,d);
 }
 
 void DateBook::initDay()
 {
         if ( !dayView ) {
                 dayView = new DateBookDay( ampm, onMonday, db, views, "day view" );
                 views->addWidget( dayView, DAY );
                 dayView->setJumpToCurTime( bJumpToCurTime );
                 dayView->setStartViewTime( startTime );
                 dayView->setRowStyle( rowStyle );
                 connect( this, SIGNAL( newEvent() ), dayView, SLOT( redraw() ) );
                         connect( dayView, SIGNAL( newEvent() ), this, SLOT( fileNew() ) );
                 connect( dayView, SIGNAL( removeEvent( const Event & ) ), this, SLOT( removeEvent( const Event & ) ) );
                 connect( dayView, SIGNAL( editEvent( const Event & ) ), this, SLOT( editEvent( const Event & ) ) );
                 connect( dayView, SIGNAL( duplicateEvent( const Event & ) ), this, SLOT( duplicateEvent( const Event & ) ) );
                 connect( dayView, SIGNAL( beamEvent( const Event & ) ), this, SLOT( beamEvent( const Event & ) ) );
                 connect( dayView, SIGNAL(sigNewEvent(const QString &)), this, SLOT(slotNewEventFromKey(const QString &)) );
         }
 }
 
 void DateBook::initWeek()
 {
         if ( !weekView ) {
                 weekView = new DateBookWeek( ampm, onMonday, db, views, "week view" );
                 weekView->setStartViewTime( startTime );
                 views->addWidget( weekView, WEEK );
                 connect( weekView, SIGNAL( showDate( int, int, int ) ), this, SLOT( showDay( int, int, int ) ) );
                 connect( this, SIGNAL( newEvent() ), weekView, SLOT( redraw() ) );
         }
 
         //But also get it right: the year that we display can be different
         //from the year of the current date. So, first find the year
         //number of the current week.
         int yearNumber, totWeeks;
         calcWeek( currentDate(), totWeeks, yearNumber, onMonday );
 
         QDate d = QDate( yearNumber, 12, 31 );
         calcWeek( d, totWeeks, yearNumber, onMonday );
 
         while ( totWeeks == 1 ) {
                 d = d.addDays( -1 );
                 calcWeek( d, totWeeks, yearNumber, onMonday );
         }
 }
 
 void DateBook::initWeekLst() {
         if ( !weekLstView ) {
                 weekLstView = new DateBookWeekLst( ampm, onMonday, db, views, "weeklst view" );
                 views->addWidget( weekLstView, WEEKLST );
 
                 //weekLstView->setStartViewTime( startTime );
                 connect( weekLstView, SIGNAL( showDate( int, int, int ) ), this, SLOT( showDay( int, int, int ) ) );
                 connect( weekLstView, SIGNAL( addEvent( const QDateTime &, const QDateTime &, const QString & , const QString &) ),
                         this, SLOT( slotNewEntry( const QDateTime &, const QDateTime &, const QString & , const QString &) ) );
                 connect( this, SIGNAL( newEvent() ), weekLstView, SLOT( redraw() ) );
                 connect( weekLstView, SIGNAL( editEvent( const Event & ) ), this, SLOT( editEvent( const Event & ) ) );
         }
 }
 
 
 void DateBook::initMonth()
 {
         if ( !monthView ) {
                 monthView = new DateBookMonth( views, "month view", FALSE, db );
                 views->addWidget( monthView, MONTH );
                 connect( monthView, SIGNAL( dateClicked( int, int, int ) ), this, SLOT( showDay( int, int, int ) ) );
                 connect( this, SIGNAL( newEvent() ), monthView, SLOT( redraw() ) );
                 qApp->processEvents();
         }
 }
 
 void DateBook::loadSettings()
 {
         Config qpeconfig( "qpe" );
         qpeconfig.setGroup("Time");
         ampm = qpeconfig.readBoolEntry( "AMPM", TRUE );
         onMonday = qpeconfig.readBoolEntry( "MONDAY" );
 
         Config config("DateBook");
         config.setGroup("Main");
         startTime = config.readNumEntry("startviewtime", 8);
         aPreset = config.readBoolEntry("alarmpreset");
         presetTime = config.readNumEntry("presettime");
         bJumpToCurTime = config.readBoolEntry("jumptocurtime");
         rowStyle = config.readNumEntry("rowstyle");
         defaultView = config.readNumEntry("defaultview",DAY);
         weeklistviewconfig = config.readNumEntry("weeklistviewconfig",NORMAL);
 
         defaultLocation=config.readEntry("defaultLocation");
         QString tmpString=config.readEntry("defaultCategories");
         QStringList tmpStringList=QStringList::split(",",tmpString);
         defaultCategories.truncate(0);
 
         for( QStringList::Iterator i=tmpStringList.begin(); i!=tmpStringList.end(); i++) {
                 defaultCategories.resize(defaultCategories.count()+1);
                 defaultCategories[defaultCategories.count()-1]=(*i).toInt();
         }
 }
 
 void DateBook::saveSettings()
 {
         Config config( "qpe" );
         Config configDB( "DateBook" );
         configDB.setGroup( "Main" );
         configDB.writeEntry("startviewtime",startTime);
         configDB.writeEntry("alarmpreset",aPreset);
         configDB.writeEntry("presettime",presetTime);
         configDB.writeEntry("jumptocurtime", bJumpToCurTime);
         configDB.writeEntry("rowstyle", rowStyle);
         configDB.writeEntry("defaultview",defaultView);
         configDB.writeEntry("weeklistviewconfig",weeklistviewconfig);
 
         configDB.writeEntry("defaultLocation",defaultLocation);
         QStringList tmpStringList;
         for( uint i=0; i<defaultCategories.count(); i++) {
                 tmpStringList << QString::number(defaultCategories[i]);
         }
         configDB.writeEntry("defaultCategories",tmpStringList.join(","));
 }
 
 void DateBook::appMessage(const QCString& msg, const QByteArray& data)
 {
         bool needShow = FALSE;
         if ( msg == "alarm(QDateTime,int)" ) {
                 QDataStream ds(data,IO_ReadOnly);
                 QDateTime when; int warn;
                 ds >> when >> warn;
 
                 // check to make it's okay to continue,
                 // this is the case that the time was set ahead, and
                 // we are forced given a stale alarm...
                 QDateTime current = QDateTime::currentDateTime();
                 if ( current.time().hour() != when.time().hour() && current.time().minute() != when.time().minute() )
                         return;
 
                 QValueList<EffectiveEvent> list = db->getEffectiveEvents(when.addSecs(warn*60));
                 if ( list.count() > 0 ) {
                         QString msg;
                         bool bSound = FALSE;
                         int stopTimer = 0;
                         bool found = FALSE;
                         for ( QValueList<EffectiveEvent>::ConstIterator it=list.begin(); it!=list.end(); ++it ) {
                                 if ( (*it).event().hasAlarm() ) {
                                         found = TRUE;
                                         msg += "<CENTER><B>" + (*it).description() + "</B>"
                                         + "<BR>" + (*it).location() + "<BR>"
                                         + TimeString::dateString((*it).event().start(),ampm)
                                         + (warn
                                                 ? tr(" (in " + QString::number(warn)
                                                 + tr(" minutes)"))
                                                 : QString(""))
                                         + "<BR>"
                                         + (*it).notes() + "</CENTER>";
                                         if ( (*it).event().alarmSound() != Event::Silent ) {
                                                 bSound = TRUE;
                                         }
                                 }
                         }
                         if ( found ) {
                                 if ( bSound ) {
                                         Sound::soundAlarm();
                                         alarmCounter = 0;
                                         stopTimer = startTimer( 5000 );
                                 }
                                 QDialog dlg( this, 0, TRUE );
                                 QVBoxLayout *vb = new QVBoxLayout( &dlg );
                                 QScrollView *view = new QScrollView( &dlg, "scrollView");
                                 view->setResizePolicy( QScrollView::AutoOneFit );
                                 vb->addWidget( view );
                                 QLabel *lblMsg = new QLabel( msg, &dlg );
                                 view->addChild( lblMsg );
                                 QPushButton *cmdOk = new QPushButton( tr("OK"), &dlg );
                                 connect( cmdOk, SIGNAL(clicked()), &dlg, SLOT(accept()) );
                                 vb->addWidget( cmdOk );
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-                                dlg.showMaximized();
-#endif
-                                needShow = dlg.exec();
+                                needShow = QPEApplication::execDialog( &dlg );
 
                                 if ( bSound )
                                         killTimer( stopTimer );
                                 }
                         }
                 } else if ( msg == "nextView()" ) {
                     needShow = true;
                         if ( !qApp-> activeWindow ( )) {
                                 needShow = TRUE;
                         } else {
                                 QWidget* cur = views->visibleWidget();
                                 if ( cur ) {
                                 if ( cur == dayView )
                                         viewWeek();
                                 else if ( cur == weekView )
                                         viewWeekLst();
                                 else if ( cur == weekLstView )
                                         viewMonth();
                                 else if ( cur == monthView )
                                         viewDay();
                                 needShow = TRUE;
                         }
                 }
     }   else if (msg == "editEvent(int)") {
         /* simple copy from receive */
         QDataStream stream(data,IO_ReadOnly);
         int uid;
         stream >> uid;
         Event e=db->eventByUID(uid);
         editEvent(e);
     } else if (msg == "viewDefault(QDate)"){
         /* simple copy from receive */
         QDataStream stream(data,IO_ReadOnly);
         QDate day;
         stream >> day;
         viewDefault(day);
         needShow = true;
      }
 
     if ( needShow ) {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
         //      showMaximized();
 #else
         //      show();
 #endif
         //      raise();
                 QPEApplication::setKeepRunning();
         //      setActiveWindow();
         }
 }
 
 void DateBook::reload()
 {
         db->reload();
         if ( dayAction->isOn() ) viewDay();
         else if ( weekAction->isOn() ) viewWeek();
         else if ( monthAction->isOn() ) viewMonth();
         syncing = FALSE;
 }
 
 void DateBook::flush()
 {
         syncing = TRUE;
         db->save();
 }
 
 void DateBook::timerEvent( QTimerEvent *e )
 {
         if ( alarmCounter < 10 ) {
                 alarmCounter++;
                 Sound::soundAlarm();
         } else {
                 killTimer( e->timerId() );
         }
 }
 
 void DateBook::changeClock( bool newClock )
 {
         ampm = newClock;
         // repaint the affected objects...
         if (dayView) dayView->redraw();
         if (weekView) weekView->redraw();
         if (weekLstView) weekLstView->redraw();
 }
 
 void DateBook::changeWeek( bool m )
 {
         /* no need to redraw, each widget catches.  Do need to
         store though for widgets we haven't made yet */
         onMonday = m;
 }
 
 void DateBook::slotToday()
 {
         // we need to view today using default view
         view(defaultView,QDate::currentDate());
 }
 
 void DateBook::closeEvent( QCloseEvent *e )
 {
         if(syncing) {
                 /* no need to save, did that at flush */
                 e->accept();
                 return;
         }
 
         // save settings will generate it's own error messages, no
         // need to do checking ourselves.
         saveSettings();
         if ( db->save() ) {
                 e->accept();
         } else {
                 if ( QMessageBox::critical( this, tr( "Out of space" ),
                                                 tr("Calendar was unable to save\n"
                                                 "your changes.\n"
                                                 "Free up some space and try again.\n"
                                                 "\nQuit anyway?"),
                                                 QMessageBox::Yes|QMessageBox::Escape,
                                                 QMessageBox::No|QMessageBox::Default )
                         != QMessageBox::No )
                         e->accept();
                 else
                         e->ignore();
     }
 }
 
 // Entering directly from the "keyboard"
 void DateBook::slotNewEventFromKey( const QString &str )
 {
     if (syncing) {
         QMessageBox::warning( this, tr("Calendar"),
                               tr( "Can not edit data, currently syncing") );
         return;
     }
 
     // We get to here from a key pressed in the Day View
     // So we can assume some things.  We want the string
     // passed in to be part of the description.
     QDateTime start, end;
     if ( views->visibleWidget() == dayView ) {
         dayView->selectedDates( start, end );
     } else if ( views->visibleWidget() == monthView ) {
         QDate d = monthView->selectedDate();
         start = end = d;
         start.setTime( QTime( 10, 0 ) );
         end.setTime( QTime( 12, 0 ) );
     } else if ( views->visibleWidget() == weekView ) {
         QDate d = weekView->date();
         start = end = d;
         start.setTime( QTime( 10, 0 ) );
         end.setTime( QTime( 12, 0 ) );
     } else if ( views->visibleWidget() == weekLstView ) {
         QDate d = weekLstView->date();
         start = end = d;
         start.setTime( QTime( 10, 0 ) );
         end.setTime( QTime( 12, 0 ) );
         }
     slotNewEntry(start, end, str);
 }
 void DateBook::slotNewEntry(const QDateTime &start, const QDateTime &end, const QString &str, const QString &location) {
         // argh!  This really needs to be encapsulated in a class
         // or function.
         QDialog newDlg( this, 0, TRUE );
         newDlg.setCaption( DateEntryBase::tr("New Event") );
         DateEntry *e;
         QVBoxLayout *vb = new QVBoxLayout( &newDlg );
         QScrollView *sv = new QScrollView( &newDlg );
         sv->setResizePolicy( QScrollView::AutoOneFit );
         sv->setFrameStyle( QFrame::NoFrame );
         sv->setHScrollBarMode( QScrollView::AlwaysOff );
         vb->addWidget( sv );
 
         Event ev;
         ev.setDescription(  str );
         // When the new gui comes in, change this...
         if(location==0) {
                 if(defaultLocation.isEmpty()) {
                         ev.setLocation(tr("(Unknown)"));
                 } else {
                         ev.setLocation( defaultLocation );
                 }
         } else {
                 ev.setLocation(location);
         }
         ev.setCategories(defaultCategories);
         ev.setStart( start );
         ev.setEnd( end );
 
         e = new DateEntry( onMonday, ev, ampm, &newDlg );
         e->setAlarmEnabled( aPreset, presetTime, Event::Loud );
         sv->addChild( e );
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-        newDlg.showMaximized();
-#endif
-        while (newDlg.exec()) {
+        while ( QPEApplication::execDialog( &newDlg ) ) {
                 ev = e->event();
                 ev.assignUid();
                 QString error = checkEvent( ev );
                 if ( !error.isNull() ) {
                 if ( QMessageBox::warning( this, tr("Error!"), error, tr("Fix it"), tr("Continue"), 0, 0, 1 ) == 0 )
                         continue;
                 }
                 db->addEvent( ev );
                 emit newEvent();
                 break;
         }
 }
 
 void DateBook::setDocument( const QString &filename )
 {
     if ( filename.find(".vcs") != int(filename.length()) - 4 ) return;
 
     QValueList<Event> tl = Event::readVCalendar( filename );
     for( QValueList<Event>::Iterator it = tl.begin(); it != tl.end(); ++it ) {
         db->addEvent( *it );
     }
 }
 
 static const char * beamfile = "/tmp/obex/event.vcs";
 
 void DateBook::beamEvent( const Event &e )
 {
     qDebug("trying to beamn");
     unlink( beamfile ); // delete if exists
     mkdir("/tmp/obex/", 0755);
     Event::writeVCalendar( beamfile, e );
     Ir *ir = new Ir( this );
     connect( ir, SIGNAL( done( Ir * ) ), this, SLOT( beamDone( Ir * ) ) );
     QString description = e.description();
     ir->send( beamfile, description, "text/x-vCalendar" );
 }
 
 void DateBook::beamDone( Ir *ir )
 {
     delete ir;
     unlink( beamfile );
 }
 
 void DateBook::slotFind()
 {
     // move it to the day view...
     viewDay();
     FindDialog frmFind( "Calendar", this ); // no tr needed
     frmFind.setUseDate( true );
     frmFind.setDate( currentDate() );
     QObject::connect( &frmFind,
                       SIGNAL(signalFindClicked(const QString&, const QDate&,
                                                bool, bool, int)),
                       this,
                       SLOT(slotDoFind(const QString&, const QDate&,
                                       bool, bool, int)) );
     QObject::connect( this,
                       SIGNAL(signalNotFound()),
                       &frmFind,
                       SLOT(slotNotFound()) );
     QObject::connect( this,
                       SIGNAL(signalWrapAround()),
                       &frmFind,
                       SLOT(slotWrapAround()) );
         frmFind.move(0,0);
     frmFind.exec();
     inSearch = false;
 }
 
 bool catComp( QArray<int> cats, int category )
 {
     bool returnMe;
     int i,
         count;
 
     count = int(cats.count());
     returnMe = false;
     if ( (category == -1 && count == 0) || category == -2 )
         returnMe = true;
     else {
         for ( i = 0; i < count; i++ ) {
             if ( category == cats[i] ) {
                 returnMe = true;
                 break;
             }
         }
     }
     return returnMe;
 }
 
 
 void DateBook::slotDoFind( const QString& txt, const QDate &dt,
                            bool caseSensitive, bool /*backwards*/,
                            int category )
 {
     QDateTime dtEnd( QDate(3001, 1, 1), QTime(0, 0, 0) ),
         next;
 
     QRegExp r( txt );
     r.setCaseSensitive( caseSensitive );
 
 
     static Event rev,
         nonrev;
     if ( !inSearch ) {
         rev.setStart( QDateTime(QDate(1960, 1, 1), QTime(0, 0, 0)) );
         nonrev.setStart( rev.start() );
         inSearch = true;
     }
     static QDate searchDate = dt;
     static bool wrapAround = true;
     bool candidtate;
     candidtate = false;
 
     QValueList<Event> repeats = db->getRawRepeats();
 
     // find the candidate for the first repeat that matches...
     QValueListConstIterator<Event> it;
     QDate start = dt;
     for ( it = repeats.begin(); it != repeats.end(); ++it ) {
         if ( catComp( (*it).categories(), category ) ) {
             while ( nextOccurance( *it, start, next ) ) {
                 if ( next < dtEnd ) {
                     if ( (*it).match( r ) && !(next <= rev.start()) ) {
                         rev = *it;
                         dtEnd = next;
                         rev.setStart( next );
                         candidtate = true;
                         wrapAround = true;
                         start = dt;
                         break;
                     } else
                         start = next.date().addDays( 1 );
                 }
             }
         }
     }
 
     // now the for first non repeat...
     QValueList<Event> nonRepeats = db->getNonRepeatingEvents( dt, dtEnd.date() );
     qHeapSort( nonRepeats.begin(), nonRepeats.end() );
     for ( it = nonRepeats.begin(); it != nonRepeats.end(); ++it ) {
         if ( catComp( (*it).categories(), category ) ) {
             if ( (*it).start() < dtEnd ) {
                 if ( (*it).match( r ) && !(*it <= nonrev) ) {
                     nonrev = *it;
                     dtEnd = nonrev.start();
                     candidtate = true;
                     wrapAround = true;
                     break;
                 }
             }
         }
     }
     if ( candidtate ) {
         dayView->setStartViewTime( dtEnd.time().hour() );
         dayView->setDate( dtEnd.date().year(), dtEnd.date().month(),
                           dtEnd.date().day() );
     } else {
         if ( wrapAround ) {
             emit signalWrapAround();
             rev.setStart( QDateTime(QDate(1960, 1, 1), QTime(0, 0, 0)) );
             nonrev.setStart( rev.start() );
         } else
             emit signalNotFound();
         wrapAround = !wrapAround;
     }
 }
 
 Event DateBookDBHack::eventByUID(int uid) {
 
     // FIXME: Dirty Hacks to get hold of the private event lists
     QDate start;
     QDate end=start.addDays(-1);
     QValueList<Event> myEventList=getNonRepeatingEvents(start,end);
     QValueList<Event> myRepeatEvents=getRawRepeats();
 
     QValueList<Event>::ConstIterator it;
 
     for (it = myEventList.begin(); it != myEventList.end(); it++) {
         if ((*it).uid() == uid) return *it;
     }
     for (it = myRepeatEvents.begin(); it != myRepeatEvents.end(); it++) {
         if ((*it).uid() == uid) return *it;
     }
 
     qDebug("Event not found: uid=%d\n", uid);
     Event ev;
     return ev; // return at least
 }
 
diff --git a/core/pim/datebook/dateentryimpl.cpp b/core/pim/datebook/dateentryimpl.cpp
index d9e5225..856837c 100644
--- a/core/pim/datebook/dateentryimpl.cpp
+++ b/core/pim/datebook/dateentryimpl.cpp
@@ -1,576 +1,570 @@
 /**********************************************************************
 ** 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 "dateentryimpl.h"
 #include "repeatentry.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/categoryselect.h>
 #include <qpe/datebookmonth.h>
 #include <qpe/global.h>
 #include <qpe/timeconversion.h>
 #include <qpe/timestring.h>
 #include <qpe/tzselect.h>
 
 #include <qevent.h>
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qmultilineedit.h>
 #include <qpopupmenu.h>
 #include <qscrollview.h>
 #include <qspinbox.h>
 #include <qtoolbutton.h>
 
 #include <opie/otimepicker.h>
 #include "onoteedit.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 
 /*
  *  Constructs a DateEntry which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 
 DateEntry::DateEntry( bool startOnMonday, const QDateTime &start,
                       const QDateTime &end, bool whichClock, QWidget* parent,
                       const char* name )
     : DateEntryBase( parent, name ),
       ampm( whichClock ),
       startWeekOnMonday( startOnMonday ),
       m_showStart(true)
 {
     init();
     setDates(start,end);
     setFocusProxy(comboDescription);
 }
 
 bool DateEntry::eventFilter(QObject *obj, QEvent *ev )
 {
   if( ev->type() == QEvent::FocusIn ){
     if( obj == comboStart ){
       timePickerStart->setHour(startTime.hour());
       timePickerStart->setMinute(startTime.minute());
       TimePickerLabel->setText( tr("Start Time" ) );
       m_showStart= true;
     }else if( obj == comboEnd ){
       timePickerStart->setHour(endTime.hour());
       timePickerStart->setMinute(endTime.minute());
       TimePickerLabel->setText( tr("End Time") );
       m_showStart = false;
     }
   } else if( ev->type() == QEvent::FocusOut ){
 //    if( obj == comboEnd ){
 //      QString s;
 //      s.sprintf("%.2d:%.2d",endTime.hour(), endTime.minute());
 //      comboEnd->setText(s);
 //    }
 //    else if( obj == comboStart ){
 //      QString s;
 //      s.sprintf("%.2d:%.2d",startTime.hour(), startTime.minute());
 //      comboStart->setText(s);
 //    }
   }
 
   return false;
 }
 
 static void addOrPick( QComboBox* combo, const QString& t )
 {
     // Pick an  item if one excists
     for (int i=0; i<combo->count(); i++) {
         if ( combo->text(i) == t ) {
             combo->setCurrentItem(i);
             return;
         }
     }
 
     // Else add one
     combo->insertItem(t);
     combo->setCurrentItem(combo->count()-1);
 }
 
 DateEntry::DateEntry( bool startOnMonday, const Event &event, bool whichClock,
                       QWidget* parent,  const char* name )
     : DateEntryBase( parent, name ),
       ampm( whichClock ),
       startWeekOnMonday( startOnMonday ),
       m_showStart(true)
 
 {
     init();
     setDates(event.start(),event.end());
     comboCategory->setCategories( event.categories(), "Calendar", tr("Calendar") );
     if(!event.description().isEmpty())
         addOrPick( comboDescription, event.description() );
     if(!event.location().isEmpty())
         addOrPick( comboLocation, event.location() );
     checkAlarm->setChecked( event.hasAlarm() );
     checkAllDay->setChecked( event.type() == Event::AllDay );
     if(!event.notes().isEmpty()) noteStr=event.notes();
     else noteStr="";
     spinAlarm->setValue(event.alarmTime());
     if ( event.alarmSound() != Event::Silent )
         comboSound->setCurrentItem( 1 );
     if ( event.hasRepeat() ) {
         rp = event.repeatPattern();
         cmdRepeat->setText( tr("Repeat...") );
     }
     setRepeatLabel();
 }
 
 void DateEntry::setDates( const QDateTime& s, const QDateTime& e )
 {
     startDate = s.date();
     endDate = e.date();
     startTime = s.time();
     endTime = e.time();
 
     startDateChanged( s.date().year(), s.date().month(), s.date().day() );
     endDateChanged( e.date().year(), e.date().month(), e.date().day() );
 
     updateTimeEdit(true,true);
 }
 
 void DateEntry::updateTimeEdit(bool s, bool e) {
 
     // Comboboxes
     QString strStart, strEnd;
     int shour, ehour;
     if ( ampm ) {
         shour = startTime.hour();
         ehour = endTime.hour();
         if ( shour >= 12 ) {
             if ( shour > 12 )
                 shour -= 12;
             strStart.sprintf( "%d:%02d PM", shour, startTime.minute() );
         } else {
             if ( shour == 0 )
                 shour = 12;
             strStart.sprintf( "%d:%02d AM", shour, startTime.minute() );
         }
         if ( ehour == 24 && endTime.minute() == 0 ) {
             strEnd  = "11:59 PM"; // or "midnight"
         } else if ( ehour >= 12 ) {
             if ( ehour > 12 )
                 ehour -= 12;
             strEnd.sprintf( "%d:%02d PM", ehour, endTime.minute() );
         } else {
             if ( ehour == 0 )
                 ehour = 12;
             strEnd.sprintf( "%d:%02d AM", ehour, endTime.minute() );
         }
     } else {
         strStart.sprintf( "%02d:%02d", startTime.hour(), startTime.minute() );
         strEnd.sprintf( "%02d:%02d", endTime.hour(), endTime.minute() );
     }
 
     if (s) comboStart->setText(strStart);
     if (e) comboEnd->setText(strEnd);
 }
 
 void DateEntry::init()
 {
     comboDescription->setInsertionPolicy(QComboBox::AtCurrent);
     comboLocation->setInsertionPolicy(QComboBox::AtCurrent);
 
     initCombos();
     QPopupMenu *m1 = new QPopupMenu( this );
     startPicker = new DateBookMonth( m1, 0, TRUE );
     m1->insertItem( startPicker );
     buttonStart->setPopup( m1 );
     connect( startPicker, SIGNAL( dateClicked( int, int, int ) ),
              this, SLOT( startDateChanged( int, int, int ) ) );
 
     //Let start button change both start and end dates
     connect( startPicker, SIGNAL( dateClicked( int, int, int ) ),
              this, SLOT( endDateChanged( int, int, int ) ) );
     connect( qApp, SIGNAL( clockChanged( bool ) ),
              this, SLOT( slotChangeClock( bool ) ) );
     connect( qApp, SIGNAL(weekChanged(bool)),
              this, SLOT(slotChangeStartOfWeek(bool)) );
 
     connect( editNote, SIGNAL(clicked()),
              this, SLOT(slotEditNote()) );
 
     QPopupMenu *m2 = new QPopupMenu( this );
     endPicker = new DateBookMonth( m2, 0, TRUE );
     m2->insertItem( endPicker );
     buttonEnd->setPopup( m2 );
     connect( endPicker, SIGNAL( dateClicked( int, int, int ) ),
              this, SLOT( endDateChanged( int, int, int ) ) );
 
     connect(timePickerStart, SIGNAL( timeChanged(const QTime &) ),
             this, SLOT( startTimePicked(const QTime &) ));
     // install eventFilters
     comboEnd->installEventFilter( this );
     comboStart->installEventFilter( this );
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 DateEntry::~DateEntry()
 {
     // no need to delete child widgets, Qt does it all for us
         //cout << "Del: " << comboStart->currentText() << endl;
 }
 
 /*
  * public slot
  */
 
 void DateEntry::slotEditNote() {
   QString s;
   s = "<B>"+ TimeString::longDateString( startDate ) + "</B>";
 //  s.sprintf("<B>%d/%d</B> ", startDate.day(), startDate.month());
   NoteEntry noteDlg(s+comboDescription->currentText(), noteStr,
                     this,0,TRUE);
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-  noteDlg.showMaximized();
-#endif
-  if (noteDlg.exec() ) {
+  if ( QPEApplication::execDialog( &noteDlg ) ) {
     noteStr=noteDlg.note->text();
   }
 
 }
 
 void DateEntry::endDateChanged( int y, int m, int d )
 {
     endDate.setYMD( y, m, d );
     if ( endDate < startDate ) {
         endDate = startDate;
     }
 
     buttonEnd->setText( TimeString::shortDate( endDate ) );
 
     endPicker->setDate( endDate.year(), endDate.month(), endDate.day() );
 }
 
 static QTime parseTime( const QString& s, bool ampm )
 {
     QTime tmpTime;
     QStringList l = QStringList::split( ':', s );
     int hour = l[0].toInt();
     if ( ampm ) {
         int i=0;
         while (i<int(l[1].length()) && l[1][i]>='0' && l[1][i]<='9')
             i++;
         QString digits = l[1].left(i);
         if ( l[1].contains( "PM", FALSE ) ) {
             if ( hour != 12 )
                 hour += 12;
         } else {
             if ( hour == 12 )
                 hour = 0;
         }
         l[1] = digits;
     }
     int minute = l[1].toInt();
     if ( minute > 59 )
         minute = 59;
     else if ( minute < 0 )
         minute = 0;
     if ( hour > 23 ) {
         hour = 23;
         minute = 59;
     } else if ( hour < 0 )
         hour = 0;
     tmpTime.setHMS( hour, minute, 0 );
     return tmpTime;
 }
 
 /*
  * public slot
  */
 void DateEntry::endTimeChanged( const QString &s )
 {
   endTimeChanged( parseTime(s,ampm) );
 }
 
 void DateEntry::endTimeChanged( const QTime &t ) {
     if ( endDate > startDate || t >= startTime ) {
         endTime = t;
     } else {
         endTime = startTime;
         //comboEnd->setCurrentItem( comboStart->currentItem() );
     }
     timePickerStart->setHour(endTime.hour());
     timePickerStart->setMinute(endTime.minute());
 }
 
 /*
  * public slot
  */
 void DateEntry::startDateChanged( int y, int m, int d )
 {
     QDate prev = startDate;
     startDate.setYMD( y, m, d );
     if ( rp.type == Event::Weekly &&
          startDate.dayOfWeek() != prev.dayOfWeek() ) {
         // if we change the start of a weekly repeating event
         // set the repeating day appropriately
         char mask = 1 << (prev.dayOfWeek()-1);
         rp.days &= (~mask);
         rp.days |= 1 << (startDate.dayOfWeek()-1);
     }
 
     buttonStart->setText( TimeString::shortDate( startDate ) );
 
     // our pickers must be reset...
     startPicker->setDate( y, m, d );
     endPicker->setDate( y, m, d );
 }
 
 /*
  * public slot
  */
 void DateEntry::startTimeEdited( const QString &s )
 {
     startTimeChanged(parseTime(s,ampm));
     updateTimeEdit(false,true);
     timePickerStart->setHour(startTime.hour());
     timePickerStart->setMinute(startTime.minute());
 }
 
 void DateEntry::startTimeChanged( const QTime &t )
 {
     int duration=startTime.secsTo(endTime);
     startTime = t;
     endTime=t.addSecs(duration);
 }
 void DateEntry::startTimePicked( const QTime &t ) {
   if(m_showStart ){
     startTimeChanged(t);
     updateTimeEdit(true,true);
   }else{
     endTimeChanged(t);
     updateTimeEdit(false, true );
   }
 }
 
 /*
  * public slot
  */
 void DateEntry::typeChanged( const QString &s )
 {
     bool b = s != "All Day";
     buttonStart->setEnabled( b );
     comboStart->setEnabled( b );
     comboEnd->setEnabled( b );
 }
 
 void DateEntry::slotRepeat()
 {
     // Work around for compiler Bug..
     RepeatEntry *e;
 
     // it is better in my opinion to just grab this from the mother,
     // since, this dialog doesn't need to keep track of it...
     if ( rp.type != Event::NoRepeat )
         e = new RepeatEntry( startWeekOnMonday, rp, startDate, this);
     else
         e = new RepeatEntry( startWeekOnMonday, startDate, this );
 
-#if defined(Q_WS_QWS) || defined(_WS_QWS_)
-    e->showMaximized();
-#endif
-    if ( e->exec() ) {
+    if ( QPEApplication::execDialog( e ) ) {
         rp = e->repeatPattern();
         setRepeatLabel();
     }
     // deleting sounds like a nice idea...
     delete e;
 }
 
 void DateEntry::slotChangeStartOfWeek( bool onMonday )
 {
     startWeekOnMonday = onMonday;
 }
 
 Event DateEntry::event()
 {
     Event ev;
     Event::SoundTypeChoice st;
     ev.setDescription( comboDescription->currentText() );
     ev.setLocation( comboLocation->currentText() );
     ev.setCategories( comboCategory->currentCategories() );
     ev.setType( checkAllDay->isChecked() ? Event::AllDay : Event::Normal );
     if ( startDate > endDate ) {
         QDate tmp = endDate;
         endDate = startDate;
         startDate = tmp;
     }
 
     // This is now done in the changed slots
     //    startTime = parseTime( comboStart->text(), ampm );
     //endTime = parseTime( comboEnd->text(), ampm );
 
     if ( startTime > endTime && endDate == startDate ) {
         QTime tmp = endTime;
         endTime = startTime;
         startTime = tmp;
     }
     // don't set the time if theres no need too
     if ( ev.type() == Event::AllDay ) {
         startTime.setHMS( 0, 0, 0 );
         endTime.setHMS( 23, 59, 59 );
     }
 
     // adjust start and end times based on timezone
     QDateTime start( startDate, startTime );
     QDateTime end( endDate, endTime );
     time_t start_utc, end_utc;
 
 //    qDebug( "tz: %s", timezone->currentZone().latin1() );
 
     // get real timezone
     QString realTZ;
     realTZ = QString::fromLocal8Bit( getenv("TZ") );
 
     // set timezone
     if ( setenv( "TZ", timezone->currentZone(), true ) != 0 )
         qWarning( "There was a problem setting the timezone." );
 
     // convert to UTC based on selected TZ (calling tzset internally)
     start_utc = TimeConversion::toUTC( start );
     end_utc = TimeConversion::toUTC( end );
 
     // done playing around... put it all back
     unsetenv( "TZ" );
     if ( !realTZ.isNull() )
         if ( setenv( "TZ", realTZ, true ) != 0 )
             qWarning( "There was a problem setting the timezone." );
 
     // convert UTC to local time (calling tzset internally)
     ev.setStart( TimeConversion::fromUTC( start_utc ) );
     ev.setEnd( TimeConversion::fromUTC( end_utc ) );
 
     // we only have one type of sound at the moment... LOUD!!!
     if ( comboSound->currentItem() != 0 )
         st = Event::Loud;
     else
         st = Event::Silent;
     ev.setAlarm( checkAlarm->isChecked(), spinAlarm->value(), st );
     if ( rp.type != Event::NoRepeat )
         ev.setRepeat( TRUE, rp );
     ev.setNotes( noteStr );
 
                 //cout << "Start: " << comboStart->currentText() << endl;
 
     return ev;
 }
 
 void DateEntry::setRepeatLabel()
 {
 
     switch( rp.type ) {
         case Event::Daily:
             cmdRepeat->setText( tr("Daily...") );
             break;
         case Event::Weekly:
             cmdRepeat->setText( tr("Weekly...") );
             break;
         case Event::MonthlyDay:
         case Event::MonthlyDate:
             cmdRepeat->setText( tr("Monthly...") );
             break;
         case Event::Yearly:
             cmdRepeat->setText( tr("Yearly...") );
             break;
         default:
             cmdRepeat->setText( tr("No Repeat...") );
     }
 }
 
 void DateEntry::setAlarmEnabled( bool alarmPreset, int presetTime, Event::SoundTypeChoice sound )
 {
     checkAlarm->setChecked( alarmPreset );
     spinAlarm->setValue( presetTime );
     if ( sound != Event::Silent )
         comboSound->setCurrentItem( 1 );
     else
         comboSound->setCurrentItem( 0 );
 }
 
 void DateEntry::initCombos()
 {
     /*
     comboStart->clear();
     comboEnd->clear();
     if ( ampm ) {
         for ( int i = 0; i < 24; i++ ) {
             if ( i == 0 ) {
                 comboStart->insertItem( "12:00 AM" );
                 comboStart->insertItem( "12:30 AM" );
                 comboEnd->insertItem( "12:00 AM" );
                 comboEnd->insertItem( "12:30 AM" );
             } else if ( i == 12 ) {
                 comboStart->insertItem( "12:00 PM" );
                 comboStart->insertItem( "12:30 PM" );
                 comboEnd->insertItem( "12:00 PM" );
                 comboEnd->insertItem( "12:30 PM" );
             } else if ( i > 12 ) {
                 comboStart->insertItem( QString::number( i - 12 ) + ":00 PM" );
                 comboStart->insertItem( QString::number( i - 12 ) + ":30 PM" );
                 comboEnd->insertItem( QString::number( i - 12 ) + ":00 PM" );
                 comboEnd->insertItem( QString::number( i - 12 ) + ":30 PM" );
             } else {
                 comboStart->insertItem( QString::number( i) + ":00 AM" );
                 comboStart->insertItem( QString::number( i ) + ":30 AM" );
                 comboEnd->insertItem( QString::number( i ) + ":00 AM" );
                 comboEnd->insertItem( QString::number( i ) + ":30 AM" );
             }
         }
     } else {
         for ( int i = 0; i < 24; i++ ) {
             if ( i < 10 ) {
                 comboStart->insertItem( QString("0")
                                         + QString::number(i) + ":00" );
                 comboStart->insertItem( QString("0")
                                         + QString::number(i) + ":30" );
                 comboEnd->insertItem( QString("0")
                                       + QString::number(i) + ":00" );
                 comboEnd->insertItem( QString("0")
                                       + QString::number(i) + ":30" );
             } else {
                 comboStart->insertItem( QString::number(i) + ":00" );
                 comboStart->insertItem( QString::number(i) + ":30" );
                 comboEnd->insertItem( QString::number(i) + ":00" );
                 comboEnd->insertItem( QString::number(i) + ":30" );
             }
         }
     }
     */
 }
 
 void DateEntry::slotChangeClock( bool whichClock )
 {
     ampm = whichClock;
     initCombos();
     setDates( QDateTime( startDate, startTime ), QDateTime( endDate, endTime ) );
 }
 
diff --git a/core/pim/datebook2/mainwindow.cpp b/core/pim/datebook2/mainwindow.cpp
index be30415..7ff2204 100644
--- a/core/pim/datebook2/mainwindow.cpp
+++ b/core/pim/datebook2/mainwindow.cpp
@@ -1,305 +1,302 @@
 
 #include <qcopchannel_qws.h>
 #include <qwidgetstack.h>
 #include <qlabel.h>
 #include <qaction.h>
 #include <qpopupmenu.h>
 #include <qtimer.h>
 
 #include <qpe/qpeapplication.h>
 #include <qpe/ir.h>
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qpe/qpemessagebox.h>
 #include <qpe/resource.h>
 
 #include "editor.h"
 #include "show.h"
 #include "templatemanager.h"
 #include "bookmanager.h"
 #include "mainwindow.h"
 
 
 using namespace Datebook;
 
 MainWindow::MainWindow()
     : OPimMainWindow( "Datebook", 0, 0 ), m_descMan( "Descriptions" ),  m_locMan( "Locations" )
 {
     setIcon( Resource::loadPixmap( "datebook_icon" ) );
     initUI();
     initManagers();
     initView();
     initConfig();
 
     QTimer::singleShot(0, this, SLOT(populate() ) );
 
     QCopChannel* chan = new QCopChannel( "QPE/System", this );
     connect( chan, SIGNAL( received(const QCString&, const QByteArray& ) ),
              this, SLOT( slotReceive( const QCString&, const QByteArray& ) ) );
 
     chan  = new QCopChannel( "QPE/Datebook", this );
     connect( chan, SIGNAL( received(const QCString&, const QByteArray& ) ),
              this, SLOT( slotReceive( const QCString&, const QByteArray& ) ) );
 }
 MainWindow::~MainWindow() {
     m_tempMan.save();
     m_locMan.save();
     m_descMan.save();
 
     manager()->save();
     delete m_manager;
 }
 void MainWindow::doSetDocument( const QString& str ) {
 
 }
 void MainWindow::flush() {
     manager()->save();
 }
 void MainWindow::reload() {
     manager()->reload();
 }
 int MainWindow::create() {
     return 0;
 }
 bool MainWindow::remove( int uid ) {
     manager()->remove( uid );
     return true;
 }
 void MainWindow::beam( int uid ) {
 
 }
 void MainWindow::show( int uid ) {
 
     eventShow()->show( manager()->event( uid ) );
 }
 void MainWindow::add( const OPimRecord& ad) {
     manager()->add( ad );
 }
 void MainWindow::edit() {
     edit ( currentView()->currentItem() );
 }
 void MainWindow::edit( int uid ) {
 
 }
 /*
  * init tool bars layout and so on
  */
 void MainWindow::initUI() {
     setToolBarsMovable( false );
 
     m_stack = new QWidgetStack( this );
     setCentralWidget( m_stack );
 
     m_toolBar = new QToolBar( this );
     m_toolBar->setHorizontalStretchable( TRUE );
 
     QMenuBar* mb = new QMenuBar( m_toolBar );
 
     m_popView    = new QPopupMenu( this );
     m_popSetting = new QPopupMenu( this );
 
     mb->insertItem( tr("View"), m_popView );
     mb->insertItem( tr("Settings" ), m_popSetting );
 
     m_popTemplate = new QPopupMenu( this );
     m_popTemplate->setCheckable( TRUE );
     connect( m_popTemplate, SIGNAL(activated(int) ),
              this, SLOT(slotNewFromTemplate(int) ) );
     m_popView->insertItem(tr("New from template"), m_popTemplate, -1, 0);
 
 
     QAction* a = new QAction( tr("New Event"), Resource::loadPixmap("new"),
                               QString::null, 0, this, 0 );
     a->addTo( m_toolBar );
     a->addTo( m_popView );
     connect(a, SIGNAL( activated() ), this, SLOT( create() ) );
 
     a = new QAction( tr("Edit Event"), Resource::loadPixmap("edit"),
                      QString::null, 0, this, 0 );
     a->addTo( m_popView );
     connect(a, SIGNAL( activated() ), this, SLOT( edit() ) );
 
     a = new QAction( tr("Today" ), Resource::loadPixmap( "datebook/to_day"),
                      QString::null, 0, this, 0 );
     a->addTo( m_toolBar );
     connect(a, SIGNAL( activated() ), this, SLOT( slotGoToNow() ) );
 
     a = new QAction( tr("Find"), Resource::loadPixmap( "mag" ),
                      QString::null, 0, this, 0 );
     a->addTo( m_toolBar );
     connect(a, SIGNAL( activated() ), this, SLOT( slotFind() ) );
 
     a = new QAction( tr("Configure"), QString::null, 0, 0 );
     a->addTo( m_popSetting );
     connect(a, SIGNAL( activated() ), this, SLOT( slotConfigure() ) );
 
     a = new QAction( tr("Configure Locations"), QString::null, 0, 0 );
     a->addTo( m_popSetting );
     connect(a, SIGNAL( activated() ), this, SLOT( slotConfigureLocs() ) );
 
     a = new QAction( tr("Configure Descriptions"), QString::null, 0, 0 );
     a->addTo( m_popSetting );
     connect(a, SIGNAL( activated() ), this, SLOT(slotConfigureDesc() ) );
 
     a = new QAction( tr("Configure Templates"), QString::null, 0, 0 );
     a->addTo( m_popSetting );
     connect(a, SIGNAL( activated() ), this, SLOT(slotConfigureTemp() ) );
 
     connect( qApp, SIGNAL(clockChanged(bool) ),
              this, SLOT(slotClockChanged(bool) ) );
     connect( qApp, SIGNAL(weekChanged(bool) ),
              this, SLOT(slotWeekChanged(bool) ) );
 
     connect( qApp, SIGNAL(appMessage(const QCString&, const QByteArray& ) ),
              this, SLOT(slotAppMessage( const QCString&, const QByteArray& ) ) );
 }
 void MainWindow::initConfig() {
 
 }
 void MainWindow::initView() {
 
 }
 void MainWindow::initManagers() {
     m_manager = new BookManager;
 
     m_tempMan.load();
     m_locMan.load();
     m_descMan.load();
 
     setTemplateMenu();
 }
 void MainWindow::raiseCurrentView() {
 
 }
 /*
  * populate the view
  */
 void MainWindow::populate() {
     if (!manager()->isLoaded() )
         manager()->load();
 }
 void MainWindow::slotGoToNow() {
 
 }
 View* MainWindow::currentView() {
 
 }
 void MainWindow::slotFind() {
 
 }
 void MainWindow::slotConfigure() {
 
 }
 void MainWindow::slotClockChanged( bool ) {
 
 }
 void MainWindow::slotWeekChanged(bool ) {
 
 }
 void MainWindow::slotAppMessage( const QCString&, const QByteArray& ) {
 
 }
 void MainWindow::slotReceive( const QCString&, const QByteArray& ) {
 
 }
 BookManager* MainWindow::manager() {
     return m_manager;
 }
 TemplateManager MainWindow::templateManager() {
     return m_tempMan;
 }
 LocationManager MainWindow::locationManager() {
     return m_locMan;
 }
 DescriptionManager MainWindow::descriptionManager() {
     return m_descMan;
 }
 void MainWindow::setLocationManager( const LocationManager& loc) {
     m_locMan = loc;
 }
 void MainWindow::setDescriptionManager( const DescriptionManager& dsc ) {
     m_descMan = dsc;
 }
 Show* MainWindow::eventShow() {
     return m_show;
 }
 void MainWindow::slotAction( QAction* act ) {
 
 }
 void MainWindow::slotConfigureLocs() {
     LocationManagerDialog dlg( locationManager() );
     dlg.setCaption( tr("Configure Locations") );
-    dlg.showMaximized();
-    if (dlg.exec() == QDialog::Accepted ) {
+    if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted ) {
         setLocationManager( dlg.manager() );
     }
 }
 void MainWindow::slotConfigureDesc() {
     DescriptionManagerDialog dlg( descriptionManager() );
     dlg.setCaption( tr("Configure Descriptions") );
-    dlg.showMaximized();
-    if (dlg.exec() == QDialog::Accepted ) {
+    if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted ) {
         setDescriptionManager( dlg.manager() );
     }
 }
 void MainWindow::slotConfigureTemp() {
     TemplateDialog dlg( templateManager(), editor() );
     dlg.setCaption( tr("Configure Templates") );
-    dlg.showMaximized();
-    if ( dlg.exec() == QDialog::Accepted ) {
+    if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted ) {
         m_tempMan = dlg.manager();
         setTemplateMenu();
     }
 }
 void MainWindow::hideShow() {
 
 }
 void MainWindow::viewPopup(int ) {
 
 }
 void MainWindow::viewAdd(const QDate& ) {
 
 }
 void MainWindow::viewAdd( const QDateTime&, const QDateTime& ) {
 
 }
 bool MainWindow::viewAP()const{
 }
 bool MainWindow::viewStartMonday()const {
 
 }
 void MainWindow::setTemplateMenu() {
     m_popTemplate->clear();
 
     QStringList list = templateManager().names();
     for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
         m_popTemplate->insertItem( (*it) );
     }
 }
 /*
  * get the name of the item with the id id
  * then ask for an OEvent from the manager
  */
 void MainWindow::slotNewFromTemplate(int id ) {
     QString name = m_popTemplate->text( id );
 
     OEvent ev = templateManager().value( name );
 
     if ( editor()->edit( ev ) ) {
         ev =  editor()->event();
         ev.setUid( -1 );
         manager()->add( ev );
 
         /*
          * no we'll find out if the current view
          * should show the new event
          * and then we will ask it to refresh
          * FIXME for now we'll call a refresh
          */
         currentView()->reschedule();
         raiseCurrentView();
     }
 }
 Editor* MainWindow::editor() {
     return m_edit;
 }
diff --git a/core/pim/todo/mainwindow.cpp b/core/pim/todo/mainwindow.cpp
index d06a405..fc189bd 100644
--- a/core/pim/todo/mainwindow.cpp
+++ b/core/pim/todo/mainwindow.cpp
@@ -1,1045 +1,1044 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 <>
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <unistd.h>
 
 #include <qmenubar.h>
 #include <qmessagebox.h>
 #include <qtoolbar.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qwidgetstack.h>
 #include <qaction.h>
 #include <qtimer.h>
 #include <qvbox.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qwhatsthis.h>
 
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/ir.h>
 #include <qpe/resource.h>
 #include <qpe/qpemessagebox.h>
 #include <qpe/alarmserver.h>
 #include <qpe/timestring.h>
 #include <qpe/qpeapplication.h>
 
 #include <opie/orecur.h>
 #include <opie/opimnotifymanager.h>
 #include <opie/otodoaccessvcal.h>
 #include <opie/owidgetstack.h>
 
 #include <opie/oapplicationfactory.h>
 
 #include "quickeditimpl.h"
 #include "todotemplatemanager.h"
 #include "templateeditor.h"
 #include "tableview.h"
 
 #include "textviewshow.h"
 #include "todoeditor.h"
 #include "mainwindow.h"
 
 OPIE_EXPORT_APP( OApplicationFactory<Todo::MainWindow> )
 
 using namespace Todo;
 
 MainWindow::MainWindow( QWidget* parent,
                         const char* name, WFlags )
     : OPimMainWindow( "Todolist", parent, name, WType_TopLevel | WStyle_ContextHelp )
 {
     if (!name)
         setName("todo window");
 
     m_syncing = false;
     m_showing = false;
     m_counter = 0;
     m_tempManager = new TemplateManager();
     m_tempManager->load();
 
     initUI();
     initConfig();
     initViews();
     initActions();
     initEditor();
     initShow();
     initTemplate();
 
     populateTemplates();
     raiseCurrentView();
     QTimer::singleShot(0, this, SLOT(populateCategories() ) );
 }
 void MainWindow::initTemplate() {
     m_curTempEd = new TemplateEditor( this, templateManager() );
 }
 void MainWindow::initActions() {
 
     // Data menu
     m_edit->insertItem(QWidget::tr("New from template"), m_template,
                        -1, 0 );
 
     QAction* a = new QAction( QWidget::tr("New Task" ), Resource::loadPixmap( "new" ),
                               QString::null, 0, this, 0 );
     connect(a, SIGNAL( activated() ),
             this, SLOT( slotNew() ) );
     a->setWhatsThis( QWidget::tr( "Click here to create a new task." ) );
     a->addTo(m_tool );
     a->addTo(m_edit );
 
     a = new QAction( QWidget::tr("Edit Task"), Resource::loadIconSet( "edit" ),
                      QString::null, 0, this, 0 );
     connect(a, SIGNAL(activated() ),
             this, SLOT( slotEdit() ) );
     a->setWhatsThis( QWidget::tr( "Click here to modify the current task." ) );
     a->addTo( m_tool );
     a->addTo( m_edit );
     m_editAction = a;
 
     a = new QAction( QString::null, QWidget::tr("View Task"), 0, this, 0 );
     connect(a, SIGNAL( activated() ),
             this, SLOT( slotShowDetails() ) );
     a->addTo( m_edit );
 
     m_edit->insertSeparator();
 
     a = new QAction( QWidget::tr("Delete..."),  Resource::loadIconSet( "trash" ),
                      QString::null, 0, this, 0 );
     connect(a, SIGNAL(activated() ),
             this, SLOT(slotDelete() ) );
     a->setWhatsThis( QWidget::tr( "Click here to remove the current task." ) );
     a->addTo( m_tool );
     a->addTo( m_edit );
     m_deleteAction = a;
 
     a = new QAction( QString::null, QWidget::tr("Delete all..."), 0, this, 0 );
     connect(a, SIGNAL( activated() ),
             this, SLOT( slotDeleteAll() ) );
     a->addTo(m_edit );
     m_deleteAllAction = a;
 
     a = new QAction( QString::null, QWidget::tr("Delete completed"),
                      0, this, 0 );
     connect(a, SIGNAL( activated() ),
             this, SLOT( slotDeleteCompleted() ) );
     a->addTo(m_edit );
     a->setEnabled( TRUE );
     m_deleteCompleteAction = a;
 
     m_edit->insertSeparator();
 
     a = new QAction( QString::null, QWidget::tr("Duplicate"), 0, this, 0 );
     connect(a, SIGNAL( activated() ),
             this, SLOT( slotDuplicate() ) );
     a->addTo(m_edit );
     m_duplicateAction = a;
 
     m_edit->insertSeparator();
 
     if ( Ir::supported() ) {
         a = new QAction( QWidget::tr( "Beam" ), Resource::loadPixmap( "beam" ), QString::null, 0, this, 0 );
         connect( a, SIGNAL( activated() ), this, SLOT( slotBeam() ) );
         a->setWhatsThis( QWidget::tr( "Click here to send the current task to another device." ) );
         a->addTo( m_edit );
         a->addTo( m_tool );
     }
 
 #if 0
     // Options menu
     a = new QAction( QWidget::tr("Find"), Resource::loadIconSet( "mag" ),
                      QString::null, 0, this, 0 );
     connect(a, SIGNAL( activated() ), this, SLOT( slotFind() ) );
     a->addTo( m_options );
     m_findAction = a;
 
 
     m_options->insertSeparator();
 #endif
 
     m_completedAction = new QAction( QString::null, QWidget::tr("Show completed tasks"),
                                      0, this, 0, TRUE );
     m_completedAction->addTo( m_options );
     m_completedAction->setOn( showCompleted() );
     connect(m_completedAction, SIGNAL( toggled(bool) ), this, SLOT(slotShowCompleted(bool) ) );
 
     a = new QAction( QString::null, QWidget::tr("Show only over-due tasks"),
                      0, this, 0, TRUE );
     a->addTo( m_options );
     a->setOn( showOverDue() );
     connect(a, SIGNAL(toggled(bool)), this, SLOT(slotShowDue(bool) ) );
 
     m_showDeadLineAction = new QAction( QString::null, QWidget::tr("Show task deadlines"),
                                         0, this, 0, TRUE );
     m_showDeadLineAction->addTo( m_options );
     m_showDeadLineAction->setOn( showDeadline() );
     connect(m_showDeadLineAction, SIGNAL(toggled(bool) ), this, SLOT( slotShowDeadLine( bool ) ) );
 
     m_showQuickTaskAction = new QAction( QString::null, QWidget::tr("Show quick task bar"),
                                      0, this, 0, TRUE );
     m_showQuickTaskAction->addTo( m_options );
     m_showQuickTaskAction->setOn( showQuickTask() );
     connect(m_showQuickTaskAction, SIGNAL( toggled(bool) ), this, SLOT(slotShowQuickTask(bool) ) );
 
     m_options->insertSeparator();
 
     m_bar->insertItem( QWidget::tr("Data") ,m_edit );
     m_bar->insertItem( QWidget::tr("Category"),  m_catMenu );
     m_bar->insertItem( QWidget::tr("Options"), m_options );
 
     m_curQuick = new QuickEditImpl( this, m_quicktask );
     addToolBar( (QToolBar *)m_curQuick->widget(), QWidget::tr( "QuickEdit" ), QMainWindow::Top, TRUE );
     m_curQuick->signal()->connect( this, SLOT(slotQuickEntered() ) );
 
 }
 /* m_curCat from Config */
 void MainWindow::initConfig() {
     Config config( "todo" );
     config.setGroup( "View" );
     m_completed =  config.readBoolEntry( "ShowComplete", TRUE );
     m_curCat = config.readEntry( "Category",    QString::null );
     m_deadline =  config.readBoolEntry( "ShowDeadLine", TRUE);
     m_overdue = config.readBoolEntry("ShowOverDue", FALSE );
     m_quicktask = config.readBoolEntry("ShowQuickTask", TRUE);
 }
 void MainWindow::initUI() {
 
     m_stack = new OWidgetStack(this,  "main stack");
 
     setCentralWidget( m_stack );
 
     setToolBarsMovable( FALSE );
 
     QToolBar *menubarholder = new QToolBar( this );
     menubarholder->setHorizontalStretchable( TRUE );
     m_bar = new QMenuBar( menubarholder );
 
     m_tool = new QToolBar( this );
 
     /** QPopupMenu */
     m_edit = new QPopupMenu( this );
     m_options = new QPopupMenu( this );
     m_catMenu = new QPopupMenu( this );
     m_template = new QPopupMenu( this );
 
     m_catMenu->setCheckable( TRUE );
     m_template->setCheckable( TRUE );
 
     connect(m_catMenu, SIGNAL(activated(int) ),
             this, SLOT(setCategory(int) ) );
     connect(m_template, SIGNAL(activated(int) ),
             this, SLOT(slotNewFromTemplate(int) ) );
 }
 void MainWindow::initViews() {
 
     TableView* tableView = new TableView( this, m_stack );
     QWhatsThis::add( tableView, QWidget::tr( "This is a listing of all current tasks.\n\nThe list displays the following information:\n1. Completed - A green checkmark indicates task is completed.  Click here to complete a task.\n2. Priority - a graphical representation of task priority.  Double-click here to modify.\n3. Description - description of task.  Click here to select the task.\n4. Deadline - shows when task is due.  This column can be shown or hidden by selecting Options->'Show task deadlines' from the menu above." ) );
     m_stack->addWidget( tableView,  m_counter++ );
     m_views.append( tableView );
     m_curView = tableView;
     connectBase( tableView );
     /* add QString type + QString configname to
      * the View menu
      * and subdirs for multiple views
      */
 }
 void MainWindow::initEditor() {
     m_curEdit = new Editor();
 }
 void MainWindow::initShow() {
     m_curShow = new TextViewShow(this, this);
     m_stack->addWidget( m_curShow->widget() , m_counter++ );
 }
 MainWindow::~MainWindow() {
     delete templateManager();
 }
 void MainWindow::connectBase( ViewBase* ) {
     // once templates and signals mix we'll use it again
 }
 QPopupMenu* MainWindow::contextMenu( int , bool recur ) {
     QPopupMenu* menu = new QPopupMenu();
 
     m_editAction->addTo( menu );
     m_deleteAction->addTo( menu );
     m_duplicateAction->addTo( menu );
 
     menu->insertSeparator();
 
     /*
      * if this event recurs we allow
      * to detach it.
      * remove all
      */
     if ( recur ) {
         ; // FIXME
     }
 
     return menu;
 }
 QPopupMenu* MainWindow::options() {
     qWarning("Options");
     return m_options;
 }
 QPopupMenu* MainWindow::edit() {
     return m_edit;
 }
 QToolBar* MainWindow::toolbar() {
     return m_tool;
 }
 OTodoAccess::List MainWindow::list()const {
     return m_todoMgr.list();
 }
 OTodoAccess::List MainWindow::sorted( bool asc, int sortOrder ) {
     int cat = 0;
     if ( m_curCat != QWidget::tr("All Categories") )
         cat = currentCatId();
     if ( m_curCat == QWidget::tr("Unfiled") )
         cat = -1;
 
     qWarning(" Category %d %s",  cat, m_curCat.latin1() );
 
     int filter = 1;
 
     if (!m_completed )
         filter |= 4;
     if (m_overdue)
         filter |= 2;
 
     return m_todoMgr.sorted( asc, sortOrder, filter, cat );
 }
 OTodoAccess::List MainWindow::sorted( bool asc, int sortOrder, int addFilter) {
     int cat = 0;
     if ( m_curCat != QWidget::tr("All Categories") )
         cat = currentCatId();
 
     if ( m_curCat == QWidget::tr("Unfiled") )
         cat = -1;
 
     return m_todoMgr.sorted(asc, sortOrder, addFilter,  cat );
 }
 OTodo MainWindow::event( int uid ) {
     return m_todoMgr.event( uid );
 }
 bool MainWindow::isSyncing()const {
     return m_syncing;
 }
 TemplateManager* MainWindow::templateManager() {
     return m_tempManager;
 }
 Editor* MainWindow::currentEditor() {
     return m_curEdit;
 }
 TodoShow* MainWindow::currentShow() {
     return m_curShow;
 }
 void MainWindow::slotReload() {
     m_syncing = FALSE;
     m_todoMgr.reload();
     currentView()->updateView( );
     raiseCurrentView();
 }
 void MainWindow::closeEvent( QCloseEvent* e ) {
     if (m_stack->visibleWidget() == currentShow()->widget() ) {
         m_showing = false;
         raiseCurrentView();
         e->ignore();
         return;
     }
     /*
      * we should have flushed and now we're still saving
      * so there is no need to flush
      */
     if (m_syncing ) {
         e->accept();
         return;
     }
     bool quit = false;
     if ( m_todoMgr.saveAll() ){
         qWarning("saved");
         quit = true;
     }else {
         if ( QMessageBox::critical( this, QWidget::tr("Out of space"),
                                     QWidget::tr("Todo was unable\n"
                                        "to save your changes.\n"
                                        "Free up some space\n"
                                        "and try again.\n"
                                        "\nQuit Anyway?"),
                                     QMessageBox::Yes|QMessageBox::Escape,
                                     QMessageBox::No|QMessageBox::Default)
              != QMessageBox::No ) {
             e->accept();
             quit = true;
         }else
             e->ignore();
 
     }
 
     if (quit ) {
         Config config( "todo" );
         config.setGroup( "View" );
         config.writeEntry( "ShowComplete", showCompleted() );
         config.writeEntry( "Category", currentCategory() );
         config.writeEntry( "ShowDeadLine", showDeadline());
         config.writeEntry( "ShowOverDue", showOverDue() );
         config.writeEntry( "ShowQuickTask", showQuickTask() );
         /* save templates */
         templateManager()->save();
         e->accept();
         QTimer::singleShot(0, qApp, SLOT(closeAllWindows()) );
     }
 }
 void MainWindow::populateTemplates() {
     m_template->clear();
     QStringList list = templateManager()->templates();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         m_template->insertItem( (*it) );
     }
 }
 /*
  * slotNewFromTemplate
  * We use the edit widget to do
  * the config but we setUid(1)
  * to get a new uid
  */
 /*
  * first we get the name of the template
  * then we will use the TemplateManager
  */
 void MainWindow::slotNewFromTemplate( int id ) {
     QString name = m_template->text( id );
 
     OTodo event = templateManager()->templateEvent( name );
     event = currentEditor()->edit(this,
                                   event );
 
     if ( currentEditor()->accepted() ) {
         /* assign new todo */
         event.setUid( 1 );
         handleAlarms( OTodo(), event );
         m_todoMgr.add( event );
         currentView()->addEvent( event );
 
         populateCategories();
     }
     raiseCurrentView();
 }
 void MainWindow::slotNew() {
     create();
 }
 void MainWindow::slotDuplicate() {
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                                                          QWidget::tr("Data can not be edited, currently syncing"));
         return;
     }
     OTodo ev = m_todoMgr.event( currentView()->current() );
     /* let's generate a new uid */
     ev.setUid(1);
     m_todoMgr.add( ev );
 
     currentView()->addEvent( ev );
     raiseCurrentView();
 }
 void MainWindow::slotDelete() {
     if (!currentView()->current() )
         return;
 
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                                                          QWidget::tr("Data can not be edited, currently syncing"));
         return;
     }
     QString strName = currentView()->currentRepresentation();
     if (!QPEMessageBox::confirmDelete(this, QWidget::tr("Todo"), strName ) )
         return;
 
     handleAlarms( m_todoMgr.event( currentView()->current() ), OTodo() );
     m_todoMgr.remove( currentView()->current() );
     currentView()->removeEvent( currentView()->current() );
     raiseCurrentView();
 }
 void MainWindow::slotDelete(int uid ) {
     if( uid == 0 ) return;
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                                                          QWidget::tr("Data can not be edited, currently syncing"));
         return;
     }
     OTodo to = m_todoMgr.event(uid);
     if (!QPEMessageBox::confirmDelete(this, QWidget::tr("Todo"), to.toShortText() ) )
         return;
 
     handleAlarms(to, OTodo() );
     m_todoMgr.remove( to.uid() );
     currentView()->removeEvent( to.uid() );
     raiseCurrentView();
 }
 void MainWindow::slotDeleteAll() {
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                              QWidget::tr("Data can not be edited, currently syncing"));
         return;
     }
 
 
     if ( !QPEMessageBox::confirmDelete( this, QWidget::tr( "Todo" ), QWidget::tr("all tasks?") ) )
         return;
 
     m_todoMgr.removeAll();
     currentView()->clear();
 
     raiseCurrentView();
 }
 void MainWindow::slotDeleteCompleted() {
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                              QWidget::tr("Data can not be edited, currently syncing"));
         return;
     }
 
     if ( !QPEMessageBox::confirmDelete( this, QWidget::tr( "Todo" ), QWidget::tr("all completed tasks?") ) )
         return;
 
 
     m_todoMgr.removeCompleted();
     currentView()->updateView( );
 }
 void MainWindow::slotFind() {
 
 }
 void MainWindow::slotEdit() {
     slotEdit( currentView()->current() );
 }
 /*
  * set the category
  */
 void MainWindow::setCategory( int c) {
     if ( c <= 0 ) return;
 
 
     qWarning("Iterating over cats %d", c );
     for ( unsigned int i = 1; i < m_catMenu->count(); i++ )
         m_catMenu->setItemChecked(i, c == (int)i );
 
     if (c == 1 ) {
         m_curCat = QString::null;
         setCaption( QWidget::tr("Todo") + " - " + QWidget::tr("All Categories" ) );
 
     }else if ( c == (int)m_catMenu->count() - 1 ) {
         m_curCat = QWidget::tr("Unfiled");
         setCaption( QWidget::tr("Todo") + " - " + QWidget::tr("Unfiled") );
     }else {
         m_curCat = m_todoMgr.categories()[c-2];
         setCaption( QWidget::tr("Todo") + " - " + m_curCat );
     }
     m_catMenu->setItemChecked( c, true );
 
     currentView()->setShowCategory( m_curCat );
     raiseCurrentView();
 }
 void MainWindow::slotShowDeadLine( bool dead) {
     m_deadline = dead;
     currentView()->setShowDeadline( dead );
 }
 void MainWindow::slotShowCompleted( bool show) {
     m_completed = show;
     currentView()->setShowCompleted( m_completed );
 }
 void MainWindow::slotShowQuickTask( bool show ) {
     m_quicktask = show;
     if ( m_quicktask )
         m_curQuick->widget()->show();
     else
         m_curQuick->widget()->hide();
 }
 bool MainWindow::showOverDue()const {
     return m_overdue;
 }
 void MainWindow::setDocument( const QString& fi) {
     DocLnk doc(fi);
     if (doc.isValid() )
         receiveFile(doc.file() );
     else
         receiveFile(fi );
 }
 
 static const char *beamfile = "/tmp/opie-todo.vcs";
 void MainWindow::slotBeam() {
     beam( currentView()->current() );
 }
 void MainWindow::beamDone( Ir* ir) {
     delete ir;
     ::unlink( beamfile );
 }
 void MainWindow::receiveFile( const QString& filename ) {
     OTodoAccessVCal* cal = new OTodoAccessVCal(filename );
 
     OTodoAccess acc( cal );
     acc.load();
     OTodoAccess::List list = acc.allRecords();
 
     if (list.count()){
 
             QString message = QWidget::tr("<P>%1 new tasks arrived.<p>Would you like to add them to your Todolist?").arg(list.count() );
 
             if ( QMessageBox::information(this, QWidget::tr("New Tasks"),
                                           message, QMessageBox::Ok,
                                           QMessageBox::Cancel ) == QMessageBox::Ok ) {
                     OTodoAccess::List::Iterator it;
                     for ( it = list.begin(); it != list.end(); ++it )
                             m_todoMgr.add( (*it) );
 
                     currentView()->updateView();
             }
     }
 }
 
 void MainWindow::slotFlush() {
     m_syncing = TRUE;
     m_todoMgr.save();
 }
 void MainWindow::slotShowDetails() {
     slotShow( currentView()->current() );
 }
 /*
  * populate the Categories
  * Menu
  */
 void MainWindow::populateCategories() {
     m_todoMgr.load();
 
     m_catMenu->clear();
     int id, rememberId;
     id = 1;
     rememberId = 1;
 
     m_catMenu->insertItem( QWidget::tr( "All Categories" ), id++ );
     m_catMenu->insertSeparator();
     QStringList categories = m_todoMgr.categories();
     categories.append( QWidget::tr( "Unfiled" ) );
     for ( QStringList::Iterator it = categories.begin();
           it != categories.end(); ++it ) {
         m_catMenu->insertItem( *it, id );
         if ( *it == currentCategory() )
             rememberId = id;
         ++id;
     }
     setCategory( rememberId );
 }
 bool MainWindow::showCompleted()const {
     return m_completed;
 }
 bool MainWindow::showDeadline()const {
     return m_deadline;
 }
 bool MainWindow::showQuickTask()const {
     return m_quicktask;
 }
 QString MainWindow::currentCategory()const {
     return m_curCat;
 }
 int MainWindow::currentCatId() {
     return m_todoMgr.catId( m_curCat );
 }
 ViewBase* MainWindow::currentView() {
     return m_curView;
 }
 void MainWindow::raiseCurrentView() {
     // due QPE/Application/todolist show(int)
     // we might not have the populateCategories slot called once
     // we would show the otodo but then imediately switch to the currentView
     // if we're initially showing we shouldn't raise the table
     // in returnFromView we fix up m_showing
     if (m_showing ) return;
 
     m_stack->raiseWidget( m_curView->widget() );
 }
 void MainWindow::slotShowDue(bool ov) {
     m_overdue = ov;
     currentView()->showOverDue( ov );
     raiseCurrentView();
 }
 void MainWindow::slotShow( int uid ) {
     if ( uid == 0 ) return;
     qWarning("slotShow");
     currentShow()->slotShow( event( uid ) );
     m_stack->raiseWidget( currentShow()->widget() );
 }
 void MainWindow::slotShowNext() {
     int l = currentView()->next();
     if (l!=0)
         slotShow(l);
 }
 void MainWindow::slotShowPrev() {
     int l = currentView()->prev();
     if (l!=0)
         slotShow(l);
 }
 void MainWindow::slotEdit( int uid ) {
     if (uid == 0 ) return;
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                              QWidget::tr("Data can't be edited, currently syncing"));
         return;
     }
 
     OTodo old_todo = m_todoMgr.event( uid );
 
     OTodo todo = currentEditor()->edit(this, old_todo );
 
     /* if completed */
     if ( currentEditor()->accepted() ) {
         handleAlarms( old_todo, todo );
         m_todoMgr.update( todo.uid(), todo );
         currentView()->replaceEvent( todo );
         /* a Category might have changed */
         populateCategories();
     }
 
     raiseCurrentView();
 }
 /*
 void MainWindow::slotUpdate1( int uid, const SmallTodo& ev) {
     m_todoMgr.update( uid, ev );
 }
 */
 void MainWindow::updateTodo(  const OTodo& ev) {
     m_todoMgr.update( ev.uid() , ev );
 }
 /* The view changed it's configuration
  * update the view menu
  */
 void MainWindow::slotUpdate3( QWidget* ) {
 
 }
 void MainWindow::updateList() {
     m_todoMgr.updateList();
 }
 void MainWindow::setReadAhead( uint count ) {
     if (m_todoMgr.todoDB() )
         m_todoMgr.todoDB()->setReadAhead( count );
 }
 void MainWindow::slotQuickEntered() {
     qWarning("entered");
     OTodo todo = quickEditor()->todo();
     if (todo.isEmpty() )
         return;
 
     m_todoMgr.add( todo );
     currentView()->addEvent( todo );
     raiseCurrentView();
 }
 QuickEditBase* MainWindow::quickEditor() {
     return m_curQuick;
 }
 void MainWindow::slotComplete( int uid ) {
     slotComplete( event(uid) );
 }
 void MainWindow::slotComplete( const OTodo& todo ) {
     OTodo to = todo;
     to.setCompleted( !to.isCompleted() );
     to.setCompletedDate( QDate::currentDate() );
 
     /*
      * if the item does recur
      * we need to spin it off
      * and update the items duedate to the next
      * possible recurrance of this item...
      * the spinned off one will loose the
      * recurrence.
      * We calculate the difference between the old due date and the
      * new one and add this diff to start, completed and alarm dates
      * -zecke
      */
     if ( to.hasRecurrence() && to.isCompleted() ) {
         OTodo to2( to );
 
         /* the spinned off one won't recur anymore */
         to.setRecurrence( ORecur() );
 
         ORecur rec = to2.recurrence();
         rec.setStart( to.dueDate() );
         to2.setRecurrence( rec );
         /*
          * if there is a next occurence
          * from the duedate of the last recurrance
          */
         QDate date;
         if ( to2.recurrence().nextOcurrence( to2.dueDate().addDays(1), date ) ) {
             int dayDiff = to.dueDate().daysTo( date );
             qWarning("day diff is %d", dayDiff );
             QDate inval;
             /* generate a new uid for the old record */
             to.setUid( 1 );
 
             /* add the old one cause it has a new UID here cause it was spin off */
             m_todoMgr.add( to );
 
             /*
              * update the due date
              * start date
              * and complete date
              */
             to2.setDueDate( date );
             rec.setStart( date );
             to2.setRecurrence( rec );  // could be Monday, TuesDay, Thursday every week
 
             /* move start date */
             if (to2.hasStartDate() )
                 to2.setStartDate( to2.startDate().addDays( dayDiff ) );
 
             /* now the alarms */
             if (to2.hasNotifiers() ) {
                 OPimNotifyManager::Alarms _als = to2.notifiers().alarms();
                 OPimNotifyManager::Alarms als;
 
                 /* for every alarm move the day */
                 for ( OPimNotifyManager::Alarms::Iterator it = _als.begin(); it != _als.end(); ++it ) {
                     OPimAlarm al = (*it);
                     al.setDateTime( al.dateTime().addDays( dayDiff ) );
                     als.append( al );
                 }
                 to2.notifiers().setAlarms( als );
                 handleAlarms( OTodo(), todo );
             }
             to2.setCompletedDate( inval );
             to2.setCompleted( false );
 
             updateTodo( to2 );
         }else
             updateTodo( to );
     }else
         updateTodo( to );
 
     currentView()->updateView();
     raiseCurrentView();
 }
 void MainWindow::flush() {
     slotFlush();
 }
 void MainWindow::reload() {
     slotReload();
 }
 int MainWindow::create() {
     int uid = 0;
     if(m_syncing) {
         QMessageBox::warning(this, QWidget::tr("Todo"),
                              QWidget::tr("Data can not be edited, currently syncing"));
         return uid;
     }
     m_todoMgr.load();
 
 
     OTodo todo = currentEditor()->newTodo( currentCatId(),
                                            this );
 
     if ( currentEditor()->accepted() ) {
         //todo.assignUid();
         uid = todo.uid();
         handleAlarms( OTodo(), todo );
         m_todoMgr.add( todo );
         currentView()->addEvent( todo );
 
 
         // I'm afraid we must call this every time now, otherwise
         // spend expensive time comparing all these strings...
         // but only call if we changed something -zecke
         populateCategories();
     }
     raiseCurrentView( );
 
     return uid;
 }
 /* delete it silently... */
 bool MainWindow::remove( int uid ) {
     if (m_syncing) return false;
 
     /* argh need to get the whole OEvent... to disable alarms -zecke */
     handleAlarms( OTodo(), m_todoMgr.event( uid ) );
 
     return m_todoMgr.remove( uid );
 }
 void MainWindow::beam( int uid) {
     if( uid == 0 ) return;
 
     ::unlink( beamfile );
     m_todoMgr.load();
 
     OTodo todo = event( uid );
     OTodoAccessVCal* cal = new OTodoAccessVCal(QString::fromLatin1(beamfile) );
     OTodoAccess acc( cal );
     acc.load();
     acc.add( todo );
     acc.save();
     Ir* ir = new Ir(this );
     connect(ir, SIGNAL(done(Ir*) ),
             this, SLOT(beamDone(Ir*) ) );
     ir->send(beamfile, todo.summary(), "text/x-vCalendar" );
 }
 void MainWindow::show( int uid ) {
     m_todoMgr.load(); // might not be loaded yet
     m_showing = true;
     slotShow( uid );
     raise();
     QPEApplication::setKeepRunning();
 }
 void MainWindow::edit( int uid ) {
     m_todoMgr.load();
     slotEdit( uid );
 }
 void MainWindow::add( const OPimRecord& rec) {
     if ( rec.rtti() != OTodo::rtti() ) return;
     m_todoMgr.load(); // might not be loaded
 
     const OTodo& todo = static_cast<const OTodo&>(rec);
 
     m_todoMgr.add(todo );
     currentView()->addEvent( todo );
 
 
     // I'm afraid we must call this every time now, otherwise
     // spend expensive time comparing all these strings...
     // but only call if we changed something -zecke
     populateCategories();
 }
 void MainWindow::slotReturnFromView() {
     m_showing = false;
     raiseCurrentView();
 }
 
 namespace {
     OPimNotifyManager::Alarms findNonMatching( const OPimNotifyManager::Alarms& oldAls,
                                                const OPimNotifyManager::Alarms& newAls ) {
         OPimNotifyManager::Alarms nonMatching;
         OPimNotifyManager::Alarms::ConstIterator oldIt = oldAls.begin();
         OPimNotifyManager::Alarms::ConstIterator newIt;
         for ( ; oldIt != oldAls.end(); ++oldIt ) {
             bool found = false;
             QDateTime oldDt = (*oldIt).dateTime();
             for (newIt= newAls.begin(); newIt != newAls.end(); ++newIt ) {
                 if ( oldDt == (*newIt).dateTime() ) {
                     found = true;
                     break;
                     }
             }
             if (!found)
                 nonMatching.append( (*oldIt) );
         }
         return nonMatching;
     }
     void addAlarms( const OPimNotifyManager::Alarms& als, int uid ) {
         OPimNotifyManager::Alarms::ConstIterator it;
         for ( it = als.begin(); it != als.end(); ++it ) {
             qWarning("Adding alarm for %s", (*it).dateTime().toString().latin1() );
             AlarmServer::addAlarm( (*it).dateTime(), "QPE/Application/todolist", "alarm(QDateTime,int)", uid );
         }
 
     }
     void removeAlarms( const OPimNotifyManager::Alarms& als, int uid ) {
         OPimNotifyManager::Alarms::ConstIterator it;
         for ( it = als.begin(); it != als.end(); ++it ) {
             qWarning("Removinf alarm for %s",  (*it).dateTime().toString().latin1() );
             AlarmServer::deleteAlarm( (*it).dateTime(), "QPE/Application/todolist", "alarm(QDateTime,int)", uid );
         }
     }
 }
 
 void MainWindow::handleAlarms( const OTodo& oldTodo, const OTodo& newTodo) {
     /*
      * if oldTodo is not empty and has notifiers we need to find the deleted ones
      */
     if(!oldTodo.isEmpty() && oldTodo.hasNotifiers() ) {
         OPimNotifyManager::Alarms removed;
         OPimNotifyManager::Alarms oldAls = oldTodo.notifiers().alarms();
         if (!newTodo.hasNotifiers() )
             removed = oldAls;
         else
             removed = findNonMatching( oldAls, newTodo.notifiers().alarms() );
 
         removeAlarms( removed, oldTodo.uid() );
     }
     if ( newTodo.hasNotifiers() ) {
         OPimNotifyManager::Alarms added;
         if ( oldTodo.isEmpty() || !oldTodo.hasNotifiers() )
             added = newTodo.notifiers().alarms();
         else
             added = findNonMatching( newTodo.notifiers().alarms(), oldTodo.notifiers().alarms() );
 
         addAlarms( added, newTodo.uid() );
     }
 }
 /* we might have not loaded the db */
 void MainWindow::doAlarm( const QDateTime& dt, int uid ) {
     m_todoMgr.load();
 
     OTodo todo = m_todoMgr.event( uid );
     if (!todo.hasNotifiers() ) return;
 
     /*
      * let's find the right alarm and find out if silent
      * then show a richtext widget
      */
     bool loud = false;
     OPimNotifyManager::Alarms als = todo.notifiers().alarms();
     OPimNotifyManager::Alarms::Iterator it;
     for ( it = als.begin(); it != als.end(); ++it ) {
         if ( (*it).dateTime() == dt ) {
             loud = ( (*it).sound() == OPimAlarm::Loud );
             break;
         }
     }
     if (loud)
         startAlarm();
 
     QDialog dlg(this, 0, TRUE );
     QVBoxLayout* lay = new QVBoxLayout( &dlg );
     QTextView* view = new QTextView( &dlg );
     lay->addWidget( view );
     QPushButton* btnOk = new QPushButton( tr("Ok"), &dlg );
     connect( btnOk, SIGNAL(clicked() ), &dlg, SLOT(accept() ) );
     lay->addWidget( btnOk );
 
     QString text = tr("<h1>Alarm at %1</h1><br>").arg( TimeString::dateString( dt ) );
     text += todo.toRichText();
     view->setText( text );
 
-    dlg.showMaximized();
-    bool needToStay = dlg.exec();
+    bool needToStay = QPEApplication::execDialog( &dlg );
 
     if (loud)
         killAlarm();
 
     if (needToStay) {
 //        showMaximized();
 //        raise();
         QPEApplication::setKeepRunning();
 //        setActiveWindow();
     }
 
 }
 
diff --git a/core/pim/todo/todoeditor.cpp b/core/pim/todo/todoeditor.cpp
index c204325..78aedd6 100644
--- a/core/pim/todo/todoeditor.cpp
+++ b/core/pim/todo/todoeditor.cpp
@@ -1,63 +1,62 @@
 
+#include <qpe/qpeapplication.h>
+
 #include "otaskeditor.h"
 #include "todoeditor.h"
 
 using namespace Todo;
 
 Editor::Editor() {
     m_accepted = false;
     m_self = 0l;
 }
 Editor::~Editor() {
     delete m_self;
     m_self = 0;
 }
 OTodo Editor::newTodo( int cur,
                            QWidget*) {
 
     OTaskEditor *e = self();
     e->setCaption( QObject::tr("Enter Task") );
     e->init( cur );
 
+    int ret = QPEApplication::execDialog( e );
 
-    e->showMaximized();
-
-    int ret = e->exec();
     if ( QDialog::Accepted == ret ) {
         m_accepted = true;
     }else
         m_accepted = false;
 
     OTodo ev = e->todo();
     qWarning("Todo uid");
     qWarning("Todo %s %d %d", ev.summary().latin1(), ev.progress(), ev.isCompleted() );
     ev.setUid(1);
 
     return ev;
 }
 OTodo Editor::edit( QWidget *,
                         const OTodo& todo ) {
     OTaskEditor *e = self();
     e->init( todo );
     e->setCaption( QObject::tr( "Edit Task" ) );
 
-    e->showMaximized();
-    int ret = e->exec();
+    int ret = QPEApplication::execDialog( e );
 
     OTodo ev = e->todo();
     if ( ret == QDialog::Accepted )
         m_accepted = true;
     else
         m_accepted = false;
 
     return ev;
 }
 bool Editor::accepted()const {
     return m_accepted;
 }
 OTaskEditor* Editor::self() {
     if (!m_self )
         m_self = new OTaskEditor(0);
 
     return m_self;
 }
diff --git a/core/settings/light-and-power/light.cpp b/core/settings/light-and-power/light.cpp
index d6d09a1..b21215b 100644
--- a/core/settings/light-and-power/light.cpp
+++ b/core/settings/light-and-power/light.cpp
@@ -1,315 +1,315 @@
 /*
                              This file is part of the OPIE Project
                =.            Copyright (c)  2002 Maximilian Reiss <harlekin@handhelds.org>
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This file is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This file is distributed in the hope that
      +  .  -:.       =       it will be useful, but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU General
 ..}^=.=       =       ;      Public License for more details.
 ++=   -.     .`     .:
  :     =  ...= . :.=-        You should have received a copy of the GNU
  -.   .:....=;==+<;          General Public License along with this file;
   -_. . .   )=.  =           see the file COPYING. If not, write to the
     --        :-=`           Free Software Foundation, Inc.,
                              59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "light.h"
 
 #include <qpe/config.h>
 #include <qpe/power.h>
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
 #endif
+#include <qpe/qpeapplication.h>
 
 #include <qlabel.h>
 #include <qcheckbox.h>
 #include <qtabwidget.h>
 #include <qslider.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qgroupbox.h>
 #include <qcombobox.h>
 
 #include <opie/odevice.h>
 
 #include "sensor.h"
 
 using namespace Opie;
 
 LightSettings::LightSettings( QWidget* parent,  const char* name, WFlags )
         : LightSettingsBase( parent, name, false, WStyle_ContextHelp )
 {
         m_bres = ODevice::inst ( )-> displayBrightnessResolution ( );
         m_cres = ODevice::inst ( )-> displayContrastResolution ( );
 
     // check whether to show the light sensor stuff
 
         if ( !ODevice::inst ( )-> hasLightSensor ( )) {
                 auto_brightness-> hide ( );
                 CalibrateLightSensor-> hide ( );
                 auto_brightness_ac-> hide ( );
                 CalibrateLightSensor_ac-> hide ( );
         }
 
     // check whether to show the contrast stuff
 
         if (m_cres) {
                 GroupLight->setTitle(tr("Backlight && Contrast"));
                 GroupLight_ac->setTitle(GroupLight->title());
         } else {
                 contrast->hide();
                 contrast_ac->hide();
         }
 
     // check whether to show the cpu frequency stuff
 
         QStrList freq = ODevice::inst()->allowedCpuFrequencies();
         if ( freq.count() ) {
                 frequency->insertStrList( freq );
                 frequency_ac->insertStrList( freq );
         } else {
                 frequencyLabel->hide();
                 frequency->hide();
                 frequencyLabel_ac->hide();
                 frequency_ac->hide();
         }
 
     // check whether to show the hinge action stuff
 
     if ( !ODevice::inst()->hasHingeSensor() ) {
         closeHingeLabel->hide();
         closeHingeAction->hide();
         closeHingeLabel_ac->hide();
         closeHingeAction_ac->hide();
     }
 
         Config config ( "apm" );
         config. setGroup ( "Battery" );
 
         // battery spinboxes
         interval_dim->      setValue ( config. readNumEntry ( "Dim", 30 ));
         interval_lightoff-> setValue ( config. readNumEntry ( "LightOff", 20 ));
         interval_suspend->  setValue ( config. readNumEntry ( "Suspend", 60 ));
 
         // battery check and slider
         LcdOffOnly->setChecked ( config. readBoolEntry ( "LcdOffOnly", false ));
 
         // CPU frequency
         frequency->setCurrentItem( config.readNumEntry("Freq", 0) );
 
         // hinge action
         closeHingeAction->setCurrentItem( config.readNumEntry("CloseHingeAction", 0) );
 
     int bright = config. readNumEntry ( "Brightness", 127 );
         int contr  = m_oldcontrast = config. readNumEntry ( "Contrast", 127 );
         brightness-> setTickInterval ( QMAX( 16, 256 / m_bres ));
         brightness-> setLineStep ( QMAX( 1, 256 / m_bres ));
         brightness-> setPageStep ( QMAX( 1, 256 / m_bres ));
         brightness-> setValue ( bright );
 
         if (m_cres) {
                 contrast-> setTickInterval ( QMAX( 16, 256 / m_cres ));
                 contrast-> setLineStep ( QMAX( 1, 256 / m_cres ));
                 contrast-> setPageStep ( QMAX( 1, 256 / m_cres ));
                 contrast-> setValue ( contr );
         }
 
         // light sensor
         auto_brightness-> setChecked ( config. readBoolEntry ( "LightSensor", false ));
         m_sensordata = config. readListEntry ( "LightSensorData", ';' );
 
         config. setGroup ( "AC" );
 
         // ac spinboxes
         interval_dim_ac->      setValue ( config. readNumEntry ( "Dim", 60 ));
         interval_lightoff_ac-> setValue ( config. readNumEntry ( "LightOff", 120 ));
         interval_suspend_ac->  setValue ( config. readNumEntry ( "Suspend", 0 ));
 
         // ac check and slider
         LcdOffOnly_ac-> setChecked ( config. readBoolEntry ( "LcdOffOnly", false ));
 
         // CPU frequency
         frequency_ac->setCurrentItem( config.readNumEntry("Freq", 0) );
 
         // hinge action
         closeHingeAction_ac->setCurrentItem( config.readNumEntry("CloseHingeAction", 0) );
 
         bright = config. readNumEntry ( "Brightness", 255 );
         brightness_ac-> setTickInterval ( QMAX( 16, 256 / m_bres ));
         brightness_ac-> setLineStep ( QMAX( 1, 256 / m_bres ));
         brightness_ac-> setPageStep ( QMAX( 1, 256 / m_bres ));
         brightness_ac-> setValue ( bright );
 
         if (m_cres) {
                 contr = config. readNumEntry ( "Contrast", 127);
                 contrast_ac-> setTickInterval ( QMAX( 16, 256 / m_cres ));
                 contrast_ac-> setLineStep ( QMAX( 1, 256 / m_cres ));
                 contrast_ac-> setPageStep ( QMAX( 1, 256 / m_cres ));
                 contrast_ac-> setValue ( contr );
         }
 
         // light sensor
         auto_brightness_ac-> setChecked ( config. readBoolEntry ( "LightSensor", false ));
         m_sensordata_ac = config. readListEntry ( "LightSensorData", ';' );
 
         // warnings
         config. setGroup ( "Warnings" );
         warnintervalBox-> setValue ( config. readNumEntry ( "checkinterval", 10000 ) / 1000 );
         lowSpinBox->      setValue ( config. readNumEntry ( "powerverylow", 10 ) );
         criticalSpinBox-> setValue ( config. readNumEntry ( "powercritical", 5 ) );
 
         m_resettimer = new QTimer ( this );
         connect ( m_resettimer, SIGNAL( timeout ( )), this, SLOT( resetBacklight ( )));
 
         if ( PowerStatusManager::readStatus ( ). acStatus ( ) != PowerStatus::Online ) {
                 tabs-> setCurrentPage ( 0 );
         }
         else {
                 tabs-> setCurrentPage ( 1 );
         }
 
         connect ( brightness, SIGNAL( valueChanged ( int )), this, SLOT( setBacklight ( int )));
         connect ( brightness_ac, SIGNAL( valueChanged ( int )), this, SLOT( setBacklight ( int )));
         if (m_cres) {
                 connect ( contrast,    SIGNAL( valueChanged ( int )), this, SLOT( setContrast ( int )));
                 connect ( contrast_ac, SIGNAL( valueChanged ( int )), this, SLOT( setContrast ( int )));
         }
         connect( frequency, SIGNAL( activated(int) ), this, SLOT( setFrequency(int) ) );
         connect( frequency_ac, SIGNAL( activated(int) ), this, SLOT( setFrequency(int) ) );
         connect( closeHingeAction, SIGNAL( activated(int) ), this, SLOT( setCloseHingeAction(int) ) );
         connect( closeHingeAction_ac, SIGNAL( activated(int) ), this, SLOT( setCloseHingeAction(int) ) );
 }
 
 LightSettings::~LightSettings ( )
 {
 }
 
 void LightSettings::calibrateSensor ( )
 {
         Sensor *s = new Sensor ( m_sensordata, this );
         connect ( s, SIGNAL( viewBacklight ( int )), this, SLOT( setBacklight ( int )));
-        s-> showMaximized ( );
-        s-> exec ( );
+        QPEApplication::execDialog( s );
         delete s;
 }
 
 void LightSettings::calibrateSensorAC ( )
 {
         Sensor *s = new Sensor ( m_sensordata_ac, this );
         connect ( s, SIGNAL( viewBacklight ( int )), this, SLOT( setBacklight ( int )));
         s-> showMaximized ( );
         s-> exec ( );
         delete s;
 }
 
 void LightSettings::setBacklight ( int bright )
 {
         QCopEnvelope e ( "QPE/System", "setBacklight(int)" );
         e << bright;
 
         if ( bright != -1 ) {
                 m_resettimer-> stop ( );
                 m_resettimer-> start ( 4000, true );
         }
 }
 
 void LightSettings::setContrast ( int contr )
 {
         if (contr == -1) contr = m_oldcontrast;
         ODevice::inst ( )-> setDisplayContrast(contr);
 }
 
 void LightSettings::setFrequency ( int index )
 {
         qWarning("LightSettings::setFrequency(%d)", index);
         ODevice::inst ( )-> setCurrentCpuFrequency(index);
 }
 
 void LightSettings::resetBacklight ( )
 {
         setBacklight ( -1 );
         setContrast ( -1 );
 }
 
 void LightSettings::setCloseHingeAction ( int index )
 {
     qWarning("LightSettings::setCloseHingeStatus(%d)", index);
 }
 
 void LightSettings::accept ( )
 {
         Config config ( "apm" );
 
         // bat
         config. setGroup ( "Battery" );
         config. writeEntry ( "LcdOffOnly", LcdOffOnly-> isChecked ( ));
         config. writeEntry ( "Dim",        interval_dim-> value ( ));
         config. writeEntry ( "LightOff",   interval_lightoff-> value ( ));
         config. writeEntry ( "Suspend",    interval_suspend-> value ( ));
         config. writeEntry ( "Brightness", brightness-> value () );
         if (m_cres)
         config. writeEntry ( "Contrast",   contrast-> value () );
         config. writeEntry ( "Freq",       frequency->currentItem() );
         config. writeEntry ( "CloseHingeAction", closeHingeAction->currentItem() );
 
         // ac
         config. setGroup ( "AC" );
         config. writeEntry ( "LcdOffOnly", LcdOffOnly_ac-> isChecked ( ));
         config. writeEntry ( "Dim",        interval_dim_ac-> value ( ));
         config. writeEntry ( "LightOff",   interval_lightoff_ac-> value ( ));
         config. writeEntry ( "Suspend",    interval_suspend_ac-> value ( ));
         config. writeEntry ( "Brightness", brightness_ac-> value () );
         if (m_cres)
         config. writeEntry ( "Contrast",   contrast_ac-> value () );
         config. writeEntry ( "Freq",       frequency_ac->currentItem() );
         config. writeEntry ( "CloseHingeAction", closeHingeAction_ac->currentItem() );
 
         // only make light sensor stuff appear if the unit has a sensor
         if ( ODevice::inst ( )-> hasLightSensor ( )) {
                 config. setGroup ( "Battery" );
                 config. writeEntry ( "LightSensor", auto_brightness->isChecked() );
                 config. writeEntry ( "LightSensorData", m_sensordata, ';' );
                 config. setGroup ( "AC" );
                 config. writeEntry ( "LightSensor", auto_brightness_ac->isChecked() );
                 config. writeEntry ( "LightSensorData", m_sensordata_ac, ';' );
         }
 
         // advanced
         config. setGroup ( "Warnings" );
         config. writeEntry ( "check_interval", warnintervalBox-> value ( ) * 1000 );
         config. writeEntry ( "power_verylow",  lowSpinBox-> value ( ));
         config. writeEntry ( "power_critical", criticalSpinBox-> value ( ));
         config. write ( );
 
         // notify the launcher
         {
                 QCopEnvelope e ( "QPE/System", "reloadPowerWarnSettings()" );
         }
         {
                 QCopEnvelope e ( "QPE/System", "setScreenSaverInterval(int)" );
                 e << -1;
         }
         LightSettingsBase::accept ( );
 }
 
 void LightSettings::done ( int r )
 {
         m_resettimer-> stop ( );
         resetBacklight ( );
 
         LightSettingsBase::done ( r );
         close ( );
 }