Ejemplo n.º 1
0
void EmfPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap & pix, const QPointF &)
{
	setClipping();

#ifdef Q_WS_WIN
	HBITMAP hBmp = pix.toWinHBITMAP();
	HBRUSH wbrush = CreatePatternBrush(hBmp);

	QMatrix m = painter()->worldMatrix();
	QRectF dr = m.mapRect(r);

	RECT rect;
	rect.left = qRound(dr.left());
	rect.top = qRound(dr.top());
	rect.right = qRound(dr.right());
	rect.bottom = qRound(dr.bottom());

	FillRect(metaDC, &rect, wbrush);

	DeleteObject(hBmp);
	DeleteObject(wbrush);
#else
	int width = qRound(r.width());
	int height = qRound(r.height());

	QPixmap pixmap(width, height);
	QPainter p(&pixmap);
	p.drawTiledPixmap(0, 0, width, height, pix);
	p.end();

	drawPixmap(r, pixmap, QRectF());
#endif

	resetClipping();
}
Ejemplo n.º 2
0
void WINAPI DrawXorBar(HDC hdc, int x1, int y1, int width, int height)
{
    static WORD _dotPatternBmp[8] = 
    { 
    0x00aa, 0x0055, 0x00aa, 0x0055, 
    0x00aa, 0x0055, 0x00aa, 0x0055
    };

    HBITMAP hbitmap;
    HBRUSH hbrush,hbrushOld;

    hbitmap = CreateBitmap(8,8,1,1,_dotPatternBmp);
    hbrush = CreatePatternBrush(hbitmap);

    SetBrushOrgEx(hdc,x1,y1,0);

    hbrushOld = (HBRUSH)SelectObject(hdc,hbrush);

    PatBlt(hdc,x1,y1,width,height,PATINVERT);

    SelectObject(hdc,hbrushOld);

    DeleteObject(hbrush);
    DeleteObject(hbitmap);
} 
Ejemplo n.º 3
0
void CChineseChessDlg::DrawChessImage(int x, int y, HDC dc)
{
	HBITMAP hbmp;
	char name[3];
	char path[255];
	GetModuleFileName(NULL,path,255);
	(_tcsrchr(path,_T('\\')))[1] = 0;
	strcat(path,_T("\\Sourse\\"));
	if (chess[y][x].chessType != 0)
	{
		if (chess[y][x].isSelect)
		{
			strcat(path,_T("x"));
		}
		itoa(chess[y][x].chessType,name,10);
		strcat(path,name);
		strcat(path,_T(".bmp"));
		hbmp = (HBITMAP)LoadImage(AfxGetInstanceHandle(),path,
			IMAGE_BITMAP,50,50,LR_LOADFROMFILE);
		HBRUSH brush = CreatePatternBrush(hbmp); 
		HGDIOBJ hOld = SelectObject(dc,brush);
		RECT rec;
		rec.left = x * 50 ;
		rec.top = y * 50 ;
		rec.bottom = rec.top + 50;
		rec.right = rec.left + 50;
		FillRect(dc,&rec,brush);

		//╩ж╦╢т╜охв╢л╛
		SelectObject(dc, hOld);

		DeleteObject(brush);
		DeleteObject(hOld);
	}
}
Ejemplo n.º 4
0
int CTabCtrl2::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CTabCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;

	CRect rc;
	GetWindowRect(rc);
	CDC* dc = GetDC();

	HDC hDCMem = CreateCompatibleDC(dc->GetSafeHdc());
	HBITMAP hBmp = CreateCompatibleBitmap(dc->GetSafeHdc(), rc.right - rc.left, rc.bottom - rc.top);
	HGDIOBJ hBmpOld = SelectObject(hDCMem, hBmp);

	SendMessage(WM_PRINTCLIENT, (WPARAM)hDCMem, (LPARAM)(PRF_ERASEBKGND | PRF_CLIENT | PRF_NONCLIENT));

	hBgBrush = CreatePatternBrush(hBmp);

	SelectObject(hDCMem, hBmpOld);

	DeleteObject(hBmp);
	DeleteDC(hDCMem);
	ReleaseDC(dc);	

	return 0;
}
Ejemplo n.º 5
0
static BOOL
MonSelDrawDisabledRect(IN OUT PMONITORSELWND infoPtr,
                       IN HDC hDC,
                       IN const RECT *prc)
{
    BOOL Ret = FALSE;

    if (infoPtr->hbrDisabled == NULL)
    {
        static const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};

        if (infoPtr->hbmDisabledPattern == NULL)
        {
            infoPtr->hbmDisabledPattern = CreateBitmap(8,
                                          8,
                                          1,
                                          1,
                                          Pattern);
        }

        if (infoPtr->hbmDisabledPattern != NULL)
            infoPtr->hbrDisabled = CreatePatternBrush(infoPtr->hbmDisabledPattern);
    }

    if (infoPtr->hbrDisabled != NULL)
    {
        /* FIXME: Implement */
    }

    return Ret;
}
Ejemplo n.º 6
0
/***********************************************************************
 *           update_wallpaper
 */
