OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/shell/osshell/accesory/newpad/npfile.c

1081 lines
29 KiB
C
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*
* npfile.c - Routines for file i/o for notepad
* Copyright (C) 1984-2000 Microsoft Corporation
*/
#include "precomp.h"
HANDLE hFirstMem;
const CHAR BOM_UTF8[3] = {(BYTE) 0xEF, (BYTE) 0xBB, (BYTE)0xBF};
//****************************************************************
//
// ReverseEndian
//
// Purpose: copies unicode character from one endian source
// to another.
//
// may work on lpDst == lpSrc
//
VOID ReverseEndian( PTCHAR lpDst, PTCHAR lpSrc, DWORD nChars )
{
DWORD cnt;
for( cnt=0; cnt < nChars; cnt++,lpDst++,lpSrc++ )
{
*lpDst= (TCHAR) (((*lpSrc<<8) & 0xFF00) + ((*lpSrc>>8)&0xFF));
}
}
//*****************************************************************
//
// AnsiWriteFile()
//
// Purpose : To simulate the effects of _lwrite() in a Unicode
// environment by converting to ANSI buffer and
// writing out the ANSI text.
// Returns : TRUE is successful, FALSE if not
// GetLastError() will have the error code.
//
//*****************************************************************
BOOL AnsiWriteFile(HANDLE hFile, // file to write to
UINT uCodePage, // code page to convert unicode to
LPVOID lpBuffer, // unicode buffer
DWORD nChars, // number of unicode chars
DWORD nBytes ) // number of ascii chars to produce
{
LPSTR lpAnsi; // pointer to allocate buffer
BOOL Done; // status from write (returned)
DWORD nBytesWritten; // number of bytes written
lpAnsi= (LPSTR) LocalAlloc( LPTR, nBytes + 1 );
if( !lpAnsi )
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return (FALSE);
}
ConvertFromUnicode(uCodePage, // code page
g_fSaveEntity, // fNoBestFit
g_fSaveEntity, // fWriteEntities
(LPWSTR) lpBuffer, // wide char buffer
nChars, // chars in wide char buffer
lpAnsi, // resultant ascii string
nBytes, // size of ascii string buffer
NULL); // flag to set if default char used
Done = WriteFile(hFile, lpAnsi, nBytes, &nBytesWritten, NULL);
LocalFree(lpAnsi);
return(Done);
} // end of AnsiWriteFile()
// Routines to deal with the soft EOL formatting.
//
// MLE Actually inserts characters into the text being under edit, so they
// have to be removed before saving the file.
//
// It turns out that MLE will get confused if the current line is bigger than
// the current file, so we will reset the cursor to 0,0 to keep it from looking stupid.
// Should be fixed in MLE, but...
//
VOID ClearFmt(VOID)
{
if( fWrap )
{
GotoAndScrollInView( 1 );
SendMessage( hwndEdit, EM_FMTLINES, (WPARAM)FALSE, 0 );// remove soft EOLs
}
}
VOID RestoreFmt(VOID)
{
if( fWrap )
{
NpReCreate( ES_STD ); // slow but it works
}
}
BOOL FDetectEncodingW(LPCTSTR szFile, LPCWSTR rgch, UINT cch, UINT *pcp)
{
TCHAR szExt[_MAX_EXT];
if (FDetectXmlEncodingW(rgch, cch, pcp))
{
// We recognized this as an XML file with a valid encoding
return TRUE;
}
if (FDetectHtmlEncodingW(rgch, cch, pcp))
{
// We recognized this as an HTML file with a valid encoding
return TRUE;
}
_wsplitpath(szFile, NULL, NULL, NULL, szExt);
if (lstrcmpi(szExt, TEXT(".css")) == 0)
{
if (FDetectCssEncodingW(rgch, cch, pcp))
{
// We recognized this as CSS file with a valid encoding
return TRUE;
}
}
return FALSE;
}
/* Save notepad file to disk. szFileSave points to filename. fSaveAs
is TRUE iff we are being called from SaveAsDlgProc. This implies we must
open file on current directory, whether or not it already exists there
or somewhere else in our search path.
Assumes that text exists within hwndEdit. 30 July 1991 Clark Cyr
*/
BOOL SaveFile(HWND hwndParent, LPCTSTR szFile, BOOL fSaveAs)
{
LPTSTR lpch;
UINT nChars;
BOOL flag;
BOOL fNew = FALSE;
BOOL fSaveEntity;
BOOL fDefCharUsed = FALSE;
BOOL* pfDefCharUsed;
static const WCHAR wchBOM = BYTE_ORDER_MARK;
static const WCHAR wchRBOM = REVERSE_BYTE_ORDER_MARK;
HLOCAL hEText; // handle to MLE text
UINT cpDetected;
DWORD nBytesWritten; // number of bytes written
UINT cchMbcs; // length of equivalent MBCS file
if (g_cpSave == CP_AUTO)
{
UINT cch;
HANDLE hText;
int id;
g_cpSave = g_cpOpened;
// Check for an HTML or XML file with a declared encoding
// If one is found, suggest the declared encoding
cch = (UINT) SendMessage(hwndEdit, WM_GETTEXTLENGTH, 0, 0);
hText = (HANDLE) SendMessage(hwndEdit, EM_GETHANDLE, 0, 0);
if (hText != NULL)
{
LPCTSTR rgwch = (LPTSTR) LocalLock(hText);
if (rgwch != NULL)
{
if (FDetectEncodingW(szFile, rgwch, cch, &cpDetected))
{
// We detected an expected encoding for this file
g_cpSave = cpDetected;
}
LocalUnlock(hText);
}
}
id = (int) DialogBoxParam(hInstanceNP,
MAKEINTRESOURCE(IDD_SELECT_ENCODING),
hwndNP,
SelectEncodingDlgProc,
(LPARAM) &g_cpSave);
if (id == IDCANCEL)
{
return(FALSE);
}
}
/* If saving to an existing file, make sure correct disk is in drive */
if (!fSaveAs)
{
fp = CreateFile(szFile, // name of file
GENERIC_READ|GENERIC_WRITE, // access mode
FILE_SHARE_READ, // share mode
NULL, // security descriptor
OPEN_EXISTING, // how to create
FILE_ATTRIBUTE_NORMAL, // file attributes
NULL); // hnd of file with attrs
}
else
{
// Carefully open the file. Do not truncate it if it exists.
// set the fNew flag if it had to be created.
// We do all this in case of failures later in the process.
fp = CreateFile(szFile, // name of file
GENERIC_READ|GENERIC_WRITE, // access mode
FILE_SHARE_READ|FILE_SHARE_WRITE, // share mode
NULL, // security descriptor
OPEN_ALWAYS, // how to create
FILE_ATTRIBUTE_NORMAL, // file attributes
NULL); // hnd of file with attrs
if( fp != INVALID_HANDLE_VALUE )
{
fNew= (GetLastError() != ERROR_ALREADY_EXISTS );
}
}
if( fp == INVALID_HANDLE_VALUE )
{
if (fSaveAs)
AlertBox( hwndParent, szNN, szCREATEERR, szFile,
MB_APPLMODAL | MB_OK | MB_ICONWARNING);
return FALSE;
}
// if wordwrap, remove soft carriage returns
// Also move the cursor to a safe place to get around MLE bugs
ClearFmt();
/* Must get text length after formatting */
nChars = (UINT) SendMessage(hwndEdit, WM_GETTEXTLENGTH, 0, 0);
hEText = (HANDLE) SendMessage(hwndEdit, EM_GETHANDLE, 0, 0);
if ((hEText == NULL) || ((lpch = (LPTSTR) LocalLock(hEText)) == NULL))
{
goto FailFile;
}
Retry:
// Determine the SaveAs file type, and write the appropriate BOM.
// If the filetype is UTF-8 or Ansi, do the conversion.
if (FDetectEncodingW(szFile, lpch, nChars, &cpDetected))
{
// We detected an expected encoding for this file
if (g_cpSave != cpDetected)
{
int id;
// Display a warning that encodings do not match
id = MessageBox(hwndNP,
szEncodingMismatch,
szNN,
MB_APPLMODAL | MB_YESNOCANCEL | MB_ICONWARNING);
if (id == IDCANCEL)
{
goto CleanUp;
}
if (id == IDYES)
{
g_cpSave = cpDetected;
}
}
}
switch (g_cpSave)
{
case CP_UTF16 :
if (g_wbSave != wbNo)
{
WriteFile(fp, &wchBOM, ByteCountOf(1), &nBytesWritten, NULL);
}
flag = WriteFile(fp, lpch, ByteCountOf(nChars), &nBytesWritten, NULL);
break;
case CP_UTF16BE :
if (g_wbSave != wbNo)
{
WriteFile(fp, &wchRBOM, ByteCountOf(1), &nBytesWritten, NULL);
}
ReverseEndian(lpch, lpch, nChars);
flag = WriteFile(fp, lpch, ByteCountOf(nChars), &nBytesWritten, NULL);
ReverseEndian(lpch, lpch, nChars);
break;
case CP_UTF8 :
// For UTF-8, write the BOM and continue to the default case.
// For XML, do NOT write a BOM for wbDefault
if ((g_wbSave == wbYes) || ((g_wbSave == wbDefault) && !FIsXmlW(lpch, nChars)))
{
WriteFile(fp, &BOM_UTF8, 3, &nBytesWritten, NULL);
}
// Fall through to convert and write the file
default:
fSaveEntity = g_fSaveEntity && FSupportWriteEntities(g_cpSave);
pfDefCharUsed = NULL;
if (!fSaveEntity && (g_cpSave != CP_UTF8))
{
pfDefCharUsed = &fDefCharUsed;
}
cchMbcs = ConvertFromUnicode(g_cpSave,
TRUE,
fSaveEntity,
(LPWSTR) lpch,
nChars,
NULL,
0,
pfDefCharUsed);
if (fDefCharUsed)
{
int id = (int) DialogBox(hInstanceNP,
MAKEINTRESOURCE(IDD_SAVE_UNICODE_DIALOG),
hwndNP,
SaveUnicodeDlgProc);
switch (id)
{
case IDC_SAVE_AS_UNICODE :
g_cpSave = CP_UTF16;
goto Retry;
case IDOK :
// Continue.
break;
case IDCANCEL :
goto CleanUp;
}
}
if (pfDefCharUsed != NULL)
{
// We need to convert again because WideCharToMultiByte
// sometimes fails with pfDefUsedChar != NULL.
cchMbcs = ConvertFromUnicode(g_cpSave,
fSaveEntity,
fSaveEntity,
(LPWSTR) lpch,
nChars,
NULL,
0,
NULL);
}
flag = AnsiWriteFile(fp, g_cpSave, lpch, nChars, cchMbcs);
break;
}
if (!flag)
{
SetCursor(hStdCursor); /* display normal cursor */
FailFile:
AlertUser_FileFail(szFile);
CleanUp:
SetCursor(hStdCursor);
CloseHandle(fp); fp=INVALID_HANDLE_VALUE;
if( hEText )
LocalUnlock( hEText );
if (fNew)
DeleteFile(szFile);
//
// if wordwrap, insert soft carriage returns
//
RestoreFmt();
return FALSE;
}
SetEndOfFile(fp);
g_cpOpened = g_cpSave;
g_wbOpened = g_wbSave;
SendMessage(hwndEdit, EM_SETMODIFY, FALSE, 0L);
SetFileName(szFile);
CloseHandle(fp); fp=INVALID_HANDLE_VALUE;
if( hEText )
LocalUnlock( hEText );
//
// if wordwrap, insert soft carriage returns
//
RestoreFmt();
// Display the normal cursor
SetCursor(hStdCursor);
return TRUE;
} // end of SaveFile()
/* Read contents of file from disk.
* Do any conversions required.
* File is already open, referenced by handle fp
* Close the file when done.
* If cpOpen != CP_AUTO, then use it as codepage, otherwise do automagic guessing.
*/
BOOL LoadFile(LPCTSTR szFile, BOOL fSelectEncoding)
{
UINT len, i, nChars;
LPTSTR lpch=NULL;
LPTSTR lpBuf;
LPSTR lpBufAfterBOM;
UINT cpOpen;
BOOL fLog=FALSE;
TCHAR* p;
BY_HANDLE_FILE_INFORMATION fiFileInfo;
BOOL bStatus; // boolean status
HLOCAL hNewEdit=NULL; // new handle for edit buffer
HANDLE hMap; // file mapping handle
TCHAR szNullFile[2]; // fake null mapped file
if( fp == INVALID_HANDLE_VALUE )
{
AlertUser_FileFail( szFile );
return (FALSE);
}
//
// Get size of file
// We use this heavy duty GetFileInformationByHandle API
// because it finds bugs. It takes longer, but it only is
// called at user interaction time.
//
bStatus= GetFileInformationByHandle( fp, &fiFileInfo );
len= (UINT) fiFileInfo.nFileSizeLow;
// NT may delay giving this status until the file is accessed.
// i.e. the open succeeds, but operations may fail on damaged files.
if( !bStatus )
{
AlertUser_FileFail( szFile );
CloseHandle( fp ); fp=INVALID_HANDLE_VALUE;
return( FALSE );
}
// If the file is too big, fail now.
// -1 not valid because we need a zero on the end.
//
// bug# 168148: silently fails to open 2.4 gig text file on win64
// Caused by trying to convert ascii file to unicode which overflowed
// the dword length handled by multibytetowidechar conversion.
// Since no one will be happy with the performance of the MLE with
// a file this big, we will just refuse to open it now.
//
// For example, on a Pentium 173 MHz with 192 Megs o'RAM (Tecra 8000)
// I got these results:
//
// size CPU-time
// 0 .12
// 1 .46
// 2 .77
// 3 1.041
// 4 1.662
// 5 2.092
// 6 2.543
// 7 3.023
// 8 3.534
// 9 4.084
// 10 4.576
// 16 8.371
// 32 23.142
// 64 74.426
//
// Curve fitting these numbers to cpu-time=a+b*size+c*size*size
// we get a really good fit with cpu= .24+.28*size+.013*size*size
//
// For 1 gig, this works out to be 3.68 hours. 2 gigs=14.6 hours
//
// And the user isn't going to be happy with adding or deleting characters
// with the MLE control. It wants to keep the memory stuctures uptodate
// at all times.
//
// Going to richedit isn't a near term solution either:
//
// size CPU-time
// 2 3.8
// 4 9.0
// 6 21.9
// 8 30.4
// 10 65.3
// 16 1721 or >3.5 hours (it was still running when I killed it)
//
//
// feature: should we only bail if not unicode?
//
if( len >=0x4000000 || fiFileInfo.nFileSizeHigh != 0 )
{
AlertBox( hwndNP, szNN, szErrSpace, szFile,
MB_APPLMODAL | MB_OK | MB_ICONWARNING );
CloseHandle (fp); fp=INVALID_HANDLE_VALUE;
return (FALSE);
}
SetCursor(hWaitCursor); // physical I/O takes time
//
// Create a file mapping so we don't page the file to
// the pagefile. This is a big win on small ram machines.
//
if( len != 0 )
{
lpBuf= NULL;
hMap= CreateFileMapping( fp, NULL, PAGE_READONLY, 0, len, NULL );
if( hMap )
{
lpBuf= MapViewOfFile( hMap, FILE_MAP_READ, 0,0,len);
CloseHandle( hMap );
}
}
else // file mapping doesn't work on zero length files
{
lpBuf= (LPTSTR) &szNullFile;
*lpBuf= 0; // null terminate
}
CloseHandle( fp ); fp=INVALID_HANDLE_VALUE;
if( lpBuf == NULL )
{
SetCursor( hStdCursor );
//
// bug# 192007: Opening migrated files with bad RSS gives bad error msg
//
// We used to just say 'out of memory', but that was wrong.
// We will now give the standard OS error message.
// If the user doesn't understand that, then FormatMessage s/b be fixed.
//
AlertUser_FileFail( szFile );
return( FALSE );
}
//
// protect access to the mapped file with a try/except so we
// can detect I/O errors.
//
//
// WARNING: be very very careful. This code is pretty fragile.
// Files across the network, or RSM files (tape) may throw excepts
// at random points in this code. Anywhere the code touches the
// memory mapped file can cause an AV. Make sure variables are
// in consistent state if an exception is thrown. Be very careful
// with globals.
__try
{
/* Determine the file type and number of characters
* If the user overrides, use what is specified.
* Otherwise, we depend on 'IsTextUnicode' getting it right.
* If it doesn't, bug IsTextUnicode.
*/
cpOpen = g_cpDefault;
if (fSelectEncoding || (cpOpen == CP_AUTO))
{
switch (*lpBuf)
{
TCHAR szExt[_MAX_EXT];
case BYTE_ORDER_MARK:
cpOpen = CP_UTF16;
break;
case REVERSE_BYTE_ORDER_MARK:
cpOpen = CP_UTF16BE;
break;
case BOM_UTF8_HALF:
// UTF-8 BOM has 3 bytes; if it doesn't have UTF-8 BOM just fall through ..
if ((len > 2) && (((BYTE *) lpBuf)[2] == BOM_UTF8_2HALF))
{
cpOpen = CP_UTF8;
break;
}
// Fall through
default:
// Is the file Unicode without BOM ?
if (IsInputTextUnicode((LPSTR) lpBuf, len))
{
cpOpen = CP_UTF16;
break;
}
if (FDetectXmlEncodingA((LPSTR) lpBuf, len, &cpOpen))
{
// We recognized this as an XML file with a valid encoding
break;
}
if (FDetectHtmlEncodingA((LPSTR) lpBuf, len, &cpOpen))
{
// We recognized this as an HTML file with a valid encoding
break;
}
_wsplitpath(szFile, NULL, NULL, NULL, szExt);
if (lstrcmpi(szExt, TEXT(".css")) == 0)
{
if (FDetectCssEncodingA((LPSTR) lpBuf, len, &cpOpen))
{
// We recognized this as an HTML file with a valid encoding
break;
}
}
// Is the file UTF-8 even though it doesn't have UTF-8 BOM.
if (IsTextUTF8((LPSTR) lpBuf, len))
{
cpOpen = CP_UTF8;
break;
}
// Well, assume default or ANSI if no default
if (fSelectEncoding)
{
// Use MLANG to detect the encoding as default in Select Encoding dialog
if (FDetectEncodingA((LPSTR) lpBuf, len, &cpOpen))
{
// We recognized this as an XML file with a valid encoding
break;
}
}
// Use default
cpOpen = g_cpDefault;
if (cpOpen == CP_AUTO)
{
cpOpen = g_cpANSI;
}
break;
}
}
if (fSelectEncoding)
{
int id;
id = (int) DialogBoxParam(hInstanceNP,
MAKEINTRESOURCE(IDD_SELECT_ENCODING),
hwndNP,
SelectEncodingDlgProc,
(LPARAM) &cpOpen);
if (id == IDCANCEL)
{
if (lpBuf != (LPTSTR) &szNullFile)
{
UnmapViewOfFile(lpBuf);
}
return(FALSE);
}
}
lpBufAfterBOM = (LPSTR) lpBuf;
if (cpOpen == CP_UTF16)
{
if ((len >= sizeof(WCHAR)) && ((*(WCHAR *) lpBuf) == BYTE_ORDER_MARK))
{
// Skip the BOM
lpBufAfterBOM = (LPSTR) lpBuf + sizeof(WCHAR);
len -= sizeof(WCHAR);
}
}
else if (cpOpen == CP_UTF16BE)
{
if ((len >= sizeof(WCHAR)) && ((*(WCHAR *) lpBuf) == REVERSE_BYTE_ORDER_MARK))
{
// Skip the BOM
lpBufAfterBOM = (LPSTR) lpBuf + sizeof(WCHAR);
len -= sizeof(WCHAR);
}
}
else if (cpOpen == CP_UTF8)
{
if ((len >= 3) && ((*(WCHAR *) lpBuf) == BOM_UTF8_HALF) && (((BYTE *) lpBuf)[2] == BOM_UTF8_2HALF))
{
// Skip the BOM
lpBufAfterBOM = (LPSTR) lpBuf + 3;
len -= 3;
}
}
// Find out no. of chars present in the string.
if ((cpOpen == CP_UTF16) || (cpOpen == CP_UTF16BE))
{
nChars = len / sizeof(WCHAR);
}
else
{
nChars = ConvertToUnicode(cpOpen, (LPSTR) lpBufAfterBOM, len, NULL, 0);
}
//
// Don't display text until all done.
//
SendMessage(hwndEdit, WM_SETREDRAW, FALSE, 0);
// Reset selection to 0
SendMessage(hwndEdit, EM_SETSEL, 0, 0L);
SendMessage(hwndEdit, EM_SCROLLCARET, 0, 0);
// resize the edit buffer
// if we can't resize the memory, inform the user
hNewEdit= LocalReAlloc(hEdit, ByteCountOf(nChars + 1), LMEM_MOVEABLE);
if( !hNewEdit )
{
TCHAR szFileT[MAX_PATH]; /* Private copy of current filename */
/* Bug 7441: New() modifies szFileOpened to which szFile may point.
* Save a copy of the filename to pass to AlertBox.
* 17 November 1991 Clark R. Cyr
*/
lstrcpy(szFileT, szFile);
New(FALSE);
/* Display the hour glass cursor */
SetCursor(hStdCursor);
AlertBox( hwndNP, szNN, szFTL, szFileT,
MB_APPLMODAL | MB_OK | MB_ICONWARNING);
if( lpBuf != (LPTSTR) &szNullFile )
{
UnmapViewOfFile( lpBuf );
}
// let user see old text
SendMessage(hwndEdit, WM_SETREDRAW, FALSE, 0);
return FALSE;
}
/* Transfer file from temporary buffer to the edit buffer */
lpch= (LPTSTR) LocalLock(hNewEdit);
if (cpOpen == CP_UTF16)
{
CopyMemory(lpch, lpBufAfterBOM, ByteCountOf(nChars));
}
else if (cpOpen == CP_UTF16BE)
{
ReverseEndian(lpch, (LPTSTR) lpBufAfterBOM, nChars);
}
else
{
ConvertToUnicode(cpOpen, (LPSTR) lpBufAfterBOM, len, lpch, nChars);
}
// Got everything; update global safe now
g_cpOpened = cpOpen;
if ((cpOpen != CP_UTF16) && (cpOpen != CP_UTF16BE) && (cpOpen != CP_UTF8))
{
g_wbOpened = wbDefault;
}
else if (lpBufAfterBOM != (LPSTR) lpBuf)
{
g_wbOpened = wbYes;
}
else
{
g_wbOpened = wbNo;
}
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
AlertBox( hwndNP, szNN, szDiskError, szFile,
MB_APPLMODAL | MB_OK | MB_ICONWARNING );
nChars= 0; // don't deal with it.
}
/* Free file mapping */
if( lpBuf != (LPTSTR) &szNullFile )
{
UnmapViewOfFile( lpBuf );
}
if( lpch )
{
// Fix any NUL character that came in from the file to be spaces.
for (i = 0, p = lpch; i < nChars; i++, p++)
{
if( *p == (TCHAR) 0 )
*p= TEXT(' ');
}
// null terminate it. Safe even if nChars==0 because it is 1 TCHAR bigger
*(lpch+nChars)= (TCHAR) 0; /* zero terminate the thing */
// Set 'fLog' if first characters in file are ".LOG"
fLog= *lpch++ == TEXT('.') && *lpch++ == TEXT('L') &&
*lpch++ == TEXT('O') && *lpch == TEXT('G');
}
if( hNewEdit )
{
LocalUnlock( hNewEdit );
// now it is safe to set the global edit handle
hEdit= hNewEdit;
}
SetFileName(szFile);
/* Pass handle to edit control. This is more efficient than WM_SETTEXT
* which would require twice the buffer space.
*/
/* Bug 7443: If EM_SETHANDLE doesn't have enough memory to complete things,
* it will send the EN_ERRSPACE message. If this happens, don't put up the
* out of memory notification, put up the file to large message instead.
* 17 November 1991 Clark R. Cyr
*/
dwEmSetHandle = SETHANDLEINPROGRESS;
SendMessage(hwndEdit, EM_SETHANDLE, (WPARAM)hEdit, 0);
if (dwEmSetHandle == SETHANDLEFAILED)
{
SetCursor(hStdCursor);
dwEmSetHandle = 0;
AlertBox(hwndNP, szNN, szFTL, szFile, MB_APPLMODAL|MB_OK|MB_ICONWARNING);
New(FALSE);
SendMessage (hwndEdit, WM_SETREDRAW, TRUE, 0);
return(FALSE);
}
dwEmSetHandle = 0;
PostMessage (hwndEdit, EM_LIMITTEXT, (WPARAM)CCHNPMAX, 0L);
/* If file starts with ".LOG" go to end and stamp date time */
if (fLog)
{
SendMessage( hwndEdit, EM_SETSEL, (WPARAM)nChars, (LPARAM)nChars);
SendMessage( hwndEdit, EM_SCROLLCARET, 0, 0);
InsertDateTime(TRUE);
}
/* Move vertical thumb to correct position */
SetScrollPos(hwndNP,
SB_VERT,
(int) SendMessage (hwndEdit, WM_VSCROLL, EM_GETTHUMB, 0),
TRUE);
/* Now display text */
SendMessage(hwndEdit, WM_SETREDRAW, TRUE, 0);
InvalidateRect(hwndEdit, NULL, TRUE);
UpdateWindow(hwndEdit);
SetCursor(hStdCursor);
return( TRUE );
}
/* New Command - reset everything
*/
void New(BOOL fCheck)
{
HANDLE hTemp;
TCHAR* pSz;
if (!fCheck || CheckSave (FALSE))
{
SendMessage(hwndEdit, WM_SETTEXT, 0, (LPARAM) TEXT(""));
SetFileName(NULL);
SendMessage(hwndEdit, EM_SETSEL, 0, 0);
SendMessage(hwndEdit, EM_SCROLLCARET, 0, 0);
// resize of 1 NULL character i.e. zero length
hTemp= LocalReAlloc( hEdit, sizeof(TCHAR), LMEM_MOVEABLE );
if( hTemp )
{
hEdit= hTemp;
}
// null terminate the buffer. LocalReAlloc won't do it
// because in all cases it is not growing which is the
// only time it would zero out anything.
pSz= LocalLock( hEdit );
*pSz= TEXT('\0');
LocalUnlock( hEdit );
SendMessage (hwndEdit, EM_SETHANDLE, (WPARAM)hEdit, 0L);
szSearch[0] = (TCHAR) 0;
// Set encoding of new document
g_cpOpened = g_cpDefault;
if (g_cpOpened == CP_AUTO)
{
g_cpOpened = g_cpANSI;
}
g_wbOpened = wbDefault;
}
} // end of New()
/* If sz does not have extension, append ".txt"
* This function is useful for getting to undecorated filenames
* that setup apps use. DO NOT CHANGE the extension. Too many setup
* apps depend on this functionality.
*/
void AddExt( TCHAR* sz )
{
TCHAR* pch1;
int ch;
DWORD dwSize;
dwSize= lstrlen(sz);
pch1= sz + dwSize; // point to end
ch= *pch1;
while( ch != TEXT('.') && ch != TEXT('\\') && ch != TEXT(':') && pch1 > sz)
{
//
// backup one character. Do NOT use CharPrev because
// it sometimes doesn't actually backup. Some Thai
// tone marks fit this category but there seems to be others.
// This is safe since it will stop at the beginning of the
// string or on delimiters listed above. bug# 139374 2/13/98
//
// pch1= (TCHAR*)CharPrev (sz, pch1);
pch1--; // back up
ch= *pch1;
}
if( *pch1 != TEXT('.') )
{
if( dwSize + sizeof(".txt") <= MAX_PATH ) { // avoid buffer overruns
lstrcat( sz, TEXT(".txt") );
}
}
}
/* AlertUser_FileFail(LPTSTR szFile)
*
* szFile is the name of file that was attempted to open.
* Some sort of failure on file open. Alert the user
* with some monologue box. At least give him decent
* error messages.
*/
VOID AlertUser_FileFail(LPCTSTR szFile)
{
TCHAR msg[256]; // buffer to format message into
DWORD dwStatus; // status from FormatMessage
UINT style= MB_APPLMODAL | MB_OK | MB_ICONWARNING;
// Check GetLastError to see why we failed
dwStatus=
FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
GetUserDefaultLangID(),
msg, // where message will end up
CharSizeOf(msg), NULL );
if( dwStatus )
{
MessageBox(hwndNP, msg, szNN, style);
}
else
{
AlertBox(hwndNP, szNN, szDiskError, szFile, style);
}
}
Copy Permalink