[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von MaikG:
>BMF_SPECIALFMT = 0x80

>Probiers mal damit. Einfach weglassen geht nicht. Sonst wäre es ja nicht da!


Und woher kommt diese Konstante?

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von Der_Wanderer:
Mensch MaikG, du bist echt ein harter Fall...
Bitte lese den Thread nochmal genau durch, und mache dir klar was Colormap vs. Hi/True Color bedeutet, also ein Pen vs. RGB Farben sind.

---

Und ich dachte, ich hätte das Pen-Sharing Konzept Einsteigerfreundlich erklärt: http://w3.norman-interactive.com/C-Kurs_8_5.html.
Falls in meinem C-Kurs was nicht klar sein sollte, bin ich jederzeit für konstruktive Kritik offen.

Nochmal kurz das "Pen-Konzept für Dummies":

Ein Pen kann man sich vorstellen wie einen Buntstift. Alle Stifte sind nummeriert. Mit ObtainBestPen() kann man die Nummer des Stiftes ermitteln, die am besten zur gewünschten Farbe passt. Allerdings haben die AmigaOS-Pens im Gegensatz zu Buntstiften keine feste Farbe, sondern die Farbe eines Stiftes kann sich ändern. Wenn man also z.B. schreibt SetAPen(rp, 2L) und dies beim ersten Programmlauf schwarz sein sollte, kann man sich nicht sicher sein, daß dies beim nächsten Programmlauf ebenfalls wieder so sein wird. Pen Nr. 2 ist zwar einer der Pens, die von der Workbench gesetzt werden, aber es kann ja durchaus sein, daß der User eine andere Farbeinstellung wählt. Dann kann Pen Nr. 2 z.B. auch lila-blass-blau oder sonst was sein.

Was anderes ist es, wenn man Grafik-Funktionen verwendet, die einen RGB-Wert als Eingabeparameter erwarten, wie z.B. die CybergraphX-Funktion WriteRGBPixel():

Zitat:

---

CyberGFX/WriteRGBPixel
NAME

WriteRGBPixel -- Writes a pixel to a specified location
SYNOPSIS

error = WriteRGBPixel(RastPort,x ,y ,color)
D0 A1 D0 D1 D2
ULONG WriteRGBPixel(struct RastPort *,UWORD,UWORD,ULONG);

FUNCTION

Write the alpha,red,green and blue 8-bit color component of the given color to a specified x,y location within a certain RastPort
INPUTS

rp - pointer to a RastPort structure
x,y - the coordinates of the pixel
color - the desired color in AARRGGBB format. Every component
allocates 8 bits of the returned longword. The coding is as
follows:
AA - 8-bit alpha channel component
(set it to 00 if you dont want to use it!)
RR - 8-bit red component of the pixel
GG - 8-bit green component
BB - 8-bit blue component

RESULT

error = 0 if pixel succesfully changed
= -1 if (x,y) is outside the rastport

NOTES

This function should only be used on screens depths > 8 bits. Use WritePixel() on 8 bit screens!
SEE ALSO

ReadRGBPixel(), graphics.library/WritePixel()

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von Mad_Dog:
Mit Hilfe der CybergraphiX Funktion WritePixelArray() (Nicht zu verwechseln mit der OS 3.1-Funktion WritePixelArray8()) Kann man das sehr wohl in einen RastPort einbringen und anschließend Systemkonform damit umgehen.

---

Zitat:

---

Original von MaikG:
Trotzdem kann ich auf einer nicht angezeigten 24 Bit BitMap Text
schreiben und auch SetAPen verwenden. Das geht unter OS3-CGX, OS4
und UAE-P96.

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von kev:
Bei Verwendung eines "Friends" wird die Farbtabelle des Friends, resp. des Screens, übernommen. Daher Änderungen an der Bildschirmpalette führen auch zu Änderungen an der ColorMap der BitMap(s).

---

Zitat:

---

Original von Der_Wanderer:
Wie man eine Colormap anlegt bzw. an eine Bitmap anhägnt weiss ich nicht.

---

Zitat:

---

Allerdings geht das nicht unter OS3, es sei den AfAOS ist installiert. Aber selbst dann geht es nicht, weil es in Afa OS nur ein Hack ist und ohne Screen wird trotzdem schwarz gezeichnet.
Dazu müsste man den Picasso Treiber ändern. Vielleicht wird das ja aber bald gemacht ;-)

---

