void VolumeControlData::DrawVolumeControl(HDC hDC)
{
HDC hdcTemp = CreateCompatibleDC(hDC);
HBITMAP hbmpTemp = CreateCompatibleBitmap(hDC, cx, cy);
SelectObject(hdcTemp, hbmpTemp);
RECT clientRect = {0, 0, cx, cy};
FillRect(hdcTemp, &clientRect, (HBRUSH)COLOR_WINDOW);
HBRUSH hGray = CreateSolidBrush(REVERSE_COLOR(Color_Gray));
HBRUSH hRed = CreateSolidBrush(0x2020bf);//0xff4040);
float visualVolume = (bDisabled) ? 0.0f : curVolume;
int cxAdjust = cx;
if(bDrawIcon) cxAdjust -= 32;
const int padding = 1;
const float volSliceSize = float(cxAdjust-(padding*9))/10.0f;
int volPixelPos = int(visualVolume*float(cxAdjust));
if(volSliceSize > 1.0f)
{
float ySliceStart, ySliceSize;
if(bDrawIcon)
{
ySliceStart = 4.0f;
ySliceSize = float((cy-ySliceStart)/10);
}
else
{
ySliceStart = 0.0f;
ySliceSize = float(cy/10);
}
for(int i=0; i<10; i++)
{
int pos = int(volSliceSize*float(i)) + (padding*i);
RECT sliceRect = {pos, int(ySliceStart+((9.0f-float(i))*ySliceSize)), pos+int(volSliceSize), cy};
if(sliceRect.right < volPixelPos) //full
FillRect(hdcTemp, &sliceRect, hRed);
else if(sliceRect.left < volPixelPos) //half
{
RECT leftHalf, rightHalf;
mcpy(&leftHalf, &sliceRect, sizeof(sliceRect));
mcpy(&rightHalf, &sliceRect, sizeof(sliceRect));
rightHalf.left = leftHalf.right = volPixelPos;
FillRect(hdcTemp, &leftHalf, hRed);
FillRect(hdcTemp, &rightHalf, hGray);
}
else //empty
FillRect(hdcTemp, &sliceRect, hGray);
}
if(bDrawIcon)
DrawIcon(hdcTemp, cx-32, 0, (visualVolume > VOLN_MUTELEVEL) ? hiconPlay : hiconMute);
if(visualVolume > VOLN_MUTELEVEL && bHasCapture)
{
HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
HFONT hfontOld = (HFONT)SelectObject(hdcTemp, hFont);
SetTextColor(hdcTemp, GetSysColor(COLOR_WINDOWTEXT));
SetBkMode(hdcTemp, TRANSPARENT);
String volText= FormattedString(TEXT("%d%%"), int(curVolume*100));
TextOut(hdcTemp, clientRect.left + (LONG)volSliceSize, clientRect.top, volText, slen(volText));
SelectObject(hdcTemp, hfontOld);
}
}
BitBlt(hDC, 0, 0, cx, cy, hdcTemp, 0, 0, SRCCOPY);
DeleteObject(hdcTemp);
DeleteObject(hbmpTemp);
DeleteObject(hGray);
DeleteObject(hRed);
}
int main()
{
// Create a normal DC and a memory DC for the entire screen. The
// normal DC provides a "snapshot" of the screen contents. The
// memory DC keeps a copy of this "snapshot" in the associated
// bitmap.
HDC hdcScreen, hdcCompatible;
HBITMAP hbmScreen;
SYSTEMTIME time;
char* filename;
char* filepath;
char* regSubKeyBase = "Software\\PJBSoftware\\ScreenShooter";
bool isRegVersion = false;
filepath = (char*)malloc(100 * sizeof(char));
if (!filepath) return 1;
HKEY progKey;
//Get the screenshot location from the registry, else stuff 'em in "My Documents"
if (RegOpenKeyEx(HKEY_CURRENT_USER,regSubKeyBase,0,KEY_QUERY_VALUE,&progKey) == ERROR_SUCCESS)
{
DWORD buffsize = 100;
DWORD type;
if (RegQueryValueEx(progKey,"ScreenshotPath",NULL,&type,(LPBYTE)filepath,&buffsize) != ERROR_SUCCESS) return 1;
}
else
{
char* username = (char*) malloc(25 * sizeof(char));
if (! username) return 1;
DWORD buffsize = 25;
BOOL st = GetUserName(username,&buffsize);
if (!st) return 1;
sprintf(filepath,"C:\\Documents and Settings\\%s\\My Documents",username);
free (username);
}
// Get the time
GetLocalTime((LPSYSTEMTIME)&time);
hdcScreen = CreateDC("DISPLAY", NULL, NULL, NULL);
hdcCompatible = CreateCompatibleDC(hdcScreen);
// Create a compatible bitmap for hdcScreen.
hbmScreen = CreateCompatibleBitmap(hdcScreen,
GetDeviceCaps(hdcScreen, HORZRES),
GetDeviceCaps(hdcScreen, VERTRES));
if (hbmScreen == 0)
printf("Could not create bitmap\n");
// Select the bitmaps into the compatible DC.
if (!SelectObject(hdcCompatible, hbmScreen))
printf("Could not select bitmap\n");
//Copy color data for the entire display into a
//bitmap that is selected into a compatible DC.
if (!BitBlt(hdcCompatible,
0,0,
GetDeviceCaps(hdcScreen, HORZRES), GetDeviceCaps(hdcScreen, VERTRES),
hdcScreen,
0,0,
SRCCOPY))
printf("Screen to Compat Blt Failed\n");
filename = (char*)malloc(150 * sizeof(char));
if (!filename) return 1;
sprintf(filename,"%s\\screenshot-%04u-%02u-%02u-%02u%02u%02u.bmp",filepath,time.wYear,time.wMonth,time.wDay,time.wHour,time.wMinute,time.wSecond);
free(filepath);
CreateBMPFile(filename,CreateBitmapInfoStruct(hbmScreen),hbmScreen,hdcCompatible);
free(filename);
return 0;
}
//Loosely based on writeWindowText() @ 0x0041F2B0
void Bitmap::blitKoreanChar(const char *ch, int &x, int &y, u8 fontSize, u8 color) {
static HFONT gulim_8pt = NULL, gulim_9pt = NULL, gulim_10pt = NULL, gulim_11pt = NULL;
static HDC bufferDc = NULL;
static HBITMAP bufferBmp = NULL; //Temporary bitmap to draw the character
//Load Korean fonts
if (!gulim_9pt) {
HDC screenDc = GetDC(NULL);
LOGFONT lFont = {};
strcpy(lFont.lfFaceName, "±¼¸²");
lFont.lfCharSet = HANGUL_CHARSET;
lFont.lfHeight = -MulDiv(8, GetDeviceCaps(screenDc, LOGPIXELSY), 72); //Not in StarCraft
gulim_8pt = CreateFontIndirect(&lFont);
lFont.lfHeight = -MulDiv(9, GetDeviceCaps(screenDc, LOGPIXELSY), 72);
gulim_9pt = CreateFontIndirect(&lFont);
lFont.lfWeight = FW_BOLD;
lFont.lfHeight = -MulDiv(10, GetDeviceCaps(screenDc, LOGPIXELSY), 72);
gulim_10pt = CreateFontIndirect(&lFont);
lFont.lfWeight = FW_BOLD;
lFont.lfHeight = -MulDiv(11, GetDeviceCaps(screenDc, LOGPIXELSY), 72);
gulim_11pt = CreateFontIndirect(&lFont);
ReleaseDC(NULL, screenDc);
}
//Load main and buffer DCs
if (!bufferBmp) {
HDC mainDc = GetDC(*hWndMainSC);
bufferDc = CreateCompatibleDC(mainDc);
SetBkMode(bufferDc, OPAQUE);
SetTextColor(bufferDc, RGB(255, 255, 255));
SetBkColor(bufferDc, RGB(0, 0, 0));
SelectObject(bufferDc, GetStockObject(BLACK_BRUSH));
bufferBmp = CreateCompatibleBitmap(mainDc, KOR_CHAR_MAX_WIDTH, KOR_CHAR_MAX_HEIGHT);
SelectObject(bufferDc, bufferBmp);
ReleaseDC(*hWndMainSC, mainDc);
}
//Assume this function is only drawing in-game stuff
HFONT currentFont;
switch (fontSize) {
case 0:
currentFont = gulim_8pt; break; //SC uses 9pt, but who cares :P
case 1:
currentFont = gulim_9pt; break;
case 2:
currentFont = gulim_10pt; break; //SC uses 11pt, but who cares :P
case 3:
default:
currentFont = gulim_11pt; break;
}
SelectObject(bufferDc, currentFont);
char koreanChars[3];
*(u16*)koreanChars = *(u16*) ch;
koreanChars[2] = '\0';
//Retrieve the size of the rectangular area to draw the character
RECT chRect = {};
DrawText(bufferDc, koreanChars, strlen(koreanChars), &chRect, DT_CALCRECT);
//Fill the character rectangle with black background
Rectangle(bufferDc, chRect.left - 1, chRect.top - 1, chRect.right + 1, chRect.bottom + 1);
//Write character into temporary bitmap buffer
DrawText(bufferDc, koreanChars, strlen(koreanChars), &chRect, 0);
//Copy pixel data from temporary bitmap into temporary buffer
static u8 bitmapBuffer[KOR_CHAR_MAX_WIDTH * KOR_CHAR_MAX_HEIGHT];
GetBitmapBits(bufferBmp, KOR_CHAR_MAX_WIDTH * chRect.bottom, bitmapBuffer);
//Copy pixels from temporary buffer into StarCraft's own buffer
for (int yOff = 0; yOff < chRect.bottom; ++yOff) {
for (int xOff = 0; xOff < chRect.right; ++xOff) {
if (bitmapBuffer[xOff + KOR_CHAR_MAX_WIDTH * yOff]) {
this->drawDot(x + xOff + 1, y + yOff + 3, gbFontColors[color][0]); //Shadow
this->drawDot(x + xOff, y + yOff + 2, gbFontColors[color][1]);
}
}
}
//Advance pixels
x += chRect.right;
}
static void readscreen(void)
{
#if !defined(OPENSSL_SYS_WINCE) && !defined(OPENSSL_SYS_WIN32_CYGWIN)
HDC hScrDC; /* screen DC */
HDC hMemDC; /* memory DC */
HBITMAP hBitmap; /* handle for our bitmap */
HBITMAP hOldBitmap; /* handle for previous bitmap */
BITMAP bm; /* bitmap properties */
unsigned int size; /* size of bitmap */
char *bmbits; /* contents of bitmap */
int w; /* screen width */
int h; /* screen height */
int y; /* y-coordinate of screen lines to grab */
int n = 16; /* number of screen lines to grab at a time */
if (GetVersion() >= 0x80000000 || !OPENSSL_isservice())
return;
/* Create a screen DC and a memory DC compatible to screen DC */
hScrDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
hMemDC = CreateCompatibleDC(hScrDC);
/* Get screen resolution */
w = GetDeviceCaps(hScrDC, HORZRES);
h = GetDeviceCaps(hScrDC, VERTRES);
/* Create a bitmap compatible with the screen DC */
hBitmap = CreateCompatibleBitmap(hScrDC, w, n);
/* Select new bitmap into memory DC */
hOldBitmap = SelectObject(hMemDC, hBitmap);
/* Get bitmap properties */
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
size = (unsigned int)bm.bmWidthBytes * bm.bmHeight * bm.bmPlanes;
bmbits = OPENSSL_malloc(size);
if (bmbits) {
/* Now go through the whole screen, repeatedly grabbing n lines */
for (y = 0; y < h-n; y += n)
{
unsigned char md[MD_DIGEST_LENGTH];
/* Bitblt screen DC to memory DC */
BitBlt(hMemDC, 0, 0, w, n, hScrDC, 0, y, SRCCOPY);
/* Copy bitmap bits from memory DC to bmbits */
GetBitmapBits(hBitmap, size, bmbits);
/* Get the hash of the bitmap */
MD(bmbits,size,md);
/* Seed the random generator with the hash value */
RAND_add(md, MD_DIGEST_LENGTH, 0);
}
OPENSSL_free(bmbits);
}
/* Select old bitmap back into memory DC */
hBitmap = SelectObject(hMemDC, hOldBitmap);
/* Clean up */
DeleteObject(hBitmap);
DeleteDC(hMemDC);
DeleteDC(hScrDC);
#endif /* !OPENSSL_SYS_WINCE */
}
bool
Initialize () {
// no WinMain so get the module handle:
g_hInstance = GetModuleHandle(NULL);
if (g_hInstance == NULL)
return false;
// register the window class:
WNDCLASS wc;
wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = WINDOW_TITLE;
if (RegisterClass(&wc) == 0)
return false;
// create the window:
g_hWnd = CreateWindow(
WINDOW_TITLE, // class name
WINDOW_TITLE, // title
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, // style
CW_USEDEFAULT, CW_USEDEFAULT, // position
CW_USEDEFAULT, CW_USEDEFAULT, // size
NULL, // no parent
NULL, // no menu
g_hInstance, // instance
NULL // no special
);
if (g_hWnd == NULL)
return false;
// setup double buffering:
g_hDC = GetDC(g_hWnd);
if (g_hDC == NULL)
return false;
g_hMemDC = CreateCompatibleDC(g_hDC);
if (g_hMemDC == NULL)
return false;
g_hMemBMP = CreateCompatibleBitmap(g_hDC, WINDOW_WIDTH, WINDOW_HEIGHT);
if (g_hMemBMP == NULL)
return false;
SelectObject(g_hMemDC, g_hMemBMP);
// colors used to draw the effect:
g_hColor1 = CreateSolidBrush(RGB(184, 178, 251));
g_hColor2 = CreateSolidBrush(RGB(98, 72, 124));
if (g_hColor1 == NULL || g_hColor2 == NULL)
return false;
return true;
}
bool
Initialize () {
// no WinMain so get the module handle:
g_hInstance = GetModuleHandle(NULL);
if (g_hInstance == NULL)
return false;
// register the window class:
WNDCLASS wc;
wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = WINDOW_TITLE;
if (RegisterClass(&wc) == 0)
return false;
// create the window:
g_hWnd = CreateWindow(
WINDOW_TITLE, // class name
WINDOW_TITLE, // title
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, // style
CW_USEDEFAULT, CW_USEDEFAULT, // position
CW_USEDEFAULT, CW_USEDEFAULT, // size
NULL, // no parent
NULL, // no menu
g_hInstance, // instance
NULL // no special
);
if (g_hWnd == NULL)
return false;
// setup double buffering:
g_hDC = GetDC(g_hWnd);
if (g_hDC == NULL)
return false;
g_hMemDC = CreateCompatibleDC(g_hDC);
if (g_hMemDC == NULL)
return false;
g_hMemBMP = CreateCompatibleBitmap(g_hDC, WINDOW_WIDTH, WINDOW_HEIGHT);
if (g_hMemBMP == NULL)
return false;
SelectObject(g_hMemDC, g_hMemBMP);
// color used to draw the background:
g_hBlue = CreateSolidBrush(RGB(100, 149, 237));
if (g_hBlue == NULL)
return FALSE;
// setup octocat:
octocat_hdc = CreateCompatibleDC(g_hDC);
if (octocat_hdc == NULL)
return FALSE;
octocat_bmp = CreateCompatibleBitmap(g_hDC, octocat_w, octocat_h);
if (octocat_bmp == NULL)
return FALSE;
SelectObject(octocat_hdc, octocat_bmp);
SetDIBits(octocat_hdc, octocat_bmp, 0, 320, octocat, &sprbmi, DIB_RGB_COLORS);
return true;
}
int _tmain(int argc, _TCHAR* argv[])
{
if( argc < 2 )
{
_tprintf(_T("converts a picture to a tank map\n"));
_tprintf(_T("supported formats: bmp, gif, jpg, wmf, ico\n"));
_tprintf(_T("using: mkmap bmpfile.bmp [mapfile]\n"));
return 0;
}
_tprintf(_T("input file: \n %s\n"), argv[1]);
IPicture *pPicture = LoadPicture(argv[1]);
if( NULL == pPicture )
{
_tprintf(_T("Loading FAILED!\n"));
return -1;
}
HDC hdc = GetDC(NULL);
long height, width;
pPicture->get_Height(&height);
pPicture->get_Width(&width);
long height_ = MulDiv(height, GetDeviceCaps(hdc, LOGPIXELSY), HIMETRIC_INCH);
long width_ = MulDiv(width, GetDeviceCaps(hdc, LOGPIXELSX), HIMETRIC_INCH);
_tprintf(_T("width %d px\n"), width_);
_tprintf(_T("height %d px\n"), height_);
HDC hdc_tmp = CreateCompatibleDC(hdc);
HBITMAP bmp = CreateCompatibleBitmap(hdc, width_, height_);
ReleaseDC(NULL, hdc);
HBITMAP old = (HBITMAP) SelectObject(hdc_tmp, bmp);
pPicture->Render(hdc_tmp, 0, 0, width_, height_, 0, height, width, -height, NULL);
_TCHAR outfn[MAX_PATH];
if( argc > 2 )
_tcscpy(outfn, argv[2]);
else
_stprintf(outfn, _T("%s.tankmap"), argv[1]);
FILE *file = _tfopen(outfn, _T("wt"));
if( NULL != file )
{
_tprintf(_T("writing map to '%s'\n"), outfn);
try
{
fwassert(_ftprintf(file, _T("<tank map>\n")));
fwassert(_ftprintf(file, _T("width %d\n"), width_));
fwassert(_ftprintf(file, _T("height %d\n"), height_));
_TCHAR name[MAX_OBJNAME];
int objcount = 0;
for( int y = 0; y < height_; y++ )
for( int x = 0; x < width_; x++ )
{
if( ObjectFromColor(name, GetPixel(hdc_tmp, x, y)) )
{
fwassert(_ftprintf(file, _T("%s %d %d\n"), name, 16 + x * 32, 16 + y * 32));
objcount++;
}
}
_tprintf(_T("%d objects written\n"), objcount);
_tprintf(_T("done.\n"), objcount);
}
catch(const _TCHAR *msg)
{
fclose(file);
_tprintf(msg);
}
}
else
{
_tprintf(_T("can't open file '%s' for writing\n"), outfn);
}
SelectObject(hdc_tmp, old);
DeleteObject(bmp);
DeleteDC(hdc_tmp);
SAFE_RELEASE(pPicture);
return 0;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_CREATE:
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
{
RECT cr;
GetClientRect(hWnd, &cr);
int width = cr.right - cr.left;
int height = cr.bottom - cr.top;
HDC bufDC;
HBITMAP bufBMP;
bufDC = CreateCompatibleDC(hdc);
bufBMP = CreateCompatibleBitmap(hdc, width, height);
SelectObject(bufDC, bufBMP);
setPaintDC(bufDC);
RECT r = {0};
r.right = width;
r.bottom = height;
FillRect(bufDC, &r, GetStockBrush(WHITE_BRUSH));
paint();
setPaintDC(NULL);
BitBlt(hdc, 0, 0, width, height, bufDC, 0, 0, SRCCOPY);
DeleteObject(bufBMP);
DeleteDC(bufDC);
}
EndPaint(hWnd, &ps);
break;
case WM_MOUSEMOVE:
{
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
mouseMove(x, y);
}
break;
case WM_LBUTTONDOWN:
SetCapture(hWnd);
mouseDown();
break;
case WM_LBUTTONUP:
ReleaseCapture();
mouseUp();
break;
case WM_KEYDOWN:
{
int vk = wParam;
char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR);
keyDown(ch, vk);
}
break;
case WM_KEYUP:
{
int vk = wParam;
char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR);
keyUp(ch, vk);
}
break;
case WM_TIMER:
switch(wParam)
{
case IDT_TIMER0:
timerTick();
break;
}
break;
case WM_DESTROY:
finalize();
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void __cdecl InitGui(void *param)
{
HWND hparentwnd;
HANDLE hinst;
WNDCLASSEX wndclass;
char szFile[80];
hinst = GetModuleHandle(NULL);
GetModuleFileName (hinst, szFile, sizeof(szFile));
#ifdef DEBUG
printf ("hinst = %x\n", hinst);
printf ("File = %s\n", szFile);
#endif
/* Fill in window class structure with parameters that describe
the main window. */
/* CS_OWNDC : un DC pour chaque fenêtre de la classe */
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wndclass.lpfnWndProc = (WNDPROC)WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hinst;
wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wndclass.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
wndclass.lpszClassName = szFile;
wndclass.lpszMenuName = NULL;
if (!RegisterClassEx(&wndclass))
Win32Error("Register class");
hparentwnd = GetFocus();
my_window = CreateWindow(szFile, szTitle,
WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
CW_USEDEFAULT, 0,
CW_USEDEFAULT, 0,
/* screenwidth, screendepth, */
hparentwnd, NULL, hinst, NULL);
if (!my_window) {
Win32Error("Create window");
}
#ifdef DEBUG
fprintf(stderr, "my_window = %x\n", my_window);
#endif
#ifdef LOOPMSG
/* Acknowledge for UpdateWindow() (WM_PAINT message generated) */
hMutex = CreateMutex(NULL, FALSE, "DrawingMutex");
my_dc = GetDC(my_window);
/* Device context for drawing and the associated bitmap. */
drawing_dc = CreateCompatibleDC(my_dc);
hbm = CreateCompatibleBitmap(my_dc, screenwidth, screendepth);
SelectObject(drawing_dc, hbm);
/* Blank the bitmap */
SelectObject(drawing_dc, GetStockObject(WHITE_BRUSH));
PatBlt(drawing_dc, 0, 0, screenwidth, screendepth, PATCOPY);
hAccelTable = LoadAccelerators (hinst, szTitle);
ShowWindow(my_window, SW_SHOWNORMAL);
UpdateWindow(my_window);
/* Running the message loop */
while (GetMessage(&msg, my_window, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
#else
drawing_dc = my_dc = GetDC(my_window);
#endif
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
static int x1 = 0;
static int y1 = 0;
static int x2 = 0;
static int y2 = 0;
static vector<mLine> lList;
static HBITMAP currentBitmap = NULL;
static bool isCopy = false;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
//isCopy = !isCopy;
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
case ID_DRAW:
{
isCopy = false;
HMENU men = GetMenu(hWnd);
EnableMenuItem(men, ID_COPY, MF_BYCOMMAND | MF_ENABLED);
EnableMenuItem(men, ID_DRAW, MF_BYCOMMAND | MF_GRAYED);
break;
}
case ID_COPY:
{
HMENU men = GetMenu(hWnd);
EnableMenuItem(men, ID_COPY, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(men, ID_DRAW, MF_BYCOMMAND | MF_ENABLED);
isCopy = true;
break;
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_CREATE:
{
HMENU men = GetMenu(hWnd);
EnableMenuItem(men, ID_COPY, MF_BYCOMMAND | MF_ENABLED);
EnableMenuItem(men, ID_DRAW, MF_BYCOMMAND | MF_GRAYED);
break;
}
case WM_RENDERFORMAT:
{
onRenderFormat(hWnd, wParam, currentBitmap);
break;
}
case WM_RENDERALLFORMATS:
{
onRenderAllFormat(hWnd, wParam, currentBitmap);
break;
}
case WM_DESTROYCLIPBOARD:
{
if (currentBitmap != NULL)
{
DeleteObject(currentBitmap);
currentBitmap = NULL;
}
break;
}
case WM_LBUTTONDOWN:
{
x1 = x2 = GET_X_LPARAM(lParam);
y1 = y2 = GET_Y_LPARAM(lParam);
break;
}
case WM_LBUTTONUP:
{
if (isCopy)
{
hdc = GetDC(hWnd);
HDC memDC = CreateCompatibleDC(hdc);
SetROP2(hdc, R2_NOTXORPEN);
Rectangle(hdc, min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2));
//
if (x1 > x2)
std::swap(x1, x2);
if (y1 > y2)
std::swap(y1, y2);
//
if (currentBitmap != NULL)
DeleteObject(currentBitmap);
HBITMAP temp = (HBITMAP)SelectObject(memDC, CreateCompatibleBitmap(hdc, x2 - x1, y2 - y1));
BitBlt(memDC, 0, 0, x2 - x1, y2 - y1, hdc, x1, y1, SRCCOPY);
temp = (HBITMAP) SelectObject(memDC, temp);
DeleteDC(memDC);
ReleaseDC(hWnd, hdc);
//int gg = sizeof(BITMAP);
if (temp != NULL)
{
OpenClipboard(hWnd);
EmptyClipboard();
SetClipboardData(CF_BITMAP, NULL);
CloseClipboard();
currentBitmap = temp;
MessageBox(hWnd, L"The Image has been copied to clipboard.", L"Copy Successfully", MB_OK);
}
else
{
MessageBox(hWnd, L"Cannot copy image to clipboard.", L"Error", MB_OK);
}
x1 = x2;
y1 = y2;
}
else
{
}
break;
}
case WM_MOUSEMOVE:
{
if (wParam & VK_LBUTTON)
{
int nx, ny;
nx = GET_X_LPARAM(lParam);
ny = GET_Y_LPARAM(lParam);
hdc = GetDC(hWnd);
if (isCopy)
{
hdc = GetDC(hWnd);
SetROP2(hdc, R2_NOTXORPEN);
Rectangle(hdc, min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2));
Rectangle(hdc, min(x1, nx), min(y1, ny), max(x1, nx), max(y1, ny));
ReleaseDC(hWnd, hdc);
}
else
{
mLine l;
l.setPos(x1, y1, nx, ny);
x1 = nx;
y1 = ny;
lList.push_back(l);
InvalidateRect(hWnd, 0, TRUE);
UpdateWindow(hWnd);
}
x2 = nx;
y2 = ny;
ReleaseDC(hWnd, hdc);
}
break;
}
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code here...
for (int i = 0; i < lList.size(); ++i)
lList[i].Draw(hdc, NULL);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
static void drawbmp(fz_context *ctx, fz_document *doc, fz_page *page, fz_display_list *list, int pagenum, fz_cookie *cookie)
{
float zoom;
fz_matrix ctm;
fz_irect ibounds;
fz_rect bounds, tbounds;
int w, h;
fz_device *dev;
HDC dc, dc_main;
RECT rc;
HBRUSH bg_brush;
HBITMAP hbmp;
BITMAPINFO bmi = { 0 };
int bmp_data_len;
unsigned char *bmp_data;
fz_bound_page(doc, page, &bounds);
zoom = resolution / 72;
fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
tbounds = bounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
w = width;
h = height;
if (res_specified)
{
fz_round_rect(&ibounds, &tbounds);
if (w && ibounds.x1 - ibounds.x0 <= w)
w = 0;
if (h && ibounds.y1 - ibounds.y0 <= h)
h = 0;
}
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
if (w == 0)
scalex = fit ? 1.0f : scaley;
if (h == 0)
scaley = fit ? 1.0f : scalex;
if (!fit)
scalex = scaley = min(scalex, scaley);
fz_concat(&ctm, &ctm, fz_scale(&scale_mat, scalex, scaley));
tbounds = bounds;
fz_transform_rect(&tbounds, &ctm);
}
fz_round_rect(&ibounds, &tbounds);
fz_rect_from_irect(&tbounds, &ibounds);
w = ibounds.x1 - ibounds.x0;
h = ibounds.y1 - ibounds.y0;
dc_main = GetDC(NULL);
hbmp = CreateCompatibleBitmap(dc_main, w, h);
if (!hbmp)
fz_throw(ctx, FZ_ERROR_GENERIC, "failed to create a %d x %d bitmap for page %d", w, h, pagenum);
dc = CreateCompatibleDC(dc_main);
DeleteObject(SelectObject(dc, hbmp));
SetRect(&rc, 0, 0, w, h);
bg_brush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
FillRect(dc, &rc, bg_brush);
DeleteObject(bg_brush);
dev = fz_new_gdiplus_device(ctx, dc, &tbounds);
if (list)
fz_run_display_list(list, dev, &ctm, &tbounds, cookie);
else
fz_run_page(doc, page, dev, &ctm, cookie);
fz_free_device(dev);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = output_format == OUT_TGA ? -h : h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = output_format == OUT_TGA ? 32 : 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmp_data_len = output_format == OUT_TGA ? w * h * 4 : ((w * 3 + 3) / 4) * 4 * h;
bmp_data = fz_malloc(ctx, bmp_data_len);
if (!GetDIBits(dc, hbmp, 0, h, bmp_data, &bmi, DIB_RGB_COLORS))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot draw page %d", pagenum, filename);
DeleteDC(dc);
ReleaseDC(NULL, dc_main);
DeleteObject(hbmp);
if (output)
{
char buf[512];
FILE *f;
sprintf(buf, output, pagenum);
f = fopen(buf, "wb");
if (!f)
fz_throw(ctx, FZ_ERROR_GENERIC, "could not create raster file '%s'", buf);
if (output_format == OUT_TGA)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr(ctx), w, h, bmp_data);
fz_write_tga(ctx, pix, buf, 0);
fz_drop_pixmap(ctx, pix);
}
else
{
BITMAPFILEHEADER bmpfh = { 0 };
static const int one = 1;
if (!*(char *)&one)
fz_throw(ctx, FZ_ERROR_GENERIC, "rendering to BMP is not supported on big-endian architectures");
bmpfh.bfType = MAKEWORD('B', 'M');
bmpfh.bfOffBits = sizeof(bmpfh) + sizeof(bmi);
bmpfh.bfSize = bmpfh.bfOffBits + bmp_data_len;
fwrite(&bmpfh, sizeof(bmpfh), 1, f);
fwrite(&bmi, sizeof(bmi), 1, f);
fwrite(bmp_data, 1, bmp_data_len, f);
}
fclose(f);
}
if (showmd5)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr(ctx), bmp_data_len / 4 / h, h, bmp_data);
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
fz_drop_pixmap(ctx, pix);
}
fz_free(ctx, bmp_data);
}
static SDL_bool
WIN_GetDisplayMode(_THIS, LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mode)
{
SDL_VideoData *vid_data = (SDL_VideoData *) _this->driverdata;
SDL_DisplayModeData *data;
DEVMODE devmode;
HDC hdc;
devmode.dmSize = sizeof(devmode);
devmode.dmDriverExtra = 0;
if (!EnumDisplaySettings(deviceName, index, &devmode)) {
return SDL_FALSE;
}
data = (SDL_DisplayModeData *) SDL_malloc(sizeof(*data));
if (!data) {
return SDL_FALSE;
}
data->DeviceMode = devmode;
data->DeviceMode.dmFields =
(DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY |
DM_DISPLAYFLAGS);
data->ScaleX = 1.0f;
data->ScaleY = 1.0f;
data->DiagDPI = 0.0f;
data->HorzDPI = 0.0f;
data->VertDPI = 0.0f;
/* Fill in the mode information */
mode->format = SDL_PIXELFORMAT_UNKNOWN;
mode->w = devmode.dmPelsWidth;
mode->h = devmode.dmPelsHeight;
mode->refresh_rate = devmode.dmDisplayFrequency;
mode->driverdata = data;
if (index == ENUM_CURRENT_SETTINGS
&& (hdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL) {
char bmi_data[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
LPBITMAPINFO bmi;
HBITMAP hbm;
#if 0
int logical_width = GetDeviceCaps( hdc, HORZRES );
int logical_height = GetDeviceCaps( hdc, VERTRES );
data->ScaleX = (float)logical_width / devmode.dmPelsWidth;
data->ScaleY = (float)logical_height / devmode.dmPelsHeight;
mode->w = logical_width;
mode->h = logical_height;
#endif
// WIN_GetMonitorDPI needs mode->w and mode->h
// so only call after those are set.
if (vid_data->GetDpiForMonitor) {
WIN_GetMonitorDPIData dpi_data;
RECT monitor_rect;
dpi_data.vid_data = vid_data;
dpi_data.mode = mode;
dpi_data.mode_data = data;
monitor_rect.left = devmode.dmPosition.x;
monitor_rect.top = devmode.dmPosition.y;
monitor_rect.right = monitor_rect.left + 1;
monitor_rect.bottom = monitor_rect.top + 1;
EnumDisplayMonitors(NULL, &monitor_rect, WIN_GetMonitorDPI, (LPARAM)&dpi_data);
} else {
// We don't have the Windows 8.1 routine so just
// get system DPI.
data->HorzDPI = (float)GetDeviceCaps( hdc, LOGPIXELSX );
data->VertDPI = (float)GetDeviceCaps( hdc, LOGPIXELSY );
if (data->HorzDPI == data->VertDPI) {
data->DiagDPI = data->HorzDPI;
} else {
data->DiagDPI = SDL_ComputeDiagonalDPI( mode->w,
mode->h,
(float)GetDeviceCaps( hdc, HORZSIZE ) / 25.4f,
(float)GetDeviceCaps( hdc, VERTSIZE ) / 25.4f );
}
}
SDL_zero(bmi_data);
bmi = (LPBITMAPINFO) bmi_data;
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hbm = CreateCompatibleBitmap(hdc, 1, 1);
GetDIBits(hdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
GetDIBits(hdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
DeleteObject(hbm);
DeleteDC(hdc);
if (bmi->bmiHeader.biCompression == BI_BITFIELDS) {
switch (*(Uint32 *) bmi->bmiColors) {
case 0x00FF0000:
mode->format = SDL_PIXELFORMAT_RGB888;
break;
case 0x000000FF:
mode->format = SDL_PIXELFORMAT_BGR888;
break;
case 0xF800:
mode->format = SDL_PIXELFORMAT_RGB565;
break;
case 0x7C00:
mode->format = SDL_PIXELFORMAT_RGB555;
break;
}
} else if (bmi->bmiHeader.biBitCount == 8) {
mode->format = SDL_PIXELFORMAT_INDEX8;
} else if (bmi->bmiHeader.biBitCount == 4) {
mode->format = SDL_PIXELFORMAT_INDEX4LSB;
}
} else {
/* FIXME: Can we tell what this will be? */
if ((devmode.dmFields & DM_BITSPERPEL) == DM_BITSPERPEL) {
switch (devmode.dmBitsPerPel) {
case 32:
mode->format = SDL_PIXELFORMAT_RGB888;
break;
case 24:
mode->format = SDL_PIXELFORMAT_RGB24;
break;
case 16:
mode->format = SDL_PIXELFORMAT_RGB565;
break;
case 15:
mode->format = SDL_PIXELFORMAT_RGB555;
break;
case 8:
mode->format = SDL_PIXELFORMAT_INDEX8;
break;
case 4:
mode->format = SDL_PIXELFORMAT_INDEX4LSB;
break;
}
}
}
return SDL_TRUE;
}
void CtrlMemView::onPaint(WPARAM wParam, LPARAM lParam)
{
// draw to a bitmap for double buffering
PAINTSTRUCT ps;
HDC actualHdc = BeginPaint(wnd, &ps);
HDC hdc = CreateCompatibleDC(actualHdc);
HBITMAP hBM = CreateCompatibleBitmap(actualHdc, rect.right-rect.left, rect.bottom-rect.top);
SelectObject(hdc, hBM);
SetBkMode(hdc,OPAQUE);
HPEN standardPen = CreatePen(0,0,0xFFFFFF);
HBRUSH standardBrush = CreateSolidBrush(0xFFFFFF);
HPEN oldPen = (HPEN) SelectObject(hdc,standardPen);
HBRUSH oldBrush = (HBRUSH) SelectObject(hdc,standardBrush);
HFONT oldFont = (HFONT) SelectObject(hdc,(HGDIOBJ)font);
// white background
SelectObject(hdc,standardPen);
SelectObject(hdc,standardBrush);
Rectangle(hdc,0,0,rect.right,rect.bottom);
// draw one extra row that may be partially visible
for (int i = 0; i < visibleRows+1; i++)
{
char temp[32];
unsigned int address=windowStart + i*rowSize;
int rowY = rowHeight*i;
sprintf(temp,"%08X",address);
SetTextColor(hdc,0x600000);
TextOutA(hdc,addressStart,rowY,temp,(int)strlen(temp));
SetTextColor(hdc,0x000000);
u32 memory[4];
bool valid = debugger != NULL && debugger->isAlive() && Memory::IsValidAddress(address);
if (valid)
{
memory[0] = debugger->readMemory(address);
memory[1] = debugger->readMemory(address+4);
memory[2] = debugger->readMemory(address+8);
memory[3] = debugger->readMemory(address+12);
}
u8* m = (u8*) memory;
for (int j = 0; j < rowSize; j++)
{
if (valid) sprintf(temp,"%02X",m[j]);
else strcpy(temp,"??");
unsigned char c = m[j];
if (c < 32 || c >= 128 || valid == false) c = '.';
if (address+j == curAddress && searching == false)
{
COLORREF oldBkColor = GetBkColor(hdc);
COLORREF oldTextColor = GetTextColor(hdc);
if (hasFocus && !asciiSelected)
{
SetTextColor(hdc,0xFFFFFF);
SetBkColor(hdc,0xFF9933);
if (selectedNibble == 0) SelectObject(hdc,(HGDIOBJ)underlineFont);
} else {
SetTextColor(hdc,0);
SetBkColor(hdc,0xC0C0C0);
}
TextOutA(hdc,hexStart+j*3*charWidth,rowY,&temp[0],1);
if (hasFocus && !asciiSelected)
{
if (selectedNibble == 1) SelectObject(hdc,(HGDIOBJ)underlineFont);
else SelectObject(hdc,(HGDIOBJ)font);
}
TextOutA(hdc,hexStart+j*3*charWidth+charWidth,rowY,&temp[1],1);
if (hasFocus && asciiSelected)
{
SetTextColor(hdc,0xFFFFFF);
SetBkColor(hdc,0xFF9933);
} else {
SetTextColor(hdc,0);
SetBkColor(hdc,0xC0C0C0);
SelectObject(hdc,(HGDIOBJ)font);
}
TextOutA(hdc,asciiStart+j*(charWidth+2),rowY,(char*)&c,1);
SetTextColor(hdc,oldTextColor);
SetBkColor(hdc,oldBkColor);
} else {
TextOutA(hdc,hexStart+j*3*charWidth,rowY,temp,2);
TextOutA(hdc,asciiStart+j*(charWidth+2),rowY,(char*)&c,1);
}
}
}
SelectObject(hdc,oldFont);
SelectObject(hdc,oldPen);
SelectObject(hdc,oldBrush);
// copy bitmap to the actual hdc
BitBlt(actualHdc,0,0,rect.right,rect.bottom,hdc,0,0,SRCCOPY);
DeleteObject(hBM);
DeleteDC(hdc);
DeleteObject(standardPen);
DeleteObject(standardBrush);
EndPaint(wnd, &ps);
}
HBITMAP Explorerplusplus::CaptureTabScreenshot(int iTabId)
{
HDC hdc;
HDC hdcSrc;
HBITMAP hBitmap;
HBITMAP hPrevBitmap;
Gdiplus::Color color(0,0,0);
RECT rcMain;
RECT rcTab;
HWND hTab = m_hListView[iTabId];
GetClientRect(m_hContainer,&rcMain);
GetClientRect(hTab,&rcTab);
/* Main window BitBlt. */
hdc = GetDC(m_hContainer);
hdcSrc = CreateCompatibleDC(hdc);
/* Any bitmap sent back to the operating system will need to be in 32-bit
ARGB format. */
Gdiplus::Bitmap bi(GetRectWidth(&rcMain),GetRectHeight(&rcMain),PixelFormat32bppARGB);
bi.GetHBITMAP(color,&hBitmap);
/* BitBlt the main window into the bitmap. */
hPrevBitmap = (HBITMAP)SelectObject(hdcSrc,hBitmap);
BitBlt(hdcSrc,0,0,GetRectWidth(&rcMain),GetRectHeight(&rcMain),hdc,0,0,SRCCOPY);
/* Now BitBlt the tab onto the main window. */
HDC hdcTab;
HDC hdcTabSrc;
HBITMAP hbmTab;
HBITMAP hbmTabPrev;
BOOL bVisible;
hdcTab = GetDC(hTab);
hdcTabSrc = CreateCompatibleDC(hdcTab);
hbmTab = CreateCompatibleBitmap(hdcTab,GetRectWidth(&rcTab),GetRectHeight(&rcTab));
hbmTabPrev = (HBITMAP)SelectObject(hdcTabSrc,hbmTab);
bVisible = IsWindowVisible(hTab);
if(!bVisible)
{
ShowWindow(hTab,SW_SHOW);
}
PrintWindow(hTab,hdcTabSrc,PW_CLIENTONLY);
if(!bVisible)
{
ShowWindow(hTab,SW_HIDE);
}
MapWindowPoints(hTab,m_hContainer,(LPPOINT)&rcTab,2);
BitBlt(hdcSrc,rcTab.left,rcTab.top,GetRectWidth(&rcTab),GetRectHeight(&rcTab),hdcTabSrc,0,0,SRCCOPY);
SelectObject(hdcTabSrc,hbmTabPrev);
DeleteObject(hbmTab);
DeleteDC(hdcTabSrc);
ReleaseDC(hTab,hdcTab);
/* Shrink the bitmap. */
HDC hdcThumbnailSrc;
HBITMAP hbmThumbnail;
POINT pt;
hdcThumbnailSrc = CreateCompatibleDC(hdc);
/* Thumbnail bitmap. */
Gdiplus::Bitmap bmpThumbnail(GetRectWidth(&rcMain),GetRectHeight(&rcMain),PixelFormat32bppARGB);
bmpThumbnail.GetHBITMAP(color,&hbmThumbnail);
hPrevBitmap = (HBITMAP)SelectObject(hdcThumbnailSrc,hbmThumbnail);
/* Finally, shrink the full-scale bitmap down into a thumbnail. */
SetStretchBltMode(hdcThumbnailSrc,HALFTONE);
SetBrushOrgEx(hdcThumbnailSrc,0,0,&pt);
BitBlt(hdcThumbnailSrc,0,0,GetRectWidth(&rcMain),GetRectHeight(&rcMain),hdcSrc,0,0,SRCCOPY);
SetBitmapDimensionEx(hbmThumbnail,GetRectWidth(&rcMain),GetRectHeight(&rcMain),NULL);
SelectObject(hdcThumbnailSrc,hPrevBitmap);
DeleteDC(hdcThumbnailSrc);
DeleteObject(hBitmap);
SelectObject(hdcSrc,hPrevBitmap);
DeleteDC(hdcSrc);
ReleaseDC(m_hContainer,hdc);
return hbmThumbnail;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
HWND hwndParent = hWndParent;
HWND hwndImage = hWndImage;
if (hwnd == hwndParent) {
if (message == WM_SIZE) {
ShowWindow(hwndImage, wParam == SIZE_MINIMIZED ? SW_HIDE : SW_SHOW);
}
if (message == WM_WINDOWPOSCHANGED) {
SetWindowPos(hwndImage, hwndParent, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
}
return CallWindowProc(
(long (__stdcall *)(HWND,unsigned int,unsigned int,long))oldProc,
hwnd,
message,
wParam,
lParam
);
}
switch (message) {
case WM_PAINT:
if (bgBitmap.bReady) {
ECS();
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwnd, &ps);
if (bgBitmap.iType == MIL_BITMAP) {
HDC cdc = CreateCompatibleDC(hdc);
SelectObject(cdc, bgBitmap.hBitmap);
for (unsigned int x = 0; x < uWndWidth; x += bgBitmap.rPos.right) {
for (unsigned int y = 0; y < uWndHeight; y += bgBitmap.rPos.bottom) {
BitBlt(hdc, x, y, bgBitmap.rPos.right, bgBitmap.rPos.bottom, cdc, 0, 0, SRCCOPY);
}
}
DeleteDC(cdc);
}
else {
int r = GetRValue(bgBitmap.cGradientFrom) << 10;
int g = GetGValue(bgBitmap.cGradientFrom) << 10;
int b = GetBValue(bgBitmap.cGradientFrom) << 10;
int dr = ((GetRValue(bgBitmap.cGradientTo) << 10) - r) / (int)uWndHeight * 4;
int dg = ((GetGValue(bgBitmap.cGradientTo) << 10) - g) / (int)uWndHeight * 4;
int db = ((GetBValue(bgBitmap.cGradientTo) << 10) - b) / (int)uWndHeight * 4;
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = uWndWidth;
rect.bottom = 4;
while (rect.top < (int)uWndHeight)
{
HBRUSH brush = CreateSolidBrush(RGB(r>>10,g>>10,b>>10));
FillRect(hdc, &rect, brush);
DeleteObject(brush);
rect.top+=4;
rect.bottom+=4;
r+=dr;
g+=dg;
b+=db;
}
}
myImageList *img = bgBitmap.next;
while (img) {
if (img->iType == MIL_TEXT) {
SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, img->cTextColor);
SelectObject(hdc, img->hFont);
DrawText(hdc, img->szText, -1, &img->rPos, DT_TOP | DT_LEFT | DT_NOPREFIX | DT_WORDBREAK);
}
else if (img->iType == MIL_BITMAP) {
HDC cdc = CreateCompatibleDC(hdc);
SelectObject(cdc, img->hBitmap);
BitBlt(hdc, img->rPos.left, img->rPos.top, img->rPos.right - img->rPos.left, img->rPos.bottom - img->rPos.top, cdc, 0, 0, SRCCOPY);
DeleteDC(cdc);
}
else {
COLORREF cColor;
HBITMAP bmAndBack, bmAndObject, bmAndMem, bmSave;
HBITMAP bmBackOld, bmObjectOld, bmMemOld, bmSaveOld;
HDC hdcMem, hdcBack, hdcObject, hdcTemp, hdcSave;
POINT ptSize;
HBITMAP hBitmap = img->hBitmap;
hdcTemp = CreateCompatibleDC(hdc);
SelectObject(hdcTemp, hBitmap); // Select the bitmap
ptSize.x = img->rPos.right - img->rPos.left;
ptSize.y = img->rPos.bottom - img->rPos.top;
DPtoLP(hdcTemp, &ptSize, 1); // Convert from device to logical points
// Create some DCs to hold temporary data.
hdcBack = CreateCompatibleDC(hdc);
hdcObject = CreateCompatibleDC(hdc);
hdcMem = CreateCompatibleDC(hdc);
hdcSave = CreateCompatibleDC(hdc);
// Create a bitmap for each DC. DCs are required for a number of
// GDI functions.
// Monochrome DC
bmAndBack = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL);
// Monochrome DC
bmAndObject = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL);
bmAndMem = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y);
bmSave = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y);
// Each DC must select a bitmap object to store pixel data.
bmBackOld = (HBITMAP)SelectObject(hdcBack, bmAndBack);
bmObjectOld = (HBITMAP)SelectObject(hdcObject, bmAndObject);
bmMemOld = (HBITMAP)SelectObject(hdcMem, bmAndMem);
bmSaveOld = (HBITMAP)SelectObject(hdcSave, bmSave);
// Set proper mapping mode.
SetMapMode(hdcTemp, GetMapMode(hdc));
// Save the bitmap sent here, because it will be overwritten.
BitBlt(hdcSave, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCCOPY);
// Set the background color of the source DC to the color.
// contained in the parts of the bitmap that should be transparent
cColor = SetBkColor(hdcTemp, img->cTransparent);
// Create the object mask for the bitmap by performing a BitBlt
// from the source bitmap to a monochrome bitmap.
BitBlt(hdcObject, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0,
SRCCOPY);
// Set the background color of the source DC back to the original
// color.
SetBkColor(hdcTemp, cColor);
// Create the inverse of the object mask.
BitBlt(hdcBack, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0,
NOTSRCCOPY);
// Copy the background of the main DC to the destination.
BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdc, img->rPos.left, img->rPos.top,
SRCCOPY);
// Mask out the places where the bitmap will be placed.
BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0, SRCAND);
// Mask out the transparent colored pixels on the bitmap.
BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdcBack, 0, 0, SRCAND);
// XOR the bitmap with the background on the destination DC.
BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCPAINT);
// Copy the destination to the screen.
BitBlt(hdc, img->rPos.left, img->rPos.top, ptSize.x, ptSize.y, hdcMem, 0, 0,
SRCCOPY);
// Place the original bitmap back into the bitmap sent here.
BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdcSave, 0, 0, SRCCOPY);
// Delete the memory bitmaps.
DeleteObject(SelectObject(hdcBack, bmBackOld));
DeleteObject(SelectObject(hdcObject, bmObjectOld));
DeleteObject(SelectObject(hdcMem, bmMemOld));
DeleteObject(SelectObject(hdcSave, bmSaveOld));
// Delete the memory DCs.
DeleteDC(hdcMem);
DeleteDC(hdcBack);
DeleteDC(hdcObject);
DeleteDC(hdcSave);
DeleteDC(hdcTemp);
}
img = img->next;
}
LCS();
EndPaint(hwnd, &ps);
}
break;
case WM_WINDOWPOSCHANGING:
if (IsWindow(hwndParent))
{
LPWINDOWPOS wp = (LPWINDOWPOS) lParam;
wp->flags |= SWP_NOACTIVATE;
wp->hwndInsertAfter = hwndParent;
}
break;
case WM_CLOSE:
DestroyWindow(hwnd);
break;
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
//-----------------------------------WinProc-----------------------------
//
//-----------------------------------------------------------------------
LRESULT CALLBACK WindowProc(HWND hWnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{
//these hold the dimensions of the client window area
static int cxClient, cyClient;
//used to create the back buffer
static HDC hdcBackBuffer;
static HBITMAP hBitmap;
static HBITMAP hOldBitmap;
switch(msg)
{
case WM_CREATE:
{
//seed the random number generator
srand((unsigned) time(NULL));
//get the size of the client window
RECT rect;
GetClientRect(hWnd, &rect);
cxClient = rect.right;
cyClient = rect.bottom;
//create a surface for us to render to(backbuffer)
hdcBackBuffer = CreateCompatibleDC(NULL);
HDC hdc = GetDC(hWnd);
hBitmap = CreateCompatibleBitmap(hdc,
cxClient,
cyClient);
ReleaseDC(hWnd, hdc);
hOldBitmap = (HBITMAP)SelectObject(hdcBackBuffer, hBitmap);
}
break;
//check key press messages
case WM_KEYUP:
{
switch(wparam)
{
case VK_ESCAPE:
{
PostQuitMessage(0);
}
break;
}//end WM_KEYUP switch
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
//fill our backbuffer with white
BitBlt(hdcBackBuffer,
0,
0,
cxClient,
cyClient,
NULL,
NULL,
NULL,
WHITENESS);
//render the gun
g_Gun.Render(hdcBackBuffer);
//now blit backbuffer to front
BitBlt(ps.hdc, 0, 0, cxClient, cyClient, hdcBackBuffer, 0, 0, SRCCOPY);
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
{
SelectObject(hdcBackBuffer, hOldBitmap);
//clean up our backbuffer objects
DeleteDC(hdcBackBuffer);
DeleteObject(hBitmap);
// kill the application, this sends a WM_QUIT message
PostQuitMessage(0);
}
break;
default:break;
}//end switch
// default msg handler
return (DefWindowProc(hWnd, msg, wparam, lparam));
}//end WinProc
/*****************************************************************
* CreateCaret (USER32.@)
*/
BOOL WINAPI CreateCaret( HWND hwnd, HBITMAP bitmap, INT width, INT height )
{
BOOL ret;
RECT r;
int old_state = 0;
int hidden = 0;
HBITMAP hBmp = 0;
HWND prev = 0;
TRACE("hwnd=%p\n", hwnd);
if (!hwnd) return FALSE;
if (bitmap && (bitmap != (HBITMAP)1))
{
BITMAP bmp;
if (!GetObjectA( bitmap, sizeof(bmp), &bmp )) return FALSE;
width = bmp.bmWidth;
height = bmp.bmHeight;
bmp.bmBits = NULL;
hBmp = CreateBitmapIndirect(&bmp);
if (hBmp)
{
/* copy the bitmap */
LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, bmp.bmWidthBytes * bmp.bmHeight);
GetBitmapBits(bitmap, bmp.bmWidthBytes * bmp.bmHeight, buf);
SetBitmapBits(hBmp, bmp.bmWidthBytes * bmp.bmHeight, buf);
HeapFree(GetProcessHeap(), 0, buf);
}
}
else
{
HDC hdc;
if (!width) width = GetSystemMetrics(SM_CXBORDER);
if (!height) height = GetSystemMetrics(SM_CYBORDER);
/* create the uniform bitmap on the fly */
hdc = GetDC(hwnd);
if (hdc)
{
HDC hMemDC = CreateCompatibleDC(hdc);
if (hMemDC)
{
if ((hBmp = CreateCompatibleBitmap(hMemDC, width, height )))
{
HBITMAP hPrevBmp = SelectObject(hMemDC, hBmp);
SetRect( &r, 0, 0, width, height );
FillRect(hMemDC, &r, bitmap ? GetStockObject(GRAY_BRUSH) : GetStockObject(WHITE_BRUSH));
SelectObject(hMemDC, hPrevBmp);
}
DeleteDC(hMemDC);
}
ReleaseDC(hwnd, hdc);
}
}
if (!hBmp) return FALSE;
SERVER_START_REQ( set_caret_window )
{
req->handle = wine_server_user_handle( hwnd );
req->width = width;
req->height = height;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev && !hidden) /* hide the previous one */
{
/* FIXME: won't work if prev belongs to a different process */
KillSystemTimer( prev, TIMERID );
if (old_state) CARET_DisplayCaret( prev, &r );
}
if (Caret.hBmp) DeleteObject( Caret.hBmp );
Caret.hBmp = hBmp;
Caret.timeout = GetProfileIntA( "windows", "CursorBlinkRate", 500 );
return TRUE;
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PetscDrawCreate_Win32"
PetscErrorCode PetscDrawCreate_Win32(PetscDraw draw)
{
PetscDraw_Win32 *windraw;
HANDLE hThread = NULL;
PetscErrorCode ierr;
WindowNode newnode;
PetscFunctionBegin;
ierr = PetscNew(PetscDraw_Win32,&windraw);CHKERRQ(ierr);
draw->data = windraw;
/* the following is temporary fix for initializing a global datastructure */
if(!g_hWindowListMutex) {
g_hWindowListMutex = CreateMutex(NULL,FALSE,NULL);
}
ierr = PetscMemcpy(draw->ops,&DvOps,sizeof(DvOps));CHKERRQ(ierr);
windraw->hReadyEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
/* makes call to MessageLoopThread to creat window and attach a thread */
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)MessageLoopThread_Win32,draw,0,(unsigned long*)hThread);
CloseHandle(hThread);
WaitForSingleObject(windraw->hReadyEvent,INFINITE);
CloseHandle(windraw->hReadyEvent);
WaitForSingleObject(g_hWindowListMutex,INFINITE);
ierr = PetscNew(struct _p_WindowNode,&newnode);CHKERRQ(ierr);
newnode->MouseListHead = NULL;
newnode->MouseListTail = NULL;
newnode->wnext = WindowListHead;
newnode->wprev = NULL;
newnode->hWnd = windraw->hWnd;
if(WindowListHead != NULL) {
WindowListHead->wprev = newnode;
}
WindowListHead = newnode;
windraw->hdc = GetDC(windraw->hWnd);
windraw->stringheight = 10;
windraw->stringwidth = 6;
windraw->linewidth = 1; /* default pixel sizes of graphics until user changes them */
windraw->pointdiameter = 1;
windraw->node = newnode;
windraw->x = draw->x;
windraw->y = draw->y;
windraw->w = newnode->bitwidth = draw->w;
windraw->h = newnode->bitheight = draw->h;
/* Create and initialize primary graphics buffer */
newnode->Buffer = CreateCompatibleDC(windraw->hdc);
newnode->BufferBit = CreateCompatibleBitmap(windraw->hdc,windraw->w,windraw->h);
newnode->store = SelectObject(newnode->Buffer,newnode->BufferBit);
ExtFloodFill(newnode->Buffer,0,0,COLOR_WINDOW,FLOODFILLBORDER);
newnode->event = CreateEvent(NULL,TRUE,FALSE,NULL);
newnode->DoubleBuffered = PETSC_FALSE;
ReleaseDC(windraw->hWnd,windraw->hdc);
ReleaseMutex(g_hWindowListMutex);
PetscFunctionReturn(0);
}
bool Win32Window::takeScreenshot(uint8_t *pixelData)
{
if (mIsVisible)
{
return false;
}
bool error = false;
// Hack for DWM: There is no way to wait for DWM animations to finish, so we just have to wait
// for a while before issuing screenshot if window was just made visible.
{
static const double WAIT_WINDOW_VISIBLE_MS = 0.5; // Half a second for the animation
double timeSinceVisible = mSetVisibleTimer->getElapsedTime();
if (timeSinceVisible < WAIT_WINDOW_VISIBLE_MS)
{
Sleep(static_cast<DWORD>((WAIT_WINDOW_VISIBLE_MS - timeSinceVisible) * 1000));
}
}
HDC screenDC = nullptr;
HDC windowDC = nullptr;
HDC tmpDC = nullptr;
HBITMAP tmpBitmap = nullptr;
if (!error)
{
screenDC = GetDC(nullptr);
error = screenDC == nullptr;
}
if (!error)
{
windowDC = GetDC(mNativeWindow);
error = windowDC == nullptr;
}
if (!error)
{
tmpDC = CreateCompatibleDC(screenDC);
error = tmpDC == nullptr;
}
if (!error)
{
tmpBitmap = CreateCompatibleBitmap(screenDC, mWidth, mHeight);
error = tmpBitmap == nullptr;
}
RECT rect = {0, 0, 0, 0};
if (!error)
{
MapWindowPoints(mNativeWindow, nullptr, reinterpret_cast<LPPOINT>(&rect), 0);
error = SelectObject(tmpDC, tmpBitmap) == nullptr;
}
if (!error)
{
error = BitBlt(tmpDC, 0, 0, mWidth, mHeight, screenDC, rect.left, rect.top, SRCCOPY) == TRUE;
}
if (!error)
{
BITMAPINFOHEADER bitmapInfo;
bitmapInfo.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.biWidth = mWidth;
bitmapInfo.biHeight = -mHeight;
bitmapInfo.biPlanes = 1;
bitmapInfo.biBitCount = 32;
bitmapInfo.biCompression = BI_RGB;
bitmapInfo.biSizeImage = 0;
bitmapInfo.biXPelsPerMeter = 0;
bitmapInfo.biYPelsPerMeter = 0;
bitmapInfo.biClrUsed = 0;
bitmapInfo.biClrImportant = 0;
int getBitsResult = GetDIBits(screenDC, tmpBitmap, 0, mHeight, pixelData,
reinterpret_cast<BITMAPINFO*>(&bitmapInfo), DIB_RGB_COLORS);
error = getBitsResult != 0;
}
if (tmpBitmap != nullptr)
{
DeleteObject(tmpBitmap);
}
if (tmpDC != nullptr)
{
DeleteDC(tmpDC);
}
if (screenDC != nullptr)
{
ReleaseDC(nullptr, screenDC);
}
if (windowDC != nullptr)
{
ReleaseDC(mNativeWindow, windowDC);
}
return !error;
}
//
// InitWindowRegion
//
// We display the video in a window that has a region selected into it that
// matches the word we are passed in. By doing this we let Windows manage
// all the clipping and mouse technology. The trick is in creating a region
// that matches the word, which is done by using paths. We create a path for
// a temporary HDC, draw the word and then end the path. After that, we can then
// ask Windows for a region that describes that path. That gives us a region
// for the outside of the word, so we bitwise "not" it to get the word region.
//
HRESULT CVideoText::InitWindowRegion(TCHAR *pStringName)
{
ASSERT(pStringName);
OSVERSIONINFO VersionInfo;
VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
EXECUTE_ASSERT(GetVersionEx(&VersionInfo));
// Set a window region according to the OS capabilities
if ((VersionInfo.dwPlatformId & VER_PLATFORM_WIN32_NT) == 0)
{
m_Size.cx = 320;
m_Size.cy = 240;
return NOERROR;
}
// Get the text extents the word passed in will require based on the
// font and bitmap selected in the current device context. For it to
// be displayed in a different font it must be selected into the HDC
HDC hdc = CreateCompatibleDC(m_hdc);
HFONT hFont = CreateVideoFont();
SelectObject(hdc,hFont);
GetTextExtentPoint32((HDC) hdc, // The output device context
pStringName, // The string we'll be using
lstrlen(pStringName), // Number of characters in it
(LPSIZE) &m_Size); // Filled in with the extents
// Create a bitmap that matches the current format
HBITMAP hMaskBitmap = CreateCompatibleBitmap(hdc,m_Size.cx,m_Size.cy);
if (hMaskBitmap == NULL) {
ASSERT(hMaskBitmap);
return E_UNEXPECTED;
}
// Select the monochrome bitmap into the device context
HBITMAP hBitmap = (HBITMAP) SelectObject(hdc,hMaskBitmap);
EXECUTE_ASSERT(BeginPath(hdc));
// Draw the string into the monochrome bitmap
ExtTextOut((HDC) hdc, // Target device context
(int) 0, // x coordinate reference
(int) 0, // Likewise y coordinate
(DWORD) 0, // No special flags to set
NULL, // No clipping rectangle
pStringName, // Pointer to text words
lstrlen(pStringName), // Number of characters
NULL); // Intercharacter spacing
EXECUTE_ASSERT(EndPath(hdc));
HRGN hOutside = PathToRegion(hdc);
HRGN hFullWindow = CreateRectRgn(0,0,m_Size.cx,m_Size.cy);
HRGN hWordRegion = CreateRectRgn(0,0,1,1);
CombineRgn(hWordRegion,hFullWindow,hOutside,RGN_DIFF);
SetWindowRgn(m_hwnd,hWordRegion,TRUE);
// Clear up the regions we created
DeleteObject(hWordRegion);
DeleteObject(hOutside);
DeleteObject(hFullWindow);
// Delete the HDC and text bitmap
SelectObject(hdc,hBitmap);
HFONT hDefault = (HFONT) GetStockObject(SYSTEM_FONT);
SelectObject(hdc,hDefault);
DeleteObject(hFont);
DeleteObject(hMaskBitmap);
DeleteDC(hdc);
return NOERROR;
} // InitWindowRegion
void DynamicFontGenerator::GenerateFont()
{
if (!m_dirty)
return;
m_dirty = false;
m_texture->createTexture(math::vector3di(m_textureSize.x,m_textureSize.y, 1), video::EPixel_Alpha8);
bool m_mask = true;
if (m_data->fontDirty)
{
m_data->Recreate(m_fontResolution, m_bold, m_italic,m_underline, m_fontName);
}
HBITMAP bmp = CreateCompatibleBitmap(m_data->dc, m_textureSize.x, m_textureSize.y);
HDC bmpdc = CreateCompatibleDC(m_data->dc);
HBRUSH brush = CreateSolidBrush(RGB(0, 0, 0));
HPEN pen = CreatePen(PS_NULL, 0, RGB(0, 0, 0));
HGDIOBJ oldbmp = SelectObject(bmpdc, bmp);
HGDIOBJ oldbmppen = SelectObject(bmpdc, pen);
HGDIOBJ oldbmpbrush = SelectObject(bmpdc, brush);
HGDIOBJ oldbmpFont = SelectObject(bmpdc, m_data->font);
SetBkMode(bmpdc, OPAQUE);
SetBkColor(bmpdc, RGB(0,0,0));
SetTextColor(bmpdc, RGB(255, 255, 255));
Rectangle(bmpdc, 0, 0, m_textureSize.x, m_textureSize.y);
core::stringw text = L"";
// prepare characters
std::vector<wchar_t> sorted;
std::vector<math::vector2d> rectSize;
std::vector< core::BinPackerOutRect > packs;
{
for (int i = 0; i < m_charsAttr.size(); ++i)
delete m_charsAttr[i];
m_charsAttr.clear();
FontCharacterRange* range = 0;
std::set<wchar_t>::iterator it = m_chars.begin();
sorted.resize(m_chars.size());
std::vector<int> rangeMap;
wchar_t lastID = -1;
wchar_t minID = -1;
int firstIdx = 0;
for (int i=0; it != m_chars.end(); ++it,++i)
{
sorted[i] = *it;
}
std::sort(sorted.begin(), sorted.end());
for (int i = 0; i < sorted.size();++i)
{
wchar_t c = sorted[i];
if (lastID == -1)
{
minID = c;
lastID = c;
}
else
{
if (c!=lastID+1)
{
if (!range)
{
range = new FontCharacterRange();
}
range->SetMinMax(minID,lastID);
m_charsAttr.push_back(range);
range = new FontCharacterRange();
minID = c;
firstIdx = i;
}
lastID = c;
rangeMap.push_back(m_charsAttr.size());
}
text.append(1,c);
//calculate character size
SIZE sz;
GetTextExtentPoint32W(bmpdc, &c, 1, &sz);
rectSize.push_back(math::vector2d(sz.cx, sz.cy));
}
if (range != 0){
range->SetMinMax(minID, lastID);
m_charsAttr.push_back(range);
}
core::BinPacker packer;
packer.Pack(rectSize, packs, math::vector2d(m_textureSize.x, m_textureSize.y), false);
math::vector2d invSize(1.0f / m_textureSize.x, 1.0f / m_textureSize.y);
float invRes = 1.0f / (float)m_fontResolution;
for (int i = 0; i < packs.size();++i)
{
int id = packs[i].ID;
FontCharacterRange* range= m_charsAttr[rangeMap[id]];
FontCharAttr* attr = range->GetCharacterInfo(sorted[id]);
attr->rectSize = rectSize[id] * invRes;
attr->texID = 0;
attr->texcoords.ULPoint = packs[i].pos*invSize;
attr->texcoords.BRPoint = attr->texcoords.ULPoint + rectSize[id] * invSize;
}
}
for (int i = 0; i < packs.size(); ++i)
{
core::BinPackerOutRect& p = packs[i];
TextOutW(bmpdc, p.pos.x, p.pos.y, &sorted[p.ID], 1);
}
BITMAP bmpInfo;
//get image info
GetObject(bmp, sizeof(BITMAP), &bmpInfo);
uchar *buffer;
int pixel = m_mask ? 4 : 3;
int line = (bmpInfo.bmWidth*pixel + pixel) & 0xfffffffc;
int dataSize = line*(bmpInfo.bmHeight);
//get image data
buffer = new uchar[dataSize];
video::IHardwarePixelBuffer* pixBuff= m_texture->getSurface(0);
video::LockedPixelBox lbox = pixBuff->lock(math::box3d(0, 0, 0, m_textureSize.x, m_textureSize.y, 1), video::IHardwareBuffer::ELO_Discard);
uchar* dstPixels = (uchar*)lbox.data;
GetBitmapBits(bmp, dataSize, buffer);
for (int i = 0; i < m_textureSize.x*m_textureSize.y; ++i)
{
dstPixels[i] = buffer[i * 4];
}
pixBuff->unlock();
delete[] buffer;
SelectObject(bmpdc, oldbmp);
SelectObject(bmpdc, oldbmppen);
SelectObject(bmpdc, oldbmpbrush);
DeleteDC(bmpdc);
DeleteObject(brush);
DeleteObject(pen);
DeleteObject(bmp);
}
HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader,
BOOL blLogo) // ロゴの有無
{
HDC hScrDC, hMemDC; // screen DC and memory DC
HBITMAP hBitmap, hOldBitmap; // handles to deice-dependent bitmaps
int nX, nY, nX2, nY2; // coordinates of rectangle to grab
int nWidth, nHeight; // DIB width and height
int xScrn, yScrn; // screen resolution
// check for an empty rectangle
if (IsRectEmpty(lpRect))
return NULL;
// create a DC for the screen and create
// a memory DC compatible to screen DC
hScrDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
hMemDC = CreateCompatibleDC(hScrDC);
// get points of rectangle to grab
nX = lpRect->left;
nY = lpRect->top;
nX2 = lpRect->right;
nY2 = lpRect->bottom;
// get screen resolution
xScrn = GetDeviceCaps(hScrDC, HORZRES);
yScrn = GetDeviceCaps(hScrDC, VERTRES);
//make sure bitmap rectangle is visible
if (nX < 0)
nX = 0;
if (nY < 0)
nY = 0;
if (nX2 > xScrn)
nX2 = xScrn;
if (nY2 > yScrn)
nY2 = yScrn;
nWidth = nX2 - nX;
nHeight = nY2 - nY;
// create a bitmap compatible with the screen DC
hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
// select new bitmap into memory DC
hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
// bitblt screen DC to memory DC
BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
// Text impose
if (blLogo) {
AddText(hMemDC);
}
// select old bitmap back into memory DC and get handle to
// bitmap of the screen
hBitmap = (HBITMAP) SelectObject(hMemDC, hOldBitmap);
// Copy the bitmap data into the provided BYTE buffer
GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
// clean up
DeleteDC(hScrDC);
DeleteDC(hMemDC);
// return handle to the bitmap
return hBitmap;
}
VOID vTestPal3(HDC hdc)
{
HBRUSH hbrR, hbrG, hbrB;
HDC hdc8;
HBITMAP hbm8;
if (GetDeviceCaps(hdc,BITSPIXEL) > 8)
return;
hbm8 = CreateCompatibleBitmap(hdc, 64, 64);
hdc8 = CreateCompatibleDC(hdc);
SelectObject(hdc8, hbm8);
hbrR = CreateSolidBrush(RGB(255,0,0));
hbrG = CreateSolidBrush(RGB(0,255,0));
hbrB = CreateSolidBrush(RGB(0,0,255));
SelectObject(hdc8, hbrR);
PatBlt(hdc8, 0, 0, 64, 64, PATCOPY);
SelectObject(hdc8, hbrG);
PatBlt(hdc8, 16, 16, 32, 32, PATCOPY);
SelectObject(hdc8, hbrB);
PatBlt(hdc8, 24, 24, 16, 16, PATCOPY);
// See what the bitmap looks like.
BitBlt(hdc, 0, 100, 64, 64, hdc8, 0, 0, SRCCOPY);
// Get the header
bmi256.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi256.bmiHeader.biBitCount = 0;
GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
// Get the color table
GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
// Get the bits
if (64 != GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS))
DbgPrint("The GetDIBits failed vTestPal3\n");
// Look at the bits.
SetDIBitsToDevice(hdc, 64, 100, 64, 64, 0, 0, 0, 64,
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
// Do them left half right half
SetDIBitsToDevice(hdc, 128, 100, 32, 64, 0, 0, 0, 64,
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
SetDIBitsToDevice(hdc, 160, 100, 32, 64, 32, 0, 0, 64,
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
DeleteDC(hdc8);
DeleteObject(hbm8);
DeleteObject(hbrR);
DeleteObject(hbrG);
DeleteObject(hbrB);
}
VOID CRenoBuffer::OnPaint()
{
CPaintDC dc(this);
CRect clipRect;
dc.GetClipBox(clipRect);
CRect clientRect;
GetClientRect(clientRect);
// Start doublebuffering
HDC hCompatibleDC = CreateCompatibleDC(dc.GetSafeHdc());
HBITMAP hBackbuffer = CreateCompatibleBitmap(dc.GetSafeHdc(),clientRect.Width(),clientRect.Height());
HBITMAP hOldBitmap = (HBITMAP)SelectObject(hCompatibleDC,hBackbuffer);
SetBoundsRect(hCompatibleDC,clipRect,NULL);
FillRect(hCompatibleDC,clientRect,(HBRUSH)CBrush(BACKGROUND_COLOR).GetSafeHandle());
HGDIOBJ hOldFont = SelectObject(hCompatibleDC,theApp.GetFont());
SetBkMode(hCompatibleDC,TRANSPARENT);
CRect boundsRect;
GetClientRect(boundsRect);
boundsRect.DeflateRect(RENO_BUFFER_MARGIN_HORIZONTAL,RENO_BUFFER_MARGIN_VERTICAL);
COLORREF colorDefault = GetTextColor(hCompatibleDC);
COLORREF colorSystem = RGB(44,88,222);
SIZE size;
TEXTMETRIC textmetrics;
for(LONG i = m_BufferScrollLine; i < m_Buffer.GetCount(); ++i)
{
if(!m_Buffer[i].GetLength())
{
GetTextExtentPoint32(hCompatibleDC,TEXT(" "),1,&size);
boundsRect.bottom -= size.cy;
continue;
}
// Currently only color system messages
if(m_Buffer[i].GetAt(0) == TEXT('*'))
SetTextColor(hCompatibleDC,colorSystem);
else
SetTextColor(hCompatibleDC,colorDefault);
// Set a fixed stack size
ULONG stack[32];
ULONG stackTop = 0;
// Put the default font at the bottom of the stack
stack[stackTop++] = RENO_FONT_NORMAL;
LONG x = boundsRect.left;
LONG index = 0;
while(index < m_Buffer[i].GetLength())
{
LONG control = -1;
// Find a control character
for(LONG j = index + 1; j < m_Buffer[i].GetLength(); ++j)
{
if(m_Buffer[i].GetAt(j) == IRC_CONTROL_BOLD ||
m_Buffer[i].GetAt(j) == IRC_CONTROL_UNDERLINE ||
m_Buffer[i].GetAt(j) == IRC_CONTROL_ITALIC ||
m_Buffer[i].GetAt(j) == IRC_CONTROL_NORMAL)
{
// Found one
control = j;
break;
}
}
if(control == -1)
{
// We are going to the end of the line
control = m_Buffer[i].GetLength();
}
// Colors
// "black" : "\x0301",
// "dark blue" : "\x0302",
// "dark green" : "\x0303",
// "green" : "\x0303",
// "red" : "\x0304",
// "light red" : "\x0304",
// "dark red" : "\x0305",
// "purple" : "\x0306",
// "brown" : "\x0307", // On some clients this is orange, others it is brown
// "orange" : "\x0307",
// "yellow" : "\x0308",
// "light green" : "\x0309",
// "aqua" : "\x0310",
// "light blue" : "\x0311",
// "blue" : "\x0312",
// "violet" : "\x0313",
// "grey" : "\x0314",
// "gray" : "\x0314",
// "light grey" : "\x0315",
// "light gray" : "\x0315",
// "white" : "\x0316",
// Other formatting
// "normal" : "\x0F",
// "bold" : "\x02",
// "reverse" : "\x16",
// "underline" : "\x1F",
switch(m_Buffer[i].GetAt(index))
{
case IRC_CONTROL_BOLD:
if(stack[stackTop-1] == RENO_FONT_BOLD)
--stackTop; // Pop the top
else
stack[stackTop++] = RENO_FONT_BOLD; // Push
++index; // Skip the control character
break;
case IRC_CONTROL_ITALIC:
if(stack[stackTop-1] ==RENO_FONT_ITALIC)
--stackTop; // Pop the top
else
stack[stackTop++] = RENO_FONT_ITALIC; // Push
++index; // Skip the control character
break;
case IRC_CONTROL_UNDERLINE:
if(stack[stackTop-1] == RENO_FONT_UNDERLINE)
--stackTop; // Pop the top
else
stack[stackTop++] = RENO_FONT_UNDERLINE; // Push
++index; // Skip the control character
break;
case IRC_CONTROL_NORMAL:
if(stack[stackTop-1] == RENO_FONT_NORMAL && stackTop > 1)
--stackTop; // Pop the top
else
stack[stackTop++] = RENO_FONT_NORMAL; // Push
++index; // Skip the control character
break;
}
if(control - index)
{
SelectObject(hCompatibleDC,theApp.GetFont(stack[stackTop-1]));
GetTextExtentPoint32(hCompatibleDC,m_Buffer[i].GetBuffer() + index,control - index,&size);
TextOut(hCompatibleDC,x,boundsRect.bottom - size.cy,m_Buffer[i].GetBuffer() + index,control - index);
x += size.cx;
// Retrieve the overhang value from the TEXTMETRIC structure and subtract it from the x-increment (This is only necessary for non-TrueType raster fonts)
GetTextMetrics(hCompatibleDC,&textmetrics);
x -= textmetrics.tmOverhang;
}
index = control;
}
GetTextExtentPoint32(hCompatibleDC,TEXT(" "),1,&size); // TODO Maybe not necessary, the size struct will already be set from some above call
boundsRect.bottom -= size.cy;
if(boundsRect.bottom < -size.cy)
break; // No point in painting further cause everything would get clipped
}
// Update the scrollbar
if(m_Buffer.GetCount() > 1)
{
SelectObject(hCompatibleDC,theApp.GetFont());
GetTextMetrics(hCompatibleDC,&textmetrics);
SCROLLINFO info;
info.cbSize = sizeof(info);
info.fMask = SIF_ALL;
info.nMin = 0;
info.nMax = m_Buffer.GetCount()-1 + clientRect.Height()/textmetrics.tmHeight-1;
info.nPos = m_Buffer.GetCount()-1 - m_BufferScrollLine;
info.nPage = clientRect.Height()/textmetrics.tmHeight;
SetScrollInfo(SB_VERT,&info);
EnableScrollBar(SB_VERT,ESB_ENABLE_BOTH);
}
else
{
EnableScrollBar(SB_VERT,ESB_DISABLE_BOTH);
}
SelectObject(hCompatibleDC,hOldFont);
// End doublebuffering
BitBlt(dc.GetSafeHdc(),0,0,clientRect.Width(),clientRect.Height(),hCompatibleDC,0,0,SRCCOPY);
SelectObject(hCompatibleDC,hOldBitmap);
DeleteObject(hBackbuffer);
DeleteDC(hCompatibleDC);
}
//
// 函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// 目的: 处理主窗口的消息。
//
// WM_COMMAND - 处理应用程序菜单
// WM_PAINT - 绘制主窗口
// WM_DESTROY - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// 分析菜单选择:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
{
hdc = BeginPaint(hWnd, &ps);
HDC comDC = CreateCompatibleDC(hdc);
RECT rect;
GetClientRect(hWnd, &rect);//这时还不能绘图，因为没有地方画 ^_^
//下面建立一个与屏幕显示兼容的位图，至于位图的大小嘛，可以用窗口的大小，也可以自己定义（如：有滚动条时就要大于当前窗口的大小，在BitBlt时决定拷贝内存的哪部分到屏幕上
HBITMAP comBitmap = CreateCompatibleBitmap(hdc,
rect.right - rect.left, rect.bottom-rect.top);
//将位图选入到内存显示设备中
//只有选入了位图的内存显示设备才有地方绘图，画到指定的位图上
HBITMAP oldBitmap = (HBITMAP)SelectObject(comDC, comBitmap);
//先用背景色将位图清除干净，这里我用的是白色作为背景(否则会为黑色)
//你也可以用自己应该用的颜色
HBRUSH brush = CreateSolidBrush(RGB(255, 255, 255));
FillRect(comDC, &rect, brush);
DeleteObject(brush);
//进行绘图操作
LineTo(comDC, 100, 100);
LineTo(comDC, 300, 300);
TextOut(comDC, 200, 200, L"兼容DC测试", 6);
Rectangle(comDC, 500, 100, 800, 300);
//将内存中的图拷贝到屏幕上进行显示
BitBlt(hdc, 0, 0, rect.right - rect.left, rect.bottom -rect.top, comDC,
0, 0, SRCCOPY);
//绘图完成后的清理
DeleteObject(comBitmap);
DeleteObject(comDC);
EndPaint(hWnd, &ps);
break;
}
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
BOOL
vncDesktop::InitBitmap()
{
// Get the device context for the whole screen and find it's size
m_hrootdc = ::GetDC(NULL);
if (m_hrootdc == NULL) {
//vnclog.Print(LL_INTERR, VNCLOG("failed to get display context\n"));
return FALSE;
}
m_bmrect = rfb::Rect(0, 0,
GetDeviceCaps(m_hrootdc, HORZRES),
GetDeviceCaps(m_hrootdc, VERTRES));
//vnclog.Print(LL_INTINFO, VNCLOG("bitmap dimensions are %d x %d\n"), m_bmrect.br.x, m_bmrect.br.y);
// Create a compatible memory DC
m_hmemdc = CreateCompatibleDC(m_hrootdc);
if (m_hmemdc == NULL) {
//vnclog.Print(LL_INTERR, VNCLOG("failed to create compatibleDC(%d)\n"), GetLastError());
return FALSE;
}
// Check that the device capabilities are ok
if ((GetDeviceCaps(m_hrootdc, RASTERCAPS) & RC_BITBLT) == 0)
{
MessageBox(
NULL,
"vncDesktop : root device doesn't support BitBlt\n"
"WinVNC cannot be used with this graphic device driver",
szAppName,
MB_ICONSTOP | MB_OK
);
return FALSE;
}
if ((GetDeviceCaps(m_hmemdc, RASTERCAPS) & RC_DI_BITMAP) == 0)
{
MessageBox(
NULL,
"vncDesktop : memory device doesn't support GetDIBits\n"
"WinVNC cannot be used with this graphics device driver",
szAppName,
MB_ICONSTOP | MB_OK
);
return FALSE;
}
// Create the bitmap to be compatible with the ROOT DC!!!
m_membitmap = CreateCompatibleBitmap(m_hrootdc, m_bmrect.br.x, m_bmrect.br.y);
if (m_membitmap == NULL) {
//vnclog.Print(LL_INTERR, VNCLOG("failed to create memory bitmap(%d)\n"), GetLastError());
return FALSE;
}
//vnclog.Print(LL_INTINFO, VNCLOG("created memory bitmap\n"));
// Get the bitmap's format and colour details
int result;
memset(&m_bminfo, 0, sizeof(m_bminfo));
m_bminfo.bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
m_bminfo.bmi.bmiHeader.biBitCount = 0;
result = ::GetDIBits(m_hmemdc, m_membitmap, 0, 1, NULL, &m_bminfo.bmi, DIB_RGB_COLORS);
if (result == 0) {
//vnclog.Print(LL_INTERR, VNCLOG("unable to get display format\n"));
return FALSE;
}
result = ::GetDIBits(m_hmemdc, m_membitmap, 0, 1, NULL, &m_bminfo.bmi, DIB_RGB_COLORS);
if (result == 0) {
//vnclog.Print(LL_INTERR, VNCLOG("unable to get display colour info\n"));
return FALSE;
}
//vnclog.Print(LL_INTINFO, VNCLOG("got bitmap format\n"));
// Henceforth we want to use a top-down scanning representation
m_bminfo.bmi.bmiHeader.biHeight = - abs(m_bminfo.bmi.bmiHeader.biHeight);
// Is the bitmap palette-based or truecolour?
m_bminfo.truecolour = (GetDeviceCaps(m_hmemdc, RASTERCAPS) & RC_PALETTE) == 0;
return TRUE;
}
// Creation de bitmap coche
HBITMAP GetMyCheckBitmaps(UINT fuCheck)
{
COLORREF crBackground; // background color
HBRUSH hbrBackground; // background brush
HBRUSH hbrTargetOld; // original background brush
HDC hdcSource; // source device context
HDC hdcTarget; // target device context
HBITMAP hbmpCheckboxes; // handle to check-box bitmap
BITMAP bmCheckbox; // structure for bitmap data
HBITMAP hbmpSourceOld; // handle to original source bitmap
HBITMAP hbmpTargetOld; // handle to original target bitmap
HBITMAP hbmpCheck; // handle to check-mark bitmap
RECT rc; // rectangle for check-box bitmap
WORD wBitmapX; // width of check-mark bitmap
WORD wBitmapY; // height of check-mark bitmap
// Get the menu background color and create a solid brush
// with that color.
crBackground = GetSysColor(COLOR_MENU);
hbrBackground = CreateSolidBrush(crBackground);
// Create memory device contexts for the source and
// destination bitmaps.
hdcSource = CreateCompatibleDC((HDC) NULL);
hdcTarget = CreateCompatibleDC(hdcSource);
// Get the size of the system default check-mark bitmap and
// create a compatible bitmap of the same size.
wBitmapX = GetSystemMetrics(SM_CXMENUCHECK);
wBitmapY = GetSystemMetrics(SM_CYMENUCHECK);
hbmpCheck = CreateCompatibleBitmap(hdcSource, wBitmapX,
wBitmapY);
// Select the background brush and bitmap into the target DC.
hbrTargetOld = SelectObject(hdcTarget, hbrBackground);
hbmpTargetOld = SelectObject(hdcTarget, hbmpCheck);
// Use the selected brush to initialize the background color
// of the bitmap in the target device context.
PatBlt(hdcTarget, 0, 0, wBitmapX, wBitmapY, PATCOPY);
// Load the predefined check box bitmaps and select it
// into the source DC.
hbmpCheckboxes = LoadBitmap((HINSTANCE) NULL,
(LPTSTR) OBM_CHECKBOXES);
hbmpSourceOld = SelectObject(hdcSource, hbmpCheckboxes);
// Fill a BITMAP structure with information about the
// check box bitmaps, and then find the upper-left corner of
// the unchecked check box or the checked check box.
GetObject(hbmpCheckboxes, sizeof(BITMAP), &bmCheckbox);
if (fuCheck == 2 /*UNCHECK*/)
{
rc.left = 0;
rc.right = (bmCheckbox.bmWidth / 4);
}
else
{
rc.left = (bmCheckbox.bmWidth / 4);
rc.right = (bmCheckbox.bmWidth / 4) * 2;
}
rc.top = 0;
rc.bottom = (bmCheckbox.bmHeight / 3);
// Copy the appropriate bitmap into the target DC. If the
// check-box bitmap is larger than the default check-mark
// bitmap, use StretchBlt to make it fit; otherwise, just
// copy it.
if (((rc.right - rc.left) > (int) wBitmapX) ||
((rc.bottom - rc.top) > (int) wBitmapY))
{
StretchBlt(hdcTarget, 0, 0, wBitmapX, wBitmapY,
hdcSource, rc.left, rc.top, rc.right - rc.left,
rc.bottom - rc.top, SRCCOPY);
}
else
{
BitBlt(hdcTarget, 0, 0, rc.right - rc.left,
rc.bottom - rc.top,
hdcSource, rc.left, rc.top, SRCCOPY);
}
// Select the old source and destination bitmaps into the
// source and destination DCs, and then delete the DCs and
// the background brush.
SelectObject(hdcSource, hbmpSourceOld);
SelectObject(hdcTarget, hbrTargetOld);
hbmpCheck = SelectObject(hdcTarget, hbmpTargetOld);
DeleteObject(hbrBackground);
DeleteObject(hdcSource);
DeleteObject(hdcTarget);
// Return a handle to the new check-mark bitmap.
return hbmpCheck;
}
void CtrlDisAsmView::onPaint(WPARAM wParam, LPARAM lParam)
{
if (!debugger->isAlive()) return;
PAINTSTRUCT ps;
HDC actualHdc = BeginPaint(wnd, &ps);
HDC hdc = CreateCompatibleDC(actualHdc);
HBITMAP hBM = CreateCompatibleBitmap(actualHdc, rect.right-rect.left, rect.bottom-rect.top);
SelectObject(hdc, hBM);
SetBkMode(hdc, TRANSPARENT);
HPEN nullPen=CreatePen(0,0,0xffffff);
HBRUSH nullBrush=CreateSolidBrush(0xffffff);
HBRUSH currentBrush=CreateSolidBrush(0xffefe8);
HPEN oldPen=(HPEN)SelectObject(hdc,nullPen);
HBRUSH oldBrush=(HBRUSH)SelectObject(hdc,nullBrush);
HFONT oldFont = (HFONT)SelectObject(hdc,(HGDIOBJ)font);
HICON breakPoint = (HICON)LoadIcon(GetModuleHandle(0),(LPCWSTR)IDI_STOP);
HICON breakPointDisable = (HICON)LoadIcon(GetModuleHandle(0),(LPCWSTR)IDI_STOPDISABLE);
unsigned int address = windowStart;
std::map<u32,int> addressPositions;
const std::set<std::string> currentArguments = getSelectedLineArguments();
DisassemblyLineInfo line;
for (int i = 0; i < visibleRows; i++)
{
manager.getLine(address,displaySymbols,line);
int rowY1 = rowHeight*i;
int rowY2 = rowHeight*(i+1);
addressPositions[address] = rowY1;
// draw background
COLORREF backgroundColor = whiteBackground ? 0xFFFFFF : debugger->getColor(address);
COLORREF textColor = 0x000000;
if (isInInterval(address,line.totalSize,debugger->getPC()))
{
backgroundColor = scaleColor(backgroundColor,1.05f);
}
if (address >= selectRangeStart && address < selectRangeEnd && searching == false)
{
if (hasFocus)
{
backgroundColor = address == curAddress ? 0xFF8822 : 0xFF9933;
textColor = 0xFFFFFF;
} else {
backgroundColor = 0xC0C0C0;
}
}
HBRUSH backgroundBrush = CreateSolidBrush(backgroundColor);
HPEN backgroundPen = CreatePen(0,0,backgroundColor);
SelectObject(hdc,backgroundBrush);
SelectObject(hdc,backgroundPen);
Rectangle(hdc,0,rowY1,rect.right,rowY1+rowHeight);
SelectObject(hdc,currentBrush);
SelectObject(hdc,nullPen);
DeleteObject(backgroundBrush);
DeleteObject(backgroundPen);
// display address/symbol
bool enabled;
if (CBreakPoints::IsAddressBreakPoint(address,&enabled))
{
if (enabled) textColor = 0x0000FF;
int yOffset = max(-1,(rowHeight-14+1)/2);
if (!enabled) yOffset++;
DrawIconEx(hdc,2,rowY1+1+yOffset,enabled ? breakPoint : breakPointDisable,32,32,0,0,DI_NORMAL);
}
SetTextColor(hdc,textColor);
char addressText[64];
getDisasmAddressText(address,addressText,true,line.type == DISTYPE_OPCODE);
TextOutA(hdc,pixelPositions.addressStart,rowY1+2,addressText,(int)strlen(addressText));
if (isInInterval(address,line.totalSize,debugger->getPC()))
{
TextOut(hdc,pixelPositions.opcodeStart-8,rowY1,L"■",1);
}
// display whether the condition of a branch is met
if (line.info.isConditional && address == debugger->getPC())
{
line.params += line.info.conditionMet ? " ; true" : " ; false";
}
drawArguments(hdc, line, pixelPositions.argumentsStart, rowY1 + 2, textColor, currentArguments);
SelectObject(hdc,boldfont);
TextOutA(hdc,pixelPositions.opcodeStart,rowY1+2,line.name.c_str(),(int)line.name.size());
SelectObject(hdc,font);
address += line.totalSize;
}
std::vector<BranchLine> branchLines = manager.getBranchLines(windowStart,address-windowStart);
for (size_t i = 0; i < branchLines.size(); i++)
{
drawBranchLine(hdc,addressPositions,branchLines[i]);
}
SelectObject(hdc,oldFont);
SelectObject(hdc,oldPen);
SelectObject(hdc,oldBrush);
// copy bitmap to the actual hdc
BitBlt(actualHdc, 0, 0, rect.right, rect.bottom, hdc, 0, 0, SRCCOPY);
DeleteObject(hBM);
DeleteDC(hdc);
DeleteObject(nullPen);
DeleteObject(nullBrush);
DeleteObject(currentBrush);
DestroyIcon(breakPoint);
DestroyIcon(breakPointDisable);
EndPaint(wnd, &ps);
}
/* Функция обработки сообщения окна.
* АРГУМЕНТЫ:
* - дескриптор окна:
* HWND hWnd;
* - номер сообщения (см. WM_***):
* UINT Msg;
* - параметр сообшения ('word parameter'):
* WPARAM wParam;
* - параметр сообшения ('long parameter'):
* LPARAM lParam;
* ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ:
* (LRESULT) - в зависимости от сообщения.
*/
LRESULT CALLBACK MyWindowFunc( HWND hWnd, UINT Msg,
WPARAM wParam, LPARAM lParam )
{
HDC hDC;
PAINTSTRUCT ps;
SYSTEMTIME st;
static INT w, h;
static BITMAP bm;
static HDC hMemDC, hMemDCClock;
static HBITMAP hBm, hBmClock;
switch (Msg)
{
case WM_CREATE:
SetTimer(hWnd, 1, 100, NULL);
hBmClock = LoadImage(NULL, "clock2.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
GetObject(hBmClock, sizeof(bm), &bm);
hDC = GetDC(hWnd);
hMemDC = CreateCompatibleDC(hDC);
hMemDCClock = CreateCompatibleDC(hDC);
ReleaseDC(hWnd, hDC);
SelectObject(hMemDCClock, hBmClock);
return 0;
case WM_SIZE:
w = LOWORD(lParam);
h = HIWORD(lParam);
if(hBm != NULL)
DeleteObject(hBm);
hDC = GetDC(hWnd);
hBm = CreateCompatibleBitmap(hDC, w, h);
ReleaseDC(hWnd, hDC);
SelectObject(hMemDC, hBm);
SendMessage(hWnd, WM_TIMER, 1, 0);
return 0;
case WM_TIMER:
//SelectObject(hMemDC, GetStockObject(NULL_PEN));
SelectObject(hMemDC, GetStockObject(DC_BRUSH));
SetDCBrushColor(hMemDC, RGB(255, 255, 255));
Rectangle(hMemDC, 0, 0, w + 1, h + 1);
StretchBlt(hMemDC, 0, 0, w, h,
hMemDCClock, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
Ellipse(hMemDC, 10, 10, h / 2, h / 2);
GetLocalTime(&st);
DrawArrow(hMemDC, w / 2, h / 2, 300, st.wSecond * 6);
DrawArrow(hMemDC, w / 2, h / 2, 250, st.wMinute * 6);
DrawArrow(hMemDC, w / 2, h / 2, 150, (st.wHour % 12) * 30);
InvalidateRect(hWnd, NULL, TRUE);
return 0;
case WM_PAINT:
hDC = BeginPaint(hWnd, &ps);
BitBlt(hDC, 0, 0, w, h, hMemDC, 0, 0, SRCCOPY);
EndPaint(hWnd, &ps);
return 0;
case WM_ERASEBKGND:
BitBlt((HDC)wParam, 0, 0, w, h, hMemDC, 0, 0, SRCCOPY);
return 0;
/*case WM_CLOSE:
if (MessageBox(hWnd, "Are you shure to exit from program?",
"Exit", MB_YESNO | MB_ICONQUESTION) == IDNO)
return 0;
break; */
case WM_DESTROY:
DeleteObject(hBm);
DeleteDC(hMemDC);
DeleteDC(hMemDCClock);
DeleteObject(hBmClock);
KillTimer(hWnd, 1);
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, Msg, wParam, lParam);
} /* End of 'MyWindowFunc' function */
void VSyncWin::VSyncInit()
{
Self = this;
CoInitialize(NULL);
HRESULT hr;
//hr = CreateDXGIFactory2(__uuidof(IDXGIFactory1), (void**)(&pFactory));
//if (FAILED(hr))
//{
// exit(0);
//}
//UINT i = 0;
////IDXGIAdapter1*> vAdapters;
//while (pFactory->EnumAdapters1(i, &m_pAdapter) != DXGI_ERROR_NOT_FOUND)
//{
// //vAdapters.push_back(pAdapter);
// //pAdapter->EnumOutputs()
// ++i;
// break; //we want the first adapter
//}
//if (m_pAdapter->EnumOutputs(0, &m_pOutput) == DXGI_ERROR_NOT_FOUND)
//{
// //error
// exit(0);
//}
RECT rc;
GetClientRect(gHwnd, &rc);
UINT width = rc.right - rc.left;
UINT height = rc.bottom - rc.top;
// for d2d support.. make it 0 not work
UINT createDeviceFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE(driverTypes);
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
UINT numFeatureLevels = ARRAYSIZE(featureLevels);
for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
mDriverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDevice(nullptr, mDriverType, nullptr, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &m_pD3dDevice, &mFeatureLevel, &m_pImmediateContext);
if (hr == E_INVALIDARG)
{
// DirectX 11.0 platforms will not recognize D3D_FEATURE_LEVEL_11_1 so we need to retry without it
hr = D3D11CreateDevice(nullptr, mDriverType, nullptr, createDeviceFlags, &featureLevels[1], numFeatureLevels - 1,
D3D11_SDK_VERSION, &m_pD3dDevice, &mFeatureLevel, &m_pImmediateContext);
}
if (SUCCEEDED(hr))
break;
}
if (FAILED(hr))
exit(0);
const double rate = 1000 / 60.0;
mSoftwareVsyncRate = FromMilliseconds(rate);
mPrevVsync = Now();
/*hr = pFactory->CreateSwapChain(m_pD3dDevice, &scd, &m_pSwapChain);
if ( FAILED(hr) )
exit(0);
*/
hr = m_pD3dDevice->QueryInterface(__uuidof(IDXGIDevice2), (void **)&m_pDXGIDevice);
if (FAILED(hr))
{
exit(0);
}
IDXGIAdapter * pDXGIAdapter;
hr = m_pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&pDXGIAdapter);
if (FAILED(hr))
{
exit(0);
}
pDXGIAdapter->GetParent(__uuidof(IDXGIFactory2), (void **)& pFactory);
if (FAILED(hr))
{
exit(0);
}
hr = pFactory->EnumAdapters1(0, &m_pAdapter);
if (FAILED(hr))
exit(0);
hr = m_pAdapter->EnumOutputs(0, &m_pOutput);
if (FAILED(hr))
exit(0);
DXGI_OUTPUT_DESC desc;
hr = m_pOutput->GetDesc(&desc);
if (FAILED(hr))
exit(0);
RECT r;
GetClientRect(gHwnd, &r);
gHeight = r.bottom - r.top;
gWidth = r.right - r.left;
DXGI_SWAP_CHAIN_DESC1 scd = { 0 };
//scd.BufferDesc.Width = gWidth;
//scd.BufferDesc.Height = gHeight;
//scd.BufferDesc.RefreshRate.Numerator = 60;
//scd.BufferDesc.RefreshRate.Denominator = 1;
//scd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
//scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
//scd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//scd.SampleDesc.Count = 1;
//scd.SampleDesc.Quality = 0;
//scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
//scd.BufferCount = 3; //1
//scd.OutputWindow = gHwnd;
//scd.Windowed = true;
//scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;// DXGI_SWAP_EFFECT_SEQUENTIAL;//DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
//scd.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;
scd.BufferUsage = DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_RENDER_TARGET_OUTPUT; // how the swap chain should be used
scd.BufferCount = 3; // a front buffer and a back buffer
scd.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // the most common swap chain format
scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // the recommended flip mode
scd.SampleDesc.Count = 1;
scd.Scaling = DXGI_SCALING_NONE;
scd.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;
scd.Width = gWidth;
scd.Height = gHeight;
hr = pFactory->CreateSwapChainForHwnd(m_pD3dDevice, gHwnd, &scd, NULL, NULL, &m_pSwapChain);
if (FAILED(hr))
{
exit(0);
}
hr = m_pSwapChain->GetBuffer(0, __uuidof(m_pBackBuffer), reinterpret_cast<void**>(&m_pBackBuffer));
if (FAILED(hr))
exit(0);
hr = m_pD3dDevice->CreateRenderTargetView(m_pBackBuffer, NULL, &m_pRenderTarget );
if (FAILED(hr))
exit(0);
m_pImmediateContext->OMSetRenderTargets(1, &m_pRenderTarget, NULL);
DXGI_MODE_DESC requestedMode;
requestedMode.Width = gWidth;
requestedMode.Height = gHeight;
requestedMode.RefreshRate.Numerator = 0;
requestedMode.RefreshRate.Denominator = 0;
requestedMode.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
requestedMode.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
requestedMode.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
DXGI_MODE_DESC mode;
hr = m_pOutput->FindClosestMatchingMode(&requestedMode, &mode, m_pD3dDevice);
if (FAILED(hr))
throw - 1;
hr = m_pSwapChain->ResizeTarget(&mode);
if (FAILED(hr))
throw -1;
mode.RefreshRate.Numerator = 0;
mode.RefreshRate.Denominator = 0;
hr = m_pSwapChain->ResizeTarget(&mode);
if (FAILED(hr))
throw - 1;
D2D1_FACTORY_OPTIONS options;
ZeroMemory(&options, sizeof(D2D1_FACTORY_OPTIONS));
hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,&m_pD2D1Factory);
if (FAILED(hr))
{
exit(0);
}
hr = m_pD2D1Factory->CreateDevice(m_pDXGIDevice, &m_pD2D1Device);
if (FAILED(hr))
{
exit(0);
}
hr = m_pD2D1Device->CreateDeviceContext(
D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
&m_pD2DContext
);
if (FAILED(hr))
{
exit(0);
}
// Direct2D needs the dxgi version of the backbuffer surface pointer.
hr = m_pSwapChain->GetBuffer(0, IID_PPV_ARGS(&m_pDxgiBackBuffer));
if (FAILED(hr))
exit(0);
auto d2dRTProps = D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_DEFAULT, D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED), 96.0, 96.0);
/*D2D1_BITMAP_PROPERTIES1 bitmapProperties = D2D1::BitmapProperties1(
D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),
96.0,
96.0
);*/
// Get a D2D surface from the DXGI back buffer to use as the D2D render target.
/*hr = m_pD2DContext->CreateBitmapFromDxgiSurface(
m_pDxgiBackBuffer,
d2dRTProps,
&m_pD2DTargetBitmap
);
if (FAILED(hr))
exit(0);*/
hr = m_pD2D1Factory->CreateDxgiSurfaceRenderTarget(m_pDxgiBackBuffer, &d2dRTProps, &m_pD2DRenderTarget);
if (FAILED(hr))
exit(0);
//m_pD2DContext->SetTarget(m_pD2DTargetBitmap);
//m_pDXGIDevice->SetMaximumFrameLatency(3);
#if 0//VSYNC
//Creating a thread
std::thread vsync([this] { this->VSyncLoop(); });
vsync.detach();
#endif
#if 0//USING_DWM_FLUSH
std::thread VSyncBlit([this] { this->BlittingThread(); });
VSyncBlit.detach();
#endif
HDC hdc = GetDC(gHwnd);
mDCBitmap1 = CreateCompatibleDC(hdc);
mDCBitmap2 = CreateCompatibleDC(hdc);
mDCBitmap3 = CreateCompatibleDC(hdc);
//HDC hdc = GetDC(hWnd);
RECT rect;
GetWindowRect(gHwnd, &rect);
gWidth = rect.right - rect.left;
gHeight = rect.bottom - rect.top;
mBitmap1 = CreateCompatibleBitmap(hdc, gWidth, gHeight);
mBitmap2 = CreateCompatibleBitmap(hdc, gWidth, gHeight);
mBitmap3 = CreateCompatibleBitmap(hdc, gWidth, gHeight);
SelectObject(mDCBitmap1, mBitmap1);
SelectObject(mDCBitmap2, mBitmap2);
SelectObject(mDCBitmap3, mBitmap3);
DeleteDC(hdc);
InitializeThreadpoolEnvironment(&mCallBackEnviron);
mPool = CreateThreadpool(NULL);
if (NULL == mPool) {
OutputDebugStringA("CreateThreadpool failed. LastError: %u\n");
exit(0);
}
//SetThreadpoolThreadMaximum(mPool, 1);
//SetThreadpoolCallbackPool(&mCallBackEnviron, mPool);
}
