void Unhook(HWND winamp)
{
if (winamp && waProc)
SetWindowLongW(winamp, GWLP_WNDPROC, (LONG_PTR)waProc);
waProc=0;
}
DockWnd::DockWnd(QWidget *main)
: QWidget(NULL)
{
#ifndef WIN32
wharfIcon = NULL;
#endif
connect(this, SIGNAL(toggleWin()), main, SLOT(toggleShow()));
connect(this, SIGNAL(showPopup(QPoint)), main, SLOT(showPopup(QPoint)));
connect(pClient, SIGNAL(event(ICQEvent*)), this, SLOT(processEvent(ICQEvent*)));
connect(pClient, SIGNAL(messageRead(ICQMessage*)), this, SLOT(messageRead(ICQMessage*)));
connect(pClient, SIGNAL(messageReceived(ICQMessage*)), this, SLOT(messageReceived(ICQMessage*)));
connect(pMain, SIGNAL(iconChanged()), this, SLOT(reset()));
m_state = 0;
showIcon = State;
QTimer *t = new QTimer(this);
connect(t, SIGNAL(timeout()), this, SLOT(timer()));
t->start(800);
bool bWMDock = false;
#ifndef WIN32
Atom r_type;
int r_format;
unsigned long count, bytes_remain;
unsigned char *prop = NULL, *prop2 = NULL;
Atom _XA_WIN_SUPPORTING_WM_CHECK = XInternAtom(qt_xdisplay(), XA_WIN_SUPPORTING_WM_CHECK, False);
int p = XGetWindowProperty(qt_xdisplay(), qt_xrootwin(), _XA_WIN_SUPPORTING_WM_CHECK,
0, 1, False, XA_CARDINAL, &r_type, &r_format,
&count, &bytes_remain, &prop);
if (p == Success && prop && r_type == XA_CARDINAL &&
r_format == 32 && count == 1)
{
Window n = *(long *) prop;
p = XGetWindowProperty(qt_xdisplay(), n, _XA_WIN_SUPPORTING_WM_CHECK, 0, 1,
False, XA_CARDINAL, &r_type, &r_format,
&count, &bytes_remain, &prop2);
if (p == Success && prop2 && r_type == XA_CARDINAL &&
r_format == 32 && count == 1)
bWMDock = true;
}
if (prop)
XFree(prop);
if (prop2)
XFree(prop2);
#endif
#ifdef USE_KDE
log(L_DEBUG, "WM props? %u", bWMDock);
if (!bWMDock)
KWin::setSystemTrayWindowFor( winId(), main->topLevelWidget()->winId());
#endif
needToggle = false;
#ifdef WIN32
QWidget::hide();
QWidget::setIcon(Pict(pClient->getStatusIcon()));
gDock = this;
oldDockProc = (WNDPROC)SetWindowLongW(winId(), GWL_WNDPROC, (LONG)DockWindowProc);
if (oldDockProc == 0)
oldDockProc = (WNDPROC)SetWindowLongA(winId(), GWL_WNDPROC, (LONG)DockWindowProc);
NOTIFYICONDATAA notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.szTip[0] = 0;
notifyIconData.uCallbackMessage = WM_DOCK;
notifyIconData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
notifyIconData.uID = 0;
Shell_NotifyIconA(NIM_ADD, ¬ifyIconData);
#else
if (!bWMDock){
setBackgroundMode(X11ParentRelative);
setIcon(Pict(pClient->getStatusIcon()));
#ifdef USE_KDE
show();
#else
hide();
#endif
}else{
wharfIcon = new WharfIcon(this);
Display *dsp = x11Display();
WId win = winId();
XWMHints *hints;
XClassHint classhint;
classhint.res_name = (char*)"sim";
classhint.res_class = (char*)"sim";
XSetClassHint(dsp, win, &classhint);
hints = XGetWMHints(dsp, win);
hints->initial_state = WithdrawnState;
hints->icon_x = 0;
hints->icon_y = 0;
hints->icon_window = wharfIcon->winId();
hints->window_group = win;
hints->flags = WindowGroupHint | IconWindowHint | IconPositionHint | StateHint;
XSetWMHints(dsp, win, hints);
XFree( hints );
XSetCommand(dsp, winId(), _argv, _argc);
resize(64, 64);
show();
}
#endif
loadUnread();
reset();
}
void Hook(HWND winamp)
{
if (winamp)
waProc = (WNDPROC)SetWindowLongW(winamp, GWLP_WNDPROC, (LONG_PTR)wa_newWndProc);
}
static inline void set_button_state( HWND hwnd, LONG state )
{
SetWindowLongW( hwnd, STATE_GWL_OFFSET, state );
}
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;
}
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);
}
DockWnd::DockWnd(DockPlugin *plugin, const char *icon, const char *text)
: QWidget(NULL, "dock", WType_TopLevel | WStyle_Customize | WStyle_NoBorder | WStyle_StaysOnTop),
EventReceiver(LowPriority)
{
#ifndef WIN32
#ifndef QT_MACOSX_VERSION
wharfIcon = NULL;
#endif
#endif
m_plugin = plugin;
setMouseTracking(true);
bNoToggle = false;
bBlink = false;
m_state = icon;
blinkTimer = new QTimer(this);
connect(blinkTimer, SIGNAL(timeout()), this, SLOT(blink()));
#ifdef WIN32
hShell = NULL;
setIcon(icon);
QWidget::hide();
gDock = this;
if (IsWindowUnicode(winId())){
(HMODULE&)hShell = LoadLibraryA("shell32.dll");
if (hShell)
(DWORD&)_Shell_NotifyIconW = (DWORD)GetProcAddress((HMODULE)hShell, "Shell_NotifyIconW");
}
if (IsWindowUnicode(winId()) && _Shell_NotifyIconW){
oldDockProc = (WNDPROC)SetWindowLongW(winId(), GWL_WNDPROC, (LONG)DockWindowProc);
NOTIFYICONDATAW notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.szTip[0] = 0;
notifyIconData.uCallbackMessage = WM_DOCK;
notifyIconData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
notifyIconData.uID = 0;
_Shell_NotifyIconW(NIM_ADD, ¬ifyIconData);
}else{
oldDockProc = (WNDPROC)SetWindowLongA(winId(), GWL_WNDPROC, (LONG)DockWindowProc);
NOTIFYICONDATAA notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.szTip[0] = 0;
notifyIconData.uCallbackMessage = WM_DOCK;
notifyIconData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
notifyIconData.uID = 0;
Shell_NotifyIconA(NIM_ADD, ¬ifyIconData);
}
#else
setMinimumSize(22, 22);
resize(22, 22);
#ifndef QT_MACOSX_VERSION
bInit = false;
inTray = false;
inNetTray = false;
Display *dsp = x11Display();
WId win = winId();
bool bEnlightenment = false;
QWidget tmp;
Atom enlightenment_desktop = XInternAtom(dsp, "ENLIGHTENMENT_DESKTOP", false);
WId w = tmp.winId();
Window p, r;
Window *c;
unsigned int nc;
while (XQueryTree(dsp, w, &r, &p, &c, &nc)){
if (c && nc > 0)
XFree(c);
if (! p) {
log(L_WARN, "No parent");
break;
}
unsigned char *data_ret = NULL;
Atom type_ret;
int i_unused;
unsigned long l_unused;
if ((XGetWindowProperty(dsp, p, enlightenment_desktop, 0, 1, False, XA_CARDINAL,
&type_ret, &i_unused, &l_unused, &l_unused,
&data_ret) == Success) && (type_ret == XA_CARDINAL)) {
if (data_ret)
XFree(data_ret);
bEnlightenment = true;
log(L_DEBUG, "Detect Enlightenment");
break;
}
if (p == r) break;
w = p;
}
if (bEnlightenment){
bInit = true;
resize(48, 48);
setFocusPolicy(NoFocus);
move(m_plugin->getDockX(), m_plugin->getDockY());
MWMHints mwm;
mwm.flags = MWM_HINTS_DECORATIONS;
mwm.functions = 0;
mwm.decorations = 0;
mwm.inputMode = 0;
mwm.status = 0;
Atom a = XInternAtom(dsp, "_MOTIF_WM_HINTS", False);
XChangeProperty(dsp, win, a, a, 32, PropModeReplace,
(unsigned char *)&mwm, sizeof(MWMHints) / 4);
XStoreName(dsp, win, "SIM");
XClassHint *xch = XAllocClassHint();
xch->res_name = (char*)"SIM";
xch->res_class = (char*)"Epplet";
XSetClassHint(dsp, win, xch);
XFree(xch);
XSetIconName(dsp, win, "SIM");
unsigned long val = (1 << 0) /* | (1 << 9) */ ;
a = XInternAtom(dsp, "_WIN_STATE", False);
XChangeProperty(dsp, win, a, XA_CARDINAL, 32, PropModeReplace,
(unsigned char *)&val, 1);
val = 2;
a = XInternAtom(dsp, "_WIN_LAYER", False);
XChangeProperty(dsp, win, a, XA_CARDINAL, 32, PropModeReplace,
(unsigned char *)&val, 1);
val = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 5);
a = XInternAtom(dsp, "_WIN_HINTS", False);
XChangeProperty(dsp, win, a, XA_CARDINAL, 32, PropModeReplace,
(unsigned char *)&val, 1);
win_name = "SIM";
win_version = VERSION;
win_info = "";
while (!comms_win)
{
ECommsSetup(dsp);
sleep(1);
}
char s[256];
snprintf(s, sizeof(s), "set clientname %s", win_name);
ECommsSend(s);
snprintf(s, sizeof(s), "set version %s", win_version);
ECommsSend(s);
snprintf(s, sizeof(s), "set info %s", win_info);
ECommsSend(s);
ESYNC;
set_background_properties(this);
setIcon(icon);
show();
return;
}
wharfIcon = new WharfIcon(this);
#endif
setBackgroundMode(X11ParentRelative);
setIcon(icon);
#ifndef QT_MACOSX_VERSION
XClassHint classhint;
classhint.res_name = (char*)"sim";
classhint.res_class = (char*)"Wharf";
XSetClassHint(dsp, win, &classhint);
Screen *screen = XDefaultScreenOfDisplay(dsp);
int screen_id = XScreenNumberOfScreen(screen);
char buf[32];
snprintf(buf, sizeof(buf), "_NET_SYSTEM_TRAY_S%d", screen_id);
Atom selection_atom = XInternAtom(dsp, buf, false);
XGrabServer(dsp);
Window manager_window = XGetSelectionOwner(dsp, selection_atom);
if (manager_window != None)
XSelectInput(dsp, manager_window, StructureNotifyMask);
XUngrabServer(dsp);
XFlush(dsp);
if (manager_window != None){
inNetTray = true;
if (!send_message(dsp, manager_window, SYSTEM_TRAY_REQUEST_DOCK, win, 0, 0)){
inNetTray = false;
}
}
Atom kde_net_system_tray_window_for_atom = XInternAtom(dsp, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", false);
long data[1];
data[0] = 0;
XChangeProperty(dsp, win, kde_net_system_tray_window_for_atom, XA_WINDOW,
32, PropModeReplace,
(unsigned char*)data, 1);
XWMHints *hints;
hints = XGetWMHints(dsp, win);
hints->initial_state = WithdrawnState;
hints->icon_x = 0;
hints->icon_y = 0;
hints->icon_window = wharfIcon->winId();
hints->window_group = win;
hints->flags = WindowGroupHint | IconWindowHint | IconPositionHint | StateHint;
XSetWMHints(dsp, win, hints);
XFree( hints );
Event eArgc(EventArgc);
int argc = (int)eArgc.process();
Event eArgv(EventArgv);
char **argv = (char**)eArgv.process();
XSetCommand(dsp, win, argv, argc);
if (!inNetTray){
move(-21, -21);
resize(22, 22);
}
#endif
show();
#endif
setTip(text);
reset();
}
/**********************************************************************
* The button control subclass window proc.
*/
LRESULT CALLBACK THEMING_ButtonSubclassProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam,
ULONG_PTR dwRefData)
{
const WCHAR* themeClass = WC_BUTTONW;
HTHEME theme;
LRESULT result;
switch (msg)
{
case WM_CREATE:
result = THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
OpenThemeData(hwnd, themeClass);
return result;
case WM_DESTROY:
theme = GetWindowTheme(hwnd);
CloseThemeData (theme);
return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
case WM_THEMECHANGED:
theme = GetWindowTheme(hwnd);
CloseThemeData (theme);
OpenThemeData(hwnd, themeClass);
break;
case WM_SYSCOLORCHANGE:
theme = GetWindowTheme(hwnd);
if (!theme) return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
/* Do nothing. When themed, a WM_THEMECHANGED will be received, too,
* which will do the repaint. */
break;
case WM_PAINT:
theme = GetWindowTheme(hwnd);
if (theme && BUTTON_Paint(theme, hwnd, (HDC)wParam))
return 0;
else
return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
case WM_ENABLE:
theme = GetWindowTheme(hwnd);
if (theme) {
RedrawWindow(hwnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW);
return 0;
} else
return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
case WM_MOUSEMOVE:
{
TRACKMOUSEEVENT mouse_event;
mouse_event.cbSize = sizeof(TRACKMOUSEEVENT);
mouse_event.dwFlags = TME_QUERY;
if(!TrackMouseEvent(&mouse_event) || !(mouse_event.dwFlags&(TME_HOVER|TME_LEAVE)))
{
mouse_event.dwFlags = TME_HOVER|TME_LEAVE;
mouse_event.hwndTrack = hwnd;
mouse_event.dwHoverTime = 1;
TrackMouseEvent(&mouse_event);
}
break;
}
case WM_MOUSEHOVER:
{
int state = (int)SendMessageW(hwnd, BM_GETSTATE, 0, 0);
SetWindowLongW(hwnd, 0, state|BST_HOT);
InvalidateRect(hwnd, NULL, FALSE);
break;
}
case WM_MOUSELEAVE:
{
int state = (int)SendMessageW(hwnd, BM_GETSTATE, 0, 0);
SetWindowLongW(hwnd, 0, state&(~BST_HOT));
InvalidateRect(hwnd, NULL, FALSE);
break;
}
case BM_SETCHECK:
case BM_SETSTATE:
theme = GetWindowTheme(hwnd);
if (theme) {
InvalidateRect(hwnd, NULL, FALSE);
}
return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
default:
/* Call old proc */
return THEMING_CallOriginalClass(hwnd, msg, wParam, lParam);
}
return 0;
}
/* some tests designed to show that Horizontal and Vertical
* window scroll bar info are not created independently */
static void scrollbar_test_default( DWORD style)
{
INT min, max, ret;
DWORD winstyle;
HWND hwnd;
SCROLLINFO si = { sizeof( SCROLLINFO), SIF_TRACKPOS };
hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
0, 0, 10, 10, 0, 0, 0, NULL);
assert( hwnd != 0);
ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
ok( ret ||
broken( !ret) /* Win 9x/ME */ , "GetScrollRange failed.\n");
/* range is 0,0 if there are no H or V scroll bars. 0,100 otherwise */
if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
ok( min == 0 && max == 0,
"Scroll bar range is %d,%d. Expected 0,0. Style %08x\n", min, max, style);
else
ok(( min == 0 && max == 100) ||
broken( min == 0 && max == 0), /* Win 9x/ME */
"Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
ret = GetScrollRange( hwnd, SB_HORZ, &min, &max);
ok( ret ||
broken( !ret) /* Win 9x/ME */ , "GetScrollRange failed.\n");
/* range is 0,0 if there are no H or V scroll bars. 0,100 otherwise */
if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
ok( min == 0 && max == 0,
"Scroll bar range is %d,%d. Expected 0,0. Style %08x\n", min, max, style);
else
ok(( min == 0 && max == 100) ||
broken( min == 0 && max == 0), /* Win 9x/ME */
"Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
/* test GetScrollInfo, vist for vertical SB */
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should fail if no H or V scroll bar styles are present. Succeed otherwise */
if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
else
ok( ret ||
broken( !ret), /* Win 9x/ME */
"GetScrollInfo failed unexpectedly. Style is %08x\n", style);
/* Same for Horizontal SB */
ret = GetScrollInfo( hwnd, SB_HORZ, &si);
/* should fail if no H or V scroll bar styles are present. Succeed otherwise */
if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
else
ok( ret ||
broken( !ret), /* Win 9x/ME */
"GetScrollInfo failed unexpectedly. Style is %08x\n", style);
/* now set the Vertical Scroll range to something that could be the default value it
* already has */;
ret = SetScrollRange( hwnd, SB_VERT, 0, 100, FALSE);
ok( ret, "SetScrollRange failed.\n");
/* and request the Horizontal range */
ret = GetScrollRange( hwnd, SB_HORZ, &min, &max);
ok( ret, "GetScrollRange failed.\n");
/* now the range should be 0,100 in ALL cases */
ok( min == 0 && max == 100,
"Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
/* See what is different now for GetScrollRange */
ret = GetScrollInfo( hwnd, SB_HORZ, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
/* report the windows style */
winstyle = GetWindowLongA( hwnd, GWL_STYLE );
/* WS_VSCROLL added to the window style */
if( !(style & WS_VSCROLL))
{
if (bThemeActive || style != WS_HSCROLL)
todo_wine
ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == ( style | WS_VSCROLL),
"unexpected style change %08x/%08x\n", winstyle, style);
else
ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == style,
"unexpected style change %08x/%08x\n", winstyle, style);
}
/* do the test again with H and V reversed.
* Start with a clean window */
DestroyWindow( hwnd);
hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
0, 0, 10, 10, 0, 0, 0, NULL);
assert( hwnd != 0);
/* Set Horizontal Scroll range to something that could be the default value it
* already has */;
ret = SetScrollRange( hwnd, SB_HORZ, 0, 100, FALSE);
ok( ret, "SetScrollRange failed.\n");
/* and request the Vertical range */
ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
ok( ret, "GetScrollRange failed.\n");
/* now the range should be 0,100 in ALL cases */
ok( min == 0 && max == 100,
"Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
/* See what is different now for GetScrollRange */
ret = GetScrollInfo( hwnd, SB_HORZ, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
/* report the windows style */
winstyle = GetWindowLongA( hwnd, GWL_STYLE );
/* WS_HSCROLL added to the window style */
if( !(style & WS_HSCROLL))
{
if (bThemeActive || style != WS_VSCROLL)
todo_wine
ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == ( style | WS_HSCROLL),
"unexpected style change %08x/%08x\n", winstyle, style);
else
ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == style,
"unexpected style change %08x/%08x\n", winstyle, style);
}
/* Slightly change the test to use SetScrollInfo
* Start with a clean window */
DestroyWindow( hwnd);
hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
0, 0, 10, 10, 0, 0, 0, NULL);
assert( hwnd != 0);
/* set Horizontal position with SetScrollInfo */
si.nPos = 0;
si.nMin = 11;
si.nMax = 22;
si.fMask |= SIF_RANGE;
ret = SetScrollInfo( hwnd, SB_HORZ, &si, FALSE);
ok( ret, "SetScrollInfo failed. Style is %08x\n", style);
/* and request the Vertical range */
ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
ok( ret, "GetScrollRange failed.\n");
/* now the range should be 0,100 in ALL cases */
ok( min == 0 && max == 100,
"Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
/* See what is different now for GetScrollRange */
ret = GetScrollInfo( hwnd, SB_HORZ, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should succeed in ALL cases */
ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
/* also test if the window scroll bars are enabled */
ret = EnableScrollBar( hwnd, SB_VERT, ESB_ENABLE_BOTH);
ok( !ret, "Vertical window scroll bar was not enabled\n");
ret = EnableScrollBar( hwnd, SB_HORZ, ESB_ENABLE_BOTH);
ok( !ret, "Horizontal window scroll bar was not enabled\n");
DestroyWindow( hwnd);
/* finally, check if adding a WS_[HV]SCROLL style of a window makes the scroll info
* available */
if( style & (WS_HSCROLL | WS_VSCROLL)) return;/* only test if not yet set */
/* Start with a clean window */
DestroyWindow( hwnd);
hwnd = CreateWindowExA( 0, "static", "", WS_POPUP ,
0, 0, 10, 10, 0, 0, 0, NULL);
assert( hwnd != 0);
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should fail */
ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
/* add scroll styles */
winstyle = GetWindowLongA( hwnd, GWL_STYLE );
SetWindowLongW( hwnd, GWL_STYLE, winstyle | WS_VSCROLL | WS_HSCROLL);
ret = GetScrollInfo( hwnd, SB_VERT, &si);
/* should still fail */
ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
/* clean up */
DestroyWindow( hwnd);
}
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);
}
}
/***********************************************************************
* 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 & ~0x0f) | BS_PUSHBUTTON;
WIN_SetStyle( hWnd, style, 0x0f & ~style );
}
set_button_state( hWnd, BUTTON_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:
if (btnPaintFunc[btn_type])
{
PAINTSTRUCT ps;
HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
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 & BUTTON_HIGHLIGHTED))
{
ReleaseCapture();
break;
}
SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
ReleaseCapture();
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 & BUTTON_CHECKED), 0 );
break;
case BS_AUTORADIOBUTTON:
SendMessageW( hWnd, BM_SETCHECK, TRUE, 0 );
break;
case BS_AUTO3STATE:
SendMessageW( hWnd, BM_SETCHECK,
(state & BUTTON_3STATE) ? 0 : ((state & 3) + 1), 0 );
break;
}
BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
}
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 & BUTTON_HIGHLIGHTED) 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) | BUTTON_HASFOCUS );
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 & ~BUTTON_HASFOCUS );
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:
if ((wParam & 0x0f) >= MAX_BTN_TYPE) break;
btn_type = wParam & 0x0f;
style = (style & ~0x0f) | btn_type;
WIN_SetStyle( hWnd, style, 0x0f & ~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) style |= WS_TABSTOP;
else style &= ~WS_TABSTOP;
SetWindowLongW( hWnd, GWL_STYLE, style );
}
if ((state & 3) != wParam)
{
set_button_state( hWnd, (state & ~3) | wParam );
paint_button( hWnd, btn_type, ODA_SELECT );
}
if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BUTTON_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)
{
if (state & BUTTON_HIGHLIGHTED) break;
set_button_state( hWnd, state | BUTTON_HIGHLIGHTED );
}
else
{
if (!(state & BUTTON_HIGHLIGHTED)) break;
set_button_state( hWnd, state & ~BUTTON_HIGHLIGHTED );
}
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;
}
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);
}
/***********************************************************************
* 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 );
}
}
/***********************************************************************
* UpDownWndProc
*/
static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
static const WCHAR themeClass[] = {'S','p','i','n',0};
HTHEME theme;
TRACE("hwnd=%p msg=%04x wparam=%08lx lparam=%08lx\n", hwnd, message, wParam, lParam);
if (!infoPtr && (message != WM_CREATE))
return DefWindowProcW (hwnd, message, wParam, lParam);
switch(message)
{
case WM_CREATE:
{
CREATESTRUCTW *pcs = (CREATESTRUCTW*)lParam;
infoPtr = Alloc (sizeof(UPDOWN_INFO));
SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
/* initialize the info struct */
infoPtr->Self = hwnd;
infoPtr->Notify = pcs->hwndParent;
infoPtr->dwStyle = pcs->style;
infoPtr->AccelCount = 0;
infoPtr->AccelVect = 0;
infoPtr->AccelIndex = -1;
infoPtr->CurVal = 0;
infoPtr->MinVal = 100;
infoPtr->MaxVal = 0;
infoPtr->Base = 10; /* Default to base 10 */
infoPtr->Buddy = 0; /* No buddy window yet */
infoPtr->Flags = (infoPtr->dwStyle & UDS_SETBUDDYINT) ? FLAG_BUDDYINT : 0;
SetWindowLongW (hwnd, GWL_STYLE, infoPtr->dwStyle & ~WS_BORDER);
if (!(infoPtr->dwStyle & UDS_HORZ))
SetWindowPos (hwnd, NULL, 0, 0, DEFAULT_WIDTH, pcs->cy,
SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
/* Do we pick the buddy win ourselves? */
if (infoPtr->dwStyle & UDS_AUTOBUDDY)
UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV));
OpenThemeData (hwnd, themeClass);
TRACE("UpDown Ctrl creation, hwnd=%p\n", hwnd);
}
break;
case WM_DESTROY:
Free (infoPtr->AccelVect);
if (infoPtr->Buddy)
RemoveWindowSubclass(infoPtr->Buddy, UPDOWN_Buddy_SubclassProc,
BUDDY_SUBCLASSID);
Free (infoPtr);
SetWindowLongPtrW (hwnd, 0, 0);
theme = GetWindowTheme (hwnd);
CloseThemeData (theme);
TRACE("UpDown Ctrl destruction, hwnd=%p\n", hwnd);
break;
case WM_ENABLE:
if (wParam) {
infoPtr->dwStyle &= ~WS_DISABLED;
} else {
infoPtr->dwStyle |= WS_DISABLED;
UPDOWN_CancelMode (infoPtr);
}
InvalidateRect (infoPtr->Self, NULL, FALSE);
break;
case WM_STYLECHANGED:
if (wParam == GWL_STYLE) {
infoPtr->dwStyle = ((LPSTYLESTRUCT)lParam)->styleNew;
InvalidateRect (infoPtr->Self, NULL, FALSE);
}
break;
case WM_THEMECHANGED:
theme = GetWindowTheme (hwnd);
CloseThemeData (theme);
OpenThemeData (hwnd, themeClass);
InvalidateRect (hwnd, NULL, FALSE);
break;
case WM_TIMER:
/* is this the auto-press timer? */
if(wParam == TIMER_AUTOPRESS) {
KillTimer(hwnd, TIMER_AUTOPRESS);
infoPtr->Flags &= ~(FLAG_PRESSED | FLAG_ARROW);
InvalidateRect(infoPtr->Self, NULL, FALSE);
}
/* if initial timer, kill it and start the repeat timer */
if(wParam == TIMER_AUTOREPEAT) {
INT delay;
KillTimer(hwnd, TIMER_AUTOREPEAT);
/* if no accel info given, used default timer */
if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0) {
infoPtr->AccelIndex = -1;
delay = REPEAT_DELAY;
} else {
infoPtr->AccelIndex = 0; /* otherwise, use it */
delay = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1;
}
SetTimer(hwnd, TIMER_ACCEL, delay, 0);
}
/* now, if the mouse is above us, do the thing...*/
if(infoPtr->Flags & FLAG_MOUSEIN) {
int temp;
temp = infoPtr->AccelIndex == -1 ? 1 : infoPtr->AccelVect[infoPtr->AccelIndex].nInc;
UPDOWN_DoAction(infoPtr, temp, infoPtr->Flags & FLAG_ARROW);
if(infoPtr->AccelIndex != -1 && infoPtr->AccelIndex < infoPtr->AccelCount-1) {
KillTimer(hwnd, TIMER_ACCEL);
infoPtr->AccelIndex++; /* move to the next accel info */
temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1;
/* make sure we have at least 1ms intervals */
SetTimer(hwnd, TIMER_ACCEL, temp, 0);
}
}
break;
case WM_CANCELMODE:
return UPDOWN_CancelMode (infoPtr);
case WM_LBUTTONUP:
if (GetCapture() != infoPtr->Self) break;
if ( (infoPtr->Flags & FLAG_MOUSEIN) &&
(infoPtr->Flags & FLAG_ARROW) ) {
SendMessageW( infoPtr->Notify,
(infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL,
MAKELONG(SB_ENDSCROLL, infoPtr->CurVal),
(LPARAM)hwnd);
if (UPDOWN_IsBuddyEdit(infoPtr))
SendMessageW(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1));
}
UPDOWN_CancelMode(infoPtr);
break;
case WM_LBUTTONDOWN:
case WM_MOUSEMOVE:
case WM_MOUSELEAVE:
if(UPDOWN_IsEnabled(infoPtr))
UPDOWN_HandleMouseEvent (infoPtr, message, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
break;
case WM_MOUSEWHEEL:
UPDOWN_MouseWheel(infoPtr, wParam);
break;
case WM_KEYDOWN:
if((infoPtr->dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(infoPtr))
return UPDOWN_KeyPressed(infoPtr, (int)wParam);
break;
case WM_PRINTCLIENT:
case WM_PAINT:
return UPDOWN_Paint (infoPtr, (HDC)wParam);
case UDM_GETACCEL:
if (wParam==0 && lParam==0) return infoPtr->AccelCount;
if (wParam && lParam) {
int temp = min(infoPtr->AccelCount, wParam);
memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL));
return temp;
}
return 0;
case UDM_SETACCEL:
{
TRACE("UDM_SETACCEL\n");
if(infoPtr->AccelVect) {
Free (infoPtr->AccelVect);
infoPtr->AccelCount = 0;
infoPtr->AccelVect = 0;
}
if(wParam==0) return TRUE;
infoPtr->AccelVect = Alloc (wParam*sizeof(UDACCEL));
if(infoPtr->AccelVect == 0) return FALSE;
memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL));
infoPtr->AccelCount = wParam;
if (TRACE_ON(updown))
{
INT i;
for (i = 0; i < wParam; i++)
TRACE("%d: nSec %u nInc %u\n", i,
infoPtr->AccelVect[i].nSec, infoPtr->AccelVect[i].nInc);
}
return TRUE;
}
case UDM_GETBASE:
return infoPtr->Base;
case UDM_SETBASE:
TRACE("UpDown Ctrl new base(%ld), hwnd=%p\n", wParam, hwnd);
if (wParam==10 || wParam==16) {
WPARAM old_base = infoPtr->Base;
infoPtr->Base = wParam;
if (old_base != infoPtr->Base)
UPDOWN_SetBuddyInt(infoPtr);
return old_base;
}
break;
case UDM_GETBUDDY:
return (LRESULT)infoPtr->Buddy;
case UDM_SETBUDDY:
return (LRESULT)UPDOWN_SetBuddy (infoPtr, (HWND)wParam);
case UDM_GETPOS:
{
BOOL ret = UPDOWN_GetBuddyInt (infoPtr);
return MAKELONG(infoPtr->CurVal, ret ? 0 : 1);
}
case UDM_SETPOS:
{
int temp = (short)LOWORD(lParam);
TRACE("UpDown Ctrl new value(%d), hwnd=%p\n", temp, hwnd);
if(!UPDOWN_InBounds(infoPtr, temp)) {
if(temp < infoPtr->MinVal) temp = infoPtr->MinVal;
if(temp > infoPtr->MaxVal) temp = infoPtr->MaxVal;
}
wParam = infoPtr->CurVal;
infoPtr->CurVal = temp;
UPDOWN_SetBuddyInt (infoPtr);
return wParam; /* return prev value */
}
case UDM_GETRANGE:
return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal);
case UDM_SETRANGE:
/* we must have:
UD_MINVAL <= Max <= UD_MAXVAL
UD_MINVAL <= Min <= UD_MAXVAL
|Max-Min| <= UD_MAXVAL */
UPDOWN_SetRange(infoPtr, (short)lParam, (short)HIWORD(lParam));
break;
case UDM_GETRANGE32:
if (wParam) *(LPINT)wParam = infoPtr->MinVal;
if (lParam) *(LPINT)lParam = infoPtr->MaxVal;
break;
case UDM_SETRANGE32:
UPDOWN_SetRange(infoPtr, (INT)lParam, (INT)wParam);
break;
case UDM_GETPOS32:
{
BOOL ret = UPDOWN_GetBuddyInt (infoPtr);
if ((LPBOOL)lParam) *((LPBOOL)lParam) = !ret;
return infoPtr->CurVal;
}
case UDM_SETPOS32:
{
int temp;
if(!UPDOWN_InBounds(infoPtr, (int)lParam)) {
if((int)lParam < infoPtr->MinVal) lParam = infoPtr->MinVal;
if((int)lParam > infoPtr->MaxVal) lParam = infoPtr->MaxVal;
}
temp = infoPtr->CurVal; /* save prev value */
infoPtr->CurVal = (int)lParam; /* set the new value */
UPDOWN_SetBuddyInt (infoPtr);
return temp; /* return prev value */
}
case UDM_GETUNICODEFORMAT:
/* we lie a bit here, we're always using Unicode internally */
return infoPtr->UnicodeFormat;
case UDM_SETUNICODEFORMAT:
{
/* do we really need to honour this flag? */
int temp = infoPtr->UnicodeFormat;
infoPtr->UnicodeFormat = (BOOL)wParam;
return temp;
}
default:
if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam);
return DefWindowProcW (hwnd, message, wParam, lParam);
}
return 0;
}