Selbst wenn es ein AfA mit angepassten P96 oder was auch immer gibt, mit dem das geht, ist das nicht mehr AOS3.x. Da iirc Maiks Wunsch war, ein AOS3.x ohne Erweiterungen zu unterstützen, fällt das dann raus.

Ansonsten würde ich, was das angeht, eher auf die Portierung der Portierung von Cairo nach Aros nach AOS3.x warten

mfg

--
Good coders do not comment. What was hard to write should be hard to read too.

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

c code:

---

/*
 *  bresenham.h
 *
 *  Grafikfunktionen zum Zeichnen von Linien und Keisen mit Hilfe des
 *  Bresenham Algorithmus.
 *
 *  Autor: Norman Walter
 *  Datum: 30.3.2008
 *
 */

#ifndef BRESENHAM_H
#define BRESENHAM_H

#include <exec/types.h>
#include <cybergraphx/cybergraphics.h>

#include <proto/exec.h>
#include <clib/cybergraphics_protos.h>

#define SGN(x) (x > 0) ? 1 : (x < 0) ? -1 : 0

/*
 *  struct raster_bitmap
 *
 *  In dieser Struktur sind die Parameter für das Bitmap zusammengefasst.
 *  Nachdem mit Hilfe der Funktion AllocRasterBitmap eine Instanz dieser Struktur
 *  erzeugt wurde, zeigt der Zeiger *data auf den Speicherbereich, in dem das
 *  eigentliche Bitmap mit der Größe size Byte liegt.
 *
 *  Die Funktionen ClearRaster, setpixel, rasterLine und rasterCircle schreiben
 *  ihre Daten in diesen Speicherbereich. Der Zeiger *date kann anschließend
 *  mit Hilfe der Funktion WritePixelArray8 aus der graphics.library in einen
 *  RastPort geschrieben werden.
 *
 */
struct raster_bitmap
{
  unsigned int width;   // Breite des Bitmaps
  unsigned int height;  // Höhe des Bitmaps
  UBYTE Depth;		// Farbtiefe in Bit
  ULONG PixFmt;		// Das Pixelformat (RGB, ARGB...)
  UBYTE BytesPerPixel;  // Bytes pro Pixel
  ULONG BytesPerRow;	// Bytes pro Zeile des Bitmaps
  UBYTE color;          // Aktuelle Pen Nummer
  UBYTE Alpha;		// Alpha der Zeichenfarbe
  UBYTE Red;		// Rotanteil der Zeichenfarbe
  UBYTE Green;		// Grünanteil der Zeichenfarbe
  UBYTE Blue;		// Blauanteil der Zeichenfarbe
  ULONG size;           // Größe des bitmapy in Byte
  UBYTE *data;          // Bilddaten des Bitmaps
};

/*
 *  AllocRaster
 *
 *  Legt eine raster_bitmap-Struktur an und initialisiert diese
 *
 *  Eingabe:	 unsigned int width  - Breite des Bitmaps in Pixel
 *           	 unsigned int height - Höhe des Bitmaps in Pixel
 *
 *  Rückgabe:    ein Zeiger auf eine raster_bitmap Struktur
 *
 */
struct raster_bitmap * AllocRasterBitmap(unsigned int width, unsigned int height, ULONG PixFmt);

/*
 *  FreeRasterBitmap
 *
 *  Gibt den Speicher einer raster_bitmap Struktur wieder frei.
 *
 *  Einganbe:	struct raster_bitmap *bm - Zeiger auf raster_bitmap Struktur
 *
 */
void FreeRasterBitmap(struct raster_bitmap *bm);

/*
 *  rasterLine
 *
 *  Zeichnet eine Linie von xstart, ystart nach xend, yend in der angegebenen
 *  raster_bitmap Struktur bm.
 *
 *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
 *		int xstart,ystart - Koordinaten des Anfangspunkts der Linie
 *              int xend, yend - Koordinaten des Endpunkts der Linie
 *
 */
void rasterLine(struct raster_bitmap *bm,int xstart,int ystart,int xend,int yend);

/*
 *  ClearRaster
 *
 *  Löscht den Inhalt des raster_bitmap bm mit der aktuellen Farbe.
 *
 *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
 *
 */
void ClearRaster(struct raster_bitmap *bm);

/*
 *  SetColor
 *
 *  Stellt die Zeichenfarbe des raster_bitmap für Zeichenoperationen ein.
 *
 *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
 *		UBYTE col - Pen Nr.
 *
 */
