Bild-Viewer Probleme

*Hey*, ein Viewer als Komponente, . @DerAltenburger, das ist ein herrliches Lehrstückchen mit der totalen Kommentierung. Leider sind ja bei der Standard keine Komponentensourcen dabei. Wird also noch ziemlich dauern, bis ich sowas schreiben kann. Interessieren würde mich die komplette Kompo also im doppelten Sinne brennend. Kannst du sie nicht auf mehrere Beiträge verteilt posten? Das wär *supi*. Falls es nicht geht, will ich dich aber auch nicht ungebeten mit einer Mail bombardieren. Es sei denn, dein Angebot wäre universell gemeint gewesen. Ansonsten wäre da noch mein Briefkasten Omega-X@t-online.de. :p Wär dann halt schade für das Bord. Denn gute Lehrbeispiele sind immer was ganz besonderes.

<edit>Kein Viewer sondern ein Gitter- und Koordinaten-Image auf Basis von TGraphicControl hab ich mal versucht, zu universalisieren. Darin war ja sogar
Koord->Canvas verborgen. Kein Picture, Stretch oder sonstige wichtige Methoden. Nicht kompatibel gegen TImage austauschbar. Total verschachtelter Code und völlig unkommentiert. Und sowas als Buchbeispiel (C++ Builder 3 im Team, C&L). Also sehr ungünstige Karten, ich mußte erst mal aufgeben. Gereizt hätte es mich aber wegen der Skalierung. Also erst noch lernen, dann ein weiterer Versuch.

DerAltenburger

Omega-X,

Haste die Klasse 'mal getestet (dynamisch in 'ner Form erzeugt und Positioniert?
Musste das Teil nur in zwei Dateien kopieren und zu Projekt hinzufuegen(als unit).

Wenn nicht , sollteste das 'mal tun, dann seh'n wir weiter. :p

Haette im Notfall auch ein Demo Prog zum Testen.

Von Kompo abgeleitete Klasse mit primitiver Malfunktion (nur ein ANSATZ zur Maussteuerung und Auswertung) hammer dann auch noch.

Was meinst Du mit: keine Komponentensourcen bei Standard dabei?
Ich nehm' den alten BCB4.0, der hat aber genug davon (bloss nie die, die ich brauche- drum selbermachen.

Die kpl. Orignalkompo waer' hier etwas zu gross und komplex(3000 Zeilen, mehrere Kompos, ohne Kommentare!)

Weis auch nicht mehr richtig, wie's funktioniert (ist vor Jahren gebastelt)

[ Dieser Beitrag wurde am 24.02.2003 um 20:30 Uhr von DerAltenburger editiert. ]

So kann das wohl noch nicht funktionieren. Die Unit hat keine Form. Neue Formen gibt's nur mit Unit. Parallel läuft der Source. In der Form-Unit klappt es aber nicht.

Hab probeweise ein TImage in eine Scrollbox abgelegt und einen FileName aufgerufen. Aber ich kann den Code nicht ansprechen. Ich brauch ja eine Form als Ansprechpartner. Oder eben die Register-Klasse dazusetzen und die Unit als Host der neuen Kompo nutzen.

FImage->Height=Dimension->ImageHeight * float(Fac) / float(Quot);

versteh ich vom Sinn her nicht. Ich käme nit Fac aus.
0.5, 1, 2, 3, = 50%, 100%, 200%, 300%. Was Quot regelt, ist mir nicht klar.

Wie das mit der Skalierung geht, konnte ich nicht rauslesen. Toll... aber auch schade, daß das Paket so umfangreich ist.

Keine KompoSourcen bei der Standard dabei meint. beim BCB3 sind in der Standard-Version keine Sourcen dabei. Mit den .hpp's allein seh ich die Geheimnisse des Komponentenbaus nicht.

DerAltenburger

Ok, Ok

Musst ein normales Projekt öffnen (neu mit Form!)

Die Unit der neuen Klasse (Kompo?) muss dazugefuegt werden.

Die beiden Dateien vom letzten Tip in gleichem Ordner!!!
ImageScrollBox.h und ImageScrollBox.cpp

In Constructor der Hauptform erzeugste die Kompo dynamisch,
im Destructor deleten nicht vergessen.

in Form noch'n paar Steuerelemente, voila

Kann nur Anzeigen, noch nicht malen.

Hier der Code Des Testprogrammes (Code von Form1, kann einfach Original von BCB ersetzen). Die Form- Unit heist: ISBTestForm.h bzw. ISBTestForm.cpp

