Mehrere Formulare an Stringgridgröße anpassen

[Delphi-Laie]

Hallo Delphifreunde!

Ein Stringgrid an ein größenveränderliches Formular, in das es eingebettet ist (align:=alClient), anzupassen, wurde schon einige Male gefragt.

Mir geht es jetzt genau im den Gegensatz, nämlich, daß das übergeordnete Formular größenbezogen so angepaßt wird, daß es das (entsprechend seiner Einträge skalierte) Stringgrid exakt aufnimmt und auf einen Blick alles anzeigt, ohne jedoch größer als nötig zu sein (ggf. die Bildschirmabmessungen als Maximum nehmen, was unschwierig ist). Dazu fand ich jedoch nichts.

Mit der Abfrage, ob die Scrollbars bzw. -balken (des Stringgrids) existieren, ist eine - etwas langsame und vom Code her weder kurze noch elegante - Bastellösung möglich, die ich mir im Verlaufe der Zeit so schlecht und recht bis zur Zufriedenheit zurechtkonstruierte. Besonders unpraktisch wird das jedoch, wenn man mehrere Formulare auf diese Weise anpassen möchte: jedesmal diese anzupassenden Codebrocken. Deshalb wollte ich das mit einer Funktion realisieren, scheiterte aber.

Weiß jemand, ob es dafür eine Komponente oder sonstwas gibt? Müßte ja eine Komponente für ein Formular mit integriertem Stringgrid sein?! Keine Ahnung, ob und wie so etwas als funktionaler Automatismus realisiert werden könnte. Mit vorsichten Vererbungsversuchen (OOP ist für mich heute leider noch ein Buch mit "nur" noch sechs Siegeln) kam ich trotz audauernder Versuche nicht weiter.

[Hansa]

Du hast also irgendwelche Stringgrids mit unterschiedlicher Grösse (bzw. eher Breite) und das Formular soll sich daran anpassen oder wie ? Dann sage, ob das die Frage ist, oder präzisiere es etwas. Das wäre nämlich fast zu einfach. 8-)

Bevor ich das nicht weiss : Soll irgendwer sich damit beschäftigen, zumindest um die Zeit jetzt. :mrgreen:

Stop, noch was : um wieviele Forms geht es ?

[hoika]

Hallo,

Zitat:

jedesmal diese anzupassenden Codebrocken. Deshalb wollte ich das mit einer Funktion realisieren, scheiterte aber.

hm ?

Delphi-Quellcode:

Unit FormTools;

XXX

procedure AdjustForm(theForm: TForm; theStringGrid: TStringGrid);
begin
  dein Code

Heiko

[Medium]

TForm.AutoSize := true -- gibts sogar schon im OI.

[Hansa]

Autosize, was nützt das ? ich sags gleich : Nix. :mrgreen:

[Bummi]

Warum, sollte Autosize Dir nicht helfen??
In folgendem Beispiel gehe ich mal davon aus daß colwith und rowheigth immer gleich sind, ansonsten halt drüberlaufen und rechnen:

Delphi-Quellcode:

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
begin
  if StringGrid1.width<(StringGrid1.colcount*(StringGrid1.Defaultcolwidth + 1) + 4) then
  StringGrid1.width:=(StringGrid1.colcount*(StringGrid1.Defaultcolwidth + 1) + 4);

  if StringGrid1.Height<(StringGrid1.Rowcount*(StringGrid1.DefaultRowHeight + 1) + 4) then
  StringGrid1.Height:=(StringGrid1.Rowcount*(StringGrid1.DefaultRowHeight + 1) + 4)


end;

[Hansa]

Ne, zuviele Fehler. Was soll z.B. das ColCount x 4 ? Jede Spalte ist gleich und von der Col abhängig ? :shock: Und jetzt ? Das ergibt wieder dasselbe. Das Stringrid läuft wieder etwas aus dem Ruder. Allerdings hat der Fragesteller sowieso noch keine Antwort gegeben. 8-)

[Delphi-Laie]

Hallo, besten Dank für Eure Antworten!

Zitat:

Zitat von Hansa (Beitrag 1058439)

Du hast also irgendwelche Stringgrids mit unterschiedlicher Grösse (bzw. eher Breite) und das Formular soll sich daran anpassen oder wie ?

Ja, genau das meine ich.

Zitat:

Zitat von Hansa (Beitrag 1058439)

Dann sage, ob das die Frage ist, oder präzisiere es etwas. Das wäre nämlich fast zu einfach. 8-)

Dann ist mein Spürsinn, das aufzuspüren, vielleicht noch entwicklungsbedürftig. Wie gesagt, mit dem "manuellen" stufigen Zoomen (jeweils um einen Pixel) und Abfrage, ob die Scrollbalken vorhanden sind, läßt sich etwas zusammenbasteln, was aber weder performant noch elegant ist.

Zitat:

Zitat von Hansa (Beitrag 1058439)

Stop, noch was : um wieviele Forms geht es ?

Um mehrere, das schrieb ich bereits.

Inzwischen kamen ja einige Antworten, mal schauen, was ich davon am besten verarbeitet bekomme.

Wenn sich Bedarf ergäbe (was ich nicht hoffe), dann würde ich mich noch mal melden.

Nochmals besten Dank Euch allen!

[Hansa]

Nun gut, da muss man mal sehen, wie so etwas geht. 8-) Bei mir liegt auf der Form zuerst mal ein Panel. Das Panel hat ein Stringgrid und das ist auf alClient gesetzt, d.h. es füllt das Panel komplett aus. Die Form wird dann je nach Panelgrösse angepasst.

Delphi-Quellcode:

procedure ErmittleGridBreite;
...
PanelBreite := 0;
for i := 0 to sg.ColCount - 1 do
  PanelBreite := PanelBreite + sg.ColWidths [i] + 1;
...
// im FormShow dann :

ErmittleGridBreite;  // setzt PanelBreite
width := PanelBreite;

PanelBreite ist übrigens als Form-protected deklariert. Warum wohl ? Deshalb die Frage nach Anzahl der Forms. "mehrere" ist natürlich gute Antwort. :lol:

[Medium]

Was ist hier falsch an AutoSize? :shock:
Es sorgt dafür, dass alle visuellen Komponenten auf dem Formular so eng wie es grad geht eingeschlossen werden. War nicht ganz genau DAS gefragt? :gruebel:

[DeddyH]

Zitat:

