hhctrl.h File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wine/winternl.h"
#include "winuser.h"
#include "winnls.h"
#include "htmlhelp.h"
#include "ole2.h"
#include "exdisp.h"
#include "mshtmhst.h"
#include "commctrl.h"
#include "wine/itss.h"
#include "wine/heap.h"
#include "wine/list.h"

Include dependency graph for hhctrl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ChmPath
struct	ContentItem
struct	IndexSubItem
struct	IndexItem
struct	SearchItem
struct	CHMInfo
struct	HHTab
struct	IndexPopup
struct	SearchTab
struct	ContentsTab
struct	wintype_stringsW
struct	wintype_stringsA
struct	WebBrowserContainer
struct	HHInfo

Macros
#define	COBJMACROS
#define	WB_GOBACK   0
#define	WB_GOFORWARD   1
#define	WB_GOHOME   2
#define	WB_SEARCH   3
#define	WB_REFRESH   4
#define	WB_STOP   5
#define	WB_PRINT   6
#define	TAB_CONTENTS   0
#define	TAB_INDEX   1
#define	TAB_SEARCH   2
#define	TAB_FAVORITES   3
#define	TAB_NUMTABS   TAB_FAVORITES

Typedefs
typedef struct ContentItem	ContentItem
typedef struct IndexSubItem	IndexSubItem
typedef struct IndexItem	IndexItem
typedef struct SearchItem	SearchItem
typedef struct CHMInfo	CHMInfo

Functions
BOOL	InitWebBrowser (HHInfo *, HWND) DECLSPEC_HIDDEN
void	ReleaseWebBrowser (HHInfo *) DECLSPEC_HIDDEN
void	ResizeWebBrowser (HHInfo *, DWORD, DWORD) DECLSPEC_HIDDEN
void	DoPageAction (WebBrowserContainer *, DWORD) DECLSPEC_HIDDEN
void	InitContent (HHInfo *) DECLSPEC_HIDDEN
void	ReleaseContent (HHInfo *) DECLSPEC_HIDDEN
void	ActivateContentTopic (HWND, LPCWSTR, ContentItem *) DECLSPEC_HIDDEN
void	InitIndex (HHInfo *) DECLSPEC_HIDDEN
void	ReleaseIndex (HHInfo *) DECLSPEC_HIDDEN
CHMInfo *	OpenCHM (LPCWSTR szFile) DECLSPEC_HIDDEN
BOOL	LoadWinTypeFromCHM (HHInfo *info) DECLSPEC_HIDDEN
CHMInfo *	CloseCHM (CHMInfo *pCHMInfo) DECLSPEC_HIDDEN
void	SetChmPath (ChmPath *, LPCWSTR, LPCWSTR) DECLSPEC_HIDDEN
IStream *	GetChmStream (CHMInfo *, LPCWSTR, ChmPath *) DECLSPEC_HIDDEN
LPWSTR	FindContextAlias (CHMInfo *, DWORD) DECLSPEC_HIDDEN
WCHAR *	GetDocumentTitle (CHMInfo *, LPCWSTR) DECLSPEC_HIDDEN
HHInfo *	CreateHelpViewer (HHInfo *, LPCWSTR, HWND) DECLSPEC_HIDDEN
void	ReleaseHelpViewer (HHInfo *) DECLSPEC_HIDDEN
BOOL	NavigateToUrl (HHInfo *, LPCWSTR) DECLSPEC_HIDDEN
BOOL	NavigateToChm (HHInfo *, LPCWSTR, LPCWSTR) DECLSPEC_HIDDEN
void	MergeChmProperties (HH_WINTYPEW *, HHInfo *, BOOL) DECLSPEC_HIDDEN
void	UpdateHelpWindow (HHInfo *info) DECLSPEC_HIDDEN
void	InitSearch (HHInfo *info, const char *needle) DECLSPEC_HIDDEN
void	ReleaseSearch (HHInfo *info) DECLSPEC_HIDDEN
LPCWSTR	skip_schema (LPCWSTR url) DECLSPEC_HIDDEN
void	wintype_stringsA_free (struct wintype_stringsA *stringsA) DECLSPEC_HIDDEN
void	wintype_stringsW_free (struct wintype_stringsW *stringsW) DECLSPEC_HIDDEN
WCHAR *	decode_html (const char *html_fragment, int html_fragment_len, UINT code_page) DECLSPEC_HIDDEN
HHInfo *	find_window (const WCHAR *window) DECLSPEC_HIDDEN
static void *	__WINE_ALLOC_SIZE (2) heap_realloc_zero(void *mem
static LPWSTR	strdupW (LPCWSTR str)
static LPWSTR	strdupnAtoW (LPCSTR str, LONG lenA)
static LPWSTR	strdupAtoW (LPCSTR str)
static LPSTR	strdupWtoA (LPCWSTR str)

Variables
struct list window_list	DECLSPEC_HIDDEN
static void size_t	len

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file hhctrl.h.

TAB_CONTENTS

#define TAB_CONTENTS   0

Definition at line 116 of file hhctrl.h.

TAB_FAVORITES

#define TAB_FAVORITES   3

Definition at line 119 of file hhctrl.h.

TAB_INDEX

#define TAB_INDEX   1

Definition at line 117 of file hhctrl.h.

TAB_NUMTABS

#define TAB_NUMTABS   TAB_FAVORITES

Definition at line 120 of file hhctrl.h.

TAB_SEARCH

#define TAB_SEARCH   2

Definition at line 118 of file hhctrl.h.

WB_GOBACK

#define WB_GOBACK   0

Definition at line 46 of file hhctrl.h.

WB_GOFORWARD

#define WB_GOFORWARD   1

Definition at line 47 of file hhctrl.h.

WB_GOHOME

#define WB_GOHOME   2

Definition at line 48 of file hhctrl.h.

WB_PRINT

#define WB_PRINT   6

Definition at line 52 of file hhctrl.h.

WB_REFRESH

#define WB_REFRESH   4

Definition at line 50 of file hhctrl.h.

WB_SEARCH

#define WB_SEARCH   3

Definition at line 49 of file hhctrl.h.

WB_STOP

#define WB_STOP   5

Definition at line 51 of file hhctrl.h.

Typedef Documentation

CHMInfo

typedef struct CHMInfo CHMInfo

ContentItem

typedef struct ContentItem ContentItem

IndexItem

typedef struct IndexItem IndexItem

IndexSubItem

typedef struct IndexSubItem IndexSubItem

SearchItem

typedef struct SearchItem SearchItem

Function Documentation

__WINE_ALLOC_SIZE()

static void * __WINE_ALLOC_SIZE ( 2  )

inlinestatic

ActivateContentTopic()

void ActivateContentTopic	(	HWND	hWnd,
		LPCWSTR	filename,
		ContentItem *	item
	)

Definition at line 330 of file content.c.

{
    if (lstrcmpiW(item->local, filename) == 0)
    {
        SendMessageW(hWnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM) item->id);
        return;
    }
 
    if (item->next)
        ActivateContentTopic(hWnd, filename, item->next);
 
    if (item->child)
        ActivateContentTopic(hWnd, filename, item->child);
}

