* Help Viewer Implementation
*
* Copyright 2005 James Hawkins
+ * Copyright 2007 Jacek Caban for CodeWeavers
+ * Copyright 2011 Owen Rudge for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include <stdarg.h>
+#include "hhctrl.h"
-#include "windef.h"
-#include "winbase.h"
#include "wingdi.h"
-#include "winuser.h"
-#include "winnls.h"
#include "commctrl.h"
-#include "htmlhelp.h"
-#include "ole2.h"
-#include "wine/unicode.h"
+#include "wininet.h"
+
+#include "wine/debug.h"
#include "resource.h"
-#include "chm.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
+
+static LRESULT Help_OnSize(HWND hWnd);
+static void ExpandContract(HHInfo *pHHInfo);
/* Window type defaults */
#define WINTYPE_DEFAULT_Y 100
#define WINTYPE_DEFAULT_WIDTH 740
#define WINTYPE_DEFAULT_HEIGHT 640
-#define WINTYPE_DEFAULT_NAVWIDTH 251
+#define WINTYPE_DEFAULT_NAVWIDTH 250
+
+#define TAB_TOP_PADDING 8
+#define TAB_RIGHT_PADDING 4
+#define TAB_MARGIN 8
+#define EDIT_HEIGHT 20
+
+static const WCHAR szEmpty[] = {0};
-typedef struct tagHHInfo
+/* Loads a string from the resource file */
+static LPWSTR HH_LoadString(DWORD dwID)
{
- HH_WINTYPEW *pHHWinType;
- CHMInfo *pCHMInfo;
- HINSTANCE hInstance;
- LPWSTR szCmdLine;
- HWND hwndTabCtrl;
- HFONT hFont;
-} HHInfo;
+ LPWSTR string = NULL;
+ LPCWSTR stringresource;
+ int iSize;
+
+ iSize = LoadStringW(hhctrl_hinstance, dwID, (LPWSTR)&stringresource, 0);
+
+ string = heap_alloc((iSize + 2) * sizeof(WCHAR)); /* some strings (tab text) needs double-null termination */
+ memcpy(string, stringresource, iSize*sizeof(WCHAR));
+ string[iSize] = 0;
-extern HINSTANCE hhctrl_hinstance;
+ return string;
+}
-static LPWSTR HH_ANSIToUnicode(LPCSTR ansi)
+static HRESULT navigate_url(HHInfo *info, LPCWSTR surl)
{
- LPWSTR unicode;
- int count;
+ VARIANT url;
+ HRESULT hres;
+
+ TRACE("%s\n", debugstr_w(surl));
+
+ V_VT(&url) = VT_BSTR;
+ V_BSTR(&url) = SysAllocString(surl);
- count = MultiByteToWideChar(CP_ACP, 0, ansi, -1, NULL, 0);
- unicode = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, ansi, -1, unicode, count);
+ hres = IWebBrowser2_Navigate2(info->web_browser, &url, 0, 0, 0, 0);
- return unicode;
+ VariantClear(&url);
+
+ if(FAILED(hres))
+ TRACE("Navigation failed: %08x\n", hres);
+
+ return hres;
}
-/* Loads a string from the resource file */
-static LPWSTR HH_LoadString(DWORD dwID)
+BOOL NavigateToUrl(HHInfo *info, LPCWSTR surl)
{
- LPWSTR string = NULL;
- int iSize;
+ ChmPath chm_path;
+ BOOL ret;
+ HRESULT hres;
- iSize = LoadStringW(hhctrl_hinstance, dwID, NULL, 0);
- iSize += 2; /* some strings (tab text) needs double-null termination */
+ static const WCHAR url_indicator[] = {':', '/', '/', 0};
- string = HeapAlloc(GetProcessHeap(), 0, iSize * sizeof(WCHAR));
- LoadStringW(hhctrl_hinstance, dwID, string, iSize);
+ TRACE("%s\n", debugstr_w(surl));
- return string;
+ if (strstrW(surl, url_indicator)) {
+ hres = navigate_url(info, surl);
+ if(SUCCEEDED(hres))
+ return TRUE;
+ } /* look up in chm if it doesn't look like a full url */
+
+ SetChmPath(&chm_path, info->pCHMInfo->szFile, surl);
+ ret = NavigateToChm(info, chm_path.chm_file, chm_path.chm_index);
+
+ heap_free(chm_path.chm_file);
+ heap_free(chm_path.chm_index);
+
+ return ret;
+}
+
+BOOL AppendFullPathURL(LPCWSTR file, LPWSTR buf, LPCWSTR index)
+{
+ static const WCHAR url_format[] =
+ {'m','k',':','@','M','S','I','T','S','t','o','r','e',':','%','s',':',':','%','s','%','s',0};
+ static const WCHAR slash[] = {'/',0};
+ static const WCHAR empty[] = {0};
+ WCHAR full_path[MAX_PATH];
+
+ TRACE("%s %p %s\n", debugstr_w(file), buf, debugstr_w(index));
+
+ if(!GetFullPathNameW(file, sizeof(full_path)/sizeof(full_path[0]), full_path, NULL)) {
+ WARN("GetFullPathName failed: %u\n", GetLastError());
+ return FALSE;
+ }
+
+ wsprintfW(buf, url_format, full_path, (!index || index[0] == '/') ? empty : slash, index);
+ return TRUE;
+}
+
+BOOL NavigateToChm(HHInfo *info, LPCWSTR file, LPCWSTR index)
+{
+ WCHAR buf[INTERNET_MAX_URL_LENGTH];
+ LPWSTR ptr;
+
+ TRACE("%p %s %s\n", info, debugstr_w(file), debugstr_w(index));
+
+ if ((!info->web_browser) || !AppendFullPathURL(file, buf, index))
+ return FALSE;
+
+ /* FIXME: HACK */
+ if((ptr = strchrW(buf, '#')))
+ *ptr = 0;
+
+ return SUCCEEDED(navigate_url(info, buf));
+}
+
+static void DoSync(HHInfo *info)
+{
+ WCHAR buf[INTERNET_MAX_URL_LENGTH];
+ HRESULT hres;
+ DWORD len;
+ BSTR url;
+
+ hres = IWebBrowser2_get_LocationURL(info->web_browser, &url);
+
+ if (FAILED(hres))
+ {
+ WARN("get_LocationURL failed: %08x\n", hres);
+ return;
+ }
+
+ /* If we're not currently viewing a page in the active .chm file, abort */
+ if ((!AppendFullPathURL(info->pszFile, buf, NULL)) || (len = lstrlenW(buf) > lstrlenW(url)))
+ {
+ SysFreeString(url);
+ return;
+ }
+
+ if (lstrcmpiW(buf, url) > 0)
+ {
+ static const WCHAR delimW[] = {':',':','/',0};
+ const WCHAR *index;
+
+ index = strstrW(url, delimW);
+
+ if (index)
+ ActivateContentTopic(info->tabs[TAB_CONTENTS].hwnd, index + 3, info->content); /* skip over ::/ */
+ }
+
+ SysFreeString(url);
+}
+
+/* Size Bar */
+
+#define SIZEBAR_WIDTH 4
+
+static const WCHAR szSizeBarClass[] = {
+ 'H','H',' ','S','i','z','e','B','a','r',0
+};
+
+/* Draw the SizeBar */
+static void SB_OnPaint(HWND hWnd)
+{
+ PAINTSTRUCT ps;
+ HDC hdc;
+ RECT rc;
+
+ hdc = BeginPaint(hWnd, &ps);
+
+ GetClientRect(hWnd, &rc);
+
+ /* dark frame */
+ rc.right += 1;
+ rc.bottom -= 1;
+ FrameRect(hdc, &rc, GetStockObject(GRAY_BRUSH));
+
+ /* white highlight */
+ SelectObject(hdc, GetStockObject(WHITE_PEN));
+ MoveToEx(hdc, rc.right, 1, NULL);
+ LineTo(hdc, 1, 1);
+ LineTo(hdc, 1, rc.bottom - 1);
+
+
+ MoveToEx(hdc, 0, rc.bottom, NULL);
+ LineTo(hdc, rc.right, rc.bottom);
+
+ EndPaint(hWnd, &ps);
+}
+
+static void SB_OnLButtonDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
+{
+ SetCapture(hWnd);
+}
+
+static void SB_OnLButtonUp(HWND hWnd, WPARAM wParam, LPARAM lParam)
+{
+ HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+ POINT pt;
+
+ pt.x = (short)LOWORD(lParam);
+ pt.y = (short)HIWORD(lParam);
+
+ /* update the window sizes */
+ pHHInfo->WinType.iNavWidth += pt.x;
+ Help_OnSize(hWnd);
+
+ ReleaseCapture();
+}
+
+static void SB_OnMouseMove(HWND hWnd, WPARAM wParam, LPARAM lParam)
+{
+ /* ignore WM_MOUSEMOVE if not dragging the SizeBar */
+ if (!(wParam & MK_LBUTTON))
+ return;
+}
+
+static LRESULT CALLBACK SizeBar_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_LBUTTONDOWN:
+ SB_OnLButtonDown(hWnd, wParam, lParam);
+ break;
+ case WM_LBUTTONUP:
+ SB_OnLButtonUp(hWnd, wParam, lParam);
+ break;
+ case WM_MOUSEMOVE:
+ SB_OnMouseMove(hWnd, wParam, lParam);
+ break;
+ case WM_PAINT:
+ SB_OnPaint(hWnd);
+ break;
+ default:
+ return DefWindowProcW(hWnd, message, wParam, lParam);
+ }
+
+ return 0;
+}
+
+static void HH_RegisterSizeBarClass(HHInfo *pHHInfo)
+{
+ WNDCLASSEXW wcex;
+
+ wcex.cbSize = sizeof(WNDCLASSEXW);
+ wcex.style = 0;
+ wcex.lpfnWndProc = SizeBar_WndProc;
+ wcex.cbClsExtra = 0;
+ wcex.cbWndExtra = 0;
+ wcex.hInstance = hhctrl_hinstance;
+ wcex.hIcon = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+ wcex.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_SIZEWE);
+ wcex.hbrBackground = (HBRUSH)(COLOR_MENU + 1);
+ wcex.lpszMenuName = NULL;
+ wcex.lpszClassName = szSizeBarClass;
+ wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+
+ RegisterClassExW(&wcex);
+}
+
+static void SB_GetSizeBarRect(HHInfo *info, RECT *rc)
+{
+ RECT rectWND, rectTB, rectNP;
+
+ GetClientRect(info->WinType.hwndHelp, &rectWND);
+ GetClientRect(info->WinType.hwndToolBar, &rectTB);
+ GetClientRect(info->WinType.hwndNavigation, &rectNP);
+
+ rc->left = rectNP.right;
+ rc->top = rectTB.bottom;
+ rc->bottom = rectWND.bottom - rectTB.bottom;
+ rc->right = SIZEBAR_WIDTH;
+}
+
+static BOOL HH_AddSizeBar(HHInfo *pHHInfo)
+{
+ HWND hWnd;
+ HWND hwndParent = pHHInfo->WinType.hwndHelp;
+ DWORD dwStyles = WS_CHILDWINDOW | WS_OVERLAPPED;
+ DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
+ RECT rc;
+
+ if (!pHHInfo->WinType.fNotExpanded)
+ dwStyles |= WS_VISIBLE;
+
+ SB_GetSizeBarRect(pHHInfo, &rc);
+
+ hWnd = CreateWindowExW(dwExStyles, szSizeBarClass, szEmpty, dwStyles,
+ rc.left, rc.top, rc.right, rc.bottom,
+ hwndParent, NULL, hhctrl_hinstance, NULL);
+ if (!hWnd)
+ return FALSE;
+
+ /* store the pointer to the HH info struct */
+ SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
+
+ pHHInfo->hwndSizeBar = hWnd;
+ return TRUE;
}
/* Child Window */
'H','H',' ','C','h','i','l','d',0
};
-static const WCHAR szEmpty[] = {0};
-
-static void Child_OnPaint(HWND hWnd)
+static LRESULT Child_OnPaint(HWND hWnd)
{
PAINTSTRUCT ps;
HDC hdc;
SelectObject(hdc, GetStockObject(DC_PEN));
SetDCPenColor(hdc, GetSysColor(COLOR_BTNSHADOW));
- /* Draw the top and right borders */
- MoveToEx(hdc, 0, 0, NULL);
- LineTo(hdc, rc.right - 1, 0);
- LineTo(hdc, rc.right - 1, rc.bottom);
+ /* Draw the top border */
+ LineTo(hdc, rc.right, 0);
- /* Fill in the background, taking the border lines into account */
- rc.top += 2;
- rc.right -= 1;
- FillRect(hdc, &rc, GetSysColorBrush(COLOR_3DFACE));
+ SelectObject(hdc, GetStockObject(WHITE_PEN));
+ MoveToEx(hdc, 0, 1, NULL);
+ LineTo(hdc, rc.right, 1);
}
EndPaint(hWnd, &ps);
+
+ return 0;
+}
+
+static void ResizeTabChild(HHInfo *info, int tab)
+{
+ HWND hwnd = info->tabs[tab].hwnd;
+ INT width, height;
+ RECT rect, tabrc;
+ DWORD cnt;
+
+ GetClientRect(info->WinType.hwndNavigation, &rect);
+ SendMessageW(info->hwndTabCtrl, TCM_GETITEMRECT, 0, (LPARAM)&tabrc);
+ cnt = SendMessageW(info->hwndTabCtrl, TCM_GETROWCOUNT, 0, 0);
+
+ rect.left = TAB_MARGIN;
+ rect.top = TAB_TOP_PADDING + cnt*(tabrc.bottom-tabrc.top) + TAB_MARGIN;
+ rect.right -= TAB_RIGHT_PADDING + TAB_MARGIN;
+ rect.bottom -= TAB_MARGIN;
+ width = rect.right-rect.left;
+ height = rect.bottom-rect.top;
+
+ SetWindowPos(hwnd, NULL, rect.left, rect.top, width, height,
+ SWP_NOZORDER | SWP_NOACTIVATE);
+
+ switch (tab)
+ {
+ case TAB_INDEX: {
+ int scroll_width = GetSystemMetrics(SM_CXVSCROLL);
+ int border_width = GetSystemMetrics(SM_CXBORDER);
+ int edge_width = GetSystemMetrics(SM_CXEDGE);
+
+ /* Resize the tab widget column to perfectly fit the tab window and
+ * leave sufficient space for the scroll widget.
+ */
+ SendMessageW(info->tabs[TAB_INDEX].hwnd, LVM_SETCOLUMNWIDTH, 0,
+ width-scroll_width-2*border_width-2*edge_width);
+
+ break;
+ }
+ case TAB_SEARCH: {
+ int scroll_width = GetSystemMetrics(SM_CXVSCROLL);
+ int border_width = GetSystemMetrics(SM_CXBORDER);
+ int edge_width = GetSystemMetrics(SM_CXEDGE);
+ int top_pos = 0;
+
+ SetWindowPos(info->search.hwndEdit, NULL, 0, top_pos, width,
+ EDIT_HEIGHT, SWP_NOZORDER | SWP_NOACTIVATE);
+ top_pos += EDIT_HEIGHT + TAB_MARGIN;
+ SetWindowPos(info->search.hwndList, NULL, 0, top_pos, width,
+ height-top_pos, SWP_NOZORDER | SWP_NOACTIVATE);
+ /* Resize the tab widget column to perfectly fit the tab window and
+ * leave sufficient space for the scroll widget.
+ */
+ SendMessageW(info->search.hwndList, LVM_SETCOLUMNWIDTH, 0,
+ width-scroll_width-2*border_width-2*edge_width);
+
+ break;
+ }
+ }
+}
+
+static LRESULT Child_OnSize(HWND hwnd)
+{
+ HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+ RECT rect;
+
+ if(!info || hwnd != info->WinType.hwndNavigation)
+ return 0;
+
+ GetClientRect(hwnd, &rect);
+ SetWindowPos(info->hwndTabCtrl, HWND_TOP, 0, 0,
+ rect.right - TAB_RIGHT_PADDING,
+ rect.bottom - TAB_TOP_PADDING, SWP_NOMOVE);
+
+ ResizeTabChild(info, TAB_CONTENTS);
+ ResizeTabChild(info, TAB_INDEX);
+ return 0;
}
-LRESULT CALLBACK Child_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+static LRESULT OnTabChange(HWND hwnd)
+{
+ HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+
+ TRACE("%p\n", hwnd);
+
+ if (!info)
+ return 0;
+
+ if(info->tabs[info->current_tab].hwnd)
+ ShowWindow(info->tabs[info->current_tab].hwnd, SW_HIDE);
+
+ info->current_tab = SendMessageW(info->hwndTabCtrl, TCM_GETCURSEL, 0, 0);
+
+ if(info->tabs[info->current_tab].hwnd)
+ ShowWindow(info->tabs[info->current_tab].hwnd, SW_SHOW);
+
+ return 0;
+}
+
+static LRESULT OnTopicChange(HHInfo *info, void *user_data)
+{
+ LPCWSTR chmfile = NULL, name = NULL, local = NULL;
+ ContentItem *citer;
+ SearchItem *siter;
+ IndexItem *iiter;
+
+ if(!user_data || !info)
+ return 0;
+
+ switch (info->current_tab)
+ {
+ case TAB_CONTENTS:
+ citer = (ContentItem *) user_data;
+ name = citer->name;
+ local = citer->local;
+ while(citer) {
+ if(citer->merge.chm_file) {
+ chmfile = citer->merge.chm_file;
+ break;
+ }
+ citer = citer->parent;
+ }
+ break;
+ case TAB_INDEX:
+ iiter = (IndexItem *) user_data;
+ if(iiter->nItems == 0) {
+ FIXME("No entries for this item!\n");
+ return 0;
+ }
+ if(iiter->nItems > 1) {
+ int i = 0;
+ LVITEMW lvi;
+
+ SendMessageW(info->popup.hwndList, LVM_DELETEALLITEMS, 0, 0);
+ for(i=0;i<iiter->nItems;i++) {
+ IndexSubItem *item = &iiter->items[i];
+ WCHAR *name = iiter->keyword;
+
+ if(item->name)
+ name = item->name;
+ memset(&lvi, 0, sizeof(lvi));
+ lvi.iItem = i;
+ lvi.mask = LVIF_TEXT|LVIF_PARAM;
+ lvi.cchTextMax = strlenW(name)+1;
+ lvi.pszText = name;
+ lvi.lParam = (LPARAM) item;
+ SendMessageW(info->popup.hwndList, LVM_INSERTITEMW, 0, (LPARAM)&lvi);
+ }
+ ShowWindow(info->popup.hwndPopup, SW_SHOW);
+ return 0;
+ }
+ name = iiter->items[0].name;
+ local = iiter->items[0].local;
+ chmfile = iiter->merge.chm_file;
+ break;
+ case TAB_SEARCH:
+ siter = (SearchItem *) user_data;
+ name = siter->filename;
+ local = siter->filename;
+ chmfile = info->pCHMInfo->szFile;
+ break;
+ default:
+ FIXME("Unhandled operation for this tab!\n");
+ return 0;
+ }
+
+ if(!chmfile)
+ {
+ FIXME("No help file found for this item!\n");
+ return 0;
+ }
+
+ TRACE("name %s loal %s\n", debugstr_w(name), debugstr_w(local));
+
+ NavigateToChm(info, chmfile, local);
+ return 0;
+}
+
+/* Capture the Enter/Return key and send it up to Child_WndProc as an NM_RETURN message */
+static LRESULT CALLBACK EditChild_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ WNDPROC editWndProc = (WNDPROC)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+
+ if(message == WM_KEYUP && wParam == VK_RETURN)
+ {
+ NMHDR nmhdr;
+
+ nmhdr.hwndFrom = hWnd;
+ nmhdr.code = NM_RETURN;
+ SendMessageW(GetParent(GetParent(hWnd)), WM_NOTIFY, wParam, (LPARAM)&nmhdr);
+ }
+ return editWndProc(hWnd, message, wParam, lParam);
+}
+
+static LRESULT CALLBACK Child_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
- case WM_PAINT:
- Child_OnPaint(hWnd);
+ case WM_PAINT:
+ return Child_OnPaint(hWnd);
+ case WM_SIZE:
+ return Child_OnSize(hWnd);
+ case WM_NOTIFY: {
+ HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+ NMHDR *nmhdr = (NMHDR*)lParam;
+
+ switch(nmhdr->code) {
+ case TCN_SELCHANGE:
+ return OnTabChange(hWnd);
+ case TVN_SELCHANGEDW:
+ return OnTopicChange(info, (void*)((NMTREEVIEWW *)lParam)->itemNew.lParam);
+ case NM_DBLCLK:
+ if(!info)
+ return 0;
+ switch(info->current_tab)
+ {
+ case TAB_INDEX:
+ return OnTopicChange(info, (void*)((NMITEMACTIVATE *)lParam)->lParam);
+ case TAB_SEARCH:
+ return OnTopicChange(info, (void*)((NMITEMACTIVATE *)lParam)->lParam);
+ }
break;
- default:
- return DefWindowProcW(hWnd, message, wParam, lParam);
+ case NM_RETURN:
+ if(!info)
+ return 0;
+ switch(info->current_tab) {
+ case TAB_INDEX: {
+ HWND hwndList = info->tabs[TAB_INDEX].hwnd;
+ LVITEMW lvItem;
+
+ lvItem.iItem = (int) SendMessageW(hwndList, LVM_GETSELECTIONMARK, 0, 0);
+ lvItem.mask = TVIF_PARAM;
+ SendMessageW(hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem);
+ OnTopicChange(info, (void*) lvItem.lParam);
+ return 0;
+ }
+ case TAB_SEARCH: {
+ if(nmhdr->hwndFrom == info->search.hwndEdit) {
+ char needle[100];
+ DWORD i, len;
+
+ len = GetWindowTextA(info->search.hwndEdit, needle, sizeof(needle));
+ if(!len)
+ {
+ FIXME("Unable to get search text.\n");
+ return 0;
+ }
+ /* Convert the requested text for comparison later against the
+ * lower case version of HTML file contents.
+ */
+ for(i=0;i<len;i++)
+ needle[i] = tolower(needle[i]);
+ InitSearch(info, needle);
+ return 0;
+ }else if(nmhdr->hwndFrom == info->search.hwndList) {
+ HWND hwndList = info->search.hwndList;
+ LVITEMW lvItem;
+
+ lvItem.iItem = (int) SendMessageW(hwndList, LVM_GETSELECTIONMARK, 0, 0);
+ lvItem.mask = TVIF_PARAM;
+ SendMessageW(hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem);
+ OnTopicChange(info, (void*) lvItem.lParam);
+ return 0;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ break;
+ }
+ default:
+ return DefWindowProcW(hWnd, message, wParam, lParam);
}
return 0;
wcex.cbSize = sizeof(WNDCLASSEXW);
wcex.style = 0;
- wcex.lpfnWndProc = (WNDPROC)Child_WndProc;
+ wcex.lpfnWndProc = Child_WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
- wcex.hInstance = pHHInfo->hInstance;
+ wcex.hInstance = hhctrl_hinstance;
wcex.hIcon = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
wcex.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
- wcex.hbrBackground = (HBRUSH)(COLOR_3DFACE);
+ wcex.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szChildClass;
wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
#define ICON_SIZE 20
-static void TB_AddButton(TBBUTTON *pButtons, DWORD dwIndex, DWORD dwID)
+static void DisplayPopupMenu(HHInfo *info)
{
- /* FIXME: Load the correct button bitmaps */
- pButtons[dwIndex].iBitmap = STD_PRINT;
+ HMENU menu, submenu;
+ TBBUTTONINFOW button;
+ MENUITEMINFOW item;
+ POINT coords;
+ RECT rect;
+ DWORD index;
+
+ menu = LoadMenuW(hhctrl_hinstance, MAKEINTRESOURCEW(MENU_POPUP));
+
+ if (!menu)
+ return;
+
+ submenu = GetSubMenu(menu, 0);
+
+ /* Update the Show/Hide menu item */
+ item.cbSize = sizeof(MENUITEMINFOW);
+ item.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_STRING;
+ item.fType = MFT_STRING;
+ item.fState = MF_ENABLED;
+
+ if (info->WinType.fNotExpanded)
+ item.dwTypeData = HH_LoadString(IDS_SHOWTABS);
+ else
+ item.dwTypeData = HH_LoadString(IDS_HIDETABS);
+
+ SetMenuItemInfoW(submenu, IDTB_EXPAND, FALSE, &item);
+ heap_free(item.dwTypeData);
+
+ /* Find the index toolbar button */
+ button.cbSize = sizeof(TBBUTTONINFOW);
+ button.dwMask = TBIF_COMMAND;
+ index = SendMessageW(info->WinType.hwndToolBar, TB_GETBUTTONINFOW, IDTB_OPTIONS, (LPARAM) &button);
+
+ if (index == -1)
+ return;
+
+ /* Get position */
+ SendMessageW(info->WinType.hwndToolBar, TB_GETITEMRECT, index, (LPARAM) &rect);
+
+ coords.x = rect.left;
+ coords.y = rect.bottom;
+
+ ClientToScreen(info->WinType.hwndToolBar, &coords);
+ TrackPopupMenu(submenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON | TPM_NOANIMATION, coords.x, coords.y, 0, info->WinType.hwndHelp, NULL);
+}
+
+static void TB_OnClick(HWND hWnd, DWORD dwID)
+{
+ HHInfo *info = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+
+ switch (dwID)
+ {
+ case IDTB_STOP:
+ DoPageAction(info, WB_STOP);
+ break;
+ case IDTB_REFRESH:
+ DoPageAction(info, WB_REFRESH);
+ break;
+ case IDTB_BACK:
+ DoPageAction(info, WB_GOBACK);
+ break;
+ case IDTB_HOME:
+ NavigateToChm(info, info->pCHMInfo->szFile, info->WinType.pszHome);
+ break;
+ case IDTB_FORWARD:
+ DoPageAction(info, WB_GOFORWARD);
+ break;
+ case IDTB_PRINT:
+ DoPageAction(info, WB_PRINT);
+ break;
+ case IDTB_EXPAND:
+ case IDTB_CONTRACT:
+ ExpandContract(info);
+ break;
+ case IDTB_SYNC:
+ DoSync(info);
+ break;
+ case IDTB_OPTIONS:
+ DisplayPopupMenu(info);
+ break;
+ case IDTB_BROWSE_FWD:
+ case IDTB_BROWSE_BACK:
+ case IDTB_JUMP1:
+ case IDTB_JUMP2:
+ case IDTB_CUSTOMIZE:
+ case IDTB_ZOOM:
+ case IDTB_TOC_NEXT:
+ case IDTB_TOC_PREV:
+ break;
+ }
+}
+
+static void TB_AddButton(TBBUTTON *pButtons, DWORD dwIndex, DWORD dwID, DWORD dwBitmap)
+{
+ pButtons[dwIndex].iBitmap = dwBitmap;
pButtons[dwIndex].idCommand = dwID;
pButtons[dwIndex].fsState = TBSTATE_ENABLED;
pButtons[dwIndex].fsStyle = BTNS_BUTTON;
pButtons[dwIndex].iString = 0;
}
-static void TB_AddButtonsFromFlags(TBBUTTON *pButtons, DWORD dwButtonFlags, LPDWORD pdwNumButtons)
+static void TB_AddButtonsFromFlags(HHInfo *pHHInfo, TBBUTTON *pButtons, DWORD dwButtonFlags, LPDWORD pdwNumButtons)
{
+ int nHistBitmaps = 0, nStdBitmaps = 0, nHHBitmaps = 0;
+ HWND hToolbar = pHHInfo->WinType.hwndToolBar;
+ TBADDBITMAP tbAB;
+
+ /* Common bitmaps */
+ tbAB.hInst = HINST_COMMCTRL;
+ tbAB.nID = IDB_HIST_LARGE_COLOR;
+ nHistBitmaps = SendMessageW(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&tbAB);
+ tbAB.nID = IDB_STD_LARGE_COLOR;
+ nStdBitmaps = SendMessageW(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&tbAB);
+ /* hhctrl.ocx bitmaps */
+ tbAB.hInst = hhctrl_hinstance;
+ tbAB.nID = IDB_HHTOOLBAR;
+ nHHBitmaps = SendMessageW(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&tbAB);
+
*pdwNumButtons = 0;
if (dwButtonFlags & HHWIN_BUTTON_EXPAND)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_EXPAND);
+ {
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_EXPAND, nHistBitmaps + HIST_VIEWTREE);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_CONTRACT, nHistBitmaps + HIST_VIEWTREE);
+
+ if (pHHInfo->WinType.fNotExpanded)
+ pButtons[1].fsState |= TBSTATE_HIDDEN;
+ else
+ pButtons[0].fsState |= TBSTATE_HIDDEN;
+ }
if (dwButtonFlags & HHWIN_BUTTON_BACK)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_BACK);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_BACK, nHistBitmaps + HIST_BACK);
if (dwButtonFlags & HHWIN_BUTTON_FORWARD)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_FORWARD);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_FORWARD, nHistBitmaps + HIST_FORWARD);
if (dwButtonFlags & HHWIN_BUTTON_STOP)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_STOP);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_STOP, nHHBitmaps + HH_STOP);
if (dwButtonFlags & HHWIN_BUTTON_REFRESH)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_REFRESH);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_REFRESH, nHHBitmaps + HH_REFRESH);
if (dwButtonFlags & HHWIN_BUTTON_HOME)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_HOME);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_HOME, nHHBitmaps + HH_HOME);
+ /* FIXME: Load the correct button bitmaps */
if (dwButtonFlags & HHWIN_BUTTON_SYNC)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_SYNC);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_SYNC, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_OPTIONS)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_OPTIONS);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_OPTIONS, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_PRINT)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_PRINT);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_PRINT, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_JUMP1)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_JUMP1);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_JUMP1, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_JUMP2)
- TB_AddButton(pButtons,(*pdwNumButtons)++, IDTB_JUMP2);
+ TB_AddButton(pButtons,(*pdwNumButtons)++, IDTB_JUMP2, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_ZOOM)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_ZOOM);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_ZOOM, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_TOC_NEXT)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_NEXT);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_NEXT, nStdBitmaps + STD_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_TOC_PREV)
- TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_PREV);
+ TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_PREV, nStdBitmaps + STD_PRINT);
}
static BOOL HH_AddToolbar(HHInfo *pHHInfo)
{
HWND hToolbar;
- HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
+ HWND hwndParent = pHHInfo->WinType.hwndHelp;
DWORD toolbarFlags;
TBBUTTON buttons[IDTB_TOC_PREV - IDTB_EXPAND];
- TBADDBITMAP tbAB;
DWORD dwStyles, dwExStyles;
DWORD dwNumButtons, dwIndex;
- if (pHHInfo->pHHWinType->fsWinProperties & HHWIN_PARAM_TB_FLAGS)
- toolbarFlags = pHHInfo->pHHWinType->fsToolBarFlags;
+ if (pHHInfo->WinType.fsWinProperties & HHWIN_PARAM_TB_FLAGS)
+ toolbarFlags = pHHInfo->WinType.fsToolBarFlags;
else
toolbarFlags = HHWIN_DEF_BUTTONS;
- TB_AddButtonsFromFlags(buttons, toolbarFlags, &dwNumButtons);
-
dwStyles = WS_CHILDWINDOW | WS_VISIBLE | TBSTYLE_FLAT |
TBSTYLE_WRAPABLE | TBSTYLE_TOOLTIPS | CCS_NODIVIDER;
dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
hToolbar = CreateWindowExW(dwExStyles, TOOLBARCLASSNAMEW, NULL, dwStyles,
0, 0, 0, 0, hwndParent, NULL,
- pHHInfo->hInstance, NULL);
+ hhctrl_hinstance, NULL);
if (!hToolbar)
return FALSE;
+ pHHInfo->WinType.hwndToolBar = hToolbar;
SendMessageW(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(ICON_SIZE, ICON_SIZE));
SendMessageW(hToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
SendMessageW(hToolbar, WM_SETFONT, (WPARAM)pHHInfo->hFont, TRUE);
- /* FIXME: Load correct icons for all buttons */
- tbAB.hInst = HINST_COMMCTRL;
- tbAB.nID = IDB_STD_LARGE_COLOR;
- SendMessageW(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&tbAB);
+ TB_AddButtonsFromFlags(pHHInfo, buttons, toolbarFlags, &dwNumButtons);
for (dwIndex = 0; dwIndex < dwNumButtons; dwIndex++)
{
LPWSTR szBuf = HH_LoadString(buttons[dwIndex].idCommand);
DWORD dwLen = strlenW(szBuf);
- szBuf[dwLen + 2] = 0; /* Double-null terminate */
+ szBuf[dwLen + 1] = 0; /* Double-null terminate */
buttons[dwIndex].iString = (DWORD)SendMessageW(hToolbar, TB_ADDSTRINGW, 0, (LPARAM)szBuf);
- HeapFree(GetProcessHeap(), 0, szBuf);
+ heap_free(szBuf);
}
- SendMessageW(hToolbar, TB_ADDBUTTONSW, dwNumButtons, (LPARAM)&buttons);
+ SendMessageW(hToolbar, TB_ADDBUTTONSW, dwNumButtons, (LPARAM)buttons);
SendMessageW(hToolbar, TB_AUTOSIZE, 0, 0);
ShowWindow(hToolbar, SW_SHOW);
- pHHInfo->pHHWinType->hwndToolBar = hToolbar;
return TRUE;
}
/* Navigation Pane */
-#define TAB_PADDING 2
-#define TAB_TOP_PADDING 8
-#define TAB_RIGHT_PADDING 4
-
static void NP_GetNavigationRect(HHInfo *pHHInfo, RECT *rc)
{
- HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
- HWND hwndToolbar = pHHInfo->pHHWinType->hwndToolBar;
+ HWND hwndParent = pHHInfo->WinType.hwndHelp;
+ HWND hwndToolbar = pHHInfo->WinType.hwndToolBar;
RECT rectWND, rectTB;
GetClientRect(hwndParent, &rectWND);
rc->top = rectTB.bottom;
rc->bottom = rectWND.bottom - rectTB.bottom;
- if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_NAV_WIDTH)
- rc->right = pHHInfo->pHHWinType->iNavWidth;
- else
- rc->right = WINTYPE_DEFAULT_NAVWIDTH;
+ if (!(pHHInfo->WinType.fsValidMembers & HHWIN_PARAM_NAV_WIDTH) &&
+ pHHInfo->WinType.iNavWidth == 0)
+ {
+ pHHInfo->WinType.iNavWidth = WINTYPE_DEFAULT_NAVWIDTH;
+ }
+
+ rc->right = pHHInfo->WinType.iNavWidth;
}
-static void NP_CreateTab(HINSTANCE hInstance, HWND hwndTabCtrl, DWORD dwStrID, DWORD dwIndex)
+static DWORD NP_CreateTab(HINSTANCE hInstance, HWND hwndTabCtrl, DWORD index)
{
TCITEMW tie;
- LPWSTR tabText = HH_LoadString(dwStrID);
+ LPWSTR tabText = HH_LoadString(index);
+ DWORD ret;
tie.mask = TCIF_TEXT;
tie.pszText = tabText;
- TabCtrl_InsertItemW(hwndTabCtrl, dwIndex, &tie);
- HeapFree(GetProcessHeap(), 0, tabText);
+ ret = SendMessageW( hwndTabCtrl, TCM_INSERTITEMW, index, (LPARAM)&tie );
+
+ heap_free(tabText);
+ return ret;
}
-static BOOL HH_AddNavigationPane(HHInfo *pHHInfo)
+static BOOL HH_AddNavigationPane(HHInfo *info)
{
HWND hWnd, hwndTabCtrl;
- HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
- DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE;
+ HWND hwndParent = info->WinType.hwndHelp;
+ DWORD dwStyles = WS_CHILDWINDOW;
DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
- DWORD dwIndex = 0;
RECT rc;
- NP_GetNavigationRect(pHHInfo, &rc);
+ if (!info->WinType.fNotExpanded)
+ dwStyles |= WS_VISIBLE;
+
+ NP_GetNavigationRect(info, &rc);
hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
rc.left, rc.top, rc.right, rc.bottom,
- hwndParent, NULL, pHHInfo->hInstance, NULL);
+ hwndParent, NULL, hhctrl_hinstance, NULL);
if (!hWnd)
return FALSE;
- hwndTabCtrl = CreateWindowExW(dwExStyles, WC_TABCONTROLW, szEmpty, dwStyles,
- TAB_PADDING, TAB_TOP_PADDING,
- rc.right - TAB_PADDING - TAB_RIGHT_PADDING,
- rc.bottom - TAB_PADDING - TAB_TOP_PADDING,
- hWnd, NULL, pHHInfo->hInstance, NULL);
+ SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)info);
+
+ hwndTabCtrl = CreateWindowExW(dwExStyles, WC_TABCONTROLW, szEmpty, dwStyles | WS_VISIBLE,
+ 0, TAB_TOP_PADDING,
+ rc.right - TAB_RIGHT_PADDING,
+ rc.bottom - TAB_TOP_PADDING,
+ hWnd, NULL, hhctrl_hinstance, NULL);
if (!hwndTabCtrl)
return FALSE;
- if (pHHInfo->pHHWinType->pszToc)
- NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_CONTENTS, dwIndex++);
+ if (*info->WinType.pszToc)
+ info->tabs[TAB_CONTENTS].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_CONTENTS);
- if (pHHInfo->pHHWinType->pszIndex)
- NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_INDEX, dwIndex++);
+ if (*info->WinType.pszIndex)
+ info->tabs[TAB_INDEX].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_INDEX);
- if (pHHInfo->pHHWinType->fsWinProperties & HHWIN_PROP_TAB_SEARCH)
- NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_SEARCH, dwIndex++);
+ if (info->WinType.fsWinProperties & HHWIN_PROP_TAB_SEARCH)
+ info->tabs[TAB_SEARCH].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_SEARCH);
- if (pHHInfo->pHHWinType->fsWinProperties & HHWIN_PROP_TAB_FAVORITES)
- NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_FAVORITES, dwIndex++);
+ if (info->WinType.fsWinProperties & HHWIN_PROP_TAB_FAVORITES)
+ info->tabs[TAB_FAVORITES].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_FAVORITES);
- SendMessageW(hwndTabCtrl, WM_SETFONT, (WPARAM)pHHInfo->hFont, TRUE);
+ SendMessageW(hwndTabCtrl, WM_SETFONT, (WPARAM)info->hFont, TRUE);
- pHHInfo->hwndTabCtrl = hwndTabCtrl;
- pHHInfo->pHHWinType->hwndNavigation = hWnd;
+ info->hwndTabCtrl = hwndTabCtrl;
+ info->WinType.hwndNavigation = hWnd;
return TRUE;
}
/* HTML Pane */
-static void HP_GetHTMLRect(HHInfo *pHHInfo, RECT *rc)
+static void HP_GetHTMLRect(HHInfo *info, RECT *rc)
{
- HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
- HWND hwndToolbar = pHHInfo->pHHWinType->hwndToolBar;
- HWND hwndNavigation = pHHInfo->pHHWinType->hwndNavigation;
- RECT rectTB, rectWND, rectNP;
+ RECT rectTB, rectWND, rectNP, rectSB;
- GetClientRect(hwndParent, &rectWND);
- GetClientRect(hwndToolbar, &rectTB);
- GetClientRect(hwndNavigation, &rectNP);
+ GetClientRect(info->WinType.hwndHelp, &rectWND);
+ GetClientRect(info->WinType.hwndToolBar, &rectTB);
+ GetClientRect(info->hwndSizeBar, &rectSB);
+
+ if (info->WinType.fNotExpanded)
+ rc->left = 0;
+ else
+ {
+ GetClientRect(info->WinType.hwndNavigation, &rectNP);
+ rc->left = rectNP.right + rectSB.right;
+ }
- rc->left = rectNP.right;
rc->top = rectTB.bottom;
- rc->right = rectWND.right - rectNP.right;
+ rc->right = rectWND.right - rc->left;
rc->bottom = rectWND.bottom - rectTB.bottom;
}
static BOOL HH_AddHTMLPane(HHInfo *pHHInfo)
{
HWND hWnd;
- HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
+ HWND hwndParent = pHHInfo->WinType.hwndHelp;
DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN;
DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_CLIENTEDGE;
RECT rc;
hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
rc.left, rc.top, rc.right, rc.bottom,
- hwndParent, NULL, pHHInfo->hInstance, NULL);
+ hwndParent, NULL, hhctrl_hinstance, NULL);
if (!hWnd)
return FALSE;
+ if (!InitWebBrowser(pHHInfo, hWnd))
+ return FALSE;
+
/* store the pointer to the HH info struct */
SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
- pHHInfo->pHHWinType->hwndHTML = hWnd;
+ pHHInfo->WinType.hwndHTML = hWnd;
+ return TRUE;
+}
+
+static BOOL AddContentTab(HHInfo *info)
+{
+ if(info->tabs[TAB_CONTENTS].id == -1)
+ return TRUE; /* No "Contents" tab */
+ info->tabs[TAB_CONTENTS].hwnd = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW,
+ szEmpty, WS_CHILD | WS_BORDER | 0x25, 50, 50, 100, 100,
+ info->WinType.hwndNavigation, NULL, hhctrl_hinstance, NULL);
+ if(!info->tabs[TAB_CONTENTS].hwnd) {
+ ERR("Could not create treeview control\n");
+ return FALSE;
+ }
+
+ ResizeTabChild(info, TAB_CONTENTS);
+ ShowWindow(info->tabs[TAB_CONTENTS].hwnd, SW_SHOW);
+
+ return TRUE;
+}
+
+static BOOL AddIndexTab(HHInfo *info)
+{
+ char hidden_column[] = "Column";
+ LVCOLUMNA lvc;
+
+ if(info->tabs[TAB_INDEX].id == -1)
+ return TRUE; /* No "Index" tab */
+ info->tabs[TAB_INDEX].hwnd = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEWW,
+ szEmpty, WS_CHILD | WS_BORDER | LVS_SINGLESEL | LVS_REPORT | LVS_NOCOLUMNHEADER, 50, 50, 100, 100,
+ info->WinType.hwndNavigation, NULL, hhctrl_hinstance, NULL);
+ if(!info->tabs[TAB_INDEX].hwnd) {
+ ERR("Could not create ListView control\n");
+ return FALSE;
+ }
+ memset(&lvc, 0, sizeof(lvc));
+ lvc.mask = LVCF_TEXT;
+ lvc.pszText = hidden_column;
+ if(SendMessageW(info->tabs[TAB_INDEX].hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM) &lvc) == -1)
+ {
+ ERR("Could not create ListView column\n");
+ return FALSE;
+ }
+
+ ResizeTabChild(info, TAB_INDEX);
+ ShowWindow(info->tabs[TAB_INDEX].hwnd, SW_HIDE);
+
+ return TRUE;
+}
+
+static BOOL AddSearchTab(HHInfo *info)
+{
+ HWND hwndList, hwndEdit, hwndContainer;
+ char hidden_column[] = "Column";
+ WNDPROC editWndProc;
+ LVCOLUMNA lvc;
+
+ if(info->tabs[TAB_SEARCH].id == -1)
+ return TRUE; /* No "Search" tab */
+ hwndContainer = CreateWindowExW(WS_EX_CONTROLPARENT, szChildClass, szEmpty,
+ WS_CHILD, 0, 0, 0, 0, info->WinType.hwndNavigation,
+ NULL, hhctrl_hinstance, NULL);
+ if(!hwndContainer) {
+ ERR("Could not create search window container control.\n");
+ return FALSE;
+ }
+ hwndEdit = CreateWindowExW(WS_EX_CLIENTEDGE, WC_EDITW, szEmpty, WS_CHILD
+ | WS_VISIBLE | ES_LEFT | SS_NOTIFY, 0, 0, 0, 0,
+ hwndContainer, NULL, hhctrl_hinstance, NULL);
+ if(!hwndEdit) {
+ ERR("Could not create search ListView control.\n");
+ return FALSE;
+ }
+ if(SendMessageW(hwndEdit, WM_SETFONT, (WPARAM) info->hFont, (LPARAM) FALSE) == -1)
+ {
+ ERR("Could not set font for edit control.\n");
+ return FALSE;
+ }
+ editWndProc = (WNDPROC) SetWindowLongPtrW(hwndEdit, GWLP_WNDPROC, (LONG_PTR)EditChild_WndProc);
+ if(!editWndProc) {
+ ERR("Could not redirect messages for edit control.\n");
+ return FALSE;
+ }
+ SetWindowLongPtrW(hwndEdit, GWLP_USERDATA, (LONG_PTR)editWndProc);
+ hwndList = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEWW, szEmpty,
+ WS_CHILD | WS_VISIBLE | WS_BORDER | LVS_SINGLESEL
+ | LVS_REPORT | LVS_NOCOLUMNHEADER, 0, 0, 0, 0,
+ hwndContainer, NULL, hhctrl_hinstance, NULL);
+ if(!hwndList) {
+ ERR("Could not create search ListView control.\n");
+ return FALSE;
+ }
+ memset(&lvc, 0, sizeof(lvc));
+ lvc.mask = LVCF_TEXT;
+ lvc.pszText = hidden_column;
+ if(SendMessageW(hwndList, LVM_INSERTCOLUMNA, 0, (LPARAM) &lvc) == -1)
+ {
+ ERR("Could not create ListView column\n");
+ return FALSE;
+ }
+
+ info->search.hwndEdit = hwndEdit;
+ info->search.hwndList = hwndList;
+ info->search.hwndContainer = hwndContainer;
+ info->tabs[TAB_SEARCH].hwnd = hwndContainer;
+
+ SetWindowLongPtrW(hwndContainer, GWLP_USERDATA, (LONG_PTR)info);
+
+ ResizeTabChild(info, TAB_SEARCH);
+
+ return TRUE;
+}
+
+/* The Index tab's sub-topic popup */
+
+static void ResizePopupChild(HHInfo *info)
+{
+ int scroll_width = GetSystemMetrics(SM_CXVSCROLL);
+ int border_width = GetSystemMetrics(SM_CXBORDER);
+ int edge_width = GetSystemMetrics(SM_CXEDGE);
+ INT width, height;
+ RECT rect;
+
+ if(!info)
+ return;
+
+ GetClientRect(info->popup.hwndPopup, &rect);
+ SetWindowPos(info->popup.hwndCallback, HWND_TOP, 0, 0,
+ rect.right, rect.bottom, SWP_NOMOVE);
+
+ rect.left = TAB_MARGIN;
+ rect.top = TAB_TOP_PADDING + TAB_MARGIN;
+ rect.right -= TAB_RIGHT_PADDING + TAB_MARGIN;
+ rect.bottom -= TAB_MARGIN;
+ width = rect.right-rect.left;
+ height = rect.bottom-rect.top;
+
+ SetWindowPos(info->popup.hwndList, NULL, rect.left, rect.top, width, height,
+ SWP_NOZORDER | SWP_NOACTIVATE);
+
+ SendMessageW(info->popup.hwndList, LVM_SETCOLUMNWIDTH, 0,
+ width-scroll_width-2*border_width-2*edge_width);
+}
+
+static LRESULT CALLBACK HelpPopup_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ HHInfo *info = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+
+ switch (message)
+ {
+ case WM_SIZE:
+ ResizePopupChild(info);
+ return 0;
+ case WM_DESTROY:
+ DestroyWindow(hWnd);
+ return 0;
+ case WM_CLOSE:
+ ShowWindow(hWnd, SW_HIDE);
+ return 0;
+
+ default:
+ return DefWindowProcW(hWnd, message, wParam, lParam);
+ }
+
+ return 0;
+}
+
+static LRESULT CALLBACK PopupChild_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_NOTIFY: {
+ NMHDR *nmhdr = (NMHDR*)lParam;
+ switch(nmhdr->code)
+ {
+ case NM_DBLCLK: {
+ HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+ IndexSubItem *iter;
+
+ if(info == 0 || lParam == 0)
+ return 0;
+ iter = (IndexSubItem*) ((NMITEMACTIVATE *)lParam)->lParam;
+ if(iter == 0)
+ return 0;
+ NavigateToChm(info, info->index->merge.chm_file, iter->local);
+ ShowWindow(info->popup.hwndPopup, SW_HIDE);
+ return 0;
+ }
+ case NM_RETURN: {
+ HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+ IndexSubItem *iter;
+ LVITEMW lvItem;
+
+ if(info == 0)
+ return 0;
+
+ lvItem.iItem = (int) SendMessageW(info->popup.hwndList, LVM_GETSELECTIONMARK, 0, 0);
+ lvItem.mask = TVIF_PARAM;
+ SendMessageW(info->popup.hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem);
+ iter = (IndexSubItem*) lvItem.lParam;
+ NavigateToChm(info, info->index->merge.chm_file, iter->local);
+ ShowWindow(info->popup.hwndPopup, SW_HIDE);
+ return 0;
+ }
+ }
+ break;
+ }
+ default:
+ return DefWindowProcW(hWnd, message, wParam, lParam);
+ }
+
+ return 0;
+}
+
+static BOOL AddIndexPopup(HHInfo *info)
+{
+ static const WCHAR szPopupChildClass[] = {'H','H',' ','P','o','p','u','p',' ','C','h','i','l','d',0};
+ static const WCHAR windowCaptionW[] = {'S','e','l','e','c','t',' ','T','o','p','i','c',':',0};
+ static const WCHAR windowClassW[] = {'H','H',' ','P','o','p','u','p',0};
+ HWND hwndList, hwndPopup, hwndCallback;
+ char hidden_column[] = "Column";
+ WNDCLASSEXW wcex;
+ LVCOLUMNA lvc;
+
+ if(info->tabs[TAB_INDEX].id == -1)
+ return TRUE; /* No "Index" tab */
+
+ wcex.cbSize = sizeof(WNDCLASSEXW);
+ wcex.style = CS_HREDRAW | CS_VREDRAW;
+ wcex.lpfnWndProc = HelpPopup_WndProc;
+ wcex.cbClsExtra = 0;
+ wcex.cbWndExtra = 0;
+ wcex.hInstance = hhctrl_hinstance;
+ wcex.hIcon = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+ wcex.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
+ wcex.hbrBackground = (HBRUSH)(COLOR_MENU + 1);
+ wcex.lpszMenuName = NULL;
+ wcex.lpszClassName = windowClassW;
+ wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+ RegisterClassExW(&wcex);
+
+ wcex.cbSize = sizeof(WNDCLASSEXW);
+ wcex.style = 0;
+ wcex.lpfnWndProc = PopupChild_WndProc;
+ wcex.cbClsExtra = 0;
+ wcex.cbWndExtra = 0;
+ wcex.hInstance = hhctrl_hinstance;
+ wcex.hIcon = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+ wcex.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
+ wcex.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
+ wcex.lpszMenuName = NULL;
+ wcex.lpszClassName = szPopupChildClass;
+ wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
+ RegisterClassExW(&wcex);
+
+ hwndPopup = CreateWindowExW(WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_APPWINDOW
+ | WS_EX_WINDOWEDGE | WS_EX_RIGHTSCROLLBAR,
+ windowClassW, windowCaptionW, WS_POPUPWINDOW
+ | WS_OVERLAPPEDWINDOW | WS_VISIBLE
+ | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, CW_USEDEFAULT,
+ CW_USEDEFAULT, 300, 200, info->WinType.hwndHelp,
+ NULL, hhctrl_hinstance, NULL);
+ if (!hwndPopup)
+ return FALSE;
+
+ hwndCallback = CreateWindowExW(WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
+ szPopupChildClass, szEmpty, WS_CHILDWINDOW | WS_VISIBLE,
+ 0, 0, 0, 0,
+ hwndPopup, NULL, hhctrl_hinstance, NULL);
+ if (!hwndCallback)
+ return FALSE;
+
+ ShowWindow(hwndPopup, SW_HIDE);
+ hwndList = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEWW, szEmpty,
+ WS_CHILD | WS_BORDER | LVS_SINGLESEL | LVS_REPORT
+ | LVS_NOCOLUMNHEADER, 50, 50, 100, 100,
+ hwndCallback, NULL, hhctrl_hinstance, NULL);
+ if(!hwndList) {
+ ERR("Could not create popup ListView control\n");
+ return FALSE;
+ }
+ memset(&lvc, 0, sizeof(lvc));
+ lvc.mask = LVCF_TEXT;
+ lvc.pszText = hidden_column;
+ if(SendMessageW(hwndList, LVM_INSERTCOLUMNA, 0, (LPARAM) &lvc) == -1)
+ {
+ ERR("Could not create popup ListView column\n");
+ return FALSE;
+ }
+
+ info->popup.hwndCallback = hwndCallback;
+ info->popup.hwndPopup = hwndPopup;
+ info->popup.hwndList = hwndList;
+ SetWindowLongPtrW(hwndPopup, GWLP_USERDATA, (LONG_PTR)info);
+ SetWindowLongPtrW(hwndCallback, GWLP_USERDATA, (LONG_PTR)info);
+
+ ResizePopupChild(info);
+ ShowWindow(hwndList, SW_SHOW);
+
return TRUE;
}
/* Viewer Window */
-static void Help_OnSize(HWND hWnd, LPARAM lParam)
+static void ExpandContract(HHInfo *pHHInfo)
+{
+ RECT r, nav;
+
+ pHHInfo->WinType.fNotExpanded = !pHHInfo->WinType.fNotExpanded;
+ GetWindowRect(pHHInfo->WinType.hwndHelp, &r);
+ NP_GetNavigationRect(pHHInfo, &nav);
+
+ /* hide/show both the nav bar and the size bar */
+ if (pHHInfo->WinType.fNotExpanded)
+ {
+ ShowWindow(pHHInfo->WinType.hwndNavigation, SW_HIDE);
+ ShowWindow(pHHInfo->hwndSizeBar, SW_HIDE);
+ r.left = r.left + nav.right;
+
+ SendMessageW(pHHInfo->WinType.hwndToolBar, TB_HIDEBUTTON, IDTB_EXPAND, MAKELPARAM(FALSE, 0));
+ SendMessageW(pHHInfo->WinType.hwndToolBar, TB_HIDEBUTTON, IDTB_CONTRACT, MAKELPARAM(TRUE, 0));
+ }
+ else
+ {
+ ShowWindow(pHHInfo->WinType.hwndNavigation, SW_SHOW);
+ ShowWindow(pHHInfo->hwndSizeBar, SW_SHOW);
+ r.left = r.left - nav.right;
+
+ SendMessageW(pHHInfo->WinType.hwndToolBar, TB_HIDEBUTTON, IDTB_EXPAND, MAKELPARAM(TRUE, 0));
+ SendMessageW(pHHInfo->WinType.hwndToolBar, TB_HIDEBUTTON, IDTB_CONTRACT, MAKELPARAM(FALSE, 0));
+ }
+
+ MoveWindow(pHHInfo->WinType.hwndHelp, r.left, r.top, r.right-r.left, r.bottom-r.top, TRUE);
+}
+
+static LRESULT Help_OnSize(HWND hWnd)
{
HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+ DWORD dwSize;
RECT rc;
if (!pHHInfo)
- return;
+ return 0;
- /* Only resize the Navigation pane vertically */
- if (HIWORD(lParam))
+ if (!pHHInfo->WinType.fNotExpanded)
{
NP_GetNavigationRect(pHHInfo, &rc);
- SetWindowPos(pHHInfo->pHHWinType->hwndNavigation, HWND_TOP, 0, 0,
+ SetWindowPos(pHHInfo->WinType.hwndNavigation, HWND_TOP, 0, 0,
rc.right, rc.bottom, SWP_NOMOVE);
- GetClientRect(pHHInfo->pHHWinType->hwndNavigation, &rc);
- SetWindowPos(pHHInfo->hwndTabCtrl, HWND_TOP, 0, 0,
- rc.right - TAB_PADDING - TAB_RIGHT_PADDING,
- rc.bottom - TAB_PADDING - TAB_TOP_PADDING, SWP_NOMOVE);
+ SB_GetSizeBarRect(pHHInfo, &rc);
+ SetWindowPos(pHHInfo->hwndSizeBar, HWND_TOP, rc.left, rc.top,
+ rc.right, rc.bottom, SWP_SHOWWINDOW);
+
}
HP_GetHTMLRect(pHHInfo, &rc);
- SetWindowPos(pHHInfo->pHHWinType->hwndHTML, HWND_TOP, 0, 0,
- LOWORD(lParam), HIWORD(lParam), SWP_NOMOVE);
+ SetWindowPos(pHHInfo->WinType.hwndHTML, HWND_TOP, rc.left, rc.top,
+ rc.right, rc.bottom, SWP_SHOWWINDOW);
+
+ /* Resize browser window taking the frame size into account */
+ dwSize = GetSystemMetrics(SM_CXFRAME);
+ ResizeWebBrowser(pHHInfo, rc.right - dwSize, rc.bottom - dwSize);
+
+ return 0;
}
-LRESULT CALLBACK Help_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+static LRESULT CALLBACK Help_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
- PAINTSTRUCT ps;
- HDC hdc;
-
switch (message)
{
- case WM_SIZE:
- Help_OnSize(hWnd, lParam);
- break;
- case WM_PAINT:
- hdc = BeginPaint(hWnd, &ps);
- EndPaint(hWnd, &ps);
- break;
- case WM_DESTROY:
+ case WM_COMMAND:
+ if (HIWORD(wParam) == BN_CLICKED)
+ TB_OnClick(hWnd, LOWORD(wParam));
+ break;
+ case WM_SIZE:
+ return Help_OnSize(hWnd);
+ case WM_CLOSE:
+ ReleaseHelpViewer((HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA));
+ return 0;
+ case WM_DESTROY:
+ if(hh_process)
PostQuitMessage(0);
- break;
+ break;
- default:
- return DefWindowProcW(hWnd, message, wParam, lParam);
+ default:
+ return DefWindowProcW(hWnd, message, wParam, lParam);
}
return 0;
}
-static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
+static BOOL HH_CreateHelpWindow(HHInfo *info)
{
HWND hWnd;
- HINSTANCE hInstance = pHHInfo->hInstance;
- RECT winPos = pHHInfo->pHHWinType->rcWindowPos;
+ RECT winPos = info->WinType.rcWindowPos;
WNDCLASSEXW wcex;
DWORD dwStyles, dwExStyles;
- DWORD x, y, width, height;
+ DWORD x, y, width = 0, height = 0;
+ LPCWSTR caption;
static const WCHAR windowClassW[] = {
'H','H',' ', 'P','a','r','e','n','t',0
wcex.cbSize = sizeof(WNDCLASSEXW);
wcex.style = CS_HREDRAW | CS_VREDRAW;
- wcex.lpfnWndProc = (WNDPROC)Help_WndProc;
+ wcex.lpfnWndProc = Help_WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
- wcex.hInstance = hInstance;
+ wcex.hInstance = hhctrl_hinstance;
wcex.hIcon = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
wcex.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_MENU + 1);
RegisterClassExW(&wcex);
/* Read in window parameters if available */
- if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_STYLES)
- dwStyles = pHHInfo->pHHWinType->dwStyles;
+ if (info->WinType.fsValidMembers & HHWIN_PARAM_STYLES)
+ dwStyles = info->WinType.dwStyles | WS_OVERLAPPEDWINDOW;
else
dwStyles = WS_OVERLAPPEDWINDOW | WS_VISIBLE |
WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
- if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_EXSTYLES)
- dwExStyles = pHHInfo->pHHWinType->dwExStyles;
+ if (info->WinType.fsValidMembers & HHWIN_PARAM_EXSTYLES)
+ dwExStyles = info->WinType.dwExStyles;
else
dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_APPWINDOW |
WS_EX_WINDOWEDGE | WS_EX_RIGHTSCROLLBAR;
- if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_RECT)
+ if (info->WinType.fsValidMembers & HHWIN_PARAM_RECT)
{
x = winPos.left;
y = winPos.top;
width = winPos.right - x;
height = winPos.bottom - y;
}
- else
+ if (!width || !height)
{
x = WINTYPE_DEFAULT_X;
y = WINTYPE_DEFAULT_Y;
height = WINTYPE_DEFAULT_HEIGHT;
}
- hWnd = CreateWindowExW(dwExStyles, windowClassW, pHHInfo->pHHWinType->pszCaption,
- dwStyles, x, y, width, height, NULL, NULL, hInstance, NULL);
+ if (info->WinType.fNotExpanded)
+ {
+ if (!(info->WinType.fsValidMembers & HHWIN_PARAM_NAV_WIDTH) &&
+ info->WinType.iNavWidth == 0)
+ {
+ info->WinType.iNavWidth = WINTYPE_DEFAULT_NAVWIDTH;
+ }
+
+ x += info->WinType.iNavWidth;
+ width -= info->WinType.iNavWidth;
+ }
+
+
+ caption = info->WinType.pszCaption;
+ if (!*caption) caption = info->pCHMInfo->defTitle;
+
+ hWnd = CreateWindowExW(dwExStyles, windowClassW, caption,
+ dwStyles, x, y, width, height, NULL, NULL, hhctrl_hinstance, NULL);
if (!hWnd)
return FALSE;
UpdateWindow(hWnd);
/* store the pointer to the HH info struct */
- SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
+ SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)info);
- pHHInfo->pHHWinType->hwndHelp = hWnd;
+ info->WinType.hwndHelp = hWnd;
return TRUE;
}
}
/* Creates the whole package */
-static BOOL HH_CreateViewer(HHInfo *pHHInfo)
+static BOOL CreateViewer(HHInfo *pHHInfo)
{
HH_CreateFont(pHHInfo);
if (!HH_AddNavigationPane(pHHInfo))
return FALSE;
+ HH_RegisterSizeBarClass(pHHInfo);
+
+ if (!HH_AddSizeBar(pHHInfo))
+ return FALSE;
+
if (!HH_AddHTMLPane(pHHInfo))
return FALSE;
- return TRUE;
-}
+ if (!AddContentTab(pHHInfo))
+ return FALSE;
-static HHInfo *HH_OpenHH(HINSTANCE hInstance, LPWSTR szCmdLine)
-{
- HHInfo *pHHInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HHInfo));
+ if (!AddIndexTab(pHHInfo))
+ return FALSE;
- pHHInfo->pHHWinType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HH_WINTYPEW));
- pHHInfo->pCHMInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(CHMInfo));
- pHHInfo->hInstance = hInstance;
- pHHInfo->szCmdLine = szCmdLine;
+ if (!AddIndexPopup(pHHInfo))
+ return FALSE;
- return pHHInfo;
-}
+ if (!AddSearchTab(pHHInfo))
+ return FALSE;
-static void HH_Close(HHInfo *pHHInfo)
-{
- if (!pHHInfo)
- return;
+ InitContent(pHHInfo);
+ InitIndex(pHHInfo);
- /* Free allocated strings */
- if (pHHInfo->pHHWinType)
- {
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszType);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszCaption);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszToc);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszType);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszIndex);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszFile);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszHome);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszJump1);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszJump2);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszUrlJump1);
- HeapFree(GetProcessHeap(), 0, (LPWSTR)pHHInfo->pHHWinType->pszUrlJump2);
- }
-
- HeapFree(GetProcessHeap(), 0, pHHInfo->pHHWinType);
- HeapFree(GetProcessHeap(), 0, pHHInfo->szCmdLine);
-
- if (pHHInfo->pCHMInfo)
- {
- CHM_CloseCHM(pHHInfo->pCHMInfo);
- HeapFree(GetProcessHeap(), 0, pHHInfo->pCHMInfo);
- }
+ return TRUE;
}
-static BOOL HH_OpenCHM(HHInfo *pHHInfo)
+void ReleaseHelpViewer(HHInfo *info)
{
- if (!CHM_OpenCHM(pHHInfo->pCHMInfo, pHHInfo->szCmdLine))
- return FALSE;
+ TRACE("(%p)\n", info);
- if (!CHM_LoadWinTypeFromCHM(pHHInfo->pCHMInfo, pHHInfo->pHHWinType))
- return FALSE;
+ if (!info)
+ return;
- return TRUE;
+ /* Free allocated strings */
+ heap_free(info->pszType);
+ heap_free(info->pszCaption);
+ heap_free(info->pszToc);
+ heap_free(info->pszIndex);
+ heap_free(info->pszFile);
+ heap_free(info->pszHome);
+ heap_free(info->pszJump1);
+ heap_free(info->pszJump2);
+ heap_free(info->pszUrlJump1);
+ heap_free(info->pszUrlJump2);
+
+ if (info->pCHMInfo)
+ CloseCHM(info->pCHMInfo);
+
+ ReleaseWebBrowser(info);
+ ReleaseContent(info);
+ ReleaseIndex(info);
+ ReleaseSearch(info);
+
+ if(info->WinType.hwndHelp)
+ DestroyWindow(info->WinType.hwndHelp);
+
+ heap_free(info);
+ OleUninitialize();
}
-/* FIXME: Check szCmdLine for bad arguments */
-int WINAPI doWinMain(HINSTANCE hInstance, LPSTR szCmdLine)
+HHInfo *CreateHelpViewer(LPCWSTR filename)
{
- MSG msg;
- HHInfo *pHHInfo;
+ HHInfo *info = heap_alloc_zero(sizeof(HHInfo));
+ int i;
- if (OleInitialize(NULL) != S_OK)
- return -1;
+ /* Set the invalid tab ID (-1) as the default value for all
+ * of the tabs, this matches a failed TCM_INSERTITEM call.
+ */
+ for(i=0;i<sizeof(info->tabs)/sizeof(HHTab);i++)
+ info->tabs[i].id = -1;
- pHHInfo = HH_OpenHH(hInstance, HH_ANSIToUnicode(szCmdLine));
- if (!pHHInfo || !HH_OpenCHM(pHHInfo) || !HH_CreateViewer(pHHInfo))
- {
- OleUninitialize();
- return -1;
+ OleInitialize(NULL);
+
+ info->pCHMInfo = OpenCHM(filename);
+ if(!info->pCHMInfo) {
+ ReleaseHelpViewer(info);
+ return NULL;
}
- while (GetMessageW(&msg, 0, 0, 0))
- {
- TranslateMessage(&msg);
- DispatchMessageW(&msg);
+ if (!LoadWinTypeFromCHM(info)) {
+ ReleaseHelpViewer(info);
+ return NULL;
}
- HH_Close(pHHInfo);
- HeapFree(GetProcessHeap(), 0, pHHInfo);
- OleUninitialize();
+ if(!CreateViewer(info)) {
+ ReleaseHelpViewer(info);
+ return NULL;
+ }
- return 0;
+ return info;
}