BOOL COleIPFrameWnd::PreTranslateMessage(MSG* pMsg)
{
// check server's accelerators first
if (CFrameWnd::PreTranslateMessage(pMsg))
return TRUE;
if (pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
{
// always check to see if they exist in the default accel table
// (they may exist but not be translated when disabled)
HACCEL hAccel = GetDefaultAccelerator();
if (hAccel != NULL && IsAccelerator(hAccel,
CopyAcceleratorTable(hAccel, NULL, 0), pMsg, NULL))
{
return TRUE;
}
// check container's accelerators as last chance
OLEINPLACEFRAMEINFO frameInfo = m_frameInfo;
if (::OleTranslateAccelerator(m_lpFrame, &frameInfo, pMsg) == S_OK)
return TRUE;
}
return FALSE; // keystroke not processed.
}
BOOL COleClientItem::OnGetWindowContext(
CFrameWnd** ppMainFrame, CFrameWnd** ppDocFrame,
LPOLEINPLACEFRAMEINFO pFrameInfo)
{
ASSERT(AfxIsValidAddress(ppMainFrame, sizeof(CFrameWnd*)));
ASSERT(AfxIsValidAddress(ppDocFrame, sizeof(CFrameWnd*)));
ASSERT(pFrameInfo == NULL ||
AfxIsValidAddress(pFrameInfo, sizeof(OLEINPLACEFRAMEINFO)));
ASSERT_VALID(this);
ASSERT_VALID(m_pView);
// get main window of application
*ppMainFrame = m_pView->GetTopLevelFrame();
ASSERT_VALID(*ppMainFrame);
ASSERT_KINDOF(CFrameWnd, *ppMainFrame);
// get document window (if there is one)
CFrameWnd* pDocFrame = m_pView->GetParentFrame();
if (pDocFrame != *ppMainFrame)
{
*ppDocFrame = pDocFrame;
ASSERT_VALID(*ppDocFrame);
ASSERT_KINDOF(CFrameWnd, *ppDocFrame);
}
if (pFrameInfo != NULL)
{
// get accelerator table
CDocTemplate* pTemplate = GetDocument()->GetDocTemplate();
HACCEL hAccel = pTemplate != NULL ? pTemplate->m_hAccelInPlace : NULL;
pFrameInfo->cAccelEntries =
hAccel != NULL ? CopyAcceleratorTable(hAccel, NULL, 0) : 0;
pFrameInfo->haccel = pFrameInfo->cAccelEntries != 0 ? hAccel : NULL;
pFrameInfo->hwndFrame = (*ppMainFrame)->m_hWnd;
pFrameInfo->fMDIApp = *ppDocFrame != NULL;
}
return TRUE;
}
BOOL CResModule::ReplaceAccelerator(UINT nID, WORD wLanguage)
{
LPACCEL lpaccelNew; // pointer to new accelerator table
HACCEL haccelOld; // handle to old accelerator table
int cAccelerators; // number of accelerators in table
HGLOBAL hglAccTableNew;
const WORD* p;
int i;
haccelOld = LoadAccelerators(m_hResDll, MAKEINTRESOURCE(nID));
if (haccelOld == NULL)
MYERROR;
cAccelerators = CopyAcceleratorTable(haccelOld, NULL, 0);
lpaccelNew = (LPACCEL) LocalAlloc(LPTR, cAccelerators * sizeof(ACCEL));
if (lpaccelNew == NULL)
MYERROR;
CopyAcceleratorTable(haccelOld, lpaccelNew, cAccelerators);
// Find the accelerator that the user modified
// and change its flags and virtual-key code
// as appropriate.
BYTE xfVirt;
WORD xkey;
for (i = 0; i < cAccelerators; i++)
{
m_bDefaultAcceleratorStrings++;
if ((lpaccelNew[i].key < 0x30) ||
(lpaccelNew[i].key > 0x5A) ||
(lpaccelNew[i].key >= 0x3A && lpaccelNew[i].key <= 0x40))
continue;
TCHAR * pBuf = new TCHAR[1024];
SecureZeroMemory(pBuf, 1024 * sizeof(TCHAR));
_stprintf(pBuf, _T("ID:%d:"), lpaccelNew[i].cmd);
// get original key combination
if ((lpaccelNew[i].fVirt & FVIRTKEY) == FVIRTKEY) // 0x01
_tcscat(pBuf, _T("V"));
else
_tcscat(pBuf, _T(" "));
if ((lpaccelNew[i].fVirt & FALT) == FALT) // 0x10
_tcscat(pBuf, _T("A"));
else
_tcscat(pBuf, _T(" "));
if ((lpaccelNew[i].fVirt & FCONTROL) == FCONTROL) // 0x08
_tcscat(pBuf, _T("C"));
else
_tcscat(pBuf, _T(" "));
if ((lpaccelNew[i].fVirt & FSHIFT) == FSHIFT) // 0x04
_tcscat(pBuf, _T("S"));
else
_tcscat(pBuf, _T(" "));
_stprintf(pBuf, _T("%s+%c"), pBuf, lpaccelNew[i].key);
// Is it there?
std::map<std::wstring, RESOURCEENTRY>::iterator pAK_iter = m_StringEntries.find(pBuf);
if (pAK_iter != m_StringEntries.end())
{
m_bTranslatedAcceleratorStrings++;
xfVirt = 0;
xkey = 0;
std::wstring wtemp = pAK_iter->second.msgstr;
wtemp = wtemp.substr(wtemp.find_last_of(':')+1);
if (wtemp.size() != 6)
continue;
if (wtemp.compare(0, 1, _T("V")) == 0)
xfVirt |= FVIRTKEY;
else if (wtemp.compare(0, 1, _T(" ")) != 0)
continue; // not a space - user must have made a mistake when translating
if (wtemp.compare(1, 1, _T("A")) == 0)
xfVirt |= FALT;
else if (wtemp.compare(1, 1, _T(" ")) != 0)
continue; // not a space - user must have made a mistake when translating
if (wtemp.compare(2, 1, _T("C")) == 0)
xfVirt |= FCONTROL;
else if (wtemp.compare(2, 1, _T(" ")) != 0)
continue; // not a space - user must have made a mistake when translating
if (wtemp.compare(3, 1, _T("S")) == 0)
xfVirt |= FSHIFT;
else if (wtemp.compare(3, 1, _T(" ")) != 0)
continue; // not a space - user must have made a mistake when translating
if (wtemp.compare(4, 1, _T("+")) == 0)
{
_stscanf(wtemp.substr(5, 1).c_str(), _T("%c"), &xkey);
lpaccelNew[i].fVirt = xfVirt;
lpaccelNew[i].key = xkey;
}
}
}
// Create the new accelerator table
hglAccTableNew = LocalAlloc(LPTR, cAccelerators * 4 * sizeof(WORD));
p = (WORD *)hglAccTableNew;
lpaccelNew[cAccelerators-1].fVirt |= 0x80;
for (i = 0; i < cAccelerators; i++)
{
memcpy((void *)p, &lpaccelNew[i].fVirt, 1);
p++;
memcpy((void *)p, &lpaccelNew[i].key, sizeof(WORD));
p++;
memcpy((void *)p, &lpaccelNew[i].cmd, sizeof(WORD));
p++;
p++;
}
if (!UpdateResource(m_hUpdateRes, RT_ACCELERATOR, MAKEINTRESOURCE(nID),
(m_wTargetLang ? m_wTargetLang : wLanguage), hglAccTableNew /* haccelNew*/, cAccelerators * 4 * sizeof(WORD)))
{
goto DONE_ERROR;
}
if ((m_wTargetLang)&&(!UpdateResource(m_hUpdateRes, RT_ACCELERATOR, MAKEINTRESOURCE(nID), wLanguage, NULL, 0)))
{
goto DONE_ERROR;
}
LocalFree(lpaccelNew);
return TRUE;
DONE_ERROR:
LocalFree(lpaccelNew);
MYERROR;
}
/*
* memcmp on the tables works in Windows, but does not work in wine, as
* there is an extra undefined and unused byte between fVirt and the key
*/
static void test_accel2(void)
{
ACCEL ac[2], out[2];
HACCEL hac;
int res;
ac[0].cmd = 0;
ac[0].fVirt = 0;
ac[0].key = 0;
ac[1].cmd = 0;
ac[1].fVirt = 0;
ac[1].key = 0;
/*
* crashes on win2k
* hac = CreateAcceleratorTable( NULL, 1 );
*/
/* try a zero count */
hac = CreateAcceleratorTable( &ac[0], 0 );
ok( !hac || broken(hac != NULL), /* nt4 */ "fail\n");
if (!hac) ok( !DestroyAcceleratorTable( hac ), "destroy failed\n");
/* creating one accelerator should work */
hac = CreateAcceleratorTable( &ac[0], 1 );
ok( hac != NULL , "fail\n");
ok( 1 == CopyAcceleratorTable( hac, out, 1 ), "copy failed\n");
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* how about two of the same type? */
hac = CreateAcceleratorTable( &ac[0], 2);
ok( hac != NULL , "fail\n");
res = CopyAcceleratorTable( hac, NULL, 100 );
ok( res == 2, "copy null failed %d\n", res);
res = CopyAcceleratorTable( hac, NULL, 0 );
ok( res == 2, "copy null failed %d\n", res);
res = CopyAcceleratorTable( hac, NULL, 1 );
ok( res == 2, "copy null failed %d\n", res);
ok( 1 == CopyAcceleratorTable( hac, out, 1 ), "copy 1 failed\n");
ok( 2 == CopyAcceleratorTable( hac, out, 2 ), "copy 2 failed\n");
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
/* how about two of the same type with a non-zero key? */
ac[0].key = 0x20;
ac[1].key = 0x20;
hac = CreateAcceleratorTable( &ac[0], 2);
ok( hac != NULL , "fail\n");
ok( 2 == CopyAcceleratorTable( hac, out, 2 ), "copy 2 failed\n");
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
/* how about two of the same type with a non-zero virtual key? */
ac[0].fVirt = FVIRTKEY;
ac[0].key = 0x40;
ac[1].fVirt = FVIRTKEY;
ac[1].key = 0x40;
hac = CreateAcceleratorTable( &ac[0], 2);
ok( hac != NULL , "fail\n");
ok( 2 == CopyAcceleratorTable( hac, out, 2 ), "copy 2 failed\n");
/* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* how virtual key codes */
ac[0].fVirt = FVIRTKEY;
hac = CreateAcceleratorTable( &ac[0], 1);
ok( hac != NULL , "fail\n");
ok( 1 == CopyAcceleratorTable( hac, out, 2 ), "copy 2 failed\n");
/* ok( !memcmp( ac, out, sizeof ac/2 ), "tables different\n"); */
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* how turning on all bits? */
ac[0].cmd = 0xffff;
ac[0].fVirt = 0xff;
ac[0].key = 0xffff;
hac = CreateAcceleratorTable( &ac[0], 1);
ok( hac != NULL , "fail\n");
ok( 1 == CopyAcceleratorTable( hac, out, 1 ), "copy 1 failed\n");
/* ok( memcmp( ac, out, sizeof ac/2 ), "tables not different\n"); */
ok( out[0].cmd == ac[0].cmd, "cmd modified\n");
ok( out[0].fVirt == (ac[0].fVirt&0x7f), "fVirt not modified\n");
ok( out[0].key == ac[0].key, "key modified\n");
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
/* how turning on all bits? */
memset( ac, 0xff, sizeof ac );
hac = CreateAcceleratorTable( &ac[0], 2);
ok( hac != NULL , "fail\n");
res = CopyAcceleratorTable( hac, out, 2 );
ok( res == 2, "copy 2 failed %d\n", res);
/* ok( memcmp( ac, out, sizeof ac ), "tables not different\n"); */
ok( out[0].cmd == ac[0].cmd, "cmd modified\n");
ok( out[0].fVirt == (ac[0].fVirt&0x7f), "fVirt not modified\n");
ok( out[0].key == ac[0].key, "key modified\n");
if (res == 2)
{
ok( out[1].cmd == ac[1].cmd, "cmd modified\n");
ok( out[1].fVirt == (ac[1].fVirt&0x7f), "fVirt not modified\n");
ok( out[1].key == ac[1].key, "key modified\n");
}
ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
}
static void test_accel1(void)
{
UINT r, n;
HACCEL hAccel;
ACCEL ac[10];
/* now create our own valid accelerator table */
n = 0;
ac[n].cmd = 1000;
ac[n].key = 'A';
ac[n++].fVirt = FVIRTKEY | FNOINVERT;
ac[n].cmd = 1001;
ac[n].key = 'B';
ac[n++].fVirt = FNOINVERT;
ac[n].cmd = 0;
ac[n].key = 0;
ac[n++].fVirt = 0;
hAccel = CreateAcceleratorTable( &ac[0], n );
ok( hAccel != NULL, "create accelerator table\n");
r = DestroyAcceleratorTable( hAccel );
ok( r, "destroy accelerator table\n");
/* now try create an invalid one */
n = 0;
ac[n].cmd = 1000;
ac[n].key = 'A';
ac[n++].fVirt = FVIRTKEY | FNOINVERT;
ac[n].cmd = 0xffff;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0xffff;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0xfff0;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0x0000;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0x0001;
hAccel = CreateAcceleratorTable( &ac[0], n );
ok( hAccel != NULL, "create accelerator table\n");
r = CopyAcceleratorTable( hAccel, NULL, 0 );
ok( r == n, "two entries in table %u/%u\n", r, n);
r = CopyAcceleratorTable( hAccel, &ac[0], n );
ok( r == n, "still should be two entries in table %u/%u\n", r, n);
n=0;
ok( ac[n].cmd == 1000, "cmd 0 not preserved got %x\n", ac[n].cmd);
ok( ac[n].key == 'A', "key 0 not preserved got %x\n", ac[n].key);
ok( ac[n].fVirt == (FVIRTKEY | FNOINVERT), "fVirt 0 not preserved got %x\n", ac[n].fVirt);
if (++n == r) goto done;
ok( ac[n].cmd == 0xffff, "cmd 1 not preserved got %x\n", ac[n].cmd);
ok( ac[n].key == 0xffff, "key 1 not preserved got %x\n", ac[n].key);
ok( ac[n].fVirt == 0x007f, "fVirt 1 wrong got %x\n", ac[n].fVirt);
if (++n == r) goto done;
ok( ac[n].cmd == 0xfff0, "cmd 2 not preserved got %x\n", ac[n].cmd);
ok( (ac[n].key & 0xff) == 0xff, "key 2 not preserved got %x\n", ac[n].key);
ok( ac[n].fVirt == 0x0070, "fVirt 2 wrong got %x\n", ac[n].fVirt);
if (++n == r) goto done;
ok( ac[n].cmd == 0xfff0, "cmd 3 not preserved got %x\n", ac[n].cmd);
ok( (ac[n].key & 0xff) == 0xff, "key 3 not preserved got %x\n", ac[n].key);
ok( ac[n].fVirt == 0x0000, "fVirt 3 wrong got %x\n", ac[n].fVirt);
if (++n == r) goto done;
ok( ac[n].cmd == 0xfff0, "cmd 4 not preserved got %x\n", ac[n].cmd);
ok( ac[n].key == 0xffff, "key 4 not preserved got %x\n", ac[n].key);
ok( ac[n].fVirt == 0x0001, "fVirt 4 wrong got %x\n", ac[n].fVirt);
done:
r = DestroyAcceleratorTable( hAccel );
ok( r, "destroy accelerator table\n");
hAccel = CreateAcceleratorTable( &ac[0], 0 );
ok( !hAccel || broken(hAccel != NULL), /* nt4 */ "zero elements should fail\n");
/* these will on crash win2k
hAccel = CreateAcceleratorTable( NULL, 1 );
hAccel = CreateAcceleratorTable( &ac[0], -1 );
*/
}
//------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int cmdShow)
{
int i;
HDC dc;
MSG mesg;
RECT rc;
inst = hInstance;
//DPIAware
typedef BOOL(WINAPI *TGetProcAddress)();
TGetProcAddress getProcAddress = (TGetProcAddress)GetProcAddress(GetModuleHandle(_T("user32")), "SetProcessDPIAware");
if(getProcAddress) getProcAddress();
memset(custom, 200, sizeof(custom));
_tcscpy(pdfObject.fn, _T("sudoku.pdf"));
pdfObject.pageWidth=595;
pdfObject.pageHeight=842;
pdfObject.count=6;
pdfObject.countPerPage=6;
pdfObject.border=40;
pdfObject.spacing=20;
readini();
//load common controls
#if _WIN32_IE >= 0x0300
INITCOMMONCONTROLSEX iccs;
iccs.dwSize= sizeof(INITCOMMONCONTROLSEX);
iccs.dwICC= ICC_BAR_CLASSES;
InitCommonControlsEx(&iccs);
#else
InitCommonControls();
#endif
// create the main window
WNDCLASS wc;
ZeroMemory(&wc, sizeof(wc));
wc.lpfnWndProc = WndMainProc;
wc.hInstance = inst;
wc.lpszClassName = CLASSNAME;
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
if(!RegisterClass(&wc)){
#ifdef UNICODE
msg("This version cannot run on Windows 95/98/ME.");
#else
msg("RegisterClass failed");
#endif
return 2;
}
scrW= GetSystemMetrics(SM_CXSCREEN);
scrH= GetSystemMetrics(SM_CYSCREEN);
aminmax(mainLeft, 0, scrW-50);
aminmax(mainTop, 0, scrH-50);
hWin = CreateWindow(CLASSNAME, title,
WS_OVERLAPPEDWINDOW | WS_CAPTION | WS_CLIPCHILDREN,
mainLeft, mainTop, mainW, mainH, 0, 0, inst, 0);
if(!hWin){
msg("CreateWindow failed");
return 3;
}
haccel= LoadAccelerators(inst, MAKEINTRESOURCE(IDR_ACCELERATOR));
Naccel= CopyAcceleratorTable(haccel, accel, sizeA(accel));
initLang();
//create status bar
statusbar= CreateStatusWindow(WS_CHILD, 0, hWin, 1);
static int parts[]={100, 140, 210, 230, -1};
dc=GetDC(hWin);
for(i=0; i<sizeA(parts)-1; i++){
parts[i]=parts[i]*GetDeviceCaps(dc, LOGPIXELSX)/96;
}
ReleaseDC(hWin, dc);
SendMessage(statusbar, SB_SETPARTS, sizeA(parts), (LPARAM)parts);
ShowWindow(statusbar, SW_SHOW);
//create tool bar
i=sizeA(tbb);
for(TBBUTTON *u=tbb; u<endA(tbb); u++){
if(u->fsStyle==TBSTYLE_SEP) i--;
}
toolbar = CreateToolbarEx(hWin,
WS_CHILD|TBSTYLE_TOOLTIPS, 2, i,
inst, IDB_TOOLBAR, tbb, sizeA(tbb),
16, 16, 16, 15, sizeof(TBBUTTON));
GetClientRect(toolbar, &rc);
MapWindowPoints(toolbar, hWin, (POINT*)&rc, 2);
toolH= rc.bottom;
if(toolBarVisible) ShowWindow(toolbar, SW_SHOW);
langChanged();
ShowWindow(hWin, cmdShow);
initSquare(false);
UpdateWindow(hWin);
toolBitmap();
numButtons();
while(GetMessage(&mesg, NULL, 0, 0)==TRUE){
if(!TranslateAccelerator(hWin, haccel, &mesg)){
TranslateMessage(&mesg);
DispatchMessage(&mesg);
}
}
if(delreg) deleteini(HKEY_CURRENT_USER);
return 0;
}
static void test_accel1(void)
{
UINT r, n;
HACCEL hAccel;
ACCEL ac[10];
/* now create our own valid accelerator table */
n = 0;
ac[n].cmd = 1000;
ac[n].key = 'A';
ac[n++].fVirt = FVIRTKEY | FNOINVERT;
ac[n].cmd = 1001;
ac[n].key = 'B';
ac[n++].fVirt = FNOINVERT;
ac[n].cmd = 0;
ac[n].key = 0;
ac[n++].fVirt = 0;
hAccel = CreateAcceleratorTable( &ac[0], n );
ok( hAccel != NULL, "create accelerator table\n");
r = DestroyAcceleratorTable( hAccel );
ok( r, "destroy accelerator table\n");
/* now try create an invalid one */
n = 0;
ac[n].cmd = 1000;
ac[n].key = 'A';
ac[n++].fVirt = FVIRTKEY | FNOINVERT;
ac[n].cmd = 0xffff;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0xffff;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0xfff0;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0x0000;
ac[n].cmd = 0xfff0;
ac[n].key = 0xffff;
ac[n++].fVirt = (SHORT) 0x0001;
hAccel = CreateAcceleratorTable( &ac[0], n );
ok( hAccel != NULL, "create accelerator table\n");
r = CopyAcceleratorTable( hAccel, NULL, 0 );
ok( r == n, "two entries in table\n");
r = CopyAcceleratorTable( hAccel, &ac[0], r );
ok( r == n, "still should be two entries in table\n");
n=0;
ok( ac[n].cmd == 1000, "cmd 0 not preserved\n");
ok( ac[n].key == 'A', "key 0 not preserved\n");
ok( ac[n].fVirt == (FVIRTKEY | FNOINVERT), "fVirt 0 not preserved\n");
n++;
ok( ac[n].cmd == 0xffff, "cmd 1 not preserved\n");
ok( ac[n].key == 0xffff, "key 1 not preserved\n");
ok( ac[n].fVirt == 0x007f, "fVirt 1 not changed\n");
n++;
ok( ac[n].cmd == 0xfff0, "cmd 2 not preserved\n");
ok( ac[n].key == 0x00ff, "key 2 not preserved\n");
ok( ac[n].fVirt == 0x0070, "fVirt 2 not changed\n");
n++;
ok( ac[n].cmd == 0xfff0, "cmd 3 not preserved\n");
ok( ac[n].key == 0x00ff, "key 3 not preserved\n");
ok( ac[n].fVirt == 0x0000, "fVirt 3 not changed\n");
n++;
ok( ac[n].cmd == 0xfff0, "cmd 4 not preserved\n");
ok( ac[n].key == 0xffff, "key 4 not preserved\n");
ok( ac[n].fVirt == 0x0001, "fVirt 4 not changed\n");
r = DestroyAcceleratorTable( hAccel );
ok( r, "destroy accelerator table\n");
hAccel = CreateAcceleratorTable( &ac[0], 0 );
ok( !hAccel, "zero elements should fail\n");
/* these will on crash win2k
hAccel = CreateAcceleratorTable( NULL, 1 );
hAccel = CreateAcceleratorTable( &ac[0], -1 );
*/
}