crypt32: Implement CertFindCRLInStore for find type CRL_FIND_ISSUED_FOR.
[wine] / dlls / hhctrl.ocx / help.c
1 /*
2  * Help Viewer Implementation
3  *
4  * Copyright 2005 James Hawkins
5  * Copyright 2007 Jacek Caban for CodeWeavers
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 "hhctrl.h"
23
24 #include "wingdi.h"
25 #include "commctrl.h"
26 #include "wininet.h"
27
28 #include "wine/debug.h"
29
30 #include "resource.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
33
34 static LRESULT Help_OnSize(HWND hWnd);
35
36 /* Window type defaults */
37
38 #define WINTYPE_DEFAULT_X           280
39 #define WINTYPE_DEFAULT_Y           100
40 #define WINTYPE_DEFAULT_WIDTH       740
41 #define WINTYPE_DEFAULT_HEIGHT      640
42 #define WINTYPE_DEFAULT_NAVWIDTH    250
43
44 #define TAB_TOP_PADDING     8
45 #define TAB_RIGHT_PADDING   4
46 #define TAB_MARGIN  8
47
48 static const WCHAR szEmpty[] = {0};
49
50 /* Loads a string from the resource file */
51 static LPWSTR HH_LoadString(DWORD dwID)
52 {
53     LPWSTR string = NULL;
54     LPCWSTR stringresource;
55     int iSize;
56
57     iSize = LoadStringW(hhctrl_hinstance, dwID, (LPWSTR)&stringresource, 0);
58
59     string = heap_alloc((iSize + 2) * sizeof(WCHAR)); /* some strings (tab text) needs double-null termination */
60     memcpy(string, stringresource, iSize*sizeof(WCHAR));
61     string[iSize] = 0;
62
63     return string;
64 }
65
66 static HRESULT navigate_url(HHInfo *info, LPCWSTR surl)
67 {
68     VARIANT url;
69     HRESULT hres;
70
71     TRACE("%s\n", debugstr_w(surl));
72
73     V_VT(&url) = VT_BSTR;
74     V_BSTR(&url) = SysAllocString(surl);
75
76     hres = IWebBrowser2_Navigate2(info->web_browser, &url, 0, 0, 0, 0);
77
78     VariantClear(&url);
79
80     if(FAILED(hres))
81         TRACE("Navigation failed: %08x\n", hres);
82
83     return hres;
84 }
85
86 BOOL NavigateToUrl(HHInfo *info, LPCWSTR surl)
87 {
88     ChmPath chm_path;
89     BOOL ret;
90     HRESULT hres;
91
92     static const WCHAR url_indicator[] = {':', '/', '/', 0};
93
94     TRACE("%s\n", debugstr_w(surl));
95
96     if (strstrW(surl, url_indicator)) {
97         hres = navigate_url(info, surl);
98         if(SUCCEEDED(hres))
99             return TRUE;
100     } /* look up in chm if it doesn't look like a full url */
101
102     SetChmPath(&chm_path, info->pCHMInfo->szFile, surl);
103     ret = NavigateToChm(info, chm_path.chm_file, chm_path.chm_index);
104
105     heap_free(chm_path.chm_file);
106     heap_free(chm_path.chm_index);
107
108     return ret;
109 }
110
111 BOOL NavigateToChm(HHInfo *info, LPCWSTR file, LPCWSTR index)
112 {
113     WCHAR buf[INTERNET_MAX_URL_LENGTH];
114     WCHAR full_path[MAX_PATH];
115     LPWSTR ptr;
116
117     static const WCHAR url_format[] =
118         {'m','k',':','@','M','S','I','T','S','t','o','r','e',':','%','s',':',':','%','s','%','s',0};
119     static const WCHAR slash[] = {'/',0};
120     static const WCHAR empty[] = {0};
121
122     TRACE("%p %s %s\n", info, debugstr_w(file), debugstr_w(index));
123
124     if (!info->web_browser)
125         return FALSE;
126
127     if(!GetFullPathNameW(file, sizeof(full_path)/sizeof(full_path[0]), full_path, NULL)) {
128         WARN("GetFullPathName failed: %u\n", GetLastError());
129         return FALSE;
130     }
131
132     wsprintfW(buf, url_format, full_path, (!index || index[0] == '/') ? empty : slash, index);
133
134     /* FIXME: HACK */
135     if((ptr = strchrW(buf, '#')))
136        *ptr = 0;
137
138     return SUCCEEDED(navigate_url(info, buf));
139 }
140
141 /* Size Bar */
142
143 #define SIZEBAR_WIDTH   4
144
145 static const WCHAR szSizeBarClass[] = {
146     'H','H',' ','S','i','z','e','B','a','r',0
147 };
148
149 /* Draw the SizeBar */
150 static void SB_OnPaint(HWND hWnd)
151 {
152     PAINTSTRUCT ps;
153     HDC hdc;
154     RECT rc;
155     
156     hdc = BeginPaint(hWnd, &ps);
157
158     GetClientRect(hWnd, &rc);
159
160     /* dark frame */
161     rc.right += 1;
162     rc.bottom -= 1;
163     FrameRect(hdc, &rc, GetStockObject(GRAY_BRUSH));
164
165     /* white highlight */
166     SelectObject(hdc, GetStockObject(WHITE_PEN));
167     MoveToEx(hdc, rc.right, 1, NULL);
168     LineTo(hdc, 1, 1);
169     LineTo(hdc, 1, rc.bottom - 1);
170
171     
172     MoveToEx(hdc, 0, rc.bottom, NULL);
173     LineTo(hdc, rc.right, rc.bottom);
174
175     EndPaint(hWnd, &ps);
176 }
177
178 static void SB_OnLButtonDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
179 {
180     SetCapture(hWnd);
181 }
182
183 static void SB_OnLButtonUp(HWND hWnd, WPARAM wParam, LPARAM lParam)
184 {
185     HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
186     POINT pt;
187
188     pt.x = (short)LOWORD(lParam);
189     pt.y = (short)HIWORD(lParam);
190
191     /* update the window sizes */
192     pHHInfo->WinType.iNavWidth += pt.x;
193     Help_OnSize(hWnd);
194
195     ReleaseCapture();
196 }
197
198 static void SB_OnMouseMove(HWND hWnd, WPARAM wParam, LPARAM lParam)
199 {
200     /* ignore WM_MOUSEMOVE if not dragging the SizeBar */
201     if (!(wParam & MK_LBUTTON))
202         return;
203 }
204
205 static LRESULT CALLBACK SizeBar_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
206 {
207     switch (message)
208     {
209         case WM_LBUTTONDOWN:
210             SB_OnLButtonDown(hWnd, wParam, lParam);
211             break;
212         case WM_LBUTTONUP:
213             SB_OnLButtonUp(hWnd, wParam, lParam);
214             break;
215         case WM_MOUSEMOVE:
216             SB_OnMouseMove(hWnd, wParam, lParam);
217             break;
218         case WM_PAINT:
219             SB_OnPaint(hWnd);
220             break;
221         default:
222             return DefWindowProcW(hWnd, message, wParam, lParam);
223     }
224
225     return 0;
226 }
227
228 static void HH_RegisterSizeBarClass(HHInfo *pHHInfo)
229 {
230     WNDCLASSEXW wcex;
231
232     wcex.cbSize         = sizeof(WNDCLASSEXW);
233     wcex.style          = 0;
234     wcex.lpfnWndProc    = SizeBar_WndProc;
235     wcex.cbClsExtra     = 0;
236     wcex.cbWndExtra     = 0;
237     wcex.hInstance      = hhctrl_hinstance;
238     wcex.hIcon          = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
239     wcex.hCursor        = LoadCursorW(NULL, (LPCWSTR)IDC_SIZEWE);
240     wcex.hbrBackground  = (HBRUSH)(COLOR_MENU + 1);
241     wcex.lpszMenuName   = NULL;
242     wcex.lpszClassName  = szSizeBarClass;
243     wcex.hIconSm        = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
244
245     RegisterClassExW(&wcex);
246 }
247
248 static void SB_GetSizeBarRect(HHInfo *info, RECT *rc)
249 {
250     RECT rectWND, rectTB, rectNP;
251
252     GetClientRect(info->WinType.hwndHelp, &rectWND);
253     GetClientRect(info->WinType.hwndToolBar, &rectTB);
254     GetClientRect(info->WinType.hwndNavigation, &rectNP);
255
256     rc->left = rectNP.right;
257     rc->top = rectTB.bottom;
258     rc->bottom = rectWND.bottom - rectTB.bottom;
259     rc->right = SIZEBAR_WIDTH;
260 }
261
262 static BOOL HH_AddSizeBar(HHInfo *pHHInfo)
263 {
264     HWND hWnd;
265     HWND hwndParent = pHHInfo->WinType.hwndHelp;
266     DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE | WS_OVERLAPPED;
267     DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
268     RECT rc;
269
270     SB_GetSizeBarRect(pHHInfo, &rc);
271
272     hWnd = CreateWindowExW(dwExStyles, szSizeBarClass, szEmpty, dwStyles,
273                            rc.left, rc.top, rc.right, rc.bottom,
274                            hwndParent, NULL, hhctrl_hinstance, NULL);
275     if (!hWnd)
276         return FALSE;
277
278     /* store the pointer to the HH info struct */
279     SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
280
281     pHHInfo->hwndSizeBar = hWnd;
282     return TRUE;
283 }
284
285 /* Child Window */
286
287 static const WCHAR szChildClass[] = {
288     'H','H',' ','C','h','i','l','d',0
289 };
290
291 static LRESULT Child_OnPaint(HWND hWnd)
292 {
293     PAINTSTRUCT ps;
294     HDC hdc;
295     RECT rc;
296
297     hdc = BeginPaint(hWnd, &ps);
298
299     /* Only paint the Navigation pane, identified by the fact
300      * that it has a child window
301      */
302     if (GetWindow(hWnd, GW_CHILD))
303     {
304         GetClientRect(hWnd, &rc);
305
306         /* set the border color */
307         SelectObject(hdc, GetStockObject(DC_PEN));
308         SetDCPenColor(hdc, GetSysColor(COLOR_BTNSHADOW));
309
310         /* Draw the top border */
311         LineTo(hdc, rc.right, 0);
312
313         SelectObject(hdc, GetStockObject(WHITE_PEN));
314         MoveToEx(hdc, 0, 1, NULL);
315         LineTo(hdc, rc.right, 1);
316     }
317
318     EndPaint(hWnd, &ps);
319
320     return 0;
321 }
322
323 static void ResizeTabChild(HHInfo *info, HWND hwnd)
324 {
325     RECT rect, tabrc;
326     DWORD cnt;
327
328     GetClientRect(info->WinType.hwndNavigation, &rect);
329     SendMessageW(info->hwndTabCtrl, TCM_GETITEMRECT, 0, (LPARAM)&tabrc);
330     cnt = SendMessageW(info->hwndTabCtrl, TCM_GETROWCOUNT, 0, 0);
331
332     rect.left = TAB_MARGIN;
333     rect.top = TAB_TOP_PADDING + cnt*(tabrc.bottom-tabrc.top) + TAB_MARGIN;
334     rect.right -= TAB_RIGHT_PADDING + TAB_MARGIN;
335     rect.bottom -= TAB_MARGIN;
336
337     SetWindowPos(hwnd, NULL, rect.left, rect.top, rect.right-rect.left,
338                  rect.bottom-rect.top, SWP_NOZORDER | SWP_NOACTIVATE);
339 }
340
341 static LRESULT Child_OnSize(HWND hwnd)
342 {
343     HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
344     RECT rect;
345
346     if(!info || hwnd != info->WinType.hwndNavigation)
347         return 0;
348
349     GetClientRect(hwnd, &rect);
350     SetWindowPos(info->hwndTabCtrl, HWND_TOP, 0, 0,
351                  rect.right - TAB_RIGHT_PADDING,
352                  rect.bottom - TAB_TOP_PADDING, SWP_NOMOVE);
353
354     ResizeTabChild(info, info->tabs[TAB_CONTENTS].hwnd);
355     return 0;
356 }
357
358 static LRESULT OnTabChange(HWND hwnd)
359 {
360     HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
361
362     TRACE("%p\n", hwnd);
363
364     if (!info)
365         return 0;
366
367     if(info->tabs[info->current_tab].hwnd)
368         ShowWindow(info->tabs[info->current_tab].hwnd, SW_HIDE);
369
370     info->current_tab = SendMessageW(info->hwndTabCtrl, TCM_GETCURSEL, 0, 0);
371
372     if(info->tabs[info->current_tab].hwnd)
373         ShowWindow(info->tabs[info->current_tab].hwnd, SW_SHOW);
374
375     return 0;
376 }
377
378 static LRESULT OnTopicChange(HWND hwnd, ContentItem *item)
379 {
380     HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
381     LPCWSTR chmfile = NULL;
382     ContentItem *iter = item;
383
384     if(!item || !info)
385         return 0;
386
387     TRACE("name %s loal %s\n", debugstr_w(item->name), debugstr_w(item->local));
388
389     while(iter) {
390         if(iter->merge.chm_file) {
391             chmfile = iter->merge.chm_file;
392             break;
393         }
394         iter = iter->parent;
395     }
396
397     NavigateToChm(info, chmfile, item->local);
398     return 0;
399 }
400
401 static LRESULT CALLBACK Child_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
402 {
403     switch (message)
404     {
405     case WM_PAINT:
406         return Child_OnPaint(hWnd);
407     case WM_SIZE:
408         return Child_OnSize(hWnd);
409     case WM_NOTIFY: {
410         NMHDR *nmhdr = (NMHDR*)lParam;
411         switch(nmhdr->code) {
412         case TCN_SELCHANGE:
413             return OnTabChange(hWnd);
414         case TVN_SELCHANGEDW:
415             return OnTopicChange(hWnd, (ContentItem*)((NMTREEVIEWW *)lParam)->itemNew.lParam);
416         }
417         break;
418     }
419     default:
420         return DefWindowProcW(hWnd, message, wParam, lParam);
421     }
422
423     return 0;
424 }
425
426 static void HH_RegisterChildWndClass(HHInfo *pHHInfo)
427 {
428     WNDCLASSEXW wcex;
429
430     wcex.cbSize         = sizeof(WNDCLASSEXW);
431     wcex.style          = 0;
432     wcex.lpfnWndProc    = Child_WndProc;
433     wcex.cbClsExtra     = 0;
434     wcex.cbWndExtra     = 0;
435     wcex.hInstance      = hhctrl_hinstance;
436     wcex.hIcon          = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
437     wcex.hCursor        = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
438     wcex.hbrBackground  = (HBRUSH)(COLOR_BTNFACE + 1);
439     wcex.lpszMenuName   = NULL;
440     wcex.lpszClassName  = szChildClass;
441     wcex.hIconSm        = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
442
443     RegisterClassExW(&wcex);
444 }
445
446 /* Toolbar */
447
448 #define ICON_SIZE   20
449
450 static void TB_OnClick(HWND hWnd, DWORD dwID)
451 {
452     HHInfo *info = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
453
454     switch (dwID)
455     {
456         case IDTB_STOP:
457             DoPageAction(info, WB_STOP);
458             break;
459         case IDTB_REFRESH:
460             DoPageAction(info, WB_REFRESH);
461             break;
462         case IDTB_BACK:
463             DoPageAction(info, WB_GOBACK);
464             break;
465         case IDTB_HOME:
466             NavigateToChm(info, info->pCHMInfo->szFile, info->WinType.pszHome);
467             break;
468         case IDTB_FORWARD:
469             DoPageAction(info, WB_GOFORWARD);
470             break;
471         case IDTB_EXPAND:
472         case IDTB_CONTRACT:
473         case IDTB_SYNC:
474         case IDTB_PRINT:
475         case IDTB_OPTIONS:
476         case IDTB_BROWSE_FWD:
477         case IDTB_BROWSE_BACK:
478         case IDTB_JUMP1:
479         case IDTB_JUMP2:
480         case IDTB_CUSTOMIZE:
481         case IDTB_ZOOM:
482         case IDTB_TOC_NEXT:
483         case IDTB_TOC_PREV:
484             break;
485     }
486 }
487
488 static void TB_AddButton(TBBUTTON *pButtons, DWORD dwIndex, DWORD dwID)
489 {
490     /* FIXME: Load the correct button bitmaps */
491     pButtons[dwIndex].iBitmap = STD_PRINT;
492     pButtons[dwIndex].idCommand = dwID;
493     pButtons[dwIndex].fsState = TBSTATE_ENABLED;
494     pButtons[dwIndex].fsStyle = BTNS_BUTTON;
495     pButtons[dwIndex].dwData = 0;
496     pButtons[dwIndex].iString = 0;
497 }
498
499 static void TB_AddButtonsFromFlags(TBBUTTON *pButtons, DWORD dwButtonFlags, LPDWORD pdwNumButtons)
500 {
501     *pdwNumButtons = 0;
502
503     if (dwButtonFlags & HHWIN_BUTTON_EXPAND)
504         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_EXPAND);
505
506     if (dwButtonFlags & HHWIN_BUTTON_BACK)
507         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_BACK);
508
509     if (dwButtonFlags & HHWIN_BUTTON_FORWARD)
510         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_FORWARD);
511
512     if (dwButtonFlags & HHWIN_BUTTON_STOP)
513         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_STOP);
514
515     if (dwButtonFlags & HHWIN_BUTTON_REFRESH)
516         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_REFRESH);
517
518     if (dwButtonFlags & HHWIN_BUTTON_HOME)
519         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_HOME);
520
521     if (dwButtonFlags & HHWIN_BUTTON_SYNC)
522         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_SYNC);
523
524     if (dwButtonFlags & HHWIN_BUTTON_OPTIONS)
525         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_OPTIONS);
526
527     if (dwButtonFlags & HHWIN_BUTTON_PRINT)
528         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_PRINT);
529
530     if (dwButtonFlags & HHWIN_BUTTON_JUMP1)
531         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_JUMP1);
532
533     if (dwButtonFlags & HHWIN_BUTTON_JUMP2)
534         TB_AddButton(pButtons,(*pdwNumButtons)++, IDTB_JUMP2);
535
536     if (dwButtonFlags & HHWIN_BUTTON_ZOOM)
537         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_ZOOM);
538
539     if (dwButtonFlags & HHWIN_BUTTON_TOC_NEXT)
540         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_NEXT);
541
542     if (dwButtonFlags & HHWIN_BUTTON_TOC_PREV)
543         TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_PREV);
544 }
545
546 static BOOL HH_AddToolbar(HHInfo *pHHInfo)
547 {
548     HWND hToolbar;
549     HWND hwndParent = pHHInfo->WinType.hwndHelp;
550     DWORD toolbarFlags;
551     TBBUTTON buttons[IDTB_TOC_PREV - IDTB_EXPAND];
552     TBADDBITMAP tbAB;
553     DWORD dwStyles, dwExStyles;
554     DWORD dwNumButtons, dwIndex;
555
556     if (pHHInfo->WinType.fsWinProperties & HHWIN_PARAM_TB_FLAGS)
557         toolbarFlags = pHHInfo->WinType.fsToolBarFlags;
558     else
559         toolbarFlags = HHWIN_DEF_BUTTONS;
560
561     TB_AddButtonsFromFlags(buttons, toolbarFlags, &dwNumButtons);
562
563     dwStyles = WS_CHILDWINDOW | WS_VISIBLE | TBSTYLE_FLAT |
564                TBSTYLE_WRAPABLE | TBSTYLE_TOOLTIPS | CCS_NODIVIDER;
565     dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
566
567     hToolbar = CreateWindowExW(dwExStyles, TOOLBARCLASSNAMEW, NULL, dwStyles,
568                                0, 0, 0, 0, hwndParent, NULL,
569                                hhctrl_hinstance, NULL);
570     if (!hToolbar)
571         return FALSE;
572
573     SendMessageW(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(ICON_SIZE, ICON_SIZE));
574     SendMessageW(hToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
575     SendMessageW(hToolbar, WM_SETFONT, (WPARAM)pHHInfo->hFont, TRUE);
576
577     /* FIXME: Load correct icons for all buttons */
578     tbAB.hInst = HINST_COMMCTRL;
579     tbAB.nID = IDB_STD_LARGE_COLOR;
580     SendMessageW(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&tbAB);
581
582     for (dwIndex = 0; dwIndex < dwNumButtons; dwIndex++)
583     {
584         LPWSTR szBuf = HH_LoadString(buttons[dwIndex].idCommand);
585         DWORD dwLen = strlenW(szBuf);
586         szBuf[dwLen + 1] = 0; /* Double-null terminate */
587
588         buttons[dwIndex].iString = (DWORD)SendMessageW(hToolbar, TB_ADDSTRINGW, 0, (LPARAM)szBuf);
589         heap_free(szBuf);
590     }
591
592     SendMessageW(hToolbar, TB_ADDBUTTONSW, dwNumButtons, (LPARAM)buttons);
593     SendMessageW(hToolbar, TB_AUTOSIZE, 0, 0);
594     ShowWindow(hToolbar, SW_SHOW);
595
596     pHHInfo->WinType.hwndToolBar = hToolbar;
597     return TRUE;
598 }
599
600 /* Navigation Pane */
601
602 static void NP_GetNavigationRect(HHInfo *pHHInfo, RECT *rc)
603 {
604     HWND hwndParent = pHHInfo->WinType.hwndHelp;
605     HWND hwndToolbar = pHHInfo->WinType.hwndToolBar;
606     RECT rectWND, rectTB;
607
608     GetClientRect(hwndParent, &rectWND);
609     GetClientRect(hwndToolbar, &rectTB);
610
611     rc->left = 0;
612     rc->top = rectTB.bottom;
613     rc->bottom = rectWND.bottom - rectTB.bottom;
614
615     if (!(pHHInfo->WinType.fsValidMembers & HHWIN_PARAM_NAV_WIDTH) &&
616           pHHInfo->WinType.iNavWidth == 0)
617     {
618         pHHInfo->WinType.iNavWidth = WINTYPE_DEFAULT_NAVWIDTH;
619     }
620
621     rc->right = pHHInfo->WinType.iNavWidth;
622 }
623
624 static DWORD NP_CreateTab(HINSTANCE hInstance, HWND hwndTabCtrl, DWORD index)
625 {
626     TCITEMW tie;
627     LPWSTR tabText = HH_LoadString(index);
628     DWORD ret;
629
630     tie.mask = TCIF_TEXT;
631     tie.pszText = tabText;
632
633     ret = SendMessageW( hwndTabCtrl, TCM_INSERTITEMW, index, (LPARAM)&tie );
634
635     heap_free(tabText);
636     return ret;
637 }
638
639 static BOOL HH_AddNavigationPane(HHInfo *info)
640 {
641     HWND hWnd, hwndTabCtrl;
642     HWND hwndParent = info->WinType.hwndHelp;
643     DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE;
644     DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
645     RECT rc;
646
647     NP_GetNavigationRect(info, &rc);
648
649     hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
650                            rc.left, rc.top, rc.right, rc.bottom,
651                            hwndParent, NULL, hhctrl_hinstance, NULL);
652     if (!hWnd)
653         return FALSE;
654
655     SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)info);
656
657     hwndTabCtrl = CreateWindowExW(dwExStyles, WC_TABCONTROLW, szEmpty, dwStyles,
658                                   0, TAB_TOP_PADDING,
659                                   rc.right - TAB_RIGHT_PADDING,
660                                   rc.bottom - TAB_TOP_PADDING,
661                                   hWnd, NULL, hhctrl_hinstance, NULL);
662     if (!hwndTabCtrl)
663         return FALSE;
664
665     if (*info->WinType.pszToc)
666         info->tabs[TAB_CONTENTS].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_CONTENTS);
667
668     if (*info->WinType.pszIndex)
669         info->tabs[TAB_INDEX].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_INDEX);
670
671     if (info->WinType.fsWinProperties & HHWIN_PROP_TAB_SEARCH)
672         info->tabs[TAB_SEARCH].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_SEARCH);
673
674     if (info->WinType.fsWinProperties & HHWIN_PROP_TAB_FAVORITES)
675         info->tabs[TAB_FAVORITES].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_FAVORITES);
676
677     SendMessageW(hwndTabCtrl, WM_SETFONT, (WPARAM)info->hFont, TRUE);
678
679     info->hwndTabCtrl = hwndTabCtrl;
680     info->WinType.hwndNavigation = hWnd;
681     return TRUE;
682 }
683
684 /* HTML Pane */
685
686 static void HP_GetHTMLRect(HHInfo *info, RECT *rc)
687 {
688     RECT rectTB, rectWND, rectNP, rectSB;
689
690     GetClientRect(info->WinType.hwndHelp, &rectWND);
691     GetClientRect(info->WinType.hwndToolBar, &rectTB);
692     GetClientRect(info->WinType.hwndNavigation, &rectNP);
693     GetClientRect(info->hwndSizeBar, &rectSB);
694
695     rc->left = rectNP.right + rectSB.right;
696     rc->top = rectTB.bottom;
697     rc->right = rectWND.right - rc->left;
698     rc->bottom = rectWND.bottom - rectTB.bottom;
699 }
700
701 static BOOL HH_AddHTMLPane(HHInfo *pHHInfo)
702 {
703     HWND hWnd;
704     HWND hwndParent = pHHInfo->WinType.hwndHelp;
705     DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN;
706     DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_CLIENTEDGE;
707     RECT rc;
708
709     HP_GetHTMLRect(pHHInfo, &rc);
710
711     hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
712                            rc.left, rc.top, rc.right, rc.bottom,
713                            hwndParent, NULL, hhctrl_hinstance, NULL);
714     if (!hWnd)
715         return FALSE;
716
717     if (!InitWebBrowser(pHHInfo, hWnd))
718         return FALSE;
719
720     /* store the pointer to the HH info struct */
721     SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
722
723     ShowWindow(hWnd, SW_SHOW);
724     UpdateWindow(hWnd);
725
726     pHHInfo->WinType.hwndHTML = hWnd;
727     return TRUE;
728 }
729
730 static BOOL AddContentTab(HHInfo *info)
731 {
732     info->tabs[TAB_CONTENTS].hwnd = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW,
733            szEmpty, WS_CHILD | WS_BORDER | 0x25, 50, 50, 100, 100,
734            info->WinType.hwndNavigation, NULL, hhctrl_hinstance, NULL);
735     if(!info->tabs[TAB_CONTENTS].hwnd) {
736         ERR("Could not create treeview control\n");
737         return FALSE;
738     }
739
740     ResizeTabChild(info, info->tabs[TAB_CONTENTS].hwnd);
741     ShowWindow(info->tabs[TAB_CONTENTS].hwnd, SW_SHOW);
742
743     return TRUE;
744 }
745
746 /* Viewer Window */
747
748 static LRESULT Help_OnSize(HWND hWnd)
749 {
750     HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
751     DWORD dwSize;
752     RECT rc;
753
754     if (!pHHInfo)
755         return 0;
756
757     NP_GetNavigationRect(pHHInfo, &rc);
758     SetWindowPos(pHHInfo->WinType.hwndNavigation, HWND_TOP, 0, 0,
759                  rc.right, rc.bottom, SWP_NOMOVE);
760
761     SB_GetSizeBarRect(pHHInfo, &rc);
762     SetWindowPos(pHHInfo->hwndSizeBar, HWND_TOP, rc.left, rc.top,
763                  rc.right, rc.bottom, SWP_SHOWWINDOW);
764
765     HP_GetHTMLRect(pHHInfo, &rc);
766     SetWindowPos(pHHInfo->WinType.hwndHTML, HWND_TOP, rc.left, rc.top,
767                  rc.right, rc.bottom, SWP_SHOWWINDOW);
768
769     /* Resize browser window taking the frame size into account */
770     dwSize = GetSystemMetrics(SM_CXFRAME);
771     ResizeWebBrowser(pHHInfo, rc.right - dwSize, rc.bottom - dwSize);
772
773     return 0;
774 }
775
776 static LRESULT CALLBACK Help_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
777 {
778     switch (message)
779     {
780     case WM_COMMAND:
781         if (HIWORD(wParam) == BN_CLICKED)
782             TB_OnClick(hWnd, LOWORD(wParam));
783         break;
784     case WM_SIZE:
785         return Help_OnSize(hWnd);
786     case WM_CLOSE:
787         ReleaseHelpViewer((HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA));
788         return 0;
789     case WM_DESTROY:
790         if(hh_process)
791             PostQuitMessage(0);
792         break;
793
794     default:
795         return DefWindowProcW(hWnd, message, wParam, lParam);
796     }
797
798     return 0;
799 }
800
801 static BOOL HH_CreateHelpWindow(HHInfo *info)
802 {
803     HWND hWnd;
804     RECT winPos = info->WinType.rcWindowPos;
805     WNDCLASSEXW wcex;
806     DWORD dwStyles, dwExStyles;
807     DWORD x, y, width, height;
808
809     static const WCHAR windowClassW[] = {
810         'H','H',' ', 'P','a','r','e','n','t',0
811     };
812
813     wcex.cbSize         = sizeof(WNDCLASSEXW);
814     wcex.style          = CS_HREDRAW | CS_VREDRAW;
815     wcex.lpfnWndProc    = Help_WndProc;
816     wcex.cbClsExtra     = 0;
817     wcex.cbWndExtra     = 0;
818     wcex.hInstance      = hhctrl_hinstance;
819     wcex.hIcon          = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
820     wcex.hCursor        = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
821     wcex.hbrBackground  = (HBRUSH)(COLOR_MENU + 1);
822     wcex.lpszMenuName   = NULL;
823     wcex.lpszClassName  = windowClassW;
824     wcex.hIconSm        = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
825
826     RegisterClassExW(&wcex);
827
828     /* Read in window parameters if available */
829     if (info->WinType.fsValidMembers & HHWIN_PARAM_STYLES)
830         dwStyles = info->WinType.dwStyles | WS_OVERLAPPEDWINDOW;
831     else
832         dwStyles = WS_OVERLAPPEDWINDOW | WS_VISIBLE |
833                    WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
834
835     if (info->WinType.fsValidMembers & HHWIN_PARAM_EXSTYLES)
836         dwExStyles = info->WinType.dwExStyles;
837     else
838         dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_APPWINDOW |
839                      WS_EX_WINDOWEDGE | WS_EX_RIGHTSCROLLBAR;
840
841     if (info->WinType.fsValidMembers & HHWIN_PARAM_RECT)
842     {
843         x = winPos.left;
844         y = winPos.top;
845         width = winPos.right - x;
846         height = winPos.bottom - y;
847     }
848     else
849     {
850         x = WINTYPE_DEFAULT_X;
851         y = WINTYPE_DEFAULT_Y;
852         width = WINTYPE_DEFAULT_WIDTH;
853         height = WINTYPE_DEFAULT_HEIGHT;
854     }
855
856     hWnd = CreateWindowExW(dwExStyles, windowClassW, info->WinType.pszCaption,
857                            dwStyles, x, y, width, height, NULL, NULL, hhctrl_hinstance, NULL);
858     if (!hWnd)
859         return FALSE;
860
861     ShowWindow(hWnd, SW_SHOW);
862     UpdateWindow(hWnd);
863
864     /* store the pointer to the HH info struct */
865     SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)info);
866
867     info->WinType.hwndHelp = hWnd;
868     return TRUE;
869 }
870
871 static void HH_CreateFont(HHInfo *pHHInfo)
872 {
873     LOGFONTW lf;
874
875     GetObjectW(GetStockObject(ANSI_VAR_FONT), sizeof(LOGFONTW), &lf);
876     lf.lfWeight = FW_NORMAL;
877     lf.lfItalic = FALSE;
878     lf.lfUnderline = FALSE;
879
880     pHHInfo->hFont = CreateFontIndirectW(&lf);
881 }
882
883 static void HH_InitRequiredControls(DWORD dwControls)
884 {
885     INITCOMMONCONTROLSEX icex;
886
887     icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
888     icex.dwICC = dwControls;
889     InitCommonControlsEx(&icex);
890 }
891
892 /* Creates the whole package */
893 static BOOL CreateViewer(HHInfo *pHHInfo)
894 {
895     HH_CreateFont(pHHInfo);
896
897     if (!HH_CreateHelpWindow(pHHInfo))
898         return FALSE;
899
900     HH_InitRequiredControls(ICC_BAR_CLASSES);
901
902     if (!HH_AddToolbar(pHHInfo))
903         return FALSE;
904
905     HH_RegisterChildWndClass(pHHInfo);
906
907     if (!HH_AddNavigationPane(pHHInfo))
908         return FALSE;
909
910     HH_RegisterSizeBarClass(pHHInfo);
911
912     if (!HH_AddSizeBar(pHHInfo))
913         return FALSE;
914
915     if (!HH_AddHTMLPane(pHHInfo))
916         return FALSE;
917
918     if (!AddContentTab(pHHInfo))
919         return FALSE;
920
921     InitContent(pHHInfo);
922
923     return TRUE;
924 }
925
926 void ReleaseHelpViewer(HHInfo *info)
927 {
928     TRACE("(%p)\n", info);
929
930     if (!info)
931         return;
932
933     /* Free allocated strings */
934     heap_free(info->pszType);
935     heap_free(info->pszCaption);
936     heap_free(info->pszToc);
937     heap_free(info->pszIndex);
938     heap_free(info->pszFile);
939     heap_free(info->pszHome);
940     heap_free(info->pszJump1);
941     heap_free(info->pszJump2);
942     heap_free(info->pszUrlJump1);
943     heap_free(info->pszUrlJump2);
944
945     if (info->pCHMInfo)
946         CloseCHM(info->pCHMInfo);
947
948     ReleaseWebBrowser(info);
949     ReleaseContent(info);
950
951     if(info->WinType.hwndHelp)
952         DestroyWindow(info->WinType.hwndHelp);
953
954     heap_free(info);
955     OleUninitialize();
956 }
957
958 HHInfo *CreateHelpViewer(LPCWSTR filename)
959 {
960     HHInfo *info = heap_alloc_zero(sizeof(HHInfo));
961
962     OleInitialize(NULL);
963
964     info->pCHMInfo = OpenCHM(filename);
965     if(!info->pCHMInfo) {
966         ReleaseHelpViewer(info);
967         return NULL;
968     }
969
970     if (!LoadWinTypeFromCHM(info)) {
971         ReleaseHelpViewer(info);
972         return NULL;
973     }
974
975     if(!CreateViewer(info)) {
976         ReleaseHelpViewer(info);
977         return NULL;
978     }
979
980     return info;
981 }