explorerframe: Implement expansion of nodes.
[wine] / dlls / mciavi32 / wnd.c
1 /*
2  * Digital video MCI Wine Driver
3  *
4  * Copyright 1999, 2000 Eric POUECH
5  * Copyright 2003 Dmitry Timoshkov
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <string.h>
23 #include "private_mciavi.h"
24 #include "wine/debug.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
27
28 static const WCHAR mciaviW[] = {'M','C','I','A','V','I',0};
29
30 static LRESULT WINAPI MCIAVI_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
31 {
32     TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hWnd, uMsg, wParam, lParam);
33
34     switch (uMsg) {
35     case WM_CREATE:
36         SetWindowLongW(hWnd, 0, (LPARAM)((CREATESTRUCTW *)lParam)->lpCreateParams);
37         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
38
39     case WM_DESTROY:
40         MCIAVI_mciClose(GetWindowLongW(hWnd, 0), MCI_WAIT, NULL);
41         SetWindowLongW(hWnd, 0, 0);
42         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
43
44     case WM_ERASEBKGND:
45         {
46             RECT        rect;
47             GetClientRect(hWnd, &rect);
48             FillRect((HDC)wParam, &rect, GetStockObject(BLACK_BRUSH));
49         }
50        return 1;
51
52     case WM_PAINT:
53         {
54             WINE_MCIAVI *wma = (WINE_MCIAVI *)mciGetDriverData(GetWindowLongW(hWnd, 0));
55
56             if (!wma)
57                 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
58             
59             EnterCriticalSection(&wma->cs);
60
61             /* the animation isn't playing, don't paint */
62             if (wma->dwStatus == MCI_MODE_NOT_READY)
63             {
64                 LeaveCriticalSection(&wma->cs);
65                 /* default paint handling */
66                 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
67             }
68
69             if (wParam)
70                 MCIAVI_PaintFrame(wma, (HDC)wParam);
71             else
72             {
73                 PAINTSTRUCT ps;
74                 BeginPaint(hWnd, &ps);
75                 MCIAVI_PaintFrame(wma, ps.hdc);
76                 EndPaint(hWnd, &ps);
77             }
78
79             LeaveCriticalSection(&wma->cs);
80         }
81        return 1;
82
83     default:
84         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
85     }
86 }
87
88 BOOL MCIAVI_UnregisterClass(void)
89 {
90     return UnregisterClassW(mciaviW, MCIAVI_hInstance);
91 }
92
93 BOOL MCIAVI_RegisterClass(void)
94 {
95     WNDCLASSW wndClass;
96
97     ZeroMemory(&wndClass, sizeof(WNDCLASSW));
98     wndClass.style         = CS_DBLCLKS;
99     wndClass.lpfnWndProc   = MCIAVI_WindowProc;
100     wndClass.cbWndExtra    = sizeof(MCIDEVICEID);
101     wndClass.hInstance     = MCIAVI_hInstance;
102     wndClass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
103     wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
104     wndClass.lpszClassName = mciaviW;
105
106     if (RegisterClassW(&wndClass)) return TRUE;
107     if (GetLastError() == ERROR_CLASS_ALREADY_EXISTS) return TRUE;
108
109     return FALSE;
110 }
111
112 BOOL    MCIAVI_CreateWindow(WINE_MCIAVI* wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms)
113 {
114     static const WCHAR captionW[] = {'W','i','n','e',' ','M','C','I','-','A','V','I',' ','p','l','a','y','e','r',0};
115     HWND        hParent = 0;
116     DWORD       dwStyle = WS_OVERLAPPEDWINDOW;
117     RECT        rc;
118
119     /* what should be done ? */
120     if (wma->hWnd) return TRUE;
121
122     if (dwFlags & MCI_DGV_OPEN_PARENT)  hParent = lpOpenParms->hWndParent;
123     if (dwFlags & MCI_DGV_OPEN_WS)      dwStyle = lpOpenParms->dwStyle;
124
125     rc.left = rc.top = 0;
126     rc.right = (wma->hic ? wma->outbih : wma->inbih)->biWidth;
127     rc.bottom = (wma->hic ? wma->outbih : wma->inbih)->biHeight;
128     AdjustWindowRect(&rc, dwStyle, FALSE);
129     if (!(dwStyle & (WS_CHILD|WS_POPUP))) /* overlapped window ? */
130     {
131         rc.right -= rc.left;
132         rc.bottom -= rc.top;
133         rc.left = rc.top = CW_USEDEFAULT;
134     }
135
136     wma->hWnd = CreateWindowW(mciaviW, captionW,
137                               dwStyle, rc.left, rc.top,
138                               rc.right, rc.bottom,
139                               hParent, 0, MCIAVI_hInstance,
140                               ULongToPtr(wma->wDevID));
141     wma->hWndPaint = wma->hWnd;
142     return wma->hWnd != 0;
143 }
144
145 /***************************************************************************
146  *                              MCIAVI_mciPut                   [internal]
147  */
148 DWORD   MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
149 {
150     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
151     RECT                rc;
152
153     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
154
155     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
156     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
157     if (dwFlags & MCI_TEST)     return 0;
158
159     EnterCriticalSection(&wma->cs);
160
161     if (dwFlags & MCI_DGV_RECT) {
162         /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
163          * So convert input MCI RECT into a normal RECT */
164         rc.left = lpParms->rc.left;
165         rc.top = lpParms->rc.top;
166         rc.right = lpParms->rc.left + lpParms->rc.right;
167         rc.bottom = lpParms->rc.top + lpParms->rc.bottom;
168     } else {
169         GetClientRect(wma->hWndPaint, &rc);
170     }
171
172     if (dwFlags & MCI_DGV_PUT_CLIENT) {
173         FIXME("PUT_CLIENT %s\n", wine_dbgstr_rect(&rc));
174         LeaveCriticalSection(&wma->cs);
175         return MCIERR_UNRECOGNIZED_COMMAND;
176     }
177     if (dwFlags & MCI_DGV_PUT_DESTINATION) {
178         TRACE("PUT_DESTINATION %s\n", wine_dbgstr_rect(&rc));
179         wma->dest = rc;
180     }
181     if (dwFlags & MCI_DGV_PUT_FRAME) {
182         FIXME("PUT_FRAME %s\n", wine_dbgstr_rect(&rc));
183         LeaveCriticalSection(&wma->cs);
184         return MCIERR_UNRECOGNIZED_COMMAND;
185     }
186     if (dwFlags & MCI_DGV_PUT_SOURCE) {
187         TRACE("PUT_SOURCE %s\n", wine_dbgstr_rect(&rc));
188         wma->source = rc;
189     }
190     if (dwFlags & MCI_DGV_PUT_VIDEO) {
191         FIXME("PUT_VIDEO %s\n", wine_dbgstr_rect(&rc));
192         LeaveCriticalSection(&wma->cs);
193         return MCIERR_UNRECOGNIZED_COMMAND;
194     }
195     if (dwFlags & MCI_DGV_PUT_WINDOW) {
196         TRACE("PUT_WINDOW %s\n", wine_dbgstr_rect(&rc));
197         SetWindowPos(wma->hWndPaint, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER);
198     }
199     LeaveCriticalSection(&wma->cs);
200     return 0;
201 }
202
203 /******************************************************************************
204  *                              MCIAVI_mciWhere                 [internal]
205  */
206 DWORD   MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
207 {
208     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
209     RECT                rc;
210
211     TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
212
213     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
214     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
215     /* Ignore MCI_TEST flag. */
216
217     EnterCriticalSection(&wma->cs);
218
219     if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
220         if (dwFlags & MCI_DGV_WHERE_MAX) {
221             GetClientRect(wma->hWndPaint, &rc);
222             TRACE("WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
223         } else {
224             TRACE("WHERE_DESTINATION %s\n", wine_dbgstr_rect(&wma->dest));
225             rc = wma->dest;
226         }
227     }
228     if (dwFlags & MCI_DGV_WHERE_FRAME) {
229         if (dwFlags & MCI_DGV_WHERE_MAX)
230             FIXME("MCI_DGV_WHERE_FRAME_MAX\n");
231         else
232             FIXME("MCI_DGV_WHERE_FRAME\n");
233         LeaveCriticalSection(&wma->cs);
234         return MCIERR_UNRECOGNIZED_COMMAND;
235     }
236     if (dwFlags & MCI_DGV_WHERE_SOURCE) {
237         if (dwFlags & MCI_DGV_WHERE_MAX) {
238             rc.left = 0;
239             rc.top = 0;
240             rc.right = wma->inbih->biWidth;
241             rc.bottom = wma->inbih->biHeight;
242             TRACE("WHERE_SOURCE_MAX %s\n", wine_dbgstr_rect(&rc));
243         } else {
244             TRACE("WHERE_SOURCE %s\n", wine_dbgstr_rect(&wma->source));
245             rc = wma->source;
246         }
247     }
248     if (dwFlags & MCI_DGV_WHERE_VIDEO) {
249         if (dwFlags & MCI_DGV_WHERE_MAX)
250             FIXME("WHERE_VIDEO_MAX\n");
251         else
252             FIXME("WHERE_VIDEO\n");
253         LeaveCriticalSection(&wma->cs);
254         return MCIERR_UNRECOGNIZED_COMMAND;
255     }
256     if (dwFlags & MCI_DGV_WHERE_WINDOW) {
257         if (dwFlags & MCI_DGV_WHERE_MAX) {
258             GetWindowRect(GetDesktopWindow(), &rc);
259             TRACE("WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
260         } else {
261             GetWindowRect(wma->hWndPaint, &rc);
262             TRACE("WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
263         }
264     }
265
266     /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
267      * So convert the normal RECT into a MCI RECT before returning */
268     lpParms->rc.left = rc.left;
269     lpParms->rc.top = rc.top;
270     lpParms->rc.right = rc.right - rc.left;
271     lpParms->rc.bottom = rc.bottom - rc.top;
272
273     LeaveCriticalSection(&wma->cs);
274     return 0;
275 }
276
277 /***************************************************************************
278  *                              MCIAVI_mciWindow                        [internal]
279  */
280 DWORD   MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
281 {
282     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
283
284     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
285
286     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
287     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
288     if (dwFlags & MCI_TEST)     return 0;
289
290     EnterCriticalSection(&wma->cs);
291
292     if (dwFlags & MCI_DGV_WINDOW_HWND) {
293         if (IsWindow(lpParms->hWnd))
294         {
295             TRACE("Setting hWnd to %p\n", lpParms->hWnd);
296             if (wma->hWnd) ShowWindow(wma->hWnd, SW_HIDE);
297             wma->hWndPaint = (lpParms->hWnd == MCI_DGV_WINDOW_DEFAULT) ? wma->hWnd : lpParms->hWnd;
298         }
299     }
300     if (dwFlags & MCI_DGV_WINDOW_STATE) {
301         TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
302         ShowWindow(wma->hWndPaint, lpParms->nCmdShow);
303     }
304     if (dwFlags & MCI_DGV_WINDOW_TEXT) {
305         TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
306         SetWindowTextW(wma->hWndPaint, lpParms->lpstrText);
307     }
308
309     LeaveCriticalSection(&wma->cs);
310     return 0;
311 }