Referenced by ActivateContentTopic(), and DoSync().

CloseCHM()

CHMInfo * CloseCHM

(

CHMInfo *

pCHMInfo

)

Definition at line 670 of file chm.c.

{
    if(chm->pITStorage)
        IITStorage_Release(chm->pITStorage);
 
    if(chm->pStorage)
        IStorage_Release(chm->pStorage);
 
    if(chm->strings_stream)
        IStream_Release(chm->strings_stream);
 
    if(chm->strings_size) {
        DWORD i;
 
        for(i=0; i<chm->strings_size; i++)
            heap_free(chm->strings[i]);
    }
 
    heap_free(chm->strings);
    heap_free(chm->defWindow);
    heap_free(chm->defTitle);
    heap_free(chm->defTopic);
    heap_free(chm->defToc);
    heap_free(chm->szFile);
    heap_free(chm->compiledFile);
    heap_free(chm);
 
    return NULL;
}

Referenced by OpenCHM(), and ReleaseHelpViewer().

CreateHelpViewer()

HHInfo * CreateHelpViewer	(	HHInfo *	info,
		LPCWSTR	filename,
		HWND	caller
	)

Definition at line 1831 of file help.c.

{
    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 < ARRAY_SIZE(info->tabs); 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;
}

Referenced by CreateHelpViewer(), and HtmlHelpW().

decode_html()

WCHAR * decode_html	(	const char *	html_fragment,
		int	html_fragment_len,
		UINT	code_page
	)

Definition at line 1902 of file help.c.

{
    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;
}

Referenced by parse_index_obj_node_param(), and parse_obj_node_param().

DoPageAction()

void DoPageAction	(	WebBrowserContainer *	container,
		DWORD	dwAction
	)

Definition at line 753 of file webbrowser.c.

{
    if (!container || !container->web_browser)
        return;
 
    switch (dwAction)
    {
        case WB_GOBACK:
            IWebBrowser2_GoBack(container->web_browser);
            break;
        case WB_GOFORWARD:
            IWebBrowser2_GoForward(container->web_browser);
            break;
        case WB_GOHOME:
            IWebBrowser2_GoHome(container->web_browser);
            break;
        case WB_SEARCH:
            IWebBrowser2_GoSearch(container->web_browser);
            break;
        case WB_REFRESH:
            IWebBrowser2_Refresh(container->web_browser);
            break;
        case WB_STOP:
            IWebBrowser2_Stop(container->web_browser);
            break;
        case WB_PRINT:
            IWebBrowser2_ExecWB(container->web_browser, OLECMDID_PRINT, OLECMDEXECOPT_DONTPROMPTUSER, 0, 0);
            break;
    }
}

Referenced by TB_OnClick(), and UI_ShowContextMenu().

find_window()

HHInfo * find_window

(

const WCHAR *

window

)

Definition at line 1967 of file help.c.

{
    HHInfo *info;
 
    LIST_FOR_EACH_ENTRY(info, &window_list, HHInfo, entry)
    {
        if (lstrcmpW(info->WinType.pszType, window) == 0)
            return info;
    }
    return NULL;
}

FindContextAlias()

LPWSTR FindContextAlias	(	CHMInfo *	chm,
		DWORD	index
	)

