DCBITMAP [ERLEDIGT]

[Manfred]

Ich versuche mich gerade darin, ein Bild im JPG Format auf dem Bildschirm anzuzeigen. Beim Durchlesen bin ich auf DCBITMAP gestossen. Ich stelle aber gerade fest, dass ich irgendwie nicht verstehe, wie das denn nun ablaufen soll/muß.

Ich habe mir mal das Beispiel in der Doku angesehen, aber so richtig kapiere ich das nicht. Das Bild liegt als Datei vor und soll auch immer nur als Datei geladen werden.

Nun habe ich einen Dialog erzeugt, in den ich das Bild stellen möchte. Aber da passiert man gar nichts. Was ist denn außer einem Dialog als Parent, DCBITMAP noch weiter notwendig?

Hier mal mein Konstrukt. Ich denke mal, dass ist nicht korrekt?

Code: Alles auswählen

PROCEDURE routen()
          LOCAL cVersion := "15.04.2010"
          LOCAL getlist  := {}
          LOCAL GetOptions
          LOCAL nFensterBreite := 500
          LOCAL nFensterHoehe  := 500

          LOCAL oKarte  := NIL
          LOCAL oDialog := NIL

          MEMVAR oHauptDialog

          DCBITMAP "..\karte\map1.jpg";
         AUTOSCALE;
            OBJECT oKarte;
            PARENT oDialog
//------------------------------------------------------------------------------
          DCGETOPTIONS;
                BORDER XBPDLG_SIZEBORDER;
            HILITEGETS GRA_CLR_CYAN;
           NOMAXBUTTON;
           NOMINBUTTON;
                 PIXEL;
            SAYOPTIONS XBPSTATIC_TEXT_VCENTER+XBPSTATIC_TEXT_RIGHT;
          TOOLTIPCOLOR GRA_CLR_BLACK, GRA_CLR_YELLOW;
           WINDOWWIDTH nFensterBreite;
          WINDOWHEIGHT nFensterHoehe

          DCREAD GUI;
           APPWINDOW oHauptDialog:drawingArea;
                EVAL {|| zeigeBild(oKarte,oDialog)};
             OPTIONS GetOptions;
              PARENT @oDialog;
               TITLE "Routen " + cVersion
          RETURN
********************************************************************************
FUNCTION zeigeBild(oKarte,oDialog)
         DC_BitMapDraw(oDialog,oKarte,.T.)
         RETURN(.T.)

[Wolfgang Ciriack]

Hallo Manfred,
mit Bitmaps gibt es im Dialog immer ein paar Probleme.
Erzeuge am Besten ein Static, auf dem du das Bitmap plazierst, dann gibts später auch keine Probleme mit Repaint etc.

[AUGE_OHR]

Code: Alles auswählen

DCBITMAP "..\karte\map1.jpg";

hm ... wenn es "so" nicht geht würde ich ein Object oder Codeblock ausprobieren.

Code: Alles auswählen

