git.oblomov.eu Git - wine/blob - 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 extern struct list window_list;
  45
  46 BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved)
  47 {
  48     TRACE("(%p,%d,%p)\n", hInstance, fdwReason, lpvReserved);
  49
  50     switch (fdwReason)
  51     {
  52     case DLL_PROCESS_ATTACH:
  53         hhctrl_hinstance = hInstance;
  54         DisableThreadLibraryCalls(hInstance);
  55         break;
  56     case DLL_PROCESS_DETACH:
  57         break;
  58     }
  59     return TRUE;
  60 }
  61
  62 static const char *command_to_string(UINT command)
  63 {
  64 #define X(x) case x: return #x
  65     switch (command)
  66     {
  67         X( HH_DISPLAY_TOPIC );
  68         X( HH_DISPLAY_TOC );
  69         X( HH_DISPLAY_INDEX );
  70         X( HH_DISPLAY_SEARCH );
  71         X( HH_SET_WIN_TYPE );
  72         X( HH_GET_WIN_TYPE );
  73         X( HH_GET_WIN_HANDLE );
  74         X( HH_ENUM_INFO_TYPE );
  75         X( HH_SET_INFO_TYPE );
  76         X( HH_SYNC );
  77         X( HH_RESERVED1 );
  78         X( HH_RESERVED2 );
  79         X( HH_RESERVED3 );
  80         X( HH_KEYWORD_LOOKUP );
  81         X( HH_DISPLAY_TEXT_POPUP );
  82         X( HH_HELP_CONTEXT );
  83         X( HH_TP_HELP_CONTEXTMENU );
  84         X( HH_TP_HELP_WM_HELP );
  85         X( HH_CLOSE_ALL );
  86         X( HH_ALINK_LOOKUP );
  87         X( HH_GET_LAST_ERROR );
  88         X( HH_ENUM_CATEGORY );
  89         X( HH_ENUM_CATEGORY_IT );
  90         X( HH_RESET_IT_FILTER );
  91         X( HH_SET_INCLUSIVE_FILTER );
  92         X( HH_SET_EXCLUSIVE_FILTER );
  93         X( HH_INITIALIZE );
  94         X( HH_UNINITIALIZE );
  95         X( HH_SAFE_DISPLAY_TOPIC );
  96         X( HH_PRETRANSLATEMESSAGE );
  97         X( HH_SET_GLOBAL_PROPERTY );
  98     default: return "???";
  99     }
 100 #undef X
 101 }
 102
 103 static BOOL resolve_filename(const WCHAR *filename, WCHAR *fullname, DWORD buflen, WCHAR **index, WCHAR **window)
 104 {
 105     const WCHAR *extra;
 106     WCHAR chm_file[MAX_PATH];
 107
 108     static const WCHAR helpW[] = {'\\','h','e','l','p','\\',0};
 109     static const WCHAR delimW[] = {':',':',0};
 110     static const WCHAR delim2W[] = {'>',0};
 111
 112     filename = skip_schema(filename);
 113
 114     /* the format is "helpFile[::/index][>window]" */
 115     if (index) *index = NULL;
 116     if (window) *window = NULL;
 117
 118     extra = strstrW(filename, delim2W);
 119     if (extra)
 120     {
 121         memcpy(chm_file, filename, (extra-filename)*sizeof(WCHAR));
 122         chm_file[extra-filename] = 0;
 123         filename = chm_file;
 124         if (window)
 125             *window = strdupW(extra+1);
 126     }
 127
 128     extra = strstrW(filename, delimW);
 129     if (extra)
 130     {
 131         if (filename != chm_file)
 132             memcpy(chm_file, filename, (extra-filename)*sizeof(WCHAR));
 133         chm_file[extra-filename] = 0;
 134         filename = chm_file;
 135         if (index)
 136             *index = strdupW(extra+2);
 137     }
 138
 139     GetFullPathNameW(filename, buflen, fullname, NULL);
 140     if (GetFileAttributesW(fullname) == INVALID_FILE_ATTRIBUTES)
 141     {
 142         GetWindowsDirectoryW(fullname, buflen);
 143         strcatW(fullname, helpW);
 144         strcatW(fullname, filename);
 145     }
 146     return (GetFileAttributesW(fullname) != INVALID_FILE_ATTRIBUTES);
 147 }
 148
 149 static inline HHInfo *find_window(const WCHAR *window)
 150 {
 151     HHInfo *info;
 152
 153     LIST_FOR_EACH_ENTRY(info, &window_list, HHInfo, entry)
 154     {
 155         if (strcmpW(info->WinType.pszType, window) == 0)
 156             return info;
 157     }
 158     return NULL;
 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=%lx)\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             heap_free(default_index);
 203             heap_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             heap_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                 index = (const WCHAR *)data;
 221             break;
 222         }
 223
 224         res = NavigateToChm(info, info->pCHMInfo->szFile, index);
 225         heap_free(default_index);
 226
 227         if(!res)
 228         {
 229             ReleaseHelpViewer(info);
 230             return NULL;
 231         }
 232
 233         switch(command)
 234         {
 235         case HH_DISPLAY_TOPIC:
 236         case HH_DISPLAY_TOC:
 237             tab_index = TAB_CONTENTS;
 238             break;
 239         case HH_DISPLAY_INDEX:
 240             tab_index = TAB_INDEX;
 241             if (data)
 242                 FIXME("Should select keyword '%s'.\n", debugstr_w((WCHAR *)data));
 243             break;
 244         case HH_DISPLAY_SEARCH:
 245             tab_index = TAB_SEARCH;
 246             if (data)
 247                 FIXME("Should display search specified by HH_FTS_QUERY structure.\n");
 248             break;
 249         }
 250         /* open the requested tab */
 251         memset(&nmhdr, 0, sizeof(nmhdr));
 252         nmhdr.code = TCN_SELCHANGE;
 253         SendMessageW(info->hwndTabCtrl, TCM_SETCURSEL, (WPARAM)info->tabs[tab_index].id, 0);
 254         SendMessageW(info->WinType.hwndNavigation, WM_NOTIFY, 0, (LPARAM)&nmhdr);
 255
 256         return info->WinType.hwndHelp;
 257     }
 258     case HH_HELP_CONTEXT: {
 259         HHInfo *info;
 260         LPWSTR url;
 261
 262         if (!filename)
 263             return NULL;
 264
 265         if (!resolve_filename(filename, fullname, MAX_PATH, NULL, NULL))
 266         {
 267             WARN("can't find %s\n", debugstr_w(filename));
 268             return 0;
 269         }
 270
 271         info = CreateHelpViewer(NULL, fullname, caller);
 272         if(!info)
 273             return NULL;
 274
 275         url = FindContextAlias(info->pCHMInfo, data);
 276         if(!url)
 277         {
 278             ReleaseHelpViewer(info);
 279             return NULL;
 280         }
 281
 282         NavigateToUrl(info, url);
 283         heap_free(url);
 284         return info->WinType.hwndHelp;
 285     }
 286     case HH_PRETRANSLATEMESSAGE: {
 287         static BOOL warned = FALSE;
 288
 289         if (!warned)
 290         {
 291             FIXME("HH_PRETRANSLATEMESSAGE unimplemented\n");
 292             warned = TRUE;
 293         }
 294         return 0;
 295     }
 296     case HH_CLOSE_ALL: {
 297         HHInfo *info, *next;
 298
 299         LIST_FOR_EACH_ENTRY_SAFE(info, next, &window_list, HHInfo, entry)
 300         {
 301             TRACE("Destroying window %s.\n", debugstr_w(info->WinType.pszType));
 302             ReleaseHelpViewer(info);
 303         }
 304         return 0;
 305     }
 306     case HH_SET_WIN_TYPE: {
 307         HH_WINTYPEW *wintype = (HH_WINTYPEW *)data;
 308         WCHAR *window = NULL;
 309         HHInfo *info = NULL;
 310
 311         if (!filename && wintype->pszType)
 312             window = strdupW(wintype->pszType);
 313         else if (!filename || !resolve_filename(filename, fullname, MAX_PATH, NULL, &window) || !window)
 314         {
 315             WARN("can't find window name: %s\n", debugstr_w(filename));
 316             return 0;
 317         }
 318         info = find_window(window);
 319         if (!info)
 320         {
 321             info = heap_alloc_zero(sizeof(HHInfo));
 322             info->WinType.pszType = info->stringsW.pszType = window;
 323             list_add_tail(&window_list, &info->entry);
 324         }
 325         else
 326             heap_free(window);
 327
 328         TRACE("Changing WINTYPE, fsValidMembers=0x%x\n", wintype->fsValidMembers);
 329
 330         MergeChmProperties(wintype, info);
 331         return 0;
 332     }
 333     case HH_GET_WIN_TYPE: {
 334         HH_WINTYPEW *wintype = (HH_WINTYPEW *)data;
 335         WCHAR *window = NULL;
 336         HHInfo *info = NULL;
 337
 338         if (!filename || !resolve_filename(filename, fullname, MAX_PATH, NULL, &window) || !window)
 339         {
 340             WARN("can't find window name: %s\n", debugstr_w(filename));
 341             return 0;
 342         }
 343         info = find_window(window);
 344         if (!info)
 345         {
 346             WARN("Could not find window named %s.\n", debugstr_w(window));
 347             heap_free(window);
 348             return (HWND)~0;
 349         }
 350
 351         TRACE("Retrieving WINTYPE for %s.\n", debugstr_w(window));
 352         *wintype = info->WinType;
 353         heap_free(window);
 354         return 0;
 355     }
 356     default:
 357         FIXME("HH case %s not handled.\n", command_to_string( command ));
 358     }
 359
 360     return 0;
 361 }
 362
 363 static void wintypeAtoW(const HH_WINTYPEA *data, HH_WINTYPEW *wdata, struct wintype_stringsW *stringsW)
 364 {
 365     memcpy(wdata, data, sizeof(*data));
 366     /* convert all of the ANSI strings to Unicode */
 367     wdata->pszType       = stringsW->pszType       = strdupAtoW(data->pszType);
 368     wdata->pszCaption    = stringsW->pszCaption    = strdupAtoW(data->pszCaption);
 369     wdata->pszToc        = stringsW->pszToc        = strdupAtoW(data->pszToc);
 370     wdata->pszIndex      = stringsW->pszIndex      = strdupAtoW(data->pszIndex);
 371     wdata->pszFile       = stringsW->pszFile       = strdupAtoW(data->pszFile);
 372     wdata->pszHome       = stringsW->pszHome       = strdupAtoW(data->pszHome);
 373     wdata->pszJump1      = stringsW->pszJump1      = strdupAtoW(data->pszJump1);
 374     wdata->pszJump2      = stringsW->pszJump2      = strdupAtoW(data->pszJump2);
 375     wdata->pszUrlJump1   = stringsW->pszUrlJump1   = strdupAtoW(data->pszUrlJump1);
 376     wdata->pszUrlJump2   = stringsW->pszUrlJump2   = strdupAtoW(data->pszUrlJump2);
 377     wdata->pszCustomTabs = stringsW->pszCustomTabs = strdupAtoW(data->pszCustomTabs);
 378 }
 379
 380 static void wintypeWtoA(const HH_WINTYPEW *wdata, HH_WINTYPEA *data, struct wintype_stringsA *stringsA)
 381 {
 382     memcpy(data, wdata, sizeof(*wdata));
 383     /* convert all of the Unicode strings to ANSI */
 384     data->pszType       = stringsA->pszType       = strdupWtoA(wdata->pszType);
 385     data->pszCaption    = stringsA->pszCaption    = strdupWtoA(wdata->pszCaption);
 386     data->pszToc        = stringsA->pszToc        = strdupWtoA(wdata->pszToc);
 387     data->pszIndex      = stringsA->pszFile       = strdupWtoA(wdata->pszIndex);
 388     data->pszFile       = stringsA->pszFile       = strdupWtoA(wdata->pszFile);
 389     data->pszHome       = stringsA->pszHome       = strdupWtoA(wdata->pszHome);
 390     data->pszJump1      = stringsA->pszJump1      = strdupWtoA(wdata->pszJump1);
 391     data->pszJump2      = stringsA->pszJump2      = strdupWtoA(wdata->pszJump2);
 392     data->pszUrlJump1   = stringsA->pszUrlJump1   = strdupWtoA(wdata->pszUrlJump1);
 393     data->pszUrlJump2   = stringsA->pszUrlJump2   = strdupWtoA(wdata->pszUrlJump2);
 394     data->pszCustomTabs = stringsA->pszCustomTabs = strdupWtoA(wdata->pszCustomTabs);
 395 }
 396
 397 /******************************************************************
 398  *              HtmlHelpA (HHCTRL.OCX.14)
 399  */
 400 HWND WINAPI HtmlHelpA(HWND caller, LPCSTR filename, UINT command, DWORD_PTR data)
 401 {
 402     WCHAR *wfile = strdupAtoW( filename );
 403     HWND result = 0;
 404
 405     if (data)
 406     {
 407         switch(command)
 408         {
 409         case HH_ALINK_LOOKUP:
 410         case HH_DISPLAY_SEARCH:
 411         case HH_DISPLAY_TEXT_POPUP:
 412         case HH_GET_LAST_ERROR:
 413         case HH_KEYWORD_LOOKUP:
 414         case HH_SYNC:
 415             FIXME("structures not handled yet\n");
 416             break;
 417
 418         case HH_SET_WIN_TYPE:
 419         {
 420             struct wintype_stringsW stringsW;
 421             HH_WINTYPEW wdata;
 422
 423             wintypeAtoW((HH_WINTYPEA *)data, &wdata, &stringsW);
 424             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)&wdata );
 425             wintype_stringsW_free(&stringsW);
 426             goto done;
 427         }
 428         case HH_GET_WIN_TYPE:
 429         {
 430             HH_WINTYPEW wdata;
 431             HHInfo *info;
 432
 433             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)&wdata );
 434             if (!wdata.pszType) break;
 435             info = find_window(wdata.pszType);
 436             if (!info) break;
 437             wintype_stringsA_free(&info->stringsA);
 438             wintypeWtoA(&wdata, (HH_WINTYPEA *)data, &info->stringsA);
 439             goto done;
 440         }
 441
 442         case HH_DISPLAY_INDEX:
 443         case HH_DISPLAY_TOPIC:
 444         case HH_DISPLAY_TOC:
 445         case HH_GET_WIN_HANDLE:
 446         case HH_SAFE_DISPLAY_TOPIC:
 447         {
 448             WCHAR *wdata = strdupAtoW( (const char *)data );
 449             result = HtmlHelpW( caller, wfile, command, (DWORD_PTR)wdata );
 450             heap_free(wdata);
 451             goto done;
 452         }
 453
 454         case HH_CLOSE_ALL:
 455         case HH_HELP_CONTEXT:
 456         case HH_INITIALIZE:
 457         case HH_PRETRANSLATEMESSAGE:
 458         case HH_TP_HELP_CONTEXTMENU:
 459         case HH_TP_HELP_WM_HELP:
 460         case HH_UNINITIALIZE:
 461             /* either scalar or pointer to scalar - do nothing */
 462             break;
 463
 464         default:
 465             FIXME("Unknown command: %s (%d)\n", command_to_string(command), command);
 466             break;
 467         }
 468     }
 469
 470     result = HtmlHelpW( caller, wfile, command, data );
 471 done:
 472     heap_free(wfile);
 473     return result;
 474 }
 475
 476 /******************************************************************
 477  *              doWinMain (HHCTRL.OCX.13)
 478  */
 479 int WINAPI doWinMain(HINSTANCE hInstance, LPSTR szCmdLine)
 480 {
 481     MSG msg;
 482     int len, buflen, mapid = -1;
 483     WCHAR *filename;
 484     char *endq = NULL;
 485     HWND hwnd;
 486
 487     hh_process = TRUE;
 488
 489     /* Parse command line option of the HTML Help command.
 490      *
 491      * Note: The only currently handled action is "mapid",
 492      *  which corresponds to opening a specific page.
 493      */
 494     while(*szCmdLine == '-')
 495     {
 496         LPSTR space, ptr;
 497
 498         ptr = szCmdLine + 1;
 499         space = strchr(ptr, ' ');
 500         if(!strncmp(ptr, "mapid", space-ptr))
 501         {
 502             char idtxt[10];
 503
 504             ptr += strlen("mapid")+1;
 505             space = strchr(ptr, ' ');
 506             /* command line ends without number */
 507             if (!space)
 508                 return 0;
 509             memcpy(idtxt, ptr, space-ptr);
 510             idtxt[space-ptr] = '\0';
 511             mapid = atoi(idtxt);
 512             szCmdLine = space+1;
 513         }
 514         else
 515         {
 516             FIXME("Unhandled HTML Help command line parameter! (%.*s)\n", (int)(space-szCmdLine), szCmdLine);
 517             return 0;
 518         }
 519     }
 520
 521     /* FIXME: Check szCmdLine for bad arguments */
 522     if (*szCmdLine == '\"')
 523         endq = strchr(++szCmdLine, '\"');
 524
 525     if (endq)
 526         len = endq - szCmdLine;
 527     else
 528         len = strlen(szCmdLine);
 529
 530     /* no filename given */
 531     if (!len)
 532         return 0;
 533
 534     buflen = MultiByteToWideChar(CP_ACP, 0, szCmdLine, len, NULL, 0) + 1;
 535     filename = heap_alloc(buflen * sizeof(WCHAR));
 536     MultiByteToWideChar(CP_ACP, 0, szCmdLine, len, filename, buflen);
 537     filename[buflen-1] = 0;
 538
 539     /* Open a specific help topic */
 540     if(mapid != -1)
 541         hwnd = HtmlHelpW(GetDesktopWindow(), filename, HH_HELP_CONTEXT, mapid);
 542     else
 543         hwnd = HtmlHelpW(GetDesktopWindow(), filename, HH_DISPLAY_TOPIC, 0);
 544
 545     heap_free(filename);
 546
 547     if (!hwnd)
 548     {
 549         ERR("Failed to open HTML Help file '%s'.\n", szCmdLine);
 550         return 0;
 551     }
 552
 553     while (GetMessageW(&msg, 0, 0, 0))
 554     {
 555         TranslateMessage(&msg);
 556         DispatchMessageW(&msg);
 557     }
 558
 559     return 0;
 560 }
 561
 562 /******************************************************************
 563  *              DllGetClassObject (HHCTRL.OCX.@)
 564  */
 565 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 566 {
 567     FIXME("(%s %s %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 568     return CLASS_E_CLASSNOTAVAILABLE;
 569 }
 570
 571 /***********************************************************************
 572  *              DllRegisterServer (HHCTRL.OCX.@)
 573  */
 574 HRESULT WINAPI DllRegisterServer(void)
 575 {
 576     return __wine_register_resources( hhctrl_hinstance );
 577 }
 578
 579 /***********************************************************************
 580  *              DllUnregisterServer (HHCTRL.OCX.@)
 581  */
 582 HRESULT WINAPI DllUnregisterServer(void)
 583 {
 584     return __wine_unregister_resources( hhctrl_hinstance );
 585 }