git.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 void PIRKeysetMetaData::addControlledDevice(
  95   PIRMakeName make,
  96   const char *model,
  97   PIRDeviceTypeName type)
  98 {
  99   controlledDevices.insert(
 100     PIRDCPair(
 101       DeviceInfo(make, model, type),
 102       index));
 103 }
 104
 105
 106 void PIRKeysetMetaData::addKey(
 107   const char *name,
 108   PIRKeyName key,
 109   unsigned long data,
 110   unsigned int size)
 111 {
 112   // Don't have a system for the unmapped keys yet!
 113   if (key != Unmapped_Key)
 114   {
 115     keys[key] = name;
 116
 117     threadableProtocol->addKey(key, data, size);
 118   }
 119 }
 120
 121
 122 void PIRKeysetMetaData::addSIRC12Key(
 123   const char *name,
 124   PIRKeyName key,
 125   unsigned int addressData,
 126   unsigned int commandData)
 127 {
 128   if (key != Unmapped_Key)
 129   {
 130     keys[key] = name;
 131     threadableProtocol->addSIRCKey(key, addressData, 5, commandData);
 132   }
 133 }
 134
 135
 136 void PIRKeysetMetaData::addSIRC15Key(
 137   const char *name,
 138   PIRKeyName key,
 139   unsigned int addressData,
 140   unsigned int commandData)
 141 {
 142   if (key != Unmapped_Key)
 143   {
 144     keys[key] = name;
 145     threadableProtocol->addSIRCKey(key, addressData, 8, commandData);
 146   }
 147 }
 148
 149
 150 void PIRKeysetMetaData::addSIRC20Key(
 151   const char *name,
 152   PIRKeyName key,
 153   unsigned int secondaryAddressData,
 154   unsigned int primaryAddressData,
 155   unsigned int commandData)
 156 {
 157   if (key != Unmapped_Key)
 158   {
 159     keys[key] = name;
 160     threadableProtocol->addSIRC20Key(
 161       key, secondaryAddressData, primaryAddressData, commandData);
 162   }
 163 }
 164
 165
 166 void PIRKeysetMetaData::addSharpKey(
 167   const char *name,
 168   PIRKeyName key,
 169   unsigned int addressData,
 170   unsigned int commandData)
 171 {
 172   if (key != Unmapped_Key)
 173   {
 174     keys[key] = name;
 175     threadableProtocol->addSharpKey(key, addressData, commandData);
 176   }
 177 }
 178
 179
 180 void PIRKeysetMetaData::addNECKey(
 181   const char *name,
 182   PIRKeyName key,
 183   unsigned int addressData,
 184   unsigned int commandData)
 185 {
 186   if (key != Unmapped_Key)
 187   {
 188     keys[key] = name;
 189     threadableProtocol->addNECKey(key, addressData, commandData);
 190   }
 191 }
 192
 193
 194 void PIRKeysetMetaData::addPanOldKey(
 195   const char *name,
 196   PIRKeyName key,
 197   unsigned int addressData,
 198   unsigned int commandData)
 199 {
 200   if (key != Unmapped_Key)
 201   {
 202     keys[key] = name;
 203     threadableProtocol->addPanOldKey(key, addressData, commandData);
 204   }
 205 }
 206
 207
 208 void PIRKeysetMetaData::addPioneerKey(
 209   const char *name,
 210   PIRKeyName key,
 211   unsigned int addressOne,
 212   unsigned int commandOne,
 213   unsigned int addressTwo,
 214   unsigned int commandTwo)
 215 {
 216   if (key != Unmapped_Key)
 217   {
 218     keys[key] = name;
 219     threadableProtocol->addPioneerKey(
 220       key, addressOne, commandOne, addressTwo, commandTwo);
 221   }
 222 }
 223
 224
 225 /*
 226 void PIRKeysetMetaData::addRCAKey(
 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->addPioneerKey(
 236       key, addressData, commandData);
 237   }
 238 }
 239 */
 240
 241
 242 void PIRKeysetMetaData::addKaseikyoKey(
 243   const char *name,
 244   PIRKeyName key,
 245   unsigned int addressData,
 246   unsigned int commandData)
 247 {
 248   if (key != Unmapped_Key)
 249   {
 250     keys[key] = name;
 251     threadableProtocol->addKaseikyoKey(key, addressData, commandData);
 252   }
 253 }
 254
 255
 256 void PIRKeysetMetaData::addDishKey(
 257   const char *name,
 258   PIRKeyName key,
 259   unsigned int firstCommand,
 260   unsigned int secondCommand)
 261 {
 262   if (key != Unmapped_Key)
 263   {
 264     keys[key] = name;
 265     threadableProtocol->addDishKey(key, firstCommand, secondCommand);
 266   }
 267 }
 268
 269
 270 void PIRKeysetMetaData::addXMPKey(
 271   const char *name,
 272   PIRKeyName key,
 273   unsigned int firstCommand,
 274   unsigned int secondCommand)
 275 {
 276   if (key != Unmapped_Key)
 277   {
 278     keys[key] = name;
 279     threadableProtocol->addXMPKey(key, firstCommand, secondCommand);
 280   }
 281 }
 282
 283
 284 void PIRKeysetMetaData::setPreData(
 285   unsigned long data,
 286   unsigned int bits)
 287 {
 288   threadableProtocol->setPreData(data, bits);
 289 }
 290
 291
 292 void PIRKeysetMetaData::setPostData(
 293   unsigned long data,
 294   unsigned int bits)
 295 {
 296   threadableProtocol->setPostData(data, bits);
 297 }
 298
 299
 300 void PIRKeysetMetaData::setKeysetName(
 301   const char *n)
 302 {
 303   keysetName = n;
 304 }
 305
 306
 307 bool PIRKeysetMetaData::clearProtocol()
 308 {
 309   if (!threadableProtocol)
 310   {
 311     return true;
 312   }
 313   else if (!commandInFlight)
 314   {
 315     delete threadableProtocol;
 316     threadableProtocol = 0;
 317     return true;
 318   }
 319
 320   return false;
 321 }