TRUE->true, FALSE->false

5 files changed, 12 insertions, 12 deletions

diff --git a/noncore/net/opiestumbler/opiestumbler.cpp b/noncore/net/opiestumbler/opiestumbler.cpp
index bc4a7ab..2f4f54b 100644
--- a/noncore/net/opiestumbler/opiestumbler.cpp
+++ b/noncore/net/opiestumbler/opiestumbler.cpp
@@ -18,161 +18,161 @@
 //#include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 
 #include <opie2/odebug.h>
 #include <opie2/ostation.h>
 #include <opie2/omanufacturerdb.h>
 #include <opie2/onetwork.h>
 #include <opie2/oprocess.h>
 
 #include "stumbler.h"
 #include "opiestumbler.h"
 #include "stumblersettings.h"
 #include "stationviewitem.h"
 #include "stumblerstation.h"
 #include "stationinfo.h"
     
 
 using Opie::Net::OWirelessNetworkInterface;
 using Opie::Net::ONetwork;
 
 
 QString OpieStumbler::appCaption() {
     return QObject::tr("OpieStumbler");
 }
 
 OpieStumbler::OpieStumbler(QWidget *parent, const char *name, WFlags)
     :QMainWindow(parent, name, WStyle_ContextHelp),
     m_listCurrent(new QListView(this)), m_listHistory(new QListView(this)),
     m_stationsCurrent(new QList<Opie::Net::OStation>),
     m_popupCurrent(new QPopupMenu(this)),
     m_popupHistory(new QPopupMenu(this)),
     m_db(NULL), m_proc(NULL)
 {
     
     if ( QCopChannel::isRegistered("QPE/OpieStumbler") ) {
          QCopEnvelope e("QPE/OpieStumbler", "show()");
          exit(EXIT_SUCCESS);
     }
 
     QGridLayout *grid = new QGridLayout( this, 1, 1, 3, 0, "grid");
     QVBoxLayout *lay = new QVBoxLayout( NULL, 0, 5, "lay" );
     QSpacerItem *spacer = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Fixed );
     lay->addItem(spacer);
     lay->addWidget(m_listCurrent);
     lay->addWidget(m_listHistory);
     grid->addLayout(lay, 0, 0);
 
-    m_stationsCurrent->setAutoDelete(TRUE);
+    m_stationsCurrent->setAutoDelete(true);
     
     m_channel = new QCopChannel( "QPE/OpieStumbler", this );
     connect(m_channel, SIGNAL(received(const QCString &, const QByteArray &)), 
             this, SLOT(slotMessageReceived( const QCString &, const QByteArray &)) );
     
     //setCaption(appCaption());
     //setCentralWidget(grid);
