reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-04 17:56:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5bc1a8de87
wine/dlls/hhctrl.ocx/help.c

896 lines
25 KiB
C
Raw Blame History

/*
* Help Viewer Implementation
*
* Copyright 2005 James Hawkins
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdarg.h>
#define COBJMACROS
#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 "exdisp.h"
#include "wininet.h"
#include "wine/unicode.h"
#include "wine/debug.h"
#include "resource.h"
#include "chm.h"
#include "webbrowser.h"
WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
static void Help_OnSize(HWND hWnd);
/* Window type defaults */
#define WINTYPE_DEFAULT_X 280
#define WINTYPE_DEFAULT_Y 100
#define WINTYPE_DEFAULT_WIDTH 740
#define WINTYPE_DEFAULT_HEIGHT 640
#define WINTYPE_DEFAULT_NAVWIDTH 250
static const WCHAR szEmpty[] = {0};
typedef struct tagHHInfo
{
HH_WINTYPEW *pHHWinType;
CHMInfo *pCHMInfo;
WBInfo *pWBInfo;
HINSTANCE hInstance;
LPWSTR szCmdLine;
HWND hwndTabCtrl;
HWND hwndSizeBar;
HFONT hFont;
} HHInfo;
extern HINSTANCE hhctrl_hinstance;
static LPWSTR HH_ANSIToUnicode(LPCSTR ansi)
{
LPWSTR unicode;
int count;
count = MultiByteToWideChar(CP_ACP, 0, ansi, -1, NULL, 0);
unicode = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, ansi, -1, unicode, count);
return unicode;
}
/* Loads a string from the resource file */
static LPWSTR HH_LoadString(DWORD dwID)
{
LPWSTR string = NULL;
int iSize;
iSize = LoadStringW(hhctrl_hinstance, dwID, NULL, 0);
iSize += 2; /* some strings (tab text) needs double-null termination */
string = HeapAlloc(GetProcessHeap(), 0, iSize * sizeof(WCHAR));
LoadStringW(hhctrl_hinstance, dwID, string, iSize);
return string;
}
static BOOL NavigateToChm(WBInfo *pWBInfo, LPCWSTR file, LPCWSTR index)
{
WCHAR buf[INTERNET_MAX_URL_LENGTH];
WCHAR full_path[MAX_PATH];
VARIANT url;
static const WCHAR url_format[] =
{'m','k',':','@','M','S','I','T','S','t','o','r','e',':','%','s',':',':','/','%','s',0};
if (!pWBInfo->pWebBrowser2)
return FALSE;
if(!GetFullPathNameW(file, sizeof(full_path), full_path, NULL)) {
WARN("GetFullPathName failed: %u\n", GetLastError());
return FALSE;
}
wsprintfW(buf, url_format, full_path, index);
V_VT(&url) = VT_BSTR;
V_BSTR(&url) = SysAllocString(buf);
IWebBrowser2_Navigate2(pWBInfo->pWebBrowser2, &url, 0, 0, 0, 0);
VariantClear(&url);
return TRUE;
}
/* 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->pHHWinType->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 = (WNDPROC)SizeBar_WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = pHHInfo->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 *pHHInfo, RECT *rc)
{
RECT rectWND, rectTB, rectNP;
GetClientRect(pHHInfo->pHHWinType->hwndHelp, &rectWND);
GetClientRect(pHHInfo->pHHWinType->hwndToolBar, &rectTB);
GetClientRect(pHHInfo->pHHWinType->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->pHHWinType->hwndHelp;
DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE | WS_OVERLAPPED;
DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
RECT rc;
SB_GetSizeBarRect(pHHInfo, &rc);
hWnd = CreateWindowExW(dwExStyles, szSizeBarClass, szEmpty, dwStyles,
rc.left, rc.top, rc.right, rc.bottom,
hwndParent, NULL, pHHInfo->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 */
static const WCHAR szChildClass[] = {
'H','H',' ','C','h','i','l','d',0
};
static void Child_OnPaint(HWND hWnd)
{
PAINTSTRUCT ps;
HDC hdc;
RECT rc;
hdc = BeginPaint(hWnd, &ps);
/* Only paint the Navigation pane, identified by the fact
* that it has a child window
*/
if (GetWindow(hWnd, GW_CHILD))
{
GetClientRect(hWnd, &rc);
/* set the border color */
SelectObject(hdc, GetStockObject(DC_PEN));
SetDCPenColor(hdc, GetSysColor(COLOR_BTNSHADOW));
/* Draw the top border */
LineTo(hdc, rc.right, 0);
SelectObject(hdc, GetStockObject(WHITE_PEN));
MoveToEx(hdc, 0, 1, NULL);
LineTo(hdc, rc.right, 1);
}
EndPaint(hWnd, &ps);
}
static LRESULT CALLBACK Child_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_PAINT:
Child_OnPaint(hWnd);
break;
default:
return DefWindowProcW(hWnd, message, wParam, lParam);
}
return 0;
}
static void HH_RegisterChildWndClass(HHInfo *pHHInfo)
{
WNDCLASSEXW wcex;
wcex.cbSize = sizeof(WNDCLASSEXW);
wcex.style = 0;
wcex.lpfnWndProc = (WNDPROC)Child_WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = pHHInfo->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 = szChildClass;
wcex.hIconSm = LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
RegisterClassExW(&wcex);
}
/* Toolbar */
#define ICON_SIZE 20
static void TB_OnClick(HWND hWnd, DWORD dwID)
{
HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
switch (dwID)
{
case IDTB_STOP:
WB_DoPageAction(pHHInfo->pWBInfo, WB_STOP);
break;
case IDTB_REFRESH:
WB_DoPageAction(pHHInfo->pWBInfo, WB_REFRESH);
break;
case IDTB_BACK:
WB_DoPageAction(pHHInfo->pWBInfo, WB_GOBACK);
break;
case IDTB_HOME:
NavigateToChm(pHHInfo->pWBInfo, pHHInfo->pCHMInfo->szFile, pHHInfo->pHHWinType->pszHome);
break;
case IDTB_FORWARD:
WB_DoPageAction(pHHInfo->pWBInfo, WB_GOFORWARD);
break;
case IDTB_EXPAND:
case IDTB_CONTRACT:
case IDTB_SYNC:
case IDTB_PRINT:
case IDTB_OPTIONS:
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)
{
/* FIXME: Load the correct button bitmaps */
pButtons[dwIndex].iBitmap = STD_PRINT;
pButtons[dwIndex].idCommand = dwID;
pButtons[dwIndex].fsState = TBSTATE_ENABLED;
pButtons[dwIndex].fsStyle = BTNS_BUTTON;
pButtons[dwIndex].dwData = 0;
pButtons[dwIndex].iString = 0;
}
static void TB_AddButtonsFromFlags(TBBUTTON *pButtons, DWORD dwButtonFlags, LPDWORD pdwNumButtons)
{
*pdwNumButtons = 0;
if (dwButtonFlags & HHWIN_BUTTON_EXPAND)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_EXPAND);
if (dwButtonFlags & HHWIN_BUTTON_BACK)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_BACK);
if (dwButtonFlags & HHWIN_BUTTON_FORWARD)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_FORWARD);
if (dwButtonFlags & HHWIN_BUTTON_STOP)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_STOP);
if (dwButtonFlags & HHWIN_BUTTON_REFRESH)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_REFRESH);
if (dwButtonFlags & HHWIN_BUTTON_HOME)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_HOME);
if (dwButtonFlags & HHWIN_BUTTON_SYNC)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_SYNC);
if (dwButtonFlags & HHWIN_BUTTON_OPTIONS)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_OPTIONS);
if (dwButtonFlags & HHWIN_BUTTON_PRINT)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_PRINT);
if (dwButtonFlags & HHWIN_BUTTON_JUMP1)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_JUMP1);
if (dwButtonFlags & HHWIN_BUTTON_JUMP2)
TB_AddButton(pButtons,(*pdwNumButtons)++, IDTB_JUMP2);
if (dwButtonFlags & HHWIN_BUTTON_ZOOM)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_ZOOM);
if (dwButtonFlags & HHWIN_BUTTON_TOC_NEXT)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_NEXT);
if (dwButtonFlags & HHWIN_BUTTON_TOC_PREV)
TB_AddButton(pButtons, (*pdwNumButtons)++, IDTB_TOC_PREV);
}
static BOOL HH_AddToolbar(HHInfo *pHHInfo)
{
HWND hToolbar;
HWND hwndParent = pHHInfo->pHHWinType->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;
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);
if (!hToolbar)
return FALSE;
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);
for (dwIndex = 0; dwIndex < dwNumButtons; dwIndex++)
{
LPWSTR szBuf = HH_LoadString(buttons[dwIndex].idCommand);
DWORD dwLen = strlenW(szBuf);
szBuf[dwLen + 2] = 0; /* Double-null terminate */
buttons[dwIndex].iString = (DWORD)SendMessageW(hToolbar, TB_ADDSTRINGW, 0, (LPARAM)szBuf);
HeapFree(GetProcessHeap(), 0, szBuf);
}
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_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;
RECT rectWND, rectTB;
GetClientRect(hwndParent, &rectWND);
GetClientRect(hwndToolbar, &rectTB);
rc->left = 0;
rc->top = rectTB.bottom;
rc->bottom = rectWND.bottom - rectTB.bottom;
if (!(pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_NAV_WIDTH) &&
pHHInfo->pHHWinType->iNavWidth == 0)
{
pHHInfo->pHHWinType->iNavWidth = WINTYPE_DEFAULT_NAVWIDTH;
}
rc->right = pHHInfo->pHHWinType->iNavWidth;
}
static void NP_CreateTab(HINSTANCE hInstance, HWND hwndTabCtrl, DWORD dwStrID, DWORD dwIndex)
{
TCITEMW tie;
LPWSTR tabText = HH_LoadString(dwStrID);
tie.mask = TCIF_TEXT;
tie.pszText = tabText;
SendMessageW( hwndTabCtrl, TCM_INSERTITEMW, dwIndex, (LPARAM)&tie );
HeapFree(GetProcessHeap(), 0, tabText);
}
static BOOL HH_AddNavigationPane(HHInfo *pHHInfo)
{
HWND hWnd, hwndTabCtrl;
HWND hwndParent = pHHInfo->pHHWinType->hwndHelp;
DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE;
DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
DWORD dwIndex = 0;
RECT rc;
NP_GetNavigationRect(pHHInfo, &rc);
hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
rc.left, rc.top, rc.right, rc.bottom,
hwndParent, NULL, pHHInfo->hInstance, NULL);
if (!hWnd)
return FALSE;
hwndTabCtrl = CreateWindowExW(dwExStyles, WC_TABCONTROLW, szEmpty, dwStyles,
0, TAB_TOP_PADDING,
rc.right - TAB_RIGHT_PADDING,
rc.bottom - TAB_TOP_PADDING,
hWnd, NULL, pHHInfo->hInstance, NULL);
if (!hwndTabCtrl)
return FALSE;
if (*pHHInfo->pHHWinType->pszToc)
NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_CONTENTS, dwIndex++);
if (*pHHInfo->pHHWinType->pszIndex)
NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_INDEX, dwIndex++);
if (pHHInfo->pHHWinType->fsWinProperties & HHWIN_PROP_TAB_SEARCH)
NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_SEARCH, dwIndex++);
if (pHHInfo->pHHWinType->fsWinProperties & HHWIN_PROP_TAB_FAVORITES)
NP_CreateTab(pHHInfo->hInstance, hwndTabCtrl, IDS_FAVORITES, dwIndex++);
SendMessageW(hwndTabCtrl, WM_SETFONT, (WPARAM)pHHInfo->hFont, TRUE);
pHHInfo->hwndTabCtrl = hwndTabCtrl;
pHHInfo->pHHWinType->hwndNavigation = hWnd;
return TRUE;
}
/* HTML Pane */
static void HP_GetHTMLRect(HHInfo *pHHInfo, RECT *rc)
{
RECT rectTB, rectWND, rectNP, rectSB;
GetClientRect(pHHInfo->pHHWinType->hwndHelp, &rectWND);
GetClientRect(pHHInfo->pHHWinType->hwndToolBar, &rectTB);
GetClientRect(pHHInfo->pHHWinType->hwndNavigation, &rectNP);
GetClientRect(pHHInfo->hwndSizeBar, &rectSB);
rc->left = rectNP.right + rectSB.right;
rc->top = rectTB.bottom;
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;
DWORD dwStyles = WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN;
DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_CLIENTEDGE;
RECT rc;
HP_GetHTMLRect(pHHInfo, &rc);
hWnd = CreateWindowExW(dwExStyles, szChildClass, szEmpty, dwStyles,
rc.left, rc.top, rc.right, rc.bottom,
hwndParent, NULL, pHHInfo->hInstance, NULL);
if (!hWnd)
return FALSE;
if (!WB_EmbedBrowser(pHHInfo->pWBInfo, 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;
return TRUE;
}
/* Viewer Window */
static void Help_OnSize(HWND hWnd)
{
HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
DWORD dwSize;
RECT rc;
if (!pHHInfo)
return;
NP_GetNavigationRect(pHHInfo, &rc);
SetWindowPos(pHHInfo->pHHWinType->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_RIGHT_PADDING,
rc.bottom - 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, rc.left, rc.top,
rc.right, rc.bottom, SWP_SHOWWINDOW);
/* Resize browser window taking the frame size into account */
dwSize = GetSystemMetrics(SM_CXFRAME);
WB_ResizeBrowser(pHHInfo->pWBInfo, rc.right - dwSize, rc.bottom - dwSize);
}
static LRESULT CALLBACK Help_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED)
TB_OnClick(hWnd, LOWORD(wParam));
break;
case WM_SIZE:
Help_OnSize(hWnd);
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProcW(hWnd, message, wParam, lParam);
}
return 0;
}
static BOOL HH_CreateHelpWindow(HHInfo *pHHInfo)
{
HWND hWnd;
HINSTANCE hInstance = pHHInfo->hInstance;
RECT winPos = pHHInfo->pHHWinType->rcWindowPos;
WNDCLASSEXW wcex;
DWORD dwStyles, dwExStyles;
DWORD x, y, width, height;
static const WCHAR windowClassW[] = {
'H','H',' ', 'P','a','r','e','n','t',0
};
wcex.cbSize = sizeof(WNDCLASSEXW);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)Help_WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = 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);
/* Read in window parameters if available */
if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_STYLES)
dwStyles = pHHInfo->pHHWinType->dwStyles;
else
dwStyles = WS_OVERLAPPEDWINDOW | WS_VISIBLE |
WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
if (pHHInfo->pHHWinType->fsValidMembers & HHWIN_PARAM_EXSTYLES)
dwExStyles = pHHInfo->pHHWinType->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)
{
x = winPos.left;
y = winPos.top;
width = winPos.right - x;
height = winPos.bottom - y;
}
else
{
x = WINTYPE_DEFAULT_X;
y = WINTYPE_DEFAULT_Y;
width = WINTYPE_DEFAULT_WIDTH;
height = WINTYPE_DEFAULT_HEIGHT;
}
hWnd = CreateWindowExW(dwExStyles, windowClassW, pHHInfo->pHHWinType->pszCaption,
dwStyles, x, y, width, height, NULL, NULL, hInstance, NULL);
if (!hWnd)
return FALSE;
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
/* store the pointer to the HH info struct */
SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pHHInfo);
pHHInfo->pHHWinType->hwndHelp = hWnd;
return TRUE;
}
static void HH_CreateFont(HHInfo *pHHInfo)
{
LOGFONTW lf;
GetObjectW(GetStockObject(ANSI_VAR_FONT), sizeof(LOGFONTW), &lf);
lf.lfWeight = FW_NORMAL;
lf.lfItalic = FALSE;
lf.lfUnderline = FALSE;
pHHInfo->hFont = CreateFontIndirectW(&lf);
}
static void HH_InitRequiredControls(DWORD dwControls)
{
INITCOMMONCONTROLSEX icex;
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = dwControls;
InitCommonControlsEx(&icex);
}
/* Creates the whole package */
static BOOL HH_CreateViewer(HHInfo *pHHInfo)
{
HH_CreateFont(pHHInfo);
if (!HH_CreateHelpWindow(pHHInfo))
return FALSE;
HH_InitRequiredControls(ICC_BAR_CLASSES);
if (!HH_AddToolbar(pHHInfo))
return FALSE;
HH_RegisterChildWndClass(pHHInfo);
if (!HH_AddNavigationPane(pHHInfo))
return FALSE;
HH_RegisterSizeBarClass(pHHInfo);
if (!HH_AddSizeBar(pHHInfo))
return FALSE;
if (!HH_AddHTMLPane(pHHInfo))
return FALSE;
return TRUE;
}
static HHInfo *HH_OpenHH(HINSTANCE hInstance, LPWSTR szCmdLine)
{
HHInfo *pHHInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HHInfo));
pHHInfo->pHHWinType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HH_WINTYPEW));
pHHInfo->pCHMInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(CHMInfo));
pHHInfo->pWBInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(WBInfo));
pHHInfo->hInstance = hInstance;
pHHInfo->szCmdLine = szCmdLine;
return pHHInfo;
}
static void HH_Close(HHInfo *pHHInfo)
{
if (!pHHInfo)
return;
/* 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->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);
}
if (pHHInfo->pWBInfo)
{
WB_UnEmbedBrowser(pHHInfo->pWBInfo);
HeapFree(GetProcessHeap(), 0, pHHInfo->pWBInfo);
}
}
static BOOL HH_OpenCHM(HHInfo *pHHInfo)
{
if (!CHM_OpenCHM(pHHInfo->pCHMInfo, pHHInfo->szCmdLine))
return FALSE;
if (!CHM_LoadWinTypeFromCHM(pHHInfo->pCHMInfo, pHHInfo->pHHWinType))
return FALSE;
return TRUE;
}
/* FIXME: Check szCmdLine for bad arguments */
int WINAPI doWinMain(HINSTANCE hInstance, LPSTR szCmdLine)
{
MSG msg;
HHInfo *pHHInfo;
if (FAILED(OleInitialize(NULL)))
return -1;
pHHInfo = HH_OpenHH(hInstance, HH_ANSIToUnicode(szCmdLine));
if (!pHHInfo || !HH_OpenCHM(pHHInfo) || !HH_CreateViewer(pHHInfo))
{
OleUninitialize();
return -1;
}
NavigateToChm(pHHInfo->pWBInfo, pHHInfo->pCHMInfo->szFile, pHHInfo->pHHWinType->pszFile);
while (GetMessageW(&msg, 0, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
HH_Close(pHHInfo);
HeapFree(GetProcessHeap(), 0, pHHInfo);
OleUninitialize();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink