vcs.maemo.org Git - pierogi/blob - pirkeysetmetadata.cpp

   1 #include "pirkeysetmetadata.h"
   2 #include "pirselectdeviceform.h"
   3 #include "pirkeysetwidgetitem.h"
   4 #include "protocols/pirprotocol.h"
   5
   6 #include <iostream>
   7
   8 // Global helper object:
   9 extern PIRMakeMgr makeManager;
  10
  11 // Static member definition:
  12 PIRDeviceCollection PIRKeysetMetaData::controlledDevices;
  13
  14 // Thread synchronization stuff:
  15 extern bool commandInFlight;
  16
  17 PIRKeysetMetaData::PIRKeysetMetaData(
  18   const char *r,
  19   PIRMakeName m,
  20   unsigned int i)
  21   : threadableProtocol(NULL),
  22     index(i),
  23     keysetName(r),
  24     make(m)
  25 {
  26 }
  27
  28
  29 PIRKeysetMetaData::~PIRKeysetMetaData()
  30 {
  31   clearProtocol();
  32 }
  33
  34
  35 bool PIRKeysetMetaData::hasKey(
  36   PIRKeyName name) const
  37 {
  38   return (keys.find(name) != keys.end());
  39 }
  40
  41
  42 void PIRKeysetMetaData::moveToThread(
  43   QThread *thread)
  44 {
  45   if (threadableProtocol)
  46   {
  47     // Do I need some error checking here?
  48     threadableProtocol->moveToThread(thread);
  49   }
  50 }
  51
  52
  53 void PIRKeysetMetaData::populateDevices(
  54   PIRSelectDeviceForm *sdf)
  55 {
  56   PIRKeysetWidgetItem *kwi;
  57
  58   PIRDeviceCollection::const_iterator i = controlledDevices.begin();
  59
  60   while (i != controlledDevices.end())
  61   {
  62     // Create a widget for the keyset:
  63     QString tempString = makeManager.getMakeString(i->first.make);
  64     tempString.append(" ");
  65     tempString.append(i->first.model);
  66
  67     kwi = new PIRKeysetWidgetItem(
  68       tempString, i->first.model, i->second, i->first.make, i->first.type);
  69
  70     sdf->addWidgetItem(kwi);
  71
  72     ++i;
  73   }
  74 }
  75
  76
  77 unsigned int PIRKeysetMetaData::getID() const
  78 {
  79   return index;
  80 }
  81
  82
  83 PIRMakeName PIRKeysetMetaData::getMake() const
  84 {
  85   return make;
  86 }
  87
  88 const char *PIRKeysetMetaData::getKeysetName() const
  89 {
  90   return keysetName;
  91 }
  92
  93
  94 unsigned int PIRKeysetMetaData::getCarrierFrequency() const
  95 {
  96   if (!threadableProtocol)
  97   {
  98     return 0;
  99   }
 100
 101   return threadableProtocol->getCarrierFrequency();
 102 }
 103
 104
 105 void PIRKeysetMetaData::setCarrierFrequency(
 106   unsigned int carrierFrequency)
 107 {
 108   if (!threadableProtocol)
 109   {
 110     return;
 111   }
 112
 113   threadableProtocol->setCarrierFrequency(carrierFrequency);
 114 }
 115
 116
 117 unsigned int PIRKeysetMetaData::getDutyCycle() const
 118 {
 119   if (!threadableProtocol)
 120   {
 121     return 0;
 122   }
 123
 124   return threadableProtocol->getDutyCycle();
 125 }
 126
 127
 128 void PIRKeysetMetaData::setDutyCycle(
 129   unsigned int dutyCycle)
 130 {
 131   if (!threadableProtocol)
 132   {
 133     return;
 134   }
 135
 136   threadableProtocol->setDutyCycle(dutyCycle);
 137 }
 138
 139
 140 void PIRKeysetMetaData::addControlledDevice(
 141   PIRMakeName make,
 142   const char *model,
 143   PIRDeviceTypeName type)
 144 {
 145   controlledDevices.insert(
 146     PIRDCPair(
 147       DeviceInfo(make, model, type),
 148       index));
 149 }
 150
 151
 152 void PIRKeysetMetaData::addKey(
 153   const char *name,
 154   PIRKeyName key,
 155   unsigned long data,
 156   unsigned int size)
 157 {
 158   // Don't have a system for the unmapped keys yet!
 159   if (key != Unmapped_Key)
 160   {
 161     keys[key] = name;
 162
 163     threadableProtocol->addKey(key, data, size);
 164   }
 165 }
 166
 167
 168 void PIRKeysetMetaData::addSIRC12Key(
 169   const char *name,
 170   PIRKeyName key,
 171   unsigned int addressData,
 172   unsigned int commandData)
 173 {
 174   if (key != Unmapped_Key)
 175   {
 176     keys[key] = name;
 177     threadableProtocol->addSIRCKey(key, addressData, 5, commandData);
 178   }
 179 }
 180
 181
 182 void PIRKeysetMetaData::addSIRC15Key(
 183   const char *name,
 184   PIRKeyName key,
 185   unsigned int addressData,
 186   unsigned int commandData)
 187 {
 188   if (key != Unmapped_Key)
 189   {
 190     keys[key] = name;
 191     threadableProtocol->addSIRCKey(key, addressData, 8, commandData);
 192   }
 193 }
 194
 195
 196 void PIRKeysetMetaData::addSIRC20Key(
 197   const char *name,
 198   PIRKeyName key,
 199   unsigned int secondaryAddressData,
 200   unsigned int primaryAddressData,
 201   unsigned int commandData)
 202 {
 203   if (key != Unmapped_Key)
 204   {
 205     keys[key] = name;
 206     threadableProtocol->addSIRC20Key(
 207       key, secondaryAddressData, primaryAddressData, commandData);
 208   }
 209 }
 210
 211
 212 void PIRKeysetMetaData::addSharpKey(
 213   const char *name,
 214   PIRKeyName key,
 215   unsigned int addressData,
 216   unsigned int commandData)
 217 {
 218   if (key != Unmapped_Key)
 219   {
 220     keys[key] = name;
 221     threadableProtocol->addSharpKey(key, addressData, commandData);
 222   }
 223 }
 224
 225
 226 void PIRKeysetMetaData::addNECKey(
 227   const char *name,
 228   PIRKeyName key,
 229   unsigned int addressData,
 230   unsigned int commandData)
 231 {
 232   if (key != Unmapped_Key)
 233   {
 234     keys[key] = name;
 235     threadableProtocol->addNECKey(key, addressData, commandData);
 236   }
 237 }
 238
 239
 240 void PIRKeysetMetaData::addPanOldKey(
 241   const char *name,
 242   PIRKeyName key,
 243   unsigned int addressData,
 244   unsigned int commandData)
 245 {
 246   if (key != Unmapped_Key)
 247   {
 248     keys[key] = name;
 249     threadableProtocol->addPanOldKey(key, addressData, commandData);
 250   }
 251 }
 252
 253
 254 void PIRKeysetMetaData::addPioneerKey(
 255   const char *name,
 256   PIRKeyName key,
 257   unsigned int addressOne,
 258   unsigned int commandOne,
 259   unsigned int addressTwo,
 260   unsigned int commandTwo)
 261 {
 262   if (key != Unmapped_Key)
 263   {
 264     keys[key] = name;
 265     threadableProtocol->addPioneerKey(
 266       key, addressOne, commandOne, addressTwo, commandTwo);
 267   }
 268 }
 269
 270
 271 /*
 272 void PIRKeysetMetaData::addRCAKey(
 273   const char *name,
 274   PIRKeyName key,
 275   unsigned int addressData,
 276   unsigned int commandData)
 277 {
 278   if (key != Unmapped_Key)
 279   {
 280     keys[key] = name;
 281     threadableProtocol->addPioneerKey(
 282       key, addressData, commandData);
 283   }
 284 }
 285 */
 286
 287
 288 void PIRKeysetMetaData::addKaseikyoKey(
 289   const char *name,
 290   PIRKeyName key,
 291   unsigned int addressData,
 292   unsigned int commandData)
 293 {
 294   if (key != Unmapped_Key)
 295   {
 296     keys[key] = name;
 297     threadableProtocol->addKaseikyoKey(key, addressData, commandData);
 298   }
 299 }
 300
 301
 302 void PIRKeysetMetaData::addDishKey(
 303   const char *name,
 304   PIRKeyName key,
 305   unsigned int firstCommand,
 306   unsigned int secondCommand)
 307 {
 308   if (key != Unmapped_Key)
 309   {
 310     keys[key] = name;
 311     threadableProtocol->addDishKey(key, firstCommand, secondCommand);
 312   }
 313 }
 314
 315
 316 void PIRKeysetMetaData::addXMPKey(
 317   const char *name,
 318   PIRKeyName key,
 319   unsigned int firstCommand,
 320   unsigned int secondCommand)
 321 {
 322   if (key != Unmapped_Key)
 323   {
 324     keys[key] = name;
 325     threadableProtocol->addXMPKey(key, firstCommand, secondCommand);
 326   }
 327 }
 328
 329
 330 void PIRKeysetMetaData::setPreData(
 331   unsigned long data,
 332   unsigned int bits)
 333 {
 334   threadableProtocol->setPreData(data, bits);
 335 }
 336
 337
 338 void PIRKeysetMetaData::setPostData(
 339   unsigned long data,
 340   unsigned int bits)
 341 {
 342   threadableProtocol->setPostData(data, bits);
 343 }
 344
 345
 346 void PIRKeysetMetaData::setKeysetName(
 347   const char *n)
 348 {
 349   keysetName = n;
 350 }
 351
 352
 353 bool PIRKeysetMetaData::clearProtocol()
 354 {
 355   if (!threadableProtocol)
 356   {
 357     return true;
 358   }
 359   else if (!commandInFlight)
 360   {
 361     delete threadableProtocol;
 362     threadableProtocol = 0;
 363     return true;
 364   }
 365
 366   return false;
 367 }