Exemplo n.º 1
1
    // static
    void CanvasGdiplus::InitializeDC(HDC context)
    {
        // Enables world transformation.
        // If the GM_ADVANCED graphics mode is set, GDI always draws arcs in the
        // counterclockwise direction in logical space. This is equivalent to the
        // statement that, in the GM_ADVANCED graphics mode, both arc control points
        // and arcs themselves fully respect the device context's world-to-device
        // transformation.
        BOOL res = SetGraphicsMode(context, GM_ADVANCED);
        DCHECK(res != 0);

        // Enables dithering.
        res = SetStretchBltMode(context, HALFTONE);
        DCHECK(res != 0);
        // As per SetStretchBltMode() documentation, SetBrushOrgEx() must be called
        // right after.
        res = SetBrushOrgEx(context, 0, 0, NULL);
        DCHECK(res != 0);

        // Sets up default orientation.
        res = SetArcDirection(context, AD_CLOCKWISE);
        DCHECK(res != 0);

        // Sets up default colors.
        res = SetBkColor(context, RGB(255, 255, 255));
        DCHECK(res != CLR_INVALID);
        res = SetTextColor(context, RGB(0, 0, 0));
        DCHECK(res != CLR_INVALID);
        res = SetDCBrushColor(context, RGB(255, 255, 255));
        DCHECK(res != CLR_INVALID);
        res = SetDCPenColor(context, RGB(0, 0, 0));
        DCHECK(res != CLR_INVALID);

        // Sets up default transparency.
        res = SetBkMode(context, OPAQUE);
        DCHECK(res != 0);
        res = SetROP2(context, R2_COPYPEN);
        DCHECK(res != 0);
    }
