void MessageBox (ULONG idText, ULONG idTitle, ULONG flStyle)
{
CHAR szText[CCHMAXMSG];
CHAR szTitle[CCHMAXMSG];
PCHAR pszTitle;
/* idTitle = 0 => kein Titel */
/* idTitle = MBTITLE_ERROR => Titel "Fehler" */
/* idTitle sonst => Text ID */
WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP), hmod,
idText, CCHMAXMSG, szText);
switch (idTitle)
{
case MBTITLE_ERROR:
pszTitle = NULL;
break;
case 0:
pszTitle = "";
break;
default:
WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP), hmod,
idTitle, CCHMAXMSG, szTitle);
pszTitle = szTitle;
}
WinMessageBox (HWND_DESKTOP, HWND_DESKTOP, szText,
pszTitle, IDD_MESSAGEBOX, flStyle);
return;
}
/****************************************************************\
* Initialization routine *
*--------------------------------------------------------------*
* *
* Name: Init() *
* *
* Purpose: Performs initialization functions required before *
* the main window can be created. *
* *
* Usage: Called once before the main window is created. *
* *
* Method: - installs the routine ExitProc into the *
* DosExitList chain *
* - registers all window classes *
* - performs any command line processing *
* *
* Returns: TRUE - initialization is successful *
* FALSE - initialization failed *
* *
\****************************************************************/
BOOL Init(VOID)
{
/* Add ExitProc to the exit list to handle the exit processing */
if(DosExitList(EXLST_ADD, ExitProc))
{
return FALSE;
}
/* load application name from resource file */
if(!WinLoadString(hab, (HMODULE)0, IDS_APPNAME, MAXAPPNAMELEN, szAppName))
return FALSE;
if(!WinLoadString(hab, 0, IDS_UNTITLED, MESSAGELEN, szUntitled))
return FALSE;
/* register the main client window class */
if(WinRegisterClass(hab,
(PSZ)szAppName,
(PFNWP)MainWndProc,
CS_SIZEREDRAW | CS_SYNCPAINT | CS_CLIPCHILDREN,
0) == 0)
return FALSE;
/* Turn off hard-error popup after GP-FAULT. No return codes
checked as it is cosmetic and if it doesn't work the only side
effect will be to have the default hard-error popup show up. */
return TRUE;
} /* Init() */
int CheckFiles(char * szDir)
{
int iRes;
CHAR szCurrentDir[CCHMAXPATH];
CHAR szDirAndFile[CCHMAXPATH+12];
CHAR szFileName[LITTLEBUF];
CHAR szMessage[MAXBUF];
//Copy directory
strcpy(szCurrentDir, szDir);
//Check ZED.EXE
SetStatus(ID_ZEDEXE);
WinLoadString(hab, 0, ID_ZED_FILENAME, LITTLEBUF, szFileName);
sprintf(szDirAndFile, "%s%s", szCurrentDir, szFileName);
iRes=access(szDirAndFile, R_OK);
if (iRes!=0) goto ERROR;
//Check ZED.HLP
SetStatus(ID_ZEDHLP);
WinLoadString(hab, 0, ID_ZED_HELP_FILENAME, LITTLEBUF, szFileName);
sprintf(szDirAndFile, "%s%s", szCurrentDir, szFileName);
iRes=access(szDirAndFile, R_OK);
if (iRes!=0) goto ERROR;
//Check ZED.ICO
SetStatus(ID_ZEDICO);
WinLoadString(hab, 0, ID_ZED_ICON_FILENAME, LITTLEBUF, szFileName);
sprintf(szDirAndFile, "%s%s", szCurrentDir, szFileName);
iRes=access(szDirAndFile, R_OK);
if (iRes!=0) goto ERROR;
//Check README.TXT
SetStatus(ID_ZEDREADME);
WinLoadString(hab, 0, ID_ZED_README_FILENAME, LITTLEBUF, szFileName);
sprintf(szDirAndFile, "%s%s", szCurrentDir, szFileName);
iRes=access(szDirAndFile, R_OK);
if (iRes!=0) goto ERROR;
//Check REGISTER.TXT
//SetStatus(ID_REGISTER);
//WinLoadString(hab, 0, ID_REGISTER_FILENAME, LITTLEBUF, szFileName);
//sprintf(szDirAndFile, "%s%s", szCurrentDir, szFileName);
//iRes=access(szDirAndFile, R_OK);
//if (iRes!=0) return -1;
return 0;
ERROR:
sprintf(szMessage,"%s %s",
"Can't find the file ", szDirAndFile);
WinMessageBox(HWND_DESKTOP, hwndClient, szMessage,
"ZED - Install", 0,
MB_OK | MB_MOVEABLE | MB_ICONHAND);
return -1;
}
VOID DispErrorMsg(HAB hab, HWND hwndFrame, PCH FileName, LONG LineNum)
{
PERRINFO pErrInfoBlk;
PSZ pszOffSet, pszErrMsg;
ERRORID ErrorId;
PCH ErrorStr;
CHAR szbuff[125];
DosBeep(800,10);
#if defined(DEBUG)
DosBeep(800,10);
DosBeep(800,10);
DosBeep(800,10);
DosBeep(800,10);
DosBeep(800,10);
#endif /* defined(DEBUG) */
if (!hab)
{ /* Non-PM Error */
WinLoadString( habMain,0, IDS_UNKNOWNMSG, sizeof(szbuff), (PSZ)szbuff);
ErrorStr = (char*) malloc(strlen(szbuff)+strlen(FileName)+10);
sprintf(ErrorStr, szbuff, FileName, LineNum);
WinMessageBox(HWND_DESKTOP, /* Parent window is desk top */
hwndFrame, /* Owner window is our frame */
(PSZ)ErrorStr, /* PMWIN Error message */
szErrorTitle, /* Title bar message */
MSGBOXID, /* Message identifier */
MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */
free(ErrorStr);
return;
}
ErrorId = WinGetLastError(hab);
if ((pErrInfoBlk = WinGetErrorInfo(hab)) != (PERRINFO)NULL)
{
pszOffSet = ((PSZ)pErrInfoBlk) + pErrInfoBlk->offaoffszMsg;
pszErrMsg = ((PSZ)pErrInfoBlk) + *((PULONG)pszOffSet);
WinLoadString( habMain,0, IDS_ERRORMSG, sizeof(szbuff), (PSZ)szbuff);
ErrorStr = (char *)malloc(strlen(szbuff)+strlen(pszErrMsg)+strlen(FileName)+10);
sprintf(ErrorStr, szbuff, pszErrMsg, FileName, LineNum);
WinMessageBox(HWND_DESKTOP, /* Parent window is desk top */
hwndFrame, /* Owner window is our frame */
(PSZ)ErrorStr, /* PMWIN Error message */
szErrorTitle, /* Title bar message */
MSGBOXID, /* Message identifier */
MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */
free(ErrorStr);
WinFreeErrorInfo(pErrInfoBlk);
}
}
/*************************************************************************
* Name : InitializeDialog
*
* Description : This function performs the necessary initializations and
* setups that are required to show/run a dialog box as a
* main window. The message queue will be created, as will
* the dialog box.
*
* Concepts : Secondary Windows is used to create and show a dialog box.
* A system clock is displayed till the application is loaded.
*
* MMPM/2 API's : WinLoadSecondaryWindow
* WinQuerySecondaryHWND
*
* Parameters : None.
*
* Return : None.
*
*************************************************************************/
void InitializeDialog()
{
CHAR achTitle[STRING_SIZE] = "";
CHAR achDefaultSize[STRING_SIZE] = "";
/* Initialize the Dialog window */
hab = WinInitialize(0);
/* create a message queue for the window */
hmq = WinCreateMsgQueue(hab,0);
/* Load the Dialog - This will return the Handle to the Frame */
hwndFrame =
WinLoadSecondaryWindow(HWND_DESKTOP
,HWND_DESKTOP
,(PFNWP)MainDialogProc
,(HMODULE)NULL
,ID_SAMPLE
,(PVOID)NULL);
/*
* By specifying the QS_DIALOG flag we will get the handle to the Dialog of
* the frame
*/
hwndDiag = WinQuerySecondaryHWND(hwndFrame,QS_DIALOG);
/* Get the string for default size */
WinLoadString(
hab,
(HMODULE) NULL,
IDS_DEFAULT_SIZE,
(SHORT) sizeof( achDefaultSize),
achDefaultSize);
/* Add Default Size menu item to system menu of the secondary window. */
WinInsertDefaultSize(hwndFrame, achDefaultSize);
/*
* Get the window title string from the Resource string table
* and set it as the window text for the dialog window.
*/
WinLoadString(
hab,
(HMODULE) NULL,
IDS_MAIN_WINDOW_TITLE,
(SHORT) sizeof( achTitle),
achTitle);
/* Set the Title of the Dialog */
WinSetWindowText( hwndFrame, achTitle);
}
/**************************************************************************
*
* Name : GetFileName()
*
* Description: gets the name of the save file
*
* Concepts: called when the user needs to supply a name for
* the file to be saved
*
* calls the standard file open dialog to get the
* file name.
*
* API's : WinLoadString
* WinFileDlg
*
* Parameters : [none]
*
* Return : TRUE if successful in getting a file name
* FALSE if not successful in getting a file name
*
*************************************************************************/
BOOL GetFileName(VOID)
{
FILEDLG fdg;
CHAR szTitle[MESSAGELEN], szButton[MESSAGELEN];
fdg.cbSize = sizeof(FILEDLG);
if(!WinLoadString(hab, 0, IDS_SAVE, MESSAGELEN, szTitle))
{
MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
return FALSE;
}
if(!WinLoadString(hab, 0, IDS_SAVE, MESSAGELEN, szButton))
{
MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
return FALSE;
}
fdg.pszTitle = szTitle;
fdg.pszOKButton = szButton;
fdg.ulUser = 0L;
fdg.fl = FDS_HELPBUTTON | FDS_CENTER | FDS_SAVEAS_DIALOG;
fdg.pfnDlgProc = (PFNWP)TemplateSaveFilterProc;
fdg.lReturn = 0L;
fdg.lSRC = 0L;
fdg.hMod = (HMODULE)NULL;
fdg.usDlgId = FILESAVE;
fdg.x = 0;
fdg.y = 0;
fdg.pszIType = (PSZ)NULL;
fdg.papszITypeList = (PAPSZ)NULL;
fdg.pszIDrive = (PSZ)NULL;
fdg.papszIDriveList = (PAPSZ)NULL;
fdg.sEAType = (SHORT)0;
fdg.papszFQFilename = (PAPSZ)NULL;
fdg.ulFQFCount = 0L;
strcpy(fdg.szFullFile, szFullPath);
/* get the file */
if(!WinFileDlg(HWND_DESKTOP, hwndMain, &fdg))
return FALSE;
if(fdg.lReturn != ID_OK)
return FALSE;
/* copy file name and path returned into buffers */
strcpy(szFullPath, fdg.szFullFile);
return TRUE;
} /* End of GetFileName */
MRESULT EXPENTRY PrefFilesDlgProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch (msg)
{
case WM_INITDLG:
WinSendDlgItemMsg(hwnd, DID_PUBLIC_FILE_STRN, EM_SETTEXTLIMIT,
MPFROMSHORT(CCHMAXPATH), NULL);
WinSendDlgItemMsg(hwnd, DID_PRIVATE_FILE_STRN, EM_SETTEXTLIMIT,
MPFROMSHORT(CCHMAXPATH), NULL);
WinSendDlgItemMsg(hwnd, DID_RANDOM_FILE_STRN, EM_SETTEXTLIMIT,
MPFROMSHORT(CCHMAXPATH), NULL);
PrefSetStrings(hwnd, &TempData);
break;
case WM_COMMAND:
switch(SHORT1FROMMP(mp1))
{
case WM_BROWSE_PUBLIC_FILE:
Len = WinLoadString(Hab, hRessourceModule, IDS_SELECT_PUBKEY_TITLE,
TITLESTRN_MAXLEN, Title);
FileSettingsSelection(hwnd, TempData.PublicKeyFile, Title, "*.pkr");
PrefSetStrings(hwnd, &TempData);
return (MRESULT)TRUE;
case WM_BROWSE_PRIVATE_FILE:
Len = WinLoadString(Hab, hRessourceModule, IDS_SELECT_PRIVKEY_TITLE,
TITLESTRN_MAXLEN, Title);
FileSettingsSelection(hwnd, TempData.PrivateKeyFile, Title, "*.skr");
PrefSetStrings(hwnd, &TempData);
return (MRESULT)TRUE;
case WM_BROWSE_RANDOM_FILE:
Len = WinLoadString(Hab, hRessourceModule, IDS_SELECT_RANDSEED_TITLE,
TITLESTRN_MAXLEN, Title);
FileSettingsSelection(hwnd, TempData.RandomSeedFile, Title, "*.bin");
PrefSetStrings(hwnd, &TempData);
return (MRESULT)TRUE;
}
break;
default:
return WinDefDlgProc (hwnd, msg, mp1, mp2);
}
return (MRESULT)FALSE;
}
// usage: WavePlayer [options] [file1 [file2 ... [fileN]]]
// v# - volume (0-100)
// i# - device index (0 - default)
// l - loop (stop playing when closed)
int main(int argc, char **argv)
{
AnchorBlock ab;
MessageQueue mq(ab);
HWND hwndFrame = NULLHANDLE;
HWND hwndClient = NULLHANDLE;
FRAMECDATA fcd;
PSZ pszClientClass = NULL;
PSZ pszTitle = NULL;
QMSG qmsg;
pbcRegisterClass();
PINITDATA pinitdata = new INITDATA;
memset(pinitdata, 0, sizeof(INITDATA));
pinitdata->cbSize = sizeof(INITDATA);
pinitdata->argc = argc;
pinitdata->argv = argv;
fcd.cb = sizeof(fcd);
fcd.flCreateFlags = FCF_TITLEBAR | FCF_SYSMENU | FCF_MINMAX | FCF_SIZEBORDER | FCF_ICON | FCF_SHELLPOSITION | FCF_TASKLIST;
fcd.hmodResources = NULLHANDLE;
fcd.idResources = WIN_MAIN;
pszClientClass = new char[128];
WinLoadString(ab, (HMODULE)NULLHANDLE, IDS_CLIENTCLASSNAME, 128, pszTitle);
WinRegisterClass(ab, pszClientClass, MainWndProc, CS_SIZEREDRAW, QW_EXTRA);
pszTitle = new char[128];
WinLoadString(ab, (HMODULE)NULLHANDLE, IDS_APPNAME, 128, pszTitle);
hwndFrame = WinCreateWindow(HWND_DESKTOP, WC_FRAME, pszTitle, WS_ANIMATE, 0, 0, 0, 0, (HWND)NULLHANDLE, HWND_TOP, WIN_MAIN, (PVOID)&fcd, (PVOID)NULL);
hwndClient = WinCreateWindow(hwndFrame, pszClientClass, (PSZ)NULL, 0, 0, 0, 0, 0, hwndFrame, HWND_TOP, FID_CLIENT, (PVOID)pinitdata, (PVOID)NULL);
delete pszClientClass;
delete pszTitle;
if(hwndFrame == NULLHANDLE || hwndClient == NULLHANDLE)
return 1;
while(WinGetMsg(ab, &qmsg, NULL, NULL, NULL))
WinDispatchMsg(ab, &qmsg);
WinDestroyWindow(hwndFrame);
return 0;
}
void SetWindowTitle( HWND hwndWnd )
{
CHAR szWinTitle[MAX_STRING_BYTES];
CHAR szUntitled[MAX_STRING_BYTES];
/*
* Use the application title as the first part of the window title
*/
strncpy( szWinTitle, szAppName, MAX_STRING_BYTES );
/*
* If there is an allocated data buffer, concatenate a dash ( '-' ) and
* either the name of the file or the string "(untitled)" to the window
* title string.
*/
if ( pbFileBuffer != NULL )
{
strncat( szWinTitle, " - ", MAX_STRING_BYTES );
if ( *szFileName == '\0' )
{
WinLoadString( habAnchor, NULLHANDLE, IDS_UNTITLED, sizeof( szUntitled ), szUntitled );
strncat( szWinTitle, szUntitled, MAX_STRING_BYTES );
}
else
{
strncat( szWinTitle, szFileName, MAX_STRING_BYTES );
}
}
WinSetWindowText( WinQueryWindow( hwndWnd, QW_PARENT), szWinTitle );
}
USHORT DisplayMessageBox( ULONG ulMessageID, ULONG ulTitleID, ULONG ulStyle )
{
CHAR szMessage[MAX_STRING_BYTES] = "";
CHAR szTitle[MAX_STRING_BYTES] = "";
WinLoadString( habAnchor, NULLHANDLE, ulMessageID, sizeof( szMessage ), szMessage );
WinLoadString( habAnchor, NULLHANDLE, ulTitleID, sizeof( szTitle ), szTitle );
return WinMessageBox( HWND_DESKTOP,
HWND_DESKTOP,
szMessage,
szTitle,
0,
ulStyle );
}
int main()
{
HMQ hmq;
QMSG qmsg;
ULONG flFrameFlags = FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
FCF_MINMAX | FCF_SHELLPOSITION | FCF_TASKLIST |
FCF_ICON | FCF_MENU;
CHAR szClientClass[] = "CLIENT";
hab = WinInitialize (0);
hmq = WinCreateMsgQueue (hab, 0);
WinRegisterClass (hab, szClientClass, (PFNWP)ClientWndProc, 0, 0);
WinLoadString (hab, 0, ID_APPNAME, sizeof(szTitle), szTitle);
hWndFrame = WinCreateStdWindow (HWND_DESKTOP, WS_VISIBLE,
&flFrameFlags, szClientClass, szTitle, 0, 0, ID_APPNAME, &hWndClient);
while (WinGetMsg (hab, &qmsg, 0, 0, 0))
WinDispatchMsg (hab, &qmsg);
WinDestroyWindow (hWndFrame);
WinDestroyMsgQueue (hmq);
WinTerminate (hab);
return (0);
}
/**********************************************************************
* Function: CopyClipBoardData2TempFile
* Info : Check clipboard for text data and copy them to temp file
* Result : NO_ERROR, ERROR_ACCESS_DENIED, ERROR_OPEN_FAILED
**********************************************************************/
ULONG CopyClipBoardData2TempFile(void)
{
ULONG Result = NO_ERROR, MsgID;
PSZ pszMem;
FILE *fp;
int c;
if (WinOpenClipbrd(Hab))
{
pszMem = (PSZ) WinQueryClipbrdData(Hab, CF_TEXT);
if (NULL == pszMem)
Result = ERROR_INVALID_DATA;
else
{
if (NULL != (fp = fopen(TempFile, "wb")))
{
while (0 != (c = (int)(*pszMem)))
{
fputc(c, fp);
++pszMem;
}
fclose(fp);
}
else
Result = ERROR_OPEN_FAILED;
}
WinCloseClipbrd(Hab);
}
else
Result = ERROR_ACCESS_DENIED;
if (NO_ERROR != Result)
{
switch(Result)
{
case ERROR_INVALID_DATA:
MsgID = IDS_INVALID_CLIPBOARD_DATA;
break;
case ERROR_ACCESS_DENIED:
MsgID = IDS_NO_CLIPBOARD_ACCESS;
break;
default:
MsgID = IDS_GENERAL_PROCESS_FAILURE;
break;
}
Len = WinLoadString(Hab, hRessourceModule, MsgID,
MSGSTRN_MAXLEN, Msg);
WinMessageBox(HWND_DESKTOP, hwndMainDialog, Msg, NULL, 0, MB_ERROR | MB_OK);
}
return Result;
}
BOOL mwpCreate(HWND hWnd, MPARAM mp1)
{
BOOL fAbort = FALSE;
PINITDATA pinitdata = (PINITDATA)mp1;
ULONG flSlider = WS_VISIBLE | SLS_HORIZONTAL | SLS_CENTER | SLS_PRIMARYSCALE1 | SLS_HOMELEFT | SLS_BUTTONSLEFT | SLS_SNAPTOINCREMENT | SLS_RIBBONSTRIP | WS_DISABLED;
ULONG flSText = WS_VISIBLE | SS_TEXT | DT_VCENTER | DT_RIGHT;
SLDCDATA sldData;
PSZ pszTitle = new char[128];
HAB hAB = WinQueryAnchorBlock(hWnd);
WinCreateWindow(hWnd, WC_PROGRESSBAR, (PSZ)NULL, WS_VISIBLE, 10, 10, 300, 60, hWnd, HWND_TOP, PB_PROGRESS, (PVOID)NULL, (PVOID)NULL);
WinLoadString(hAB, (HMODULE)NULLHANDLE, IDS_VOLUME, 128, pszTitle);
WinCreateWindow(hWnd, WC_STATIC, pszTitle, flSText, 20, 40, 100, 40, hWnd, HWND_TOP, ST_VOLUME, NULL, NULL);
sldData.cbSize = sizeof(sldData);
sldData.usScale1Increments = 100;
sldData.usScale1Spacing = 0;
WinCreateWindow(hWnd, WC_SLIDER, (PSZ)NULL, flSlider, 20, 40, 100, 40, hWnd, HWND_TOP, SLRD_VOLUME, &sldData, NULL);
pinitdata->hWnd = hWnd;
if(_beginthread(StartupThread, NULL, 16386, (void*)pinitdata) == 0)
fAbort = TRUE;
delete pszTitle;
return fAbort;
}
BOOL getMessage(char* text, ULONG ulID, LONG lSizeText, HMODULE hResource, HWND hwnd)
{
if(!WinLoadString(WinQueryAnchorBlock(hwnd),hResource,ulID,lSizeText,text)) {
sprintf(text,"");
return FALSE;
}
return TRUE;
}
/****************************************************************\
* Initialization routine
*--------------------------------------------------------------
*
* Name: Init()
*
* Purpose: Performs initialization functions.
*
* Usage: Called once before the message queue is queried.
*
* Method:
* - starts processing thread
* - registers all window classes
*
* Returns:
* TRUE - initialization is successful
* FALSE - initialization failed
\****************************************************************/
BOOL Init(int argc, char *argv[])
{
PTIB ptibDummy;
PIB *ppibProcess;
ULONG flCtlData; /* frame control data */
/* load application name from resource file */
if(!WinLoadString(hab, NULLHANDLE, IDS_APPNAME, MAXNAMEL, (PSZ)szAppName))
return FALSE;
/* register the main client window class */
if(!WinRegisterClass(hab,
(PSZ)szAppName,
MainWndProc,
CS_SIZEREDRAW | CS_CLIPCHILDREN,
0UL))
{
return FALSE;
}
flCtlData = FCF_STANDARD | FCF_VERTSCROLL | FCF_HORZSCROLL;
hwndMainFrame = WinCreateStdWindow(HWND_DESKTOP,
WS_VISIBLE,
&flCtlData,
(PSZ)szAppName,
(PSZ)NULL,
WS_VISIBLE,
NULLHANDLE,
IDR_MAIN,
&hwndMain);
if (NULLHANDLE == hwndMainFrame)
return FALSE;
WinSetWindowText(hwndMainFrame, (PSZ)szAppName);
if (DosGetInfoBlocks(&ptibDummy, &ppibProcess) ||
!(hqQ = InitQ((*ppibProcess).pib_ulpid, /* process that will send WM_CLOSE command */
hwndMainFrame))) /* window to post to */
return FALSE;
if (argc > 1)
{
RESULTCODES resc;
CHAR pszBuff[CCHMAXPATH];
if ((BOOL)DosExecPgm((PSZ)pszBuff, CCHMAXPATH, EXEC_ASYNC, NULL, NULL, &resc, argv[1]))
{
MessageBox(hwndMain, IDMSG_CANNOT_EXEC_CLIENT, MB_CUAWARNING | MB_OK, TRUE);
}
}
InitHelp();
return TRUE;
} /* Init() */
static void FileWarning(PSZ pFileName, ULONG MsgID)
{
PSZ pStrn;
if (NULL == pFileName)
return;
Len = WinLoadString(Hab, hRessourceModule, IDS_WARNING,
TITLESTRN_MAXLEN, Title);
Len = WinLoadString(Hab, hRessourceModule, MsgID,
MSGSTRN_MAXLEN, Msg);
pStrn = (PSZ) malloc((Len+strlen(pFileName)+1)*sizeof(CHAR));
if (NULL != pStrn)
{
sprintf(pStrn, Msg, pFileName);
WinAlarm(HWND_DESKTOP, WA_WARNING);
WinMessageBox(HWND_DESKTOP, hwndMainDialog, pStrn, Title, 0, MB_WARNING | MB_OK);
free(pStrn);
}
}
ULONG Init(VOID)
#endif
{
/* Add ExitProc to the exit list to handle the exit processing. If
* there is an error, then terminate the process since there have
* not been any resources allocated yet
*/
if (DosExitList(EXLST_ADD, (PFNEXITLIST)ExitProc))
{
MessageBox(HWND_DESKTOP,
IDMSG_CANNOTLOADEXITLIST, 0,
MB_OK | MB_ERROR,
TRUE);
DosExit(EXIT_PROCESS, RETURN_ERROR);
}
/* load application name from resource file */
if(0==WinLoadString(vhab, (HMODULE)NULL, IDS_APPNAME, CCHAPPNAME, szAppName))
return IDMSG_CANNOTLOADSTRING;
/* register the main client window class */
if (!WinRegisterClass(vhab,
szAppName,
(PFNWP)MainWndProc,
0L,
0))
return IDMSG_INITFAILED;
/*
* create main application window & detach scrollbars
*/
if (!InitMainWindow())
return IDMSG_MAINWINCREATEFAILED;
/*
* set up globals used for sizing & system pointers
*/
if (!InitGlobalVars())
return IDMSG_INITFAILED;
/*
* this function prepares the application for loading images
*/
InitClientArea(vhwndClient);
/*
* initialize help mechanism
*/
#ifdef HELP_MANAGER_ENABLED
HelpInit();
#endif
return NO_ERROR;
} /* End of Init */
extern char *DUILoadString( int id )
{
char buff[256];
char *ret;
int size;
size = WinLoadString( 0, NULLHANDLE, id, sizeof( buff ), buff );
// size = LoadString( GetModuleHandle( NULL ), id, buff, sizeof( buff ) );
buff[size] = NULLCHAR;
ret = DbgAlloc( size + 1 );
strcpy( ret, buff );
return( ret );
}
VOID GetNLSString(PSZ pszBuf,
ULONG cbBuf,
ULONG id)
{
if (!WinLoadString(G_hab,
G_hmodNLS,
id,
cbBuf,
pszBuf))
sprintf(pszBuf,
"Cannot load string resource %d from \"%s\"",
id,
G_szNLSDLL);
}
/**************************************************************************
*
* Name : UpdateTitleText
*
* Description: Updates the text in the main window's title bar to
* display the app name, followed by the separator,
* followed by the file name.
*
* Concepts : Called at init time and when the text file is changed.
* Gets the program name, appends the separator, and
* appends the file name.
*
* API's : WinLoadString
* WinSetWindowText
* WinWindowFromID
*
* Parameters : hwnd = window handle
*
* Return : [none]
*
*************************************************************************/
VOID UpdateTitleText(HWND hwnd)
{
CHAR szBuf[MAXNAMEL+TITLESEPARATORLEN+CCHMAXPATH];
CHAR szSeparator[TITLESEPARATORLEN+1];
PSZ pszT;
WinLoadString(hab, (HMODULE)0, IDS_APPNAME, MAXNAMEL, szBuf);
WinLoadString(hab,
(HMODULE)0,
IDS_TITLEBARSEPARATOR,
TITLESEPARATORLEN,
szSeparator);
strcat(szBuf, szSeparator);
if(szFullPath[0] == '\0')
pszT = szUntitled;
else
pszT = szFullPath;
strcat(szBuf, pszT);
WinSetWindowText(WinWindowFromID(hwnd, FID_TITLEBAR), szBuf);
} /* End of UpdateTitleText */
/*
load_configuration_data
Load all module configuration data from the INI-file into the
configuration_data structure, if not done already loaded.
*/
void load_configuration_data(void)
{
if(configuration_data_loaded == FALSE){
// data not loaded yet
ULONG size;
// get name of the saver module (stored as resource string)
if(WinLoadString(hab, hmodDLL, IDS_MODULENAME,
SAVER_NAME_MAXLEN, (PSZ)modulename) == 0){
// resource string not found. indicate error by
// setting module name to empty string (the name
// "" is interpreted as an error by SSDLL.DLL and
// the module does not show up in the list box).
strcpy(modulename, "");
return;
}
// load data from INI-file. the key name is the name of the
// saver module
size = query_profile_data();
if(size != sizeof(configuration_data)
|| configuration_data.version != MODULEVERSION
|| strncmp(modulename, configuration_data.modulename, sizeof(modulename)) != 0){
// if entry is not found or entry has invalid size or
// entry has wrong version number, create a new entry
// with default values and write it to the INI-file
configuration_data.version = MODULEVERSION;
configuration_data.enabled = TRUE;
configuration_data.animation_speed = CONFIGURATION_DEFAULT_ANIMATIONSPEED;
strncpy(configuration_data.modulename, modulename, sizeof(configuration_data.modulename));
/*
$$$$$ insert code here $$$$$
If you have added data to the configuration_data
structure, insert code here to set the default
values for your data items.
$$$$$ for example $$$$$
*/
configuration_data.count = CONFIGURATION_DEFAULT_COUNT;
configuration_data.colors = COLORS_DEFAULT;
configuration_data.blank_screen = CONFIGURATION_DEFAULT_BLANKSCREEN;
write_profile_data();
}
configuration_data_loaded = TRUE;
}
}
/*
load_configuration_data
Load all module configuration data from the INI-file into the
configuration_data structure, if not done already loaded.
*/
void load_configuration_data(void)
{
if(configuration_data_loaded == FALSE){
// data not loaded yet
ULONG size;
BOOL fSuccess;
// get name of the saver module (stored as resource string)
if(WinLoadString(hab, hmodDLL, IDS_MODULENAME,
SAVER_NAME_MAXLEN, (PSZ)modulename) == 0){
// resource string not found. indicate error by
// setting module name to empty string (the name
// "" is interpreted as an error by SSDLL.DLL and
// the module does not show up in the list box).
strcpy(modulename, "");
return;
}
// load data from INI-file. the key name is the name of the
// saver module
size = sizeof(configuration_data);
fSuccess = PrfQueryProfileData(HINI_USER,
(PSZ)application_name, (PSZ)modulename,
(PSZ)&configuration_data, &size);
if(!fSuccess || size != sizeof(configuration_data) || configuration_data.version != MODULEVERSION){
// if entry is not found or entry has invalid size or
// entry has wrong version number, create a new entry
// with default values and write it to the INI-file
configuration_data.version = MODULEVERSION;
configuration_data.enabled = TRUE;
configuration_data.animation_speed = CONFIGURATION_DEFAULT_ANIMATIONSPEED;
/*
$$$$$ insert code here $$$$$
If you have added data to the configuration_data
structure, insert code here to set the default
values for your data items.
$$$$$ for example $$$$$
configuration_data.count = CONFIGURATION_DEFAULT_COUNT;
*/
configuration_data.drunken = DRUNKEN;
PrfWriteProfileData(HINI_USER, (PSZ)application_name, (PSZ)modulename, (PSZ)&configuration_data, sizeof(configuration_data));
}
configuration_data_loaded = TRUE;
}
}
SOM_Scope void SOMLINK WPSamFM_wpclsInitData (M_WPSamF *somSelf)
{
/* M_WPSamFData *somThis = M_WPSamFGetData (somSelf); */
M_WPSamFMethodDebug ("M_WPSamF","WPSamFM_wpclsInitData");
parent_wpclsInitData (somSelf);
_clsQueryModuleHandle (somSelf);
/* Get Class Title */
if (!WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP),
_clsQueryModuleHandle (somSelf),
IDS_TITLE_WPSAMF,
sizeof (szSamFClassTitle),
szSamFClassTitle))
strcpy (szSamFClassTitle, _wpclsQueryTitle (somSelf));
M_WPSamFMethodDebug ("M_WPSamF","WPSamFM_wpclsInitData Ende");
return;
}
SOM_Scope BOOL SOMLINK WPSamFolder_wpAddSettingsPages (WPSamF *somSelf,
HWND hwndNotebook)
{
PAGEINFO pageinfo;
CHAR szPageName[CCHMAXPGNAME];
/* WPSamFData *somThis = WPSamFGetData (somSelf); */
WPSamFMethodDebug ("WPSamF","WPSamFolder_wpAddSettingsPages");
memset ((PCH)&pageinfo,0,sizeof (PAGEINFO));
WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP), hmod,
IDS_WPSAMF_PG1, CCHMAXPGNAME, szPageName);
pageinfo.cb = sizeof (PAGEINFO);
pageinfo.hwndPage = NULLHANDLE;
pageinfo.usPageStyleFlags = BKA_MAJOR;
pageinfo.usPageInsertFlags = BKA_FIRST;
pageinfo.usSettingsFlags = SETTINGS_PAGE_NUMBERS;
pageinfo.pfnwp = CtxtDlgProc;
pageinfo.resid = hmod;
pageinfo.dlgid = IDD_CONTEXTMENU;
pageinfo.pszName = szPageName;
pageinfo.pCreateParams = somSelf;
pageinfo.idDefaultHelpPanel = PANEL_CONTEXTMENU;
pageinfo.pszHelpLibraryName = HELPFILE;
if (!_wpInsertSettingsPage (somSelf, hwndNotebook, &pageinfo))
{
DebugE (D_SOM, "_wpAddSettingsPages",
"Failed to add Context_Menu settings page");
return (FALSE);
}
if (!parent_wpAddSettingsPages (somSelf, hwndNotebook))
{
DebugE (D_SOM, "_wpAddSettingsPages",
" Failed to add parent's settings pages");
return (FALSE);
}
return TRUE;
}
/*
load_configuration_data
Load all module configuration data from the INI-file into the
configuration_data structure, if not done already loaded.
*/
void load_configuration_data(void)
{
if(configuration_data_loaded == FALSE){
/* data not loaded yet */
ULONG size;
/* get name of the saver module (stored as resource string) */
if(WinLoadString(hab, hmodDLL, IDS_MODULENAME,
SAVER_NAME_MAXLEN, (PSZ)modulename) == 0){
/* resource string not found. indicate error by */
/* setting module name to empty string (the name */
/* "" is interpreted as an error by SSDLL.DLL and */
/* the module does not show up in the list box). */
strcpy(modulename, "");
return;
}
/* load data from INI-file. the key name is the name of the */
/* saver module */
size = query_profile_data();
if(size != sizeof(configuration_data) || configuration_data.version != MODULEVERSION){
/* if entry is not found or entry has invalid size or */
/* entry has wrong version number, create a new entry */
/* with default values and write it to the INI-file */
configuration_data.version = MODULEVERSION;
configuration_data.enabled = TRUE;
configuration_data.tracename = TRUE;
configuration_data.show3d = TRUE;
configuration_data.gravity = CONFIGURATION_DEFAULT_GRAVITY;
configuration_data.whitestar_count = CONFIGURATION_DEFAULT_STARS;
configuration_data.redstar_count = CONFIGURATION_DEFAULT_STARS;
configuration_data.bluestar_count = CONFIGURATION_DEFAULT_STARS;
configuration_data.yellowstar_count = CONFIGURATION_DEFAULT_STARS;
write_profile_data();
}
configuration_data_loaded = TRUE;
}
}
/****************************************************************\
*
*--------------------------------------------------------------
*
* Name:ClkCreate()
*
* Purpose:Intialize a newly created client window
*
*
*
* Usage:
*
* Method:
* -
*
* -
* -
*
* -
* -
*
* Returns:
* 1 - if sucessful execution completed
* 0 - if error
\****************************************************************/
VOID ClkCreate ( HWND hwnd )
{
LONG cxScreen , cyScreen; /* screen dimensions */
LONG xLeft , yBottom ; /* frame window location */
ULONG cbBuf;
LONG cyHeight;
LONG cxWidth;
hwndClient = hwnd;
WinLoadString(hab, NULLHANDLE, IDS_TITLE, 0, (PSZ)szTitle );
WinLoadString(hab, NULLHANDLE, IDS_HELPTITLE, 256, (PSZ)szHelpTitle);
GetCountryDependent();
/* we are called before the global hwndFrame is valid */
hwndFrame = WinQueryWindow ( hwnd , QW_PARENT) ;
hwndTitleBar = WinWindowFromID ( hwndFrame , FID_TITLEBAR ) ;
hwndSysMenu = WinWindowFromID ( hwndFrame , FID_SYSMENU ) ;
hwndMinMax = WinWindowFromID ( hwndFrame , FID_MINMAX ) ;
/* load our menus */
hwndMenu = WinLoadMenu (hwndFrame, NULLHANDLE, IDR_MAIN);
/* determine screen dimensions */
/* open a device context and create a presentation space */
hdc = WinOpenWindowDC (hwnd);
hps = GpiCreatePS (hab, hdc, &sizl, PU_ARBITRARY | GPIT_MICRO |
GPIA_ASSOC);
/*
* Create our off-screen 'buffer'.
*/
hdcBuffer = DevOpenDC ( (HAB)0L, OD_MEMORY, "*", 0L, NULL, hdc);
hpsBuffer = GpiCreatePS (hab, hdcBuffer, &sizl, PU_ARBITRARY |
GPIT_MICRO | GPIA_ASSOC);
GpiCreateLogColorTable (hpsBuffer, 0, LCOLF_RGB, 0, 0, (PLONG)NULL);
/* get the device resolutions so we can make the face appear circular */
DevQueryCaps (hdc, (LONG)CAPS_VERTICAL_RESOLUTION,(LONG) 1L, &cyRes);
DevQueryCaps (hdc, CAPS_HORIZONTAL_RESOLUTION, 1L, &cxRes);
DevQueryCaps (hdc, CAPS_COLOR_PLANES, 1L, &cColorPlanes);
DevQueryCaps (hdc, CAPS_COLOR_BITCOUNT, 1L, &cColorBitcount);
cxScreen = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN);
cyScreen = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN);
/*
* Calculate an initial window position and size.
*/
xLeft = cxScreen / 8;
yBottom = cyScreen / 2;
cxWidth = cxScreen / 3;
cyHeight = cyScreen / 2;
WinSetWindowPos (hwndFrame, NULLHANDLE, xLeft, yBottom,
cxWidth, cyHeight,
SWP_SIZE | SWP_MOVE | SWP_ACTIVATE);
cbBuf = sizeof(cp);
if (!PrfQueryProfileData(HINI_USER, SZ_APPNAME, SZ_KEYNAME, &cp, &cbBuf))
{
cp.usMajorTickPref = CLKTM_ALWAYS;
cp.usMinorTickPref = CLKTM_NOTICONIC;
cp.clrBackground = 0x00008080;
cp.clrFace = 0x00008080;
cp.clrHourHand = RGB_RED;
cp.clrMinuteHand = RGB_RED;
cp.fControlsHidden = FALSE;
cp.usDispMode = DM_TIME | DM_ANALOG | DM_SECONDHAND;
cp.alarm.uchHour = 0;
cp.alarm.uchMinutes = 0;
cp.alarm.usMode = 0;
SetRGBColors();
/* position the window and make it visible */
WinSetWindowPos( hwndFrame , NULLHANDLE ,
xLeft , yBottom ,
cxWidth , cyHeight ,
SWP_SIZE | SWP_MOVE | SWP_ACTIVATE);
WinQueryWindowPos(hwndFrame, &cp.swp);
}
else
{ /*Protect against garbage swp*/
cp.swp.hwnd = hwndFrame;
cp.swp.hwndInsertBehind = HWND_TOP;
cp.swp.fl = (cp.swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE)) | SWP_SIZE | SWP_MOVE | SWP_ACTIVATE;
SetRGBColors();
WinSetMultWindowPos(hab, &cp.swp, 1);
}
if (cp.fControlsHidden)
ClkHideFrameControls (hwndFrame);
/*
* Check relevant items.
*/
WinSendMsg( hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT( IDM_TIME, TRUE),
MPFROM2SHORT( MIA_CHECKED,
( (cp.usDispMode & DM_TIME)? MIA_CHECKED
: ~MIA_CHECKED) ) );
WinSendMsg( hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT( IDM_DATE, TRUE),
MPFROM2SHORT( MIA_DISABLED,
( (!(cp.usDispMode & DM_TIME))? MIA_DISABLED
: ~MIA_DISABLED) ) );
WinSendMsg( hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT( IDM_DATE, TRUE),
MPFROM2SHORT( MIA_CHECKED,
( (cp.usDispMode & DM_DATE)? MIA_CHECKED
: ~MIA_CHECKED) ) );
WinSendMsg( hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT( IDM_TIME, TRUE),
MPFROM2SHORT( MIA_DISABLED,
( ((!(cp.usDispMode & DM_DATE) || (cp.usDispMode & DM_ANALOG)))? MIA_DISABLED
: ~MIA_DISABLED) ) );
WinSendMsg( hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT( (cp.usDispMode & DM_DIGITAL)
?IDM_DIGITAL
:IDM_ANALOG,
TRUE),
MPFROM2SHORT( MIA_CHECKED,
MIA_CHECKED));
WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_SECONDHAND, TRUE),
MPFROM2SHORT( MIA_CHECKED,
( (cp.usDispMode & DM_SECONDHAND) ? MIA_CHECKED
: ~MIA_CHECKED)));
/*
* Disable these items if the digital clock is visible
* since they won't apply.
*/
if (cp.usDispMode & DM_DIGITAL)
{
WinSendMsg (hwndMenu, MM_SETITEMATTR,
MPFROM2SHORT(IDM_SECONDHAND, TRUE),
MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
WinSendMsg (hwndMenu, MM_SETITEMATTR,
MPFROM2SHORT( IDM_TICKS, TRUE), MPFROM2SHORT( MIA_DISABLED,
MIA_DISABLED));
}
/* have we been asked to start as an icon? */
if (fStartAsIcon)
WinSetWindowPos(hwndFrame, NULLHANDLE, 0, 0, 0, 0, SWP_MINIMIZE);
WinShowWindow(hwndFrame, TRUE);
/* get the time in a format for dislaying */
DosGetDateTime(&dt);
dt.hours = (UCHAR )(dt.hours * (UCHAR) 5) % (UCHAR) 60 + dt.minutes / (UCHAR)12;
/* start a timer */
WinStartTimer (hab, hwnd, IDR_MAIN, 1000);
WinLoadString(hab, NULLHANDLE, IDS_TITLE, 80, (PSZ)szTitle);
GetCountryDependent();
}
/**************************************************************************
*
* Name : MyWindowProc
*
* Description: The window procedure associated with the client area in
* the standard frame window. It processes all messages
* either sent or posted to the client area, depending on
* the message command and parameters.
*
* Concepts :
*
* API's : WinLoadString
* WinInvalidateRegion
* WinPostMsg
* WinDefWindowProc
* WinBeginPaint
* GpiSetColor
* GpiSetBackColor
* GpiSetBackMix
* GpiCharStringAt
* WinEndPaint
*
* Parameters : hwnd = window handle
* msg = message code
* mp1 = first message parameter
* mp2 = second message parameter
*
* Return : depends on message sent
*
*************************************************************************/
MRESULT EXPENTRY MyWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
switch( msg )
{
case WM_TIMER: {
WinInvalidateRegion( hwnd, 0L, FALSE );
break;
}
case WM_CREATE:
/*
* Window initialization is performed here in WM_CREATE processing
* WinLoadString loads strings from the resource file.
*/
WinLoadString( hab, (HMODULE)0L, IDS_HELLO, STRINGLENGTH, szHello );
WinLoadString( hab, (HMODULE)0L, IDS_1, STRINGLENGTH, sz1 );
WinLoadString( hab, (HMODULE)0L, IDS_2, STRINGLENGTH, sz2 );
WinLoadString( hab, (HMODULE)0L, IDS_3, STRINGLENGTH, sz3 );
strcpy( szString, szHello ); /* Copy text Hello into szString*/
break;
case WM_COMMAND:
/*
* When the user chooses option 1, 2, or 3 from the Options pull-
* down, the text string is set to 1, 2, or 3, and
* WinInvalidateRegion sends a WM_PAINT message.
* When Exit is chosen, the application posts itself a WM_CLOSE
* message.
*/
{
USHORT command; /* WM_COMMAND command value */
command = SHORT1FROMMP(mp1); /* Extract the command value */
switch (command)
{
case ID_EXITPROG:
WinPostMsg( hwnd, WM_CLOSE, (MPARAM)0, (MPARAM)0 );
break;
default:
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
break;
}
case WM_ERASEBACKGROUND:
/*
* Return TRUE to request PM to paint the window background
* in SYSCLR_WINDOW.
*/
return (MRESULT)( TRUE );
case WM_PAINT:
/*
* Window contents are drawn here in WM_PAINT processing.
*/
{
HPS hps; /* Presentation Space handle */
RECTL rc; /* Rectangle coordinates */
POINTL pt; /* String screen coordinates */
POINTL pPos;
LONG lColor,r,g,b;
FATTRS fat;
HPS shps = WinGetScreenPS(HWND_DESKTOP);
fat.usRecordLength = sizeof(FATTRS); /* sets size of structure */
fat.fsSelection = 0; /* uses default selection */
fat.lMatch = 0L; /* does not force match */
fat.idRegistry = 0; /* uses default registry */
fat.usCodePage = 0; /* code-page 850 */
fat.lMaxBaselineExt = 14L; /* requested font height is 12 pels */
fat.lAveCharWidth = 14L; /* requested font width is 12 pels */
fat.fsType = 0; /* uses default type */
fat.fsFontUse = FATTR_FONTUSE_NOMIX;/* doesn't mix with graphics */
strcpy(fat.szFacename ,"Courier");
WinQueryPointerPos(HWND_DESKTOP, &pPos);
hps = WinBeginPaint( hwnd, 0L, &rc );
GpiCreateLogColorTable(shps, 0, LCOLF_RGB, 0, 0, NULL);
GpiCreateLogColorTable(hps, 0, LCOLF_RGB, 0, 0, NULL);
pt.x = 10; pt.y = 27; /* Set the text coordinates, */
lColor=GpiQueryPel(shps, &pPos);
GpiSetBackColor( hps, 16777215); /* its background and */
WinFillRect( hps, &rc, lColor);
GpiSetBackMix( hps, BM_OVERPAINT ); /* how it mixes, */
b = lColor & 0x000000FF;
lColor = lColor >> 8;
g = lColor & 0x000000FF;
lColor = lColor >> 8;
r = lColor & 0x000000FF;
WinReleasePS(shps);
sprintf(szString,"Color: #%.2X%.2X%.2X",r,g,b);
GpiCreateLogFont(hps, NULL, 1L, &fat);
GpiSetCharSet(hps, 1L);
GpiSetCharMode(hps, CM_MODE1);
GpiCharStringAt( hps,&pt ,(LONG)strlen( szString ), szString );
WinEndPaint( hps ); /* Drawing is complete */
break;
}
case WM_CLOSE:
WinPostMsg( hwnd, WM_QUIT, (MPARAM)0,(MPARAM)0 );/* Cause termination*/
break;
default:
/*
* Everything else comes here. This call MUST exist
* in your window procedure.
*/
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
return (MRESULT)FALSE;
} /* End of MyWindowProc */
//-------------------------------------------------------------------------
//
// Show - Display the file dialog
//
//-------------------------------------------------------------------------
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *retval)
{
NS_ENSURE_ARG_POINTER(retval);
PRBool result = PR_FALSE;
nsCAutoString fileBuffer;
char *converted = ConvertToFileSystemCharset(mDefault);
if (nsnull == converted) {
LossyCopyUTF16toASCII(mDefault, fileBuffer);
}
else {
fileBuffer.Assign(converted);
nsMemory::Free( converted );
}
char *title = ConvertToFileSystemCharset(mTitle);
if (nsnull == title)
title = ToNewCString(mTitle);
nsCAutoString initialDir;
if (mDisplayDirectory)
mDisplayDirectory->GetNativePath(initialDir);
// If no display directory, re-use the last one.
if(initialDir.IsEmpty())
initialDir = mLastUsedDirectory;
mFile.Truncate();
FILEDLG filedlg;
memset(&filedlg, 0, sizeof(FILEDLG));
filedlg.cbSize = sizeof(FILEDLG);
filedlg.pszTitle = title;
if (mMode == modeGetFolder) {
PL_strncat(filedlg.szFullFile, initialDir.get(), MAX_PATH);
PL_strncat(filedlg.szFullFile, "\\", 1);
PL_strncat(filedlg.szFullFile, "^", 1);
filedlg.fl = FDS_OPEN_DIALOG | FDS_CENTER;
filedlg.pfnDlgProc = DirDialogProc;
DosError(FERR_DISABLEHARDERR);
WinFileDlg(HWND_DESKTOP, mWnd, &filedlg);
DosError(FERR_ENABLEHARDERR);
char* tempptr = strstr(filedlg.szFullFile, "^");
if (tempptr)
*tempptr = '\0';
if (filedlg.lReturn == DID_OK) {
result = PR_TRUE;
if (!mDisplayDirectory)
mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1");
if (mDisplayDirectory)
mDisplayDirectory->InitWithNativePath(nsDependentCString(filedlg.szFullFile));
mFile.Assign(filedlg.szFullFile);
}
}
else {
PL_strncpy(filedlg.szFullFile, initialDir.get(), MAX_PATH);
PL_strncat(filedlg.szFullFile, "\\", 1);
PL_strncat(filedlg.szFullFile, fileBuffer.get(), MAX_PATH);
filedlg.fl = FDS_CENTER;
if (mMode == modeSave) {
filedlg.fl |= FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB;
} else if (mMode == modeOpenMultiple) {
filedlg.fl |= FDS_MULTIPLESEL | FDS_OPEN_DIALOG;
} else {
filedlg.fl |= FDS_OPEN_DIALOG;
}
PMYDATA pmydata;
pmydata = (PMYDATA)calloc(1, sizeof(MYDATA));
filedlg.ulUser = (ULONG)pmydata;
filedlg.pfnDlgProc = FileDialogProc;
PRUint32 i;
PSZ *apszTypeList;
apszTypeList = (PSZ *)malloc(mTitles.Length()*sizeof(PSZ)+1);
for (i = 0; i < mTitles.Length(); i++)
{
const nsString& typeWide = mTitles[i];
nsAutoCharBuffer buffer;
PRInt32 bufLength;
WideCharToMultiByte(0, typeWide.get(), typeWide.Length(),
buffer, bufLength);
apszTypeList[i] = ToNewCString(nsDependentCString(buffer.Elements()));
}
apszTypeList[i] = 0;
filedlg.papszITypeList = (PAPSZ)apszTypeList;
PSZ *apszFilterList;
apszFilterList = (PSZ *)malloc(mFilters.Length()*sizeof(PSZ)+1);
for (i = 0; i < mFilters.Length(); i++)
{
const nsString& filterWide = mFilters[i];
apszFilterList[i] = ToNewCString(filterWide);
}
apszFilterList[i] = 0;
pmydata->papszIFilterList = (PAPSZ)apszFilterList;
pmydata->ulCurExt = mSelectedType;
PRBool fileExists;
do {
DosError(FERR_DISABLEHARDERR);
WinFileDlg(HWND_DESKTOP, mWnd, &filedlg);
DosError(FERR_ENABLEHARDERR);
if ((filedlg.lReturn == DID_OK) && (mMode == modeSave)) {
PRFileInfo64 fileinfo64;
PRStatus status = PR_GetFileInfo64(filedlg.szFullFile, &fileinfo64);
if (status == PR_SUCCESS) {
fileExists = PR_TRUE;
} else {
fileExists = PR_FALSE;
}
if (fileExists) {
if (!gpszFDSaveCaption) {
HMODULE hmod;
char LoadError[CCHMAXPATH];
char loadedString[256];
int length;
DosLoadModule(LoadError, CCHMAXPATH, "PMSDMRI", &hmod);
length = WinLoadString((HAB)0, hmod, 1110, 256, loadedString);
gpszFDSaveCaption = (char*)malloc(length+1);
strcpy(gpszFDSaveCaption, loadedString);
length = WinLoadString((HAB)0, hmod, 1135, 256, loadedString);
gpszFDFileExists = (char*)malloc(length+1);
strcpy(gpszFDFileExists, loadedString);
length = WinLoadString((HAB)0, hmod, 1136, 256, loadedString);
gpszFDFileReadOnly = (char*)malloc(length+1);
strcpy(gpszFDFileReadOnly, loadedString);
int i;
for (i=0;i<256 && gpszFDFileExists[i];i++ ) {
if (gpszFDFileExists[i] == '%') {
gpszFDFileExists[i+1] = 's';
break;
}
}
for (i=0;i<256 && gpszFDFileReadOnly[i];i++ ) {
if (gpszFDFileReadOnly[i] == '%') {
gpszFDFileReadOnly[i+1] = 's';
break;
}
}
DosFreeModule(hmod);
}
char pszFullText[256+CCHMAXPATH];
FILESTATUS3 fsts3;
ULONG ulResponse;
DosQueryPathInfo( filedlg.szFullFile, FIL_STANDARD, &fsts3, sizeof(FILESTATUS3));
if (fsts3.attrFile & FILE_READONLY) {
sprintf(pszFullText, gpszFDFileReadOnly, filedlg.szFullFile);
ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText,
gpszFDSaveCaption, 0,
MB_OK | MB_MOVEABLE | MB_WARNING);
} else {
sprintf(pszFullText, gpszFDFileExists, filedlg.szFullFile);
ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText,
gpszFDSaveCaption, 0,
MB_YESNO | MB_MOVEABLE | MB_WARNING);
}
if (ulResponse == MBID_YES) {
fileExists = PR_FALSE;
}
}
}
} while (mMode == modeSave && fileExists && filedlg.lReturn == DID_OK);
if (filedlg.lReturn == DID_OK) {
result = PR_TRUE;
if (mMode == modeOpenMultiple) {
nsresult rv;
if (filedlg.papszFQFilename) {
for (ULONG i=0;i<filedlg.ulFQFCount;i++) {
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
rv = file->InitWithNativePath(nsDependentCString(*(filedlg.papszFQFilename)[i]));
NS_ENSURE_SUCCESS(rv,rv);
rv = mFiles.AppendObject(file);
NS_ENSURE_SUCCESS(rv,rv);
}
WinFreeFileDlgList(filedlg.papszFQFilename);
} else {
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
rv = file->InitWithNativePath(nsDependentCString(filedlg.szFullFile));
NS_ENSURE_SUCCESS(rv,rv);
rv = mFiles.AppendObject(file);
NS_ENSURE_SUCCESS(rv,rv);
}
} else {
mFile.Assign(filedlg.szFullFile);
}
mSelectedType = (PRInt16)pmydata->ulCurExt;
}
for (i = 0; i < mTitles.Length(); i++)
{
nsMemory::Free(*(filedlg.papszITypeList[i]));
}
free(filedlg.papszITypeList);
for (i = 0; i < mFilters.Length(); i++)
{
nsMemory::Free(*(pmydata->papszIFilterList[i]));
}
free(pmydata->papszIFilterList);
free(pmydata);
}
if (title)
nsMemory::Free( title );
if (result) {
PRInt16 returnOKorReplace = returnOK;
nsresult rv;
// Remember last used directory.
nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
file->InitWithNativePath(mFile);
nsCOMPtr<nsIFile> dir;
if (NS_SUCCEEDED(file->GetParent(getter_AddRefs(dir)))) {
nsCOMPtr<nsILocalFile> localDir(do_QueryInterface(dir));
if (localDir) {
nsCAutoString newDir;
localDir->GetNativePath(newDir);
if(!newDir.IsEmpty())
PL_strncpyz(mLastUsedDirectory, newDir.get(), MAX_PATH+1);
// Update mDisplayDirectory with this directory, also.
// Some callers rely on this.
if (!mDisplayDirectory)
mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1");
if (mDisplayDirectory)
mDisplayDirectory->InitWithNativePath( nsDependentCString(mLastUsedDirectory) );
}
}
if (mMode == modeSave) {
// Windows does not return resultReplace,
// we must check if file already exists
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists)
returnOKorReplace = returnReplace;
}
*retval = returnOKorReplace;
}
else {
*retval = returnCancel;
}
return NS_OK;
}
/**************************************************************************
*
* Name : HelpInit()
*
* Description: Initializes the IPF help facility
*
* Concepts : Called once during initialization of the program
*
* Initializes the HELPINIT structure and creates the
* help instance. If successful, the help instance
* is associated with the main window.
*
* API's : WinLoadString
* WinCreateHelpInstance
* WinAssociateHelpInstance
*
* Parameters : [none]
*
* Return : [none]
*
*************************************************************************/
VOID HelpInit(VOID)
{
HELPINIT hini;
CHAR szLibName[HELPLIBRARYNAMELEN];
CHAR szWindowTitle[HELPLIBRARYNAMELEN];
/* inititalize help init structure */
hini.cb = sizeof(HELPINIT);
hini.ulReturnCode = 0;
hini.pszTutorialName = (PSZ)NULL; /* if tutorial added, add name here */
hini.phtHelpTable = (PHELPTABLE)(0xFFFF0000 | IMAGE_HELP_TABLE);
hini.hmodHelpTableModule = 0;
hini.hmodAccelActionBarModule = 0;
hini.idAccelTable = 0;
hini.idActionBar = 0;
#if (defined(PORT_16) || defined(PORT_S116))
#ifdef DEBUG
hini.usShowPanelId = CMIC_SHOW_PANEL_ID;
#else
hini.usShowPanelId = CMIC_HIDE_PANEL_ID;
#endif /* DEBUG */
#else /* NOT PORT_16 */
#ifdef DEBUG
hini.fShowPanelId = CMIC_SHOW_PANEL_ID;
#else
hini.fShowPanelId = CMIC_HIDE_PANEL_ID;
#endif /* DEBUG */
#endif /* NOT PORT_16 */
if (!WinLoadString(vhab,
(HMODULE)0,
IDS_HELPWINDOWTITLE,
HELPLIBRARYNAMELEN,
(PSZ)szWindowTitle))
{
MessageBox(vhwndFrame, IDMSG_CANNOTLOADSTRING, 0,
MB_OK | MB_ERROR, FALSE);
return;
}
hini.pszHelpWindowTitle = (PSZ)szWindowTitle;
if (!WinLoadString(vhab,
(HMODULE)0,
IDS_HELPLIBRARYNAME,
HELPLIBRARYNAMELEN,
(PSZ)szLibName))
{
MessageBox(vhwndFrame, IDMSG_CANNOTLOADSTRING, 0,
MB_OK | MB_ERROR, FALSE);
return;
}
hini.pszHelpLibraryName = (PSZ)szLibName;
/* creating help instance */
hwndHelpInstance = WinCreateHelpInstance(vhab, &hini);
if (!hwndHelpInstance || hini.ulReturnCode)
{
MessageBox(vhwndFrame, IDMSG_HELPLOADERROR, 0,
MB_OK | MB_ERROR, FALSE);
return;
}
/* associate help instance with main frame */
if (!WinAssociateHelpInstance(hwndHelpInstance, vhwndFrame))
{
MessageBox(vhwndFrame, IDMSG_HELPLOADERROR, 0,
MB_OK | MB_ERROR, FALSE);
return;
}
/* set flag to enable Help menu items */
vfHelpEnabled = TRUE;
} /* End of HelpInit */
/*************************************************************************
*
* Name : WinProc(hwnd, msg, mp1, mp2)
*
* Description: Processes the messages sent to the main client
* window. This routine processes the basic
* messages all client windows should process.
*
* Concepts : This procedure provides service routines for the general
* PM events (messages) that PM sends to the window, as well
* as the user initiated events (messages) that are generated
* when the user selects the action bar and pulldown menu
* controls or the corresponding keyboard accelerators.
*
* The switch statement shown below distributes the window
* messages to the respective message service routines, which
* are set apart by the case statements. The window
* procedures must provide an appropriate service routine for
* its end user initiated messages, as well as the general PM
* messages (like the WM_CLOSE message). If a message is sent
* to this procedure for which there is no programmed case
* clause (i.e., no service routine), the message is defaulted
* function WinDefWindowProc, where it is disposed of by PM.
*
* Time-consuming tasks are posted to the object window where
* they can be performed without the 1/10 second turnaround
* time imposed on the client window. When the object window
* is busy, the client window is usually disabled. The object
* window then posts an acknowledgement
* back to the client when the lengthy task is completed.
*
* Cases under the big switch appear in alphabetical order.
*
* API's : WinLoadString
* WinMessageBox
* WinQueryWindowULong
* WinSendMsg
* WinPostMsg
* WinIsWindowEnabled
* WinSetPointer
* WinQuerySysPointer
* WinBeginPaint
* WinQueryWindowRect
* WinFillRect
* WinEndPaint
* WinInvalidateRect
* WinSetWindowText
* GpiDrawChain
* GpiConvert
* GpiSetDefaultViewMatrix
* GpiAssociate
* GpiDestroyPS
* GpiDeleteBitmap
* GpiDeleteMetafile
*
* Parameters : HWND window handle
* ULONG message
* MPARAM message parameter 1
* MPARAM message parameter 2
*
* Result : MRESULT message result
*
*************************************************************************/
MRESULT EXPENTRY WinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
BOOL bOK;
PMAIN_PARM pmp;
HPS hps;
RECTL rectl;
PSZ psz;
CHAR szWork[ LEN_WORKSTRING ];
SHORT sStep;
ULONG ulWork;
SHORT sNewPos;
ULONG rc;
switch(msg)
{
case WM_CLOSE:
/* obtain the main parameter pointer from window words */
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
#ifdef OSA_AWARE
/* Do OSA termination */
TerminateOSA(hwnd);
#endif
if( pmp->fBusy )
{
/* OK to close when object window is busy? */
WinLoadString( pmp->hab, (HMODULE)NULLHANDLE,
ERRMSG_CLOSE_QUESTION, LEN_WORKSTRING, szWork );
ulWork = WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_YESNOCANCEL | MB_MOVEABLE |
MB_CUANOTIFICATION | MB_APPLMODAL);
if( ulWork == MBID_YES )
{
/* close down the application in spite of being busy */
pmp->fCancel = TRUE;
/* disable client during exit */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0 , (MPARAM)0 );
/* start a watchdog timer to ensure a timely death */
WinStartTimer( pmp->hab, hwnd, ID_DEATH_TIMER, LEN_DEATH_TIMER );
/* Tell object window to close, quit, and post me a WM_QUIT */
WinPostMsg( pmp->hwndObject, WM_USER_CLOSE, (MPARAM)hwnd, (MPARAM)0 );
}
}
else
{
/* not busy, so initiate closure by telling object window to close */
WinPostMsg( pmp->hwndObject, WM_USER_CLOSE, (MPARAM)hwnd, (MPARAM)0 );
}
return (MRESULT)NULL;
case WM_COMMAND:
/* do menu activities; see menu.c */
return Menu( hwnd, msg, mp1, mp2 );
case WM_CREATE:
/*
* Do one-time, startup processing in PRTCREAT.C.
* This function allocates the pmp, a pointer to the program's
* main parameters. See the declaration of this block of
* parameters in PRTSAMP.H, the MAIN_PARM structure.
*
* The Create() function allocates this structure and
* begins to initialize it. Throughout all the code, the pmp->
* pointer is usually obtainable with a call to WinQueryWindowULong.
* Window word space for this pointer was reserved on the call
* to WinRegisterClass.
*
* Create() allocates, initializes, and stores the pmp pointer
* in the client window words. It then starts thread 2 of the
* application on which the object window operates. The pmp
* pointer is passed to thread 2 with _beginthread in PRTCREAT.C.
* The pmp is passed to the object window on the call to
* WinCreateWindow in PRTOBJ.C. Finally, the object window stores
* the pmp in its window words under the WM_CREATE case of the
* ObjectWinProc in PRTOBJ.C.
*
*/
Create( hwnd );
#ifdef OSA_AWARE
/* Do OSA Initialization */
InitOSA(hwnd);
#endif
#ifdef OSA_AWARE
/* Generate a Apple Event - Open Application to myself (Workaround) */
rc = GenerateOSAEvent(hwnd, msg, MPFROMSHORT(IDM_AEOPENAPP), mp2);
#endif
return (MRESULT)NULL;
case WM_HSCROLL:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* Compute some fraction of scroll bar range for a unit of scrolling. */
sStep = pmp->sHScrollRange / 50;
switch( SHORT2FROMMP( mp2 ))
{
case SB_LINELEFT:
pmp->sHScrollPos -= sStep;
break;
case SB_PAGELEFT:
pmp->sHScrollPos -= pmp->sizelClient.cx;
break;
case SB_LINERIGHT:
pmp->sHScrollPos += sStep;
break;
case SB_PAGERIGHT:
pmp->sHScrollPos += pmp->sizelClient.cx;
break;
case SB_SLIDERPOSITION:
case SB_SLIDERTRACK:
pmp->sHScrollPos = SHORT1FROMMP( mp2 );
break;
}
/* Don't allow step assignments to exceed limits of zero to range. */
pmp->sHScrollPos = max( (SHORT)0,
min( pmp->sHScrollPos, pmp->sHScrollRange ));
if( pmp->sHScrollPos != SHORT1FROMMR(WinSendMsg( pmp->hwndHScroll,
SBM_QUERYPOS, (MPARAM)0, (MPARAM)0 )))
{
/*
* New scroll bar thumbbutton position is different than current.
* Set a new X translation value to effect the scroll.
* Current scale setting affects the X element of the matrix.
*/
pmp->matlfDefView.lM31 = OFFSET_XY_TWIPS - (LONG)(pmp->floatScale *
(float)( pmp->sHScrollPos));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient,
9,
&pmp->matlfDefView,
TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
CalibrateHorizontalScrollBar( pmp );
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
case WM_MOUSEMOVE:
/* display which pointer? -- could query pmp->fBusy or... */
if( WinIsWindowEnabled( hwnd ))
{
/* not disabled; display regular pointer */
WinSetPointer( HWND_DESKTOP,
WinQuerySysPointer( HWND_DESKTOP, SPTR_ARROW, FALSE ));
}
else
{
/* disabled; display hourglass because I'm busy */
WinSetPointer( HWND_DESKTOP,
WinQuerySysPointer( HWND_DESKTOP, SPTR_WAIT, FALSE ));
}
return (MRESULT) 1;
case WM_NACK_BITMAP_NOT_SUPPORTED:
/*
* Object window does not support this format of bitmap -
* show a message box.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab, (HMODULE)0,
ERRMSG_BITMAP_NOT_SUPPORTED, LEN_WORKSTRING, szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUACRITICAL | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_NACK_BITMAP_ERROR:
/*
* Object window had error loading the bitmap file -
* show a message box
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab,
(HMODULE)NULLHANDLE,
ERRMSG_BAD_BITMAP,
LEN_WORKSTRING,
szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_NACK_FILE_READING_ERROR:
/*
* Object window had a problem with reading the disk -
* show a message box.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab, (HMODULE)NULLHANDLE,
ERRMSG_READ_ERROR, LEN_WORKSTRING, szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUACRITICAL | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_PAINT:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* do not rely on client window rectangle being correct */
WinQueryUpdateRect( hwnd, &rectl );
WinQueryWindowRect( hwnd, &rectl );
/* current mode of the program affects window painting */
switch( pmp->ulMode )
{
case MODE_UNKNOWN:
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_DEFAULT_SCREEN,
(MPARAM)hwnd, (MPARAM)0 );
/* must call default window proc for window validation */
break;
case MODE_TEXT:
if( pmp->fBusy )
{
/*
* Object window is busy with the client PS drawing into
* retained segments. Use a cached micro PS to merely
* fill the client window with a background wash.
*
* Proper painting of the text will occur in due time
* because the WM_USER_ACK case below will
* invalidate the client window and force a paint.
* The object window won't be busy then.
*/
hps = WinBeginPaint( hwnd, (HPS) 0, &rectl );
pmassert( pmp->hab, hps );
bOK = WinFillRect( hps, &rectl, SYSCLR_WINDOW );
pmassert( pmp->hab, bOK );
WinEndPaint( hps );
}
else
{
/* PS not busy. Use GpiDrawChain to repaint the text */
hps = WinBeginPaint( hwnd, (HPS)pmp->hpsClient, &rectl );
pmassert( pmp->hab, hps );
bOK = WinFillRect( pmp->hpsClient, &rectl, SYSCLR_WINDOW );
pmassert( pmp->hab, bOK );
/*
* GpiDrawChain re-plays the GpiCharString orders that were
* retain in the WM_USER_PAGINATE case in prtobj.c
*/
bOK = GpiDrawChain( pmp->hpsClient );
pmassert( pmp->hab, bOK );
bOK = WinEndPaint( pmp->hpsClient );
pmassert( pmp->hab, bOK );
}
return (MRESULT) 0;
case MODE_BITMAP:
if( pmp->hbm )
{
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_BITMAP,
(MPARAM)hwnd, (MPARAM)0 );
}
/* must call default window proc for window validation */
break;
case MODE_METAFILE:
hps = WinBeginPaint( hwnd, (HPS) 0, &rectl );
pmassert( pmp->hab, hps );
WinFillRect( hps, &rectl, SYSCLR_WINDOW );
if( pmp->hmf )
{
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_METAFILE,
(MPARAM)hwnd, (MPARAM)0 );
}
WinEndPaint( hps );
return (MRESULT) 0;
default:
pmassert( pmp->hab, NULL == "bad case in WM_PAINT" );
}
break;
#ifdef OSA_AWARE
case WM_SEMANTICEVENT:
/* Handle Apple Event Manager Semantic Event */
WinMessageBox( HWND_DESKTOP,
HWND_DESKTOP,
"WM_SEMANTIC_EVENT was received",
"WinProc",
(USHORT)0,
MB_OK | MB_NOICON);
/* Call ProcessSemanticEvent to process the Apple Event */
ProcessSemanticEvent( hwnd, msg, mp1, mp2 );
return (MRESULT) 0;
#endif
case WM_SIZE:
/* Do size process if frame is not minimized */
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/*
* If the object window is busy drawing, the GPI calls here can fail
* because the PS is busy. Check for this situation and delay
* the sizing operation by a few milliseconds.
*/
if( pmp->fBusy )
{
WinStartTimer( pmp->hab, hwnd, ID_SIZE_TIMER, LEN_SIZE_TIMER );
return (MRESULT) 0;
}
ulWork = WinQueryWindowULong( pmp->hwndFrame, QWL_STYLE );
if( !( ulWork & WS_MINIMIZED ))
{
/* Frame is not minimized. Get window size in pels. */
WinQueryWindowRect( hwnd, &rectl );
/* how many twips will fit into the client window now? */
bOK = GpiConvert( pmp->hpsClient, CVTC_DEVICE,
CVTC_WORLD, 2L, (PPOINTL)&rectl );
pmassert( pmp->hab, bOK );
/* compute client size in twips, store in pmp */
pmp->sizelClient.cx = rectl.xRight - rectl.xLeft;
pmp->sizelClient.cy = rectl.yTop - rectl.yBottom;
/* Try to keep the current position still in view by calculating */
/* the difference between size required and client window. */
/* The scroll position is then either 0 or the minimum of the */
/* difference and the old scroll position */
sNewPos = (LONG)FixedInchesToTwips(pmp->form.fxxWidth) +
(((float)(2 * OFFSET_XY_TWIPS)) / pmp->floatScale) -
pmp->sizelClient.cx;
pmp->sHScrollPos = min( max( 0, sNewPos), pmp->sHScrollPos);
sNewPos = (LONG)FixedInchesToTwips(pmp->form.fxyHeight) +
(((float)(2 * OFFSET_XY_TWIPS)) / pmp->floatScale) -
pmp->sizelClient.cy;
pmp->sVScrollPos = min( max( 0, sNewPos), pmp->sVScrollPos);
/* recalibrate the scroll bars */
CalibrateHorizontalScrollBar( pmp );
CalibrateVerticalScrollBar( pmp );
/*
* Modify def-view matrix translation to home the displayed page.
* This depends on the current scaling value.
*/
pmp->matlfDefView.lM31 = OFFSET_XY_TWIPS - (LONG)(pmp->floatScale *
(float)( pmp->sHScrollPos));
pmp->matlfDefView.lM32 = OFFSET_XY_TWIPS + (LONG)(pmp->floatScale *
(float)( pmp->sVScrollPos - pmp->sVScrollRange ));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient, 9,
&pmp->matlfDefView, TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
/* force a paint */
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
case WM_TIMER:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
switch( (ULONG) mp1 )
{
case ID_DEATH_TIMER:
/* object window never posted a quit in allotted time.
WinPostMsg( hwnd, WM_QUIT, 0, 0 );
break;
case ID_SIZE_TIMER:
/* object window was busy with the PS before; try sizing now */
bOK = WinStopTimer( pmp->hab, hwnd, ID_SIZE_TIMER );
pmassert( pmp->hab, bOK );
WinSendMsg( hwnd, WM_SIZE, 0, 0 );
break;
}
return (MRESULT) 0;
case WM_USER_ACK:
/*
* Object window is done processing lengthy task.
* mp1 contains the WM_USER msg originally posted to the object window
* mp2 may contain a result code, depending on mp1
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* reenable the client window */
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
switch( (ULONG)mp1 )
{
case WM_USER_LOAD_BITMAP:
case WM_USER_LOAD_METAFILE:
case WM_USER_LOAD_TEXT:
/*
* Do size processing so that document will
* "home" in the client window.
*/
WinSendMsg( hwnd, WM_SIZE, (MPARAM)0, (MPARAM)0 );
break;
case WM_USER_PAGINATE:
switch( (ULONG)mp2 )
{
case PAGINATE_EOF:
case PAGINATE_EOF_PART_PAGE:
/* seek top of file */
fseek( pmp->f, 0, SEEK_SET );
}
WinInvalidateRect( hwnd, NULL, FALSE );
break;
}
return (MRESULT) 0;
case WM_USER_DISABLE_CLIENT:
/*
* usually disable before posting a task to the object window
* this message may be sent; disable menu action bar as well
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
pmp->fBusy = TRUE;
WinEnableWindow( pmp->hwndClient, FALSE );
WinEnableWindow( pmp->hwndMenubar, FALSE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, FALSE );
return (MRESULT)0;
case WM_USER_ENABLE_CLIENT:
/*
* usually enable upon receipt of object window ack/nack
* this message may be sent; enable menu actions if text mode
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
pmp->fBusy = FALSE;
WinEnableWindow( pmp->hwndClient, TRUE );
WinEnableWindow( pmp->hwndMenubar, TRUE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, TRUE );
if( pmp->ulMode == MODE_TEXT )
{
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, TRUE );
}
return (MRESULT) 0;
case WM_USER_NEW_MODE:
/*
* The program now has a new file, file type, or printer, or
* printer form, orientation, resolution, etc. The receipt
* and processing of this message works to reset the program:
* Old file, bitmap, or metafile handles are closed, and
* new ones get opened. The titlebar shows the new filename.
* This case works very much like a program reset.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* close processing on current file */
switch( pmp->ulMode )
{
case MODE_BITMAP:
/* destroy previous memory dc, ps, and hbm */
if( pmp->hpsMemory )
{
GpiAssociate( pmp->hpsMemory, (HDC)0 );
GpiDestroyPS( pmp->hpsMemory );
pmp->hpsMemory = (HPS) 0;
}
if( pmp->hdcMemory )
{
DevCloseDC( pmp->hdcMemory );
pmp->hdcMemory = (HDC) 0;
}
if( pmp->hbm )
{
GpiDeleteBitmap( pmp->hbm );
pmp->hbm = (HBITMAP) 0;
}
break;
case MODE_METAFILE:
/* destroy old metafile handle */
if( pmp->hmf )
{
GpiDeleteMetaFile( pmp->hmf );
pmp->hmf = (HMF) 0;
}
break;
case MODE_TEXT:
fclose( pmp->f );
pmp->f = (FILE *) 0;
/* turn off options for text mode */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_SETFONT, FALSE );
break;
}
/* turn off options for all modes */
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, FALSE );
/* copy over current values with the next values */
pmp->ulMode = pmp->ulNextMode;
strcpy( pmp->szFilename, pmp->szNextFilename );
/* enable the print menu option if mode is known and there
is a printer set up. */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PRINT,
(pmp->ulMode != MODE_UNKNOWN && pmp->hpsPrinterInfo ) );
/* update title bar text and show filename in use */
if( *pmp->szFilename )
{
/* parse full-qualified filename to just get filename and extension */
psz = strrchr( pmp->szFilename, '\\' );
if (psz && *psz)
{
++psz;
}
else
{
psz = pmp->szFilename;
}
sprintf( szWork, "%s - %s", pmp->pszTitle, psz );
}
else
{
strcpy( szWork, pmp->pszTitle );
}
WinSetWindowText( pmp->hwndTitlebar, szWork );
/* enable options for all modes */
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, TRUE );
/* process this new mode */
switch( pmp->ulMode )
{
case MODE_BITMAP:
/* load the bitmap into memory so it is compatible with the screen */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
WinPostMsg( pmp->hwndObject, WM_USER_LOAD_BITMAP,
(MPARAM)hwnd, (MPARAM)FLAGS_SCREEN );
break;
case MODE_METAFILE:
/* make object window read metafile */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
WinPostMsg( pmp->hwndObject, WM_USER_LOAD_METAFILE, (MPARAM)hwnd, 0 );
break;
case MODE_TEXT:
/* turn on options for text mode */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_SETFONT, TRUE );
/* reset view matrix that was last in effect for viewing text pages; */
/* this gets lost after viewing a metafile */
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient, 9,
&pmp->matlfDefView, TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
/* disable until text loaded */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
/* tell object window to load the text file */
bOK = WinPostMsg( pmp->hwndObject, WM_USER_LOAD_TEXT, (MPARAM)hwnd, 0 );
pmassert( pmp->hab, bOK );
break;
case MODE_UNKNOWN:
/* size screen to get correct scrollbars */
WinPostMsg( pmp->hwndClient, WM_SIZE, 0, 0 );
break;
}
return (MRESULT) 0;
case WM_VSCROLL:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* Compute some fraction of scroll bar range for a unit of scrolling. */
sStep = pmp->sVScrollRange / 50;
switch( SHORT2FROMMP( mp2 ))
{
case SB_LINEUP:
pmp->sVScrollPos -= sStep;
break;
case SB_PAGEUP:
pmp->sVScrollPos -= pmp->sizelClient.cy;
break;
case SB_LINEDOWN:
pmp->sVScrollPos += sStep;
break;
case SB_PAGEDOWN:
pmp->sVScrollPos += pmp->sizelClient.cy;
break;
case SB_SLIDERPOSITION:
case SB_SLIDERTRACK:
sNewPos = SHORT1FROMMP( mp2 );
pmp->sVScrollPos = sNewPos;
break;
}
/* Don't allow step assignments to exceed limits of zero to range. */
pmp->sVScrollPos = max( (SHORT)0,
min( pmp->sVScrollPos, pmp->sVScrollRange ));
if( pmp->sVScrollPos != SHORT1FROMMR(WinSendMsg( pmp->hwndVScroll,
SBM_QUERYPOS, (MPARAM)0, (MPARAM)0 )))
{
/*
* New scroll bar thumbbutton position is different than current.
* Set a new Y translation value to effect the scroll.
* Current scale setting affects the Y element of the matrix.
*/
pmp->matlfDefView.lM32 = OFFSET_XY_TWIPS + (LONG)(pmp->floatScale *
(float)( pmp->sVScrollPos - pmp->sVScrollRange ));
pmp->matlfDefView.lM32 = (LONG)(pmp->floatScale *
(float)( OFFSET_XY_TWIPS +
pmp->sVScrollPos -
pmp->sVScrollRange ));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient,
9,
&pmp->matlfDefView,
TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
CalibrateVerticalScrollBar( pmp );
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
} /* End of WinProc */