Zitat von Medium (Beitrag 1058525)

Was ist hier falsch an AutoSize? :shock:
Es sorgt dafür, dass alle visuellen Komponenten auf dem Formular so eng wie es grad geht eingeschlossen werden. War nicht ganz genau DAS gefragt? :gruebel:

Die Frage habe ich mir auch schon gestellt.

[Delphi-Laie]

Hallo hoika/Heiko! Wo hast Du das:

Zitat:

Zitat von hoika (Beitrag 1058440)

Delphi-Quellcode:

Unit FormTools;

XXX

procedure AdjustForm(theForm: TForm; theStringGrid: TStringGrid);
begin
  dein Code

her? In/ab welcher Delphiversion ist das zu haben?? Nicht einmal mein Turbodelphi kennt das. Das scheint aber genau das zu sein, was ich suche. Es gefiel mir von Anfang an auch am besten.

*******************

Autosize beim Forumular hilft übrigens nichts: Nicht nur, daß das Formular nicht mehr manuell zoombar ist, es ist natürlich auch nicht paßgenau, sondern zu klein: Sogar beide Scrollbalken des Stringgrids erscheinen. Keine Ahnung, was da "auto" gemacht wurde. Hineinprogrammierte Vorab-Intelligenz ist eben nicht immer so weitblickend, vorausschauend ausgelegt worden, daß sie später allen Anforderungen standhält.

******************

Hallo Bummi, auch Dir danke!

Zitat:

Zitat von Bummi (Beitrag 1058444)

In folgendem Beispiel gehe ich mal davon aus daß colwith und rowheigth immer gleich sind, ansonsten halt drüberlaufen und rechnen:

Nein, sind sie nicht, sondern immer verschieden. Deshalb wollte ich es flexibel haben.

Zitat:

Zitat von Bummi (Beitrag 1058444)

Delphi-Quellcode:

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
begin
  if StringGrid1.width<(StringGrid1.colcount*(StringGrid1.Defaultcolwidth + 1) + 4) then
  StringGrid1.width:=(StringGrid1.colcount*(StringGrid1.Defaultcolwidth + 1) + 4);

  if StringGrid1.Height<(StringGrid1.Rowcount*(StringGrid1.DefaultRowHeight + 1) + 4) then
  StringGrid1.Height:=(StringGrid1.Rowcount*(StringGrid1.DefaultRowHeight + 1) + 4)


end;

Die Breite und Höhe eines StringGrids zu berechnen und daran - nach viel Ermitteln und Probieren - die Formulargröße pixelgenau so anzupassen, daß das Stringgrid ohne Scrollbalken auskommt, ist letztlich - ich meine das jetzt nicht abwertend - auch wieder nur eine Bastellösung (von der ich auch eine habe). Auch hier müßten jedesmal die Codezeilen erneut in den Quelltext eingefügt und wieder die Bezeichner entsprechend angepaßt werden.

Deshalb wäre eine Routine (wie hoika angedeutet) prima, aber mit OOP scheint es kaum zu funktionieren; höchstens mit einer der Formularklasse übergeordneten Klasse, in der eine solche Routine eingebaut wird, erscheint das möglich, aber daß ich so etwas hinbekomme (sofern es überhaupt möglich ist), ist nahezu ausgeschlossen.

[Hansa]

Autosize gibts bei mir auch nicht. Was soll das denn nützen ? Ich erschlage die Breite des Stringgrids und die der Spalten mit einem Schlag. :mrgreen:

[Medium]

@Hansa: Möglich, dass das in älteren Versionen noch nicht vorhanden ist. Es tut das, was ich in einem vorigen Beitrag bereits schrieb.

Zitat:

Zitat von Delphi-Laie (Beitrag 1058572)

Hallo hoika/Heiko! Wo hast Du das:
[...]
her?

Die Zeile "dein code" hätte ein entscheidender Hinweis sein können. Hoika wollte damit wohl sagen: Bau dir einfach eine eigene Methode, die ein beliebiges Formular und Grid entgegen nimmt, womit du diese eine Funktion für alle Formulare mit Grid verwenden könntest. Sowas spezielles wirst du kaum fertig finden...

Zitat:

Zitat von Delphi-Laie (Beitrag 1058572)

Autosize beim Forumular hilft übrigens nichts:[...]

Ich habe AutoSize auf Formularen in etlichen Projekten völlig ohne solche Probleme benutzt. Manchmal ist es eben auch die Art und Weise der Verwendung, die die Funktion stört. Zum Beispiel sollte es mehr als offensichtlich sein, dass man auf einem AutoSize-Formular keine unmittelbaren Children mit anderen Alignments als alNone, und ggf. alCustom haben sollte. Das wäre z.B. eine Stelle zum mal nachsehen - wir haben deinen Code ja nicht hier.

[Bummi]

Zitat:

Deshalb wäre eine Routine (wie hoika angedeutet) prima, aber mit OOP scheint es kaum zu funktionieren; höchstens mit einer der Formularklasse übergeordneten Klasse, in der eine solche Routine eingebaut wird, erscheint das möglich, aber daß ich so etwas hinbekomme (sofern es überhaupt möglich ist), ist nahezu ausgeschlossen.

Wenn Du so auf OOP stehst kannst Du entweder eine Klasse von TStringgrid ableiten und hier eine Property MachMichSoGrossDassIchKeineScrollbalkenbrauchenUnd ZiehMeinenParentMit:Boolean einbauen, spätestens hier muß Du aber wieder Code schreiben die Coulmnbreiten addieren, wenn Gitterlinen siohtbar sind deren Breite mit berechnen, das selbe für die Spalen und eine geeignete Stelle finden an der die Einstellugen bei Änderugen nachgezogen werden.

Oder Du hast schon in weiser Voraussicht Deine Formularen von einer Basisklasse abgeleitet (lässt sich auch nachrüsten) in der die Routine einmalig implementiert wird z.B. eine OnPaint Routine für Stringgrids

Und hier dann:
With TStringGrid(Sender) do .....

etc.

[Delphi-Laie]

Die Eigenschaft "Autosize" gibt es ab Delphi 4.

Danke noch einmal für Eure Reaktionen!

Daß ich auf OOP stehe, kann ich nun beileibe nicht behaupten (sowohl mein Pseudonym als auch meine Ausführungen hier und sonstwo belegen das), aber ich werde mich noch einmal - unterstützt von Euren Hinweisen - in diese Sache hineinknien. Überhaupt, mangels echtem Interesse beschäftige ich mich im Bereich der Programmierung immer nur mit dem, was ich zur Lösung meines Problemes gerade benötige (der Weg ist für mich nicht das Ziel, sondern nur das Ziel selbst ist es).


