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