Manipulationen des RSC-Files, Teil 4

In den drei ersten Folgen wurde gezeigt, wie man die langweiligen Dialoge etwas individueller gestalten kann. Es wurde demonstriert, wie aus einem RSC-File eine Unit wird, wie ein Bild in ein fertiges Menü eingeschleust werden kann und wie man Bewegung in Dialoge bringt. Auch diese Folge widmet sich dem gleichen Grundthema. Sie beantwortet die Frage, wie man einem RSC-Editor (K-Resource) eine x-beliebige Grafik untermogeln kann.

Hintergründe von Dialogen werden im allgemeinen zur besseren Unterscheidung der Einzelinformationen mit verschiedenen Füllmustern unterlegt. Die Anzahl der Muster ist aber beschränkt, so daß viele Programmierer die Anwendung eines RSC-Editors scheuen und sich eigene Dialoge per Programm zusammenstellen.

Warum sollte man sich aber damit abmühen, wenn doch mit diesem Editor ein komfortables Werkzeug zur Verfügung steht? Warum soll man Positionierungen von Objekten errechnen, die dann doch nie dort erscheinen, wo man es sich wünschte, wenn der Editor uns dies abnimmt?

Der Hintergrund ist die eine Seite meines Themas. Die zweite Seite sind die vielen Icons, die man wohl mit dem Icon-Editor (aber mühsam) erzeugen kann, die aber dann auch, eben wegen der meist mangelhaften Malfähigkeit, nicht befriedigen.

Wie wäre es denn mit einem schönen Bild von halber Schirmgröße, das Sie irgendwo auf Ihren Disketten versteckt haben, in dem sich einige Punkte als Bedien-Buttons anbieten, und das Sie gerne als Dialog einsetzen möchten?

Genau das ermöglicht Ihnen das Programm, das hier abgedruckt ist. Schauen Sie sich das Bild an. Es ist nicht sonderlich schön, demonstriert aber die Möglichkeiten. Um die kleinen Schriften sind dünne Rahmen zu erkennen. Es sind die hier bewußt sichtbar gelassenen Rahmen von I-Boxen. Alle 5 Schriften haben die Flagge Exit, Wählbar und Knopf, einer zusätzlich die Flagge Default. Doch soll nicht der zweite Schritt vor dem ersten gemacht werden.

Das Programm

Die Aufgabe des Programmes PicInRsc ist es

Diese Datei kann dann mit dem RSC-Editor weiterbearbeitet werden.

Die erzeugte Datei stellt ein Minimum dar. Auch der Ausgangsknopf kann weggelassen werde. Nur ist dann bei der Weiterverarbeitung unbedingt sofort ein EXIT-BUTTON einzufügen. Andernfalls können Sie den Test nicht verlassen.

Über den Kopf einer RSC-Datei brauche ich hier nichts zu wiederholen. Er ist in den 3 vorangegangenen Folgen und in anderen Aufsätzen dieser Zeitschrift hinreichend erläutert worden. Auch der Aufbau der Datei wurde bereits beschrieben.

Das Programm erzeugt

Ein wenig Rechenknobelei ist bei der Größenfestlegung der vier Objekte notwendig.

Bestimmend ist die Grafik, die ja per Maus ausgewählt wurde. Dieses Rechteck wird auf eine Breite gebracht, die durch 16 teilbar ist. Damit ergibt die Breite dividiert durch 8 eine gerade Zahl, wie sie der Bit-Block braucht.

Das umschließende Rechteck wird links, rechts und oben um ein Zeichenmaß größer gemacht. Unten werden 2 Zeichen angehängt, da noch Platz für den Ausgangsknopf bereitgehalten werden muß. Später, im Resource Construction Set, können Sie noch alles ändern.

Die Koordinaten und die Abmessungen werden nicht in Pixeln, sondern in Zeichengrößen angegeben. Das bedeutet: in x-Richtung steht eine 1 für jeweils 8 Pixel und in y-Richtung eine 1 für 16 Pixel (bei Farbmonitoren für 8? Prüfen Sie das bitte, falls Sie einen Colormonitor haben. Warum soll ich denn alles alleine machen?)

Falls Sie sich mal einen Hexdump von einem RSC-File machen (Tip: RSCMaker aus der ersten Folgen nehmen), werden Sie sich vielleicht über so eigenartige Werte wie z.B. 0706H wundern. Das Objekt ist nicht etwa 706H Bytes breit. Es ist 6*8 + 7 Pixel groß. Im Lowbyte stehen die ganzen Bytes, im Highbyte der Rest, der immer erscheint, wenn im RSC-Editor die Option Raster ausgeschaltet wird und die Abmessungen nicht durch die Zeichengrößen teilbar sind.

Bei einem Grafikobjekt stimmt das aber nicht für die Breite und Höhe. Sie finden dann an gleicher Stelle die Maße in Pixeln jeweils im Highbyte. Bei einem 80 Bits breiten Bild z.B. sehen Sie den sedezima-len Wert $5000(!) und nicht etwa $000A für 10 Bytes.

Würden wir das bereits im Programm berücksichtigen, würde der Compiler bei Bildern größer 256 Bits Breite aussteigen. Zahlen größer 100H lassen sich nun mal nicht in einem Byte unterbringen.

Schreiben Sie nun ein Minimalprogramm, das nur einen Dialog zeigen soll. Wie Sie sehen, sehen Sie nichts, zumindest nur einen leeren Dialog. War die ganze Mühe umsonst? Sicher nicht, sonst brauchten Sie dies alles nicht zu lesen.

Der RSC-Editor hat so seine Eigenheiten. Aber eine unserer Eigenheiten ist doch, daß wir uns davon nicht einschüchtern lassen.

Weiterverarbeitung mit dem RSC-Editor

Schauen wir doch einmal, was im Editor so vor sich geht. War Ihre Grafik, die ja als Bit-Muster dem Editor untergeschoben werden soll, maximal 100 * 224 Pixel groß, haben Sie und auch er keine Probleme. Auch Ihr Testprogramm wird Sie zufriedengestellt haben.

Versuchen Sie die kleine Grafik zu editieren. Rechts stehen die Abmessungen. Die Höhe in Pixeln, die Breite ist immer durch 16 teilbar, ganz gleich, was Sie auch eintippen (77 z.B. wird automatisch auf 80 = 5*16 erhöht). Sie können dem Objekt einen Namen geben und es auch mit dem Icon-Editor bearbeiten.

Bei größeren Grafiken verweigert uns der Pixel-Editor seine Künste. Wir müssen mit dem Bild ohne Weiterverarbeitung auskommen. Nicht einmal ein Name wird akzeptiert.

Beim Abspeichern gibt’s allerdings keine Probleme, wohl aber beim Wiedereinladen. Der Rahmen des Musters scheint sich aufgelöst zu haben. Ein Klick auf das Bild invertiert das Vaterobjekt. Ganz links, wieder in das Format "Rest im Highbyte, ganze Bytes im Lowbyte" gebracht, erscheint nach Suchen das Rechteck, das das Objekt Bitimage umspannen soll. Ein Klick in die untere rechte Ecke bringt den Rahmen wieder auf die ursprüngliche Größe. Diesen faulen Trick braucht man nur, wenn man weitere Objekte auf die Grafik legen will. Das benutzende Programm arbeitet einwandfrei!

Schauen Sie sich noch einmal die jetzt vom RSC geänderte Datei über den RSC-Maker an. Anstelle der Objektmaße in ganzen Bytes bzw. Wörtern hat er wieder, diesmal unsinnige, Größen ins Highbyte geschrieben.

Testen wollen wir auch

Damit der Frust beim Testprogramm nicht allzu lange anhält, müssen wir einen kleinen Trick anwenden. Im Listing 2 finden Sie die kleine Prozedur Korrektur, die einmal vor dem Aufruf der Dialogbox angesprungen werden muß. Sie stellt die ursprünglich vom Programm errechneten (und vom RSC veränderten) Maße des Objektes wieder her.

In einem Anwenderprogramm werden Objektabmessung und Lage in Pixeln und nicht mehr in Bytes oder Worten angegeben. Die Größe des Objektes 1, unserer Grafik, muß geändert werden. Woher bekommen wir aber die Maße?

Aus dem Bit-Block, der zu einem Bit-Blockobjekt gehört wie z.B eine Tedinfo zu einem Textobjekt. ObjektSpec des Objektes zeigt auf diesen Bit-Block. Und dort steht die Breite in Bytes(!) und die Höhe in Pixeln. Aus den Bytes werden Pixel gemacht (*8) und beide Werte in das Objektrechteck kopiert. Das war’s.

Einen (allerdings trinkbaren) Wermutstropfen kann ich Ihnen nicht ersparen. Erinnern Sie sich bitte an die Aussage der ersten Folge, daß eine RSC-Datei maximal 32768 Bytes groß sein darf. Ursache für diese Beschränkung sind die in Wörtern abgelegten relativen Entfernungen innerhalb der Datei. Und ein Wort ist eben maximal Maxint groß.

Würden Sie den gesamten Bildschirm als Dialog benutzen, wären bereits 32000 Bytes für die Grafik aufgebraucht. Für weitere Dialoge und Menus wäre dann kaum noch Platz. Man würde hier wohl den Weg über ein eigenes Desktop gehen. Auch hier hilft uns ein wenig Überlegung:

Die vom Bit-Block beschriebene Grafik muß sich ja nicht innerhalb der RSC-Datei befinden. Der Adreßzeiger aus diesem Bit-Block ist Gott sei Dank 32 Bits breit und kann damit in den gesamten Atari-Speicher verweisen. Erzeugen Sie die Minimaldatei wie oben beschrieben. Legen Sie genau auf die Grafik eine I-Box und auf Ihre ausgewählten Positionen Bedienknöpfe, ebenfalls als I-Box mit unsichtbarem Rand. Bis hierher entspricht alles dem Normalverfahren. Nehmen Sie nun die Grafik, die ja als Objekt Nr. 1 geschaffen wurde, unter die Maus und werfen Sie sie in den Mülleimer.

Aber dann nützt das ganze Verfahren ja nichts, werden Sie vielleicht jetzt denken. Gemach, gemach! In der zweiten Folge hatte ich gezeigt, wie Bit-Muster in fertige Dialoge und Menüs eingebunden werden können. Schauen Sie sich das Programm RscPict noch einmal an. In dem hier beschrieben Fall haben Sie es noch viel einfacher. (Das weggeworfene Bild existiert ja hoffentlich noch). Sie ersparen sich die umständliche Berechnung der Objektgröße. Die I-Box, die dann durch die Grafik wieder ersetzt werden soll, hat ja genau die Größe wie eben die Grafik. Alle unsichtbaren Bedienknöpfe liegen auch über den ausgewählten Flächen.

Besitzer von Farbmonitoren haben es etwas schwerer. Setzen Sie das beschriebene Programm auf einem monochromen Schirm ein. Die Höhe des aufzuziehenden Rahmens darf höchstens etwas kleiner als die halbe Bildschirmhöhe sein. Beantworten Sie die Eingangsfrage nach der Zielauflösung mit Low. Im RSC, sofern noch der S/W-Schirm benutzt wird, erscheint die Grafik halb so hoch wie die Box. Testen Sie mit der Option Kompatibilität, ob der dann beim Anklicken der Grafik erscheinende dünne Rahmen sich innerhalb der umschließenden Box befindet. Bei Einsatz des RSC auf einem Farbschirm paßt die Grafik in diese Box.

In der niedrigen Auflösung stimmen die Proportionen des Dialogbildes mit denen des Bildes auf dem hochauflösenden Schirm überein. In der mittleren ist das Bild nach unten verzerrt. Probieren Sie mit den Werten um chH, ob Sie diesen Schönheitsfehler nicht beseitigen können.

