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 / w32accel.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  4.9 KB  |  201 lines
  1. #include "stdafx.h"
  2. #include <vd2/system/w32assist.h>
  3. #include <vd2/Dita/accel.h>
  4.  
  5. void VDUIExtractAcceleratorTableW32(VDAccelTableDefinition& dst, HACCEL haccel, const VDAccelToCommandEntry *pCommands, uint32 nCommands) {
  6.     uint32 n = CopyAcceleratorTable(haccel, NULL, 0);
  7.     vdfastvector<ACCEL> accels(n);
  8.  
  9.     n = CopyAcceleratorTable(haccel, accels.data(), n);
  10.  
  11.     dst.Clear();
  12.     for(uint32 i=0; i<n; ++i) {
  13.         const ACCEL& accel = accels[i];
  14.  
  15.         bool found = false;
  16.         for(uint32 j=0; j<nCommands; ++j) {
  17.             if (pCommands[j].mId == accel.cmd) {
  18.                 VDAccelTableEntry ent;
  19.                 ent.mCommandId = accel.cmd;
  20.                 ent.mpCommand = pCommands[j].mpName;
  21.  
  22.                 ent.mAccel.mVirtKey = accel.key;
  23.                 ent.mAccel.mModifiers = 0;
  24.  
  25.                 VDASSERT(accel.fVirt & FVIRTKEY);
  26.                 if (accel.fVirt & FALT)
  27.                     ent.mAccel.mModifiers |= VDUIAccelerator::kModAlt;
  28.  
  29.                 if (accel.fVirt & FCONTROL)
  30.                     ent.mAccel.mModifiers |= VDUIAccelerator::kModCtrl;
  31.  
  32.                 if (accel.fVirt & FSHIFT)
  33.                     ent.mAccel.mModifiers |= VDUIAccelerator::kModShift;
  34.  
  35.                 switch(accel.key) {
  36.                   case VK_INSERT:
  37.                   case VK_DELETE:
  38.                   case VK_HOME:
  39.                   case VK_END:
  40.                   case VK_NEXT:
  41.                   case VK_PRIOR:
  42.                   case VK_LEFT:
  43.                   case VK_RIGHT:
  44.                   case VK_UP:
  45.                   case VK_DOWN:
  46.                       ent.mAccel.mModifiers |= VDUIAccelerator::kModExtended;
  47.                       break;
  48.                 }
  49.  
  50.                 dst.Add(ent);
  51.                 found = true;
  52.                 break;
  53.             }
  54.         }
  55.  
  56.         VDASSERT(found);
  57.     }
  58. }
  59.  
  60. void VDUIGetAcceleratorStringInternal(const VDUIAccelerator& accel, VDStringW& s) {
  61.     union {
  62.         wchar_t w[1024];
  63.         char a[1024];
  64.     } buf;
  65.  
  66.     UINT scanCode = MapVirtualKey(accel.mVirtKey, 0);
  67.     if (!scanCode)
  68.         return;
  69.  
  70.     LPARAM lParam = (scanCode << 16) | (1 << 25);
  71.  
  72.     if (accel.mModifiers & VDUIAccelerator::kModExtended)
  73.         lParam |= (1 << 24);
  74.  
  75.     if (VDIsWindowsNT()) {
  76.         if (GetKeyNameTextW(lParam, buf.w, 1024))
  77.             s.append(buf.w);
  78.     } else {
  79.         if (GetKeyNameTextA(lParam, buf.a, 1024))
  80.             s.append(VDTextAToW(buf.a));
  81.     }
  82. }
  83.  
  84. void VDUIGetAcceleratorString(const VDUIAccelerator& accel, VDStringW& s) {
  85.     s.clear();
  86.  
  87.     if (accel.mModifiers & VDUIAccelerator::kModCtrl) {
  88.         VDUIAccelerator accelCtrl;
  89.         accelCtrl.mVirtKey = VK_CONTROL;
  90.         accelCtrl.mModifiers = 0;
  91.         VDUIGetAcceleratorStringInternal(accelCtrl, s);
  92.  
  93.         s += L"+";
  94.     }
  95.  
  96.     if (accel.mModifiers & VDUIAccelerator::kModShift) {
  97.         VDUIAccelerator accelShift;
  98.         accelShift.mVirtKey = VK_SHIFT;
  99.         accelShift.mModifiers = 0;
  100.         VDUIGetAcceleratorStringInternal(accelShift, s);
  101.  
  102.         s += L"+";
  103.     }
  104.  
  105.     if (accel.mModifiers & VDUIAccelerator::kModAlt) {
  106.         VDUIAccelerator accelAlt;
  107.         accelAlt.mVirtKey = VK_MENU;
  108.         accelAlt.mModifiers = 0;
  109.         VDUIGetAcceleratorStringInternal(accelAlt, s);
  110.  
  111.         s += L"+";
  112.     }
  113.  
  114.     VDUIGetAcceleratorStringInternal(accel, s);
  115. }
  116.  
  117. HACCEL VDUIBuildAcceleratorTableW32(const VDAccelTableDefinition& def) {
  118.     uint32 n = def.GetSize();
  119.     vdfastvector<ACCEL> accels(n);
  120.  
  121.     for(size_t i=0; i<n; ++i) {
  122.         const VDAccelTableEntry& entry = def[i];
  123.  
  124.         ACCEL& accel = accels[i];
  125.  
  126.         accel.fVirt = FVIRTKEY;
  127.  
  128.         if (entry.mAccel.mModifiers & VDUIAccelerator::kModCtrl)
  129.             accel.fVirt |= FCONTROL;
  130.  
  131.         if (entry.mAccel.mModifiers & VDUIAccelerator::kModShift)
  132.             accel.fVirt |= FSHIFT;
  133.  
  134.         if (entry.mAccel.mModifiers & VDUIAccelerator::kModAlt)
  135.             accel.fVirt |= FALT;
  136.  
  137.         accel.key = (WORD)entry.mAccel.mVirtKey;
  138.         accel.cmd = (WORD)entry.mCommandId;
  139.     }
  140.  
  141.     return CreateAcceleratorTable(accels.data(), n);
  142. }
  143.  
  144. void VDUIUpdateMenuAcceleratorsW32(HMENU hmenu, const VDAccelTableDefinition& def) {
  145.     int n = GetMenuItemCount(hmenu);
  146.  
  147.     VDStringA bufa;
  148.     VDStringW keystr;
  149.     for(int i=0; i<n; ++i) {
  150.         MENUITEMINFOA miia;
  151.  
  152.         miia.cbSize        = sizeof(MENUITEMINFOA);
  153.         miia.fMask        = MIIM_ID | MIIM_SUBMENU | MIIM_FTYPE;
  154.         miia.dwTypeData    = NULL;
  155.         miia.cch        = 0;
  156.  
  157.         if (GetMenuItemInfoA(hmenu, i, TRUE, &miia)) {
  158.             if (miia.hSubMenu) {
  159.                 VDUIUpdateMenuAcceleratorsW32(miia.hSubMenu, def);
  160.             } else {
  161.                 const uint32 id = miia.wID;
  162.  
  163.                 miia.fMask        = MIIM_STRING;
  164.                 miia.dwTypeData = NULL;
  165.                 miia.cch        = 0;
  166.                 if (GetMenuItemInfoA(hmenu, i, TRUE, &miia)) {
  167.                     ++miia.cch;
  168.                     bufa.resize(miia.cch);
  169.         
  170.                     miia.dwTypeData    = (LPSTR)bufa.data();
  171.  
  172.                     if (GetMenuItemInfoA(hmenu, i, TRUE, &miia)) {
  173.                         VDStringA::size_type pos = bufa.find('\t');
  174.                         if (pos != VDStringA::npos)
  175.                             bufa.resize(pos);
  176.                         else
  177.                             bufa.resize(miia.cch);
  178.  
  179.                         const uint32 m = def.GetSize();
  180.                         for(uint32 j=0; j<m; ++j) {
  181.                             const VDAccelTableEntry& ent = def[j];
  182.  
  183.                             if (ent.mCommandId == id) {
  184.                                 VDUIGetAcceleratorString(ent.mAccel, keystr);
  185.                     
  186.                                 bufa.push_back('\t');
  187.                                 bufa.append(VDTextWToA(keystr).c_str());
  188.                                 break;
  189.                             }
  190.                         }
  191.  
  192.                         miia.fMask = MIIM_STRING;
  193.                         miia.dwTypeData = (LPSTR)bufa.c_str();
  194.                         VDVERIFY(SetMenuItemInfoA(hmenu, i, TRUE, &miia));
  195.                     }
  196.                 }
  197.             }
  198.         }
  199.     }
  200. }
  201.