Exemplo n.º 2
0
void sStretch2D(const sU32 *data,sInt width,const sRect &source,const sRect &dest)
{
  BITMAPINFO bmi;
  sClear(bmi);

  bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth = width;
  bmi.bmiHeader.biHeight = -source.y1;
  bmi.bmiHeader.biPlanes = 1;
  bmi.bmiHeader.biBitCount = 32;
  bmi.bmiHeader.biCompression = BI_RGB;
  SetStretchBltMode(sGDIDC,STRETCH_DELETESCANS);
  StretchDIBits(
    sGDIDC,
    dest.x0,dest.y0,dest.SizeX(),dest.SizeY(),
    source.x0,source.y0,source.SizeX(),source.SizeY(),
    data,&bmi,DIB_RGB_COLORS,SRCCOPY);
}
Exemplo n.º 3
0
void ImageWndPicWnd::LoadPic(CString T)
{
	if(org.LoadImage(T)==S_OK)
	{
		FileName=T;
		SetStretchBltMode(ava.GetDC(),COLORONCOLOR);		
		org.StretchTo(&ava,ava.Rgn,org.Rgn,SRCCOPY);
        HGDIOBJ tfont=ava.SelectObject(font1);
		ava.SetBkMode(TRANSPARENT); ava.SetTextColor(clRED);
		ava.TextOut(0,0,T);
		T.Format("%dx%d",org.w,org.h); ava.TextOut(0,10,T);
		ava.SelectObject(tfont); 
		CaptureButton.ShowWindow(SW_HIDE); DragAcceptFiles(FALSE);
		UpdateNow();
		Parent->Ctrls.Xmax=org.w; Parent->Ctrls.UpdateData();
	}
	else FileName="";		 
}
Exemplo n.º 4
0
void CPrizeEndDlg::DrawSponsorImg() 
{
	if (m_SponsorImage.IsNull()) return;

	CDC *pDC = this->GetDC();

	CDC dcMemory;
	dcMemory.CreateCompatibleDC(pDC); 
	CBitmap bitmap;
	bitmap.CreateCompatibleBitmap(pDC, m_SponsorImage.GetWidth(), m_SponsorImage.GetHeight());
	CBitmap *pOldBitmap = dcMemory.SelectObject(&bitmap);
	SetStretchBltMode(dcMemory.GetSafeHdc(), STRETCH_DELETESCANS/*COLORONCOLOR*/);
	m_SponsorImage.StretchBlt(dcMemory, 0, 0, m_SponsorImage.GetWidth(), m_SponsorImage.GetHeight(), SRCCOPY);
	pDC->StretchBlt(116, 188, 300, 300,
		&dcMemory, 0, 0, m_SponsorImage.GetWidth(), m_SponsorImage.GetHeight(), SRCCOPY);
	dcMemory.SelectObject(pOldBitmap);
	dcMemory.DeleteDC();
}
Exemplo n.º 5
0
HRESULT
Frame::DoRenderSample(IMediaSample *sample)
{
	if(FRAME_DECODING) { 
		if(debug) printf("Frame::DoRenderSample Cancelling DoRenderSample while FRAME_DECODING\n");
		return S_FALSE;
	}
	FRAME_PROCESSING  = false;
	if(STOP_REQUESTED) return S_FALSE;
	FRAME_PROCESSING  = true;
	data = 0;
	sample->GetPointer( &data );
	processFrame();
	bool newtag = false;
	bool newage = (last_tag_age == decoder->tagAge()) ? false : true ; 
	for(int i=0; i < 15; i++) { if( tag_string[i] != last_tag_string[i] ) newtag = true; }
	paintFrame(newtag, newage);
	for(int i=0; i < 15; i++) last_tag_string[i] = tag_string[i];
	last_tag_age = decoder->tagAge();
	//d_videoAlignmentTest();
	bmi.bmiHeader = bmih;
	HDC hdc = GetDC(hwnd);	
	HRESULT hr;
	SetStretchBltMode(hdc, HALFTONE);
	hr = StretchDIBits(hdc, 
		(c_width-v_display_width)/2, 
		(c_height - GetSystemMetrics(SM_CYMENU) - config->V_MSG_STRIP_SIZE - v_display_height)/2,
		v_display_width, v_display_height,
		0, 0, 
		v_width, v_height,
		data, &bmi, DIB_RGB_COLORS, SRCCOPY);
	ReleaseDC(hwnd, hdc);
	/* OVERLAY TEST
	RECT rect;
	rect.right  = 10;
	rect.left   = 20;
	rect.top    = 5;
	rect.bottom = 10;
	FillRect(hdc, &rect, debug_brush);
	OVERLAY TEST */
	if(config->V_D_PIXDEBUG) Sleep(600);	
	FRAME_PROCESSING  = false;
	return hr;
}
Exemplo n.º 6
0
void __fastcall TForm1::_GetBitmap(TImage* img)
{
//    if (Quality != l_jpg->Scale) l_jpg->Scale = Quality;
    std::auto_ptr<Graphics::TBitmap> Bitmap(new Graphics::TBitmap);
    Bitmap->Assign(jpg);

    int myWidth = img->Width;
    int myHeight = img->Height;
    img->Picture->Bitmap->Width = img->Width;
    img->Picture->Bitmap->Height = img->Height;

    if (Bitmap->Width > Bitmap->Height) {
        double k = (double)Bitmap->Height / (double)Bitmap->Width;
        myHeight = img->Width * k;
        if (myHeight > img->Height) {
            myHeight = img->Height;
            myWidth = img->Height / k;
        }
    }
    else {
        double k = (double)Bitmap->Width / (double)Bitmap->Height;
        myWidth = img->Height * k;
        if ( myWidth > img->Width) {
            myWidth = img->Width;
            myHeight = img->Width / k;
        }
    }

    img->Picture->Bitmap->Canvas->Brush->Color = clBlack;
    img->Picture->Bitmap->Canvas->FillRect(TRect(0,0,img->Width,img->Height));

    SetStretchBltMode(img->Picture->Bitmap->Canvas->Handle, HALFTONE);

    StretchBlt(
        img->Picture->Bitmap->Canvas->Handle, // приемник
        (img->Width - myWidth)/2, (img->Height - myHeight) / 2, // координаты верхнего угла приемника
        myWidth, myHeight,
        Bitmap->Canvas->Handle, // исходник
        0, 0, // координаты верхнего угла исходника
        Bitmap->Width, Bitmap->Height,
        SRCCOPY
    );
}
Exemplo n.º 7
0
long CHSDib::Draw(HDC pDC, long xoffset, long yoffset,BOOL bTracking /*= FALSE*/)
{
	if( (hDib) && (pDC) ) 
	{
		CRect rect(xoffset, yoffset, m_bi.biWidth, m_bi.biHeight);

		if( bTracking == 2 ) // focus
		{
			FillRect(pDC, &rect, (HBRUSH) (COLOR_INFOBK + 1));
		}
		else if( bTracking == 1) // over
		{
			FillRect(pDC, &rect, (HBRUSH) (COLOR_WINDOW + 1));
		}
		else
		{
			FillRect(pDC, &rect, (HBRUSH) (COLOR_BTNFACE + 1));
		}

		CBrush hBrush;
		hBrush.CreateSolidBrush(0);
		FrameRect(pDC, &rect, (HBRUSH) hBrush );
		hBrush.DeleteObject();
		//LPSTR lpDIB = (char*)hDib;	//set image to hdc...
		//SetStretchBltMode(pDC,MAXSTRETCHBLTMODE);//COLORONCOLOR);	
		//SetDIBitsToDevice(pDC, xoffset, yoffset,
		//	m_bi.biWidth, m_bi.biHeight, 0, 0, 0,
		//	m_bi.biHeight, GetBits(),
		//	(BITMAPINFO*)lpDIB, DIB_RGB_COLORS);

#if Support_CHSDib
		//palette must be correctly filled
		LPSTR lpDIB = (char*)hDib;	//set image to hdc...
		SetStretchBltMode(pDC,MAXSTRETCHBLTMODE);//COLORONCOLOR);	
		SetDIBitsToDevice(pDC, xoffset, yoffset,
			m_bi.biWidth, m_bi.biHeight, 0, 0, 0,
			m_bi.biHeight, GetBits(),
			(BITMAPINFO*)lpDIB, DIB_RGB_COLORS);
#endif
		return 1;
	} 
	return 0;
}
Exemplo n.º 8
0
// Here, we grab DC's and stuff from vfw and stash it into our own structure
//***************************************************************************
static long AVIDrawBegin(PINSTINFO pi, ICDRAWBEGIN FAR *lpicd, LONG cbicd)
//***************************************************************************
{
	if (lpicd->dwFlags & ICDRAW_QUERY)
		return ICERR_BADFORMAT;
	pi->hdc = lpicd->hdc;
	pi->xDst = lpicd->xDst;
	pi->yDst = lpicd->yDst;
	pi->dxDst = lpicd->dxDst;
	pi->dyDst = lpicd->dyDst;
	pi->xSrc = lpicd->xSrc;
	pi->ySrc = lpicd->ySrc;
	pi->dxSrc = lpicd->dxSrc;
	pi->dySrc = lpicd->dySrc;
	SetStretchBltMode(pi->hdc, COLORONCOLOR);
	if (!DrawDibBegin(pi->hdd, pi->hdc, pi->dxDst, pi->dyDst, lpicd->lpbi, pi->dxSrc, pi->dySrc, 0))
		return ICERR_UNSUPPORTED;
	return ICERR_OK;
}
Exemplo n.º 9
0
static void sttPreviewSkin(MODERNOPTOBJECT *obj, TCHAR *fn, LPDRAWITEMSTRUCT lps)
{
	if (!fn) return;

	char svc[128];
	mir_snprintf(svc, SIZEOF(svc), "%s%s", obj->lpzThemeModuleName, TS_SKIN_PREVIEW);
	if (ServiceExists(svc))
		CallService(svc, (WPARAM)lps, (LPARAM)fn);
	else {
		char *afn = mir_t2a(fn);
		char *fnpreview = (char *)mir_alloc(lstrlenA(afn) + 10);
		lstrcpyA(fnpreview, afn);
		lstrcatA(fnpreview, ".png");
		HBITMAP hbmPreview = (HBITMAP)CallService(MS_UTILS_LOADBITMAP, 0, (LPARAM)fnpreview);
		mir_free(afn);
		mir_free(fnpreview);

		if (!hbmPreview) return;

		BITMAP bmp;
		GetObject(hbmPreview, sizeof(bmp), &bmp);

		SIZE szDst = { abs(bmp.bmWidth), abs(bmp.bmHeight) };
		if ((szDst.cx > lps->rcItem.right-lps->rcItem.left) || (szDst.cy > lps->rcItem.bottom-lps->rcItem.top)) {
			float q = min(
				float(lps->rcItem.right-lps->rcItem.left) / szDst.cx,
				float(lps->rcItem.bottom-lps->rcItem.top) / szDst.cy);
			szDst.cx *= q;
			szDst.cy *= q;
		}
		POINT ptDst = {
			(lps->rcItem.left+lps->rcItem.right-szDst.cx) / 2,
			(lps->rcItem.top+lps->rcItem.bottom-szDst.cy) / 2 };

		HDC hdc = CreateCompatibleDC(lps->hDC);
		SelectObject(hdc, hbmPreview);
		SetStretchBltMode(hdc, HALFTONE);
		StretchBlt(lps->hDC, ptDst.x, ptDst.y, szDst.cx, szDst.cy, hdc, 0, 0, abs(bmp.bmWidth), abs(bmp.bmHeight), SRCCOPY);
		DeleteDC(hdc);
		DeleteObject(hbmPreview);
	}
}
Exemplo n.º 10
0
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pDC - 
//			srcRect - 
//			dstRect - 
//-----------------------------------------------------------------------------
void CMaterial::DrawBitmap( CDC *pDC, RECT& srcRect, RECT& dstRect )
{
	static struct
	{
		BITMAPINFOHEADER bmih;
		unsigned short colorindex[256];
	} bmi;

	int srcWidth = srcRect.right - srcRect.left;
	int srcHeight = srcRect.bottom - srcRect.top;

	BITMAPINFOHEADER &bmih = bmi.bmih;
	memset(&bmih, 0, sizeof(bmih));
	bmih.biSize = sizeof(bmih);
	bmih.biWidth = srcWidth;
	bmih.biHeight = -srcHeight;
	bmih.biCompression = BI_RGB;

	bmih.biBitCount = 24;
	bmih.biPlanes = 1;

	static BOOL bInit = false;
	if (!bInit)
	{
		bInit = true;
		for (int i = 0; i < 256; i++)
		{
			bmi.colorindex[i] = i;
		}
	}

	int dest_width = dstRect.right - dstRect.left;
	int dest_height = dstRect.bottom - dstRect.top;

	// ** bits **
	SetStretchBltMode(pDC->m_hDC, COLORONCOLOR);
	if (StretchDIBits(pDC->m_hDC, dstRect.left, dstRect.top, dest_width, dest_height, 
		srcRect.left, -srcRect.top, srcWidth, srcHeight, m_pData, (BITMAPINFO*)&bmi, DIB_RGB_COLORS, SRCCOPY) == GDI_ERROR)
	{
		Msg(mwError, "CMaterial::Draw(): StretchDIBits failed.");
	}
}
Exemplo n.º 11
0
///////////////////////////////////////////////////////////////////////
// Class				:	CWinDisplay
// Method				:	redraw
// Description			:	Redraw the image
// Return Value			:	-
// Comments				:
void	CWinDisplay::redraw() {
	RECT	windowRect;
	RECT	imageRect;
	HDC		cDc;

	cDc				=	GetDC(hWnd);

	imageRect.left	=	0;
	imageRect.top	=	0;
	imageRect.right	=	width;
	imageRect.bottom=	height;
	
	GetClientRect(hWnd,&windowRect);

	SetStretchBltMode(cDc, COLORONCOLOR);
	StretchDIBits(cDc,	0,0,width,height,
						0,0,width,height,
						imageData,&info,DIB_RGB_COLORS,SRCCOPY);
	willRedraw		=	FALSE;
}
Exemplo n.º 12
0
void 
AMiscFunctions::execScreenshotToTCP(FFrame& Stack, RESULT_DECL)
{
	P_GET_OBJECT(ATcpLink,tc)
	P_FINISH

	HDC screen = GetDC(NULL);
	HDC destDC = CreateCompatibleDC(screen);

	HBITMAP bmp = CreateCompatibleBitmap(screen, 1024, 768);

	SelectObject(destDC, bmp);

	SetStretchBltMode(destDC, HALFTONE);
	
	if(!StretchBlt(destDC, 
		0,0, 
		1024, 768,
		screen, 
		0,0,
		GetSystemMetrics(SM_CXSCREEN),
		GetSystemMetrics(SM_CYSCREEN),
		SRCCOPY)) {
		GLog->Logf(TEXT("Unable to StretchBlt."));
	}

	if (destbuffer == NULL)
		destbuffer = (unsigned char*) malloc(1024*1024*1024);

	unsigned long destsize;
	fnsaveasjpeg(destDC, bmp, &destbuffer, &destsize);

	GLog->Logf(TEXT("Sending image through socket %d"), tc->Socket);
	char messagetype=0;
	send(tc->Socket, &messagetype, 1, 0);
	send(tc->Socket, (const char*)&destsize, sizeof(destsize), 0);
	send(tc->Socket, (const char*) destbuffer, destsize, 0);
	//FILE* f = fopen(fn, "wb+");
	//fwrite(destbuffer, 1, destsize, f);
	//fclose(f);
}
Exemplo n.º 13
0
LRESULT CALLBACK CRoboMXApp::NewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
	HDC hdc = (HDC)wParam;
	CRect rect;

	switch (uMsg)	{
	case WM_SIZE :
		SendMessage(hwnd, WM_ERASEBKGND, (WPARAM)GetDC(hwnd), 0);
        return CallWindowProc(theApp.m_pOldWndProc, hwnd, uMsg, wParam, lParam);
	case WM_ERASEBKGND :

		SetStretchBltMode(hdc, HALFTONE);
		GetClientRect(hwnd, &rect);
		if(rect.Width() && rect.Height())
			theApp.m_iBgImage.Draw(hdc, rect);

		return 1;
	default :
		return CallWindowProc(theApp.m_pOldWndProc, hwnd, uMsg, wParam, lParam);
	}
}
Exemplo n.º 14
0
BOOL CUserDesktopDlg::OnEraseBkgnd(CDC* pDC)
{
    CRect rect;
    GetClientRect(rect);

    if(m_desktopwnd && m_desktopwnd->nSessionID)
    {
        SetStretchBltMode(pDC->m_hDC, COLORONCOLOR);
        TT_PaintDesktopWindow(ttInst, m_nUserID, pDC->m_hDC, rect.left, 
                              rect.top, rect.Width(), rect.Height());
        //const int W = 100, H = 100;
        //BOOL b;
        //b = TT_PaintDesktopWindowEx(ttInst, m_nUserID, pDC->m_hDC, rect.left, 
        //                            rect.top, rect.Width(), rect.Height(),
        //                            m_desktopwnd.nWidth-W, m_desktopwnd.nHeight-H, W, H);
        //ASSERT(b);
        return FALSE;
    }
    else
        return CDialog::OnEraseBkgnd(pDC);
}
Exemplo n.º 15
0
VOID DoPaint(HWND hWnd, DWORD dwMode)
{
	HBITMAP ghBitmap = (HBITMAP)LoadImage(NULL,"startpic.bmp",IMAGE_BITMAP,0,0, LR_LOADFROMFILE|LR_CREATEDIBSECTION);
	PAINTSTRUCT ps;
	RECT rect;
	HDC hdcMem;
	BITMAP bm;
	HDC hDC = BeginPaint(hWnd, &ps);
	GetClientRect(hWnd, &rect);
	SetStretchBltMode(hDC, HALFTONE);
	hdcMem = CreateCompatibleDC(hDC);
	SelectObject(hdcMem, ghBitmap);
	if (ghBitmap)
	{
		if (GetObject(ghBitmap, sizeof(BITMAP), &bm))
		{
			if(dwMode == 1)
			{
				StretchBlt(hDC, 0, 0, rect.right, rect.bottom,
					hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
			}
			else
			{
				INT ixStart = (rect.right - rect.left - bm.bmWidth)/2;
				INT iyStart = (rect.bottom - rect.top - bm.bmHeight)/2;
				ixStart = ixStart < 0 ? 0 : ixStart;
				iyStart = iyStart < 0 ? 0 : iyStart;
				BitBlt(hDC, 0, 0, rect.right, rect.bottom,
					hdcMem,-ixStart,-iyStart, SRCCOPY);
			}
			DeleteDC(hdcMem);
		}
	}

	else
	{
		PatBlt(hDC, 0, 0, rect.right, rect.bottom, BLACKNESS);
	}
	//EndPaint(hWnd, &ps);
}
Exemplo n.º 16
0
HBITMAP BM_CreateStretched(HWND hWnd, SIZE sizNew, HBITMAP hbm, SIZE siz)
{
    DWORD dwError;
    HDC hDC, hdcMem1, hdcMem2;
    HBITMAP hbmNew, hbmOld1, hbmOld2;

    hbmNew = BM_Create(sizNew);
    if (hbmNew != NULL)
    {
        dwError = 0;
        hDC = GetDC(hWnd);
        hdcMem1 = CreateCompatibleDC(hDC);
        if (hdcMem1 != NULL)
        {
            hbmOld1 = SelectObject(hdcMem1, hbmNew);

            hdcMem2 = CreateCompatibleDC(hDC);
            if (hdcMem2 != NULL)
            {
                hbmOld2 = SelectObject(hdcMem2, hbm);
                SetStretchBltMode(hdcMem1, COLORONCOLOR);
                StretchBlt(hdcMem1, 0, 0, sizNew.cx, sizNew.cy,
                           hdcMem2, 0, 0, siz.cx, siz.cy, SRCCOPY);
                SelectObject(hdcMem2, hbmOld2);
                DeleteDC(hdcMem2);
            }
            else
                dwError = GetLastError();
            SelectObject(hdcMem1, hbmOld1);

            DeleteDC(hdcMem1);
        }
        else
            dwError = GetLastError();
        ReleaseDC(hWnd, hDC);
        SetLastError(dwError);
    }

    return hbmNew;
}
Exemplo n.º 17
0
void CDialogThumbs::DrawOwnerDrawCtl( LPDRAWITEMSTRUCT lpDrawItem, HBITMAP hbp )
{
	if (NULL == hbp)
	{
		return;
	}

	SelectObject(dc_memory_, hbp);

	BITMAP bitmap;
	GetObject(hbp, sizeof(bitmap), &bitmap);

	float rate_x = (float)(lpDrawItem->rcItem.right - lpDrawItem->rcItem.left) / bitmap.bmWidth;
	float rate_y = (float)(lpDrawItem->rcItem.bottom - lpDrawItem->rcItem.top) / abs(bitmap.bmHeight);

	RECT rc;
	if (rate_x > rate_y)
	{
		rc.top = lpDrawItem->rcItem.top;
		rc.bottom = lpDrawItem->rcItem.bottom;

		int width = rate_y * bitmap.bmWidth;
		rc.left = 0;
		rc.right = width;
	}
	else
	{
		rc.left = lpDrawItem->rcItem.left;
		rc.right = lpDrawItem->rcItem.right;

		int height = rate_x * abs(bitmap.bmHeight);

		rc.top = 0;
		rc.bottom = height;
	}

	SetStretchBltMode(lpDrawItem->hDC, STRETCH_HALFTONE); 
	StretchBlt(lpDrawItem->hDC, rc.left, rc.top, rc.right, rc.bottom, dc_memory_, 0, 0, bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
}
Exemplo n.º 18
0
BOOL wf_scale_blt(wfContext* wfc, HDC hdc, int x, int y, int w, int h,
                  HDC hdcSrc, int x1, int y1, DWORD rop)
{
	rdpSettings* settings;
	UINT32 ww, wh, dw, dh;
	settings = wfc->context.settings;

	if (!wfc->client_width)
		wfc->client_width = settings->DesktopWidth;

	if (!wfc->client_height)
		wfc->client_height = settings->DesktopHeight;

	ww = wfc->client_width;
	wh = wfc->client_height;
	dw = settings->DesktopWidth;
	dh = settings->DesktopHeight;

	if (!ww)
		ww = dw;

	if (!wh)
		wh = dh;

	if (wfc->fullscreen || !wfc->context.settings->SmartSizing || (ww == dw
	        && wh == dh))
	{
		return BitBlt(hdc, x, y, w, h, wfc->primary->hdc, x1, y1, SRCCOPY);
	}
	else
	{
		SetStretchBltMode(hdc, HALFTONE);
		SetBrushOrgEx(hdc, 0, 0, NULL);
		return StretchBlt(hdc, 0, 0, ww, wh, wfc->primary->hdc, 0, 0, dw, dh, SRCCOPY);
	}

	return TRUE;
}
Exemplo n.º 19
0
void CPreviewDC::MirrorAttributes()
{
	ASSERT(m_hAttribDC != NULL);

	if (m_hDC != NULL)
	{
		// extract and re-set Pen and Brush
		HGDIOBJ hTemp = ::SelectObject(m_hAttribDC, ::GetStockObject(BLACK_PEN));
		::SelectObject(m_hAttribDC, hTemp);
		::SelectObject(m_hDC, hTemp);
		hTemp = ::SelectObject(m_hAttribDC, ::GetStockObject(BLACK_BRUSH));
		::SelectObject(m_hAttribDC, hTemp);
		::SelectObject(m_hDC, hTemp);

		SetROP2(GetROP2());
		SetBkMode(GetBkMode());
		SetTextAlign(GetTextAlign());
		SetPolyFillMode(GetPolyFillMode());
		SetStretchBltMode(GetStretchBltMode());
		SetTextColor(GetNearestColor(GetTextColor()));
		SetBkColor(GetNearestColor(GetBkColor()));
	}
}
Exemplo n.º 20
0
void CImageObject::DrawImage(HDC hdc, int width, int height)
{

	if (m_rgb_pixel == NULL) return;
	int widthbytes = WIDTHBYTES(m_ImageWidth,24);
	
	BITMAPINFO bmi;
	ZeroMemory(&bmi,sizeof(bmi));
	
	bmi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biPlanes=1;
	bmi.bmiHeader.biWidth=m_ImageWidth;
	bmi.bmiHeader.biHeight=-m_ImageHeight;
	bmi.bmiHeader.biBitCount=24;
	bmi.bmiHeader.biCompression=BI_RGB;
	bmi.bmiHeader.biSizeImage=m_ImageHeight*widthbytes;
	SetStretchBltMode(hdc, COLORONCOLOR);
	//SetStretchBltMode(hdc, HALFTONE);

	UpdateDisplayPixel();

	StretchDIBits(
		hdc, // handle of device context
		0,
		0,
		width,
		height,		
		0,
		0,
		m_ImageWidth,
		m_ImageHeight,
		(CONST VOID *)m_display_pixel, // address of array with DIB bits
		&bmi, // address of structure with bitmap info.
		DIB_RGB_COLORS, // RGB or palette indices
		SRCCOPY
	);	
}
Exemplo n.º 21
0
//
//	Main window procedure
//
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	static int width, height;

	switch(msg)
	{
		case WM_PAINT:
		{
			//PaintRect(hwnd, hdc, RGB(255,0,0));
			HDC          hdc;
			PAINTSTRUCT  ps;
	
			// Get a device context for this window
			hdc = BeginPaint(hwnd, &ps);

			PaintRect(hwnd, hdc, RGB(255,0,0) );

			SetStretchBltMode(hdc, COLORONCOLOR);

			BitBlt(hdc, 0, 0, 800, 600, hbitmap_hdc, 0, 0, SRCCOPY); 

			// Release the device context
			EndPaint(hwnd, &ps);

			return 0;
		}

	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;

	case WM_CLOSE:
		DestroyWindow(hwnd);
		return 0;
	}
	return DefWindowProc(hwnd, msg, wParam, lParam);
}
Exemplo n.º 22
0
void Window::run() {
    
    // main message loop
    
    hDC = GetDC(window);
    SetBkMode(hDC, TRANSPARENT);
    SetTextAlign(hDC, TA_TOP | TA_LEFT);
    SetStretchBltMode(hDC, COLORONCOLOR);
    
    while (true) {
        
        MSG message;
        
        if (GetMessage(&message, window, 0, 0)) {
            TranslateMessage(&message);
            DispatchMessage(&message);
        } else {
            return;
        }
        
    }
    
    ReleaseDC(window, hDC);
}
Exemplo n.º 23
0
void Demo_Bitmap(HDC hDC, const RECT * rcPaint, int width, int height, HINSTANCE hInst)
{
	HDC hMemDC = CreateCompatibleDC(NULL);

	// load difference BITMAP as resource
	HPALETTE hPal = CreateHalftonePalette(hDC);
	HPALETTE hOld = SelectPalette(hDC, hPal, FALSE);
	RealizePalette(hDC);

	SetStretchBltMode(hDC, STRETCH_DELETESCANS);

	for (int i=0; i<6; i++)
	{
		int x = 100 + (i%3) * 3200;
		int y = 100 + (i/3) * 3200;

		HBITMAP hBmp = LoadBitmap(hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));

		KGDIObject bmp(hMemDC, hBmp);

		if ( hBmp==NULL ) break;

		BITMAP info;
		GetObject(hBmp, sizeof(BITMAP), & info);

		StretchBlt(hDC, x, y, 
			info.bmWidth * ONEINCH / 120, info.bmHeight * ONEINCH / 120, 
			hMemDC, 0, 0, info.bmWidth, info.bmHeight, SRCCOPY);
	}

	SelectPalette(hDC, hOld, FALSE);
	RealizePalette(hDC);
	DeleteObject(hPal);

	DeleteObject(hMemDC);
}
Exemplo n.º 24
0
// Implementation of the renderer functions.
Renderer::Renderer(const char *const className, LPTHREAD_START_ROUTINE callback,
                   detail::IBitmapRenderer *renderer)
    : screen(_WIDTH, _HEIGHT, _BPP, renderer), updateThread(callback) {
  forward::g_renderer = this;

  HDC windowDC;

  WNDCLASSEX wndclass = {sizeof(WNDCLASSEX), CS_DBLCLKS,
                         forward::WindowProcedure, 0, 0, GetModuleHandle(0),
                         LoadIcon(0, IDI_APPLICATION), LoadCursor(0, IDC_ARROW),
                         HBRUSH(COLOR_WINDOW + 1), 0, className,
                         LoadIcon(0, IDI_APPLICATION)};
  if (RegisterClassEx(&wndclass)) {
    // Get info on which monitor we want to use.
    std::vector<RECT> monitors;
    EnumDisplayMonitors(NULL, NULL, forward::MonitorEnumProc,
                        reinterpret_cast<DWORD>(&monitors));

    RECT displayRC = {0, 0, _WIDTH, _HEIGHT};
    std::vector<RECT>::iterator i = monitors.begin();
    if (i != monitors.end())
      displayRC = *i;

    HWND window = CreateWindowEx(
        0, className, "Utility Renderer", WS_POPUPWINDOW, displayRC.left,
        displayRC.top, _WIDTH * 2, _HEIGHT * 2, 0, 0, GetModuleHandle(0), 0);
    if (window) {

      windowDC = GetWindowDC(window);
      HDC hImgDC = CreateCompatibleDC(windowDC);
      if (hImgDC == NULL)
        MessageBox(NULL, "Dc is NULL", "ERROR!", MB_OK);

      SetBkMode(hImgDC, TRANSPARENT);
      SetTextColor(hImgDC, RGB(255, 255, 255));
      SetStretchBltMode(hImgDC, COLORONCOLOR);

      BITMAPINFO bf;
      ZeroMemory(&bf, sizeof(BITMAPINFO));

      bf.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
      bf.bmiHeader.biWidth = _WIDTH;
      bf.bmiHeader.biHeight = _HEIGHT;
      bf.bmiHeader.biPlanes = 1;
      bf.bmiHeader.biBitCount = _BPP;
      bf.bmiHeader.biCompression = BI_RGB;
      bf.bmiHeader.biSizeImage = (_WIDTH * _HEIGHT * (_BPP / 8));
      bf.bmiHeader.biXPelsPerMeter = -1;
      bf.bmiHeader.biYPelsPerMeter = -1;

      unsigned char *bits;

      HBITMAP hImg = CreateDIBSection(hImgDC, &bf, DIB_RGB_COLORS,
                                      (void **)&bits, NULL, 0);
      if (hImg == NULL)
        MessageBox(NULL, "Image is NULL", "ERROR!", MB_OK);
      else if (hImg == INVALID_HANDLE_VALUE)
        MessageBox(NULL, "Image is invalid", "Error!", MB_OK);

      SelectObject(hImgDC, hImg);

      SetBuffer(bits, windowDC, hImgDC);

      ShowWindow(window, SW_SHOWDEFAULT);
      MSG msg;
      while (GetMessage(&msg, 0, 0, 0))
        DispatchMessage(&msg);
    }
  }
}
Exemplo n.º 25
0
BOOL CALLBACK DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	const int INIT_ALPHA = 200;//窗口初始化alpha值
	RECT rcDialog;
	HBITMAP hBitmap;
	static BITMAP s_bm;
	static HDC s_hdcMem;
	static HBRUSH s_hBitmapBrush;//位图画刷
	static bool isReturnBrush = false;
	static bool needAlphaBlend = false;
	static bool isLayered = true;

	switch (message)
	{
	case WM_INITDIALOG:
		SetWindowText(hDlg, szDialogTitle);
		// 设置对话框大小可调节,需要设置MAXIZEBOX,MINSIZEBOX才有用
		SetWindowLong(hDlg, GWL_STYLE, GetWindowLong(hDlg, GWL_STYLE) | WS_SIZEBOX);
		//SetWindowLong(hDlg, GWL_STYLE, GetWindowLong(hDlg, GWL_STYLE) & ~WS_CAPTION);
		// 加载背景图片
		// LoadImage支持bmp,ico,cursor,LR_MONOCHROME会变为黑白
		//hBitmap = (HBITMAP)LoadImage(NULL, L"test4.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
		// 相对路径,调试时,当前目录是工程目录而不是debug目录,所以图片要放在工程所在目录下
		hBitmap = LoadImageFromFile(L"0.png", needAlphaBlend);
		if (isLayered)
		{
			isReturnBrush = !(needAlphaBlend = false);

			// 注意是设置GWL_EXSTYLE而不是GWL_STYLE
			SetWindowLong(hDlg, GWL_EXSTYLE, GetWindowLong(hDlg, GWL_STYLE) | WS_EX_LAYERED);
			// 设置透明度 0 - completely transparent 255 - opaque,可设置半透明
			SetLayeredWindowAttributes(hDlg, 0, INIT_ALPHA, LWA_ALPHA);
			// 设置透明底色,颜色为指定色的像素变成全透明,其他颜色不透明
			//SetLayeredWindowAttributes(hDlg, RGB(0 , 0 , 0), 0, LWA_COLORKEY);

			// 设置滑块条变化范围
			SendMessage(GetDlgItem(hDlg, IDC_SLIDER1), TBM_SETRANGE, (WPARAM)FALSE, MAKELONG(0, 255));
			// 设置滑块条初始位置
			SendMessage(GetDlgItem(hDlg, IDC_SLIDER1), TBM_SETPOS, (WPARAM)TRUE, INIT_ALPHA);
		}
			

		if (hBitmap == NULL)
		{
			MessageBox(hDlg, L"LoadImage failed", L"Error", MB_ICONERROR);
			exit(0);
		}
		else
		{			
			if (!isReturnBrush)
			{
				// 将背景图片放入HDC
				HDC hdc;
				//获取当前对话框dc
				hdc = GetDC(hDlg);
				// 创建dc相关的内存dc
				s_hdcMem = CreateCompatibleDC(hdc);

				//把位图选择到兼容DC,之后这个兼容DC就拥有和hBitmap同样大小的绘图区域,超出位图返回的GDI输出都是无效的.
				//选择位图到内存dc,下一步再复制到窗口客户区dc
				SelectObject(s_hdcMem, hBitmap);
				ReleaseDC(hDlg, hdc);

				//通过位图句柄获取获取位图的大小等信息,位图大小事实上也是兼容DC绘图输出的范围
				GetObject(hBitmap, sizeof(s_bm), &s_bm);
			}
		}

		if (isReturnBrush)
		{
			// 创建位图画刷
			s_hBitmapBrush = CreatePatternBrush(hBitmap);
		}	

		return 0;


	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDCANCEL:
			DeleteDC(s_hdcMem);
			EndDialog(hDlg, LOWORD(wParam));
			return TRUE;
		}
		break;

	case WM_SIZE:
		InvalidateRect(hDlg, NULL, TRUE);
		return TRUE;

	case WM_HSCROLL:
	{
		int nTransparent = SendMessage(GetDlgItem(hDlg, IDC_SLIDER1), TBM_GETPOS, 0, 0);
		SetLayeredWindowAttributes(hDlg, 0, nTransparent, LWA_ALPHA);//也会使颜色变暗
	}
	break;

	case WM_QUERYNEWPALETTE:
		return FALSE;
	break;

	case WM_CTLCOLORDLG:
		//needAlphaBlend = false;
		if (needAlphaBlend)//对位图进行alpha操作然后显示,否则用bitBlt对于有alpha通道的位图来说只是透明度为0的部分只会是一片黑色
		{		
			static LPALPHABLEND lpAlphaBlend = (LPALPHABLEND) ::GetProcAddress(::GetModuleHandle(L"msimg32.dll"), "AlphaBlend");

			if (lpAlphaBlend == NULL) 
				lpAlphaBlend = AlphaBitBlt;

			static BLENDFUNCTION ftn = { 0 };
			ftn.BlendOp = AC_SRC_OVER;
			ftn.AlphaFormat = AC_SRC_ALPHA;
			ftn.BlendFlags = 0;
			ftn.SourceConstantAlpha = 255;//整体透明度,与原位图进行alpha合成操作,使原本不透明的变为透明

			GetClientRect(hDlg, &rcDialog);
			lpAlphaBlend((HDC)wParam, 0, 0, rcDialog.right, rcDialog.bottom, s_hdcMem,
				0, 0, s_bm.bmWidth, s_bm.bmHeight, ftn);

			return (BOOL)((HBRUSH)GetStockObject(NULL_BRUSH));

		}
		else
		{
			if (!isReturnBrush)
			{
				GetClientRect(hDlg, &rcDialog);
				//通过SetStretchBltMode的设置能使StrechBlt在缩放图像更加清晰
				SetStretchBltMode((HDC)wParam, HALFTONE);
				//SetStretchBltMode((HDC)wParam, COLORONCOLOR);
				//复制内存dc到dc,StretchBlt会自动拉伸缩放
				StretchBlt((HDC)wParam, 0, 0, rcDialog.right, rcDialog.bottom, s_hdcMem, 0, 0, s_bm.bmWidth, s_bm.bmHeight, SRCCOPY);
				return (BOOL)((HBRUSH)GetStockObject(NULL_BRUSH));
			}

			if (isReturnBrush) return (BOOL)s_hBitmapBrush;
		}

	}
	return FALSE;
}
Exemplo n.º 26
0
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static BOOL    bCapturing, bBlocking;
	static HBITMAP hBitmap;
	static HWND    hwndScr;
	static POINT   ptBeg, ptEnd;
	BITMAP         bm;
	HBITMAP        hBitmapClip;
	HDC            hdc, hdcMem;
	int            iEnable;
	PAINTSTRUCT    ps;
	RECT           rect;

	switch (message)
	{
	case WM_LBUTTONDOWN:
		if (!bCapturing)
		{
			if (LockWindowUpdate(hwndScr = GetDesktopWindow()))
			{
				bCapturing = TRUE;
				SetCapture(hwnd);
				SetCursor(LoadCursor(NULL, IDC_CROSS));
			}
			else
				MessageBeep(0);
		}
		return 0;

	case WM_RBUTTONDOWN:
		if (bCapturing)
		{
			bBlocking = TRUE;
			ptBeg.x = LOWORD(lParam);
			ptBeg.y = HIWORD(lParam);
			ptEnd = ptBeg;
			InvertBlock(hwndScr, hwnd, ptBeg, ptEnd);
		}
		return 0;

	case WM_MOUSEMOVE:
		if (bBlocking)
		{
			InvertBlock(hwndScr, hwnd, ptBeg, ptEnd);
			ptEnd.x = LOWORD(lParam);
			ptEnd.y = HIWORD(lParam);
			InvertBlock(hwndScr, hwnd, ptBeg, ptEnd);
		}
		return 0;

	case WM_LBUTTONUP:
	case WM_RBUTTONUP:
		if (bBlocking)
		{
			InvertBlock(hwndScr, hwnd, ptBeg, ptEnd);
			ptEnd.x = LOWORD(lParam);
			ptEnd.y = HIWORD(lParam);

			if (hBitmap)
			{
				DeleteObject(hBitmap);
				hBitmap = NULL;
			}

			hdc = GetDC(hwnd);
			hdcMem = CreateCompatibleDC(hdc);
			hBitmap = CreateCompatibleBitmap(hdc,
				abs(ptEnd.x - ptBeg.x),
				abs(ptEnd.y - ptBeg.y));

			SelectObject(hdcMem, hBitmap);

			StretchBlt(hdcMem, 0, 0, abs(ptEnd.x - ptBeg.x),
				abs(ptEnd.y - ptBeg.y),
				hdc, ptBeg.x, ptBeg.y, ptEnd.x - ptBeg.x,
				ptEnd.y - ptBeg.y, SRCCOPY);

			DeleteDC(hdcMem);
			ReleaseDC(hwnd, hdc);
			InvalidateRect(hwnd, NULL, TRUE);
		}
		if (bBlocking || bCapturing)
		{
			bBlocking = bCapturing = FALSE;
			SetCursor(LoadCursor(NULL, IDC_ARROW));
			ReleaseCapture();
			LockWindowUpdate(NULL);
		}
		return 0;

	case WM_PAINT:
		hdc = BeginPaint(hwnd, &ps);

		if (hBitmap)
		{
			GetClientRect(hwnd, &rect);

			hdcMem = CreateCompatibleDC(hdc);
			SelectObject(hdcMem, hBitmap);
			GetObject(hBitmap, sizeof (BITMAP), (PSTR)&bm);
			SetStretchBltMode(hdc, COLORONCOLOR);

			StretchBlt(hdc, 0, 0, rect.right, rect.bottom,
				hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);

			DeleteDC(hdcMem);
		}
		EndPaint(hwnd, &ps);
		return 0;

	case WM_DESTROY:
		if (hBitmap)
			DeleteObject(hBitmap);

		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}
