[BACK]Return to sem_file.c CVS log [TXT] [DIR] Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / semaph

Annotation of os232sdk/toolkt20/c/samples/semaph/sem_file.c, revision 1.1

1.1     ! root        1: /*==============================================================*\
        !             2:  *  sem_file.c - routines for handling the standard file menu  *
        !             3:  *                 commands                                    *
        !             4:  *      Created 1990, Microsoft, IBM Corp.                      *
        !             5:  *--------------------------------------------------------------*
        !             6:  *                                                             *
        !             7:  *  This module contains the code for the WM_COMMAND messages  *
        !             8:  *  posted by the standard File menu.                          *
        !             9:  *                                                             *
        !            10:  *--------------------------------------------------------------*
        !            11:  *                                                             *
        !            12:  *  This source file contains the following functions:         *
        !            13:  *                                                             *
        !            14:  *          FileNew(mp2);                                      *
        !            15:  *          FileOpen(mp2);                                     *
        !            16:  *          FileSave(mp2);                                     *
        !            17:  *          FileSaveAs(mp2);                                   *
        !            18:  *          FilePrint(mp2);                                    *
        !            19:  *          FilePageSetup(mp2);                                *
        !            20:  *          FilePrintSetup(mp2);                               *
        !            21:  *                                                             *
        !            22: \*==============================================================*/
        !            23: 
        !            24: /*--------------------------------------------------------------*\
        !            25:  *  Include files, macros, defined constants, and externs      *
        !            26: \*--------------------------------------------------------------*/
        !            27: 
        !            28: #define  LINT_ARGS
        !            29: 
        !            30: #define  INCL_WIN
        !            31: #define  INCL_GPI
        !            32: #define  INCL_DOSPROCESS
        !            33: #include <os2.h>
        !            34: #include "sem_main.h"
        !            35: #include "sem_xtrn.h"
        !            36: 
        !            37: /*--------------------------------------------------------------*\
        !            38:  *  Global variables                                           *
        !            39: \*--------------------------------------------------------------*/
        !            40: 
        !            41: /*--------------------------------------------------------------*\
        !            42:  *  Entry point declarations                                   *
        !            43: \*--------------------------------------------------------------*/
        !            44: 
        !            45: 
        !            46: #ifdef LATER
        !            47: 
        !            48: /****************************************************************\
        !            49:  *  New file routine                                           *
        !            50:  *--------------------------------------------------------------*
        !            51:  *                                                             *
        !            52:  *  Name:   FileNew(mp2)                                       *
        !            53:  *                                                             *
        !            54:  *  Purpose: Processes the File menu's New item                 *
        !            55:  *                                                             *
        !            56:  *  Usage:  called whenever New from the File menu is selected *
        !            57:  *                                                             *
        !            58:  *  Method:                                                    *
        !            59:  *                                                             *
        !            60:  *                                                             *
        !            61:  *  Returns:                                                   *
        !            62:  *                                                             *
        !            63: \****************************************************************/
        !            64: VOID FileNew(mp2)
        !            65: MPARAM mp2;        /* second parameter of WM_COMMAND message */
        !            66: {
        !            67: 
        !            68:     /*--------------------------------------------------------------*\
        !            69:      * Enter routines for creating a new file and window           *
        !            70:     \*--------------------------------------------------------------*/
        !            71: 
        !            72:     /* This routine currently doesn't use the mp2 parameter but       *\
        !            73:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !            74:     \* warning at compile time.                                      */
        !            75:     mp2;
        !            76: 
        !            77: }   /* FileNew() */
        !            78: 
        !            79: 
        !            80: 
        !            81: /****************************************************************\
        !            82:  *  Open file routine                                          *
        !            83:  *--------------------------------------------------------------*
        !            84:  *                                                             *
        !            85:  *  Name:   FileOpen(mp2)                                      *
        !            86:  *                                                             *
        !            87:  *  Purpose: Processes the File menu's Open item.               *
        !            88:  *                                                             *
        !            89:  *  Usage:  called whenever Open from the File menu is selected        *
        !            90:  *                                                             *
        !            91:  *  Method:  calls the standard file open dialog to get the    *
        !            92:  *         file name.  The file name is passed onto DosOpen    *
        !            93:  *         which returns the handle to the file.  The file     *
        !            94:  *         input procedure is called and then the file handle  *
        !            95:  *         is closed.                                          *
        !            96:  *                                                             *
        !            97:  *  Returns:                                                   *
        !            98:  *                                                             *
        !            99: \****************************************************************/
        !           100: VOID FileOpen(MPARAM mp2)
        !           101: {
        !           102:     FILEDLG fdg;
        !           103:     HFILE hfIn;
        !           104:     USHORT usAction;
        !           105: 
        !           106:     fdg.cbSize = sizeof(FILEDLG);
        !           107:     fdg.pszTitle = "Open...";
        !           108:     fdg.pszButton = "Open";
        !           109:     fdg.henum = NULL;
        !           110:     fdg.lUser = 0L;
        !           111:     fdg.fl = FDS_HELPBUTTON | FDS_CENTER;
        !           112:     fdg.pfnDlgProc = NULL;
        !           113:     fdg.lReturn = 0L;
        !           114:     fdg.ffb = 0;
        !           115:     fdg.hmod = NULL;
        !           116:     fdg.idDlg = NULL;
        !           117:     fdg.iTopFile = 0;
        !           118:     fdg.x = 0;
        !           119:     fdg.x = 0;
        !           120: 
        !           121:     if(!WinLoadString(hab, NULL, IDS_FILEOPENEXT, MAX_FILTER, fdg.szFilter))  {
        !           122:        WinMessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, TRUE);
        !           123:        return;
        !           124:     }
        !           125: 
        !           126:     fdg.szPath[0] = 0;         /* use current directory */
        !           127:     fdg.szFile[0] = 0;         /* specify no default file */
        !           128:     fdg.szFullFile[CCHMAXPATH];
        !           129: 
        !           130:     /* get the file */
        !           131:     if(!KitFileDlg(hwndMain, (PFILEDLG)&fdg))
        !           132:        return;
        !           133: 
        !           134: 
        !           135:     /*--------------------------------------------------------------*\
        !           136:      * Upon sucessful return of a file, open it for reading        *
        !           137:     \*--------------------------------------------------------------*/
        !           138: 
        !           139:     if(fdg.lReturn == ID_OK)  {
        !           140:        if( DosOpen(fdg.szFullFile,
        !           141:                    &hfIn,
        !           142:                    (PUSHORT)&usAction,
        !           143:                    0L,
        !           144:                    FILE_NORMAL,
        !           145:                    FILE_OPEN,
        !           146:                    OPEN_ACCESS_READ | OPEN_SHARE_DENYNONE,
        !           147:                    0L))  {
        !           148:            MessageBox(hwndOwner, IDMSG_CANNOTOPENINPUTFILE);
        !           149:            return;
        !           150:        }
        !           151: 
        !           152:        /*--------------------------------------------------------------*\
        !           153:         *  Place routine for reading the file here                     *
        !           154:        \*--------------------------------------------------------------*/
        !           155: 
        !           156: 
        !           157:        DosClose(hfIn);
        !           158:     }
        !           159: 
        !           160:     /* This routine currently doesn't use the mp2 parameter but       *\
        !           161:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !           162:     \* warning at compile time.                                      */
        !           163:     mp2;
        !           164: 
        !           165: }   /* FileOpen() */
        !           166: 
        !           167: 
        !           168: /****************************************************************\
        !           169:  *  Print file routine                                         *
        !           170:  *--------------------------------------------------------------*
        !           171:  *                                                             *
        !           172:  *  Name:   FilePrint(mp2)                                     *
        !           173:  *                                                             *
        !           174:  *  Purpose: Processes the File menu's Print item.              *
        !           175:  *                                                             *
        !           176:  *  Usage:  called whenever Print from the File menu is        *
        !           177:  *         selected                                            *
        !           178:  *                                                             *
        !           179:  *  Method:  Routine calls the application's print routine      *
        !           180:  *                                                             *
        !           181:  *  Returns:                                                   *
        !           182:  *                                                             *
        !           183: \****************************************************************/
        !           184: VOID FilePrint(MPARAM mp2)
        !           185: {
        !           186: 
        !           187:     Print(hwndMain);
        !           188: 
        !           189:     /* This routine currently doesn't use the mp2 parameter but       *\
        !           190:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !           191:     \* warning at compile time.                                      */
        !           192:     mp2;
        !           193: 
        !           194: }   /* FilePrint() */
        !           195: 
        !           196: /****************************************************************\
        !           197:  *  Page setup routine                                         *
        !           198:  *--------------------------------------------------------------*
        !           199:  *                                                             *
        !           200:  *  Name:   FilePageSetup(mp2)                                 *
        !           201:  *                                                             *
        !           202:  *  Purpose: Processes the File menu's Page Setup item.         *
        !           203:  *                                                             *
        !           204:  *  Usage:  called whenever Page Setup from the File menu is   *
        !           205:  *         selected                                            *
        !           206:  *                                                             *
        !           207:  *  Method:  Routine calls the application's page setup routine *
        !           208:  *                                                             *
        !           209:  *  Returns:                                                   *
        !           210:  *                                                             *
        !           211: \****************************************************************/
        !           212: VOID FilePageSetup(MPARAM mp2)
        !           213: {
        !           214: 
        !           215:     PageSetup(hwndMain);
        !           216: 
        !           217:     /* This routine currently doesn't use the mp2 parameter but       *\
        !           218:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !           219:     \* warning at compile time.                                      */
        !           220:     mp2;
        !           221: 
        !           222: }   /* FilePageSetup() */
        !           223: 
        !           224: /****************************************************************\
        !           225:  *  Print Setup routine                                        *
        !           226:  *--------------------------------------------------------------*
        !           227:  *                                                             *
        !           228:  *  Name:   FilePageSetup(mp2)                                 *
        !           229:  *                                                             *
        !           230:  *  Purpose: Processes the File menu's Print Setup item.        *
        !           231:  *                                                             *
        !           232:  *  Usage:  called whenever Print Setup from the File menu is  *
        !           233:  *         selected                                            *
        !           234:  *                                                             *
        !           235:  *  Method:  Routine calls the application's Print Setup routine*
        !           236:  *                                                             *
        !           237:  *  Returns:                                                   *
        !           238:  *                                                             *
        !           239: \****************************************************************/
        !           240: VOID FilePrintSetup(MPARAM mp2)
        !           241: {
        !           242: 
        !           243:     PrintSetup(hwndMain);
        !           244: 
        !           245:     /* This routine currently doesn't use the mp2 parameter but       *\
        !           246:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !           247:     \* warning at compile time.                                      */
        !           248:     mp2;
        !           249: 
        !           250: }   /* FilePrintSetup() */
        !           251: 
        !           252: #endif
        !           253: 
        !           254: /****************************************************************\
        !           255:  *  Exit routine                                               *
        !           256:  *--------------------------------------------------------------*
        !           257:  *                                                             *
        !           258:  *  Name:   FileExit(mp2)                                      *
        !           259:  *                                                             *
        !           260:  *  Purpose: Processes the File menu's Exit item.               *
        !           261:  *                                                             *
        !           262:  *  Usage:  called whenever Exit from the file menu is         *
        !           263:  *         selected                                            *
        !           264:  *                                                             *
        !           265:  *  Method:  Routine posts a WM_CLOSE message to the main      *
        !           266:  *          application window.                                *
        !           267:  *                                                             *
        !           268:  *  Returns:                                                   *
        !           269:  *                                                             *
        !           270: \****************************************************************/
        !           271: VOID FileExit(MPARAM mp2)
        !           272: {
        !           273: 
        !           274:     WinPostMsg(hwndMain, WM_CLOSE, (MPARAM)NULL, (MPARAM)NULL);
        !           275: 
        !           276:     /* This routine currently doesn't use the mp2 parameter but       *\
        !           277:      * it is referenced here to prevent an 'Unreferenced Parameter'  *
        !           278:     \* warning at compile time.                                      */
        !           279:     mp2;
        !           280: 
        !           281: }   /* FileExit() */
unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.