void CreateMenuBitmaps(void)
{
HBITMAP bitmaps[sizeof(MenuBitmapIDs)/sizeof(int)];
HDC hDC = GetDC(hwndFrame);
int i;
for (i=0; i < sizeof(MenuBitmapIDs)/sizeof(int); i++)
{
bitmaps[i] = LoadBitmap(hInstance, (LPTSTR)MenuBitmapIDs[i]);
}
for (i=0; i < sizeof(MenuBitmaps)/ sizeof(struct menuBitmap); i++)
{
DWORD n = GetVersion();
if (LOBYTE(LOWORD(n)) >= 6)
{
// windows 7 or later, use transparent bitmaps
MenuBitmaps[i].bitmap = ConvertToTransparent(CopyBitmap(hwndFrame, bitmaps[MenuBitmaps[i].bitmapNum],
MenuBitmaps[i].submapNum * 16, 0 , 16, 16), 0xc0c0c0);
}
else
{
// windows XP or earlier, change the bitmap background...
MenuBitmaps[i].bitmap = CopyBitmap(hwndFrame, bitmaps[MenuBitmaps[i].bitmapNum],
MenuBitmaps[i].submapNum * 16, 0 , 16, 16);
ChangeBitmapColor(MenuBitmaps[i].bitmap, 0xc0c0c0, RetrieveSysColor(COLOR_MENU));
}
}
for (i=0; i < sizeof(MenuBitmapIDs)/sizeof(int); i++)
DeleteObject(bitmaps[i]);
ReleaseDC(hwndFrame, hDC);
}
void CSkinProgress::CopyFrom(CRect r, CBitmap &m_N, CBitmap &m_Dw)
{
CDC* dc = GetDC();
CopyBitmap(dc, m_Normal, m_N, r);
CopyBitmap(dc, m_Down, m_Dw, r);
ModifyStyle(WS_BORDER | WS_TABSTOP , 0);
}
void ClientView::CopyBitmap(const BBitmap *bmp, BRect frame, bool diff)
{
if(diff)
AddBitmap(mBmp, frame, bmp);
else
CopyBitmap(mBmp, frame, bmp);
BMessage msg(UPDATE);
msg.AddRect("rect", frame);
Window()->PostMessage(&msg, this);
}
BOOL CDlgCfgSetUptTime::OnInitDialog()
{
CNonFrameChildDlg::OnInitDialog();
SetTitle(_T("起始时间设置"));
wnddateStart_.SetTime(&CTime(2009, 1, 1, 21, 0, 0));
wnddateEnd_.SetTime(&CTime(2009, 1, 1, 23, 59, 0));
// Out Line
outboxLine_.Attach(CopyBitmap(i8desk::ui::SkinMgrInstance().GetSkin(_T("Common/ControlOutBox.png"))));
wndStartTime_.SetThemeParent(GetSafeHwnd());
wndStopTime_.SetThemeParent(GetSafeHwnd());
return TRUE;
}
/**
* Create the clipboard data for a given format.
* This assumes that the clipboard is open.
* @param HGLOBAL hData the clipboard data.
* @param size_t maxMemory the max memory we want to allow to prevent lock-up.
* @return ClipboardData*|NULL either the data or NULL if the format does not exist.
*/
ClipboardData* ClipboardData::FromClipboardBitmap(HGLOBAL hData, size_t maxMemory)
{
// check the memory size.
if (maxMemory > 0 && GetBitmapSize((HBITMAP)hData) > maxMemory)
{
return NULL;
}
// build the data clipboard so we can restore it.
ClipboardData *cf = new ClipboardData();
// copy the meta file.
cf->data = static_cast<void*>(CopyBitmap( (HBITMAP)hData ));
cf->dataSize = 0;
cf->uFormat = CF_BITMAP;
// return the created filedata.
return cf;
}
BOOL CSkinProgress::ConvertBitmap(
CBitmap *pDestBmp,
CBitmap *pSrcBmp,
CDC *pDC)
{
BITMAP SrcBmpInfo;
BITMAPINFO sBmpInfoSrc;
HBITMAP BMPInfo;
unsigned char *pDataBmp;
DWORD dwDataCount;
int nResult;
pDataBmp = NULL;
if (pDestBmp != NULL && pSrcBmp != NULL)
{
if (pDC == NULL)
{
CPaintDC PaintDC(m_hWnd);
pDC = &PaintDC;
}
pSrcBmp->GetBitmap(&SrcBmpInfo);
if (SrcBmpInfo.bmBitsPixel == GetDeviceCaps(*pDC, BITSPIXEL))
{
nResult = (int) CopyBitmap(pDestBmp, pSrcBmp);
}else
{
dwDataCount = SrcBmpInfo.bmWidthBytes * SrcBmpInfo.bmHeight;
pDataBmp = new unsigned char[dwDataCount];
if (pDataBmp != NULL)
{
pSrcBmp->GetBitmapBits(dwDataCount, pDataBmp);
SrcBmpInfo.bmBits = pDataBmp;
sBmpInfoSrc.bmiColors[0].rgbBlue = 0;
sBmpInfoSrc.bmiColors[0].rgbGreen = 0;
sBmpInfoSrc.bmiColors[0].rgbRed = 0;
sBmpInfoSrc.bmiColors[0].rgbReserved = 0;
sBmpInfoSrc.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
sBmpInfoSrc.bmiHeader.biWidth = SrcBmpInfo.bmWidth;
sBmpInfoSrc.bmiHeader.biHeight = 0 - SrcBmpInfo.bmHeight;
sBmpInfoSrc.bmiHeader.biPlanes = SrcBmpInfo.bmPlanes;
sBmpInfoSrc.bmiHeader.biBitCount = SrcBmpInfo.bmBitsPixel;
sBmpInfoSrc.bmiHeader.biCompression = BI_RGB;
sBmpInfoSrc.bmiHeader.biSizeImage = 0;
sBmpInfoSrc.bmiHeader.biXPelsPerMeter = 0;
sBmpInfoSrc.bmiHeader.biYPelsPerMeter = 0;
sBmpInfoSrc.bmiHeader.biClrUsed = 0;
sBmpInfoSrc.bmiHeader.biClrImportant = 0;
BMPInfo = CreateDIBitmap(pDC->m_hDC, &sBmpInfoSrc.bmiHeader, CBM_INIT, pDataBmp, &sBmpInfoSrc, DIB_RGB_COLORS);
CBitmap TempBmp(BMPInfo);
nResult = (int) CopyBitmap(pDestBmp, &TempBmp);
DeleteObject(BMPInfo);
delete[] pDataBmp;
if (nResult != 0)
{
return true;
}
}
}
}
return false;
}
BOOL CSkinProgress::SetBitmap(
CBitmap *pTempBitmap,
BOOL bDisplay)
{
BITMAP sBmpSrc;
HBITMAP hOldBitmap;
HBITMAP hOldStretch;
CRect WndRect;
CDC BmpDC;
CDC StretchDC;
mPaintRect.SetRect(0, 0, 0, 0);
GetClientRect(&WndRect);
CPaintDC PaintDC(m_hWnd);
if (mpBaseBmp != NULL)
delete mpBaseBmp;
mpBaseBmp = new CBitmap;
if (mpCompatibleBmp != NULL)
delete mpCompatibleBmp;
mpCompatibleBmp = new CBitmap;
if (pTempBitmap == NULL)
return FALSE;
CopyBitmap(mpBaseBmp, pTempBitmap);
ConvertBitmap(mpCompatibleBmp, mpBaseBmp, &PaintDC);
mpCompatibleBmp->GetBitmap(&sBmpSrc);
mnBmpWidth = sBmpSrc.bmWidth / SKIN_PROGRESS_BITMAP_COUNT;
mnBmpHeight = sBmpSrc.bmHeight;
if (mpStretchBmp != NULL)
delete mpStretchBmp;
mpStretchBmp = new CBitmap;
mpStretchBmp->CreateCompatibleBitmap(PaintDC, sBmpSrc.bmWidth, WndRect.Height() - 2);
BmpDC.CreateCompatibleDC(PaintDC);
hOldBitmap = BmpDC.SelectBitmap(*mpCompatibleBmp);
StretchDC.CreateCompatibleDC(PaintDC);
hOldStretch = StretchDC.SelectBitmap(*mpStretchBmp);
StretchDC.SetStretchBltMode(HALFTONE);
StretchDC.StretchBlt(0, 0, sBmpSrc.bmWidth, WndRect.Height() - 2, BmpDC, 0, 0, sBmpSrc.bmWidth, sBmpSrc.bmHeight, SRCCOPY);
StretchDC.SelectBitmap(hOldStretch);
StretchDC.DeleteDC();
BmpDC.SelectBitmap(hOldBitmap);
BmpDC.DeleteDC();
mpStretchBmp->GetBitmap(&sBmpSrc);
mnBmpWidth = sBmpSrc.bmWidth / SKIN_PROGRESS_BITMAP_COUNT;
mnBmpHeight = sBmpSrc.bmHeight;
mBarImageList.Destroy();
if(!mBarImageList.Create(mnBmpWidth, mnBmpHeight, ILC_COLOR32, 0, 0))
{
return false;
}else
{
mBarImageList.Add(*mpStretchBmp, RGB(0, 255, 255));
if (bDisplay != false)
{
OnCalcPos();
}
return true;
}
}
void ClipboardData::ToClipboard()
{
// do we have a name to restore??
UINT format = uFormat;
if ( dataName != NULL)
{
UINT u = RegisterClipboardFormat( dataName);
if (u > 0)
{
// the format has changed it seems.
format = u;
}
}
switch (format)
{
case CF_HDROP:
{
ClipboardDropData* cdd = static_cast<ClipboardDropData*>(data);
// get the size of the clipboard.
size_t size = cdd->GetDropfilesSize();
if (size > 0)
{
// make some room for this DROPFILES item.
HGLOBAL hGlobal = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, size);
// lock it so we can now use it.
DROPFILES *df = (DROPFILES*)GlobalLock(hGlobal);
// populate the data if we can.
if (cdd->PopulateDropFiles(df, size))
{
// release the lock
GlobalUnlock(hGlobal);
// set the data in the clipboard.
SetClipboardData(CF_HDROP, hGlobal);
}
else
{
// release the lock
GlobalUnlock(hGlobal);
// free the memory
GlobalFree(hGlobal);
}
}
}
break;
case CF_ENHMETAFILE:
SetClipboardData(CF_ENHMETAFILE, CopyEnhMetaFile((HENHMETAFILE)data, NULL));
break;
case CF_BITMAP:
SetClipboardData(CF_BITMAP, CopyBitmap( (HBITMAP)data ));
break;
default:
if (dataSize > 0)
{
// get some data
HGLOBAL hGlobal = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, dataSize);
void* pMem = GlobalLock(hGlobal);
memcpy(pMem, data, dataSize);
GlobalUnlock(hGlobal);
// we can no save the data.
SetClipboardData(format, hGlobal);
}
else
{
// there is no data to set...
SetClipboardData(format, 0);
}
break;
}
}
status_t
BIcon::_MakeBitmaps(const BBitmap* bitmap, uint32 flags)
{
// make our own versions of the bitmap
BRect b(bitmap->Bounds());
color_space format = bitmap->ColorSpace();
BBitmap* normalBitmap = CreateBitmap(b, format, B_INACTIVE_ICON_BITMAP);
if (normalBitmap == NULL)
return B_NO_MEMORY;
BBitmap* disabledBitmap = NULL;
if ((flags & B_CREATE_DISABLED_ICON_BITMAPS) != 0) {
disabledBitmap = CreateBitmap(b, format,
B_INACTIVE_ICON_BITMAP | B_DISABLED_ICON_BITMAP);
if (disabledBitmap == NULL)
return B_NO_MEMORY;
}
BBitmap* clickedBitmap = NULL;
if ((flags & (B_CREATE_ACTIVE_ICON_BITMAP
| B_CREATE_PARTIALLY_ACTIVE_ICON_BITMAP)) != 0) {
clickedBitmap = CreateBitmap(b, format, B_ACTIVE_ICON_BITMAP);
if (clickedBitmap == NULL)
return B_NO_MEMORY;
}
BBitmap* disabledClickedBitmap = NULL;
if (disabledBitmap != NULL && clickedBitmap != NULL) {
disabledClickedBitmap = CreateBitmap(b, format,
B_ACTIVE_ICON_BITMAP | B_DISABLED_ICON_BITMAP);
if (disabledClickedBitmap == NULL)
return B_NO_MEMORY;
}
// copy bitmaps from file bitmap
uint8* nBits = normalBitmap != NULL ? (uint8*)normalBitmap->Bits() : NULL;
uint8* dBits = disabledBitmap != NULL
? (uint8*)disabledBitmap->Bits() : NULL;
uint8* cBits = clickedBitmap != NULL ? (uint8*)clickedBitmap->Bits() : NULL;
uint8* dcBits = disabledClickedBitmap != NULL
? (uint8*)disabledClickedBitmap->Bits() : NULL;
uint8* fBits = (uint8*)bitmap->Bits();
int32 nbpr = normalBitmap->BytesPerRow();
int32 fbpr = bitmap->BytesPerRow();
int32 pixels = b.IntegerWidth() + 1;
int32 lines = b.IntegerHeight() + 1;
if (format == B_RGB32 || format == B_RGB32_BIG) {
// nontransparent version
// iterate over color components
for (int32 y = 0; y < lines; y++) {
for (int32 x = 0; x < pixels; x++) {
int32 nOffset = 4 * x;
int32 fOffset = 4 * x;
nBits[nOffset + 0] = fBits[fOffset + 0];
nBits[nOffset + 1] = fBits[fOffset + 1];
nBits[nOffset + 2] = fBits[fOffset + 2];
nBits[nOffset + 3] = 255;
// clicked bits are darker (lame method...)
if (cBits != NULL) {
cBits[nOffset + 0] = uint8((float)nBits[nOffset + 0] * 0.8);
cBits[nOffset + 1] = uint8((float)nBits[nOffset + 1] * 0.8);
cBits[nOffset + 2] = uint8((float)nBits[nOffset + 2] * 0.8);
cBits[nOffset + 3] = 255;
}
// disabled bits have less contrast (lame method...)
if (dBits != NULL) {
uint8 grey = 216;
float dist = (nBits[nOffset + 0] - grey) * 0.4;
dBits[nOffset + 0] = (uint8)(grey + dist);
dist = (nBits[nOffset + 1] - grey) * 0.4;
dBits[nOffset + 1] = (uint8)(grey + dist);
dist = (nBits[nOffset + 2] - grey) * 0.4;
dBits[nOffset + 2] = (uint8)(grey + dist);
dBits[nOffset + 3] = 255;
}
// disabled bits have less contrast (lame method...)
if (dcBits != NULL) {
uint8 grey = 188;
float dist = (nBits[nOffset + 0] - grey) * 0.4;
dcBits[nOffset + 0] = (uint8)(grey + dist);
dist = (nBits[nOffset + 1] - grey) * 0.4;
dcBits[nOffset + 1] = (uint8)(grey + dist);
dist = (nBits[nOffset + 2] - grey) * 0.4;
dcBits[nOffset + 2] = (uint8)(grey + dist);
dcBits[nOffset + 3] = 255;
}
}
fBits += fbpr;
nBits += nbpr;
if (cBits != NULL)
cBits += nbpr;
if (dBits != NULL)
dBits += nbpr;
if (dcBits != NULL)
dcBits += nbpr;
}
} else if (format == B_RGBA32 || format == B_RGBA32_BIG) {
// transparent version
// iterate over color components
for (int32 y = 0; y < lines; y++) {
for (int32 x = 0; x < pixels; x++) {
int32 nOffset = 4 * x;
int32 fOffset = 4 * x;
nBits[nOffset + 0] = fBits[fOffset + 0];
nBits[nOffset + 1] = fBits[fOffset + 1];
nBits[nOffset + 2] = fBits[fOffset + 2];
nBits[nOffset + 3] = fBits[fOffset + 3];
// clicked bits are darker (lame method...)
if (cBits != NULL) {
cBits[nOffset + 0] = (uint8)(nBits[nOffset + 0] * 0.8);
cBits[nOffset + 1] = (uint8)(nBits[nOffset + 1] * 0.8);
cBits[nOffset + 2] = (uint8)(nBits[nOffset + 2] * 0.8);
cBits[nOffset + 3] = fBits[fOffset + 3];
}
// disabled bits have less opacity
if (dBits != NULL) {
uint8 grey = ((uint16)nBits[nOffset + 0] * 10
+ nBits[nOffset + 1] * 60
+ nBits[nOffset + 2] * 30) / 100;
float dist = (nBits[nOffset + 0] - grey) * 0.3;
dBits[nOffset + 0] = (uint8)(grey + dist);
dist = (nBits[nOffset + 1] - grey) * 0.3;
dBits[nOffset + 1] = (uint8)(grey + dist);
dist = (nBits[nOffset + 2] - grey) * 0.3;
dBits[nOffset + 2] = (uint8)(grey + dist);
dBits[nOffset + 3] = (uint8)(fBits[fOffset + 3] * 0.3);
}
// disabled bits have less contrast (lame method...)
if (dcBits != NULL) {
dcBits[nOffset + 0] = (uint8)(dBits[nOffset + 0] * 0.8);
dcBits[nOffset + 1] = (uint8)(dBits[nOffset + 1] * 0.8);
dcBits[nOffset + 2] = (uint8)(dBits[nOffset + 2] * 0.8);
dcBits[nOffset + 3] = (uint8)(fBits[fOffset + 3] * 0.3);
}
}
fBits += fbpr;
nBits += nbpr;
if (cBits != NULL)
cBits += nbpr;
if (dBits != NULL)
dBits += nbpr;
if (dcBits != NULL)
dcBits += nbpr;
}
} else {
// unsupported format
return B_BAD_VALUE;
}
// make the partially-on bitmaps a copy of the on bitmaps
if ((flags & B_CREATE_PARTIALLY_ACTIVE_ICON_BITMAP) != 0) {
if (CopyBitmap(clickedBitmap, B_PARTIALLY_ACTIVATE_ICON_BITMAP) == NULL)
return B_NO_MEMORY;
if ((flags & B_CREATE_DISABLED_ICON_BITMAPS) != 0) {
if (CopyBitmap(disabledClickedBitmap,
B_PARTIALLY_ACTIVATE_ICON_BITMAP | B_DISABLED_ICON_BITMAP)
== NULL) {
return B_NO_MEMORY;
}
}
}
return B_OK;
}
bool BitmapToSDF(Pixel *SourceBitmap, BMSize SourceWidth, BMSize SourceHeight, Pixel *DestBitmap, BMSize DestWidth, BMSize DestHeight, BMSize InsertX, BMSize InsertY, BMSize InsertWidth, BMSize InsertHeight)
{
// Check parameters
if(SourceBitmap == nullptr || SourceWidth == 0 || SourceHeight == 0 || DestBitmap == nullptr || SourceBitmap == DestBitmap || DestWidth == 0 || DestHeight == 0 || (InsertX + InsertWidth) > DestWidth || (InsertY + InsertHeight) > DestHeight || InsertWidth == 0 || InsertHeight == 0)
return false;
// Sizes
const BMSize SDFWidth = SourceWidth + SDFPaddingSize;
const BMSize SDFHeight = SourceHeight + SDFPaddingSize;
// Create two 1-bit per point grids from the Source bitmap, the grids being inverses of each other
SDFPoint *Grid1 = new SDFPoint[SDFWidth*SDFHeight]();
SDFPoint *Grid2 = new SDFPoint[SDFWidth*SDFHeight]();
for(BMSize i = 0; i < SDFWidth*SDFHeight; ++i) // Fill grids with blank
{
Grid1[i] = SDFInside;
Grid2[i] = SDFOutside;
}
for(BMSize y = 0; y < SourceHeight; ++y) // Write data from source
{
for(BMSize x = 0; x < SourceWidth; ++x)
{
if(SourceBitmap[(y*SourceWidth) + x] < 128)
{
Grid1[(((SDFPaddingSize / 2) + y)*SDFWidth) + ((SDFPaddingSize / 2) + x)] = SDFInside;
Grid2[(((SDFPaddingSize / 2) + y)*SDFWidth) + ((SDFPaddingSize / 2) + x)] = SDFOutside;
}
else
{
Grid1[(((SDFPaddingSize / 2) + y)*SDFWidth) + ((SDFPaddingSize / 2) + x)] = SDFOutside;
Grid2[(((SDFPaddingSize / 2) + y)*SDFWidth) + ((SDFPaddingSize / 2) + x)] = SDFInside;
}
}
}
// Compute SDF grids
GenerateSDF(Grid1, SDFWidth, SDFHeight);
GenerateSDF(Grid2, SDFWidth, SDFHeight);
// Copy SDF to destination bitmap
if(SDFWidth == InsertWidth && SDFHeight == InsertHeight && false) // The generation size and output size are the same, so there is no need to convert
{
// Copy the final values directly to the destination bitmap
for(BMSize y = 0; y < SDFHeight; ++y)
{
for(BMSize x = 0; x < SDFWidth; ++x)
{
// Calculate the actual distance from the dx/dy
int dist1 = (int)(sqrt((double)SDFGetPoint(Grid1, x, y, SDFWidth, SDFHeight).DistSq()));
int dist2 = (int)(sqrt((double)SDFGetPoint(Grid2, x, y, SDFWidth, SDFHeight).DistSq()));
int dist = dist1 - dist2;
// Clamp
int c = dist * 3 + 128;
if(c < 0) c = 0;
if(c > 255) c = 255;
// Write to bitmap
DestBitmap[((InsertY + y)*SDFWidth) + (InsertX + x)] = c;
}
}
}
else // Need to scale the output
{
// Copy the final values to a temporary buffer first
Pixel *SDF = new Pixel[SDFWidth*SDFHeight]();
for(BMSize y = 0; y < SDFHeight; ++y)
{
for(BMSize x = 0; x < SDFWidth; ++x)
{
// Calculate the actual distance from the dx/dy
int dist1 = (int)(sqrt((double)SDFGetPoint(Grid1, x, y, SDFWidth, SDFHeight).DistSq()));
int dist2 = (int)(sqrt((double)SDFGetPoint(Grid2, x, y, SDFWidth, SDFHeight).DistSq()));
int dist = dist1 - dist2;
// Clamp
int c = dist * 3 + 128;
if(c < 0) c = 0;
if(c > 255) c = 255;
// Write to bitmap
SDF[(y*SDFWidth) + x] = c;
}
}
// Scale bitmap to final size and copy it to the destination buffer
CopyBitmap(SDF, SDFWidth, SDFHeight, DestBitmap, DestWidth, DestHeight, InsertX, InsertY, InsertWidth, InsertHeight);
delete[] SDF;
}
// Done
delete[] Grid1;
delete[] Grid2;
return true;
}
