home *** CD-ROM | disk | FTP | other *** search
/ Best Tools for JAVA / Best Tools for JAVA.iso / POSTSCPT / GSVIEW / SRC / GVWCLIP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-01  |  10.1 KB  |  336 lines
  1. /* Copyright (C) 1993, 1994, Russell Lang.  All rights reserved.
  2.   
  3.   This file is part of GSview.
  4.   
  5.   This program is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the GSview Free Public Licence 
  9.   (the "Licence") for full details.
  10.   
  11.   Every copy of GSview must include a copy of the Licence, normally in a 
  12.   plain ASCII text file named LICENCE.  The Licence grants you the right 
  13.   to copy, modify and redistribute GSview, but only under certain conditions 
  14.   described in the Licence.  Among other things, the Licence requires that 
  15.   the copyright notice and this notice be preserved on all copies.
  16. */
  17.  
  18. /* gvwclip.c */
  19. /* Clipboard module for Windows GSview */
  20. #include "gvwin.h"
  21.  
  22. long hugewrite(HFILE hf, const void _huge *hpvBuffer, long cbBuffer);  /* in gvweps.c */
  23. void paste_to_file(void);
  24. void clip_convert(void);
  25. void clip_add_palette(void);
  26. void clip_add_ddb(void);
  27. void clip_add_dib(void);
  28.  
  29. /* copy a DIB from the clipboard to a file */
  30. void
  31. paste_to_file(void)
  32. {
  33. HGLOBAL hglobal;
  34. LPBITMAPINFOHEADER pbmih;
  35. BITMAPFILEHEADER bmfh;
  36. UINT palcolors;
  37. UINT palsize;
  38. DWORD bitmap_size;
  39. BYTE _huge *lpBits;
  40. static char output[MAXSTR];
  41. HFILE hfile;
  42.     if (!OpenClipboard(hwndimg)) {
  43.         play_sound(SOUND_ERROR);
  44.         return;
  45.     }
  46.     if (!IsClipboardFormatAvailable(CF_DIB)) {
  47.         CloseClipboard();
  48.         play_sound(SOUND_ERROR);
  49.         return;
  50.     }
  51.     hglobal = (HGLOBAL)GetClipboardData(CF_DIB);
  52.     pbmih = (LPBITMAPINFOHEADER)GlobalLock(hglobal);
  53.     palcolors = dib_pal_colors((LPBITMAP2)pbmih);
  54.     if (pbmih->biSize == sizeof(BITMAPCOREHEADER))
  55.         palsize = palcolors * sizeof(RGBTRIPLE); 
  56.     else
  57.         palsize = palcolors * sizeof(RGBQUAD);
  58.     bitmap_size = (DWORD)pbmih->biHeight *  dib_bytewidth((LPBITMAP2)pbmih);
  59.  
  60.     bmfh.bfType = ('M'<<8) | 'B';
  61.     bmfh.bfReserved1 = 0;
  62.     bmfh.bfReserved2 = 0;
  63.     bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + pbmih->biSize + palsize;
  64.     bmfh.bfSize = bmfh.bfOffBits + bitmap_size;
  65.  
  66.     if ( get_filename(output, TRUE, FILTER_BMP, NULL, IDS_TOPICEDIT)
  67.         && ((hfile = _lcreat(output, 0)) != HFILE_ERROR) ) {
  68.         hugewrite(hfile, &bmfh, sizeof(BITMAPFILEHEADER));
  69.         hugewrite(hfile, pbmih, pbmih->biSize + palsize);
  70.         lpBits =  ((BYTE _huge *)pbmih) + pbmih->biSize + palsize;
  71.         hugewrite(hfile, lpBits, bitmap_size);
  72.         _lclose(hfile);
  73.     }
  74.     GlobalUnlock(hglobal);
  75.     CloseClipboard();
  76. }
  77.  
  78. /* convert bitmap (DIB or DDB) in clipboard to */
  79. /* CF_DIB, CF_BITMAP and CF_PALETTE */
  80. void
  81. clip_convert(void)
  82. {
  83.     if (!OpenClipboard(hwndimg)) {
  84.         play_sound(SOUND_ERROR);
  85.         return;
  86.     }
  87.     if (IsClipboardFormatAvailable(CF_DIB)) {
  88.         if (!IsClipboardFormatAvailable(CF_PALETTE))
  89.         clip_add_palette();
  90.         if (!IsClipboardFormatAvailable(CF_BITMAP))
  91.             clip_add_ddb();
  92.     }
  93.     else {
  94.         if (IsClipboardFormatAvailable(CF_BITMAP)) {
  95.         clip_add_dib();
  96.             if (!IsClipboardFormatAvailable(CF_PALETTE))
  97.             clip_add_palette();
  98.         }
  99.         else 
  100.         play_sound(SOUND_ERROR);
  101.     }
  102.     CloseClipboard();
  103. }
  104.  
  105. /* Read DIB from the clipboard, create PALETTE and add to clipboard */
  106. void
  107. clip_add_palette(void)
  108. {
  109. HGLOBAL hglobal;
  110. LPBITMAPINFOHEADER pbmih;
  111. UINT palcolors;
  112. UINT palsize;
  113. int i;
  114. LPLOGPALETTE logpalette;
  115. HPALETTE hpalette;
  116. RGBQUAD FAR *prgbquad;
  117. RGBTRIPLE FAR *prgbtriple;
  118.  
  119.     if (!IsClipboardFormatAvailable(CF_DIB)) {
  120.         play_sound(SOUND_ERROR);
  121.         return;
  122.     }
  123.     hglobal = (HGLOBAL)GetClipboardData(CF_DIB);
  124.     pbmih = (LPBITMAPINFOHEADER)GlobalLock(hglobal);
  125.     palcolors = dib_pal_colors((LPBITMAP2)pbmih);
  126.     if (pbmih->biSize == sizeof(BITMAPCOREHEADER))
  127.         palsize = palcolors * sizeof(RGBTRIPLE); 
  128.     else
  129.         palsize = palcolors * sizeof(RGBQUAD);
  130.     hpalette = (HPALETTE)NULL;
  131.     if (palsize) {
  132.         /* create palette to match DIB */
  133.         logpalette = (LPLOGPALETTE) malloc( sizeof(LOGPALETTE) + 
  134.         palcolors * sizeof(PALETTEENTRY) );
  135.         if (logpalette == (LPLOGPALETTE)NULL) {
  136.         GlobalUnlock(hglobal);
  137.         play_sound(SOUND_ERROR);
  138.         return;
  139.         }
  140.         logpalette->palVersion = 0x300;
  141.         logpalette->palNumEntries = (WORD)palcolors;
  142.         prgbquad = (RGBQUAD FAR *)(((BYTE _huge *)pbmih) + pbmih->biSize);
  143.         if (pbmih->biSize == sizeof(BITMAPCOREHEADER)) {
  144.         /* OS2 format */
  145.             prgbtriple = (RGBTRIPLE FAR *)prgbquad;
  146.             for (i=0; i<palcolors; i++) {
  147.                 logpalette->palPalEntry[i].peFlags = 0;
  148.             logpalette->palPalEntry[i].peRed   = prgbtriple[i].rgbtRed;
  149.             logpalette->palPalEntry[i].peGreen = prgbtriple[i].rgbtGreen;
  150.             logpalette->palPalEntry[i].peBlue  = prgbtriple[i].rgbtBlue;
  151.             }
  152.         }
  153.         else {
  154.         /* Windows Format */
  155.             for (i=0; i<palcolors; i++) {
  156.                 logpalette->palPalEntry[i].peFlags = 0;
  157.             logpalette->palPalEntry[i].peRed   = prgbquad[i].rgbRed;
  158.             logpalette->palPalEntry[i].peGreen = prgbquad[i].rgbGreen;
  159.             logpalette->palPalEntry[i].peBlue  = prgbquad[i].rgbBlue;
  160.             }
  161.         }
  162.         hpalette = CreatePalette(logpalette);
  163.         free((void *)logpalette);
  164.         SetClipboardData(CF_PALETTE, hpalette);
  165.     }
  166.     GlobalUnlock(hglobal);
  167. }
  168.  
  169.  
  170. /* Read DIB from the clipboard, convert to DDB and add to clipboard */
  171. void
  172. clip_add_ddb(void)
  173. {
  174. HGLOBAL hglobal;
  175. LPBITMAPINFOHEADER pbmih;
  176. UINT palcolors;
  177. UINT palsize;
  178. HPALETTE hpalette;
  179. HDC hdc;
  180. HBITMAP hbitmap;
  181.  
  182.     hglobal = (HGLOBAL)GetClipboardData(CF_DIB);
  183.     pbmih = (LPBITMAPINFOHEADER)GlobalLock(hglobal);
  184.     palcolors = dib_pal_colors((LPBITMAP2)pbmih);
  185.     if (pbmih->biSize == sizeof(BITMAPCOREHEADER))
  186.         palsize = palcolors * sizeof(RGBTRIPLE); 
  187.     else
  188.         palsize = palcolors * sizeof(RGBQUAD);
  189.  
  190.     hdc = GetDC(hwndimg);
  191.     hpalette = GetClipboardData(CF_PALETTE);
  192.     if (hpalette) {
  193.         SelectPalette(hdc,hpalette,NULL);
  194.         RealizePalette(hdc);
  195.     }
  196.     hbitmap = CreateDIBitmap(hdc, pbmih, CBM_INIT,
  197.         ((BYTE _huge *)pbmih) + pbmih->biSize + palsize,
  198.         (LPBITMAPINFO)pbmih, DIB_RGB_COLORS);
  199.     ReleaseDC(hwndimg, hdc);
  200.     GlobalUnlock(hglobal);
  201.     SetClipboardData(CF_BITMAP, hbitmap);
  202. }
  203.  
  204. /* make a DIB from a BITMAP in the clipboard */
  205. /* GetDIBits won't work for 4 plane or 4 bit/pixel bitmaps */
  206. /* clipboard must be open */
  207. HGLOBAL 
  208. make_dib(void)
  209. {
  210. LPBITMAPINFOHEADER pbmih;
  211. LPBITMAPINFO pbmi;
  212. BYTE FAR *lpBits;
  213. HBITMAP hbitmap;
  214. UINT palcolors;
  215. UINT palsize;
  216. UINT byte_width;
  217. DWORD bitmap_size;
  218. HGLOBAL hglobal;
  219. HDC hdc;
  220. HDC hdc_bit;
  221. BITMAP bm;
  222. PALETTEENTRY *pe;
  223. int i;
  224.     hbitmap = GetClipboardData(CF_BITMAP);
  225.     hdc = GetDC((HWND)NULL);
  226.     hdc_bit = CreateCompatibleDC(hdc);
  227.     ReleaseDC((HWND)NULL,hdc);
  228.     GetObject(hbitmap, sizeof(BITMAP), &bm);
  229.     if (bm.bmPlanes == 4) {
  230.         HBITMAP hbitmap_new, hbitmap_old;
  231.         HDC hdc_new;
  232.         /* convert format to 1 plane, 1 bit/pixel */ 
  233.         bm.bmPlanes = 1;
  234.         bm.bmBitsPixel = 1;
  235.         hdc_new = CreateCompatibleDC(hdc_bit);
  236.         hbitmap_new = CreateBitmap(bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel, NULL);
  237.         SelectBitmap(hdc_new, hbitmap_new);
  238.         hbitmap_old = SelectBitmap(hdc_bit, hbitmap);
  239.         BitBlt(hdc_new, 0, 0, bm.bmWidth, bm.bmHeight, hdc_bit, 0, 0, SRCCOPY);
  240.         SelectBitmap(hdc_bit, hbitmap_old);
  241.         DeleteDC(hdc_new);
  242.         hbitmap = hbitmap_new;
  243.     }
  244.      byte_width = (((bm.bmWidth * bm.bmBitsPixel + 31) & ~31) >> 3);
  245.     bitmap_size = (DWORD)bm.bmHeight *  byte_width;
  246.     palcolors = 1<<(bm.bmBitsPixel * bm.bmPlanes);
  247.     palsize = palcolors * sizeof(RGBQUAD);
  248.     hglobal = GlobalAlloc(GHND, sizeof(BITMAPINFOHEADER) + palsize + bitmap_size);
  249.     if (hglobal != (HGLOBAL)NULL) {
  250.         lpBits = GlobalLock(hglobal);
  251.         pbmi = (LPBITMAPINFO)lpBits;
  252.         pbmih = (LPBITMAPINFOHEADER)lpBits;
  253.         lpBits += sizeof(BITMAPINFOHEADER) + palsize;
  254.         pbmih->biSize = sizeof(BITMAPINFOHEADER);
  255.         pbmih->biWidth = bm.bmWidth;
  256.         pbmih->biHeight = bm.bmHeight;
  257.         pbmih->biPlanes = 1;
  258.         pbmih->biBitCount = (WORD)(bm.bmBitsPixel * bm.bmPlanes);
  259.         pbmih->biCompression = BI_RGB;
  260.         pbmih->biSizeImage = bitmap_size;
  261.         pbmih->biXPelsPerMeter = (int)(option.xdpi / 25.4 * 1000);
  262.         pbmih->biYPelsPerMeter = (int)(option.ydpi / 25.4 * 1000);
  263.         pbmih->biClrUsed = palcolors;
  264.         pbmih->biClrImportant = palcolors;
  265.         /* create colour table from system palette */
  266.         pe = malloc(palcolors * sizeof(PALETTEENTRY));
  267.         if (IsClipboardFormatAvailable(CF_PALETTE)) {
  268.         HPALETTE hpalette = GetClipboardData(CF_PALETTE);
  269.         i = GetObject(hpalette, sizeof(int), pe);
  270.         GetPaletteEntries(hpalette, 0, i, pe);
  271.         }
  272.         else
  273.             GetSystemPaletteEntries(hdc_bit, 0, palcolors, pe);
  274.         for (i=0; i<palcolors; i++) {
  275.         pbmi->bmiColors[i].rgbRed = pe[i].peRed;
  276.         pbmi->bmiColors[i].rgbGreen = pe[i].peGreen;
  277.         pbmi->bmiColors[i].rgbBlue = pe[i].peBlue;
  278.         pbmi->bmiColors[i].rgbReserved = 0;
  279.         }
  280.         free((void *)pe);
  281.         i = GetDIBits(hdc_bit, hbitmap, 0, (UINT)pbmih->biHeight,
  282.         lpBits, pbmi, DIB_RGB_COLORS);
  283.         GlobalUnlock(hglobal);
  284.         if (i == 0) {
  285.         GlobalFree(hglobal);
  286.         hglobal = NULL;
  287.         }
  288.     }
  289.     DeleteDC(hdc_bit);
  290.     if (hbitmap != GetClipboardData(CF_BITMAP))
  291.         DeleteBitmap(hbitmap);
  292.     return hglobal;
  293. }
  294.  
  295. /* Read DDB from the clipboard, convert to DIB and add to clipboard */
  296. void
  297. clip_add_dib(void)
  298. {
  299. HGLOBAL hglobal;
  300.     hglobal = make_dib();
  301.     if (hglobal != (HGLOBAL)NULL)
  302.             SetClipboardData(CF_DIB, hglobal);
  303. }
  304.  
  305. #ifdef NOT_USED
  306. /* not used */
  307. /* Read bitmap (CF_DIB or CF_BITMAP) from the clipboard */
  308. /* convert to Metafile Picture and add to clipboard */
  309. void
  310. clip_add_metafile(void)
  311. {
  312. LPMETAFILEPICT lpmfp;
  313. HGLOBAL hglobal;
  314. HMETAFILE hmf;
  315.     if ( (hmf = make_metafile()) == (HMETAFILE)NULL ) {
  316.         return;
  317.     }
  318.  
  319.     hglobal = GlobalAlloc(GHND | GMEM_SHARE, sizeof(METAFILEPICT)); 
  320.     lpmfp = GlobalLock(hglobal);
  321.     lpmfp->mm = MM_ANISOTROPIC;
  322.     if (bitmap_width)
  323.         lpmfp->xExt = (int)(bitmap_width / xdpi * 2540);
  324.     else 
  325.         lpmfp->xExt = 21000;    /* A4 */
  326.     if (bitmap_height)
  327.         lpmfp->yExt = (int)(bitmap_height / ydpi * 2540);
  328.     else
  329.         lpmfp->yExt = 29700;    /* A4 */
  330.     lpmfp->hMF = hmf;
  331.     GlobalUnlock(hglobal);
  332.     SetClipboardData(CF_METAFILEPICT, hglobal);
  333.     return;
  334. }
  335. #endif
  336.