Definition at line 175 of file chm.c.

{
    IStream *ivb_stream;
    DWORD size, read, i;
    DWORD *buf;
    LPCSTR ret = NULL;
    HRESULT hres;
 
    static const WCHAR wszIVB[] = {'#','I','V','B',0};
 
    hres = IStorage_OpenStream(chm->pStorage, wszIVB, NULL, STGM_READ, 0, &ivb_stream);
    if(FAILED(hres)) {
        WARN("Could not open #IVB stream: %08x\n", hres);
        return NULL;
    }
 
    hres = IStream_Read(ivb_stream, &size, sizeof(size), &read);
    if(FAILED(hres)) {
        WARN("Read failed: %08x\n", hres);
        IStream_Release(ivb_stream);
        return NULL;
    }
 
    buf = heap_alloc(size);
    hres = IStream_Read(ivb_stream, buf, size, &read);
    IStream_Release(ivb_stream);
    if(FAILED(hres)) {
        WARN("Read failed: %08x\n", hres);
        heap_free(buf);
        return NULL;
    }
 
    size /= 2*sizeof(DWORD);
 
    for(i=0; i<size; i++) {
        if(buf[2*i] == index) {
            ret = GetChmString(chm, buf[2*i+1]);
            break;
        }
    }
 
    heap_free(buf);
 
    TRACE("returning %s\n", debugstr_a(ret));
    return strdupAtoW(ret);
}

Referenced by HtmlHelpW().

GetChmStream()

IStream * GetChmStream	(	CHMInfo *	info,
		LPCWSTR	parent_chm,
		ChmPath *	chm_file
	)

Definition at line 539 of file chm.c.

{
    IStorage *storage;
    IStream *stream = NULL;
    HRESULT hres;
 
    TRACE("%s (%s :: %s)\n", debugstr_w(parent_chm), debugstr_w(chm_file->chm_file),
          debugstr_w(chm_file->chm_index));
 
    if(parent_chm || chm_file->chm_file) {
        hres = IITStorage_StgOpenStorage(info->pITStorage,
                chm_file->chm_file ? chm_file->chm_file : parent_chm, NULL,
                STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &storage);
        if(FAILED(hres)) {
            WARN("Could not open storage: %08x\n", hres);
            return NULL;
        }
    }else {
        storage = info->pStorage;
        IStorage_AddRef(info->pStorage);
    }
 
    hres = IStorage_OpenStream(storage, chm_file->chm_index, NULL, STGM_READ, 0, &stream);
    IStorage_Release(storage);
    if(FAILED(hres))
        WARN("Could not open stream: %08x\n", hres);
 
    return stream;
}

Referenced by InitContent(), InitIndex(), and parse_sitemap_object().

GetDocumentTitle()

WCHAR * GetDocumentTitle	(	CHMInfo *	info,
		LPCWSTR	document
	)

Definition at line 572 of file chm.c.

{
    strbuf_t node, node_name, content;
    WCHAR *document_title = NULL;
    IStream *str = NULL;
    IStorage *storage;
    stream_t stream;
    HRESULT hres;
 
    TRACE("%s\n", debugstr_w(document));
 
    storage = info->pStorage;
    if(!storage) {
        WARN("Could not open storage to obtain the title for a document.\n");
        return NULL;
    }
    IStorage_AddRef(storage);
 
    hres = IStorage_OpenStream(storage, document, NULL, STGM_READ, 0, &str);
    IStorage_Release(storage);
    if(FAILED(hres))
        WARN("Could not open stream: %08x\n", hres);
 
    stream_init(&stream, str);
    strbuf_init(&node);
    strbuf_init(&content);
    strbuf_init(&node_name);
 
    while(next_node(&stream, &node)) {
        get_node_name(&node, &node_name);
 
        TRACE("%s\n", node.buf);
 
        if(!_strnicmp(node_name.buf, "title", -1)) {
            if(next_content(&stream, &content) && content.len > 1)
            {
                document_title = strdupnAtoW(&content.buf[1], content.len-1);
                FIXME("magic: %s\n", debugstr_w(document_title));
                break;
            }
        }
 
        strbuf_zero(&node);
    }
 
    strbuf_free(&node);
    strbuf_free(&content);
    strbuf_free(&node_name);
    IStream_Release(str);
 
    return document_title;
}

Referenced by OnTopicChange().

InitContent()

void InitContent

(

HHInfo *

info

)

Definition at line 304 of file content.c.

{
    IStream *stream;
    insert_type_t insert_type;
 
    info->content = heap_alloc_zero(sizeof(ContentItem));
    SetChmPath(&info->content->merge, info->pCHMInfo->szFile, info->WinType.pszToc);
 
    stream = GetChmStream(info->pCHMInfo, info->pCHMInfo->szFile, &info->content->merge);
    if(!stream) {
        TRACE("Could not get content stream\n");
        return;
    }
 
    info->content->child = parse_hhc(info, stream, info->content, &insert_type);
    IStream_Release(stream);
 
    set_item_parents(NULL, info->content);
    fill_content_tree(info->tabs[TAB_CONTENTS].hwnd, NULL, info->content);
}

