2 files changed, 39 insertions, 21 deletions

diff --git a/core/apps/embeddedkonsole/commandeditdialog.cpp b/core/apps/embeddedkonsole/commandeditdialog.cpp
index 697bf72..1e08767 100644
--- a/core/apps/embeddedkonsole/commandeditdialog.cpp
+++ b/core/apps/embeddedkonsole/commandeditdialog.cpp
@@ -1,191 +1,200 @@
 //comandeditdialog.cpp
 
 #include "commandeditdialog.h"
 #include "playlistselection.h"
+
+#include <opie2/oresource.h>
+
 #include <qpe/config.h>
-#include <qpe/resource.h>
+
+#include <qapplication.h>
 #include <qtoolbutton.h>
 #include <qlineedit.h>
 #include <qheader.h>
 #include <qlabel.h>
 #include "smallcommandeditdialogbase.h"
 
 CommandEditDialog::CommandEditDialog(QWidget *parent, const char* name, WFlags fl )
     : CommandEditDialogBase(parent, name, TRUE, fl)
 
 {
   m_SuggestedCommandList->addColumn( tr("Command Selection") );
   m_SuggestedCommandList->header()->hide();
   m_SuggestedCommandList->setSorting(-1,FALSE);
   m_SuggestedCommandList->clearSelection();
   m_SuggestedCommandList->setSorting(0,TRUE);
   QListViewItem *item;
   item = new QListViewItem( m_SuggestedCommandList,"export ");
   item = new QListViewItem( m_SuggestedCommandList,"ifconfig ");
   item = new QListViewItem( m_SuggestedCommandList,"ipkg ");
   item = new QListViewItem( m_SuggestedCommandList,"gzip ");
   item = new QListViewItem( m_SuggestedCommandList,"gunzip ");
   item = new QListViewItem( m_SuggestedCommandList,"chgrp ");
   item = new QListViewItem( m_SuggestedCommandList,"chown ");
   item = new QListViewItem( m_SuggestedCommandList,"date ");
   item = new QListViewItem( m_SuggestedCommandList,"dd ");
   item = new QListViewItem( m_SuggestedCommandList,"dmesg ");
   item = new QListViewItem( m_SuggestedCommandList,"fuser ");
   item = new QListViewItem( m_SuggestedCommandList,"hostname ");
   item = new QListViewItem( m_SuggestedCommandList,"kill ");
   item = new QListViewItem( m_SuggestedCommandList,"killall ");
   item = new QListViewItem( m_SuggestedCommandList,"ln ");
   item = new QListViewItem( m_SuggestedCommandList,"ln -s ");
   item = new QListViewItem( m_SuggestedCommandList,"lsmod");
   item = new QListViewItem( m_SuggestedCommandList,"depmod -a");
   item = new QListViewItem( m_SuggestedCommandList,"modprobe ");
   item = new QListViewItem( m_SuggestedCommandList,"mount ");
   item = new QListViewItem( m_SuggestedCommandList,"more ");
   item = new QListViewItem( m_SuggestedCommandList,"sort ");
   item = new QListViewItem( m_SuggestedCommandList,"touch ");
   item = new QListViewItem( m_SuggestedCommandList,"umount ");
   item = new QListViewItem( m_SuggestedCommandList,"mknod ");
   item = new QListViewItem( m_SuggestedCommandList,"netstat ");
   item = new QListViewItem( m_SuggestedCommandList,"route ");
   item = new QListViewItem( m_SuggestedCommandList,"cardctl eject ");
   m_SuggestedCommandList->setSelected(m_SuggestedCommandList->firstChild(),TRUE);
   m_SuggestedCommandList->sort();
 
   connect( m_SuggestedCommandList, SIGNAL( clicked(QListViewItem*) ), m_PlayListSelection, SLOT( addToSelection(QListViewItem*) ) );
 
-
+  bool bigPixmaps = qApp->desktop()->size().width()>330;
 
   ToolButton1->setTextLabel("new");
-  ToolButton1->setPixmap(Resource::loadPixmap("new"));
+  ToolButton1->setUsesBigPixmap( bigPixmaps );
+  ToolButton1->setPixmap( Opie::Core::OResource::loadPixmap( "new", Opie::Core::OResource::SmallIcon ) );
   ToolButton1->setAutoRaise(TRUE);
   ToolButton1->setFocusPolicy(QWidget::NoFocus);
   connect(ToolButton1,SIGNAL(clicked()),this,SLOT(showAddDialog()));
 
   ToolButton2->setTextLabel("edit");
-  ToolButton2->setPixmap(Resource::loadPixmap("edit"));
+  ToolButton2->setUsesBigPixmap( bigPixmaps );
+  ToolButton2->setPixmap( Opie::Core::OResource::loadPixmap( "edit", Opie::Core::OResource::SmallIcon ) );
   ToolButton2->setAutoRaise(TRUE);
   ToolButton2->setFocusPolicy(QWidget::NoFocus);
   connect(ToolButton2,SIGNAL(clicked()),this,SLOT(showEditDialog()));
 
   ToolButton3->setTextLabel("delete");
-  ToolButton3->setPixmap(Resource::loadPixmap("editdelete"));
+  ToolButton3->setUsesBigPixmap( bigPixmaps );
+  ToolButton3->setPixmap( Opie::Core::OResource::loadPixmap( "editdelete", Opie::Core::OResource::SmallIcon ) );
   ToolButton3->setAutoRaise(TRUE);
   ToolButton3->setFocusPolicy(QWidget::NoFocus);
   connect(ToolButton3,SIGNAL(clicked()),m_PlayListSelection,SLOT(removeSelected()));
 
   ToolButton4->setTextLabel("up");
-  ToolButton4->setPixmap(Resource::loadPixmap("up"));
+  ToolButton4->setUsesBigPixmap( bigPixmaps );
+  ToolButton4->setPixmap( Opie::Core::OResource::loadPixmap( "up", Opie::Core::OResource::SmallIcon ) );
   ToolButton4->setAutoRaise(TRUE);
   ToolButton4->setFocusPolicy(QWidget::NoFocus);
   connect(ToolButton4,SIGNAL(clicked()),m_PlayListSelection,SLOT(moveSelectedUp()));
 
   ToolButton5->setTextLabel("down");
-  ToolButton5->setPixmap(Resource::loadPixmap("down"));
+  ToolButton5->setUsesBigPixmap( bigPixmaps );
+  ToolButton5->setPixmap( Opie::Core::OResource::loadPixmap( "down", Opie::Core::OResource::SmallIcon ) );
   ToolButton5->setAutoRaise(TRUE);
   ToolButton5->setFocusPolicy(QWidget::NoFocus);
 
 connect(ToolButton5,SIGNAL(clicked()),m_PlayListSelection,SLOT(moveSelectedDown()));
 
 
 
 
   QListViewItem *current = m_SuggestedCommandList->selectedItem();
     if ( current )
         item->moveItem( current );
     m_SuggestedCommandList->setSelected( item, TRUE );
     m_SuggestedCommandList->ensureItemVisible( m_SuggestedCommandList->selectedItem() );
   Config cfg( "Konsole" );
   cfg.setGroup("Commands");
   if (cfg.readEntry("Commands Set","FALSE") == "TRUE") {
    for (int i = 0; i < 100; i++) {
      QString tmp;
      tmp = cfg.readEntry( QString::number(i),"");
      if (!tmp.isEmpty())
          m_PlayListSelection->addStringToSelection(tmp);
    }
   } else {
 
 m_PlayListSelection->addStringToSelection("ls ");
 m_PlayListSelection->addStringToSelection("cardctl eject");
 m_PlayListSelection->addStringToSelection("cat ");
 m_PlayListSelection->addStringToSelection("cd ");
 m_PlayListSelection->addStringToSelection("chmod ");
 m_PlayListSelection->addStringToSelection("cp ");
 m_PlayListSelection->addStringToSelection("dc ");
 m_PlayListSelection->addStringToSelection("df ");
 m_PlayListSelection->addStringToSelection("dmesg");
 m_PlayListSelection->addStringToSelection("echo ");
 m_PlayListSelection->addStringToSelection("env");
 m_PlayListSelection->addStringToSelection("find ");
 m_PlayListSelection->addStringToSelection("free");
 m_PlayListSelection->addStringToSelection("grep ");
 m_PlayListSelection->addStringToSelection("ifconfig ");
 m_PlayListSelection->addStringToSelection("ipkg ");
 m_PlayListSelection->addStringToSelection("mkdir ");
 m_PlayListSelection->addStringToSelection("mv ");
 m_PlayListSelection->addStringToSelection("nc localhost 7776");
 m_PlayListSelection->addStringToSelection("nc localhost 7777");
 m_PlayListSelection->addStringToSelection("nslookup ");
 m_PlayListSelection->addStringToSelection("ping ");
 m_PlayListSelection->addStringToSelection("ps aux");
 m_PlayListSelection->addStringToSelection("pwd ");
 m_PlayListSelection->addStringToSelection("rm ");
 m_PlayListSelection->addStringToSelection("rmdir ");
 m_PlayListSelection->addStringToSelection("route ");
 m_PlayListSelection->addStringToSelection("set ");
 m_PlayListSelection->addStringToSelection("traceroute");
 
 }
 }
 CommandEditDialog::~CommandEditDialog()
 {
 }
 
 void CommandEditDialog::accept()
 {
 int i = 0;
   Config *cfg = new Config("Konsole");
   cfg->setGroup("Commands");
   cfg->clearGroup();
 
     QListViewItemIterator it( m_PlayListSelection );
 
     for ( ; it.current(); ++it ) {
 //    odebug << it.current()->text(0) << oendl; 
     cfg->writeEntry(QString::number(i),it.current()->text(0));
     i++;
 
     }
     cfg->writeEntry("Commands Set","TRUE");
 //    odebug << "CommandEditDialog::accept() - written" << oendl; 
     delete cfg;
     emit commandsEdited();
     close();
 
 
 
 
 
 }
 
 void CommandEditDialog::showEditDialog()
 {
 editCommandBase *d = new editCommandBase(this,"smalleditdialog", TRUE);
 d->setCaption("Edit command");
 d->TextLabel->setText("Edit command:");
 d->commandEdit->setText(m_PlayListSelection->currentItem()->text(0));
 int i = d->exec();
 if ((i==1) && (!(d->commandEdit->text()).isEmpty()))
   m_PlayListSelection->currentItem()->setText(0,(d->commandEdit->text()));
 }
 
 void CommandEditDialog::showAddDialog()
 {
 
 editCommandBase *d = new editCommandBase(this,"smalleditdialog", TRUE);
 int i = d->exec();
 if ((i==1) && (!(d->commandEdit->text()).isEmpty()))
 m_PlayListSelection->addStringToSelection(d->commandEdit->text());
 
 }
 
