开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 信息检索与抽取 > 查看源码
win32dib.c
资源名称：swarm-2.2.tar.gz　[点击查看]
上传用户：shenzhenrh
上传日期：2013-05-12
资源大小：2904k
文件大小：17k
源码类别：

信息检索与抽取

开发平台：

Unix_Linux

win32dib.c：源码内容
  1. // Swarm library. Copyright (C) 1996-2000 Swarm Development Group.
  2. // This library is distributed without any warranty; without even the
  3. // implied warranty of merchantability or fitness for a particular purpose.
  4. // See file LICENSE for details and terms of copying.
  6. #include "win32dib.h"
  8. #ifdef _WIN32
  9. #include <windows.h>
  10. #define BOOL w32BOOL
  11. #include <misc.h>
  12. #undef BOOL
  14. dib_t *
  15. dib_create (void)
  16. {
  17.   dib_t *dib = xmalloc (sizeof (dib_t));
  18.   
  19.   dib->window = NULL;
  20.   dib->colormapBlocks = 0;
  21.   dib->colormapSize = 0;
  22.   dib->colormap = NULL;
  23.   memset (dib->colormapOffsets, 0, sizeof (dib->colormapOffsets));
  24.   memset (dib->colormapObjects, 0, sizeof (dib->colormapObjects));
  25.   dib->sourceDC = NULL;
  26.   dib->destDC = NULL;
  27.   dib->dibInfo = xmalloc (sizeof (CDIB_BITMAP));
  28.   dib->bitmap = NULL;
  29.   dib->oldBitmap = NULL;
  30.   dib->bits = NULL;
  31.   dib->palette = NULL;
  32.   dib->oldPalette = NULL;
  33.   dib->xBitmapOffset = 0;
  34.   dib->yBitmapOffset = 0;
  36.   return dib;
  37. }
  39. void
  40. dib_destroy (dib_t *dib)
  41. {
  42.   XFREE (dib->dibInfo);
  43.   dib->dibInfo = NULL;
  44.   if (dib->colormap)
  45.     XFREE (dib->colormap);
  46.   if (dib->bitmap)
  47.     {
  48.       if (dib->window)
  49.         {
  50.           HDC hdc = GetDC (dib->window);
  52.           SelectObject (hdc, dib->oldBitmap);
  53.           DeleteObject (dib->bitmap);
  54.           ReleaseDC (dib->window, hdc);
  55.         }
  56.       else
  57.         {
  58.           HDC hdc = CreateCompatibleDC (NULL);
  60.           SelectObject (hdc, dib->oldBitmap);
  61.           DeleteObject (dib->bitmap);
  62.           DeleteDC (hdc);
  63.         }
  64.     }
  65.   else if (dib->bits != NULL)
  66.     XFREE (dib->bits);
  68.   dib->bitmap = NULL;
  69.   dib->oldBitmap = NULL;
  70.   dib->bits = NULL;
  72.   if (dib->palette)
  73.     {
  74.       DeleteObject (dib->palette);
  75.       dib->palette = NULL;
  76.     }
  77.   dib->oldPalette = NULL;
  78.   if (dib->sourceDC)
  79.     {
  80.       DeleteDC (dib->sourceDC);
  81.       dib->sourceDC = NULL;
  82.     }
  83.   if (dib->destDC)
  84.     {
  85.       if (dib->window)
  86.         ReleaseDC (dib->window, dib->destDC);
  87.       else
  88.         DeleteDC (dib->destDC);
  89.       dib->destDC = NULL;
  90.     }
  91.   dib->window = NULL;
  92.   dib->xBitmapOffset = 0;
  93.   dib->yBitmapOffset = 0;
  94. }
  96. void
  97. dib_createBitmap (dib_t *dib, HWND window, unsigned width, unsigned height)
  98. {
  99.   HDC hdc;
  101.   if (window)
  102.     hdc = GetDC (window);
  103.   else
  104.     hdc = CreateCompatibleDC (NULL);
  105.   
  106.   dib->window = window;
  108.   if (width & 3)
  109.     width += 4 - (width & 3);
  111.   dib->dibInfo->bmiHead.biSize = sizeof (BITMAPINFOHEADER);
  112.   dib->dibInfo->bmiHead.biWidth = width;
  113.   if (TOP_DOWN_DIB)
  114.     dib->dibInfo->bmiHead.biHeight = -height;
  115.   else
  116.     dib->dibInfo->bmiHead.biHeight = height;
  117.   dib->dibInfo->bmiHead.biPlanes = 1;
  118.   dib->dibInfo->bmiHead.biBitCount = 24;
  119.   dib->dibInfo->bmiHead.biCompression = BI_RGB;
  120.   dib->dibInfo->bmiHead.biSizeImage = 0;
  121.   dib->dibInfo->bmiHead.biClrUsed = 0;
  122.   dib->dibInfo->bmiHead.biClrImportant = 0;
  123.   dib->bitmap = CreateDIBSection (hdc,
  124.   (BITMAPINFO *) dib->dibInfo,
  125.   DIB_RGB_COLORS,
  126.   &dib->bits,
  127.   NULL,
  128.   0 /* ignored if above is NULL */ );
  129.   if (window)
  130.     ReleaseDC (window, hdc);
  131.   else
  132.     DeleteDC (hdc);
  133. }
  135. #define SNAPSHOTPALETTE ((void *)0xdeaf)
  137. void
  138. dib_snapshot (dib_t *dib, BOOL windowDCFlag)
  139. {
  140.   HDC hdc = windowDCFlag ? GetWindowDC (dib->window) : GetDC (dib->window);
  141.   HDC hmemdc = CreateCompatibleDC (hdc);
  142.   HDC hbmmem;
  143.   RECT rect;
  144.   unsigned width, height, newWidth;
  145.   int caps;
  146.   HGDIOBJ hb1;
  147.   HPALETTE holdPal = NULL;
  148.   unsigned pixelCount, bufsize;
  149.   LPBYTE bits;
  150.   WORD depth;
  151.   LPBITMAPINFOHEADER pbmp = &dib->dibInfo->bmiHead;
  152.   LOGPALETTE *plp = NULL;
  154.   depth = (GetDeviceCaps (hdc, BITSPIXEL) <= 8) ? 8 : 24;
  155.   GetWindowRect (dib->window, &rect);
  156.   dib->bitmap = NULL;
  158.   if (dib->window == HWND_DESKTOP)
  159.     {
  160.       height = GetDeviceCaps (hdc, VERTRES);
  161.       width = GetDeviceCaps (hdc, HORZRES);
  162.     }
  163.   else
  164.     {
  165.       height = rect.bottom - rect.top;
  166.       width = rect.right - rect.left;
  167.     }
  168.   if (width & 3)
  169.     newWidth = width + 4 - (width & 3);
  170.   else
  171.     newWidth = width;
  173.   hbmmem = CreateCompatibleBitmap (hdc, newWidth, height);
  175.   hb1 = SelectObject (hmemdc, hbmmem);
  177.   caps = GetDeviceCaps (hdc, RASTERCAPS);
  178.   if (caps & RC_PALETTE)
  179.     {
  180.       UINT cnt;
  181.       HPALETTE hpal;
  182.       
  183.       cnt = GetDeviceCaps (hdc, SIZEPALETTE);
  184.       plp = xmalloc (sizeof (LOGPALETTE) + sizeof (PALETTEENTRY) * cnt);
  185.       plp->palVersion = 0x0300;
  186.       plp->palNumEntries = cnt;
  187.       cnt = GetSystemPaletteEntries (hdc, 0, cnt, plp->palPalEntry);
  188.       if (cnt == 0)
  189. abort ();
  190.       hpal = CreatePalette (plp);
  191.       SelectPalette (hmemdc, hpal, FALSE);
  192.       holdPal = SelectPalette (hdc, hpal, FALSE);
  193.     }
  194.   if (BitBlt (hmemdc, 0, 0, width, height, hdc, 0, 0, SRCCOPY) == FALSE)
  195.     abort ();
  196.   pixelCount = newWidth * height;
  197.   bufsize = pixelCount * (depth >> 3);
  198.   pbmp->biSize = sizeof (BITMAPINFOHEADER);
  199.   pbmp->biWidth = newWidth;
  200.   pbmp->biHeight = -height;
  201.   pbmp->biPlanes = 1;
  202.   pbmp->biBitCount = depth;
  203.   pbmp->biCompression = BI_RGB;
  204.   bits = xmalloc (bufsize);
  205.   hbmmem = SelectObject (hmemdc, hb1);
  207.   if (depth == 8)
  208.     {
  209.       if (GetDIBits (hmemdc, hbmmem, 0, height,
  210.      bits,
  211.                      (LPBITMAPINFO) pbmp,
  212.                      DIB_PAL_COLORS) != (int) height)
  213. abort ();
  214.       
  215.       {
  216. unsigned i;
  217. BYTE max = 0;
  218. LPBYTE colors = (PVOID) pbmp + sizeof (BITMAPINFOHEADER);
  219. LPBYTE pixels = bits;
  221. for (i = 0; i < pixelCount; i++)
  222.   if (pixels[i] > max)
  223.     max = pixels[i];
  225. {
  226.   unsigned colorCount = max + 1;
  227.   unsigned long map[colorCount];
  228.         
  229.   for (i = 0; i < colorCount; i++)
  230.             {
  231.               PALETTEENTRY *pe = &plp->palPalEntry[i];
  232.               
  233.               map[i] = (pe->peRed) | (pe->peGreen << 8) | (pe->peBlue << 16);
  234.             }
  235.   dib_augmentPalette (dib, SNAPSHOTPALETTE, colorCount, map);
  236. }
  237.       }
  238.     }
  239.   else if (depth == 24)
  240.     {
  241.       if (GetDIBits (hmemdc, hbmmem, 0, height,
  242.      bits,
  243.                      (LPBITMAPINFO) pbmp,
  244.                      DIB_RGB_COLORS) != (int) height)
  245. abort ();
  246.     }
  247.   else
  248.     abort ();
  249.   DeleteObject (hbmmem);
  250.   dib->bits = bits;
  251.   if (holdPal)
  252.     SelectObject (hdc, holdPal);
  253.   if (plp)
  254.     XFREE (plp);
  255.   ReleaseDC (dib->window, hdc);
  256.   DeleteDC (hmemdc);
  257. }
  259. int
  260. dib_paletteIndexForObject (dib_t *dib, void *object)
  261. {
  262.   unsigned i;
  264.   for (i = 0; i < dib->colormapBlocks; i++)
  265.     if (object == dib->colormapObjects[i])
  266.       return i;
  267.   return -1;
  268. }
  270. void
  271. dib_get_color (dib_t *dib, void *object, unsigned color, BYTE *red, BYTE *green, BYTE *blue)
  272. {
  273.   WORD depth = dib->dibInfo->bmiHead.biBitCount;
  274.   
  275.   if (depth == 8)
  276.     {
  277.       RGBQUAD *rgb = &dib->dibInfo->rgb[color];
  279.       *red = rgb->rgbRed;
  280.       *green = rgb->rgbGreen;
  281.       *blue = rgb->rgbBlue;
  282.     }
  283.   else if (depth == 24)
  284.     {
  285.       unsigned colorValue;
  286.       int index = dib_paletteIndexForObject (dib, object);
  287.       unsigned colorOffset = (index == -1) ? 0 : dib->colormapOffsets[index];
  288.       if (colorOffset + color < dib->colormapSize)
  289.         colorValue = dib->colormap[colorOffset + color];
  290.       else
  291.         {
  292. #if 0
  293.           fprintf (stderr, "color %u out of range (>= %u + %u = %un",
  294.                    color, colorOffset, color, dib->colormapSize);
  295. #endif
  296.           colorValue = 0;
  297.         }
  299.       *blue = colorValue >> 16;
  300.       *green = (colorValue >> 8) & 0xff;
  301.       *red = colorValue & 0xff;
  302.     }
  303.   else
  304.     abort ();
  305. }
  307. void
  308. dib_augmentPalette (dib_t *dib,
  309.     void *object,
  310.     unsigned colormapSize,
  311.     unsigned long *colormap)
  312. {
  313.   unsigned lastSize = dib->colormapSize;
  314.   WORD depth = dib->dibInfo->bmiHead.biBitCount;
  315.   unsigned bi;
  317.   for (bi = 0; bi < dib->colormapBlocks; bi++)
  318.     if (object == dib->colormapObjects[bi])
  319.       break;
  320.   if (bi < dib->colormapBlocks)
  321.     {
  322.       unsigned offset = dib->colormapOffsets[bi];
  323.       unsigned next = ((bi == dib->colormapBlocks - 1)
  324.        ? dib->colormapSize
  325.        : dib->colormapOffsets[bi + 1]);
  326.       unsigned size = next - offset;
  328.       if (size == dib->colormapSize)
  329. {
  330.   unsigned i;
  332.   for (i = 0; i < size; i++)
  333.     if (dib->colormap[i + offset] != colormap[i])
  334.       break;
  335.   if (i == size)
  336.     return;
  337. }
  338.     }
  339.   
  340.   dib->colormapObjects[bi] = object;
  341.   dib->colormapOffsets[bi] = lastSize;
  342.   dib->colormapSize += colormapSize;
  343.   dib->colormapBlocks++;
  344.   
  346.   if (depth == 8)
  347.     {
  348.       unsigned i;
  349.       RGBQUAD *rgb = &dib->dibInfo->rgb[lastSize];
  350.       
  351.       for (i = 0; i < colormapSize; i++)
  352.         {
  353.           rgb[i].rgbRed = colormap[i] & 0xff;
  354.           rgb[i].rgbGreen = (colormap[i] & 0xff00) >> 8;
  355.           rgb[i].rgbBlue = (colormap[i] & 0xff0000) >> 16;
  356.         }  
  358.       if (dib->bitmap)
  359. {
  360.   HDC shdc = CreateCompatibleDC (NULL);
  361.   UINT ret;
  362.   
  363.   dib->oldBitmap = SelectObject (shdc, dib->bitmap);
  364.   ret = SetDIBColorTable (shdc, 0, dib->colormapSize,
  365.   dib->dibInfo->rgb);
  366.   SelectObject (shdc, dib->oldBitmap);
  367.   DeleteDC (shdc);
  368. }
  369.     }
  370.   else if (depth == 24)
  371.     {
  372.       unsigned long *newcolormap;
  373.       unsigned i;
  374.       unsigned newSize = dib->colormapSize * sizeof (unsigned long);
  375.       
  376.       dib->colormap = dib->colormap
  377. ? xrealloc (dib->colormap, newSize)
  378. : xmalloc (newSize);
  379.       newcolormap = &dib->colormap[lastSize];
  380.       
  381.       for (i = 0; i < colormapSize; i++)
  382. newcolormap[i] = colormap[i];
  383.     }
  384. }
  386. void
  387. dib_fill (dib_t *dib,
  388.   int x, int y,
  389.   unsigned width, unsigned height,
  390.   void *object,
  391.   unsigned color)
  392. {
  393.   unsigned frameWidth = dib->dibInfo->bmiHead.biWidth;
  394.   unsigned frameHeight = (dib->dibInfo->bmiHead.biHeight < 0
  395.   ? -dib->dibInfo->bmiHead.biHeight
  396.   : dib->dibInfo->bmiHead.biHeight);
  397.   unsigned yoff;
  398.   int wdiff, hdiff;
  399.   int clipx, clipy;
  400.   WORD depth = dib->dibInfo->bmiHead.biBitCount;
  401.   unsigned row_width;
  403.   if (x < 0)
  404.     {
  405.       if (-x > (int)width)
  406.         return;
  407.       width -= (-x);
  408.       clipx = 0;
  409.     }
  410.   else if (x > (int)frameWidth)
  411.     return;
  412.   else clipx = x;
  414.   if (y < 0)
  415.     {
  416.       if (-y > (int)height)
  417.         return;
  418.       height -= (-y);
  419.       clipy = 0;
  420.     }
  421.   else if (y > (int)frameHeight)
  422.     return;
  423.   else clipy = y;
  425.   wdiff = clipx + width - frameWidth;
  427.   if (wdiff > 0)
  428.     width -= wdiff;
  430.   hdiff = clipy + height - frameHeight;
  432.   if (hdiff > 0)
  433.     height -= hdiff;
  434.    
  435.   if (frameWidth & 3)
  436.     frameWidth += 4 - (frameWidth & 3);
  438.   row_width = frameWidth * ((depth == 24) ? 3 : 1);
  439.       
  440.   if (row_width & 3)
  441.     row_width += 4 - (row_width & 3);
  443.   if (depth == 8)
  444.     {
  445.       LPBYTE base = (LPBYTE) dib->bits + (clipy * row_width);
  447.       for (yoff = 0; yoff < height; yoff++)
  448. {
  449.   unsigned xoff;
  450.   LPBYTE ybase = &base[yoff * row_width + clipx];
  451.   
  452.   for (xoff = 0; xoff < width; xoff++)
  453.     ybase[xoff] =  color;
  454. }
  455.     }
  456.   else if (depth == 24)
  457.     {
  458.       LPBYTE base = ((LPBYTE) dib->bits) + (clipy * row_width);
  459.       BYTE red, green, blue;
  460.       unsigned fsize = frameWidth * 3;
  462.       if (fsize & 3)
  463. fsize += (4 - (fsize & 3));
  465.       dib_get_color (dib, object, color, &red, &green, &blue);
  466.       for (yoff = 0; yoff < height; yoff++)
  467. {
  468.   unsigned xoff;
  469.   LPBYTE ybase = base + ((yoff * fsize) + (clipx * 3));
  471.   for (xoff = 0; xoff < width; xoff++)
  472.     {
  473.       LPBYTE xbase = ybase + xoff * 3;
  475.       xbase[0] = blue;
  476.       xbase[1] = green;
  477.       xbase[2] = red;
  478.     }
  479. }
  480.     }
  481.   else
  482.     abort ();
  483. }
  485. void
  486. dib_ellipse (dib_t *dib,
  487.      int x, int y,
  488.      unsigned width, unsigned height,
  489.      unsigned pixels,
  490.      void *object,
  491.      unsigned color)
  492. {
  493.   HPEN oldPen, pen;
  494.   HBRUSH oldBrush;
  495.   BYTE red, green, blue;
  497.   dib_get_color (dib, object, color, &red, &green, &blue);
  498.   pen = CreatePen (PS_SOLID, pixels, RGB (red, green, blue));
  500.   dib_lock (dib);
  501.   
  502.   oldPen = SelectObject (dib->sourceDC, pen);
  503.   oldBrush = SelectObject (dib->sourceDC, GetStockObject (NULL_BRUSH));
  505.   Ellipse (dib->sourceDC, x, y, x + width, y + height);
  506.   
  507.   DeleteObject (SelectObject (dib->sourceDC, oldPen));
  508.   SelectObject (dib->sourceDC, oldBrush);
  510.   dib_unlock (dib);
  511. }
  513. void
  514. dib_line (dib_t *dib,
  515.           int x0, int y0,
  516.           int x1, int y1,
  517.           unsigned pixels,
  518.   void *object,
  519.           unsigned color)
  520. {
  521.   HPEN oldPen, pen;
  522.   HBRUSH oldBrush;
  523.   BYTE red, green, blue;
  525.   dib_get_color (dib, object, color, &red, &green, &blue);
  526.   pen = CreatePen (PS_SOLID, pixels, RGB (red, green, blue));
  528.   dib_lock (dib);
  529.   
  530.   oldPen = SelectObject (dib->sourceDC, pen);
  531.   oldBrush = SelectObject (dib->sourceDC, GetStockObject (NULL_BRUSH));
  533.   MoveToEx (dib->sourceDC, x0, y0, NULL);
  534.   LineTo (dib->sourceDC, x1, y1);
  535.   
  536.   DeleteObject (SelectObject (dib->sourceDC, oldPen));
  537.   SelectObject (dib->sourceDC, oldBrush);
  539.   dib_unlock (dib);
  540. }
  542. void
  543. dib_rectangle (dib_t *dib,
  544.                int x, int y,
  545.                unsigned width, unsigned height,
  546.                unsigned pixels,
  547.        void *object,
  548.                unsigned color)
  549. {
  550.   HPEN oldPen, pen;
  551.   HBRUSH oldBrush;
  552.   BYTE red, green, blue;
  554.   dib_get_color (dib, object, color, &red, &green, &blue);
  555.   pen = CreatePen (PS_SOLID, pixels, RGB (red, green, blue));
  557.   dib_lock (dib);
  558.   
  559.   oldPen = SelectObject (dib->sourceDC, pen);
  560.   oldBrush = SelectObject (dib->sourceDC, GetStockObject (NULL_BRUSH));
  562.   Rectangle (dib->sourceDC, x, y, x + width, y + height);
  563.   
  564.   DeleteObject (SelectObject (dib->sourceDC, oldPen));
  565.   SelectObject (dib->sourceDC, oldBrush);
  567.   dib_unlock (dib);
  568. }
  571. BOOL
  572. dib_paintBlit (dib_t *dib,
  573.        HDC destDC,
  574.        int destX, int destY,
  575.        int sourceX, int sourceY,
  576.        unsigned sourceWidth, unsigned sourceHeight)
  577. {
  578.   unsigned frameWidth = dib->dibInfo->bmiHead.biWidth;
  579.   int diff;
  581.   diff = (destX + sourceWidth) - frameWidth;
  583.   if (diff > 0)
  584.     sourceWidth -= diff;
  586.   GdiFlush ();
  588.   {
  589.     /* Lock */
  590.     HDC sourceDC = CreateCompatibleDC (destDC);
  592.     dib->oldBitmap = SelectObject (sourceDC, dib->bitmap);
  593.     
  594.     /* Blit */
  595.     {
  596.       BOOL result;
  597.       
  598.       SelectPalette (destDC, dib->palette, FALSE);
  599.       RealizePalette (destDC);
  601.       result = BitBlt (destDC, 
  602.        destX, destY,
  603.        sourceWidth, sourceHeight,
  604.        sourceDC, 
  605.        sourceX + dib->xBitmapOffset,
  606.        sourceY + dib->yBitmapOffset,
  607.        SRCCOPY);
  608.       
  609.       /* Unlock */
  610.       SelectObject (sourceDC, dib->oldBitmap);
  611.       DeleteDC (sourceDC);
  612.       
  613.       return result;
  614.     }
  615.   }
  616. }
  618. void
  619. dib_copy_metadata (dib_t *source, dib_t *dest)
  620. {
  621.   memcpy (dest->dibInfo, source->dibInfo, sizeof (CDIB_BITMAP));
  622.   dest->colormapBlocks = source->colormapBlocks;
  623.   dest->colormapSize = source->colormapSize;
  624.   if (source->colormap)
  625.     {
  626.       size_t size = source->colormapSize * sizeof (unsigned long);
  628.       dest->colormap = xmalloc (size);
  629.       memcpy (dest->colormap, source->colormap, size);
  630.     }
  631.   else
  632.     dest->colormap = NULL;
  633.   memcpy (dest->colormapOffsets,
  634.   source->colormapOffsets,
  635.   sizeof (source->colormapOffsets));
  636.   memcpy (dest->colormapObjects,
  637.   source->colormapObjects,
  638.   sizeof (source->colormapObjects));
  639.   memcpy (dest->dibInfo->rgb,
  640.   source->dibInfo->rgb,
  641.   sizeof (RGBQUAD) * source->colormapSize);
  642. #if 0
  643.   {
  644.     HDC shdc = CreateCompatibleDC (NULL);
  645.     
  646.     dest->oldBitmap = SelectObject (shdc, dest->bitmap);
  647.     SetDIBColorTable (shdc, 0, dest->colormapSize, dest->dibInfo->rgb);
  648.     SelectObject (shdc, dest->oldBitmap);
  649.     DeleteDC (shdc);
  650.   }
  651. #endif
  652. }
  654. BOOL
  655. dib_copy (dib_t *source, dib_t *dest,
  656.           int destx, int desty,
  657.           unsigned width, unsigned height)
  658. {
  659.   BOOL result;
  661.   if (dib_lock (dest) == NULL)
  662.     return FALSE;
  663.   if (dib_lock (source) == NULL)
  664.     return FALSE;
  666.   result = BitBlt (dest->sourceDC, destx, desty,
  667.    width, height,
  668.    source->sourceDC, 0, 0,
  669.    SRCCOPY);
  670.   dib_unlock (source);
  671.   dib_unlock (dest);
  672.   return result;
  673. }
  675. LPBYTE
  676. dib_lock (dib_t *dib)
  677. {
  678.   GdiFlush ();
  679.   
  680.   dib->destDC = GetDC (dib->window);
  681.   dib->sourceDC = CreateCompatibleDC (dib->destDC);
  683.   dib->oldBitmap = SelectObject (dib->sourceDC, dib->bitmap);
  684.   
  685.   return dib->bits;
  686. }
  688. void
  689. dib_unlock (dib_t *dib)
  690. {
  691.   SelectObject (dib->sourceDC, dib->oldBitmap);
  692.   
  693.   DeleteDC (dib->sourceDC);
  694.   dib->sourceDC = NULL;
  695.   ReleaseDC (dib->window, dib->destDC);
  696.   dib->destDC = NULL;
  697. }
  699. #if 0
  700. void
  701. dib_setPaintOffset (dib_t *dib, int xOffset, int yOffset)
  702. {
  703.   dib->xBitmapOffset = xOffset;
  704.   dib->yBitmapOffset = yOffset;
  705. }
  707. LPBYTE
  708. dib_getSurface (dib_t *dib)
  709. {
  710.   if (dib->bitmap == NULL)
  711.     return NULL;
  713.   return (PIXEL_TYPE *)dib->bits;
  714. }
  716. int
  717. dib_getWidth (dib_t *dib)
  718. {
  719.   if (dib->bitmap == NULL)
  720.     return -1;
  721.   
  722.   return dib->dibInfo->bmiHead.biWidth;
  723. }
  726. int
  727. dib_getHeight (dib_t *dib)
  728. {
  729.   if (dib->bitmap == NULL)
  730.     return -1;
  732.   {
  733.     int height = dib->dibInfo->bmiHead.biHeight;
  735.     return height < 0 ? -height : height;
  736.   }
  737. }
  739. BOOL
  740. dib_blit (dib_t *dib,
  741.   int destX, int destY,
  742.   int sourceX, int sourceY,
  743.   unsigned sourceWidth, unsigned sourceHeight)
  744. {
  745.   int diff = destX + sourceWidth - dib->dibInfo->bmiHead.biWidth;
  746.   
  747.   if (diff > 0)
  748.     sourceWidth -= diff;
  750.   SelectPalette (dib->destDC, dib->palette, FALSE);
  751.   RealizePalette (dib->destDC);
  752.   return BitBlt (dib->destDC,
  753.                  destX, destY,
  754.                  sourceWidth, sourceHeight,
  755.                  dib->sourceDC,
  756.                  sourceX, sourceY,
  757.                  SRCCOPY);
  758. }
  760. #endif
  761. #endif