index.c File Reference

#include "hhctrl.h"
#include "stream.h"
#include "wine/debug.h"

Include dependency graph for index.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (htmlhelp)
static void	fill_index_tree (HWND hwnd, IndexItem *item)
static void	item_realloc (IndexItem *item, int num_items)
static void	parse_index_obj_node_param (IndexItem *item, const char *text, UINT code_page)
static IndexItem *	parse_index_sitemap_object (HHInfo *info, stream_t *stream)
static IndexItem *	parse_li (HHInfo *info, stream_t *stream)
static void	parse_hhindex (HHInfo *info, IStream *str, IndexItem *item)
void	InitIndex (HHInfo *info)
void	ReleaseIndex (HHInfo *info)

Function Documentation

fill_index_tree()

static void fill_index_tree ( HWND  hwnd, IndexItem *  item  )

static

Definition at line 28 of file index.c.

{
    int index = 0;
    LVITEMW lvi;
 
    while(item) {
        TRACE("tree debug: %s\n", debugstr_w(item->keyword));
 
        if(!item->keyword)
        {
            FIXME("HTML Help index item has no keyword.\n");
            item = item->next;
            continue;
        }
        memset(&lvi, 0, sizeof(lvi));
        lvi.iItem = index++;
        lvi.mask = LVIF_TEXT|LVIF_PARAM|LVIF_INDENT;
        lvi.iIndent = item->indentLevel;
        lvi.cchTextMax = lstrlenW(item->keyword)+1;
        lvi.pszText = item->keyword;
        lvi.lParam = (LPARAM)item;
        item->id = (HTREEITEM)SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&lvi);
        item = item->next;
    }
}

Referenced by InitIndex().

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().

item_realloc()

static void item_realloc ( IndexItem *  item, int  num_items  )

static

Definition at line 54 of file index.c.

{
    item->nItems = num_items;
    item->items = heap_realloc(item->items, sizeof(IndexSubItem)*item->nItems);
    item->items[item->nItems-1].name = NULL;
    item->items[item->nItems-1].local = NULL;
    item->itemFlags = 0x00;
}

Referenced by parse_hhindex(), and parse_index_obj_node_param().

parse_hhindex()

static void parse_hhindex ( HHInfo *  info, IStream *  str, IndexItem *  item  )

static

Definition at line 215 of file index.c.

{
    stream_t stream;
    strbuf_t node, node_name;
    int indent_level = -1;
 
    strbuf_init(&node);
    strbuf_init(&node_name);
 
    stream_init(&stream, str);
 
    while(next_node(&stream, &node)) {
        get_node_name(&node, &node_name);
 
        TRACE("%s\n", node.buf);
 
        if(!_strnicmp(node_name.buf, "li", -1)) {
            IndexItem *new_item;
 
            new_item = parse_li(info, &stream);
            if(new_item && item->keyword && lstrcmpW(new_item->keyword, item->keyword) == 0) {
                int num_items = item->nItems;
 
                item_realloc(item, num_items+1);
                memcpy(&item->items[num_items], &new_item->items[0], sizeof(IndexSubItem));
                heap_free(new_item->keyword);
                heap_free(new_item->items);
                heap_free(new_item);
            } else if(new_item) {
                item->next = new_item;
                item->next->merge = item->merge;
                item = item->next;
                item->indentLevel = indent_level;
            }
        }else if(!_strnicmp(node_name.buf, "ul", -1)) {
            indent_level++;
        }else if(!_strnicmp(node_name.buf, "/ul", -1)) {
            indent_level--;
        }else {
            WARN("Unhandled tag! %s\n", node_name.buf);
        }
 
        strbuf_zero(&node);
    }
 
    strbuf_free(&node);
    strbuf_free(&node_name);
}

Referenced by InitIndex().

parse_index_obj_node_param()

static void parse_index_obj_node_param ( IndexItem *  item, const char *  text, UINT  code_page  )

static

Definition at line 71 of file index.c.

{
    const char *ptr;
    LPWSTR *param;
    int len;
 
    ptr = get_attr(text, "name", &len);
    if(!ptr) {
        WARN("name attr not found\n");
        return;
    }
 
    /* Allocate a new sub-item, either on the first run or whenever a
     * sub-topic has filled out both the "name" and "local" params.
     */
    if(item->itemFlags == 0x11 && (!_strnicmp("name", ptr, len) || !_strnicmp("local", ptr, len)))
        item_realloc(item, item->nItems+1);
    if(!_strnicmp("keyword", ptr, len)) {
        param = &item->keyword;
    }else if(!item->keyword && !_strnicmp("name", ptr, len)) {
        /* Some HTML Help index files use an additional "name" parameter
         * rather than the "keyword" parameter.  In this case, the first
         * occurrence of the "name" parameter is the keyword.
         */
        param = &item->keyword;
    }else if(!_strnicmp("name", ptr, len)) {
        item->itemFlags |= 0x01;
        param = &item->items[item->nItems-1].name;
    }else if(!_strnicmp("local", ptr, len)) {
        item->itemFlags |= 0x10;
        param = &item->items[item->nItems-1].local;
    }else {
        WARN("unhandled param %s\n", debugstr_an(ptr, len));
        return;
    }
 
    ptr = get_attr(text, "value", &len);
    if(!ptr) {
        WARN("value attr not found\n");
        return;
    }
 
    *param = decode_html(ptr, len, code_page);
}

Referenced by parse_index_sitemap_object().

parse_index_sitemap_object()

static IndexItem * parse_index_sitemap_object ( HHInfo *  info, stream_t *  stream  )

static

Definition at line 122 of file index.c.

{
    strbuf_t node, node_name;
    IndexItem *item;
 
    strbuf_init(&node);
    strbuf_init(&node_name);
 
    item = heap_alloc_zero(sizeof(IndexItem));
    item->nItems = 0;
    item->items = heap_alloc_zero(0);
    item->itemFlags = 0x11;
 
    while(next_node(stream, &node)) {
        get_node_name(&node, &node_name);
 
        TRACE("%s\n", node.buf);
 
        if(!_strnicmp(node_name.buf, "param", -1)) {
            parse_index_obj_node_param(item, node.buf, info->pCHMInfo->codePage);
        }else if(!_strnicmp(node_name.buf, "/object", -1)) {
            break;
        }else {
            WARN("Unhandled tag! %s\n", node_name.buf);
        }
 
        strbuf_zero(&node);
    }
 
    strbuf_free(&node);
    strbuf_free(&node_name);
 
    return item;
}

Referenced by parse_li().

parse_li()

static IndexItem * parse_li ( HHInfo *  info, stream_t *  stream  )

static

Definition at line 163 of file index.c.

{
    strbuf_t node, node_name;
    IndexItem *ret = NULL;
 
    strbuf_init(&node);
    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, "object", -1)) {
            const char *ptr;
            int len;
 
            static const char sz_text_sitemap[] = "text/sitemap";
 
            ptr = get_attr(node.buf, "type", &len);
 
            if(ptr && len == sizeof(sz_text_sitemap)-1
               && !memcmp(ptr, sz_text_sitemap, len)) {
                ret = parse_index_sitemap_object(info, stream);
                break;
            }
        }else {
            WARN("Unhandled tag! %s\n", node_name.buf);
        }
 
        strbuf_zero(&node);
    }
    if(!ret)
        FIXME("Failed to parse <li> tag!\n");
 
    strbuf_free(&node);
    strbuf_free(&node_name);
 
    return ret;
}

Referenced by parse_hhindex().

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().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

htmlhelp

)