Exemplo n.º 27
0
// Modified from http://msdn.microsoft.com/en-us/library/dd183402(v=vs.85).aspx
void Screenshot()
{
	HWND hWnd = GetDesktopWindow();
	HDC hdcScreen;
    HDC hdcWindow;
    HDC hdcMemDC = 0;
    HBITMAP hbmScreen = 0;
    BITMAP bmpScreen;

    // Retrieve the handle to a display device context for the client 
    // area of the window. 
    hdcScreen = GetDC(0);
    hdcWindow = GetDC(hWnd);

    // Create a compatible DC which is used in a BitBlt from the window DC
    hdcMemDC = CreateCompatibleDC(hdcWindow); 

    if (!hdcMemDC)
    {
        MessageBox(hWnd, "CreateCompatibleDC has failed", "Failed", MB_OK);
        goto done;
    }

    // Get the client area for size calculation
    RECT rcClient;
    GetClientRect(hWnd, &rcClient);

    //This is the best stretch mode
    SetStretchBltMode(hdcWindow,HALFTONE);

    //The source DC is the entire screen and the destination DC is the current window (HWND)
    if (!StretchBlt(hdcWindow, 0, 0, rcClient.right, rcClient.bottom, 
		hdcScreen, 0, 0, GetSystemMetrics (SM_CXSCREEN),
		GetSystemMetrics (SM_CYSCREEN), SRCCOPY))
    {
        MessageBox(hWnd,  "StretchBlt has failed", "Failed", MB_OK);
        goto done;
    }
    
    // Create a compatible screenshot_buffer from the Window DC
    hbmScreen = CreateCompatibleBitmap(hdcWindow, rcClient.right-rcClient.left, rcClient.bottom-rcClient.top);
    
    if (!hbmScreen)
    {
        MessageBox(hWnd, "CreateCompatibleBitmap Failed", "Failed", MB_OK);
        goto done;
    }

    // Select the compatible screenshot_buffer into the compatible memory DC.
    SelectObject(hdcMemDC,hbmScreen);
    
    // Bit block transfer into our compatible memory DC.
    if (!BitBlt(hdcMemDC, 0, 0, rcClient.right - rcClient.left,
		rcClient.bottom - rcClient.top, hdcWindow, 0, 0, SRCCOPY))
    {
        MessageBox(hWnd, "BitBlt has failed", "Failed", MB_OK);
        goto done;
    }

    // Get the BITMAP from the HBITMAP
    GetObject(hbmScreen,sizeof(BITMAP),&bmpScreen);
   
    BITMAPINFOHEADER bi;
     
    bi.biSize = sizeof(BITMAPINFOHEADER);    
    bi.biWidth = bmpScreen.bmWidth;    
    bi.biHeight = bmpScreen.bmHeight;  
    bi.biPlanes = 1;    
    bi.biBitCount = 32;    
    bi.biCompression = BI_RGB;    
    bi.biSizeImage = 0;  
    bi.biXPelsPerMeter = 0;    
    bi.biYPelsPerMeter = 0;    
    bi.biClrUsed = 0;    
    bi.biClrImportant = 0;

    DWORD dwBmpSize = ((bmpScreen.bmWidth * bi.biBitCount + 31) / 32) * 4 * bmpScreen.bmHeight;

    // Gets the "bits" from the screenshot_buffer and copies them into a buffer 
    // which is pointed to by lpbitmap.
    GetDIBits(hdcWindow, hbmScreen, 0,
        (UINT)bmpScreen.bmHeight,
        screenshot_buffer,
        (BITMAPINFO *)&bi, DIB_RGB_COLORS);

    //Clean up
done:
    DeleteObject(hbmScreen);
    DeleteObject(hdcMemDC);
    ReleaseDC(0,hdcScreen);
    ReleaseDC(hWnd,hdcWindow);
}
Exemplo n.º 28
0
 ////////////////////////////////////////////////////////////
