home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rb3774 / dmcust / dmcust.c next >
Encoding:
C/C++ Source or Header  |  1992-06-28  |  15.1 KB  |  440 lines
  1. //****************************************************************************************
  2. //
  3. //  DMCUST.C - a demo program by Alan Chambers - UK PS Technical Support, whilst on 
  4. //             a residency at the ITSC, Boca Raton
  5. //
  6. //  Updated to work with GA code, 6 May 1992
  7. //
  8. //  This program reads several names, addresses and phone numbers from a file (DMCUST.DAT)
  9. //  and displays them as icons in a container window.  These items can be moved from
  10. //  one instance of this program to another by direct manipulation; they can be dropped
  11. //  on an order form displayed by the DMORDER sample to fill in the customer details therein,
  12. //  and they can be dropped on the telephone icon shown by the DMPHONE sample, to simulate
  13. //  a telephone dialler.
  14. //
  15. //
  16. //  This sample illustrates several different aspects of drag/drop:
  17. //
  18. //      - initiating a drag from a container window
  19. //      - using the DRM_PRINT rendering mechanism to allow application printing by
  20. //        drag/drop to a workplace shell printer object
  21. //      - using the DRM_DISCARD rendering mechanism to allow deletion of application
  22. //        items by dragging them to the workplace shell shredder object
  23. //      - implementing both ends of a user defined rendering mechanism (here called
  24. //        DRM_SHAREMEM)
  25. //
  26. //****************************************************************************************
  27. //
  28. // The program concentrates on demonstrating drag/drop techniques and is therefore
  29. // very simple in other respects. In particular, the so called customers to be displayed
  30. // are read from a simple flat file called DMCUST.DAT that can be read with fscanf().  
  31. // The following lines illustrate the format of this file - note that each text 
  32. /* field must have no imbedded blanks:
  33.  
  34. Alan_Chambers Somewhere_nice 123-4567
  35. John_Major 10_Downing_Street 999-4444
  36. A.N.Other Somewhere_horrible 987-5432
  37. George_Bush The_Whitehouse 456-8765
  38.  
  39. ******************************************************************************************/
  40.  
  41.  
  42. #define INCL_WIN
  43. #define INCL_GPI
  44. #define INCL_DOS
  45.  
  46. #include <os2.h>                         
  47. #include "dmcust.h"                      
  48. #include <stdio.h>
  49. #include <string.h>
  50. #include <stdlib.h>
  51. #include <ctype.h>
  52. #include <memory.h>
  53.  
  54. //***************************************************************************** */
  55. //
  56. //  #defines, typedefs and function headers
  57. //
  58. //***************************************************************************** */
  59.  
  60.  
  61.  
  62. #define OBJECTDATASIZE 100
  63. #define DRAGXFERMEMNAME "\\SHAREMEM\\DragXfer.mem"
  64.  
  65.  
  66. typedef struct {
  67.                  char name[30];
  68.                  char address[100];
  69.                  char phone[15];
  70.                } 
  71.                  CUSTOMER, *PCUSTOMER;
  72.  
  73. typedef struct{
  74.                 RECORDCORE core;          // control info for CONTAINER window
  75.                 CUSTOMER cust;            // application defined data
  76.               }
  77.                 CONTRECORD, *PCONTRECORD;
  78.  
  79. MRESULT EXPENTRY CustWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 );
  80. void FillWindow(HWND);
  81. void AddCustomer(HWND, PCUSTOMER, ULONG, ULONG);
  82. void RemoveCustomer(HWND, PCONTRECORD);
  83. void PrintCustomer(PCONTRECORD, PPRINTDEST);
  84.  
  85.  
  86.  
  87. //***************************************************************************** */
  88. //
  89. //  Some global variables
  90. //
  91. //***************************************************************************** */
  92.  
  93. HAB  hab;                               /* PM anchor block handle           */
  94. HPOINTER hptrCustIcon;                  /* Icon used for dragging customers */
  95.  
  96. //***************************************************************************** */
  97. //
  98. //  Main procedure - designed to create main (only) window and process messages
  99. //
  100. //***************************************************************************** */
  101.  
  102. INT main (VOID)
  103. { 
  104.   HMQ  hmq;                                   /* Message queue handle         */
  105.   QMSG qmsg;                                  /* Message from message queue   */
  106.   HWND hwndMain;
  107.   ULONG flCreate = FCF_STANDARD & ~FCF_MENU;  /* frame window creation flags */
  108.  
  109.   hab = WinInitialize(0);
  110.  
  111.   hmq = WinCreateMsgQueue(hab, 0);
  112.  
  113.   hptrCustIcon = WinLoadPointer(HWND_DESKTOP, 0, ID_CUSTPOINTER);
  114.  
  115.   WinRegisterClass(                       
  116.        hab,                               
  117.         (PSZ)"CustWindow",                
  118.         (PFNWP)CustWindowProc,            
  119.         CS_SIZEREDRAW,                    
  120.         sizeof(PVOID)
  121.         );
  122.  
  123.   hwndMain = WinCreateStdWindow(
  124.                    HWND_DESKTOP,           
  125.                    0,                      
  126.                    &flCreate,              
  127.                    "CustWindow",           
  128.                    "Customer Window",
  129.                    0,                      
  130.                    (HMODULE)0L,            
  131.                    ID_WINDOW,              
  132.                    NULL
  133.                    );
  134.  
  135.  
  136.   while(WinGetMsg(hab, &qmsg, 0L, 0, 0))       // message processing loop
  137.      WinDispatchMsg(hab, &qmsg);
  138.  
  139.  
  140.   WinDestroyWindow(hwndMain);
  141.   WinDestroyMsgQueue( hmq );             
  142.   WinTerminate( hab );                   
  143.  
  144.   return(0);
  145. } 
  146.  
  147.  
  148. //***************************************************************************** */
  149. //
  150. //  Window procedure for main (only) window
  151. //
  152. //***************************************************************************** */
  153.  
  154. MRESULT EXPENTRY CustWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
  155. {
  156.   typedef struct {
  157.                    HWND hwndContainer;
  158.                  } 
  159.                    INSTANCE, *PINSTANCE;
  160.  
  161.   PINSTANCE wd;
  162.   SWP swp;
  163.   PCONTRECORD pcrec;
  164.   PCNRDRAGINIT pcnrdinit;
  165.   PCNRDRAGINFO pcnrdinfo;
  166.   PDRAGINFO pdinfo;
  167.   DRAGITEM ditem;
  168.   DRAGIMAGE dimg;
  169.   PDRAGTRANSFER pdxfer;
  170.   PCUSTOMER pxfercust, pxferfromcust;
  171.   PDRAGITEM pditem;
  172.   char dragxfermemname[100];
  173.   ULONG rc;
  174.   char srceType[100], srceRMF[100];
  175.   char srceFileName[100], srcePath[100];
  176.  
  177.   wd = (PINSTANCE)WinQueryWindowPtr(hwnd, 0);    // retrieve instance data pointer
  178.  
  179.   switch( msg )
  180.   {
  181.      case WM_CREATE:
  182.        wd = (PINSTANCE)malloc(sizeof(INSTANCE));   // allocate instance data space
  183.        WinSetWindowPtr(hwnd, 0, (PVOID)wd);        // and store in window words
  184.  
  185.        wd->hwndContainer = WinCreateWindow( hwnd, WC_CONTAINER, NULL, 
  186.                                         CCS_AUTOPOSITION | WS_VISIBLE | CCS_EXTENDSEL, 
  187.                                         0, 0, 0, 0, 
  188.                                         hwnd, HWND_TOP, ID_CONTAINER,
  189.                                         0, 0);
  190.  
  191.        FillWindow(wd->hwndContainer); 
  192.      
  193.        rc = WinSetWindowPos( WinQueryWindow(hwnd, QW_PARENT), 
  194.                       HWND_TOP, 100, 90, 400, 300,
  195.                       SWP_SIZE | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE);
  196.       break;
  197.  
  198.  
  199.     case WM_CONTROL:
  200.       switch (SHORT2FROMMP(mp1))
  201.       {
  202.         case CN_INITDRAG:
  203.            pcnrdinit = (PCNRDRAGINIT)mp2;
  204.            if((pcrec = (PCONTRECORD)(pcnrdinit->pRecord)) != NULL)
  205.            {          
  206.               pdinfo = DrgAllocDraginfo(1);
  207.  
  208.               ditem.hwndItem = hwnd;
  209.               ditem.ulItemID = (ULONG)pcrec;
  210.               ditem.hstrType = DrgAddStrHandle("DRT_CUSTOMER");    
  211.               ditem.hstrRMF = DrgAddStrHandle("(DRM_SHAREMEM,DRM_PRINT,DRM_DISCARD)x(DRF_TEXT)");
  212.               ditem.hstrContainerName = DrgAddStrHandle("Boca Raton Branch");
  213.               ditem.hstrSourceName = DrgAddStrHandle(pcrec->cust.name);
  214.               ditem.hstrTargetName = (HSTR)0;
  215.               ditem.fsControl = 0;  ditem.fsSupportedOps = 0;
  216.  
  217.               rc = DrgSetDragitem(pdinfo, &ditem, (ULONG)sizeof(ditem), 0);
  218.  
  219.               dimg.cb = sizeof(DRAGIMAGE);
  220.               dimg.cptl = 0;
  221.               dimg.hImage = hptrCustIcon;
  222.               dimg.sizlStretch.cx = 10L;
  223.               dimg.sizlStretch.cy = 10L;
  224.               dimg.fl = DRG_ICON;
  225.               dimg.cxOffset = 0;
  226.               dimg.cyOffset = 0;
  227.  
  228.               DrgDrag(hwnd, pdinfo, (PDRAGIMAGE)&dimg, 1, VK_ENDDRAG, NULL); 
  229.  
  230.               DrgFreeDraginfo(pdinfo);
  231.            }
  232.            break;
  233.  
  234.  
  235.         case CN_DRAGOVER:
  236.            pcnrdinfo = (PCNRDRAGINFO)mp2;
  237.            pdinfo = pcnrdinfo->pDragInfo;
  238.            pditem = DrgQueryDragitemPtr(pdinfo, 0);
  239.  
  240.            if(DrgVerifyRMF(pditem, "DRM_SHAREMEM", "DRF_TEXT"))
  241.            {
  242.              DrgFreeDraginfo(pdinfo);
  243.              return(MPFROM2SHORT(DOR_DROP, DO_MOVE));
  244.            }
  245.            else
  246.            {
  247.              DrgFreeDraginfo(pdinfo);
  248.              return(MPFROM2SHORT(DOR_NEVERDROP, 0));
  249.            }
  250.            break;
  251.  
  252.  
  253.         case CN_DROP:
  254.            pcnrdinfo = (PCNRDRAGINFO)mp2;
  255.            pdinfo = pcnrdinfo->pDragInfo;
  256.            pditem = DrgQueryDragitemPtr(pdinfo, 0);
  257.            
  258.            DrgQueryStrName(pditem->hstrSourceName, 100, srceFileName);
  259.            DrgQueryStrName(pditem->hstrContainerName, 100, srcePath);
  260.            DrgQueryStrName(pditem->hstrType, 100, srceType);
  261.            DrgQueryStrName(pditem->hstrRMF, 100, srceRMF);
  262.  
  263.  
  264.            // allocated a named shared memory object for a customer *pxfercust
  265.  
  266.            rc = DosAllocSharedMem((PPVOID)&pxfercust, DRAGXFERMEMNAME, sizeof(CUSTOMER), PAG_COMMIT | PAG_WRITE | PAG_READ);
  267.  
  268.  
  269.            // allocate and fill the dxfer structure;
  270.  
  271.            pdxfer = DrgAllocDragtransfer(1);      
  272.  
  273.            pdxfer->cb = sizeof(DRAGTRANSFER);
  274.            pdxfer->hwndClient = hwnd;
  275.            pdxfer->pditem = pditem;
  276.            pdxfer->hstrSelectedRMF = DrgAddStrHandle("DRM_CUSTOMER");
  277.            pdxfer->hstrRenderToName = DrgAddStrHandle(DRAGXFERMEMNAME);
  278.            pdxfer->ulTargetInfo = 0;
  279.            pdxfer->usOperation = DO_MOVE;
  280.  
  281.            // This is like a WinSendMsg except that it also does a DosGiveMem for the dragtransfer struct
  282.            rc = (ULONG)DrgSendTransferMsg(pdinfo->hwndSource, DM_RENDER, (MPARAM)pdxfer, NULL);
  283.  
  284.            
  285.            if(rc == TRUE)
  286.            {
  287.              AddCustomer(wd->hwndContainer, pxfercust, 10, 10);
  288.            }
  289.  
  290.            DrgFreeDraginfo(pdinfo);
  291.            DrgFreeDragtransfer(pdxfer);
  292.            DosFreeMem((PVOID)pxfercust);
  293.  
  294.            break;           
  295.  
  296.         default: ;
  297.       }
  298.       break;
  299.  
  300.  
  301.     case DM_RENDER:
  302.       pdxfer = (PDRAGTRANSFER)mp1;
  303.       pxferfromcust = &(((PCONTRECORD)(pdxfer->pditem->ulItemID))->cust);   //pointer to recordcore for dragged item
  304.  
  305.       DrgQueryStrName(pdxfer->hstrRenderToName, 100, dragxfermemname);  // get shared mem name
  306.        
  307.       DosGetNamedSharedMem((PPVOID)&pxfercust, dragxfermemname, PAG_WRITE | PAG_READ);
  308.       memcpy(pxfercust, pxferfromcust, sizeof(CUSTOMER));
  309.       DosFreeMem((PVOID)pxfercust);
  310.  
  311.       if(pdxfer->usOperation == DO_MOVE)      // if it's a move, remove the customer
  312.       {
  313.         RemoveCustomer(wd->hwndContainer, (PCONTRECORD)(pdxfer->pditem->ulItemID));
  314.       }
  315.  
  316.       return((MRESULT)TRUE);
  317.       break;
  318.    
  319.     case DM_PRINTOBJECT:         /* mp1 points to a DRAGITEM, mp2 to a PRINTDEST structure */
  320.       pditem = (PDRAGITEM)mp1;   /* PLEASE NOTE: there is an error in the online PM Reference */
  321.                                  /* which says that mp1 points to a DRAGINFO structure      */
  322.  
  323.       PrintCustomer((PCONTRECORD)(pditem->ulItemID), ((PPRINTDEST)mp2));
  324.  
  325.       return((MRESULT)DRR_SOURCE);      /* indicates that we will do the printing, */
  326.       break;                            /* rather than the printer object          */
  327.  
  328.  
  329.     case DM_DISCARDOBJECT:                       /* mp1 points to a DRAGINFO structure */
  330.       pdinfo = (PDRAGINFO)mp1;                   /* the item to be deleted             */
  331.       pditem = DrgQueryDragitemPtr(pdinfo, 0);
  332.  
  333.       RemoveCustomer((HWND)wd->hwndContainer, (PCONTRECORD)(pditem->ulItemID));
  334.  
  335.       return((MRESULT)DRR_SOURCE);               /* indicates that we take responsibility */
  336.       break;                                      /* for deleting the item                 */
  337.  
  338.  
  339.     case WM_COMMAND:
  340.       switch (SHORT1FROMMP(mp1))          /* test the command value from mp1 */
  341.       {
  342.         case ID_EXITPROG:
  343.           WinPostMsg( hwnd, WM_CLOSE, (MPARAM)0, (MPARAM)0 );
  344.           break;
  345.  
  346.         default:
  347.           return WinDefWindowProc(hwnd, msg, mp1, mp2);
  348.       }
  349.       break;
  350.  
  351.  
  352.     case WM_SIZE:
  353.       WinQueryWindowPos(hwnd, &swp);
  354.       WinSetWindowPos(wd->hwndContainer, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,  
  355.                       SWP_SIZE | SWP_SHOW); 
  356.       break;
  357.  
  358.     case WM_CLOSE:
  359.       WinPostMsg( hwnd, WM_QUIT, (MPARAM)0,(MPARAM)0 );     
  360.       break;
  361.    
  362.     case WM_DESTROY:
  363.       free(wd);
  364.       break;
  365.  
  366.     default:
  367.       return WinDefWindowProc(hwnd, msg, mp1, mp2);
  368.   }
  369.   return (MRESULT)FALSE;
  370. } 
  371.  
  372.  
  373. //***************************************************************************** */
  374. //
  375. //  Three utility functions used in program
  376. //
  377. //***************************************************************************** */
  378. void FillWindow(HWND hwndContainer)
  379. {
  380.   CUSTOMER cust;
  381.   FILE *finput;
  382.  
  383.   if((finput = fopen("dmcust.dat", "r")) != NULL)
  384.     while(fscanf(finput, "%s%s%s", cust.name, cust.address, cust.phone) == 3)
  385.     {
  386.       WinSendMsg(hwndContainer, CM_ALLOCRECORD,
  387.                                        (MPARAM)(sizeof(CONTRECORD) - sizeof(RECORDCORE)), (MPARAM)1);
  388.       AddCustomer(hwndContainer, &cust, 10, 10);
  389.     }
  390. }
  391.  
  392.  
  393. void AddCustomer(HWND hwndContainer, CUSTOMER* pcustomer, ULONG x, ULONG y)
  394. {
  395.   PCONTRECORD pcrec;
  396.   RECORDINSERT rci;
  397.  
  398.   pcrec = (PCONTRECORD)WinSendMsg(hwndContainer, CM_ALLOCRECORD,
  399.                                    (MPARAM)(sizeof(CONTRECORD) - sizeof(RECORDCORE)), (MPARAM)1);
  400.   pcrec->core.ptlIcon.x = x;  pcrec->core.ptlIcon.y = y;
  401.   pcrec->core.preccNextRecord = NULL;
  402.   
  403.   memcpy(&pcrec->cust, pcustomer, sizeof(CUSTOMER));
  404.   pcrec->core.pszIcon = pcrec->cust.name;
  405.   pcrec->core.hptrIcon = hptrCustIcon;
  406.   rci.cb = sizeof(RECORDINSERT);
  407.   rci.pRecordOrder = (PRECORDCORE)CMA_FIRST;
  408.   rci.pRecordParent = NULL;
  409.   rci.zOrder = CMA_TOP;
  410.   rci.cRecordsInsert = 1;
  411.   rci.fInvalidateRecord = TRUE;
  412.  
  413.   (ULONG)WinSendMsg(hwndContainer, CM_INSERTRECORD, (MPARAM)pcrec, (MPARAM)&rci);
  414. }
  415.  
  416. void RemoveCustomer(HWND container, PCONTRECORD pcrec)
  417. {
  418.   PRECORDCORE aprc[10];
  419.  
  420.   aprc[0] = &(pcrec->core);
  421.   WinSendMsg(container, CM_ERASERECORD, (MPARAM)&(pcrec->core), 0L);
  422.   WinSendMsg(container, CM_REMOVERECORD, (MPARAM)aprc, MPFROM2SHORT(1, CMA_FREE));
  423. }
  424.  
  425. void PrintCustomer(PCONTRECORD pcrec, PPRINTDEST pdest)
  426. {
  427.   // Here one should extract the print queue name from the PRINTDEST structure
  428.   // and use PM printing functions to print to that queue.  For sample PM
  429.   // printing code, please see the PRTSAMP toolkit sample.
  430.   //
  431.   // To keep this drag/drop sample simple we will will just copy the data to LPT1
  432.   // regardless of which print object the item was dropped on.
  433.  
  434.   FILE *fprt;
  435.   fprt = fopen("LPT1", "w");
  436.   fprintf(fprt, "\n\nCustomer name: %s\n         Address: %s\n         Phone: %s",
  437.                  pcrec->cust.name, pcrec->cust.address, pcrec->cust.phone);
  438.   fclose(fprt);
  439. }
  440.