show widgets again since we need them now

2 files changed, 0 insertions, 5 deletions

diff --git a/noncore/apps/opie-console/modemconfigwidget.cpp b/noncore/apps/opie-console/modemconfigwidget.cpp
index ce44dab..37eb184 100644
--- a/noncore/apps/opie-console/modemconfigwidget.cpp
+++ b/noncore/apps/opie-console/modemconfigwidget.cpp
@@ -1,235 +1,232 @@
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qcombobox.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qhbox.h>
 #include <qregexp.h>
 
 #include "modemconfigwidget.h"
 #include "dialdialog.h"
 
 namespace {
     void setCurrent( const QString& str, QComboBox* bo ) {
         uint b = bo->count();
         for (int i = 0; i < bo->count(); i++ ) {
             if ( bo->text(i) == str ) {
                 bo->setCurrentItem( i );
                 return;
             }
         }
         bo->insertItem( str );
         bo->setCurrentItem( b );
     }
 }
 
 ModemConfigWidget::ModemConfigWidget( const QString& name, QWidget* parent,
                                 const char* na )
     : ProfileDialogConnectionWidget( name, parent, na ) {
 
     m_lay = new QVBoxLayout( this );
     m_device = new QLabel(tr( "Modem is attached to:" ), this );
     m_deviceCmb = new QComboBox(this );
     m_deviceCmb->setEditable( TRUE );
 
     QLabel* telLabel = new QLabel( this );
     telLabel->setText( tr( "Enter telefon number here:" ) );
-    // m_telNumber = new QLineEdit( this );
     QHBox *buttonBox = new QHBox( this );
     m_telNumber = new QLineEdit( buttonBox );
     QPushButton *atButton = new QPushButton( buttonBox );
     atButton->setText( tr( "AT commands" ) );
-    // disabled for now
-    atButton->hide();
     connect( atButton, SIGNAL( clicked() ), this, SLOT( slotAT() ) );
 
     QPushButton *dialButton = new QPushButton( buttonBox );
     dialButton->setText( tr( "Enter number" ) );
     connect( dialButton, SIGNAL( clicked() ), this, SLOT( slotDial() ) );
 
     m_base = new IOLayerBase( this, "base" );
 
     m_lay->addWidget( m_device );
     m_lay->addWidget( m_deviceCmb );
     m_lay->addWidget( telLabel );
     m_lay->addWidget( buttonBox );
     m_lay->addWidget( m_base );
     m_lay->addStretch( 0 );
 
     m_deviceCmb->insertItem( "/dev/ttyS0" );
     m_deviceCmb->insertItem( "/dev/ttyS1" );
     m_deviceCmb->insertItem( "/dev/ttyS2" );
 
     atConf = new  ATConfigDialog( this, "ATConfig", true );
 }
 
 ModemConfigWidget::~ModemConfigWidget() {
 
 }
 void ModemConfigWidget::load( const Profile& prof ) {
 
     int rad_flow = prof.readNumEntry( "Flow" );
     int rad_parity = prof.readNumEntry( "Parity" );
     int speed = prof.readNumEntry( "Speed" );
     int dbits = prof.readNumEntry("DataBits");
     int sbits = prof.readNumEntry("StopBits");
     QString number = prof.readEntry( "Number" );
 
     if ( !number.isEmpty() ) {
         m_telNumber->setText( number );
     }
 
     if ( rad_flow == 1 ) {
         m_base->setFlow( IOLayerBase::Hardware );
     } else if (rad_flow == 2) {
         m_base->setFlow( IOLayerBase::Software );
     } else if (rad_flow == 0) {
          m_base->setFlow( IOLayerBase::None );
     }
 
 
     if ( rad_parity == 1 ) {
         m_base->setParity( IOLayerBase::Even );
     } else if ( rad_parity == 2 ){
         m_base->setParity( IOLayerBase::Odd );
     } else {
         m_base->setParity( IOLayerBase::NonePar );
     }
 
     switch( speed ) {
     case 115200:
         m_base->setSpeed( IOLayerBase::Baud_115200 );
         break;
     case 57600:
         m_base->setSpeed( IOLayerBase::Baud_57600 );
         break;
     case 38400:
         m_base->setSpeed( IOLayerBase::Baud_38400 );
         break;
     case 19200:
         m_base->setSpeed( IOLayerBase::Baud_19200 );
         break;
     case 9600:
     default:
         m_base->setSpeed( IOLayerBase::Baud_9600 );
         break;
     }
 
 
     if ( dbits == 5) {
         m_base->setData( IOLayerBase::Data_Five );
     } else if (rad_flow == 6) {
         m_base->setData( IOLayerBase::Data_Six );
     } else if (rad_flow == 7) {
         m_base->setData( IOLayerBase::Data_Seven );
     } else {
         m_base->setData( IOLayerBase::Data_Eight );
     }
 
     if ( sbits == 2) {
         m_base->setStop( IOLayerBase::Stop_Two );
     } else if ( sbits == 15 ) {
         m_base->setStop( IOLayerBase::Stop_OnePointFive );
     } else {
         m_base->setStop( IOLayerBase::Stop_One );
     }
 
 
 
     if ( prof.readEntry( "Device" ).isEmpty() ) {
         return;
     }
     setCurrent( prof.readEntry( "Device" ), m_deviceCmb );
 
     atConf->readConfig( prof );
 }
 
 /*
  * save speed,
  * flow,
  * parity
  */
 void ModemConfigWidget::save( Profile& prof ) {
     int flow, parity, speed, data, stop;
     flow = parity = speed = data = stop = 0;
     prof.writeEntry( "Device", m_deviceCmb->currentText() );
 
 
     switch( m_base->flow() ) {
     case IOLayerBase::None:
         flow = 0;
         break;
     case IOLayerBase::Software:
         flow = 2;
         break;
     case IOLayerBase::Hardware:
         flow = 1;
         break;
     }
 
     switch( m_base->parity() ) {
     case IOLayerBase::Odd:
         parity = 2;
         break;
     case IOLayerBase::Even:
         parity = 1;
         break;
     case IOLayerBase::NonePar:
         parity = 0;
         break;
     }
 
     switch( m_base->speed() ) {
     case IOLayerBase::Baud_115200:
         speed = 115200;
         break;
     case IOLayerBase::Baud_57600:
         speed = 57600;
         break;
     case IOLayerBase::Baud_38400:
         speed = 38400;
         break;
     case IOLayerBase::Baud_19200:
         speed = 19200;
         break;
     case IOLayerBase::Baud_9600:
         speed = 9600;
         break;
     }
 
     switch( m_base->data() ) {
     case IOLayerBase::Data_Five:
         data = 5;
         break;
     case IOLayerBase::Data_Six:
         data = 6;
         break;
     case IOLayerBase::Data_Seven:
         data = 7;
         break;
     case IOLayerBase::Data_Eight:
         data = 8;
         break;
     }
 
     switch( m_base->stop() ) {
     case IOLayerBase::Stop_One:
         stop = 1;
         break;
     case IOLayerBase::Stop_OnePointFive:
         stop = 15;
         break;
     case IOLayerBase::Stop_Two:
         stop = 2;
         break;
     }
 
     prof.writeEntry( "Flow", flow );
     prof.writeEntry( "Parity", parity );
     prof.writeEntry( "Speed", speed );
     prof.writeEntry("DataBits", data);
     prof.writeEntry("StopBits", stop);
     prof.writeEntry( "Number", m_telNumber->text() );
 
 
     atConf->writeConfig(prof);
diff --git a/noncore/apps/opie-console/terminalwidget.cpp b/noncore/apps/opie-console/terminalwidget.cpp
index eb14a3f..a8cee93 100644
--- a/noncore/apps/opie-console/terminalwidget.cpp
+++ b/noncore/apps/opie-console/terminalwidget.cpp
@@ -1,227 +1,225 @@
 #include <qbuttongroup.h>
 #include <qlabel.h>
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qradiobutton.h>
 #include <qgroupbox.h>
 #include <qvbox.h>
 #include <qhgroupbox.h>
 #include <qhbuttongroup.h>
 #include <qlayout.h>
 #include <qhbox.h>
 
 #include "terminalwidget.h"
 
 namespace {
     enum TermIds {
         id_term_vt100 = 0,
         id_term_vt102,
         id_term_linux,
         id_term_xterm
     };
 
     enum ColourIds {
         id_term_black,
         id_term_white,
         id_term_green,
         id_term_orange
     };
 
     enum FontIds {
         id_size_small,
         id_size_medium,
         id_size_large
     };
 };
 
 TerminalWidget::TerminalWidget( const QString& name, QWidget* parent,
                                 const char* na )
     : ProfileDialogTerminalWidget( name, parent, na ) {
 
     m_terminal = new QLabel(tr("Terminal Type"), this );
     m_terminalBox = new QComboBox(this);
     m_colorLabel = new QLabel(tr("Color scheme"), this);
     m_colorCmb = new QComboBox(this );
 
     m_groupSize = new QHButtonGroup(tr("Font size"), this );
     m_sizeSmall = new QRadioButton(tr("small"),  m_groupSize );
     m_sizeMedium = new QRadioButton(tr("medium"),  m_groupSize );
     m_sizeLarge = new QRadioButton(tr("large"),  m_groupSize );
 
     m_groupConv = new QHGroupBox(tr("Line-break conversions"), this );
     m_convInbound  = new QCheckBox(tr("Inbound"), m_groupConv );
     m_convOutbound = new QCheckBox(tr("Outbound"), m_groupConv );
-    m_groupConv->hide();
 
     m_groupOptions = new QHGroupBox( tr("Options"), this );
     m_optionEcho = new QCheckBox(tr("Local echo"), m_groupOptions );
     m_optionWrap = new QCheckBox(tr("Line wrap"), m_groupOptions );
-    m_groupOptions->hide();
 
     m_lroot = new QVBoxLayout( this  );
     m_typeBox = new  QVBoxLayout( m_lroot );
     m_colorBox = new QVBoxLayout( m_lroot );
 
     // Layout
     m_typeBox->add(m_terminal );
     m_typeBox->add(m_terminalBox );
     m_lroot->add(m_groupSize );
 
     m_colorBox->add(  m_colorLabel );
     m_colorBox->add(  m_colorCmb   );
 
     m_lroot->add(m_groupConv );
     m_lroot->add(m_groupOptions );
     m_lroot->addStretch( 0 );
 
     // Fill in some options
     qWarning("Options for terminal box");
     m_terminalBox->insertItem( tr("VT 100"), 0 ); // /*, id_term_vt100*/ );
     m_terminalBox->insertItem( tr("VT 102"), 1 );  // /* , id_term_vt102 */);
     m_terminalBox->insertItem( tr("Linux Console"), 2 ); //, id_term_linux );
     m_terminalBox->insertItem( tr("X-Terminal"), 3 ); //, id_term_xterm );
     //m_terminalBox->insertItem( tr("ANSI"), id_term_ansi );
 
     m_colorCmb->insertItem( tr("black on white"), id_term_black );
     m_colorCmb->insertItem( tr("white on black"), id_term_white );
     m_colorCmb->insertItem( tr("green on black"), id_term_green );
     m_colorCmb->insertItem( tr("orange on black"), id_term_orange );
 
     // signals + slots
     /*
     connect(m_terminalBox, SIGNAL(activated(int) ),
             this, SLOT(slotTermTerm(int) ) );
     connect(m_colorBox, SIGNAL(activated(int) ),
             tis, SLOT(slotTermColor(int) ) );
     connect(m_groupSize, SIGNAL(activated(int) ),
             this, SLOT(slotTermFont(int) ) );
 
     connect(m_optionEcho, SIGNAL(toggled(bool) ),
             this, SLOT(slotTermEcho(bool) ) );
     connect(m_optionWrap, SIGNAL(toggled(bool) ),
             this, SLOT(slotTermWrap(bool) ) );
     connect(m_convInbound, SIGNAL(toggled(bool) ),
             this, SLOT(slotTermInbound(bool) ) );
     connect(m_convOutbound, SIGNAL(toggled(bool) ),
             this, SLOT(slotTermOutbound(bool) ) );
 */
 }
 TerminalWidget::~TerminalWidget() {
 }
 void TerminalWidget::load( const Profile& prof ) {
     int term = prof.readNumEntry("Terminal");
     int color = prof.readNumEntry("Color");
     int fontsize = prof.readNumEntry("Font");
     int opt_echo = prof.readNumEntry("Echo");
     int opt_wrap = prof.readNumEntry("Wrap");
     int opt_inbound = prof.readNumEntry("Inbound");
     int opt_outbound = prof.readNumEntry("Outbound");
 
     switch( term ) {
     case Profile::VT100:
         m_terminalBox->setCurrentItem(id_term_vt100 );
         break;
     case Profile::VT102:
         m_terminalBox->setCurrentItem(id_term_vt102 );
         break;
     case Profile::Linux:
         m_terminalBox->setCurrentItem(id_term_linux );
         break;
     case Profile::XTerm:
         m_terminalBox->setCurrentItem(id_term_xterm );
         break;
     default:
         m_terminalBox->setCurrentItem(id_term_vt102 );
         break;
     };
 
     switch( color ) {
     case Profile::Black:
         m_colorCmb->setCurrentItem(id_term_black );
         break;
     case Profile::White:
         m_colorCmb->setCurrentItem(id_term_white );
         break;
     case Profile::Green:
         m_colorCmb->setCurrentItem(id_term_green );
         break;
     case Profile::Orange:
         m_colorCmb->setCurrentItem(id_term_orange );
         break;
     default:
         break;
     };
 
     switch( fontsize ) {
     case Profile::Micro:
         m_sizeSmall->setChecked(true );
         break;
     case Profile::Small:
         m_sizeMedium->setChecked(true );
         break;
     case Profile::Medium:
         m_sizeLarge->setChecked( true );
         break;
     default:
         m_sizeMedium->setChecked(true );
         break;
     };
 
     if (opt_echo) m_optionEcho->setChecked( true );
     if (opt_wrap) m_optionWrap->setChecked( true );
     if (opt_inbound) m_convInbound->setChecked( true );
     if (opt_outbound) m_convOutbound->setChecked( true );
 
 }
 void TerminalWidget::save( Profile& profile ) {
     switch(m_terminalBox->currentItem() ) {
     case id_term_vt100:
         profile.writeEntry("Terminal", Profile::VT100 );
         break;
     case id_term_vt102:
         profile.writeEntry("Terminal", Profile::VT102 );
         break;
     case id_term_linux:
         profile.writeEntry("Terminal", Profile::Linux );
         break;
     case id_term_xterm:
         profile.writeEntry("Terminal", Profile::XTerm );
         break;
     //case id_term_ansi:
     //    profile.writeEntry("Terminal", Profile::VT102 );
     //    break;
     default:
         break;
     };
 
     // color
     switch(m_colorCmb->currentItem() ) {
     case id_term_black:
         profile.writeEntry("Color", Profile::Black );
         break;
     case id_term_white:
         profile.writeEntry("Color", Profile::White );
         break;
     case id_term_green:
         profile.writeEntry("Color", Profile::Green );
         break;
     case id_term_orange:
         profile.writeEntry("Color", Profile::Orange );
         break;
     default:
         break;
     };
 
     if (m_sizeSmall->isChecked() ) {
         profile.writeEntry("Font", Profile::Micro );
     }else if (m_sizeMedium->isChecked() ) {
         profile.writeEntry("Font", Profile::Small );
     }else {
         profile.writeEntry("Font", Profile::Medium );
     }
 
     profile.writeEntry("Echo", m_optionEcho->isChecked() );
     profile.writeEntry("Wrap", m_optionWrap->isChecked() );
     profile.writeEntry("Inbound", m_convInbound->isChecked() );
     profile.writeEntry("Outbound",m_convOutbound->isChecked() );
 }