home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Sound Sensations!
/
sound_sensations.iso
/
soundb
/
sndhack
/
file.c
< prev
next >
Wrap
C/C++ Source or Header
|
1991-07-30
|
18KB
|
541 lines
#include <windows.h>
#include <io.h>
#include <errno.h>
#include <string.h>
#include <sys\types.h>
#include <sys\stat.h>
#include "app.h"
/*
* Module: file.c
*
* Contains: File related functions. File oriented fuctions
* show go here. This includes file related callback functions
* for such dialog boxes as Open, Save, SaveAs.
*
*/
/*********************************************************************/
/* Local Function Prototypes */
/*********************************************************************/
int FAR PASCAL SaveAsDlg(HWND, unsigned, WORD, LONG);
HANDLE FAR PASCAL OpenDlg(HWND, unsigned, WORD, LONG);
void UpdateListBox(HWND hDlg);
void FileSetDefExt(PSTR Ext, PSTR Name);
void FileSeparateName(LPSTR DestPath, LPSTR DestFile, LPSTR Src);
void FileAddExt(PSTR Name, PSTR Ext);
BOOL FileCheckName(HWND hDlg, PSTR Dest, PSTR Src);
BOOL FileSaveBuffer(HWND Hdlg);
void FileSetNewBuffer(HANDLE hNewBuffer, PSTR Title);
/*********************************************************************/
/* Local data and structures */
/*********************************************************************/
static char FileName[128] = ""; /* the name of the current file */
static char PathName[128] = ""; /* file pathname */
static char OpenName[128] = ""; /* name of a file to try and open */
static char DefPath[128] = ""; /* current path */
static char DefSpec[13] = "*.wsn"; /* current file specification */
static char DefExt[] = ".wsn"; /* current default extension */
static char str[255] = ""; /* work string */
static HANDLE hEditBuffer; /* edit buffer */
static HANDLE hOldBuffer; /* old buffer handle */
static HANDLE hHourGlass; /* handle to hourglass cursor */
static HANDLE hSaveCursor; /* current cursor handle */
static int hFile; /* file handle */
static int count; /* number of chars read or written*/
static PSTR pBuffer; /* address of read/write buffer */
static OFSTRUCT OfStruct; /* information from OpenFile() */
static struct stat FileStatus; /* information from fstat() */
static BOOL bSaveEnabled = FALSE; /* TRUE if text in the edit buffer*/
static PSTR pEditBuffer; /* address of the edit buffer */
static RECT Rect; /* dimension of the client window */
static HWND hwnd; /* handle to main window */
/*********************************************************************/
/* Global functions */
/*********************************************************************/
/*-------------------------------------------------------------------*/
/* Set current file to NEW. */
/*-------------------------------------------------------------------*/
void FileNew(hWnd)
HWND hWnd;
{
if (!FileQuerySave(hWnd))
return;
FileName[0] = 0;
/* Update the edit buffer */
wsprintf(str, "%s %s", (LPSTR) WindowName,(LPSTR)" - Untitled");
FileSetNewBuffer(NULL, str);
}
/*-------------------------------------------------------------------*/
/* Invoke a dialog box to open a file, check to save the current file*/
/*-------------------------------------------------------------------*/
void FileOpen(hWnd)
HWND hWnd;
{
int numbytes;
if (!FileQuerySave(hWnd))
return;
/* Open the file and get its handle */
hFile = GoDialogBox(hInst, "Open", hWnd, (FARPROC)OpenDlg);
if (hFile <= 0)
return;
/* Allocate edit buffer to the size of the file + 1 */
hEditBuffer = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, (WORD)(FileStatus.st_size+1));
if (!hEditBuffer) {
MessageBox(hWnd, "Not enough memory.", NULL, MB_OK | MB_ICONHAND);
return;
}
hSaveCursor = SetCursor(hHourGlass);
pEditBuffer = LocalLock(hEditBuffer);
numbytes = _lread(hFile, (LPSTR)pEditBuffer, (WORD)FileStatus.st_size);
close(hFile);
/* # bytes read must equal file size */
if (numbytes != FileStatus.st_size) {
wsprintf(str, "Error reading %s.", (LPSTR)FileName);
SetCursor(hSaveCursor); /* Remove the hourglass */
MessageBox(hWnd, str, NULL, MB_OK | MB_ICONEXCLAMATION);
}
LocalUnlock(hEditBuffer);
/* Set up a new buffer and window title */
wsprintf(str, (LPSTR)"%s - %s", (LPSTR)WindowName, (LPSTR)FileName);
FileSetNewBuffer(hEditBuffer, str);
SetCursor(hSaveCursor);
}
/*-------------------------------------------------------------------*/
/* Save the current file */
/*-------------------------------------------------------------------*/
void FileSave(hWnd)
HWND hWnd;
{
if (!FileName[0])
FileSaveAs(hWnd);
FileSaveBuffer(hWnd);
}
/*-------------------------------------------------------------------*/
/* Save the current file prompting for a filename */
/*-------------------------------------------------------------------*/
void FileSaveAs(hWnd)
HWND hWnd;
{
int Success;
/* Call the SaveAsDlg() function to get the new filename */
Success = GoDialogBox(hInst, "SaveAs", hWnd, (FARPROC)SaveAsDlg);
/* If successful, update the window title, save the file */
if (Success == IDOK) {
wsprintf(str, (LPSTR)"%s - %s", (LPSTR)WindowName,(LPSTR)FileName);
SetWindowText(hWnd, str);
FileSaveBuffer(hWnd);
}
}
/*-------------------------------------------------------------------*/
/* SaveAs dialog box callback function. */
/*-------------------------------------------------------------------*/
int FAR PASCAL SaveAsDlg(hDlg, message, wParam, lParam)
HWND hDlg;
unsigned message;
WORD wParam;
LONG lParam;
{
char TempName[128];
switch (message) {
case WM_INITDIALOG:
/* If no filename is entered, don't allow the user to save to it */
if (!FileName[0])
bSaveEnabled = FALSE;
else {
bSaveEnabled = TRUE;
/* Process the path to fit within the IDC_PATH field */
DlgDirList(hDlg, DefPath, NULL, IDC_PATH, 0x4010);
/* Send the current filename to the edit control */
SetDlgItemText(hDlg, IDC_EDIT, FileName);
/* Accept all characters in the edit control */
SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, 0, MAKELONG(0, 0x7fff));
}
/* Enable or disable the save control depending on whether the
* filename exists.
*/
EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled);
/* Set the focus to the edit control within the dialog box */
SetFocus(GetDlgItem(hDlg, IDC_EDIT));
return(FALSE); /* FALSE since Focus was changed */
case WM_COMMAND:
switch (wParam) {
case IDC_EDIT:
/* If there was previously no filename in the edit
* control, then the save control must be enabled as soon as
* a character is entered.
*/
if (HIWORD(lParam) == EN_CHANGE && !bSaveEnabled)
EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled = TRUE);
return (TRUE);
case IDOK:
/* Get the filename from the edit control */
GetDlgItemText(hDlg, IDC_EDIT, TempName, 128);
/* If there are no wildcards, then separate the name into
* path and name. If a path was specified, replace the
* default path with the new path.
*/
if (FileCheckName(hDlg, FileName, TempName)) {
FileSeparateName((LPSTR) str, (LPSTR) DefSpec, (LPSTR) FileName);
if (str[0])
strcpy(DefPath, str);
/* Tell the caller a filename was selected */
EndDialog(hDlg, IDOK);
}
return (TRUE);
case IDCANCEL:
/* Tell the caller the user canceled the SaveAs function */
EndDialog(hDlg, IDCANCEL);
return (TRUE);
}
break;
}
return (FALSE);
}
/*-------------------------------------------------------------------*/
/* Open dialog box callback function. */
/*-------------------------------------------------------------------*/
HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
HWND hDlg;
unsigned message;
WORD wParam;
LONG lParam;
{
WORD index;
PSTR pTptr;
HANDLE hFile;
switch (message) {
case WM_COMMAND:
switch (wParam) {
case IDC_LISTBOX:
if (HIWORD(lParam) == LBN_SELCHANGE) {
/* If item is a directory name, append "*.*" */
if (DlgDirSelect(hDlg, str, IDC_LISTBOX))
strcat(str, DefSpec);
SetDlgItemText(hDlg, IDC_EDIT, str);
SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, NULL, MAKELONG(0, 0x7fff));
break;
}
else if (HIWORD(lParam) == LBN_DBLCLK)
;
else
return(TRUE);
case IDOK:
GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
FileSeparateName((LPSTR) str, (LPSTR) DefSpec, (LPSTR) OpenName);
if (str[0])
strcpy(DefPath, str);
FileSetDefExt(DefExt, DefSpec);
UpdateListBox(hDlg);
return (TRUE);
}
if (!OpenName[0]) {
MessageBox(hDlg, "No filename specified.", NULL, MB_OK | MB_ICONHAND);
return (TRUE);
}
FileAddExt(OpenName, DefExt);
/* Open the file */
if ((int)(hFile = OpenFile(OpenName, (LPOFSTRUCT)&OfStruct, OF_READ)) == -1) {
wsprintf(str, "Error %d opening %s.", OfStruct.nErrCode, (LPSTR)OpenName);
MessageBox(hDlg, str, NULL, MB_OK | MB_ICONHAND);
}
else {
/* Make sure there's enough room for the file */
fstat(hFile, &FileStatus);
if (FileStatus.st_size > MAXFILESIZE) {
wsprintf(str,
"Not enough memory to load %s.\n%s exceeds %ld bytes.",
(LPSTR)OpenName,
(LPSTR)OpenName,
MAXFILESIZE);
MessageBox(hDlg, str, NULL, MB_OK | MB_ICONHAND);
return (TRUE);
}
/* File is opened and there is enough room so return
* the handle to the caller.
*/
strcpy(FileName, OpenName);
EndDialog(hDlg, hFile);
return (TRUE);
}
return (TRUE);
case IDCANCEL:
EndDialog(hDlg, NULL);
return (TRUE);
}
break;
case WM_INITDIALOG: /* message: initialize */
UpdateListBox(hDlg);
SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
SendDlgItemMessage(hDlg, /* dialog handle */
IDC_EDIT, /* where to send message */
EM_SETSEL, /* select characters */
NULL, /* additional information */
MAKELONG(0, 0x7fff)); /* entire contents */
SetFocus(GetDlgItem(hDlg, IDC_EDIT));
return (FALSE); /* Indicates the focus is set to a control */
}
return FALSE;
}
/*-------------------------------------------------------------------*/
/* Update the list box of OpenDlg. */
/*-------------------------------------------------------------------*/
void UpdateListBox(hDlg)
HWND hDlg;
{
strcpy(str, DefPath);
strcat(str, DefSpec);
DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);
/* To ensure that the listing is made for a subdir. of
* current drive dir...
*/
if (!strchr (DefPath, ':'))
DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);
/* Remove the '..' character from path if it exists, since this
* will make DlgDirList move us up an additional level in the tree
* when UpdateListBox() is called again.
*/
if (strstr (DefPath, ".."))
DefPath[0] = '\0';
SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
}
/*-------------------------------------------------------------------*/
/* Change the default extension. */
/*-------------------------------------------------------------------*/
void FileSetDefExt(Ext, Name)
PSTR Ext, Name;
{
PSTR pTptr;
pTptr = Name;
while (*pTptr && *pTptr != '.')
pTptr++;
if (*pTptr)
if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
strcpy(Ext, pTptr);
}
/*-------------------------------------------------------------------*/
/* Separate the filename and the path. */
/*-------------------------------------------------------------------*/
void FileSeparateName(lpDestPath, lpDestFileName, lpSrcFileName)
LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
{
LPSTR lpTmp;
char cTmp;
lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
if (*lpTmp != ':' && *lpTmp != '\\') {
lstrcpy(lpDestFileName, lpSrcFileName);
lpDestPath[0] = 0;
return;
}
lstrcpy(lpDestFileName, lpTmp + 1);
cTmp = *(lpTmp + 1);
lstrcpy(lpDestPath, lpSrcFileName);
*(lpTmp + 1) = cTmp;
lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
}
/*-------------------------------------------------------------------*/
/* Add the default extension to a file name. */
/*-------------------------------------------------------------------*/
void FileAddExt(Name, Ext)
PSTR Name, Ext;
{
PSTR pTptr;
pTptr = Name;
while (*pTptr && *pTptr != '.')
pTptr++;
if (*pTptr != '.')
strcat(Name, Ext);
}
/*-------------------------------------------------------------------*/
/* Check the filename for wildcards and extension when saving a file.*/
/*-------------------------------------------------------------------*/
BOOL FileCheckName(hDlg,pDest, pSrc)
HWND hDlg;
PSTR pDest, pSrc;
{
PSTR pTmp;
if (!pSrc[0])
return (FALSE); /* Indicates no filename was specified */
pTmp = pSrc;
while (*pTmp) { /* Searches the string for wildcards */
switch (*pTmp++) {
case '*':
case '?':
MessageBox(hDlg, "Wildcards not allowed.", NULL, MB_OK | MB_ICONEXCLAMATION);
return (FALSE);
}
}
FileAddExt(pSrc, DefExt);
if (OpenFile(pSrc, (LPOFSTRUCT) &OfStruct, OF_EXIST) >= 0) {
wsprintf(str, "Replace existing %s?", (LPSTR)pSrc);
if (MessageBox(hDlg, str, WindowName, MB_OKCANCEL | MB_ICONHAND) == IDCANCEL)
return (FALSE);
}
strcpy(pDest, pSrc);
return (TRUE);
}
/*-------------------------------------------------------------------*/
/* Save the contents of the edit buffer to a file. */
/*-------------------------------------------------------------------*/
BOOL FileSaveBuffer(hDlg)
HWND hDlg;
{
BOOL bSuccess;
int numbytes;
if ((hFile = OpenFile(FileName, &OfStruct, OF_PROMPT|OF_CANCEL|OF_CREATE)) < 0) {
wsprintf(str, "Cannot write to %s.", (LPSTR)FileName);
MessageBox(hDlg, str, NULL, MB_OK | MB_ICONEXCLAMATION);
return (FALSE);
}
hEditBuffer = SendMessage(hEditWindow, EM_GETHANDLE, 0, 0L);
pEditBuffer = LocalLock(hEditBuffer);
hSaveCursor = SetCursor(hHourGlass);
numbytes = _lwrite(hFile, (LPSTR)pEditBuffer, (WORD)strlen(pEditBuffer));
close(hFile);
SetCursor(hSaveCursor);
if (numbytes != strlen(pEditBuffer)) {
wsprintf(str, "Error writing to %s.", (LPSTR)FileName);
MessageBox(hDlg, str, NULL, MB_OK | MB_ICONHAND);
bSuccess = FALSE;
}
else {
bSuccess = TRUE; /* Indicates the file was saved */
}
LocalUnlock(hEditBuffer);
SendMessage(hEditWindow, EM_SETMODIFY, 0, 0L);
return (bSuccess);
}
/*-------------------------------------------------------------------*/
/* Ask if the current contents of the edit buffer should be saved. */
/*-------------------------------------------------------------------*/
BOOL FileQuerySave(hWnd)
HWND hWnd;
{
int Response;
if (SendMessage(hEditWindow, EM_GETMODIFY, 0, 0L) != 0) {
wsprintf(str, "Save current changes: %s", (LPSTR)FileName);
Response = MessageBox(hWnd, str, WindowName, MB_YESNOCANCEL | MB_ICONEXCLAMATION);
if (Response == IDYES) {
while (!FileName[0]) {
Response = GoDialogBox(hInst, "SaveAs", hWnd, (FARPROC)SaveAsDlg);
if (Response == IDOK)
continue;
else
return (FALSE);
}
FileSaveBuffer(hWnd);
}
else if (Response == IDCANCEL)
return(FALSE);
}
return(TRUE);
}
/*-------------------------------------------------------------------*/
/* Reset the edit window file buffer to a new one. */
/*-------------------------------------------------------------------*/
void FileSetNewBuffer(hNewBuffer, Title)
HANDLE hNewBuffer;
PSTR Title;
{
HANDLE hOldBuffer;
hOldBuffer = SendMessage(hEditWindow, EM_GETHANDLE, 0, 0L);
LocalFree(hOldBuffer);
if (!hNewBuffer)
hNewBuffer = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, 1);
/* Updates the buffer and displays new buffer */
SendMessage(hEditWindow, EM_SETHANDLE, hNewBuffer, 0L);
SendMessage(hEditWindow, EM_SETMODIFY, 0, 0L);
SetWindowText(hWindow, Title);
SetFocus(hEditWindow);
}