void SetColor(struct raster_bitmap *bm, UBYTE col);

void SetColorRGBA(struct raster_bitmap *bm, UBYTE r, UBYTE g, UBYTE b, UBYTE a);

/*
 *  setpixel
 *
 *  Setzt den Bildpunkt x,y in der Farbe des eingestellten Pens.
 *
 *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
 *		unsigned int x,y - Koordinaten des Bildpunkts
 *
 */
void setpixel(struct raster_bitmap *bm, unsigned int  x, unsigned int y);

/*
 *  rasterCircle
 *
 *  Zeichnet einen Kreis mit Radius radius um den Kreismittelpunkt x0,y0.
 *
 *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
 *		int y0,y0 - Koordinaten des Kreismittelpunks.
 *              int radius - Radius des Kreises
 *
 */
void rasterCircle(struct raster_bitmap *bm, int x0, int y0, int radius);

#endif

---

c code:

---

/*
 *  bresenham.c
 *
 *  Autor: Norman Walter
 *  Datum: 30.3.2008
 *
 */

#ifndef BRESENHAM_H
#include "bresenham.h"
#endif

struct raster_bitmap * AllocRasterBitmap(unsigned int width, unsigned int height, ULONG PixFmt)
{
   struct raster_bitmap *bm;

   bm = (struct raster_bitmap *)AllocVec(sizeof(struct raster_bitmap),NULL);

   bm->width = width;
   bm->height = height;
   bm->PixFmt = PixFmt;

   switch (PixFmt)
   {
	case PIXFMT_RGB24:
	case PIXFMT_BGR24:
		bm->Depth = 24;
		bm->BytesPerPixel = 3;
	break;

	case PIXFMT_ARGB32:
	case PIXFMT_BGRA32:
	case PIXFMT_RGBA32:
		bm->Depth = 32;
		bm->BytesPerPixel = 4;
	break;

	default:
		bm->Depth = 8;
		bm->BytesPerPixel = 1;		
   }

   bm->BytesPerRow = bm->width * bm->BytesPerPixel;
   bm->size = bm->BytesPerRow * bm->height;
   bm->color = 1;

   // RGBA-Komponenten für die Zeichenfarbe setzen
   bm->Alpha = 0xFF;
   bm->Red = 0xFF;
   bm->Green = 0xFF;
   bm->Blue = 0xFF;

   bm->data = (UBYTE *)AllocVec(bm->size, MEMF_CLEAR);

   return bm;
}

void FreeRasterBitmap(struct raster_bitmap *bm)
{
   FreeVec(bm->data);
   FreeVec(bm);
}

void ClearRaster(struct raster_bitmap *bm)
{
   ULONG x,y;
   
   for (x=0; x < bm->width; x++)
   {
	for (y=0; y < bm->height; y++)
	{
		setpixel(bm,x,y);
	}
   }

}

void SetColor(struct raster_bitmap *bm, UBYTE col)
{
    bm->color = col;
}

void SetColorRGBA(struct raster_bitmap *bm, UBYTE r, UBYTE g, UBYTE b, UBYTE a)
{
    bm->Red = r;
    bm->Green = g;
    bm->Blue = b;
    bm->Alpha = a;
}

void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
{
    ULONG pos = bm->width * y + x;

    if (x >= 0 && x < bm->width && y >= 0 && y < bm->height)
    {
	switch (bm->PixFmt)
	{
		case PIXFMT_RGB24:
			bm->data[pos] = bm->Red;
			bm->data[pos + 1] = bm->Green;
			bm->data[pos + 2] = bm->Blue;
		break;

		case PIXFMT_BGR24:
			bm->data[pos] = bm->Blue;
			bm->data[pos + 1] = bm->Green;
			bm->data[pos + 2] = bm->Red;
		break;

		case PIXFMT_RGBA32:
			bm->data[pos] = bm->Red;
			bm->data[pos + 1] = bm->Green;
			bm->data[pos + 2] = bm->Blue;
			bm->data[pos + 3] = bm->Alpha;
		break;

		case PIXFMT_ARGB32:
			bm->data[pos] = bm->Alpha;
			bm->data[pos + 1] = bm->Red;
			bm->data[pos + 2] = bm->Green;
			bm->data[pos + 3] = bm->Blue;
		break;

		case PIXFMT_BGRA32:
			bm->data[pos] = bm->Blue;
			bm->data[pos + 1] = bm->Green;
			bm->data[pos + 2] = bm->Red;
			bm->data[pos + 3] = bm->Alpha;
		break;

		default:
			bm->data[pos] = bm->color;
	}

    }
}