Wenn's nicht klappt, melde Dich, dann Mail ich das Project
(!!! Ich hab' den CBuilder 4.0), das kann Ärger machen?)

HEADER fuer Testprogramm- Form
//---------------------------------------------------------------------------
#ifndef ISBTestFormH
#define ISBTestFormH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>

#include "ImageScrollBox.h"
#include <Dialogs.hpp>
#include <ExtDlgs.hpp>
//---------------------------------------------------------------------------
//Test- Programm- Form mit:
//  UpDown- Objekt zum Zoomen
//  Label fuer Zoom- Anzeige
//  BildOeffnenDialog
//  Load- Button
//  Quit- Button
//  ImageScroller- Komponente!!!
class TForm1 : public TForm
{
__published:    // Von der IDE verwaltete Komponenten
        TUpDown *UD;
        TLabel *ZF;
        TOpenPictureDialog *OPDlg;
        TButton *Load;
        TButton *Quit;
        void __fastcall UDClick(TObject *Sender, TUDBtnType Button);
        void __fastcall QuitClick(TObject *Sender);
        void __fastcall LoadClick(TObject *Sender);
        void __fastcall FormActivate(TObject *Sender);
private:    // Anwenderdeklarationen
        TImageScroller *ISB;
public:     // Anwenderdeklarationen
        __fastcall TForm1(TComponent* Owner);
        __fastcall ~TForm1();
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
HEADER fuer Testprogramm- Form ENDE

UNIT fuer Testprogramm- Form
//---------------------------------------------------------------------------
#include <vcl.h>
#include <jpeg.hpp>
#pragma hdrstop
#include "ISBTestForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{ ISB=new TImageScroller(this);              //ImageScrollbox erzeugen
  ISB->Parent=this;                          //sonst keine Anzeige!!!
  ISB->Left=10;                              //Position und Abmessung
  ISB->Top=16;                               //einstellen
  ISB->Width=400;                            //weil's keine Kompo
  ISB->Height=300;                           //in IDE ist!
  ISB->Anchors<<akLeft<<akBottom<<akRight<<akTop;
}
//---------------------------------------------------------------------------
__fastcall TForm1::~TForm1()
{ delete ISB;                                //ImageScrollBox freigeben
}
//---------------------------------------------------------------------------
//UpDow zum Zoomen betaetigt
void __fastcall TForm1::UDClick(TObject *Sender, TUDBtnType Button)
{ ZF->Caption=UD->Position;                  //Zoom- Wert anzeigen
  ISB->Zoom(UD->Position,100);               //Bild Zoomen in Scrollbox
}
//---------------------------------------------------------------------------
//Quit- Button gedrueckt
void __fastcall TForm1::QuitClick(TObject *Sender)
{ Close();
}
//---------------------------------------------------------------------------
//Load- Button gedrueckt
void __fastcall TForm1::LoadClick(TObject *Sender)
{ if (OPDlg->Execute()==mrOk)                //Datei auswaehlen
  { ISB->LoadFromFile(OPDlg->FileName);      //Datei in Anzeige- Scrollbox laden
    UD->Position=ISB->Dimension->ImageZoom * 100;
    ZF->Caption=UD->Position;                //Zoomwert in UpDown und Label stellen
  }
}
//---------------------------------------------------------------------------
//Beim Aktivieren gleich 'n Bild laden!
void __fastcall TForm1::FormActivate(TObject *Sender)
{ Form1->LoadClick(Sender);
}
//---------------------------------------------------------------------------
UNIT fuer Testprogramm- Form ENDE

[ Dieser Beitrag wurde am 25.02.2003 um 12:39 Uhr von DerAltenburger editiert. ]

Jetzt wird mir einiges klar:

ISB->Zoom(UD->Position,100);

Ab BCB4 gibt es also einen TImageScroller mit integrierter Scroll- und Zoom-Function. Also braucht niemand mehr rausfinden, wie man das codet. Ich hab die Klasse nicht, also knobel ich am Algor rum.

Vielleicht geht es sinnvoll gar nicht im TImage? Die internen Methoden sind dafür nicht ausgelegt? Hab bisher noch keine geeignete Kompo entdeckt. Ich müßte sie also bauen, um weiterkommen zu können. Pg, daß ich den relevanten Code nicht kenne. Das liegt doch noch außerhalb der Erfahrung.

Ich muß halt sehen, daß ich irgendwie weiterkomm. Wovon ist denn TImageScroller abgeleitet? TGraphicControl?

DerAltenburger

Ganz falsch!!!

Im BCB 4.0 gigt's keinen TImageScroller!

Die neueren BCB's sollen sowas haben, aber nicht bis 4.0 (die hab' ich)