BOOL update_wallpaper( const WCHAR *wallpaper, const WCHAR *pattern )
{
    int pat[8];

    if (hbrushPattern) DeleteObject( hbrushPattern );
    hbrushPattern = 0;
    memset( pat, 0, sizeof(pat) );
    if (pattern)
    {
        char buffer[64];
        WideCharToMultiByte( CP_ACP, 0, pattern, -1, buffer, sizeof(buffer), NULL, NULL );
        if (sscanf( buffer, " %d %d %d %d %d %d %d %d",
                    &pat[0], &pat[1], &pat[2], &pat[3],
                    &pat[4], &pat[5], &pat[6], &pat[7] ))
        {
            WORD ptrn[8];
            HBITMAP hbitmap;
            int i;

            for (i = 0; i < 8; i++) ptrn[i] = pat[i] & 0xffff;
            hbitmap = CreateBitmap( 8, 8, 1, 1, ptrn );
            hbrushPattern = CreatePatternBrush( hbitmap );
            DeleteObject( hbitmap );
        }
    }
    init_wallpaper( wallpaper );
    RedrawWindow( GetDesktopWindow(), 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
    return TRUE;
}
Ejemplo n.º 7
0
/***********************************************************************
 *           DESKTOP_SetPattern
 *
 * Set the desktop pattern.
 */
BOOL DESKTOP_SetPattern( LPCWSTR pattern )
{
    int pat[8];

    if (hbrushPattern) DeleteObject( hbrushPattern );
    hbrushPattern = 0;
    memset( pat, 0, sizeof(pat) );
    if (pattern)
    {
        char buffer[64];
        WideCharToMultiByte( CP_ACP, 0, pattern, -1, buffer, sizeof(buffer), NULL, NULL );
        if (sscanf( buffer, " %d %d %d %d %d %d %d %d",
                    &pat[0], &pat[1], &pat[2], &pat[3],
                    &pat[4], &pat[5], &pat[6], &pat[7] ))
        {
            WORD ptrn[8];
            HBITMAP hbitmap;
            int i;

            for (i = 0; i < 8; i++) ptrn[i] = pat[i] & 0xffff;
            hbitmap = CreateBitmap( 8, 8, 1, 1, ptrn );
            hbrushPattern = CreatePatternBrush( hbitmap );
            DeleteObject( hbitmap );
        }
    }
    return TRUE;
}
Ejemplo n.º 8
0
static TroughClientData *TroughClientDataInit(Tcl_Interp *interp)
{
    TroughClientData *cd = (TroughClientData*)ckalloc(sizeof(*cd));
    cd->PatternBitmap = CreateBitmap(8, 8, 1, 1, Pattern);
    cd->PatternBrush  = CreatePatternBrush(cd->PatternBitmap);
    Ttk_RegisterCleanup(interp, cd, TroughClientDataDeleteProc);
    return cd;
}
Ejemplo n.º 9
0
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Place code here.

    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_SAPPER, szWindowClass, MAX_LOADSTRING);
	HBITMAP hBmp = LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPBACK));

	HBRUSH hBrush = CreatePatternBrush(hBmp);

	BombField::setBmpEmpty(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPBUT)));
	BombField::setBmp0(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP0)));
	BombField::setBmpFlag(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPFLAG)));
	BombField::setBmpQm(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPQM)));
	BombField::setBmpBomb(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPBOMB)));
	BombField::setBmp1(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP1)));
	BombField::setBmp2(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP2)));
	BombField::setBmp3(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP3)));
	BombField::setBmp4(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP4)));
	BombField::setBmp5(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP5)));
	BombField::setBmp6(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP6)));
	BombField::setBmp7(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP7)));
	BombField::setBmp8(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAP8)));
	BombField::setBmpExploded(LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BITMAPEXPL)));

	if (!MyRegisterClass(hInstance, hBrush))
		return FALSE;

    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SAPPER));

    MSG msg;

    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}
