Initial import. Contains the im, cd and iup librairies, and a "working" Makefile for them under linux.

1 files changed, 668 insertions, 0 deletions

diff --git a/iup/src/win/iupwin_image.c b/iup/src/win/iupwin_image.c
new file mode 100755
index 0000000..2db9800
--- /dev/null
+++ b/iup/src/win/iupwin_image.c
@@ -0,0 +1,668 @@
+/** \file
+ * \brief Image Resource.
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <windows.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_image.h"
+
+#include "iupwin_drv.h"
+
+/* RGB in RGBA DIBs are pre-multiplied by alpha to AlphaBlend usage. */
+#define iupALPHAPRE(_src, _alpha) (((_src)*(_alpha))/255)
+
+static int winDibNumColors(BITMAPINFOHEADER* bmih)
+{
+  if (bmih->biBitCount > 8)
+  {
+    if (bmih->biCompression == BI_BITFIELDS)
+      return 3;
+    else
+      return 0;
+  }
+  else
+  {
+    if (bmih->biClrUsed != 0)
+      return bmih->biClrUsed;
+    else
+      return 1 << bmih->biBitCount;
+  }
+}
+
+void iupdrvImageGetRawData(void* handle, unsigned char* imgdata)
+{
+  int x, y, w, h, bpp, bmp_line_size, bits_size;
+  BYTE* bits;
+  HANDLE hHandle = (HANDLE)handle;
+  void* dib = GlobalLock(hHandle);
+  BITMAPINFOHEADER* bmih = (BITMAPINFOHEADER*)dib;
+
+  w = bmih->biWidth;
+  h = abs(bmih->biHeight);
+  bpp = iupImageNormBpp(bmih->biBitCount);
+  bmp_line_size = ((w * bmih->biBitCount + 31) / 32) * 4;    /* DWORD aligned, 4 bytes boundary in a N bpp image */
+  bits_size = bmp_line_size*h;
+
+  bits = ((BYTE*)dib) + sizeof(BITMAPINFOHEADER) + winDibNumColors(bmih)*sizeof(RGBQUAD);
+
+  /* windows bitmaps are bottom up */
+  /* imgdata is bottom up */
+
+  if (bmih->biHeight < 0)
+    bits = bits + (bits_size - bmp_line_size); /* start of last line */
+
+  if (bpp == 8)
+  {
+    for (y = 0; y < h; y++)
+    {
+      for (x = 0; x < w; x++)
+      {
+        switch (bmih->biBitCount)
+        {
+        case 1:
+          *imgdata++ = (unsigned char)((bits[x / 8] >> (7 - x % 8)) & 0x01);
+          break;
+        case 4:
+          *imgdata++ = (unsigned char)((bits[x / 2] >> ((1 - x % 2) * 4)) & 0x0F);
+          break;
+        case 8:
+          *imgdata++ = bits[x];
+          break;
+        }
+      }
+    
+      if (bmih->biHeight < 0)
+        bits -= bmp_line_size;
+      else
+        bits += bmp_line_size;
+    }
+  }
+  else
+  {
+    int offset, planesize;
+    unsigned short color;
+    unsigned int rmask = 0, gmask = 0, bmask = 0, 
+                  roff = 0, goff = 0, boff = 0; /* pixel bit mask control when reading 16 and 32 bpp images */
+    unsigned char *red, *green, *blue, *alpha;
+
+    planesize = w*h;
+    red = imgdata;
+    green = imgdata+planesize;
+    blue = imgdata+2*planesize;
+    alpha = imgdata+3*planesize;
+    
+    if (bmih->biBitCount == 16)
+      offset = bmp_line_size;  /* do not increment for each pixel, jump line */
+    else
+      offset = bmp_line_size - (w*bmih->biBitCount)/8;   /* increment for each pixel, jump pad */
+    
+    if (bmih->biCompression == BI_BITFIELDS)
+    {
+      unsigned int Mask;
+      unsigned int* palette = (unsigned int*)(((BYTE*)bmih) + sizeof(BITMAPINFOHEADER));
+      
+      rmask = Mask = palette[0];
+      while (!(Mask & 0x01))
+      {Mask >>= 1; roff++;}
+      
+      gmask = Mask = palette[1];
+      while (!(Mask & 0x01))
+      {Mask >>= 1; goff++;}
+      
+      bmask = Mask = palette[2];
+      while (!(Mask & 0x01))
+      {Mask >>= 1; boff++;}
+    }
+    else if (bmih->biBitCount == 16)
+    {
+      bmask = 0x001F;
+      gmask = 0x03E0;
+      rmask = 0x7C00;
+      boff = 0;
+      goff = 5;
+      roff = 10;
+    }
+    
+    for (y = 0; y < h; y++)
+    {
+      for (x = 0; x < w; x++)
+      {
+        if (bmih->biBitCount == 16)
+        {
+          color = ((unsigned short*)bits)[x];
+          *red++ = (unsigned char)((((rmask & color) >> roff) * 255) / (rmask >> roff));
+          *green++ = (unsigned char)((((gmask & color) >> goff) * 255) / (gmask >> goff));
+          *blue++ = (unsigned char)((((bmask & color) >> boff) * 255) / (bmask >> boff));
+        }
+        else
+        {
+          *blue++ = *bits++;
+          *green++ = *bits++;
+          *red++ = *bits++;
+          
+          if (bmih->biBitCount == 32)
+          {
+            if (alpha)
+              *alpha++ = *bits++;
+            else
+              bits++;
+          }
+        }
+      }
+      
+      bits += offset;
+
+      if (bmih->biHeight < 0)
+        bits -= 2*bmp_line_size;
+    }
+  }
+
+  GlobalUnlock(hHandle);
+}
+
+void* iupdrvImageCreateImageRaw(int width, int height, int bpp, iupColor* colors, int colors_count, unsigned char *imgdata)
+{
+  int y,x,bmp_line_size,channels,bits_size,header_size;
+  HANDLE hHandle;
+  BYTE* bits;   /* DIB bitmap bits, created in CreateDIBSection and filled here */
+  void* dib;
+  BITMAPINFOHEADER* bmih;
+
+  bmp_line_size = ((width * bpp + 31) / 32) * 4;    /* DWORD aligned, 4 bytes boundary in a N bpp image */
+  bits_size = bmp_line_size*height;
+  header_size = sizeof(BITMAPINFOHEADER) + colors_count*sizeof(RGBQUAD);
+
+  hHandle = GlobalAlloc(GMEM_MOVEABLE, header_size+bits_size);
+  if (!hHandle)
+    return NULL;
+
+  dib = GlobalLock(hHandle);
+  bits = ((BYTE*)dib) + header_size;
+
+  bmih = (BITMAPINFOHEADER*)dib;
+
+  memset(bmih, 0, sizeof(BITMAPINFOHEADER));
+  bmih->biSize = sizeof(BITMAPINFOHEADER);
+  bmih->biWidth  = width;
+  bmih->biHeight = height;
+  bmih->biPlanes = 1; /* not the same as PLANES */
+  bmih->biBitCount = (WORD)bpp;
+  bmih->biCompression = BI_RGB;
+  bmih->biClrUsed = colors_count;
+
+  if (colors_count)
+  {
+    RGBQUAD* bitmap_colors = (RGBQUAD*)(((BYTE*)dib) + sizeof(BITMAPINFOHEADER));
+    int i;
+    for (i=0;i<colors_count;i++)
+    {
+      bitmap_colors[i].rgbRed   = colors[i].r;
+      bitmap_colors[i].rgbGreen = colors[i].g;
+      bitmap_colors[i].rgbBlue  = colors[i].b;
+      bitmap_colors[i].rgbReserved = 0;
+    }
+  }
+
+  channels = 1;
+  if (bpp == 24)
+    channels = 3;
+  else if (bpp == 32)
+    channels = 4;
+
+  /* windows bitmaps are bottom up */
+  /* imgdata is bottom up */
+
+  if (bpp != 8) /* (bpp == 32 || bpp == 24) */
+  {
+    unsigned char *r, *g, *b, *a;
+
+    int planesize = width*height;
+    r = imgdata;
+    g = imgdata+planesize;
+    b = imgdata+2*planesize;
+    a = imgdata+3*planesize;
+
+    for (y=0; y<height; y++)
+    {
+      int lineoffset = y*width;
+      for (x=0; x<width; x++)
+      {
+        int offset = channels*x;
+        /* Windows Bitmap order is BGRA */
+        BYTE *bmp_b = &bits[offset],
+             *bmp_g = bmp_b+1,
+             *bmp_r = bmp_g+1,
+             *bmp_a = bmp_r+1;
+
+        *bmp_r = r[lineoffset+x];
+        *bmp_g = g[lineoffset+x];
+        *bmp_b = b[lineoffset+x];
+
+        if (channels == 4)  /* bpp==32 */
+        {
+          *bmp_a = a[lineoffset+x];
+
+          /* RGB in RGBA DIBs are pre-multiplied by alpha to AlphaBlend usage. */
+          *bmp_r = iupALPHAPRE(*bmp_r,*bmp_a);
+          *bmp_g = iupALPHAPRE(*bmp_g,*bmp_a);
+          *bmp_b = iupALPHAPRE(*bmp_b,*bmp_a);
+        }
+      }
+
+      bits += bmp_line_size;
+    }
+  }
+  else
+  {
+    for (y=0; y<height; y++)
+    {
+      int lineoffset = y*width;
+      for (x=0; x<width; x++)
+      {
+        bits[x] = imgdata[lineoffset+x];
+      }
+
+      bits += bmp_line_size;
+    }
+  }
+
+  GlobalUnlock(hHandle);
+  return hHandle;
+}
+
+int iupdrvImageGetRawInfo(void* handle, int *w, int *h, int *bpp, iupColor* colors, int *colors_count)
+{
+  HANDLE hHandle = (HANDLE)handle;
+  void* dib = GlobalLock(hHandle);
+  BITMAPINFOHEADER* bmih = (BITMAPINFOHEADER*)dib;
+  
+  if (w) *w = bmih->biWidth;
+  if (h) *h = abs(bmih->biHeight);
+  if (bpp) *bpp = iupImageNormBpp(bmih->biBitCount);
+
+  if (bmih->biBitCount <= 8)
+  {
+    RGBQUAD* bitmap_colors = (RGBQUAD*)(((BYTE*)bmih) + sizeof(BITMAPINFOHEADER));
+    int i;
+
+    if (bmih->biClrUsed != 0)
+      *colors_count = bmih->biClrUsed;
+    else
+      *colors_count = 1 << bmih->biBitCount;
+
+    for (i=0;i<*colors_count;i++)
+    {
+      colors[i].r = bitmap_colors[i].rgbRed;
+      colors[i].g = bitmap_colors[i].rgbGreen;
+      colors[i].b = bitmap_colors[i].rgbBlue;
+    }
+  }
+
+  GlobalUnlock(hHandle);
+  return 1;
+}
+
+static int winImageInitDibColors(iupColor* colors, RGBQUAD* bmpcolors, int colors_count, 
+                                 unsigned char bg_r, unsigned char bg_g, unsigned char bg_b, int make_inactive)
+{
+  int i, ret = 0;
+  for (i=0;i<colors_count;i++)
+  {
+    bmpcolors[i].rgbRed   = colors[i].r;
+    bmpcolors[i].rgbGreen = colors[i].g;
+    bmpcolors[i].rgbBlue  = colors[i].b;
+    bmpcolors[i].rgbReserved = colors[i].a;
+
+    if (bmpcolors[i].rgbReserved == 0) /* full transparent alpha */
+    {
+      bmpcolors[i].rgbBlue = bg_b; 
+      bmpcolors[i].rgbGreen = bg_g; 
+      bmpcolors[i].rgbRed = bg_r;
+      ret = 1;
+    }
+    else
+      bmpcolors[i].rgbReserved = 0; /* clear non transparent mark */
+
+    if (make_inactive)
+      iupImageColorMakeInactive(&(bmpcolors[i].rgbRed), &(bmpcolors[i].rgbGreen), &(bmpcolors[i].rgbBlue), 
+                                bg_r, bg_g, bg_b);
+  }
+
+  return ret;
+}
+
+static HBITMAP winImageCreateBitmap(Ihandle *ih, int width, int height, int bpp, BYTE** bits, 
+                                    unsigned char bg_r, unsigned char bg_g, unsigned char bg_b, int make_inactive)
+{
+  HDC hDC;
+  int colors_count;
+  HBITMAP hBitmap;
+  BITMAPINFOHEADER* bmih;  /* bitmap info header */
+  iupColor colors[256];
+
+  if (bpp == 32 || bpp == 24)
+    colors_count = 0;
+  else /* bpp == 8 */
+    iupImageInitColorTable(ih, colors, &colors_count);
+
+  bmih = malloc(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*colors_count);
+  if (!bmih)
+    return NULL;
+
+  memset(bmih, 0, sizeof(BITMAPINFOHEADER));
+  bmih->biSize = sizeof(BITMAPINFOHEADER);
+  bmih->biWidth  = width;
+  bmih->biHeight = height;
+  bmih->biPlanes = 1; /* not the same as PLANES */
+  bmih->biBitCount = (WORD)bpp;
+  bmih->biCompression = BI_RGB;
+  bmih->biClrUsed = colors_count;
+
+  if (colors_count)
+  {
+    /* since colors are only passed to the CreateDIBSection here, must update BGCOLOR and inactive here */
+    RGBQUAD* bitmap_colors = (RGBQUAD*)(((BYTE*)bmih) + sizeof(BITMAPINFOHEADER));
+    if (winImageInitDibColors(colors, bitmap_colors, colors_count, bg_r, bg_g, bg_b, make_inactive))
+      iupAttribSetStr(ih, "_IUP_BGCOLOR_DEPEND", "1");
+  }
+
+  hDC = GetDC(NULL);
+  hBitmap = CreateDIBSection(hDC, (BITMAPINFO*)bmih, DIB_RGB_COLORS, (void**)bits, NULL, 0x0);
+  ReleaseDC(NULL, hDC);
+  free(bmih);
+
+  return hBitmap;
+}
+
+void* iupdrvImageCreateImage(Ihandle *ih, const char* bgcolor, int make_inactive)
+{
+  unsigned char bg_r = 0, bg_g = 0, bg_b = 0;
+  int y,x,bmp_line_size,data_line_size,
+      width = ih->currentwidth,
+      height = ih->currentheight,
+      channels = iupAttribGetInt(ih, "CHANNELS"),
+      flat_alpha = iupAttribGetBoolean(ih, "FLAT_ALPHA"),
+      bpp = iupAttribGetInt(ih, "BPP");
+  unsigned char *imgdata = (unsigned char*)iupAttribGetStr(ih, "WID");
+  HBITMAP hBitmap;
+  BYTE* bits;   /* DIB bitmap bits, created in CreateDIBSection and filled here */
+
+  iupStrToRGB(bgcolor, &bg_r, &bg_g, &bg_b);
+
+  hBitmap = winImageCreateBitmap(ih, width, height, bpp, &bits, bg_r, bg_g, bg_b, make_inactive);
+  if (!hBitmap)
+    return NULL;
+
+  bmp_line_size = ((width * bpp + 31) / 32) * 4;    /* DWORD aligned, 4 bytes boundary in a N bpp image */
+  data_line_size = width*channels;
+
+  /* windows bitmaps are bottom up */
+  imgdata += (height-1)*data_line_size;  /* iupimage is top down */
+
+  for (y=0; y<height; y++)
+  {
+    for (x=0; x<width; x++)
+    {
+      if (bpp != 8) /* (bpp == 32 || bpp == 24) */
+      {
+        int offset = channels*x;
+        /* Windows Bitmap order is BGRA */
+        BYTE *b = &bits[offset],
+             *g = b+1,
+             *r = g+1,
+             *a = r+1,
+             *dat = &imgdata[offset];
+
+        *r = *(dat);
+        *g = *(dat+1);
+        *b = *(dat+2);
+
+        if (channels == 4)  /* bpp==32 */
+        {
+          if (flat_alpha)
+          {
+            *a = *(dat+3);
+            *r = iupALPHABLEND(*r, bg_r, *a);
+            *g = iupALPHABLEND(*g, bg_g, *a);
+            *b = iupALPHABLEND(*b, bg_b, *a);
+            *a = 255;
+          }
+
+          if (make_inactive)
+            iupImageColorMakeInactive(r, g, b, bg_r, bg_g, bg_b);
+
+          if (!flat_alpha)
+          {
+            *a = *(dat+3);
+
+            /* RGB in RGBA DIBs are pre-multiplied by alpha to AlphaBlend usage. */
+            *r = iupALPHAPRE(*r,*a);
+            *g = iupALPHAPRE(*g,*a);
+            *b = iupALPHAPRE(*b,*a);
+          }
+        }
+      }
+      else /* bpp == 8 */
+      {
+        bits[x] = imgdata[x];
+      }
+    }
+
+    bits += bmp_line_size;
+    imgdata -= data_line_size;    /* iupimage is top down */
+  }
+
+  if (make_inactive || (channels == 4 && flat_alpha))
+    iupAttribSetStr(ih, "_IUP_BGCOLOR_DEPEND", "1");
+
+  return hBitmap;
+}
+
+static HBITMAP winImageCreateBitmask(Ihandle *ih, int invert)
+{
+  int y, x, mask_line_size,data_line_size, colors_count, set,
+      width = ih->currentwidth,
+      height = ih->currentheight,
+      channels = iupAttribGetInt(ih, "CHANNELS"),
+      bpp = iupAttribGetInt(ih, "BPP");
+  unsigned char *imgdata = (unsigned char*)iupAttribGetStr(ih, "WID");
+  HBITMAP hBitmap;
+  BYTE* bitmask, *bitmask_ptr;
+  iupColor colors[256];
+
+  if (bpp == 8)
+    iupImageInitColorTable(ih, colors, &colors_count);
+
+  mask_line_size = ((width + 15) / 16) * 2;      /* WORD aligned, 2 bytes boundary in a 1 bpp image */
+  data_line_size = width*channels;
+
+  bitmask = malloc(height * mask_line_size);
+  memset(bitmask, 0, height * mask_line_size); /* opaque */
+
+  /* mask and iupimage are top down */
+
+  bitmask_ptr = bitmask;
+  for (y=0; y<height; y++)
+  {
+    for (x=0; x<width; x++)
+    {
+      set = 0;
+
+      if (bpp == 32)
+      {
+        BYTE* dat = &imgdata[channels*x];
+        if (*(dat+3) == 0) /* full transparent alpha */
+          set = 1;
+      }
+      else if (bpp == 8)
+      {
+        unsigned char index = imgdata[x];
+        if (colors[index].a == 0) /* full transparent alpha */
+          set = 1;
+      }
+
+      if (set)
+        bitmask_ptr[x/8] |= 1 << (7 - (x % 8)); /* set transparent mask bit */
+    }
+
+    bitmask_ptr += mask_line_size;
+    imgdata += data_line_size;
+  }
+
+  if (invert)
+  {
+    int k, size = height * mask_line_size;
+    for (k = 0; k < size; k++)
+      bitmask[k] = ~bitmask[k];
+  }
+  
+  hBitmap = CreateBitmap(width, height, 1, 1, bitmask);
+  free(bitmask);
+  return hBitmap;
+}
+
+static HICON winImageCreateIcon(Ihandle *ih, int is_cursor)
+{
+  HBITMAP hBitmap, hBitmapMask;
+  ICONINFO iconinfo;
+  HICON icon;
+  char* color0 = NULL;
+
+  /* If cursor and no transparency defined, assume 0 if transparent. 
+     We do this only in Windows and because of backward compatibility. */
+  if (is_cursor)
+  {
+    int bpp = iupAttribGetInt(ih, "BPP");
+    if (bpp == 8)
+    {
+      if (!iupStrEqual(iupAttribGet(ih, "0"), "BGCOLOR") &&
+          !iupStrEqual(iupAttribGet(ih, "1"), "BGCOLOR") &&
+          !iupStrEqual(iupAttribGet(ih, "2"), "BGCOLOR"))
+      {
+        color0 = iupStrDup(iupAttribGet(ih, "0"));
+        iupAttribSetStr(ih, "0", "BGCOLOR");
+      }
+    }
+  }
+   
+  hBitmap = iupdrvImageCreateImage(ih, NULL, 0);
+  if (!hBitmap) 
+  {
+    if (color0) free(color0);
+    return NULL;
+  }
+
+  /* Transparency mask */
+  hBitmapMask = winImageCreateBitmask(ih, 0);
+  if (!hBitmapMask)
+  {
+    DeleteObject(hBitmap);
+    if (color0) free(color0);
+    return NULL;
+  }
+ 
+  /* destination = (destination AND bitmask) XOR bitmap */
+  iconinfo.hbmMask = hBitmapMask;   /* AND */
+  iconinfo.hbmColor = hBitmap;      /* XOR */
+
+  if (is_cursor)
+  {
+    int x=0,y=0;
+    iupStrToIntInt(iupAttribGet(ih, "HOTSPOT"), &x, &y, ':');
+
+    iconinfo.xHotspot = x;
+    iconinfo.yHotspot = y;
+    iconinfo.fIcon = FALSE;
+  }
+  else
+    iconinfo.fIcon = TRUE;
+  
+  icon = CreateIconIndirect(&iconinfo);
+
+  DeleteObject(hBitmap);
+  DeleteObject(hBitmapMask);
+
+  if (color0)
+  {
+    iupAttribStoreStr(ih, "0", color0);
+    free(color0);
+  }
+  
+  return icon;
+}
+
+void* iupdrvImageCreateIcon(Ihandle *ih)
+{
+  return winImageCreateIcon(ih, 0);
+}
+
+void* iupdrvImageCreateCursor(Ihandle *ih)
+{
+  return winImageCreateIcon(ih, 1);
+}
+
+void* iupdrvImageCreateMask(Ihandle *ih)
+{
+  int invert = 1;
+  if (!ih) return NULL;
+  if (iupAttribGet(ih, "_IUPIMG_NO_INVERT")) invert = 0;
+  return (void*)winImageCreateBitmask(ih, invert);
+}
+
+void* iupdrvImageLoad(const char* name, int type)
+{
+  int iup2win[3] = {IMAGE_BITMAP, IMAGE_ICON, IMAGE_CURSOR};
+  HANDLE hImage = LoadImage(iupwin_hinstance, (LPCTSTR)name, iup2win[type], 0, 0, type==0?LR_CREATEDIBSECTION:0);
+  if (!hImage && iupwin_dll_hinstance)
+    hImage = LoadImage(iupwin_dll_hinstance, (LPCTSTR)name, iup2win[type], 0, 0, type==0?LR_CREATEDIBSECTION:0);
+  if (!hImage)
+    hImage = LoadImage(NULL, (LPCTSTR)name, iup2win[type], 0, 0, LR_LOADFROMFILE|(type==0?LR_CREATEDIBSECTION:0));
+  return hImage;
+}
+
+int iupdrvImageGetInfo(void* handle, int *w, int *h, int *bpp)
+{
+  BITMAP bm;
+  if (!GetObject((HBITMAP)handle, sizeof(BITMAP), (LPSTR)&bm))
+  {
+    if (w) *w = 0;
+    if (h) *h = 0;
+    if (bpp) *bpp = 0;
+    return 0;
+  }
+  if (w) *w = bm.bmWidth;
+  if (h) *h = abs(bm.bmHeight);
+  if (bpp) *bpp = iupImageNormBpp(bm.bmBitsPixel*bm.bmPlanes);
+  return 1;
+}
+
+void iupdrvImageDestroy(void* handle, int type)
+{
+  switch (type)
+  {
+  case IUPIMAGE_IMAGE:
+    if (GetObjectType((HBITMAP)handle)==OBJ_BITMAP)
+      DeleteObject((HBITMAP)handle);
+    else
+      GlobalFree((HANDLE)handle);
+    break;
+  case IUPIMAGE_ICON:
+    DestroyIcon((HICON)handle);
+    break;
+  case IUPIMAGE_CURSOR:
+    DestroyCursor((HCURSOR)handle);
+    break;
+  }
+}
+