Bild-Viewer Probleme

Ich hab in meinem Viewer (TImage) eine Zoomfunktion eingebaut. Bilder laden und zoomen klappt einwandfrei. Aber da fehlt noch was. Ich find keine Entsprechung in der Hilfe, FAQ und so.

Größer zoomen macht keinen Ärger. Wenn ich aber nach dem kleiner zoomen wieder zurück geh, sind Bildinformationen verloren gegangen. Da muß ich sicher einen virtuellen Weg wählen, der das Bild nicht verändert? Wie muß ich da vorgehen?
Wenn ich was rauskopieren will, zoom ich ziemlich groß, klar. Das MarkRect ist dann ganz weit von der Maus weg oder sogar außerhalb vom Bild. Das dumme ist, eine umgerechnete Korrektur wirkt auf die Canvas, die Stiftposition orientiert sich aber an der Graphic. Hab leider keine Vorstellung, wie ich beides zusammenbringen kann.

Kann mir jemand weiterhelfen?

DerAltenburger

Ich denk' mal du zeichnest gezoomtes Bild in Canvas von TImage zurück!? :o
Dann haste nach halbieren nur noch die Hälfte der Pixel! Wird wieder vergrößert, wirds pixelig!

Ausweg 1 : Bild in TBitmap(ev. TPicture speichern und unverändertlassen. Alle Zoom Funktionen davon ausgehend berechnen! (Immer vom "Original" aus)

Ausweg 2 : TImage in z.b. TScrollbox "einbetten", Bild in TImage laden (Stretch = false, Autosize = true!!!), TImage- Abmessungen für Zoom- Faktor berechnen, TImage Position und Größe setzen (Pixel bleiben erhalten!!!)

Variante 2 ist mein Favorit. Pixel bleiben erhalten, in Scrollbox kann Bild gerollt werden!

Hoffe daß das hilft;
(Fragen an HeinigComp@aol.com wenn unbedingt nötig)

junix

Original erstellt von DerAltenburger:
(Fragen an HeinigComp@aol.com wenn unbedingt nötig)

Falsches verhalten. bei Fragen hier wieder posten... nur so funktioniert das Forum hier.

-junix

Methode 1 ist das, was ich "virtuelle" Methode nannte. Ein besseres Wort fiel mir nicht ein. Erst hatte ich Sorgen wegen dem Speicher. Aber du hast recht, so muß man es machen. Ist ja auch zu jeder Zeit nur 1 Bild im Speicher.

Die 2. Variante klappt bei mir nicht. Wie machst du das? Das Bild bestimmt, wie groß das TImage ist. Also muß ich das Bild verändern, dann geht es. Und dann stimmt auch die Mausposition.

Rauskopieren wird man wohl nicht bei Verkleinerung. Ist zu ungenau. Vielleicht aber doch bei großen Bildern. Und da gehen dann Informationen verloren. Beim vergrößerten Bild ist das kein Thema. Erst im Speicher auf 100% zurückverkleinern, dann ins Clipboard.

Reinkopieren genauso? Das soll ja kein reiner Betrachter werden. Etwas Nutzen ist immer gut.

Scheint wohl nur so etwas umständlich zu gehen. Klaro nehm ich eine ScrollBox. Das geht bei beiden Methoden. Ich denk sowieso, ich soll beide kombinieren. Wenn

das mit dem AutoSize=true interessiert mich. Da ist doch noch ein Trick dabei. So einfach kann das gar nicht gehen. Hab es natürlich versucht, obwohl ich weiß, daß es nichts bringt. Versehentlich hatte ich die Einstellungen auch schon so. Also wenn du den Trick noch verraten könntest, das wär supi.

DerAltenburger

Der Trick:

AutoSize=trueSize
Stretch=false beim Laden des Bitmap!!

-> TImage passt sich an's Bild an.
-> TScrollbox passt sich an TImage an (Scrollbalken bei Bedarf)

Zum "zoomen" muss natürlich
Stretch=true und
AutoSize=false
gestellt werden!

(Bei Neuladen eines Bildes wieder umschalten!!!)

Nicht ungünstig:
KOMPO bauen mit Methode
- LoadFromFile ö.ä.
- Zoom ö.ä.
-> in den Methoden die Umschaltungen machen!
- Originalgrösse (nach Laden) in Eigenschaft speichern ist günstig

Aufpassen: Position in Scrollbox selber festlegen, speziell bei Laden!

[ Dieser Beitrag wurde am 23.02.2003 um 20:53 Uhr von DerAltenburger editiert. ]

Jetzt versteh ich, wie das gemeint war. Ich lös das normalerweise etwas anders. Zur Anzeige der Bilddaten brauch ich dessen Width und Height. Das frag ich als erstes ab und pass TImage noch vor dem Laden dem Bild an. Dabei wird auch gleich der Form-Caption erstellt.

Ich brauch dann normalerweise während der Operationen nicht mehr AutoSize und Stretch verstellen. AutoSize bleibt auf false, Stretch bleibt auf true. Insofern ist die Behandlung einfach.

Da ich wohl sowieso eine Bitmap erstellen muß, kann ich auch gleich das Bild darein laden. Von der aus würde ich dann ins TImage stretchen und auch die Picture->Graphic synchronisieren. Das klingt gut. So werd ich drangehen. Dann klappt es auch mit dem Markieren.

@DerAltenburger, deine Tips sind gut. Methodisch aufgebauter Code liest sich viel leichter und ist kompakter. Das wird mit der Übung immer besser.

Kompo draus machen? Erst muß es mal sauber laufen. Dann wär das sicher mal 'ne schöne Aufgabe. Hab noch keine gebaut.

Anpassen will ich die Position des TImage sowieso. Bei einem Viewer ist das irgendwie Pflicht. Dann kommt noch FullScreen mit unterdrückten Scrollkalken und Taststursteuerung. Ein Child-Fenster oder bsDialog ohne Titelleiste, mal schaun.

Danke für die Hilfe. Mit dem Plan in der Hand fühl ich mich in der Werkstatt schon ganz wohl.

DerAltenburger

Freut mich, wenns hilft!

Der Tip war nur 'ne Kurzform! In meiner Kompo mach ichs auch mit extra Bitmap, berechnen, TImage anpassen und dann Bild in TImage-ist etwas umstaendlicher aber eleganter- dann flimmerts auch nicht so oft!.

Mit Property 'Einpassen (true/false) kann auch beim Laden noch gesteuert werden, ob Originalgroesse mit ev. Rollbalken oder eingepasst- dann MUSS natuerlich mit Bitmap vorgeladen unfd berechnet werden-, die Form war mir blos zu lang hier.

Hab 'mal die Kurzform der KOMPO mit Rollbalken(ist noch keine Kompo fuer IDE!!!)

HEADER fuer ImageScroller- Klasse
//---------------------------------------------------------------------------
#ifndef ImageScrollBoxH
#define ImageScrollBoxH
//---------------------------------------------------------------------------
//Hilfsklasse zum Speichern der Bildabmessungen
class  PACKAGE TImageDimension : public TPersistent
{
private:
   int FImageWidth;
   int FImageHeight;
        float FImageZoom;
public:
__published:
   __property int ImageWidth = {read=FImageWidth, write=FImageWidth, default=0};
   __property int ImageHeight = {read=FImageHeight, write=FImageHeight, default=0};
   __property float ImageZoom = {read=FImageZoom, write=FImageZoom, default=0};
};
//---------------------------------------------------------------------------
//Klasse zum Anzeigen von Bildern in einer Scrollbox
class PACKAGE TImageScroller : public TScrollBox
{
private:
protected:
  AnsiString FFName;                         //zum Dateiname- speichern
public:
  TImage *FImage;                            //Bildanzeige
  TImageDimension* Dimension;                //zum Abmessungen speichern
               __fastcall TImageScroller(TComponent* Owner);
               __fastcall ~TImageScroller(void);
        void __fastcall LoadFromFile(AnsiString FName);
        void __fastcall Zoom(int Fac, int Quot);
//        Boolean __fastcall SaveToFile(AnsiString FName);
  __property AnsiString FName={read=FFName,nodefault};
__published:
};
//---------------------------------------------------------------------------
#endif
HEADER fuer ImageScroller- Klasse ENDE

UNIT fuer ImageScroller- Klasse
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "ImageScrollBox.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck wird benutzt, um sicherzustellen, daß die erzeugten Komponenten keine
// rein virtuellen Funktionen haben.
static inline void ValidCtrCheck(TImageScroller *)
{
        new TImageScroller(NULL);
}
//Constructor fuer ImageScrollbox
//---------------------------------------------------------------------------
__fastcall TImageScroller::TImageScroller(TComponent* Owner)
         : TScrollBox(Owner)
{ Dimension=new TImageDimension;             //Hilfsklasse erzeugen
  FImage=new TImage(this);                   //Bildanzeige erzeugen
  FImage->Parent=this;                       //sonst keine Anzeige!!!
}
//---------------------------------------------------------------------------
//Destructor fuer ImageScrollbox
__fastcall TImageScroller::~TImageScroller(void)
{ delete FImage;                             //Bildanzeige freigeben
  delete Dimension;                          //Hilfsklasse freigeben
}
//---------------------------------------------------------------------------
//Bild aus Datei laden
void __fastcall TImageScroller::LoadFromFile(AnsiString FName)
{ FImage->AutoSize=true;                     //Anzeige soll sich an Bild anpassen
  FImage->Stretch=false;                     //Bild nicht verzerren!!!
  try                                        //falls beim Laden was schiefgeht
  { FImage->Picture->LoadFromFile(FName);    //Bilddatei laden
    FFName=FName;                            //Name speichern
    Dimension->ImageWidth=FImage->Width;     //Bild- Abmessungen
    Dimension->ImageHeight=FImage->Height;
    Dimension->ImageZoom=1;                  //speichern
  }
  catch(...)                                 //falls Fehler beim laden
  { FName="";                                //Alle
    Dimension->ImageWidth=0;                 //Daten
    Dimension->ImageHeight=0;                //fuer ungueltig
    Dimension->ImageZoom=0;                  //erklaeren
  }
}
//---------------------------------------------------------------------------
//Anzeige Zoomen (Originalgroesse * Fac / Quot)
void __fastcall TImageScroller::Zoom(int Fac, int Quot)
{ FImage->AutoSize=false;                    //Anzeige nicht anpassen an Bild!!!
  FImage->Stretch=true;                      //Bild 'verzerren'
  FImage->Width=Dimension->ImageWidth * float(Fac) / float(Quot);
  FImage->Height=Dimension->ImageHeight * float(Fac) / float(Quot);
  //ohne typecast gibt's Ganzzahldivision!!!
}
//---------------------------------------------------------------------------
Unit fuer ImageScroller- Klasse ENDE

Edit:
Bitte die Code-Tags benutzen. Danke!

[ Dieser Beitrag wurde am 24.02.2003 um 12:45 Uhr von Jansen editiert. ]

Tschuldigung, bin Anfaenger. Naechstemal richtig!

[ Dieser Beitrag wurde am 24.02.2003 um 12:54 Uhr von DerAltenburger editiert. ]

*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!!!