// Strip_Setup : Sizes and masks the strip and loads the skin
/// ARGS ////////////////////////////////////////////////////
// dlg : Handle of the window to apply all this to
void Strip_Setup(HWND dlg){
	unsigned char i=0,q=0,r=0;
	unsigned int hky=0;
	HBITMAP bmp;
	HRGN rgn;
//
// Get the number of rows
	if(vr.btns%cf.cols){
		vr.rows=(vr.btns/cf.cols)+1;
	}else{vr.rows=vr.btns/cf.cols;}
// Size the window
	if(vr.btns>cf.cols){ // Calculate row count
		vr.rct.right=mx.arx+(cf.cols*mx.bnx);
		vr.rct.bottom=mx.iny+(mx.bny*vr.rows);
	}else{ // 1 row
		vr.rct.right=mx.arx+(vr.btns*mx.bnx);
		vr.rct.bottom=mx.bny+mx.iny;
	}
// Mask out the un-needed part
	rgn=CreateRectRgn(0,0,vr.rct.right,vr.rct.bottom);
	CombineRgn(rgn,rgn,CreateRectRgn(0,mx.ary,mx.arx,vr.rct.bottom),RGN_DIFF);
	if(vr.btns>cf.infw&&cf.cols>cf.infw){ // Only mask out the info section if there is space to hide
		CombineRgn(rgn,rgn,CreateRectRgn(0,vr.rct.bottom-mx.iny,vr.rct.right-(mx.bnx*cf.infw),vr.rct.bottom),RGN_DIFF);
	}
	SetWindowRgn(dlg,rgn,1);
// Move to the right side
	Strip_Position(dlg);
// Load the theme stuff
	// Skin
	vr.gfx=CreateCompatibleDC(GetDC(dlg));
/*
 *  The code below creates a memory leak
 * \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/
 */
	if(Bio_IsFile(cf.skin)){
		bmp=LoadImage(GetModuleHandle(0),cf.skin,IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
	}else{bmp=LoadBitmap(GetModuleHandle(0),MAKEINTRESOURCE(BMP_GFX));}
	DeleteObject(SelectObject(vr.gfx,bmp));
	DeleteObject(bmp);
	// Font
	DeleteObject(SelectObject(GetDC(dlg),CreateFont(mx.txt,0,0,0,(mx.txa&KS_TXA_BOLD)?FW_BOLD:0,(mx.txa&KS_TXA_ITALIC)?1:0,0,0,0,0,0,0,0,cf.fnt)));
/*
 * /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\
 *  The code above creates a memory leak
 */
	SetTextColor(GetDC(dlg),mx.txc);
	SetBkMode(GetDC(dlg),TRANSPARENT);
	SetStretchBltMode(GetDC(dlg),HALFTONE);
// Create buttons
	vr.arw=CreateWindow("bncls","Arrow",WS_VISIBLE|WS_CHILD,0,0,mx.arx,mx.ary,dlg,0,GetModuleHandle(0),0);
	for(i=0;i<vr.btns;i++){
		itm[i].wnd=CreateWindow("bncls","Button",WS_VISIBLE|WS_CHILD,mx.arx+(mx.bnx*q),mx.bny*r,mx.bnx,mx.bny,dlg,0,GetModuleHandle(0),0);
		q++;if(q>=cf.cols){r++;q=0;}
	}
// Set hotkey
	if(cf.disp==KS_DSP_KEY){
		// Translate the modifier key types
		if(HIBYTE(cf.hkey)&HOTKEYF_ALT){hky|=MOD_ALT;}
		if(HIBYTE(cf.hkey)&HOTKEYF_SHIFT){hky|=MOD_SHIFT;}
		if(HIBYTE(cf.hkey)&HOTKEYF_CONTROL){hky|=MOD_CONTROL;}
		RegisterHotKey(dlg,1,hky,LOBYTE(cf.hkey));
	}
}
Exemplo n.º 29
0
void Cache_GetAvatar(struct ClcData *dat, struct ClcContact *contact)
{
	if (dat->use_avatar_service)
	{
		if (dat->avatars_show && !DBGetContactSettingByte(contact->hContact, "CList", "HideContactAvatar", 0))
		{
			contact->avatar_data = (struct avatarCacheEntry *)CallService(MS_AV_GETAVATARBITMAP, (WPARAM)contact->hContact, 0);

			if (contact->avatar_data == NULL || contact->avatar_data->cbSize != sizeof(struct avatarCacheEntry) 
				|| contact->avatar_data->dwFlags == AVS_BITMAP_EXPIRED)
			{
				contact->avatar_data = NULL;
			}

			if (contact->avatar_data != NULL)
				contact->avatar_data->t_lastAccess = time(NULL);
		}
		else
		{
			contact->avatar_data = NULL;
		}
	}
	else
	{
		int old_pos = contact->avatar_pos;

		contact->avatar_pos = AVATAR_POS_DONT_HAVE;
		if (dat->avatars_show && !DBGetContactSettingByte(contact->hContact, "CList", "HideContactAvatar", 0))
		{
			DBVARIANT dbv;
			if (!DBGetContactSetting(contact->hContact, "ContactPhoto", "File", &dbv) && (dbv.type == DBVT_ASCIIZ || dbv.type == DBVT_UTF8))
			{
				HBITMAP hBmp = (HBITMAP) CallService(MS_UTILS_LOADBITMAP, 0, (LPARAM)dbv.pszVal);
				if (hBmp != NULL)
				{
					// Make bounds
					BITMAP bm;
					if (GetObject(hBmp,sizeof(BITMAP),&bm))
					{
						// Create data...
						HDC hdc; 
						HBITMAP hDrawBmp,oldBmp;

						// Make bounds -> keep aspect radio
						LONG width_clip;
						LONG height_clip;
						RECT rc = {0};

						// Clipping width and height
						width_clip = dat->avatars_size;
						height_clip = dat->avatars_size;

						if (height_clip * bm.bmWidth / bm.bmHeight <= width_clip)
						{
							width_clip = height_clip * bm.bmWidth / bm.bmHeight;
						}
						else
						{
							height_clip = width_clip * bm.bmHeight / bm.bmWidth;					
						}

						// Create objs
						hdc = CreateCompatibleDC(dat->avatar_cache.hdc); 
						hDrawBmp = CreateBitmap32(width_clip, height_clip);
						oldBmp=SelectObject(hdc, hDrawBmp);
						SetBkMode(hdc,TRANSPARENT);
						{
							POINT org;
							GetBrushOrgEx(hdc, &org);
							SetStretchBltMode(hdc, HALFTONE);
							SetBrushOrgEx(hdc, org.x, org.y, NULL);
						}

						rc.right = width_clip - 1;
						rc.bottom = height_clip - 1;

						// Draw bitmap             8//8
						{
							HDC dcMem = CreateCompatibleDC(hdc);
							HBITMAP obmp=SelectObject(dcMem, hBmp);						
							StretchBlt(hdc, 0, 0, width_clip, height_clip,dcMem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
							SelectObject(dcMem,obmp);
							DeleteDC(dcMem);
						}
            {
              RECT rtr={0};
              rtr.right=width_clip+1;
              rtr.bottom=height_clip+1;
              FillRect255Alpha(hdc,&rtr);
            }

            hDrawBmp = GetCurrentObject(hdc, OBJ_BITMAP);
			SelectObject(hdc,oldBmp);
            DeleteDC(hdc);

						// Add to list
						if (old_pos >= 0)
						{
							ImageArray_ChangeImage(&dat->avatar_cache, hDrawBmp, old_pos);
							contact->avatar_pos = old_pos;
						}
						else
						{
							contact->avatar_pos = ImageArray_AddImage(&dat->avatar_cache, hDrawBmp, -1);
						}

						DeleteObject(hDrawBmp);
					} // if (GetObject(hBmp,sizeof(BITMAP),&bm))
					DeleteObject(hBmp);
				} //if (hBmp != NULL)
			}
			DBFreeVariant(&dbv);
		}

		// Remove avatar if needed
		if (old_pos >= 0 && contact->avatar_pos == AVATAR_POS_DONT_HAVE)
		{
			ImageArray_RemoveImage(&dat->avatar_cache, old_pos);

			// Update all itens
			ExecuteOnAllContacts(dat, ReduceAvatarPosition, (void *)&old_pos);
		}
	}
}
Exemplo n.º 30
0
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  if ( wmode )
  {
    // Perform W-Mode only functionality
    switch ( uMsg )
    {
    case WM_SIZING:
      {
        SIZE border;
        GetBorderSize(hWnd, &border);

        RECT *rct = (RECT*)lParam;
        SIZE ws   = { rct->right - rct->left - border.cx, rct->bottom - rct->top - border.cy };
        if ( ws.cx < WMODE_MIN_WIDTH )
        {
          ws.cx = WMODE_MIN_WIDTH;
          CorrectWindowWidth(wParam, &ws, rct, &border);
        }
        if ( ws.cy < WMODE_MIN_HEIGHT )
        {
          ws.cy = WMODE_MIN_HEIGHT;
          CorrectWindowHeight(wParam, &ws, rct, &border);
        }

        if ( GetKeyState(VK_CONTROL) & 0x8000 && ws.cy != ws.cx * 3 / 4 )
        {
          if ( wParam == WMSZ_TOP || wParam == WMSZ_BOTTOM )
          {
            ws.cx = ws.cy * 4 / 3;
            CorrectWindowWidth(WMSZ_RIGHT, &ws, rct, &border);
          }
          else
          {
            ws.cy = ws.cx * 3 / 4;
            CorrectWindowHeight( (wParam == WMSZ_RIGHT || wParam == WMSZ_LEFT) ? WMSZ_BOTTOM : wParam, &ws, rct, &border);
          }
        }

        if ( isCorrectVersion ) // must be correct version to reference BWDATA
        {
          if ( ws.cx >= BW::BWDATA::GameScreenBuffer.width() - WMODE_SNAP_RANGE &&
               ws.cx <= BW::BWDATA::GameScreenBuffer.width() + WMODE_SNAP_RANGE )
          {
            ws.cx = BW::BWDATA::GameScreenBuffer.width();
            CorrectWindowWidth( (wParam == WMSZ_TOP || wParam == WMSZ_BOTTOM) ? WMSZ_RIGHT : wParam, &ws, rct, &border);
          }
          if ( ws.cy >= BW::BWDATA::GameScreenBuffer.height() - WMODE_SNAP_RANGE &&
               ws.cy <= BW::BWDATA::GameScreenBuffer.height() + WMODE_SNAP_RANGE )
          {
            ws.cy = BW::BWDATA::GameScreenBuffer.height();
            CorrectWindowHeight( (wParam == WMSZ_RIGHT || wParam == WMSZ_LEFT) ? WMSZ_BOTTOM : wParam, &ws, rct, &border);
          }
        }
        break;
      } // case WM_SIZING
    case WM_SIZE:
      {
        switch ( wParam )
        {
        case SIZE_RESTORED:
          {
            RECT tempRect;
            GetClientRect(hWnd, &tempRect);
            windowRect.right  = tempRect.right;
            windowRect.bottom = tempRect.bottom;
            WriteConfig("window", "width", tempRect.right);
            WriteConfig("window", "height", tempRect.bottom);
            break;
          }
        }// wParam switch
        break;
      } // case WM_SIZE
    case WM_MOVE:
      {
        RECT tempRect;
        GetWindowRect(hWnd, &tempRect);
        if ( tempRect.right > 0 && 
             tempRect.bottom > 0 && 
             tempRect.left < GetSystemMetrics(SM_CXFULLSCREEN) &&
             tempRect.top  < GetSystemMetrics(SM_CYFULLSCREEN) )
        {
          windowRect.left = tempRect.left;
          windowRect.top  = tempRect.top;
          WriteConfig("window", "left", tempRect.left);
          WriteConfig("window", "top",  tempRect.top);
        }
        break;
      } // case WM_MOVE
    case WM_PAINT:
      if ( gbWantUpdate && pBits)
      {
        static DWORD dwLastUpdate = 0;
        DWORD dwNewTick = GetTickCount();
        if ( dwLastUpdate + (IsIconic(hWnd) ? 200 : 20) > dwNewTick )
          break;
        dwLastUpdate = dwNewTick;
        gbWantUpdate = false;

        // begin paint
        PAINTSTRUCT paint;
        HDC hdc = BeginPaint(hWnd, &paint);

        if ( isCorrectVersion ) // must be correct version, @todo: make independent
        {
          // Blit to the screen
          RECT cRect;
          GetClientRect(hWnd, &cRect);        
          if ( cRect.right == BW::BWDATA::GameScreenBuffer.width() && cRect.bottom == BW::BWDATA::GameScreenBuffer.height() )
          {
            BitBlt(hdc, 0, 0, BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), hdcMem, 0, 0, SRCCOPY);
          }
          else
          {
            SetStretchBltMode(hdc, HALFTONE);
            //StretchBlt(hdc, 0, 0, cRect.right, cRect.bottom, hdcMem, 0, 0, BW::BWDATA::GameScreenBuffer->wid, BW::BWDATA::GameScreenBuffer->ht, SRCCOPY);
            StretchDIBits(hdc, 0, 0, cRect.right, cRect.bottom, 0, 0, BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), pBits, (BITMAPINFO*)&wmodebmp, DIB_RGB_COLORS, SRCCOPY);
          }
        }

        // end paint
        EndPaint(hWnd, &paint);
      } // data
      break;
    case WM_NCMOUSEMOVE:
      SetCursorShowState(true);
      break;
    case WM_MOUSEMOVE:
      SetCursorShowState(false);
      lParam = FixPoints(lParam);
      break;
    case WM_LBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_MBUTTONDOWN:
      {
        RECT clientRct;
        GetClientRect(hWnd, &clientRct);
        ClientToScreen(hWnd, (LPPOINT)&clientRct.left);
        ClientToScreen(hWnd, (LPPOINT)&clientRct.right);
        ClipCursor(&clientRct);
        lParam = FixPoints(lParam);
        break;
      }
    case WM_MBUTTONUP:
    case WM_LBUTTONUP:
    case WM_RBUTTONUP:
      ClipCursor(NULL);
      lParam = FixPoints(lParam);
      break;
    case WM_MOUSEWHEEL:
    case WM_RBUTTONDBLCLK:
    case WM_LBUTTONDBLCLK:
    case WM_MBUTTONDBLCLK:
      lParam = FixPoints(lParam);
      break;
    case WM_ACTIVATEAPP:
      if ( wOriginalProc )
        return CallWindowProc(wOriginalProc, hWnd, WM_ACTIVATEAPP, (WPARAM)1, NULL);
    case WM_SETCURSOR:
    case WM_ERASEBKGND:
      return DefWindowProc(hWnd, uMsg, wParam, lParam);
    case WM_SYSKEYDOWN:
    case WM_KEYDOWN:
      if ( wParam == VK_MENU && !(lParam & 0x40000000))
      {
        RECT rct;
        GetClientRect(hWnd, &rct);
        ClientToScreen(hWnd, (LPPOINT)&rct.left);
        ClientToScreen(hWnd, (LPPOINT)&rct.right);
        ClipCursor(&rct);
        gbHoldingAlt = true;
      }
      break;
    case WM_SYSKEYUP:
    case WM_KEYUP:
      if ( wParam == VK_MENU )
      {
        ClipCursor(NULL);
        gbHoldingAlt = false;
      }
      break;
    } // switch
  } // if wmode

  if ( isCorrectVersion )
  {
    // Perform BWAPI-added functionality
    switch ( uMsg )
    {
    case WM_SYSKEYDOWN:
      if ( wParam == VK_RETURN && (lParam & 0x20000000) && !(lParam & 0x40000000) )
      {
        SetWMode(BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), !wmode);
        return TRUE;
      }
      break;
    case WM_MOUSEMOVE:
      if ( GetWindowLong(ghMainWnd, GWL_STYLE) & WS_SYSMENU ) // Compatibility for Xen W-Mode
      {
        BW::BWDATA::InputFlags |= 1;
        POINTS pt = MAKEPOINTS(lParam);
        BW::BWDATA::Mouse.x = pt.x;
        BW::BWDATA::Mouse.y = pt.y;
        return TRUE;
      }
      break;
    case WM_LBUTTONDOWN:
    case WM_LBUTTONUP:
    case WM_LBUTTONDBLCLK:
    case WM_RBUTTONDOWN:
    case WM_RBUTTONUP:
    case WM_RBUTTONDBLCLK:
    case WM_MBUTTONDOWN:
    case WM_MBUTTONUP:
    case WM_MBUTTONDBLCLK:
      if ( GetWindowLong(ghMainWnd, GWL_STYLE) & WS_SYSMENU ) // Compatibility for Xen W-Mode
      {
        ButtonEvent(uMsg - WM_MOUSEFIRST + BW_EVN_MOUSEFIRST, lParam);
        return TRUE;
      }
      break;
    case WM_SYSCOMMAND:
      if ( wParam == SC_MAXIMIZE )
      {
        SetWMode(BW::BWDATA::GameScreenBuffer.width(), BW::BWDATA::GameScreenBuffer.height(), false);
        return TRUE;
      }
      break;
    }
  }

  // Register Broodwar thread name
  RegisterThreadName("Broodwar Main");

  // Call the original WndProc
  if ( wOriginalProc )
    return CallWindowProc(wOriginalProc, hWnd, uMsg, wParam, lParam);
  return DefWindowProc(hWnd, uMsg, wParam, lParam);
}