home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sftick.zip / adv / object / SLIDEROB.C < prev    next >
Text File  |  1994-04-21  |  13KB  |  426 lines
  1. #define INCL_DOS
  2. #define INCL_WINDIALOGS
  3. #define INCL_WINMENUS
  4. #define INCL_WINSTDSLIDER
  5. #define INCL_WINSYS
  6. #define INCL_WINWINDOWMGR
  7.  
  8. #include <os2.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include "sliderob.h"
  13.  
  14. #define CLS_OBJECT               "ObjectClass"
  15.  
  16. #define UM_STARTCOPY             ( WM_USER )
  17. #define UM_COPYDONE              ( WM_USER + 1 )
  18.  
  19. #define COPY_FILE                "SLIDEROB.C"
  20. #define BACKUP_FILE              "SLIDEROB.BAK"
  21.  
  22. #define SZ_STACK                 16384
  23.  
  24. typedef struct _SLIDERINFO {
  25.    ULONG       ulStructSize ;
  26.    HWND        hwndSlider ;
  27.    HWND        hwndObject ;
  28.    HWND        hwndDialog ;
  29.    HEV         hevQuitSem ;
  30. } SLIDERINFO, * PSLIDERINFO ;
  31.  
  32. typedef VOID ( * _Optlink PFNCOPY ) ( PVOID ) ;
  33.  
  34. BOOL CopyFile ( HWND hwndSlider ) ;
  35. MRESULT EXPENTRY ObjectWndProc ( HWND hwndWnd,
  36.                                  ULONG ulMsg,
  37.                                  MPARAM mpParm1,
  38.                                  MPARAM mpParm2 ) ;
  39.  
  40. VOID CopyThread ( PSLIDERINFO psiSlider ) ;
  41.  
  42. MRESULT EXPENTRY DlgProc ( HWND hwndDlg,
  43.                            ULONG ulMsg,
  44.                            MPARAM mpParm1,
  45.                            MPARAM mpParm2 ) ;
  46.  
  47. INT main ( VOID )
  48. {
  49.    HAB               habAnchor ;
  50.    HMQ               hmqQueue ;
  51.    PSLIDERINFO       pSliderInfo ;
  52.    APIRET            rc ;
  53.  
  54.    habAnchor = WinInitialize ( 0 ) ;
  55.    hmqQueue = WinCreateMsgQueue ( habAnchor, 0 ) ;
  56.  
  57.    pSliderInfo = (PSLIDERINFO) malloc ( sizeof ( SLIDERINFO )) ;
  58.    if ( pSliderInfo == NULL ) {
  59.       WinMessageBox ( HWND_DESKTOP,
  60.                       HWND_DESKTOP,
  61.                       "Out of memory !",
  62.                       "Error",
  63.                       0,
  64.                       MB_ICONEXCLAMATION | MB_OK ) ;
  65.       WinDestroyMsgQueue ( hmqQueue ) ;
  66.       WinTerminate ( habAnchor ) ;
  67.       return 0 ;
  68.    } /* endif */
  69.  
  70.    pSliderInfo->ulStructSize = sizeof ( SLIDERINFO ) ;
  71.    rc  = DosCreateEventSem( NULL,
  72.                             &(pSliderInfo->hevQuitSem),
  73.                             DC_SEM_SHARED,
  74.                             FALSE ) ;
  75.    if (rc) {
  76.  
  77.       WinMessageBox ( HWND_DESKTOP,
  78.                       HWND_DESKTOP,
  79.                       "Cannot create Event Semaphore",
  80.                       "Error",
  81.                       0,
  82.                       MB_ICONEXCLAMATION | MB_OK ) ;
  83.  
  84.       free ( pSliderInfo ) ;
  85.       WinDestroyMsgQueue ( hmqQueue ) ;
  86.       WinTerminate ( habAnchor ) ;
  87.       return 0 ;
  88.  
  89.    } /* endif */
  90.  
  91.  
  92.    if ( _beginthread(( PFNCOPY ) CopyThread,
  93.                        0,
  94.                        SZ_STACK,
  95.                        ( PVOID ) pSliderInfo ) == - 1 ) {
  96.  
  97.       WinMessageBox ( HWND_DESKTOP,
  98.                       HWND_DESKTOP,
  99.                       "Cannot create thread !",
  100.                       "Error",
  101.                       0,
  102.                       MB_ICONEXCLAMATION | MB_OK ) ;
  103.  
  104.       free ( pSliderInfo ) ;
  105.       WinDestroyMsgQueue ( hmqQueue ) ;
  106.       WinTerminate ( habAnchor ) ;
  107.       return 0 ;
  108.    } /* endif */
  109.  
  110.    WinDlgBox ( HWND_DESKTOP,
  111.                HWND_DESKTOP,
  112.                DlgProc,
  113.                NULLHANDLE,
  114.                IDD_FCOPYDLG,
  115.                pSliderInfo ) ;
  116.  
  117.    WinDestroyMsgQueue ( hmqQueue ) ;
  118.  
  119.    /* destroy the object window and wait until it signals that it
  120.       has been destroyed */
  121.  
  122.    WinDestroyWindow ( pSliderInfo->hwndObject ) ;
  123.    DosWaitEventSem( pSliderInfo->hevQuitSem , SEM_INDEFINITE_WAIT ) ;
  124.    free ( pSliderInfo ) ;
  125.    WinTerminate ( habAnchor ) ;
  126.    return 0 ;
  127. }
  128.  
  129. MRESULT EXPENTRY DlgProc ( HWND hwndDlg,
  130.                            ULONG ulMsg,
  131.                            MPARAM mpParm1,
  132.                            MPARAM mpParm2 )
  133. {
  134.    PSLIDERINFO psiSlider ;
  135.  
  136.    psiSlider = WinQueryWindowPtr ( hwndDlg, 0 ) ;
  137.  
  138.    switch ( ulMsg ) {
  139.  
  140.    case WM_INITDLG:
  141.       {
  142.          CHAR        achFont [16] ;
  143.          USHORT      usIndex ;
  144.          CHAR        achMessage [64] ;
  145.  
  146.          psiSlider = (PSLIDERINFO) PVOIDFROMMP ( mpParm2 ) ;
  147.          WinSetWindowPtr ( hwndDlg, 0, psiSlider ) ;
  148.  
  149.          psiSlider->hwndDialog = hwndDlg ;
  150.          psiSlider->hwndSlider = WinWindowFromID ( hwndDlg,
  151.                                                      IDS_SLIDER ) ;
  152.  
  153.          //--------------------------------------------------------
  154.          // Set the size of the tick marks
  155.          //--------------------------------------------------------
  156.  
  157.          WinSendDlgItemMsg ( hwndDlg,
  158.                              IDS_SLIDER,
  159.                              SLM_SETTICKSIZE,
  160.                              MPFROM2SHORT ( SMA_SETALLTICKS, 7 ) ,
  161.                              0 ) ;
  162.  
  163.          strcpy ( achFont, "8.Tms Rmn" ) ;
  164.          WinSetPresParam ( WinWindowFromID ( hwndDlg, IDS_SLIDER ) ,
  165.                            PP_FONTNAMESIZE,
  166.                            strlen ( achFont ) + 1,
  167.                            achFont ) ;
  168.  
  169.          for ( usIndex = 0 ; usIndex < 11 ; usIndex ++ ) {
  170.             sprintf ( achMessage, "%d%%", usIndex * 10 ) ;
  171.  
  172.             WinSendDlgItemMsg ( hwndDlg,
  173.                                 IDS_SLIDER,
  174.                                 SLM_SETSCALETEXT,
  175.                                 MPFROMSHORT ( usIndex ) ,
  176.                                 MPFROMP ( achMessage )) ;
  177.          } /* endfor */
  178.       }
  179.       break ;
  180.  
  181.  
  182.    case WM_COMMAND:
  183.  
  184.       switch ( SHORT1FROMMP ( mpParm1 )) {
  185.  
  186.          case IDP_START:
  187.             WinPostMsg ( psiSlider->hwndObject,
  188.                          UM_STARTCOPY,
  189.                          0,
  190.                          0 ) ;
  191.             WinEnableWindow ( WinWindowFromID ( hwndDlg,
  192.                                                 IDP_START ) ,
  193.                               FALSE ) ;
  194.             break ;
  195.  
  196.          case IDP_CANCEL:
  197.             WinDismissDlg ( hwndDlg, FALSE ) ;
  198.             break ;
  199.  
  200.          default:
  201.             return WinDefDlgProc ( hwndDlg,
  202.                                    ulMsg,
  203.                                    mpParm1,
  204.                                    mpParm2 ) ;
  205.       } /* endswitch */
  206.       break ;
  207.  
  208.    case UM_COPYDONE:
  209.       {
  210.          USHORT      usState ;
  211.          CHAR        achMessage [60] ;
  212.  
  213.          WinEnableWindow ( WinWindowFromID ( hwndDlg,
  214.                                              IDP_START ) ,
  215.                            TRUE ) ;
  216.  
  217.          usState = SHORT1FROMMP ( mpParm1 ) ;
  218.          if ( usState == TRUE ) {
  219.             strcpy ( achMessage, "Copy completed Successfully" ) ;
  220.             WinAlarm ( HWND_DESKTOP, WA_NOTE ) ;
  221.          } else {
  222.             strcpy ( achMessage, "Copy failed" ) ;
  223.             WinAlarm ( HWND_DESKTOP, WA_ERROR ) ;
  224.          } /* endif */
  225.  
  226.          WinMessageBox ( HWND_DESKTOP,
  227.                          hwndDlg,
  228.                          achMessage,
  229.                          "Copy Status",
  230.                          0,
  231.                          MB_OK | MB_INFORMATION ) ;
  232.       }
  233.       break ;
  234.  
  235.    default:
  236.       return WinDefDlgProc ( hwndDlg,
  237.                              ulMsg,
  238.                              mpParm1,
  239.                              mpParm2 ) ;
  240.    } /* endswitch */
  241.  
  242.    return MRFROMSHORT ( FALSE ) ;
  243. }
  244.  
  245. VOID CopyThread ( PSLIDERINFO psiSlider )
  246. {
  247.    HAB        habAnchor ;
  248.    HMQ        hmqQueue ;
  249.    QMSG       qmMsg ;
  250.  
  251.    habAnchor = WinInitialize ( 0 ) ;
  252.    hmqQueue = WinCreateMsgQueue ( habAnchor, 0 ) ;
  253.  
  254.    WinRegisterClass ( habAnchor,
  255.                       CLS_OBJECT,
  256.                       ObjectWndProc,
  257.                       0,
  258.                       sizeof ( PVOID )) ;
  259.  
  260.    psiSlider->hwndObject = WinCreateWindow ( HWND_OBJECT,
  261.                                              CLS_OBJECT,
  262.                                              NULL,
  263.                                              0,
  264.                                              0,
  265.                                              0,
  266.                                              0,
  267.                                              0,
  268.                                              NULLHANDLE,
  269.                                              HWND_TOP,
  270.                                              ID_OBJECT,
  271.                                              psiSlider,
  272.                                              NULL ) ;
  273.  
  274.    if ( psiSlider->hwndObject != NULLHANDLE ) {
  275.       while (WinGetMsg ( habAnchor,
  276.                          &qmMsg,
  277.                          NULLHANDLE,
  278.                          0,
  279.                          0 ))
  280.  
  281.           WinDispatchMsg ( habAnchor, &qmMsg ) ;
  282.       WinDestroyWindow ( psiSlider->hwndObject ) ;
  283.    } /* endif */
  284.  
  285.    WinDestroyMsgQueue ( hmqQueue ) ;
  286.    WinTerminate ( habAnchor ) ;
  287.    DosPostEventSem( psiSlider->hevQuitSem ) ;
  288.    return ;
  289. }
  290.  
  291. MRESULT EXPENTRY ObjectWndProc ( HWND hwndWnd,
  292.                                  ULONG  ulMsg,
  293.                                  MPARAM mpParm1,
  294.                                  MPARAM mpParm2 )
  295. {
  296.    switch ( ulMsg ) {
  297.  
  298.       case WM_CREATE:
  299.          WinSetWindowPtr ( hwndWnd, 0, PVOIDFROMMP ( mpParm1 )) ;
  300.          break ;
  301.  
  302.       case UM_STARTCOPY:
  303.          {
  304.             PSLIDERINFO pSliderInfo ;
  305.  
  306.             pSliderInfo = WinQueryWindowPtr ( hwndWnd, 0 ) ;
  307.  
  308.             if ( CopyFile ( pSliderInfo->hwndSlider )) {
  309.                WinPostMsg ( pSliderInfo->hwndDialog,
  310.                             UM_COPYDONE,
  311.                             MPFROMSHORT ( TRUE ) ,
  312.                             0 ) ;
  313.             } else {
  314.                WinPostMsg ( pSliderInfo->hwndDialog,
  315.                             UM_COPYDONE,
  316.                             MPFROMSHORT ( FALSE ) ,
  317.                             0 ) ;
  318.             } /* endif */
  319.          }
  320.          break ;
  321.  
  322.       default:
  323.          return WinDefWindowProc ( hwndWnd,
  324.                                    ulMsg,
  325.                                    mpParm1,
  326.                                    mpParm2 ) ;
  327.    } /* endswitch */
  328.  
  329.    return MRFROMSHORT ( FALSE ) ;
  330. }
  331.  
  332. BOOL CopyFile ( HWND hwndSlider )
  333. {
  334.    APIRET            arRc ;
  335.    FILESTATUS3       fsStatus ;
  336.    PBYTE             pbBuffer ;
  337.    HFILE             hfRead ;
  338.    ULONG             ulAction ;
  339.    HFILE             hfWrite ;
  340.    ULONG             ulSzBlock ;
  341.    USHORT            usIndex ;
  342.    ULONG             ulBytesRead ;
  343.    ULONG             ulBytesWritten ;
  344.  
  345.    arRc = DosQueryPathInfo ( COPY_FILE,
  346.                              FIL_STANDARD,
  347.                              (PVOID) &fsStatus,
  348.                              sizeof ( fsStatus )) ;
  349.  
  350.    if ( !arRc ) {
  351.  
  352.       ulSzBlock = fsStatus.cbFile / 10 + 1 ;
  353.  
  354.       pbBuffer = (PBYTE) malloc ( ulSzBlock ) ;
  355.  
  356.       //-----------------------------------------------------------
  357.       // Open up the file for reading
  358.       //-----------------------------------------------------------
  359.  
  360.       arRc = DosOpen ( COPY_FILE,
  361.                        &hfRead,
  362.                        &ulAction,
  363.                        0,
  364.                        FILE_NORMAL,
  365.                        FILE_OPEN,
  366.                        OPEN_ACCESS_READONLY | OPEN_SHARE_DENYWRITE,
  367.                        0 ) ;
  368.  
  369.       //-----------------------------------------------------------
  370.       // Open up the backup file for write
  371.       //-----------------------------------------------------------
  372.  
  373.       arRc = DosOpen ( BACKUP_FILE,
  374.                        &hfWrite,
  375.                        &ulAction,
  376.                        0,
  377.                        FILE_NORMAL,
  378.                        FILE_CREATE,
  379.                        OPEN_ACCESS_WRITEONLY |
  380.                        OPEN_SHARE_DENYREADWRITE,
  381.                        0 ) ;
  382.  
  383.       for ( usIndex = 1 ; usIndex < 11 ; usIndex ++ ) {
  384.  
  385.          //--------------------------------------------------------
  386.          // Read a block
  387.          //--------------------------------------------------------
  388.  
  389.          DosRead ( hfRead,
  390.                    pbBuffer,
  391.                    ulSzBlock,
  392.                    &ulBytesRead ) ;
  393.  
  394.          //--------------------------------------------------------
  395.          // Write a block
  396.          //--------------------------------------------------------
  397.  
  398.          DosWrite ( hfWrite,
  399.                     pbBuffer,
  400.                     ulBytesRead,
  401.                     &ulBytesWritten ) ;
  402.  
  403.          //--------------------------------------------------------
  404.          // Tell the slider to move
  405.          //--------------------------------------------------------
  406.  
  407.          WinSendMsg ( hwndSlider,
  408.                       SLM_SETSLIDERINFO,
  409.                       MPFROM2SHORT ( SMA_SLIDERARMPOSITION,
  410.                          SMA_INCREMENTVALUE ) ,
  411.                       MPFROMSHORT ( usIndex )) ;
  412.       } /* endfor */
  413.  
  414.       //-----------------------------------------------------------
  415.       // Clean up
  416.       //-----------------------------------------------------------
  417.  
  418.       DosClose ( hfRead ) ;
  419.       DosClose ( hfWrite ) ;
  420.       free ( pbBuffer ) ;
  421.       return TRUE ;
  422.    } else {
  423.       return FALSE ;
  424.    } /* endif */
  425. }
  426.