diff --git a/core/apps/embeddedkonsole/konsole.cpp b/core/apps/embeddedkonsole/konsole.cpp
index de00494..7f3ea65 100644
--- a/core/apps/embeddedkonsole/konsole.cpp
+++ b/core/apps/embeddedkonsole/konsole.cpp
@@ -1,1001 +1,1010 @@
 
 /* ---------------------------------------------------------------------- */
 /*                                                                        */
 /* [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>
 // enhancements added by Phillip Kuhn
 
 #include <stdlib.h>
 #include <sys/types.h>
 #include <pwd.h>
 #include <unistd.h>
 
 #ifdef  QT_QWS_OPIE
 #include <opie2/ocolorpopupmenu.h>
 #include <opie2/odebug.h>
+#include <opie2/oresource.h>
+
 using namespace Opie;
 #endif
 
-#include <qpe/resource.h>
-
 #include <qmenubar.h>
 #include <qtabbar.h>
 #include <qpe/config.h>
 #include <qfontdatabase.h>
 #include <qfile.h>
 #include <qspinbox.h>
 #include <qlayout.h>
 
 #include <sys/wait.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 
 #include "konsole.h"
 #include "commandeditdialog.h"
 
 class EKNumTabBar : public QTabBar
 {
 public:
     EKNumTabBar(QWidget *parent = 0, const char *name = 0) :
             QTabBar(parent, name)
     {}
 
     //  QList<QTab> *getTabList() { return(tabList()); }
 
     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();
             }
         }
     }
 
     virtual QSize sizeHint() const
     {
         if (isHidden())
         {
             return(QSize(0,0));
         }
         else
         {
             QSize size = QTabBar::sizeHint();
             int shrink = 5;
             if (qApp->desktop()->width() > 600 || qApp->desktop()->height() > 600)
             {
                 shrink = 10;
             }
             size.setHeight(size.height() - shrink);
             return(size);
         }
     }
 
 };
 
 class EKNumTabWidget : public QTabWidget
 {
 public:
     EKNumTabWidget(QWidget* parent) : QTabWidget(parent)
     {
         setTabBar(new EKNumTabBar(parent,"EKTabBar"));
         setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
     }
 
     EKNumTabBar *getTabBar() const
     {
         return ((EKNumTabBar*)tabBar());
     }
 
 
     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) odebug << "setuid failed" << oendl;
     if(setgid(getgid()) != 0) odebug << "setgid failed" << oendl;  // drop privileges
 
 
 //  QPEApplication::grabKeyboard(); // for CTRL and ALT
 
     odebug << "keyboard grabbed" << oendl;
 #ifdef FAKE_CTRL_AND_ALT
     odebug << "Fake Ctrl and Alt defined" << oendl;
     QPEApplication::grabKeyboard(); // for CTRL and ALT
 #endif
 
     *shell = getenv("SHELL");
     owarn << "SHell initially is " << *shell << "" << oendl;
 
     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();
     }
 
     if( putenv((char*)"COLORTERM=") !=0)
         odebug << "putenv failed" << oendl;  // to trigger mc's color detection
 }
 
 
 Konsole::Konsole(QWidget* parent, const char* name, WFlags fl) :
         QMainWindow(parent, name, fl)
 {
     QStrList tmp; const char* shell;
 
     konsoleInit( &shell);
     init(shell,tmp);
 }
 
 Konsole::Konsole(const char* name, const char* _pgm, QStrList & _args, int)
         : QMainWindow(0, name)
 {
     init(_pgm,_args);
 }
 
 struct HistoryItem
 {
     HistoryItem(int c, const QString &l)
     {
         count = c;
         line = l;
     }
     int count;
     QString line;
 };
 
 class HistoryList : public QList<HistoryItem>
 {
     virtual int compareItems( QCollection::Item item1, QCollection::Item item2)
     {
         int c1 = ((HistoryItem*)item1)->count;
         int c2 = ((HistoryItem*)item2)->count;
         if (c1 > c2)
             return(1);
         if (c1 < c2)
             return(-1);
         return(0);
     }
 };
 
 void Konsole::initCommandList()
 {
     //    odebug << "Konsole::initCommandList" << oendl;
     Config cfg( "Konsole" );
     cfg.setGroup("Commands");
     //    commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
     commonCombo->clear();
 
     if (cfg.readEntry("ShellHistory","TRUE") == "FALSE") {
         QString histfilename = QString(getenv("HOME")) + "/.bash_history";
         histfilename = cfg.readEntry("ShellHistoryPath",histfilename);
         QFile histfile(histfilename);
         // note: compiler barfed on:
         // QFile histfile(QString(getenv("HOME")) + "/.bash_history");
         if (histfile.open( IO_ReadOnly ))  {
             QString line;
             uint i;
             HistoryList items;
 
             int lineno = 0;
             while(!histfile.atEnd()) {
                 if (histfile.readLine(line, 200) < 0) {
                     break;
                 }
                 line = line.left(line.length()-1);
                 lineno++;
 
                 for(i=0; i<items.count(); i++) {
                     if (line == items.at(i)->line) {
                         // weight recent commands & repeated commands more
                         // by adding up the index of each command
                         items.at(i)->count += lineno;
                         break;
                     }
                 }
                 if (i >= items.count()) {
                     items.append(new HistoryItem(lineno, line));
                 }
             }
             items.sort();
             int n = items.count();
             if (n > 40) {
                 n = 40;
             }
             for(int i=0; i<n; i++) {
                 // should insert start of command, but keep whole thing
                 if (items.at(items.count()-i-1)->line.length() < 30) {
                     commonCombo->insertItem(items.at(items.count()-i-1)->line);
                 }
             }
             histfile.close();
         }
     }
     if (cfg.readEntry("Commands Set","FALSE") == "FALSE") {
         for (int i = 0; commonCmds[i] != NULL; i++) {
             commonCombo->insertItem(commonCmds[i]);
         }
     } else {
         for (int i = 0; i < 100; i++) {
             if (!(cfg.readEntry( QString::number(i),"")).isEmpty())
                 commonCombo->insertItem(cfg.readEntry( QString::number(i),""));
         }
     }
 
 
 }
 
 static void sig_handler(int x)
 {
     printf("got signal %d\n",x);
 }
 
 void Konsole::init(const char* _pgm, QStrList & _args)
 {
 
 #if 0
     for(int i=1; i<=31; i++)
     {
         if (i != SIGPIPE && i != SIGPROF && i != SIGSEGV
                 && i != SIGINT && i != SIGILL && i != SIGTERM
                 && i != SIGBUS)
             signal(i,sig_handler);
     }
 #endif
     signal(SIGSTOP, sig_handler);
     signal(SIGCONT, sig_handler);
     signal(SIGTSTP, sig_handler);
 
     b_scroll = TRUE; // histon;
     n_keytab = 0;
     n_render = 0;
     startUp=0;
     fromMenu = FALSE;
     fullscreen = false;
 
     setCaption( tr( "Konsole" ) );
-    setIcon( Resource::loadPixmap( "konsole/Terminal" ) );
+    setIcon( Opie::Core::OResource::loadPixmap( "konsole/Terminal", Opie::Core::OResource::SmallIcon ) );
 
     Config cfg( "Konsole" );
     cfg.setGroup("Font");
     QString tmp;
 
     // initialize the list of allowed fonts ///////////////////////////////////
 
     QString cfgFontName = cfg.readEntry("FontName","Lcfont");
     int cfgFontSize = cfg.readNumEntry("FontSize",18);
 
     cfont = -1;
 
     // this code causes repeated access to all the font files
     // which does slow down startup
     QFontDatabase fontDB;
     QStringList familyNames;
     familyNames = fontDB.families( FALSE );
     QString s;
     int fontIndex = 0;
     int familyNum = 0;
     fontList = new QPopupMenu( this );
 
     for(uint j = 0; j < (uint)familyNames.count(); j++)
     {
         s = familyNames[j];
         if ( s.contains('-') )
         {
             int i = s.find('-');
             s = s.right( s.length() - i - 1 ) + " [" + s.left( i ) + "]";
         }
         s[0] = s[0].upper();
 
         QValueList<int> sizes = fontDB.pointSizes( familyNames[j] );
 
         printf("family[%d] = %s with %d sizes\n", j, familyNames[j].latin1(),
                sizes.count());
 
         if (sizes.count() > 0)
         {
             QPopupMenu *sizeMenu;
             QFont f;
             int last_width = -1;
             sizeMenu = NULL;
 
             for(uint i = 0; i < (uint)sizes.count() + 4; i++)
             {
                 //    printf("family %s size %d  ", familyNames[j].latin1(), sizes[i]);
                 // need to divide by 10 on the Z, but not otherwise
                 int size;
 
                 if (i >= (uint)sizes.count())
                 {
                     // try for expandable fonts
                     size = sizes[sizes.count()-1] + 2 * (i - sizes.count() + 1);
                 }
                 else
                 {
                     printf("sizes[%d] = %d\n", i, sizes[i]);
                     size = sizes[i];
                 }
 
                 f = QFont(familyNames[j], size);
                 f.setFixedPitch(true);
                 QFontMetrics fm(f);
                 // don't trust f.fixedPitch() or f.exactMatch(), they lie!!
                 if (fm.width("l") == fm.width("m")
                         && (i < (uint)sizes.count()
                             || fm.width("m") > last_width))
                 {
                     if (i < (uint)sizes.count())
                     {
                         last_width = fm.width("m");
                     }
                     if (sizeMenu == NULL)
                     {
                         sizeMenu = new QPopupMenu();
                     }
                     int id = sizeMenu->insertItem(QString("%1").arg(size), fontIndex);
                     sizeMenu->setItemParameter(id, fontIndex);
                     sizeMenu->connectItem(id, this, SLOT(setFont(int)));
                     QString name = s + " " + QString::number(size);
                     fonts.append(new VTFont(name, f, familyNames[j], familyNum, size));
                     if (familyNames[j] == cfgFontName && size == cfgFontSize)
                     {
                         cfont = fontIndex;
                     }
                     printf("FOUND: %s family %s size %d\n", name.latin1(), familyNames[j].latin1(), size);
                     fontIndex++;
                 }
             }
             if (sizeMenu)
             {
                 fontList->insertItem(s, sizeMenu, familyNum + 1000);
 
                 familyNum++;
             }
         }
 
     }
 
     if (cfont < 0 || cfont >= (int)fonts.count())
     {
         cfont = 0;
     }
 
     // create terminal emulation framework ////////////////////////////////////
     nsessions = 0;
 
     tab = new EKNumTabWidget(this);
     //  tab->setMargin(tab->margin()-5);
     connect(tab, SIGNAL(currentChanged(QWidget*)), this, SLOT(switchSession(QWidget*)));
 
     // create terminal toolbar ////////////////////////////////////////////////
     setToolBarsMovable( FALSE );
     menuToolBar = new QToolBar( this );
     menuToolBar->setHorizontalStretchable( TRUE );
 
     QMenuBar *menuBar = new QMenuBar( menuToolBar );
 
     setFont(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")
     {
         ec_cmdlist = editCommandListMenu->insertItem( tr( "Show command list" ));
         listHidden=TRUE;
     }
     else
     {
         ec_cmdlist = editCommandListMenu->insertItem( tr( "Hide command list" ));
         listHidden=FALSE;
     }
 
     cfg.setGroup("Tabs");
 
     tabMenu = new QPopupMenu(this);
     tm_bottom = tabMenu->insertItem(tr("Bottom" ));
     tm_top = tabMenu->insertItem(tr("Top"));
     tm_hidden = tabMenu->insertItem(tr("Hidden"));
 
     configMenu->insertItem(tr("Tabs"), tabMenu);
 
     tmp=cfg.readEntry("Position","Top");
     if(tmp=="Top")
     {
         tab->setTabPosition(QTabWidget::Top);
         tab->getTabBar()->show();
         tabPos = tm_top;
     }
     else if (tmp=="Bottom")
     {
         tab->setTabPosition(QTabWidget::Bottom);
         tab->getTabBar()->show();
         tabPos = tm_bottom;
     }
     else
     {
         tab->getTabBar()->hide();
         tab->setMargin(tab->margin());
         tabPos = tm_hidden;
     }
 
     cm_bw = colorMenu->insertItem(tr( "Black on White"));
     cm_wb = colorMenu->insertItem(tr( "White on Black"));
     cm_gb = colorMenu->insertItem(tr( "Green on Black"));
     //  cm_bt = colorMenu->insertItem(tr( "Black on Transparent"));
     cm_br = colorMenu->insertItem(tr( "Black on Pink"));
     cm_rb = colorMenu->insertItem(tr( "Pink on Black"));
     cm_gy = colorMenu->insertItem(tr( "Green on Yellow"));
     cm_bm = colorMenu->insertItem(tr( "Blue on Magenta"));
     cm_mb = colorMenu->insertItem(tr( "Magenta on Blue"));
     cm_cw = colorMenu->insertItem(tr( "Cyan on White"));
     cm_wc = colorMenu->insertItem(tr( "White on Cyan"));
     cm_bb = colorMenu->insertItem(tr( "Blue on Black"));
     cm_ab = colorMenu->insertItem(tr( "Amber on Black"));
     cm_default = colorMenu->insertItem(tr("default"));
 
 #ifdef QT_QWS_OPIE
 
     colorMenu->insertItem(tr( "Custom"));
 #endif
 
     configMenu->insertItem(tr( "Colors") ,colorMenu);
 
     sessionList = new QPopupMenu(this);
-    sessionList-> insertItem ( Resource::loadPixmap ( "konsole/Terminal" ), tr( "new session" ),  this,
-                               SLOT(newSession()) );
+    sessionList-> insertItem ( Opie::Core::OResource::loadPixmap( "konsole/Terminal", Opie::Core::OResource::SmallIcon ),
+                               tr( "new session" ), this, SLOT(newSession()) );
 
     //  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( tabMenu, SIGNAL( activated(int) ), this, SLOT( tabMenuSelected(int) ));
     connect( scrollMenu, SIGNAL(activated(int)),this,SLOT(scrollMenuSelected(int)));
     connect( editCommandListMenu,SIGNAL(activated(int)),this,SLOT(editCommandListMenuSelected(int)));
     connect( sessionList, SIGNAL(activated(int)), this, SLOT( sessionListSelected(int) ) );
 
     menuBar->insertItem( tr("View"), configMenu );
     menuBar->insertItem( tr("Fonts"), fontList );
     menuBar->insertItem( tr("Sessions"), sessionList );
 
     toolBar = new QToolBar( this );
 
     QAction *a;
 
     // Button Commands
-    a = new QAction( tr("New"), Resource::loadPixmap( "konsole/konsole" ), QString::null, 0, this, 0 );
+    a = new QAction( tr("New"), Opie::Core::OResource::loadPixmap( "konsole/konsole", Opie::Core::OResource::SmallIcon ),
+                     QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( newSession() ) );
     a->addTo( toolBar );
 
-    a = new QAction( tr("Full Screen"), Resource::loadPixmap( "fullscreen" ), QString::null, 0, this, 0 );
+    a = new QAction( tr("Full Screen"), Opie::Core::OResource::loadPixmap( "fullscreen", Opie::Core::OResource::SmallIcon ),
+                     QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( toggleFullScreen() ) );
     a->addTo( toolBar );
 
-    a = new QAction( tr("Zoom"), Resource::loadPixmap( "zoom" ), QString::null, 0, this, 0 );
+    a = new QAction( tr("Zoom"), Opie::Core::OResource::loadPixmap( "zoom", Opie::Core::OResource::SmallIcon ),
+                     QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( cycleZoom() ) );
     a->addTo( toolBar );
 
 
-    a = new QAction( tr("Enter"), Resource::loadPixmap( "konsole/enter" ), QString::null, 0, this, 0 );
+    a = new QAction( tr("Enter"), Opie::Core::OResource::loadPixmap( "konsole/enter", Opie::Core::OResource::SmallIcon ),
+                     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 );
+    a = new QAction( tr("Space"), Opie::Core::OResource::loadPixmap( "konsole/space", Opie::Core::OResource::SmallIcon ),
+                     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 );
+    a = new QAction( tr("Tab"), Opie::Core::OResource::loadPixmap( "konsole/tab", Opie::Core::OResource::SmallIcon ),
+                     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 );
+    a = new QAction( tr("Up"), Opie::Core::OResource::loadPixmap( "konsole/up", Opie::Core::OResource::SmallIcon ),
+                     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 );
+    a = new QAction( tr("Down"), Opie::Core::OResource::loadPixmap( "konsole/down", Opie::Core::OResource::SmallIcon ),
+                     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 );
+    a = new QAction( tr("Paste"), Opie::Core::OResource::loadPixmap( "paste", Opie::Core::OResource::SmallIcon ),
+                     QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( hitPaste() ) );
     a->addTo( toolBar );
 
     secondToolBar = new QToolBar( this );
     secondToolBar->setHorizontalStretchable( TRUE );
 
     commonCombo = new QComboBox( secondToolBar );
     //  commonCombo->setMaximumWidth(236);
 
     ec_quick = editCommandListMenu->insertItem( tr( "Quick Edit" ) );
     if( listHidden)
     {
         secondToolBar->hide();
         editCommandListMenu->setItemEnabled(ec_quick ,FALSE);
     }
     ec_edit = 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) ));
 
     sm_none = scrollMenu->insertItem(tr( "None" ));
     sm_left = scrollMenu->insertItem(tr( "Left" ));
     sm_right = scrollMenu->insertItem(tr( "Right" ));
     //   scrollMenu->insertSeparator(4);
     //   scrollMenu->insertItem(tr( "Horizontal" ));
 
     configMenu->insertItem(tr( "ScrollBar" ),scrollMenu);
 
     configMenu->insertItem(tr( "History..." ), this, SLOT(historyDialog()));
 
     cm_wrap = configMenu->insertItem(tr( "Wrap" ));
     cfg.setGroup("ScrollBar");
     configMenu->setItemChecked(cm_wrap, cfg.readBoolEntry("HorzScroll",0));
 
     cm_beep = configMenu->insertItem(tr( "Use Beep" ));
     cfg.setGroup("Menubar");
     configMenu->setItemChecked(cm_beep, cfg.readBoolEntry("useBeep",0));
 
     fullscreen_msg = new QLabel(this);
     fullscreen_msg-> setAlignment ( AlignCenter | SingleLine );
     fullscreen_msg-> hide();
     fullscreen_msg-> setSizePolicy ( QSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Expanding ));
     fullscreen_msg-> setAutoResize(true);
     fullscreen_msg-> setFrameStyle(QFrame::PopupPanel | QFrame::Raised);
     fullscreen_msg-> setText(tr("To exit fullscreen, tap here."));
 
     fullscreen_timer = new QTimer(this);
     connect(fullscreen_timer, SIGNAL(timeout()),
             this, SLOT(fullscreenTimeout()));
     show_fullscreen_msg = true;
 
     //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;
 
     cfg.setGroup("CommandLine");
 
     if (cfg.hasKey("shell_args"))
     {
         QStringList se_args_list = cfg.readListEntry("shell_args",'|');
         for(uint i = 0; i < se_args_list.count(); i++)
         {
             se_args.prepend(se_args_list[se_args_list.count() - i - 1].latin1());
         }
     }
     else
     {
         se_args.prepend("--login");
     }
 
     se_pgm = cfg.readEntry("shell_bin", QString(se_pgm));
 
     // this is the "documentation" for those who know to look
     if (! cfg.hasKey("shell_args"))
     {
         cfg.writeEntry("shell_args",QStringList::fromStrList(se_args),'|');
     }
     if (! cfg.hasKey("shell_bin"))
     {
         cfg.writeEntry("shell_bin",QString(se_pgm));
     }
 
     parseCommandLine();
 
     // read and apply default values ///////////////////////////////////////////
     resize(321, 321); // Dummy.
     QSize currentSize = size();
     if (currentSize != size())
         defaultSize = size();
 
 
     /* allows us to catch cancel/escape */
     reparent ( 0, WStyle_Customize | WStyle_NoBorder,
                QPoint ( 0, 0 ));
 }
 
 void Konsole::show()
 {
     if ( !nsessions )
     {
         newSession();
     }
     QMainWindow::show();
 
 }
 
 void Konsole::initSession(const char*, QStrList &)
 {
     QMainWindow::show();
 }
 
 Konsole::~Konsole()
 {
     while (nsessions > 0)
     {
         doneSession(getTe(), 0);
     }
 }
 
 void
 Konsole::historyDialog()
 {
     QDialog *d = new QDialog ( this, "histdlg", true );
     //    d-> setCaption ( tr( "History" ));
 
     QBoxLayout *lay = new QVBoxLayout ( d, 4, 4  );
 
     QLabel *l = new QLabel ( tr( "History Lines:" ), d );
     lay-> addWidget ( l );
 
     Config cfg( "Konsole" );
     cfg.setGroup("History");
     int hist = cfg.readNumEntry("history_lines",300);
     int avg_line = cfg.readNumEntry("avg_line_length",60);
 
     QSpinBox *spin = new QSpinBox ( 1, 100000, 20, d );
     spin-> setValue ( hist );
     spin-> setWrapping ( true );
     spin-> setButtonSymbols ( QSpinBox::PlusMinus );
     lay-> addWidget ( spin );
 
     if ( d-> exec ( ) == QDialog::Accepted )
     {
         cfg.writeEntry("history_lines", spin->value());
         cfg.writeEntry("avg_line_length", avg_line);
         if (getTe() != NULL)
         {
             getTe()->currentSession->setHistory(true);
         }
     }
 
     delete d;
 }
 
 
 void Konsole::cycleZoom()
 {
     TEWidget* te = getTe();
     QFont font = te->getVTFont();
     int size = font.pointSize();
     changeFontSize(1);
     font = te->getVTFont();
     if (font.pointSize() <= size)
     {
         do
         {
             font = te->getVTFont();
             size = font.pointSize();
             changeFontSize(-1);
             font = te->getVTFont();
         }
         while (font.pointSize() < size);
     }
 }
 
 void Konsole::changeFontSize(int delta)
 {
     //  printf("delta font size %d\n", delta);
     TEWidget* te = getTe();
     QFont font = te->getVTFont();
     int size = font.pointSize();
     int closest = delta > 0? 10000 : -10000;
     int closest_font = -1;
     for(uint i = 0; i < fonts.count(); i++)
     {
         if (fonts.at(i)->getFont() == font)
         {
             if (delta > 0)
             {
                 if (i+1 < fonts.count()
                         && fonts.at(i+1)->getFamilyNum() == fonts.at(i)->getFamilyNum())
                 {
                     setFont(i+1);
                     printf("font %d\n", i+1);
                     return;
                 }
             }
             else if (delta < 0)
             {
                 if (i > 0
                         && fonts.at(i-1)->getFamilyNum() == fonts.at(i)->getFamilyNum())
                 {
                     setFont(i-1);
                     printf("font %d\n", i-1);
                     return;
                 }
             }
         }
         int fsize = fonts.at(i)->getSize();
         printf("%d size=%d fsize=%d closest=%d\n", i, size, fsize, closest);
         if ((delta > 0 && fsize > size && fsize < closest)
                 || (delta < 0 && fsize < size && fsize > closest))
         {
             closest = fsize;
             closest_font = i;
         }
     }
     if (closest_font >= 0)
     {
         printf("font closest %d (%d)\n", closest_font, closest);
         setFont(closest_font);
     }
 }
 
 int Konsole::findFont(const QString& name, int size, bool exactMatch)
 {
     for(uint i = 0; i < fonts.count(); i++)
     {
         if (fonts.at(i)->getName() == name
                 && fonts.at(i)->getSize() == size)
         {
             return(i);
         }
     }
     if (exactMatch)
     {
         return(-1);
     }
     for(uint i = 0; i < fonts.count(); i++)
     {
         if (fonts.at(i)->getSize() == size)
         {
             return(i);
         }
     }
     return(-1);
 }
 
 void Konsole::setFont(int f)
 {
     VTFont* font = fonts.at(f);
     if (font)
     {
         TEWidget* te = getTe();
         if (te != 0)
         {
             te->setVTFont(font->getFont());
         }
         cfont = f;
 
         int familyNum = font->getFamilyNum();
         int size = font->getSize();
         printf("familyNum = %d  size = %d  count=%d\n", familyNum, size,
                fontList->count());
         for(int i = 0; i < (int)fontList->count(); i++)
         {
             fontList->setItemChecked(i + 1000, i == familyNum);
         }
         for(int i = 0; i < (int)fonts.count(); i++)
         {
             fontList->setItemChecked(i, fonts.at(i)->getFamilyNum() == familyNum
                                      && fonts.at(i)->getSize() == size);
         }
         Config cfg( "Konsole" );
         cfg.setGroup("Font");
         QString ss = "Session"+ QString::number(tab->currentPageIndex()+1);
         if (tab->currentPageIndex() == 0)
         {
             cfg.writeEntry("FontName", fonts.at(cfont)->getFamily());
             cfg.writeEntry("FontSize", fonts.at(cfont)->getSize());
         }
         cfg.writeEntry("FontName"+ss, fonts.at(cfont)->getFamily());
         cfg.writeEntry("FontSize"+ss, fonts.at(cfont)->getSize());
     }
 }
 
 #if 0
 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());
         }
     }
 }
 #endif
 
 
 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()