home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / BKUPINI.ZIP / INIPGMS.SAV < prev    next >
Text File  |  1990-05-20  |  45KB  |  1,012 lines
  1. #define EXTERN
  2. #include "INIPGMS.h"
  3.  
  4. /************************************************************************/
  5. /*                                                                      */
  6. /* Presentation Manager Program Main Body                               */
  7. /*                                                                      */
  8. /* The following routine is the Presentation Manager program Main Body. */
  9. /* The Main Body of a PM program is concerned with associating the      */
  10. /* application with the Presentation Manager system, creating its       */
  11. /* message queue, registering and displaying its main window, servicing */
  12. /* its message queue during the time that the application is active,    */
  13. /* and disassociating the application from PM when the user is finished */
  14. /* with the application. The remaining parts of this source module that */
  15. /* are concerned with the Presentation Manager are the application's    */
  16. /* window procedures (main window procedure, child window procedures,   */
  17. /* and dialog window procedures) that process the messages associated   */
  18. /* with the application's various windows.                              */
  19. /*                                                                      */
  20. /************************************************************************/
  21.  
  22. SHORT cdecl main(argc, argv)
  23. int argc;
  24. char *argv[];
  25. {
  26.  QMSG qmsg;  // MSG structure to store your messages                 
  27.  PID  pid;   // Process identifier for adding name to switch list
  28.  TID  tid;   // Thread identifier 
  29.  
  30.  // The WinInitialize routine initializes the Presentation Manager
  31.  // facilities for use by this application and returns a handle to the
  32.  // anchor block assigned to the application by PM.
  33.  
  34.  if((hAB = WinInitialize(NULL)) == NULL)
  35.     return(FALSE);
  36.   
  37.  // The WinCreateMsgQueue call creates a message queue for this application.
  38.  
  39.  if((hMQ = WinCreateMsgQueue(hAB, 0)) == NULL)
  40.     return(FALSE);
  41.  
  42.  // The following function registers the classes of all application windows.
  43.  if(!RegisterClass())
  44.     return(FALSE);
  45.  
  46.  // The CreateWindow function creates a frame window for this application's
  47.  // top window, and set the window's size and location as appropriate.
  48.  
  49.  hWndFrame = CreateWindow((HWND)HWND_DESKTOP,
  50.           FCF_TITLEBAR     |
  51.           FCF_SYSMENU      |
  52.           FCF_MINBUTTON    |
  53.           FCF_MAXBUTTON    |
  54.           FCF_SIZEBORDER   |
  55.           FCF_MENU         |
  56.           FCF_SHELLPOSITION,
  57.           szAppName,
  58.           "OS2 INI File Management",
  59.           ID_INIPGMS,
  60.           0, 0,
  61.           0, 0,
  62.           &hWndClient,
  63.           0L, SWP_SHOW);
  64.  
  65.  if(hWndFrame == NULL)
  66.     return(FALSE);
  67.  
  68.  // The following in-line routine fills out the application's switch control
  69.  // structure with the appropriate information to add the application's name
  70.  // to the OS/2 Task Manager List, a list of the jobs currently running on
  71.  // the computer.
  72.  
  73.  WinQueryWindowProcess(hWndFrame, &pid, &tid);
  74.  pSwctl.hwnd = hWndFrame;                         // Frame window handle   
  75.  pSwctl.idProcess = pid;                          // Process identifier    
  76.  pSwctl.uchVisibility = SWL_VISIBLE;              // visibility            
  77.  pSwctl.fbJump = SWL_JUMPABLE;                    // Jump indicator
  78.  strcpy(pSwctl.szSwtitle, "OS2 INI File Management");   // Frame window title
  79.  hSwitch = WinAddSwitchEntry(&pSwctl);
  80.    
  81.  // The following is the message loop for the application.
  82.  
  83.  while(WinGetMsg(hAB, (PQMSG)&qmsg, NULL, 0, 0))
  84.        WinDispatchMsg(hAB,(PQMSG)&qmsg);
  85.  
  86.  // Perform clean up before exiting application.
  87.  // The following routine destroys the application's frame window (which
  88.  // also destroys its child windows), destroys its message queue, and
  89.  // disassociates the application from the Presentation Manager system.
  90.  
  91.  WinDestroyWindow(hWndFrame); // Destroy the frame window
  92.  WinDestroyMsgQueue(hMQ);     // Destroy this application's message clue
  93.  WinTerminate(hAB);           // Terminate this application's use of the
  94.                               // Presentation Manager resources
  95. } // end of main
  96.  
  97.  
  98. // The following Dialog box calls are generated for the dialog boxes that
  99. // have been selected as "Client Area" dialog boxes.  To use these calls,
  100. // simply copy them to the appropriate location in the application.
  101.  
  102. #if 0
  103.  
  104.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)DSPLGRPSMsgProc, 
  105.              NULL, IDLG_DSPLGRPS, NULL);
  106.  
  107.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)SAVEPGMSMsgProc, 
  108.              NULL, IDLG_SAVEPGMS, NULL);
  109.  
  110.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)BKUPRUNMsgProc, 
  111.              NULL, IDLG_BKUPRUN, NULL);
  112.  
  113. #endif
  114.  
  115. /************************************************************************/
  116. /*                                                                      */   
  117. /* Main Window Procedure                                                */
  118. /*                                                                      */
  119. /* This procedure provides service routines for the general PM events   */
  120. /* (messages) that PM sends to the window, as well as the user          */
  121. /* initiated events (messages) that are generated when the user selects */
  122. /* the action bar and pulldown menu controls or the corresponding       */
  123. /* keyboard accelerators.                                               */
  124. /*                                                                      */
  125. /* The SWITCH statement shown below distributes the window messages to  */
  126. /* the respective message service routines, which are set apart by the  */
  127. /* CASE statements. The window procedures must provide an appropriate   */
  128. /* service routine for its end user initiated messages, as well as the  */
  129. /* general PM messages (like the WM_CLOSE message). If a message is     */
  130. /* sent to this procedure for which there is no programmed CASE clause  */
  131. /* (i.e., no service routine), the message is defaulted to the          */
  132. /* WinDefWindowProc function, where it is disposed of by PM.            */
  133. /*                                                                      */
  134. /************************************************************************/
  135.  
  136. MRESULT EXPENTRY WndProc(hWnd, message, mp1, mp2)
  137. HWND hWnd;
  138. USHORT message;
  139. MPARAM mp1;
  140. MPARAM mp2;
  141. {                            // Beginning of message processor
  142.    HPS hPS;                  // Handle for the Presentation Space
  143.    RECTL rClient;            // Handle to rectangle formed by client area
  144.    USHORT rc;                // common return code value
  145.  
  146.    switch(message)
  147.      {
  148.       case WM_COMMAND:
  149.         // The PM messages for action bar and pulldown menu items are
  150.         // processed in this routine.
  151.   
  152.            switch(SHORT1FROMMP(mp1))
  153.             {
  154.              case IDM_FILE_OPENINIFILE:
  155.                   // Place User Code to respond to the             
  156.                   // Menu Item Named "~Open .INI file..." here.
  157.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)OPENINIMsgProc,
  158.                                  NULL, IDLG_OPENINI, NULL);
  159.                   break;
  160.  
  161.              case IDM_FILE_EXTRACTFROMSYSTEM:
  162.                   // Place User Code to respond to the             
  163.                   // Menu Item Named "~Extract from system..." here.
  164.                   /* Extract Function Goes Here */
  165.                   hiniSource = HINI_USERPROFILE ;
  166.                   hiniTarget = hiniUser ;
  167.                   WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)DSPLGRPSMsgProc, 
  168.                             NULL, IDLG_DSPLGRPS, NULL) ;
  169.                   break;
  170.  
  171.              case IDM_FILE_RELOADTOSYSTEM:
  172.                   // Place User Code to respond to the             
  173.                   // Menu Item Named "~Reload to System..." here.
  174.                   /*  Reload goes here  */
  175.                   hiniSource = hiniUser;
  176.                   hiniTarget = HINI_USERPROFILE;
  177.                   WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)DSPLGRPSMsgProc, 
  178.                             NULL, IDLG_DSPLGRPS, NULL) ;
  179.                   break;
  180.  
  181.              case IDM_FILE_BACKUPSYSTEMINIS:
  182.                   // Place User Code to respond to the             
  183.                   // Menu Item Named "~Backup system INIs..." here.
  184.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)BKSYSINIMsgProc,
  185.                                  NULL, IDLG_BKSYSINI, NULL);
  186.                   break;
  187.  
  188.              case IDM_FILE_EXIT:
  189.                   // Place User Code to respond to the             
  190.                   // Menu Item Named "E~xit" here.
  191.                   /*  Exit Code Goes Here */
  192.                   WinPostMsg(hWnd, WM_CLOSE, 0L, 0L);
  193.                   break;
  194.  
  195.  
  196.              default:
  197.                   break; // End of default case for switch(mp1)
  198.             }
  199.            break;        // End of WM_COMMAND
  200.    
  201.       case WM_CREATE:
  202.            // The WM_CREATE message is sent to a window when an application
  203.            // requests that the window be created.  The window procedure for
  204.            // the new window receives this message after the window is
  205.            // created, but before the window becomes visible.
  206.            //
  207.  
  208.            /*   Allocate Memory for Data Operations          */
  209.  
  210.            if( !DosAllocSeg( WORKAREASIZE,
  211.                              (PSEL)&SELECTOROF( pvoidWorkAreaOrigin ),
  212.                              SEG_NONSHARED))
  213.                OFFSETOF( pvoidWorkAreaOrigin ) = 0;
  214.            pvoidWorkArea  = pvoidWorkAreaOrigin ;
  215.            ulWorkAreaSize = WORKAREASIZE ;
  216.            hiniUser       = NULL ;
  217.            szUserIni[0]   = '\0' ;
  218.  
  219.            break;       // End of WM_CREATE
  220.  
  221.       case WM_MOUSEMOVE:
  222.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  223.            break;
  224.  
  225.       case WM_SIZE:     // code for sizing client area                     
  226.            break;       // End of WM_SIZE 
  227.     
  228.       case WM_PAINT:    // code for the window's client area
  229.            // Obtain a handle to a cache presentation space
  230.            hPS = WinBeginPaint(hWnd, NULL, NULL);
  231.  
  232.            // Determine the size of the client area
  233.            WinQueryWindowRect(hWnd, &rClient);
  234.  
  235.            // Fill the background with the default background color
  236.            WinFillRect(hPS, &rClient, CLR_BACKGROUND);
  237.  
  238.            // return presentation space to state before WinBeginPaint
  239.            WinEndPaint(hPS);
  240.            break;       // End of WM_PAINT
  241.  
  242.  
  243.       case WM_CLOSE:  // close the window
  244.            if(hWnd != hWndClient)
  245.              break;
  246.            if( hiniUser ) PrfCloseProfile( hiniUser ) ;
  247.            DosFreeSeg( SELECTOROF( pvoidWorkAreaOrigin ) );
  248.            WinPostMsg(hWnd, WM_QUIT, 0L, 0L);
  249.            break;       // End of WM_CLOSE
  250.      
  251.       default:
  252.            // For any message for which you don't specifically provide a
  253.            // service routine, you should return the message to PM using
  254.            // the WinDefWindowProc function.
  255.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  256.            break;  // End of default 
  257.      } 
  258.    return(0L);
  259. } // End of WndProc
  260.  
  261. /************************************************************************/
  262. /*                                                                      */
  263. /* Dialog Window Procedure                                              */
  264. /*                                                                      */
  265. /* This procedure is associated with the dialog box that is included in */
  266. /* the function name of the procedure. It provides the service routines */
  267. /* for the events (messages) that occur because the end user operates   */
  268. /* one of the dialog box's buttons, entry fields, or controls.          */
  269. /*                                                                      */
  270. /* The SWITCH statement in the function distributes the dialog box      */
  271. /* messages to the respective service routines, which are set apart by  */
  272. /* the CASE clauses. Like any other PM window, the Dialog Window        */
  273. /* procedures must provide an appropriate service routine for their end */
  274. /* user initiated messages as well as for the general PM messages (like */
  275. /* the WM_CLOSE message). If a message is sent to this procedure for    */
  276. /* which there is no programmed CASE condition (no service routine),    */
  277. /* the message is defaulted to the WinDefDlgProc function, where it is  */
  278. /* disposed of by PM.                                                   */
  279. /*                                                                      */
  280. /************************************************************************/
  281.  
  282. MRESULT EXPENTRY DSPLGRPSMsgProc(hWndDlg, message, mp1, mp2)
  283. HWND hWndDlg;
  284. USHORT message;
  285. MPARAM mp1;
  286. MPARAM mp2;
  287. { 
  288.  SHORT i;
  289.           
  290.  BOOL           fSuccess ;
  291.  ULONG          ulBufferMax ;
  292.  USHORT         ulNumPgmEnts, ulPgmEntCtr, sSelect ;
  293.           
  294.  switch(message)
  295.    {
  296.     case WM_INITDLG:
  297.  
  298.          WinSendDlgItemMsg (hWndDlg, DsplGrps_GrpList,
  299.                             LM_DELETEALL, NULL, NULL) ;
  300.  
  301.          ulBufferMax = ulWorkAreaSize ;
  302.          if( !hiniSource )
  303.              {
  304.              if( !WinDlgBox(HWND_DESKTOP, hWndDlg,
  305.                            (PFNWP)OPENINIMsgProc,
  306.                            NULL, IDLG_OPENINI, NULL) )
  307.                  {
  308.                  WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL),0L);
  309.                  break ;
  310.                  }
  311.              hiniSource = hiniUser ;
  312.              }
  313.          fSuccess = PrfQueryProfileData( hiniSource,
  314.                                          "PM_ProgramList000", "ProgramEntry",
  315.                                          pvoidWorkArea,
  316.                                          &ulBufferMax ) ;         
  317.          PgmEntPtr = PgmEntPtrSel = (PROGRAMENTRY *)pvoidWorkArea ;
  318.          ulPgmEntSize             = ulBufferMax +1 ;
  319.          (PBYTE)PgmEntPtrEnd      = (PBYTE)pvoidWorkArea + ulPgmEntSize ;
  320.          (PBYTE)pvoidWorkArea     = (PBYTE)PgmEntPtrEnd +1 ;
  321.          ulWorkAreaSize          -= ulPgmEntSize+1 ;
  322.          for( ulNumPgmEnts = ulBufferMax/sizeof(PROGRAMENTRY),
  323.                  ulPgmEntCtr  = 0 ;
  324.               ulPgmEntCtr < ulNumPgmEnts ;
  325.               ulPgmEntCtr++, PgmEntPtrSel++ )
  326.               {
  327.               WinSendDlgItemMsg(hWndDlg, DsplGrps_GrpList, LM_INSERTITEM,
  328.                                 MPFROM2SHORT (LIT_SORTASCENDING, 0),
  329.                                 MPFROMP (PgmEntPtrSel->szTitle)) ;
  330.               }
  331.          *(PCHAR)pvoidWorkArea = '\0' ; 
  332.  
  333.          break; // End of WM_INITDLG
  334.                            
  335.     case WM_CONTROL:
  336.          switch(SHORT1FROMMP(mp1))
  337.            {
  338.             case DsplGrps_GrpList: // List box
  339.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  340.                                                 DsplGrps_GrpList,
  341.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  342.                  WinSendDlgItemMsg(hWndDlg, DsplGrps_GrpList,
  343.                                    LM_QUERYITEMTEXT,
  344.                                    MPFROM2SHORT(sSelect, ulWorkAreaSize),
  345.                                    MPFROMP(pvoidWorkArea)) ;
  346.                  if( SHORT2FROMMP( mp1 ) == LN_ENTER )
  347.                      WinPostMsg(hWndDlg, WM_COMMAND,
  348.                                 MPFROM2SHORT(DID_OK,0), 0L);
  349.                  break;
  350.  
  351.            }
  352.          break; // End of WM_CONTROL
  353.    
  354.     case WM_COMMAND:
  355.          switch(SHORT1FROMMP(mp1))
  356.            {
  357.             case DID_OK:
  358.                  if( !strlen( (PSZ)pvoidWorkArea ) ) break ;
  359.                  for( PgmEntPtrSel = PgmEntPtr ;
  360.                       strcmp((PSZ)pvoidWorkArea, PgmEntPtrSel->szTitle) ;
  361.                       PgmEntPtrSel++ ) ;
  362.                  WinDlgBox(HWND_DESKTOP, hWndDlg, (PFNWP)SAVEPGMSMsgProc, 
  363.                            NULL, IDLG_SAVEPGMS, NULL);
  364.                  *(PCHAR)pvoidWorkArea = '\0' ; 
  365.                  break ;
  366.  
  367.                  WinDismissDlg(hWndDlg, TRUE);
  368.                  break;
  369.  
  370.             case DID_CANCEL:
  371.                  // Ignore data values entered into the dialog controls
  372.                  // and dismiss the dialog window
  373.                  WinDismissDlg(hWndDlg, FALSE);
  374.                  break;
  375.            }
  376.          break; // End of WM_COMMAND
  377.                                
  378.     case WM_CLOSE:
  379.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  380.          break; // End of WM_CLOSE 
  381.            
  382.     default:
  383.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  384.          break;
  385.    }
  386.  return FALSE;
  387. } /* End of DSPLGRPSMsgProc */
  388.  
  389.  
  390. /************************************************************************/
  391. /*                                                                      */
  392. /* Dialog Window Procedure                                              */
  393. /*                                                                      */
  394. /* This procedure is associated with the dialog box that is included in */
  395. /* the function name of the procedure. It provides the service routines */
  396. /* for the events (messages) that occur because the end user operates   */
  397. /* one of the dialog box's buttons, entry fields, or controls.          */
  398. /*                                                                      */
  399. /* The SWITCH statement in the function distributes the dialog box      */
  400. /* messages to the respective service routines, which are set apart by  */
  401. /* the CASE clauses. Like any other PM window, the Dialog Window        */
  402. /* procedures must provide an appropriate service routine for their end */
  403. /* user initiated messages as well as for the general PM messages (like */
  404. /* the WM_CLOSE message). If a message is sent to this procedure for    */
  405. /* which there is no programmed CASE condition (no service routine),    */
  406. /* the message is defaulted to the WinDefDlgProc function, where it is  */
  407. /* disposed of by PM.                                                   */
  408. /*                                                                      */
  409. /************************************************************************/
  410.  
  411. MRESULT EXPENTRY SAVEPGMSMsgProc(hWndDlg, message, mp1, mp2)
  412. HWND hWndDlg;
  413. USHORT message;
  414. MPARAM mp1;
  415. MPARAM mp2;
  416. { 
  417.  SHORT i;
  418.           
  419.  HPROGRAM   hprogUserGrp ;
  420.  ULONG      cchBufferMax, ulCount, ulWork, ulGrpKeyLen,
  421.             ulKeyDataSize, ulDetailsLen ;
  422.  PVOID      pvoidKeyData ;
  423.  PSZ        pszKeyName ;
  424.  USHORT     sSelect ;
  425.           
  426.  switch(message)
  427.    {
  428.     case WM_INITDLG:
  429.  
  430.          WinSendDlgItemMsg (hWndDlg, SavePgms_Titles,
  431.                             LM_DELETEALL, NULL, NULL) ;
  432.          WinSendDlgItemMsg(hWndDlg, SavePgms_GrpName, EM_SETTEXTLIMIT,
  433.                            MPFROM2SHORT (80, 0), NULL) ;
  434.          WinSendDlgItemMsg(hWndDlg, SavePgms_Txt1, EM_SETTEXTLIMIT,
  435.                            MPFROM2SHORT (80, 0), NULL) ;
  436.          WinSetDlgItemText (hWndDlg, SavePgms_GrpName, PgmEntPtrSel->szTitle) ;
  437.          if( hiniSource == HINI_USERPROFILE )
  438.              WinSetDlgItemText (hWndDlg, SavePgms_Txt1,
  439.                                 "Select Installed Programs(s) to Save") ;
  440.              else
  441.              WinSetDlgItemText (hWndDlg, SavePgms_Txt1,
  442.                                 "Select Installed Programs(s) to Restore") ;
  443.          pTitles      = (PPROGTITLE)pvoidWorkArea ;
  444.          ulTitlesSize = PrfQueryProgramTitles( hiniSource,
  445.                                                PgmEntPtrSel->hprog,
  446.                                                pTitles,
  447.                                                ulWorkAreaSize,
  448.                                                &ulCount ) ;
  449.          (PBYTE)pTitlesEnd = (PBYTE)pTitles + ulTitlesSize ;
  450.          for( ulWork  = 0 ; ulWork < ulCount ; ulWork++, pTitles++ )
  451.               {
  452.               WinSendDlgItemMsg(hWndDlg, SavePgms_Titles, LM_INSERTITEM,
  453.                                 MPFROM2SHORT (LIT_END, 0),
  454.                                 MPFROMP (pTitles->pszTitle)) ;
  455.               } 
  456.          pTitles              = (PPROGTITLE)pvoidWorkArea ;
  457.          (PBYTE)pvoidWorkArea = (PBYTE)pTitlesEnd + 1 ;
  458.          ulWorkAreaSize      -= ulTitlesSize + 1 ; 
  459.          
  460.          break; // End of WM_INITDLG
  461.                            
  462.     case WM_CONTROL:
  463.          switch(SHORT1FROMMP(mp1))
  464.            {
  465.             case SavePgms_Titles: // List box
  466.                  {
  467.                  }
  468.                  break;
  469.  
  470.            }
  471.          break; // End of WM_CONTROL
  472.    
  473.     case WM_COMMAND:
  474.          switch(SHORT1FROMMP(mp1))
  475.            {
  476.             case DID_OK:
  477.                  sSelect = (USHORT)WinSendDlgItemMsg(hWndDlg,
  478.                                         SavePgms_Titles,
  479.                                         LM_QUERYSELECTION,
  480.                                         MPFROMSHORT(LIT_FIRST),
  481.                                         0L ) ;
  482.                  if( sSelect == LIT_NONE ) break ;
  483.                  if( !hiniTarget )
  484.                      {
  485.                      if( !WinDlgBox(HWND_DESKTOP, hWndDlg,
  486.                                     (PFNWP)OPENINIMsgProc,
  487.                                     NULL, IDLG_OPENINI, NULL) ) break ;
  488.                      hiniTarget = hiniUser ;
  489.                      }
  490.                  hprogUserGrp = PrfCreateGroup( hiniTarget,
  491.                                                 PgmEntPtrSel->szTitle,
  492.                                                 SHE_VISIBLE ) ;
  493.                  ulGrpKeyLen  = ulWorkAreaSize ;
  494.                  if( PrfQueryProfileData( hiniSource,
  495.                                           PgmEntPtrSel->szTitle,
  496.                                           NULL,
  497.                                           pvoidWorkArea,
  498.                                           &ulGrpKeyLen )  )
  499.                       {
  500.                       (PBYTE)pvoidKeyData = (PBYTE)pvoidWorkArea + 
  501.                                             ulGrpKeyLen + 1 ;
  502.                       for( pszKeyName = (PSZ)pvoidWorkArea;
  503.                            strlen(pszKeyName) ;
  504.                            pszKeyName += strlen(pszKeyName)+1 )
  505.                            {
  506.                            ulKeyDataSize       = ulWorkAreaSize -
  507.                                                  (ulGrpKeyLen + 1) ;
  508.                            PrfQueryProfileData( hiniSource,
  509.                                                 PgmEntPtrSel->szTitle,
  510.                                                 pszKeyName,
  511.                                                 pvoidKeyData,
  512.                                                 &ulKeyDataSize ) ;
  513.                            PrfWriteProfileData( hiniTarget,
  514.                                                 PgmEntPtrSel->szTitle,
  515.                                                 pszKeyName,
  516.                                                 pvoidKeyData,
  517.                                                 ulKeyDataSize ) ;
  518.                            }
  519.                       }
  520.                  for( sSelect = (USHORT)WinSendDlgItemMsg(hWndDlg,
  521.                                         SavePgms_Titles,
  522.                                         LM_QUERYSELECTION,
  523.                                         MPFROMSHORT(LIT_FIRST),
  524.                                         0L ) ;
  525.                       sSelect != LIT_NONE;
  526.                       sSelect = (USHORT)WinSendDlgItemMsg(hWndDlg,
  527.                                         SavePgms_Titles,
  528.                                         LM_QUERYSELECTION,
  529.                                         MPFROMSHORT(sSelect),
  530.                                         0L ) )
  531.                       {
  532.                       ulDetailsLen = PrfQueryDefinition( hiniSource,
  533.                                         (pTitles+sSelect)->hprog,
  534.                                         (PPROGDETAILS)pvoidWorkArea,
  535.                                         ulWorkAreaSize ) ;
  536.                       PrfAddProgram( hiniTarget, (PPROGDETAILS)pvoidWorkArea,
  537.                                         hprogUserGrp ) ;
  538.                       }
  539.                       
  540.                  WinDismissDlg(hWndDlg, TRUE);
  541.                  break;
  542.  
  543.             case DID_CANCEL:
  544.                  // Ignore data values entered into the dialog controls
  545.                  // and dismiss the dialog window
  546.                  WinDismissDlg(hWndDlg, FALSE);
  547.                  break;
  548.            }
  549.          break; // End of WM_COMMAND
  550.                                
  551.     case WM_CLOSE:
  552.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  553.          break; // End of WM_CLOSE 
  554.            
  555.     default:
  556.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  557.          break;
  558.    }
  559.  return FALSE;
  560. } /* End of SAVEPGMSMsgProc */
  561.  
  562.  
  563. /************************************************************************/
  564. /*                                                                      */
  565. /* Dialog Window Procedure                                              */
  566. /*                                                                      */
  567. /* This procedure is associated with the dialog box that is included in */
  568. /* the function name of the procedure. It provides the service routines */
  569. /* for the events (messages) that occur because the end user operates   */
  570. /* one of the dialog box's buttons, entry fields, or controls.          */
  571. /*                                                                      */
  572. /* The SWITCH statement in the function distributes the dialog box      */
  573. /* messages to the respective service routines, which are set apart by  */
  574. /* the CASE clauses. Like any other PM window, the Dialog Window        */
  575. /* procedures must provide an appropriate service routine for their end */
  576. /* user initiated messages as well as for the general PM messages (like */
  577. /* the WM_CLOSE message). If a message is sent to this procedure for    */
  578. /* which there is no programmed CASE condition (no service routine),    */
  579. /* the message is defaulted to the WinDefDlgProc function, where it is  */
  580. /* disposed of by PM.                                                   */
  581. /*                                                                      */
  582. /************************************************************************/
  583.  
  584. MRESULT EXPENTRY OPENINIMsgProc(hWndDlg, message, mp1, mp2)
  585. HWND hWndDlg;
  586. USHORT message;
  587. MPARAM mp1;
  588. MPARAM mp2;
  589. { 
  590.  SHORT i;
  591.           
  592.  USHORT sSelect, CurDisk ;
  593.  ULONG  DriveMap ;
  594.  UCHAR  buffer[80] ;
  595.  PSZ    IniMask = "*.ini" ;
  596.           
  597.  switch(message)
  598.    {
  599.     case WM_INITDLG:
  600.          WinSendDlgItemMsg(hWndDlg, OpenIni_CWD, EM_SETTEXTLIMIT,
  601.                            MPFROM2SHORT (80, 0), NULL) ;
  602.          WinSendDlgItemMsg(hWndDlg, OpenIni_IniName, EM_SETTEXTLIMIT,
  603.                            MPFROM2SHORT (8, 0), NULL) ;
  604.          WinSetDlgItemText (hWndDlg, OpenIni_IniName, "") ;
  605.          CurDir2DlgText(  hWndDlg, OpenIni_CWD ) ;
  606.          DrvList2DlgBox(  hWndDlg, OpenIni_DriveList) ;
  607.          DirList2DlgBox(  hWndDlg, OpenIni_DirList) ;
  608.          FileList2DlgBox( hWndDlg, OpenIni_FileList, IniMask) ;
  609.          break; // End of WM_INITDLG
  610.                            
  611.     case WM_CONTROL:
  612.          switch(SHORT1FROMMP(mp1))
  613.            {
  614.             case OpenIni_IniName: // Entry field
  615.                  break;
  616.  
  617.             case OpenIni_DriveList: // List box
  618.  
  619.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  620.                                                 OpenIni_DriveList,
  621.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  622.                  WinSendDlgItemMsg(hWndDlg, OpenIni_DriveList,
  623.                                    LM_QUERYITEMTEXT,
  624.                                    MPFROM2SHORT(sSelect, sizeof buffer),
  625.                                    MPFROMP(buffer)) ;
  626.                  if( SHORT2FROMMP( mp1 ) != LN_ENTER )  break;
  627.                  DosQCurDisk( &CurDisk, &DriveMap );
  628.                  if(DosSelectDisk (buffer [1] - '@')!=0)
  629.                      DosSelectDisk ( CurDisk );
  630.                  WinPostMsg(hWndDlg, WM_INITDLG, 0L, 0L);
  631.  
  632.                  break;
  633.  
  634.             case OpenIni_DirList: // List box
  635.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  636.                                                 OpenIni_DirList,
  637.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  638.                  WinSendDlgItemMsg(hWndDlg, OpenIni_DirList,
  639.                                    LM_QUERYITEMTEXT,
  640.                                    MPFROM2SHORT(sSelect, sizeof buffer),
  641.                                    MPFROMP(buffer)) ;
  642.                  if( SHORT2FROMMP( mp1 ) != LN_ENTER )  break;
  643.                  strcpy(buffer,buffer);
  644.                  for(i=1; i<=strlen(buffer)&&buffer[i]!=']';i++)
  645.                      buffer[i-1]=buffer[i];
  646.                  buffer[i-1]=0x00;
  647.          DosChDir(buffer, 0L) ;
  648.                  WinPostMsg(hWndDlg, WM_INITDLG, 0L, 0L);
  649.                  break;
  650.  
  651.             case OpenIni_FileList: // List box
  652.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  653.                                                 OpenIni_FileList,
  654.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  655.                  if( sSelect == LIT_NONE ) break ;
  656.                  WinSendDlgItemMsg(hWndDlg, OpenIni_FileList,
  657.                                    LM_QUERYITEMTEXT,
  658.                                    MPFROM2SHORT(sSelect, sizeof buffer),
  659.                                    MPFROMP(buffer)) ;
  660.                  for(sSelect = 0; buffer[sSelect] != '.'; sSelect++ ) ;
  661.                  buffer[sSelect] = '\0' ;
  662.                  WinSetDlgItemText (hWndDlg, OpenIni_IniName, buffer) ;
  663.                  if( SHORT2FROMMP( mp1 ) != LN_ENTER )  break;
  664.                  WinPostMsg(hWndDlg, WM_COMMAND, MPFROM2SHORT(DID_OK,0L), 0L);
  665.                  break;
  666.  
  667.            }
  668.          break; // End of WM_CONTROL
  669.    
  670.     case WM_COMMAND:
  671.          switch(SHORT1FROMMP(mp1))
  672.            {
  673.             case DID_OK:
  674.                  if( !WinQueryDlgItemText(hWndDlg,
  675.                                           OpenIni_IniName,
  676.                                           ulWorkAreaSize,
  677.                                           pvoidWorkArea ) ) break ;
  678.                  if( hiniUser ) PrfCloseProfile( hiniUser ) ;
  679.                  WinQueryDlgItemText(hWndDlg, OpenIni_CWD,
  680.                                      sizeof(szUserIni), szUserIni ) ;
  681.                  strcat( szUserIni, (PSZ)pvoidWorkArea ) ;
  682.                  strcat( szUserIni, ".INI" ) ;
  683.                  hiniUser = PrfOpenProfile( hAB, szUserIni ) ;
  684.                  WinDismissDlg(hWndDlg, TRUE);
  685.                  break;
  686.  
  687.             case DID_CANCEL:
  688.                  // Ignore data values entered into the dialog controls
  689.                  // and dismiss the dialog window
  690.                  WinDismissDlg(hWndDlg, FALSE);
  691.                  break;
  692.            }
  693.          break; // End of WM_COMMAND
  694.                                
  695.     case WM_CLOSE:
  696.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  697.          break; // End of WM_CLOSE 
  698.            
  699.     default:
  700.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  701.          break;
  702.    }
  703.  return FALSE;
  704. } /* End of OPENINIMsgProc */
  705.  
  706.  
  707. /************************************************************************/
  708. /*                                                                      */
  709. /* Dialog Window Procedure                                              */
  710. /*                                                                      */
  711. /* This procedure is associated with the dialog box that is included in */
  712. /* the function name of the procedure. It provides the service routines */
  713. /* for the events (messages) that occur because the end user operates   */
  714. /* one of the dialog box's buttons, entry fields, or controls.          */
  715. /*                                                                      */
  716. /* The SWITCH statement in the function distributes the dialog box      */
  717. /* messages to the respective service routines, which are set apart by  */
  718. /* the CASE clauses. Like any other PM window, the Dialog Window        */
  719. /* procedures must provide an appropriate service routine for their end */
  720. /* user initiated messages as well as for the general PM messages (like */
  721. /* the WM_CLOSE message). If a message is sent to this procedure for    */
  722. /* which there is no programmed CASE condition (no service routine),    */
  723. /* the message is defaulted to the WinDefDlgProc function, where it is  */
  724. /* disposed of by PM.                                                   */
  725. /*                                                                      */
  726. /************************************************************************/
  727.  
  728. MRESULT EXPENTRY BKSYSINIMsgProc(hWndDlg, message, mp1, mp2)
  729. HWND hWndDlg;
  730. USHORT message;
  731. MPARAM mp1;
  732. MPARAM mp2;
  733. { 
  734.  SHORT i;
  735.           
  736.  VOID APIENTRY Backup_Ini() ;
  737.  USHORT sSelect, CurDisk ;
  738.  ULONG  DriveMap ;
  739.  UCHAR  buffer[MAXNAMEL+1] ;
  740.  
  741.  #define SEGSIZE 4096
  742.  #define ALLOCFLAGS 0
  743.  TID     ThreadId ;
  744.  SEL     ThreadStackSel ;
  745.  PBYTE   StackEnd ;
  746.  
  747.  switch(message)
  748.    {
  749.     case WM_INITDLG:
  750.          CurDir2DlgText(  hWndDlg, Bksysini_CWD ) ;
  751.          DrvList2DlgBox(  hWndDlg, Bksysini_DriveList) ;
  752.          DirList2DlgBox(  hWndDlg, Bksysini_DirList) ;
  753.          break; // End of WM_INITDLG
  754.                            
  755.     case WM_CONTROL:
  756.          switch(SHORT1FROMMP(mp1))
  757.            {
  758.             case Bksysini_DriveList: // List box
  759.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  760.                                                 Bksysini_DriveList,
  761.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  762.                  WinSendDlgItemMsg(hWndDlg, Bksysini_DriveList,
  763.                                    LM_QUERYITEMTEXT,
  764.                                    MPFROM2SHORT(sSelect, sizeof buffer),
  765.                                    MPFROMP(buffer)) ;
  766.                  if( SHORT2FROMMP( mp1 ) != LN_ENTER )  break;
  767.                  DosQCurDisk( &CurDisk, &DriveMap );
  768.                  if(DosSelectDisk (buffer [1] - '@')!=0)
  769.                      DosSelectDisk ( CurDisk );
  770.                  WinPostMsg(hWndDlg, WM_INITDLG, 0L, 0L);
  771.                  break;
  772.  
  773.             case Bksysini_DirList: // List box
  774.                  sSelect = (USHORT) WinSendDlgItemMsg (hWndDlg,
  775.                                                 Bksysini_DirList,
  776.                                                 LM_QUERYSELECTION, 0L, 0L) ;
  777.                  WinSendDlgItemMsg(hWndDlg, Bksysini_DirList,
  778.                                    LM_QUERYITEMTEXT,
  779.                                    MPFROM2SHORT(sSelect, sizeof buffer),
  780.                                    MPFROMP(buffer)) ;
  781.                  if( SHORT2FROMMP( mp1 ) != LN_ENTER )  break;
  782.                  strcpy(buffer,buffer);
  783.                  for(i=1; i<=strlen(buffer)&&buffer[i]!=']';i++)
  784.                      buffer[i-1]=buffer[i];
  785.                  buffer[i-1]=0x00;
  786.          DosChDir(buffer, 0L) ;
  787.                  WinPostMsg(hWndDlg, WM_INITDLG, 0L, 0L);
  788.                  break;
  789.  
  790.            }
  791.          break; // End of WM_CONTROL
  792.    
  793.     case WM_COMMAND:
  794.          switch(SHORT1FROMMP(mp1))
  795.            {
  796.             case DID_OK:
  797.                  WinQueryDlgItemText(hWndDlg, Bksysini_CWD,
  798.                                      WORKAREASIZE, pvoidWorkArea ) ;
  799.                  DosAllocSeg( SEGSIZE, &ThreadStackSel, ALLOCFLAGS ) ;
  800.                  StackEnd = MAKEP(ThreadStackSel, SEGSIZE-1) ;
  801.                  DosCreateThread((PFNTHREAD)Backup_Ini, &ThreadId, StackEnd);
  802.                  WinDlgBox(HWND_DESKTOP, hWndDlg, (PFNWP)BKUPRUNMsgProc, 
  803.                            NULL, IDLG_BKUPRUN, NULL);
  804.                  DosFreeSeg( ThreadStackSel );
  805.                  WinDismissDlg(hWndDlg, TRUE);
  806.                  break;
  807.  
  808.             case DID_CANCEL:
  809.                  // Ignore data values entered into the dialog controls
  810.                  // and dismiss the dialog window
  811.                  WinDismissDlg(hWndDlg, FALSE);
  812.                  break;
  813.            }
  814.          break; // End of WM_COMMAND
  815.                                
  816.     case WM_CLOSE:
  817.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  818.          break; // End of WM_CLOSE 
  819.            
  820.     default:
  821.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  822.          break;
  823.    }
  824.  return FALSE;
  825. } /* End of BKSYSINIMsgProc */
  826.  
  827.  
  828. /************************************************************************/
  829. /*                                                                      */
  830. /* Dialog Window Procedure                                              */
  831. /*                                                                      */
  832. /* This procedure is associated with the dialog box that is included in */
  833. /* the function name of the procedure. It provides the service routines */
  834. /* for the events (messages) that occur because the end user operates   */
  835. /* one of the dialog box's buttons, entry fields, or controls.          */
  836. /*                                                                      */
  837. /* The SWITCH statement in the function distributes the dialog box      */
  838. /* messages to the respective service routines, which are set apart by  */
  839. /* the CASE clauses. Like any other PM window, the Dialog Window        */
  840. /* procedures must provide an appropriate service routine for their end */
  841. /* user initiated messages as well as for the general PM messages (like */
  842. /* the WM_CLOSE message). If a message is sent to this procedure for    */
  843. /* which there is no programmed CASE condition (no service routine),    */
  844. /* the message is defaulted to the WinDefDlgProc function, where it is  */
  845. /* disposed of by PM.                                                   */
  846. /*                                                                      */
  847. /************************************************************************/
  848.  
  849. MRESULT EXPENTRY BKUPRUNMsgProc(hWndDlg, message, mp1, mp2)
  850. HWND hWndDlg;
  851. USHORT message;
  852. MPARAM mp1;
  853. MPARAM mp2;
  854. { 
  855.  SHORT i;
  856.           
  857.  #define SLEEPSHORT 5L
  858.  
  859.  switch(message)
  860.    {
  861.     case WM_INITDLG:
  862.          hwndThreadWaiter = hWndDlg ;
  863.          break; // End of WM_INITDLG
  864.                            
  865.     case WM_CONTROL:
  866.          switch(SHORT1FROMMP(mp1))
  867.            {
  868.            }
  869.          break; // End of WM_CONTROL
  870.    
  871.     case WM_COMMAND:
  872.          switch(SHORT1FROMMP(mp1))
  873.            {
  874.             case DID_OK:
  875.                  WinDismissDlg(hWndDlg, TRUE);
  876.                  break;
  877.  
  878.             case DID_CANCEL:
  879.                  // Ignore data values entered into the dialog controls
  880.                  // and dismiss the dialog window
  881.                  WinDismissDlg(hWndDlg, FALSE);
  882.                  break;
  883.             case THREAD_GONE:
  884.                  DosSleep( SLEEPSHORT ) ;
  885.                  WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  886.                  break ;
  887.            }
  888.          break; // End of WM_COMMAND
  889.                                
  890.     case WM_CLOSE:
  891.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  892.          break; // End of WM_CLOSE 
  893.            
  894.     default:
  895.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  896.          break;
  897.    }
  898.  return FALSE;
  899. } /* End of BKUPRUNMsgProc */
  900.  
  901.  
  902.  
  903.  
  904. /************************************************************************/
  905. /*                                                                      */
  906. /* RegisterClass Function                                               */
  907. /*                                                                      */
  908. /* The following function registers all the classes of all the windows  */
  909. /* associated with this application. The function returns TRUE if it is */
  910. /* successful, otherwise it returns FALSE.                              */
  911. /*                                                                      */
  912. /************************************************************************/
  913.  
  914. INT RegisterClass()
  915. {
  916.  INT rc;
  917.  
  918.  strcpy(szAppName, "INIPGMS");
  919.  rc = WinRegisterClass(hAB,             // Anchor block handle            
  920.                       (PCH)szAppName,   // Name of class being registered 
  921.                       (PFNWP)WndProc,   // Window procedure for class     
  922.                       CS_SIZEREDRAW , 
  923.                       NULL);            // Extra bytes to reserve         
  924.  if (rc == FALSE)
  925.    return(FALSE);
  926.  
  927.  return(TRUE);
  928. } // End of RegisterClass
  929.  
  930.  
  931.  
  932. /************************************************************************/
  933. /*                                                                      */
  934. /* CreateWindow Function                                                */
  935. /*                                                                      */
  936. /* The following function is used to create a window (the main window,  */
  937. /* a child window, an icon window, etc.) and set it's initial size and  */
  938. /* position. It returns the handle to the frame window.                 */
  939. /*                                                                      */
  940. /************************************************************************/
  941.  
  942. HWND CreateWindow(
  943.    HWND   hWndParent,  // Handle to the parent of the window to be created
  944.    ULONG  ctldata,     // Frame control flags for the window
  945.    PCH    appname,     // Class name of the window
  946.    PCH    title,       // Title of the window
  947.    USHORT ResID,       // Resource id value
  948.    INT    x,           // Initial horizontal and vertical location of origin
  949.    INT    y,
  950.    INT    cx,          // Initial width and height of the window
  951.    INT    cy, 
  952.    PHWND  hWndClient,  // Handle to the client area of the window
  953.    ULONG  lfStyle,     // Frame window style
  954.    USHORT uSizeStyle)  // User defined size and location flags
  955. {
  956.    USHORT rc;            // accepts return codes from function calls
  957.    HWND   hWndFrame;     // local handle to created window frame
  958.    USHORT SizeStyle;     // local window positioning options
  959.    CHAR   MsgBuffer[80]; // buffer for error messages
  960.       
  961.    // Create the frame window
  962.    hWndFrame = WinCreateStdWindow(hWndParent,  // parent of window
  963.                                   lfStyle,     // frame window style
  964.                                   &ctldata,    // frame flags
  965.                                   appname,     // class name
  966.                                   title,       // window title
  967.                                   0L,          // client window style
  968.                                   NULL,        // module for resources
  969.                                   ResID,       // resource id
  970.                                   (HWND FAR *)hWndClient); // client handle
  971.  
  972.    // if hWndFrame is NULL, an error occured when opening the window, notify
  973.    //     the user and exit this function
  974.    if(hWndFrame == NULL)
  975.      {
  976.       WinLoadString(hAB, NULL, IDS_ERR_WINDOW_CREATE, 80, MsgBuffer);
  977.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  978.                     NULL, NULL, MB_OK|MB_ICONEXCLAMATION);
  979.       return((HWND)NULL);
  980.      }
  981.  
  982.    // set up size options
  983.    SizeStyle = SWP_ACTIVATE | SWP_ZORDER | uSizeStyle;
  984.  
  985.    // if the either the intial x or y position of the window is non-zero,
  986.    //    set the window to its new position
  987.    if((x > 0) || (y > 0))
  988.      SizeStyle |= SWP_MOVE;
  989.    // if either the width or the height are non-zero, then the size of the
  990.    //     created window will be changed, set SizeStyle accordingly
  991.    if((cx > 0) || (cy > 0))
  992.      SizeStyle |= SWP_SIZE;
  993.    // set the size and position of the window and activate it
  994.    rc = WinSetWindowPos(hWndFrame, HWND_TOP, x, y, cx, cy, SizeStyle);
  995.    
  996.    // if rc is not set to TRUE then WinSetWindowPos failed, notify the user
  997.    //     and exit this function
  998.    if(!rc)
  999.      {
  1000.       WinLoadString(hAB, NULL, IDS_ERR_WINDOW_POS, 80, MsgBuffer);
  1001.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  1002.                     NULL, NULL, MB_OK|MB_ICONEXCLAMATION);
  1003.       return((HWND)NULL);
  1004.      }
  1005.  
  1006.    // return the handle to the frame window
  1007.    return(hWndFrame);
  1008. }  // End of CreateWindow
  1009.  
  1010.  
  1011.  
  1012.