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