Ejemplo n.º 10
0
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR szCmd, int nShow)
{
	HWND hwnd;
	MSG msg;
	WNDCLASSEX wcls;
	HBITMAP hbitmap = LoadBitmap(GetModuleHandle(NULL), TEXT("background"));
	HBRUSH hbrush = CreatePatternBrush(hbitmap);
	DeleteObject(hbitmap);

	wcls.cbSize = sizeof(wcls);
	wcls.style = CS_HREDRAW | CS_VREDRAW;
	wcls.lpfnWndProc = WndProc;
	wcls.hInstance = hInst;
	wcls.cbWndExtra = 0;
	wcls.cbClsExtra = 0;
	wcls.hbrBackground = hbrush/*(HBRUSH)GetStockObject(NULL_BRUSH)*/;
	wcls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wcls.hIconSm = NULL;
	wcls.hCursor = LoadCursor(NULL, IDC_ARROW);
	wcls.lpszClassName = szAppName;
	wcls.lpszMenuName = NULL;

	if (!RegisterClassEx(&wcls)){
		MessageBox(NULL, TEXT("注册类出错!"), TEXT("错误"), MB_ICONERROR);
		return 0;
	}

	wcls.cbWndExtra = sizeof(BOOL);
	wcls.lpfnWndProc = ButtonProc;
	wcls.lpszClassName = TEXT("mybutton");
	wcls.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);


	if (!RegisterClassEx(&wcls)){
		MessageBox(NULL, TEXT("注册类出错!"), TEXT("错误"), MB_ICONERROR);
		return 0;
	}

	hwnd = CreateWindow(szAppName,
		szAppName,
		WS_OVERLAPPED | WS_CAPTION | \
		WS_SYSMENU | WS_MINIMIZEBOX,
		CW_USEDEFAULT, CW_USEDEFAULT,
		CW_USEDEFAULT, CW_USEDEFAULT,
		NULL, NULL, hInst, NULL);

	ShowWindow(hwnd, nShow);
	UpdateWindow(hwnd);

	while (GetMessage(&msg, NULL, 0, 0)){
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	DeleteObject(hbrush);
	return msg.wParam;
}
Ejemplo n.º 11
0
static void DrawPreview(HWND hwnd, HDC hdc)
{
	BITMAPINFO bi;
	bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
	bi.bmiHeader.biWidth = 8;
	bi.bmiHeader.biHeight = -8;
	bi.bmiHeader.biPlanes = 1;
	bi.bmiHeader.biBitCount = 32;
	bi.bmiHeader.biCompression = BI_RGB;
	HBITMAP hBmpBrush = CreateDIBSection(0, &bi, DIB_RGB_COLORS, 0, 0, 0);
	HDC dcBmp = CreateCompatibleDC(0);
	HBITMAP hBmpSave = (HBITMAP)SelectObject(dcBmp, hBmpBrush);
	HBRUSH hbr = CreateSolidBrush(RGB(0xcc, 0xcc, 0xcc));

	RECT rc;
	SetRect(&rc, 0, 0, 8, 8);
	FillRect(dcBmp, &rc, hbr);
	DeleteObject(hbr);
	hbr = CreateSolidBrush(RGB(0xff, 0xff, 0xff));
	SetRect(&rc, 4, 0, 8, 4);
	FillRect(dcBmp, &rc, hbr);
	SetRect(&rc, 0, 4, 4, 8);
	FillRect(dcBmp, &rc, hbr);
	DeleteObject(hbr);
	SelectObject(dcBmp, hBmpSave);
	DeleteDC(dcBmp);

	GetClientRect(hwnd, &rc);
	hbr = CreatePatternBrush(hBmpBrush);
	SetBrushOrgEx(hdc, 1, 1, 0);
	FillRect(hdc, &rc, hbr);
	DeleteObject(hbr);
	DeleteObject(hBmpBrush);

	if (gPreviewOk)
	{
		int width = min(rc.right, wndPreview->getContent()->getWidth());
		int height = min(rc.bottom, wndPreview->getContent()->getHeight());
		int left = (rc.right - width) / 2;
		int top = (rc.bottom - height) / 2;


		BLENDFUNCTION bf;
		bf.BlendOp = AC_SRC_OVER;
		bf.BlendFlags = 0;
		bf.SourceConstantAlpha = 255;
		bf.AlphaFormat = AC_SRC_ALPHA;
		AlphaBlend(hdc, left, top, width, height,
			wndPreview->getContent()->getDC(),
			0, 0, width, height, bf);

	}

	FrameRect(hdc, &rc, GetStockBrush(LTGRAY_BRUSH));
}
Ejemplo n.º 12
0
static void drawPatternSimple(HDC hdc, const RECT& destRect, HBITMAP hbmp, const POINT& phase)
{
    OwnPtr<HBRUSH> hBrush = adoptPtr(CreatePatternBrush(hbmp));
    if (!hBrush)
        return;

    POINT oldOrg;
    SetBrushOrgEx(hdc, destRect.left - phase.x, destRect.top - phase.y, &oldOrg);
    FillRect(hdc, &destRect, hBrush.get());
    SetBrushOrgEx(hdc, oldOrg.x, oldOrg.y, 0);
}
Ejemplo n.º 13
0
STATICFN HBRUSH NEAR MyCreateSolidBrush(
    DWORD rgb)
{
    HDC hdc;
    HDC hdcMem;
    HBRUSH hbr;
    HBRUSH hbrOld;
    HBITMAP hbmPat;
    HBITMAP hbmOld;

    /*
     * First, create a brush for the given RGB value.
     */
    hbr = CreateSolidBrush(rgb);

    /*
     * Create a temporary memory DC.
     */
    hdc = GetDC(ghwndMain);
    hdcMem = CreateCompatibleDC(hdc);

    /*
     * Create a temporary bitmap.
     */
    hbmPat = MyCreateBitmap(hdc, 8, 8, gnColorPalColors);
    ReleaseDC(ghwndMain, hdc);

    /*
     * Draw the (possibly) dithered pattern on the temporary bitmap.
     */
    hbmOld = SelectObject(hdcMem, hbmPat);
    hbrOld = SelectObject(hdcMem, hbr);
    PatBlt(hdcMem, 0, 0, 8, 8, PATCOPY);
    SelectObject(hdcMem, hbrOld);
    SelectObject(hdcMem, hbmOld);
    DeleteDC(hdcMem);

    /*
     * Delete the first brush.
     */
    DeleteObject(hbr);

    /*
     * Now create a pattern brush out of the (dithered) bitmap.
     */
    hbr = CreatePatternBrush(hbmPat);

    DeleteObject(hbmPat);

    /*
     * Return the pattern brush.
     */
    return hbr;
}
Ejemplo n.º 14
0
HBRUSH CreatePatternBrushFromFile(LPCTSTR pszFile)
{
    HBRUSH hbr = NULL;
    HBITMAP hbm = (HBITMAP)LoadImage(g_hinst, pszFile,
                   IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
    if (hbm) {
        hbr = CreatePatternBrush(hbm);
        DeleteObject(hbm);
    }
    return hbr;
}
Ejemplo n.º 15
0
void Test_MaskBlt_Brush()
{
    HDC hdcDst, hdcSrc;
    struct
    {
        BITMAPINFOHEADER bmiHeader;
        ULONG aulColors[2];
    } bmiData = {{sizeof(BITMAPINFOHEADER), 16, 16, 1, 1, BI_RGB, 0, 10, 10, 2,0}, {0, 0xFFFFFF}};
    PBITMAPINFO pbmi = (PBITMAPINFO)&bmiData;
    HBITMAP hbmDst, hbmSrc, hbmMsk;
    PULONG pulBitsDst, pulBitsSrc, pulBitsMsk;
    BOOL ret;
    HBRUSH hbr;

    /* Create a dest dc and bitmap */
    hdcDst = CreateCompatibleDC(NULL);
    hbmDst = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsDst, NULL, 0);
    SelectObject(hdcDst, hbmDst);

    /* Create a source dc and bitmap */
    hdcSrc = CreateCompatibleDC(NULL);
    hbmSrc = CreateDIBSection(hdcSrc, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsSrc, NULL, 0);
    SelectObject(hdcSrc, hbmSrc);

    hbr = CreateHatchBrush(HS_CROSS, 0);
    ok(hbr != 0, "failed to create brush\n");
    ok(SelectObject(hdcDst, hbr) != 0, "failed to select brush\n");

    /* Do the masking (SRCCOPY / NOOP) */
    pulBitsDst[0] = 0x00000000;
    pulBitsSrc[0] = 0xFFFFFFFF;
    ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, NULL, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000));
    ok(ret == 1, "MaskBlt failed (%d)\n", ret);
    ok(pulBitsDst[0] == 0, "pulBitsDst[0] == 0x%lx\n", pulBitsDst[0]);

    /* Create a 1 bpp pattern brush */
    pbmi->bmiHeader.biWidth = 8;
    hbmMsk = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsMsk, NULL, 0);
    ok(hbmMsk != 0, "CreateDIBSection failed\n");
    hbr = CreatePatternBrush(hbmMsk);
    ok(hbr != 0, "CreatePatternBrush failed\n");
    ok(SelectObject(hdcDst, hbr) != 0, "failed to select brush\n");

    /* Do the masking (SRCCOPY / NOOP) */
    pulBitsDst[0] = 0x00000000;
    pulBitsSrc[0] = 0xFFFFFFFF;
    pulBitsMsk[0] = 0xCCAAFF00;
    ret = MaskBlt(hdcDst, 0, 0, 16, 1, hdcSrc, 0, 0, NULL, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000));
    ok(ret == 1, "MaskBlt failed (%d)\n", ret);
    ok(pulBitsDst[0] == 0, "pulBitsDst[0] == 0x%lx\n", pulBitsDst[0]);

}
Ejemplo n.º 16
0
void CEdit::DrawDragRect( const RECT &rc ) const
{
	HDC hDC = GetDC( m_hWnd );
	short bits[8] = { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55 };
	HBITMAP hbmPattern = CreateBitmap( 8, 8, 1, 1, &bits );
	HBRUSH hbrPattern = CreatePatternBrush( hbmPattern );
	HBRUSH hOldBrush = ( HBRUSH ) SelectObject( hDC, hbrPattern );
	VERIFY( PatBlt( hDC, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATINVERT ) );
	SelectObject( hDC, hOldBrush );
	DeleteObject( hbrPattern );
	DeleteObject( hbmPattern );
	ReleaseDC( m_hWnd, hDC );
}
Ejemplo n.º 17
0
void load_main_screen()
{

	short i;
 	RECT map_from_orig = {372,0,380,8},map_from,brush_to = {0,0,8,8};

	main_dc = GetDC(mainPtr);

	SelectObject(main_dc,font);
	SetBkMode(main_dc,TRANSPARENT);


	SetStretchBltMode(main_dc,STRETCH_DELETESCANS);

	terrain_buttons_gworld = CreateCompatibleBitmap(main_dc,terrain_buttons_rect.right,terrain_buttons_rect.bottom);

	ter_draw_gworld = CreateCompatibleBitmap(main_dc,terrain_rect.right,terrain_rect.bottom);

	dlg_buttons_gworld = load_pict(2000);
	mixed_gworld = load_pict(903);

	run_startup_g();


	world_screen = terrain_rect;
	OffsetRect(&world_screen,TER_RECT_UL_X,TER_RECT_UL_Y);

	for (i = 0; i < 10; i++)
		monst_gworld[i] = load_pict(1100 + i);
	for (i = 0; i < 6; i++)
		terrain_gworld[i] = load_pict(800 + i);
	small_terrain_gworld = load_pict(904);
	editor_mixed = load_pict(906);
	anim_gworld = load_pict(820);
	field_gworld = load_pict(821);
	talkfaces_gworld = load_pict(860);
	items_gworld = load_pict(901);
	tiny_obj_gworld = load_pict(900);
	dlogpics_gworld = load_pict(850);
	dialog_pattern_gworld = CreateCompatibleBitmap(main_dc,192,256);
	pattern_gworld = CreateCompatibleBitmap(main_dc,192,256);
	//draw_main_screen();

	for (i = 0; i < 25; i++) {
		map_from = map_from_orig;
		OffsetRect(&map_from,8 * (i / 10),8 * (i % 10));
		map_bitmap[i] = CreateCompatibleBitmap(main_dc,8,8);
		rect_draw_some_item(mixed_gworld,map_from,map_bitmap[i],brush_to,0,0);
		map_brush[i] = CreatePatternBrush(map_bitmap[i]);
		}
}
Ejemplo n.º 18
0
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
     static TCHAR szAppName [] = TEXT ("Bricks3") ;
     HBITMAP      hBitmap ;
     HBRUSH       hBrush ;
     HWND         hwnd ;
     MSG          msg ;
     WNDCLASS     wndclass ;

     hBitmap = LoadBitmap (hInstance, TEXT ("Bricks")) ;
     hBrush = CreatePatternBrush (hBitmap) ;
     DeleteObject (hBitmap) ;

     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = hBrush ; 
     wndclass.lpszMenuName  = NULL ;
     wndclass.lpszClassName = szAppName ;
     
     if (!RegisterClass (&wndclass))
     {
          MessageBox (NULL, TEXT ("This program requires Windows NT!"),
                      szAppName, MB_ICONERROR) ;
          return 0 ;
     }
     
     hwnd = CreateWindow (szAppName, TEXT ("CreatePatternBrush Demo"), 
                          WS_OVERLAPPEDWINDOW, 
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

     ShowWindow (hwnd, iCmdShow) ;
     UpdateWindow (hwnd) ;

     while (GetMessage (&msg, NULL, 0, 0))
     {
          TranslateMessage (&msg) ;
          DispatchMessage (&msg) ;
     }

     DeleteObject (hBrush) ;
     return msg.wParam ;
}
Ejemplo n.º 19
0
HBRUSH Globals::GetGrabHandleBrush(int nIndex)
{
	EnterCriticalSection(&m_csGlobals);
	if (NULL == m_hBrushGrab[nIndex])
	{
		HBITMAP hBmp = (HBITMAP)LoadImage(g_hInstance, MAKEINTRESOURCE(IDB_GRAB1+nIndex), IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
		if (g_fSysWinNT)
			m_hBrushGrab[nIndex] = CreatePatternBrush(hBmp);
		else
			m_hBrushGrab[nIndex] = (HBRUSH)hBmp;
	}
	LeaveCriticalSection(&m_csGlobals);
	return m_hBrushGrab[nIndex];
}
Ejemplo n.º 20
0
static void CreatePreview(TSelectorData *sd, TCHAR *fn, LPDRAWITEMSTRUCT lps)
{
	HDC hdc = CreateCompatibleDC(lps->hDC);
	sd->hbmpPreview = CreateCompatibleBitmap(lps->hDC, lps->rcItem.right - lps->rcItem.left, lps->rcItem.bottom - lps->rcItem.top);
	SelectObject(hdc, sd->hbmpPreview);

	RECT rc;
	HBRUSH hbr;

	BITMAPINFO bi = {0};
	bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
	bi.bmiHeader.biWidth = 8;
	bi.bmiHeader.biHeight = -8;
	bi.bmiHeader.biPlanes = 1;
	bi.bmiHeader.biBitCount = 32;
	bi.bmiHeader.biCompression = BI_RGB;

	HBITMAP hBmpBrush = (HBITMAP)CreateDIBSection(0, &bi, DIB_RGB_COLORS, 0, 0, 0);
	HDC dcBmp = CreateCompatibleDC(0);
	HBITMAP hBmpSave = (HBITMAP)SelectObject(dcBmp, hBmpBrush);
	hbr = CreateSolidBrush(RGB(0xcc, 0xcc, 0xcc));
	SetRect(&rc, 0, 0, 8, 8);
	FillRect(dcBmp, &rc, hbr);
	DeleteObject(hbr);
	hbr = CreateSolidBrush(RGB(0xff, 0xff, 0xff));
	SetRect(&rc, 4, 0, 8, 4);
	FillRect(dcBmp, &rc, hbr);
	SetRect(&rc, 0, 4, 4, 8);
	FillRect(dcBmp, &rc, hbr);
	DeleteObject(hbr);
	SelectObject(dcBmp, hBmpSave);
	DeleteDC(dcBmp);

	rc = lps->rcItem;
	OffsetRect(&rc, -rc.left, -rc.top);
	hbr = CreatePatternBrush(hBmpBrush);
	SetBrushOrgEx(hdc, 1, 1, 0);
	FillRect(hdc, &rc, hbr);
	DeleteObject(hbr);
	DeleteObject(hBmpBrush);

	HDC hdcSave = lps->hDC;
	lps->hDC = hdc;
	sttPreviewSkin(sd->obj, fn, lps);
	lps->hDC = hdcSave;

	FrameRect(hdc, &rc, GetStockBrush(LTGRAY_BRUSH));
	DeleteDC(hdc);
}
Ejemplo n.º 21
0
// call only once at the beginning of program
void RegisterSplitterWndClass() {
    if (splitterBmp)
        return;

    static WORD dotPatternBmp[8] = {
        0x00aa, 0x0055, 0x00aa, 0x0055, 0x00aa, 0x0055, 0x00aa, 0x0055
    };

    splitterBmp = CreateBitmap(8, 8, 1, 1, dotPatternBmp);
    splitterBrush = CreatePatternBrush(splitterBmp);

    WNDCLASSEX wcex;
    FillWndClassEx(wcex, SPLITTER_CLASS_NAME, WndProcSplitter);
    RegisterClassEx(&wcex);
}
Ejemplo n.º 22
0
//-------------------------------------------------------------------------
//	load a resource and turn it into a brush
//-------------------------------------------------------------------------
HBRUSH GWinControl::GetBrushFromResource(int Resource)
{
	HBITMAP HBitmap = NULL;
	HBRUSH HBrush = NULL;
	
	//	didnt load from external file, try loading internal resource
	HBitmap = (HBITMAP)LoadImage( GApp::g_HInstance, MAKEINTRESOURCE(Resource), IMAGE_BITMAP, 0, 0, 0x0 );
	if ( HBitmap ) 
	{
		HBrush = CreatePatternBrush( HBitmap );
		DeleteObject( HBitmap );
		return HBrush;
	}

	return HBrush;
}
Ejemplo n.º 23
0
HBRUSH get_desktop_brush(void)
{
    HBRUSH brush;
    HBITMAP bitmap;
    HDC mem_dc, desptop_dc;
    desptop_dc = GetDC(NULL);
    mem_dc = CreateCompatibleDC(desptop_dc);
    bitmap = CreateCompatibleBitmap(desptop_dc, g_screen_width, g_screen_height);
    SelectObject(mem_dc, bitmap);
    BitBlt(mem_dc, 0, 0, g_screen_width, g_screen_height, desptop_dc, 0, 0, SRCCOPY);
    brush = CreatePatternBrush(bitmap); //通过位图创建画刷
    DeleteObject(bitmap);
    DeleteDC(mem_dc);
    ReleaseDC(NULL, desptop_dc);

    return brush;
}
Ejemplo n.º 24
0
void OnPaint(HWND hWnd){
	PAINTSTRUCT ps = {0};
	HDC hdc = BeginPaint(hWnd,&ps);
	
	HPEN hPen = CreatePen(PS_DASH,10,RGB(255,0,0));
	//HBRUSH hBrush = CreateSolidBrush(RGB(0,255,0));
	//HGDIOBJ hBrush = GetStockObject(NULL_BRUSH);
	
	HBITMAP hBmp = LoadBitmap(g_hInstance,MAKEINTRESOURCE(IDB_BITMAP1));
	HBRUSH hBrush = CreatePatternBrush(hBmp);


	HGDIOBJ nOldPen = SelectObject(hdc,hBrush);

	int nOldMode = SetMapMode(hdc,MM_ISOTROPIC);
	SetWindowExtEx(hdc,1,1,NULL);
	SetViewportExtEx(hdc,1,2,NULL);

	switch(g_kind){
		case ID_ARC:
			DrawArc(hdc);
			break;
		case ID_POINT:
			DrawPoint(hdc);
			break;
		case ID_LINE:
			DrawLine(hdc);
			break;
		case ID_RECT:
			DrawRect(hdc);
			break;
		case ID_ROUNDRECT:
			DrawRoundRect(hdc);
			break;
		case ID_CIRCLE:
			DrawCircle(hdc);
			break;
		case ID_BMP:
			DrawBmp(hdc);
			break;
	}
	SelectObject(hdc,nOldPen);
	//DeleteObject(hPen);
	SetMapMode(hdc,nOldMode);
	EndPaint(hWnd,&ps);
}
Ejemplo n.º 25
0
static void win32_init(void)
{
    WNDCLASS wc;

    INITCOMMONCONTROLSEX icex;

    icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icex.dwICC = ICC_BAR_CLASSES;
    InitCommonControlsEx(&icex);

    wc.style = 0;
    wc.lpfnWndProc = (WNDPROC) MainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = inst;
    wc.hIcon = LoadIcon(inst, MAKEINTRESOURCE(0));
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    if (!(wc.hbrBackground = CreatePatternBrush(LoadBitmap(inst, "wood1"))))
        wc.hbrBackground=CreateSolidBrush(clWoodenDown);
    wc.lpszMenuName = 0;
    wc.lpszClassName = "MainWindow";

    if (!RegisterClass(&wc))
        die("RegisterClass");

    wc.style = 0;
    wc.lpfnWndProc = (WNDPROC) TermWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = inst;
    wc.hIcon = 0;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground=0;
    wc.lpszMenuName = 0;
    wc.lpszClassName = "Term";

    if (!RegisterClass(&wc))
        die("RegisterClass");

    load_font();
    draw_init(&df);
    InitializeCriticalSection(&vt_mutex);
    if (!(timer=CreateWaitableTimer(0, 0, 0)))
        die("CreateWaitableTimer");
}
Ejemplo n.º 26
0
void Test_BrushOrigin()
{
    ULONG aulBits[2] = {0x5555AAAA, 0};
    HBITMAP hbmp;
    HBRUSH hbr;
    BOOL ret;

    hbmp = CreateBitmap(2, 2, 1, 1, aulBits);
    if (!hbmp)
    {
        printf("Couln not create a bitmap\n");
        return;
    }

    hbr = CreatePatternBrush(hbmp);
    if (!hbr)
    {
        printf("Couln not create a bitmap\n");
        return;
    }

    if (!SelectObject(hdcTarget, hbr))
    {
        printf("failed to select pattern brush\n");
        return;
    }

    ret = PatBlt(hdcTarget, 0, 0, 2, 2, PATCOPY);
    ok_long(ret, 1);
    ok_long(gpulTargetBits[0], 0xffffff);
    ok_long(gpulTargetBits[1], 0);
    ok_long(gpulTargetBits[16], 0);
    ok_long(gpulTargetBits[17], 0xffffff);
    //printf("0x%lx, 0x%lx\n", gpulTargetBits[0], gpulTargetBits[1]);

    ret = PatBlt(hdcTarget, 1, 0, 2, 2, PATCOPY);
    ok_long(ret, 1);
    ok_long(gpulTargetBits[0], 0xffffff);
    ok_long(gpulTargetBits[1], 0);
    ok_long(gpulTargetBits[2], 0xffffff);
    ok_long(gpulTargetBits[16], 0);
    ok_long(gpulTargetBits[17], 0xffffff);
    ok_long(gpulTargetBits[18], 0);

}
Ejemplo n.º 27
0
VOID
CreateFrameBrushes(VOID)
{
  FrameBrushes[0] = CreateSolidBrush(RGB(0,0,0));
  FrameBrushes[1] = CreateSolidBrush(RGB(0,0,128));
  FrameBrushes[2] = CreateSolidBrush(RGB(10,36,106));
  FrameBrushes[3] = CreateSolidBrush(RGB(128,128,128));
  FrameBrushes[4] = CreateSolidBrush(RGB(181,181,181));
  FrameBrushes[5] = CreateSolidBrush(RGB(212,208,200));
  FrameBrushes[6] = CreateSolidBrush(RGB(236,233,216));
  FrameBrushes[7] = CreateSolidBrush(RGB(255,255,255));
  FrameBrushes[8] = CreateSolidBrush(RGB(49,106,197));
  FrameBrushes[9] = CreateSolidBrush(RGB(58,110,165));
  FrameBrushes[10] = CreateSolidBrush(RGB(64,64,64));
  FrameBrushes[11] = CreateSolidBrush(RGB(255,255,225));
  hHatch = CreateBitmap(8, 8, 1, 1, HatchBitmap);
  FrameBrushes[12] = CreatePatternBrush(hHatch);
}
Ejemplo n.º 28
0
void __cdecl
WinMainCRTStartup()
{
	HWND hWnd;
	HBITMAP bgbm = prepareBackground();
	HBRUSH bgbrush = CreatePatternBrush(bgbm);
	inst = GetModuleHandle(0);

	{
		WNDCLASS wc = {
			0, //style
			winProc, //lpfnWndProc
			0, //cbClsExtra
			0, //cbWndExtra
			inst, //hInstance
			0, //hIcon
			LoadCursor(NULL,IDC_ARROW), //hCursor
			bgbrush,
			0, //lpszMenuName
			TITLE //lpszClassName
		};
		RegisterClass(&wc);
	}

	hWnd = CreateWindow(TITLE, TITLE, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_VISIBLE, 0, 0, WIN_WIDTH, WIN_HEIGHT, 0, 0, inst, 0);

	{
		MSG msg;

		while (GetMessage(&msg, 0, 0, 0)) {
			if (!hDlgCurrent || !IsDialogMessage(hDlgCurrent, &msg)) {
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
	}

	DestroyWindow(hWnd);
	DeleteObject(bgbrush);
	DeleteObject(bgbm);
	ExitProcess(0);
}
Ejemplo n.º 29
0
void RingDockSite::SetBgBmp(HBITMAP hbm,BOOL bSetOrg/*=FALSE*/)
{
	if(hbm)
	{
		HBRUSH hBrush = m_Background.hBrush;
		GetBmpSize(hbm,(SIZE*)&m_Background);
		m_Background.hBrush = CreatePatternBrush(hbm);		
		m_Background.bSetOrg = bSetOrg;

		if(m_Background.bNeedDelete)
		{
			UpdateAllSiteBkg(hBrush);
			DeleteObject(hBrush);
		}
		m_Background.bNeedDelete = FALSE;
		UpdateBkg();
	}
	else
		SetBgColor(GetSysColor(COLOR_BTNFACE));
}
Ejemplo n.º 30
0
BOOL Ctl_CreateBrushes( )
/************************************************************************/
{
WORD Pattern[16];
HBITMAP hBitmap;
int i;

Ctl_hShadowBrush = CreateSolidBrush( Ctl_GetBtnShadowColor() );
Ctl_hButtonBrush = CreateSolidBrush( Ctl_GetBtnFaceColor() );
for ( i=0; i<16; i+=2 )
	Pattern[i] = 0xAAAA;
for ( i=1; i<16; i+=2 )
	Pattern[i] = 0x5555;
hBitmap = CreateBitmap( 16, 16, 1, 1, (LPTR)Pattern );
Ctl_hHilightBrush = CreatePatternBrush( hBitmap );
DeleteObject( hBitmap );
Ctl_hShadowPen = CreatePen( PS_SOLID, 1, Ctl_GetBtnShadowColor());
Ctl_hButtonPen = CreatePen( PS_SOLID, 1, Ctl_GetBtnFaceColor());
return(TRUE);
}