Referenced by CreateViewer().

InitIndex()

void InitIndex

(

HHInfo *

info

)

Definition at line 265 of file index.c.

{
    IStream *stream;
 
    info->index = heap_alloc_zero(sizeof(IndexItem));
    info->index->nItems = 0;
    SetChmPath(&info->index->merge, info->pCHMInfo->szFile, info->WinType.pszIndex);
 
    stream = GetChmStream(info->pCHMInfo, info->pCHMInfo->szFile, &info->index->merge);
    if(!stream) {
        TRACE("Could not get index stream\n");
        return;
    }
 
    parse_hhindex(info, stream, info->index);
    IStream_Release(stream);
 
    fill_index_tree(info->tabs[TAB_INDEX].hwnd, info->index->next);
}

Referenced by CreateViewer().

InitSearch()

void InitSearch	(	HHInfo *	info,
		const char *	needle
	)

Definition at line 222 of file search.c.

{
    CHMInfo *chm = info->pCHMInfo;
    SearchItem *root_item = alloc_search_item(NULL, NULL);
 
    SearchCHM_Storage(root_item, chm->pStorage, needle);
    fill_search_tree(info->search.hwndList, root_item->next);
    if(info->search.root)
        ReleaseSearch(info);
    info->search.root = root_item;
}

Referenced by Child_WndProc().

InitWebBrowser()

BOOL InitWebBrowser	(	HHInfo *	info,
		HWND	hwndParent
	)

Definition at line 670 of file webbrowser.c.

{
    WebBrowserContainer *container;
    IOleInPlaceObject *inplace;
    HRESULT hr;
    RECT rc;
 
    container = heap_alloc_zero(sizeof(*container));
    if (!container)
        return FALSE;
 
    container->IOleClientSite_iface.lpVtbl = &OleClientSiteVtbl;
    container->IOleInPlaceSite_iface.lpVtbl = &OleInPlaceSiteVtbl;
    container->IOleInPlaceFrame_iface.lpVtbl = &OleInPlaceFrameVtbl;
    container->IDocHostUIHandler_iface.lpVtbl = &DocHostUIHandlerVtbl;
    container->ref = 1;
    container->hwndWindow = hwndParent;
 
    info->web_browser = container;
 
    hr = OleCreate(&CLSID_WebBrowser, &IID_IOleObject, OLERENDER_DRAW, 0,
                   &container->IOleClientSite_iface, &MyIStorage,
                   (void **)&container->ole_obj);
 
    if (FAILED(hr)) goto error;
 
    GetClientRect(hwndParent, &rc);
 
    hr = OleSetContainedObject((struct IUnknown *)container->ole_obj, TRUE);
    if (FAILED(hr)) goto error;
 
    hr = IOleObject_DoVerb(container->ole_obj, OLEIVERB_SHOW, NULL,
                           &container->IOleClientSite_iface, -1, hwndParent, &rc);
    if (FAILED(hr)) goto error;
 
    hr = IOleObject_QueryInterface(container->ole_obj, &IID_IOleInPlaceObject, (void**)&inplace);
    if (FAILED(hr)) goto error;
 
    IOleInPlaceObject_SetObjectRects(inplace, &rc, &rc);
    IOleInPlaceObject_Release(inplace);
 
    hr = IOleObject_QueryInterface(container->ole_obj, &IID_IWebBrowser2, (void **)&container->web_browser);
    if (SUCCEEDED(hr))
        return TRUE;
 
error:
    ReleaseWebBrowser(info);
    return FALSE;
}

Referenced by HH_AddHTMLPane().

LoadWinTypeFromCHM()

BOOL LoadWinTypeFromCHM

(

HHInfo *

info

)

Definition at line 344 of file chm.c.