Nochmals vielen Dank und viele Grüße!

[hoika]

Hallo,

OOP.

Delphi-Quellcode:

unit FormTools;

interface

type
  TAutoSizeToolClass = class
    public
      class function AutoSizeForm(theForm: TForm; theStringGrid: TStringGrid);
  end;

Heiko

[Delphi-Laie]

Hallo Hoika bzw. Heiko, danke!

Zitat:

Zitat von hoika (Beitrag 1058612)

Hallo,

OOP.

Delphi-Quellcode:

unit FormTools;

interface

type
  TAutoSizeToolClass = class
    public
      class function AutoSizeForm(theForm: TForm; theStringGrid: TStringGrid);
  end;

Heiko

Mit etwas ähnlichem versuchte ich mich auch, scheiterte aber: Ich leitete eine Formularklasse von TForm ab. Das Problem: Die Methode war nicht in der übergeordneten Klasse (TForm) sichtbar bzw. verfügbar, egal, wohin ich sie packte (Vererbung ist ja auch genaugenommen etwas, was nur die Kinder betrifft, deshalb meine Idee mit einer der TForm übergeordneten Klasse). Auch direkt in die TForm-Klasse eine Methode zu implementieren, führte mich nicht weiter.

Wird diese TAutoSizeToolClass-Klasse bzw. dessen Methode AutoSizeForm ohne Problem für die TForm-Klasse erreichbar sein? Oder gibt es da auch wieder etwas besonderes zu beachten?

Danke für die Geduld und Gruß!

Delphi-Laie

[Hansa]

Zitat:

Zitat von Delphi-Laie (Beitrag 1058615)

Ich leitete eine Formularklasse von TForm ab.

...und das ist zum Scheitern verurteilt. :lol: Bzw. unnötig kompliziert. Mache eine Standardform mit dem Grid und schiebe den Krempel in die Objektablage. Da nimmst Du jetzt die Forms her und fertig (neu -> weitere). Der englische Begriff für Objektablage ist allerdings besser, als der deutsche : Form-Inheritance. Das verdeutlicht eher, um was es geht. 8-)

[Bummi]

@Hansa
Ich teile Deine Meinung absolut nicht.
Jedes Projekt hat andere Anforderungen und keines meiner Projekt wird ohne Template bzw. mehre Vererbungsebenen an Templates erstellt.
Die Erstellung und Wartung der Templates ist trivial und jedes beinhaltet den für seine Ebene nötigen Maximalumfang an Funktionalität.
Auf diese Art können redundante Codeanschnitte weitestgehend vermieden werden und Funktionalitäten jederzeit nachgerüstet oder angepasst werden.
Wenn ich hierfür die Objektablage verwenden würde wäre diese 1. bis zum Platzen voll und viele Funktionen die erst in einem Projektrahmen zur Verfügung könnten gar nicht erst implementiert werden.

MfG
Thomas

[Hansa]

Zitat:

Zitat von Bummi (Beitrag 1058642)

Wenn ich hierfür die Objektablage verwenden würde wäre diese 1. bis zum Platzen voll und viele Funktionen die erst in einem Projektrahmen zur Verfügung könnten gar nicht erst implementiert werden.

Ne, absolut falsch. Problem ist : in erforderlichen Formularen wird redundant Code eingefügt. Das ist nicht gut. Du musst eine Form-Historie aufbauen. Immer vererben und fertig.

[Bummi]

Nach rund 300 Projekte mit Aufwänden mit zwischen 2 Wochen und 4 Jahren bin ich sicher, daß Aufgrund der extrem verschiedenen/gegensätzlichen Kundenanforderungen das von Dir beschrieben Vorgehen für mich nicht praxisgerecht ist.
Aber wir solltest daß hier beenden wir sind weit OT.

[blauweiss]

Hallo,

was macht ihr da, und warum.....?:shock:

Warum nicht einfach so:

Delphi-Quellcode:

function GetGridWidth(aStringGrid: TStringGrid): integer;
var
  i: integer;
begin
  Result := 0;
  with aStringGrid do
    for i := 0 to ColCount-1 do
      inc(Result, ColWidths[i] + GridLineWidth);
end; // GetGridWidth

function GetGridHeight(aStringGrid: TStringGrid): integer;
var
  i: integer;
begin
  Result := 0;
  with aStringGrid do
    for i := 0 to RowCount-1 do
      inc(Result, RowHeights[i] + GridLineWidth);
end; // GetGridHeight

procedure AdjustFormSize(aStringGrid: TStringGrid; aForm: TForm);
begin
  with aStringGrid do
    begin
      ClientWidth := GetGridWidth(aStringGrid);
      ClientHeight := GetGridHeight(aStringGrid);
    end;
  aForm.AutoSize := true;
end; // AdjustFormSize

und dann im FormShow oder wo es passieren soll

Delphi-Quellcode:

procedure TForm1.FormShow(Sender: TObject);
begin
  AdjustFormSize(StringGrid1, Self);
end;

OOP und Objektablage geht natürlich auch.

Grüße,
blauweiss

[Hansa]

Mann, mann, Bummi :shock: OT ist das hier bei weitem nicht.

Das hier ist Spass oder nicht ?

Zitat:

Zitat von Bummi (Beitrag 1058646)

Nach rund 300 Projekte mit Aufwänden mit zwischen 2 Wochen und 4 Jahren bin ich sicher,..

Bei 300 Projekten, wieviele Forms gibt es da ? 3000 ? Und Du schlägst ernsthaft vor, da nicht grundlegende Eigenschaften zu vererben ? Einmal entwickeln und immer wieder verwenden ? Selbst wenn es nur darum geht, eine nicht Windows-konforme, dafüt aber ISO-mässige Funktion einzubauen ? Das kommt in die Standardform und fertig. Guck mal beim DIN-Institut nach. 8-)

[Delphi-Laie]

Hallo hoika / Heiko, es könnte soo einfach sein, wie Du andeutetest:

Zitat:

Zitat von hoika (Beitrag 1058440)

Delphi-Quellcode:

Unit FormTools;

XXX

procedure AdjustForm(theForm: TForm; theStringGrid: TStringGrid);
begin
  dein Code

