| /* | |
| * 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 | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #include "hhctrl.h" | |
| #include "wingdi.h" | |
| #include "commctrl.h" | |
| #include "wininet.h" | |
| #include "wine/debug.h" | |
| #include "resource.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp); | |
| static LRESULT Help_OnSize(HWND hWnd); | |
| static void ExpandContract(HHInfo *pHHInfo); | |
| /* Window type defaults */ | |
| #define WINTYPE_DEFAULT_X 280 | |
| #define WINTYPE_DEFAULT_Y 100 | |
| #define WINTYPE_DEFAULT_WIDTH 740 | |
| #define WINTYPE_DEFAULT_HEIGHT 640 | |
| #define WINTYPE_DEFAULT_NAVWIDTH 250 | |
| #define TAB_TOP_PADDING 8 | |
| #define TAB_RIGHT_PADDING 4 | |
| #define TAB_MARGIN 8 | |
| #define EDIT_HEIGHT 20 | |
| struct list window_list = LIST_INIT(window_list); | |
| static const WCHAR szEmpty[] = {0}; | |
| struct html_encoded_symbol { | |
| const char *html_code; | |
| char ansi_symbol; | |
| }; | |
| /* | |
| * Table mapping the conversion between HTML encoded symbols and their ANSI code page equivalent. | |
| * Note: Add additional entries in proper alphabetical order (a binary search is used on this table). | |
| */ | |
| static struct html_encoded_symbol html_encoded_symbols[] = | |
| { | |
| {"AElig", 0xC6}, | |
| {"Aacute", 0xC1}, | |
| {"Acirc", 0xC2}, | |
| {"Agrave", 0xC0}, | |
| {"Aring", 0xC5}, | |
| {"Atilde", 0xC3}, | |
| {"Auml", 0xC4}, | |
| {"Ccedil", 0xC7}, | |
| {"ETH", 0xD0}, | |
| {"Eacute", 0xC9}, | |
| {"Ecirc", 0xCA}, | |
| {"Egrave", 0xC8}, | |
| {"Euml", 0xCB}, | |
| {"Iacute", 0xCD}, | |
| {"Icirc", 0xCE}, | |
| {"Igrave", 0xCC}, | |
| {"Iuml", 0xCF}, | |
| {"Ntilde", 0xD1}, | |
| {"Oacute", 0xD3}, | |
| {"Ocirc", 0xD4}, | |
| {"Ograve", 0xD2}, | |
| {"Oslash", 0xD8}, | |
| {"Otilde", 0xD5}, | |
| {"Ouml", 0xD6}, | |
| {"THORN", 0xDE}, | |
| {"Uacute", 0xDA}, | |
| {"Ucirc", 0xDB}, | |
| {"Ugrave", 0xD9}, | |
| {"Uuml", 0xDC}, | |
| {"Yacute", 0xDD}, | |
| {"aacute", 0xE1}, | |
| {"acirc", 0xE2}, | |
| {"acute", 0xB4}, | |
| {"aelig", 0xE6}, | |
| {"agrave", 0xE0}, | |
| {"amp", '&'}, | |
| {"aring", 0xE5}, | |
| {"atilde", 0xE3}, | |
| {"auml", 0xE4}, | |
| {"brvbar", 0xA6}, | |
| {"ccedil", 0xE7}, | |
| {"cedil", 0xB8}, | |
| {"cent", 0xA2}, | |
| {"copy", 0xA9}, | |
| {"curren", 0xA4}, | |
| {"deg", 0xB0}, | |
| {"divide", 0xF7}, | |
| {"eacute", 0xE9}, | |
| {"ecirc", 0xEA}, | |
| {"egrave", 0xE8}, | |
| {"eth", 0xF0}, | |
| {"euml", 0xEB}, | |
| {"frac12", 0xBD}, | |
| {"frac14", 0xBC}, | |
| {"frac34", 0xBE}, | |
| {"gt", '>'}, | |
| {"iacute", 0xED}, | |
| {"icirc", 0xEE}, | |
| {"iexcl", 0xA1}, | |
| {"igrave", 0xEC}, | |
| {"iquest", 0xBF}, | |
| {"iuml", 0xEF}, | |
| {"laquo", 0xAB}, | |
| {"lt", '<'}, | |
| {"macr", 0xAF}, | |
| {"micro", 0xB5}, | |
| {"middot", 0xB7}, | |
| {"nbsp", ' '}, | |
| {"not", 0xAC}, | |
| {"ntilde", 0xF1}, | |
| {"oacute", 0xF3}, | |
| {"ocirc", 0xF4}, | |
| {"ograve", 0xF2}, | |
| {"ordf", 0xAA}, | |
| {"ordm", 0xBA}, | |
| {"oslash", 0xF8}, | |
| {"otilde", 0xF5}, | |
| {"ouml", 0xF6}, | |
| {"para", 0xB6}, | |
| {"plusmn", 0xB1}, | |
| {"pound", 0xA3}, | |
| {"quot", '"'}, | |
| {"raquo", 0xBB}, | |
| {"reg", 0xAE}, | |
| {"sect", 0xA7}, | |
| {"shy", 0xAD}, | |
| {"sup1", 0xB9}, | |
| {"sup2", 0xB2}, | |
| {"sup3", 0xB3}, | |
| {"szlig", 0xDF}, | |
| {"thorn", 0xFE}, | |
| {"times", 0xD7}, | |
| {"uacute", 0xFA}, | |
| {"ucirc", 0xFB}, | |
| {"ugrave", 0xF9}, | |
| {"uml", 0xA8}, | |
| {"uuml", 0xFC}, | |
| {"yacute", 0xFD}, | |
| {"yen", 0xA5}, | |
| {"yuml", 0xFF} | |
| }; | |
| static inline BOOL navigation_visible(HHInfo *info) | |
| { | |
| return ((info->WinType.fsWinProperties & HHWIN_PROP_TRI_PANE) && !info->WinType.fNotExpanded); | |
| } | |
| /* Loads a string from the resource file */ | |
| static LPWSTR HH_LoadString(DWORD dwID) | |
| { | |
| 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; | |
| return string; | |
| } | |
| static HRESULT navigate_url(HHInfo *info, LPCWSTR surl) | |
| { | |
| VARIANT url; | |
| HRESULT hres; | |
| TRACE("%s\n", debugstr_w(surl)); | |
| V_VT(&url) = VT_BSTR; | |
| V_BSTR(&url) = SysAllocString(surl); | |
| hres = IWebBrowser2_Navigate2(info->web_browser->web_browser, &url, 0, 0, 0, 0); | |
| VariantClear(&url); | |
| if(FAILED(hres)) | |
| TRACE("Navigation failed: %08x\n", hres); | |
| return hres; | |
| } | |
| BOOL NavigateToUrl(HHInfo *info, LPCWSTR surl) | |
| { | |
| ChmPath chm_path; | |
| BOOL ret; | |
| HRESULT hres; | |
| static const WCHAR url_indicator[] = {':', '/', '/', 0}; | |
| TRACE("%s\n", debugstr_w(surl)); | |
| 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; | |
| } | |
| static 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]; | |
| TRACE("%p %s %s\n", info, debugstr_w(file), debugstr_w(index)); | |
| if ((!info->web_browser) || !AppendFullPathURL(file, buf, index)) | |
| return FALSE; | |
| return SUCCEEDED(navigate_url(info, buf)); | |
| } | |
| static void DoSync(HHInfo *info) | |
| { | |
| WCHAR buf[INTERNET_MAX_URL_LENGTH]; | |
| HRESULT hres; | |
| BSTR url; | |
| hres = IWebBrowser2_get_LocationURL(info->web_browser->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->WinType.pszFile, buf, NULL)) || (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, 0); | |
| 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 = sizeof(LONG_PTR); | |
| 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); | |
| SetRect(rc, rectNP.right, rectTB.bottom, SIZEBAR_WIDTH, rectWND.bottom - rectTB.bottom); | |
| } | |
| 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 (navigation_visible(pHHInfo)) | |
| 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, 0, (LONG_PTR)pHHInfo); | |
| pHHInfo->hwndSizeBar = hWnd; | |
| return TRUE; | |
| } | |
| /* Child Window */ | |
| static const WCHAR szChildClass[] = { | |
| 'H','H',' ','C','h','i','l','d',0 | |
| }; | |
| static LRESULT Child_OnPaint(HWND hWnd) | |
| { | |
| PAINTSTRUCT ps; | |
| HDC hdc; | |
| RECT rc; | |
| hdc = BeginPaint(hWnd, &ps); | |
| /* Only paint the Navigation pane, identified by the fact | |
| * that it has a child window | |
| */ | |
| if (GetWindow(hWnd, GW_CHILD)) | |
| { | |
| GetClientRect(hWnd, &rc); | |
| /* set the border color */ | |
| SelectObject(hdc, GetStockObject(DC_PEN)); | |
| SetDCPenColor(hdc, GetSysColor(COLOR_BTNSHADOW)); | |
| /* Draw the top border */ | |
| LineTo(hdc, rc.right, 0); | |
| 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, 0); | |
| 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); | |
| ResizeTabChild(info, TAB_SEARCH); | |
| return 0; | |
| } | |
| static LRESULT OnTabChange(HWND hwnd) | |
| { | |
| HHInfo *info = (HHInfo*)GetWindowLongPtrW(hwnd, 0); | |
| int tab_id, tab_index, i; | |
| TRACE("%p\n", hwnd); | |
| if (!info) | |
| return 0; | |
| if(info->tabs[info->current_tab].hwnd) | |
| ShowWindow(info->tabs[info->current_tab].hwnd, SW_HIDE); | |
| tab_id = (int) SendMessageW(info->hwndTabCtrl, TCM_GETCURSEL, 0, 0); | |
| /* convert the ID of the tab to an index in our tab list */ | |
| tab_index = -1; | |
| for (i=0; i<TAB_NUMTABS; i++) | |
| { | |
| if (info->tabs[i].id == tab_id) | |
| { | |
| tab_index = i; | |
| break; | |
| } | |
| } | |
| if (tab_index == -1) | |
| { | |
| FIXME("Tab ID %d does not correspond to a valid index in the tab list.\n", tab_id); | |
| return 0; | |
| } | |
| info->current_tab = tab_index; | |
| 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) | |
| item->name = GetDocumentTitle(info->pCHMInfo, item->local); | |
| 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: | |
| return Child_OnPaint(hWnd); | |
| case WM_SIZE: | |
| return Child_OnSize(hWnd); | |
| case WM_NOTIFY: { | |
| HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, 0); | |
| 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 TVN_ITEMEXPANDINGW: { | |
| TVITEMW *item = &((NMTREEVIEWW *)lParam)->itemNew; | |
| HWND hwndTreeView = info->tabs[TAB_CONTENTS].hwnd; | |
| item->mask = TVIF_IMAGE|TVIF_SELECTEDIMAGE; | |
| if (item->state & TVIS_EXPANDED) | |
| { | |
| item->iImage = HHTV_FOLDER; | |
| item->iSelectedImage = HHTV_FOLDER; | |
| } | |
| else | |
| { | |
| item->iImage = HHTV_OPENFOLDER; | |
| item->iSelectedImage = HHTV_OPENFOLDER; | |
| } | |
| SendMessageW(hwndTreeView, TVM_SETITEMW, 0, (LPARAM)item); | |
| return 0; | |
| } | |
| 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; | |
| 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; | |
| } | |
| static void HH_RegisterChildWndClass(HHInfo *pHHInfo) | |
| { | |
| WNDCLASSEXW wcex; | |
| wcex.cbSize = sizeof(WNDCLASSEXW); | |
| wcex.style = 0; | |
| wcex.lpfnWndProc = Child_WndProc; | |
| wcex.cbClsExtra = 0; | |
| wcex.cbWndExtra = sizeof(LONG_PTR); | |
| 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 = szChildClass; | |
| wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION); | |
| RegisterClassExW(&wcex); | |
| } | |
| /* Toolbar */ | |
| #define ICON_SIZE 20 | |
| static void DisplayPopupMenu(HHInfo *info) | |
| { | |
| 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, 0); | |
| switch (dwID) | |
| { | |
| case IDTB_STOP: | |
| DoPageAction(info->web_browser, WB_STOP); | |
| break; | |
| case IDTB_REFRESH: | |
| DoPageAction(info->web_browser, WB_REFRESH); | |
| break; | |
| case IDTB_BACK: | |
| DoPageAction(info->web_browser, WB_GOBACK); | |
| break; | |
| case IDTB_HOME: | |
| NavigateToChm(info, info->pCHMInfo->szFile, info->WinType.pszHome); | |
| break; | |
| case IDTB_FORWARD: | |
| DoPageAction(info->web_browser, WB_GOFORWARD); | |
| break; | |
| case IDTB_PRINT: | |
| DoPageAction(info->web_browser, 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_NOTES: | |
| case IDTB_CONTENTS: | |
| case IDTB_INDEX: | |
| case IDTB_SEARCH: | |
| case IDTB_HISTORY: | |
| case IDTB_FAVORITES: | |
| /* These are officially unimplemented as of the Windows 7 SDK */ | |
| 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].dwData = 0; | |
| pButtons[dwIndex].iString = 0; | |
| } | |
| 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; | |
| DWORD unsupported; | |
| /* 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, HHTB_NUMBITMAPS, (LPARAM)&tbAB); | |
| *pdwNumButtons = 0; | |
| unsupported = dwButtonFlags & (HHWIN_BUTTON_BROWSE_FWD | | |
| HHWIN_BUTTON_BROWSE_BCK | HHWIN_BUTTON_NOTES | HHWIN_BUTTON_CONTENTS | | |
| HHWIN_BUTTON_INDEX | HHWIN_BUTTON_SEARCH | HHWIN_BUTTON_HISTORY | | |
| HHWIN_BUTTON_FAVORITES | HHWIN_BUTTON_JUMP1 | HHWIN_BUTTON_JUMP2 | | |
| HHWIN_BUTTON_ZOOM | HHWIN_BUTTON_TOC_NEXT | HHWIN_BUTTON_TOC_PREV); | |
| if (unsupported) | |
| FIXME("got asked for unsupported buttons: %06x\n", unsupported); | |
| if (dwButtonFlags & HHWIN_BUTTON_EXPAND) | |
| { | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_EXPAND, nHHBitmaps + HHTB_EXPAND); | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_CONTRACT, nHHBitmaps + HHTB_CONTRACT); | |
| 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, nHistBitmaps + HIST_BACK); | |
| if (dwButtonFlags & HHWIN_BUTTON_FORWARD) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_FORWARD, nHistBitmaps + HIST_FORWARD); | |
| if (dwButtonFlags & HHWIN_BUTTON_STOP) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_STOP, nHHBitmaps + HHTB_STOP); | |
| if (dwButtonFlags & HHWIN_BUTTON_REFRESH) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_REFRESH, nHHBitmaps + HHTB_REFRESH); | |
| if (dwButtonFlags & HHWIN_BUTTON_HOME) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_HOME, nHHBitmaps + HHTB_HOME); | |
| if (dwButtonFlags & HHWIN_BUTTON_SYNC) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_SYNC, nHHBitmaps + HHTB_SYNC); | |
| if (dwButtonFlags & HHWIN_BUTTON_OPTIONS) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_OPTIONS, nStdBitmaps + STD_PROPERTIES); | |
| if (dwButtonFlags & HHWIN_BUTTON_PRINT) | |
| TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_PRINT, nStdBitmaps + STD_PRINT); | |
| } | |
| static BOOL HH_AddToolbar(HHInfo *pHHInfo) | |
| { | |
| HWND hToolbar; | |
| HWND hwndParent = pHHInfo->WinType.hwndHelp; | |
| DWORD toolbarFlags; | |
| TBBUTTON buttons[IDTB_TOC_PREV - IDTB_EXPAND]; | |
| DWORD dwStyles, dwExStyles; | |
| DWORD dwNumButtons, dwIndex; | |
| if (pHHInfo->WinType.fsWinProperties & HHWIN_PARAM_TB_FLAGS) | |
| toolbarFlags = pHHInfo->WinType.fsToolBarFlags; | |
| else | |
| toolbarFlags = HHWIN_DEF_BUTTONS; | |
| dwStyles = WS_CHILDWINDOW | 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, | |
| 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); | |
| 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 + 1] = 0; /* Double-null terminate */ | |
| buttons[dwIndex].iString = (DWORD)SendMessageW(hToolbar, TB_ADDSTRINGW, 0, (LPARAM)szBuf); | |
| heap_free(szBuf); | |
| } | |
| SendMessageW(hToolbar, TB_ADDBUTTONSW, dwNumButtons, (LPARAM)buttons); | |
| SendMessageW(hToolbar, TB_AUTOSIZE, 0, 0); | |
| if (pHHInfo->WinType.fsWinProperties & HHWIN_PROP_TRI_PANE) | |
| ShowWindow(hToolbar, SW_SHOW); | |
| return TRUE; | |
| } | |
| /* Navigation Pane */ | |
| static void NP_GetNavigationRect(HHInfo *pHHInfo, RECT *rc) | |
| { | |
| HWND hwndParent = pHHInfo->WinType.hwndHelp; | |
| HWND hwndToolbar = pHHInfo->WinType.hwndToolBar; | |
| RECT rectWND, rectTB; | |
| GetClientRect(hwndParent, &rectWND); | |
| GetClientRect(hwndToolbar, &rectTB); | |
| rc->left = 0; | |
| rc->top = rectTB.bottom; | |
| rc->bottom = rectWND.bottom - rectTB.bottom; | |
| if (!(pHHInfo->WinType.fsValidMembers & HHWIN_PARAM_NAV_WIDTH) && | |
| pHHInfo->WinType.iNavWidth == 0) | |
| { | |
| pHHInfo->WinType.iNavWidth = WINTYPE_DEFAULT_NAVWIDTH; | |
| } | |
| rc->right = pHHInfo->WinType.iNavWidth; | |
| } | |
| static DWORD NP_CreateTab(HINSTANCE hInstance, HWND hwndTabCtrl, DWORD index) | |
| { | |
| TCITEMW tie; | |
| LPWSTR tabText = HH_LoadString(index); | |
| DWORD ret; | |
| tie.mask = TCIF_TEXT; | |
| tie.pszText = tabText; | |
| ret = SendMessageW( hwndTabCtrl, TCM_INSERTITEMW, index, (LPARAM)&tie ); | |
| heap_free(tabText); | |
| return ret; | |
| } | |
| static BOOL HH_AddNavigationPane(HHInfo *info) | |
| { | |
| HWND hWnd, hwndTabCtrl; | |
| HWND hwndParent = info->WinType.hwndHelp; | |
| DWORD dwStyles = WS_CHILDWINDOW; | |
| DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR; | |
| RECT rc; | |
| if (navigation_visible(info)) | |
| dwStyles |= WS_VISIBLE; | |
| NP_GetNavigationRect(info, &rc); | |
| hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles, | |
| rc.left, rc.top, rc.right, rc.bottom, | |
| hwndParent, NULL, hhctrl_hinstance, NULL); | |
| if (!hWnd) | |
| return FALSE; | |
| SetWindowLongPtrW(hWnd, 0, (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 (*info->WinType.pszToc) | |
| info->tabs[TAB_CONTENTS].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_CONTENTS); | |
| if (*info->WinType.pszIndex) | |
| info->tabs[TAB_INDEX].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_INDEX); | |
| if (info->WinType.fsWinProperties & HHWIN_PROP_TAB_SEARCH) | |
| info->tabs[TAB_SEARCH].id = NP_CreateTab(hhctrl_hinstance, hwndTabCtrl, IDS_SEARCH); | |
| 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)info->hFont, TRUE); | |
| info->hwndTabCtrl = hwndTabCtrl; | |
| info->WinType.hwndNavigation = hWnd; | |
| return TRUE; | |
| } | |
| /* HTML Pane */ | |
| static void HP_GetHTMLRect(HHInfo *info, RECT *rc) | |
| { | |
| RECT rectTB, rectWND, rectNP, rectSB; | |
| GetClientRect(info->WinType.hwndHelp, &rectWND); | |
| GetClientRect(info->hwndSizeBar, &rectSB); | |
| rc->left = 0; | |
| rc->top = 0; | |
| if (navigation_visible(info)) | |
| { | |
| GetClientRect(info->WinType.hwndNavigation, &rectNP); | |
| rc->left += rectNP.right + rectSB.right; | |
| } | |
| if (info->WinType.fsWinProperties & HHWIN_PROP_TRI_PANE) | |
| { | |
| GetClientRect(info->WinType.hwndToolBar, &rectTB); | |
| rc->top += rectTB.bottom; | |
| } | |
| rc->right = rectWND.right - rc->left; | |
| rc->bottom = rectWND.bottom - rc->top; | |
| } | |
| static BOOL HH_AddHTMLPane(HHInfo *pHHInfo) | |
| { | |
| HWND hWnd; | |
| 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; | |
| HP_GetHTMLRect(pHHInfo, &rc); | |
| hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles, | |
| rc.left, rc.top, rc.right, rc.bottom, | |
| 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, 0, (LONG_PTR)pHHInfo); | |
| ShowWindow(hWnd, SW_SHOW); | |
| UpdateWindow(hWnd); | |
| pHHInfo->WinType.hwndHTML = hWnd; | |
| return TRUE; | |
| } | |
| static BOOL AddContentTab(HHInfo *info) | |
| { | |
| HIMAGELIST hImageList; | |
| HBITMAP hBitmap; | |
| HWND hWnd; | |
| if(info->tabs[TAB_CONTENTS].id == -1) | |
| return TRUE; /* No "Contents" tab */ | |
| hWnd = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW, szEmpty, WS_CHILD | WS_BORDER | TVS_LINESATROOT | |
| | TVS_SHOWSELALWAYS | TVS_HASBUTTONS, 50, 50, 100, 100, | |
| info->WinType.hwndNavigation, NULL, hhctrl_hinstance, NULL); | |
| if(!hWnd) { | |
| ERR("Could not create treeview control\n"); | |
| return FALSE; | |
| } | |
| hImageList = ImageList_Create(16, 16, ILC_COLOR32, 0, HHTV_NUMBITMAPS); | |
| hBitmap = LoadBitmapW(hhctrl_hinstance, MAKEINTRESOURCEW(IDB_HHTREEVIEW)); | |
| ImageList_Add(hImageList, hBitmap, NULL); | |
| SendMessageW(hWnd, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)hImageList); | |
| info->contents.hImageList = hImageList; | |
| info->tabs[TAB_CONTENTS].hwnd = hWnd; | |
| ResizeTabChild(info, TAB_CONTENTS); | |
| ShowWindow(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, 0, (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, 0); | |
| 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, 0); | |
| 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, 0); | |
| 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 = sizeof(LONG_PTR); | |
| 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 = sizeof(LONG_PTR); | |
| 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, 0, (LONG_PTR)info); | |
| SetWindowLongPtrW(hwndCallback, 0, (LONG_PTR)info); | |
| ResizePopupChild(info); | |
| ShowWindow(hwndList, SW_SHOW); | |
| return TRUE; | |
| } | |
| /* Viewer Window */ | |
| 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, 0); | |
| DWORD dwSize; | |
| RECT rc; | |
| if (!pHHInfo) | |
| return 0; | |
| if (navigation_visible(pHHInfo)) | |
| { | |
| NP_GetNavigationRect(pHHInfo, &rc); | |
| SetWindowPos(pHHInfo->WinType.hwndNavigation, HWND_TOP, 0, 0, | |
| rc.right, rc.bottom, 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->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; | |
| } | |
| void UpdateHelpWindow(HHInfo *info) | |
| { | |
| if (!info->WinType.hwndHelp) | |
| return; | |
| WARN("Only the size of the window is currently updated.\n"); | |
| if (info->WinType.fsValidMembers & HHWIN_PARAM_RECT) | |
| { | |
| RECT *rect = &info->WinType.rcWindowPos; | |
| INT x, y, width, height; | |
| x = rect->left; | |
| y = rect->top; | |
| width = rect->right - x; | |
| height = rect->bottom - y; | |
| SetWindowPos(info->WinType.hwndHelp, NULL, rect->left, rect->top, width, height, | |
| SWP_NOZORDER | SWP_NOACTIVATE); | |
| } | |
| } | |
| static LRESULT CALLBACK Help_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) | |
| { | |
| switch (message) | |
| { | |
| 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, 0)); | |
| return 0; | |
| case WM_DESTROY: | |
| if(hh_process) | |
| PostQuitMessage(0); | |
| break; | |
| default: | |
| return DefWindowProcW(hWnd, message, wParam, lParam); | |
| } | |
| return 0; | |
| } | |
| static BOOL HH_CreateHelpWindow(HHInfo *info) | |
| { | |
| HWND hWnd, parent = 0; | |
| RECT winPos = info->WinType.rcWindowPos; | |
| WNDCLASSEXW wcex; | |
| DWORD dwStyles, dwExStyles; | |
| 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 = Help_WndProc; | |
| wcex.cbClsExtra = 0; | |
| wcex.cbWndExtra = sizeof(LONG_PTR); | |
| 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); | |
| /* Read in window parameters if available */ | |
| if (info->WinType.fsValidMembers & HHWIN_PARAM_STYLES) | |
| { | |
| dwStyles = info->WinType.dwStyles; | |
| if (!(info->WinType.dwStyles & WS_CHILD)) | |
| dwStyles |= WS_OVERLAPPEDWINDOW; | |
| } | |
| else | |
| dwStyles = WS_OVERLAPPEDWINDOW | WS_VISIBLE | | |
| WS_CLIPSIBLINGS | WS_CLIPCHILDREN; | |
| 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 (info->WinType.fsValidMembers & HHWIN_PARAM_RECT) | |
| { | |
| x = winPos.left; | |
| y = winPos.top; | |
| width = winPos.right - x; | |
| height = winPos.bottom - y; | |
| } | |
| if (!width || !height) | |
| { | |
| x = WINTYPE_DEFAULT_X; | |
| y = WINTYPE_DEFAULT_Y; | |
| width = WINTYPE_DEFAULT_WIDTH; | |
| height = WINTYPE_DEFAULT_HEIGHT; | |
| } | |
| if (!(info->WinType.fsWinProperties & HHWIN_PROP_TRI_PANE) && 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; | |
| if (info->WinType.dwStyles & WS_CHILD) | |
| parent = info->WinType.hwndCaller; | |
| hWnd = CreateWindowExW(dwExStyles, windowClassW, caption, | |
| dwStyles, x, y, width, height, parent, NULL, hhctrl_hinstance, NULL); | |
| if (!hWnd) | |
| return FALSE; | |
| ShowWindow(hWnd, SW_SHOW); | |
| UpdateWindow(hWnd); | |
| /* store the pointer to the HH info struct */ | |
| SetWindowLongPtrW(hWnd, 0, (LONG_PTR)info); | |
| info->WinType.hwndHelp = hWnd; | |
| return TRUE; | |
| } | |
| static void HH_CreateFont(HHInfo *pHHInfo) | |
| { | |
| LOGFONTW lf; | |
| GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf); | |
| lf.lfWeight = FW_NORMAL; | |
| lf.lfItalic = FALSE; | |
| lf.lfUnderline = FALSE; | |
| pHHInfo->hFont = CreateFontIndirectW(&lf); | |
| } | |
| static void HH_InitRequiredControls(DWORD dwControls) | |
| { | |
| INITCOMMONCONTROLSEX icex; | |
| icex.dwSize = sizeof(INITCOMMONCONTROLSEX); | |
| icex.dwICC = dwControls; | |
| InitCommonControlsEx(&icex); | |
| } | |
| /* Creates the whole package */ | |
| static BOOL CreateViewer(HHInfo *pHHInfo) | |
| { | |
| HH_CreateFont(pHHInfo); | |
| if (!HH_CreateHelpWindow(pHHInfo)) | |
| return FALSE; | |
| HH_InitRequiredControls(ICC_BAR_CLASSES); | |
| if (!HH_AddToolbar(pHHInfo)) | |
| return FALSE; | |
| HH_RegisterChildWndClass(pHHInfo); | |
| if (!HH_AddNavigationPane(pHHInfo)) | |
| return FALSE; | |
| HH_RegisterSizeBarClass(pHHInfo); | |
| if (!HH_AddSizeBar(pHHInfo)) | |
| return FALSE; | |
| if (!HH_AddHTMLPane(pHHInfo)) | |
| return FALSE; | |
| if (!AddContentTab(pHHInfo)) | |
| return FALSE; | |
| if (!AddIndexTab(pHHInfo)) | |
| return FALSE; | |
| if (!AddIndexPopup(pHHInfo)) | |
| return FALSE; | |
| if (!AddSearchTab(pHHInfo)) | |
| return FALSE; | |
| InitContent(pHHInfo); | |
| InitIndex(pHHInfo); | |
| pHHInfo->viewer_initialized = TRUE; | |
| return TRUE; | |
| } | |
| void wintype_stringsW_free(struct wintype_stringsW *stringsW) | |
| { | |
| heap_free(stringsW->pszType); | |
| heap_free(stringsW->pszCaption); | |
| heap_free(stringsW->pszToc); | |
| heap_free(stringsW->pszIndex); | |
| heap_free(stringsW->pszFile); | |
| heap_free(stringsW->pszHome); | |
| heap_free(stringsW->pszJump1); | |
| heap_free(stringsW->pszJump2); | |
| heap_free(stringsW->pszUrlJump1); | |
| heap_free(stringsW->pszUrlJump2); | |
| } | |
| void wintype_stringsA_free(struct wintype_stringsA *stringsA) | |
| { | |
| heap_free(stringsA->pszType); | |
| heap_free(stringsA->pszCaption); | |
| heap_free(stringsA->pszToc); | |
| heap_free(stringsA->pszIndex); | |
| heap_free(stringsA->pszFile); | |
| heap_free(stringsA->pszHome); | |
| heap_free(stringsA->pszJump1); | |
| heap_free(stringsA->pszJump2); | |
| heap_free(stringsA->pszUrlJump1); | |
| heap_free(stringsA->pszUrlJump2); | |
| heap_free(stringsA->pszCustomTabs); | |
| } | |
| void ReleaseHelpViewer(HHInfo *info) | |
| { | |
| TRACE("(%p)\n", info); | |
| if (!info) | |
| return; | |
| list_remove(&info->entry); | |
| wintype_stringsA_free(&info->stringsA); | |
| wintype_stringsW_free(&info->stringsW); | |
| if (info->pCHMInfo) | |
| CloseCHM(info->pCHMInfo); | |
| ReleaseWebBrowser(info); | |
| ReleaseContent(info); | |
| ReleaseIndex(info); | |
| ReleaseSearch(info); | |
| if(info->contents.hImageList) | |
| ImageList_Destroy(info->contents.hImageList); | |
| if(info->WinType.hwndHelp) | |
| DestroyWindow(info->WinType.hwndHelp); | |
| heap_free(info); | |
| OleUninitialize(); | |
| } | |
| HHInfo *CreateHelpViewer(HHInfo *info, LPCWSTR filename, HWND caller) | |
| { | |
| HHInfo *tmp_info; | |
| unsigned int i; | |
| if(!info) | |
| { | |
| info = heap_alloc_zero(sizeof(HHInfo)); | |
| list_add_tail(&window_list, &info->entry); | |
| } | |
| /* 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; | |
| OleInitialize(NULL); | |
| info->pCHMInfo = OpenCHM(filename); | |
| if(!info->pCHMInfo) { | |
| ReleaseHelpViewer(info); | |
| return NULL; | |
| } | |
| if (!LoadWinTypeFromCHM(info)) { | |
| ReleaseHelpViewer(info); | |
| return NULL; | |
| } | |
| info->WinType.hwndCaller = caller; | |
| /* If the window is already open then load the file in that existing window */ | |
| if ((tmp_info = find_window(info->WinType.pszType)) && tmp_info != info) | |
| { | |
| ReleaseHelpViewer(info); | |
| return CreateHelpViewer(tmp_info, filename, caller); | |
| } | |
| if(!info->viewer_initialized && !CreateViewer(info)) { | |
| ReleaseHelpViewer(info); | |
| return NULL; | |
| } | |
| return info; | |
| } | |
| /* | |
| * Search the table of HTML entities and return the corresponding ANSI symbol. | |
| */ | |
| static char find_html_symbol(const char *entity, int entity_len) | |
| { | |
| int max = sizeof(html_encoded_symbols)/sizeof(html_encoded_symbols[0])-1; | |
| int min = 0, dir; | |
| while(min <= max) | |
| { | |
| int pos = (min+max)/2; | |
| const char *encoded_symbol = html_encoded_symbols[pos].html_code; | |
| dir = strncmp(encoded_symbol, entity, entity_len); | |
| if(dir == 0 && !encoded_symbol[entity_len]) return html_encoded_symbols[pos].ansi_symbol; | |
| if(dir < 0) | |
| min = pos+1; | |
| else | |
| max = pos-1; | |
| } | |
| return 0; | |
| } | |
| /* | |
| * Decode a string containing HTML encoded characters into a unicode string. | |
| */ | |
| WCHAR *decode_html(const char *html_fragment, int html_fragment_len, UINT code_page) | |
| { | |
| const char *h = html_fragment, *amp, *sem; | |
| char symbol, *tmp; | |
| int len, tmp_len = 0; | |
| WCHAR *unicode_text; | |
| tmp = heap_alloc(html_fragment_len+1); | |
| while(1) | |
| { | |
| symbol = 0; | |
| amp = strchr(h, '&'); | |
| if(!amp) break; | |
| len = amp-h; | |
| /* Copy the characters prior to the HTML encoded character */ | |
| memcpy(&tmp[tmp_len], h, len); | |
| tmp_len += len; | |
| amp++; /* skip ampersand */ | |
| sem = strchr(amp, ';'); | |
| /* Require a semicolon after the ampersand */ | |
| if(!sem) | |
| { | |
| h = amp; | |
| tmp[tmp_len++] = '&'; | |
| continue; | |
| } | |
| /* Find the symbol either by using the ANSI character number (prefixed by the pound symbol) | |
| * or by searching the HTML entity table */ | |
| len = sem-amp; | |
| if(amp[0] == '#') | |
| { | |
| char *endnum = NULL; | |
| int tmp; | |
| tmp = (char) strtol(amp, &endnum, 10); | |
| if(endnum == sem) | |
| symbol = tmp; | |
| } | |
| else | |
| symbol = find_html_symbol(amp, len); | |
| if(!symbol) | |
| { | |
| FIXME("Failed to translate HTML encoded character '&%.*s;'.\n", len, amp); | |
| h = amp; | |
| tmp[tmp_len++] = '&'; | |
| continue; | |
| } | |
| /* Insert the new symbol */ | |
| h = sem+1; | |
| tmp[tmp_len++] = symbol; | |
| } | |
| /* Convert any remaining characters */ | |
| len = html_fragment_len-(h-html_fragment); | |
| memcpy(&tmp[tmp_len], h, len); | |
| tmp_len += len; | |
| tmp[tmp_len++] = 0; /* NULL-terminate the string */ | |
| len = MultiByteToWideChar(code_page, 0, tmp, tmp_len, NULL, 0); | |
| unicode_text = heap_alloc(len*sizeof(WCHAR)); | |
| MultiByteToWideChar(code_page, 0, tmp, tmp_len, unicode_text, len); | |
| heap_free(tmp); | |
| return unicode_text; | |
| } | |
| /* Find the HTMLHelp structure for an existing window title */ | |
| HHInfo *find_window(const WCHAR *window) | |
| { | |
| HHInfo *info; | |
| LIST_FOR_EACH_ENTRY(info, &window_list, HHInfo, entry) | |
| { | |
| if (strcmpW(info->WinType.pszType, window) == 0) | |
| return info; | |
| } | |
| return NULL; | |
| } |