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 PIRKeysetMetaData::PIRKeysetMetaData(
  15   const char *r,
  16   PIRMakeName m,
  17   unsigned int i)
  18   : threadableProtocol(NULL),
  19     index(i),
  20     keysetName(r),
  21     make(m)
  22 {
  23 }
  24
  25
  26 PIRKeysetMetaData::~PIRKeysetMetaData()
  27 {
  28   if (threadableProtocol) delete threadableProtocol;
  29   threadableProtocol = 0;
  30 }
  31
  32
  33 bool PIRKeysetMetaData::hasKey(
  34   PIRKeyName name) const
  35 {
  36   return (keys.find(name) != keys.end());
  37 }
  38
  39
  40 void PIRKeysetMetaData::moveToThread(
  41   QThread *thread)
  42 {
  43   if (threadableProtocol)
  44   {
  45     // Do I need some error checking here?
  46     threadableProtocol->moveToThread(thread);
  47   }
  48 }
  49
  50
  51 void PIRKeysetMetaData::populateDevices(
  52   PIRSelectDeviceForm *sdf)
  53 {
  54   PIRKeysetWidgetItem *kwi;
  55
  56   PIRDeviceCollection::const_iterator i = controlledDevices.begin();
  57
  58   while (i != controlledDevices.end())
  59   {
  60     // Create a widget for the keyset:
  61     QString tempString = makeManager.getMakeString(i->first.make);
  62     tempString.append(" ");
  63     tempString.append(i->first.model);
  64
  65     kwi = new PIRKeysetWidgetItem(
  66       tempString, i->first.model, i->second, i->first.make, i->first.type);
  67
  68     sdf->addWidgetItem(kwi);
  69
  70     ++i;
  71   }
  72 }
  73
  74
  75 unsigned int PIRKeysetMetaData::getID() const
  76 {
  77   return index;
  78 }
  79
  80
  81 PIRMakeName PIRKeysetMetaData::getMake() const
  82 {
  83   return make;
  84 }
  85
  86 const char *PIRKeysetMetaData::getKeysetName() const
  87 {
  88   return keysetName;
  89 }
  90
  91
  92 void PIRKeysetMetaData::addControlledDevice(
  93   PIRMakeName make,
  94   const char *model,
  95   PIRDeviceTypeName type)
  96 {
  97   controlledDevices.insert(
  98     PIRDCPair(
  99       DeviceInfo(make, model, type),
 100       index));
 101 }
 102
 103
 104 void PIRKeysetMetaData::addKey(
 105   const char *name,
 106   PIRKeyName key,
 107   unsigned long data,
 108   unsigned int size)
 109 {
 110   // Don't have a system for the unmapped keys yet!
 111   if (key != Unmapped_Key)
 112   {
 113     keys[key] = name;
 114
 115     threadableProtocol->addKey(key, data, size);
 116   }
 117 }
 118
 119
 120 void PIRKeysetMetaData::addSIRC12Key(
 121   const char *name,
 122   PIRKeyName key,
 123   unsigned int addressData,
 124   unsigned int commandData)
 125 {
 126   if (key != Unmapped_Key)
 127   {
 128     keys[key] = name;
 129     threadableProtocol->addSIRCKey(key, addressData, 5, commandData);
 130   }
 131 }
 132
 133
 134 void PIRKeysetMetaData::addSIRC15Key(
 135   const char *name,
 136   PIRKeyName key,
 137   unsigned int addressData,
 138   unsigned int commandData)
 139 {
 140   if (key != Unmapped_Key)
 141   {
 142     keys[key] = name;
 143     threadableProtocol->addSIRCKey(key, addressData, 8, commandData);
 144   }
 145 }
 146
 147
 148 void PIRKeysetMetaData::addSIRC20Key(
 149   const char *name,
 150   PIRKeyName key,
 151   unsigned int secondaryAddressData,
 152   unsigned int primaryAddressData,
 153   unsigned int commandData)
 154 {
 155   if (key != Unmapped_Key)
 156   {
 157     keys[key] = name;
 158     threadableProtocol->addSIRC20Key(
 159       key, secondaryAddressData, primaryAddressData, commandData);
 160   }
 161 }
 162
 163
 164 void PIRKeysetMetaData::addSharpKey(
 165   const char *name,
 166   PIRKeyName key,
 167   unsigned int addressData,
 168   unsigned int commandData)
 169 {
 170   if (key != Unmapped_Key)
 171   {
 172     keys[key] = name;
 173     threadableProtocol->addSharpKey(key, addressData, commandData);
 174   }
 175 }
 176
 177
 178 void PIRKeysetMetaData::addNECKey(
 179   const char *name,
 180   PIRKeyName key,
 181   unsigned int addressData,
 182   unsigned int commandData)
 183 {
 184   if (key != Unmapped_Key)
 185   {
 186     keys[key] = name;
 187     threadableProtocol->addNECKey(key, addressData, commandData);
 188   }
 189 }
 190
 191
 192 void PIRKeysetMetaData::addPanOldKey(
 193   const char *name,
 194   PIRKeyName key,
 195   unsigned int addressData,
 196   unsigned int commandData)
 197 {
 198   if (key != Unmapped_Key)
 199   {
 200     keys[key] = name;
 201     threadableProtocol->addPanOldKey(key, addressData, commandData);
 202   }
 203 }
 204
 205
 206 void PIRKeysetMetaData::addPioneerKey(
 207   const char *name,
 208   PIRKeyName key,
 209   unsigned int addressOne,
 210   unsigned int commandOne,
 211   unsigned int addressTwo,
 212   unsigned int commandTwo)
 213 {
 214   if (key != Unmapped_Key)
 215   {
 216     keys[key] = name;
 217     threadableProtocol->addPioneerKey(
 218       key, addressOne, commandOne, addressTwo, commandTwo);
 219   }
 220 }
 221
 222
 223 /*
 224 void PIRKeysetMetaData::addRCAKey(
 225   const char *name,
 226   PIRKeyName key,
 227   unsigned int addressData,
 228   unsigned int commandData)
 229 {
 230   if (key != Unmapped_Key)
 231   {
 232     keys[key] = name;
 233     threadableProtocol->addPioneerKey(
 234       key, addressData, commandData);
 235   }
 236 }
 237 */
 238
 239
 240 void PIRKeysetMetaData::addKaseikyoKey(
 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->addKaseikyoKey(key, addressData, commandData);
 250   }
 251 }
 252
 253
 254 void PIRKeysetMetaData::addDishKey(
 255   const char *name,
 256   PIRKeyName key,
 257   unsigned int firstCommand,
 258   unsigned int secondCommand)
 259 {
 260   if (key != Unmapped_Key)
 261   {
 262     keys[key] = name;
 263     threadableProtocol->addDishKey(key, firstCommand, secondCommand);
 264   }
 265 }
 266
 267
 268 void PIRKeysetMetaData::addXMPKey(
 269   const char *name,
 270   PIRKeyName key,
 271   unsigned int firstCommand,
 272   unsigned int secondCommand)
 273 {
 274   if (key != Unmapped_Key)
 275   {
 276     keys[key] = name;
 277     threadableProtocol->addXMPKey(key, firstCommand, secondCommand);
 278   }
 279 }
 280
 281
 282 void PIRKeysetMetaData::setPreData(
 283   unsigned long data,
 284   unsigned int bits)
 285 {
 286   threadableProtocol->setPreData(data, bits);
 287 }
 288
 289
 290 void PIRKeysetMetaData::setPostData(
 291   unsigned long data,
 292   unsigned int bits)
 293 {
 294   threadableProtocol->setPostData(data, bits);
 295 }
 296
 297
 298 void PIRKeysetMetaData::setKeysetName(
 299   const char *n)
 300 {
 301   keysetName = n;
 302 }
 303
 304
 305 void PIRKeysetMetaData::clearProtocol()
 306 {
 307   if (threadableProtocol)
 308   {
 309     delete threadableProtocol;
 310     threadableProtocol = 0;
 311   }
 312 }