Heiko

Nun, meine Unit mit dem "tausendmal bewährten Code" (der in den einzelnen Units mit jeweils angepaßten Bezeichnern funktionert) sieht nunmehr so aus:

Delphi-Quellcode:

unit Formtools;

interface;

uses
 Windows
 , Forms
 , Grids
 ;

const  Zeilenhoehe=17;Zellenbreitenzuschlag=6;

procedure Form_Skalieren(Form:TForm;StringGrid:TStringGrid);

implementation;

procedure Form_Skalieren(Form:TForm;StringGrid:TStringGrid);
var l,m:word;
begin
Form.Hide;

//Spaltenbreitenskalierung des Grids
for l:=0 to pred(StringGrid.ColCount) do StringGrid.ColWidths[l]:=Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,0]);//Skalieren nach Tabellenkopf
for l:=0 to pred(StringGrid.ColCount) do for m:=1 to pred(StringGrid.RowCount) do
  if StringGrid.ColWidths[l]<Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,m])
  then StringGrid.ColWidths[l]:=Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,m]);

//maximale horizontale Ausdehnung des Fensters ermitteln
Form.Width:=1;
while ((GetWindowlong(StringGrid.Handle,GWL_STYLE) and WS_HSCROLL)<>0) and (Form.width<screen.width) do Form.Width:=succ(Form.Width);

//maximale vertikale Ausdehnung des Fensters ermitteln
Form.Height:=succ(Form.Height-Form.ClientHeight);
while ((GetWindowlong(StringGrid.Handle,GWL_STYLE) and WS_VSCROLL)<>0) and (Form.Height<Screen.Height) do Form.Height:=succ(Form.Height);

//Horizontalkorrektur; es ginge wohl auch umgekehrt: 1. vertikale, 2. horizontale Ausdehnung ermitteln und schließlich Vertikalkorrektur
if ((GetWindowlong(StringGrid.Handle,GWL_STYLE) and WS_HSCROLL)=0) then //Horizontalscrollleiste nicht zu sehen
  begin
  while (GetWindowlong(StringGrid.Handle,GWL_STYLE) and WS_HSCROLL)=0 do Form.Width:=pred(Form.Width);
  Form.Width:=succ(Form.Width)
  end;

Form.Position:=poScreenCenter;
Form.Show

end;
end.

Es funktioniert - aber leider nur beim Formular "Form1". Bei den anderen Formularen bleibt der Code hängen, und zwar in der Zeile (unter "Horizontalkorrektur")

Delphi-Quellcode:

while (GetWindowlong(StringGrid.Handle,GWL_STYLE) and WS_HSCROLL)=0 do Form.Width:=pred(Form.Width)

,

und zwar wird dort die Breite ("Width") aus unerklärlichen Gründen in der While-Schleife nicht mehr verändert (dekrementiert). Was nützt (mir) der eigentlich sehr gute Debugger, wenn er nicht das tut, was im Quelltext angezeigt wird? Nichts!

Daß diese Funktion insgesamt überhaupt funktionieren soll (und es beim Form1 sogar zu meiner Verblüffung tut), ist mir völlig schleierhaft, weil hier doch nur Werteparameter, jedoch keine Variablenparameter übergeben werden (schließlich möchte ich ja das Originalformular verändern, also in seiner Größe anpassen, nicht jedoch irgendeine seiner Kopien). Ich kenne es von Pascal so, daß bei Werteparametern lokale Kopien angelegt werden, deshalb kam mir so etwas einfaches wie Dein obiger Vorschlag gar nicht erst in den Sinn. Doch das Formular und das StringGrid als Variablenparameter übergeben zu wollen/versuchen, war der Beginn meiner ersten und leider abenteuerlich-frustrationsreichen Exkursion in die (Un)Tiefen der objektorientierten Programmierung, die mich schließlich hilfesuchend in dieses Forum trieben. Doch trotz aufoperungsvoller Hilfe aller hier Beteiligen bin ich momentan meinem Ziel kein Quentchen nähergekommen.

[blauweiss]

Hallo Delphi-Laie,

ruhig Blut, das wird schon....

Du möchtest also nicht nur die Form-Größe minimal setzen, sondern auch die einzelnen Spaltenbreiten so minimieren, daß genau der Zelleninhalt gezeigt wird.
Hier mein Vorschlag:

Delphi-Quellcode:

procedure MinimizeColWidths(aStringGrid: TStringGrid);
var
  x, y: integer;
  onewidth, biggestwidth: integer;
begin
  with aStringGrid do
    for x := 0 to ColCount-1 do
      begin
        biggestwidth := 0;
        for y := 0 to RowCount-1 do
          begin
            onewidth := Canvas.TextWidth(Cells[x, y]);
            if (onewidth > biggestwidth) then
              biggestwidth := onewidth;
          end;
        ColWidths[x] := biggestwidth + 6;
      end;
end; // MinimizeColWidths

Und dann verwende bitte um Gottes Willen Form.AutoSize := true und nicht diese Krücke mit den Scrollbars. Mein Code oben z.B. macht, was Du willst.

Zu Deinen weiteren Fragen:
1. Form und StringGrid sind Instanzen von Klassen, sprich pointer. Hier brauchst Du nur dann mit var-Parametern arbeiten, wenn Du den Verweis auf die Instanz an sich in der Prozedur ändern willst. Du brauchst kein var, wenn Du nur Bestandteile(Properties) der Instanz ändern willst. Es stimmt, das war unter Standard-Pascal logischer.
2. die Ursache dafür, daß Form.Width nicht weiter minimiert werden kann, liegt vermutlich an Constraints, die die Minimalgröße beschränken. Dein Programm würde dann auch stand-alone in einer Endlos-Schleife hängenbleiben. Mit dem Debugger hat das nichts zu tun.

Und Du könntest Dir auch überlegen, wie Dein Code ordentlicher eingerückt werden könnte... 8-)

Grüße,
blauweiss

[Delphi-Laie]

Hallo blauweiss, besten Dank!

Die Skalierung des Stringgrids, konkret der Minimierung seiner Spaltenbreiten, ist nicht mein Problem; meine Codezeilen dazu funktionieren. Deine sind m.E. auch nicht substantiell anders; mir scheint sogar so, als daß meine sogar ein Quentchen effizienter sind, da ich die Spaltenbreiten anfangs nicht einnull(t)e (so sah man Code früher auch aus), sondern gleich mit der Spaltenbreite der ersten Zeile bestücke.

