void Ctl_DrawBtnBevel (
HDC hDC, // Handle to DC in which to draw bevel
RECT rRect, // Rectangle of outer bounds of the bevel
WORD wThickness) // Thickness, multiple of windows border thicknes
/***********************************************************************/
{
int i;
HANDLE hDarkBrush = CreateSolidBrush (GetSysColor(COLOR_BTNSHADOW));
HANDLE hLightBrush = CreateSolidBrush (RGB(255,255,255));
HANDLE hOldBrush = SelectObject (hDC,hDarkBrush);
int cxBorder = GetSystemMetrics (SM_CXBORDER);
int cyBorder = GetSystemMetrics (SM_CYBORDER);
int cx,cy;
for (i=0;i<(int)wThickness;i++)
{
cx = i * cxBorder;
cy = i * cyBorder;
SelectObject (hDC,hLightBrush);
PatBlt (hDC,rRect.left+cx,rRect.top+cy,
cxBorder,(rRect.bottom-rRect.top)-2*cy,PATCOPY);
PatBlt (hDC,rRect.left+cx,rRect.top+cy,
(rRect.right-rRect.left)-2*cx,cyBorder,PATCOPY);
SelectObject (hDC,hDarkBrush);
PatBlt (hDC,rRect.right-cxBorder-cx,rRect.top+cy,
cxBorder,(rRect.bottom-rRect.top)-2*cy,PATCOPY);
PatBlt (hDC,rRect.left+cx,rRect.bottom-cyBorder-cy,
(rRect.right-rRect.left)-2*cx,cyBorder,PATCOPY);
}
SelectObject (hDC,hOldBrush);
DeleteObject (hDarkBrush);
DeleteObject (hLightBrush);
}
/*
* internal
*/
static __inline VOID BltCard(HDC hdc, INT x, INT y, INT dx, INT dy, HDC hdcCard, DWORD dwRasterOp, BOOL bStretch)
{
if (bStretch)
{
StretchBlt(hdc, x, y, dx, dy, hdcCard, 0, 0, CARD_WIDTH, CARD_HEIGHT, dwRasterOp);
} else
{
BitBlt(hdc, x, y, dx, dy, hdcCard, 0, 0, dwRasterOp);
/*
* This is need when using Microsoft images, because they use two-color red/white images for
* red cards and thus needs fix-up of the edge to black color.
*/
#if 0
if (ISREDCARD(card))
{
PatBlt(hdc, x, y + 2, 1, dy - 4, BLACKNESS);
PatBlt(hdc, x + dx - 1, y + 2, 1, dy - 4, BLACKNESS);
PatBlt(hdc, x + 2, y, dx - 4, 1, BLACKNESS);
PatBlt(hdc, x + 2, y + dy - 1, dx - 4, 1, BLACKNESS);
SetPixel(hdc, x + 1, y + 1, 0);
SetPixel(hdc, x + dx - 2, y + 1, 0);
SetPixel(hdc, x + 1, y + dy - 2, 0);
SetPixel(hdc, x + dx - 2, y + dy - 2, 0);
}
#endif
}
}
//-----------------------------------------------------------------------------
// Name: HighlightWindow (from MSDN Spy Sample)
// Object: highlight or unhightlight a window
// Parameters :
// in : HWND hwnd : target window handle
// BOOL fDraw : TRUE to draw, FALSE to clear
// Return : TRUE on success
//-----------------------------------------------------------------------------
void CSelectWindow::HighlightWindow( HWND hwnd, BOOL fDraw )
{
#define DINV 3
HDC hdc;
RECT rc;
BOOL bBorderOn;
bBorderOn = fDraw;
if (hwnd == NULL || !IsWindow(hwnd))
return;
hdc = GetWindowDC(hwnd);
GetWindowRect(hwnd, &rc);
OffsetRect(&rc, -rc.left, -rc.top);
if (!IsRectEmpty(&rc))
{
PatBlt(hdc, rc.left, rc.top, rc.right - rc.left, DINV, DSTINVERT);
PatBlt(hdc, rc.left, rc.bottom - DINV, DINV,
-(rc.bottom - rc.top - 2 * DINV), DSTINVERT);
PatBlt(hdc, rc.right - DINV, rc.top + DINV, DINV,
rc.bottom - rc.top - 2 * DINV, DSTINVERT);
PatBlt(hdc, rc.right, rc.bottom - DINV, -(rc.right - rc.left),
DINV, DSTINVERT);
}
ReleaseDC(hwnd, hdc);
}
// utility function that uses the PatBlt function to
// render a tracking rectangle
void RenderTrackingRect(IN HDC HDestDC, IN const RECT& RRender)
{
const int width = RRender.right - RRender.left;
const int height = RRender.bottom - RRender.top;
const DWORD dwROP3 = DSTINVERT; // experiment with others
// render top bar
PatBlt(HDestDC,
RRender.left, RRender.top,
width, line_width,
dwROP3);
// render bottom bar
PatBlt(HDestDC,
RRender.left, RRender.bottom - line_width,
width, line_width,
dwROP3);
// render left bar
PatBlt(HDestDC,
RRender.left, RRender.top + line_width,
line_width, height - (2 * line_width),
dwROP3);
// render right bar
PatBlt(HDestDC,
RRender.right - line_width, RRender.top + line_width,
line_width, height - (2 * line_width),
dwROP3);
}
void DrawUIBorder( LPRECT lprc )
{
HDC hDC;
int sbx, sby;
hDC = CreateDC( "DISPLAY", NULL, NULL, NULL );
SelectObject( hDC, GetStockObject( GRAY_BRUSH ) );
sbx = GetSystemMetrics( SM_CXBORDER );
sby = GetSystemMetrics( SM_CYBORDER );
PatBlt( hDC, lprc->left,
lprc->top,
lprc->right - lprc->left-sbx,
sby, PATINVERT );
PatBlt( hDC, lprc->right - sbx,
lprc->top,
sbx,
lprc->bottom - lprc->top-sby, PATINVERT );
PatBlt( hDC, lprc->right,
lprc->bottom-sby,
-(lprc->right - lprc->left-sbx),
sby, PATINVERT );
PatBlt( hDC, lprc->left,
lprc->bottom,
sbx,
-(lprc->bottom - lprc->top-sby), PATINVERT );
DeleteDC( hDC );
}
static void Win32_AspectBlt( HDC hdc, win32BackBuffer_t *buffer, int width, int height ) {
if ( height == 0 ) {
height = 1;
}
if ( width == 0 ) {
width = 1;
}
float scale = 1.f;
int scaledWidth = buffer->width;
int scaledHeight = buffer->height;
if ( width < height ) {
scaledWidth = width;
scale = ( ( ( float ) width / ( float ) buffer->width ) + 0.5f );
scaledHeight = ( int ) ( ( scale * ( float ) buffer->height ) + 0.5f );
} else {
scaledHeight = height;
scale = ( ( ( float ) height / ( float ) buffer->height ) + 0.5f );
scaledWidth = ( int ) ( ( scale * ( float ) buffer->width ) + 0.5f );
}
int x = ( int ) ( ( ( width - scaledWidth ) / 2.f ) + 0.5f );
int y = ( int ) ( ( ( height - scaledHeight ) / 2.f ) + 0.5f );
PatBlt( hdc, 0, 0, width, height, WHITENESS );
PatBlt( hdc, x, y, scaledWidth, scaledHeight, BLACKNESS );
StretchDIBits( hdc,
x, y, scaledWidth, scaledHeight,
0, 0, buffer->width, buffer->height,
buffer->memory, &buffer->bitmapInfo,
DIB_RGB_COLORS, SRCCOPY );
/*PatBlt( hdc, 0, 0, x, y, WHITENESS );
PatBlt( hdc, x + scaledWidth, y + scaledHeight, width - x, height - y, WHITENESS );*/
}
/*
* highlightWindowFrame
*
* Highlight (or unhighlight) the specified
* window handle's frame.
*/
static void
highlightWindowFrame(HWND hWnd)
{
HDC hdc;
RECT rc;
if (!IsWindow(hWnd))
return;
hdc = GetWindowDC(hWnd);
GetWindowRect(hWnd, &rc);
OffsetRect(&rc, -rc.left, -rc.top);
if (!IsRectEmpty(&rc)) {
PatBlt(hdc, rc.left, rc.top, rc.right-rc.left, DINV, DSTINVERT);
PatBlt(hdc, rc.left, rc.bottom-DINV, DINV, -(rc.bottom-rc.top-2*DINV),
DSTINVERT);
PatBlt(hdc, rc.right-DINV, rc.top+DINV, DINV, rc.bottom-rc.top-2*DINV,
DSTINVERT);
PatBlt(hdc, rc.right, rc.bottom-DINV, -(rc.right-rc.left), DINV,
DSTINVERT);
}
ReleaseDC(hWnd, hdc);
UpdateWindow(hWnd);
}
INTERNAL_LINKAGE int
Win32DisplayBufferInWindow(HDC deviceContext, Win32ScreenBuffer *screenBuffer, Win32WindowSize window_size)
{
int result = 0;
int offsetX = 10;
int offsetY = 10;
#if 0
// top
PatBlt(deviceContext, 0, 0, window_size.width, offsetY, BLACKNESS);
// left
PatBlt(deviceContext, 0, 0, offsetX, window_size.height, BLACKNESS);
// bottom
PatBlt(deviceContext, 0, screenBuffer->height + offsetY,
windowSize.width, windowSize.height, BLACKNESS);
// right
PatBlt(deviceContext, screenBuffer->width + offsetX, 0,
windowSize.width, windowSize.height, BLACKNESS);
#endif
result = StretchDIBits(deviceContext,
0, 0, window_size.width, window_size.height,
0, 0, screenBuffer->width, screenBuffer->height,
screenBuffer->memory,
(BITMAPINFO *)&screenBuffer->bitmapInfo,
DIB_RGB_COLORS, SRCCOPY);
return result;
}
void DisplayStreamInfos(HWND hW)
{
HWND hWS=GetDlgItem(hW,IDC_SAREA);
HDC hdc;RECT r;HBRUSH hBO;int ch,dy,i,j,id;
//----------------------------------------------------//
GetClientRect(hWS,&r); // get size of stream display
hdc=GetDC(hWS); // device context
r.right--; // leave the right border intact
ScrollDC(hdc,-1,0,&r,&r,NULL,NULL); // scroll one pixel to the left
//----------------------------------------------------//
hBO = (HBRUSH) SelectObject(hdc,hBStream[0]); // clean the right border
PatBlt(hdc,r.right-1,0,1,r.bottom,PATCOPY);
//----------------------------------------------------//
dy=r.bottom/MAXCHAN; // size of one channel area
for(ch=0;ch<MAXCHAN;ch++) // loop the channels
{
if(s_chan[ch].iIrqDone)
{
s_chan[ch].iIrqDone=0;
PatBlt(hdc,r.right-1,ch*r.bottom/MAXCHAN,
1,dy,BLACKNESS);
continue;
}
if(s_chan[ch].bOn) // channel is on?
{
j=s_chan[ch].sval;if(j<0) j=-j; // -> get one channel data (-32k ... 32k)
j=(dy*j)/32768; if(j==0) j=1; // -> adjust to display coords
i=(dy/2)+(ch*r.bottom/MAXCHAN)-j/2; // -> position where to paint it
if (s_chan[ch].iMute) id=1; // -> get color id
else if(s_chan[ch].bNoise) id=2;
else if(s_chan[ch].bFMod==2) id=3;
else if(s_chan[ch].bFMod==1) id=4;
else id=5;
SelectObject(hdc,hBStream[id]); // -> select the brush
PatBlt(hdc,r.right-1,i,1,j,PATCOPY); // -> paint the value line
}
if(ch) SetPixel(hdc,r.right-1, // -> not first line?
ch*r.bottom/MAXCHAN,RGB(0,0,0)); // --> draw the line (one dot scrolled to the left)
}
//----------------------------------------------------//
SelectObject(hdc,hBO); // repair brush
ReleaseDC(hWS,hdc); // release context
}
void DrawRectangle(HDC hdc, int x1, int y1, int x2, int y2)
{
HGDIOBJ hOldBrush = ::SelectObject(hdc, ::GetSysColorBrush(COLOR_BTNSHADOW));
PatBlt(hdc, x1, y1, x2 - x1, 1, PATCOPY);
PatBlt(hdc, x1, y1, 1, y2 - y1, PATCOPY);
PatBlt(hdc, x1, y2, x2 - x1, 1, PATCOPY);
PatBlt(hdc, x2, y1, 1, y2 - y1 + 1, PATCOPY);
::SelectObject(hdc, hOldBrush);
}
/**
* Transfer our buffer into windows via StretchDIBits syscall.
* @param *buffer A pointer to the buffer info struct. We use a pointer because
* it is a fairly big struct so that if the compiler doesn't inline
* the code, it would require a 'big' memory copy in the stack. So
* we send the pointer even though we do not modify the origin struct.
*/
internal void
Win32TransferBufferToWindows(HDC deviceContext,
win32_offscreen_buffer *buffer,
int windowWidth, int windowHeight)
{
if((windowWidth >= 2 * buffer->width) &&
(windowHeight >= 2 * buffer->height))
{
// If we can double stretch the buffer, we do it, because double-sampling
// will not produce artifacts with StretchDIBits
StretchDIBits(deviceContext,
/*
x, y, destWidth, destHeight,
x, y, originWidth, originHeight,
*/
0, 0, 2 * buffer->width, 2 * buffer->height,
0, 0, buffer->width, buffer->height,
buffer->memory,
&buffer->info,
DIB_RGB_COLORS,
SRCCOPY);
}
else
{
int offsetX = 10;
int offsetY = 10;
// We have to clean the rectangles outside of our render target rectangle
PatBlt(deviceContext, 0, 0, windowWidth, offsetY, BLACKNESS);
PatBlt(deviceContext, 0, 0, offsetX, windowHeight, BLACKNESS);
PatBlt(deviceContext, offsetX, offsetY + buffer->height,
windowWidth - offsetX, windowHeight - (offsetY + buffer->height),
BLACKNESS);
PatBlt(deviceContext, offsetX + buffer->width, offsetY,
windowWidth - (offsetX + buffer->width), windowHeight - offsetY,
BLACKNESS);
// NOTE(Cristián): For prototyping, we're are always going to blit 1-1 pixels
// to make sure we don't introduce artifacts. This will change when the renderer
// code is done.
StretchDIBits(deviceContext,
/*
x, y, destWidth, destHeight,
x, y, originWidth, originHeight,
*/
offsetX, offsetY, buffer->width, buffer->height,
0, 0, buffer->width, buffer->height,
buffer->memory,
&buffer->info,
DIB_RGB_COLORS,
SRCCOPY);
}
}
/*****************************************************************************
*
* TWnd_OnPaint
*
* Handle WM_PAINT message to time window.
*
* HWND hWnd - Window handle
*
* Repaint the 3D inset borders around the edge of the client area.
* Repaint the time.
*
*****************************************************************************/
VOID NEAR PASCAL TWnd_OnPaint( HWND hWnd) { PAINTSTRUCT ps; HDC hDC;
HBRUSH hBrOld; int nWidth; int nHeight;
RECT rc;
GetClientRect(hWnd, &rc);
nWidth = rc.right;
nHeight = rc.bottom;
hDC = BeginPaint(hWnd, &ps);
hBrOld = (HBRUSH)SelectObject(hDC, GetStockObject(GRAY_BRUSH));
PatBlt(hDC, 0, 0, 1, nHeight-1, PATCOPY);
PatBlt(hDC, 1, 0, nWidth-2, 1, PATCOPY);
SelectObject(hDC, GetStockObject(BLACK_BRUSH));
PatBlt(hDC, 1, 1, 1, nHeight-3, PATCOPY);
PatBlt(hDC, 2, 1, nWidth-4, 1, PATCOPY);
SelectObject(hDC, GetStockObject(WHITE_BRUSH));
PatBlt(hDC, rc.right-1, 0, 1, nHeight-1, PATCOPY);
PatBlt(hDC, 0, rc.bottom-1, nWidth, 1, PATCOPY);
SelectObject(hDC, GetStockObject(LTGRAY_BRUSH));
PatBlt(hDC, rc.right-2, 1, 1, nHeight-2, PATCOPY);
PatBlt(hDC, 1, rc.bottom-2, nWidth-2, 1, PATCOPY);
SelectObject(hDC, hBrOld);
gbRepaint = TRUE;
PaintTime(hDC);
EndPaint(hWnd, &ps);
}
/******************************************************************************
* DrawBox(hDC, xChar, yChar, wChar, kChar, scale, htSep)
*
* purpose: draws the edit box for the character being edited and colors the
* grid squares according to the pixels set for the character.
*
* params: HDC hDC : handle to display context
* DWORD xChar : x-location of char box.
* DWORD yChar : y-location of char box
* DWORD wChar : width of char box
* DWORD kChar : height of char
* INT wScale : Scale of the squares.
* DWORD htSep : height of square separators
*
* returns: none
*
* side effects: alters matBox (global 2-d array with ready pixel info. on
* currently displayed box)
*****************************************************************************/
VOID
DrawBox(
HDC hDC,
DWORD xChar, /* x-location of char. */
DWORD yChar, /* y-location of char. */
DWORD wChar, /* width of char. */
DWORD kChar, /* height of char */
INT wScale, /* scale of the squares. */
DWORD htSep /* hgt of square separators */
)
/* draw a character of separate squares of height 'scale' with sep. 'htSep' */
{
DWORD i, j, sep;
if (fAll) { /* redraw them all */
for (j = 0; j < kChar; j++) {
sep = (j >= font.Ascent) ? htSep : 0;
for (i = 0; i < wChar; i++) {
if (wScale == 1)
SetPixel(hDC, xChar + i, yChar + j,
matBox[i][j] == TRUE ? BLACK : WHITE);
else
PatBlt(hDC,
xChar + wScale * i,
yChar + wScale * j + sep,
wScale - htSep,
wScale - htSep,
colors[matBox[i][j] == TRUE ? 1 : 0]);
}
}
}
else { /* redraw one just flipped */
if (wScale == 1)
SetPixel(hDC,
xChar + ptC.x,
yChar + ptC.y,
matBox[ptC.x][ptC.y] == TRUE ? BLACK : WHITE);
else {
sep = (((DWORD) ptC.y >= font.Ascent) ? htSep : 0L);
SelectObject(hDC, hbrGray);
PatBlt(hDC,
xChar + wScale * ptC.x,
yChar + wScale * ptC.y + sep,
wScale - htSep,
wScale - htSep,
colors[matBox[ptC.x][ptC.y]]);
}
}
}
VOID
TreeListDrawSplitBar(
__in PTREELIST_OBJECT Object,
__in LONG x,
__in LONG y,
__in BOOLEAN EndTrack
)
{
HDC hdc;
RECT Rect;
HBRUSH hBrushOld;
hdc = GetDC(Object->hWnd);
if (!hdc) {
return;
}
GetClientRect(Object->hWnd, &Rect);
hBrushOld = SelectObject(hdc, Object->hBrushBar);
//
// Clean the splibar we drew last time
//
if (Object->SplitbarLeft > 0) {
PatBlt(hdc, Object->SplitbarLeft, y,
Object->SplitbarBorder,
Rect.bottom - Rect.top - y,
PATINVERT );
}
if (!EndTrack) {
Rect.left += x;
PatBlt(hdc, Rect.left, y, Object->SplitbarBorder,
Rect.bottom - Rect.top - y, PATINVERT);
Object->SplitbarLeft = Rect.left;
}
else {
Object->SplitbarLeft = 0xffff8001;
}
SelectObject(hdc, hBrushOld);
ReleaseDC(Object->hWnd, hdc);
}
void Vid::SetMode( int ModeValue ) {
if ( BackBuffer ) {
Shutdown();
}
WindowWidth = ModeList[ModeValue].Width;
WindowHeight = ModeList[ModeValue].Height;
BufferHeight = WindowHeight;
BufferWidth = WindowWidth;
if ( ModeList[ModeValue].Type == ModeState::WINDOWED ) {
SetWindowedMode( ModeValue );
} else {
SetFullscrenMode( ModeValue );
}
ShowWindow( MainWindow, SW_SHOWDEFAULT );
HDC DeviceContext = GetDC( MainWindow );
PatBlt( DeviceContext, 0, 0, BufferWidth, BufferHeight, BLACKNESS );
ReleaseDC( MainWindow, DeviceContext );
// define our bitmap info
BitMapInfo.bmiHeader.biSize = sizeof( BitMapInfo.bmiHeader );
BitMapInfo.bmiHeader.biWidth = BufferWidth;
BitMapInfo.bmiHeader.biHeight = -BufferHeight;
BitMapInfo.bmiHeader.biPlanes = 1;
BitMapInfo.bmiHeader.biBitCount = 8 * BytesPerPixel;
BitMapInfo.bmiHeader.biCompression = BI_RGB;
BackBuffer = FrameBuffer( BufferWidth, BufferHeight, BytesPerPixel );
}
LRESULT CALLBACK MainWindowCallback( HWND Window,
UINT Message,
WPARAM WParam,
LPARAM LParam)
{
LRESULT Result = 0;
switch(Message){
case WM_SIZE:
{
OutputDebugStringA("WN_SIZE \n" );
}break;
case WM_DESTROY:
{
OutputDebugStringA("WN_DESTROY \n" );
}break;
case WM_CLOSE:
{
OutputDebugStringA("WN_CLOSE \n" );
}break;
case WM_ACTIVATEAPP:
{
OutputDebugStringA("WM_ACTIVATEAPP \n" );
}break;
case WM_PAINT:
{
PAINTSTRUCT Paint;
HDC DeviceContext = BeginPaint(Window,&Paint );
int X = Paint.rcPaint.left;
int Y = Paint.rcPaint.top;
int Height = Paint.rcPaint.bottom - Paint.rcPaint.top;
int Width = Paint.rcPaint.right - Paint.rcPaint.left;
static DWORD operation = WHITENESS;
PatBlt(DeviceContext,X, Y, Width,Height, operation);
if(operation == WHITENESS){
operation = BLACKNESS;
}
else{
operation = WHITENESS;
}
EndPaint(Window, &Paint);
}
default:
{
//OutputDebugStringA("Default \n" );
Result = DefWindowProc(Window,Message,WParam,LParam);
}break;
}
return Result;
}
BOOL
MyInvert(
IN PCONSOLE_INFORMATION Console,
IN PSMALL_RECT SmallRect
)
/*++
invert a rect
--*/
{
RECT Rect;
Rect.left = SmallRect->Left-Console->CurrentScreenBuffer->Window.Left;
Rect.top = SmallRect->Top-Console->CurrentScreenBuffer->Window.Top;
Rect.right = SmallRect->Right+1-Console->CurrentScreenBuffer->Window.Left;
Rect.bottom = SmallRect->Bottom+1-Console->CurrentScreenBuffer->Window.Top;
if (Console->CurrentScreenBuffer->Flags & CONSOLE_TEXTMODE_BUFFER) {
Rect.left *= Console->CurrentScreenBuffer->BufferInfo.TextInfo.FontSize.X;
Rect.top *= Console->CurrentScreenBuffer->BufferInfo.TextInfo.FontSize.Y;
Rect.right *= Console->CurrentScreenBuffer->BufferInfo.TextInfo.FontSize.X;
Rect.bottom *= Console->CurrentScreenBuffer->BufferInfo.TextInfo.FontSize.Y;
}
PatBlt(Console->hDC,
Rect.left,
Rect.top,
Rect.right - Rect.left,
Rect.bottom - Rect.top,
DSTINVERT
);
return(TRUE);
}
HBITMAP E_Util::ConvertIconToBitmap(HICON hIcon, int nWidth, int nHeight, COLORREF clrBackground)
{
if (hIcon == NULL)
return NULL;
HDC hDC = NULL;
HDC hMemDC = NULL;
HBITMAP hBitmap = NULL;
HBITMAP hOldBitmap = NULL;
HBRUSH hBrush = NULL;
HBRUSH hOldBrush = NULL;
BOOL bGotBitmap = false;
try {
hDC = ::GetDC(NULL);
if (hDC != NULL) {
hBitmap = CreateCompatibleBitmap(hDC, nWidth, nHeight);
if (hBitmap != NULL) {
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL) {
// Select the bitmap into the memory device context
hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap);
hBrush = CreateSolidBrush(clrBackground);
if (hBrush != NULL) {
// Fill the bitmap with the background color
hOldBrush = (HBRUSH)SelectObject(hMemDC, hBrush);
PatBlt(hMemDC, 0, 0, nWidth, nHeight, PATCOPY);
// Draw the icon
DrawIconEx(hMemDC, 0, 0, hIcon, nWidth, nHeight, 0, NULL, DI_IMAGE);
bGotBitmap = true;
}
}
}
}
// Cleanup
if (hOldBrush != NULL)
SelectObject(hMemDC, hOldBrush);
if (hOldBitmap != NULL)
SelectObject(hMemDC, hOldBitmap);
if (hBrush != NULL)
DeleteObject(hBrush);
if (hMemDC != NULL)
DeleteDC(hMemDC);
if (hDC != NULL)
::ReleaseDC(NULL, hDC);
if (!bGotBitmap && hBitmap != NULL) {
DeleteObject(hBitmap);
hBitmap = NULL;
}
}
catch (...) {
}
return hBitmap;
}
/* Fill a rectangle. */
static int
win_ddb_fill_rectangle(gx_device * dev, int x, int y, int w, int h,
gx_color_index color)
{
fit_fill(dev, x, y, w, h);
/* Use PatBlt for filling. Special-case black. */
if (color == 0)
PatBlt(wdev->hdcbit, x, y, w, h, rop_write_0s);
else {
select_brush((int)color);
PatBlt(wdev->hdcbit, x, y, w, h, rop_write_pattern);
}
win_update((gx_device_win *) dev);
return 0;
}
void DrawWndOnParentTransparent(HWND hWnd, PAERO_SUBCLASS_WND_DATA pWndData)
{
RECT rcWnd;
VERIFY(GetWindowRect(hWnd, &rcWnd));
HWND hParent = GetParent(hWnd);
if(hParent)
{
ScreenToClient(hParent, &rcWnd);
HDC hdc = GetDC(hParent);
if(hdc)
{
BP_PAINTPARAMS params = { sizeof(BP_PAINTPARAMS) };
params.dwFlags = BPPF_ERASE;
HDC hdcPaint = NULL;
HPAINTBUFFER hBufferedPaint = NULL;
hBufferedPaint = pWndData->m_pUxTheme->BeginBufferedPaint(hdc, &rcWnd, BPBF_TOPDOWNDIB, ¶ms, &hdcPaint);
if (hdcPaint)
{
VERIFY(PatBlt(hdcPaint, 0, 0, RECTWIDTH(rcWnd), RECTHEIGHT(rcWnd), BLACKNESS));
VERIFY(S_OK==pWndData->m_pUxTheme->BufferedPaintSetAlpha(hBufferedPaint, &rcWnd, 0x00));
VERIFY(S_OK==pWndData->m_pUxTheme->EndBufferedPaint(hBufferedPaint, TRUE));
}
VERIFY(1==ReleaseDC(hParent, hdc));
}
}
}
/*
* @implemented
*/
INT WINAPI
FillRect(HDC hDC, CONST RECT *lprc, HBRUSH hbr)
{
BOOL Ret;
HBRUSH prevhbr = NULL;
/* Select brush if specified */
if (hbr)
{
/* Handle system colors */
if (hbr <= (HBRUSH)(COLOR_MENUBAR + 1))
hbr = GetSysColorBrush(PtrToUlong(hbr) - 1);
prevhbr = SelectObject(hDC, hbr);
if (prevhbr == NULL)
return (INT)FALSE;
}
Ret = PatBlt(hDC, lprc->left, lprc->top, lprc->right - lprc->left,
lprc->bottom - lprc->top, PATCOPY);
/* Select old brush */
if (prevhbr)
SelectObject(hDC, prevhbr);
return (INT)Ret;
}
static void MaskRegion( HDC hdc, RECT * rct, COLORREF cTransparentColor,
COLORREF cBackgroundColor )
{
HDC hdcTemp, hdcObject, hdcBack, hdcMem;
POINT ptSize;
COLORREF cColor;
HBITMAP bmAndObject, bmAndBack, bmBackOld, bmObjectOld,
bmAndTemp, bmTempOld, bmAndMem, bmMemOld;
HBRUSH hBrush, hBrOld;
ptSize.x = rct->right - rct->left + 1;
ptSize.y = rct->bottom - rct->top + 1;
hBrush = CreateSolidBrush(cBackgroundColor);
hdcTemp = CreateCompatibleDC(hdc);
hdcObject = CreateCompatibleDC(hdc);
hdcBack = CreateCompatibleDC(hdc);
hdcMem = CreateCompatibleDC(hdc);
bmAndTemp = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y);
bmAndMem = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y);
bmAndObject = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL);
bmAndBack = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL);
bmTempOld = SelectObject(hdcTemp, bmAndTemp);
bmMemOld = SelectObject(hdcMem, bmAndMem);
bmBackOld = SelectObject(hdcBack, bmAndBack);
bmObjectOld = SelectObject(hdcObject, bmAndObject);
hBrOld = SelectObject(hdcMem, hBrush);
BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdc, rct->left, rct->top, SRCCOPY);
SetMapMode(hdcTemp, GetMapMode(hdc));
cColor = SetBkColor(hdcTemp, cTransparentColor);
BitBlt(hdcObject, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCCOPY);
SetBkColor(hdcTemp, cColor);
BitBlt(hdcBack, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0, NOTSRCCOPY);
PatBlt(hdcMem, 0,0, ptSize.x, ptSize.y, PATCOPY);
BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0, SRCAND);
BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdcBack, 0, 0, SRCAND);
BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCPAINT);
BitBlt(hdc, rct->left, rct->top, ptSize.x, ptSize.y, hdcMem, 0, 0, SRCCOPY);
DeleteObject(SelectObject(hdcMem, hBrOld));
DeleteObject(SelectObject(hdcTemp, bmTempOld));
DeleteObject(SelectObject(hdcMem, bmMemOld));
DeleteObject(SelectObject(hdcBack, bmBackOld));
DeleteObject(SelectObject(hdcObject, bmObjectOld));
DeleteDC(hdcMem);
DeleteDC(hdcBack);
DeleteDC(hdcObject);
DeleteDC(hdcTemp);
}
static void
l_ui_patblt(struct rdp_inst * inst, uint8 opcode, int x, int y, int cx, int cy,
RD_BRUSH * brush, int bgcolor, int fgcolor)
{
wfInfo * wfi;
HBRUSH br;
HBRUSH org_br;
int org_bkmode;
COLORREF org_bkcolor;
COLORREF org_textcolor;
wfi = GET_WFI(inst);
//printf("ui_patblt: style %d x %d y %d cx %d cy %d\n", brush->style, x, y, cx, cy);
bgcolor = wf_color_convert(wfi, bgcolor, inst->settings->server_depth);
fgcolor = wf_color_convert(wfi, fgcolor, inst->settings->server_depth);
br = wf_create_brush(wfi, brush, fgcolor, inst->settings->server_depth);
org_bkmode = SetBkMode(wfi->drw->hdc, OPAQUE);
org_bkcolor = SetBkColor(wfi->drw->hdc, bgcolor);
org_textcolor = SetTextColor(wfi->drw->hdc, fgcolor);
org_br = (HBRUSH)SelectObject(wfi->drw->hdc, br);
PatBlt(wfi->drw->hdc, x, y, cx, cy, rop3_code_table[opcode]);
SelectObject(wfi->drw->hdc, org_br);
DeleteObject(br);
SetBkMode(wfi->drw->hdc, org_bkmode);
SetBkColor(wfi->drw->hdc, org_bkcolor);
SetTextColor(wfi->drw->hdc, org_textcolor);
if (wfi->drw == wfi->backstore)
{
wf_invalidate_region(wfi, x, y, x + cx, y + cy);
}
}
/***********************************************************************
* BitBlt (GDI32.@)
*/
BOOL WINAPI DECLSPEC_HOTPATCH BitBlt( HDC hdcDst, INT xDst, INT yDst, INT width,
INT height, HDC hdcSrc, INT xSrc, INT ySrc, DWORD rop )
{
if (!rop_uses_src( rop )) return PatBlt( hdcDst, xDst, yDst, width, height, rop );
else return StretchBlt( hdcDst, xDst, yDst, width, height,
hdcSrc, xSrc, ySrc, width, height, rop );
}
void wf_gdi_patblt(wfContext* wfc, PATBLT_ORDER* patblt)
{
HBRUSH brush;
HBRUSH org_brush;
int org_bkmode;
UINT32 fgcolor;
UINT32 bgcolor;
COLORREF org_bkcolor;
COLORREF org_textcolor;
fgcolor = freerdp_color_convert_bgr(patblt->foreColor, wfc->srcBpp, wfc->dstBpp, wfc->clrconv);
bgcolor = freerdp_color_convert_bgr(patblt->backColor, wfc->srcBpp, wfc->dstBpp, wfc->clrconv);
brush = wf_create_brush(wfc, &patblt->brush, fgcolor, wfc->srcBpp);
org_bkmode = SetBkMode(wfc->drawing->hdc, OPAQUE);
org_bkcolor = SetBkColor(wfc->drawing->hdc, bgcolor);
org_textcolor = SetTextColor(wfc->drawing->hdc, fgcolor);
org_brush = (HBRUSH)SelectObject(wfc->drawing->hdc, brush);
PatBlt(wfc->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop));
SelectObject(wfc->drawing->hdc, org_brush);
DeleteObject(brush);
SetBkMode(wfc->drawing->hdc, org_bkmode);
SetBkColor(wfc->drawing->hdc, org_bkcolor);
SetTextColor(wfc->drawing->hdc, org_textcolor);
if (wfc->drawing == wfc->primary)
wf_invalidate_region(wfc, patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
internal void Win32DisplayBufferInWindow(win32_offscreen_buffer *Buffer, HDC DeviceContext, int WindowWidth, int WindowHeight) {
if ((WindowWidth >= Buffer->Width * 2) && (WindowHeight >= Buffer->Height * 2)) {
StretchDIBits(DeviceContext, 0, 0, Buffer->Width * 2, Buffer->Height * 2, 0, 0, Buffer->Width, Buffer->Height, Buffer->Memory, &Buffer->Info, DIB_RGB_COLORS, SRCCOPY);
}
else {
int OffsetX = 10;
int OffsetY = 10;
PatBlt(DeviceContext, 0, 0, WindowWidth, OffsetY, BLACKNESS);
PatBlt(DeviceContext, 0, OffsetY + Buffer->Height, WindowWidth, WindowHeight, BLACKNESS);
PatBlt(DeviceContext, 0, 0, OffsetX, WindowHeight, BLACKNESS);
PatBlt(DeviceContext, OffsetX + Buffer->Width, 0, WindowWidth, WindowHeight, BLACKNESS);
StretchDIBits(DeviceContext, OffsetX, OffsetY, Buffer->Width, Buffer->Height, 0, 0, Buffer->Width, Buffer->Height, Buffer->Memory, &Buffer->Info, DIB_RGB_COLORS, SRCCOPY);
}
}
void DrawBar(HWND hWindow, int iPos)
/***********************************************************************/
{
HRGN hClipRgn; // the clipping region
RECT rClient;
LPLISTBOXDATA lpData = ListBox_GetData(hWindow);
if (!lpData)
return;
HDC hDC = GetDC(hWindow);
// make sure we are clipped to client rect
GetClientRect(hWindow, &rClient);
hClipRgn = CreateRectRgn(0,0, rClient.right - rClient.left, rClient.bottom - rClient.top);
SelectClipRgn(hDC, hClipRgn);
DeleteObject(hClipRgn);
// draw the bar
PatBlt(hDC, rClient.left,
rClient.top + (iPos*lpData->iItemHeight)-(LINE_WIDTH/2),
rClient.right-rClient.left,
LINE_WIDTH,
PATINVERT);
ReleaseDC(hWindow, hDC);
}
static void TroughElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
TroughClientData *cd = clientData;
TkWinDCState dcState;
HDC hdc = TkWinGetDrawableDC(Tk_Display(tkwin), d, &dcState);
HBRUSH hbr;
COLORREF bk, oldbk, oldtxt;
hbr = SelectObject(hdc, GetSysColorBrush(COLOR_SCROLLBAR));
bk = GetSysColor(COLOR_3DHIGHLIGHT);
oldtxt = SetTextColor(hdc, GetSysColor(COLOR_3DFACE));
oldbk = SetBkColor(hdc, bk);
/* WAS: if (bk (COLOR_3DHIGHLIGHT) == GetSysColor(COLOR_WINDOW)) ... */
if (GetSysColor(COLOR_SCROLLBAR) == GetSysColor(COLOR_BTNFACE)) {
/* Draw using the pattern brush */
SelectObject(hdc, cd->PatternBrush);
}
PatBlt(hdc, b.x, b.y, b.width, b.height, PATCOPY);
SetBkColor(hdc, oldbk);
SetTextColor(hdc, oldtxt);
SelectObject(hdc, hbr);
TkWinReleaseDrawableDC(d, hdc, &dcState);
}
void CMovPlayerFrm::OnPaint()
{
if(NULL==lpPrimary)return;
if(DD_OK == lpPrimary->IsLost()){
if(forccNum<3){
HDC hDC = ::GetDC(m_hWnd);
HBRUSH brush = CreateSolidBrush(RGB(0, 0, 8));
HBRUSH old_brush = (HBRUSH)SelectObject(hDC,brush);
PatBlt(hDC,0,0, 800, 600, PATCOPY);
SelectObject(hDC,old_brush);
DrawSurface(GetDeviceCaps(hDC,BITSPIXEL));
DeleteObject(brush);
::ReleaseDC(m_hWnd,hDC);
}
}else{
lpPrimary->Restore();
if(lpSrcSurface)lpSrcSurface->Restore();
}
}
LRESULT CALLBACK MainWindowCallback(HWND windowHandle, UINT message, WPARAM wParam, LPARAM lParam) {
LRESULT result = NULL;
switch (message) {
case WM_SIZE: {
} break;
case WM_DESTROY: {
} break;
case WM_CLOSE: {
} break;
case WM_ACTIVATEAPP: {
} break;
case WM_PAINT: {
PAINTSTRUCT paint;
HDC deviceContext = BeginPaint(windowHandle, &paint);
int height = paint.rcPaint.bottom - paint.rcPaint.top;
int width = paint.rcPaint.right - paint.rcPaint.left;
PatBlt(deviceContext, paint.rcPaint.left, paint.rcPaint.top, width, height, WHITENESS);
EndPaint(windowHandle, &paint);
} break;
default: {
result = DefWindowProc(windowHandle, message, wParam, lParam);
} break;
}
return result;
}
