void CxSkinButton::DrawBitmap(CDC* dc, HBITMAP hbmp, RECT r, int DrawMode)
{
// DrawMode: 0=Normal; 1=stretch; 2=tiled fill
if(DrawMode==2){
FillWithBitmap(dc,hbmp,r);
return;
}
if(!hbmp) return; //safe check
int cx=r.right - r.left;
int cy=r.bottom - r.top;
CDC dcBmp,dcMask;
dcBmp.CreateCompatibleDC(dc);
dcBmp.SelectObject(hbmp);
if (m_bMask.m_hObject!=NULL){
dcMask.CreateCompatibleDC(dc);
dcMask.SelectObject(m_bMask);
CDC hdcMem;
hdcMem.CreateCompatibleDC(dc);
CBitmap hBitmap;
hBitmap.CreateCompatibleBitmap(dc,cx,cy);
hdcMem.SelectObject(hBitmap);
hdcMem.BitBlt(r.left,r.top,cx,cy,dc,0,0,SRCCOPY);
if(!DrawMode){
hdcMem.BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCINVERT);
hdcMem.BitBlt(r.left,r.top,cx,cy,&dcMask,0,0,SRCAND);
hdcMem.BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCINVERT);
} else {
int bx=GetBitmapWidth(hbmp);
int by=GetBitmapHeight(hbmp);
hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCINVERT);
hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcMask,0,0,bx,by,SRCAND);
hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCINVERT);
}
dc->BitBlt(r.left,r.top,cx,cy,&hdcMem,0,0,SRCCOPY);
hdcMem.DeleteDC();
hBitmap.DeleteObject();
DeleteDC(dcMask);
} else {
if(!DrawMode){
dc->BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCCOPY);
} else {
int bx=GetBitmapWidth(hbmp);
int by=GetBitmapHeight(hbmp);
dc->StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCCOPY);
}
}
DeleteDC(dcBmp);
}
void
wxLCDWindow::OnPaint(wxPaintEvent& event)
{
wxPaintDC dc(this);
int dw = GetClientSize().GetWidth();
int dh = GetClientSize().GetHeight();
int bw = GetBitmapWidth();
int bh = GetBitmapHeight();
double xs = (double) dw / bw;
double ys = (double) dh / bh;
double as = xs > ys? ys : xs;
dc.SetUserScale(as, as);
dc.SetDeviceOrigin(((dw - bw * as) / 2), ((dh - bh * as) / 2));
DoDrawing(&dc);
}
void CxSkinButton::FillWithBitmap(CDC* dc, HBITMAP hbmp, RECT r)
{
if(!hbmp) return;
CDC memdc;
memdc.CreateCompatibleDC(dc);
memdc.SelectObject(hbmp);
int w = r.right - r.left;
int h = r.bottom - r.top;
int x,y,z;
int bx=GetBitmapWidth(hbmp);
int by=GetBitmapHeight(hbmp);
for (y = r.top ; y < h ; y += by){
if ((y+by)>h) by=h-y;
z=bx;
for (x = r.left ; x < w ; x += z){
if ((x+z)>w) z=w-x;
dc->BitBlt(x, y, z, by, &memdc, 0, 0, SRCCOPY);
}
}
DeleteDC(memdc);
}
void CSkinTab::DrawBitmap(CDC* dc, HBITMAP hbmp, CRect rect)
{
RECT r;
r.left = rect.left;
r.top = rect.top;
r.right = rect.right;
r.bottom = rect.bottom;
if(!hbmp)
return;
int cx=r.right - r.left;
int cy=r.bottom - r.top;
int xbmp = GetBitmapWidth(hbmp);
int ybmp = GetBitmapHeight(hbmp);
CDC l_BufferDC ;
l_BufferDC.CreateCompatibleDC( dc) ;
CBitmap l_BufferBitmap ;
l_BufferBitmap.CreateCompatibleBitmap( dc, cx, cy ) ;
CBitmap* l_pOldBufferBitmap = l_BufferDC.SelectObject( &l_BufferBitmap ) ;
CDC l_MaskDC ;
l_MaskDC.CreateCompatibleDC( dc ) ;
CBitmap l_MaskBitmap ;
l_MaskBitmap.CreateBitmap( cx, cy, 1, 1, NULL ) ;
CBitmap* l_pOldMaskBitmap = l_MaskDC.SelectObject( &l_MaskBitmap ) ;
#define ROP4_TRANSPARENTBLIT 0xCCAA0020
#define SRCMASK 0x00220326
l_BufferDC.FillSolidRect( r.left,r.top,r.right,r.bottom, RGB( 255, 0, 255 ) ) ;
CDC l_MemoryDC ;
l_MemoryDC.CreateCompatibleDC( dc) ;
l_MemoryDC.SelectObject(hbmp) ;
////画图标
//RECT rico;
//rico.left=0;
//rico.top = 0;
//rico.right = xbmp;
//rico.bottom = ybmp;
//DrawIcon(&l_MemoryDC,rico,D_TOP);
////画标题
//RECT rbmp;
//rbmp.left=0;
//rbmp.top = 0;
//rbmp.right = xbmp;
//rbmp.bottom = ybmp;
//DrawTitle(&l_MemoryDC, rbmp);
l_BufferDC.BitBlt( 0, 0, cx, cy, &l_MemoryDC, 0, 0, SRCCOPY ) ;
COLORREF l_crOldBack = l_BufferDC.SetBkColor( RGB( 255, 0, 255 ) ) ;
l_MaskDC.BitBlt( 0, 0, cx, cy, &l_BufferDC, 0, 0, SRCCOPY ) ;
l_BufferDC.SetBkColor( l_crOldBack ) ;
if(!dc->MaskBlt( r.left, r.top, cx,cy,&l_BufferDC,0,0,l_MaskBitmap,0,0,ROP4_TRANSPARENTBLIT ) )
{
CDC l_CopyDC ;
l_CopyDC.CreateCompatibleDC( dc ) ;
CBitmap l_CopyBitmap ;
l_CopyBitmap.CreateCompatibleBitmap(dc, cx, cy ) ;
CBitmap* l_pOldCopyBitmap = l_CopyDC.SelectObject( &l_CopyBitmap ) ;
l_CopyDC.BitBlt( 0, 0, cx, cy, dc, 0, 0, SRCCOPY ) ;
l_CopyDC.BitBlt( 0, 0, cx, cy, &l_MaskDC, 0, 0, SRCAND ) ;
l_BufferDC.BitBlt( 0, 0, cx, cy, &l_MaskDC, 0, 0, SRCMASK ) ;
l_CopyDC.BitBlt( 0, 0, cx, cy, &l_BufferDC, 0, 0, SRCPAINT ) ;
dc->BitBlt( 0, 0, cx, cy, &l_CopyDC, 0, 0, SRCCOPY ) ;
l_CopyDC.SelectObject( l_pOldCopyBitmap ) ;
}
}
StrBuf* GenLynxSprite (const Bitmap* B, const Collection* A)
/* Generate binary output in Lynx sprite format for the bitmap B. The output
* is stored in a string buffer (which is actually a dynamic char array) and
* returned.
*
* The Lynx will draw 4 quadrants:
* - Down right
* - Up right
* - Up left
* - Down left
*
* The sprite will end with a byte 0.
*/
{
enum Mode M;
StrBuf* D;
signed X, Y;
unsigned OX, OY;
char ColorBits;
char ColorMask;
char EdgeIndex;
/* Get EdgeIndex */
EdgeIndex = GetEdgeIndex (A);
/* Action point of the sprite */
OX = GetActionPointX (A);
OY = GetActionPointY (A);
if (OX >= GetBitmapWidth (B)) {
Error ("Action point X cannot be larger than bitmap width");
}
if (OY >= GetBitmapHeight (B)) {
Error ("Action point Y cannot be larger than bitmap height");
}
printf("OX = %d OY = %d\n", OX, OY);
/* Output the image properties */
Print (stdout, 1, "Image is %ux%u with %u colors%s\n",
GetBitmapWidth (B), GetBitmapHeight (B), GetBitmapColors (B),
BitmapIsIndexed (B)? " (indexed)" : "");
/* Get the sprite mode */
M = GetMode (A);
/* Now check if bitmap indexes are ok */
if (GetBitmapColors (B) > 16) {
Error ("Too many colors for a Lynx sprite");
}
ColorBits = 4;
ColorMask = 0x0f;
if (GetBitmapColors (B) < 9) {
ColorBits = 3;
ColorMask = 0x07;
}
if (GetBitmapColors (B) < 5) {
ColorBits = 2;
ColorMask = 0x03;
}
if (GetBitmapColors (B) < 3) {
ColorBits = 1;
ColorMask = 0x01;
}
/* Create the output buffer and resize it to the required size. */
D = NewStrBuf ();
SB_Realloc (D, 63);
/* Convert the image for quadrant bottom right */
for (Y = OY; Y < (signed)GetBitmapHeight (B); ++Y) {
signed i = 0;
signed LastOpaquePixel = -1;
char LineBuffer[512]; /* The maximum size is 508 pixels */
/* Fill the LineBuffer for easier optimisation */
for (X = OX; X < (signed)GetBitmapWidth (B); ++X) {
/* Fetch next bit into byte buffer */
LineBuffer[i] = GetPixel (B, X, Y).Index & ColorMask;
if (LineBuffer[i] != EdgeIndex) {
LastOpaquePixel = i;
}
++i;
}
encodeSprite(D, M, ColorBits, ColorMask, LineBuffer, i, LastOpaquePixel);
}
if ((OY == 0) && (OX == 0)) {
/* Trivial case only one quadrant */
/* Mark end of sprite */
SB_AppendChar (D, 0);
/* Return the converted bitmap */
return D;
}
/* Next quadrant */
SB_AppendChar (D, 1);
/* Convert the image for quadrant top right */
for (Y = OY - 1; Y >= 0; --Y) {
signed i = 0;
signed LastOpaquePixel = -1;
char LineBuffer[512]; /* The maximum size is 508 pixels */
/* Fill the LineBuffer for easier optimisation */
for (X = OX; X < (signed)GetBitmapWidth (B); ++X) {
/* Fetch next bit into byte buffer */
LineBuffer[i] = GetPixel (B, X, Y).Index & ColorMask;
if (LineBuffer[i] != EdgeIndex) {
LastOpaquePixel = i;
}
++i;
}
encodeSprite(D, M, ColorBits, ColorMask, LineBuffer, i, LastOpaquePixel);
}
if (OX == 0) {
/* Special case only two quadrants */
/* Mark end of sprite */
SB_AppendChar (D, 0);
/* Return the converted bitmap */
return D;
}
/* Next quadrant */
SB_AppendChar (D, 1);
/* Convert the image for quadrant top left */
for (Y = OY - 1; Y >= 0; --Y) {
signed i = 0;
signed LastOpaquePixel = -1;
char LineBuffer[512]; /* The maximum size is 508 pixels */
/* Fill the LineBuffer for easier optimisation */
for (X = OX - 1; X >= 0; --X) {
/* Fetch next bit into byte buffer */
LineBuffer[i] = GetPixel (B, X, Y).Index & ColorMask;
if (LineBuffer[i] != EdgeIndex) {
LastOpaquePixel = i;
}
++i;
}
encodeSprite(D, M, ColorBits, ColorMask, LineBuffer, i, LastOpaquePixel);
}
/* Next quadrant */
SB_AppendChar (D, 1);
/* Convert the image for quadrant bottom left */
for (Y = OY; Y < (signed)GetBitmapHeight (B); ++Y) {
signed i = 0;
signed LastOpaquePixel = -1;
char LineBuffer[512]; /* The maximum size is 508 pixels */
/* Fill the LineBuffer for easier optimisation */
for (X = OX - 1; X >= 0; --X) {
/* Fetch next bit into byte buffer */
LineBuffer[i] = GetPixel (B, X, Y).Index & ColorMask;
if (LineBuffer[i] != EdgeIndex) {
LastOpaquePixel = i;
}
++i;
}
encodeSprite(D, M, ColorBits, ColorMask, LineBuffer, i, LastOpaquePixel);
}
/* End sprite */
SB_AppendChar (D, 0);
/* Return the converted bitmap */
return D;
}
void WriteCFile (const StrBuf* Data, const Collection* A, const Bitmap* B)
/* Write the contents of Data to a file in C format */
{
FILE* F;
const char* D;
unsigned Size;
/* Get the name of the image */
const StrBuf* S = GetBitmapName (B);
/* Get the file name */
const char* Name = NeedAttrVal (A, "name", "write");
/* Check the number of bytes per line */
unsigned BytesPerLine = GetBytesPerLine (A);
/* Get the number base */
unsigned Base = GetBase (A);
/* Get the identifier */
const char* Ident = GetIdentifier (A);
/* Open the output file */
F = fopen (Name, "w");
if (F == 0) {
Error ("Cannot open output file `%s': %s", Name, strerror (errno));
}
/* Write a readable header */
fprintf (F,
"/*\n"
"** This file was generated by %s %s from\n"
"** %.*s (%ux%u, %u colors%s)\n"
"*/\n"
"\n",
ProgName,
GetVersionAsString (),
SB_GetLen (S), SB_GetConstBuf (S),
GetBitmapWidth (B), GetBitmapHeight (B),
GetBitmapColors (B),
BitmapIsIndexed (B)? ", indexed" : "");
/* If an identifier was given, output #defines for width, height, the
** number of colors and declare a variable for the data.
*/
if (Ident) {
fprintf (F,
"#define %s_COLORS %u\n"
"#define %s_WIDTH %u\n"
"#define %s_HEIGHT %u\n"
"const unsigned char %s[] = {\n",
Ident, GetBitmapColors (B),
Ident, GetBitmapWidth (B),
Ident, GetBitmapHeight (B),
Ident);
}
/* Write the data */
D = SB_GetConstBuf (Data);
Size = SB_GetLen (Data);
while (Size) {
unsigned I;
/* Output one line */
unsigned Chunk = Size;
if (Chunk > BytesPerLine) {
Chunk = BytesPerLine;
}
fputs (" ", F);
for (I = 0; I < Chunk; ++I) {
switch (Base) {
case 10:
fprintf (F, "%u,", *D++ & 0xFF);
break;
case 16:
fprintf (F, "0x%02X,", *D++ & 0xFF);
break;
}
}
fputc ('\n', F);
/* Bump the counters */
Size -= Chunk;
}
/* Terminate the array if we had an identifier */
if (Ident) {
fputs ("};\n", F);
}
/* Close the file */
if (fclose (F) != 0) {
Error ("Error closing output file `%s': %s", Name, strerror (errno));
}
}
StrBuf* GenVic2Sprite (const Bitmap* B, const Collection* A)
/* Generate binary output in VICII sprite format for the bitmap B. The output
** is stored in a string buffer (which is actually a dynamic char array) and
** returned.
*/
{
enum Mode M;
StrBuf* D;
unsigned X, Y;
/* Output the image properties */
Print (stdout, 1, "Image is %ux%u with %u colors%s\n",
GetBitmapWidth (B), GetBitmapHeight (B), GetBitmapColors (B),
BitmapIsIndexed (B)? " (indexed)" : "");
/* Get the sprite mode */
M = GetMode (A);
/* Check the height of the bitmap */
if (GetBitmapHeight (B) != HEIGHT) {
Error ("Invalid bitmap height (%u) for conversion to vic2 sprite",
GetBitmapHeight (B));
}
/* If the mode wasn't given, determine it from the image properties */
if (M == smAuto) {
switch (GetBitmapWidth (B)) {
case WIDTH_HR:
M = smHighRes;
break;
case WIDTH_MC:
M = smMultiColor;
break;
default:
Error ("Cannot determine mode from image properties");
}
}
/* Now check if mode and the image properties match */
if (M == smMultiColor) {
if (GetBitmapWidth (B) != WIDTH_MC || GetBitmapColors (B) > 4) {
Error ("Invalid image properties for multicolor sprite");
}
} else {
if (GetBitmapWidth (B) != WIDTH_HR || GetBitmapColors (B) > 2) {
Error ("Invalid image properties for highres sprite");
}
}
/* Create the output buffer and resize it to the required size. */
D = NewStrBuf ();
SB_Realloc (D, 63);
/* Convert the image */
for (Y = 0; Y < HEIGHT; ++Y) {
unsigned char V = 0;
if (M == smHighRes) {
for (X = 0; X < WIDTH_HR; ++X) {
/* Fetch next bit into byte buffer */
V = (V << 1) | (GetPixel (B, X, Y).Index & 0x01);
/* Store full bytes into the output buffer */
if ((X & 0x07) == 0x07) {
SB_AppendChar (D, V);
V = 0;
}
}
} else {
for (X = 0; X < WIDTH_MC; ++X) {
/* Fetch next bit into byte buffer */
V = (V << 2) | (GetPixel (B, X, Y).Index & 0x03);
/* Store full bytes into the output buffer */
if ((X & 0x03) == 0x03) {
SB_AppendChar (D, V);
V = 0;
}
}
}
}
/* Return the converted bitmap */
return D;
}
