| /* |
| * 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 |
| * Copyright 2010 Vitaly Perov |
| * |
| * 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; |
| |
| case ENCODING_UTF8: |
| LoadStringW(Globals.hInstance, STRING_UTF8, buffer, length); |
| break; |
| |
| case ENCODING_ANSI: |
| { |
| CPINFOEXW cpi; |
| GetCPInfoExW(CP_ACP, 0, &cpi); |
| lstrcpynW(buffer, cpi.CodePageName, length); |
| break; |
| } |
| |
| default: |
| assert(0 && "bad encoding in load_encoding_name"); |
| 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 }; |
| |
| nResult=GetWindowTextLengthW(Globals.hEdit); |
| if (SendMessageW(Globals.hEdit, EM_GETMODIFY, 0, 0) && |
| (nResult || Globals.szFileName[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 | FILE_SHARE_WRITE, 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 LPWSTR dialog_print_to_file(HWND hMainWnd) |
| { |
| OPENFILENAMEW ofn; |
| static WCHAR file[MAX_PATH] = {'o','u','t','p','u','t','.','p','r','n',0}; |
| static const WCHAR defExt[] = {'p','r','n',0}; |
| |
| ZeroMemory(&ofn, sizeof(ofn)); |
| |
| ofn.lStructSize = sizeof(ofn); |
| ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT; |
| ofn.hwndOwner = hMainWnd; |
| ofn.lpstrFile = file; |
| ofn.nMaxFile = MAX_PATH; |
| ofn.lpstrDefExt = defExt; |
| |
| if(GetSaveFileNameW(&ofn)) |
| return file; |
| else |
| return FALSE; |
| } |
| 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]; |
| static const WCHAR szDefaultExt[] = { 't','x','t',0 }; |
| static const WCHAR txt_files[] = { '*','.','t','x','t',0 }; |
| |
| ZeroMemory(&openfilename, sizeof(openfilename)); |
| |
| 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.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]; |
| static const WCHAR szDefaultExt[] = { 't','x','t',0 }; |
| static const WCHAR txt_files[] = { '*','.','t','x','t',0 }; |
| |
| ZeroMemory(&saveas, sizeof(saveas)); |
| |
| 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.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 WCHAR *expand_header_vars(WCHAR *pattern, int page) |
| { |
| int length = 0; |
| int i; |
| BOOL inside = FALSE; |
| WCHAR *buffer = NULL; |
| |
| for (i = 0; pattern[i]; i++) |
| { |
| if (inside) |
| { |
| if (pattern[i] == '&') |
| length++; |
| else if (pattern[i] == 'p') |
| length += 11; |
| inside = FALSE; |
| } |
| else if (pattern[i] == '&') |
| inside = TRUE; |
| else |
| length++; |
| } |
| |
| buffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR)); |
| if (buffer) |
| { |
| int j = 0; |
| inside = FALSE; |
| for (i = 0; pattern[i]; i++) |
| { |
| if (inside) |
| { |
| if (pattern[i] == '&') |
| buffer[j++] = '&'; |
| else if (pattern[i] == 'p') |
| { |
| static const WCHAR percent_dW[] = {'%','d',0}; |
| j += wnsprintfW(&buffer[j], 11, percent_dW, page); |
| } |
| inside = FALSE; |
| } |
| else if (pattern[i] == '&') |
| inside = TRUE; |
| else |
| buffer[j++] = pattern[i]; |
| } |
| buffer[j++] = 0; |
| } |
| return buffer; |
| } |
| |
| static BOOL notepad_print_page(HDC hdc, RECT *rc, BOOL dopage, int page, LPTEXTINFO tInfo) |
| { |
| int b, y; |
| TEXTMETRICW tm; |
| SIZE szMetrics; |
| WCHAR *footer_text = NULL; |
| |
| footer_text = expand_header_vars(Globals.szFooter, page); |
| if (footer_text == NULL) |
| return FALSE; |
| |
| 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); |
| HeapFree(GetProcessHeap(), 0, footer_text); |
| 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, footer_text) * 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, footer_text); |
| if (dopage) |
| { |
| EndPage(hdc); |
| } |
| HeapFree(GetProcessHeap(), 0, footer_text); |
| 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; |
| |
| if(printer.Flags & PD_PRINTTOFILE) |
| { |
| di.lpszOutput = dialog_print_to_file(printer.hwndOwner); |
| if(!di.lpszOutput) |
| return; |
| } |
| |
| /* 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; |
| } |