bBitMap1 := {||'..\images\' + cBitMap1}
DCBITMAP bBitMap1 PARENT oPhoto1 AUTOSCALE CENTER ;
   TITLE 'BIT MAP (Photo 1)' ;
   HELPCODE '.'

[Manfred]

Boh ey,

ich werd' porös.

Ich habe das Unterverzeichnis falsch geschrieben. Anstatt zu meckern, kommt einfach nur kein Bild.

[Manfred]

Ich erweitere das hier nochmals...

Wenn ich das hier habe:

Code: Alles auswählen

PROCEDURE routen()
          LOCAL cVersion := "19.04.2010"
          LOCAL getlist  := {}
          LOCAL GetOptions
          LOCAL nFensterBreite  := 1024
          LOCAL nFensterHoehe   := 768
          LOCAL nStatusbarHoehe := 30

          LOCAL oDialog      := NIL
          LOCAL oHintergrund := NIL
          LOCAL oKarte       := NIL
          LOCAL oKoordinaten := NIL
          LOCAL oLeer        := NIL
          LOCAL oStatusBar   := NIL
          LOCAL oTExt        := NIL

          MEMVAR oHauptDialog

          nFensterBreite := oHauptDialog:clientSize[1]
          nFensterHoehe  := oHauptDialog:clientSize[2]

         @ 30,1 DCSTATIC;
                    EVAL {|o| o:setPointer(,XBPSTATIC_SYSICON_MOVE,XBPWINDOW_POINTERTYPE_SYSPOINTER),;
                         o:lbClick := {|aPos, uNil, self| test(aPos,oHintergrund,oKarte) },;
                         o:leave   := {|uNil1,uNil2,self| oText:SetCaption("") },;
                         o:motion  := {|aPos, uNil, self| oText:SetCaption(Alltrim(Str(aPos[1])) + "," + Alltrim(Str(aPos[2])) ) };
                         };
                  OBJECT oHintergrund;
                    SIZE DCGUI_PARENTWIDTH,DCGUI_PARENTHEIGHT-nStatusbarHoehe

          DCSTATUSBAR oStatusBar;
                ALIGN DCGUI_ALIGN_BOTTOM;
               HEIGHT nStatusbarHoehe

         @ 3,0 DCSTATIC;
                 OBJECT oKoordinaten;
                 PARENT oStatusBar;
                   SIZE 200,20;
                   TYPE XBPSTATIC_TYPE_RECESSEDBOX

         @ 2,2 DCSAY "unten";
              OBJECT oText;
              PARENT oKoordinaten;
                SIZE 100,20

         @ 3,0 DCSTATIC;
                 OBJECT oLeer;
                 PARENT oStatusBar;
                   SIZE 700,20;
                   TYPE XBPSTATIC_TYPE_RECESSEDBOX

          DCBITMAP "..\karten\map1.jpg";
         AUTOSCALE;
            OBJECT oKarte;
            PARENT oHintergrund
//------------------------------------------------------------------------------
          DCGETOPTIONS;
                BORDER XBPDLG_SIZEBORDER;
            HILITEGETS GRA_CLR_CYAN;
           NOMAXBUTTON;
           NOMINBUTTON;
                 PIXEL;
            SAYOPTIONS XBPSTATIC_TEXT_VCENTER+XBPSTATIC_TEXT_RIGHT;
            SCROLLBARS XBP_SCROLLBAR_VERT+XBP_SCROLLBAR_HORIZ;
          TOOLTIPCOLOR GRA_CLR_BLACK, GRA_CLR_YELLOW;
           WINDOWWIDTH nFensterBreite;
          WINDOWHEIGHT nFensterHoehe

          DCREAD GUI;
           APPWINDOW oHauptDialog:drawingArea;
                EVAL {|| zeigeBild(oKarte,oHintergrund)};
             OPTIONS GetOptions;
              PARENT @oDialog;
               TITLE "Routen " + cVersion
          RETURN
********************************************************************************
FUNCTION zeigeBild(oKarte,oHintergrund)
         DC_BitMapDraw(oHintergrund,oKarte,.T.)
         RETURN(.T.)
********************************************************************************
FUNCTION test(aPos,oHintergrund,oKarte)
         MEMVAR oMessage

         oHintergrund:setPointer(,XBPSTATIC_SYSICON_DEFAULT,XBPWINDOW_POINTERTYPE_SYSPOINTER)
         oMessage:anzeigen("Hier könnte jetzt ein Fenster zur Auswahl der HS ausgehen" + CRLF + ;
                           "Koordinaten " + Alltrim(Str(aPos[1])) + "," + Alltrim(Str(aPos[2]));
                          )
         oHintergrund:setPointer(,XBPSTATIC_SYSICON_MOVE,XBPWINDOW_POINTERTYPE_SYSPOINTER)
         RETURN(.T.)

und in der Funktion test im Debugger oKarte:ySize oder oKarte:ySize abfrage, dann steht da nur "0" drin. Kann ich darüber nicht die Größe des JPG abfragen? Ich möchte gerne haben, dass ich egal auf welchem PC usw. immer die gleiche und richtige Größe des Parent habe, damit die Koordinaten stimmen. Deshalb habe ich eine Stelle gesucht, um die Größe des JPG zu ermitteln. Das scheint aber nicht so zu klappen, wie ich es mir erhofft habe.

[Tom]

Hallo, Manfred.

Ich habe auch ein wenig damit herumgespielt, bekomme aber ebenfalls für oBitMap:xSize/ySize immer nur Nullen zurück. Jetzt müsste man mal ein "plain Xbase++"-Beispiel bauen, um zu testen, ob XbpBitmap in diesen iVars überhaupt etwas speichert.

[Tom]

Aha.

Ganz ohne Darstellerei:

Code: Alles auswählen

oBitMap := DC_GetBitmap(cMeineJpgDatei)
? oBitmap:xSize // und jetzt kommt auch was

[Manfred]

Hi Tom,

Danke für den Tipp. Diese Funktion habe ich einfach überlesen. Dabei habe ich ganz genau im Handbuch nachgesehen, bevor ich meine Frage hier reingestellt habe.
Wobei mir jetzt gerade auch eingefallen ist, dass ich ja mit den Massen eigentlich nur den Clientsize des Parent ermittele. Jetzt muß ich mir mal überlegen, wie ich die Maße des Parents daraus zusammenstricke, aus denen sich dann der Clientsize ergeben würde, in den ich das Bild lege.

[Tom]

Hallo, Manfred.

Damit das ganze noch stimmt, solltest Du relativ skalieren, und zwar auf beide Koordinaten bezogen. Wenn Du für die Bitmap z.B. eine Fläche von 300 x 200 Pixeln zur Verfügung hast, während das Bild aber 500 x 400 Pixel groß ist, musst Du das Bild so skalieren, dass sein Seitenverhältnis beibehalten wird. Die Fläche hat eines von 3 zu 2 (also 1,5 bezogen auf die Breite), während das Bild eines von 5 zu 4 (also 1,25 bezogen auf die Breite) hat. Da das Verhältnis in diesem Fall beim Bild kleiner ist, muss auf Basis der Höhe skaliert werden (400 Pixel auf 200, also geteilt durch zwei, bezogen auf die Breite ergibt 250 x 200). Wenn es beim Bild größer ist, muss bezogen auf die Breite skaliert werden (Breite des Bildes auf Breite der Fläche beziehen und Höhe mit diesem Faktor umrechnen). Eigentlich ganz simpel. Hauptsache, die Relationen stimmen (also das Seitenverhältnis des Bildes wird beibehalten). Den Skalierungsfaktor musst Du Dir merken, weil er später benötigt wird, um den Punkt auch im Original(bild) zuordnen zu können.

[Manfred]

brrrr..

ich dachte mir, ich habe ein Bild von z.B. 800x600. Diese Größe bleibt ja immer gleich, egal wie wo wann ich es darstelle. Daraus wollte ich dann berechnen, wie groß der Parent herum sein muß, damit das Bild genau da rein paßt. Wenn das Bild größer als der Clientsize vom Parent ist, dann sollen unten und rechts Scrollbalken erscheinen. Sowas hatte ich auch schon, zumindest mit Scrollbalken, aber dabei ist mir aufgefallen, das der rechte Scrollbalken aus dem Sichtfeld nahezu komplett verschwindet. Man kommt also mit der Maus nicht mehr dran.

Das wäre jetzt meine nächste Frage gewesen, wieso der rechts verschwindet. Dafür würde ich aber dann einen neuen anderen Thread eröffnen.

[Tom]

Dafür gibt's eine DCGET OPTION: SCROLLBARS.

Du baust ein Fenster auf, das so groß ist, wie Du es eben brauchst (Maximal: AppDeskTop():CurrentSize()). Diese Größe legst Du bei den DCGET OPTIONS fest. Dann platzierst Du in diesem Fenster ein Static-Objekt, das so groß wie das Bild ist, und eben möglicherweise sehr viel größer als das Fenster, und darauf platzierst Du das Bild. Die Option SCROLLBARS fügt dann automatisch Scrollbars ein, feddisch.

Aber wirklich schön ist das nicht. Schöner ist es, das Bild auf die Fenstergröße zu skalieren und die Bildpunkte entsprechend herunterzurechnen.

[Manfred]

Hi Tom,

nur damit Du nicht denkst, ich bin total unvorbereitet. Das mit den SCROLLBARS habe ich ja schon gemacht. Da kam eben oben genanntes Ergebnis bei raus.

Das andere, was Du da vorschlägst, kann ich nicht ganz nachvollziehen, bzw. ich bin mir noch nicht sicher in wie weit ich es überhaupt so anwenden kann.

Für mich ist erst mal wichtig, dass auf jedem Bildschirm die Pixelangaben, auf die der Mauszeiger gerade steht, gleich sind. Egal welche Auflösung der Bildschirm hat. Deshalb wäre es doch besser, ich würde immer ein festes Maß vorgeben, das überall gleich ist.

Allerdings habe ich ein paar Gedanken, die ich anfänglich hatte schon wieder überdacht und für den Papierkorb vorbereitet. Ich schätze einmal, dass ich erst mal das weitere Drumherum näher angehen muss um zu sehen, ob es überhaupt so klappt, wie ich es weiter vorhabe.

[Tom]

Hallo, Manfred.

Wenn das mit SCROLLBARS nicht klappt, hast Du irgendwas vermurkst.

Wenn Du eine maximale Bildschirmauflösung von X x Y hast, kannst Du die Karte wie von mir vorhin erklärt skalieren. Du musst dann nur alle Koordinaten mit dem gleichen Faktor umrechnen, dann stimmt wieder alles. Das gilt für ein- wie ausgehende Koordinaten, sollte doch aber kein Problem sein, weil Du ja nur einen Faktor hast, nämlich den Maßstab der Karte. Wenn Du sie mit 1,5 in beide Richtungen vergrößerst, damit sie in einer von beiden den Bildschirm füllt, musst Du nur die Koordinaten, die sich auf das Bild beziehen (!), immer mit diesem Faktor multiplizieren. That's it.

[Manfred]

Hm,

ich habe einfach nur ein

Code: Alles auswählen

SCROLLBARS XBP_SCROLLBAR_VERT+XBP_SCROLLBAR_HORIZ

in DCGETOPTIONS eingefügt. Mehr nicht. Auf 2 verschiedenen PC war das gleiche Ergebnis. Unten alles klar, rechts 3/4 verschwunden.

Aber das ist es ja mit Deinem Vorschlag, ich weiß nicht ob ich den so umsetzen kann. Ich muß mich erstmal noch schlau machen, wieviel da jetzt auf einmal angezeigt werden muß. Ich wollte zu Anfang nur wissen, ob meine Idee generell umsetzbar ist. Das scheint wohl der Fall zu sein.

Ich dachte mir es wird das JPG am Bildschirm angezeigt, es wandert ein Fadenkreuz darüber und beim Mausklick links, geht ein Fenster auf, in dem man dann den Meldepunkt aussucht und mit den Pixelangaben in Verbindung mit der jeweiligen Karte und der Größe speichert. Das sollte eine Garantie dafür sein, dass dieser Punkt egal auf welchem PC und mit welcher Auflösung immer im Zusammenhang mit dem JPG steht und an der richtigen Stelle angezeigt wird.

[Tom]

Hallo, Manfred.

Das habe ich schon so verstanden. Und da die Bildschirme und die Bilder nie gleich groß sind, musst Du das Bild entweder scrollen oder skalieren. Wenn Du letzteres tust, was ich empfehlen würde (denn mit Scrollbalken sieht man ja nur einen Bildausschnitt), musst Du Dir nur merken, wie Du skaliert hast, also um welchen Faktor das angezeigte Bild kleiner oder größer ist als das Original. Alle Positionsbestimmungen müssen dem dann einfach Rechnung tragen:

Das Bild ist im Orginal 1000 x 500, wird aber auf 600 x 400 angezeigt. Also wird es in beide Richtungen mit 0,6 skaliert (Bildverhältnis 2, Flächenverhältnis 1,5: die Breite ist entscheidend, 600/1000 = 0,6), ändert seine Größe auf 600 x 300. Wenn man in diesem Bild jetzt auf den Punkt 600 x 300 klickt, müssen die hier zurückgegebenen Koordinaten ({600,300}) jeweils nur durch den Faktor (0,6) geteilt werden. 600/0,6 = 1000, analog 300/0,6 = 500. Das kannst Du schon in der Anzeige der Mauskoordinaten tun, aber auch an allen anderen Punkten.

[Manfred]

Ja,

jetzt habe ich es auch verstanden, wie Du es meinst.

[Tom]

Das ganze hat allerdings einen - möglicherweise schwerwiegenden - Haken. Wenn Du ein Bild verkleinerst, bist Du nicht mehr pixelgenau, weil die Darstellung weniger Pixel hat als das Original. Dasselbe gilt für die Vergrößerung des Bildes, aber in weniger drastischer Weise. Wenn die Koordinaten also keine Toleranzen zulassen, kann es sein, dass eine Zuordnung nicht mehr möglich ist, weil Du durch die Umrechnung der Klick-Koordinaten bei Verkleinerung bestimmte Zielkoordinaten einfach nicht mehr erreichst. Um beim Beispiel zu bleiben:

Das Bild ist 1000 x 500 und skaliert auf 600 x 300. Ein Klick auf 600/300 liefert per Umrechnung 1000/500 zurück. Aber ein Klick auf 599/300 liefert 998,33/500 bzw. gerundet 998/500 zurück. Den Punkt 999/500 kannst Du jetzt nicht mehr ansteuern. Wenn kein System möglich ist, dass hier Toleranzen erlaubt, musst Du doch mit Scrollbalken arbeiten.

[Manfred]

Hm,

ich habe das mal eben probiert. Die Sache ist jetzt aber folgende:

Wie kriege ich denn raus, wie groß das JPG jetzt im Einsatz ist? Es hat ja in dem Parent ein anderes Maß, als es im Original hat.

Wen ich mit AUTOSCALE arbeite, dann wird das Seitenverhältnis wohl beibehalten, wenn ich es aber ohne mache, dann habe ich eine verschobene Anzeige.

[Manfred]

Oops,

Du warst schneller.

Wie genau die Punkte sein müssen, kann ich jetzt auch noch nicht sagen. Wie schon erwähnt, ich wollte erstmal sehen, was überhaupt machbar ist. Und dann was vernünftig ist.

[Tom]

Du musst das Static, auf dem das JPG platziert wird, verhältnismäßig richtig groß berechnen! Es muss also dem Seitenverhältnis entsprechen. Dann kannst Du auch mit AUTOSCALE arbeiten - der von Dir errechnete Verhältnisfaktor müsste weiterhin stimmen.

[Manfred]

MIT Autoscale klappt ja, dann habe ich zwar evtl. oben oder rechts einen Rand, aber das wäre erstmal nicht problematisch. OHNE Autoscale sieht es etwas verschroben aus.

[Tom]

OHNE Autoscale sieht es etwas verschroben aus.

Das darf eigentlich nicht so sein, wenn das Seitenverhältnis von Bild und "Parent" übereinstimmt.

[Manfred]

Autsch,

ich vergas. Das Programmfenster wird auf die gesamte Größe gemacht und der Bildparent wird in den kompletten parent:clientsize() gepackt. Da sind dann natürlich die Verhältnisse nicht so kirchlich. Da muß ich mir auch noch was zu einfallen lassen. Sind ja im Moment nur Tests um zu sehen, was wann und wo wie aussieht. Und weil ich irgendwie haben wollte, dass der Anwender eine Karte egal welchen Ausmaßes benutzen kann. So wollte ich evtl. die Möglichkeit des Zoomens geben, in dem einfach die Karten gewechselt werden mit anderer Auflösung. Es kann ja sein, dass auf einer anderen Karte die Punkte anders vergeben werden sollen, aber die Größe anders dargestellt sein muss, oder soll. Ob das jetzt auch alles sinnvoll ist, muss auch noch geklärt werden. das Teil wird ja zunächst in meinem geheimen Kämmerlein entworfen und erst später dem Anwender vorgeführt, ob er damit einverstanden ist. Wichtig ist zunächst: Ist meine Idee generell umsetzbar.

[Tom]

Da muß ich mir auch noch was zu einfallen lassen.

Pack auf Deinen "Bildparent" ein weiteres (meinetwegen transparentes) Static in der richtigen Größe bzw. mit den richtigen Seitenverhältnissen (also im Seitenverhältnis des BILDES, je nachdem etwas schmaler oder niedriger). Wenn Du darauf das Bild anzeigen lässt, ist alles tutti. Aber warum Du Dich mit Skalierungen befasst, um dann doch einfach automatisch irgendeine Größe zu nehmen, das musst Du mir bei Gelegenheit mal erklären.

[Manfred]

ich denke mal am 15.05. kann ich Dir was dazu sagen, oder zeigen. Im Moment ist das alles Neuland für mich und ich muß auch noch lernen, was zu tun und zu lassen ist.