void rasterLine(struct raster_bitmap *bm,int xstart,int ystart,int xend,int yend)
{
   int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;
 
/* Entfernung in beiden Dimensionen berechnen */
   dx = xend - xstart;
   dy = yend - ystart;
 
/* Vorzeichen des Inkrements bestimmen */
   incx = SGN(dx);
   incy = SGN(dy);
   if(dx<0) dx = -dx;
   if(dy<0) dy = -dy;
 
/* feststellen, welche Entfernung größer ist */
   if (dx>dy)
   {
      /* x ist schnelle Richtung */
      pdx=incx; pdy=0;    /* pd. ist Parallelschritt */
      ddx=incx; ddy=incy; /* dd. ist Diagonalschritt */
      es =dy;   el =dx;   /* Fehlerschritte schnell, langsam */
   }
   else
   {
      /* y ist schnelle Richtung */
      pdx=0;    pdy=incy; /* pd. ist Parallelschritt */
      ddx=incx; ddy=incy; /* dd. ist Diagonalschritt */
      es =dx;   el =dy;   /* Fehlerschritte schnell, langsam */
   }
 
/* Initialisierungen vor Schleifenbeginn */
   x = xstart;
   y = ystart;
   err = el/2;
   setpixel(bm,x,y);
 
/* Pixel berechnen */
   for(t=0; t<el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
   {
      /* Aktualisierung Fehlerterm */
      err -= es; 
      if(err<0)
      {
          /* Fehlerterm wieder positiv (>=0) machen */
          err += el;
          /* Schritt in langsame Richtung, Diagonalschritt */
          x += ddx;
          y += ddy;
      }
      else
      {
          /* Schritt in schnelle Richtung, Parallelschritt */
          x += pdx;
          y += pdy;
      }

      setpixel(bm,x,y);
   }
} /* gbham() */

void rasterCircle(struct raster_bitmap *bm, int x0, int y0, int radius)
{
    int f = 1 - radius;
    int ddF_x = 0;
    int ddF_y = -2 * radius;
    int x = 0;
    int y = radius;
 
    setpixel(bm, x0, y0 + radius);
    setpixel(bm, x0, y0 - radius);
    setpixel(bm, x0 + radius, y0);
    setpixel(bm, x0 - radius, y0);
 
    while(x < y) 
    {
      if(f >= 0) 
      {
        y--;
        ddF_y += 2;
        f += ddF_y;
      }
      x++;
      ddF_x += 2;
      f += ddF_x + 1;
 
      setpixel(bm, x0 + x, y0 + y);
      setpixel(bm, x0 - x, y0 + y);
      setpixel(bm, x0 + x, y0 - y);
      setpixel(bm, x0 - x, y0 - y);
      setpixel(bm, x0 + y, y0 + x);
      setpixel(bm, x0 - y, y0 + x);
      setpixel(bm, x0 + y, y0 - x);
      setpixel(bm, x0 - y, y0 - x);
    }
}

---

[ - Answer - Quote - Direct link - ]

code:

---

void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
{
    ULONG pos = bm->width * y + x;
...

---

code:

---

void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
{
    ULONG pos = (bm->width * y + x) * bm->Depth/8;
...

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Ich müsste dann aber auch irgendwie die Bitmap flags eintragen,
weil ich muss das ja Blitten(vorschau).

---

Zitat:

---

Dann hab ich noch ein anderes Problem.
Ich hab jetzt ein paar farbreduzierungen geschrieben, um auch
eine vorschau auf AGA zu ermöglichen.
Nun bekomme ich die Workbenchtiefe nicht raus. 1-8 Bit geht aber
für alles darüber wird 8 Bit angegeben.
So kann ich nicht unterscheiden wann welche Funktion verwendet
werden muss.

---

Zitat:

---

Datatypes sind auch so eine Sache, wenn man 8 Bit oder weniger
hat muss die Palette ja dem Screen angepasst werden.
Kein Screen -> keine Farbneuberechnung.

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von MaikG:
Bissher scheint das 24 Bit drucken mit
meinen derzeitigen kenntnissen unter AGA nicht möglich.

---

Zitat:

---

Das Drucken von Graphik erlaubt nun die Angabe von RTG Bitmaps. Dabei werden
alle RTG Systeme untertützt, die das CyberGFX API cybergraphics.library
unerstützen. Wenn Die Applikation bislang die Druckausgabe nur mit einer
planaren Bitmap der graphics.library aufgebaut hat oder eine Bitmap eines
dieser RTG Systeme auf 12 oder 8 Bit Farbtiefe konvertiert hat, so kann sie
jetzt direkt die RTG Bitmaps ausgeben. Eine Colormap muß für eine High- (16 bit)
oder Truecolor (24 oder 32 Bit) Bitmap nicht angegeben werden.

---

Zitat:

---

Der neue Befehl PRD_DUMPRPORTTAGS erweitert den alten Befehl PRD_DUMPRPORT
um eine Tagliste. Derzeit sind 3 Tags definiert und implementiert:

DRPA_SouceHook: Der Wert für dieses Tags muß ein Pointer auf eine struct Hook
sein. Dieser Hook wird aufgerufen, um die Quelldaten zu lesen. Der Hook
erhält als object NULL und als message einen Zeiger auf struct DRPSourceMsg.
Diese Struktur enthält die Position und Größe des Arrays, das ausgelesen
werden soll, sowie einen Zeiger auf ein Feld von ULONGs, in die die Daten
geschrieben werden. Dieses Feld hat genau die Größe Breite*Höhe, wie sie
in der message stehen. Jedes Pixel wird als ein ULONG mit der Form
0x00RRGGBB eingetragen.

Typischerweise ist die Höhe für normalen Druck und die Breite für Querdruck
jeweils 1. Ein Programm kann für diesen Fall spezielle Optimierungen
verwenden, aber muß den allgemeinen Fall auch unterstützen.

Benutzt man das Tag DRPA_SourceHook so braucht weder ein RastPort noch eine
Colormap angegeben werden.

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von Der_Wanderer:
muss heissen:

code:

---

void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
{
    ULONG pos = (bm->width * y + x) * bm->Depth/8;
...

---

---

c code:

---

void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
{
    ULONG pos = (bm->width * y + x) * bm->BytesPerPixel;
...

---

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von MaikG:
ARGB-Arrays bekomme ich nur Zeilenweise hin, mehr als eine
Zeile endete immer in grafikmüll.

---

[ - Answer - Quote - Direct link - ]

c code:

---

...

struct raster_bitmap *bm24;

...

bm24 = AllocRasterBitmap(BMWIDTH,BMHEIGHT,PIXFMT_RGB24);

... Zeichenoperationen hier einfügen

WritePixelArray(bm24->data, 0, 0,
		bm24->BytesPerRow,
		win->RPort,
		win->BorderLeft,
		win->BorderTop,
		BMWIDTH,BMHEIGHT,
		RECTFMT_RGB);

---

[ - Answer - Quote - Direct link - ]

[ - Answer - Quote - Direct link - ]

Zitat:

---

Original von MaikG:
>Hier mal der Ausschnitt aus de, Code, wo das Pixel-Array in den
>RastPort des Fensters mittels WritePixelArray() eingefügt wird.


Ah, danke. Jetzt weiss ich was falsch war, ich hab PixelsPerRow
statt BytesPerRow angegeben.

---

c code:

---

switch (PixFmt)
   {
	case PIXFMT_RGB24:
	case PIXFMT_BGR24:
		bm->Depth = 24;
		bm->BytesPerPixel = 3;
	break;

	case PIXFMT_ARGB32:
	case PIXFMT_BGRA32:
	case PIXFMT_RGBA32:
		bm->Depth = 32;
		bm->BytesPerPixel = 4;
	break;

	default:
		bm->Depth = 8;
		bm->BytesPerPixel = 1;		
   }

---

c code:

---

bm->BytesPerRow = bm->width * bm->BytesPerPixel;

---

[ - Answer - Quote - Direct link - ]

code:

---

'$INCLUDE dos.bh
'$INCLUDE exec.bh
'$INCLUDE graphics.bh
'$INCLUDE intuition.bh
'$INCLUDE Printer.bc
'$INCLUDE utility.bh

LIBRARY OPEN "dos.library",37
LIBRARY OPEN "exec.library",37
LIBRARY OPEN "graphics.library",39
LIBRARY OPEN "intuition.library",37
LIBRARY OPEN "utility.library"

DEFINT a-z

REM $VARCHECKS

DIM SHARED temptag&(20)
DIM SHARED h&(Hook_sizeof%2)

DECLARE FUNCTION Readpixels&


FUNCTION Readpixels&(DRPMsg2&)
STATIC x&,y&, myWidht&, myHeight&, r&,buffer&
STATIC DRPMsg&
 PRINT "reached"
 DRPMsg&=PEEKL(DRPMsg2&)
 x&=PEEKL(DRPMsg&+DRP_x%)
 y&=PEEKL(DRPMsg&+DRP_y%)
 myWidht&=PEEKL(DRPMsg&+DRP_width%)
 myHeight&=PEEKL(DRPMsg&+DRP_height%)
 buffer&=PEEKL(DRPMsg&+DRP_buf%)
 r&=y&<<16
  FOR x&=0 TO myWidht&-1
   POKEL buffer&, (r& OR x&) ^&h00ffffff
  NEXT x&
Readpixels&=TRUE&
END FUNCTION



FUNCTION dumpRP%(BYVAL rp&, BYVAL cm&, BYVAL modeID&, x%,y%,x1%,y1%)
	STATIC pmp&, pio&, sigfr&, r%

	dumpRP% = -1

	pmp& = CreateMsgPort&()
		pio& = CreateIORequest&(pmp&, IODRPTagsReq_sizeof%)
			r% = OpenDevice&(SADD("printer.device" + CHR$(0)), 0, pio&, 0)
			IF r% = 0 THEN
				POKEW pio& + IODRPReqio_Command%, PRD_DUMPRPORTTAGS&
				POKEL pio& + io_RastPort%, NULL&
				POKEL pio& + io_ColorMap%, NULL&
				POKEL pio& + io_Modes%,    NULL&
				POKEW pio& + io_SrcX%, 0
				POKEW pio& + io_SrcY%, 0
				POKEW pio& + io_SrcWidth%, 256
				POKEW pio& + io_SrcHeight%, 256
				POKEL pio& + io_DestCols%, 256
				POKEL pio& + io_DestRows%, 256
				POKEW pio& + io_Special%, SPECIAL_MILROWS& OR SPECIAL_MILCOLS&
				POKEL pio& + io_Taglist%, VARPTR(temptag&(0))

				SendIO pio&

				sigfr& = xWait&((1& << PEEKB(pmp& + mp_SigBit)))

				IF sigfr& AND (1& << PEEKB(pmp& + mp_SigBit%)) THEN
					' printer is either ready or an error has occurred

					WHILE GetMsg&(pmp&)
					WEND
				END IF

				dumpRP% = PEEKB(pio& + IODRPReqio_Error%)

				CloseDevice pio&
			ELSE
				dumpRP% = r%
			END IF
			DeleteIORequest& pio&
			DeleteMsgPort pmp&
END FUNCTION



INITHOOK VARPTR(h&(0)), VARPTRS(Readpixels&)

TAGLIST VARPTR(temptag&(0)), _
 DRPA_SourceHook&, VARPTR(h&(0)) ,_
 DRPA_AspectX&, 1, _
 DRPA_AspectY&, 1, _
TAG_END&


junk&=dumpRP%(rp&, cm&, modeID&, x%,y%,x1%,y1%)

---

code:

---

' >=OS3.5 stuff
CONST PRD_RESETPREFS& = &hD&
CONST PRD_LOADPREFS&  = &hE&
CONST PRD_USEPREFS& =   &hF&
CONST PRD_SAVEPREFS&=&h10&
CONST PRD_READPREFS&=&h11&
CONST PRD_WRITEPREFS&=&h12&
CONST PRD_EDITPREFS&=&h13&
CONST PRD_SETERRHOOK&=&h14&
CONST PRD_DUMPRPORTTAGS&=&h15&


'IODRPTagsReq fields 
CONST io_Taglist% =62
CONST IODRPTagsReq_sizeof%=66


'DRPSourceMsg fields 
CONST DRP_x% = 0
CONST DRP_y% = 4
CONST DRP_width% = 8
CONST DRP_height% = 16
CONST DRP_buf% = 20
CONST DRPSourceMsg_sizeof%=78 'fill this buffer with 0x00RRGGBB pixels

CONST DRPA_Dummy&=&h80060000

CONST DRPA_ICCProfile&=&h80060001&
CONST DRPA_ICCName&=&h80060002&
CONST DRPA_NoColCorrect&=&h80060003&
CONST DRPA_SourceHook&=&h80060004& 
CONST DRPA_AspectX&=&h80060005& 
CONST DRPA_AspectY&=&h80060006&

---

[ - Answer - Quote - Direct link - ]