DC mit höherer auslösung als die des systems ?

pixartist

ich will ein bild in nen dc selecten, welches mehr pixel hat, als mein monitor...ich bekomm aber kein dc mit mehr pixeln !? GetDC(0) liefert ja nur n DC mit meiner auflösung! wie bekomm ich denn das mal hin ?

keksekekse

CreateCompatibleDC
CreateCompatibleBitmap und das Bitmap in den DC selecten

pixartist

keksekekse schrieb:

CreateCompatibleDC
CreateCompatibleBitmap und das Bitmap in den DC selecten

häääääää?
CreateCompatibleDC mit welchem parameter??

CodeFinder

In etwa so:

const int iWidthRes  = 1200,
          iHeightRes = 1600;
HDC hdcScreen = GetDC(NULL);
HDC hdcMem = CreateCompatibleDC(hdcScreen);
HBITMAP hbmpPrev = static_cast<HBITMAP>(SelectObject(hdcMem, CreateCompatibleBitmap(hdcScreen, iWidthRes, iHeightRes)));
ReleaseDC(NULL, hdcScreen);

// ...
// ToDo: Irgendwas mit hdcMem machen...
// ...

// Clean-Up:
DeleteObject(SelectObject(hdcMem, hbmpPrev));
DeleteDC(hdcMem);

pixartist

hm dann verstehe ich nicht wieso das nicht geht?

HBITMAP loadImg(char* path)
{
	if(HBITMAP ret = (HBITMAP)LoadImage(0,path,IMAGE_BITMAP,0,0,LR_LOADFROMFILE))
		return ret;
	else
		return NULL;

}
HDC getScreenShot()
{
	return GetDC(0);
}
HBITMAP getBitmapScreenShot()
{
	HDC screen = getScreenShot();
	HDC hdcCompatible = CreateCompatibleDC(screen); 
	HBITMAP screenBitmap = CreateCompatibleBitmap(screen, GetDeviceCaps(screen, HORZRES), GetDeviceCaps(screen, VERTRES));
	SelectObject(hdcCompatible, screenBitmap);
	BitBlt(hdcCompatible,0,0, GetDeviceCaps(screen, HORZRES), GetDeviceCaps(screen, VERTRES), screen, 0,0,SRCCOPY) ;
	return screenBitmap;
}
HDC getBitmapHDC(HBITMAP img)
{
	HDC hdcImage = CreateCompatibleDC(GetDC(0));
	SelectObject(hdcImage,img);
	return hdcImage;
}
SIZE getBitmapSize(HBITMAP img)
{

	BITMAP imgInfo;
	GetObject(img, sizeof(BITMAP), (LPSTR)&imgInfo);
	SIZE ret;
	ret.cx = imgInfo.bmWidth;
	ret.cy = imgInfo.bmHeight;
	return ret;
}
HDC getHDCScaled(float xscale, float yscale, HDC source)
{
	HDC hdcScaled = CreateCompatibleDC(getScreenShot()); 
	HBITMAP hbmScaled = CreateCompatibleBitmap(source, 
                    GetDeviceCaps(source, HORZRES) * xscale, 
                    GetDeviceCaps(source, VERTRES) * yscale); 
	SelectObject(hdcScaled, hbmScaled);
	StretchBlt(hdcScaled, 
                     0, 0, 
                     GetDeviceCaps(source, HORZRES) * xscale,  GetDeviceCaps(source, VERTRES) * yscale, 
                     source, 
                     0, 0, 
                     GetDeviceCaps(source, HORZRES), GetDeviceCaps(source, VERTRES), 
                     SRCCOPY); 
	return hdcScaled;

}

hBitmap = loadImg(szFileName);
							GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;

							HDC scrShot = getBitmapHDC(hBitmap);
							hdcMem = getHDCScaled(1, 1, scrShot);

jetzt wird aber die bitmap nur so gross angezeigt, wie meine bildschirmauflösung ist

geeky

Du hast dein sxcale und yscale ja auch auf 1?

Wenn ich das richtig verstehe:

+--------------+   +--------+
|              |   | Screen |
|     Bild     |   +--------+
|              |
+--------------+
// Bild größer als Screen

Du lädst also die Bitmap mit sagen wir mal 1280x1024
und hast nen Screen von sagen wir mal 800x600
Also musst du das Bild kleiner StretchBlitten (Faktor 800/1280=0.625).
Praktischerweise gibtst du bei StretchBlt() einfach das Quellrechteck und das Zielrechteck an und brauchst quasi nichts weiter als Größe der Quell- und Zielfläche.

pixartist

nein nein!
ich will nicht ein grösseres bild verkleinern, um es ganz sehen zu können! ich will einen HDC, der mehr pixel fasst als mein bildschirm! versteht mich denn keiner?

+---------------+
|               |
|    Screen     |
|               |
|               |
+---------------+

+---------------------------------------------+
|               |                             |
|               |                             |
|     Im DC     |                             |
|               |                             |
|---------------+                             |
|                  BILD                       |
|                                             |
|                                             |
|                                             |
|                                             |
+---------------------------------------------+

versteht ihr? im dc ist nur der bereich meines bildes, der so gross ist wie mein screen!

wenn ich jetzt in meinem programm zb an den rechten bildrand scrolle, dann

BitBlt (hdc, 0, 0, (winSize.cx-200), (winSize.cy-50), hdcMem, imgxp, imgyp, SRCCOPY) ;

ist die variable imgxp > 0 und (winSize.cx-200) ist grösser als die bildbreite meines bildschirms...aber der teil des bildes, der im DC auf coordinaten liegt, die ausserhalb der auflösung meines bildschirms sind, wird nicht angezeigt!

dh ich hab dann folgendes:

+---------------------------------------------+
|            |  |         |                   |
|            |  |         |                   |
|     Im DC  |  |Nicht sichtbar               |
|            |  |         |                   |
|------------+--+---------+                   |
|                  BILD                       |
|                                             |
|                                             |
|                                             |
|                                             |
+---------------------------------------------+

geeky

Ein MemoryDC (welches von CreateCompatibleDC() erzeugt wird) ist immer genauso groß wie die rein-selektierte Bitmap.
getBitmapHDC() sollte quasi ein DC liefern, das so groß ist wie das img.

Bei getHDCScaled() erzeugst du aber immer nur so große Bitmaps wie der Screen groß ist.

pixartist schrieb:

versteht ihr? im dc ist nur der bereich meines bildes, der so gross ist wie mein screen!

Wie kommst Du darauf ? Welcher dc ? Du hast zwei davon.

Eventuell mal prüfen, ob bei BitBlt () "winSize.cx", "winSize.cy", "imgxp" und "imgyp" korrekt hoch- und runtergezählt werden.

pixartist

ja ok war mein fehler in der resize methode