dlls/hhctrl.ocx/hhctrl.c

   1 /*
   2  * hhctrl implementation
   3  *
   4  * Copyright 2004 Krzysztof Foltman
   5  * Copyright 2007 Jacek Caban for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "wine/debug.h"
  23
  24 #include <stdarg.h>
  25
  26 #define COBJMACROS
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "winnls.h"
  32 #include "htmlhelp.h"
  33 #include "ole2.h"
  34 #include "rpcproxy.h"
  35
  36 #define INIT_GUID
  37 #include "hhctrl.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
  40
  41 HINSTANCE hhctrl_hinstance;
  42 BOOL hh_process = FALSE;
  43
  44
  45 BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved)
  46 {
  47     TRACE("(%p,%ld,%p)\n", hInstance, fdwReason, lpvReserved);
  48
  49     switch (fdwReason)
  50     {
  51     case DLL_PROCESS_ATTACH:
  52         hhctrl_hinstance = hInstance;
  53         DisableThreadLibraryCalls(hInstance);
  54         break;
  55     }
  56     return TRUE;
  57 }
  58
  59 static const char *command_to_string(UINT command)
  60 {
  61 #define X(x) case x: return #x
  62     switch (command)
  63     {
  64         X( HH_DISPLAY_TOPIC );
  65         X( HH_DISPLAY_TOC );
  66         X( HH_DISPLAY_INDEX );
  67         X( HH_DISPLAY_SEARCH );
  68         X( HH_SET_WIN_TYPE );
  69         X( HH_GET_WIN_TYPE );
  70         X( HH_GET_WIN_HANDLE );
  71         X( HH_ENUM_INFO_TYPE );
  72         X( HH_SET_INFO_TYPE );
  73         X( HH_SYNC );
  74         X( HH_RESERVED1 );
  75         X( HH_RESERVED2 );
  76         X( HH_RESERVED3 );
  77         X( HH_KEYWORD_LOOKUP );
  78         X( HH_DISPLAY_TEXT_POPUP );
  79         X( HH_HELP_CONTEXT );
  80         X( HH_TP_HELP_CONTEXTMENU );
  81         X( HH_TP_HELP_WM_HELP );
  82         X( HH_CLOSE_ALL );
  83         X( HH_ALINK_LOOKUP );
  84         X( HH_GET_LAST_ERROR );
  85         X( HH_ENUM_CATEGORY );
  86         X( HH_ENUM_CATEGORY_IT );
  87         X( HH_RESET_IT_FILTER );
  88         X( HH_SET_INCLUSIVE_FILTER );
  89         X( HH_SET_EXCLUSIVE_FILTER );
  90         X( HH_INITIALIZE );
  91         X( HH_UNINITIALIZE );
  92         X( HH_SAFE_DISPLAY_TOPIC );
  93         X( HH_PRETRANSLATEMESSAGE );
  94         X( HH_SET_GLOBAL_PROPERTY );
  95     default: return "???";
  96     }
  97 #undef X
  98 }
  99
 100 static BOOL resolve_filename(const WCHAR *env_filename, WCHAR *fullname, DWORD buflen, WCHAR **index, WCHAR **window)
 101 {
 102     static const WCHAR helpW[] = {'\\','h','e','l','p','\\',0};
 103     static const WCHAR delimW[] = {':',':',0};
 104     static const WCHAR delim2W[] = {'>',0};
 105
 106     DWORD env_len;
 107     WCHAR *filename, *extra;
 108
 109     env_filename = skip_schema(env_filename);
 110
 111     /* the format is "helpFile[::/index][>window]" */
 112     if (index) *index = NULL;
 113     if (window) *window = NULL;
 114
 115     env_len = ExpandEnvironmentStringsW(env_filename, NULL, 0);
 116     if (!env_len)
 117         return 0;
 118
 119     filename = malloc(env_len * sizeof(WCHAR));
 120     if (filename == NULL)
 121         return 0;
 122
 123     ExpandEnvironmentStringsW(env_filename, filename, env_len);
 124
 125     extra = wcsstr(filename, delim2W);
 126     if (extra)
 127     {
 128         *extra = 0;
 129         if (window)
 130             *window = wcsdup(extra + 1);
 131     }
 132
 133     extra = wcsstr(filename, delimW);
 134     if (extra)
 135     {
 136         *extra = 0;
 137         if (index)
 138             *index = wcsdup(extra + 2);
 139     }
 140
 141     GetFullPathNameW(filename, buflen, fullname, NULL);
 142     if (GetFileAttributesW(fullname) == INVALID_FILE_ATTRIBUTES)
 143     {
 144         GetWindowsDirectoryW(fullname, buflen);
 145         lstrcatW(fullname, helpW);
 146         lstrcatW(fullname, filename);
 147     }
 148
 149     free(filename);
 150
 151     if (GetFileAttributesW(fullname) == INVALID_FILE_ATTRIBUTES)
 152     {
 153         if (window) free(*window);
 154         if (index) free(*index);
 155         return FALSE;
 156     }
 157
 158     return TRUE;
 159 }
 160
 161 /******************************************************************
 162  *              HtmlHelpW (HHCTRL.OCX.15)
 163  */
 164 HWND WINAPI HtmlHelpW(HWND caller, LPCWSTR filename, UINT command, DWORD_PTR data)
 165 {
 166     WCHAR fullname[MAX_PATH];
 167
 168     TRACE("(%p, %s, command=%s, data=%Ix)\n",
 169           caller, debugstr_w( filename ),
 170           command_to_string( command ), data);
 171
 172     switch (command)
 173     {
 174     case HH_DISPLAY_TOPIC:
 175     case HH_DISPLAY_TOC:
 176     case HH_DISPLAY_INDEX:
 177     case HH_DISPLAY_SEARCH:{
 178         BOOL res;
 179         NMHDR nmhdr;
 180         HHInfo *info = NULL;
 181         WCHAR *window = NULL;
 182         const WCHAR *index = NULL;
 183         WCHAR *default_index = NULL;
 184         int tab_index = TAB_CONTENTS;
 185
 186         if (!filename)
 187             return NULL;
 188
 189         if (!resolve_filename(filename, fullname, MAX_PATH, &default_index, &window))
 190         {
 191             WARN("can't find %s\n", debugstr_w(filename));
 192             return 0;
 193         }
 194         index = default_index;
 195
 196         if (window)
 197             info = find_window(window);
 198
 199         info = CreateHelpViewer(info, fullname, caller);
 200         if(!info)
 201         {
 202             free(default_index);
 203             free(window);
 204             return NULL;
 205         }
 206
 207         if(!index)
 208             index = info->WinType.pszFile;
 209         if(!info->WinType.pszType)
 210             info->WinType.pszType = info->stringsW.pszType = window;
 211         else
 212             free(window);
 213
 214         /* called to load a specified topic */
 215         switch(command)
 216         {
 217         case HH_DISPLAY_TOPIC:
 218         case HH_DISPLAY_TOC:
 219             if (data)
 220             {
 221                 static const WCHAR delimW[] = {':',':',0};
 222                 const WCHAR *i = (const WCHAR *)data;
 223
 224                 index = wcsstr(i, delimW);
 225                 if(index)
 226                 {
 227                     if(memcmp(info->pCHMInfo->szFile, i, index-i))
 228                         FIXME("Opening a CHM file in the context of another is not supported.\n");
 229                     index += lstrlenW(delimW);
 230                 }
 231                 else
 232                     index = i;
 233             }
 234             break;
 235         }
 236
 237         res = NavigateToChm(info, info->pCHMInfo->szFile, index);
 238         free(default_index);
 239
 240         if(!res)
 241         {
 242             ReleaseHelpViewer(info);
 243             return NULL;
 244         }
 245
 246         switch(command)
 247         {
 248         case HH_DISPLAY_TOPIC:
 249         case HH_DISPLAY_TOC:
 250             tab_index = TAB_CONTENTS;
 251             break;
 252         case HH_DISPLAY_INDEX:
 253             tab_index = TAB_INDEX;
 254             if (data)
 255                 FIXME("Should select keyword '%s'.\n", debugstr_w((WCHAR *)data));
 256             break;
 257         case HH_DISPLAY_SEARCH:
 258             tab_index = TAB_SEARCH;
 259             if (data)
 260                 FIXME("Should display search specified by HH_FTS_QUERY structure.\n");
 261             break;
 262         }
 263         /* open the requested tab */
 264         memset(&nmhdr, 0, sizeof(nmhdr));
 265         nmhdr.code = TCN_SELCHANGE;
 266         SendMessageW(info->hwndTabCtrl, TCM_SETCURSEL, (WPARAM)info->tabs[tab_index].id, 0);
 267         SendMessageW(info->WinType.hwndNavigation, WM_NOTIFY, 0, (LPARAM)&nmhdr);
 268
 269         return info->WinType.hwndHelp;
 270     }
 271     case HH_HELP_CONTEXT: {
 272         WCHAR *window = NULL;
 273         HHInfo *info = NULL;
 274         LPWSTR url;
 275
 276         if (!filename)
 277             return NULL;
 278
 279         if (!resolve_filename(filename, fullname, MAX_PATH, NULL, &window))
 280         {
 281             WARN("can't find %s\n", debugstr_w(filename));
 282             return 0;
 283         }
 284
 285         if (window)
 286             info = find_window(window);
 287
 288         info = CreateHelpViewer(info, fullname, caller);
 289         if(!info)
 290         {
 291             free(window);
 292             return NULL;
 293         }
 294
 295         if(!info->WinType.pszType)
 296             info->WinType.pszType = info->stringsW.pszType = window;
 297         else
 298             free(window);
 299
 300         url = FindContextAlias(info->pCHMInfo, data);
 301         if(!url)
 302         {
 303             if(!data) /* there may legitimately be no context alias for id 0 */
 304                 return info->WinType.hwndHelp;
 305             ReleaseHelpViewer(info);
 306             return NULL;
 307         }
 308
 309         NavigateToUrl(info, url);
 310         free(url);
 311         return info->WinType.hwndHelp;
 312     }
 313     case HH_PRETRANSLATEMESSAGE: {
 314         static BOOL warned = FALSE;
 315
 316         if (!warned)
 317         {
 318             FIXME("HH_PRETRANSLATEMESSAGE unimplemented\n");
 319             warned = TRUE;
 320         }
 321         return 0;
 322     }
 323     case HH_CLOSE_ALL: {
 324         HHInfo *info, *next;
 325
 326         LIST_FOR_EACH_ENTRY_SAFE(info, next, &window_list, HHInfo, entry)
 327         {
 328             TRACE("Destroying window %s.\n", debugstr_w(info->WinType.pszType));
 329             ReleaseHelpViewer(info);
 330         }
 331         return 0;
 332     }
 333     case HH_SET_WIN_TYPE: {
 334         HH_WINTYPEW *wintype = (HH_WINTYPEW *)data;
 335         WCHAR *window = NULL;
 336         HHInfo *info = NULL;
 337
 338         if (!filename && wintype->pszType)
 339             window = wcsdup(wintype->pszType);
 340         else if (!filename || !resolve_filename(filename, fullname, MAX_PATH, NULL, &window) || !window)
 341         {
 342             WARN("can't find window name: %s\n", debugstr_w(filename));
 343             return 0;
 344         }
 345         info = find_window(window);
 346         if (!info)
 347         {
 348             info = calloc(1, sizeof(HHInfo));
 349             info->WinType.pszType = info->stringsW.pszType = window;
 350             list_add_tail(&window_list, &info->entry);
 351         }
 352         else
 353             free(window);
 354
 355         TRACE("Changing WINTYPE, fsValidMembers=0x%lx\n", wintype->fsValidMembers);
 356
 357         MergeChmProperties(wintype, info, TRUE);
 358         UpdateHelpWindow(info);
 359         return 0;
 360     }
 361     case HH_GET_WIN_TYPE: {
 362         HH_WINTYPEW *wintype = (HH_WINTYPEW *)data;
 363         WCHAR *window = NULL;
 364         HHInfo *info = NULL;
 365
 366         if (!filename || !resolve_filename(filename, fullname, MAX_PATH, NULL, &window) || !window)
 367         {
 368             WARN("can't find window name: %s\n", debugstr_w(filename));
 369             return 0;
 370         }
 371         info = find_window(window);
 372         if (!info)
 373         {
 374             WARN("Could not find window named %s.\n", debugstr_w(window));
 375             free(window);
 376             return (HWND)~0;
 377         }
 378
 379         TRACE("Retrieving WINTYPE for %s.\n", debugstr_w(window));
 380         *wintype = info->WinType;
 381         free(window);
 382         return 0;
 383     }
 384     default:
 385         FIXME("HH case %s not handled.\n", command_to_string( command ));
 386     }
 387
 388     return 0;
 389 }
 390
 391 static void wintypeAtoW(const HH_WINTYPEA *data, HH_WINTYPEW *wdata, struct wintype_stringsW *stringsW)
 392 {
 393     memcpy(wdata, data, sizeof(*data));
 394     /* convert all of the ANSI strings to Unicode */
 395     wdata->pszType       = stringsW->pszType       = strdupAtoW(data->pszType);
 396     wdata->pszCaption    = stringsW->pszCaption    = strdupAtoW(data->pszCaption);
 397     wdata->pszToc        = stringsW->pszToc        = strdupAtoW(data->pszToc);
 398     wdata->pszIndex      = stringsW->pszIndex      = strdupAtoW(data->pszIndex);
 399     wdata->pszFile       = stringsW->pszFile       = strdupAtoW(data->pszFile);
 400     wdata->pszHome       = stringsW->pszHome       = strdupAtoW(data->pszHome);
 401     wdata->pszJump1      = stringsW->pszJump1      = strdupAtoW(data->pszJump1);
 402     wdata->pszJump2      = stringsW->pszJump2      = strdupAtoW(data->pszJump2);
 403     wdata->pszUrlJump1   = stringsW->pszUrlJump1   = strdupAtoW(data->pszUrlJump1);
 404     wdata->pszUrlJump2   = stringsW->pszUrlJump2   = strdupAtoW(data->pszUrlJump2);
 405     wdata->pszCustomTabs = stringsW->pszCustomTabs = strdupAtoW(data->pszCustomTabs);
 406 }
 407
 408 static void wintypeWtoA(const HH_WINTYPEW *wdata, HH_WINTYPEA *data, struct wintype_stringsA *stringsA)
 409 {
 410     memcpy(data, wdata, sizeof(*wdata));
 411     /* convert all of the Unicode strings to ANSI */
 412     data->pszType       = stringsA->pszType       = strdupWtoA(wdata->pszType);
 413     data->pszCaption    = stringsA->pszCaption    = strdupWtoA(wdata->pszCaption);
 414     data->pszToc        = stringsA->pszToc        = strdupWtoA(wdata->pszToc);
 415     data->pszIndex      = stringsA->pszFile       = strdupWtoA(wdata->pszIndex);
 416     data->pszFile       = stringsA->pszFile       = strdupWtoA(wdata->pszFile);
 417     data->pszHome       = stringsA->pszHome       = strdupWtoA(wdata->pszHome);
 418     data->pszJump1      = stringsA->pszJump1      = strdupWtoA(wdata->pszJump1);
 419     data->pszJump2      = stringsA->pszJump2      = strdupWtoA(wdata->pszJump2);
 420     data->pszUrlJump1   = stringsA->pszUrlJump1   = strdupWtoA(wdata->pszUrlJump1);
 421     data->pszUrlJump2   = stringsA->pszUrlJump2   = strdupWtoA(wdata->pszUrlJump2);
 422     data->pszCustomTabs = stringsA->pszCustomTabs = strdupWtoA(wdata->pszCustomTabs);
 423 }
 424
 425 /******************************************************************
 426  *              HtmlHelpA (HHCTRL.OCX.14)
 427  */
 428 HWND WINAPI HtmlHelpA(HWND caller, LPCSTR filename, UINT command, DWORD_PTR data)
 429 {
 430     WCHAR *wfile = strdupAtoW( filename );
 431     HWND result = 0;
 432
 433     if (data)
 434     {
 435         switch(command)
 436         {
 437         case HH_ALINK_LOOKUP:
 438         case HH_DISPLAY_SEARCH:
 439         case HH_DISPLAY_TEXT_POPUP:
 440         case HH_GET_LAST_ERROR:
 441         case HH_KEYWORD_LOOKUP:
 442         case HH_SYNC:
 443             FIXME("structures not handled yet\n");
 444             break;
 445
 446         case HH_SET_WIN_TYPE:
 447         {
 448             struct wintype_stringsW stringsW;
 449             HH_WINTYPEW wdata;
 450
 451             wintypeAtoW((HH_WINTYPEA *)data, &wdata, &stringsW);
 452             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)&wdata );
 453             wintype_stringsW_free(&stringsW);
 454             goto done;
 455         }
 456         case HH_GET_WIN_TYPE:
 457         {
 458             HH_WINTYPEW wdata;
 459             HHInfo *info;
 460
 461             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)&wdata );
 462             if (!wdata.pszType) break;
 463             info = find_window(wdata.pszType);
 464             if (!info) break;
 465             wintype_stringsA_free(&info->stringsA);
 466             wintypeWtoA(&wdata, (HH_WINTYPEA *)data, &info->stringsA);
 467             goto done;
 468         }
 469
 470         case HH_DISPLAY_INDEX:
 471         case HH_DISPLAY_TOPIC:
 472         case HH_DISPLAY_TOC:
 473         case HH_GET_WIN_HANDLE:
 474         case HH_SAFE_DISPLAY_TOPIC:
 475         {
 476             WCHAR *wdata = strdupAtoW( (const char *)data );
 477             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)wdata );
 478             free(wdata);
 479             goto done;
 480         }
 481
 482         case HH_CLOSE_ALL:
 483         case HH_HELP_CONTEXT:
 484         case HH_INITIALIZE:
 485         case HH_PRETRANSLATEMESSAGE:
 486         case HH_TP_HELP_CONTEXTMENU:
 487         case HH_TP_HELP_WM_HELP:
 488         case HH_UNINITIALIZE:
 489             /* either scalar or pointer to scalar - do nothing */
 490             break;
 491
 492         default:
 493             FIXME("Unknown command: %s (%d)\n", command_to_string(command), command);
 494             break;
 495         }
 496     }
 497
 498     result = HtmlHelpW( caller, wfile, command, data );
 499 done:
 500     free(wfile);
 501     return result;
 502 }
 503
 504 /******************************************************************
 505  *              doWinMain (HHCTRL.OCX.13)
 506  */
 507 int WINAPI doWinMain(HINSTANCE hInstance, LPSTR szCmdLine)
 508 {
 509     MSG msg;
 510     int len, buflen, mapid = -1;
 511     WCHAR *filename;
 512     char *endq = NULL;
 513     HWND hwnd;
 514
 515     hh_process = TRUE;
 516
 517     /* Parse command line option of the HTML Help command.
 518      *
 519      * Note: The only currently handled action is "mapid",
 520      *  which corresponds to opening a specific page.
 521      */
 522     while(*szCmdLine == '-')
 523     {
 524         LPSTR space, ptr;
 525
 526         ptr = szCmdLine + 1;
 527         space = strchr(ptr, ' ');
 528         if(!strncmp(ptr, "mapid", space-ptr))
 529         {
 530             char idtxt[10];
 531
 532             ptr += strlen("mapid")+1;
 533             space = strchr(ptr, ' ');
 534             /* command line ends without number */
 535             if (!space)
 536                 return 0;
 537             memcpy(idtxt, ptr, space-ptr);
 538             idtxt[space-ptr] = '\0';
 539             mapid = atoi(idtxt);
 540             szCmdLine = space+1;
 541         }
 542         else
 543         {
 544             FIXME("Unhandled HTML Help command line parameter! (%.*s)\n", (int)(space-szCmdLine), szCmdLine);
 545             return 0;
 546         }
 547     }
 548
 549     /* FIXME: Check szCmdLine for bad arguments */
 550     if (*szCmdLine == '\"')
 551         endq = strchr(++szCmdLine, '\"');
 552
 553     if (endq)
 554         len = endq - szCmdLine;
 555     else
 556         len = strlen(szCmdLine);
 557
 558     /* no filename given */
 559     if (!len)
 560         return 0;
 561
 562     buflen = MultiByteToWideChar(CP_ACP, 0, szCmdLine, len, NULL, 0) + 1;
 563     filename = malloc(buflen * sizeof(WCHAR));
 564     MultiByteToWideChar(CP_ACP, 0, szCmdLine, len, filename, buflen);
 565     filename[buflen-1] = 0;
 566
 567     /* Open a specific help topic */
 568     if(mapid != -1)
 569         hwnd = HtmlHelpW(GetDesktopWindow(), filename, HH_HELP_CONTEXT, mapid);
 570     else
 571         hwnd = HtmlHelpW(GetDesktopWindow(), filename, HH_DISPLAY_TOPIC, 0);
 572
 573     free(filename);
 574
 575     if (!hwnd)
 576     {
 577         ERR("Failed to open HTML Help file '%s'.\n", szCmdLine);
 578         return 0;
 579     }
 580
 581     while (GetMessageW(&msg, 0, 0, 0))
 582     {
 583         TranslateMessage(&msg);
 584         DispatchMessageW(&msg);
 585     }
 586
 587     return 0;
 588 }
 589
 590 /******************************************************************
 591  *              DllGetClassObject (HHCTRL.OCX.@)
 592  */
 593 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 594 {
 595     FIXME("(%s %s %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 596     return CLASS_E_CLASSNOTAVAILABLE;
 597 }