Deshalb hab' ich ja so einen geprogt!
Das ist die UNIT fuer ImageScroller , die ich zuerst gepostet hab'!!!
Ist von TScrollBox abgeleitet, besser waere TCustomScrollBox) (Kuck mal in den Header!)

zu: ISB->Zoom(UD->Position,100);

ISB is' der ImageScroller aus der UNIT,
UD is' ein UpDown- Objekt vom BCB in der Form!

Daraus kann eine echte Komponente fuer die IDE gemacht werden, dann hat der BCB ein TImageScroller! :p

Die Unit kann aber auch so in jedes Programm aufgenommen werden!

Aus der UNIT / der Komponente kann mehr abgeleitet werden:

'TImageZoomScroller' mit Maus- Zoom- Bedienung (MouseMove anpassen) oder Rollradbedienung(recht umfangreich die Entwicklung!)

'TImageCutScroller' mit Ausschneidefunktion (viele Mausroutinen anzupassen)

'TImagePaintScroller' mit primitiven Malfunktionen (recht umstaendlich!)

Da kannste viel probieren und ableiten(vererben!!!)

[ Dieser Beitrag wurde am 25.02.2003 um 19:40 Uhr von DerAltenburger editiert. ]

Axo, langsam seh ich die Zusammenhänge. Die Zeile

ISB->Anchors<<akLeft<<akBottom<<akRight<<akTop;

hatte mich irritiert. Anchors ist keine Member. Bei Zoom hab ich dann schon gar nicht mehr geschaut. Ist aber Member von TImagsScroller.

Ole, soweit läuft es. Ohne Register-Class lassen sich Kompos viel besser aufbauen. Mangels Erfahrung wußte ich das nicht.

Die Anchors scheinen nützlich zu sein. Das Bild öffnet momentan Top/Left.

Dann such ich die Möglichkeit, Canvas-Handel reinzubringen. In der Hierarchie ist es nicht enthalten. Wenn ich TGraphicControl reinbringen könnte, wäre die benötigte Basis erst mal komplett. Multiple Basisklassen werden aber nicht unterstützt. Wie bring ich dann die Methoden rein?

DerAltenburger

Na, 's geht ja