Mein Problem ist auch nicht, Formulare an die Größe des eingebetteten StringGrids anzupassen, auch der Code funktioniert (bei Delphi 2 & 3) stets (ab Delphi 4 allerdings nicht beim ersten Aufruf des jeweiligen bzw. eines jeden Formulares, das habe ich dann angepaßt) zu meiner Zufriedenheit.

Mein Problem ist, daß ich diese Größenanpassung(en) in eine Routine (Funktion oder Prozedur, egal) packen wollte, um mir Codewiederholungen mit lästigen und fehlerträchtigen Bezeichnerbenennungsanpassungen zu sparen.

Autosize funktioniert dafür nicht (zu meiner Zufriedenheit), das schrieb ich schon.

Das mit dem Constrain stimmt: Das Fenster ist merkwürdigerweise auf 112 Pixel (das Minimum) voreingestellt, so daß die Dekrementierungsschleife natürlich endlos wird. Merkwürdig, wenn die Codezeilen direkt verwende, funktionieren sie tadellos.... Danke auch für diesen Hinweis!

Wie das ganze funktionieren soll, ist in meinem Programm "Prozesse" (auch hier veröffentlicht) zu sehen, was allerdings immer noch Feinschliff benötigt (Fehlerbereinigungen und Codeoptimierung).

Ich werde der Reihe nach alle Hinweise, die mir hier (und auch per PM) zukamen, durcharbeiten (hoikas Idee war die erste).

Aber nun weiß ich wenigstens dank Deiner, daß ich eine weitere Pascal-Altlast, die immer noch in meinem Kopfe umhergeistert, nicht 1:1 in Delph übernehmen kann.

Und Du hast recht: Maximal übersichtlich ist mein Code nicht (Asche auf mein Haupt).

[Delphi-Laie]

So, ich habe es jetzt anscheinend geschafft. Hoikas Idee war wohl doch richtig, der Fehler lag an einem fehlerhaften Aufruf der Routine: Es müssen natürlich FormX und FormX.StringGrid (X=Nummer des jeweiligen Formulares) übergeben werden, ich übergab jedoch stets nur StringGrid1 und damit das des aktuellen, aufrufenden Formulares.

Dank an alle noch einmal!

Ich werde das beizeiten in mein Prozeßbetrachtungsprogramm einbauen.

[sx2008]

Zitat:

Zitat von Delphi-Laie (Beitrag 1058707)

Die Skalierung des Stringgrids, konkret der Minimierung seiner Spaltenbreiten, ist nicht mein Problem; meine Codezeilen dazu funktionieren. Deine sind m.E. auch nicht substantiell anders; mir scheint sogar so, als daß meine sogar ein Quentchen effizienter sind...

Der Code von blauweiss hat Qualität, denn er ist wiederverwendbar durch seine definierte Schnittstelle.
Die "definierte Schnittstelle" ist ganz einfach eine Procedure mit Übergabeparameter.

Delphi-Quellcode:

procedure MinimizeColWidths(aStringGrid: TStringGrid);

Dein Code ist dagegen nicht wiederverwendbar, sondern einfach in eine andere Procedure eingebettet.
Ich weiss nicht ob dir bewusst ist dass deine

Delphi-Quellcode:

procedure Form_Skalieren(Form:TForm;StringGrid:TStringGrid)

eigentlich drei Dinge tut:
1.) das Stringgrid in der Breite anpassen
2.) Höhe und Breite des Formulars (mehrfach!) ändern
3.) das Formular unsichtbar und wieder sichtbar machen
Also ist der Name "Form_Skalieren" nicht wirklich passend.

Dagegen ist die Procedure "MinimizeColWidths" fast perfekt.
Der Name beschreibt recht gut was passieren soll,
wobei ich eher von Optimieren statt von Minimieren sprechen würde.

Eine Procedure, Funktion oder Methode sollte genau eine Aufgabe durchführen.
Falls mehr als eine Aufgabe durchgeführt wird, müssen die Teilaufgaben
als Unterfunktionen implementiert werden.

[hoika]

Hallo,

wenn es läuft, ist es doch schon mal besser als nichts ... ;)

Delphi-Quellcode:

ColWidths[x] := biggestwidth + 6;

Der Grund für das +6 würde mich mal interessieren.
Ist das die Breite einer Scrollbar ?

Ich würde den Code auch mal mit "large fonts" testen.

Der Code funktioniert übrigens wohl auch nicht im FormCreate,
sondern erst im FormActivate (Canvas ist noch nicht richtig initialisiert)


Heiko

[Delphi-Laie]

Zitat:

Zitat von sx2008 (Beitrag 1058709)

Eine Procedure, Funktion oder Methode sollte genau eine Aufgabe durchführen.

Ist das nicht Ansichtssache?

Letztlich ist auch eine Unit ein Modul, und zwar eines, das meistens Code für ziemlich viel Aufgaben enthält und i.d.R. auch durchführt.

Zitat:

Zitat von sx2008 (Beitrag 1058709)

Falls mehr als eine Aufgabe durchgeführt wird, müssen die Teilaufgaben als Unterfunktionen implementiert werden.

Vermutlich meinst Du, wenn an verschiedenen Codestellen der (prinzipiell) gleiche Code im Quelltext vorhanden ist bzw. beim Programmablauf ausgeführt wird, dann sollten Unterprogramme eingesetzt werden.

Zitat:

Zitat von hoika (Beitrag 1058716)

Delphi-Quellcode:

ColWidths[x] := biggestwidth + 6;

Der Grund für das +6 würde mich mal interessieren.
Ist das die Breite einer Scrollbar ?

Ich kann nur für mich antworten. Ich fummelte mir einen ähnlichen Wert zurecht, damit das Stringgrid nicht gar zu gequetscht wird: So ist wenigstens noch ein ganz klein wenig Platz zwischen Schrift und Spaltentrennern.

Zitat:

Zitat von hoika (Beitrag 1058716)

Der Code funktioniert übrigens wohl auch nicht im FormCreate,
sondern erst im FormActivate (Canvas ist noch nicht richtig initialisiert)

Jein. Bei Delphi 2 und 3 funktioniert er auch schon im FormCreate (ich deutete das weiter vorn an), ab Delphi 4 leider nicht (da habe ich umständlich zwei Codeblöcke, je nachdem, ob Anfang oder später). Aber nunmehr bin ich dank Deiner auf eine Fährte gestoßen, die den Code, was die Delphi-Versionen anbetrifft, evtl. universeller gestalten läßt.