{
    LARGE_INTEGER liOffset;
    IStorage *pStorage = info->pCHMInfo->pStorage;
    IStream *pStream = NULL;
    HH_WINTYPEW wintype;
    HRESULT hr;
    DWORD cbRead;
    BOOL ret = FALSE;
 
    static const WCHAR empty[] = {0};
    static const WCHAR toc_extW[] = {'h','h','c',0};
    static const WCHAR index_extW[] = {'h','h','k',0};
    static const WCHAR windowsW[] = {'#','W','I','N','D','O','W','S',0};
 
    /* HH_WINTYPE as stored on disk.  It's identical to HH_WINTYPE except that the pointer fields
       have been changed to DWORDs, so that the layout on 64-bit remains unchanged. */
    struct file_wintype
    {
        int          cbStruct;
        BOOL         fUniCodeStrings;
        DWORD        pszType;
        DWORD        fsValidMembers;
        DWORD        fsWinProperties;
        DWORD        pszCaption;
        DWORD        dwStyles;
        DWORD        dwExStyles;
        RECT         rcWindowPos;
        int          nShowState;
        DWORD        hwndHelp;
        DWORD        hwndCaller;
        DWORD        paInfoTypes;
        DWORD        hwndToolBar;
        DWORD        hwndNavigation;
        DWORD        hwndHTML;
        int          iNavWidth;
        RECT         rcHTML;
        DWORD        pszToc;
        DWORD        pszIndex;
        DWORD        pszFile;
        DWORD        pszHome;
        DWORD        fsToolBarFlags;
        BOOL         fNotExpanded;
        int          curNavType;
        int          tabpos;
        int          idNotify;
        BYTE         tabOrder[HH_MAX_TABS+1];
        int          cHistory;
        DWORD        pszJump1;
        DWORD        pszJump2;
        DWORD        pszUrlJump1;
        DWORD        pszUrlJump2;
        RECT         rcMinSize;
        int          cbInfoTypes;
        DWORD        pszCustomTabs;
    } file_wintype;
 
    memset(&wintype, 0, sizeof(wintype));
    wintype.cbStruct = sizeof(wintype);
    wintype.fUniCodeStrings = TRUE;
 
    hr = IStorage_OpenStream(pStorage, windowsW, NULL, STGM_READ, 0, &pStream);
    if (SUCCEEDED(hr))
    {
        /* jump past the #WINDOWS header */
        liOffset.QuadPart = sizeof(DWORD) * 2;
 
        hr = IStream_Seek(pStream, liOffset, STREAM_SEEK_SET, NULL);
        if (FAILED(hr)) goto done;
 
        /* read the HH_WINTYPE struct data */
        hr = IStream_Read(pStream, &file_wintype, sizeof(file_wintype), &cbRead);
        if (FAILED(hr)) goto done;
 
        /* convert the #STRINGS offsets to actual strings */
        wintype.pszType         = ConvertChmString(info, file_wintype.pszType);
        wintype.fsValidMembers  = file_wintype.fsValidMembers;
        wintype.fsWinProperties = file_wintype.fsWinProperties;
        wintype.pszCaption      = ConvertChmString(info, file_wintype.pszCaption);
        wintype.dwStyles        = file_wintype.dwStyles;
        wintype.dwExStyles      = file_wintype.dwExStyles;
        wintype.rcWindowPos     = file_wintype.rcWindowPos;
        wintype.nShowState      = file_wintype.nShowState;
        wintype.iNavWidth       = file_wintype.iNavWidth;
        wintype.rcHTML          = file_wintype.rcHTML;
        wintype.pszToc          = ConvertChmString(info, file_wintype.pszToc);
        wintype.pszIndex        = ConvertChmString(info, file_wintype.pszIndex);
        wintype.pszFile         = ConvertChmString(info, file_wintype.pszFile);
        wintype.pszHome         = ConvertChmString(info, file_wintype.pszHome);
        wintype.fsToolBarFlags  = file_wintype.fsToolBarFlags;
        wintype.fNotExpanded    = file_wintype.fNotExpanded;
        wintype.curNavType      = file_wintype.curNavType;
        wintype.tabpos          = file_wintype.tabpos;
        wintype.idNotify        = file_wintype.idNotify;
        memcpy(&wintype.tabOrder, file_wintype.tabOrder, sizeof(wintype.tabOrder));
        wintype.cHistory        = file_wintype.cHistory;
        wintype.pszJump1        = ConvertChmString(info, file_wintype.pszJump1);
        wintype.pszJump2        = ConvertChmString(info, file_wintype.pszJump2);
        wintype.pszUrlJump1     = ConvertChmString(info, file_wintype.pszUrlJump1);
        wintype.pszUrlJump2     = ConvertChmString(info, file_wintype.pszUrlJump2);
        wintype.rcMinSize       = file_wintype.rcMinSize;
        wintype.cbInfoTypes     = file_wintype.cbInfoTypes;
    }
    else
    {
        /* no defined window types so use (hopefully) sane defaults */
        static const WCHAR defaultwinW[] = {'d','e','f','a','u','l','t','w','i','n','\0'};
        wintype.pszType    = strdupW(info->pCHMInfo->defWindow ? info->pCHMInfo->defWindow : defaultwinW);
        wintype.pszToc     = strdupW(info->pCHMInfo->defToc ? info->pCHMInfo->defToc : empty);
        wintype.pszIndex   = strdupW(empty);
        wintype.fsValidMembers = 0;
        wintype.fsWinProperties = HHWIN_PROP_TRI_PANE;
        wintype.dwStyles = WS_POPUP;
        wintype.dwExStyles = 0;
        wintype.nShowState = SW_SHOW;
        wintype.curNavType = HHWIN_NAVTYPE_TOC;
    }
 
    /* merge the new data with any pre-existing HH_WINTYPE structure */
    MergeChmProperties(&wintype, info, FALSE);
    if (!info->WinType.pszCaption)
#ifdef __REACTOS__
        info->WinType.pszCaption = info->stringsW.pszCaption = (info->pCHMInfo->defTitle ? strdupW(info->pCHMInfo->defTitle) : HH_LoadString(IDS_DEFTITLE));
#else
        info->WinType.pszCaption = info->stringsW.pszCaption = strdupW(info->pCHMInfo->defTitle ? info->pCHMInfo->defTitle : empty);
#endif
    if (!info->WinType.pszFile)
        info->WinType.pszFile    = info->stringsW.pszFile    = strdupW(info->pCHMInfo->defTopic ? info->pCHMInfo->defTopic : empty);
    if (!info->WinType.pszToc)
        info->WinType.pszToc     = info->stringsW.pszToc     = FindHTMLHelpSetting(info, toc_extW);
    if (!info->WinType.pszIndex)
        info->WinType.pszIndex   = info->stringsW.pszIndex   = FindHTMLHelpSetting(info, index_extW);
 
    wintype_free(&wintype);
    ret = TRUE;
 
done:
    if (pStream)
        IStream_Release(pStream);
 
    return ret;
}

