Mehrere Formulare an Stringgridgröße anpassen

**Delphi-Laie**

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

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:

zusammenfalten · markieren

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")

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:

zusammenfalten · markieren

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...

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

Hallo, besten Dank für Eure Antworten!

Zitat von Hansa:

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 von Hansa:

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

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 von Hansa:

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.

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.

markieren

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;