[sx2008]

Zitat:

Zitat von Delphi-Laie (Beitrag 1058748)

Zitat:

Zitat von sx2008 (Beitrag 1058709)

Eine Procedure, Funktion oder Methode sollte genau eine Aufgabe durchführen.

Ist das nicht Ansichtssache?

Eher eine professionelle Einstellung zum Programmieren.
In dem Buch "Clean Code: A Handbook of Agile Software Craftsmanship" von Robert C. Martin wird das ausführlich beschrieben.
Kurzzusammenfassung

[Bummi]

@sx2008
wenn ich die Kurzzusammenfassung lese, kann ich mich den wenigsten Punkten uneingeschränkt anschließen.

[BUG]

Zitat:

Zitat von Bummi (Beitrag 1058841)

@sx2008
wenn ich die Kurzzusammenfassung lese, kann ich mich den wenigsten Punkten uneingeschränkt anschließen.

Du brauchst dich ja nicht dogmatisch an das Buch halten (steht sogar im Buch, nur beim "Durcharbeiten" der darin enthaltenen Übungen soll man sich darauf einlassen).
Und die Kurzzusammenfassung kann die Überzeugungsarbeit des Buches nicht bei weitem leisten, dazu ist sie einfach zu knapp :)

[Delphi-Laie]

Zitat:

Zitat von sx2008 (Beitrag 1058834)

Zitat:

Zitat von Delphi-Laie (Beitrag 1058748)

Zitat:

Zitat von sx2008 (Beitrag 1058709)

Eine Procedure, Funktion oder Methode sollte genau eine Aufgabe durchführen.

Ist das nicht Ansichtssache?

Eher eine professionelle Einstellung zum Programmieren.

Eine Einstellung (und nichts anderes ist es) zum professionellen Programmieren wäre ein klein wenig dezenter gewesen. Eine Einstellung (!) jedoch als "professionell" hinzustellen, halte ich - mit Verlaub - schon ein wenig für überheblich.

Letztlich ist es doch auch (und gerade?) im Bereich der Programmierung, der Informatik, wie übrigens in jeder Wissenschaft, in jedem Fachgebiete, so, daß alle möglichen, teilweise sogar konträre Meinungen aufeinanderprallen - manchmal sogar mehr, als es Diskutanten gibt.

Natürlich kann man Programmaufgaben so weit "herunterbrechen" (schönes Modewort), daß zum Schluß fast nur noch die einzelne Anweisung übrigbleibt. Hinsichtlich der Fehleranfälligkeit, Übersichtlichkeit und Wartbarkeit des Quelltextes, der Größe und Ablaufgeschwindigkeit des Compilates u.ä. Größen mag das aber nicht gerade Optimum sein - und schon gar nicht pauschal.

[Delphi-Laie]

Zitat:

Zitat von blauweiss (Beitrag 1058651)

Hallo,

was macht ihr da, und warum.....?:shock:

Warum nicht einfach so:

Delphi-Quellcode:

function GetGridWidth(aStringGrid: TStringGrid): integer;
var
  i: integer;
begin
  Result := 0;
  with aStringGrid do
    for i := 0 to ColCount-1 do
      inc(Result, ColWidths[i] + GridLineWidth);
end; // GetGridWidth

function GetGridHeight(aStringGrid: TStringGrid): integer;
var
  i: integer;
begin
  Result := 0;
  with aStringGrid do
    for i := 0 to RowCount-1 do
      inc(Result, RowHeights[i] + GridLineWidth);
end; // GetGridHeight

procedure AdjustFormSize(aStringGrid: TStringGrid; aForm: TForm);
begin
  with aStringGrid do
    begin
      ClientWidth := GetGridWidth(aStringGrid);
      ClientHeight := GetGridHeight(aStringGrid);
    end;
  aForm.AutoSize := true;
end; // AdjustFormSize

und dann im FormShow oder wo es passieren soll

Delphi-Quellcode:

procedure TForm1.FormShow(Sender: TObject);
begin
  AdjustFormSize(StringGrid1, Self);
end;

Ganz einfache Antwort: Weil dieser Code nicht so funktioniert, wie ich es wünsche und auch beschrieb. Nicht nur, daß die Scrollbalken zu sehen sind (sofern erlaubt), das StringGrid wird nicht vollständig dargestellt (auch dann nicht, wenn der Bildschirm dafür eigentlich groß genug ist), und das Formular ist "dank" AutoSize nicht einmal mehr manuell zoombar.

Sooo simpel ist es also wohl nicht, womit auch die Frage nach dem Warum beantwortet ist.

[BUG]

Zitat:

Zitat von Delphi-Laie (Beitrag 1058881)

[...]

Sicher kann man es auch übertreiben oder gar missverstehen und ins Gegenteil verkehren.

Aber vielfach ist Programmieren ein Kampf gegen Komplexität.
Man hackt sie in Teile, packt sie in Boxen und wendet abstrakte (und damit einfachere) Konzepte auf sie an, um Probleme zu lösen, die man im Ganzen nicht fassen kann.
Dabei sollte man sich (ohne vernünftigen Grund) nicht selbst in den Rücken fallen.


Warum sind zum Beispiel funktionale Programmiersprachen zur Zeit für viele interessant: Seiteneffektfreiheit.
Das Beschränken einer Funktion/Prozedur auf eine Aufgabe könnte man als schwächeres verwandtes Konzept verstehen. Es kann zwar Seiteneffekte geben, aber diese sollten sich nur auf für Entwickler erwartbare Teile des Programms auswirken.

Zitat:

3.) das Formular unsichtbar und wieder sichtbar machen

Zum Beispiel das ist völlig unerwartet für "Form_Skalieren". Wenn du diese Prozedure eventuell später an anderer Stelle aufrufst, wunderst du dich, warum dein Formular "flackert", onShow ausgeführt wird und dein Formular zentriert wird.
Da bist du den Fehler gefunden hast ...

[Satty67]

Ist da eigentlich die Ausgangsfrage richtig gestellt?

Das Formular an ein StringGrid anpassen ist ja eine Kleinigkeit (ClientWith auf StrigGrid.Width oder Form.AutoSize wurde ja schon genannt).