Ohne RegisterClass kann man die 'Kompo' gt editieren/ testen (Ist ja keine Kompo, nur 'ne Klasse! Gut was?

Ein Canvas->Handle brauchste net, is schon da!

TImageScroller->FImage->Canvas.... damit kannste malen wie in TImage (Ist ja eins)
!!! Deshalb ist das Ding public, was eigentlich nicht sein soll!?

*Hey*,

ISB->FImage->Canvas->Pen->Width = 1;
oder
ISB->FImage->Picture->SaveToFile("Save.bmp");

bringen nicht mal die klitzekleinste Fehlermeldung. Hab ich was falsch gemacht. :p Das ist die Stufe, zu der ich noch nicht so bald den Draht gefunden hätte. Und dabei eigentlich ganz harmlos. Raus mit der scrollbox aus meiner Anwendung und Image überall gegen ISB->FImage ersetzen.

Warum soll Canvas nicht public sein? Selbst in der ScrollBox könnte es durchaus Sinn machen, wenn man ein Hintergrundbild anzeigen will. Im FImage wird es sowieso gebraucht. Und... Canwas ist nur Member von FImage. Und so soll es IMHO sein.

Nur der Vorteil ist mir noch nicht klar. Kann diese Kombi mehr als die Einzelkompos? Eine Klasse zu haben, ist zwar immer interessant und Wiederverwertbar.

Aber sonst? Angenommen, ich will FImage transparent machen und eine Vorlage drunterlegen. Genau das will ich dann später. Da ich FImage nicht allein ansprechen kann, werd ich allein für diese Aufgabe die Klasse recht kompliziert bauen müssen. Ich bin also noch nicht sicher, ob die Kombination Sinn hier macht. Das Arbeiten mit einzelnen Kompos ist problemloser.

Auch das Zoomen mit TUpDown ist in der Praxis nicht befriedigend. Ich überbrücke Größen zwischen 25% und 1000%. Ich hab jetzt 2 Button für +/-, eine 100%-Schnelltaste und die TComboBox mit festen Werten. Das kommt schon mal edel. Ich müßte also die Klasse speziell auf diesen bedarf einrichten.

Da stellt sich natürlich die Frage, ob ich die inzwischen doch schon fast 1000 Zeilen des Grafiktools wirklich umstellen soll. Ich arbeite zB. gern modular. Erst mal schnell eine Simpelroutine zum Schaun, wie es gelingt, dann werden die Aufgaben spezialisiert. Der Gourmet würde sicher Klassenwege und modularen Aufbau gekonnt kombinieren.

Was aber beim erreichten Stand vor allem brennend interessiert, ist der Weg und der richtige Platz, logische/physikalische Koordinaten umzurechnen, damit die Malposition immer unter den Cursor liegt. Dann könnte ich mit einer gezoomten Kompo die Ungenauigkeiten, die durch den Weg mit der Speicherbitmap reinkomen, sauber vermeiden. Pixel soll Pixel sein. Und nicht irgend was zufälliges, das bei 100% teilweise wieder weggewischt wird. Das ist momentan mern größter Kummer.

Panzerechse

probiers mal mit affrak_2k1
cooles proggie

can much do
under otherem:
* streck piktures
* vergreater pikturs

Leider, das Proggy ist den Suchmaschinen nicht bekannt. Ich müßte die Seite finden, die es im Sortiment hat. Weißt du sie zufällig? Ich wollte der Sache schon nachgehen.

AndreasW

Hi,

@<Omega-X>:
Zitat: Sourcecode der Komponenten sind ab der Enteroprise-Version dabei.

@DerAltenburger :

Dimension=new TImageDimension;

und, wo gibst du den wieder frei ?

DerAltenburger

AndreasW:

IM DESTRUCTOR von TImageScroller!!!

DerAltenburger

Omega-X:

Eine Klasse (komponente) soll ALLE Datenelemente kapseln!!!
Dazu sind diese privat oder protected zu erzeugen!
Zugriff auf Inhalte der Elemente soll nur mit METHODEN moeglich sein (die koennen Fehler testen usw)- das ist OOP pur!!!

Bin manchmal zu faul Methoden zu schreiben, dann mach ich publics, is' aber nicht ganz sauber. :p

Zum Malen in dem ImageScroller kannste mal das probieren:

TImagePaintScroller ableiten von TImageScroller mit neuen Methoden zum malen
(Im Test- Programm musste dann aber TImagePaintScroller erzeuge, verwenden, deleten!!! Sonst macht der nur das vom Vorgaenger wie gehabt
Mit der neuen Klasse (Kompo) kannste im gezoomten Bild malen!

In die Headerdateikommt das

//---------------------------------------------------------------------------
//Klasse zum Anzeigen von Bildern und Zeichnen in einer Scrollbox
class PACKAGE TImagePaintScroller : public TImageScroller
{
private:
protected:
  Boolean FPenDown;
  TPoint FPenPos;
DYNAMIC void __fastcall MouseDown(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
DYNAMIC void __fastcall MouseUp(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
DYNAMIC void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
public:
               __fastcall TImagePaintScroller(TComponent* Owner);
               __fastcall ~TImagePaintScroller(void);
  __property Boolean PenDown={read=FPenDown,write=FPenDown,nodefault};
  __property TPoint PenPos={read=FPenPos,write=FPenPos,nodefault};
__published:
};

In die CPP- Datei kommt das

//---------------------------------------------------------------------------
// ValidCtrCheck wird benutzt, um sicherzustellen, daß die erzeugten Komponenten keine
// rein virtuellen Funktionen haben.
static inline void ValidCtrCheck(TImagePaintScroller *)
{
        new TImagePaintScroller(NULL);
}
//Constructor fuer ImageScrollbox
//---------------------------------------------------------------------------
__fastcall TImagePaintScroller::TImagePaintScroller(TComponent* Owner)
         : TImageScroller(Owner)
{ FPenDown=false;
  FPenPos=Point(0,0);
  FImage->Enabled=false;
}
//---------------------------------------------------------------------------
//Destructor fuer ImageScrollbox
__fastcall TImagePaintScroller::~TImagePaintScroller(void)
{
}
//---------------------------------------------------------------------------
void __fastcall TImagePaintScroller::MouseDown(TMouseButton Button, Classes::TShiftState Shift, int X, int Y)
{ if (Button==mbLeft)
    FPenDown=true;
}
//---------------------------------------------------------------------------
void __fastcall TImagePaintScroller::MouseUp(TMouseButton Button, Classes::TShiftState Shift, int X, int Y)
{ if (Button==mbLeft)
    FPenDown=false;
}
//---------------------------------------------------------------------------
void __fastcall TImagePaintScroller::MouseMove(Classes::TShiftState Shift, int X, int Y)
{
  if (ControlAtPos(Point(X,Y),true)==FImage)
    FImage->Canvas->MoveTo(PenPos.x,PenPos.y);
    FPenPos=Point(float(X-FImage->Left) / Dimension->ImageZoom,float(Y-FImage->Top) / Dimension->ImageZoom);
  if (FPenDown)
  {
    FImage->Canvas->LineTo(PenPos.x,PenPos.y);
  }
}

PS:
In TImageScroller->Zoom(....) muss was ergaenzt werden:

Dimension->ImageZoom=float(Fac) / float(Quot);

als letzter Befehl.
Hatte ich vergessen. Ohne das klappt skalierung nicht bei malen mit Zoomfaktor!!!

[ Dieser Beitrag wurde am 26.02.2003 um 09:58 Uhr von DerAltenburger editiert. ]

AndreasW

Original erstellt von DerAltenburger:
IM DESTRUCTOR von TImageScroller!!!

man, ich glaub ich brauch ne Brille *G*

entschuldige...

DerAltenburger

Andreas:

's geht auch mit Hund und Stock

(Meine Variante, oder der Nase nach?)

Laufen tut es schon mal. Nur kann ich nicht zeichnen. Wenn ein TToolButten (tbsCheck) gecheckt ist, soll FPenDown=true gesetzt werden. Ich konnte bisher nicht rausfinden, wie ich in der TestForm auf die Variable zugreifen kann. In die Declaration hab ich ImagePaintScroll aufgenommen.

DerAltenburger

Willst Du mit der Maus malen oder mit 'Koordinaten' von aussen???

Mit der Maus muesste es schon gehen!!! (Kuck mal in MouseDown / MouseUp!!!

Von aussen nicht moeglich , da FPenDown PROTECTED ist (wie es sein soll!)
Noch nicht :
musst im Header
Boolean FPenPos;
in den Bereich public verschieben

oder eine public Methode schreiben (alle Methoden koennen an FPenPos)

[ Dieser Beitrag wurde am 26.02.2003 um 22:25 Uhr von DerAltenburger editiert. ]

Ja, public ist klar. Hab ich sowieso keine Anns vor... noch nicht.

PenDown bleibt unbekannt. Die Tatstatur sagt mir, ich soll die Form der Member benennen. Aber ich hab keine Form. Wenn ich nicht doch was übersehen hab, muß die Verständigung wohl anders gehen. - Also noch mal explizit geschaut, alle Header sind eingebunden, der Dialog zu "Unit Header einbinden" bestätigt es.

<edit>Willst Du mit der Maus malen oder mit 'Koordinaten' von aussen???
Mein Ziel ist ja das Maltool. Aber der Viewer hat seinen Reiz und verdient es auch, ausgebaut zu werden. Vor allem interessiert mich aber, den richtigen Weg zu erkunden, mit dem Zoomen + sauberes Malen gelingt. (Ich bekomm zu Recht übelste Schläge, wenn ich vermeintlich richtige Hilfe in verwandten Themen gebe. Obwohl ich "Klappe halten sollen" statt zB. Aufklärung als läppisches Argument mit Mobbingwirkung empfinde, will ich da wirklich dran schrauben).

DerAltenburger

Hi Omega-X,

Du bist ja ganz schoen hartnaeckig ( recht so!!!)

Also nochmal langsam:
Die Klasse TImagePaintScroller kann von sich aus mit der Maus malen!!!
Die Maus wird aber von INNEN automatisch 'verwaltet' - da brauchste Dich
nicht d'rum kuemmern.
Bei MouseDown wird PenDown aktiviert,
Bei MouseUp wird PenDown deaktiviert
Und wenn Du dazwischen die Maus bewegst, malt das Ding den Mausweg!?

!!! Musst die (linke) Maustaste gedrueckt halten !!!
Von Aussen malen kannste direkt in FImage (ist ja leider public)

PS: Es muss nur ein gueltiges Bitmap d'rin sei !!!
Maus malt nur ueber FImage
Wenn gar kein Bitmat in FImage ist, gibts 'ne Exception
(War zu faul das abzufangen , deshalb lade ich in Demo als erstes ein Bild, damit was da ist!!!)

[ Dieser Beitrag wurde am 27.02.2003 um 12:15 Uhr von DerAltenburger editiert. ]