Damit will ich meine Ratschläge beenden. Ihr nächstes Programm wird sicherlich eifrig vom GEM Gebrauch machen, künstlerische Dialoge zeigen und auf das externe RSC-File ganz verzichten.

Literatur:

[1] Handbuch Maxon-Pascal
[2] Handbuch Megamax Modula 2, ASH
[3] Aumilter, Luda, Möllmann: GEM-Programmierung in C, Verlag Markt & Technik [4] Diverse Artikel in ST-Computer
[5] ST-Computer Extra Nr 2, Einführung in das Resource Construction Set


(**************************************************** * * * Listing 1 * * * * Bilder aufbereiten für den RSC-Editor * * * * in Maxon-Pascal * * * * B.Volkmer (c) 1992 MAXON Computer * * * * Hinweis : Nur die RSC-Editoren, die auf dem * * K-Resourceeditor aufbauen, verarbeiten das * * Ergebnis dieses Programmes. Dazu gehört auch * * NRSC, wie er dem Megamax Modula beiliegt. * * Die DRI-Editoren verabschieden sich unflätig, * * obwohl sie bei der Bearbeitung so tun, als * * kapierten sie die Bitmenge. * * Das Bild muß (!!) mit einem hochauflösenden * * Monitor, also monochrom, erstellt werden. * * * ****************************************************) Program PicInRSC; Uses DOS, AES, VDI, GEM, GrafBase; CONST BildGroesse = 32000; TYPE MaxArray = ARRAY[0..32000] OF INTEGER; PicPointer = ^MaxArray; RSHDR = RECORD (* Namen nach Atari-Profibuch *) rshVrsn : INTEGER; (* Versionsnummer *) rshObject : INTEGER; (* ^ auf 1. Object *) rshTedinfo : INTEGER; (* ^ auf 1. TEDInfo *) rshIconblk : INTEGER; (* ^ auf 1. IconBlock*) rshBitblk : INTEGER; (* ^ auf 1. BitBlock *) rshFrstr : INTEGER; (* ^ auf fr. Strings *) rshString : INTEGER; (* ^ auf Strings *) rshImdata : INTEGER; (* ^ auf Images *) rshFrimg : INTEGER; (* ^ auf fr. Images *) rshTrindex : INTEGER; (* ^ auf Baumadressen*) rshnObs : INTEGER; (* Anzahl Objekte *) rshnTree : INTEGER; (* Anzahl Bäume *) rshnTed : INTEGER; (* Anzahl TEDs *) rshnIb : INTEGER; (* Anzahl Icons *) rshnBb : INTEGER; (* Anzahl Bitimages *) rshnString : INTEGER; (* Anzahl fr. Strings*) rshnImages : INTEGER; (* Anzahl fr. Images *) rshRssize : INTEGER; (* Länge RSC-File *) END; PRSHDR = ^RSHDR; VAR handle : INTEGER; ScrAdr : POINTER; inPfad,inFile, UrPfad, egal, inName, outPfad, outFile, outName : String[60]; fhandle,f : File; rahmen : Rectangle; SScreen, SPuffer : PtrMemFormDef;(* ^auf MFD*) Screen, Puffer : MemFormDef; (* MFD *) rscspace, PiPoi : PicPointer; Header : PRSHDR; PObj : PtrObjTree; (*TreePointer*) Obj : Object; PBit : PtrBitBlock;(*BitPointer *) Bit : BitBlock; neededSpace, gelesen : INTEGER; TreeP : ^POINTER; chW,chH,rezol : INTEGER; but, du : INTEGER; abbruch, ok : BOOLEAN; (**************************************************** * Bild wird eingelesen. Es sollte im Screenformat * * 32000 Bytes lang vorliegen * ****************************************************) PROCEDURE BildLaden; BEGIN inPfad := '\*.*'; inFile := #0; SelectFile(inPfad,inFile,ok); (* FileSelector *) IF ok THEN BEGIN HideCursor(handle); ClearWorkstation(handle); FSplit(inPfad,UrPfad,egal,egal); InName := UrFfad + inFile; (*$I-*) RESET(fhandle,inName); (*$I+*) IF IOResult = 0 THEN BEGIN BlockRead(fhandle,ScrAdr^,BildGroesse,gelesen); Close(fhandle); END; ShowCursor(handle,TRUE); END; END (* BildLaden *); (**************************************************** * gewünschten Ausschnitt mit der Maus aufziehen * * Mindestgröße 16 * 8 Pixel oder wie Sie wollen * ****************************************************) FUNCTION MausEcke(VAR eck : Rectangle):BOOLEAN; VAR buttons : MButtonSet; keys : SpecialKeySet; punkt : Point; ends : BOOLEAN; eckl : Rectangle; BEGIN REPEAT GrafMouse (pointHand, NIL); REPEAT MouseKeyState(punkt,buttons,keys); UNTIL ((msBut1 IN buttons) OR (msBut2 IN buttons)); GrafMouse(arrow,NIL); IF msBut1 IN buttons THEN BEGIN GrafMouse(thinCross,NIL); Rect(punkt.x, punkt.y,16,8,eckl); RubberBox(eckl,eck); GrafMouse( arrow,NIL); ends := TRUE END ELSE ends : = FALSE; UNTIL (eck.w >=32) & (eck.h >= 16); MausEcke := ends; END (* MausEcke *); (**************************************************** * Erzeugen des RSC-Files im Buffer * * Space-Angaben für den RSC-Editor nicht in * * Pixeln, sondern : * * LowByte : X DIV 8; y DIV 16 (oder 8 in * * den niedrigen Auflösungen) * * HighByte: Rest in Einzelpixeln * * Bei Grafiken w und h als Pixel im Highbyte * ****************************************************) PROCEDURE RscBereiten (ra : Rectangle); VAR PicSize : INTEGER; destRahm : Rectangle; HeadLength : INTEGER; BEGIN GetPhysMemForm(Screen); (* MFDB Screen *) (* für CopyOpaque vorbereiten *) GetMem(SScreen,SizeOf(MemFormDef)); (*Schirm *) GetMem(SPuffer, SizeOf(MemFormDef)); (* Ziel *) SScreen^:= Screen; WITH ra DO BEGIN w := (w DIV 16) * 16; PicSize := (w DIV 8) * h; (* Bytes * Höhe*) END; neededSpace (* wie groß wird das RSC-File?*) := SizeOf(RSHDR) (* Header *) + LONGINT(PicSize) (* Bildbytes *) + LONGINT(SizeOf(BitBlock)) (*+1 BitBlock *) + LONGINT(SizeOf(Object)*4) (*+4 Objekte *) + LONGINT(4); (* + Adresse Baum *) GetMemfrscspace, neededSpace);(*Platz anford. *) HeadLength := SizeOf(RSHDR); (* Headerlänge=36*) Header := POINTER(rscspace); (*Header vorn*) WITH Header^ DO BEGIN rshVrsn := 1; (* oder was so einfällt *) (* zwischen dem Header und dem 1. Baum stehen die Bilddaten und der BitBlock *) rshObject := HeadLength + PicSize + SizeOf(BitBlock); rshTedinfo := rshObject; (* keine Textinfo *) rshIconblk := rshObject; (* keine Iconinfo, *) rshBitblk := HeadLength + PicSize; (* ^ auf BitBlocklnfo *) rshFrstr := rshBitblk; (* erden *) rshString := HeadLength; (* keine fr. Str. *) rshImdata := HeadLength; (* auf Bitmuster *) rshFrimg := rshObject; (* erden *) (*-----------*) rshnObs := 4; (* 4 Objekte:1 Rahmen, 1 IBox *) (* 1 Bild, 1 Ausgang *) rshnTree := 1; (* 1 Baum *) rshnTed := 0; (* kein TEds *) rshnIb := 0; rshnBb := 1; (* 1 Bitblock, na klar*) rshnString:= 0; rshnImages:= 0; rshRssize := neededSpace; rshTrindex:= rshRssize - 4; (* Baumtabelle *) END; (* Danach folgen die Bilddaten *) PiPoi := POINTER(LONGINT(rscspace) + LONGINT(Header^.rshImdata)); WITH SPuffer^ DO BEGIN (* Puffer der Bildwerte *) start := PiPoi; (* darauf zeigt MemFormDef *) w := ra.w; (* des Zielpuffers *) h := ra.h; words := ra.w DIV 16; standardForm := 1; planes := 1; (* nur monochrom *) END; (* und Bildausschnitt hinein *) destRahm := ra; WITH destRahm DO BEGIN x := 0; y := 0; END; (* Rahmen ra vom Screen in Puffer SPuffer, oben links *) HideCursor(handle); (* ohne Maus kopieren *) CopyOpaque(handle,SScreen,SPuffer, ra,destRahm,onlyS); ShowCursor(handle,TRUE); (* Platz des Bitblocks beschreiben *) PBit := POINTER(LONGINT(rscspace) + LONGINT(Header^.rshBitblk)); WITH PBit^ DO BEGIN data := POINTER(LONGINT(Header^.rshImdata)); (* Adr. Bitmuster *) x := 0; y :=0; (* Lage Bild zum Rahmen *) h := ra.h; (* Hoehe in Pixel *) bytes := ra.w DIV 8; (* gerade Zahl *) color := $0071; END; (* die Objekte stehen hinter dem Bitblock *) PObj:=POINTER(LONGINT(rscspace) + LONGINT(Header^.rshObject)); WITH PObj^[0] DO BEGIN (*erstes Objekt beschreiben*) next := NoObject; (* -1, 1. Objekt *) head := 1; tail := 3; typ := 20; (* eine BOX *) state := [outLineObj]; (* outlined *) flags := []; (* keine Flags *) WITH spec DO BEGIN lettThick := 2; (* Rahmen innen *) color := $1180; (* Farbe ja, Replace *) END; WITH space DO BEGIN x := 0; y := 0; w := ra.w DIV cHW + 4; h := ra.h DIV chH + 5 +(ra.h MOD chH) * 256; END; END; WITH PObj^[1] DO BEGIN (* das zweite Objekt *) (* ist nur eine IBOX *) next := 3; (* Nr 3 ist Schwester*) tail := 2; head := 2; (* Nr 2 ist 1 Sohn *) typ := 25; (* IBox *) flags := []; state := []; (* nichts vorgewählt *) spec.lettThick := -1; spec.color := $1100; WITH space DO BEGIN x := 1; y := 1; w := ra.w DIV cHW + 2; h := ra.h DIV chH + 2 + (ra.h MOD chH) * 256; END; END; WITH PObj^[2] DO BEGIN (* das dritte Objekt *) (* ist nur ein Bitmuster ohne Rahmen *) next := 1; (* Nr1 ist Vater *) tail := NoObject; (* kein Nachfolger *) head := NoObject; typ := 23; (* = BitImage *) flags := []; state := []; (* nichts vorgewählt *) spec.more:=POINTER(LONGINT(Header^.rshBitblk)); (* ^ auf den BitBlock *) WITH space DO BEGIN x := 1; y := 1; w := ra.w DIV cHW; h := ra.h DIV cHH + (ra.h MOD chH) * 256; END; END; (* Das Folgeobjekt kann weggelassen werden. Dann: tail[0] := 1; next[1] := 0; flags[2] := [lastObjFlg]; rshnObs := 3; für neededSpace 4 durch 3 ersetzen Im Editor sofort einen Ausgangsbutton hinzufügen ! *) WITH PObj^[3] DO BEGIN (* das Ausstiegsobjekt*) next := 0; (* zum Pappi zeigen *) tail := NoObject; head := NoObject; typ := 27; (* Typ BOXCHAR *) state:= []; flags:= [selectFlg,defaultFlg,selectExitFlg,lastObjFlg]; WITH spec DO BEGIN lettThick := $4102; (* 'A'+Rahmen innen *) color := $1191; (* Farbe ja, Replace*) END; WITH space DO BEGIN w := 4; h := 2; x := (ra.w - w) DIV 2 DIV chW; y := (ra.h + 3 * chH) DIV chH; END; END; (* die Adressleiste fur die Baume füllen *) TreeP := POINTER(LONGINT(rscspace) + LONGINT(Header^.rshRssize - 4)); TreeP^ := POINTER(LONGINT(Header^.rshObject)); END (*RscBereiten*); (**************************************************** * und Ergebnis von RscBereiten abspeichern. Der * * RSC-Editor tritt nun in Aktion. * ****************************************************) PROCEDURE Speichern; BEGIN outPfad := 'F:\*.RSC'; outFile := #0; SelectFile(outPfad,outFile,ok); (*FileSelektor*) IF ok THEN BEGIN FSplit(outPfad,UrPfad,egal,egal); (*Pfad isol.*) outName := UrPfad + outFile; (*$I-*) ReWrite(f,outName); (*$I+*) IF IoResult = 0 THEN BEGIN BlockWrite(f,rscspace^,neededSpace); Close(f); END; END; (* wenn ok *) END (*Speichern*); BEGIN (********** Hauptprogramm***************) InitGem(RC,handle,ok); IF ok THEN BEGIN IF ~AES.GemError THEN BEGIN GetScreen(ScrAdr,ScrAdr,rezol); (* Schirmadr.*) IF rezol < 2 THEN FormAlert(1,'[1][Läuft nicht|auf Farbmonitor][sorry]',but) ELSE BEGIN FormAlert(1,'[2][ Zielauflösung ][ Hoch |Med,Low]',but); IF but = 1 THEN chH := 16 ELSE chH := 8; cHW := 8; REPEAT FormAlert(1,'[1][Bild mit FSel.Box|laden ][Ja]',but); BildLaden; FormAlert(1,'[1][Rahmen mit Maus|aufziehen ] [ja]',but); IF MausEcke(rahmen) THEN BEGIN RscBereiten(rahmen); FormAlert(1,'[1][RSC mit FSel.Box|abspeichern][Ja]',but); Speichern; END; FormAlert(1,'[2][Noch ein Durchgang][Nein! Ja ]',but); abbruch := but = 1; UNTIL abbruch; END; (* wenn HiRes *) END; (* wenn kein GEMError *) ExitGem(handle); END; (* wenn Init ok *) END (* PicInRSC*).

