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 */