reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-02 00:36:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2d870e27fb
wine/programs/notepad/dialog.c
Francois Gouget 8a18e0e43a Assorted spelling fixes.
2008-04-07 13:36:18 +02:00

848 lines
25 KiB
C
Raw Blame History

/*
* Notepad (dialog.c)
*
* Copyright 1998,99 Marcel Baur <mbaur@g26.ethz.ch>
* Copyright 2002 Sylvain Petreolle <spetreolle@yahoo.fr>
* Copyright 2002 Andriy Palamarchuk
* Copyright 2007 Rolf Kalbermatter
*
* 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
*/
#define UNICODE
#include <assert.h>
#include <stdio.h>
#include <windows.h>
#include <commdlg.h>
#include <shlwapi.h>
#include "main.h"
#include "dialog.h"
#define SPACES_IN_TAB 8
#define PRINT_LEN_MAX 500
static const WCHAR helpfileW[] = { 'n','o','t','e','p','a','d','.','h','l','p',0 };
static INT_PTR WINAPI DIALOG_PAGESETUP_DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
VOID ShowLastError(void)
{
DWORD error = GetLastError();
if (error != NO_ERROR)
{
LPWSTR lpMsgBuf;
WCHAR szTitle[MAX_STRING_LEN];
LoadString(Globals.hInstance, STRING_ERROR, szTitle, SIZEOF(szTitle));
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error, 0,
(LPTSTR) &lpMsgBuf, 0, NULL);
MessageBox(NULL, lpMsgBuf, szTitle, MB_OK | MB_ICONERROR);
LocalFree(lpMsgBuf);
}
}
/**
* Sets the caption of the main window according to Globals.szFileTitle:
* Untitled - Notepad if no file is open
* filename - Notepad if a file is given
*/
static void UpdateWindowCaption(void)
{
WCHAR szCaption[MAX_STRING_LEN];
WCHAR szNotepad[MAX_STRING_LEN];
static const WCHAR hyphenW[] = { ' ','-',' ',0 };
if (Globals.szFileTitle[0] != '\0')
lstrcpy(szCaption, Globals.szFileTitle);
else
LoadString(Globals.hInstance, STRING_UNTITLED, szCaption, SIZEOF(szCaption));
LoadString(Globals.hInstance, STRING_NOTEPAD, szNotepad, SIZEOF(szNotepad));
lstrcat(szCaption, hyphenW);
lstrcat(szCaption, szNotepad);
SetWindowText(Globals.hMainWnd, szCaption);
}
int DIALOG_StringMsgBox(HWND hParent, int formatId, LPCWSTR szString, DWORD dwFlags)
{
WCHAR szMessage[MAX_STRING_LEN];
WCHAR szResource[MAX_STRING_LEN];
/* Load and format szMessage */
LoadString(Globals.hInstance, formatId, szResource, SIZEOF(szResource));
wnsprintf(szMessage, SIZEOF(szMessage), szResource, szString);
/* Load szCaption */
if ((dwFlags & MB_ICONMASK) == MB_ICONEXCLAMATION)
LoadString(Globals.hInstance, STRING_ERROR, szResource, SIZEOF(szResource));
else
LoadString(Globals.hInstance, STRING_NOTEPAD, szResource, SIZEOF(szResource));
/* Display Modal Dialog */
if (hParent == NULL)
hParent = Globals.hMainWnd;
return MessageBox(hParent, szMessage, szResource, dwFlags);
}
static void AlertFileNotFound(LPCWSTR szFileName)
{
DIALOG_StringMsgBox(NULL, STRING_NOTFOUND, szFileName, MB_ICONEXCLAMATION|MB_OK);
}
static int AlertFileNotSaved(LPCWSTR szFileName)
{
WCHAR szUntitled[MAX_STRING_LEN];
LoadString(Globals.hInstance, STRING_UNTITLED, szUntitled, SIZEOF(szUntitled));
return DIALOG_StringMsgBox(NULL, STRING_NOTSAVED, szFileName[0] ? szFileName : szUntitled,
MB_ICONQUESTION|MB_YESNOCANCEL);
}
/**
* Returns:
* TRUE - if file exists
* FALSE - if file does not exist
*/
BOOL FileExists(LPCWSTR szFilename)
{
WIN32_FIND_DATA entry;
HANDLE hFile;
hFile = FindFirstFile(szFilename, &entry);
FindClose(hFile);
return (hFile != INVALID_HANDLE_VALUE);
}
static VOID DoSaveFile(VOID)
{
HANDLE hFile;
DWORD dwNumWrite;
LPSTR pTemp;
DWORD size;
hFile = CreateFile(Globals.szFileName, GENERIC_WRITE, FILE_SHARE_WRITE,
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
ShowLastError();
return;
}
size = GetWindowTextLengthA(Globals.hEdit) + 1;
pTemp = HeapAlloc(GetProcessHeap(), 0, size);
if (!pTemp)
{
CloseHandle(hFile);
ShowLastError();
return;
}
size = GetWindowTextA(Globals.hEdit, pTemp, size);
if (!WriteFile(hFile, pTemp, size, &dwNumWrite, NULL))
ShowLastError();
else
SendMessage(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
SetEndOfFile(hFile);
CloseHandle(hFile);
HeapFree(GetProcessHeap(), 0, pTemp);
}
/**
* Returns:
* TRUE - User agreed to close (both save/don't save)
* FALSE - User cancelled close by selecting "Cancel"
*/
BOOL DoCloseFile(void)
{
int nResult;
static const WCHAR empty_strW[] = { 0 };
if (SendMessage(Globals.hEdit, EM_GETMODIFY, 0, 0))
{
/* prompt user to save changes */
nResult = AlertFileNotSaved(Globals.szFileName);
switch (nResult) {
case IDYES: DIALOG_FileSave();
break;
case IDNO: break;
case IDCANCEL: return(FALSE);
default: return(FALSE);
} /* switch */
} /* if */
SetFileName(empty_strW);
UpdateWindowCaption();
return(TRUE);
}
void DoOpenFile(LPCWSTR szFileName)
{
static const WCHAR dotlog[] = { '.','L','O','G',0 };
HANDLE hFile;
LPSTR pTemp;
DWORD size;
DWORD dwNumRead;
WCHAR log[5];
/* Close any files and prompt to save changes */
if (!DoCloseFile())
return;
hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
AlertFileNotFound(szFileName);
return;
}
size = GetFileSize(hFile, NULL);
if (size == INVALID_FILE_SIZE)
{
CloseHandle(hFile);
ShowLastError();
return;
}
size++;
pTemp = HeapAlloc(GetProcessHeap(), 0, size);
if (!pTemp)
{
CloseHandle(hFile);
ShowLastError();
return;
}
if (!ReadFile(hFile, pTemp, size, &dwNumRead, NULL))
{
CloseHandle(hFile);
HeapFree(GetProcessHeap(), 0, pTemp);
ShowLastError();
return;
}
CloseHandle(hFile);
pTemp[dwNumRead] = 0;
if (IsTextUnicode(pTemp, dwNumRead, NULL))
{
LPWSTR p = (LPWSTR)pTemp;
/* We need to strip BOM Unicode character, SetWindowTextW won't do it for us. */
if (*p == 0xFEFF || *p == 0xFFFE) p++;
SetWindowTextW(Globals.hEdit, p);
}
else
SetWindowTextA(Globals.hEdit, pTemp);
HeapFree(GetProcessHeap(), 0, pTemp);
SendMessage(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
SendMessage(Globals.hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
SetFocus(Globals.hEdit);
/* If the file starts with .LOG, add a time/date at the end and set cursor after */
if (GetWindowTextW(Globals.hEdit, log, sizeof(log)/sizeof(log[0])) && !lstrcmp(log, dotlog))
{
static const WCHAR lfW[] = { '\r','\n',0 };
SendMessage(Globals.hEdit, EM_SETSEL, GetWindowTextLength(Globals.hEdit), -1);
SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
DIALOG_EditTimeDate();
SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
}
SetFileName(szFileName);
UpdateWindowCaption();
}
VOID DIALOG_FileNew(VOID)
{
static const WCHAR empty_strW[] = { 0 };
/* Close any files and prompt to save changes */
if (DoCloseFile()) {
SetWindowText(Globals.hEdit, empty_strW);
SendMessage(Globals.hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
SetFocus(Globals.hEdit);
}
}
VOID DIALOG_FileOpen(VOID)
{
OPENFILENAME openfilename;
WCHAR szPath[MAX_PATH];
WCHAR szDir[MAX_PATH];
static const WCHAR szDefaultExt[] = { 't','x','t',0 };
static const WCHAR txt_files[] = { '*','.','t','x','t',0 };
ZeroMemory(&openfilename, sizeof(openfilename));
GetCurrentDirectory(SIZEOF(szDir), szDir);
lstrcpy(szPath, txt_files);
openfilename.lStructSize = sizeof(openfilename);
openfilename.hwndOwner = Globals.hMainWnd;
openfilename.hInstance = Globals.hInstance;
openfilename.lpstrFilter = Globals.szFilter;
openfilename.lpstrFile = szPath;
openfilename.nMaxFile = SIZEOF(szPath);
openfilename.lpstrInitialDir = szDir;
openfilename.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST |
OFN_HIDEREADONLY;
openfilename.lpstrDefExt = szDefaultExt;
if (GetOpenFileName(&openfilename))
DoOpenFile(openfilename.lpstrFile);
}
VOID DIALOG_FileSave(VOID)
{
if (Globals.szFileName[0] == '\0')
DIALOG_FileSaveAs();
else
DoSaveFile();
}
VOID DIALOG_FileSaveAs(VOID)
{
OPENFILENAME saveas;
WCHAR szPath[MAX_PATH];
WCHAR szDir[MAX_PATH];
static const WCHAR szDefaultExt[] = { 't','x','t',0 };
static const WCHAR txt_files[] = { '*','.','t','x','t',0 };
ZeroMemory(&saveas, sizeof(saveas));
GetCurrentDirectory(SIZEOF(szDir), szDir);
lstrcpy(szPath, txt_files);
saveas.lStructSize = sizeof(OPENFILENAME);
saveas.hwndOwner = Globals.hMainWnd;
saveas.hInstance = Globals.hInstance;
saveas.lpstrFilter = Globals.szFilter;
saveas.lpstrFile = szPath;
saveas.nMaxFile = SIZEOF(szPath);
saveas.lpstrInitialDir = szDir;
saveas.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT |
OFN_HIDEREADONLY;
saveas.lpstrDefExt = szDefaultExt;
if (GetSaveFileName(&saveas)) {
SetFileName(szPath);
UpdateWindowCaption();
DoSaveFile();
}
}
typedef struct {
LPWSTR mptr;
LPWSTR mend;
LPWSTR lptr;
DWORD len;
} TEXTINFO, *LPTEXTINFO;
static int notepad_print_header(HDC hdc, RECT *rc, BOOL dopage, BOOL header, int page, LPWSTR text)
{
SIZE szMetric;
if (*text)
{
/* Write the header or footer */
GetTextExtentPoint32(hdc, text, lstrlen(text), &szMetric);
if (dopage)
ExtTextOut(hdc, (rc->left + rc->right - szMetric.cx) / 2,
header ? rc->top : rc->bottom - szMetric.cy,
ETO_CLIPPED, rc, text, lstrlen(text), NULL);
return 1;
}
return 0;
}
static BOOL notepad_print_page(HDC hdc, RECT *rc, BOOL dopage, int page, LPTEXTINFO tInfo)
{
int b, y;
TEXTMETRIC tm;
SIZE szMetrics;
if (dopage)
{
if (StartPage(hdc) <= 0)
{
static const WCHAR failedW[] = { 'S','t','a','r','t','P','a','g','e',' ','f','a','i','l','e','d',0 };
static const WCHAR errorW[] = { 'P','r','i','n','t',' ','E','r','r','o','r',0 };
MessageBox(Globals.hMainWnd, failedW, errorW, MB_ICONEXCLAMATION);
return FALSE;
}
}
GetTextMetrics(hdc, &tm);
y = rc->top + notepad_print_header(hdc, rc, dopage, TRUE, page, Globals.szFileName) * tm.tmHeight;
b = rc->bottom - 2 * notepad_print_header(hdc, rc, FALSE, FALSE, page, Globals.szFooter) * tm.tmHeight;
do {
INT m, n;
if (!tInfo->len)
{
/* find the end of the line */
while (tInfo->mptr < tInfo->mend && *tInfo->mptr != '\n' && *tInfo->mptr != '\r')
{
if (*tInfo->mptr == '\t')
{
/* replace tabs with spaces */
for (m = 0; m < SPACES_IN_TAB; m++)
{
if (tInfo->len < PRINT_LEN_MAX)
tInfo->lptr[tInfo->len++] = ' ';
else if (Globals.bWrapLongLines)
break;
}
}
else if (tInfo->len < PRINT_LEN_MAX)
tInfo->lptr[tInfo->len++] = *tInfo->mptr;
if (tInfo->len >= PRINT_LEN_MAX && Globals.bWrapLongLines)
break;
tInfo->mptr++;
}
}
/* Find out how much we should print if line wrapping is enabled */
if (Globals.bWrapLongLines)
{
GetTextExtentExPoint(hdc, tInfo->lptr, tInfo->len, rc->right - rc->left, &n, NULL, &szMetrics);
if (n < tInfo->len && tInfo->lptr[n] != ' ')
{
m = n;
/* Don't wrap words unless it's a single word over the entire line */
while (m && tInfo->lptr[m] != ' ') m--;
if (m > 0) n = m + 1;
}
}
else
n = tInfo->len;
if (dopage)
ExtTextOut(hdc, rc->left, y, ETO_CLIPPED, rc, tInfo->lptr, n, NULL);
tInfo->len -= n;
if (tInfo->len)
{
memcpy(tInfo->lptr, tInfo->lptr + n, tInfo->len * sizeof(WCHAR));
y += tm.tmHeight + tm.tmExternalLeading;
}
else
{
/* find the next line */
while (tInfo->mptr < tInfo->mend && y < b && (*tInfo->mptr == '\n' || *tInfo->mptr == '\r'))
{
if (*tInfo->mptr == '\n')
y += tm.tmHeight + tm.tmExternalLeading;
tInfo->mptr++;
}
}
} while (tInfo->mptr < tInfo->mend && y < b);
notepad_print_header(hdc, rc, dopage, FALSE, page, Globals.szFooter);
if (dopage)
{
EndPage(hdc);
}
return TRUE;
}
VOID DIALOG_FilePrint(VOID)
{
DOCINFO di;
PRINTDLG printer;
int page, dopage, copy;
LOGFONT lfFont;
HFONT hTextFont, old_font = 0;
DWORD size;
BOOL ret = FALSE;
RECT rc;
LPWSTR pTemp;
TEXTINFO tInfo;
WCHAR cTemp[PRINT_LEN_MAX];
/* Get Current Settings */
ZeroMemory(&printer, sizeof(printer));
printer.lStructSize = sizeof(printer);
printer.hwndOwner = Globals.hMainWnd;
printer.hDevMode = Globals.hDevMode;
printer.hDevNames = Globals.hDevNames;
printer.hInstance = Globals.hInstance;
/* Set some default flags */
printer.Flags = PD_RETURNDC | PD_NOSELECTION;
printer.nFromPage = 0;
printer.nMinPage = 1;
/* we really need to calculate number of pages to set nMaxPage and nToPage */
printer.nToPage = 0;
printer.nMaxPage = -1;
/* Let commdlg manage copy settings */
printer.nCopies = (WORD)PD_USEDEVMODECOPIES;
if (!PrintDlg(&printer)) return;
Globals.hDevMode = printer.hDevMode;
Globals.hDevNames = printer.hDevNames;
SetMapMode(printer.hDC, MM_TEXT);
/* initialize DOCINFO */
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = Globals.szFileTitle;
di.lpszOutput = NULL;
di.lpszDatatype = NULL;
di.fwType = 0;
/* Get the file text */
size = GetWindowTextLength(Globals.hEdit) + 1;
pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
if (!pTemp)
{
DeleteDC(printer.hDC);
ShowLastError();
return;
}
size = GetWindowText(Globals.hEdit, pTemp, size);
if (StartDoc(printer.hDC, &di) > 0)
{
/* Get the page margins in pixels. */
rc.top = MulDiv(Globals.iMarginTop, GetDeviceCaps(printer.hDC, LOGPIXELSY), 2540) -
GetDeviceCaps(printer.hDC, PHYSICALOFFSETY);
rc.bottom = GetDeviceCaps(printer.hDC, PHYSICALHEIGHT) -
MulDiv(Globals.iMarginBottom, GetDeviceCaps(printer.hDC, LOGPIXELSY), 2540);
rc.left = MulDiv(Globals.iMarginLeft, GetDeviceCaps(printer.hDC, LOGPIXELSX), 2540) -
GetDeviceCaps(printer.hDC, PHYSICALOFFSETX);
rc.right = GetDeviceCaps(printer.hDC, PHYSICALWIDTH) -
MulDiv(Globals.iMarginRight, GetDeviceCaps(printer.hDC, LOGPIXELSX), 2540);
/* Create a font for the printer resolution */
lfFont = Globals.lfFont;
lfFont.lfHeight = MulDiv(lfFont.lfHeight, GetDeviceCaps(printer.hDC, LOGPIXELSY), get_dpi());
/* Make the font a bit lighter */
lfFont.lfWeight -= 100;
hTextFont = CreateFontIndirect(&lfFont);
old_font = SelectObject(printer.hDC, hTextFont);
for (copy = 1; copy <= printer.nCopies; copy++)
{
page = 1;
tInfo.mptr = pTemp;
tInfo.mend = pTemp + size;
tInfo.lptr = cTemp;
tInfo.len = 0;
do {
if (printer.Flags & PD_PAGENUMS)
{
/* a specific range of pages is selected, so
* skip pages that are not to be printed
*/
if (page > printer.nToPage)
break;
else if (page >= printer.nFromPage)
dopage = 1;
else
dopage = 0;
}
else
dopage = 1;
ret = notepad_print_page(printer.hDC, &rc, dopage, page, &tInfo);
page++;
} while (ret && tInfo.mptr < tInfo.mend);
if (!ret) break;
}
EndDoc(printer.hDC);
SelectObject(printer.hDC, old_font);
DeleteObject(hTextFont);
}
DeleteDC(printer.hDC);
HeapFree(GetProcessHeap(), 0, pTemp);
}
VOID DIALOG_FilePrinterSetup(VOID)
{
PRINTDLG printer;
ZeroMemory(&printer, sizeof(printer));
printer.lStructSize = sizeof(printer);
printer.hwndOwner = Globals.hMainWnd;
printer.hDevMode = Globals.hDevMode;
printer.hDevNames = Globals.hDevNames;
printer.hInstance = Globals.hInstance;
printer.Flags = PD_PRINTSETUP;
printer.nCopies = 1;
PrintDlg(&printer);
Globals.hDevMode = printer.hDevMode;
Globals.hDevNames = printer.hDevNames;
}
VOID DIALOG_FileExit(VOID)
{
PostMessage(Globals.hMainWnd, WM_CLOSE, 0, 0l);
}
VOID DIALOG_EditUndo(VOID)
{
SendMessage(Globals.hEdit, EM_UNDO, 0, 0);
}
VOID DIALOG_EditCut(VOID)
{
SendMessage(Globals.hEdit, WM_CUT, 0, 0);
}
VOID DIALOG_EditCopy(VOID)
{
SendMessage(Globals.hEdit, WM_COPY, 0, 0);
}
VOID DIALOG_EditPaste(VOID)
{
SendMessage(Globals.hEdit, WM_PASTE, 0, 0);
}
VOID DIALOG_EditDelete(VOID)
{
SendMessage(Globals.hEdit, WM_CLEAR, 0, 0);
}
VOID DIALOG_EditSelectAll(VOID)
{
SendMessage(Globals.hEdit, EM_SETSEL, 0, (LPARAM)-1);
}
VOID DIALOG_EditTimeDate(VOID)
{
SYSTEMTIME st;
WCHAR szDate[MAX_STRING_LEN];
static const WCHAR spaceW[] = { ' ',0 };
GetLocalTime(&st);
GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, szDate, MAX_STRING_LEN);
SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)szDate);
SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)spaceW);
GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, szDate, MAX_STRING_LEN);
SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)szDate);
}
VOID DIALOG_EditWrap(VOID)
{
BOOL modify = FALSE;
static const WCHAR editW[] = { 'e','d','i','t',0 };
DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL |
ES_AUTOVSCROLL | ES_MULTILINE;
RECT rc;
DWORD size;
LPWSTR pTemp;
size = GetWindowTextLength(Globals.hEdit) + 1;
pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
if (!pTemp)
{
ShowLastError();
return;
}
GetWindowText(Globals.hEdit, pTemp, size);
modify = SendMessage(Globals.hEdit, EM_GETMODIFY, 0, 0);
DestroyWindow(Globals.hEdit);
GetClientRect(Globals.hMainWnd, &rc);
if( Globals.bWrapLongLines ) dwStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
Globals.hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, editW, NULL, dwStyle,
0, 0, rc.right, rc.bottom, Globals.hMainWnd,
NULL, Globals.hInstance, NULL);
SendMessage(Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, (LPARAM)FALSE);
SetWindowTextW(Globals.hEdit, pTemp);
SendMessage(Globals.hEdit, EM_SETMODIFY, (WPARAM)modify, 0);
SetFocus(Globals.hEdit);
HeapFree(GetProcessHeap(), 0, pTemp);
Globals.bWrapLongLines = !Globals.bWrapLongLines;
CheckMenuItem(GetMenu(Globals.hMainWnd), CMD_WRAP,
MF_BYCOMMAND | (Globals.bWrapLongLines ? MF_CHECKED : MF_UNCHECKED));
}
VOID DIALOG_SelectFont(VOID)
{
CHOOSEFONT cf;
LOGFONT lf=Globals.lfFont;
ZeroMemory( &cf, sizeof(cf) );
cf.lStructSize=sizeof(cf);
cf.hwndOwner=Globals.hMainWnd;
cf.lpLogFont=&lf;
cf.Flags=CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT;
if( ChooseFont(&cf) )
{
HFONT currfont=Globals.hFont;
Globals.hFont=CreateFontIndirect( &lf );
Globals.lfFont=lf;
SendMessage( Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, (LPARAM)TRUE );
if( currfont!=NULL )
DeleteObject( currfont );
}
}
VOID DIALOG_Search(VOID)
{
ZeroMemory(&Globals.find, sizeof(Globals.find));
Globals.find.lStructSize = sizeof(Globals.find);
Globals.find.hwndOwner = Globals.hMainWnd;
Globals.find.hInstance = Globals.hInstance;
Globals.find.lpstrFindWhat = Globals.szFindText;
Globals.find.wFindWhatLen = SIZEOF(Globals.szFindText);
Globals.find.Flags = FR_DOWN|FR_HIDEWHOLEWORD;
/* We only need to create the modal FindReplace dialog which will */
/* notify us of incoming events using hMainWnd Window Messages */
Globals.hFindReplaceDlg = FindText(&Globals.find);
assert(Globals.hFindReplaceDlg !=0);
}
VOID DIALOG_SearchNext(VOID)
{
if (Globals.lastFind.lpstrFindWhat == NULL)
DIALOG_Search();
else /* use the last find data */
NOTEPAD_DoFind(&Globals.lastFind);
}
VOID DIALOG_HelpContents(VOID)
{
WinHelp(Globals.hMainWnd, helpfileW, HELP_INDEX, 0);
}
VOID DIALOG_HelpSearch(VOID)
{
/* Search Help */
}
VOID DIALOG_HelpHelp(VOID)
{
WinHelp(Globals.hMainWnd, helpfileW, HELP_HELPONHELP, 0);
}
VOID DIALOG_HelpAboutNotepad(VOID)
{
static const WCHAR notepadW[] = { 'W','i','n','e',' ','N','o','t','e','p','a','d',0 };
WCHAR szNotepad[MAX_STRING_LEN];
HICON icon = LoadImageW( Globals.hInstance, MAKEINTRESOURCE(IDI_NOTEPAD),
IMAGE_ICON, 48, 48, LR_SHARED );
LoadString(Globals.hInstance, STRING_NOTEPAD, szNotepad, SIZEOF(szNotepad));
ShellAbout(Globals.hMainWnd, szNotepad, notepadW, icon);
}
/***********************************************************************
*
* DIALOG_FilePageSetup
*/
VOID DIALOG_FilePageSetup(void)
{
DialogBox(Globals.hInstance, MAKEINTRESOURCE(DIALOG_PAGESETUP),
Globals.hMainWnd, DIALOG_PAGESETUP_DlgProc);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* DIALOG_PAGESETUP_DlgProc
*/
static INT_PTR WINAPI DIALOG_PAGESETUP_DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_COMMAND:
switch (wParam)
{
case IDOK:
/* save user input and close dialog */
GetDlgItemText(hDlg, IDC_PAGESETUP_HEADERVALUE, Globals.szHeader, SIZEOF(Globals.szHeader));
GetDlgItemText(hDlg, IDC_PAGESETUP_FOOTERVALUE, Globals.szFooter, SIZEOF(Globals.szFooter));
Globals.iMarginTop = GetDlgItemInt(hDlg, IDC_PAGESETUP_TOPVALUE, NULL, FALSE) * 100;
Globals.iMarginBottom = GetDlgItemInt(hDlg, IDC_PAGESETUP_BOTTOMVALUE, NULL, FALSE) * 100;
Globals.iMarginLeft = GetDlgItemInt(hDlg, IDC_PAGESETUP_LEFTVALUE, NULL, FALSE) * 100;
Globals.iMarginRight = GetDlgItemInt(hDlg, IDC_PAGESETUP_RIGHTVALUE, NULL, FALSE) * 100;
EndDialog(hDlg, IDOK);
return TRUE;
case IDCANCEL:
/* discard user input and close dialog */
EndDialog(hDlg, IDCANCEL);
return TRUE;
case IDHELP:
{
/* FIXME: Bring this to work */
static const WCHAR sorryW[] = { 'S','o','r','r','y',',',' ','n','o',' ','h','e','l','p',' ','a','v','a','i','l','a','b','l','e',0 };
static const WCHAR helpW[] = { 'H','e','l','p',0 };
MessageBox(Globals.hMainWnd, sorryW, helpW, MB_ICONEXCLAMATION);
return TRUE;
}
default:
break;
}
break;
case WM_INITDIALOG:
/* fetch last user input prior to display dialog */
SetDlgItemText(hDlg, IDC_PAGESETUP_HEADERVALUE, Globals.szHeader);
SetDlgItemText(hDlg, IDC_PAGESETUP_FOOTERVALUE, Globals.szFooter);
SetDlgItemInt(hDlg, IDC_PAGESETUP_TOPVALUE, Globals.iMarginTop / 100, FALSE);
SetDlgItemInt(hDlg, IDC_PAGESETUP_BOTTOMVALUE, Globals.iMarginBottom / 100, FALSE);
SetDlgItemInt(hDlg, IDC_PAGESETUP_LEFTVALUE, Globals.iMarginLeft / 100, FALSE);
SetDlgItemInt(hDlg, IDC_PAGESETUP_RIGHTVALUE, Globals.iMarginRight / 100, FALSE);
break;
}
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink