msxml3: Remove get_ownerDocument() forward.
[wine] / dlls / hhctrl.ocx / help.c
index a96182a..31060fe 100644 (file)
@@ -2,6 +2,8 @@
  * 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 */
@@ -86,9 +336,7 @@ static const WCHAR szChildClass[] = {
     '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;
@@ -107,29 +355,289 @@ static void Child_OnPaint(HWND hWnd)
         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;
@@ -141,13 +649,13 @@ static void HH_RegisterChildWndClass(HHInfo *pHHInfo)
 
     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);
@@ -159,10 +667,103 @@ static void HH_RegisterChildWndClass(HHInfo *pHHInfo)
 
 #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;
@@ -170,117 +771,131 @@ static void TB_AddButton(TBBUTTON *pButtons, DWORD dwIndex, DWORD dwID)
     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);
@@ -290,91 +905,105 @@ static void NP_GetNavigationRect(HHInfo *pHHInfo, RECT *rc)
     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;
@@ -383,81 +1012,420 @@ static BOOL HH_AddHTMLPane(HHInfo *pHHInfo)
 
     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
@@ -465,10 +1433,10 @@ static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
 
     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);
@@ -479,26 +1447,26 @@ static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
     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;
@@ -506,8 +1474,24 @@ static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
         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;
 
@@ -515,9 +1499,9 @@ static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
     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;
 }
 
@@ -543,7 +1527,7 @@ static void HH_InitRequiredControls(DWORD dwControls)
 }
 
 /* Creates the whole package */
-static BOOL HH_CreateViewer(HHInfo *pHHInfo)
+static BOOL CreateViewer(HHInfo *pHHInfo)
 {
     HH_CreateFont(pHHInfo);
 
@@ -560,91 +1544,94 @@ static BOOL HH_CreateViewer(HHInfo *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;
 }