FsWin32KeyMapper::FsWin32KeyMapper()
{
	int i;

	mapVKtoFSKEY=new int [FS_NUM_VK];
	mapFSKEYtoVK=new int [FSKEY_NUM_KEYCODE];

	for(i=0; i<FS_NUM_VK; i++)
	{
		mapVKtoFSKEY[i]=FSKEY_NULL;
	}
	for(i=0; i<FSKEY_NUM_KEYCODE; i++)
	{
		mapFSKEYtoVK[i]=0;
	}

	AddKeyMapping(FSKEY_SPACE,               VK_SPACE);
	AddKeyMapping(FSKEY_0,                   '0');
	AddKeyMapping(FSKEY_1,                   '1');
	AddKeyMapping(FSKEY_2,                   '2');
	AddKeyMapping(FSKEY_3,                   '3');
	AddKeyMapping(FSKEY_4,                   '4');
	AddKeyMapping(FSKEY_5,                   '5');
	AddKeyMapping(FSKEY_6,                   '6');
	AddKeyMapping(FSKEY_7,                   '7');
	AddKeyMapping(FSKEY_8,                   '8');
	AddKeyMapping(FSKEY_9,                   '9');
	AddKeyMapping(FSKEY_A,                   'A');
	AddKeyMapping(FSKEY_B,                   'B');
	AddKeyMapping(FSKEY_C,                   'C');
	AddKeyMapping(FSKEY_D,                   'D');
	AddKeyMapping(FSKEY_E,                   'E');
	AddKeyMapping(FSKEY_F,                   'F');
	AddKeyMapping(FSKEY_G,                   'G');
	AddKeyMapping(FSKEY_H,                   'H');
	AddKeyMapping(FSKEY_I,                   'I');
	AddKeyMapping(FSKEY_J,                   'J');
	AddKeyMapping(FSKEY_K,                   'K');
	AddKeyMapping(FSKEY_L,                   'L');
	AddKeyMapping(FSKEY_M,                   'M');
	AddKeyMapping(FSKEY_N,                   'N');
	AddKeyMapping(FSKEY_O,                   'O');
	AddKeyMapping(FSKEY_P,                   'P');
	AddKeyMapping(FSKEY_Q,                   'Q');
	AddKeyMapping(FSKEY_R,                   'R');
	AddKeyMapping(FSKEY_S,                   'S');
	AddKeyMapping(FSKEY_T,                   'T');
	AddKeyMapping(FSKEY_U,                   'U');
	AddKeyMapping(FSKEY_V,                   'V');
	AddKeyMapping(FSKEY_W,                   'W');
	AddKeyMapping(FSKEY_X,                   'X');
	AddKeyMapping(FSKEY_Y,                   'Y');
	AddKeyMapping(FSKEY_Z,                   'Z');
	AddKeyMapping(FSKEY_ESC,                 VK_ESCAPE);
	AddKeyMapping(FSKEY_F1,                  VK_F1);
	AddKeyMapping(FSKEY_F2,                  VK_F2);
	AddKeyMapping(FSKEY_F3,                  VK_F3);
	AddKeyMapping(FSKEY_F4,                  VK_F4);
	AddKeyMapping(FSKEY_F5,                  VK_F5);
	AddKeyMapping(FSKEY_F6,                  VK_F6);
	AddKeyMapping(FSKEY_F7,                  VK_F7);
	AddKeyMapping(FSKEY_F8,                  VK_F8);
	AddKeyMapping(FSKEY_F9,                  VK_F9);
	AddKeyMapping(FSKEY_F10,                 VK_F10);
	AddKeyMapping(FSKEY_F11,                 VK_F11);
	AddKeyMapping(FSKEY_F12,                 VK_F12);
	AddKeyMapping(FSKEY_PRINTSCRN,           0 /* Unassignable */);
	AddKeyMapping(FSKEY_SCROLLLOCK,          VK_SCROLL);
	AddKeyMapping(FSKEY_PAUSEBREAK,          VK_PAUSE);
	AddKeyMapping(FSKEY_TILDA,               VK_OEM_3);
	AddKeyMapping(FSKEY_MINUS,               VK_OEM_MINUS);
	AddKeyMapping(FSKEY_PLUS,                VK_OEM_PLUS);
	AddKeyMapping(FSKEY_BS,                  VK_BACK);
	AddKeyMapping(FSKEY_TAB,                 VK_TAB);
	AddKeyMapping(FSKEY_LBRACKET,            VK_OEM_4);
	AddKeyMapping(FSKEY_RBRACKET,            VK_OEM_6);
	AddKeyMapping(FSKEY_BACKSLASH,           VK_OEM_5);
	AddKeyMapping(FSKEY_CAPSLOCK,            VK_CAPITAL);
	AddKeyMapping(FSKEY_SEMICOLON,           VK_OEM_1);
	AddKeyMapping(FSKEY_SINGLEQUOTE,         VK_OEM_7);
	AddKeyMapping(FSKEY_ENTER,               VK_RETURN);
	AddKeyMapping(FSKEY_SHIFT,               VK_SHIFT);
	AddKeyMapping(FSKEY_COMMA,               VK_OEM_COMMA);
	AddKeyMapping(FSKEY_DOT,                 VK_OEM_PERIOD);
	AddKeyMapping(FSKEY_SLASH,               VK_OEM_2);
	AddKeyMapping(FSKEY_CTRL,                VK_CONTROL);
	AddKeyMapping(FSKEY_ALT,                 VK_MENU);
	AddKeyMapping(FSKEY_INS,                 VK_INSERT);
	AddKeyMapping(FSKEY_DEL,                 VK_DELETE);
	AddKeyMapping(FSKEY_HOME,                VK_HOME);
	AddKeyMapping(FSKEY_END,                 VK_END);
	AddKeyMapping(FSKEY_PAGEUP,              VK_PRIOR);
	AddKeyMapping(FSKEY_PAGEDOWN,            VK_NEXT);
	AddKeyMapping(FSKEY_UP,                  VK_UP);
	AddKeyMapping(FSKEY_DOWN,                VK_DOWN);
	AddKeyMapping(FSKEY_LEFT,                VK_LEFT);
	AddKeyMapping(FSKEY_RIGHT,               VK_RIGHT);
	AddKeyMapping(FSKEY_NUMLOCK,             VK_NUMLOCK);
	AddKeyMapping(FSKEY_TEN0,                VK_NUMPAD0);
	AddKeyMapping(FSKEY_TEN1,                VK_NUMPAD1);
	AddKeyMapping(FSKEY_TEN2,                VK_NUMPAD2);
	AddKeyMapping(FSKEY_TEN3,                VK_NUMPAD3);
	AddKeyMapping(FSKEY_TEN4,                VK_NUMPAD4);
	AddKeyMapping(FSKEY_TEN5,                VK_NUMPAD5);
	AddKeyMapping(FSKEY_TEN6,                VK_NUMPAD6);
	AddKeyMapping(FSKEY_TEN7,                VK_NUMPAD7);
	AddKeyMapping(FSKEY_TEN8,                VK_NUMPAD8);
	AddKeyMapping(FSKEY_TEN9,                VK_NUMPAD9);
	AddKeyMapping(FSKEY_TENDOT,              VK_DECIMAL);
	AddKeyMapping(FSKEY_TENSLASH,            VK_DIVIDE);
	AddKeyMapping(FSKEY_TENSTAR,             VK_MULTIPLY);
	AddKeyMapping(FSKEY_TENMINUS,            VK_SUBTRACT);
	AddKeyMapping(FSKEY_TENPLUS,             VK_ADD);
	AddKeyMapping(FSKEY_TENENTER,            0 /* Unassignable */);
}
Beispiel #2
0
// WM_COMMAND handler.
LRESULT KeyboardPage::OnCommand( UINT nNotifyCode, UINT nCtrlID, HWND hWndCtrl )
{
	// What's up?
	switch ( nCtrlID )
	{
		case	EditToolbar::ETID_NEW:
			// Command toolbar?
			if ( hWndCtrl == m_ComTools )
			{
				// Obtain button rectangle.
				ClsRect rc;
				m_ComTools.GetItemRect( 0, rc );

				// Convert rectangle to screen
				// coordinates.
				m_ComTools.ClientToScreen( rc );

				// Show the menu.
				::TrackPopupMenuEx( m_Menu,//*m_Menu.GetSubMenu( 0 ),
						  TPM_LEFTALIGN,
						  rc.Left(),
						  rc.Bottom(),
						  GetSafeHWND(),
						  NULL );
			}
			else
			{
				// Show the key recorder.
				KeyRec kr;
				ClsString str;
				if ( kr.KeyRecord( *GetParent(), str ))
					AddKeyMapping( str );
			}
			return 0;

		case	EditToolbar::ETID_DELETE:
			// Command toolbar?
			if ( hWndCtrl == m_ComTools )
			{
				// Get current selection.
				LPCNODE pCNode = ( LPCNODE )m_Commands.GetItemData( m_Commands.GetCurSel());
				if ( pCNode != ( LPCNODE )LB_ERR )
				{
					// Save selection position.
					int nSel = m_Commands.GetCurSel();
					int nPos = nSel;
					int nMax = m_Commands.GetCount();
					
					// Select the next or previous
					// entry.
					if ( nSel == nMax - 1 && nSel ) nSel--;
					else				nSel++;

					// Select the new item
					m_Commands.SetCurSel( nSel );

					// Remove the node from the listview.
					m_Commands.DeleteString( nPos );

					// Remove it from the command list.
					Remove(( LPNODE )pCNode );

					// Free the node
					// data.
					if ( pCNode->nType != CTYPE_HARDCODED )
						::FreePooled( pParserPool, pCNode->pcStr );

					// And the node itself.
					::FreePooled( pParserPool, pCNode );

					// Setup GUI.
					SetupControls();
					pSettings->Changed( m_pParser );
				}
				return 0;
			}
			else
			{
				// Get the key descriptor.
				TCHAR szKeyString[ 64 ];
				int nSel = m_Keys.GetCurSel(), nMax = m_Keys.GetCount();
				if ( nSel != LB_ERR )
				{
					if ( m_Keys.GetText( nSel, szKeyString ) != LB_ERR )
					{
						// Convert to a code and qualifier.
						TCHAR cCode, cQual;
						if ( ::Str2CodeQual( szKeyString, &cCode, &cQual ))
						{
							// Remove the hash. This will automatically destroy
							// the command-list aswell.
							::RemHash( pParserPool, m_pParser->aHash, cCode, cQual );

							// Remove it from the listview.
							m_Keys.DeleteString( nSel );

							// Was it the last one?
							if ( nSel == nMax - 1 ) nSel--;

							// Select the next or previous key.
							m_Keys.SetCurSel( nSel );
							SendMessage( WM_COMMAND, MAKEWPARAM( IDC_KEYS, LBN_SELCHANGE ), ( LPARAM )m_Keys.GetSafeHWND());

							// Changes made...
							pSettings->Changed( m_pParser );
						}
					}
				}
			}
			return 0;

		case	EditToolbar::ETID_UP:
		{
			// Valid node?
			LPCNODE pCNode = ( LPCNODE )m_Commands.GetItemData( m_Commands.GetCurSel());
			if ( pCNode != ( LPCNODE )LB_ERR )
			{
				// Get it's predecessor.
				LPCNODE pCPrev = pCNode->lpPrev;

				// Swap both data entries.
				CNODE cTemp;
				cTemp.nType	  = pCPrev->nType;
				cTemp.uCommand	  = pCPrev->uCommand;
				pCPrev->nType	  = pCNode->nType;
				pCPrev->uCommand  = pCNode->uCommand;
				pCNode->nType	  = cTemp.nType;
				pCNode->uCommand  = cTemp.uCommand;

				// Select the previous item which
				// in fact is the already selected
				// item.
				m_Commands.SetCurSel( m_Commands.GetCurSel() - 1 );
				SetupControls();
				pSettings->Changed( m_pParser );
				return 0;
			}
		}

		case	EditToolbar::ETID_DOWN:
		{
			// Valid node?
			LPCNODE pCNode = ( LPCNODE )m_Commands.GetItemData( m_Commands.GetCurSel());
			if ( pCNode != ( LPCNODE )LB_ERR )
			{
				// Get it's successor.
				LPCNODE pCNext = pCNode->lpNext;
				
				// Swap both data entries.
				CNODE cTemp;
				cTemp.nType	  = pCNext->nType;
				cTemp.uCommand	  = pCNext->uCommand;
				pCNext->nType	  = pCNode->nType;
				pCNext->uCommand  = pCNode->uCommand;
				pCNode->nType	  = cTemp.nType;
				pCNode->uCommand  = cTemp.uCommand;

				// Select the next item which
				// in fact is the already selected
				// item.
				m_Commands.SetCurSel( m_Commands.GetCurSel() + 1 );
				SetupControls();
				pSettings->Changed( m_pParser );
				return 0;
			}
		}

		case	IDS_INSERT:
			CreateNode( CTYPE_TEXT, ( LPVOID )( LPCTSTR )ClsString( MAKEINTRESOURCE( IDS_NEWINSERT )));
			return 0;

		case	IDS_HARDCODED:
			CreateNode( CTYPE_HARDCODED, ( LPVOID )( ::GetCommandTable()->nCommandID ));
			return 0;

		case	IDS_RUN:
			CreateNode( CTYPE_RUN, ( LPVOID )( _T( "Calc.exe" )));
			return 0;

		case	IDS_OPEN:
			CreateNode( CTYPE_SHELLOPEN, ( LPVOID )( _T( "ReadMe.txt" )));
			return 0;

		case	IDC_KEYS:
			if ( nNotifyCode == LBN_SELCHANGE )
			{
				// Get the current selection.
				LPHASH pSel = GetSelection();
				if ( pSel )
				{
					// Clear the contents of the command list.
					m_Commands.ResetContent();

					// Add commands.
					LPCNODE pNode;
					for ( pNode = pSel->lpCommands->lpFirst; pNode->lpNext; pNode = pNode->lpNext )
						m_Commands.AddString(( LPCTSTR )pNode );
				}
			}
			// Setup controls.
			SetupControls();
			return 0;

		case	IDC_COMMANDS:
			// Double-click?
			if ( nNotifyCode == LBN_DBLCLK )
			{
				// Find the command node.
				LPCNODE pCNode = ( LPCNODE )m_Commands.GetItemData( m_Commands.GetCurSel());
				if ( pCNode != ( LPCNODE )LB_ERR )
				{
					// What's the type?
					switch ( pCNode->nType )
					{
						case	CTYPE_HARDCODED:
						{
							// Open the editor.
							Hardcoded h;
							if ( h.Select( *GetParent(), pCNode ))
							{
								// Refresh list.
								m_Commands.Invalidate();
								pSettings->Changed( m_pParser );
							}
							break;
						}

						case	CTYPE_TEXT:
						{
							// Open the editor.
							TextInsert ti;
							HICON hIcon = ImageList_GetIcon( m_hImages, 1, ILD_NORMAL );
							if ( ti.Edit( *GetParent(), pCNode, hIcon ))
							{
								// Refresh list.
								m_Commands.Invalidate();
								pSettings->Changed( m_pParser );
							}
							if ( hIcon ) ::DestroyIcon( hIcon );
							return 0;
						}
						
						case	CTYPE_RUN:
						case	CTYPE_SHELLOPEN:
						{
							// Open the editor.
							Run r;
							if ( r.Edit( *GetParent(), pCNode ))
							{
								// Refresh list.
								m_Commands.Invalidate();
								pSettings->Changed( m_pParser );
							}
						}
					}
				}
			}
			else
				// Setup GUI.
				SetupControls();
			return 0;
	}
	// Pass to the base class.
	return Page::OnCommand( nNotifyCode, nCtrlID, hWndCtrl );
}