mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2695 lines
89 KiB
2695 lines
89 KiB
/****************************************************************************
|
|
|
|
PROGRAM: CharMap
|
|
|
|
PURPOSE: Utility providing users an easy interface for selecting special
|
|
characters.
|
|
|
|
COMMENTS:
|
|
Created by MikeSch (7-16-91)
|
|
Partially derived from WinWord 2.0 Insert.Symbol dialog.
|
|
|
|
****************************************************************************/
|
|
|
|
#define WIN31
|
|
#include "windows.h"
|
|
#include <port1632.h>
|
|
#include "charmap.h"
|
|
#include "stdlib.h"
|
|
#include "tchar.h"
|
|
#ifdef UNICODE
|
|
#include "wchar.h"
|
|
#else
|
|
#include "stdio.h"
|
|
#endif
|
|
#include "commctrl.h"
|
|
|
|
/*
|
|
* Macros
|
|
*/
|
|
#define FMagData(psycm) ((psycm)->xpMagCurr != 0)
|
|
#define abs(x) (((x) >= 0) ? (x) : (-(x)))
|
|
|
|
/*
|
|
* Useful constants.
|
|
*/
|
|
#define STATUSPOINTSIZE 8 // Point size of status bar font.
|
|
#define DX_BITMAP 20 // Width of TT bitmap.
|
|
#define DY_BITMAP 12 // Height of TT bitmap.
|
|
#define BACKGROUND 0x000000FF // bright blue
|
|
#define BACKGROUNDSEL 0x00FF00FF // bright purple
|
|
#define BUTTONFACE 0x00C0C0C0 // bright grey
|
|
#define BUTTONSHADOW 0x00808080 // dark grey
|
|
|
|
// Font types
|
|
#define PS_OPENTYPE_FONT 0x0001
|
|
#define TT_OPENTYPE_FONT 0x0002
|
|
#define TRUETYPE_FONT 0x0004
|
|
#define TYPE1_FONT 0x0008
|
|
|
|
/*
|
|
* Globals.
|
|
*/
|
|
HANDLE hInst;
|
|
INT cchSymRow = 32; // Number of characters across the character grid.
|
|
INT cchSymCol = 8; // Number of rows in the character grid.
|
|
UTCHAR chSymFirst = 32;
|
|
UTCHAR chSymLast = 255;
|
|
SYCM sycm; // Tons of data need to do char grid painting.
|
|
UINT wCFRichText = 0; // Private clipboard format, rich text format.
|
|
HFONT hFontClipboard = NULL; // Tells us which font is in the clipboard.
|
|
HANDLE hstrClipboard = NULL; // Contains the string which is in the clipboard.
|
|
BOOL fDelClipboardFont = FALSE; // The clipboard font needs to be deleted.
|
|
INT iControl = ID_CHARGRID; // Index indicating which control has focus.
|
|
HBITMAP hbmFont = NULL; // TT bitmap drawn before font facenames in combo.
|
|
LONG lEditSel = 0; // Contains the selection range of the EC.
|
|
HBRUSH hStaticBrush; // Used for static controls during WM_CTLCOLOR
|
|
|
|
//
|
|
// 04 Dec 92 - GregoryW
|
|
// Currently there is no defined
|
|
// interface for querying what character ranges a Unicode font
|
|
// supports. For now this table only has the subsets that contain
|
|
// characters supported by the Lucida Sans Unicode font uncommented.
|
|
// When we get an API that allows querying the font driver for
|
|
// ranges of Unicode characters supported (and whether or not a font
|
|
// is a Unicode font!) then all entries can be uncommented.
|
|
//
|
|
USUBSET aSubsetData[] = {{ 0x0020, 0x00ff, IDS_LATIN1},
|
|
{ 0x0100, 0x017f, IDS_LATINEXA},
|
|
{ 0x0180, 0x024f, IDS_LATINEXB},
|
|
{ 0x0250, 0x02af, IDS_IPAEX},
|
|
{ 0x02b0, 0x02ff, IDS_SPACINGMODIFIERS},
|
|
{ 0x0300, 0x036f, IDS_COMBININGDIACRITICS},
|
|
{ 0x0370, 0x03cf, IDS_BASICGREEK},
|
|
{ 0x03d0, 0x03ff, IDS_GREEKSYMBOLS},
|
|
{ 0x0400, 0x04ff, IDS_CYRILLIC},
|
|
// not supported { 0x0530, 0x058f, IDS_ARMENIAN},
|
|
{ 0x0590, 0x05ff, IDS_HEBREW},
|
|
// not supported { 0x0600, 0x0652, IDS_BASICARABIC},
|
|
// not supported { 0x0653, 0x06ff, IDS_ARABICEX},
|
|
// not supported { 0x0900, 0x097f, IDS_DEVANAGARI},
|
|
// not supported { 0x0980, 0x09ff, IDS_BENGALI},
|
|
// not supported { 0x0a00, 0x0a7f, IDS_GURMUKHI},
|
|
// not supported { 0x0a80, 0x0aff, IDS_GUJARATI},
|
|
// not supported { 0x0b00, 0x0b7f, IDS_ORIYA},
|
|
// not supported { 0x0b80, 0x0bff, IDS_TAMIL},
|
|
// not supported { 0x0c00, 0x0c7f, IDS_TELUGU},
|
|
// not supported { 0x0c80, 0x0cff, IDS_KANNADA},
|
|
// not supported { 0x0d00, 0x0d7f, IDS_MALAYALAM},
|
|
// not supported { 0x0e00, 0x0e7f, IDS_THAI},
|
|
// not supported { 0x0e80, 0x0eff, IDS_LAO},
|
|
// not supported { 0x10d0, 0x10ff, IDS_BASICGEORGIAN},
|
|
// not supported { 0x10a0, 0x10cf, IDS_GEORGIANEX},
|
|
// not supported { 0x1100, 0x11ff, IDS_HANGULJAMO},
|
|
// not supported { 0x1e00, 0x1eff, IDS_LATINEXADDITIONAL},
|
|
// not supported { 0x1f00, 0x1fff, IDS_GREEKEX},
|
|
// not supported { 0x2000, 0x206f, IDS_GENERALPUNCTUATION},
|
|
// not supported { 0x2070, 0x209f, IDS_SUPERANDSUBSCRIPTS},
|
|
{ 0x20a0, 0x20cf, IDS_CURRENCYSYMBOLS},
|
|
// not supported { 0x20d0, 0x20ff, IDS_COMBININGDIACRITICSFORSYMBOLS},
|
|
{ 0x2100, 0x214f, IDS_LETTERLIKESYMBOLS},
|
|
// not supported { 0x2150, 0x218f, IDS_NUMBERFORMS},
|
|
{ 0x2190, 0x21ff, IDS_ARROWS},
|
|
{ 0x2200, 0x22ff, IDS_MATHEMATICALOPS},
|
|
// not supported { 0x2300, 0x23ff, IDS_MISCTECHNICAL},
|
|
// not supported { 0x2400, 0x243f, IDS_CONTROLPICTURES},
|
|
// not supported { 0x2440, 0x245f, IDS_OPTICALCHAR},
|
|
// not supported { 0x2460, 0x24ff, IDS_ENCLOSEDALPHANUM},
|
|
// not supported { 0x2500, 0x257f, IDS_BOXDRAWING},
|
|
// not supported { 0x2580, 0x259f, IDS_BLOCKELEMENTS},
|
|
// not supported { 0x25a0, 0x25ff, IDS_GEOMETRICSHAPES},
|
|
// not supported { 0x2600, 0x26ff, IDS_MISCDINGBATS},
|
|
// not supported { 0x2700, 0x27bf, IDS_DINGBATS},
|
|
// not supported { 0x3000, 0x303f, IDS_CJKSYMBOLSANDPUNC},
|
|
// not supported { 0x3040, 0x309f, IDS_HIRAGANA},
|
|
// not supported { 0x30a0, 0x30ff, IDS_KATAKANA},
|
|
// not supported { 0x3100, 0x312f, IDS_BOPOMOFO},
|
|
// not supported { 0x3130, 0x318f, IDS_HANGULCOMPATIBILITYJAMO},
|
|
// not supported { 0x3190, 0x319f, IDS_CJKMISC},
|
|
// not supported { 0x3200, 0x32ff, IDS_ENCLOSEDCJKLETTERSANDMONTHS},
|
|
// not supported { 0x3300, 0x33ff, IDS_CJKCOMPATIBILITY},
|
|
// not supported { 0x3400, 0x3d2d, IDS_HANGUL},
|
|
// not supported { 0x3d2e, 0x44b7, IDS_HANGULSUPPA},
|
|
// not supported { 0x44b8, 0x4dff, IDS_HANGULSUPPB},
|
|
// not supported { 0x4e00, 0x9fff, IDS_CJKUNIFIEDIDEOGRAPHS},
|
|
// not supported { 0xe000, 0xf8ff, IDS_PRIVATEUSEAREA},
|
|
// not supported { 0xf900, 0xfaff, IDS_CJKCOMPATIBILITYIDEOGRAPHS},
|
|
// not supported { 0xfb00, 0xfb4f, IDS_ALPAHPRESENTATIONFORMS},
|
|
// not supported { 0xfb50, 0xfdff, IDS_ARABICPRESENTATIONFORMSA},
|
|
// not supported { 0xfe30, 0xfe4f, IDS_CJKCOMPFORMS},
|
|
// not supported { 0xfe50, 0xfe6f, IDS_SMALLFORMVARIANTS},
|
|
// not supported { 0xfe70, 0xfefe, IDS_ARABICPRESENTATIONFORMSB},
|
|
// not supported { 0xff00, 0xffef, IDS_HALFANDFULLWIDTHFORMS},
|
|
// not supported { 0xfff0, 0xfffd, IDS_SPECIALS}
|
|
};
|
|
INT cSubsets = sizeof(aSubsetData) / sizeof(USUBSET);
|
|
INT iCurSubset = 0; // index of current Unicode subset - default to Latin-1
|
|
|
|
// Useful window handles.
|
|
HWND hwndDialog;
|
|
HWND hwndCharGrid;
|
|
|
|
// Data used to draw the status bar.
|
|
RECT rcStatusLine; // Bounding rect for status bar.
|
|
RECT rcToolbar[2]; // Bounding rects for toolbars.
|
|
INT dyStatus; // Height of status bar.
|
|
INT dyToolbar[2]; // Height of tool bars.
|
|
INT dxHelpField; // Width of help window.
|
|
INT dxKeystrokeField; // Width of keystroke window.
|
|
TCHAR szKeystrokeText[30]; // Buffer for keystroke text.
|
|
TCHAR szKeystrokeLabel[30]; // Buffer for keystroke label.
|
|
TCHAR szSpace[15]; // Strings for keystroke description.
|
|
TCHAR szCtrl[15];
|
|
TCHAR szCtrlAlt[25];
|
|
TCHAR szShiftCtrlAlt[25];
|
|
TCHAR szAlt[15];
|
|
TCHAR szUnicodeLabel[23]; // Buffer for Unicode label.
|
|
INT iKeystrokeTextStart; // Place to start appending text to above.
|
|
INT iUnicodeLabelStart; // Place to start appending text to above.
|
|
HFONT hfontStatus; // Font used for text of status bar.
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
|
|
|
|
PURPOSE: calls initialization function, processes message loop, cleanup.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
INT PASCAL WinMain(
|
|
HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine,
|
|
int nCmdShow)
|
|
{
|
|
MSG msg;
|
|
|
|
if (!InitApplication(hInstance))
|
|
return (FALSE);
|
|
|
|
InitCommonControls();
|
|
|
|
// Perform initialization for this instance.
|
|
if (!InitInstance(hInstance, nCmdShow)) {
|
|
return (FALSE);
|
|
}
|
|
|
|
while (GetMessage(&msg,
|
|
NULL,
|
|
0,
|
|
0))
|
|
{
|
|
// Filter for possible tabs now to implement context sensitive help.
|
|
if (msg.message == WM_KEYDOWN)
|
|
if (!UpdateHelpText(&msg, NULL))
|
|
continue;
|
|
|
|
// Main message loop.
|
|
if (!IsDialogMessage(hwndDialog, &msg)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
// Free up some stuff.
|
|
if (hfontStatus)
|
|
DeleteObject(hfontStatus);
|
|
if (hbmFont)
|
|
DeleteObject(hbmFont);
|
|
|
|
return (int)(msg.wParam);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: InitApplication(HANDLE)
|
|
|
|
PURPOSE: Initializes window data and registers window class
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
BOOL InitApplication(HANDLE hInstance)
|
|
{
|
|
WNDCLASS wc;
|
|
|
|
/*
|
|
* Register a window class that we will use to draw the character grid
|
|
* into.
|
|
*/
|
|
wc.style = CS_DBLCLKS;
|
|
wc.lpfnWndProc = CharGridWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = TEXT("CharGridWClass");
|
|
|
|
if (!RegisterClass(&wc))
|
|
return (FALSE);
|
|
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = DefDlgProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = DLGWINDOWEXTRA;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDIC_CHARMAP));
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = TEXT("MyDlgClass");
|
|
|
|
if (!RegisterClass(&wc))
|
|
return (FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: InitInstance(HANDLE, int)
|
|
|
|
PURPOSE: Does some initialization and creates main window which is a
|
|
dialog.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
BOOL InitInstance(HANDLE hInstance, INT nCmdShow)
|
|
{
|
|
INT i;
|
|
|
|
// Save the instance handle in a global variable.
|
|
hInst = hInstance;
|
|
|
|
// This font will be used to paint the status line.
|
|
hfontStatus = CreateFont(-PointsToHeight(STATUSPOINTSIZE), 0, 0, 0, 400, 0, 0, 0,
|
|
ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, TEXT("Helv"));
|
|
dyStatus = 2 * PointsToHeight(STATUSPOINTSIZE);
|
|
dyToolbar[0] = 28; /* defined by UI gods */
|
|
dyToolbar[1] = 28; /* defined by UI gods */
|
|
|
|
// Load the Unicode subset names before initializing the main window.
|
|
for (i = 0; i < cSubsets; i++) {
|
|
if (!LoadString(
|
|
hInst,
|
|
aSubsetData[i].StringResId,
|
|
(LPTSTR)aSubsetData[i].Name,
|
|
50)
|
|
)
|
|
return (FALSE);
|
|
}
|
|
|
|
// Create a main window for this application instance.
|
|
if (!(hwndDialog = CreateDialog(hInstance, TEXT("CharMap"), NULL,
|
|
CharMapDlgProc)))
|
|
return (FALSE);
|
|
|
|
/*
|
|
* Initialize some strings used for the Keystroke status bar field.
|
|
*/
|
|
// For international purposes, this string could be length 0.
|
|
LoadString(
|
|
hInst,
|
|
IDS_KEYSTROKE,
|
|
(LPTSTR)szKeystrokeLabel,
|
|
BTOC(sizeof(szKeystrokeLabel))
|
|
);
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_UNICODELABEL,
|
|
(LPTSTR)szUnicodeLabel,
|
|
BTOC(sizeof(szUnicodeLabel))
|
|
))
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_SPACE,
|
|
(LPTSTR)szSpace,
|
|
BTOC(sizeof(szSpace))
|
|
))
|
|
return (FALSE);
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_CTRL,
|
|
(LPTSTR)szCtrl,
|
|
BTOC(sizeof(szCtrl))
|
|
))
|
|
return (FALSE);
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_CTRLALT,
|
|
(LPTSTR)szCtrlAlt,
|
|
BTOC(sizeof(szCtrlAlt))
|
|
))
|
|
return (FALSE);
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_SHIFTCTRLALT,
|
|
(LPTSTR)szShiftCtrlAlt,
|
|
BTOC(sizeof(szShiftCtrlAlt))
|
|
))
|
|
return (FALSE);
|
|
if (!LoadString(
|
|
hInst,
|
|
IDS_ALT,
|
|
(LPTSTR)szAlt,
|
|
BTOC(sizeof(szAlt))
|
|
))
|
|
return (FALSE);
|
|
|
|
// Store the index to where we start adding status line text changes.
|
|
iKeystrokeTextStart = lstrlen(szKeystrokeLabel);
|
|
iUnicodeLabelStart = lstrlen(szUnicodeLabel);
|
|
|
|
/*
|
|
* Initialize keystroke text, make the window visible,
|
|
* update its client area, and return "success".
|
|
*/
|
|
UpdateKeystrokeText(NULL, sycm.chCurr, FALSE);
|
|
ShowWindow(hwndDialog, nCmdShow);
|
|
UpdateWindow(hwndDialog);
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: CharMapDlgProc(HWND, UINT, WPARAM, LPARAM)
|
|
|
|
PURPOSE: Processes messages for the main window.
|
|
|
|
COMMENTS: This window is a dialog box.
|
|
|
|
****************************************************************************/
|
|
|
|
INT_PTR APIENTRY CharMapDlgProc(
|
|
HWND hWnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
switch (message) {
|
|
case WM_CTLCOLORSTATIC:
|
|
{
|
|
POINT point;
|
|
|
|
SetBkColor((HDC)wParam, GetSysColor(COLOR_BTNFACE));
|
|
UnrealizeObject(hStaticBrush);
|
|
point.x = point.y = 0;
|
|
ClientToScreen(hWnd, &point);
|
|
|
|
return((INT_PTR)hStaticBrush);
|
|
break;
|
|
}
|
|
|
|
case WM_INITDIALOG:
|
|
{
|
|
RECT rectParent, rectTopRightControl;
|
|
INT iSubset;
|
|
|
|
/*
|
|
* Create the character grid with dimensions which just fit inside
|
|
* the space allowed in the dialog. When it processes the
|
|
* WM_CREATE message it will be sized and centered more accurately.
|
|
*/
|
|
GetClientRect(hWnd, &rectParent);
|
|
GetWindowRect(GetDlgItem(hWnd, ID_CLOSE), &rectTopRightControl);
|
|
ScreenToClient(hWnd, (LPPOINT)&(rectTopRightControl.left));
|
|
ScreenToClient(hWnd, (LPPOINT)&(rectTopRightControl.right));
|
|
|
|
if (!(hwndCharGrid =
|
|
CreateWindow(
|
|
TEXT("CharGridWClass"),
|
|
NULL,
|
|
WS_CHILD | WS_VISIBLE | WS_TABSTOP,
|
|
1,
|
|
rectParent.top + dyToolbar[0] + dyToolbar[1],
|
|
rectParent.right - 1,
|
|
rectParent.bottom - rectParent.top - dyStatus - dyToolbar[0] - dyToolbar[1] - 1,
|
|
hWnd,
|
|
(HMENU) ID_CHARGRID,
|
|
hInst,
|
|
NULL
|
|
))) {
|
|
DestroyWindow(hWnd);
|
|
break;
|
|
}
|
|
|
|
hStaticBrush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
|
|
|
|
// Initialize the status line data.
|
|
dxHelpField = 22 * rectParent.right / 32;
|
|
dxKeystrokeField = 8 * rectParent.right / 32;
|
|
rcStatusLine = rectParent;
|
|
rcStatusLine.top = rcStatusLine.bottom - dyStatus;
|
|
|
|
// Initialize the toolbars
|
|
rcToolbar[0] = rectParent;
|
|
rcToolbar[0].bottom = rcToolbar[0].top + dyToolbar[0];
|
|
|
|
rcToolbar[1] = rcToolbar[0];
|
|
rcToolbar[1].top = rcToolbar[0].bottom + GetSystemMetrics(SM_CYBORDER);
|
|
rcToolbar[1].bottom = rcToolbar[1].top + dyToolbar[1];
|
|
|
|
// Disable Copy button.
|
|
EnableWindow(GetDlgItem(hWnd, ID_COPY), FALSE);
|
|
|
|
/* fill "Subset" list box */
|
|
for (iSubset = 0; iSubset < cSubsets; iSubset++) {
|
|
SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_ADDSTRING,
|
|
0,
|
|
(LPARAM)aSubsetData[iSubset].Name
|
|
);
|
|
|
|
}
|
|
iCurSubset = SelectInitialSubset(hWnd);
|
|
|
|
}
|
|
|
|
/* fall through to WM_FONTCHANGE */
|
|
case WM_FONTCHANGE:
|
|
{
|
|
HDC hdc = GetDC(hWnd);
|
|
|
|
/*
|
|
* Get the fonts from the system and put them in the font selection
|
|
* combo box.
|
|
*/
|
|
if (message == WM_FONTCHANGE) {
|
|
SaveCurrentFont(hWnd);
|
|
SendDlgItemMessage(hWnd, ID_FONT, CB_RESETCONTENT, 0, 0L);
|
|
}
|
|
|
|
EnumFontFamilies(hdc, NULL, (FONTENUMPROC)FontLoadProc, (LPARAM)hWnd);
|
|
|
|
ReleaseDC(hWnd, hdc);
|
|
|
|
// Setup character dimensions and select this font.
|
|
RecalcCharMap(hWnd, &sycm, SelectInitialFont(hWnd),
|
|
(message == WM_FONTCHANGE));
|
|
SendDlgItemMessage(hWnd, ID_STRING, WM_SETFONT,
|
|
(WPARAM)sycm.hFont, (DWORD)TRUE);
|
|
|
|
if (message == WM_INITDIALOG)
|
|
SetFocus(hwndCharGrid);
|
|
/* fall through to WM_SYSCOLORCHANGE */
|
|
else
|
|
break;
|
|
}
|
|
|
|
case WM_SYSCOLORCHANGE:
|
|
if (hbmFont)
|
|
DeleteObject(hbmFont);
|
|
hbmFont = LoadBitmaps(IDBM_TT);
|
|
DeleteObject(hStaticBrush);
|
|
hStaticBrush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
|
|
break;
|
|
|
|
case WM_PARENTNOTIFY:
|
|
{
|
|
POINTS points;
|
|
DWORD dwMsgPos;
|
|
POINT point;
|
|
|
|
/*
|
|
* We process this message to implement the context sensitive
|
|
* help. Downclicks to controls are found here, the help
|
|
* message is updated in the status bar.
|
|
*/
|
|
// BUG - The parameters with this message are unreliable!
|
|
if (wParam == WM_LBUTTONDOWN) {
|
|
dwMsgPos = GetMessagePos();
|
|
points = MAKEPOINTS(dwMsgPos);
|
|
point.x = points.x;
|
|
point.y = points.y;
|
|
UpdateHelpText(NULL, WindowFromPoint(point));
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
case WM_PAINT:
|
|
|
|
{
|
|
HBRUSH hBrush;
|
|
RECT rcTemp, rectNextButton;
|
|
INT dyBorder, dxBorder;
|
|
PAINTSTRUCT ps;
|
|
HDC hdc;
|
|
|
|
/*
|
|
* This code implements painting of the status bar.
|
|
*/
|
|
hdc = BeginPaint(hWnd, &ps);
|
|
|
|
rcTemp = rcStatusLine;
|
|
|
|
dyBorder = GetSystemMetrics(SM_CYBORDER);
|
|
dxBorder = GetSystemMetrics(SM_CXBORDER);
|
|
|
|
// Make the whole thing grey.
|
|
if (hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE))) {
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
rcTemp.left = rcToolbar[0].left;
|
|
rcTemp.top = rcToolbar[0].top;
|
|
rcTemp.right = rcToolbar[1].right;
|
|
rcTemp.bottom = rcToolbar[1].bottom;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
GetWindowRect(GetDlgItem(hWnd, ID_TOPLEFT), &rectNextButton);
|
|
ScreenToClient(hWnd, (LPPOINT)&(rectNextButton.left));
|
|
ScreenToClient(hWnd, (LPPOINT)&(rectNextButton.right));
|
|
// solid black line across bottom of toolbar
|
|
if (hBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOWFRAME))) {
|
|
rcTemp = rcToolbar[0];
|
|
rcTemp.top = rcTemp.bottom;
|
|
rcTemp.bottom += dyBorder;
|
|
rcTemp.left = rectNextButton.left - 2 - dxBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
rcTemp = rcToolbar[1];
|
|
rcTemp.top = rcTemp.bottom;
|
|
rcTemp.bottom += dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// vertical line
|
|
rcTemp.top = rcToolbar[0].top;
|
|
rcTemp.bottom = rcToolbar[1].bottom;
|
|
rcTemp.left = rectNextButton.left - 2 - dxBorder;
|
|
rcTemp.right = rectNextButton.left - 2;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
if (hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW))) {
|
|
|
|
// Status line top.
|
|
rcTemp.left = 8 * dyBorder;
|
|
rcTemp.right = rcTemp.left + dxHelpField;
|
|
rcTemp.top = rcStatusLine.top + dyBorder * 2;
|
|
rcTemp.bottom = rcTemp.top + dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Keystroke line top.
|
|
rcTemp.right = rcStatusLine.right - 8 * dyBorder;
|
|
rcTemp.left = rcTemp.right - dxKeystrokeField;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Status line left side.
|
|
rcTemp = rcStatusLine;
|
|
rcTemp.left = 8 * dyBorder;
|
|
rcTemp.right = rcTemp.left + dyBorder;
|
|
rcTemp.top += dyBorder * 2;
|
|
rcTemp.bottom -= dyBorder * 2;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Keystroke line left side.
|
|
rcTemp.left = rcStatusLine.right - 9 * dyBorder - dxKeystrokeField;
|
|
rcTemp.right = rcTemp.left + dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
if (hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNHIGHLIGHT))) {
|
|
|
|
// Status line bottom.
|
|
rcTemp.left = 8 * dyBorder;
|
|
rcTemp.right = rcTemp.left + dxHelpField;
|
|
rcTemp.top = rcStatusLine.bottom - 3 * dyBorder;
|
|
rcTemp.bottom = rcTemp.top + dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Keystroke line bottom.
|
|
rcTemp.right = rcStatusLine.right - 8 * dyBorder;
|
|
rcTemp.left = rcTemp.right - dxKeystrokeField;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Status line right side.
|
|
rcTemp = rcStatusLine;
|
|
rcTemp.left = 8 * dyBorder + dxHelpField;
|
|
rcTemp.right = rcTemp.left + dyBorder;
|
|
rcTemp.top += dyBorder * 2;
|
|
rcTemp.bottom -= dyBorder * 2;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
// Keystroke line right side.
|
|
rcTemp.left = rcStatusLine.right - 8 * dyBorder;
|
|
rcTemp.right = rcTemp.left + dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
// solid black line across top
|
|
|
|
if (hBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOWFRAME))) {
|
|
rcTemp = rcStatusLine;
|
|
rcTemp.bottom = rcTemp.top;
|
|
rcTemp.top -= dyBorder;
|
|
FillRect(hdc, &rcTemp, hBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
PaintStatusLine(hdc, TRUE, TRUE);
|
|
|
|
EndPaint(hWnd, &ps);
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
case WM_MEASUREITEM:
|
|
{
|
|
HDC hDC;
|
|
HFONT hFont;
|
|
TEXTMETRIC tm;
|
|
|
|
hDC = GetDC(NULL);
|
|
hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0L);
|
|
if (hFont)
|
|
hFont = SelectObject(hDC, hFont);
|
|
GetTextMetrics(hDC, &tm);
|
|
if (hFont)
|
|
SelectObject(hDC, hFont);
|
|
ReleaseDC(NULL, hDC);
|
|
|
|
((LPMEASUREITEMSTRUCT)lParam)->itemHeight = max(tm.tmHeight, DY_BITMAP);
|
|
break;
|
|
}
|
|
|
|
case WM_DRAWITEM:
|
|
if (((LPDRAWITEMSTRUCT)lParam)->itemID != -1)
|
|
DrawFamilyComboItem((LPDRAWITEMSTRUCT)lParam);
|
|
|
|
break;
|
|
|
|
case WM_ASKCBFORMATNAME:
|
|
LoadString(hInst, IDS_RTF, (LPTSTR)lParam, (UINT)wParam);
|
|
|
|
return (TRUE);
|
|
|
|
case WM_PAINTCLIPBOARD:
|
|
{
|
|
LPPAINTSTRUCT lpPS;
|
|
HANDLE hFont;
|
|
LPTSTR lpstrText;
|
|
|
|
if (hstrClipboard) {
|
|
// Setup.
|
|
lpPS = (LPPAINTSTRUCT)GlobalLock((HANDLE)lParam);
|
|
lpstrText = (LPTSTR)GlobalLock(hstrClipboard);
|
|
|
|
// Lets paint.
|
|
hFont = SelectObject(lpPS->hdc, hFontClipboard);
|
|
TextOut(lpPS->hdc, 0, 0, lpstrText,
|
|
lstrlen(lpstrText));
|
|
SelectObject(lpPS->hdc, hFont);
|
|
|
|
// Cleanup.
|
|
GlobalUnlock(hstrClipboard);
|
|
GlobalUnlock((HANDLE)lParam);
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
case WM_CLOSE:
|
|
DestroyWindow(hWnd);
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
|
|
|
|
case IDCANCEL:
|
|
case ID_CLOSE:
|
|
DestroyWindow(hWnd);
|
|
return (TRUE);
|
|
break;
|
|
|
|
case ID_SELECT:
|
|
SendDlgItemMessage(hWnd, ID_STRING, WM_CHAR,
|
|
(WPARAM)sycm.chCurr, 0L);
|
|
break;
|
|
|
|
case ID_COPY:
|
|
CopyString(hWnd);
|
|
return (TRUE);
|
|
break;
|
|
|
|
case ID_FONT:
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
RecalcCharMap(hWnd, &sycm,
|
|
(INT)SendDlgItemMessage(hWnd, ID_FONT,
|
|
CB_GETCURSEL, 0, 0L),
|
|
TRUE);
|
|
SendDlgItemMessage(hWnd, ID_STRING, WM_SETFONT,
|
|
(WPARAM)sycm.hFont, (DWORD)TRUE);
|
|
} else if (HIWORD(wParam) == CBN_SETFOCUS) {
|
|
// Necessary if hotkey is used to get to the CB.
|
|
UpdateHelpText(NULL, (HWND)lParam);
|
|
}
|
|
|
|
return (TRUE);
|
|
break;
|
|
|
|
case ID_UNICODESUBSET:
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
INT iSubset;
|
|
|
|
iSubset = (INT)SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_GETCURSEL,
|
|
0, 0);
|
|
UpdateSymbolSelection(
|
|
hWnd,
|
|
aSubsetData[iSubset].BeginRange,
|
|
aSubsetData[iSubset].EndRange
|
|
);
|
|
InvalidateRect(hwndCharGrid, NULL, TRUE);
|
|
} else if (HIWORD(wParam) == CBN_SETFOCUS) {
|
|
// Necessary if hotkey is used to get to the CB.
|
|
UpdateHelpText(NULL, (HWND)lParam);
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case ID_NEXTSUBSET:
|
|
{
|
|
INT iCurSelection, iNumEntries;
|
|
|
|
iCurSelection = (INT)SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_GETCURSEL,
|
|
0, 0);
|
|
if (iCurSelection == CB_ERR) {
|
|
return 0;
|
|
}
|
|
iNumEntries = (INT)SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_GETCOUNT,
|
|
0, 0);
|
|
if (iNumEntries == CB_ERR) {
|
|
return 0;
|
|
}
|
|
if (iCurSelection++ < (iNumEntries - 1)) {
|
|
if (iCurSelection == 1) {
|
|
// Enable Previous button
|
|
EnableWindow(GetDlgItem(hWnd, ID_PREVSUBSET), TRUE);
|
|
}
|
|
|
|
SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_SETCURSEL,
|
|
iCurSelection, 0);
|
|
UpdateSymbolSelection(
|
|
hWnd,
|
|
aSubsetData[iCurSelection].BeginRange,
|
|
aSubsetData[iCurSelection].EndRange
|
|
);
|
|
InvalidateRect(hwndCharGrid, NULL, TRUE);
|
|
if (iCurSelection == (iNumEntries - 1)) {
|
|
HWND hwndButton;
|
|
|
|
EnableWindow(GetDlgItem(hWnd, ID_NEXTSUBSET), FALSE);
|
|
//
|
|
// Only reset the button style and focus if
|
|
// the "Next" button currently has it.
|
|
//
|
|
if (iControl == ID_NEXTSUBSET) {
|
|
SendDlgItemMessage(hwndDialog, ID_PREVSUBSET,
|
|
BM_SETSTYLE, BS_DEFPUSHBUTTON, 1);
|
|
SendDlgItemMessage(hwndDialog, ID_NEXTSUBSET,
|
|
BM_SETSTYLE, BS_PUSHBUTTON, 1);
|
|
hwndButton = GetDlgItem(hWnd, ID_PREVSUBSET);
|
|
SetFocus(hwndButton);
|
|
UpdateHelpText(NULL, hwndButton);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case ID_PREVSUBSET:
|
|
{
|
|
INT iCurSelection;
|
|
|
|
iCurSelection = (INT)SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_GETCURSEL,
|
|
0, 0);
|
|
if (iCurSelection == CB_ERR) {
|
|
return 0;
|
|
}
|
|
if (iCurSelection > 0) {
|
|
iCurSelection--;
|
|
|
|
if (iCurSelection == (cSubsets - 2)) {
|
|
// Enable Next button
|
|
EnableWindow(GetDlgItem(hWnd, ID_NEXTSUBSET), TRUE);
|
|
}
|
|
|
|
SendDlgItemMessage(
|
|
hWnd,
|
|
ID_UNICODESUBSET,
|
|
CB_SETCURSEL,
|
|
iCurSelection, 0);
|
|
UpdateSymbolSelection(
|
|
hWnd,
|
|
aSubsetData[iCurSelection].BeginRange,
|
|
aSubsetData[iCurSelection].EndRange
|
|
);
|
|
InvalidateRect(hwndCharGrid, NULL, TRUE);
|
|
if (iCurSelection == 0) {
|
|
HWND hwndButton;
|
|
|
|
EnableWindow(GetDlgItem(hWnd, ID_PREVSUBSET), FALSE);
|
|
//
|
|
// Only reset the button style and focus if
|
|
// the "Previous" button currently has it.
|
|
//
|
|
if (iControl == ID_PREVSUBSET) {
|
|
SendDlgItemMessage(hwndDialog, ID_NEXTSUBSET,
|
|
BM_SETSTYLE, BS_DEFPUSHBUTTON, 1);
|
|
SendDlgItemMessage(hwndDialog, ID_PREVSUBSET,
|
|
BM_SETSTYLE, BS_PUSHBUTTON, 1);
|
|
hwndButton = GetDlgItem(hWnd, ID_NEXTSUBSET);
|
|
SetFocus(hwndButton);
|
|
UpdateHelpText(NULL, hwndButton);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case ID_STRING:
|
|
if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
// Necessary if hotkey is used to get to the EC.
|
|
UpdateHelpText(NULL, (HWND)lParam);
|
|
} else if (HIWORD(wParam) == EN_CHANGE) {
|
|
// Disable Copy button if there are no chars in EC.
|
|
INT iLength;
|
|
|
|
iLength = GetWindowTextLength((HWND)lParam);
|
|
EnableWindow(GetDlgItem(hWnd, ID_COPY), (BOOL)iLength);
|
|
}
|
|
|
|
break;
|
|
|
|
case ID_HELP:
|
|
DoHelp(hWnd, TRUE);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
SaveCurrentFont(hWnd);
|
|
SaveCurrentSubset(hWnd);
|
|
DoHelp(hWnd, FALSE);
|
|
DeleteObject(hStaticBrush);
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
case WM_ACTIVATEAPP:
|
|
if (wParam) {
|
|
SendDlgItemMessage(hWnd, ID_STRING, EM_SETSEL, LOWORD(lEditSel), HIWORD(lEditSel));
|
|
} else {
|
|
lEditSel = (LONG)SendDlgItemMessage(hWnd, ID_STRING, EM_GETSEL, 0, 0L);
|
|
SendDlgItemMessage(hWnd, ID_STRING, EM_SETSEL, 0, 0L);
|
|
}
|
|
break;
|
|
|
|
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: CharGridWndProc(HWND, UINT, WPARAM, LPARAM)
|
|
|
|
PURPOSE: Processes messages for the character grid window.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
LRESULT APIENTRY CharGridWndProc(
|
|
HWND hWnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
|
|
switch (message) {
|
|
case WM_CREATE:
|
|
{
|
|
RECT rect;
|
|
HDC hdcScrn;
|
|
POINT point1, point2;
|
|
|
|
// Setup global.
|
|
hwndCharGrid = hWnd;
|
|
|
|
GetClientRect(hWnd, &rect);
|
|
|
|
/*
|
|
* Calculate metrics for the character grid and the
|
|
* magnify window.
|
|
*/
|
|
sycm.dxpBox = (rect.right-1) / (cchSymRow + 1);
|
|
sycm.dypBox = (rect.bottom-2) / (cchSymCol + 1);
|
|
sycm.dxpCM = sycm.dxpBox * cchSymRow+1;
|
|
sycm.dypCM = sycm.dypBox * cchSymCol+1; // space inside for border
|
|
|
|
sycm.dxpMag = sycm.dxpBox * 2 + 4; // twice the size + 2 bit border
|
|
sycm.dypMag = sycm.dypBox * 2 + 4;
|
|
|
|
sycm.chCurr = chSymFirst;
|
|
sycm.hFontMag = NULL;
|
|
sycm.hFont = NULL;
|
|
sycm.hdcMag = NULL;
|
|
sycm.hbmMag = NULL;
|
|
sycm.ypDest = 0;
|
|
|
|
sycm.fFocusState = sycm.fMouseDn = sycm.fCursorOff = FALSE;
|
|
|
|
// Size the window precisely so the grid fits and is centered.
|
|
MoveWindow(hWnd, (rect.right - sycm.dxpCM + 1) / 2,
|
|
(rect.bottom - sycm.dypCM + 1) / 2 + ((LPCREATESTRUCT)lParam)->y - 2,
|
|
sycm.dxpCM + 2,
|
|
sycm.dypCM + 2,
|
|
FALSE);
|
|
|
|
/*
|
|
* Figure out what the offsets are between the dialog
|
|
* and the character grid window.
|
|
*/
|
|
point1.x = point1.y = point2.x = point2.y = 0;
|
|
ClientToScreen(hWnd, &point1);
|
|
ClientToScreen(((LPCREATESTRUCT)lParam)->hwndParent, &point2);
|
|
sycm.xpCM = (point1.x - point2.x) - (sycm.dxpMag - sycm.dxpBox) / 2;
|
|
sycm.ypCM = (point1.y - point2.y) - (sycm.dypMag - sycm.dypBox) / 2;
|
|
|
|
|
|
// Create dc and bitmap for the magnify window.
|
|
if ((hdcScrn = GetWindowDC(hWnd)) != NULL)
|
|
{
|
|
if ((sycm.hdcMag = CreateCompatibleDC(hdcScrn)) != NULL)
|
|
{
|
|
SetTextColor(sycm.hdcMag,
|
|
GetSysColor(COLOR_WINDOWTEXT));
|
|
SetBkColor(sycm.hdcMag,
|
|
GetSysColor(COLOR_WINDOW));
|
|
SetBkMode(sycm.hdcMag, OPAQUE);
|
|
if ((sycm.hbmMag = CreateCompatibleBitmap(hdcScrn,
|
|
sycm.dxpMag, sycm.dypMag*2)) == NULL)
|
|
{
|
|
DeleteObject(sycm.hdcMag);
|
|
}
|
|
else
|
|
{
|
|
SelectObject(sycm.hdcMag, sycm.hbmMag);
|
|
}
|
|
}
|
|
ReleaseDC(hWnd, hdcScrn);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
if (sycm.fMouseDn)
|
|
ExitMagnify(hWnd, &sycm);
|
|
if (fDelClipboardFont)
|
|
DeleteObject(hFontClipboard);
|
|
if (sycm.hFont != NULL)
|
|
DeleteObject(sycm.hFont);
|
|
if (sycm.hFontMag != NULL)
|
|
DeleteObject(sycm.hFontMag);
|
|
if (sycm.hdcMag != NULL)
|
|
DeleteDC(sycm.hdcMag);
|
|
if (sycm.hbmMag != NULL)
|
|
DeleteObject(sycm.hbmMag);
|
|
break;
|
|
|
|
case WM_SETFOCUS:
|
|
case WM_KILLFOCUS:
|
|
RestoreSymMag(&sycm);
|
|
DrawSymChOutlineHwnd(&sycm, hWnd, sycm.chCurr, TRUE, message == WM_SETFOCUS);
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
RECT rect;
|
|
|
|
// Don't draw anything if there's an update region pending.
|
|
if (GetUpdateRect(hWnd, (LPRECT)&rect, FALSE) != 0)
|
|
break;
|
|
|
|
SetFocus(hWnd);
|
|
SetCapture(hWnd);
|
|
|
|
sycm.fMouseDn = TRUE;
|
|
|
|
if (!FMagData(&sycm))
|
|
DrawSymChOutlineHwnd(&sycm, hWnd, sycm.chCurr, FALSE, FALSE);
|
|
|
|
}
|
|
|
|
// Fall through to WM_MOUSEMOVE
|
|
|
|
case WM_MOUSEMOVE:
|
|
if (sycm.fMouseDn) {
|
|
POINT pt;
|
|
UTCHAR chMouseSymbol;
|
|
|
|
pt.x = LOWORD(lParam);
|
|
pt.y = HIWORD(lParam);
|
|
ClientToScreen(hWnd, (LPPOINT)&pt);
|
|
if (WindowFromPoint(pt) == hWnd) {
|
|
ScreenToClient(hWnd, (LPPOINT)&pt);
|
|
// convert back to a 'points'-like thing
|
|
lParam = MAKELONG((WORD)pt.x, (WORD)pt.y);
|
|
chMouseSymbol = (UTCHAR)ChFromSymLParam(&sycm, lParam);
|
|
if (chMouseSymbol > chSymLast) {
|
|
//
|
|
// We're outside of current character range (but still
|
|
// within the grid). Restore cursor and leave
|
|
// magnified character.
|
|
//
|
|
if (sycm.fCursorOff) {
|
|
sycm.fCursorOff = FALSE;
|
|
ShowCursor(TRUE);
|
|
}
|
|
} else {
|
|
//
|
|
// We're in the grid and within the range of currently
|
|
// displayed characters, display magnified character.
|
|
//
|
|
if (!sycm.fCursorOff) {
|
|
sycm.fCursorOff = TRUE;
|
|
ShowCursor(FALSE);
|
|
}
|
|
MoveSymbolSel(&sycm, chMouseSymbol);
|
|
}
|
|
} else {
|
|
// Left grid, leave magnified character and restore cursor.
|
|
if (sycm.fCursorOff) {
|
|
sycm.fCursorOff = FALSE;
|
|
ShowCursor(TRUE);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_CANCELMODE:
|
|
case WM_LBUTTONUP:
|
|
if (sycm.fMouseDn)
|
|
ExitMagnify(hWnd, &sycm);
|
|
|
|
break;
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
// Send this character to the entry field.
|
|
SendDlgItemMessage(hwndDialog, ID_STRING, WM_CHAR,
|
|
(WPARAM)sycm.chCurr, 0L);
|
|
break;
|
|
|
|
case WM_GETDLGCODE:
|
|
// Necessary to obtain arrow and tab messages.
|
|
return (DLGC_WANTARROWS | DLGC_WANTCHARS);
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
{
|
|
UTCHAR chNew = sycm.chCurr;
|
|
|
|
if (sycm.fMouseDn)
|
|
break;
|
|
|
|
switch (wParam)
|
|
{
|
|
case VK_LEFT:
|
|
if (--chNew < chSymFirst)
|
|
return 0L;
|
|
break;
|
|
|
|
case VK_UP:
|
|
if ((chNew -= (UTCHAR)cchSymRow) < chSymFirst)
|
|
return 0L;
|
|
break;
|
|
|
|
case VK_RIGHT:
|
|
if (++chNew > chSymLast)
|
|
return 0L;
|
|
break;
|
|
|
|
case VK_DOWN:
|
|
if ((chNew += (UTCHAR)cchSymRow) > chSymLast)
|
|
return 0L;
|
|
break;
|
|
|
|
default:
|
|
return 0L;
|
|
} /* switch (wParam) */
|
|
|
|
if (!FMagData(&sycm))
|
|
DrawSymChOutlineHwnd(&sycm, hWnd, sycm.chCurr, FALSE, FALSE);
|
|
MoveSymbolSel(&sycm, (UTCHAR)chNew);
|
|
}
|
|
break;
|
|
|
|
case WM_CHAR:
|
|
if (sycm.fMouseDn)
|
|
break;
|
|
|
|
if (wParam >= chSymFirst && wParam <= chSymLast) {
|
|
if (!FMagData(&sycm))
|
|
DrawSymChOutlineHwnd(&sycm, hWnd, sycm.chCurr, FALSE, FALSE);
|
|
MoveSymbolSel(&sycm, (UTCHAR) wParam);
|
|
SendDlgItemMessage(hwndDialog, ID_STRING, WM_CHAR,
|
|
(WPARAM)sycm.chCurr, 0L);
|
|
}
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
hdc = BeginPaint(hWnd, &ps);
|
|
DrawSymbolMap(&sycm, hdc);
|
|
EndPaint(hWnd, &ps);
|
|
return (TRUE);
|
|
}
|
|
|
|
default: /* Passes it on if unproccessed */
|
|
return (DefWindowProc(hWnd, message, wParam, lParam));
|
|
}
|
|
return 0L;
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: ChFromSymLParam(PSYCM, LPARAM)
|
|
|
|
PURPOSE: Determine the character to select from the mouse
|
|
position (lParam)
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
INT ChFromSymLParam(
|
|
PSYCM psycm,
|
|
LPARAM lParam)
|
|
{
|
|
return min(cchSymRow-1, max(0, ((INT) LOWORD(lParam)-1) / psycm->dxpBox))
|
|
+ min(cchSymCol-1, max(0, ((INT) HIWORD(lParam)-1) / psycm->dypBox))
|
|
* cchSymRow + chSymFirst;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawSymChOutlineHwnd(PSYCM, HWND, UTCHAR, BOOL, BOOL);
|
|
|
|
PURPOSE: Gets a DC for hwnd, calls DrawSymChOutline.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawSymChOutlineHwnd(
|
|
PSYCM psycm,
|
|
HWND hwnd,
|
|
UTCHAR ch,
|
|
BOOL fVisible,
|
|
BOOL fFocus)
|
|
{
|
|
HDC hdc = GetDC(hwnd);
|
|
DrawSymChOutline(psycm, hdc, ch, fVisible, fFocus);
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: RecalcCharMap(HWND, PSYCM, int, BOOL);
|
|
|
|
PURPOSE: Recalculate fixed character map data (font info, sizes, etc.)
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID RecalcCharMap(
|
|
HWND hwndDlg,
|
|
PSYCM psycm,
|
|
INT iCombo,
|
|
BOOL fRedraw)
|
|
{
|
|
HDC hdc;
|
|
TEXTMETRIC tm;
|
|
UINT ch;
|
|
LPINT lpdxp;
|
|
HFONT hFont;
|
|
LOGFONT LogFont;
|
|
|
|
// Get rid of the old font handles.
|
|
if (hFontClipboard && hFontClipboard == psycm->hFont)
|
|
fDelClipboardFont = TRUE;
|
|
if (psycm->hFont && hFontClipboard != psycm->hFont)
|
|
DeleteObject(psycm->hFont);
|
|
if (psycm->hFontMag)
|
|
DeleteObject(psycm->hFontMag);
|
|
|
|
hdc = GetDC(hwndCharGrid);
|
|
|
|
/*
|
|
* Set up the LogFont structure.
|
|
*/
|
|
// Make sure it fits in the grid.
|
|
LogFont.lfHeight = psycm->dypBox - 3; // Allow for whitespace.
|
|
// Set these guys to zero.
|
|
LogFont.lfWidth = LogFont.lfEscapement = LogFont.lfOrientation =
|
|
LogFont.lfWeight = 0;
|
|
// Set these at zero too.
|
|
LogFont.lfItalic = LogFont.lfUnderline = LogFont.lfStrikeOut =
|
|
LogFont.lfOutPrecision = LogFont.lfClipPrecision =
|
|
LogFont.lfQuality = LogFont.lfPitchAndFamily = 0;
|
|
// Let the facename and size define the font.
|
|
LogFont.lfCharSet = ANSI_CHARSET;
|
|
// Get the facename from the combo box.
|
|
SendDlgItemMessage(hwndDlg, ID_FONT, CB_GETLBTEXT, iCombo,
|
|
(LPARAM)(LPTSTR)LogFont.lfFaceName);
|
|
|
|
/*
|
|
* 27 Oct 92 GregoryW
|
|
* For now we don't have a way to determine if this is a
|
|
* Unicode font or an ANSI font. The best we can do is
|
|
* look at the face name to see if it is the one Unicode
|
|
* font we recognize.
|
|
*/
|
|
if (!lstrcmpi(LogFont.lfFaceName, TEXT("Lucida Sans Unicode"))) {
|
|
LONG iCurSel;
|
|
|
|
psycm->fAnsiFont = FALSE;
|
|
// Enable Block listbox and set defaults appropriately.
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_UNICODESUBSET), TRUE);
|
|
iCurSel = (LONG)SendDlgItemMessage(
|
|
hwndDlg,
|
|
ID_UNICODESUBSET,
|
|
CB_GETCURSEL,
|
|
0,
|
|
0L
|
|
);
|
|
UpdateSymbolSelection(
|
|
hwndDlg,
|
|
aSubsetData[iCurSel].BeginRange,
|
|
aSubsetData[iCurSel].EndRange
|
|
);
|
|
// Enable Previous button if not on first subset.
|
|
if (iCurSel > 0) {
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_PREVSUBSET), TRUE);
|
|
} else {
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_PREVSUBSET), FALSE);
|
|
}
|
|
// Enable Next button if not on last subset.
|
|
if (iCurSel < (cSubsets - 1)) {
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_NEXTSUBSET), TRUE);
|
|
} else {
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_NEXTSUBSET), FALSE);
|
|
}
|
|
} else {
|
|
// put back the ANSI defaults and disable Unicode Block listbox
|
|
psycm->fAnsiFont = TRUE;
|
|
UpdateSymbolSelection(hwndDlg, 32, 255);
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_UNICODESUBSET), FALSE);
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_NEXTSUBSET), FALSE);
|
|
EnableWindow(GetDlgItem(hwndDlg, ID_PREVSUBSET), FALSE);
|
|
}
|
|
|
|
// Create the font.
|
|
psycm->hFont = CreateFontIndirect(&LogFont);
|
|
hFont = SelectObject(hdc, psycm->hFont);
|
|
|
|
// Create the magnify font.
|
|
LogFont.lfHeight = psycm->dypMag - 5; // Allow for whitespace.
|
|
psycm->hFontMag = CreateFontIndirect(&LogFont);
|
|
|
|
/*
|
|
* Calculate new values and place in window data structure.
|
|
*/
|
|
GetTextMetrics(hdc, &tm);
|
|
psycm->xpCh = 2;
|
|
psycm->ypCh = (4 + psycm->dypBox - tm.tmHeight) / 2;
|
|
|
|
lpdxp = (LPINT) psycm->rgdxp;
|
|
|
|
GetCharWidth(hdc, chSymFirst, chSymLast, lpdxp);
|
|
|
|
SelectObject(hdc, hFont);
|
|
|
|
for (ch = (UINT) chSymFirst; ch <= (UINT) chSymLast; ch++, lpdxp++)
|
|
{
|
|
*lpdxp = (psycm->dxpBox - *lpdxp) / 2 - 1;
|
|
}
|
|
ReleaseDC(hwndCharGrid, hdc);
|
|
|
|
psycm->xpMagCurr = 0; // No magnification data
|
|
|
|
if (fRedraw)
|
|
InvalidateRect(hwndCharGrid, NULL, TRUE);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawSymbolMap(PSYCM, HDC);
|
|
|
|
PURPOSE: Draw all of the pieces of the symbol character map
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawSymbolMap(
|
|
PSYCM psycm,
|
|
HDC hdc)
|
|
{
|
|
BOOL fFocus;
|
|
|
|
DrawSymbolGrid(psycm, hdc);
|
|
DrawSymbolChars(psycm, hdc);
|
|
/*
|
|
* We need to force the focus rect to paint if we have the focus
|
|
* since the old focus rect has been drawn over already.
|
|
*/
|
|
if (fFocus = psycm->fFocusState)
|
|
psycm->fFocusState = FALSE;
|
|
DrawSymChOutline(psycm, hdc, psycm->chCurr, TRUE, fFocus);
|
|
}
|
|
|
|
|
|
void MoveTo(HDC hdc, int x, int y){
|
|
|
|
MoveToEx(hdc, x, y, NULL);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawSymbolGrid(PSYCM, HDC);
|
|
|
|
PURPOSE: Draw the symbol character map grid.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawSymbolGrid(
|
|
PSYCM psycm,
|
|
HDC hdc)
|
|
{
|
|
INT cli; /* Count of lines */
|
|
INT xp, yp;
|
|
INT dxpBox = psycm->dxpBox;
|
|
INT dypBox = psycm->dypBox;
|
|
HPEN hpenOld;
|
|
|
|
hpenOld = SelectObject(hdc, CreatePen(PS_SOLID, 1,
|
|
GetSysColor(COLOR_WINDOWFRAME)));
|
|
|
|
// Draw horizontal lines.
|
|
xp = psycm->dxpCM + 1;
|
|
yp = 1;
|
|
cli = cchSymCol+1;
|
|
while (cli--)
|
|
{
|
|
MoveTo(hdc, 1, yp);
|
|
LineTo(hdc, xp, yp);
|
|
yp += dypBox;
|
|
}
|
|
|
|
// Draw vertical lines.
|
|
yp = psycm->dypCM;
|
|
xp = 1;
|
|
cli = cchSymRow+1;
|
|
while (cli--)
|
|
{
|
|
MoveTo(hdc, xp, 1);
|
|
LineTo(hdc, xp, yp);
|
|
xp += dxpBox;
|
|
}
|
|
|
|
DeleteObject(SelectObject(hdc, hpenOld));
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawSymbolChars(PSYCM, HDC);
|
|
|
|
PURPOSE: Draw the symbol character map.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawSymbolChars(
|
|
PSYCM psycm,
|
|
HDC hdc)
|
|
{
|
|
INT dxpBox = psycm->dxpBox;
|
|
INT dypBox = psycm->dypBox;
|
|
|
|
INT cch;
|
|
INT x, y;
|
|
INT yp;
|
|
TCHAR ch;
|
|
|
|
HFONT hFontOld;
|
|
|
|
RECT rect;
|
|
LPRECT lprect = (LPRECT) ▭
|
|
LPINT lpdxp;
|
|
|
|
// Setup the font and colors.
|
|
hFontOld = (HFONT) SelectObject(hdc, psycm->hFont);
|
|
SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
|
|
SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
|
|
SetBkMode(hdc, OPAQUE);
|
|
|
|
// Draw characters.
|
|
cch = 1;
|
|
ch = chSymFirst;
|
|
|
|
lpdxp = (LPINT) psycm->rgdxp;
|
|
|
|
rect.top = 2;
|
|
yp = psycm->ypCh;
|
|
rect.bottom = rect.top + dypBox - 1;
|
|
|
|
for (y = 0; y++ < cchSymCol;)
|
|
{
|
|
rect.left = psycm->xpCh;
|
|
rect.right = rect.left + dxpBox - 1;
|
|
for (x = 0; x++ < cchSymRow && ch <= chSymLast;)
|
|
{
|
|
if (psycm->fAnsiFont) {
|
|
ExtTextOutA(hdc, rect.left + (*lpdxp++), yp,
|
|
ETO_OPAQUE | ETO_CLIPPED, lprect, &(CHAR)ch, 1, NULL);
|
|
} else
|
|
ExtTextOutW(hdc, rect.left + (*lpdxp++), yp,
|
|
ETO_OPAQUE | ETO_CLIPPED, lprect, &ch, 1, NULL);
|
|
ch++;
|
|
rect.left += dxpBox;
|
|
rect.right += dxpBox;
|
|
}
|
|
yp += dypBox;
|
|
rect.top += dypBox;
|
|
rect.bottom += dypBox;
|
|
}
|
|
|
|
SelectObject(hdc, hFontOld);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawSymChOutline(PSYCM, HDC, UTCHAR, BOOL, BOOL);
|
|
|
|
PURPOSE: Draw an outline around the symbol in the character map
|
|
|
|
COMMENTS: If fVisible, draw outline else erase it.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawSymChOutline(
|
|
PSYCM psycm,
|
|
HDC hdc,
|
|
UTCHAR ch,
|
|
BOOL fVisible,
|
|
BOOL fFocus)
|
|
{
|
|
HBRUSH hbrOld;
|
|
RECT rc;
|
|
INT dxpBox = psycm->dxpBox;
|
|
INT dypBox = psycm->dypBox;
|
|
|
|
hbrOld = SelectObject(hdc,
|
|
CreateSolidBrush(GetSysColor(fVisible ?
|
|
COLOR_WINDOWFRAME :
|
|
COLOR_WINDOW)));
|
|
ch -= chSymFirst;
|
|
|
|
rc.left = (ch % cchSymRow) * dxpBox +2;
|
|
rc.right = rc.left + dxpBox -1;
|
|
rc.top = (ch / cchSymRow) * dypBox +2;
|
|
rc.bottom = rc.top + dypBox -1;
|
|
|
|
// Draw selection rectangle.
|
|
PatBlt( hdc, rc.left, rc.top-2, dxpBox-1, 1, PATCOPY);
|
|
PatBlt( hdc, rc.left, rc.bottom+1, dxpBox-1, 1, PATCOPY);
|
|
PatBlt( hdc, rc.left-2, rc.top, 1, dypBox-1, PATCOPY);
|
|
PatBlt( hdc, rc.right+1, rc.top, 1, dypBox-1, PATCOPY);
|
|
|
|
DeleteObject(SelectObject(hdc, GetStockObject(NULL_BRUSH)));
|
|
|
|
// Deal with the focus rectangle.
|
|
if (fFocus != psycm->fFocusState) {
|
|
DrawFocusRect(hdc, &rc);
|
|
psycm->fFocusState = fFocus;
|
|
}
|
|
|
|
SelectObject(hdc, hbrOld);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: MoveSymbolSel(PSYCM, UTCHAR);
|
|
|
|
PURPOSE: Change the current symbol selection. Handles drawing of
|
|
magnified characters.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID MoveSymbolSel(
|
|
PSYCM psycm,
|
|
UTCHAR chNew)
|
|
{
|
|
HDC hdc;
|
|
HDC hdcMag = psycm->hdcMag;
|
|
RECT rc;
|
|
HFONT hFontOld;
|
|
HFONT hFontMag; // old font in memory dc
|
|
HPEN hpenOld;
|
|
|
|
UTCHAR chNorm = chNew - chSymFirst + 32;
|
|
INT dxpMag = psycm->dxpMag; // for quick reference
|
|
INT dypMag = psycm->dypMag;
|
|
INT ypMemSrc = psycm->ypDest;
|
|
INT ypMemDest = ypMemSrc ^ dypMag;
|
|
INT xpCurr = psycm->xpMagCurr;
|
|
INT ypCurr = psycm->ypMagCurr;
|
|
INT xpNew = psycm->xpCM + (psycm->dxpBox * (chNorm % cchSymRow));
|
|
INT ypNew = psycm->ypCM + (psycm->dypBox * ((chNorm / cchSymRow) - 1));
|
|
INT dxpCh; // width of extra character space (used to center char in box)
|
|
INT dypCh;
|
|
|
|
if (((chNew == (UTCHAR)psycm->chCurr) && FMagData(psycm)))
|
|
return;
|
|
|
|
/*
|
|
* Don't draw a magnified character if the char grid has an update
|
|
* region or is not visible.
|
|
*/
|
|
if (!IsWindowVisible(hwndCharGrid) || GetUpdateRect(hwndCharGrid, &rc, FALSE))
|
|
return;
|
|
|
|
hdc = GetDC(hwndDialog);
|
|
|
|
// Setup the magnified font character.
|
|
hFontMag = SelectObject(hdcMag, psycm->hFontMag);
|
|
{ SIZE sz;
|
|
GetTextExtentPoint(hdcMag, &chNew, 1, &sz);
|
|
|
|
dxpCh = (dxpMag - (INT)sz.cx) / 2 - 1;
|
|
dypCh = (dypMag - (INT)sz.cy) / 2 - 1;
|
|
}
|
|
hpenOld = SelectObject(hdc, CreatePen(PS_SOLID, 1,
|
|
GetSysColor(COLOR_WINDOWFRAME)));
|
|
hFontOld = SelectObject(hdc, psycm->hFontMag);
|
|
|
|
// Copy screen data to offscreen bitmap.
|
|
BitBlt(hdcMag, 0, ypMemDest, dxpMag, dypMag, hdc, xpNew, ypNew, SRCCOPY);
|
|
|
|
// Setup DC.
|
|
SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
|
|
SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
|
|
SetBkMode(hdc, OPAQUE);
|
|
|
|
if (FMagData(psycm))
|
|
{
|
|
INT xpT = xpNew - xpCurr; // point of overlap in offscreen data
|
|
INT ypT = ypNew - ypCurr;
|
|
INT dxpT = dxpMag - abs(xpT); // size of overlap
|
|
INT dypT = dypMag - abs(ypT);
|
|
|
|
if ((dxpT > 0) && (dypT > 0))
|
|
{
|
|
INT xpTmax, ypTmax; // max(0, xpT);
|
|
INT xpTmin, ypTmin; // min(0, xpT);
|
|
INT xpTnmin, ypTnmin; // min(0, -xpT);
|
|
|
|
if (xpT < 0)
|
|
{
|
|
xpTnmin = - (xpTmin = xpT);
|
|
xpTmax = 0;
|
|
}
|
|
else
|
|
{
|
|
xpTmax = xpT;
|
|
xpTnmin = xpTmin = 0;
|
|
}
|
|
if (ypT < 0)
|
|
{
|
|
ypTnmin = - (ypTmin = ypT);
|
|
ypTmax = 0;
|
|
}
|
|
else
|
|
{
|
|
ypTmax = ypT;
|
|
ypTnmin = ypTmin = 0;
|
|
}
|
|
|
|
rc.left = xpTmax;
|
|
rc.right = xpTmin + dxpMag;
|
|
rc.top = ypTmax + ypMemSrc;
|
|
rc.bottom= ypTmin + dypMag + ypMemSrc;
|
|
|
|
// Copy overlapping offscreen data.
|
|
BitBlt(hdcMag, xpTnmin, ypTnmin + ypMemDest, dxpT, dypT,
|
|
hdcMag, xpTmax, ypTmax + ypMemSrc, SRCCOPY);
|
|
|
|
// Print part of char over old screen data.
|
|
if (psycm->fAnsiFont) {
|
|
ExtTextOutA(hdcMag, xpT + dxpCh, ypT + dypCh + ypMemSrc,
|
|
ETO_OPAQUE | ETO_CLIPPED, (LPRECT) &rc, &(CHAR)chNew, 1, NULL);
|
|
} else
|
|
ExtTextOutW(hdcMag, xpT + dxpCh, ypT + dypCh + ypMemSrc,
|
|
ETO_OPAQUE | ETO_CLIPPED, (LPRECT) &rc, &chNew, 1, NULL);
|
|
|
|
}
|
|
|
|
// Restore old screen data.
|
|
BitBlt(hdc, xpCurr, ypCurr, dxpMag, dypMag, hdcMag, 0, ypMemSrc, SRCCOPY);
|
|
|
|
}
|
|
|
|
rc.right = (psycm->xpMagCurr = rc.left = xpNew) + dxpMag - 2;
|
|
rc.bottom = (psycm->ypMagCurr = rc.top = ypNew) + dypMag - 2;
|
|
|
|
|
|
// The rectangle.
|
|
MoveTo(hdc, rc.left, rc.top);
|
|
LineTo(hdc, rc.left, rc.bottom - 1);
|
|
LineTo(hdc, rc.right - 1, rc.bottom - 1);
|
|
LineTo(hdc, rc.right - 1, rc.top);
|
|
LineTo(hdc, rc.left, rc.top);
|
|
|
|
// The shadow.
|
|
MoveTo(hdc, rc.right, rc.top + 1);
|
|
LineTo(hdc, rc.right, rc.bottom);
|
|
LineTo(hdc, rc.left, rc.bottom);
|
|
MoveTo(hdc, rc.right + 1, rc.top + 2);
|
|
LineTo(hdc, rc.right + 1, rc.bottom + 1);
|
|
LineTo(hdc, rc.left + 1, rc.bottom + 1);
|
|
|
|
rc.left++;
|
|
rc.top++;
|
|
rc.right--;
|
|
rc.bottom--;
|
|
|
|
// Draw magnified character on screen.
|
|
if (psycm->fAnsiFont) {
|
|
ExtTextOutA(hdc, xpNew + dxpCh, ypNew + dypCh,
|
|
ETO_OPAQUE | ETO_CLIPPED, (LPRECT) &rc, &(CHAR)chNew, 1, NULL);
|
|
} else
|
|
ExtTextOutW(hdc, xpNew + dxpCh, ypNew + dypCh,
|
|
ETO_OPAQUE | ETO_CLIPPED, (LPRECT) &rc, &chNew, 1, NULL);
|
|
|
|
psycm->ypDest = ypMemDest;
|
|
|
|
DeleteObject(SelectObject(hdc, hpenOld));
|
|
SelectObject(hdc, hFontOld);
|
|
SelectObject(hdcMag, hFontMag);
|
|
|
|
UpdateKeystrokeText(hdc, chNew, TRUE);
|
|
|
|
ReleaseDC(hwndDialog, hdc);
|
|
|
|
psycm->chCurr = chNew;
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: RestoreSymMag(PSYCM);
|
|
|
|
PURPOSE: Restore the screen data under the magnifier.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID RestoreSymMag(
|
|
PSYCM psycm)
|
|
{
|
|
|
|
if (FMagData(psycm))
|
|
{
|
|
HDC hdc = GetDC(hwndDialog);
|
|
|
|
BitBlt(hdc, psycm->xpMagCurr, psycm->ypMagCurr,
|
|
psycm->dxpMag, psycm->dypMag,
|
|
psycm->hdcMag, 0, psycm->ypDest, SRCCOPY);
|
|
|
|
ReleaseDC(hwndDialog, hdc);
|
|
|
|
psycm->xpMagCurr = 0; // flag - no data offscreen (see FMagData)
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: FontLoadProc(LPLOGFONT, NEWTEXTMETRICEX*, short, LPTSTR);
|
|
|
|
PURPOSE: Used by EnumFonts to load our combo box with all the fonts
|
|
installed in the system.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
INT APIENTRY FontLoadProc(LPLOGFONT lpLogFont,
|
|
NEWTEXTMETRICEX* lpTextMetric,
|
|
DWORD nFontType,
|
|
LPARAM lpData)
|
|
{
|
|
INT iPos;
|
|
TCHAR szFace[LF_FACESIZE];
|
|
|
|
// Check for duplicates.
|
|
iPos = (INT)SendDlgItemMessage((HWND)lpData, ID_FONT, CB_FINDSTRING, (WPARAM)-1,
|
|
(LPARAM)&lpLogFont->lfFaceName);
|
|
|
|
if (iPos == CB_ERR) {
|
|
NotInListYet:
|
|
// Doesn't exist, insert the facename into the combo box.
|
|
iPos = (INT)SendDlgItemMessage((HWND)lpData, ID_FONT,
|
|
CB_ADDSTRING, 0,
|
|
(LPARAM)&lpLogFont->lfFaceName);
|
|
} else {
|
|
|
|
// make sure it is not just a substring (want a full match)
|
|
SendDlgItemMessage((HWND)lpData, ID_FONT, CB_GETLBTEXT, iPos, (LPARAM)(LPTSTR)szFace);
|
|
if (lstrcmpi(szFace, lpLogFont->lfFaceName))
|
|
goto NotInListYet;
|
|
|
|
// Already exists, blow out now if this is not a true type font.
|
|
if (!(nFontType & TRUETYPE_FONTTYPE))
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Store the pertinant font information in the combo item data.
|
|
*/
|
|
if ((iPos != CB_ERR) && (iPos != CB_ERRSPACE)) {
|
|
ITEMDATA ItemData;
|
|
DWORD ntmFlags = lpTextMetric->ntmTm.ntmFlags;
|
|
SHORT sFontType = 0;
|
|
|
|
if (ntmFlags & NTM_PS_OPENTYPE)
|
|
{
|
|
sFontType = PS_OPENTYPE_FONT;
|
|
}
|
|
else if (ntmFlags & NTM_TYPE1)
|
|
{
|
|
sFontType = TYPE1_FONT;
|
|
}
|
|
else if (nFontType & TRUETYPE_FONTTYPE)
|
|
{
|
|
if (ntmFlags & NTM_TT_OPENTYPE)
|
|
{
|
|
sFontType = TT_OPENTYPE_FONT;
|
|
}
|
|
else
|
|
sFontType = TRUETYPE_FONT;
|
|
}
|
|
|
|
ItemData.FontType = sFontType;
|
|
ItemData.CharSet = lpLogFont->lfCharSet;
|
|
ItemData.PitchAndFamily = lpLogFont->lfPitchAndFamily;
|
|
|
|
SendDlgItemMessage((HWND)lpData, ID_FONT, CB_SETITEMDATA, iPos,
|
|
*(DWORD *)&ItemData);
|
|
}
|
|
|
|
// Continue enumeration.
|
|
return (1);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: GetEditText(HWND);
|
|
|
|
PURPOSE: Returns HANDLE containing the text in the edit control.
|
|
|
|
COMMENTS: Caller is responsible for freeing this handle!
|
|
|
|
****************************************************************************/
|
|
|
|
HANDLE GetEditText(
|
|
HWND hwndDlg)
|
|
{
|
|
INT cchText;
|
|
HWND hwndEditCtl;
|
|
HANDLE hmem;
|
|
LPTSTR lpstrText;
|
|
LRESULT dwSel;
|
|
|
|
hwndEditCtl = GetDlgItem(hwndDlg, ID_STRING);
|
|
|
|
cchText = GetWindowTextLength(hwndEditCtl);
|
|
|
|
hmem = GlobalAlloc(0, CTOB((cchText + 1)));
|
|
|
|
lpstrText = (LPTSTR)GlobalLock(hmem);
|
|
|
|
cchText = GetWindowText(hwndEditCtl, lpstrText, cchText+1);
|
|
|
|
dwSel = SendMessage(hwndEditCtl, EM_GETSEL, 0, 0L);
|
|
|
|
if (LOWORD(dwSel) != HIWORD(dwSel)) {
|
|
// If there is a selection, then only get the selected text.
|
|
*(lpstrText + HIWORD(dwSel)) = TEXT('\0');
|
|
lstrcpy(lpstrText, lpstrText + LOWORD(dwSel));
|
|
}
|
|
|
|
GlobalUnlock(hmem);
|
|
|
|
if (cchText == 0)
|
|
hmem = GlobalFree(hmem);
|
|
|
|
return (hmem);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: CopyString(HWND);
|
|
|
|
PURPOSE: Implement the Copy function.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID CopyString(
|
|
HWND hwndDlg)
|
|
{
|
|
HANDLE hmem;
|
|
LPTSTR lpstrText;
|
|
|
|
if (hmem = GetEditText(hwndDlg)) {
|
|
lpstrText = (LPTSTR)GlobalLock(hmem);
|
|
|
|
// Copying string to clipboard.
|
|
if (OpenClipboard(hwndDlg)) {
|
|
EmptyClipboard();
|
|
SendRTFToClip(hwndDlg, lpstrText);
|
|
#ifdef UNICODE
|
|
SetClipboardData(CF_UNICODETEXT, hmem);
|
|
#else
|
|
SetClipboardData(CF_TEXT, hmem);
|
|
#endif
|
|
CloseClipboard();
|
|
} else {
|
|
// If we couldn't open the clipboard, then we need to free memory.
|
|
GlobalUnlock(hmem);
|
|
GlobalFree(hmem);
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: SendRTFToClip(HWND, LPTSTR);
|
|
|
|
PURPOSE: Put the string in the clipboard using Rich Text Format.
|
|
|
|
COMMENTS: Assumes that the clipboard has already been opened.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID SendRTFToClip(
|
|
HWND hwndDlg,
|
|
LPTSTR lpstrText)
|
|
{
|
|
INT iCurrFont;
|
|
ITEMDATA ItemData;
|
|
TCHAR szFaceName[LF_FACESIZE];
|
|
HANDLE hmemRTF, hmemClip;
|
|
LPTSTR lpstrClipString;
|
|
TCHAR achHeader[] = TEXT("{\\rtf1\\ansi {\\fonttbl{\\f0\\");
|
|
TCHAR achMiddle[] = TEXT(";}}\\sectd\\pard\\plain\\f0 ");
|
|
|
|
#define MAXLENGTHFONTFAMILY 8
|
|
#define ALITTLEEXTRA 10 // Covers extra characters + length of font size.
|
|
|
|
iCurrFont = (INT)SendDlgItemMessage(hwndDlg, ID_FONT, CB_GETCURSEL, 0, 0L);
|
|
|
|
// Get the item data - contains fonttype, charset, and pitchandfamily.
|
|
*(DWORD *)&ItemData = (DWORD)SendDlgItemMessage(hwndDlg, ID_FONT, CB_GETITEMDATA,
|
|
iCurrFont, 0L);
|
|
|
|
// Get the facename from the combo box.
|
|
SendDlgItemMessage(hwndDlg, ID_FONT, CB_GETLBTEXT, iCurrFont,
|
|
(LPARAM)(LPTSTR)szFaceName);
|
|
|
|
hmemRTF = GlobalAlloc(0, CTOB(lstrlen((LPTSTR)achHeader) +
|
|
MAXLENGTHFONTFAMILY +
|
|
lstrlen(szFaceName) +
|
|
lstrlen((LPTSTR)achMiddle) +
|
|
4 * lstrlen(lpstrText) + // 4 times in case they're all > 7 bits
|
|
ALITTLEEXTRA));
|
|
if (hmemRTF == NULL)
|
|
return;
|
|
|
|
// Allocate memory for local storage of clipboard string for owner draw.
|
|
if (hmemClip = GlobalAlloc(0, CTOB(lstrlen(lpstrText) + 1))) {
|
|
// Get rid of old guys.
|
|
if (hstrClipboard)
|
|
GlobalFree(hstrClipboard);
|
|
if (fDelClipboardFont) {
|
|
fDelClipboardFont = FALSE;
|
|
DeleteObject(hFontClipboard);
|
|
}
|
|
|
|
// Save this stuff away for owner drawing in a clipboard viewer.
|
|
hFontClipboard = sycm.hFont;
|
|
hstrClipboard = hmemClip;
|
|
lstrcpy(GlobalLock(hstrClipboard), lpstrText);
|
|
GlobalUnlock(hstrClipboard);
|
|
} else {
|
|
GlobalFree(hmemRTF);
|
|
return;
|
|
}
|
|
|
|
lpstrClipString = GlobalLock(hmemRTF);
|
|
|
|
lstrcpy(lpstrClipString, achHeader);
|
|
|
|
if (ItemData.CharSet == SYMBOL_CHARSET) {
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("ftech "));
|
|
} else {
|
|
// top four bits specify family
|
|
switch (ItemData.PitchAndFamily & 0xf0) {
|
|
case FF_DECORATIVE:
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("fdecor "));
|
|
break;
|
|
|
|
case FF_MODERN:
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("fmodern "));
|
|
break;
|
|
|
|
case FF_ROMAN:
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("froman "));
|
|
break;
|
|
|
|
case FF_SCRIPT:
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("fscript "));
|
|
break;
|
|
|
|
case FF_SWISS:
|
|
lstrcat(lpstrClipString, (LPTSTR)TEXT("fswiss "));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
lstrcat(lpstrClipString, szFaceName);
|
|
|
|
lstrcat(lpstrClipString, (LPTSTR)achMiddle);
|
|
|
|
/*
|
|
* We need to do the text character by character, making sure
|
|
* that we output a special sequence \'hh for characters bigger
|
|
* than 7 bits long!
|
|
*/
|
|
lpstrClipString = (LPTSTR)(lpstrClipString + lstrlen(lpstrClipString));
|
|
while (*lpstrText) {
|
|
if ((UTCHAR)*lpstrText < 128) {
|
|
if (*lpstrText == TEXT('\\') || *lpstrText == TEXT('{') || *lpstrText == TEXT('}'))
|
|
/*
|
|
* Need to preface these symbols with a '\' since they are
|
|
* special control characters for RTF.
|
|
*/
|
|
*lpstrClipString++ = TEXT('\\');
|
|
|
|
*lpstrClipString++ = *lpstrText++;
|
|
} else {
|
|
*lpstrClipString++ = TEXT('\\');
|
|
*lpstrClipString++ = TEXT('\'');
|
|
#ifdef BUG
|
|
//
|
|
//PERF - GregoryW 23/10/92 need a Unicode version of itoa...
|
|
//
|
|
_itoa(*(UTCHAR FAR *)lpstrText++, achMiddle, 16);
|
|
#else
|
|
wsprintf(achMiddle, TEXT("%x"), (INT)*lpstrText);
|
|
lpstrText++;
|
|
#endif
|
|
*lpstrClipString++ = achMiddle[0];
|
|
*lpstrClipString++ = achMiddle[1];
|
|
}
|
|
}
|
|
*lpstrClipString++ = TEXT('}');
|
|
*lpstrClipString = TEXT('\0');
|
|
|
|
if (!wCFRichText) {
|
|
TCHAR szRTF[80];
|
|
|
|
LoadString(hInst, IDS_RTF, szRTF, BTOC(sizeof(szRTF)) - 1);
|
|
wCFRichText = RegisterClipboardFormat(szRTF);
|
|
}
|
|
|
|
// Put RTF and OwnerDisplay formats in the clipboard.
|
|
SetClipboardData(wCFRichText, hmemRTF);
|
|
SetClipboardData(CF_OWNERDISPLAY, NULL);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: PointsToHeight(int);
|
|
|
|
PURPOSE: Calculates the height in pixels of the specified point
|
|
size for the current display.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
INT PointsToHeight(INT iPoints)
|
|
{
|
|
HDC hdc;
|
|
INT iHeight;
|
|
|
|
hdc = GetDC(HWND_DESKTOP);
|
|
iHeight = MulDiv(iPoints, GetDeviceCaps(hdc, LOGPIXELSY), 72);
|
|
ReleaseDC(HWND_DESKTOP, hdc);
|
|
return(iHeight);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: UpdateKeystrokeText(HDC, UTCHAR, BOOL);
|
|
|
|
PURPOSE: Calculates and updates the text string displayed in the
|
|
Keystroke field of the status bar.
|
|
|
|
COMMENTS: Repaints status field if fRedraw == TRUE.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID UpdateKeystrokeText(
|
|
HDC hdc,
|
|
UTCHAR chNew,
|
|
BOOL fRedraw)
|
|
{
|
|
TCHAR szUnshifted[2];
|
|
SHORT vkRes;
|
|
|
|
#ifdef UNICODE
|
|
if (chNew > 255) {
|
|
lstrcpy(szKeystrokeText, szUnicodeLabel);
|
|
wsprintf((LPTSTR)(szKeystrokeText + iUnicodeLabelStart), TEXT("U+%04x"), chNew);
|
|
} else {
|
|
#endif
|
|
lstrcpy(szKeystrokeText, szKeystrokeLabel);
|
|
if (chNew == TEXT(' ')) {
|
|
lstrcpy((LPTSTR)(szKeystrokeText + iKeystrokeTextStart), szSpace);
|
|
} else {
|
|
vkRes = VkKeyScan(chNew);
|
|
/*
|
|
* Map the virtual key code into an unshifted character value
|
|
*/
|
|
szUnshifted[0] = (TCHAR)MapVirtualKey(LOBYTE(vkRes), 2);
|
|
szUnshifted[1] = TEXT('\0');
|
|
|
|
switch(HIBYTE(vkRes)) {
|
|
case 0: // Unshifted char.
|
|
case 1: // Character is shifted, just display the shifted char.
|
|
szKeystrokeText[iKeystrokeTextStart] = chNew;
|
|
szKeystrokeText[iKeystrokeTextStart + 1] = TEXT('\0');
|
|
break;
|
|
|
|
case 2: // Character is control character.
|
|
lstrcpy((LPTSTR)(szKeystrokeText + iKeystrokeTextStart), szCtrl);
|
|
lstrcat(szKeystrokeText, (LPTSTR)szUnshifted);
|
|
break;
|
|
|
|
case 6: // Character is CONTROL+ALT.
|
|
lstrcpy((LPTSTR)(szKeystrokeText + iKeystrokeTextStart), szCtrlAlt);
|
|
lstrcat(szKeystrokeText, (LPTSTR)szUnshifted);
|
|
break;
|
|
|
|
case 7: // Character is SHIFT+CONTROL+ALT.
|
|
lstrcpy((LPTSTR)(szKeystrokeText + iKeystrokeTextStart), szShiftCtrlAlt);
|
|
lstrcat(szKeystrokeText, (LPTSTR)szUnshifted);
|
|
break;
|
|
|
|
default: // Character created via Alt + Numpad
|
|
lstrcpy((LPTSTR)(szKeystrokeText + iKeystrokeTextStart), szAlt);
|
|
wsprintf((LPTSTR)(szKeystrokeText + lstrlen(szKeystrokeText)), TEXT("%d"), chNew);
|
|
break;
|
|
}
|
|
}
|
|
#ifdef UNICODE
|
|
}
|
|
#endif
|
|
|
|
if (fRedraw)
|
|
PaintStatusLine(hdc, FALSE, TRUE);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: UpdateHelpText(LPMSG, HWND);
|
|
|
|
PURPOSE: Calculates if the Help string needs to be updated, and does
|
|
so if necessary.
|
|
|
|
COMMENTS: If hwndCtrl is not NULL, then it specifies the window handle
|
|
of the control gaining focus, and lpmsg is ignored.
|
|
|
|
If hwndCtrl is NULL, then lpmsg must point to a valid message
|
|
structure. If it is a tab character, then we calculate
|
|
what the next control is that will receive the focus.
|
|
****************************************************************************/
|
|
|
|
BOOL UpdateHelpText(
|
|
LPMSG lpmsg,
|
|
HWND hwndCtrl)
|
|
{
|
|
HDC hdc;
|
|
BOOL fPaintStatus = FALSE;
|
|
BOOL fRet = TRUE;
|
|
|
|
if (hwndCtrl != NULL) {
|
|
fPaintStatus = TRUE;
|
|
iControl = GetDlgCtrlID(hwndCtrl);
|
|
} else if (lpmsg->message == WM_KEYDOWN) {
|
|
if (lpmsg->wParam == VK_TAB) {
|
|
fPaintStatus = TRUE;
|
|
hwndCtrl = GetNextDlgTabItem(hwndDialog,
|
|
GetDlgItem(hwndDialog, iControl),
|
|
(BOOL)(GetKeyState(VK_SHIFT) & 0x8000));
|
|
iControl = GetDlgCtrlID(hwndCtrl);
|
|
if (iControl == ID_STRING) {
|
|
/*
|
|
* Do this ourselves, otherwise default action will select
|
|
* the whole edit control.
|
|
*/
|
|
SetFocus(hwndCtrl);
|
|
fRet = FALSE;
|
|
}
|
|
if (iControl == ID_CHARGRID) {
|
|
/*
|
|
* Set the default button back to "Select". The default
|
|
* might have changed to the "Next" or "Previous" button.
|
|
*/
|
|
SendMessage(hwndDialog, DM_SETDEFID, ID_SELECT, 0);
|
|
}
|
|
} else if (lpmsg->wParam == VK_F1) {
|
|
PostMessage(hwndDialog, WM_COMMAND, ID_HELP, 0L);
|
|
}
|
|
}
|
|
|
|
if (fPaintStatus) {
|
|
hdc = GetDC(hwndDialog);
|
|
PaintStatusLine(hdc, TRUE, FALSE);
|
|
ReleaseDC(hwndDialog, hdc);
|
|
}
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: UpdateSymbolSelection(HWND, INT, INT);
|
|
|
|
PURPOSE: Updates the values of the following global values:
|
|
chSymFirst
|
|
chSymLast
|
|
sycm.chCurr
|
|
Subsets in the Unicode character set have different numbers
|
|
of characters. We have to do some bounds checking in order
|
|
to set an appropriate sycm.chCurr value. The "Keystroke"
|
|
status field is updated.
|
|
|
|
COMMENTS: Repaints Keystroke field if HWND != NULL.
|
|
|
|
****************************************************************************/
|
|
VOID UpdateSymbolSelection(
|
|
HWND hwnd,
|
|
INT FirstChar,
|
|
INT LastChar)
|
|
{
|
|
UTCHAR chSymOffset;
|
|
|
|
chSymOffset = sycm.chCurr - chSymFirst;
|
|
chSymFirst = (UTCHAR)FirstChar;
|
|
chSymLast = (UTCHAR)LastChar;
|
|
sycm.chCurr = chSymOffset + chSymFirst;
|
|
if (sycm.chCurr > chSymLast) {
|
|
sycm.chCurr = chSymFirst;
|
|
}
|
|
if (hwnd != NULL) {
|
|
HDC hdc;
|
|
|
|
hdc = GetDC(hwnd);
|
|
UpdateKeystrokeText(hdc, sycm.chCurr, TRUE);
|
|
ReleaseDC(hwnd, hdc);
|
|
} else {
|
|
UpdateKeystrokeText(NULL, sycm.chCurr, FALSE);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: PaintStatusLine(HDC, BOOL, BOOL);
|
|
|
|
PURPOSE: Paints the Help and Keystroke fields in the status bar.
|
|
|
|
COMMENTS: Repaints Help field if fHelp == TRUE, repaints the Keystroke
|
|
field if fKeystroke == TRUE.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID PaintStatusLine(
|
|
HDC hdc,
|
|
BOOL fHelp,
|
|
BOOL fKeystroke)
|
|
{
|
|
HFONT hfontOld = NULL;
|
|
RECT rect;
|
|
INT dyBorder;
|
|
TCHAR szHelpText[100];
|
|
|
|
dyBorder = GetSystemMetrics(SM_CYBORDER);
|
|
|
|
if (hfontStatus)
|
|
hfontOld = SelectObject(hdc, hfontStatus);
|
|
|
|
// set the text and background colors
|
|
|
|
SetTextColor(hdc, GetSysColor(COLOR_BTNTEXT));
|
|
SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
|
|
|
|
if (fHelp) {
|
|
// now the help text, with a gray background
|
|
|
|
rect.top = rcStatusLine.top + 3 * dyBorder;
|
|
rect.bottom = rcStatusLine.bottom - 3 * dyBorder;
|
|
rect.left = 9 * dyBorder;
|
|
rect.right = rect.left + dxHelpField - 2 * dyBorder;
|
|
|
|
LoadString(hInst, iControl, szHelpText, BTOC(sizeof(szHelpText)) - 1);
|
|
|
|
ExtTextOut(hdc, rect.left + dyBorder * 2, rect.top,
|
|
ETO_OPAQUE | ETO_CLIPPED, &rect, szHelpText,
|
|
lstrlen(szHelpText), NULL);
|
|
}
|
|
|
|
if (fKeystroke) {
|
|
// now the keystroke text, with a gray background
|
|
rect.top = rcStatusLine.top + 3 * dyBorder;
|
|
rect.bottom = rcStatusLine.bottom - 3 * dyBorder;
|
|
rect.right = rcStatusLine.right - 9 * dyBorder;
|
|
rect.left = rect.right - dxKeystrokeField + 2 * dyBorder;
|
|
|
|
ExtTextOut(hdc, rect.left + dyBorder * 2, rect.top,
|
|
ETO_OPAQUE | ETO_CLIPPED, &rect, szKeystrokeText,
|
|
lstrlen(szKeystrokeText), NULL);
|
|
}
|
|
|
|
if (hfontOld)
|
|
SelectObject(hdc, hfontOld);
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DrawFamilyComboItem(LPDRAWITEMSTRUCT)
|
|
|
|
PURPOSE: Paints the font facenames and TT bitmap in the font combo box.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
BOOL DrawFamilyComboItem(
|
|
LPDRAWITEMSTRUCT lpdis)
|
|
{
|
|
HDC hDC, hdcMem;
|
|
DWORD rgbBack, rgbText;
|
|
TCHAR szFace[LF_FACESIZE];
|
|
HBITMAP hOld;
|
|
INT dy;
|
|
SHORT sFontType;
|
|
|
|
hDC = lpdis->hDC;
|
|
|
|
if (lpdis->itemState & ODS_SELECTED) {
|
|
rgbBack = SetBkColor(hDC, GetSysColor(COLOR_HIGHLIGHT));
|
|
rgbText = SetTextColor(hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
|
|
} else {
|
|
rgbBack = SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
|
|
rgbText = SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
|
|
}
|
|
|
|
SendMessage(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID, (LPARAM)(LPTSTR)szFace);
|
|
ExtTextOut(hDC, lpdis->rcItem.left + DX_BITMAP, lpdis->rcItem.top, ETO_OPAQUE | ETO_CLIPPED, &lpdis->rcItem, szFace, lstrlen(szFace), NULL);
|
|
|
|
hdcMem = CreateCompatibleDC(hDC);
|
|
if (hdcMem) {
|
|
if (hbmFont) {
|
|
hOld = SelectObject(hdcMem, hbmFont);
|
|
sFontType = ((ITEMDATA FAR *)&(lpdis->itemData))->FontType;
|
|
|
|
if (sFontType)
|
|
{
|
|
int xSrc;
|
|
|
|
dy = ((lpdis->rcItem.bottom - lpdis->rcItem.top) - DY_BITMAP) / 2;
|
|
|
|
if (sFontType & TRUETYPE_FONT)
|
|
xSrc = 0;
|
|
else if (sFontType & TT_OPENTYPE_FONT)
|
|
xSrc = 2;
|
|
else if (sFontType & PS_OPENTYPE_FONT)
|
|
xSrc = 3;
|
|
else if (sFontType & TYPE1_FONT)
|
|
xSrc = 4;
|
|
|
|
BitBlt(hDC, lpdis->rcItem.left, lpdis->rcItem.top + dy, DX_BITMAP, DY_BITMAP, hdcMem,
|
|
xSrc*DX_BITMAP, lpdis->itemState & ODS_SELECTED ? DY_BITMAP : 0, SRCCOPY);
|
|
}
|
|
|
|
SelectObject(hdcMem, hOld);
|
|
}
|
|
DeleteDC(hdcMem);
|
|
}
|
|
|
|
SetTextColor(hDC, rgbText);
|
|
SetBkColor(hDC, rgbBack);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: LoadBitmaps(int)
|
|
|
|
PURPOSE: This routine loads DIB bitmaps, and "fixes up" their color tables
|
|
so that we get the desired result for the device we are on.
|
|
|
|
COMMENTS: This routine requires:
|
|
- The DIB is a 16 color DIB authored with the standard windows colors.
|
|
- bright blue (00 00 FF) is converted to the background color.
|
|
- light grey (C0 C0 C0) is replaced with the button face color.
|
|
- dark grey (80 80 80) is replaced with the button shadow color.
|
|
|
|
This means you can't have any of these colors in your bitmap.
|
|
|
|
****************************************************************************/
|
|
|
|
HBITMAP LoadBitmaps(INT id)
|
|
{
|
|
HDC hdc;
|
|
HANDLE h;
|
|
DWORD FAR *p;
|
|
LPBYTE lpBits;
|
|
HANDLE hRes;
|
|
LPBITMAPINFOHEADER lpBitmapInfo;
|
|
INT numcolors;
|
|
DWORD rgbSelected;
|
|
DWORD rgbUnselected;
|
|
HBITMAP hbm;
|
|
|
|
rgbSelected = GetSysColor(COLOR_HIGHLIGHT);
|
|
// Flip the colors.
|
|
rgbSelected = RGB(GetBValue(rgbSelected),
|
|
GetGValue(rgbSelected),
|
|
GetRValue(rgbSelected));
|
|
rgbUnselected = GetSysColor(COLOR_WINDOW);
|
|
// Flip the colors.
|
|
rgbUnselected = RGB(GetBValue(rgbUnselected),
|
|
GetGValue(rgbUnselected),
|
|
GetRValue(rgbUnselected));
|
|
|
|
|
|
h = FindResource(hInst, MAKEINTRESOURCE(id), RT_BITMAP);
|
|
hRes = LoadResource(hInst, h);
|
|
|
|
/* Lock the bitmap and get a pointer to the color table. */
|
|
lpBitmapInfo = (LPBITMAPINFOHEADER)LockResource(hRes);
|
|
|
|
if (!lpBitmapInfo)
|
|
return FALSE;
|
|
|
|
p = (DWORD FAR *)((LPSTR)(lpBitmapInfo) + lpBitmapInfo->biSize);
|
|
|
|
/* Search for the Solid Blue entry and replace it with the current
|
|
* background RGB.
|
|
*/
|
|
numcolors = 16;
|
|
|
|
while (numcolors-- > 0) {
|
|
if (*p == BACKGROUND)
|
|
*p = rgbUnselected;
|
|
else if (*p == BACKGROUNDSEL)
|
|
*p = rgbSelected;
|
|
p++;
|
|
}
|
|
UnlockResource(hRes);
|
|
|
|
/* Now create the DIB. */
|
|
lpBitmapInfo = (LPBITMAPINFOHEADER)LockResource(hRes);
|
|
|
|
/* First skip over the header structure */
|
|
lpBits = (LPBYTE)(lpBitmapInfo + 1);
|
|
|
|
/* Skip the color table entries, if any */
|
|
lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
|
|
|
|
/* Create a color bitmap compatible with the display device */
|
|
hdc = GetDC(NULL);
|
|
hbm = CreateDIBitmap(hdc, lpBitmapInfo, (DWORD)CBM_INIT, lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS);
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
GlobalUnlock(hRes);
|
|
FreeResource(hRes);
|
|
|
|
return hbm;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: DoHelp(HWND, BOOL)
|
|
|
|
PURPOSE: This routine invokes help if BOOL is true, or dismisses help
|
|
if BOOL is false.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DoHelp(HWND hWnd, BOOL fInvokeHelp)
|
|
{
|
|
TCHAR szHelp[80];
|
|
|
|
if (LoadString(hInst, IDS_HELP, szHelp, BTOC(sizeof(szHelp)) - 1)) {
|
|
if (fInvokeHelp)
|
|
WinHelp(hWnd, (LPTSTR)szHelp, HELP_INDEX, 0L);
|
|
else
|
|
WinHelp(hWnd, (LPTSTR)szHelp, HELP_QUIT, 0L);
|
|
}
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: SaveFont(HWND)
|
|
|
|
PURPOSE: Used to save the current font facename in win.ini, so that
|
|
it can be selected the next time charmap comes up.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID SaveCurrentFont(HWND hWndDlg)
|
|
{
|
|
TCHAR szFaceName[LF_FACESIZE] = TEXT("");
|
|
|
|
SendDlgItemMessage(hWndDlg, ID_FONT, CB_GETLBTEXT,
|
|
(WORD)SendDlgItemMessage(hWndDlg, ID_FONT, CB_GETCURSEL,
|
|
0, 0L),
|
|
(LPARAM)(LPTSTR)szFaceName);
|
|
|
|
WriteProfileString(TEXT("MSCharMap"), TEXT("Font"), (LPTSTR)szFaceName);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: SelectInitialFont(HWND)
|
|
|
|
PURPOSE: Used to select the initial font by getting a saved facename
|
|
from win.ini and selecting it in the combo box.
|
|
|
|
COMMENTS: Returns index to font selected.
|
|
|
|
****************************************************************************/
|
|
|
|
INT SelectInitialFont(HWND hWndDlg)
|
|
{
|
|
TCHAR szFaceName[LF_FACESIZE] = TEXT("");
|
|
INT iIndex;
|
|
|
|
if ((GetProfileString(TEXT("MSCharMap"), TEXT("Font"), NULL, (LPTSTR)szFaceName,
|
|
BTOC(sizeof(szFaceName))) == 0) ||
|
|
((iIndex = (INT)SendDlgItemMessage(hWndDlg, ID_FONT, CB_SELECTSTRING, (WPARAM)-1,
|
|
(LPARAM)(LPTSTR)szFaceName)) == CB_ERR)) {
|
|
/*
|
|
* If there was no profile or the selection failed then try selecting
|
|
* the symbol font, if that fails then select the first one.
|
|
*/
|
|
if ((iIndex = (INT)SendDlgItemMessage(hWndDlg, ID_FONT, CB_SELECTSTRING,
|
|
(WPARAM)-1, (LPARAM)(LPTSTR)TEXT("Symbol"))) == CB_ERR)
|
|
SendDlgItemMessage(hWndDlg, ID_FONT, CB_SETCURSEL, iIndex = 0, 0L);
|
|
}
|
|
|
|
return(iIndex);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: SaveCurrentSubset(HWND)
|
|
|
|
PURPOSE: Used to save the current subset name in win.ini, so that
|
|
it can be selected the next time charmap comes up.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID SaveCurrentSubset(HWND hWndDlg)
|
|
{
|
|
TCHAR szSubsetName[LF_SUBSETSIZE] = TEXT("");
|
|
|
|
SendDlgItemMessage(hWndDlg, ID_UNICODESUBSET, CB_GETLBTEXT,
|
|
(WORD)SendDlgItemMessage(hWndDlg, ID_UNICODESUBSET, CB_GETCURSEL,
|
|
0, 0L),
|
|
(LPARAM)(LPTSTR)szSubsetName);
|
|
|
|
WriteProfileString(TEXT("MSCharMap"), TEXT("Block"), (LPTSTR)szSubsetName);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: SelectInitialSubset(HWND)
|
|
|
|
PURPOSE: Used to select the initial Unicode subset by getting a saved
|
|
block name from win.ini.
|
|
|
|
COMMENTS: Returns index to subset selected.
|
|
|
|
****************************************************************************/
|
|
|
|
INT SelectInitialSubset(HWND hWndDlg)
|
|
{
|
|
TCHAR szSubsetName[LF_SUBSETSIZE] = TEXT("");
|
|
INT iIndex;
|
|
|
|
if (
|
|
(GetProfileString(
|
|
TEXT("MSCharMap"),
|
|
TEXT("Block"),
|
|
NULL,
|
|
(LPTSTR)szSubsetName,
|
|
BTOC(sizeof(szSubsetName))
|
|
) == 0)
|
|
|| ((iIndex = (INT)SendDlgItemMessage(
|
|
hWndDlg,
|
|
ID_UNICODESUBSET,
|
|
CB_SELECTSTRING,
|
|
(WPARAM)-1,
|
|
(LPARAM)(LPTSTR)szSubsetName
|
|
)) == CB_ERR)) {
|
|
/*
|
|
* If there was no profile or the selection failed then try selecting
|
|
* the Basic Latin block, if that fails then select the first one.
|
|
*/
|
|
if ((iIndex = (INT)SendDlgItemMessage(
|
|
hWndDlg,
|
|
ID_UNICODESUBSET,
|
|
CB_SELECTSTRING,
|
|
(WPARAM)-1,
|
|
(LPARAM)(LPTSTR)TEXT("Basic Latin")
|
|
)) == CB_ERR)
|
|
SendDlgItemMessage(hWndDlg, ID_UNICODESUBSET, CB_SETCURSEL, iIndex = 0, 0L);
|
|
}
|
|
|
|
chSymFirst = (UTCHAR)aSubsetData[iIndex].BeginRange;
|
|
chSymLast = (UTCHAR)aSubsetData[iIndex].EndRange;
|
|
sycm.chCurr = chSymFirst;
|
|
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: ExitMagnify(HWND, SYCM)
|
|
|
|
PURPOSE: Used to release mouse capture, exit magnify mode,
|
|
and restore the cursor.
|
|
|
|
COMMENTS:
|
|
|
|
****************************************************************************/
|
|
|
|
VOID ExitMagnify(
|
|
HWND hWnd,
|
|
PSYCM psycm)
|
|
{
|
|
// Release capture, remove magnified character, restore cursor.
|
|
ReleaseCapture();
|
|
RestoreSymMag(psycm);
|
|
DrawSymChOutlineHwnd(psycm, hWnd, psycm->chCurr, TRUE, TRUE);
|
|
if (psycm->fCursorOff)
|
|
ShowCursor(TRUE);
|
|
psycm->fMouseDn = psycm->fCursorOff = FALSE;
|
|
}
|