Nur beides ist natürlich wenig hilfreich, bei den tatsächlichen Wünschen des TS, wie schon festgestellt wurde. Bei AutoSize passt sich das Formular an die StringGrid-Breite an, egal wie sinnvoll die aktuelle StringGrid-Breite eingestellt ist. Gleiches natürlich bei manuellem setzen von ClientWidth.

Die Frage lautet also...

Wie ermittele ich die optimale Breite/Höhe eines StringGrid, damit die Spalten und Zeilen optimal (ohne Scrollbalken und ohne Leerräume) angezeigt werden?

Die Frage nach der Client Breite/Höhe des Formulars ist also völlig unnötig, den die ist nach Klärung der tatsächlichen Frage beantwortet.

***

Eine mögliche Funktion müsste also etwa so aussehen, wie blauweiss schon im Ansatz gezeigt hat:

Delphi-Quellcode:

function BestStringGridSize(aStringGrid : TStringGrid): TSize;
var
  i : Integer;
begin
  with aStringGrid do
  begin
    Result.cx := 0;
    for i := 0 to ColCount -1 do
      inc(Result.cx, ColWidths[i]);
    inc(Result.cx, (GridLineWidth * (ColCount -1)));

    Result.cy := 0;
    for i := 0 to RowCount -1 do
      inc(Result.cy, RowHeights[i]);
    inc(Result.cy, (GridLineWidth * (RowCount -1)));
  end;
  // Add default Bevel Border
  inc(Result.cx, 4);
  inc(Result.cy, 4);
end;

Mit Size.cx/cy wird dann einfach ClientWidth/ClientHeight des Formulars gesetzt, für eine momentane Anpassung des Formulars oder Form.AutoSize für eine permanente.

Wenn das StringGrid nicht optimal passt (also ohne Scrollbalken und ohne Leerraum), war die Berechnung zu ungenau und muss optimiert werden. Ich denke also auch, das der Ansatz von blauweiss der richtige ist.

Problem könnten Unterschiedliche Designs von XP/VISTA/Win7 werden... auf ein BevelKind-Stil sollte dann verzichtet werden, um es nicht noch schwerer zu machen.

[blauweiss]

Hallo Delphi-Laie,

Zitat:

Zitat von Delphi-Laie (Beitrag 1058707)

Die Skalierung des Stringgrids, konkret der Minimierung seiner Spaltenbreiten, ist nicht mein Problem; meine Codezeilen dazu funktionieren. Deine sind m.E. auch nicht substantiell anders; mir scheint sogar so, als daß meine sogar ein Quentchen effizienter sind, da ich die Spaltenbreiten anfangs nicht einnull(t)e (so sah man Code früher auch aus), sondern gleich mit der Spaltenbreite der ersten Zeile bestücke.

Dein Code dazu:

Delphi-Quellcode:

for l:=0 to pred(StringGrid.ColCount) do StringGrid.ColWidths[l]:=Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,0]); //Skalieren nach Tabellenkopf
for l:=0 to pred(StringGrid.ColCount) do for m:=1 to pred(StringGrid.RowCount) do
  if StringGrid.ColWidths[l]<Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,m])
  then StringGrid.ColWidths[l]:=Zellenbreitenzuschlag+StringGrid.Canvas.TextWidth(StringGrid.Cells[l,m]);

Mein Vorschlag:

Delphi-Quellcode:

procedure MinimizeColWidths(aStringGrid: TStringGrid);
var
  x, y: integer;
  onewidth, biggestwidth: integer;
begin
  with aStringGrid do
    for x := 0 to ColCount-1 do
      begin
        biggestwidth := 0;
        for y := 0 to RowCount-1 do
          begin
            onewidth := Canvas.TextWidth(Cells[x, y]);
            if (onewidth > biggestwidth) then
              biggestwidth := onewidth;
          end;
        ColWidths[x] := biggestwidth + 6;
      end;
end; // MinimizeColWidths

Dein Code ist nicht effizienter, sondern 1. unleserlich und 2. weniger performant, da bei Dir x-mal die Spaltenbreite eines StringGrids geändert wird, bei mir nur 1-mal.

Zitat:

Zitat von Delphi-Laie (Beitrag 1058707)

Das mit dem Constrain stimmt: Das Fenster ist merkwürdigerweise auf 112 Pixel (das Minimum) voreingestellt, so daß die Dekrementierungsschleife natürlich endlos wird. Merkwürdig, wenn die Codezeilen direkt verwende, funktionieren sie tadellos.... Danke auch für diesen Hinweis!

Ich will Dir nicht zu nahe treten, aber das halte ich für ausgeschlossen.

Zitat:

Zitat von hoika (Beitrag 1058716)

Delphi-Quellcode:

ColWidths[x] := biggestwidth + 6;

Der Grund für das +6 würde mich mal interessieren.
Ist das die Breite einer Scrollbar ?

Dieses +6 hatte ich als Wunsch des OP interpretiert, die Zelleninhalte nicht bündig in die Spalten zu quetschen. Sie tauchen in seinem Code als Konstante auf, die ich mir erspart habe.

Zitat:

Zitat von hoika (Beitrag 1058716)

Ich würde den Code auch mal mit "large fonts" testen.

Sollte in Canvas.TextWidth berücksichtigt werden.

Zitat:

Zitat von hoika (Beitrag 1058716)

Der Code funktioniert übrigens wohl auch nicht im FormCreate,
sondern erst im FormActivate (Canvas ist noch nicht richtig initialisiert)

Deshalb hatte ich auch FormShow vorgeschlagen.

Zitat:

Zitat von Delphi-Laie (Beitrag 1058881)

Zitat:

Zitat von sx2008 (Beitrag 1058834)

Zitat:

Zitat von Delphi-Laie (Beitrag 1058748)

Zitat:

Zitat von sx2008 (Beitrag 1058709)

Eine Procedure, Funktion oder Methode sollte genau eine Aufgabe durchführen.

Ist das nicht Ansichtssache?

Eher eine professionelle Einstellung zum Programmieren.

Eine Einstellung (und nichts anderes ist es) zum professionellen Programmieren wäre ein klein wenig dezenter gewesen. Eine Einstellung (!) jedoch als "professionell" hinzustellen, halte ich - mit Verlaub - schon ein wenig für überheblich.

Letztlich ist es doch auch (und gerade?) im Bereich der Programmierung, der Informatik, wie übrigens in jeder Wissenschaft, in jedem Fachgebiete, so, daß alle möglichen, teilweise sogar konträre Meinungen aufeinanderprallen - manchmal sogar mehr, als es Diskutanten gibt.

