开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Windows Mobile > 查看源码
Keys.cpp
资源名称：TextViewNG.rar　[点击查看]
上传用户：hmc_gdtv
上传日期：2013-08-04
资源大小：798k
文件大小：19k
源码类别：

Windows Mobile

开发平台：

Visual C++

Keys.cpp：源码内容
  1. /*
  2.  * Copyright (c) 2001,2002,2003 Mike Matsnev.  All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice immediately at the beginning of the file, without modification,
  10.  *    this list of conditions, and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. Absolutely no warranty of function or purpose is made by the author
  15.  *    Mike Matsnev.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  * 
  28.  * $Id: Keys.cpp,v 1.8.2.13 2006/05/07 18:08:15 mike Exp $
  29.  * 
  30.  */
  32. #include <afxext.h>
  34. #include "Keys.h"
  35. #include "resource.h"
  36. #include "config.h"
  38. #define BUTTON_W_CH   7
  39. #define BUTTON_SPACE  5
  40. #define MARGIN       3
  42. #define LABEL_BASE    1000
  43. #define LABEL_MAX     1999
  44. #define BUTTON_BASE   2000
  45. #define BUTTON_MAX    2999
  46. #define ACTION_BASE   3000
  47. #define ACTION_MAX    3999
  48. #define KEY_BASE      4000
  49. #define KEY_MAX       4999
  51. #define MINHK       0xc0
  52. #define MAXHK       0xcf
  54. // keys
  55. static struct {
  56.   const TCHAR   *name;
  57.   UINT cmd;
  58.   UINT vk1,vk2,vk3;
  59. } g_actions[]={
  60.   { _T("Line forward"),     ID_LINE_DOWN     },
  61.   { _T("Line backward"),    ID_LINE_UP     },
  62.   { _T("Page forward"),     ID_PAGE_DOWN,   VK_DOWN,  VK_NEXT,   VK_SPACE  },
  63.   { _T("Page backward"),    ID_PAGE_UP,     VK_UP,    VK_PRIOR     },
  64.   { _T("Start of file"),    ID_START_OF_FILE, VK_HOME     },
  65.   { _T("End of file"),     ID_END_OF_FILE, VK_END     },
  66.   { _T("Toggle fullscreen"),ID_FULLSCREEN,  VK_RETURN     },
  67.   { _T("Find"),     ID_FIND     },
  68.   { _T("Find next"),     ID_FINDNEXT,    VK_F3     },
  69.   { _T("Contents"),     ID_BOOKMARKS     },
  70.   { _T("Back"),     ID_BACK,     VK_LEFT     },
  71.   { _T("Forward"),     ID_FORWARD,     VK_RIGHT     },
  72.   { _T("Exit"),     ID_APP_EXIT     },
  73.   { _T("Rotate"),     ID_ROTATE     },
  74.   { _T("Next bookmark/section"), ID_NEXTBM     },
  75.   { _T("Previous bookmark/section"), ID_PREVBM     },
  76.   { _T("Next section"),     ID_NEXTCH     },
  77.   { _T("Previous section"), ID_PREVCH     },
  78.   { _T("Start autoscroll"), ID_AS_START     },
  79.   { _T("Stop autoscroll"),  ID_AS_STOP     },
  80.   { _T("Toggle autoscroll"),ID_AS_TOGGLE     },
  81.   { _T("Faster autoscroll"),ID_AS_FASTER     },
  82.   { _T("Slower autoscroll"),ID_AS_SLOWER     },
  83.   { _T("Faster AS (fine)"), ID_AS_FASTER_FINE     },
  84.   { _T("Slower AS (fine)"), ID_AS_SLOWER_FINE     },
  85.   { _T("Open file"),     ID_FILE_OPEN     },
  86.   { _T("Next color profile"), ID_NEXT_PROFILE     },
  87. };
  88. #define NUMACTIONS    (sizeof(g_actions)/sizeof(g_actions[0]))
  90. static struct {
  91.   UINT       vk;
  92.   const TCHAR *name;
  93. } g_keys[]={
  94.   { VK_LEFT, _T("Left")  },
  95.   { VK_UP, _T("Up")    },
  96.   { VK_RIGHT, _T("Right") },
  97.   { VK_DOWN, _T("Down")  },
  98.   { VK_RETURN, _T("Enter") },
  99.   { VK_SPACE, _T("Space") },
  100.   { VK_PRIOR, _T("PgUp")  },
  101.   { VK_NEXT, _T("PgDown")},
  102.   { VK_HOME, _T("Home")  },
  103.   { VK_END, _T("End")   },
  104.   { VK_INSERT, _T("Insert")  },
  105.   { VK_DELETE, _T("Delete")  },
  106.   { VK_F1, _T("F1")      },
  107.   { VK_F2, _T("F2")      },
  108.   { VK_F3, _T("F3")      },
  109.   { VK_F4, _T("F4")      },
  110.   { VK_F5, _T("F5")      },
  111.   { VK_F6, _T("F6")      },
  112.   { VK_F7, _T("F7")      },
  113.   { VK_F8, _T("F8")      },
  114.   { VK_F9, _T("F9")      },
  115.   { VK_F10, _T("F10")     },
  116.   { VK_F11, _T("F11")     },
  117.   { VK_F12, _T("F12")     },
  118.   { 0x86, _T("Action")  },
  119. };
  120. #define NUMKEYS (sizeof(g_keys)/sizeof(g_keys[0]))
  122. #define MAXVK 256
  124. BOOL     (*g_UnregisterFunc1)(UINT one,UINT two);
  126. static bool IsMod(UINT vk) {
  127.   return  vk == VK_LWIN || vk == VK_RWIN ||
  128.   vk == VK_SHIFT || vk == VK_CONTROL ||
  129.   vk == VK_MENU || vk == VK_LSHIFT ||
  130.   vk == VK_RSHIFT || vk == VK_LCONTROL ||
  131.   vk == VK_RCONTROL || vk == VK_LMENU ||
  132.   vk == VK_RMENU;
  133. }
  135. static void GrabKey(HWND hWnd,UINT vk) {
  136.   if (g_UnregisterFunc1)
  137.     g_UnregisterFunc1(MOD_WIN,vk);
  138.   RegisterHotKey(hWnd,vk,MOD_WIN,vk);
  139. }
  141. static void ReleaseKey(HWND hWnd,UINT vk) {
  142.   UnregisterHotKey(hWnd,vk);
  143. }
  145. static const TCHAR  *GetKeyName(UINT vk) {
  146.   if (vk == 0)
  147.     return _T("");
  148.   for (int i=0;i<NUMKEYS;++i)
  149.     if (g_keys[i].vk==vk)
  150.       return g_keys[i].name;
  151.   static TCHAR   buf[32];
  152.   if (vk>=MINHK && vk<MAXHK)
  153.     _stprintf(buf,_T("App %d"),vk-MINHK);
  154.   else
  155.     _stprintf(buf,_T("Key %02x"),vk);
  156.   return buf;
  157. }
  159. static CString GetKeyNames(int i) {
  160.   CString rv;
  162.   if (g_actions[i].vk1 != 0)
  163.     rv = GetKeyName(g_actions[i].vk1);
  164.   if (g_actions[i].vk2 != 0) {
  165.     if (!rv.IsEmpty()) rv += ',';
  166.     rv += GetKeyName(g_actions[i].vk2);
  167.   }
  168.   if (g_actions[i].vk3 != 0) {
  169.     if (!rv.IsEmpty()) rv += ',';
  170.     rv += GetKeyName(g_actions[i].vk3);
  171.   }
  173.   return rv;
  174. }
  176. static int  GetActionId(UINT cmd) {
  177.   for (int i=0;i<NUMACTIONS;++i)
  178.     if (g_actions[i].cmd==cmd)
  179.       return i;
  180.   return NUMACTIONS-1;
  181. }
  183. static int  LookupKey(UINT vk) {
  184.   for (int i = 0; i < NUMACTIONS; ++i) {
  185.     if (g_actions[i].vk1 == vk)
  186.       return g_actions[i].cmd;
  187.     if (g_actions[i].vk2 == vk)
  188.       return g_actions[i].cmd;
  189.     if (g_actions[i].vk3 == vk)
  190.       return g_actions[i].cmd;
  191.   }
  192.   return 0;
  193. }
  195. static bool HaveKeys(int i) {
  196.   return g_actions[i].vk1 || g_actions[i].vk2 || g_actions[i].vk3;
  197. }
  199. static bool HaveSlots(int i) {
  200.   return !g_actions[i].vk1 || !g_actions[i].vk2 || !g_actions[i].vk3;
  201. }
  203. static void AddKey(int i,UINT vk) {
  204.   if (!g_actions[i].vk1) {
  205.     g_actions[i].vk1 = vk;
  206.     return;
  207.   }
  208.   if (!g_actions[i].vk2) {
  209.     g_actions[i].vk2 = vk;
  210.     return;
  211.   }
  212.   if (!g_actions[i].vk3) {
  213.     g_actions[i].vk3 = vk;
  214.     return;
  215.   }
  216. }
  218. static HWND g_keyowner;
  220. void Keys::InitKeys() {
  221.   for (int i = 0; i < NUMACTIONS; ++i) {
  222.     CString   kn;
  223.     kn.Format(_T("%u"),g_actions[i].cmd);
  224.     CString   val(AfxGetApp()->GetProfileString(_T("Keys2"),kn));
  225.     if (!val.IsEmpty())
  226.       if (_stscanf(val,_T("%u,%u,%u"),&g_actions[i].vk1,&g_actions[i].vk2,&g_actions[i].vk3) != 3)
  227. g_actions[i].vk1 = g_actions[i].vk2 = g_actions[i].vk3 = 0;
  228.   }
  230. #ifdef _WIN32_WCE
  231.   if (!g_UnregisterFunc1) {
  232.     HMODULE hLib=GetModuleHandle(_T("coredll.dll"));
  233.     if (hLib)
  234.       g_UnregisterFunc1=(BOOL (*)(UINT,UINT))GetProcAddress(hLib,_T("UnregisterFunc1"));
  235.   }
  236. #endif
  237. }
  239. static void SaveKeys() {
  240.   for (int i = 0; i < NUMACTIONS; ++i) {
  241.     CString   kn;
  242.     kn.Format(_T("%u"),g_actions[i].cmd);
  243.     CString   val;
  244.     val.Format(_T("%u,%u,%u"),g_actions[i].vk1,g_actions[i].vk2,g_actions[i].vk3);
  245.     AfxGetApp()->WriteProfileString(_T("Keys2"),kn,val);
  246.   }
  247. }
  249. static void GrabAct(HWND hWnd,int i) {
  250.   if (g_actions[i].vk1)
  251.     GrabKey(hWnd,g_actions[i].vk1);
  252.   if (g_actions[i].vk2)
  253.     GrabKey(hWnd,g_actions[i].vk2);
  254.   if (g_actions[i].vk3)
  255.     GrabKey(hWnd,g_actions[i].vk3);
  256. }
  258. static void ReleaseAct(HWND hWnd,int i) {
  259.   if (g_actions[i].vk1)
  260.     ReleaseKey(hWnd,g_actions[i].vk1);
  261.   if (g_actions[i].vk2)
  262.     ReleaseKey(hWnd,g_actions[i].vk2);
  263.   if (g_actions[i].vk3)
  264.     ReleaseKey(hWnd,g_actions[i].vk3);
  265. }
  267. static void GrabAllKeys(HWND hWnd) {
  268.   for (int i = 0; i < NUMACTIONS; ++i)
  269.     GrabAct(hWnd,i);
  270. }
  272. static void ReleaseAllKeys(HWND hWnd) {
  273.   for (int i = 0; i < NUMACTIONS; ++i)
  274.     ReleaseAct(hWnd,i);
  275. }
  277. void Keys::SetWindow(HWND hWnd) {
  278.   if (g_keyowner)
  279.     ReleaseAllKeys(g_keyowner);
  280.   g_keyowner=hWnd;
  281.   if (g_keyowner)
  282.     GrabAllKeys(g_keyowner);
  283.   else {
  284. #ifdef SPI_APPBUTTONCHANGE
  285.     // WinCE doesn't have SendMessageTimeout, so we have to post it
  286.     ::PostMessage(HWND_BROADCAST,WM_WININICHANGE,SPI_APPBUTTONCHANGE,0);
  287. #endif
  288.   }
  289. }
  291. bool  Keys::TranslateKey(UINT vk,UINT& cmd,int angle) {
  292.   UINT cc = LookupKey(vk);
  293.   if (!cc)
  294.     return false;
  295.   cmd = cc;
  296.   if (angle) {
  297.     int   idx;
  298.     switch (vk) {
  299.     case VK_LEFT:
  300.       idx=0;
  301.       break;
  302.     case VK_UP:
  303.       idx=1;
  304.       break;
  305.     case VK_RIGHT:
  306.       idx=2;
  307.       break;
  308.     case VK_DOWN:
  309.       idx=3;
  310.       break;
  311.     default:
  312.       return true;
  313.     }
  314.     int delta;
  315.     switch (angle) {
  316.     case 900:
  317.       delta=1;
  318.       break;
  319.     case 1800:
  320.       delta=2;
  321.       break;
  322.     case 2700:
  323.       delta=3;
  324.       break;
  325.     default:
  326.       delta=0;
  327.     }
  328.     idx=(idx+delta)%4;
  329.     switch (idx) {
  330.     case 0:
  331.       vk=VK_LEFT;
  332.       break;
  333.     case 1:
  334.       vk=VK_UP;
  335.       break;
  336.     case 2:
  337.       vk=VK_RIGHT;
  338.       break;
  339.     case 3:
  340.       vk=VK_DOWN;
  341.       break;
  342.     }
  343.     cc = LookupKey(vk);
  344.     if (!cc)
  345.       return false;
  346.     cmd=cc;
  347.     return true;
  348.   }
  349.   return true;
  350. }
  352. class CKeysDlg : public CDialog
  353. {
  354.   // Construction
  355. public:
  356.   CKeysDlg(CWnd* pParent = NULL);   // standard constructor
  357.   
  358.   // Dialog Data
  359.   //{{AFX_DATA(CKeysDlg)
  360.   enum { IDD = IDD_KEYS };
  361.   //}}AFX_DATA
  362.   
  363.   
  364.   // Overrides
  365.   // ClassWizard generated virtual function overrides
  366.   //{{AFX_VIRTUAL(CKeysDlg)
  367. protected:
  368.   virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
  369.   //}}AFX_VIRTUAL
  370.   
  371.   // Implementation
  372. protected:
  373.   void   SetButtons(int i) {
  374.     ::EnableWindow(::GetDlgItem(m_hWnd,IDCLEAR),HaveKeys(i));
  375.     ::EnableWindow(::GetDlgItem(m_hWnd,IDASSIGN),HaveSlots(i));
  376.   }
  378.   void   SetText(int i) {
  379.     LVITEM    ii;
  381.     ii.mask = LVIF_TEXT;
  382.     ii.stateMask = 0;
  383.     ii.iItem = i;
  384.     ii.iSubItem = 1;
  386.     CString ks = GetKeyNames(i);
  388.     ii.pszText = (TCHAR *)(const TCHAR *)ks;
  390.     ::SendMessage(::GetDlgItem(m_hWnd,IDC_COMMANDS),LVM_SETITEMTEXT,i,(LPARAM)&ii);
  391.   }
  393.   // Generated message map functions
  394.   //{{AFX_MSG(CKeysDlg)
  395.   virtual BOOL OnInitDialog();
  396.   afx_msg void OnActivate(NMHDR* pNMHDR, LRESULT* pResult);
  397.   //}}AFX_MSG
  398.   DECLARE_MESSAGE_MAP()
  399. };
  401. CKeysDlg::CKeysDlg(CWnd* pParent /*=NULL*/)
  402. : CDialog(CKeysDlg::IDD, pParent)
  403. {
  404.   //{{AFX_DATA_INIT(CKeysDlg)
  405.   //}}AFX_DATA_INIT
  406. }
  408. BEGIN_MESSAGE_MAP(CKeysDlg, CDialog)
  409. //{{AFX_MSG_MAP(CKeysDlg)
  410. ON_NOTIFY(LVN_ITEMCHANGED, IDC_COMMANDS, OnActivate)
  411. //}}AFX_MSG_MAP
  412. END_MESSAGE_MAP()
  414. BOOL CKeysDlg::OnInitDialog() 
  415. {
  416.   CDialog::OnInitDialog();
  418. #if POCKETPC
  419.   ((CCeCommandBar *)m_pWndEmptyCB)->LoadToolBar(cIDR_DIALOG);
  420. #endif
  422. #if POCKETPC
  423.   // resize the list box
  424.   RECT     rcC,rcB1,rcB2,rcL;
  425.   GetClientRect(&rcC);
  427.   ::GetWindowRect(::GetDlgItem(m_hWnd,IDC_LABEL),&rcL); ScreenToClient(&rcL);
  428.   ::GetWindowRect(::GetDlgItem(m_hWnd,IDASSIGN),&rcB1); ScreenToClient(&rcB1);
  429.   ::GetWindowRect(::GetDlgItem(m_hWnd,IDCLEAR),&rcB2); ScreenToClient(&rcB2);
  431.   int     delta = rcC.bottom - rcB1.bottom - 4;
  433.   if (delta > 0) {
  434.     rcL.top += delta; rcL.bottom += delta;
  435.     rcB1.top += delta; rcB1.bottom += delta;
  436.     rcB2.top += delta; rcB2.bottom += delta;
  437.     GetDlgItem(IDC_LABEL)->MoveWindow(&rcL);
  438.     GetDlgItem(IDASSIGN)->MoveWindow(&rcB1);
  439.     GetDlgItem(IDCLEAR)->MoveWindow(&rcB2);
  441.     GetDlgItem(IDC_COMMANDS)->GetWindowRect(&rcL);
  442.     ScreenToClient(&rcL);
  443.     rcL.bottom += delta;
  444.     rcL.left = rcC.left - 1;
  445.     rcL.right = rcC.right + 1;
  446.     GetDlgItem(IDC_COMMANDS)->MoveWindow(&rcL);
  447.   }
  448. #endif
  450.   ::EnableWindow(::GetDlgItem(m_hWnd,IDASSIGN),FALSE);
  451.   ::EnableWindow(::GetDlgItem(m_hWnd,IDCLEAR),FALSE);
  453.   CWnd   *lv = GetDlgItem(IDC_COMMANDS);
  455. #ifdef LVS_EX_FULLROWSELECT
  456.   lv->SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE,LVS_EX_FULLROWSELECT,LVS_EX_FULLROWSELECT);
  457. #endif
  459.   RECT   rcLV;
  460.   lv->GetClientRect(&rcLV);
  462.   int   vw = rcLV.right - rcLV.left - GetSystemMetrics(SM_CXVSCROLL);
  464.   LVCOLUMN   col;
  465.   memset(&col, 0, sizeof(col));
  467.   col.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  468.   col.fmt = LVCFMT_LEFT;
  469.   col.cx = vw / 2;
  471.   GetDlgItem(IDC_COMMANDS)->SendMessage(LVM_INSERTCOLUMN,0,(LPARAM)&col);
  473.   col.cx = vw - col.cx;
  474.   GetDlgItem(IDC_COMMANDS)->SendMessage(LVM_INSERTCOLUMN,1,(LPARAM)&col);
  476.   CString   ks;
  478.   for (int i = 0; i < NUMACTIONS; ++i) {
  479.     LVITEM    ii;
  480.     memset(&ii, 0, sizeof(ii));
  482.     ii.mask = LVIF_TEXT;
  483.     ii.stateMask = 0;
  484.     ii.pszText = (TCHAR *)g_actions[i].name;
  485.     ii.iItem = i;
  486.     ii.iSubItem = 0;
  488.     lv->SendMessage(LVM_INSERTITEM,0,(LPARAM)&ii);
  490.     ks = GetKeyNames(i);
  492.     ii.iSubItem = 1;
  493.     ii.pszText = (TCHAR *)(const TCHAR *)ks;
  495.     lv->SendMessage(LVM_SETITEMTEXT,i,(LPARAM)&ii);
  496.   }
  498.   return TRUE;
  499. }
  501. class CKeyGrabDlg : public CDialog
  502. {
  503.   // Construction
  504. public:
  505.   CKeyGrabDlg(CWnd* pParent = NULL);   // standard constructor
  507.   UINT       m_vk[16];
  509.   void Record(UINT vk) {
  510.     SetTimer(1,50,NULL);
  511.     for (int i = 0; i < sizeof(m_vk)/sizeof(m_vk[0]); ++i)
  512.       if (m_vk[i] == 0) {
  513. m_vk[i] = vk;
  514. return;
  515.       }
  516.   }
  518.   UINT Get() {
  519.     UINT    vk = 0;
  520.     for (int i = 0; i < sizeof(m_vk)/sizeof(m_vk[0]); ++i)
  521.       if (LOWORD(m_vk[i]) && (vk == 0 || LOWORD(m_vk[i]) < vk))
  522. vk = LOWORD(m_vk[i]);
  523.     return vk;
  524.   }
  526. #if 0
  527.   CString List() {
  528.     CString s;
  529.     for (int i = 0; i < sizeof(m_vk)/sizeof(m_vk[0]); ++i) {
  530.       if (m_vk[i] == 0)
  531. break;
  532.       CString t; t.Format(_T("0x%x"),m_vk[i]);
  533.       if (!s.IsEmpty())
  534. s+=' ';
  535.       s+=t;
  536.     }
  537.     return s;
  538.   }
  539. #endif
  541.   enum { IDD = IDD_KEYGRAB };
  542.   
  543. protected:
  544.   static LRESULT CALLBACK GrabKeyProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam);
  545.   
  546.   // Generated message map functions
  547.   //{{AFX_MSG(CKeyGrabDlg)
  548.   virtual BOOL OnInitDialog();
  549.   afx_msg void OnDestroy();
  550.   afx_msg void OnTimer(UINT nIDEvent);
  551.   //}}AFX_MSG
  552.   afx_msg LRESULT OnHotkey(WPARAM,LPARAM);
  553.   afx_msg LRESULT OnApp(WPARAM,LPARAM);
  554.   DECLARE_MESSAGE_MAP()
  555. };
  557. /////////////////////////////////////////////////////////////////////////////
  558. // CKeyGrabDlg dialog
  560. CKeyGrabDlg::CKeyGrabDlg(CWnd* pParent /*=NULL*/)
  561. : CDialog(CKeyGrabDlg::IDD, pParent)
  562. {
  563.   memset(m_vk,0,sizeof(m_vk));
  564. }
  566. BEGIN_MESSAGE_MAP(CKeyGrabDlg, CDialog)
  567. //{{AFX_MSG_MAP(CKeyGrabDlg)
  568. ON_WM_DESTROY()
  569. ON_WM_TIMER()
  570. //}}AFX_MSG_MAP
  571. ON_MESSAGE(WM_HOTKEY, OnHotkey)
  572. ON_MESSAGE(WM_APP, OnApp)
  573. #if POCKETPC
  574. ON_WM_SETTINGCHANGE()
  575. #endif
  576. END_MESSAGE_MAP()
  578. /////////////////////////////////////////////////////////////////////////////
  579. // CKeyGrabDlg message handlers
  581. void CKeyGrabDlg::OnTimer(UINT nIDEvent) 
  582. {
  583.   for (int i = 0; i < sizeof(m_vk)/sizeof(m_vk[0]); ++i)
  584.     if (LOWORD(m_vk[i]) && (GetAsyncKeyState(LOWORD(m_vk[i])) & 0x8000)) {
  585.       SetTimer(1,50,NULL);
  586.       return;
  587.     }
  588.   EndDialog(IDOK);
  589. }
  591. BOOL CKeyGrabDlg::OnInitDialog() {
  592.   CDialog::OnInitDialog();
  594. #if POCKETPC
  595.   ((CCeCommandBar *)m_pWndEmptyCB)->LoadToolBar(cIDR_DIALOG);
  596. #endif
  598.   RECT rcC;
  599.   GetClientRect(&rcC);
  601.   HWND hWnd = ::CreateWindow(_T("Static"),_T("Press any key..."),WS_VISIBLE|WS_CHILD|SS_CENTER,
  602.     rcC.left,rcC.top + (rcC.bottom-rcC.top)/2 - HIWORD(GetDialogBaseUnits()),
  603.     rcC.right-rcC.left,HIWORD(GetDialogBaseUnits()*2),m_hWnd,
  604.     (HMENU)47793,AfxGetInstanceHandle(),NULL);
  606.   // release all keys
  607.   if (g_keyowner)
  608.     ReleaseAllKeys(g_keyowner);
  610.   // and grab all
  611.   for (int i=MINHK;i<=MAXHK;++i)
  612.     GrabKey(m_hWnd,i);
  614.   SetWindowLong(m_hWnd,GWL_USERDATA,GetWindowLong(m_hWnd,GWL_WNDPROC));
  615.   SetWindowLong(m_hWnd,GWL_WNDPROC,(LONG)GrabKeyProc);
  617.   SetWindowLong(hWnd,GWL_USERDATA,GetWindowLong(hWnd,GWL_WNDPROC));
  618.   SetWindowLong(hWnd,GWL_WNDPROC,(LONG)GrabKeyProc);
  620.   SetFocus();
  622.   return TRUE;
  623. }
  625. void CKeyGrabDlg::OnDestroy() {
  626.   // release keys
  627.   for (int i=MINHK;i<=MAXHK;++i)
  628.     ReleaseKey(m_hWnd,i);
  629.   // and regrab
  630.   if (g_keyowner)
  631.     GrabAllKeys(g_keyowner);
  632.   CDialog::OnDestroy();
  633. }
  635. LRESULT CKeyGrabDlg::OnHotkey(WPARAM wp,LPARAM lp) {
  636.   Record(MAKELONG(HIWORD(lp),LOWORD(lp)));
  637.   return 0;
  638. }
  640. LRESULT CKeyGrabDlg::OnApp(WPARAM wp,LPARAM lp) {
  641.   if (wp == 0x86)
  642.     Record(13);
  643.   return 0;
  644. }
  646. LRESULT CALLBACK CKeyGrabDlg::GrabKeyProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam) {
  647.   WNDPROC wp = (WNDPROC)GetWindowLong(hWnd,GWL_USERDATA);
  649.   HWND   mWnd = hWnd;
  651.   if (::GetDlgCtrlID(hWnd) == 47793)
  652.     mWnd = ::GetParent(hWnd);
  654.   if (mWnd == NULL)
  655.     return CallWindowProc(wp,hWnd,uMsg,wParam,lParam);
  657.   if (uMsg == WM_KEYDOWN) {
  658.     if (!IsMod(wParam) && !(lParam & 0x40000000))
  659.       ::PostMessage(mWnd,WM_APP,wParam,0);
  660.   }
  662.   if (uMsg == WM_KEYUP) {
  663.     if (!IsMod(wParam))
  664.       ::PostMessage(mWnd,WM_HOTKEY,wParam,MAKELONG(0,wParam));
  665.     return 0;
  666.   }
  668.   if (uMsg == WM_DESTROY)
  669.     SetWindowLong(hWnd,GWL_WNDPROC,GetWindowLong(hWnd,GWL_USERDATA));
  671.   return CallWindowProc(wp,hWnd,uMsg,wParam,lParam);
  672. }
  674. void Keys::SetupKeys(CWnd *parent) {
  675.   CKeysDlg    dlg;
  676.   if (dlg.DoModal()==IDOK)
  677.     SaveKeys();
  678.   else {
  679.     HWND  owner=g_keyowner;
  680.     Keys::SetWindow(0);
  681.     Keys::InitKeys();
  682.     Keys::SetWindow(owner);
  683.   }
  684. }
  686. BOOL CKeysDlg::OnCommand(WPARAM wParam, LPARAM lParam) 
  687. {
  688.   int sel = ::SendMessage(::GetDlgItem(m_hWnd,IDC_COMMANDS),LVM_GETSELECTIONMARK,0,0);
  690.   switch (LOWORD(wParam)) {
  691.     case IDASSIGN:
  692.       if (sel >= 0 && sel < NUMACTIONS && HaveSlots(sel)) {
  693. CKeyGrabDlg dlg(this);
  694. dlg.DoModal();
  695. if (dlg.Get()) {
  696.   UINT  vk = dlg.Get();
  697.   for (int j = 0; j < NUMACTIONS; ++j) {
  698.     if (g_actions[j].vk1 == vk) {
  699.       g_actions[j].vk1 = 0;
  700.       SetText(j);
  701.     }
  702.     if (g_actions[j].vk2 == vk) {
  703.       g_actions[j].vk2 = 0;
  704.       SetText(j);
  705.     }
  706.     if (g_actions[j].vk3 == vk) {
  707.       g_actions[j].vk3 = 0;
  708.       SetText(j);
  709.     }
  710.   }
  712.   if (g_keyowner)
  713.     ReleaseAct(g_keyowner,sel);
  715.   AddKey(sel,vk);
  717.   if (g_keyowner)
  718.     GrabAct(g_keyowner,sel);
  720.   SetButtons(sel);
  721.   SetText(sel);
  722. }
  723.       }
  724.       return TRUE;
  725.     case IDCLEAR:
  726.       if (sel >= 0 && sel < NUMACTIONS) {
  727. if (g_keyowner)
  728.   ReleaseAct(g_keyowner,sel);
  729. g_actions[sel].vk1 = g_actions[sel].vk2 = g_actions[sel].vk3 = 0;
  730. SetButtons(sel);
  731. SetText(sel);
  732.       }
  733.       return TRUE;
  734.   }
  736.   return CDialog::OnCommand(wParam, lParam);
  737. }
  739. void CKeysDlg::OnActivate(NMHDR* pNMHDR, LRESULT* pResult) 
  740. {
  741.   NMLISTVIEW  *nv = (NMLISTVIEW *)pNMHDR;
  743.   if (nv->iItem >= 0 && (nv->uChanged & LVIF_STATE) && 
  744.       (nv->uNewState & LVIS_SELECTED))
  745.   {
  746.     SetButtons(nv->iItem);
  747.   }
  748. #if 0
  749.   int sel = ::SendMessage(::GetDlgItem(m_hWnd,IDC_COMMANDS),LVM_GETSELECTIONMARK,0,0);
  751.   if (sel >= 0 && sel < NUMACTIONS)
  752.     SetButtons(sel);
  753. #endif
  755.   *pResult = 0;
  756. }