00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "pointers.h"
00020
00021 namespace SaX {
00022
00023
00024
00025 SaXManipulatePointers::SaXManipulatePointers (SaXImport* in, int ptr) {
00026
00031
00032 if ( ! in ) {
00033 excNullPointerArgument ();
00034 qError (errorString(),EXC_NULLPOINTERARGUMENT);
00035 return;
00036 }
00037 if ( in->getSectionID() != SAX_POINTERS ) {
00038 excPointerImportBindFailed ( in->getSectionID() );
00039 qError (errorString(),EXC_POINTERIMPORTBINDFAILED);
00040 return;
00041 }
00042 mImport = in;
00043 mPointer = ptr;
00044 mImport -> setID ( mPointer );
00045 }
00046
00047
00048
00049
00050 bool SaXManipulatePointers::selectPointer (int ptr) {
00051
00054
00055 if (! mImport) {
00056 return false;
00057 }
00058 if (mImport -> setID ( ptr )) {
00059 mPointer = ptr;
00060 return true;
00061 }
00062 return false;
00063 }
00064
00065
00066
00067
00068 void SaXManipulatePointers::setDriver (const QString& driver) {
00069
00072
00073 if (! mImport) {
00074 return;
00075 }
00076 mImport -> setItem ( "Driver",driver );
00077 }
00078
00079
00080
00081
00082 void SaXManipulatePointers::setDevice (const QString& device) {
00083
00088
00089 if (! mImport) {
00090 return;
00091 }
00092 mImport -> setItem ( "Device",device );
00093 }
00094
00095
00096
00097
00098 void SaXManipulatePointers::setProtocol (const QString& protocol) {
00099
00102
00103 if (! mImport) {
00104 return;
00105 }
00106 mImport -> setItem ( "Protocol",protocol );
00107 }
00108
00109
00110
00111
00112 void SaXManipulatePointers::setNamePair (
00113 const QString& vendor , const QString& name
00114 ) {
00115
00121
00122 if (! mImport) {
00123 return;
00124 }
00125 QString val;
00126 QTextOStream (&val) << vendor << ";" << name;
00127 mImport -> setItem ( "Name",val );
00128 }
00129
00130
00131
00132
00133 void SaXManipulatePointers::setOption (
00134 const QString& keyword, const QString& value
00135 ) {
00136
00141
00142 if (! mImport) {
00143 return;
00144 }
00145 QString key (keyword);
00146 QString val (value);
00147 if (! value) {
00148
00149
00150
00151 mImport->setItem ("Option",key);
00152 } else {
00153
00154
00155
00156 mImport->setRawItem ("RawOption",
00157 "\""+key+"\"","\""+val+"\""
00158 );
00159 }
00160 }
00161
00162
00163
00164
00165 void SaXManipulatePointers::addOption (
00166 const QString& keyword, const QString& value
00167 ) {
00168
00173
00174 if (! mImport) {
00175 return;
00176 }
00177 QString key (keyword);
00178 QString val (value);
00179 if (! value) {
00180
00181
00182
00183 mImport->addItem ("Option",key);
00184 } else {
00185
00186
00187
00188 mImport->addRawItem ("RawOption",
00189 "\""+key+"\"","\""+val+"\""
00190 );
00191 }
00192 }
00193
00194
00195
00196
00197 void SaXManipulatePointers::removeOption (const QString& value) {
00198
00203
00204 if (! mImport) {
00205 return;
00206 }
00207 QString val (value);
00208 QString str = mImport->getItem("RawOption");
00209 if (! str.contains ("\""+val+"\"")) {
00210
00211
00212
00213 mImport->removeItem ("Option",val);
00214 } else {
00215
00216
00217
00218 mImport->removeRawItem ("RawOption","\""+val+"\"");
00219 }
00220 }
00221
00222
00223
00224
00225 QString SaXManipulatePointers::getDevice ( void ) {
00226
00230
00231 if (! mImport) {
00232 return QString();
00233 }
00234 return mImport -> getItem ("Device");
00235 }
00236
00237
00238
00239
00240 QString SaXManipulatePointers::getDriver ( void ) {
00241
00243
00244 if (! mImport) {
00245 return QString();
00246 }
00247 return mImport -> getItem ("Driver");
00248 }
00249
00250
00251
00252
00253 QString SaXManipulatePointers::getProtocol ( void ) {
00254
00256
00257 if (! mImport) {
00258 return QString();
00259 }
00260 return mImport -> getItem ("Protocol");
00261 }
00262
00263
00264
00265
00266 QDict<QString> SaXManipulatePointers::getOptions (void) {
00267
00273
00274 if (! mImport) {
00275 return QDict<QString>();
00276 }
00277 QDict<QString> result;
00278 QString stdOptions = mImport -> getItem ("Option");
00279 QString rawOptions = mImport -> getItem ("RawOption");
00280
00281
00282
00283 QStringList stdlist = QStringList::split ( ",", stdOptions );
00284 for ( QStringList::Iterator
00285 in = stdlist.begin(); in != stdlist.end(); ++in
00286 ) {
00287 QString item (*in);
00288 result.insert (item,new QString);
00289 }
00290
00291
00292
00293 QStringList rawlist = QStringList::split ( ",", rawOptions );
00294 for ( QStringList::Iterator
00295 in = rawlist.begin(); in != rawlist.end(); ++in
00296 ) {
00297 QString item (*in);
00298 QRegExp itemExp ("\"(.*)\" \"(.*)\"");
00299 int pos = itemExp.search (item);
00300 if (pos >= 0) {
00301 QString key = itemExp.cap(1);
00302 QString* val = new QString (itemExp.cap(2));
00303 result.insert (key,val);
00304 }
00305 }
00306 return result;
00307 }
00308
00309
00310
00311
00312 SaXManipulateMice::SaXManipulateMice (
00313 SaXImport* in, int ptr
00314 ) : SaXManipulateMiceIF (in,ptr) {
00315
00318
00319 mCDBMice = 0;
00320 }
00321
00322
00323
00324
00325 void SaXManipulateMice::enableWheelEmulation (int btn) {
00326
00330
00331 if (! mImport) {
00332 return;
00333 }
00334 QString button;
00335 button.sprintf ("%d",btn);
00336 mImport -> setItem ("EmulateWheel",button);
00337 }
00338
00339
00340
00341
00342 void SaXManipulateMice::disableWheelEmulation (void) {
00343
00347
00348 if (! mImport) {
00349 return;
00350 }
00351 mImport -> setItem ("EmulateWheel","");
00352 }
00353
00354
00355
00356
00357 void SaXManipulateMice::enable3ButtonEmulation (void) {
00358
00362
00363 if (! mImport) {
00364 return;
00365 }
00366 mImport -> setItem ("Emulate3Buttons","on");
00367 }
00368
00369
00370
00371
00372 void SaXManipulateMice::disable3ButtonEmulation (void) {
00373
00375
00376 if (! mImport) {
00377 return;
00378 }
00379 mImport -> setItem ("Emulate3Buttons","");
00380 }
00381
00382
00383
00384
00385 void SaXManipulateMice::enableWheel (void) {
00386
00391
00392 if (! mImport) {
00393 return;
00394 }
00395 mImport -> setItem ("ZAxisMapping","4 5");
00396 }
00397
00398
00399
00400
00401 void SaXManipulateMice::enableXAxisInvertation (void) {
00402
00405
00406 if (! mImport) {
00407 return;
00408 }
00409 mImport -> setItem ("InvX","on");
00410 }
00411
00412
00413
00414
00415 void SaXManipulateMice::enableYAxisInvertation (void) {
00416
00419
00420 if (! mImport) {
00421 return;
00422 }
00423 mImport -> setItem ("InvY","on");
00424 }
00425
00426
00427
00428
00429 void SaXManipulateMice::disableWheel (void) {
00430
00433
00434 if (! mImport) {
00435 return;
00436 }
00437 mImport -> setItem ("ZAxisMapping","");
00438 }
00439
00440
00441
00442
00443 void SaXManipulateMice::disableXAxisInvertation (void) {
00444
00447
00448 if (! mImport) {
00449 return;
00450 }
00451 mImport -> setItem ("InvX","");
00452 }
00453
00454
00455
00456
00457 void SaXManipulateMice::disableYAxisInvertation (void) {
00458
00461
00462 if (! mImport) {
00463 return;
00464 }
00465 mImport -> setItem ("InvY","");
00466 }
00467
00468
00469
00470
00471 bool SaXManipulateMice::isMouse (void) {
00472
00477
00478 if (! mImport) {
00479 return false;
00480 }
00481 QString driver = getDriver();
00482 QString fashion = mImport -> getItem ("InputFashion");
00483 if (driver == "mouse") {
00484 if (fashion != "MultiSeat") {
00485 return true;
00486 }
00487 return false;
00488 }
00489 if ((fashion != "Tablet") &&
00490 (fashion != "Pen") &&
00491 (fashion != "Eraser") &&
00492 (fashion != "VNC") &&
00493 (fashion != "Keyboard") &&
00494 (fashion != "Touchpanel")
00495 ) {
00496 return true;
00497 }
00498 return false;
00499 }
00500
00501
00502
00503
00504 bool SaXManipulateMice::isWheelEnabled (void) {
00505
00508
00509 if (! mImport) {
00510 return false;
00511 }
00512 QString zaxis = mImport -> getItem ("ZAxisMapping");
00513 if (! zaxis.isEmpty()) {
00514 return true;
00515 }
00516 return false;
00517 }
00518
00519
00520
00521
00522 bool SaXManipulateMice::isXAxisInverted (void) {
00523
00526
00527 if (! mImport) {
00528 return false;
00529 }
00530 QString xaxis = mImport -> getItem ("InvX");
00531 if (xaxis == "on") {
00532 return true;
00533 }
00534 return false;
00535 }
00536
00537
00538
00539
00540 bool SaXManipulateMice::isYAxisInverted (void) {
00541
00544
00545 if (! mImport) {
00546 return false;
00547 }
00548 QString yaxis = mImport -> getItem ("InvY");
00549 if (yaxis == "on") {
00550 return true;
00551 }
00552 return false;
00553 }
00554
00555
00556
00557
00558 bool SaXManipulateMice::isWheelEmulated (void) {
00559
00562
00563 if (! mImport) {
00564 return false;
00565 }
00566 QString emulate = mImport -> getItem ("EmulateWheel");
00567 if (! emulate.isEmpty()) {
00568 return true;
00569 }
00570 return false;
00571 }
00572
00573
00574
00575
00576 bool SaXManipulateMice::isButtonEmulated (void) {
00577
00580
00581 if (! mImport) {
00582 return false;
00583 }
00584 QString emulate = mImport -> getItem ("Emulate3Buttons");
00585 if (emulate == "on") {
00586 return true;
00587 }
00588 return false;
00589 }
00590
00591
00592
00593
00594 int SaXManipulateMice::getWheelEmulatedButton (void) {
00595
00599
00600 if (! isWheelEmulated()) {
00601 return -1;
00602 }
00603 int btn = mImport -> getItem ("EmulateWheel").toInt();
00604 return btn;
00605 }
00606
00607
00608
00609
00610 QList<QString> SaXManipulateMice::getMouseList (void) {
00611
00615
00616 mCDBMouseList.clear();
00617 if ( ! mCDBMice ) {
00618 mCDBMice = new SaXProcess ();
00619 mCDBMice -> start (CDB_POINTERS);
00620 }
00621 QDict< QDict<QString> > CDBData = mCDBMice -> getTablePointerCDB ();
00622 QDictIterator< QDict<QString> > it (CDBData);
00623 for (; it.current(); ++it) {
00624 mCDBMouseList.append (new QString (it.currentKey()));
00625 }
00626 return mCDBMouseList;
00627 }
00628
00629
00630
00631
00632 QList<QString> SaXManipulateMice::getMouseVendorList (void) {
00633
00636
00637 QList<QString> mouseList = getMouseList();
00638 mCDBMouseList.clear();
00639 QListIterator<QString> it (mouseList);
00640 for (; it.current(); ++it) {
00641 QStringList vnlist = QStringList::split ( ":", *it.current() );
00642 QString* vendorName = new QString (vnlist.first());
00643 int hasVendor = false;
00644 QListIterator<QString> io (mCDBMouseList);
00645 for (; io.current(); ++io) {
00646 if ( *io.current() == *vendorName ) {
00647 hasVendor = true;
00648 break;
00649 }
00650 }
00651 if (! hasVendor ) {
00652 mCDBMouseList.append ( vendorName );
00653 }
00654 }
00655 return mCDBMouseList;
00656 }
00657
00658
00659
00660
00661 QList<QString> SaXManipulateMice::getMouseModelList (
00662 const QString& vendor
00663 ) {
00664
00667
00668 QList<QString> mouseList = getMouseList();
00669 mCDBMouseList.clear();
00670 QListIterator<QString> it (mouseList);
00671 for (; it.current(); ++it) {
00672 QStringList vnlist = QStringList::split ( ":", *it.current() );
00673 QString vendorName = vnlist.first();
00674 QString* modelName = new QString (vnlist.last());
00675 if ( vendorName == vendor ) {
00676 mCDBMouseList.append ( modelName );
00677 }
00678 }
00679 return mCDBMouseList;
00680 }
00681
00682
00683
00684
00685 void SaXManipulateMice::setMouse ( const QString& group ) {
00686
00690
00691 if ( ! mCDBMice ) {
00692 mCDBMice = new SaXProcess ();
00693 mCDBMice -> start (CDB_POINTERS);
00694 }
00695 QList< QDict<QString> > data;
00696 data = mCDBMice -> getTablePointerCDB_DATA (
00697 group
00698 );
00699
00700
00701
00702
00703 QDict<QString>* record = data.take(0);
00704 for (int n=0;n < mPointer;n++) {
00705 data.append(new QDict<QString>());
00706 }
00707 data.append ( record );
00708
00709
00710
00711 if (data.isEmpty()) {
00712 excCDBRecordNotFound (group);
00713 qError (errorString(),EXC_CDBRECORDNOTFOUND);
00714 return;
00715 }
00716 mImport -> merge ( data );
00717
00718
00719
00720 QStringList nameList = QStringList::split ( ":", group );
00721 mImport -> setItem ( "Vendor", nameList.first() );
00722 mImport -> setItem ( "Name" , nameList.last() );
00723 }
00724
00725
00726
00727
00728 void SaXManipulateMice::setMouse (
00729 const QString& vendor, const QString& model
00730 ) {
00731
00734
00735 setMouse (vendor+":"+model);
00736 }
00737
00738
00739
00740
00741 QDict<QString> SaXManipulateMice::getMouseData (
00742 const QString& group
00743 ) {
00744
00747
00748 mCDBMouseData.clear();
00749 if ( ! mCDBMice ) {
00750 mCDBMice = new SaXProcess ();
00751 mCDBMice -> start (CDB_POINTERS);
00752 }
00753 QDict< QDict<QString> > CDBData = mCDBMice -> getTablePointerCDB ();
00754 QDictIterator< QDict<QString> > it (CDBData);
00755 for (; it.current(); ++it) {
00756 if ( it.currentKey() == group ) {
00757 mCDBMouseData = *it.current();
00758 break;
00759 }
00760 }
00761 return mCDBMouseData;
00762 }
00763
00764
00765
00766
00767 QDict<QString> SaXManipulateMice::getMouseData (
00768 const QString& vendor, const QString& name
00769 ) {
00770
00773
00774 return getMouseData (vendor+":"+name);
00775 }
00776
00777
00778
00779
00780
00781 SaXManipulateTablets::SaXManipulateTablets (
00782 SaXImport* pointer, SaXImport* layout, int id
00783 ) : SaXManipulateTabletsIF (pointer,id) {
00784
00787
00788 mManipInputDevices = new SaXManipulateDevices (pointer,layout);
00789 mCDBTabletModules = 0;
00790 mCDBTablets = 0;
00791 mCDBPens = 0;
00792 }
00793
00794
00795
00796
00797 void SaXManipulateTablets::setType (const QString& type) {
00798
00801
00802 if (! mImport) {
00803 return;
00804 }
00805 mImport -> setItem ("TabletType",type);
00806 }
00807
00808
00809
00810
00811 void SaXManipulateTablets::setMode (const QString& mode) {
00812
00815
00816 if (! mImport) {
00817 return;
00818 }
00819 mImport -> setItem ("TabletMode",mode);
00820 }
00821
00822
00823
00824
00825 bool SaXManipulateTablets::isTablet (void) {
00826
00829
00830 if (! mImport) {
00831 return false;
00832 }
00833 QString fashion = mImport -> getItem ("InputFashion");
00834 if (fashion == "Tablet") {
00835 return true;
00836 }
00837 return false;
00838 }
00839
00840
00841
00842
00843 bool SaXManipulateTablets::isPen (void) {
00844
00847
00848 if (! mImport) {
00849 return false;
00850 }
00851 QString fashion = mImport -> getItem ("InputFashion");
00852 if (fashion == "Pen") {
00853 return true;
00854 }
00855 return false;
00856 }
00857
00858
00859
00860
00861 bool SaXManipulateTablets::isEraser (void) {
00862
00866
00867 if (! mImport) {
00868 return false;
00869 }
00870 QString fashion = mImport -> getItem ("InputFashion");
00871 if (fashion == "Eraser") {
00872 return true;
00873 }
00874 return false;
00875 }
00876
00877
00878
00879
00880 QString SaXManipulateTablets::getName (void) {
00881
00883
00884 if (! mImport) {
00885 return QString();
00886 }
00887 return mImport -> getItem ("Name");
00888 }
00889
00890
00891
00892
00893 QString SaXManipulateTablets::getVendor (void) {
00894
00896
00897 if (! mImport) {
00898 return QString();
00899 }
00900 return mImport -> getItem ("Vendor");
00901 }
00902
00903
00904
00905
00906 QString SaXManipulateTablets::getType (void) {
00907
00910
00911 if (! mImport) {
00912 return QString();
00913 }
00914 return mImport -> getItem ("TabletType");
00915 }
00916
00917
00918
00919
00920 QString SaXManipulateTablets::getMode (void) {
00921
00924
00925 if (! mImport) {
00926 return QString();
00927 }
00928 return mImport -> getItem ("TabletMode");
00929 }
00930
00931
00932
00933
00934 QList<QString> SaXManipulateTablets::getTabletDrivers (void) {
00935
00938
00939 mCDBTabletDrivers.clear();
00940 if ( ! mCDBTabletModules ) {
00941 mCDBTabletModules = new SaXProcess ();
00942 mCDBTabletModules -> start (CDB_TABLETMODULES);
00943 }
00944 QDict< QDict<QString> > CDBModules=mCDBTabletModules->getTablePointerCDB();
00945 QDictIterator< QDict<QString> > it (CDBModules);
00946 for (; it.current(); ++it) {
00947 mCDBTabletDrivers.append (new QString(it.currentKey()));
00948 }
00949 return mCDBTabletDrivers;
00950 }
00951
00952
00953
00954
00955 QDict<QString> SaXManipulateTablets::getTabletOptions (const QString& driver) {
00956
00962
00963 mCDBTabletOptions.clear();
00964 if ( ! mCDBTabletModules ) {
00965 mCDBTabletModules = new SaXProcess ();
00966 mCDBTabletModules -> start (CDB_TABLETMODULES);
00967 }
00968 QList< QDict<QString> > opts;
00969 opts = mCDBTabletModules -> getTablePointerCDB_DATA (
00970 driver
00971 );
00972 if (opts.isEmpty()) {
00973 excCDBRecordNotFound (driver);
00974 qError (errorString(),EXC_CDBRECORDNOTFOUND);
00975 return QDict<QString>();
00976 }
00977 mCDBTabletOptions = *opts.at(0);
00978 return mCDBTabletOptions;
00979 }
00980
00981
00982
00983
00984 QList<QString> SaXManipulateTablets::getTabletList (void) {
00985
00989
00990 mCDBTabletList.clear();
00991 if ( ! mCDBTablets ) {
00992 mCDBTablets = new SaXProcess ();
00993 mCDBTablets -> start (CDB_TABLETS);
00994 }
00995 QDict< QDict<QString> > CDBData = mCDBTablets -> getTablePointerCDB ();
00996 QDictIterator< QDict<QString> > it (CDBData);
00997 for (; it.current(); ++it) {
00998 mCDBTabletList.append (new QString (it.currentKey()));
00999 }
01000 return mCDBTabletList;
01001 }
01002
01003
01004
01005
01006 QList<QString> SaXManipulateTablets::getTabletVendorList (void) {
01007
01010
01011 QList<QString> tabletList = getTabletList();
01012 mCDBTabletList.clear();
01013 QListIterator<QString> it (tabletList);
01014 for (; it.current(); ++it) {
01015 QStringList vnlist = QStringList::split ( ":", *it.current() );
01016 QString* vendorName = new QString (vnlist.first());
01017 int hasVendor = false;
01018 QListIterator<QString> io (mCDBTabletList);
01019 for (; io.current(); ++io) {
01020 if ( *io.current() == *vendorName ) {
01021 hasVendor = true;
01022 break;
01023 }
01024 }
01025 if (! hasVendor ) {
01026 mCDBTabletList.append ( vendorName );
01027 }
01028 }
01029 return mCDBTabletList;
01030 }
01031
01032
01033
01034
01035 QList<QString> SaXManipulateTablets::getTabletModelList (
01036 const QString& vendor
01037 ) {
01038
01041
01042 QList<QString> tabletList = getTabletList();
01043 mCDBTabletList.clear();
01044 QListIterator<QString> it (tabletList);
01045 for (; it.current(); ++it) {
01046 QStringList vnlist = QStringList::split ( ":", *it.current() );
01047 QString vendorName = vnlist.first();
01048 QString* modelName = new QString (vnlist.last());
01049 if ( vendorName == vendor ) {
01050 mCDBTabletList.append ( modelName );
01051 }
01052 }
01053 return mCDBTabletList;
01054 }
01055
01056
01057
01058
01059 QDict<QString> SaXManipulateTablets::getTabletData ( const QString& group ) {
01060
01063
01064 mCDBTabletData.clear();
01065 if ( ! mCDBTablets ) {
01066 mCDBTablets = new SaXProcess ();
01067 mCDBTablets -> start (CDB_TABLETS);
01068 }
01069 QDict< QDict<QString> > CDBData = mCDBTablets -> getTablePointerCDB ();
01070 QDictIterator< QDict<QString> > it (CDBData);
01071 for (; it.current(); ++it) {
01072 if ( it.currentKey() == group ) {
01073 mCDBTabletData = *it.current();
01074 break;
01075 }
01076 }
01077 return mCDBTabletData;
01078 }
01079
01080
01081
01082
01083 QDict<QString> SaXManipulateTablets::getTabletData (
01084 const QString& vendor,const QString& name
01085 ) {
01086
01089
01090 return getTabletData (vendor+":"+name);
01091 }
01092
01093
01094
01095
01096 QDict<QString> SaXManipulateTablets::getPenData ( const QString& group ) {
01097
01100
01101 mCDBTabletData.clear();
01102 if ( ! mCDBPens ) {
01103 mCDBPens = new SaXProcess ();
01104 mCDBPens -> start (CDB_PENS);
01105 }
01106 QDict< QDict<QString> > CDBData = mCDBPens -> getTablePointerCDB ();
01107 QDictIterator< QDict<QString> > it (CDBData);
01108 for (; it.current(); ++it) {
01109 if ( it.currentKey() == group ) {
01110 mCDBTabletData = *it.current();
01111 break;
01112 }
01113 }
01114 return mCDBTabletData;
01115 }
01116
01117
01118
01119
01120 QDict<QString> SaXManipulateTablets::getPenData (
01121 const QString& vendor,const QString& name
01122 ) {
01123
01126
01127 return getPenData (vendor+":"+name);
01128 }
01129
01130
01131
01132
01133 QList<QString> SaXManipulateTablets::getPenList (void) {
01134
01138
01139 mCDBPenList.clear();
01140 if ( ! mCDBPens ) {
01141 mCDBPens = new SaXProcess ();
01142 mCDBPens -> start (CDB_PENS);
01143 }
01144 QDict< QDict<QString> > CDBData = mCDBPens -> getTablePointerCDB ();
01145 QDictIterator< QDict<QString> > it (CDBData);
01146 for (; it.current(); ++it) {
01147 mCDBPenList.append (new QString (it.currentKey()));
01148 }
01149 return mCDBPenList;
01150 }
01151
01152
01153
01154
01155 void SaXManipulateTablets::setTablet (const QString& group) {
01156
01160
01161 if ( ! mCDBTablets ) {
01162 mCDBTablets = new SaXProcess ();
01163 mCDBTablets -> start (CDB_TABLETS);
01164 }
01165 QList< QDict<QString> > data;
01166 data = mCDBTablets -> getTablePointerCDB_DATA (
01167 group
01168 );
01169
01170
01171
01172
01173 QDict<QString>* record = data.take(0);
01174 for (int n=0;n < mPointer;n++) {
01175 data.append(new QDict<QString>());
01176 }
01177 data.append ( record );
01178
01179
01180
01181 if (data.isEmpty()) {
01182 excCDBRecordNotFound (group);
01183 qError (errorString(),EXC_CDBRECORDNOTFOUND);
01184 return;
01185 }
01186 mImport -> merge ( data );
01187
01188
01189
01190 QStringList nameList = QStringList::split ( ":", group );
01191 mImport -> setItem ( "Vendor", nameList.first() );
01192 mImport -> setItem ( "Name" , nameList.last() );
01193 }
01194
01195
01196
01197 void SaXManipulateTablets::setTablet (
01198 const QString& vendor, const QString& model
01199 ) {
01200
01203
01204 setTablet (vendor+":"+model);
01205 }
01206
01207
01208
01209
01210 int SaXManipulateTablets::addPen (const QString& group) {
01211
01217
01218 if ( ! mCDBPens ) {
01219 mCDBPens = new SaXProcess ();
01220 mCDBPens -> start (CDB_PENS);
01221 }
01222 QList< QDict<QString> > data;
01223 data = mCDBPens -> getTablePointerCDB_DATA (
01224 group
01225 );
01226 if (data.isEmpty()) {
01227 excCDBRecordNotFound (group);
01228 qError (errorString(),EXC_CDBRECORDNOTFOUND);
01229 return -1;
01230 }
01231
01232
01233
01234 QDict<QString> penData = *data.at(0);
01235 QString* type = penData["TabletType"];
01236 if (! type) {
01237 excPointerFashionTypeFailed ("undefined");
01238 qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
01239 return -1;
01240 }
01241 if ((*type != "stylus") && (*type != "eraser")) {
01242 excPointerFashionTypeFailed (*type);
01243 qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
01244 return -1;
01245 }
01246 QString fashion (SAX_INPUT_PEN);
01247 if (*type == "eraser") {
01248 fashion = SAX_INPUT_ERASER;
01249 }
01250
01251
01252
01253
01254 int newPen = mManipInputDevices->addInputDevice (fashion);
01255 if ( ! selectPointer (newPen)) {
01256 return -1;
01257 }
01258
01259
01260
01261
01262 QDict<QString>* record = data.take(0);
01263 for (int n=0;n < mPointer;n++) {
01264 data.append(new QDict<QString>());
01265 }
01266 data.append ( record );
01267
01268
01269
01270 mImport -> merge ( data );
01271
01272
01273
01274 QStringList nameList = QStringList::split ( ":", group );
01275 mImport -> setItem ( "Vendor", nameList.first() );
01276 mImport -> setItem ( "Name" , nameList.last() );
01277 return newPen;
01278 }
01279
01280
01281
01282 int SaXManipulateTablets::addPen (
01283 const QString& vendor, const QString& model
01284 ) {
01285
01290
01291 return addPen (vendor+":"+model);
01292 }
01293
01294
01295
01296
01297 int SaXManipulateTablets::removePen ( int id ) {
01298
01303
01304 if (! selectPointer ( id )) {
01305 return -1;
01306 }
01307 QString fashion (
01308 mImport->getItem("InputFashion")
01309 );
01310 if (
01311 (fashion != QString(SAX_INPUT_PEN )) &&
01312 (fashion != QString(SAX_INPUT_ERASER))
01313 ) {
01314 excPointerFashionTypeFailed (fashion);
01315 qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
01316 return -1;
01317 }
01318 return mManipInputDevices->removeInputDevice (id);
01319 }
01320
01321
01322
01323
01324 SaXManipulateTouchscreens::SaXManipulateTouchscreens (
01325 SaXImport* in, int ptr
01326 ) : SaXManipulateTouchscreensIF (in,ptr) {
01327
01331
01332 mCDBPanels = 0;
01333 }
01334
01335
01336
01337
01338 bool SaXManipulateTouchscreens::isTouchpanel (void) {
01339
01343
01344 if (! mImport) {
01345 return false;
01346 }
01347 QString fashion = mImport -> getItem ("InputFashion");
01348 if (fashion == "Touchpanel") {
01349 return true;
01350 }
01351 return false;
01352 }
01353
01354
01355
01356
01357 QString SaXManipulateTouchscreens::getName ( void ) {
01358
01362
01363 if (! mImport) {
01364 return QString();
01365 }
01366 QString name = mImport -> getItem ("Name");
01367 QStringList vnlist = QStringList::split ( ";", name );
01368 return vnlist.last();
01369 }
01370
01371
01372
01373
01374 QString SaXManipulateTouchscreens::getVendor ( void ) {
01375
01379
01380 if (! mImport) {
01381 return QString();
01382 }
01383 QString name = mImport -> getItem ("Name");
01384 QStringList vnlist = QStringList::split ( ";", name );
01385 return vnlist.first();
01386 }
01387
01388
01389
01390
01391 QString SaXManipulateTouchscreens::getType (void) {
01392
01396
01397 if (! mImport) {
01398 return QString();
01399 }
01400 return mImport -> getItem ("TabletType");
01401 }
01402
01403
01404
01405
01406 QList<QString> SaXManipulateTouchscreens::getPanelList (void) {
01407
01411
01412 mCDBPanelList.clear();
01413 if ( ! mCDBPanels ) {
01414 mCDBPanels = new SaXProcess ();
01415 mCDBPanels -> start (CDB_TOUCHERS);
01416 }
01417 QDict< QDict<QString> > CDBData = mCDBPanels -> getTablePointerCDB ();
01418 QDictIterator< QDict<QString> > it (CDBData);
01419 for (; it.current(); ++it) {
01420 mCDBPanelList.append (new QString (it.currentKey()));
01421 }
01422 return mCDBPanelList;
01423 }
01424
01425
01426
01427
01428 QList<QString> SaXManipulateTouchscreens::getPanelVendorList (void) {
01429
01432
01433 QList<QString> panelList = getPanelList();
01434 mCDBPanelList.clear();
01435 QListIterator<QString> it (panelList);
01436 for (; it.current(); ++it) {
01437 QStringList vnlist = QStringList::split ( ":", *it.current() );
01438 QString* vendorName = new QString (vnlist.first());
01439 int hasVendor = false;
01440 QListIterator<QString> io (mCDBPanelList);
01441 for (; io.current(); ++io) {
01442 if ( *io.current() == *vendorName ) {
01443 hasVendor = true;
01444 break;
01445 }
01446 }
01447 if (! hasVendor ) {
01448 mCDBPanelList.append ( vendorName );
01449 }
01450 }
01451 return mCDBPanelList;
01452 }
01453
01454
01455
01456
01457 QList<QString> SaXManipulateTouchscreens::getPanelModelList (
01458 const QString& vendor
01459 ) {
01460
01463
01464 QList<QString> panelList = getPanelList();
01465 mCDBPanelList.clear();
01466 QListIterator<QString> it (panelList);
01467 for (; it.current(); ++it) {
01468 QStringList vnlist = QStringList::split ( ":", *it.current() );
01469 QString vendorName = vnlist.first();
01470 QString* modelName = new QString (vnlist.last());
01471 if ( vendorName == vendor ) {
01472 mCDBPanelList.append ( modelName );
01473 }
01474 }
01475 return mCDBPanelList;
01476 }
01477
01478
01479
01480
01481 QDict<QString> SaXManipulateTouchscreens::getPanelData (
01482 const QString& group
01483 ) {
01484
01487
01488 mCDBPanelData.clear();
01489 if ( ! mCDBPanels ) {
01490 mCDBPanels = new SaXProcess ();
01491 mCDBPanels -> start (CDB_TOUCHERS);
01492 }
01493 QDict< QDict<QString> > CDBData = mCDBPanels -> getTablePointerCDB ();
01494 QDictIterator< QDict<QString> > it (CDBData);
01495 for (; it.current(); ++it) {
01496 if ( it.currentKey() == group ) {
01497 mCDBPanelData = *it.current();
01498 break;
01499 }
01500 }
01501 return mCDBPanelData;
01502 }
01503
01504
01505
01506
01507 QDict<QString> SaXManipulateTouchscreens::getPanelData (
01508 const QString& vendor,const QString& name
01509 ) {
01510
01513
01514 return getPanelData (vendor+":"+name);
01515 }
01516
01517
01518
01519
01520 void SaXManipulateTouchscreens::setTouchPanel (const QString& group) {
01521
01525
01526 if ( ! mCDBPanels ) {
01527 mCDBPanels = new SaXProcess ();
01528 mCDBPanels -> start (CDB_TOUCHERS);
01529 }
01530 QList< QDict<QString> > data;
01531 data = mCDBPanels -> getTablePointerCDB_DATA (
01532 group
01533 );
01534 if (data.isEmpty()) {
01535 excCDBRecordNotFound (group);
01536 qError (errorString(),EXC_CDBRECORDNOTFOUND);
01537 return;
01538 }
01539
01540
01541
01542
01543 QDict<QString>* record = data.take(0);
01544 for (int n=0;n < mPointer;n++) {
01545 data.append(new QDict<QString>());
01546 }
01547 data.append ( record );
01548
01549
01550
01551 mImport -> merge ( data );
01552
01553
01554
01555 QStringList nameList = QStringList::split ( ":", group );
01556 setNamePair (
01557 nameList.first(),
01558 nameList.last()
01559 );
01560 }
01561
01562
01563
01564
01565 void SaXManipulateTouchscreens::setTouchPanel (
01566 const QString& vendor, const QString& model
01567 ) {
01568
01571
01572 setTouchPanel (vendor+":"+model);
01573 }
01574 }