(**************************************************** * * * Listing 2 * * * * Rudiment eines kleinen Testprogrammes * * für das Ergebnis des Programmes * * PicInRSC. * * Nur wegen der Korrekturprozedur wichtig * * * ****************************************************) PROGRAM TestRscPict; (* hier die notwendigen Units einbinden *) (* auf die Prozedur Korrigieren kommt es an *) (* baum ist vom Typ PtrObjTree, pbb vom Typ PtrBitBlock, kwb und kwh sind INTEGERS *) PROCEDURE Korrigieren; BEGIN (* Bitblock ist Objekt Nr 2 im Beipielbaum *) pbb := baum^[2].spec.more; (* ^ auf BitBlock *) kwb := pbb^.bytes; (* die Imagebreite *) (* in Bytes *) baum^[2].space.w := kwb * 8; (* in Pixel an.. *) (* .. Objekt *) kwh := pbb^.h; (* die Imagehöhe.. *) baum^[2].space.h := kwh; (* ..an Objekt *) END (* Korrigieren *); BEGIN (* Hauptteil, alles wie gehabt *) (* hier die übliche Einleitung *) LoadResource('*\ABILD.RSC'); IF NOT AES.GemError THEN BEGIN baum := ResourceAddr(treeRsrc,0); Korrigieren; (* wichtig ! *) (* darstellen und GEM Beenden *) END (* TestRscPict *).

Bruno Volkmer
Links

Copyright-Bestimmungen: siehe Über diese Seite