Referenced by CreateHelpViewer().

MergeChmProperties()

void MergeChmProperties	(	HH_WINTYPEW *	src,
		HHInfo *	info,
		BOOL	override
	)

Definition at line 256 of file chm.c.

{
    DWORD unhandled_params = src->fsValidMembers & ~(HHWIN_PARAM_PROPERTIES|HHWIN_PARAM_STYLES
                             |HHWIN_PARAM_EXSTYLES|HHWIN_PARAM_RECT|HHWIN_PARAM_NAV_WIDTH
                             |HHWIN_PARAM_SHOWSTATE|HHWIN_PARAM_INFOTYPES|HHWIN_PARAM_TB_FLAGS
                             |HHWIN_PARAM_EXPANSION|HHWIN_PARAM_TABPOS|HHWIN_PARAM_TABORDER
                             |HHWIN_PARAM_HISTORY_COUNT|HHWIN_PARAM_CUR_TAB);
    HH_WINTYPEW *dst = &info->WinType;
    DWORD merge = override ? src->fsValidMembers : src->fsValidMembers & ~dst->fsValidMembers;
 
    if (unhandled_params)
        FIXME("Unsupported fsValidMembers fields: 0x%x\n", unhandled_params);
 
    dst->fsValidMembers |= merge;
    if (dst->cbStruct == 0)
    {
        /* If the structure has not been filled in yet then use all of the values */
        dst->cbStruct = sizeof(HH_WINTYPEW);
        merge = ~0;
    }
    if (merge & HHWIN_PARAM_PROPERTIES) dst->fsWinProperties = src->fsWinProperties;
    if (merge & HHWIN_PARAM_STYLES) dst->dwStyles = src->dwStyles;
    if (merge & HHWIN_PARAM_EXSTYLES) dst->dwExStyles = src->dwExStyles;
    if (merge & HHWIN_PARAM_RECT) dst->rcWindowPos = src->rcWindowPos;
    if (merge & HHWIN_PARAM_NAV_WIDTH) dst->iNavWidth = src->iNavWidth;
    if (merge & HHWIN_PARAM_SHOWSTATE) dst->nShowState = src->nShowState;
    if (merge & HHWIN_PARAM_INFOTYPES) dst->paInfoTypes = src->paInfoTypes;
    if (merge & HHWIN_PARAM_TB_FLAGS) dst->fsToolBarFlags = src->fsToolBarFlags;
    if (merge & HHWIN_PARAM_EXPANSION) dst->fNotExpanded = src->fNotExpanded;
    if (merge & HHWIN_PARAM_TABPOS) dst->tabpos = src->tabpos;
    if (merge & HHWIN_PARAM_TABORDER) memcpy(dst->tabOrder, src->tabOrder, sizeof(src->tabOrder));
    if (merge & HHWIN_PARAM_HISTORY_COUNT) dst->cHistory = src->cHistory;
    if (merge & HHWIN_PARAM_CUR_TAB) dst->curNavType = src->curNavType;
 
    /*
     * Note: We assume that hwndHelp, hwndCaller, hwndToolBar, hwndNavigation, and hwndHTML cannot be
     * modified by the user.  rcHTML and rcMinSize are not currently supported, so don't bother to copy them.
     */
 
    dst->pszType       = MergeChmString(src->pszType, &info->stringsW.pszType);
    dst->pszFile       = MergeChmString(src->pszFile, &info->stringsW.pszFile);
    dst->pszToc        = MergeChmString(src->pszToc, &info->stringsW.pszToc);
    dst->pszIndex      = MergeChmString(src->pszIndex, &info->stringsW.pszIndex);
    dst->pszCaption    = MergeChmString(src->pszCaption, &info->stringsW.pszCaption);
    dst->pszHome       = MergeChmString(src->pszHome, &info->stringsW.pszHome);
    dst->pszJump1      = MergeChmString(src->pszJump1, &info->stringsW.pszJump1);
    dst->pszJump2      = MergeChmString(src->pszJump2, &info->stringsW.pszJump2);
    dst->pszUrlJump1   = MergeChmString(src->pszUrlJump1, &info->stringsW.pszUrlJump1);
    dst->pszUrlJump2   = MergeChmString(src->pszUrlJump2, &info->stringsW.pszUrlJump2);
 
    /* FIXME: pszCustomTabs is a list of multiple zero-terminated strings so ReadString won't
     * work in this case
     */
#if 0
    dst->pszCustomTabs = MergeChmString(src->pszCustomTabs, &info->pszCustomTabs);
#endif
}

Referenced by HtmlHelpW(), and LoadWinTypeFromCHM().

NavigateToChm()

BOOL NavigateToChm	(	HHInfo *	info,
		LPCWSTR	file,
		LPCWSTR	index
	)

Definition at line 257 of file help.c.