Natürlich kann man Programmaufgaben so weit "herunterbrechen" (schönes Modewort), daß zum Schluß fast nur noch die einzelne Anweisung übrigbleibt. Hinsichtlich der Fehleranfälligkeit, Übersichtlichkeit und Wartbarkeit des Quelltextes, der Größe und Ablaufgeschwindigkeit des Compilates u.ä. Größen mag das aber nicht gerade Optimum sein - und schon gar nicht pauschal.

Deine Reaktion auf Foristen, die Dir helfen wollen, ist ungewöhnlich. Die Herangehensweise an Deine Probleme, Deine Problembeschreibungen sowie die Reaktion auf Vorschläge Anderer scheint mir nicht professionell. Das ist nicht überheblich, denn Du wirst wohl nicht professionell (beruflich) programmieren, oder ?

Zitat:

Zitat von Delphi-Laie (Beitrag 1058882)

Ganz einfache Antwort: Weil dieser Code nicht so funktioniert, wie ich es wünsche und auch beschrieb. Nicht nur, daß die Scrollbalken zu sehen sind (sofern erlaubt), das StringGrid wird nicht vollständig dargestellt (auch dann nicht, wenn der Bildschirm dafür eigentlich groß genug ist)

Ich sehe 2 mögliche Knackpunkte:
1. Setzen von ClientWidth und ClientHeight des StringGrid funktioniert nur dann wie gewünscht, wenn StringGrid.ScrollBars = ssNone
2. TForm.AutoSize scheint tatsächlich ein Problem damit zu haben, die Größe des Forms zu vergrößern, um alle Controls darzustellen. Verkleinern funktioniert aber.
Also bietet es sich an, die Form-Größe auf einen hinreichend großen Wert zu setzen und dann AutoSize auf true zu schalten. Siehe auch unten.

Zitat:

Zitat von Delphi-Laie (Beitrag 1058882)

und das Formular ist "dank" AutoSize nicht einmal mehr manuell zoombar

Davon war zuvor nach meiner Erinnerung keine Rede, aber auch hier kann Dir geholfen werden:

Delphi-Quellcode:

aForm.AutoSize := true;
aForm.AutoSize := false;

Grüße,
blauweiss

[Delphi-Laie]

Zitat:

Zitat von blauweiss (Beitrag 1059006)

Dein Code ist nicht effizienter, sondern 1. unleserlich und 2. weniger performant, da bei Dir x-mal die Spaltenbreite eines StringGrids geändert wird, bei mir nur 1-mal.

Zweites ist richtig, wie ich nunmehr einsehe. Ich werde die Spaltenbreitenanpassung des Stringgrids diesbezüglich verändern (es zumindest versuchen). Edit: Es gelang. Allerdings sehe ich es weiterhin als ein wenig günstiger an, die Spaltenbreitenmessung nicht einzunullen, sondern gleich mit den Zellenbreiten irgendeiner Zeile (beispielsweise mit den Einträgen des Tabellenkopfes) zu beginnen.

Der Löwenanteil an der Langsamkeit meines Codes steckt allerdings in der Größenanpassung des Formulares: Pixelweise (!) wird dessen Größe verändert und jedesmal das Vorhandensein eines Scrollbalkens geprüft. Dafür ist das Formualar dann aber auch exakt angepaßt. Nur nach der Stringgridgröße zu gehen, funktioniert nämlich aufgrund der verschiedenen "Themes" in XP, Vista, 7 & Co. (Luna, Aero...) nicht so, wie es mir vorschwebt.

Zitat:

Zitat von blauweiss (Beitrag 1059006)

Zitat:

Zitat von Delphi-Laie (Beitrag 1058707)

Das mit dem Constrain stimmt: Das Fenster ist merkwürdigerweise auf 112 Pixel (das Minimum) voreingestellt, so daß die Dekrementierungsschleife natürlich endlos wird. Merkwürdig, wenn die Codezeilen direkt verwende, funktionieren sie tadellos.... Danke auch für diesen Hinweis!

Ich will Dir nicht zu nahe treten, aber das halte ich für ausgeschlossen.

112 Pixel als Formularbreite lassen sich nach meiner Recherche nicht unterschreiten. Doch das ist ohnehin obsolet, weil der Prozeduraufruf fehlerhaft war.

Zitat:

Zitat von blauweiss (Beitrag 1059006)

Deine Reaktion auf Foristen, die Dir helfen wollen, ist ungewöhnlich. Die Herangehensweise an Deine Probleme, Deine Problembeschreibungen sowie die Reaktion auf Vorschläge Anderer scheint mir nicht professionell. Das ist nicht überheblich, denn Du wirst wohl nicht professionell (beruflich) programmieren, oder ?

Diese wohl eher rhetorisch gemeinte Frage dürfte schon mein selbstredendes Pseudonym beantworten. Nun, ich fragte ursprünglich, wie man die Formulargrößeanpassung in einem Unterprogramm vereinigen, zentralisieren kann, so daß man den dafür relevanten Code nicht mehrmals im Programm aufführen muß. Den entscheidenden Hinweis dazu erhielt ich (auf den ich nicht kam und auch nie gekommen wäre, weil er mit meinen aus Turbo-Pascal-Zeiten erworbenen Pascal-Kenntnissen nicht kompabitbel ist). Das andere, was hier zusätzlich noch kam, fragte ich gar nicht, doch auch das nehme ich als Anregungen gern und dankend mit und probiere auch einen Großteil davon aus und übernehme es ggf. - auch wenn ich mich nicht zu allem äußere. Du kannst aber nicht erwarten, daß ich alles, was ich an Hinweisen bekomme, auch umsetze oder auch nur vorbehaltlos und unkritisch gutheiße, nur, weil Du vielleicht ein (studierter) Informatiker und/oder ein beruflicher Programmierer bist. Zudem weiß ich, welche Mühe eine Forumstätigkeit schon dann macht, wenn man um die fachlichen Antworten nicht verlegen ist, und weiß deshalb Hilfe durchaus zu schätzen (schau mal, in wievielen Diskussionen nicht einmal ein einziger Dank kommt!). Solltest Du anzudeuten beabsichtigen, daß ich undankbar und/oder ein unbelehrbarer Sturkopf sei, dann verwahre ich mich dagegen.

Gruß

Delphi-Laie