-    setToolBarsMovable(FALSE);
+    setToolBarsMovable(false);
     
     
     QPopupMenu *fileMenu = new QPopupMenu(this);
     QPopupMenu *configMenu = new QPopupMenu(this);
     QPopupMenu *scanMenu = new QPopupMenu(this);
     
     fileMenu->insertItem( tr("Exit"), this, SLOT(close()) );
     configMenu->insertItem( tr("Configure"), this, SLOT(slotConfigure()) );
     scanMenu->insertItem( tr("Start"), this, SLOT(slotStartScanning()) );
     scanMenu->insertItem( tr("Stop"), this, SLOT(slotStopScanning()) );
 
     m_popupCurrent->insertItem( tr("Show details"), this, SLOT(slotShowDetails()) );
     m_popupCurrent->insertItem( tr("Join Network"), this, SLOT(slotJoinNetwork()) );
     
     menuBar()->insertItem(tr("File"), fileMenu);
     menuBar()->insertItem(tr("Settings"), configMenu);
     menuBar()->insertItem(tr("Scanning"), scanMenu);
     
     QPEApplication::setStylusOperation(m_listCurrent->viewport(), QPEApplication::RightOnHold);
     QPEApplication::setStylusOperation(m_listHistory->viewport(), QPEApplication::RightOnHold);
     
     m_listCurrent->addColumn(tr("SSID"));
     m_listCurrent->addColumn(tr("Chan"));
     m_listCurrent->addColumn(tr("Signal"));
     m_listCurrent->addColumn(tr("Enc"));
     m_listCurrent->setSelectionMode( QListView::Extended );
 
     m_listHistory->addColumn(tr("SSID"));
     m_listHistory->addColumn(tr("Chan"));
     m_listHistory->addColumn(tr("Max Sig"));
     m_listHistory->addColumn(tr("Enc"));
     m_listHistory->addColumn(tr("Vendor"));
    
     connect(m_listCurrent, SIGNAL(mouseButtonPressed (int, QListViewItem*, const QPoint&, int)),
             this, SLOT(slotCurrentMousePressed (int, QListViewItem*, const QPoint&, int)));
 
     connect(m_listHistory, SIGNAL(mouseButtonPressed (int, QListViewItem*, const QPoint&, int)),
             this, SLOT(slotHistoryMousePressed (int, QListViewItem*, const QPoint&, int)));
     
     for(int i = CURCHAN; i <= CURENC; ++i) {
         m_listCurrent->setColumnAlignment( i, Qt::AlignHCenter );
         m_listHistory->setColumnAlignment( i, Qt::AlignHCenter );
     }
 
     loadConfig();
     m_stumbler = new Stumbler(m_interface, this);
     connect(m_stumbler, SIGNAL(newdata()), this, SLOT(slotUpdateStations()));
 
     QTimer::singleShot(1000, this, SLOT(slotLoadManufacturers()) );
     
     slotStartScanning();
 }
 
 void OpieStumbler::slotConfigure()
 {
-    StumblerSettings settings(this, "Settings", TRUE);
+    StumblerSettings settings(this, "Settings", true);
     if (settings.exec() == QDialog::Accepted)
     loadConfig();
 }
 
 void OpieStumbler::loadConfig()
 {
     Config cfg("OpieStumbler", Config::User);
     cfg.setGroup("General");
     m_interface = cfg.readEntry("interface", "wlan0");
 }
 
 void OpieStumbler::slotStartScanning()
 {
     setCaption(appCaption() + " (" + tr("Scanning") + ")");
     m_stumbler->start();
 }
 
 void OpieStumbler::slotStopScanning()
 {
     setCaption(appCaption());
     m_stumbler->stop();
 }
 
 void OpieStumbler::slotUpdateStations()
 {
     m_stationsCurrent->clear();
     
     m_stationsCurrent = m_stumbler->stations();
     if (m_stationsCurrent) {
         QListIterator<Opie::Net::OStation> it(*m_stationsCurrent);
         for(; it.current(); ++it) {
             Opie::Net::OStation *station = it.current();
             QListIterator<StumblerStation> itr(m_stationsHistory);
             for( ; itr.current(); ++itr) {
                 if (itr.current()->st->macAddress.toString() == station->macAddress.toString()) {
                     break;
                 }
             }
             if (!itr.current()) {
                 //We need to copy the date because m_statiosCurrent has autodelete enabled
                 m_stationsHistory.append(new StumblerStation(new Opie::Net::OStation, QDateTime::currentDateTime()));
                 *(m_stationsHistory.last()->st) = (*station);
             }
             else {
                 if ( itr.current()->st->level < station->level )
                     itr.current()->st->level = station->level;
                 
                 itr.current()->lastTimeSeen = QDateTime::currentDateTime();
@@ -189,172 +189,172 @@ void OpieStumbler::displayStations()
         new StationViewItem( m_listCurrent, it.current()->ssid, QString::number(it.current()->channel),
                 QString::number(it.current()->level), it.current()->encrypted ? "Y": "N", it.current()->macAddress.toString() );
 
     m_listHistory->clear();
     for(QListIterator<StumblerStation> it(m_stationsHistory); it.current(); ++it) 
         new StationViewItem( m_listHistory, it.current()->st->ssid, QString::number(it.current()->st->channel),
                 QString::number(it.current()->st->level), it.current()->st->encrypted ? "Y": "N",
                 manufacturer(it.current()->st->macAddress.toString()), it.current()->st->macAddress.toString() );
 }
 
 void OpieStumbler::slotMessageReceived( const QCString &message, const QByteArray &parameters)
 {
     Q_UNUSED(const_cast<QByteArray &>(parameters))
 
     if ( message == "show()" )
         show();
 }
 
 void OpieStumbler::slotCurrentMousePressed(int button, QListViewItem * item, const QPoint &point, int c)
 {
     Q_UNUSED(c)
         
     if ( 2 == button ) {
         m_mac = item->text(CURENC + 1);
         m_popupCurrent->popup(point);
     }
 }
 
 
 void OpieStumbler::slotHistoryMousePressed(int button, QListViewItem * item, const QPoint &point, int c)
 {
     Q_UNUSED(c)
     
     if ( 2 == button ) {
         m_mac = item->text(HISVENDOR + 1);
         m_popupHistory->popup(point);
     }
 }
 
 void OpieStumbler::slotShowDetails()
 {
     QListIterator<StumblerStation> it(m_stationsHistory);
     for(; it.current() && it.current()->st->macAddress.toString() != m_mac; ++it );
     
     if( it.current() ) {
         StationInfo info(it.current()->st->ssid, it.current()->st->type, QString::number(it.current()->st->channel),
                 QString::number(it.current()->st->rates.last()/1000000), QString::number(it.current()->st->level),
                 it.current()->st->encrypted ? "WEP": "No", 
-                it.current()->st->macAddress.toString(), manufacturer(it.current()->st->macAddress.toString(), TRUE),
-                    it.current()->lastTimeSeen.toString() ,this, "", TRUE);
+                it.current()->st->macAddress.toString(), manufacturer(it.current()->st->macAddress.toString(), true),
+                    it.current()->lastTimeSeen.toString() ,this, "", true);
         info.exec();
     }
     
 } 
 
 void OpieStumbler::slotLoadManufacturers()
 {
     m_db = Opie::Net::OManufacturerDB::instance();
 }
 
 QString OpieStumbler::manufacturer( const QString &mac, bool extended )
 {
     QString retval;
     if ( m_db )
         if ( extended )
             retval = m_db->lookupExt(mac);
         else
             retval = m_db->lookup(mac);
 
     if ( retval.isEmpty() )
         retval = tr("Unknown");
 
     return retval;
 }
 
 void OpieStumbler::slotJoinNetwork()
 {
     slotStopScanning();
 
     OWirelessNetworkInterface *wiface = static_cast<OWirelessNetworkInterface*>(ONetwork::instance()->interface(m_interface)); 
     
     if( !wiface )
         return;
     
     QListIterator<StumblerStation> it(m_stationsHistory);
     
     for(; it.current() && it.current()->st->macAddress.toString() != m_mac; ++it );
 
     if( !it.current() )
         return;
     
     m_ssid = it.current()->st->ssid.left(it.current()->st->ssid.length()-1);
     m_splash = new QFrame( this, "splash", false, WStyle_StaysOnTop | WStyle_DialogBorder | WStyle_Customize );
     m_splash->setFrameStyle( QFrame::Panel | QFrame::Raised );
     m_splashBox = new QVBoxLayout( m_splash, 4, 4 );
     m_infoLabel = new QLabel( QString("<center><b>%1 %2</b></center>").arg(tr("Joining Network")).arg(m_ssid), m_splash );
     m_pbar = new QProgressBar( 3, m_splash );
     m_pbar->setCenterIndicator(true);
     m_splashBox->addWidget( m_infoLabel );
     m_splashBox->addWidget( m_pbar );
     int sw = m_splashBox->sizeHint().width()*2;
     int sh = m_splashBox->sizeHint().height();
     m_splash->setGeometry((240-(sw))/2, (320-sh)/2, sw, sh);
     m_splash->show();
     m_splash->raise();
 
     Opie::Net::OStation *station = it.current()->st;
     
     odebug << "Bringing interface down" << oendl;
-    wiface->setUp(FALSE);
+    wiface->setUp(false);
     
     odebug << "Setting mode to " << (station->type == "adhoc" ? "adhoc" : "managed") << oendl;
     wiface->setMode(station->type == "adhoc" ? "adhoc" : "managed" );
     
     odebug << "Setting channel to " << station->channel << oendl;
     wiface->setChannel(station->channel);
     
     odebug << "Setting SSID to " << station->ssid << oendl;
     wiface->setSSID(station->ssid);
     
     wiface->commit();
     
     odebug << "Bringing interface up" << oendl;
-    wiface->setUp(TRUE);
+    wiface->setUp(true);
     m_pbar->setProgress(1);
     //Wait 5 sec for association
     QTimer::singleShot(5000, this, SLOT(slotAssociated()));
 }
 
 void OpieStumbler::slotAssociated()
 {
     OWirelessNetworkInterface *wiface = static_cast<OWirelessNetworkInterface*>(ONetwork::instance()->interface(m_interface));
 
     if( !wiface ) {
         slotCleanSplash();
         return;
     }
 
     if (!wiface->isAssociated()) {
         Global::statusMessage(tr("Could not Join"));
         m_infoLabel->setText(tr("Could not Join"));
         QTimer::singleShot(5000, this, SLOT(slotCleanSplash()));
         return;
     }
     
     Global::statusMessage(tr("Joined"));
     m_pbar->setProgress(2);
     m_infoLabel->setText(QString("<center><b>%1 %2</b></center>").arg(tr("Joined Network")).arg(m_ssid));
    
     if(m_proc) {
         m_proc->kill();
         delete m_proc;
     }
 
     m_proc = new Opie::Core::OProcess(this);
         
     *m_proc << "udhcpc" << "-f" << "-n" << "-i" << m_interface;
     m_proc->start(Opie::Core::OProcess::DontCare);
     QTimer::singleShot(5000, this, SLOT(slotCheckDHCP()));
 }
 
 void OpieStumbler::slotCheckDHCP()
 {
     if(!m_proc->isRunning()) {
         Global::statusMessage(tr("Could not Obtain an Address"));
         m_infoLabel->setText(QString("<center><b>%1</b></center>").arg(tr("Could not Obtain an Address")));
         delete m_proc;
         m_proc = NULL;
         QTimer::singleShot(5000, this, SLOT(slotCleanSplash()));
         return;
     }
     m_listCurrent->show();
diff --git a/noncore/net/opiestumbler/opiestumbler.h b/noncore/net/opiestumbler/opiestumbler.h
index 84a69ba..263af6e 100644
--- a/noncore/net/opiestumbler/opiestumbler.h
+++ b/noncore/net/opiestumbler/opiestumbler.h
@@ -1,81 +1,81 @@
 #ifndef OPIESTUMBLER_H
 #define OPIESTUMBLER_H
 
 #include <qmainwindow.h>
 #include <qlist.h>
 
 #include "stumblerstation.h"
 
 class QString;
 class QPopupMenu;
 class Stumbler;
 class QCopChannel;
 class QListView;
 class QListViewItem;
 class QFrame;
 class QLabel;
 class QProgressBar;
 class QVBoxLayout;
 
 namespace Opie{
     namespace Net {
         class OMacAddress;
         class OStation;
         class OManufacturerDB;
     }
 
     namespace Core {
         class OProcess;
     }
 }
             
 
 class OpieStumbler: public QMainWindow {
     Q_OBJECT
 public:
 
     enum CurrentColumns { CURSSID, CURCHAN, CURSIGNAL, CURENC };
     enum HistoryColumns { HISSSID, HISCHAN, HISSIGNAL, HISENC, HISVENDOR };
     OpieStumbler(QWidget *parent = 0, const char *name = 0, WFlags f = 0);
     static QString appName() { return QString::fromLatin1("opiestumbler"); }
     static QString appCaption();
     void displayStations();
-    QString manufacturer(const QString &mac, bool extended = FALSE );
+    QString manufacturer(const QString &mac, bool extended = false );
 protected slots:
     void slotConfigure();
     void slotStartScanning();
     void slotStopScanning();
     void slotUpdateStations();
     void slotMessageReceived( const QCString &, const QByteArray & );
     void slotCurrentMousePressed(int button, QListViewItem *item, const QPoint &point, int c);
     void slotHistoryMousePressed(int button, QListViewItem *item, const QPoint &point, int c);
     void slotShowDetails();
     void slotLoadManufacturers();
     void slotJoinNetwork();
     void slotAssociated();
     void slotCheckDHCP();
     void slotCleanSplash();
 protected:
     void loadConfig();
     
     QListView *m_listCurrent;
     QListView *m_listHistory;
     QString m_interface;
     Stumbler *m_stumbler;
     QCopChannel *m_channel;
     QList <Opie::Net::OStation> *m_stationsCurrent;
     QList <StumblerStation> m_stationsHistory;
     QPopupMenu *m_popupCurrent;
     QPopupMenu *m_popupHistory;
     Opie::Net::OManufacturerDB *m_db;
     QString m_mac;
     QString m_ssid;
     Opie::Core::OProcess *m_proc;
     QFrame *m_splash;
     QVBoxLayout *m_splashBox;
     QLabel *m_infoLabel;
     QProgressBar *m_pbar;
     
 };
 
 #endif /* OPIESTUMBLER_H */
diff --git a/noncore/net/opiestumbler/stationinfo.h b/noncore/net/opiestumbler/stationinfo.h
index f8798a6..aa42932 100644
--- a/noncore/net/opiestumbler/stationinfo.h
+++ b/noncore/net/opiestumbler/stationinfo.h
@@ -1,42 +1,42 @@
 #ifndef STATIONINFO_H
 #define STATIONINFO_H
 
 #include <qdialog.h>
 #include <qlabel.h>
 
 class QWidget;
 class QString;
 class QGroupBox;
 
 class StationInfo: public QDialog
 {
     Q_OBJECT
 
 public:
     StationInfo( const QString &essid, const QString &type, const QString &channel, 
             const QString &maxrate, const QString &level, const QString &encryption, const QString &address,
             const QString &vendor, const QString &time,
-            QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 );
+            QWidget* parent = 0, const char* name = 0, bool modal = false, WFlags fl = 0 );
 
 protected:
     QLabel *m_ssidLabel;
     QLabel *m_typeLabel;
     QLabel *m_channelLabel;
     QLabel *m_maxRateLabel;
     QLabel *m_levelLabel;
     QLabel *m_encLabel;
     QLabel *m_addrLabel;
     QLabel *m_vendorLabel;
     QLabel *m_timeLabel;
     QLabel *m_ssid;
     QLabel *m_type;
     QLabel *m_channel;
     QLabel *m_maxRate;
     QLabel *m_level;
     QLabel *m_encryption;
     QLabel *m_address;
     QLabel *m_vendor;
     QLabel *m_lastTime;
 };
 
 #endif
diff --git a/noncore/net/opiestumbler/stumbler.cpp b/noncore/net/opiestumbler/stumbler.cpp
index cda6b99..10e89ce 100644
--- a/noncore/net/opiestumbler/stumbler.cpp
+++ b/noncore/net/opiestumbler/stumbler.cpp
@@ -1,80 +1,80 @@
 #include <qstring.h>
 #include <qtimer.h>
 #include <qapplication.h>
 
 //#include <opie2/onetutils.h>
 #include <opie2/onetwork.h>
 #include <opie2/odebug.h>
 
 #include "stumbler.h"
 
 using namespace Opie::Net;
 
 Stumbler::Stumbler(const QString &iface, QObject *parent, const char *name)
     :QObject(parent, name), m_interval(5000),
     m_wifaceName(iface),
     m_timer(new QTimer(this))
 {
     m_wiface = static_cast<OWirelessNetworkInterface*>(ONetwork::instance()->interface(m_wifaceName));
     connect(m_timer, SIGNAL(timeout()), this, SLOT(slotRefresh()));
 }
    
 
 void Stumbler::start()
 {
     if (!m_wiface) {
         odebug << "Error, interface " << m_wifaceName << " does not exist" << oendl;
         return;
     }
     
     if (!ONetwork::instance()->isWirelessInterface(m_wifaceName.ascii())) {
         odebug << "Error, " << m_wifaceName << " is not a wireless interface" << oendl;
         //FIXME: Tell the user about this
         return;
     }
     
     if (!m_timer->isActive()) {
         odebug << "Starting stumbler" << oendl;
-        m_wiface->setUp(FALSE);
+        m_wiface->setUp(false);
         m_wiface->setSSID("any");
         m_wiface->setAssociatedAP( OMacAddress::broadcast );
-        m_wiface->setUp(TRUE);
+        m_wiface->setUp(true);
         m_timer->start(m_interval);
     }
 }
 
 void Stumbler::stop()
 {
     if (m_timer->isActive()) {
         odebug << "Stoping stumbler" << oendl;
         m_timer->stop();
     }
 }
 
 void Stumbler::setInterval(int msec)
 {
     m_interval = msec;
     if (m_timer->isActive()) {
         m_timer->stop();
         m_timer->start(m_interval);
     }
 }
 
 void Stumbler::setIface(const QString &iface)
 {
     m_wifaceName = iface;
     m_wiface = static_cast<OWirelessNetworkInterface*>(ONetwork::instance()->interface(m_wifaceName));
 }
 
 void Stumbler::slotRefresh()
 {
     m_stationList = m_wiface->scanNetwork();
     if ( qApp )
         qApp->processEvents();
     emit (newdata());
 }
 
 Opie::Net::OStationList * Stumbler::stations()
 {
     return m_stationList;
 }
diff --git a/noncore/net/opiestumbler/stumblersettings.h b/noncore/net/opiestumbler/stumblersettings.h
index 997fc85..f444eba 100644
--- a/noncore/net/opiestumbler/stumblersettings.h
+++ b/noncore/net/opiestumbler/stumblersettings.h
@@ -1,22 +1,22 @@
 #ifndef STUMBLERSETTINGS_H
 #define STUMBLERSETTINGS_H
 
 #include <qdialog.h>
 
 class Config;
 class QLineEdit;
 
 class StumblerSettings: public QDialog {
 
 public:
-    StumblerSettings(QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags f = 0);
+    StumblerSettings(QWidget* parent = 0, const char* name = 0, bool modal = false, WFlags f = 0);
     ~StumblerSettings();
 
 protected slots:
     void accept();
 protected:
     Config *m_config;
     QLineEdit *m_interface;
 };
 
 #endif