home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / os2sdk / os2sdk12 / ddeml / msngr / bmap.c next >
Encoding:
C/C++ Source or Header  |  1990-06-22  |  14.0 KB  |  529 lines
  1. /****************************** MODULE Header ******************************\
  2. * Module Name:  bmap.c - Messenger application - bitmap module
  3. *
  4. * Created: 8/1/89  sanfords
  5. *
  6. * Copyright (c) 1988, 1989  Microsoft Corporation
  7. \***************************************************************************/
  8.  
  9. #include "msngr.h"
  10. #include "string.h"
  11. #ifdef SLOOP
  12. #define BITMAPINFOHEADER2 BITMAPINFOHEADER
  13. #define PBITMAPINFOHEADER2 PBITMAPINFOHEADER
  14. #define BITMAPINFO2 BITMAPINFO
  15. #define PBITMAPINFO2 PBITMAPINFO
  16. #endif
  17.  
  18. typedef struct _CDATA {
  19.     RECTL rcl;
  20.     HBITMAP hbm;
  21.     BOOL fSelect;
  22.     BOOL fSelecting;
  23.     NPUSERLIST npUL;
  24. } CDATA;
  25. typedef CDATA *NPCDATA;
  26.  
  27.  
  28. typedef struct _PKT {
  29.     HBITMAP hbm;
  30.     SHORT cx;
  31.     SHORT cy;
  32.     char szName[MAX_NAMESTR + 1];
  33. } PKT;
  34. typedef PKT *NPPKT;
  35.  
  36. extern HWND hwndMsngr;
  37. extern SHORT cyText;
  38. extern HAB hab;
  39. extern HSZ hszAppName;
  40. extern HSZ hszEmailName;
  41. extern char szEmailName[];
  42. extern HWND hwndLB;
  43. extern ITEMLIST msgTopicItemList[];
  44.  
  45.  
  46.  
  47. /*
  48.  * local procs
  49.  */
  50. MRESULT bmpInit(HWND hwnd, NPPKT ppktInit);
  51. MRESULT sndBmapInit(HWND hwnd, NPUSERLIST pUserItem);
  52. BOOL sndBmap(NPCDATA pcd);
  53. HBITMAP SnapRegion(HPS hps, PRECTL prcl);
  54. void DrawRgn(HPS hps, PRECTL prcl);
  55. void SortRect(PRECTL prcl, PRECTL prclSorted);
  56. HDC CreateDC(PSZ lpszDriver, HDC hdcCompat);
  57.  
  58. #define max(a,b)    (((a) > (b)) ? (a) : (b))
  59.  
  60. /*
  61.  * file globals
  62.  */
  63. ATOM fmtBmapPkt;
  64. HPOINTER hptrSelBmap = 0;
  65. HPOINTER hptrBmap = 0;
  66.  
  67. void InitBmapModule()
  68. {
  69.     fmtBmapPkt = WinAddAtom(WinQuerySystemAtomTable(), SZBMAPDATA);
  70.     hptrSelBmap = WinLoadPointer(HWND_DESKTOP, (HMODULE)NULL, IDR_SELBMAP);
  71.     hptrBmap = WinLoadPointer(HWND_DESKTOP, NULL, IDD_GETBITMAP);
  72. } 
  73.  
  74. void CloseBmapModule()
  75. {
  76.     WinDeleteAtom(WinQuerySystemAtomTable(), fmtBmapPkt);
  77.     WinDestroyPointer(hptrSelBmap);
  78.     WinDestroyPointer(hptrBmap);
  79. }
  80.  
  81. HDMGDATA bmpXfer(pXferInfo)
  82. PXFERINFO pXferInfo;
  83. {
  84.     PBYTE pbuf;
  85.     PKT pkt;
  86.     PBITMAPINFO pbmi;
  87.     HDC hdc;
  88.     HPS hpsMem;
  89.     SIZEL size;
  90.  
  91.     if (pXferInfo->usFmt != fmtBmapPkt)
  92.         return(DDE_NOTPROCESSED);
  93.  
  94.     if (pXferInfo->usType == XTYP_POKE) {
  95.         /*
  96.          * we have bitmap bits...stick them into pkt.hbm.
  97.          */
  98.         pbuf = DdeAccessData(pXferInfo->hDmgData);
  99.         
  100.         DdeCopyBlock(pbuf, (PBYTE)&pkt.szName[0], MAX_NAMESTR + 1L);
  101.         pbmi = (PBITMAPINFO)(pbuf + MAX_NAMESTR + 1);
  102.  
  103.         pkt.cx = pbmi->cx;
  104.         pkt.cy = pbmi->cy;
  105.         size.cx = (LONG)pkt.cx;
  106.         size.cy = (LONG)pkt.cy;
  107.         hdc = CreateDC((PSZ)"MEMORY", (HDC)NULL);
  108.         hpsMem = GpiCreatePS(hab, hdc, &size,
  109.                 PU_ARBITRARY | GPIT_NORMAL | GPIA_ASSOC );
  110.         pkt.hbm = GpiCreateBitmap(hpsMem, (PBITMAPINFOHEADER2)pbmi, CBM_INIT,
  111.                 (PBYTE)&pbmi->argbColor[1 << pbmi->cBitCount],
  112.                 (PBITMAPINFO2)pbmi);
  113.         GpiAssociate(hpsMem, NULL);
  114.         GpiDestroyPS(hpsMem);
  115.         DevCloseDC(hdc);
  116.         DdeFreeData(pXferInfo->hDmgData);
  117.         
  118.         WinLoadDlg(HWND_DESKTOP, hwndMsngr, BmpDlgProc, 0L, IDD_GETBITMAP,
  119.                 (PVOID)&pkt);
  120.         return(1);
  121.     }
  122.     return(0);
  123. }
  124.  
  125.  
  126. /*
  127.  * This is the proc used for receiving a bitmap
  128.  */
  129. MRESULT EXPENTRY BmpDlgProc(hwnd, msg, mp1, mp2)
  130. HWND hwnd;
  131. USHORT msg;
  132. MPARAM mp1;
  133. MPARAM mp2;
  134. {
  135.     HBITMAP hbm;
  136.     HPS hps;
  137.     WRECT wrc;
  138.     
  139.     switch(msg) {
  140.     case WM_INITDLG:
  141.         return(bmpInit(hwnd, (NPPKT)(SHORT)mp2));
  142.         break;
  143.  
  144.     case WM_DESTROY:
  145.         if (hbm = ((NPPKT)WinQueryWindowUShort(hwnd, QWS_USER))->hbm)
  146.             GpiDeleteBitmap(hbm);
  147.         WinFreeMem(hheap, (NPBYTE)WinQueryWindowUShort(hwnd, QWS_USER),
  148.                 sizeof(PKT));
  149.         break;
  150.  
  151.     case WM_WINDOWPOSCHANGED:
  152.         /*
  153.          * hide the OK button when minimized since it messes up the icon.
  154.          */
  155.         if ((LONG)mp2 & AWP_MINIMIZED)
  156.             WinShowWindow(WinWindowFromID(hwnd, MBID_OK), FALSE);
  157.         else if ((LONG)mp2 & AWP_RESTORED)
  158.             WinShowWindow(WinWindowFromID(hwnd, MBID_OK), TRUE);
  159.         return(WinDefDlgProc(hwnd, msg, mp1, mp2));
  160.         break;
  161.  
  162.     case WM_COMMAND:
  163.         WinDestroyWindow(hwnd);
  164.         break;
  165.         
  166.     case WM_PAINT:
  167.         WinDefDlgProc(hwnd, msg, mp1, mp2);
  168.         /*
  169.          * draw the bitmap just above the OK button.
  170.          */
  171.         hps = WinGetPS(hwnd);
  172.         WinQueryWindowRect(WinWindowFromID(hwnd, MBID_OK), (PRECTL)&wrc);
  173.         WinMapWindowPoints(WinWindowFromID(hwnd, MBID_OK), hwnd, (PPOINTL)&wrc, 2);
  174.         wrc.yBottom = wrc.yTop + cyText / 2;
  175.         hbm = ((NPPKT)WinQueryWindowUShort(hwnd, QWS_USER))->hbm;
  176.         WinDrawBitmap(hps, hbm, (PRECTL)NULL, (PPOINTL)&wrc, 0L, 0L, DBM_NORMAL);
  177.         WinReleasePS(hps);
  178.         break;
  179.  
  180.     default:
  181.         return(WinDefDlgProc(hwnd, msg, mp1, mp2));
  182.     }
  183.     return(0);
  184. }
  185.  
  186.  
  187. MRESULT bmpInit(hwnd, ppktInit)
  188. HWND hwnd;
  189. NPPKT ppktInit;
  190. {
  191.     char szTitle[MAX_TITLESTR];
  192.     WRECT wrc;
  193.     NPPKT ppkt;
  194.     SHORT cxMin;
  195.  
  196.     if (!(ppkt = (NPPKT)WinAllocMem(hheap, sizeof(PKT))))
  197.         return(1);    
  198.     *ppkt = *ppktInit;
  199.     WinSetWindowUShort(hwnd, QWL_USER, (USHORT)ppkt);
  200.     /*
  201.      * This is required because currently, automatic ICON resource loading
  202.      * is not supported for dialogs.
  203.      */
  204.     WinSendMsg(hwnd, WM_SETICON, (MPARAM)hptrBmap, 0L);
  205.     /*
  206.      * Set up title.
  207.      */
  208.     WinQueryWindowText(hwnd, MAX_TITLESTR, (PSZ)szTitle);
  209.     lstrcat(szTitle, szTitle, ppkt->szName);
  210.     WinSetWindowText(hwnd, (PSZ)szTitle);
  211.     /*
  212.      * resize the dialog so the bitmap just fits.
  213.      */
  214.     WinQueryWindowRect(hwnd, (PRECTL)&wrc);
  215.     cxMin = wrc.xRight;
  216.     WinQueryWindowRect(WinWindowFromID(hwnd, MBID_OK), (PRECTL)&wrc);
  217.     WinMapWindowPoints(WinWindowFromID(hwnd, MBID_OK), hwnd, (PPOINTL)&wrc, 2);
  218.     WinSetWindowPos(hwnd, NULL, 0, 0, max(wrc.xLeft * 2 + ppkt->cx, cxMin),
  219.             wrc.yTop + ppkt->cy + cyText +
  220.             (SHORT)WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR), SWP_SIZE);
  221.     return(0);
  222. }
  223.  
  224.  
  225.  
  226. MRESULT EXPENTRY SendBitmapDlgProc(hwnd, msg, mp1, mp2)
  227. HWND hwnd;
  228. USHORT msg;
  229. MPARAM mp1;
  230. MPARAM mp2;
  231. {
  232.     NPCDATA pcd;
  233.     POINTL pt;
  234.     HPS hps;
  235.  
  236.     pcd = (NPCDATA)WinQueryWindowUShort(hwnd, QWS_USER);
  237.     
  238.     switch (msg) {
  239.     case WM_INITDLG:
  240.         return(sndBmapInit(hwnd, (NPUSERLIST)(SHORT)mp2));
  241.         break;
  242.  
  243.     case WM_DESTROY:
  244.         WinFreeMem(hheap, (NPBYTE)pcd, sizeof(CDATA));
  245.         break;
  246.         
  247.     case WM_COMMAND:
  248.         switch (LOUSHORT(mp1)) {
  249.         case IDC_SENDBITMAP:
  250.             if (sndBmap(pcd))
  251.                 WinDismissDlg(hwnd, 0);
  252.             break;
  253.             
  254.         case MBID_CANCEL:                    
  255.             WinDismissDlg(hwnd, 0);
  256.             break;
  257.             
  258.         case IDC_SELECT:
  259.             pcd->fSelect = TRUE;
  260.             WinSetCapture(HWND_DESKTOP, hwnd);
  261.             break;
  262.         }
  263.         break;
  264.  
  265.     case WM_BUTTON1DOWN:
  266.         if (pcd->fSelect) {
  267.             if (pcd->hbm) {
  268.                 GpiDeleteBitmap(pcd->hbm);
  269.                 pcd->hbm = NULL;
  270.             }
  271.             WinSetRect(hab, &pcd->rcl, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1),
  272.                     SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
  273.             WinMapWindowPoints(hwnd, (HWND)HWND_DESKTOP, (PPOINTL)&pcd->rcl, 2);
  274.             hps = WinGetScreenPS(HWND_DESKTOP);
  275.             DrawRgn(hps, &pcd->rcl);
  276.             WinReleasePS(hps);
  277.             pcd->fSelecting = TRUE;
  278.         }
  279.         break;
  280.  
  281.     case WM_MOUSEMOVE:
  282.         if (pcd->fSelect) {
  283.             WinSetPointer(HWND_DESKTOP, hptrSelBmap);
  284.         } else {
  285.             WinSetPointer(HWND_DESKTOP,
  286.                     WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
  287.         }
  288.         if (pcd->fSelecting) {
  289.             hps = WinGetScreenPS(HWND_DESKTOP);
  290.             DrawRgn(hps, &pcd->rcl);    /* erase old rect */
  291.             pt.x = SHORT1FROMMP(mp1);
  292.             pt.y = SHORT2FROMMP(mp1);
  293.             WinMapWindowPoints(hwnd, HWND_DESKTOP, &pt, 1);
  294.             pcd->rcl.xRight = pt.x;
  295.             pcd->rcl.yTop = pt.y;
  296.             DrawRgn(hps, &pcd->rcl);    /* draw new one */
  297.             WinReleasePS(hps);
  298.         }
  299.         break;
  300.  
  301.     case WM_BUTTON1UP:
  302.         if (pcd->fSelecting) {
  303.             WinSetCapture(HWND_DESKTOP, (HWND)NULL);
  304.             hps = WinGetScreenPS(HWND_DESKTOP);
  305.             DrawRgn(hps, &pcd->rcl);
  306.             pcd->hbm = SnapRegion(hps, &pcd->rcl);
  307.             WinReleasePS(hps);
  308.             pcd->fSelecting = FALSE;
  309.             pcd->fSelect = FALSE;
  310.             WinEnableWindow(WinWindowFromID(hwnd, IDC_SENDBITMAP),
  311.                     !WinIsRectEmpty(hab, &pcd->rcl));
  312.         }
  313.         break;
  314.  
  315.         
  316.     default:
  317.         return(WinDefDlgProc(hwnd, msg, mp1, mp2));
  318.         break;
  319.     }
  320.     return(0);
  321. }
  322.  
  323.  
  324. /*
  325.  * returns fFailed
  326.  */
  327. MPARAM sndBmapInit(hwnd, pUserItem)
  328. HWND hwnd;
  329. NPUSERLIST pUserItem;
  330. {
  331.     NPCDATA pcd;
  332.     char szTitle[MAX_TITLESTR];
  333.     char szName[MAX_NAMESTR];
  334.     
  335.     if (!(pcd = (NPCDATA)WinAllocMem(hheap, sizeof(CDATA))))
  336.         return(1);
  337.     WinSetRectEmpty(hab, &pcd->rcl);
  338.     pcd->hbm = NULL;
  339.     pcd->fSelect = FALSE;
  340.     pcd->fSelecting = FALSE;
  341.     pcd->npUL = pUserItem;
  342.     if (pcd->npUL->hConvMsg == NULL) {
  343.         NotifyUser(SZCANTCONNECT);
  344.         return(1);
  345.     }
  346.     WinQueryWindowText(hwnd, MAX_TITLESTR, szTitle);
  347.     DdeGetHszString(pcd->npUL->hsz, szName, (LONG)MAX_NAMESTR);
  348.     lstrcat(szTitle, szTitle, szName);
  349.     WinSetWindowText(hwnd, (PSZ)szTitle);
  350.     WinSetWindowUShort(hwnd, QWS_USER, (USHORT)pcd);
  351.     return(0);
  352. }
  353.  
  354.  
  355. BOOL sndBmap(pcd)
  356. NPCDATA pcd;
  357. {
  358.     BITMAPINFOHEADER bih;
  359.     SHORT cbBuffer, cbBitmapInfo;
  360.     PBYTE pbBuffer;
  361.     PBITMAPINFO pbmi;
  362.     PSZ pszName;
  363.     SEL sel;
  364.     HPS hps;
  365.     HDC hdc;
  366.     SIZEL size;
  367.     
  368.     /*
  369.      * Compute the size of the image-data buffer and the bitmap information
  370.      * structure.
  371.      */
  372.     GpiQueryBitmapParameters(pcd->hbm, &bih);
  373.     cbBuffer = (((bih.cBitCount * bih.cx) + 31) / 32) * 4;
  374.     if (cbBuffer > 0xFFFF / bih.cy / bih.cPlanes) {
  375.         NotifyUser(SZTOOBIG);
  376.         return(FALSE);
  377.     }
  378.     cbBuffer *= bih.cy * bih.cPlanes;
  379.     cbBitmapInfo = sizeof(BITMAPINFO) +
  380.         (sizeof(RGB) * (1 << bih.cBitCount));
  381.     
  382.     /*
  383.      * Allocate memory for the image data-buffer and the bitmap information
  384.      * structure.
  385.      */
  386.     DosAllocSeg(cbBuffer + cbBitmapInfo + MAX_NAMESTR + 1, &sel, 0);
  387.     pszName = (PSZ)MAKEP(sel, 0);
  388.     lstrcpy(pszName, szEmailName);
  389.     pbmi = (PBITMAPINFO)(pszName + MAX_NAMESTR + 1);
  390.     pbBuffer = (PBYTE)&pbmi->argbColor[1 << bih.cBitCount];
  391.     *(PBITMAPINFOHEADER)pbmi = bih;
  392.  
  393.     size.cx = (LONG)bih.cx;
  394.     size.cy = (LONG)bih.cy;
  395.     hdc = CreateDC((PSZ)"MEMORY", (HDC)NULL);
  396.     hps = GpiCreatePS(hab, hdc, &size,
  397.             PU_ARBITRARY | GPIT_NORMAL | GPIA_ASSOC );
  398.     GpiSetBitmap(hps, pcd->hbm);
  399.     GpiQueryBitmapBits(hps, 0L, (LONG)bih.cy, (PBYTE)pbBuffer,
  400.             (PBITMAPINFO2)pbmi);
  401.     GpiAssociate(hps, NULL);
  402.     GpiDestroyPS(hps);
  403.     DevCloseDC(hdc);
  404.  
  405.     if (!DdeClientXfer(pszName,
  406.             (LONG)(cbBuffer + cbBitmapInfo + MAX_NAMESTR + 1),
  407.             pcd->npUL->hConvMsg,
  408.             msgTopicItemList[IIL_BMPXFER].hszItem,
  409.             fmtBmapPkt, XTYP_POKE, ulTimeout, 0L)) {
  410.         MyPostError(DdeGetLastError());
  411.     }
  412.  
  413.     DosFreeSeg(sel);
  414.     GpiDeleteBitmap(pcd->hbm);
  415.     pcd->hbm = NULL;
  416.     WinSetRectEmpty(hab, &pcd->rcl);
  417.     return(TRUE);
  418. }
  419.  
  420.  
  421. HBITMAP SnapRegion(hps, prcl)
  422. HPS hps;
  423. PRECTL prcl;
  424. {
  425.     HDC hdc;
  426.     HBITMAP hbm, hbmOld;
  427.     BITMAPINFOHEADER bih;
  428.     POINTL rgpt[3];
  429.     HPS hpsMem;
  430.     SIZEL size;
  431.  
  432.     SortRect(prcl, prcl);
  433.     WinInflateRect(hab, prcl, -1, -1);
  434.  
  435.     size.cx = (USHORT)(prcl->xRight - prcl->xLeft);
  436.     size.cy = (USHORT)(prcl->yTop - prcl->yBottom);
  437.  
  438.     /* Create a memory DC */
  439.     hdc = CreateDC((PSZ)"MEMORY", (HDC)NULL);
  440.  
  441.     /* create a memory PS */
  442.     hpsMem = GpiCreatePS(hab, hdc, &size,
  443.             PU_ARBITRARY | GPIT_NORMAL | GPIA_ASSOC );
  444.  
  445.     /* Create a bitmap */
  446.     bih.cbFix = sizeof(BITMAPINFOHEADER);
  447.     bih.cx = (SHORT)size.cx;
  448.     bih.cy = (SHORT)size.cy;
  449.     bih.cPlanes = 1;
  450.     bih.cBitCount = 8;
  451.     hbm = GpiCreateBitmap(hpsMem, (PBITMAPINFOHEADER2)&bih, 0L, 0, 0);
  452.     if (hbm == GPI_ERROR) 
  453.         return(0);
  454.     
  455.     /* put the bitmap into the memory PS */
  456.     hbmOld = GpiSetBitmap(hpsMem, hbm);
  457.  
  458.     /* copy the window to the memory PS */
  459.     rgpt[0].x = 0;
  460.     rgpt[0].y = 0;
  461.     rgpt[1].x = size.cx;
  462.     rgpt[1].y = size.cy;
  463.     rgpt[2].x = prcl->xLeft;
  464.     rgpt[2].y = prcl->yBottom;
  465.     GpiBitBlt(hpsMem, hps, 3L, (PPOINTL)&rgpt[0], ROP_SRCCOPY, 0L);
  466.  
  467.     /* free the bitmap */
  468.     GpiSetBitmap(hpsMem, hbmOld);
  469.  
  470.     /* destroy the memory DC */
  471.     GpiAssociate(hpsMem, NULL);
  472.     GpiDestroyPS(hpsMem);
  473.     DevCloseDC(hdc);
  474.     return(hbm);
  475. } /* end snapregion */
  476.  
  477.  
  478. HDC CreateDC(lpszDriver, hdcCompat)
  479. PSZ  lpszDriver;
  480. HDC hdcCompat;
  481. {
  482.     struct {
  483.         ULONG FAR *lpLogAddr;
  484.         PSZ  lpszDriver;
  485.     } opendc;
  486.  
  487.     opendc.lpLogAddr = NULL;
  488.     opendc.lpszDriver = lpszDriver;
  489.  
  490.     return((HDC)DevOpenDC(hab, OD_MEMORY, (PSZ)"*", 2L,
  491.             (PDEVOPENDATA)&opendc, hdcCompat));
  492. }
  493.  
  494.  
  495. void DrawRgn(hps, prcl)
  496. HPS hps;
  497. PRECTL prcl;
  498. {
  499.     RECTL rclSorted;
  500.     
  501.     SortRect(prcl, &rclSorted);
  502.     WinDrawBorder(hps, &rclSorted, 1, 1, SYSCLR_WINDOW, SYSCLR_WINDOW,
  503.             DB_DESTINVERT | DB_STANDARD);
  504. }
  505.  
  506. void SortRect(prcl, prclSorted)
  507. PRECTL prcl;
  508. PRECTL prclSorted;
  509. {
  510.     LONG l;
  511.  
  512.     WinCopyRect(hab, prclSorted, prcl);
  513.     if (prclSorted->yTop < prclSorted->yBottom) {
  514.         l = prclSorted->yBottom;
  515.         prclSorted->yBottom = prclSorted->yTop;
  516.         prclSorted->yTop = l;
  517.     }
  518.     
  519.     if (prclSorted->xRight < prclSorted-> xLeft) {
  520.         l = prclSorted->xRight;
  521.         prclSorted->xRight = prclSorted->xLeft;
  522.         prclSorted->xLeft = l;
  523.     }
  524. }
  525.  
  526.  
  527.  
  528.  
  529.