mirror of
https://github.com/reactos/wine.git
synced 2024-12-06 10:46:36 +00:00
1191 lines
36 KiB
C
1191 lines
36 KiB
C
/*
|
|
* 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
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <windows.h>
|
|
#include <commdlg.h>
|
|
#include <shlwapi.h>
|
|
#include <winternl.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);
|
|
|
|
/* Swap bytes of WCHAR buffer (big-endian <-> little-endian). */
|
|
static inline void byteswap_wide_string(LPWSTR str, UINT num)
|
|
{
|
|
UINT i;
|
|
for (i = 0; i < num; i++) str[i] = RtlUshortByteSwap(str[i]);
|
|
}
|
|
|
|
static void load_encoding_name(ENCODING enc, WCHAR* buffer, int length)
|
|
{
|
|
switch (enc)
|
|
{
|
|
case ENCODING_UTF16LE:
|
|
LoadStringW(Globals.hInstance, STRING_UNICODE_LE, buffer, length);
|
|
break;
|
|
|
|
case ENCODING_UTF16BE:
|
|
LoadStringW(Globals.hInstance, STRING_UNICODE_BE, buffer, length);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
CPINFOEXW cpi;
|
|
GetCPInfoExW((enc==ENCODING_UTF8) ? CP_UTF8 : CP_ACP, 0, &cpi);
|
|
lstrcpynW(buffer, cpi.CodePageName, length);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID ShowLastError(void)
|
|
{
|
|
DWORD error = GetLastError();
|
|
if (error != NO_ERROR)
|
|
{
|
|
LPWSTR lpMsgBuf;
|
|
WCHAR szTitle[MAX_STRING_LEN];
|
|
|
|
LoadStringW(Globals.hInstance, STRING_ERROR, szTitle, ARRAY_SIZE(szTitle));
|
|
FormatMessageW(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, error, 0, (LPWSTR)&lpMsgBuf, 0, NULL);
|
|
MessageBoxW(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
|
|
*/
|
|
void UpdateWindowCaption(void)
|
|
{
|
|
WCHAR szCaption[MAX_STRING_LEN];
|
|
WCHAR szNotepad[MAX_STRING_LEN];
|
|
static const WCHAR hyphenW[] = { ' ','-',' ',0 };
|
|
|
|
if (Globals.szFileTitle[0] != '\0')
|
|
lstrcpyW(szCaption, Globals.szFileTitle);
|
|
else
|
|
LoadStringW(Globals.hInstance, STRING_UNTITLED, szCaption, ARRAY_SIZE(szCaption));
|
|
|
|
LoadStringW(Globals.hInstance, STRING_NOTEPAD, szNotepad, ARRAY_SIZE(szNotepad));
|
|
lstrcatW(szCaption, hyphenW);
|
|
lstrcatW(szCaption, szNotepad);
|
|
|
|
SetWindowTextW(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 */
|
|
LoadStringW(Globals.hInstance, formatId, szResource, ARRAY_SIZE(szResource));
|
|
wnsprintfW(szMessage, ARRAY_SIZE(szMessage), szResource, szString);
|
|
|
|
/* Load szCaption */
|
|
if ((dwFlags & MB_ICONMASK) == MB_ICONEXCLAMATION)
|
|
LoadStringW(Globals.hInstance, STRING_ERROR, szResource, ARRAY_SIZE(szResource));
|
|
else
|
|
LoadStringW(Globals.hInstance, STRING_NOTEPAD, szResource, ARRAY_SIZE(szResource));
|
|
|
|
/* Display Modal Dialog */
|
|
if (hParent == NULL)
|
|
hParent = Globals.hMainWnd;
|
|
return MessageBoxW(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];
|
|
|
|
LoadStringW(Globals.hInstance, STRING_UNTITLED, szUntitled, ARRAY_SIZE(szUntitled));
|
|
return DIALOG_StringMsgBox(NULL, STRING_NOTSAVED, szFileName[0] ? szFileName : szUntitled,
|
|
MB_ICONQUESTION|MB_YESNOCANCEL);
|
|
}
|
|
|
|
static int AlertUnicodeCharactersLost(LPCWSTR szFileName)
|
|
{
|
|
WCHAR szMsgFormat[MAX_STRING_LEN];
|
|
WCHAR szEnc[MAX_STRING_LEN];
|
|
WCHAR szMsg[ARRAY_SIZE(szMsgFormat) + MAX_PATH + ARRAY_SIZE(szEnc)];
|
|
WCHAR szCaption[MAX_STRING_LEN];
|
|
|
|
LoadStringW(Globals.hInstance, STRING_LOSS_OF_UNICODE_CHARACTERS,
|
|
szMsgFormat, ARRAY_SIZE(szMsgFormat));
|
|
load_encoding_name(ENCODING_ANSI, szEnc, ARRAY_SIZE(szEnc));
|
|
wnsprintfW(szMsg, ARRAY_SIZE(szMsg), szMsgFormat, szFileName, szEnc);
|
|
LoadStringW(Globals.hInstance, STRING_NOTEPAD, szCaption,
|
|
ARRAY_SIZE(szCaption));
|
|
return MessageBoxW(Globals.hMainWnd, szMsg, szCaption,
|
|
MB_OKCANCEL|MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
/**
|
|
* Returns:
|
|
* TRUE - if file exists
|
|
* FALSE - if file does not exist
|
|
*/
|
|
BOOL FileExists(LPCWSTR szFilename)
|
|
{
|
|
WIN32_FIND_DATAW entry;
|
|
HANDLE hFile;
|
|
|
|
hFile = FindFirstFileW(szFilename, &entry);
|
|
FindClose(hFile);
|
|
|
|
return (hFile != INVALID_HANDLE_VALUE);
|
|
}
|
|
|
|
static inline BOOL is_conversion_to_ansi_lossy(LPCWSTR textW, int lenW)
|
|
{
|
|
BOOL ret = FALSE;
|
|
WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, textW, lenW, NULL, 0,
|
|
NULL, &ret);
|
|
return ret;
|
|
}
|
|
|
|
typedef enum
|
|
{
|
|
SAVED_OK,
|
|
SAVE_FAILED,
|
|
SHOW_SAVEAS_DIALOG
|
|
} SAVE_STATUS;
|
|
|
|
/* szFileName is the filename to save under; enc is the encoding to use.
|
|
*
|
|
* If the function succeeds, it returns SAVED_OK.
|
|
* If the function fails, it returns SAVE_FAILED.
|
|
* If Unicode data could be lost due to conversion to a non-Unicode character
|
|
* set, a warning is displayed. The user can continue (and the function carries
|
|
* on), or cancel (and the function returns SHOW_SAVEAS_DIALOG).
|
|
*/
|
|
static SAVE_STATUS DoSaveFile(LPCWSTR szFileName, ENCODING enc)
|
|
{
|
|
int lenW;
|
|
WCHAR* textW;
|
|
HANDLE hFile;
|
|
DWORD dwNumWrite;
|
|
PVOID pBytes;
|
|
DWORD size;
|
|
|
|
/* lenW includes the byte-order mark, but not the \0. */
|
|
lenW = GetWindowTextLengthW(Globals.hEdit) + 1;
|
|
textW = HeapAlloc(GetProcessHeap(), 0, (lenW+1) * sizeof(WCHAR));
|
|
if (!textW)
|
|
{
|
|
ShowLastError();
|
|
return SAVE_FAILED;
|
|
}
|
|
textW[0] = (WCHAR) 0xfeff;
|
|
lenW = GetWindowTextW(Globals.hEdit, textW+1, lenW) + 1;
|
|
|
|
switch (enc)
|
|
{
|
|
case ENCODING_UTF16BE:
|
|
byteswap_wide_string(textW, lenW);
|
|
/* fall through */
|
|
|
|
case ENCODING_UTF16LE:
|
|
size = lenW * sizeof(WCHAR);
|
|
pBytes = textW;
|
|
break;
|
|
|
|
case ENCODING_UTF8:
|
|
size = WideCharToMultiByte(CP_UTF8, 0, textW, lenW, NULL, 0, NULL, NULL);
|
|
pBytes = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!pBytes)
|
|
{
|
|
ShowLastError();
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
return SAVE_FAILED;
|
|
}
|
|
WideCharToMultiByte(CP_UTF8, 0, textW, lenW, pBytes, size, NULL, NULL);
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
break;
|
|
|
|
default:
|
|
if (is_conversion_to_ansi_lossy(textW+1, lenW-1)
|
|
&& AlertUnicodeCharactersLost(szFileName) == IDCANCEL)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
return SHOW_SAVEAS_DIALOG;
|
|
}
|
|
|
|
size = WideCharToMultiByte(CP_ACP, 0, textW+1, lenW-1, NULL, 0, NULL, NULL);
|
|
pBytes = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!pBytes)
|
|
{
|
|
ShowLastError();
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
return SAVE_FAILED;
|
|
}
|
|
WideCharToMultiByte(CP_ACP, 0, textW+1, lenW-1, pBytes, size, NULL, NULL);
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
break;
|
|
}
|
|
|
|
hFile = CreateFileW(szFileName, GENERIC_WRITE, FILE_SHARE_WRITE,
|
|
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if(hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
ShowLastError();
|
|
HeapFree(GetProcessHeap(), 0, pBytes);
|
|
return SAVE_FAILED;
|
|
}
|
|
if (!WriteFile(hFile, pBytes, size, &dwNumWrite, NULL))
|
|
{
|
|
ShowLastError();
|
|
CloseHandle(hFile);
|
|
HeapFree(GetProcessHeap(), 0, pBytes);
|
|
return SAVE_FAILED;
|
|
}
|
|
SetEndOfFile(hFile);
|
|
CloseHandle(hFile);
|
|
HeapFree(GetProcessHeap(), 0, pBytes);
|
|
|
|
SendMessageW(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
|
|
return SAVED_OK;
|
|
}
|
|
|
|
/**
|
|
* 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 (SendMessageW(Globals.hEdit, EM_GETMODIFY, 0, 0))
|
|
{
|
|
/* prompt user to save changes */
|
|
nResult = AlertFileNotSaved(Globals.szFileName);
|
|
switch (nResult) {
|
|
case IDYES: return DIALOG_FileSave();
|
|
|
|
case IDNO: break;
|
|
|
|
case IDCANCEL: return(FALSE);
|
|
|
|
default: return(FALSE);
|
|
} /* switch */
|
|
} /* if */
|
|
|
|
SetFileNameAndEncoding(empty_strW, ENCODING_ANSI);
|
|
|
|
UpdateWindowCaption();
|
|
return(TRUE);
|
|
}
|
|
|
|
static inline ENCODING detect_encoding_of_buffer(const void* buffer, int size)
|
|
{
|
|
static const char bom_utf8[] = { 0xef, 0xbb, 0xbf };
|
|
if (size >= sizeof(bom_utf8) && !memcmp(buffer, bom_utf8, sizeof(bom_utf8)))
|
|
return ENCODING_UTF8;
|
|
else
|
|
{
|
|
int flags = IS_TEXT_UNICODE_SIGNATURE |
|
|
IS_TEXT_UNICODE_REVERSE_SIGNATURE |
|
|
IS_TEXT_UNICODE_ODD_LENGTH;
|
|
IsTextUnicode(buffer, size, &flags);
|
|
if (flags & IS_TEXT_UNICODE_SIGNATURE)
|
|
return ENCODING_UTF16LE;
|
|
else if (flags & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
|
|
return ENCODING_UTF16BE;
|
|
else
|
|
return ENCODING_ANSI;
|
|
}
|
|
}
|
|
|
|
void DoOpenFile(LPCWSTR szFileName, ENCODING enc)
|
|
{
|
|
static const WCHAR dotlog[] = { '.','L','O','G',0 };
|
|
HANDLE hFile;
|
|
LPSTR pTemp;
|
|
DWORD size;
|
|
DWORD dwNumRead;
|
|
int lenW;
|
|
WCHAR* textW;
|
|
int i;
|
|
WCHAR log[5];
|
|
|
|
/* Close any files and prompt to save changes */
|
|
if (!DoCloseFile())
|
|
return;
|
|
|
|
hFile = CreateFileW(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;
|
|
}
|
|
|
|
/* Extra memory for (WCHAR)'\0'-termination. */
|
|
pTemp = HeapAlloc(GetProcessHeap(), 0, size+2);
|
|
if (!pTemp)
|
|
{
|
|
CloseHandle(hFile);
|
|
ShowLastError();
|
|
return;
|
|
}
|
|
|
|
if (!ReadFile(hFile, pTemp, size, &dwNumRead, NULL))
|
|
{
|
|
CloseHandle(hFile);
|
|
HeapFree(GetProcessHeap(), 0, pTemp);
|
|
ShowLastError();
|
|
return;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
|
|
size = dwNumRead;
|
|
|
|
if (enc == ENCODING_AUTO)
|
|
enc = detect_encoding_of_buffer(pTemp, size);
|
|
else if (size >= 2 && (enc==ENCODING_UTF16LE || enc==ENCODING_UTF16BE))
|
|
{
|
|
/* If UTF-16 (BE or LE) is selected, and there is a UTF-16 BOM,
|
|
* override the selection (like native Notepad).
|
|
*/
|
|
if ((BYTE)pTemp[0] == 0xff && (BYTE)pTemp[1] == 0xfe)
|
|
enc = ENCODING_UTF16LE;
|
|
else if ((BYTE)pTemp[0] == 0xfe && (BYTE)pTemp[1] == 0xff)
|
|
enc = ENCODING_UTF16BE;
|
|
}
|
|
|
|
switch (enc)
|
|
{
|
|
case ENCODING_UTF16BE:
|
|
byteswap_wide_string((WCHAR*) pTemp, size/sizeof(WCHAR));
|
|
/* Forget whether the file is BE or LE, like native Notepad. */
|
|
enc = ENCODING_UTF16LE;
|
|
|
|
/* fall through */
|
|
|
|
case ENCODING_UTF16LE:
|
|
textW = (LPWSTR)pTemp;
|
|
lenW = size/sizeof(WCHAR);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
int cp = (enc==ENCODING_UTF8) ? CP_UTF8 : CP_ACP;
|
|
lenW = MultiByteToWideChar(cp, 0, pTemp, size, NULL, 0);
|
|
textW = HeapAlloc(GetProcessHeap(), 0, (lenW+1) * sizeof(WCHAR));
|
|
if (!textW)
|
|
{
|
|
ShowLastError();
|
|
HeapFree(GetProcessHeap(), 0, pTemp);
|
|
return;
|
|
}
|
|
MultiByteToWideChar(cp, 0, pTemp, size, textW, lenW);
|
|
HeapFree(GetProcessHeap(), 0, pTemp);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Replace '\0's with spaces. Other than creating a custom control that
|
|
* can deal with '\0' characters, it's the best that can be done.
|
|
*/
|
|
for (i = 0; i < lenW; i++)
|
|
if (textW[i] == '\0')
|
|
textW[i] = ' ';
|
|
textW[lenW] = '\0';
|
|
|
|
if (lenW >= 1 && textW[0] == 0xfeff)
|
|
SetWindowTextW(Globals.hEdit, textW+1);
|
|
else
|
|
SetWindowTextW(Globals.hEdit, textW);
|
|
|
|
HeapFree(GetProcessHeap(), 0, textW);
|
|
|
|
SendMessageW(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
|
|
SendMessageW(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, ARRAY_SIZE(log)) && !lstrcmpW(log, dotlog))
|
|
{
|
|
static const WCHAR lfW[] = { '\r','\n',0 };
|
|
SendMessageW(Globals.hEdit, EM_SETSEL, GetWindowTextLengthW(Globals.hEdit), -1);
|
|
SendMessageW(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
|
|
DIALOG_EditTimeDate();
|
|
SendMessageW(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
|
|
}
|
|
|
|
SetFileNameAndEncoding(szFileName, enc);
|
|
UpdateWindowCaption();
|
|
}
|
|
|
|
VOID DIALOG_FileNew(VOID)
|
|
{
|
|
static const WCHAR empty_strW[] = { 0 };
|
|
|
|
/* Close any files and prompt to save changes */
|
|
if (DoCloseFile()) {
|
|
SetWindowTextW(Globals.hEdit, empty_strW);
|
|
SendMessageW(Globals.hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
|
|
SetFocus(Globals.hEdit);
|
|
}
|
|
}
|
|
|
|
/* Used to detect encoding of files selected in Open dialog.
|
|
* Returns ENCODING_AUTO if file can't be read, etc.
|
|
*/
|
|
static ENCODING detect_encoding_of_file(LPCWSTR szFileName)
|
|
{
|
|
DWORD size;
|
|
HANDLE hFile = CreateFileW(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return ENCODING_AUTO;
|
|
size = GetFileSize(hFile, NULL);
|
|
if (size == INVALID_FILE_SIZE)
|
|
{
|
|
CloseHandle(hFile);
|
|
return ENCODING_AUTO;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwNumRead;
|
|
BYTE buffer[MAX_STRING_LEN];
|
|
if (!ReadFile(hFile, buffer, min(size, sizeof(buffer)), &dwNumRead, NULL))
|
|
{
|
|
CloseHandle(hFile);
|
|
return ENCODING_AUTO;
|
|
}
|
|
CloseHandle(hFile);
|
|
return detect_encoding_of_buffer(buffer, dwNumRead);
|
|
}
|
|
}
|
|
|
|
static UINT_PTR CALLBACK OfnHookProc(HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static HWND hEncCombo;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
ENCODING enc;
|
|
hEncCombo = GetDlgItem(hdlg, IDC_OFN_ENCCOMBO);
|
|
for (enc = MIN_ENCODING; enc <= MAX_ENCODING; enc++)
|
|
{
|
|
WCHAR szEnc[MAX_STRING_LEN];
|
|
load_encoding_name(enc, szEnc, ARRAY_SIZE(szEnc));
|
|
SendMessageW(hEncCombo, CB_ADDSTRING, 0, (LPARAM)szEnc);
|
|
}
|
|
SendMessageW(hEncCombo, CB_SETCURSEL, (WPARAM)Globals.encOfnCombo, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if (LOWORD(wParam) == IDC_OFN_ENCCOMBO &&
|
|
HIWORD(wParam) == CBN_SELCHANGE)
|
|
{
|
|
int index = SendMessageW(hEncCombo, CB_GETCURSEL, 0, 0);
|
|
Globals.encOfnCombo = index==CB_ERR ? ENCODING_ANSI : (ENCODING)index;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
switch (((OFNOTIFYW*)lParam)->hdr.code)
|
|
{
|
|
case CDN_SELCHANGE:
|
|
if (Globals.bOfnIsOpenDialog)
|
|
{
|
|
/* Check the start of the selected file for a BOM. */
|
|
ENCODING enc;
|
|
WCHAR szFileName[MAX_PATH];
|
|
SendMessageW(GetParent(hdlg), CDM_GETFILEPATH,
|
|
ARRAY_SIZE(szFileName), (LPARAM)szFileName);
|
|
enc = detect_encoding_of_file(szFileName);
|
|
if (enc != ENCODING_AUTO)
|
|
{
|
|
Globals.encOfnCombo = enc;
|
|
SendMessageW(hEncCombo, CB_SETCURSEL, (WPARAM)enc, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VOID DIALOG_FileOpen(VOID)
|
|
{
|
|
OPENFILENAMEW 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));
|
|
|
|
GetCurrentDirectoryW(ARRAY_SIZE(szDir), szDir);
|
|
lstrcpyW(szPath, txt_files);
|
|
|
|
openfilename.lStructSize = sizeof(openfilename);
|
|
openfilename.hwndOwner = Globals.hMainWnd;
|
|
openfilename.hInstance = Globals.hInstance;
|
|
openfilename.lpstrFilter = Globals.szFilter;
|
|
openfilename.lpstrFile = szPath;
|
|
openfilename.nMaxFile = ARRAY_SIZE(szPath);
|
|
openfilename.lpstrInitialDir = szDir;
|
|
openfilename.Flags = OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_EXPLORER |
|
|
OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST |
|
|
OFN_HIDEREADONLY | OFN_ENABLESIZING;
|
|
openfilename.lpfnHook = OfnHookProc;
|
|
openfilename.lpTemplateName = MAKEINTRESOURCEW(IDD_OFN_TEMPLATE);
|
|
openfilename.lpstrDefExt = szDefaultExt;
|
|
|
|
Globals.encOfnCombo = ENCODING_ANSI;
|
|
Globals.bOfnIsOpenDialog = TRUE;
|
|
|
|
if (GetOpenFileNameW(&openfilename))
|
|
DoOpenFile(openfilename.lpstrFile, Globals.encOfnCombo);
|
|
}
|
|
|
|
/* Return FALSE to cancel close */
|
|
BOOL DIALOG_FileSave(VOID)
|
|
{
|
|
if (Globals.szFileName[0] == '\0')
|
|
return DIALOG_FileSaveAs();
|
|
else
|
|
{
|
|
switch (DoSaveFile(Globals.szFileName, Globals.encFile))
|
|
{
|
|
case SAVED_OK: return TRUE;
|
|
case SHOW_SAVEAS_DIALOG: return DIALOG_FileSaveAs();
|
|
default: return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL DIALOG_FileSaveAs(VOID)
|
|
{
|
|
OPENFILENAMEW 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));
|
|
|
|
GetCurrentDirectoryW(ARRAY_SIZE(szDir), szDir);
|
|
lstrcpyW(szPath, txt_files);
|
|
|
|
saveas.lStructSize = sizeof(OPENFILENAMEW);
|
|
saveas.hwndOwner = Globals.hMainWnd;
|
|
saveas.hInstance = Globals.hInstance;
|
|
saveas.lpstrFilter = Globals.szFilter;
|
|
saveas.lpstrFile = szPath;
|
|
saveas.nMaxFile = ARRAY_SIZE(szPath);
|
|
saveas.lpstrInitialDir = szDir;
|
|
saveas.Flags = OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_EXPLORER |
|
|
OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT |
|
|
OFN_HIDEREADONLY | OFN_ENABLESIZING;
|
|
saveas.lpfnHook = OfnHookProc;
|
|
saveas.lpTemplateName = MAKEINTRESOURCEW(IDD_OFN_TEMPLATE);
|
|
saveas.lpstrDefExt = szDefaultExt;
|
|
|
|
/* Preset encoding to what file was opened/saved last with. */
|
|
Globals.encOfnCombo = Globals.encFile;
|
|
Globals.bOfnIsOpenDialog = FALSE;
|
|
|
|
retry:
|
|
if (!GetSaveFileNameW(&saveas))
|
|
return FALSE;
|
|
|
|
switch (DoSaveFile(szPath, Globals.encOfnCombo))
|
|
{
|
|
case SAVED_OK:
|
|
SetFileNameAndEncoding(szPath, Globals.encOfnCombo);
|
|
UpdateWindowCaption();
|
|
return TRUE;
|
|
|
|
case SHOW_SAVEAS_DIALOG:
|
|
goto retry;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
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 */
|
|
GetTextExtentPoint32W(hdc, text, lstrlenW(text), &szMetric);
|
|
if (dopage)
|
|
ExtTextOutW(hdc, (rc->left + rc->right - szMetric.cx) / 2,
|
|
header ? rc->top : rc->bottom - szMetric.cy,
|
|
ETO_CLIPPED, rc, text, lstrlenW(text), NULL);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static BOOL notepad_print_page(HDC hdc, RECT *rc, BOOL dopage, int page, LPTEXTINFO tInfo)
|
|
{
|
|
int b, y;
|
|
TEXTMETRICW 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 };
|
|
MessageBoxW(Globals.hMainWnd, failedW, errorW, MB_ICONEXCLAMATION);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
GetTextMetricsW(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)
|
|
{
|
|
GetTextExtentExPointW(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)
|
|
ExtTextOutW(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)
|
|
{
|
|
DOCINFOW di;
|
|
PRINTDLGW printer;
|
|
int page, dopage, copy;
|
|
LOGFONTW 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 (!PrintDlgW(&printer)) return;
|
|
|
|
Globals.hDevMode = printer.hDevMode;
|
|
Globals.hDevNames = printer.hDevNames;
|
|
|
|
SetMapMode(printer.hDC, MM_TEXT);
|
|
|
|
/* initialize DOCINFO */
|
|
di.cbSize = sizeof(DOCINFOW);
|
|
di.lpszDocName = Globals.szFileTitle;
|
|
di.lpszOutput = NULL;
|
|
di.lpszDatatype = NULL;
|
|
di.fwType = 0;
|
|
|
|
/* Get the file text */
|
|
size = GetWindowTextLengthW(Globals.hEdit) + 1;
|
|
pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
|
|
if (!pTemp)
|
|
{
|
|
DeleteDC(printer.hDC);
|
|
ShowLastError();
|
|
return;
|
|
}
|
|
size = GetWindowTextW(Globals.hEdit, pTemp, size);
|
|
|
|
if (StartDocW(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 = CreateFontIndirectW(&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)
|
|
{
|
|
PRINTDLGW 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;
|
|
|
|
PrintDlgW(&printer);
|
|
|
|
Globals.hDevMode = printer.hDevMode;
|
|
Globals.hDevNames = printer.hDevNames;
|
|
}
|
|
|
|
VOID DIALOG_FileExit(VOID)
|
|
{
|
|
PostMessageW(Globals.hMainWnd, WM_CLOSE, 0, 0l);
|
|
}
|
|
|
|
VOID DIALOG_EditUndo(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, EM_UNDO, 0, 0);
|
|
}
|
|
|
|
VOID DIALOG_EditCut(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, WM_CUT, 0, 0);
|
|
}
|
|
|
|
VOID DIALOG_EditCopy(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, WM_COPY, 0, 0);
|
|
}
|
|
|
|
VOID DIALOG_EditPaste(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, WM_PASTE, 0, 0);
|
|
}
|
|
|
|
VOID DIALOG_EditDelete(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, WM_CLEAR, 0, 0);
|
|
}
|
|
|
|
VOID DIALOG_EditSelectAll(VOID)
|
|
{
|
|
SendMessageW(Globals.hEdit, EM_SETSEL, 0, -1);
|
|
}
|
|
|
|
VOID DIALOG_EditTimeDate(VOID)
|
|
{
|
|
SYSTEMTIME st;
|
|
WCHAR szDate[MAX_STRING_LEN];
|
|
static const WCHAR spaceW[] = { ' ',0 };
|
|
|
|
GetLocalTime(&st);
|
|
|
|
GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, szDate, MAX_STRING_LEN);
|
|
SendMessageW(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)szDate);
|
|
|
|
SendMessageW(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)spaceW);
|
|
|
|
GetDateFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, szDate, MAX_STRING_LEN);
|
|
SendMessageW(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 = GetWindowTextLengthW(Globals.hEdit) + 1;
|
|
pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
|
|
if (!pTemp)
|
|
{
|
|
ShowLastError();
|
|
return;
|
|
}
|
|
GetWindowTextW(Globals.hEdit, pTemp, size);
|
|
modify = SendMessageW(Globals.hEdit, EM_GETMODIFY, 0, 0);
|
|
DestroyWindow(Globals.hEdit);
|
|
GetClientRect(Globals.hMainWnd, &rc);
|
|
if( Globals.bWrapLongLines ) dwStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
|
|
Globals.hEdit = CreateWindowExW(WS_EX_CLIENTEDGE, editW, NULL, dwStyle,
|
|
0, 0, rc.right, rc.bottom, Globals.hMainWnd,
|
|
NULL, Globals.hInstance, NULL);
|
|
SendMessageW(Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, FALSE);
|
|
SetWindowTextW(Globals.hEdit, pTemp);
|
|
SendMessageW(Globals.hEdit, EM_SETMODIFY, 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)
|
|
{
|
|
CHOOSEFONTW cf;
|
|
LOGFONTW 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( ChooseFontW(&cf) )
|
|
{
|
|
HFONT currfont=Globals.hFont;
|
|
|
|
Globals.hFont=CreateFontIndirectW( &lf );
|
|
Globals.lfFont=lf;
|
|
SendMessageW( Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, TRUE );
|
|
if( currfont!=NULL )
|
|
DeleteObject( currfont );
|
|
}
|
|
}
|
|
|
|
VOID DIALOG_Search(VOID)
|
|
{
|
|
/* Allow only one search/replace dialog to open */
|
|
if(Globals.hFindReplaceDlg != NULL)
|
|
{
|
|
SetActiveWindow(Globals.hFindReplaceDlg);
|
|
return;
|
|
}
|
|
|
|
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 = ARRAY_SIZE(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 = FindTextW(&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_Replace(VOID)
|
|
{
|
|
/* Allow only one search/replace dialog to open */
|
|
if(Globals.hFindReplaceDlg != NULL)
|
|
{
|
|
SetActiveWindow(Globals.hFindReplaceDlg);
|
|
return;
|
|
}
|
|
|
|
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 = ARRAY_SIZE(Globals.szFindText);
|
|
Globals.find.lpstrReplaceWith = Globals.szReplaceText;
|
|
Globals.find.wReplaceWithLen = ARRAY_SIZE(Globals.szReplaceText);
|
|
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 = ReplaceTextW(&Globals.find);
|
|
assert(Globals.hFindReplaceDlg !=0);
|
|
}
|
|
|
|
VOID DIALOG_HelpContents(VOID)
|
|
{
|
|
WinHelpW(Globals.hMainWnd, helpfileW, HELP_INDEX, 0);
|
|
}
|
|
|
|
VOID DIALOG_HelpSearch(VOID)
|
|
{
|
|
/* Search Help */
|
|
}
|
|
|
|
VOID DIALOG_HelpHelp(VOID)
|
|
{
|
|
WinHelpW(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, MAKEINTRESOURCEW(IDI_NOTEPAD),
|
|
IMAGE_ICON, 48, 48, LR_SHARED);
|
|
|
|
LoadStringW(Globals.hInstance, STRING_NOTEPAD, szNotepad, ARRAY_SIZE(szNotepad));
|
|
ShellAboutW(Globals.hMainWnd, szNotepad, notepadW, icon);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* DIALOG_FilePageSetup
|
|
*/
|
|
VOID DIALOG_FilePageSetup(void)
|
|
{
|
|
DialogBoxW(Globals.hInstance, MAKEINTRESOURCEW(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 */
|
|
GetDlgItemTextW(hDlg, IDC_PAGESETUP_HEADERVALUE, Globals.szHeader, ARRAY_SIZE(Globals.szHeader));
|
|
GetDlgItemTextW(hDlg, IDC_PAGESETUP_FOOTERVALUE, Globals.szFooter, ARRAY_SIZE(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 };
|
|
MessageBoxW(Globals.hMainWnd, sorryW, helpW, MB_ICONEXCLAMATION);
|
|
return TRUE;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
/* fetch last user input prior to display dialog */
|
|
SetDlgItemTextW(hDlg, IDC_PAGESETUP_HEADERVALUE, Globals.szHeader);
|
|
SetDlgItemTextW(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;
|
|
}
|