static void set_progress_marquee(ProgressDialog *This)
{
HWND hProgress = GetDlgItem(This->hwnd, IDC_PROGRESS_BAR);
SetWindowLongW(hProgress, GWL_STYLE,
GetWindowLongW(hProgress, GWL_STYLE)|PBS_MARQUEE);
}
/***********************************************************************
* ProgressWindowProc
*/
static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
PROGRESS_INFO *infoPtr;
TRACE("hwnd=%x msg=%04x wparam=%x lParam=%lx\n", hwnd, message, wParam, lParam);
infoPtr = (PROGRESS_INFO *)GetWindowLongW(hwnd, 0);
if (!infoPtr && message != WM_CREATE)
return DefWindowProcW( hwnd, message, wParam, lParam );
switch(message) {
case WM_CREATE:
{
DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
dwExStyle &= ~(WS_EX_CLIENTEDGE | WS_EX_WINDOWEDGE);
dwExStyle |= WS_EX_STATICEDGE;
SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle | WS_EX_STATICEDGE);
/* Force recalculation of a non-client area */
SetWindowPos(hwnd, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
/* allocate memory for info struct */
infoPtr = (PROGRESS_INFO *)COMCTL32_Alloc (sizeof(PROGRESS_INFO));
if (!infoPtr) return -1;
SetWindowLongW (hwnd, 0, (DWORD)infoPtr);
/* initialize the info struct */
infoPtr->Self = hwnd;
infoPtr->MinVal = 0;
infoPtr->MaxVal = 100;
infoPtr->CurVal = 0;
infoPtr->Step = 10;
infoPtr->ColorBar = CLR_DEFAULT;
infoPtr->ColorBk = CLR_DEFAULT;
infoPtr->Font = 0;
TRACE("Progress Ctrl creation, hwnd=%04x\n", hwnd);
return 0;
}
case WM_DESTROY:
TRACE("Progress Ctrl destruction, hwnd=%04x\n", hwnd);
COMCTL32_Free (infoPtr);
SetWindowLongW(hwnd, 0, 0);
return 0;
case WM_ERASEBKGND:
PROGRESS_EraseBackground(infoPtr, wParam);
return TRUE;
case WM_GETFONT:
return (LRESULT)infoPtr->Font;
case WM_SETFONT:
return PROGRESS_SetFont (infoPtr, (HFONT)wParam, (BOOL)lParam);
case WM_PAINT:
return PROGRESS_Paint (infoPtr, (HDC)wParam);
case PBM_DELTAPOS:
{
INT oldVal;
if(lParam) UNKNOWN_PARAM(PBM_DELTAPOS, wParam, lParam);
oldVal = infoPtr->CurVal;
if(wParam != 0) {
BOOL bErase;
infoPtr->CurVal += (INT)wParam;
PROGRESS_CoercePos (infoPtr);
TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
bErase = (oldVal > infoPtr->CurVal);
InvalidateRect(hwnd, NULL, bErase);
}
return oldVal;
}
case PBM_SETPOS:
{
INT oldVal;
if (lParam) UNKNOWN_PARAM(PBM_SETPOS, wParam, lParam);
oldVal = infoPtr->CurVal;
if(oldVal != wParam) {
BOOL bErase;
infoPtr->CurVal = (INT)wParam;
PROGRESS_CoercePos(infoPtr);
TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
bErase = (oldVal > infoPtr->CurVal);
InvalidateRect(hwnd, NULL, bErase);
}
return oldVal;
}
case PBM_SETRANGE:
if (wParam) UNKNOWN_PARAM(PBM_SETRANGE, wParam, lParam);
return PROGRESS_SetRange (infoPtr, (int)LOWORD(lParam), (int)HIWORD(lParam));
case PBM_SETSTEP:
{
INT oldStep;
if (lParam) UNKNOWN_PARAM(PBM_SETSTEP, wParam, lParam);
oldStep = infoPtr->Step;
infoPtr->Step = (INT)wParam;
return oldStep;
}
case PBM_STEPIT:
{
INT oldVal;
if (wParam || lParam) UNKNOWN_PARAM(PBM_STEPIT, wParam, lParam);
oldVal = infoPtr->CurVal;
infoPtr->CurVal += infoPtr->Step;
if(infoPtr->CurVal > infoPtr->MaxVal)
infoPtr->CurVal = infoPtr->MinVal;
if(oldVal != infoPtr->CurVal)
{
BOOL bErase;
TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
bErase = (oldVal > infoPtr->CurVal);
InvalidateRect(hwnd, NULL, bErase);
}
return oldVal;
}
case PBM_SETRANGE32:
return PROGRESS_SetRange (infoPtr, (int)wParam, (int)lParam);
case PBM_GETRANGE:
if (lParam) {
((PPBRANGE)lParam)->iLow = infoPtr->MinVal;
((PPBRANGE)lParam)->iHigh = infoPtr->MaxVal;
}
return wParam ? infoPtr->MinVal : infoPtr->MaxVal;
case PBM_GETPOS:
if (wParam || lParam) UNKNOWN_PARAM(PBM_STEPIT, wParam, lParam);
return infoPtr->CurVal;
case PBM_SETBARCOLOR:
if (wParam) UNKNOWN_PARAM(PBM_SETBARCOLOR, wParam, lParam);
infoPtr->ColorBar = (COLORREF)lParam;
InvalidateRect(hwnd, NULL, TRUE);
return 0;
case PBM_SETBKCOLOR:
if (wParam) UNKNOWN_PARAM(PBM_SETBKCOLOR, wParam, lParam);
infoPtr->ColorBk = (COLORREF)lParam;
InvalidateRect(hwnd, NULL, TRUE);
return 0;
default:
if (message >= WM_USER)
ERR("unknown msg %04x wp=%04x lp=%08lx\n", message, wParam, lParam );
return DefWindowProcW( hwnd, message, wParam, lParam );
}
}
void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
if (window->monitor == monitor)
{
if (monitor)
{
if (monitor->window == window)
acquireMonitor(window);
}
else
{
RECT rect = { xpos, ypos, xpos + width, ypos + height };
AdjustWindowRectEx(&rect, getWindowStyle(window),
FALSE, getWindowExStyle(window));
SetWindowPos(window->win32.handle, HWND_TOP,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOCOPYBITS | SWP_NOACTIVATE | SWP_NOZORDER);
}
return;
}
if (window->monitor)
releaseMonitor(window);
_glfwInputWindowMonitorChange(window, monitor);
if (monitor)
{
GLFWvidmode mode;
DWORD style = GetWindowLongW(window->win32.handle, GWL_STYLE);
UINT flags = SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOCOPYBITS;
if (window->decorated)
{
style &= ~WS_OVERLAPPEDWINDOW;
style |= getWindowStyle(window);
SetWindowLongW(window->win32.handle, GWL_STYLE, style);
flags |= SWP_FRAMECHANGED;
}
_glfwPlatformGetVideoMode(monitor, &mode);
_glfwPlatformGetMonitorPos(monitor, &xpos, &ypos);
SetWindowPos(window->win32.handle, HWND_TOPMOST,
xpos, ypos, mode.width, mode.height,
flags);
acquireMonitor(window);
}
else
{
HWND after;
RECT rect = { xpos, ypos, xpos + width, ypos + height };
DWORD style = GetWindowLongW(window->win32.handle, GWL_STYLE);
UINT flags = SWP_NOACTIVATE | SWP_NOCOPYBITS;
if (window->decorated)
{
style &= ~WS_POPUP;
style |= getWindowStyle(window);
SetWindowLongW(window->win32.handle, GWL_STYLE, style);
flags |= SWP_FRAMECHANGED;
}
if (window->floating)
after = HWND_TOPMOST;
else
after = HWND_NOTOPMOST;
AdjustWindowRectEx(&rect, getWindowStyle(window),
FALSE, getWindowExStyle(window));
SetWindowPos(window->win32.handle, after,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
flags);
}
}
DECLSPEC_HIDDEN HRESULT WINAPI ITextHostImpl_TxGetPropertyBits(ITextHost *iface, DWORD dwMask, DWORD *pdwBits)
{
ITextHostImpl *This = impl_from_ITextHost(iface);
ME_TextEditor *editor = (ME_TextEditor *)GetWindowLongPtrW(This->hWnd, 0);
DWORD style;
DWORD dwBits = 0;
if (editor)
{
style = editor->styleFlags;
if (editor->mode & TM_RICHTEXT)
dwBits |= TXTBIT_RICHTEXT;
if (editor->bWordWrap)
dwBits |= TXTBIT_WORDWRAP;
if (style & ECO_AUTOWORDSELECTION)
dwBits |= TXTBIT_AUTOWORDSEL;
} else {
DWORD dwScrollBar;
style = GetWindowLongW(This->hWnd, GWL_STYLE);
ITextHostImpl_TxGetScrollBars(iface, &dwScrollBar);
dwBits |= TXTBIT_RICHTEXT|TXTBIT_AUTOWORDSEL;
if (!(dwScrollBar & ES_AUTOHSCROLL))
dwBits |= TXTBIT_WORDWRAP;
}
/* Bits that correspond to window styles. */
if (style & ES_MULTILINE)
dwBits |= TXTBIT_MULTILINE;
if (style & ES_READONLY)
dwBits |= TXTBIT_READONLY;
if (style & ES_PASSWORD)
dwBits |= TXTBIT_USEPASSWORD;
if (!(style & ES_NOHIDESEL))
dwBits |= TXTBIT_HIDESELECTION;
if (style & ES_SAVESEL)
dwBits |= TXTBIT_SAVESELECTION;
if (style & ES_VERTICAL)
dwBits |= TXTBIT_VERTICAL;
if (style & ES_NOOLEDRAGDROP)
dwBits |= TXTBIT_DISABLEDRAG;
dwBits |= TXTBIT_ALLOWBEEP;
/* The following bits are always FALSE because they are probably only
* needed for ITextServices_OnTxPropertyBitsChange:
* TXTBIT_VIEWINSETCHANGE
* TXTBIT_BACKSTYLECHANGE
* TXTBIT_MAXLENGTHCHANGE
* TXTBIT_CHARFORMATCHANGE
* TXTBIT_PARAFORMATCHANGE
* TXTBIT_SHOWACCELERATOR
* TXTBIT_EXTENTCHANGE
* TXTBIT_SELBARCHANGE
* TXTBIT_SCROLLBARCHANGE
* TXTBIT_CLIENTRECTCHANGE
*
* Documented by MSDN as not supported:
* TXTBIT_USECURRENTBKG
*/
*pdwBits = dwBits & dwMask;
return S_OK;
}
static LRESULT CALLBACK
EditGlyphEditWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PEDIT_GLYPH_INFO Info;
Info = (PEDIT_GLYPH_INFO) GetWindowLongW(hwnd, GWLP_USERDATA);
if(Info)
{
switch(uMsg)
{
case WM_CREATE:
return 0;
case WM_LBUTTONDOWN:
SetPixelBit(Info, GET_Y_LPARAM(lParam) / Info->lEditSpacing, GET_X_LPARAM(lParam) / Info->lEditSpacing, 1);
return 0;
case WM_RBUTTONDOWN:
SetPixelBit(Info, GET_Y_LPARAM(lParam) / Info->lEditSpacing, GET_X_LPARAM(lParam) / Info->lEditSpacing, 0);
return 0;
case WM_PAINT:
{
BOOL bBit;
HPEN hOldPen;
HPEN hPen;
PAINTSTRUCT ps;
RECT rect;
UINT i;
UINT j;
BeginPaint(hwnd, &ps);
// Draw the grid
GetClientRect(hwnd, &rect);
Info->lEditSpacing = rect.right / 8;
hPen = CreatePen( PS_SOLID, 1, RGB(128, 128, 128) );
hOldPen = SelectObject(ps.hdc, hPen);
for(i = 1; i < 8; i++)
{
MoveToEx(ps.hdc, i * Info->lEditSpacing, 0, NULL);
LineTo (ps.hdc, i * Info->lEditSpacing, rect.right);
MoveToEx(ps.hdc, 0, i * Info->lEditSpacing, NULL);
LineTo (ps.hdc, rect.right, i * Info->lEditSpacing);
}
SelectObject(ps.hdc, hOldPen);
DeleteObject(hPen);
// Draw all bits
for(i = 0; i < 8; i++)
{
for(j = 0; j < 8; j++)
{
bBit = (BOOL) (Info->CharacterBits[i] << j & 0x80);
GetBitRect(Info, i, j, &rect);
FillRect( ps.hdc, &rect, (HBRUSH) GetStockObject(bBit ? BLACK_BRUSH : WHITE_BRUSH) );
}
}
// Draw the bounding rectangle
SelectObject( ps.hdc, GetStockObject(NULL_BRUSH) );
Rectangle(ps.hdc, 0, 0, rect.right, rect.right);
EndPaint(hwnd, &ps);
return 0;
}
}
}
return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
static void AddOrUpdateHwnd(HWND hWnd, WCHAR *wszTitle, HICON hIcon, BOOL bHung)
{
LPAPPLICATION_PAGE_LIST_ITEM pAPLI = NULL;
HIMAGELIST hImageListLarge;
HIMAGELIST hImageListSmall;
LV_ITEMW item;
int i, count;
BOOL bAlreadyInList = FALSE;
BOOL bItemRemoved = FALSE;
memset(&item, 0, sizeof(LV_ITEMW));
/* Get the image lists */
hImageListLarge = (HIMAGELIST)SendMessageW(hApplicationPageListCtrl, LVM_GETIMAGELIST, LVSIL_NORMAL, 0);
hImageListSmall = (HIMAGELIST)SendMessageW(hApplicationPageListCtrl, LVM_GETIMAGELIST, LVSIL_SMALL, 0);
count = SendMessageW(hApplicationPageListCtrl, LVM_GETITEMCOUNT, 0, 0);
/* Check to see if it's already in our list */
for (i=0; i<count; i++)
{
memset(&item, 0, sizeof(LV_ITEMW));
item.mask = LVIF_IMAGE|LVIF_PARAM;
item.iItem = i;
SendMessageW(hApplicationPageListCtrl, LVM_GETITEMW, 0, (LPARAM) &item);
pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
if (pAPLI->hWnd == hWnd)
{
bAlreadyInList = TRUE;
break;
}
}
/* If it is already in the list then update it if necessary */
if (bAlreadyInList)
{
/* Check to see if anything needs updating */
if ((pAPLI->hIcon != hIcon) ||
(strcmpW(pAPLI->wszTitle, wszTitle) != 0) ||
(pAPLI->bHung != bHung))
{
/* Update the structure */
pAPLI->hIcon = hIcon;
pAPLI->bHung = bHung;
strcpyW(pAPLI->wszTitle, wszTitle);
/* Update the image list */
ImageList_ReplaceIcon(hImageListLarge, item.iItem, hIcon);
ImageList_ReplaceIcon(hImageListSmall, item.iItem, hIcon);
/* Update the list view */
count = SendMessageW(hApplicationPageListCtrl, LVM_GETITEMCOUNT, 0, 0);
SendMessageW(hApplicationPageListCtrl, LVM_REDRAWITEMS, 0, count);
/* UpdateWindow(hApplicationPageListCtrl); */
InvalidateRect(hApplicationPageListCtrl, NULL, 0);
}
}
/* It is not already in the list so add it */
else
{
pAPLI = HeapAlloc(GetProcessHeap(), 0, sizeof(APPLICATION_PAGE_LIST_ITEM));
pAPLI->hWnd = hWnd;
pAPLI->hIcon = hIcon;
pAPLI->bHung = bHung;
strcpyW(pAPLI->wszTitle, wszTitle);
/* Add the item to the list */
memset(&item, 0, sizeof(LV_ITEMW));
item.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
ImageList_AddIcon(hImageListLarge, hIcon);
item.iImage = ImageList_AddIcon(hImageListSmall, hIcon);
item.pszText = LPSTR_TEXTCALLBACKW;
item.iItem = SendMessageW(hApplicationPageListCtrl, LVM_GETITEMCOUNT, 0, 0);
item.lParam = (LPARAM)pAPLI;
SendMessageW(hApplicationPageListCtrl, LVM_INSERTITEMW, 0, (LPARAM) &item);
}
/* Check to see if we need to remove any items from the list */
for (i=SendMessageW(hApplicationPageListCtrl, LVM_GETITEMCOUNT, 0, 0)-1; i>=0; i--)
{
memset(&item, 0, sizeof(LV_ITEMW));
item.mask = LVIF_IMAGE|LVIF_PARAM;
item.iItem = i;
SendMessageW(hApplicationPageListCtrl, LVM_GETITEMW, 0, (LPARAM) &item);
pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
if (!IsWindow(pAPLI->hWnd)||
(strlenW(pAPLI->wszTitle) <= 0) ||
!IsWindowVisible(pAPLI->hWnd) ||
(GetParent(pAPLI->hWnd) != NULL) ||
(GetWindow(pAPLI->hWnd, GW_OWNER) != NULL) ||
(GetWindowLongW(hWnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW))
{
ImageList_Remove(hImageListLarge, item.iItem);
ImageList_Remove(hImageListSmall, item.iItem);
SendMessageW(hApplicationPageListCtrl, LVM_DELETEITEM, item.iItem, 0);
HeapFree(GetProcessHeap(), 0, pAPLI);
bItemRemoved = TRUE;
}
}
/*
* If an item was removed from the list then
* we need to resync all the items with the
* image list
*/
if (bItemRemoved)
{
count = SendMessageW(hApplicationPageListCtrl, LVM_GETITEMCOUNT, 0, 0);
for (i=0; i<count; i++)
{
memset(&item, 0, sizeof(LV_ITEMW));
item.mask = LVIF_IMAGE;
item.iItem = i;
item.iImage = i;
SendMessageW(hApplicationPageListCtrl, LVM_SETITEMW, 0, (LPARAM) &item);
}
}
ApplicationPageUpdate();
}
/***************************************************************************
* MCIAVI_mciPlay [internal]
*/
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD dwRet;
DWORD dwFromFrame, dwToFrame;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN|MCI_MCIAVI_PLAY_FULLBY2))
FIXME("Unsupported flag %08x\n", dwFlags);
EnterCriticalSection(&wma->cs);
if (!wma->hFile)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_FILE_NOT_FOUND;
}
if (!wma->hWndPaint)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_NO_WINDOW;
}
dwFromFrame = wma->dwCurrVideoFrame;
dwToFrame = wma->dwPlayableVideoFrames - 1;
if (dwFlags & MCI_FROM) {
dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
}
if (dwFlags & MCI_TO) {
dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
}
if (dwToFrame >= wma->dwPlayableVideoFrames)
dwToFrame = wma->dwPlayableVideoFrames - 1;
TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
wma->dwCurrVideoFrame = dwFromFrame;
wma->dwToVideoFrame = dwToFrame;
LeaveCriticalSection(&wma->cs);
if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
ShowWindow(wma->hWndPaint, SW_SHOWNA);
EnterCriticalSection(&wma->cs);
/* if already playing exit */
if (wma->dwStatus == MCI_MODE_PLAY)
{
LeaveCriticalSection(&wma->cs);
return 0;
}
wma->dwStatus = MCI_MODE_PLAY;
LeaveCriticalSection(&wma->cs);
if (dwFlags & MCI_WAIT)
return MCIAVI_player(wma, dwFlags, lpParms);
dwRet = MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
if (dwRet) {
EnterCriticalSection(&wma->cs);
wma->dwStatus = MCI_MODE_STOP;
LeaveCriticalSection(&wma->cs);
}
return dwRet;
}
static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
{
static const WCHAR dotW[] = { '.', 0 };
RECT rect, rcPart;
COLORREF bgCol, fgCol;
HTHEME theme;
int i, state = ETS_NORMAL;
TRACE("\n");
GetClientRect (infoPtr->Self, &rect);
theme = OpenThemeData(infoPtr->Self, WC_EDITW);
if (theme) {
DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
if (!infoPtr->Enabled)
state = ETS_DISABLED;
else if (dwStyle & ES_READONLY)
state = ETS_READONLY;
else if (GetFocus() == infoPtr->Self)
state = ETS_FOCUSED;
GetThemeColor(theme, EP_EDITTEXT, state, TMT_FILLCOLOR, &bgCol);
GetThemeColor(theme, EP_EDITTEXT, state, TMT_TEXTCOLOR, &fgCol);
if (IsThemeBackgroundPartiallyTransparent (theme, EP_EDITTEXT, state))
DrawThemeParentBackground(infoPtr->Self, hdc, &rect);
DrawThemeBackground (theme, hdc, EP_EDITTEXT, state, &rect, 0);
} else {
if (infoPtr->Enabled) {
bgCol = comctl32_color.clrWindow;
fgCol = comctl32_color.clrWindowText;
} else {
bgCol = comctl32_color.clr3dFace;
fgCol = comctl32_color.clrGrayText;
}
FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
}
SetBkColor (hdc, bgCol);
SetTextColor(hdc, fgCol);
for (i = 0; i < 3; i++) {
GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
rect.left = rcPart.right;
GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
rect.right = rcPart.left;
if (theme)
DrawThemeText(theme, hdc, EP_EDITTEXT, state, dotW, 1, DT_SINGLELINE | DT_CENTER | DT_BOTTOM, 0, &rect);
else
DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
}
if (theme)
CloseThemeData(theme);
return 0;
}
/***************************************************************************
* MCIAVI_mciPlay [internal]
*/
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD frameTime;
DWORD dwRet;
LPWAVEHDR waveHdr = NULL;
unsigned i, nHdr = 0;
DWORD dwFromFrame, dwToFrame;
DWORD numEvents = 1;
HANDLE events[2];
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (!wma->hFile)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_FILE_NOT_FOUND;
}
if (!wma->hWndPaint)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_NO_WINDOW;
}
LeaveCriticalSection(&wma->cs);
if (!(dwFlags & MCI_WAIT))
return MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
ShowWindow(wma->hWndPaint, SW_SHOWNA);
EnterCriticalSection(&wma->cs);
dwFromFrame = wma->dwCurrVideoFrame;
dwToFrame = wma->dwPlayableVideoFrames - 1;
if (lpParms && (dwFlags & MCI_FROM)) {
dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
}
if (lpParms && (dwFlags & MCI_TO)) {
dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
}
if (dwToFrame >= wma->dwPlayableVideoFrames)
dwToFrame = wma->dwPlayableVideoFrames - 1;
TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
wma->dwCurrVideoFrame = dwFromFrame;
wma->dwToVideoFrame = dwToFrame;
/* if already playing exit */
if (wma->dwStatus == MCI_MODE_PLAY)
{
LeaveCriticalSection(&wma->cs);
SetEvent(wma->ack_event);
return 0;
}
if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
{
dwRet = 0;
SetEvent(wma->ack_event);
goto mci_play_done;
}
wma->dwStatus = MCI_MODE_PLAY;
/* signal the state change */
SetEvent(wma->ack_event);
if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
FIXME("Unsupported flag %08x\n", dwFlags);
/* time is in microseconds, we should convert it to milliseconds */
frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
events[0] = wma->hStopEvent;
if (wma->lpWaveFormat) {
if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
{
/* can't play audio */
HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
wma->lpWaveFormat = NULL;
}
else
{
/* fill the queue with as many wave headers as possible */
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
events[1] = wma->hEvent;
numEvents = 2;
}
}
while (wma->dwStatus == MCI_MODE_PLAY)
{
HDC hDC;
DWORD tc, delta;
DWORD ret;
tc = GetTickCount();
hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
if (hDC)
{
MCIAVI_PaintFrame(wma, hDC);
ReleaseDC(wma->hWndPaint, hDC);
}
if (wma->lpWaveFormat)
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
delta = GetTickCount() - tc;
if (delta < frameTime)
delta = frameTime - delta;
else
delta = 0;
LeaveCriticalSection(&wma->cs);
ret = WaitForMultipleObjects(numEvents, events, FALSE, delta);
EnterCriticalSection(&wma->cs);
if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
if (wma->dwCurrVideoFrame < dwToFrame)
wma->dwCurrVideoFrame++;
else
break;
}
if (wma->lpWaveFormat) {
while (wma->dwEventCount != nHdr - 1)
{
LeaveCriticalSection(&wma->cs);
Sleep(100);
EnterCriticalSection(&wma->cs);
}
/* just to get rid of some race conditions between play, stop and pause */
LeaveCriticalSection(&wma->cs);
waveOutReset(wma->hWave);
EnterCriticalSection(&wma->cs);
for (i = 0; i < nHdr; i++)
waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
}
dwRet = 0;
if (wma->lpWaveFormat) {
HeapFree(GetProcessHeap(), 0, waveHdr);
if (wma->hWave) {
LeaveCriticalSection(&wma->cs);
waveOutClose(wma->hWave);
EnterCriticalSection(&wma->cs);
wma->hWave = 0;
}
CloseHandle(wma->hEvent);
}
mci_play_done:
wma->dwStatus = MCI_MODE_STOP;
if (lpParms && (dwFlags & MCI_NOTIFY)) {
TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return dwRet;
}
static void CB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
{
static const int cb_states[3][5] =
{
{ CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDHOT, CBS_UNCHECKEDPRESSED, CBS_UNCHECKEDNORMAL },
{ CBS_CHECKEDNORMAL, CBS_CHECKEDDISABLED, CBS_CHECKEDHOT, CBS_CHECKEDPRESSED, CBS_CHECKEDNORMAL },
{ CBS_MIXEDNORMAL, CBS_MIXEDDISABLED, CBS_MIXEDHOT, CBS_MIXEDPRESSED, CBS_MIXEDNORMAL }
};
static const int rb_states[2][5] =
{
{ RBS_UNCHECKEDNORMAL, RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDHOT, RBS_UNCHECKEDPRESSED, RBS_UNCHECKEDNORMAL },
{ RBS_CHECKEDNORMAL, RBS_CHECKEDDISABLED, RBS_CHECKEDHOT, RBS_CHECKEDPRESSED, RBS_CHECKEDNORMAL }
};
static const int cb_size = 13;
RECT bgRect, textRect;
HFONT font, hPrevFont = NULL;
LRESULT checkState = SendMessageW(hwnd, BM_GETCHECK, 0, 0);
DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
int part = ((dwStyle & BUTTON_TYPE) == BS_RADIOBUTTON) || ((dwStyle & BUTTON_TYPE) == BS_AUTORADIOBUTTON)
? BP_RADIOBUTTON
: BP_CHECKBOX;
int state = (part == BP_CHECKBOX)
? cb_states[ checkState ][ drawState ]
: rb_states[ checkState ][ drawState ];
WCHAR *text = get_button_text(hwnd);
LOGFONTW lf;
BOOL created_font = FALSE;
HRESULT hr = GetThemeFont(theme, hDC, part, state, TMT_FONT, &lf);
if (SUCCEEDED(hr)) {
font = CreateFontIndirectW(&lf);
if (!font)
TRACE("Failed to create font\n");
else {
TRACE("font = %s\n", debugstr_w(lf.lfFaceName));
hPrevFont = SelectObject(hDC, font);
created_font = TRUE;
}
} else
font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect);
if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */
bgRect.top = bgRect.top + (textRect.bottom - textRect.top - cb_size) / 2;
/* adjust for the check/radio marker */
bgRect.bottom = bgRect.top + cb_size;
bgRect.right = bgRect.left + cb_size;
textRect.left = bgRect.right + 6;
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
if (text)
{
DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect);
if (focused)
{
RECT focusRect;
focusRect = textRect;
DrawTextW(hDC, text, lstrlenW(text), &focusRect, dtFlags | DT_CALCRECT);
if (focusRect.right < textRect.right) focusRect.right++;
focusRect.bottom = textRect.bottom;
DrawFocusRect( hDC, &focusRect );
}
HeapFree(GetProcessHeap(), 0, text);
}
if (created_font) DeleteObject(font);
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
LRESULT
DefWndNCLButtonDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
PWND Wnd = ValidateHwnd(hWnd);
switch (wParam)
{
case HTCAPTION:
{
HWND hTopWnd = hWnd, parent;
while(1)
{
if ((GetWindowLongW( hTopWnd, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) != WS_CHILD)
break;
parent = GetAncestor( hTopWnd, GA_PARENT );
if (!parent || parent == GetDesktopWindow()) break;
hTopWnd = parent;
}
if ( NtUserCallHwndLock(hTopWnd, HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOWMOUSE) ||
GetActiveWindow() == hTopWnd)
{
SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam);
}
break;
}
case HTSYSMENU:
{
LONG style = GetWindowLongPtrW( hWnd, GWL_STYLE );
if (style & WS_SYSMENU)
{
if( Wnd && !(style & WS_MINIMIZE) )
{
RECT rect;
HDC hDC = GetWindowDC(hWnd);
UserGetInsideRectNC(Wnd, &rect);
UserDrawSysMenuButton(hWnd, hDC, &rect, TRUE);
ReleaseDC( hWnd, hDC );
}
SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam);
}
break;
}
case HTMENU:
{
SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTMENU, lParam);
break;
}
case HTHSCROLL:
{
SendMessageW(hWnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam);
break;
}
case HTVSCROLL:
{
SendMessageW(hWnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam);
break;
}
case HTMINBUTTON:
case HTMAXBUTTON:
case HTCLOSE:
{
DefWndDoButton(hWnd, wParam);
break;
}
case HTLEFT:
case HTRIGHT:
case HTTOP:
case HTBOTTOM:
case HTTOPLEFT:
case HTTOPRIGHT:
case HTBOTTOMLEFT:
case HTBOTTOMRIGHT:
{
/* Old comment:
* "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
* This was previously done by setting wParam=SC_SIZE + wParam - 2
*/
/* But that is not what WinNT does. Instead it sends this. This
* is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
* SC_MOUSEMENU into wParam.
*/
SendMessageW(hWnd, WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT - WMSZ_LEFT), lParam);
break;
}
case HTBORDER:
break;
}
return(0);
}
static void test_AtlAxAttachControl(void)
{
HWND hwnd;
HRESULT hr;
IUnknown *control, *container;
LONG val;
hr = AtlAxAttachControl(NULL, NULL, NULL);
ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
container = (IUnknown *)0xdeadbeef;
hr = AtlAxAttachControl(NULL, NULL, &container);
ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
ok(container == (IUnknown *)0xdeadbeef,
"Expected the output container pointer to be untouched, got %p\n", container);
hwnd = create_container_window();
hr = AtlAxAttachControl(NULL, hwnd, NULL);
ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
DestroyWindow(hwnd);
hwnd = create_container_window();
container = (IUnknown *)0xdeadbeef;
hr = AtlAxAttachControl(NULL, hwnd, &container);
ok(hr == E_INVALIDARG, "Expected AtlAxAttachControl to return E_INVALIDARG, got 0x%08x\n", hr);
ok(container == (IUnknown *)0xdeadbeef, "returned %p\n", container);
DestroyWindow(hwnd);
hr = CoCreateInstance(&CLSID_WebBrowser, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
&IID_IOleObject, (void **)&control);
ok(hr == S_OK, "Expected CoCreateInstance to return S_OK, got 0x%08x\n", hr);
if (FAILED(hr))
{
skip("Couldn't obtain a test IOleObject instance\n");
return;
}
hr = AtlAxAttachControl(control, NULL, NULL);
ok(hr == S_FALSE, "Expected AtlAxAttachControl to return S_FALSE, got 0x%08x\n", hr);
container = NULL;
hr = AtlAxAttachControl(control, NULL, &container);
ok(hr == S_FALSE, "Expected AtlAxAttachControl to return S_FALSE, got 0x%08x\n", hr);
ok(container != NULL, "got %p\n", container);
IUnknown_Release(container);
hwnd = create_container_window();
SetWindowLongW(hwnd, GWLP_USERDATA, 0xdeadbeef);
hr = AtlAxAttachControl(control, hwnd, NULL);
ok(hr == S_OK, "Expected AtlAxAttachControl to return S_OK, got 0x%08x\n", hr);
val = GetWindowLongW(hwnd, GWLP_USERDATA);
ok(val == 0xdeadbeef, "returned %08x\n", val);
DestroyWindow(hwnd);
hwnd = create_container_window();
SetWindowLongW(hwnd, GWLP_USERDATA, 0xdeadbeef);
container = NULL;
hr = AtlAxAttachControl(control, hwnd, &container);
ok(hr == S_OK, "Expected AtlAxAttachControl to return S_OK, got 0x%08x\n", hr);
ok(container != NULL, "Expected not NULL!\n");
IUnknown_Release(container);
val = GetWindowLongW(hwnd, GWLP_USERDATA);
ok(val == 0xdeadbeef, "Expected unchanged, returned %08x\n", val);
DestroyWindow(hwnd);
IUnknown_Release(control);
}
/***********************************************************************
* PROGRESS_Draw
* Draws the progress bar.
*/
static LRESULT PROGRESS_Draw (PROGRESS_INFO *infoPtr, HDC hdc)
{
HBRUSH hbrBar;
int rightBar, rightMost, ledWidth;
RECT rect;
DWORD dwStyle;
TRACE("(infoPtr=%p, hdc=%x)\n", infoPtr, hdc);
/* get the required bar brush */
if (infoPtr->ColorBar == CLR_DEFAULT)
hbrBar = GetSysColorBrush(COLOR_HIGHLIGHT);
else
hbrBar = CreateSolidBrush (infoPtr->ColorBar);
/* get client rectangle */
GetClientRect (infoPtr->Self, &rect);
InflateRect(&rect, -1, -1);
/* get the window style */
dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
/* compute extent of progress bar */
if (dwStyle & PBS_VERTICAL) {
rightBar = rect.bottom -
MulDiv (infoPtr->CurVal - infoPtr->MinVal,
rect.bottom - rect.top,
infoPtr->MaxVal - infoPtr->MinVal);
ledWidth = MulDiv (rect.right - rect.left, 2, 3);
rightMost = rect.top;
} else {
rightBar = rect.left +
MulDiv (infoPtr->CurVal - infoPtr->MinVal,
rect.right - rect.left,
infoPtr->MaxVal - infoPtr->MinVal);
ledWidth = MulDiv (rect.bottom - rect.top, 2, 3);
rightMost = rect.right;
}
/* now draw the bar */
if (dwStyle & PBS_SMOOTH) {
if (dwStyle & PBS_VERTICAL)
rect.top = rightBar;
else
rect.right = rightBar;
FillRect(hdc, &rect, hbrBar);
} else {
if (dwStyle & PBS_VERTICAL) {
while(rect.bottom > rightBar) {
rect.top = rect.bottom - ledWidth;
if (rect.top < rightMost)
rect.top = rightMost;
FillRect(hdc, &rect, hbrBar);
rect.bottom = rect.top - LED_GAP;
}
} else {
while(rect.left < rightBar) {
rect.right = rect.left + ledWidth;
if (rect.right > rightMost)
rect.right = rightMost;
FillRect(hdc, &rect, hbrBar);
rect.left = rect.right + LED_GAP;
}
}
}
/* delete bar brush */
if (infoPtr->ColorBar != CLR_DEFAULT)
DeleteObject (hbrBar);
return 0;
}
/**********************************************************************
* Push Button Functions
*/
static void PB_Paint( HWND hwnd, HDC hDC, UINT action )
{
RECT rc, r;
UINT dtFlags, uState;
HPEN hOldPen;
HBRUSH hOldBrush;
INT oldBkMode;
COLORREF oldTxtColor;
HFONT hFont;
LONG state = get_button_state( hwnd );
LONG style = GetWindowLongW( hwnd, GWL_STYLE );
BOOL pushedState = (state & BST_PUSHED);
HWND parent;
HRGN hrgn;
GetClientRect( hwnd, &rc );
/* Send WM_CTLCOLOR to allow changing the font (the colors are fixed) */
if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
parent = GetParent(hwnd);
if (!parent) parent = hwnd;
SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
hrgn = set_control_clipping( hDC, &rc );
hOldPen = SelectObject(hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME));
hOldBrush = SelectObject(hDC,GetSysColorBrush(COLOR_BTNFACE));
oldBkMode = SetBkMode(hDC, TRANSPARENT);
if (get_button_type(style) == BS_DEFPUSHBUTTON)
{
if (action != ODA_FOCUS)
Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
InflateRect( &rc, -1, -1 );
}
/* completely skip the drawing if only focus has changed */
if (action == ODA_FOCUS) goto draw_focus;
uState = DFCS_BUTTONPUSH;
if (style & BS_FLAT)
uState |= DFCS_MONO;
else if (pushedState)
{
if (get_button_type(style) == BS_DEFPUSHBUTTON )
uState |= DFCS_FLAT;
else
uState |= DFCS_PUSHED;
}
if (state & (BST_CHECKED | BST_INDETERMINATE))
uState |= DFCS_CHECKED;
DrawFrameControl( hDC, &rc, DFC_BUTTON, uState );
/* draw button label */
r = rc;
dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &r);
if (dtFlags == (UINT)-1L)
goto cleanup;
if (pushedState)
OffsetRect(&r, 1, 1);
oldTxtColor = SetTextColor( hDC, GetSysColor(COLOR_BTNTEXT) );
BUTTON_DrawLabel(hwnd, hDC, dtFlags, &r);
SetTextColor( hDC, oldTxtColor );
draw_focus:
if (action == ODA_FOCUS || (state & BST_FOCUS))
{
InflateRect( &rc, -2, -2 );
DrawFocusRect( hDC, &rc );
}
cleanup:
SelectObject( hDC, hOldPen );
SelectObject( hDC, hOldBrush );
SetBkMode(hDC, oldBkMode);
SelectClipRgn( hDC, hrgn );
if (hrgn) DeleteObject( hrgn );
}
// Here you can process the Npp Messages
// I will make the messages accessible little by little, according to the need of plugin development.
// Please let me know if you need to access to some messages :
// http://sourceforge.net/forum/forum.php?forum_id=482781
//
extern "C" __declspec(dllexport) LRESULT messageProc(UINT Message, WPARAM wParam, LPARAM lParam)
{
switch (Message){
case WM_CREATE:
hInst = GetModuleHandle(NULL);
//Create PopupMenu Dynamically
HGLOBAL hgbl;
LPDLGTEMPLATE lpdt;
LPWORD lpw;
hwndEdit = nppData._scintillaMainHandle;
hgbl = GlobalAlloc(GMEM_ZEROINIT, 1024);
lpdt = (LPDLGTEMPLATE)GlobalLock(hgbl);
// Define a dialog box.
lpdt->style = WS_POPUP | WS_BORDER ;
lpdt->cdit = 0; // Number of controls = 0
lpdt->x = 10; lpdt->y = 10;
lpdt->cx = 100; lpdt->cy = 100;
lpw = (LPWORD)(lpdt + 1);
*lpw++ = 0; // No menu
*lpw++ = 0; // Predefined dialog box class (by default)
GlobalUnlock(hgbl);
hwndPopupMenu = CreateDialogIndirect(hInst,
(LPDLGTEMPLATE)hgbl,
nppData._nppHandle,
(DLGPROC)PopupMenuProc);
GlobalFree(hgbl);
//End PopupMenuDialog
hfontCurrent = MyCreateFont(nppData._nppHandle, 10,L"Zawgyi-One");
EditProc =(WNDPROC)GetWindowLongW(nppData._scintillaMainHandle, GWL_WNDPROC);
SetWindowLong(nppData._scintillaMainHandle, GWL_WNDPROC, (long)SubEditProc);
hMenu = GetMenu(nppData._nppHandle);
CheckMenuItem(hMenu,funcItem[1]._cmdID,MF_BYCOMMAND|MF_CHECKED);//Check Disable Menu
break;
case WM_MOVE:
//move menu along with the main window
if(IsWindowVisible(hwndPopupMenu))
{
RECT rctWinMain;
GetWindowRect(hwndEdit,&rctWinMain);
int height=(burmese.menuLength>MROW?10:burmese.menuLength)*MHEIGHT+MHEIGHT+10;
int width=((burmese.menuLength/MROW)+1)*MWIDTH;
MoveWindow (hwndPopupMenu,
rctWinMain.left + pointEditCursor.x + 10,
rctWinMain.top + pointEditCursor.y + 20 ,
width,
height,
TRUE) ;
}
break;
}
return true;
}
static void CB_Paint( HWND hwnd, HDC hDC, UINT action )
{
RECT rbox, rtext, client;
HBRUSH hBrush;
int delta;
UINT dtFlags;
HFONT hFont;
LONG state = get_button_state( hwnd );
LONG style = GetWindowLongW( hwnd, GWL_STYLE );
HWND parent;
HRGN hrgn;
if (style & BS_PUSHLIKE)
{
PB_Paint( hwnd, hDC, action );
return;
}
GetClientRect(hwnd, &client);
rbox = rtext = client;
if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
parent = GetParent(hwnd);
if (!parent) parent = hwnd;
hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd);
if (!hBrush) /* did the app forget to call defwindowproc ? */
hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd );
hrgn = set_control_clipping( hDC, &client );
if (style & BS_LEFTTEXT)
{
/* magic +4 is what CTL3D expects */
rtext.right -= checkBoxWidth + 4;
rbox.left = rbox.right - checkBoxWidth;
}
else
{
rtext.left += checkBoxWidth + 4;
rbox.right = checkBoxWidth;
}
/* Since WM_ERASEBKGND does nothing, first prepare background */
if (action == ODA_SELECT) FillRect( hDC, &rbox, hBrush );
if (action == ODA_DRAWENTIRE) FillRect( hDC, &client, hBrush );
/* Draw label */
client = rtext;
dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &rtext);
/* Only adjust rbox when rtext is valid */
if (dtFlags != (UINT)-1L)
{
rbox.top = rtext.top;
rbox.bottom = rtext.bottom;
}
/* Draw the check-box bitmap */
if (action == ODA_DRAWENTIRE || action == ODA_SELECT)
{
UINT flags;
if ((get_button_type(style) == BS_RADIOBUTTON) ||
(get_button_type(style) == BS_AUTORADIOBUTTON)) flags = DFCS_BUTTONRADIO;
else if (state & BST_INDETERMINATE) flags = DFCS_BUTTON3STATE;
else flags = DFCS_BUTTONCHECK;
if (state & (BST_CHECKED | BST_INDETERMINATE)) flags |= DFCS_CHECKED;
if (state & BST_PUSHED) flags |= DFCS_PUSHED;
if (style & WS_DISABLED) flags |= DFCS_INACTIVE;
/* rbox must have the correct height */
delta = rbox.bottom - rbox.top - checkBoxHeight;
if (style & BS_TOP) {
if (delta > 0) {
rbox.bottom = rbox.top + checkBoxHeight;
} else {
rbox.top -= -delta/2 + 1;
rbox.bottom = rbox.top + checkBoxHeight;
}
} else if (style & BS_BOTTOM) {
if (delta > 0) {
rbox.top = rbox.bottom - checkBoxHeight;
} else {
rbox.bottom += -delta/2 + 1;
rbox.top = rbox.bottom - checkBoxHeight;
}
} else { /* Default */
if (delta > 0) {
int ofs = (delta / 2);
rbox.bottom -= ofs + 1;
rbox.top = rbox.bottom - checkBoxHeight;
} else if (delta < 0) {
int ofs = (-delta / 2);
rbox.top -= ofs + 1;
rbox.bottom = rbox.top + checkBoxHeight;
}
}
DrawFrameControl( hDC, &rbox, DFC_BUTTON, flags );
}
if (dtFlags == (UINT)-1L) /* Noting to draw */
return;
if (action == ODA_DRAWENTIRE)
BUTTON_DrawLabel(hwnd, hDC, dtFlags, &rtext);
/* ... and focus */
if (action == ODA_FOCUS || (state & BST_FOCUS))
{
rtext.left--;
rtext.right++;
IntersectRect(&rtext, &rtext, &client);
DrawFocusRect( hDC, &rtext );
}
SelectClipRgn( hDC, hrgn );
if (hrgn) DeleteObject( hrgn );
}
bool D3DGLSwapChain::init(const D3DPRESENT_PARAMETERS *params, HWND window, bool isauto)
{
// Params are already sanitized.
mParams = *params;
mWindow = window;
mIsAuto = isauto;
mDevCtx = GetDC(mWindow);
if(!mDevCtx)
{
ERR("Failed to get DC for windows, error: 0x%lx\n", GetLastError());
return false;
}
if(!mParams.Windowed)
{
LONG orig_style = GetWindowLongW(mWindow, GWL_STYLE);
LONG orig_exstyle = GetWindowLongW(mWindow, GWL_EXSTYLE);
LONG new_style = orig_style | WS_POPUP | WS_SYSMENU;
new_style &= ~(WS_CAPTION | WS_THICKFRAME);
LONG new_exstyle = orig_exstyle & ~(WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE);
SetWindowLongW(mWindow, GWL_STYLE, new_style);
SetWindowLongW(mWindow, GWL_EXSTYLE, new_exstyle);
SetWindowPos(mWindow, HWND_TOPMOST, 0, 0, mParams.BackBufferWidth, mParams.BackBufferHeight,
SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOACTIVATE);
}
else
{
SetWindowPos(mWindow, HWND_TOPMOST, 0, 0, mParams.BackBufferWidth, mParams.BackBufferHeight,
SWP_NOMOVE | SWP_NOACTIVATE);
}
D3DSURFACE_DESC desc;
desc.Format = mParams.BackBufferFormat;
desc.Type = D3DRTYPE_SURFACE;
desc.Usage = D3DUSAGE_RENDERTARGET;
desc.Pool = D3DPOOL_DEFAULT;
desc.MultiSampleType = mParams.MultiSampleType;
desc.MultiSampleQuality = mParams.MultiSampleQuality;
desc.Width = mParams.BackBufferWidth;
desc.Height = mParams.BackBufferHeight;
// Enforce at least one backbuffer
mParams.BackBufferCount = std::max(mParams.BackBufferCount, 1u);
for(UINT i = 0;i < mParams.BackBufferCount;++i)
{
mBackbuffers.push_back(new D3DGLRenderTarget(mParent));
if(!mBackbuffers.back()->init(&desc, true))
return false;
}
int interval = -1;
switch(mParams.PresentationInterval)
{
case D3DPRESENT_INTERVAL_DEFAULT:
interval = -1;
break;
case D3DPRESENT_INTERVAL_IMMEDIATE:
interval = 0;
break;
case D3DPRESENT_INTERVAL_ONE:
interval = 1;
break;
case D3DPRESENT_INTERVAL_TWO:
interval = 2;
break;
case D3DPRESENT_INTERVAL_THREE:
interval = 3;
break;
case D3DPRESENT_INTERVAL_FOUR:
interval = 4;
break;
default:
FIXME("Unknown swap interval: 0x%x\n", mParams.PresentationInterval);
break;
}
if(interval >= 0)
mParent->getQueue().send<SetSwapIntervalCmd>(interval);
return true;
}
void OnTopPlugin::setState()
{
QWidget *main = getMainWindow();
if (main){
#ifdef WIN32
HWND hState = HWND_NOTOPMOST;
if (getOnTop()) hState = HWND_TOPMOST;
SetWindowPos(main->winId(), hState, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
if (IsWindowUnicode(main->winId())){
if (getInTask()){
SetWindowLongW(main->winId(), GWL_EXSTYLE,
(GetWindowLongW(main->winId(), GWL_EXSTYLE) | WS_EX_APPWINDOW) & (~WS_EX_TOOLWINDOW));
}else{
DWORD exStyle = GetWindowLongW(main->winId(), GWL_EXSTYLE);
if ((exStyle & WS_EX_TOOLWINDOW) == 0){
SetWindowLongW(main->winId(), GWL_EXSTYLE, (exStyle & ~WS_EX_APPWINDOW) | WS_EX_TOOLWINDOW);
QSize s = main->size();
main->resize(s.width() + 1, s.height());
main->resize(s.width(), s.height());
}
}
}else{
if (getInTask()){
SetWindowLongA(main->winId(), GWL_EXSTYLE,
(GetWindowLongA(main->winId(), GWL_EXSTYLE) | WS_EX_APPWINDOW) & (~WS_EX_TOOLWINDOW));
}else{
DWORD exStyle = GetWindowLongA(main->winId(), GWL_EXSTYLE);
if ((exStyle & WS_EX_TOOLWINDOW) == 0){
SetWindowLongA(main->winId(), GWL_EXSTYLE, (exStyle & ~WS_EX_APPWINDOW) | WS_EX_TOOLWINDOW);
QSize s = main->size();
main->resize(s.width() + 1, s.height());
main->resize(s.width(), s.height());
}
}
}
#else
#ifdef USE_KDE
if (getOnTop()){
KWin::setState(main->winId(), NET::StaysOnTop);
}else{
KWin::clearState(main->winId(), NET::StaysOnTop);
}
if (getInTask()){
KWin::clearState(main->winId(), NET::SkipTaskbar);
}else{
KWin::setState(main->winId(), NET::SkipTaskbar);
}
#endif
#endif
}
QWidgetList *list = QApplication::topLevelWidgets();
QWidgetListIt it(*list);
QWidget *w;
while ((w = it.current()) != NULL){
++it;
if (w->inherits("Container")){
#ifdef WIN32
HWND hState = HWND_NOTOPMOST;
if (getContainerOnTop()) hState = HWND_TOPMOST;
SetWindowPos(w->winId(), hState, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
#else
#ifdef USE_KDE
if (getContainerOnTop()){
KWin::setState(w->winId(), NET::StaysOnTop);
}else{
KWin::clearState(w->winId(), NET::StaysOnTop);
}
#endif
#endif
}
}
delete list;
}
void *OnTopPlugin::processEvent(Event *e)
{
if (e->type() == EventInit)
setState();
if (e->type() == EventCommandExec){
CommandDef *cmd = (CommandDef*)(e->param());
if (cmd->id == CmdOnTop){
setOnTop(!getOnTop());
setState();
return cmd;
}
}
if (e->type() == EventCheckState){
CommandDef *cmd = (CommandDef*)(e->param());
if (cmd->id == CmdOnTop){
getState();
cmd->flags &= ~COMMAND_CHECKED;
if (getOnTop())
cmd->flags |= COMMAND_CHECKED;
return cmd;
}
}
if (e->type() == EventOnTop){
QWidget *main = getMainWindow();
if (main == NULL) return NULL;
#ifdef WIN32
HWND hState = HWND_NOTOPMOST;
if (getOnTop()) hState = HWND_TOPMOST;
if (e->param()) hState = HWND_BOTTOM;
SetWindowPos(main->winId(), hState, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
#endif
}
if (e->type() == EventInTaskManager){
QWidget *main = getMainWindow();
if (main == NULL) return NULL;
#ifdef WIN32
if (IsWindowUnicode(main->winId())){
if (e->param() && getInTask()){
SetWindowLongW(main->winId(), GWL_EXSTYLE,
(GetWindowLongW(main->winId(), GWL_EXSTYLE) | WS_EX_APPWINDOW) & (~WS_EX_TOOLWINDOW));
}else{
DWORD exStyle = GetWindowLongW(main->winId(), GWL_EXSTYLE);
if ((exStyle & WS_EX_TOOLWINDOW) == 0){
SetWindowLongW(main->winId(), GWL_EXSTYLE, (exStyle & ~WS_EX_APPWINDOW) | WS_EX_TOOLWINDOW);
QPoint p = main->pos();
QSize s = main->size();
main->resize(s.width() + 1, s.height());
main->resize(s.width(), s.height());
main->move(p);
}
}
}else{
if (e->param() && getInTask()){
SetWindowLongA(main->winId(), GWL_EXSTYLE,
(GetWindowLongA(main->winId(), GWL_EXSTYLE) | WS_EX_APPWINDOW) & (~WS_EX_TOOLWINDOW));
}else{
DWORD exStyle = GetWindowLongA(main->winId(), GWL_EXSTYLE);
if ((exStyle & WS_EX_TOOLWINDOW) == 0){
SetWindowLongA(main->winId(), GWL_EXSTYLE, (exStyle & ~WS_EX_APPWINDOW) | WS_EX_TOOLWINDOW);
QSize s = main->size();
main->resize(s.width() + 1, s.height());
main->resize(s.width(), s.height());
}
}
}
#endif
}
return NULL;
}
/***********************************************************************
*
* OSK_DlgCommand
*
* All handling of dialog command
*/
BOOL OSK_DlgCommand(WPARAM wCommand, HWND hWndControl)
{
WORD ScanCode;
INPUT Input;
BOOL bExtendedKey;
BOOL bKeyDown;
BOOL bKeyUp;
LONG WindowStyle;
/* FIXME: To be deleted when ReactOS will support WS_EX_NOACTIVATE */
if (Globals.hActiveWnd)
{
MSG msg;
SetForegroundWindow(Globals.hActiveWnd);
while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
/* KeyDown and/or KeyUp ? */
WindowStyle = GetWindowLongW(hWndControl, GWL_STYLE);
if ((WindowStyle & BS_AUTOCHECKBOX) == BS_AUTOCHECKBOX)
{
/* 2-states key like Shift, Alt, Ctrl, ... */
if (SendMessageW(hWndControl, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
bKeyDown = TRUE;
bKeyUp = FALSE;
}
else
{
bKeyDown = FALSE;
bKeyUp = TRUE;
}
}
else
{
/* Other key */
bKeyDown = TRUE;
bKeyUp = TRUE;
}
/* Extended key ? */
ScanCode = wCommand;
if (ScanCode & 0x0200)
bExtendedKey = TRUE;
else
bExtendedKey = FALSE;
ScanCode &= 0xFF;
/* Press and release the key */
if (bKeyDown)
{
Input.type = INPUT_KEYBOARD;
Input.ki.wVk = 0;
Input.ki.wScan = ScanCode;
Input.ki.time = GetTickCount();
Input.ki.dwExtraInfo = GetMessageExtraInfo();
Input.ki.dwFlags = KEYEVENTF_SCANCODE;
if (bExtendedKey) Input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
SendInput(1, &Input, sizeof(Input));
}
if (bKeyUp)
{
Input.type = INPUT_KEYBOARD;
Input.ki.wVk = 0;
Input.ki.wScan = ScanCode;
Input.ki.time = GetTickCount();
Input.ki.dwExtraInfo = GetMessageExtraInfo();
Input.ki.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP;
if (bExtendedKey) Input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
SendInput(1, &Input, sizeof(Input));
}
return TRUE;
}
void Window::OnComputedPropertyValueChanged(PropertyValue* pPropertyVal, bool handled)
{
if (pPropertyVal->m_dp == get_IsActiveProperty())
{
if (m_platformWindow)
{
bool isActive = get_IsActive();
if (isActive)
{
SetForegroundWindow(m_platformWindow->get_Handle());
//::SetWindowPos(m_platformWindow->get_Handle(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE/* | SWP_NOZORDER*/);
}
}
}
else if (pPropertyVal->m_dp == get_OpacityProperty())
{
if (m_platformWindow)
{
m_platformWindow->OnOpacityChanged();
}
}
else if (pPropertyVal->m_dp == get_ClipProperty())
{
if (m_platformWindow)
{
m_platformWindow->OnClipChanged();
}
}
else if (pPropertyVal->m_dp == get_TitleTextProperty())
{
if (m_platformWindow)
{
m_platformWindow->OnTitleTextChanged();
}
}
else if (pPropertyVal->m_dp == get_CanMinimizeProperty())
{
if (m_platformWindow)
{
bool has = get_CanMaximize();
DWORD style = GetWindowLongW(m_platformWindow->get_Handle(), GWL_STYLE);
if (has)
style |= WS_MINIMIZEBOX;
else
style &= ~WS_MINIMIZEBOX;
SetWindowLongW(m_platformWindow->get_Handle(), GWL_STYLE, style);
}
}
else if (pPropertyVal->m_dp == get_CanMaximizeProperty())
{
if (m_platformWindow)
{
bool has = get_CanMaximize();
DWORD style = GetWindowLongW(m_platformWindow->get_Handle(), GWL_STYLE);
if (has)
style |= WS_MAXIMIZEBOX;
else
style &= ~WS_MAXIMIZEBOX;
SetWindowLongW(m_platformWindow->get_Handle(), GWL_STYLE, style);
}
}
else if (pPropertyVal->m_dp == get_HasContextHelpProperty())
{
if (m_platformWindow)
{
bool has = get_HasContextHelp();
DWORD exstyle = GetWindowLongW(m_platformWindow->get_Handle(), GWL_EXSTYLE);
if (has)
exstyle |= WS_EX_CONTEXTHELP;
else
exstyle &= ~WS_EX_CONTEXTHELP;
SetWindowLongW(m_platformWindow->get_Handle(), GWL_EXSTYLE, exstyle);
}
}
else if (pPropertyVal->m_dp == get_ShowInTaskbarProperty())
{
if (m_platformWindow)
{
bool show = get_ShowInTaskbar();
/*
DWORD exstyle = GetWindowLongW(m_platformWindow->get_Handle(), GWL_EXSTYLE);
if (show)
{
exstyle |= WS_EX_APPWINDOW;
exstyle &= ~WS_EX_TOOLWINDOW;
}
else
{
exstyle &= ~WS_EX_APPWINDOW;
exstyle |= WS_EX_TOOLWINDOW;
}
SetWindowLongW(m_platformWindow->get_Handle(), GWL_EXSTYLE, exstyle);
*/
if (show)
{
MS::Windows::Shell::Private::pTaskbarList->AddTab(m_platformWindow->get_Handle());
}
else
{
MS::Windows::Shell::Private::pTaskbarList->DeleteTab(m_platformWindow->get_Handle());
}
}
}
else if (pPropertyVal->m_dp == get_FontFamilyProperty() ||
pPropertyVal->m_dp == get_FontSizeProperty() ||
pPropertyVal->m_dp == get_FontWeightProperty() ||
pPropertyVal->m_dp == get_FontStyleProperty())
{
if (m_platformWindow)
{
LOGFONT lf = {0};
// TODO: Copy16
wcscpy_s(lf.lfFaceName, get_FontFamily().c_strw_flen<LF_FACESIZE>());
lf.lfHeight = -get_FontSize();
lf.lfWeight = get_FontWeight();
HFONT hFont = CreateFontIndirect(&lf);
ASSERT(hFont);
SendMessageW(m_platformWindow->get_Handle(), WM_SETFONT, (WPARAM)hFont, TRUE/*bRedraw*/);
/*
String titleText = get_TitleText();
SetWindowTextW(m_platformWindow->get_Handle(), CStringw(titleText).c_str());
*/
}
}
else if (pPropertyVal->m_dp == get_TopmostProperty())
{
if (m_platformWindow)
{
bool topmost = get_Topmost();
if (topmost)
SetWindowPos(m_platformWindow->get_Handle(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
else
SetWindowPos(m_platformWindow->get_Handle(), HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
}
}
else if (pPropertyVal->m_dp == get_StateProperty())
{
if (m_platformWindow)
{
int state = GetPropertyValueInt(get_StateProperty());
switch (state)
{
case 0:
::ShowWindow(m_platformWindow->get_Handle(), SW_RESTORE);
break;
case 1:
::ShowWindow(m_platformWindow->get_Handle(), SW_MINIMIZE);
break;
case 2:
::ShowWindow(m_platformWindow->get_Handle(), SW_MAXIMIZE);
break;
}
}
}
else if (pPropertyVal->m_dp == get_IsEnabledProperty())
{
if (m_platformWindow)
{
bool isEnabled = get_IsEnabled();
::EnableWindow(m_platformWindow->get_Handle(), isEnabled);
}
}
else if (pPropertyVal->m_dp == get_CanCloseProperty())
{
if (m_platformWindow)
{
if (get_CanClose())
{
// SetWindowLongPtr(m_platformWindow->get_Handle(),
}
else
{
}
/*
ULONG_PTR classStyle = ::GetClassLongPtr(m_platformWindow->get_Handle(), GCL_STYLE);
if (get_CanClose()) classStyle &= ~CS_NOCLOSE;
else classStyle |= CS_NOCLOSE;
::SetClassLongPtr(m_platformWindow->get_Handle(), GCL_STYLE, classStyle);
*/
}
}
else if (pPropertyVal->m_dp == get_LeftProperty() ||
pPropertyVal->m_dp == get_TopProperty())
{
if (m_platformWindow)
{
int x = int(get_Left());
int y = int(get_Top());
int cx = int(get_ActualWidth()); // ceil??
int cy = int(get_ActualHeight()); // ceil??
if (!get_InSizeMove() && !m_inSizeMove)
{
::SetWindowPos(m_platformWindow->get_Handle(), nullptr, x, y, cx, cy,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE/* |
SWP_ASYNCWINDOWPOS // ??*/
);
}
}
}
else if (pPropertyVal->m_dp == get_ActualWidthProperty() ||
pPropertyVal->m_dp == get_ActualHeightProperty())
{
if (m_platformWindow)
{
int x = int(get_Left());
int y = int(get_Top());
int cx = int(get_ActualWidth()); // ceil??
int cy = int(get_ActualHeight()); // ceil??
if (!get_InSizeMove() && !m_inSizeMove)
{
::SetWindowPos(m_platformWindow->get_Handle(), nullptr, x, y, cx, cy,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE/* |
SWP_ASYNCWINDOWPOS // ??*/
);
}
}
}
else if (pPropertyVal->m_dp == get_RTProperty())
{
if (m_platformWindow)
{
m_platformWindow->ChangeTech();
}
}
#if 0
else if (pPropertyVal->m_dp == get_ChildProperty())
{
/*
MessageBeep(-1);
if (m_platformWindow)
{
}
*/
InvalidateVisual();
}
#endif
else if (pPropertyVal->m_dp == get_ShadowTreeProperty())
{
UIElement* uielement = get_ShadowTree();
if (uielement)
{
uielement->SetRoot(this); // This is different from default UIElement implementation
uielement->set_ParentWindow(this); // This is different from default UIElement implementation
uielement->set_Parent(this);
uielement->set_TemplatedOwner(this); // ??
InvalidateMeasure();
// // ??
// uielement->ArrangeCore(gm::SizeF(get_ActualWidth(), get_ActualHeight()));
}
handled = true;
}
else if (pPropertyVal->m_dp == get_OwnerProperty())
{
Window* owner = get_Owner();
if (m_platformWindow && m_platformWindow->get_Handle())
{
if (owner)
{
if (owner->m_platformWindow && owner->m_platformWindow->get_Handle())
{
::SetParent(m_platformWindow->get_Handle(), owner->m_platformWindow->get_Handle());
}
}
else
{
::SetParent(m_platformWindow->get_Handle(), nullptr);
}
}
}
else if (pPropertyVal->m_dp == get_TaskbarItemInfoProperty())
{
MS::Windows::Shell::TaskbarItemInfo* info = get_TaskbarItemInfo();
if (m_platformWindow)
{
HWND hWnd = m_platformWindow->get_Handle();
if (hWnd)
{
double progress = info->get_ProgressValue();
const ULONGLONG totalProgress = 1000000ULL;
// TBPFLAG tbFlags;
// MS::Windows::Shell::Private::pTaskbarList3->SetProgressState(hWnd, tbpFlags);
MS::Windows::Shell::Private::pTaskbarList3->SetProgressValue(hWnd, progress*totalProgress, totalProgress);
}
}
}
baseClass::OnComputedPropertyValueChanged(pPropertyVal, handled);
}
UINT WINAPI
WinPosGetMinMaxInfo(HWND hwnd, POINT* maxSize, POINT* maxPos,
POINT* minTrack, POINT* maxTrack)
{
MINMAXINFO MinMax;
HMONITOR monitor;
INT xinc, yinc;
LONG style = GetWindowLongW( hwnd, GWL_STYLE );
LONG adjustedStyle;
LONG exstyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
RECT rc;
WND *win;
/* Compute default values */
GetWindowRect(hwnd, &rc);
MinMax.ptReserved.x = rc.left;
MinMax.ptReserved.y = rc.top;
if ((style & WS_CAPTION) == WS_CAPTION)
adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
else
adjustedStyle = style;
GetClientRect(GetAncestor(hwnd,GA_PARENT), &rc);
AdjustWindowRectEx(&rc, adjustedStyle, ((style & WS_POPUP) && GetMenu(hwnd)), exstyle);
xinc = -rc.left;
yinc = -rc.top;
MinMax.ptMaxSize.x = rc.right - rc.left;
MinMax.ptMaxSize.y = rc.bottom - rc.top;
if (style & (WS_DLGFRAME | WS_BORDER))
{
MinMax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
MinMax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
}
else
{
MinMax.ptMinTrackSize.x = 2 * xinc;
MinMax.ptMinTrackSize.y = 2 * yinc;
}
MinMax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXMAXTRACK);
MinMax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYMAXTRACK);
MinMax.ptMaxPosition.x = -xinc;
MinMax.ptMaxPosition.y = -yinc;
if ((win = ValidateHwnd( hwnd )) )//&& win != WND_DESKTOP && win != WND_OTHER_PROCESS)
{
if (!EMPTYPOINT(win->InternalPos.MaxPos)) MinMax.ptMaxPosition = win->InternalPos.MaxPos;
}
SendMessageW( hwnd, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
/* if the app didn't change the values, adapt them for the current monitor */
if ((monitor = MonitorFromWindow( hwnd, MONITOR_DEFAULTTOPRIMARY )))
{
RECT rc_work;
MONITORINFO mon_info;
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW( monitor, &mon_info );
rc_work = mon_info.rcMonitor;
if (style & WS_MAXIMIZEBOX)
{
if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
rc_work = mon_info.rcWork;
}
if (MinMax.ptMaxSize.x == GetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
MinMax.ptMaxSize.y == GetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
{
MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
}
if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
{
MinMax.ptMaxPosition.x = rc_work.left - xinc;
MinMax.ptMaxPosition.y = rc_work.top - yinc;
}
}
/* Some sanity checks */
TRACE("%d %d / %d %d / %d %d / %d %d\n",
MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
MinMax.ptMaxTrackSize.x = max( MinMax.ptMaxTrackSize.x,
MinMax.ptMinTrackSize.x );
MinMax.ptMaxTrackSize.y = max( MinMax.ptMaxTrackSize.y,
MinMax.ptMinTrackSize.y );
if (maxSize) *maxSize = MinMax.ptMaxSize;
if (maxPos) *maxPos = MinMax.ptMaxPosition;
if (minTrack) *minTrack = MinMax.ptMinTrackSize;
if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
return 0; //FIXME: what does it return? Wine returns MINMAXINFO.
}
static inline LONG get_button_state( HWND hwnd )
{
return GetWindowLongW( hwnd, STATE_GWL_OFFSET );
}
/* Message handler for dialog box. */
static INT_PTR CALLBACK
TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
static const WCHAR wszTaskmgr[] = {'t','a','s','k','m','g','r',0};
HDC hdc;
PAINTSTRUCT ps;
LPRECT pRC;
RECT rc;
LPNMHDR pnmh;
WINDOWPLACEMENT wp;
switch (message) {
case WM_INITDIALOG:
hMainWnd = hDlg;
return OnCreate(hDlg);
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
/* Process menu commands */
switch (LOWORD(wParam))
{
case ID_FILE_NEW:
TaskManager_OnFileNew();
break;
case ID_OPTIONS_ALWAYSONTOP:
TaskManager_OnOptionsAlwaysOnTop();
break;
case ID_OPTIONS_MINIMIZEONUSE:
TaskManager_OnOptionsMinimizeOnUse();
break;
case ID_OPTIONS_HIDEWHENMINIMIZED:
TaskManager_OnOptionsHideWhenMinimized();
break;
case ID_OPTIONS_SHOW16BITTASKS:
TaskManager_OnOptionsShow16BitTasks();
break;
case ID_RESTORE:
TaskManager_OnRestoreMainWindow();
break;
case ID_VIEW_LARGE:
ApplicationPage_OnViewLargeIcons();
break;
case ID_VIEW_SMALL:
ApplicationPage_OnViewSmallIcons();
break;
case ID_VIEW_DETAILS:
ApplicationPage_OnViewDetails();
break;
case ID_VIEW_SHOWKERNELTIMES:
PerformancePage_OnViewShowKernelTimes();
break;
case ID_VIEW_CPUHISTORY_ONEGRAPHALL:
PerformancePage_OnViewCPUHistoryOneGraphAll();
break;
case ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU:
PerformancePage_OnViewCPUHistoryOneGraphPerCPU();
break;
case ID_VIEW_UPDATESPEED_HIGH:
TaskManager_OnViewUpdateSpeedHigh();
break;
case ID_VIEW_UPDATESPEED_NORMAL:
TaskManager_OnViewUpdateSpeedNormal();
break;
case ID_VIEW_UPDATESPEED_LOW:
TaskManager_OnViewUpdateSpeedLow();
break;
case ID_VIEW_UPDATESPEED_PAUSED:
TaskManager_OnViewUpdateSpeedPaused();
break;
case ID_VIEW_SELECTCOLUMNS:
ProcessPage_OnViewSelectColumns();
break;
case ID_VIEW_REFRESH:
PostMessageW(hDlg, WM_TIMER, 0, 0);
break;
case ID_WINDOWS_TILEHORIZONTALLY:
ApplicationPage_OnWindowsTileHorizontally();
break;
case ID_WINDOWS_TILEVERTICALLY:
ApplicationPage_OnWindowsTileVertically();
break;
case ID_WINDOWS_MINIMIZE:
ApplicationPage_OnWindowsMinimize();
break;
case ID_WINDOWS_MAXIMIZE:
ApplicationPage_OnWindowsMaximize();
break;
case ID_WINDOWS_CASCADE:
ApplicationPage_OnWindowsCascade();
break;
case ID_WINDOWS_BRINGTOFRONT:
ApplicationPage_OnWindowsBringToFront();
break;
case ID_APPLICATION_PAGE_SWITCHTO:
ApplicationPage_OnSwitchTo();
break;
case ID_APPLICATION_PAGE_ENDTASK:
ApplicationPage_OnEndTask();
break;
case ID_APPLICATION_PAGE_GOTOPROCESS:
ApplicationPage_OnGotoProcess();
break;
case ID_PROCESS_PAGE_ENDPROCESS:
ProcessPage_OnEndProcess();
break;
case ID_PROCESS_PAGE_ENDPROCESSTREE:
ProcessPage_OnEndProcessTree();
break;
case ID_PROCESS_PAGE_DEBUG:
ProcessPage_OnDebug();
break;
case ID_PROCESS_PAGE_SETAFFINITY:
ProcessPage_OnSetAffinity();
break;
case ID_PROCESS_PAGE_SETPRIORITY_REALTIME:
ProcessPage_OnSetPriorityRealTime();
break;
case ID_PROCESS_PAGE_SETPRIORITY_HIGH:
ProcessPage_OnSetPriorityHigh();
break;
case ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL:
ProcessPage_OnSetPriorityAboveNormal();
break;
case ID_PROCESS_PAGE_SETPRIORITY_NORMAL:
ProcessPage_OnSetPriorityNormal();
break;
case ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL:
ProcessPage_OnSetPriorityBelowNormal();
break;
case ID_PROCESS_PAGE_SETPRIORITY_LOW:
ProcessPage_OnSetPriorityLow();
break;
case ID_PROCESS_PAGE_DEBUGCHANNELS:
ProcessPage_OnDebugChannels();
break;
case ID_HELP_TOPICS:
WinHelpW(hDlg, wszTaskmgr, HELP_FINDER, 0);
break;
case ID_HELP_ABOUT:
OnAbout();
break;
case ID_FILE_EXIT:
EndDialog(hDlg, IDOK);
break;
}
break;
case WM_ONTRAYICON:
switch(lParam)
{
case WM_RBUTTONDOWN:
{
POINT pt;
BOOL OnTop;
HMENU hMenu, hPopupMenu;
GetCursorPos(&pt);
OnTop = (GetWindowLongW(hMainWnd, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0;
hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_TRAY_POPUP));
hPopupMenu = GetSubMenu(hMenu, 0);
if(IsWindowVisible(hMainWnd))
{
DeleteMenu(hPopupMenu, ID_RESTORE, MF_BYCOMMAND);
}
else
{
SetMenuDefaultItem(hPopupMenu, ID_RESTORE, FALSE);
}
if(OnTop)
{
CheckMenuItem(hPopupMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND | MF_CHECKED);
}
SetForegroundWindow(hMainWnd);
TrackPopupMenuEx(hPopupMenu, 0, pt.x, pt.y, hMainWnd, NULL);
DestroyMenu(hMenu);
break;
}
case WM_LBUTTONDBLCLK:
TaskManager_OnRestoreMainWindow();
break;
}
break;
case WM_NOTIFY:
pnmh = (LPNMHDR)lParam;
if ((pnmh->hwndFrom == hTabWnd) &&
(pnmh->idFrom == IDC_TAB) &&
(pnmh->code == TCN_SELCHANGE))
{
TaskManager_OnTabWndSelChange();
}
break;
case WM_NCPAINT:
hdc = GetDC(hDlg);
GetClientRect(hDlg, &rc);
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
ReleaseDC(hDlg, hdc);
break;
case WM_PAINT:
hdc = BeginPaint(hDlg, &ps);
GetClientRect(hDlg, &rc);
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
EndPaint(hDlg, &ps);
break;
case WM_SIZING:
/* Make sure the user is sizing the dialog */
/* in an acceptable range */
pRC = (LPRECT)lParam;
if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT)) {
/* If the width is too small enlarge it to the minimum */
if (nMinimumWidth > (pRC->right - pRC->left))
pRC->left = pRC->right - nMinimumWidth;
} else {
/* If the width is too small enlarge it to the minimum */
if (nMinimumWidth > (pRC->right - pRC->left))
pRC->right = pRC->left + nMinimumWidth;
}
if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT)) {
/* If the height is too small enlarge it to the minimum */
if (nMinimumHeight > (pRC->bottom - pRC->top))
pRC->top = pRC->bottom - nMinimumHeight;
} else {
/* If the height is too small enlarge it to the minimum */
if (nMinimumHeight > (pRC->bottom - pRC->top))
pRC->bottom = pRC->top + nMinimumHeight;
}
return TRUE;
case WM_SIZE:
/* Handle the window sizing in it's own function */
OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
break;
case WM_MOVE:
/* Handle the window moving in it's own function */
OnMove(wParam, LOWORD(lParam), HIWORD(lParam));
break;
case WM_DESTROY:
ShowWindow(hDlg, SW_HIDE);
TrayIcon_ShellRemoveTrayIcon();
wp.length = sizeof(WINDOWPLACEMENT);
GetWindowPlacement(hDlg, &wp);
TaskManagerSettings.Left = wp.rcNormalPosition.left;
TaskManagerSettings.Top = wp.rcNormalPosition.top;
TaskManagerSettings.Right = wp.rcNormalPosition.right;
TaskManagerSettings.Bottom = wp.rcNormalPosition.bottom;
if (IsZoomed(hDlg) || (wp.flags & WPF_RESTORETOMAXIMIZED))
TaskManagerSettings.Maximized = TRUE;
else
TaskManagerSettings.Maximized = FALSE;
return DefWindowProcW(hDlg, message, wParam, lParam);
case WM_TIMER:
/* Refresh the performance data */
PerfDataRefresh();
RefreshApplicationPage();
RefreshProcessPage();
RefreshPerformancePage();
TrayIcon_ShellUpdateTrayIcon();
break;
case WM_ENTERMENULOOP:
TaskManager_OnEnterMenuLoop(hDlg);
break;
case WM_EXITMENULOOP:
TaskManager_OnExitMenuLoop(hDlg);
break;
case WM_MENUSELECT:
TaskManager_OnMenuSelect(hDlg, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
break;
}
return 0;
}
/***********************************************************************
* ButtonWndProc_common
*/
LRESULT ButtonWndProc_common(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode )
{
RECT rect;
POINT pt;
LONG style = GetWindowLongW( hWnd, GWL_STYLE );
UINT btn_type = get_button_type( style );
LONG state;
HANDLE oldHbitmap;
if (!IsWindow( hWnd )) return 0;
pt.x = (short)LOWORD(lParam);
pt.y = (short)HIWORD(lParam);
switch (uMsg)
{
case WM_GETDLGCODE:
switch(btn_type)
{
case BS_USERBUTTON:
case BS_PUSHBUTTON: return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON;
case BS_DEFPUSHBUTTON: return DLGC_BUTTON | DLGC_DEFPUSHBUTTON;
case BS_RADIOBUTTON:
case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON;
case BS_GROUPBOX: return DLGC_STATIC;
default: return DLGC_BUTTON;
}
case WM_ENABLE:
paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
break;
case WM_CREATE:
if (!hbitmapCheckBoxes)
{
BITMAP bmp;
hbitmapCheckBoxes = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CHECKBOXES));
GetObjectW( hbitmapCheckBoxes, sizeof(bmp), &bmp );
checkBoxWidth = bmp.bmWidth / 4;
checkBoxHeight = bmp.bmHeight / 3;
}
if (btn_type >= MAX_BTN_TYPE)
return -1; /* abort */
/* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
if (btn_type == BS_USERBUTTON )
{
style = (style & ~BS_TYPEMASK) | BS_PUSHBUTTON;
WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
}
set_button_state( hWnd, BST_UNCHECKED );
return 0;
case WM_ERASEBKGND:
if (btn_type == BS_OWNERDRAW)
{
HDC hdc = (HDC)wParam;
RECT rc;
HBRUSH hBrush;
HWND parent = GetParent(hWnd);
if (!parent) parent = hWnd;
hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
if (!hBrush) /* did the app forget to call defwindowproc ? */
hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
(WPARAM)hdc, (LPARAM)hWnd);
GetClientRect(hWnd, &rc);
FillRect(hdc, &rc, hBrush);
}
return 1;
case WM_PRINTCLIENT:
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
if (btnPaintFunc[btn_type])
{
int nOldMode = SetBkMode( hdc, OPAQUE );
(btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE );
SetBkMode(hdc, nOldMode); /* reset painting mode */
}
if ( !wParam ) EndPaint( hWnd, &ps );
break;
}
case WM_KEYDOWN:
if (wParam == VK_SPACE)
{
SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
SetCapture( hWnd );
}
break;
case WM_LBUTTONDBLCLK:
if(style & BS_NOTIFY ||
btn_type == BS_RADIOBUTTON ||
btn_type == BS_USERBUTTON ||
btn_type == BS_OWNERDRAW)
{
BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED);
break;
}
/* fall through */
case WM_LBUTTONDOWN:
SetCapture( hWnd );
SetFocus( hWnd );
set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
break;
case WM_KEYUP:
if (wParam != VK_SPACE)
break;
/* fall through */
case WM_LBUTTONUP:
state = get_button_state( hWnd );
if (!(state & BUTTON_BTNPRESSED)) break;
state &= BUTTON_NSTATES;
set_button_state( hWnd, state );
if (!(state & BST_PUSHED))
{
ReleaseCapture();
break;
}
SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
GetClientRect( hWnd, &rect );
if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
{
state = get_button_state( hWnd );
switch(btn_type)
{
case BS_AUTOCHECKBOX:
SendMessageW( hWnd, BM_SETCHECK, !(state & BST_CHECKED), 0 );
break;
case BS_AUTORADIOBUTTON:
SendMessageW( hWnd, BM_SETCHECK, TRUE, 0 );
break;
case BS_AUTO3STATE:
SendMessageW( hWnd, BM_SETCHECK,
(state & BST_INDETERMINATE) ? 0 : ((state & 3) + 1), 0 );
break;
}
ReleaseCapture();
BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
}
else
{
ReleaseCapture();
}
break;
case WM_CAPTURECHANGED:
TRACE("WM_CAPTURECHANGED %p\n", hWnd);
state = get_button_state( hWnd );
if (state & BUTTON_BTNPRESSED)
{
state &= BUTTON_NSTATES;
set_button_state( hWnd, state );
if (state & BST_PUSHED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
}
break;
case WM_MOUSEMOVE:
if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
{
GetClientRect( hWnd, &rect );
SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 );
}
break;
case WM_SETTEXT:
{
/* Clear an old text here as Windows does */
HDC hdc = GetDC(hWnd);
HBRUSH hbrush;
RECT client, rc;
HWND parent = GetParent(hWnd);
if (!parent) parent = hWnd;
hbrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hdc, (LPARAM)hWnd);
if (!hbrush) /* did the app forget to call DefWindowProc ? */
hbrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hdc, (LPARAM)hWnd);
GetClientRect(hWnd, &client);
rc = client;
BUTTON_CalcLabelRect(hWnd, hdc, &rc);
/* Clip by client rect bounds */
if (rc.right > client.right) rc.right = client.right;
if (rc.bottom > client.bottom) rc.bottom = client.bottom;
FillRect(hdc, &rc, hbrush);
ReleaseDC(hWnd, hdc);
if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam );
else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam );
if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
InvalidateRect( hWnd, NULL, TRUE );
else
paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
return 1; /* success. FIXME: check text length */
}
case WM_SETFONT:
set_button_font( hWnd, (HFONT)wParam );
if (lParam) InvalidateRect(hWnd, NULL, TRUE);
break;
case WM_GETFONT:
return (LRESULT)get_button_font( hWnd );
case WM_SETFOCUS:
TRACE("WM_SETFOCUS %p\n",hWnd);
set_button_state( hWnd, get_button_state(hWnd) | BST_FOCUS );
paint_button( hWnd, btn_type, ODA_FOCUS );
if (style & BS_NOTIFY)
BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS);
break;
case WM_KILLFOCUS:
TRACE("WM_KILLFOCUS %p\n",hWnd);
state = get_button_state( hWnd );
set_button_state( hWnd, state & ~BST_FOCUS );
paint_button( hWnd, btn_type, ODA_FOCUS );
if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
ReleaseCapture();
if (style & BS_NOTIFY)
BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS);
InvalidateRect( hWnd, NULL, FALSE );
break;
case WM_SYSCOLORCHANGE:
InvalidateRect( hWnd, NULL, FALSE );
break;
case BM_SETSTYLE:
btn_type = wParam & BS_TYPEMASK;
style = (style & ~BS_TYPEMASK) | btn_type;
WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
/* Only redraw if lParam flag is set.*/
if (lParam)
InvalidateRect( hWnd, NULL, TRUE );
break;
case BM_CLICK:
SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
break;
case BM_SETIMAGE:
/* Check that image format matches button style */
switch (style & (BS_BITMAP|BS_ICON))
{
case BS_BITMAP:
if (wParam != IMAGE_BITMAP) return 0;
break;
case BS_ICON:
if (wParam != IMAGE_ICON) return 0;
break;
default:
return 0;
}
oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam );
InvalidateRect( hWnd, NULL, FALSE );
return (LRESULT)oldHbitmap;
case BM_GETIMAGE:
return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET );
case BM_GETCHECK:
return get_button_state( hWnd ) & 3;
case BM_SETCHECK:
if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
state = get_button_state( hWnd );
if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
{
if (wParam) WIN_SetStyle( hWnd, WS_TABSTOP, 0 );
else WIN_SetStyle( hWnd, 0, WS_TABSTOP );
}
if ((state & 3) != wParam)
{
set_button_state( hWnd, (state & ~3) | wParam );
paint_button( hWnd, btn_type, ODA_SELECT );
}
if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BST_CHECKED) && (style & WS_CHILD))
BUTTON_CheckAutoRadioButton( hWnd );
break;
case BM_GETSTATE:
return get_button_state( hWnd );
case BM_SETSTATE:
state = get_button_state( hWnd );
if (wParam)
set_button_state( hWnd, state | BST_PUSHED );
else
set_button_state( hWnd, state & ~BST_PUSHED );
paint_button( hWnd, btn_type, ODA_SELECT );
break;
case WM_NCHITTEST:
if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
/* fall through */
default:
return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) :
DefWindowProcA(hWnd, uMsg, wParam, lParam);
}
return 0;
}
int WINAPI
WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
{
WNDCLASSW wc;
HWND hWnd;
WCHAR WindowTextW[256];
char WindowTextA[256];
wc.lpszClassName = L"UnicodeClass";
wc.lpfnWndProc = UnicodeWndProc;
wc.style = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
if (RegisterClassW(&wc) == 0)
{
fprintf(stderr, "RegisterClassW failed (last error 0x%lu)\n",
GetLastError());
return 1;
}
printf("Unicode class registered, WndProc = 0x%p\n", wc.lpfnWndProc);
hWnd = CreateWindowA("UnicodeClass",
"Unicode Window",
WS_OVERLAPPEDWINDOW,
0,
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL);
if (hWnd == NULL)
{
fprintf(stderr, "CreateWindowA failed (last error 0x%lu)\n",
GetLastError());
return 1;
}
printf("Window created, IsWindowUnicode returns %s\n", IsWindowUnicode(hWnd) ? "TRUE" : "FALSE");
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
printf("Calling GetWindowTextA\n");
if (! GetWindowTextA(hWnd, WindowTextA, sizeof(WindowTextA) / sizeof(WindowTextA[0])))
{
fprintf(stderr, "GetWindowTextA failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextA returned Ansi string \"%s\"\n", WindowTextA);
printf("\n");
SavedWndProcW = (WNDPROC) GetWindowLongW(hWnd, GWL_WNDPROC);
printf("GetWindowLongW returned 0x%p\n", SavedWndProcW);
SavedWndProcA = (WNDPROC) GetWindowLongA(hWnd, GWL_WNDPROC);
printf("GetWindowLongA returned 0x%p\n", SavedWndProcA);
printf("\n");
printf("Subclassing window using SetWindowLongW, new WndProc 0x%p\n", UnicodeSubclassProc);
SetWindowLongW(hWnd, GWL_WNDPROC, (LONG) UnicodeSubclassProc);
printf("After subclass, IsWindowUnicode %s, WndProcA 0x%lx, WndProcW 0x%lx\n",
IsWindowUnicode(hWnd) ? "TRUE" : "FALSE", GetWindowLongA(hWnd, GWL_WNDPROC),
GetWindowLongW(hWnd, GWL_WNDPROC));
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
printf("\n");
printf("Subclassing window using SetWindowLongA, new WndProc 0x%p\n", AnsiSubclassProc);
SetWindowLongA(hWnd, GWL_WNDPROC, (LONG) AnsiSubclassProc);
printf("After subclass, IsWindowUnicode %s, WndProcA 0x%lx, WndProcW 0x%lx\n",
IsWindowUnicode(hWnd) ? "TRUE" : "FALSE", GetWindowLongA(hWnd, GWL_WNDPROC),
GetWindowLongW(hWnd, GWL_WNDPROC));
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
DestroyWindow(hWnd);
return 0;
}
/**********************************************************************
* BUTTON_CalcLabelRect
*
* Calculates label's rectangle depending on button style.
*
* Returns flags to be passed to DrawText.
* Calculated rectangle doesn't take into account button state
* (pushed, etc.). If there is nothing to draw (no text/image) output
* rectangle is empty, and return value is (UINT)-1.
*/
static UINT BUTTON_CalcLabelRect(HWND hwnd, HDC hdc, RECT *rc)
{
LONG style = GetWindowLongW( hwnd, GWL_STYLE );
LONG ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
WCHAR *text;
ICONINFO iconInfo;
BITMAP bm;
UINT dtStyle = BUTTON_BStoDT( style, ex_style );
RECT r = *rc;
INT n;
/* Calculate label rectangle according to label type */
switch (style & (BS_ICON|BS_BITMAP))
{
case BS_TEXT:
if (!(text = get_button_text( hwnd ))) goto empty_rect;
if (!text[0])
{
HeapFree( GetProcessHeap(), 0, text );
goto empty_rect;
}
DrawTextW(hdc, text, -1, &r, dtStyle | DT_CALCRECT);
HeapFree( GetProcessHeap(), 0, text );
break;
case BS_ICON:
if (!GetIconInfo((HICON)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), &iconInfo))
goto empty_rect;
GetObjectW (iconInfo.hbmColor, sizeof(BITMAP), &bm);
r.right = r.left + bm.bmWidth;
r.bottom = r.top + bm.bmHeight;
DeleteObject(iconInfo.hbmColor);
DeleteObject(iconInfo.hbmMask);
break;
case BS_BITMAP:
if (!GetObjectW( (HANDLE)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), sizeof(BITMAP), &bm))
goto empty_rect;
r.right = r.left + bm.bmWidth;
r.bottom = r.top + bm.bmHeight;
break;
default:
empty_rect:
rc->right = r.left;
rc->bottom = r.top;
return (UINT)-1;
}
/* Position label inside bounding rectangle according to
* alignment flags. (calculated rect is always left-top aligned).
* If label is aligned to any side - shift label in opposite
* direction to leave extra space for focus rectangle.
*/
switch (dtStyle & (DT_CENTER|DT_RIGHT))
{
case DT_LEFT: r.left++; r.right++; break;
case DT_CENTER: n = r.right - r.left;
r.left = rc->left + ((rc->right - rc->left) - n) / 2;
r.right = r.left + n; break;
case DT_RIGHT: n = r.right - r.left;
r.right = rc->right - 1;
r.left = r.right - n;
break;
}
switch (dtStyle & (DT_VCENTER|DT_BOTTOM))
{
case DT_TOP: r.top++; r.bottom++; break;
case DT_VCENTER: n = r.bottom - r.top;
r.top = rc->top + ((rc->bottom - rc->top) - n) / 2;
r.bottom = r.top + n; break;
case DT_BOTTOM: n = r.bottom - r.top;
r.bottom = rc->bottom - 1;
r.top = r.bottom - n;
break;
}
*rc = r;
return dtStyle;
}
static LRESULT
STATUSBAR_WMCreate (HWND hwnd, const CREATESTRUCTA *lpCreate)
{
STATUS_INFO *infoPtr;
NONCLIENTMETRICSW nclm;
DWORD dwStyle;
RECT rect;
int len;
TRACE("\n");
infoPtr = Alloc (sizeof(STATUS_INFO));
if (!infoPtr) goto create_fail;
SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
infoPtr->Self = hwnd;
infoPtr->Notify = lpCreate->hwndParent;
infoPtr->numParts = 1;
infoPtr->parts = 0;
infoPtr->simple = FALSE;
infoPtr->clrBk = CLR_DEFAULT;
infoPtr->hFont = 0;
infoPtr->horizontalBorder = HORZ_BORDER;
infoPtr->verticalBorder = VERT_BORDER;
infoPtr->horizontalGap = HORZ_GAP;
infoPtr->minHeight = GetSystemMetrics(SM_CYSIZE);
if (infoPtr->minHeight & 1) infoPtr->minHeight--;
STATUSBAR_NotifyFormat(infoPtr, infoPtr->Notify, NF_REQUERY);
ZeroMemory (&nclm, sizeof(nclm));
nclm.cbSize = sizeof(nclm);
SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0);
infoPtr->hDefaultFont = CreateFontIndirectW (&nclm.lfStatusFont);
GetClientRect (hwnd, &rect);
/* initialize simple case */
infoPtr->part0.bound = rect;
infoPtr->part0.text = 0;
infoPtr->part0.x = 0;
infoPtr->part0.style = 0;
infoPtr->part0.hIcon = 0;
/* initialize first part */
infoPtr->parts = Alloc (sizeof(STATUSWINDOWPART));
if (!infoPtr->parts) goto create_fail;
infoPtr->parts[0].bound = rect;
infoPtr->parts[0].text = 0;
infoPtr->parts[0].x = -1;
infoPtr->parts[0].style = 0;
infoPtr->parts[0].hIcon = 0;
OpenThemeData (hwnd, themeClass);
if (lpCreate->lpszName && (len = strlenW ((LPCWSTR)lpCreate->lpszName)))
{
infoPtr->parts[0].text = Alloc ((len + 1)*sizeof(WCHAR));
if (!infoPtr->parts[0].text) goto create_fail;
strcpyW (infoPtr->parts[0].text, (LPCWSTR)lpCreate->lpszName);
}
dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
/* native seems to clear WS_BORDER, too */
dwStyle &= ~WS_BORDER;
SetWindowLongW (hwnd, GWL_STYLE, dwStyle);
infoPtr->height = STATUSBAR_ComputeHeight(infoPtr);
if (dwStyle & SBT_TOOLTIPS) {
infoPtr->hwndToolTip =
CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP | TTS_ALWAYSTIP,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, hwnd, 0,
(HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
if (infoPtr->hwndToolTip) {
NMTOOLTIPSCREATED nmttc;
nmttc.hdr.hwndFrom = hwnd;
nmttc.hdr.idFrom = GetWindowLongPtrW (hwnd, GWLP_ID);
nmttc.hdr.code = NM_TOOLTIPSCREATED;
nmttc.hwndToolTips = infoPtr->hwndToolTip;
SendMessageW (lpCreate->hwndParent, WM_NOTIFY, nmttc.hdr.idFrom, (LPARAM)&nmttc);
}
}
return 0;
create_fail:
TRACE(" failed!\n");
if (infoPtr) STATUSBAR_WMDestroy(infoPtr);
return -1;
}
/***********************************************************************
* ScrollBarWndProc
*/
LRESULT WINAPI
ScrollBarWndProc_common(WNDPROC DefWindowProc, HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
{
#ifdef __REACTOS__ // Do this now, remove after Server side is fixed.
PWND pWnd;
PSBWND pSBWnd;
SCROLLINFO ScrollInfo;
pWnd = ValidateHwnd(Wnd);
if (pWnd)
{
if (!pWnd->fnid)
{
TRACE("ScrollBar CTL size %d\n", (sizeof(SBWND)-sizeof(WND)));
if ( pWnd->cbwndExtra != (sizeof(SBWND)-sizeof(WND)) )
{
ERR("Wrong Extra bytes for Scrollbar!\n");
return 0;
}
if (Msg != WM_CREATE)
{
return DefWindowProc(Wnd, Msg, wParam, lParam);
}
NtUserSetWindowFNID(Wnd, FNID_SCROLLBAR);
}
else
{
if (pWnd->fnid != FNID_SCROLLBAR)
{
ERR("Wrong window class for Scrollbar!\n");
return 0;
}
}
}
#endif
if (! IsWindow(Wnd))
{
return 0;
}
// Must be a scroll bar control!
pSBWnd = (PSBWND)pWnd;
switch (Msg)
{
case WM_CREATE:
IntScrollCreateScrollBar(Wnd, (LPCREATESTRUCTW) lParam);
break;
case WM_ENABLE:
{
return SendMessageW( Wnd, SBM_ENABLE_ARROWS, wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH, 0);
}
case WM_LBUTTONDBLCLK:
case WM_LBUTTONDOWN:
if (GetWindowLongW( Wnd, GWL_STYLE ) & SBS_SIZEGRIP)
{
SendMessageW( GetParent(Wnd), WM_SYSCOMMAND,
SC_SIZE + ((GetWindowLongW( Wnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) ?
WMSZ_BOTTOMLEFT : WMSZ_BOTTOMRIGHT), lParam );
}
else
{
POINT Pt;
Pt.x = (short)LOWORD(lParam);
Pt.y = (short)HIWORD(lParam);
ScrollTrackScrollBar(Wnd, SB_CTL, Pt);
}
break;
case WM_LBUTTONUP:
case WM_MOUSEMOVE:
case WM_SYSTIMER:
{
POINT Pt;
Pt.x = (short)LOWORD(lParam);
Pt.y = (short)HIWORD(lParam);
IntScrollHandleScrollEvent(Wnd, SB_CTL, Msg, Pt);
}
break;
case WM_KEYDOWN:
IntScrollHandleKbdEvent(Wnd, wParam, lParam);
break;
case WM_KEYUP:
ShowCaret(Wnd);
break;
case WM_SETFOCUS:
{
/* Create a caret when a ScrollBar get focus */
RECT Rect;
int ArrowSize, ThumbSize, ThumbPos, Vertical;
Vertical = IntScrollGetScrollBarRect(Wnd, SB_CTL, &Rect,
&ArrowSize, &ThumbSize, &ThumbPos);
if (! Vertical)
{
CreateCaret(Wnd, (HBITMAP) 1, ThumbSize - 2, Rect.bottom - Rect.top - 2);
SetCaretPos(ThumbPos + 1, Rect.top + 1);
}
else
{
CreateCaret(Wnd, (HBITMAP) 1, Rect.right - Rect.left - 2, ThumbSize - 2);
SetCaretPos(Rect.top + 1, ThumbPos + 1);
}
ShowCaret(Wnd);
}
break;
case WM_KILLFOCUS:
{
RECT Rect;
int ArrowSize, ThumbSize, ThumbPos, Vertical;
Vertical = IntScrollGetScrollBarRect(Wnd, SB_CTL, &Rect,
&ArrowSize, &ThumbSize, &ThumbPos);
if (! Vertical)
{
Rect.left = ThumbPos + 1;
Rect.right = Rect.left + ThumbSize;
}
else
{
Rect.top = ThumbPos + 1;
Rect.bottom = Rect.top + ThumbSize;
}
HideCaret(Wnd);
InvalidateRect(Wnd, &Rect, FALSE);
DestroyCaret();
}
break;
case WM_ERASEBKGND:
return 1;
case WM_GETDLGCODE:
return DLGC_WANTARROWS; /* Windows returns this value */
case WM_PAINT:
{
PAINTSTRUCT Ps;
HDC Dc;
Dc = (0 != wParam ? (HDC) wParam : BeginPaint(Wnd, &Ps));
if (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_SIZEGRIP)
{
IntScrollDrawSizeGrip(Wnd, Dc);
}
else if (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_SIZEBOX))
{
RECT Rect;
GetClientRect(Wnd, &Rect);
FillRect(Dc, &Rect, GetSysColorBrush(COLOR_SCROLLBAR));
}
else
{
IntDrawScrollBar(Wnd, Dc, SB_CTL/*, TRUE, TRUE*/);
}
if (0 == wParam)
{
EndPaint(Wnd, &Ps);
}
}
break;
case SBM_GETPOS:
return pSBWnd->SBCalc.pos;
case SBM_GETRANGE:
*(LPINT)wParam = pSBWnd->SBCalc.posMin;
*(LPINT)lParam = pSBWnd->SBCalc.posMax;
// This message does not return a value.
return 0;
case SBM_ENABLE_ARROWS:
return EnableScrollBar( Wnd, SB_CTL, wParam );
case SBM_SETPOS:
{
ScrollInfo.cbSize = sizeof(SCROLLINFO);
ScrollInfo.fMask = SIF_POS|SIF_PREVIOUSPOS;
ScrollInfo.nPos = wParam;
return IntSetScrollInfo(Wnd, &ScrollInfo, lParam);
}
case SBM_SETRANGEREDRAW:
case SBM_SETRANGE:
{
ScrollInfo.cbSize = sizeof(SCROLLINFO);
ScrollInfo.fMask = SIF_RANGE|SIF_PREVIOUSPOS;
ScrollInfo.nMin = wParam;
ScrollInfo.nMax = lParam;
return IntSetScrollInfo(Wnd, &ScrollInfo, Msg == SBM_SETRANGEREDRAW ? TRUE : FALSE);
}
case SBM_SETSCROLLINFO:
return IntSetScrollInfo(Wnd, (LPCSCROLLINFO)lParam, wParam);
case SBM_GETSCROLLINFO:
{
PSBDATA pSBData = (PSBDATA)&pSBWnd->SBCalc;
DWORD ret = NtUserSBGetParms(Wnd, SB_CTL, pSBData, (SCROLLINFO *) lParam);
if (!ret)
{
ERR("SBM_GETSCROLLINFO No ScrollInfo\n");
}
return ret;
}
case SBM_GETSCROLLBARINFO:
((PSCROLLBARINFO)lParam)->cbSize = sizeof(SCROLLBARINFO);
return NtUserGetScrollBarInfo(Wnd, OBJID_CLIENT, (PSCROLLBARINFO)lParam);
case 0x00e5:
case 0x00e7:
case 0x00e8:
case 0x00ec:
case 0x00ed:
case 0x00ee:
case 0x00ef:
WARN("unknown Win32 msg %04x wp=%08lx lp=%08lx\n",
Msg, wParam, lParam );
break;
default:
if (WM_USER <= Msg)
{
WARN("unknown msg %04x wp=%04lx lp=%08lx\n", Msg, wParam, lParam);
}
if (unicode)
return DefWindowProcW( Wnd, Msg, wParam, lParam );
else
return DefWindowProcA( Wnd, Msg, wParam, lParam );
}
return 0;
}
