+ GR_COLOR lastPixmapColour = 0;
+ GR_COLOR lastMaskColour = 0;
+
+ int i, j;
+ for (i = 0; i < w; i++)
+ {
+ for (j = 0; j < h; j++)
+ {
+ unsigned char red = image.GetRed(i, j);
+ unsigned char green = image.GetGreen(i, j);
+ unsigned char blue = image.GetBlue(i, j);
+
+ GR_COLOR colour = GR_RGB(red, green, blue);
+
+ // Efficiency measure
+ if (colour != lastPixmapColour || (i == 0 && j == 0))
+ {
+ GrSetGCForeground(pixmapGC, colour);
+ lastPixmapColour = colour;
+ }
+
+ GrPoint(pixmap, pixmapGC, i, j);
+
+ if (hasMask)
+ {
+ // scan the bitmap for the transparent colour and set the corresponding
+ // pixels in the mask to BLACK and the rest to WHITE
+ if (maskR == red && maskG == green && maskB == blue)
+ {
+ colour = GR_RGB(0, 0, 0);
+ }
+ else
+ {
+ colour = GR_RGB(255, 255, 255);
+ }
+ if (colour != lastMaskColour || (i == 0 && j == 0))
+ {
+ GrSetGCForeground(maskGC, colour);
+ lastMaskColour = colour;
+ }
+ GrPoint(maskPixmap, maskGC, i, j);
+ }
+ }
+ }
+
+ GrDestroyGC(pixmapGC);
+ if (hasMask)
+ GrDestroyGC(maskGC);
+
+ return true;
+#else
+ // !wxUSE_NANOX
+
+ UnRef();
+
+ wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
+ wxCHECK_MSG( depth == -1, false, wxT("invalid bitmap depth") );
+
+ m_refData = new wxBitmapRefData();
+
+ M_BMPDATA->m_display = wxGlobalDisplay();
+
+ Display *xdisplay = (Display*) M_BMPDATA->m_display;
+
+ int xscreen = DefaultScreen( xdisplay );
+ Window xroot = RootWindow( xdisplay, xscreen );
+ Visual* xvisual = DefaultVisual( xdisplay, xscreen );
+
+ int bpp = wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_visualDepth;
+
+ int width = image.GetWidth();
+ int height = image.GetHeight();
+ M_BMPDATA->m_width = width;
+ M_BMPDATA->m_height = height;
+
+ if (depth != 1) depth = bpp;
+ M_BMPDATA->m_bpp = depth;
+
+ if (depth == 1)
+ {
+ wxFAIL_MSG( wxT("mono images later") );
+ }
+ else
+ {
+ // Create image
+
+ XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
+ data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
+
+ if (data_image->data == NULL)
+ {
+ wxLogError( wxT("Out of memory.") ); // TODO clean
+ return false;
+ }
+
+ M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );
+
+ // Create mask
+
+ XImage *mask_image = (XImage*) NULL;
+ if (image.HasMask())
+ {
+ mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
+ mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
+
+ if (mask_image->data == NULL)
+ {
+ wxLogError( wxT("Out of memory.") ); // TODO clean
+ return false;
+ }
+
+ wxMask *mask = new wxMask();
+ mask->SetDisplay( xdisplay );
+ mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );
+
+ SetMask( mask );
+ }
+
+ if (bpp < 8) bpp = 8;
+
+ // Render
+
+ enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
+ byte_order b_o = RGB;
+
+ wxXVisualInfo* vi = wxTheApp->GetVisualInfo(M_BMPDATA->m_display);
+ unsigned long greenMask = vi->m_visualGreenMask,
+ redMask = vi->m_visualRedMask,
+ blueMask = vi->m_visualBlueMask;
+
+ if (bpp > 8)
+ {
+ if ((redMask > greenMask) && (greenMask > blueMask)) b_o = RGB;
+ else if ((redMask > blueMask) && (blueMask > greenMask)) b_o = RBG;
+ else if ((blueMask > redMask) && (redMask > greenMask)) b_o = BRG;
+ else if ((blueMask > greenMask) && (greenMask > redMask))b_o = BGR;
+ else if ((greenMask > redMask) && (redMask > blueMask)) b_o = GRB;
+ else if ((greenMask > blueMask) && (blueMask > redMask)) b_o = GBR;
+ }
+
+ int r_mask = image.GetMaskRed();
+ int g_mask = image.GetMaskGreen();
+ int b_mask = image.GetMaskBlue();
+
+ unsigned char* data = image.GetData();
+ wxASSERT_MSG( data, wxT("No image data") );
+
+ unsigned char *colorCube =
+ wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;
+
+ bool hasMask = image.HasMask();
+
+ int index = 0;
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ int r = data[index];
+ index++;
+ int g = data[index];
+ index++;
+ int b = data[index];
+ index++;
+
+ if (hasMask)
+ {
+ if ((r == r_mask) && (b == b_mask) && (g == g_mask))
+ XPutPixel( mask_image, x, y, 0 );
+ else
+ XPutPixel( mask_image, x, y, 1 );
+ }
+
+ switch (bpp)
+ {
+ case 8:
+ {
+ int pixel = 0;
+ pixel = colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 12: // SGI only
+ {
+ int pixel = 0;
+ switch (b_o)
+ {
+ case RGB: pixel = ((r & 0xf0) << 4) | (g & 0xf0) | ((b & 0xf0) >> 4); break;
+ case RBG: pixel = ((r & 0xf0) << 4) | (b & 0xf0) | ((g & 0xf0) >> 4); break;
+ case GRB: pixel = ((g & 0xf0) << 4) | (r & 0xf0) | ((b & 0xf0) >> 4); break;
+ case GBR: pixel = ((g & 0xf0) << 4) | (b & 0xf0) | ((r & 0xf0) >> 4); break;
+ case BRG: pixel = ((b & 0xf0) << 4) | (r & 0xf0) | ((g & 0xf0) >> 4); break;
+ case BGR: pixel = ((b & 0xf0) << 4) | (g & 0xf0) | ((r & 0xf0) >> 4); break;
+ }
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 15:
+ {
+ int pixel = 0;
+ switch (b_o)
+ {
+ case RGB: pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
+ case RBG: pixel = ((r & 0xf8) << 7) | ((b & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
+ case GRB: pixel = ((g & 0xf8) << 7) | ((r & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
+ case GBR: pixel = ((g & 0xf8) << 7) | ((b & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
+ case BRG: pixel = ((b & 0xf8) << 7) | ((r & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
+ case BGR: pixel = ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
+ }
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 16:
+ {
+ // I actually don't know if for 16-bit displays, it is alway the green
+ // component or the second component which has 6 bits.
+ int pixel = 0;
+ switch (b_o)
+ {
+ case RGB: pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
+ case RBG: pixel = ((r & 0xf8) << 8) | ((b & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
+ case GRB: pixel = ((g & 0xf8) << 8) | ((r & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
+ case GBR: pixel = ((g & 0xf8) << 8) | ((b & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
+ case BRG: pixel = ((b & 0xf8) << 8) | ((r & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
+ case BGR: pixel = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
+ }
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 32:
+ case 24:
+ {
+ int pixel = 0;
+ switch (b_o)
+ {
+ case RGB: pixel = (r << 16) | (g << 8) | b; break;
+ case RBG: pixel = (r << 16) | (b << 8) | g; break;
+ case BRG: pixel = (b << 16) | (r << 8) | g; break;
+ case BGR: pixel = (b << 16) | (g << 8) | r; break;
+ case GRB: pixel = (g << 16) | (r << 8) | b; break;
+ case GBR: pixel = (g << 16) | (b << 8) | r; break;
+ }
+ XPutPixel( data_image, x, y, pixel );
+ }
+ default: break;
+ }
+ } // for
+ } // for
+
+ // Blit picture
+
+ GC gc = XCreateGC( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, 0, NULL );
+ XPutImage( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, gc, data_image, 0, 0, 0, 0, width, height );
+ XDestroyImage( data_image );
+ XFreeGC( xdisplay, gc );
+
+ // Blit mask
+
+ if (image.HasMask())
+ {
+ GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
+ XPutImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), gc, mask_image, 0, 0, 0, 0, width, height );
+
+ XDestroyImage( mask_image );
+ XFreeGC( xdisplay, gc );
+ }
+ }
+
+ return true;
+#endif
+ // wxUSE_NANOX
projects / wxWidgets.git / blobdiff