home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Dita / source / accel.cpp next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  3.7 KB  |  156 lines
  1. #include "stdafx.h"
  2. #include <vd2/system/error.h>
  3. #include <vd2/system/registry.h>
  4. #include <vd2/Dita/accel.h>
  5.  
  6. VDAccelTableDefinition::VDAccelTableDefinition() {
  7. }
  8.  
  9. VDAccelTableDefinition::VDAccelTableDefinition(const VDAccelTableDefinition& src) {
  10.     mAccelerators = src.mAccelerators;
  11.  
  12.     Accelerators::iterator it(mAccelerators.begin()), itEnd(mAccelerators.end());
  13.     for(; it != itEnd; ++it) {
  14.         VDAccelTableEntry& ent = *it;
  15.  
  16.         ent.mpCommand = _strdup(ent.mpCommand);
  17.         if (!ent.mpCommand) {
  18.             while(it != mAccelerators.begin()) {
  19.                 --it;
  20.                 free((void *)it->mpCommand);
  21.             }
  22.  
  23.             throw MyMemoryError();
  24.         }
  25.     }
  26. }
  27.  
  28. VDAccelTableDefinition::~VDAccelTableDefinition() {
  29.     Clear();
  30. }
  31.  
  32. VDAccelTableDefinition& VDAccelTableDefinition::operator=(const VDAccelTableDefinition& src) {
  33.     if (&src != this) {
  34.         VDAccelTableDefinition tmp(src);
  35.  
  36.         Swap(tmp);
  37.     }
  38.  
  39.     return *this;
  40. }
  41.  
  42. uint32 VDAccelTableDefinition::GetSize() const {
  43.     return mAccelerators.size();
  44. }
  45.  
  46. const VDAccelTableEntry& VDAccelTableDefinition::operator[](uint32 index) const {
  47.     return mAccelerators[index];
  48. }
  49.  
  50. void VDAccelTableDefinition::Clear() {
  51.     while(!mAccelerators.empty()) {
  52.         VDAccelTableEntry& ent = mAccelerators.back();
  53.         free((void *)ent.mpCommand);
  54.         mAccelerators.pop_back();
  55.     }
  56. }
  57.  
  58. void VDAccelTableDefinition::Add(const VDAccelTableEntry& src) {
  59.     const char *s = _strdup(src.mpCommand);
  60.  
  61.     if (!s)
  62.         throw MyMemoryError();
  63.  
  64.     VDAccelTableEntry& acc = mAccelerators.push_back();
  65.     acc.mpCommand = s;
  66.     acc.mCommandId = src.mCommandId;
  67.     acc.mAccel = src.mAccel;
  68. }
  69.  
  70. void VDAccelTableDefinition::RemoveAt(uint32 index) {
  71.     if (index < mAccelerators.size()) {
  72.         VDAccelTableEntry& acc = mAccelerators[index];
  73.  
  74.         free((void *)acc.mpCommand);
  75.  
  76.         mAccelerators.erase(mAccelerators.begin() + index);
  77.     }
  78. }
  79.  
  80. void VDAccelTableDefinition::Swap(VDAccelTableDefinition& dst) {
  81.     mAccelerators.swap(dst.mAccelerators);
  82. }
  83.  
  84. void VDAccelTableDefinition::Save(VDRegistryKey& key) const {
  85.     VDRegistryValueIterator it(key);
  86.  
  87.     while(const char *name = it.Next()) {
  88.         unsigned v;
  89.         char term;
  90.         if (sscanf(name, "%08x%c", &v, &term) != 1)
  91.             continue;
  92.  
  93.         VDUIAccelerator accel;
  94.         accel.mVirtKey = (v & 0xffff);
  95.         accel.mModifiers = v >> 16;
  96.  
  97.         bool found = false;
  98.         for(Accelerators::const_iterator it(mAccelerators.begin()), itEnd(mAccelerators.end()); it != itEnd; ++it) {
  99.             const VDAccelTableEntry& ent = *it;
  100.  
  101.             if (ent.mAccel == accel) {
  102.                 found = true;
  103.                 break;
  104.             }
  105.         }
  106.  
  107.         if (!found)
  108.             key.removeValue(name);
  109.     }
  110.  
  111.     char buf[16];
  112.     for(Accelerators::const_iterator it(mAccelerators.begin()), itEnd(mAccelerators.end()); it != itEnd; ++it) {
  113.         const VDAccelTableEntry& ent = *it;
  114.  
  115.         sprintf(buf, "%08x", (ent.mAccel.mVirtKey & 0xffff) + (ent.mAccel.mModifiers << 16));
  116.  
  117.         key.setString(buf, ent.mpCommand);
  118.     }
  119. }
  120.  
  121. void VDAccelTableDefinition::Load(VDRegistryKey& key, const VDAccelToCommandEntry *pCommands, uint32 nCommands) {
  122.     Clear();
  123.  
  124.     VDRegistryValueIterator it(key);
  125.  
  126.     VDStringA cmd;
  127.     while(const char *name = it.Next()) {
  128.         unsigned v;
  129.         char term;
  130.         if (sscanf(name, "%08x%c", &v, &term) != 1 || !v)
  131.             continue;
  132.  
  133.         if (!key.getString(name, cmd))
  134.             continue;
  135.  
  136.         VDAccelTableEntry& ent = mAccelerators.push_back();
  137.         ent.mAccel.mVirtKey = (v & 0xffff);
  138.         ent.mAccel.mModifiers = v >> 16;
  139.         ent.mCommandId = 0;
  140.         ent.mpCommand = _strdup(cmd.c_str());
  141.         if (!ent.mpCommand) {
  142.             mAccelerators.pop_back();
  143.             throw MyMemoryError();
  144.         }
  145.  
  146.         for(uint32 i=0; i<nCommands; ++i) {
  147.             const VDAccelToCommandEntry& cmdent = pCommands[i];
  148.  
  149.             if (!_stricmp(ent.mpCommand, cmdent.mpName)) {
  150.                 ent.mCommandId = cmdent.mId;
  151.                 break;
  152.             }
  153.         }
  154.     }
  155. }
  156.