{
    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));
}

Referenced by HtmlHelpW(), NavigateToUrl(), OnTopicChange(), PopupChild_WndProc(), and TB_OnClick().

NavigateToUrl()

BOOL NavigateToUrl	(	HHInfo *	info,
		LPCWSTR	surl
	)

Definition at line 213 of file help.c.

{
    ChmPath chm_path;
    BOOL ret;
    HRESULT hres;
 
    static const WCHAR url_indicator[] = {':', '/', '/', 0};
 
    TRACE("%s\n", debugstr_w(surl));
 
    if (wcsstr(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;
}

Referenced by HtmlHelpW().

OpenCHM()

CHMInfo * OpenCHM

(

LPCWSTR

szFile

)

Definition at line 626 of file chm.c.

{
    HRESULT hres;
    CHMInfo *ret;
 
    static const WCHAR wszSTRINGS[] = {'#','S','T','R','I','N','G','S',0};
 
    if (!(ret = heap_alloc_zero(sizeof(CHMInfo))))
        return NULL;
    ret->codePage = CP_ACP;
 
    if (!(ret->szFile = strdupW(szFile))) {
        heap_free(ret);
        return NULL;
    }
 
    hres = CoCreateInstance(&CLSID_ITStorage, NULL, CLSCTX_INPROC_SERVER,
            &IID_IITStorage, (void **) &ret->pITStorage) ;
    if(FAILED(hres)) {
        WARN("Could not create ITStorage: %08x\n", hres);
        return CloseCHM(ret);
    }
 
    hres = IITStorage_StgOpenStorage(ret->pITStorage, szFile, NULL,
            STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &ret->pStorage);
    if(FAILED(hres)) {
        WARN("Could not open storage: %08x\n", hres);
        return CloseCHM(ret);
    }
    hres = IStorage_OpenStream(ret->pStorage, wszSTRINGS, NULL, STGM_READ, 0,
            &ret->strings_stream);
    if(FAILED(hres)) {
        WARN("Could not open #STRINGS stream: %08x\n", hres);
        /* It's not critical, so we pass */
    }
 
    if(!ReadChmSystem(ret)) {
        WARN("Could not read #SYSTEM\n");
        return CloseCHM(ret);
    }
 
    return ret;
}

Referenced by CreateHelpViewer().

ReleaseContent()

void ReleaseContent

(

HHInfo *

info

)

Definition at line 325 of file content.c.

{
    free_content_item(info->content);
}

Referenced by ReleaseHelpViewer().

ReleaseHelpViewer()

void ReleaseHelpViewer

(

HHInfo *

info

)

Definition at line 1802 of file help.c.

{
    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();
}

Referenced by CreateHelpViewer(), Help_WndProc(), and HtmlHelpW().

ReleaseIndex()

void ReleaseIndex

(

HHInfo *

info

)

Definition at line 288 of file index.c.

{
    IndexItem *item = info->index, *next;
    int i;
 
    if(!item) return;
    /* Note: item->merge is identical for all items, only free once */
    heap_free(item->merge.chm_file);
    heap_free(item->merge.chm_index);
    while(item) {
        next = item->next;
 
        heap_free(item->keyword);
        for(i=0;i<item->nItems;i++) {
            heap_free(item->items[i].name);
            heap_free(item->items[i].local);
        }
        heap_free(item->items);
 
        item = next;
    }
}

Referenced by ReleaseHelpViewer().

ReleaseSearch()

void ReleaseSearch

(

HHInfo *

info

)

Definition at line 235 of file search.c.

{
    SearchItem *item = info->search.root;
 
    info->search.root = NULL;
    while(item) {
        heap_free(item->filename);
        item = item->next;
    }
}

Referenced by InitSearch(), and ReleaseHelpViewer().

ReleaseWebBrowser()

void ReleaseWebBrowser

(

HHInfo *

info

)

Definition at line 720 of file webbrowser.c.

{
    WebBrowserContainer *container = info->web_browser;
    HRESULT hres;
 
    if(!container)
        return;
 
    if(container->ole_obj) {
        IOleInPlaceSite *inplace;
 
        hres = IOleObject_QueryInterface(container->ole_obj, &IID_IOleInPlaceSite, (void**)&inplace);
        if(SUCCEEDED(hres)) {
            IOleInPlaceSite_OnInPlaceDeactivate(inplace);
            IOleInPlaceSite_Release(inplace);
        }
 
        IOleObject_SetClientSite(container->ole_obj, NULL);
    }
 
    info->web_browser = NULL;
    IOleClientSite_Release(&container->IOleClientSite_iface);
}

Referenced by InitWebBrowser(), and ReleaseHelpViewer().

ResizeWebBrowser()

void ResizeWebBrowser	(	HHInfo *	info,
		DWORD	dwWidth,
		DWORD	dwHeight
	)

Definition at line 744 of file webbrowser.c.

{
    if (!info->web_browser)
        return;
 
    IWebBrowser2_put_Width(info->web_browser->web_browser, dwWidth);
    IWebBrowser2_put_Height(info->web_browser->web_browser, dwHeight);
}

Referenced by Help_OnSize().

SetChmPath()

void SetChmPath	(	ChmPath *	file,
		LPCWSTR	base_file,
		LPCWSTR	path
	)

Definition at line 503 of file chm.c.

{
    LPCWSTR ptr;
    static const WCHAR separatorW[] = {':',':',0};
 
    path = skip_schema(path);
 
    ptr = wcsstr(path, separatorW);
    if(ptr) {
        WCHAR chm_file[MAX_PATH];
        WCHAR rel_path[MAX_PATH];
        WCHAR base_path[MAX_PATH];
        LPWSTR p;
 
        lstrcpyW(base_path, base_file);
        p = wcsrchr(base_path, '\\');
        if(p)
            *p = 0;
 
        memcpy(rel_path, path, (ptr-path)*sizeof(WCHAR));
        rel_path[ptr-path] = 0;
 
        PathCombineW(chm_file, base_path, rel_path);
 
        file->chm_file = strdupW(chm_file);
        ptr += 2;
    }else {
        file->chm_file = strdupW(base_file);
        ptr = path;
    }
 
    file->chm_index = strdupW(ptr);
 
    TRACE("ChmFile = {%s %s}\n", debugstr_w(file->chm_file), debugstr_w(file->chm_index));
}

Referenced by InitContent(), InitIndex(), NavigateToUrl(), and parse_obj_node_param().

skip_schema()

LPCWSTR skip_schema

(

LPCWSTR

url

)

Definition at line 487 of file chm.c.

{
    static const WCHAR its_schema[] = {'i','t','s',':'};
    static const WCHAR msits_schema[] = {'m','s','-','i','t','s',':'};
    static const WCHAR mk_schema[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':'};
 
    if(!_wcsnicmp(its_schema, url, ARRAY_SIZE(its_schema)))
        return url + ARRAY_SIZE(its_schema);
    if(!_wcsnicmp(msits_schema, url, ARRAY_SIZE(msits_schema)))
        return url + ARRAY_SIZE(msits_schema);
    if(!_wcsnicmp(mk_schema, url, ARRAY_SIZE(mk_schema)))
        return url + ARRAY_SIZE(mk_schema);
 
    return url;
}

Referenced by resolve_filename(), and SetChmPath().

strdupAtoW()

static LPWSTR strdupAtoW ( LPCSTR  str )

inlinestatic

Definition at line 294 of file hhctrl.h.

{
    return strdupnAtoW(str, -1);
}

strdupnAtoW()

static LPWSTR strdupnAtoW ( LPCSTR  str, LONG  lenA  )

inlinestatic

Definition at line 271 of file hhctrl.h.

{
    LPWSTR ret;
    DWORD len;
 
    if(!str)
        return NULL;
 
    if (lenA > 0)
    {
        /* find length of string */
        LPCSTR eos = memchr(str, 0, lenA);
    if (eos) lenA = eos - str;
    }
 
    len = MultiByteToWideChar(CP_ACP, 0, str, lenA, NULL, 0)+1; /* +1 for null pad */
    ret = heap_alloc(len*sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, str, lenA, ret, len);
    ret[len-1] = 0;
 
    return ret;
}

Referenced by GetDocumentTitle(), ReadChmSystem(), and strdupAtoW().

strdupW()

static LPWSTR strdupW ( LPCWSTR  str )

inlinestatic

Definition at line 256 of file hhctrl.h.

{
    LPWSTR ret;
    int size;
 
    if(!str)
        return NULL;
 
    size = (lstrlenW(str)+1)*sizeof(WCHAR);
    ret = heap_alloc(size);
    memcpy(ret, str, size);
 
    return ret;
}

strdupWtoA()

static LPSTR strdupWtoA ( LPCWSTR  str )

inlinestatic

Definition at line 299 of file hhctrl.h.

{
    LPSTR ret;
    DWORD len;
 
    if(!str)
        return NULL;
 
    len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
    ret = heap_alloc(len);
    WideCharToMultiByte(CP_ACP, 0, str, -1, ret, len, NULL, NULL);
    return ret;
}

Referenced by cabinet_next_cabinet(), extract_cabinet(), ITERATE_BindImage(), msi_scrolltext_add_text(), s_remote_GetActionInfo(), and wintypeWtoA().

UpdateHelpWindow()

void UpdateHelpWindow

(

HHInfo *

info

)

Definition at line 1563 of file help.c.

{
    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);
    }
}

Referenced by HtmlHelpW().

wintype_stringsA_free()

void wintype_stringsA_free

(

struct wintype_stringsA *

stringsA

)

Definition at line 1787 of file help.c.

{
    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);
}

Referenced by HtmlHelpA(), and ReleaseHelpViewer().

wintype_stringsW_free()

void wintype_stringsW_free

(

struct wintype_stringsW *

stringsW

)

Definition at line 1773 of file help.c.

{
    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);
}

Referenced by HtmlHelpA(), and ReleaseHelpViewer().

Variable Documentation

DECLSPEC_HIDDEN

BOOL hh_process DECLSPEC_HIDDEN

extern

Definition at line 314 of file hhctrl.h.

len

void size_t len

Initial value:

{
    return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, len)

Definition at line 251 of file hhctrl.h.

Referenced by strdupnAtoW(), and strdupWtoA().