Diffstat (limited to 'noncore/settings/networksettings2/opietooth2/Opietooth.cpp') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | noncore/settings/networksettings2/opietooth2/Opietooth.cpp | 1003 |
1 files changed, 1003 insertions, 0 deletions
diff --git a/noncore/settings/networksettings2/opietooth2/Opietooth.cpp b/noncore/settings/networksettings2/opietooth2/Opietooth.cpp new file mode 100644 index 0000000..8d71f32 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/Opietooth.cpp @@ -0,0 +1,1003 @@ +#include <opie2/odebug.h> +#include <opie2/oledbox.h> + +#include <qpe/resource.h> +#include <qcheckbox.h> +#include <qgroupbox.h> +#include <qlabel.h> +#include <qprogressbar.h> +#include <qheader.h> +#include <qmessagebox.h> +#include <qapplication.h> +#include <qlistbox.h> +#include <qdialog.h> +#include <qlayout.h> +#include <qcombobox.h> +#include <qlabel.h> +#include <qlistview.h> +#include <qpushbutton.h> + +#include <Opietooth.h> +#include <OTDriver.h> +#include <OTPeer.h> +#include <OTGateway.h> +#include <OTSDPAttribute.h> +#include <OTSDPService.h> +#include <OTInquiry.h> + +using namespace Opietooth2; + +namespace Opietooth2 { + +class PeerLVI : public QListViewItem { + +public : + + PeerLVI( OTPeer * P, QListView * it ) : QListViewItem (it) { + Peer = P; + } + ~PeerLVI( void ) { + } + + inline OTPeer * peer( void ) + { return Peer; } + +private : + + OTPeer * Peer; +}; + +class ChannelLVI : public QListViewItem { + +public : + + ChannelLVI( int Ch, QListViewItem * it ) : QListViewItem (it) { + Channel = Ch; + } + ~ChannelLVI( void ) { + } + + inline int channel( void ) + { return Channel; } + +private : + + int Channel; +}; + +class DriverLVI : public QListViewItem { + +public : + + DriverLVI( OTDriver * P, QListView * it ) : QListViewItem (it) { + Driver = P; + } + ~DriverLVI( void ) { + } + + inline OTDriver * driver( void ) + { return Driver; } + +private : + + OTDriver * Driver; +}; + +class LinkKeyLVI : public QListViewItem { + +public : + + LinkKeyLVI( int Ch, QListView * it ) : QListViewItem (it) { + LinkKey = Ch; + } + ~LinkKeyLVI( void ) { + } + + inline int index( void ) + { return LinkKey; } + +private : + + int LinkKey; +}; +}; + +// +// +// +// +// + +OTPairing::OTPairing( QWidget * parent, OTIcons * _IC ) : + OTPairingGUI( parent ) { + + OT = OTGateway::getOTGateway(); + Icons = (_IC ) ? _IC : new OTIcons(); + MyIcons = (_IC == 0 ); + + // unpairing can only be done if bluetooth is disabled + Unpair_But->setEnabled( ! OT->isEnabled() ); + if( ! OT->isEnabled() ) { + Unpair_LBL->hide(); + } else { + Unpair_LBL->show(); + } + + // open linkkey file and load pairs + LinkKeyArray Keys = OT->getLinkKeys(); + LinkKeyLVI * it; + OTPeer * P; + OTDriver * D; + + for( unsigned int i = 0 ; + i < Keys.count(); + i ++ ) { + + it = new LinkKeyLVI( i, Pairs_LV ); + + P = 0; + D = OT->findDriver( Keys[i].from() ); + + if( D ) { + it->setText( 0, D->devname() ); + + // we are source + P = OT->findPeer( Keys[i].to() ); + + if( P ) { + // put name + it->setText( 1, P->name() ); + } else { + // unknown + it->setText( 1, Keys[i].to().toString() ); + } + + // and put address as sub + QListViewItem * Sub = new QListViewItem( it ); + Sub->setText( 0, D->address().toString() ); + Sub->setText( 1, Keys[i].to().toString() ); + } else { + // perhaps we are destination + D = OT->findDriver( Keys[i].to() ); + + if( D ) { + it->setText( 1, D->devname() ); + + // we are source + P = OT->findPeer( Keys[i].from() ); + + if( P ) { + // put name + it->setText( 0, P->name() ); + } else { + // unknown + it->setText( 0, Keys[i].from().toString() ); + } + + // and put address as sub + QListViewItem * Sub = new QListViewItem( it ); + Sub->setText( 0, Keys[i].from().toString() ); + Sub->setText( 1, D->address().toString() ); + } else { + // nor source nor destination -> unknown + it->setText( 0, Keys[i].from().toString() ); + it->setText( 1, Keys[i].to().toString() ); + } + } + } +} + + +OTPairing::~OTPairing() { + if( MyIcons ) + delete Icons; + OTGateway::releaseOTGateway(); +} + +void OTPairing::SLOT_Unpair( ) { + // find selected pair + + QListViewItem * it = Pairs_LV->firstChild(); + while( it ) { + if( it->isSelected() ) { + // confirm ? + if( QMessageBox::warning(0, + tr("Break pairing"), + tr("Sure ?"), + tr("Yes, break"), + tr("No, don't break") ) == 0 ) { + LinkKeyLVI * KPIt = (LinkKeyLVI *)it; + // break + OT->removeLinkKey( KPIt->index() ); + delete KPIt; + } + return; + } + it= it->nextSibling(); + } +} + +// +// +// +// +// + +OTScan::OTScan( QWidget * parent, OTIcons * _IC ) : + OTScanGUI( parent ), Filter() { + + OT = OTGateway::getOTGateway(); + Icons = (_IC ) ? _IC : new OTIcons(); + MyIcons = (_IC == 0 ); + DetectedPeers_LV->header()->hide(); + Current = 0; + SelectedPeer = 0; + SelectedChannel = 0; + + StrengthTimer = new QTimer( this ); + connect( StrengthTimer, + SIGNAL( timeout()), + this, + SLOT( SLOT_UpdateStrength()) + ); + + connect( OT, + SIGNAL( detectedPeer( OTPeer *, bool )), + this, + SLOT( SLOT_NewPeer( OTPeer *, bool )) + ); + connect( OT, + SIGNAL( finishedDetecting()), + this, + SLOT( SLOT_FinishedDetecting()) + ); + + // populate with peers we already know about + const PeerVector & P = OT->peers(); + for( unsigned int i = 0; + i < P.count(); + i ++ ) { + SLOT_NewPeer( P[i], TRUE ); + } + + // populate State fram + { QHBoxLayout * H =new QHBoxLayout( State_Frm ); + + Paired_Led = new OLedBox( green, State_Frm ); + QLabel * L1 = new QLabel( tr( "Paired" ), State_Frm ); + + H->addWidget( Paired_Led ); + H->addWidget( L1 ); + H->addStretch( 1 ); + } +} + +OTScan::~OTScan() { + if( MyIcons ) + delete Icons; + OTGateway::releaseOTGateway(); + + // send all peers that we do not care about states + QListViewItem * Lit = DetectedPeers_LV->firstChild(); + while( Lit ) { + ((PeerLVI *)Lit)->peer()->stopFindingOutState( ); + Lit = Lit->nextSibling(); + } +} + +// static scan dialog function +int OTScan::getDevice( OTPeer *& Peer, + int & Channel, + OTGateway * OT, + const UUIDVector & Filter, + QWidget* Parent ) { + bool IsUp = 0; + unsigned int i; + + // check if bluetooth is up + OTDriverList & DL = OT->getDriverList(); + for( i = 0; + i < DL.count(); + i ++ ) { + if( DL[i]->isUp() ) { + // one device that is up found + IsUp = 1; + break; + } + } + + // use this driver + OT->setScanWith( OT->driver(i) ); + + // create dialog + QDialog * Dlg = new QDialog( Parent, 0, TRUE ); + QVBoxLayout * V = new QVBoxLayout( Dlg ); + OTScan * Scn = new OTScan( Dlg ); + + connect( Scn, + SIGNAL( selected() ), + Dlg, + SLOT( accept() ) + ); + + if( Filter ) { + Scn->setScanFilter( Filter ); + } + + V->addWidget( Scn ); + Dlg->setCaption( tr("Scan Neighbourhood" ) ); + Dlg->showMaximized(); + int rv = Dlg->exec(); + + if( rv == QDialog::Accepted ) { + // get peer + Peer = Scn->selectedPeer(); + if( Peer == 0 ) { + // no peer selected + rv = QDialog::Rejected; + } else { + Channel = Scn->selectedChannel(); + } + } + + delete Dlg; + + return rv; +} + +void OTScan::setScanFilter( const UUIDVector & V ) { + Filter = V; +} + +void OTScan::resetScanFilter( void ) { + Filter.truncate(0); +} + +void OTScan::SLOT_DoScan( bool DoIt ) { + if( DoIt ) { + OT->scanNeighbourhood(); + } else { + OT->stopScanOfNeighbourhood(); + } + + scanMode( DoIt ); +} + +// double clicked on a device +void OTScan::SLOT_Selected( QListViewItem * it ) { + if( ! it ) + return; + + if( Filter.count() > 0 ) { + // filter on service + if( it->depth() == 0 ) { + // select a service and not a device + return; + } + + // store result + SelectedPeer = ((PeerLVI *)it->parent())->peer(); + SelectedChannel = ((ChannelLVI *)it)->channel(); + } else { + // click on device + if( it->depth() != 0 ) { + return; + } + + SelectedPeer = ((PeerLVI *)it)->peer(); + SelectedChannel = 0; + } + owarn << "Selected " << SelectedPeer->address().toString() << + " Channel " << SelectedChannel << oendl; + emit selected(); +} + +void OTScan::SLOT_FinishedDetecting( ) { + scanMode( false ); +} + +void OTScan::SLOT_CleanupOld( ) { + + // iterate over all peers and find those that + // are down and have no pairing info + OTPeer * TheP; + const LinkKeyArray & Keys = OT->getLinkKeys(); + + QListViewItem * Lit = DetectedPeers_LV->firstChild(); + while( Lit ) { + TheP = ((PeerLVI *)Lit)->peer(); + if( TheP->state() == OTPeer::Peer_Down ) { + unsigned int k; + + // what about linkkeys ? + for( k = 0; k < Keys.count(); k ++ ) { + if( TheP->address() == Keys[k].to() || + TheP->address() == Keys[k].from() + ) { + // part of linkkey + owarn << "LINKKEY " << TheP->address().toString() << oendl; + break; + } + } + + if( k == Keys.count() ) { + owarn << "RM LINKKEY " << TheP->address().toString() << oendl; + // not found -> remember to remove this peer + QListViewItem * Nit; + OT->removePeer( TheP ); + Nit = Lit->nextSibling(); + delete Lit; + Lit = Nit; + continue; + } + } else { + owarn << "NODOWN " << TheP->address().toString() << oendl; + } + + Lit = Lit->nextSibling(); + } +} + +void OTScan::SLOT_NewPeer( OTPeer * P, bool IsNew ){ + PeerLVI * it = 0; + + if( IsNew ) { + it = new PeerLVI( P, DetectedPeers_LV ); + } else { + // find peer in table + QListViewItem * Lit = DetectedPeers_LV->firstChild(); + while( Lit ) { + if( ((PeerLVI *)Lit)->peer() == P ) { + // this item + it = (PeerLVI *)Lit; + break; + } + Lit = Lit->nextSibling(); + } + + if( ! it ) { + owarn << "Should not occur" << oendl; + return; + } + } + + // update/show info + it->setText( 0, P->name() ); + it->setPixmap(0, Icons->deviceIcon( + OT->deviceTypeToName( P->deviceClass() ) ) ); + + // tell peer to report its state async + connect( P, + SIGNAL( peerStateReport( OTPeer *)), + this, + SLOT( SLOT_PeerState( OTPeer *)) + ); + + if( IsNew ) { + // find state + refreshState( (PeerLVI *)it, 1 ); + } else { + // update staet + SLOT_PeerState( P ); + } +} + +void OTScan::SLOT_PeerState( OTPeer * P ) { + PeerLVI * it = (PeerLVI *)DetectedPeers_LV->firstChild(); + while( it ) { + if( it->peer() == P ) { + break; + } + it = (PeerLVI * )it->nextSibling(); + } + + if( ! it ) + return; + + switch( P->state() ) { + case OTPeer::Peer_Unknown : + case OTPeer::Peer_Down : + it->setPixmap( 1, 0 ); + break; + case OTPeer::Peer_Up : + it->setPixmap( 1, Icons->loadPixmap( + ( P->connectedTo() ) ? "connected" : "notconnected" ) ); + if( it == Current && ! StrengthTimer->isActive() ) { + // start showing strength + StrengthTimer->start( 1000, FALSE ); + SLOT_UpdateStrength(); + } + break; + } +} + +void OTScan::SLOT_RefreshState( void ) { + + QListViewItem * it = DetectedPeers_LV->firstChild(); + while( it ) { + if( it->isSelected() ) { + break; + } + it = it->nextSibling(); + } + + if( ! it ) + return; + + refreshState( (PeerLVI *)it, 1 ); +} + +void OTScan::refreshState( PeerLVI * it, bool Force ) { + it->setPixmap( 1, Icons->loadPixmap( "find" ) ); + it->peer()->findOutState( 30, Force ); +} + +void OTScan::SLOT_Show( QListViewItem * it ) { + + if( ! it || it->depth() > 0 ) + return; + + QString S; + + Current = (PeerLVI *)it; + + Strength_PB->setProgress( 0 ); // reset + Address_LBL->setText( Current->peer()->address().toString() ); + Peer_GB->setTitle( Current->peer()->name() ); + + const LinkKeyArray & Keys = OT->getLinkKeys(); + + Paired_Led->setOn( FALSE ); + for( unsigned int i = 0; + i < Keys.count(); + i ++ ) { + if( Current->peer()->address() == Keys[i].to() ) { + Paired_Led->setOn( TRUE ); + break; + } + } + + if( Current->peer()->state() == OTPeer::Peer_Up ) { + RefreshServices_But->setEnabled( TRUE ); + StrengthTimer->start( 1000, FALSE ); + SLOT_UpdateStrength(); + } else { + RefreshServices_But->setEnabled( FALSE ); + } + +} + +void OTScan::SLOT_UpdateStrength( void ) { + OTDriver * D = Current->peer()->connectedTo(); + + if( D ) { + long Q = D->getLinkQuality( Current->peer()->address() ); + Strength_PB->setProgress( Q ); + if( ! Q ) { + // no quality + Strength_PB->setEnabled( TRUE ); + StrengthTimer->stop(); + } + } else { + Strength_PB->setEnabled( FALSE ); + Strength_PB->setProgress( 0 ); + // no point in continuing + StrengthTimer->stop(); + } +} + +void OTScan::SLOT_RefreshServices( void ) { + + QListViewItem * it = DetectedPeers_LV->firstChild(); + while( it ) { + if( it->isSelected() ) { + break; + } + it = it->nextSibling(); + } + + if( ! it ) + return; + + QString S; + PeerLVI * PI = (PeerLVI *)it; + + scanMode( true ); + qApp->processEvents(0); + + ServiceVector & V = PI->peer()->services(); + + while( PI->firstChild() ) { + // remove children + delete PI->firstChild(); + } + + for( unsigned int i = 0 ; + i < V.count(); + i ++ ) { + QString S; + S = V[i]->name(); + + if( S.isEmpty() ) { + continue; + } + + { QListViewItem * SIt; + UUIDVector UIDV; + QPixmap Pm; + bool Done = 0; + bool R; + short ID; + + SIt = 0; + + UIDV = V[i]->classIDList(); + // first all UUID ! 1200 12ff (Genericprofiles) + for( unsigned int j = 0; + j < UIDV.count(); + j ++ ) { + + if( Filter.count() ) { + bool FilterOut = 1; + // filter out if not in list + for( unsigned int ff = 0; + ff < Filter.count(); + ff ++ ) { + if( UIDV[j] == Filter[ff] ) { + FilterOut = 0; + break; + } + } + + if( FilterOut ) { + // not in filter list + continue; + } + } // else show + + ID = UIDV[j].toShort(); + if( ID < 0x1200 || ID > 0x12ff ) { + // use this profile + if( R ) { + unsigned int ch; + bool has; + has = V[i]->rfcommChannel( ch ); + SIt = new ChannelLVI( (has) ? (int)ch : -1 , PI ); + SIt->setText(0, V[i]->name() ); + + Pm = Icons->serviceIcon( ID, R ); + SIt->setPixmap(0, Pm ); + Done = 1; + break; + } + } + } + + if( ! Done ) { + // check other range too + for( unsigned int j = 0; + j < UIDV.count(); + j ++ ) { + + if( Filter.count() ) { + bool FilterOut = 1; + // filter out if not in list + for( unsigned int ff = 0; + ff < Filter.count(); + ff ++ ) { + if( UIDV[j] == Filter[ff] ) { + FilterOut = 0; + break; + } + } + + if( FilterOut ) { + // not in filter list + continue; + } + } // else show + + ID = UIDV[j].toShort(); + if( ID >= 0x1200 && ID <= 0x12ff ) { + // use this profile + unsigned int ch; + bool has; + has = V[i]->rfcommChannel( ch ); + SIt = new ChannelLVI( (has) ? (int)ch : -1 , PI ); + SIt->setText(0, V[i]->name() ); + + Pm = Icons->serviceIcon( ID, R ); + SIt->setPixmap(0, Pm ); + + break; + } + } + } + + } + } + + scanMode( false ); +} + +void OTScan::scanMode( bool M ) { + // avoid infinite loop because it triggers DoScan + Detect_But->blockSignals( TRUE ); + Detect_But->setOn( M ); + Detect_But->setText( (M) ? tr("Scanning") : tr("Scan") ); + Detect_But->blockSignals( FALSE ); +} + +// +// +// +// +// + +OTManage::OTManage( QWidget * parent, OTIcons * _IC ) : + OTManageGUI( parent ) { + + OT = OTGateway::getOTGateway(); + + Icons = (_IC ) ? _IC : new OTIcons(); + MyIcons = (_IC == 0 ); + AllDrivers_LV->setSorting(-1); + + connect( OT, + SIGNAL( driverListChanged() ), + this, + SLOT( SLOT_DriverListChanged() ) + ); + connect( OT, + SIGNAL( stateChange( OTDriver *, bool ) ), + this, + SLOT( SLOT_StateChange( OTDriver *, bool ) ) + ); + + SLOT_DriverListChanged(); + + AllDrivers_LV->header()->hide(); +} + +OTManage::~OTManage() { + if( MyIcons ) + delete Icons; + OTGateway::releaseOTGateway(); +} + +void OTManage::SLOT_ShowDriver( QListViewItem * It ) { + if( It == 0 || It->depth() > 0 ) + // not toplevel + return; + + DriverLVI * it = (DriverLVI *) It; + DriverIsUp_CB->setChecked( it->driver()->isUp() ); +} + +void OTManage::SLOT_UpDriver( bool Up ) { + QListViewItem * it = AllDrivers_LV->firstChild(); + while( it ) { + if( it->isSelected() ) { + OTDriver * D = ((DriverLVI *)it)->driver(); + owarn << "UP driver " << D->devname() << oendl; + // this + D->setUp( Up ); + return; + } + it = it->nextSibling(); + } +} + +void OTManage::SLOT_StateChange( OTDriver * D, bool Up ) { + QListViewItem * it = AllDrivers_LV->firstChild(); + while( it ) { + if( ((DriverLVI *)it)->driver() == D ) { + it->setPixmap( 0, + Icons->loadPixmap( ( Up ) ? "bluezon" : "bluezoff" ) ); + return; + } + it = it->nextSibling(); + } +} + +void OTManage::SLOT_DriverListChanged( ) { + DriverLVI * It; + QListViewItem * Sub; + QListViewItem * First = 0; + OTDriver* D; + OTDriverList & DL = OT->getDriverList(); + + AllDrivers_LV->clear(); + for( unsigned int i = 0; + i < DL.count(); + i ++ ) { + D = DL[i]; + It = new DriverLVI( D, AllDrivers_LV ); + + if( ! First ) + First = It; + + It->setText( 0, D->devname() ); + It->setPixmap( 0, + Icons->loadPixmap( (D->isUp()) ? + "bluezon" : "bluezoff" ) ); + + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Name" ) ); + Sub->setText( 1, D->name() ); + + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Address" ) ); + Sub->setText( 1, D->address().toString() ); + + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Revision" ) ); + Sub->setText( 1, D->revision() ); + + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Manufacturer" ) ); + Sub->setText( 1, D->manufacturer() ); + + QString Service, Device; + D->getClass( Service, Device ); + + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Service classes" ) ); + Sub->setText( 1, Service ); + Sub = new QListViewItem( It ); + Sub->setText( 0, tr( "Device class" ) ); + Sub->setText( 1, Device ); + } + + if( DL.count() ) { + AllDrivers_LV->setCurrentItem( First ); + DriverIsUp_CB->setEnabled( TRUE ); + } else { + DriverIsUp_CB->setChecked( FALSE ); + DriverIsUp_CB->setEnabled( FALSE ); + } +} + +void OTManage::SLOT_SetRefreshTimer( int v ) { + OT->setRefreshTimer( v * 1000 ); +} + +// +// +// +// +// + +OTMain::OTMain( QWidget * parent ) : OTMainGUI( parent ) { + + Icons = new OTIcons(); + OT = OTGateway::getOTGateway(); + + connect( OT, + SIGNAL( deviceEnabled( bool ) ), + this, + SLOT( SLOT_DeviceIsEnabled( bool ) ) + ); + connect( OT, + SIGNAL( driverListChanged() ), + this, + SLOT( SLOT_DriverListChanged() ) + ); + connect( OT, + SIGNAL( stateChange( OTDriver *, bool ) ), + this, + SLOT( SLOT_StateChange( OTDriver *, bool ) ) + ); + + if( ! OT->needsEnabling() ) { + MustBeEnabled_CB->hide(); + } else { + // detect current state + MustBeEnabled_CB->setChecked( + OT->isEnabled() ); + } + + SLOT_DriverListChanged(); +} + +OTMain::~OTMain() { + OTGateway::releaseOTGateway(); + delete Icons; +} + +void OTMain::SLOT_DriverListChanged() { + OTDriver * D; + OTDriverList & DL = OT->getDriverList(); + + DeviceList_CB->clear(); + for( unsigned int i = 0; + i < DL.count(); + i ++ ) { + D = DL[i]; + DeviceList_CB->insertItem( + Icons->loadPixmap( (D->isUp()) ? + "bluezon" : "bluezoff" ), + D->devname() ); + if( D == OT->scanWith() ) { + DeviceList_CB->setCurrentItem( i ); + } + } + + Scan_But->setEnabled( OT->getDriverList().count() > 0 ); + DeviceList_CB->setEnabled( OT->getDriverList().count() > 0 ); +} + +void OTMain::SLOT_EnableBluetooth( bool Up ) { + OT->SLOT_SetEnabled( Up ); +} + +void OTMain::SLOT_DeviceIsEnabled( bool Up ) { + MustBeEnabled_CB->blockSignals( TRUE ); + MustBeEnabled_CB->setChecked( Up ); + MustBeEnabled_CB->blockSignals( FALSE ); +} + +void OTMain::SLOT_Manage( void ) { + QDialog * Dlg = new QDialog( this, 0, TRUE ); + QVBoxLayout * V = new QVBoxLayout( Dlg ); + OTManage * Mng = new OTManage( Dlg, Icons ); + + V->addWidget( Mng ); + + Dlg->setCaption( tr("Manage local devices" ) ); + Dlg->showMaximized(); + Dlg->exec(); + delete Dlg; +} + +void OTMain::SLOT_Scan( void ) { + OTDriverList & DL = OT->getDriverList(); + for( unsigned int i = 0; + i < DL.count(); + i ++ ) { + if( DL[i]->isUp() && + DL[i]->devname() == DeviceList_CB->currentText() + ) { + QDialog * Dlg = new QDialog( this, 0, TRUE ); + QVBoxLayout * V = new QVBoxLayout( Dlg ); + OTScan * Scn = new OTScan( Dlg, Icons ); + + OT->setScanWith( OT->driver(i) ); + V->addWidget( Scn ); + Dlg->setCaption( tr("Scan Neighbourhood" ) ); + Dlg->showMaximized(); + Dlg->exec(); + + delete Dlg; + return; + } + } + +} + +void OTMain::SLOT_StateChange( OTDriver * D, bool Up ) { + for( int i = 0; + i < DeviceList_CB->count(); + i ++ ) { + if( DeviceList_CB->text(i) == D->devname() ) { + DeviceList_CB->changeItem( + Icons->loadPixmap( (Up) ? "bluezon" : "bluezoff" ), + D->devname(), + i ); + return; + } + } +} + +void OTMain::SLOT_Pairing( void ) { + QDialog * Dlg = new QDialog( this, 0, TRUE ); + QVBoxLayout * V = new QVBoxLayout( Dlg ); + OTPairing * Pair = new OTPairing( Dlg, Icons ); + + V->addWidget( Pair ); + Dlg->showMaximized(); + Dlg->setCaption( tr("Manage pairing" ) ); + Dlg->exec(); + + delete Dlg; +} |