Zitat von Der schöne Günther:

OnActivate -Event

Kommt jedes mal wenn die Form/App den Focus erhält... (Windows)
Create nur 1x!

Doch nochmal zum Thread Thema

Beispiel alt:

markieren

Delphi-Quellcode:

procedure TMainForm.FormCreate(Sender: TObject);
begin
  LeftPanel.Width := 100;
  RightPanel.Width := 100;
  // Center Panel is align Client... Aber wie groß jetzt
  Application.Processmessages;
  Width_für_neue_Berechnung := CenterPanel.Width;
  Berechne_Element_auf_CenterPanel(Width_für_neue_Berechnung);
  ...
end;

Beispiel neu:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMainForm.FormCreate(Sender: TObject);
begin
  LeftPanel.Width := 100;
  RightPanel.Width := 100;
  TThread.Queue(NIL,Procedure ()
                      begin
                        Width_für_neue_Berechnung := CenterPanel.Width;
                        Berechne_Element_auf_CenterPanel(Width_für_neue_Berechnung);
                      end);

  // In der Hoffnung hier den Wert nicht auch zu brauchen...
end;

Mavarik

Zitat von Mavarik:

Kommt jedes mal wenn die Form/App den Focus erhält... (Windows)
Create nur 1x!

Ja. Zugegeben, man muss man sich einmal merken ob das OnActivate nun schon mal stattgefunden hat oder nicht:

zusammenfalten · markieren

Delphi-Quellcode:

type
   TBaseForm = class(TForm)
      procedure FormActivate(Sender: TObject);
      private var
         firstActivateHappened: Boolean;
      public
         procedure initGUI(); virtual;
   end;

procedure TBaseForm.initGUI();
begin
   // Empty
end;

procedure TBaseForm.FormActivate(Sender: TObject);
begin
   if (not firstActivateHappened) then begin
      initGUI();
      firstActivateHappened := True;
   end;
   inherited;
end;

Das sind zwar zwei Zeilen mehr als es im OnCreate zu machen, aber eine Boolean-Variable ist im Vergleich zu einem TThread.Queue(..) oder Application.ProcessMessages() so herrlich unspektakulär

Du hättest nun einfach

markieren

Delphi-Quellcode:

procedure TMainForm.initGUI();
begin
   inherited;   
   Berechne_Element_auf_CenterPanel(CenterPanel.Width);
end;

Genau für Dinge wie "Wie groß ist das Element nun?" nehme ich immer "meine" OnActivate -Lösung und war damit eigentlich immer glücklich.

Ich hab sowas in OnShow ebenfalls mit einer Variable FirstShow.

Ja, das wäre ja genau das gleiche. Ich meine, ich hatte irgendeinen Grund, OnActivate statt OnShow zu nehmen. Wenn ich nicht falsch liege, kommt erst OnShow , dann OnActivate .

Hier mal ein Best Practice und DontDo Beispiel

zusammenfalten · markieren

Delphi-Quellcode:

unit Form.Main;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Objects,
  FMX.Controls.Presentation, FMX.StdCtrls;

type
  TForm1 = class( TForm )
    ToolBar1: TToolBar;
    Text1: TText;
    Label1: TLabel;
    procedure FormCreate( Sender: TObject );
  private
    procedure MeasureTextControl( AText: TText );
    procedure QueueMeasureTextControl( AText: TText );
    procedure DontDoMeasureTextControl( AText: TText );
  public

  end;

var
  Form1: TForm1;

implementation

{$R *.fmx}

{ TForm1 }

procedure TForm1.FormCreate( Sender: TObject );
begin
  Text1.Align := TAlignLayout.Client;

  // funktioniert
  // MeasureTextControl( Text1 );

  // funktioniert - Best Practice
  QueueMeasureTextControl( Text1 );

  // Fehlerhafte Darstellung
  // DontDoMeasureTextControl( Text1 );
end;

procedure TForm1.DontDoMeasureTextControl( AText: TText );
begin
  Application.ProcessMessages;
  MeasureTextControl( AText );
end;

procedure TForm1.MeasureTextControl( AText: TText );
begin
  Label1.Text := AText.Width.ToString;
end;

procedure TForm1.QueueMeasureTextControl( AText: TText );
begin
  TThread.Queue( nil,
    procedure
    begin
      MeasureTextControl( AText );
    end );
end;

end.

TThread.Queue kannst du dir an der Stelle sparen, da es sofort ausgeführt wird.
(zumindestens in Windows, aber vermutlich auch im NextGen usw.)

http://www.delphipraxis.net/179193-t...der-queue.html

Zitat von himitsu:

TThread.Queue kannst du dir an der Stelle sparen, da es sofort ausgeführt wird.
(zumindestens in Windows, aber vermutlich auch im NextGen usw.)

http://www.delphipraxis.net/179193-t...der-queue.html

Das kommt davon, wenn man ungetesten code postet...

Hatte ich inzwischen schon geändert... in einen OnIdle Handler...

Ja, ja ...

Dann ebend so ... menno

markieren

Delphi-Quellcode:

procedure TForm1.QueueMeasureTextControl( AText: TText );
begin
  TThread.ExecLater<TText>( MeasureTextControl, AText );
end;

Gut, dafür braucht man einen ThreadHelper

zusammenfalten · markieren

Delphi-Quellcode:

unit ThreadHelper;

interface

uses
  System.Classes,
  System.SysUtils;

type
  TThreadHelper = class helper for TThread
    class procedure ExecLater( AProc: TProc ); overload;
    class procedure ExecLater<T>( AProc: TProc<T>; AArg: T ); overload;
    class procedure ExecLater<T1, T2>( AProc: TProc<T1, T2>; AArg1: T1; AArg2: T2 ); overload;
    class procedure ExecLater<T1, T2, T3>( AProc: TProc<T1, T2, T3>; AArg1: T1; AArg2: T2; AArg3: T3 ); overload;
    class procedure ExecLater<T1, T2, T3, T4>( AProc: TProc<T1, T2, T3, T4>; AArg1: T1; AArg2: T2; AArg3: T3; AArg4: T4 ); overload;
  end;

implementation

{ TThreadHelper }

class procedure TThreadHelper.ExecLater( AProc: TProc );
begin
  TThread.CreateAnonymousThread(
    procedure
    begin
      TThread.Current.Synchronize(
        procedure
        begin
          AProc( );
        end );
    end ).Start( );
end;

class procedure TThreadHelper.ExecLater<T1, T2, T3, T4>( AProc: TProc<T1, T2, T3, T4>; AArg1: T1; AArg2: T2; AArg3: T3; AArg4: T4 );
begin
  TThread.CreateAnonymousThread(
    procedure
    begin
      TThread.Current.Synchronize(
        procedure
        begin
          AProc( AArg1, AArg2, AArg3, AArg4 );
        end );
    end ).Start( );
end;

class procedure TThreadHelper.ExecLater<T1, T2, T3>( AProc: TProc<T1, T2, T3>; AArg1: T1; AArg2: T2; AArg3: T3 );
begin
  TThread.CreateAnonymousThread(
    procedure
    begin
      TThread.Current.Synchronize(
        procedure
        begin
          AProc( AArg1, AArg2, AArg3 );
        end );
    end ).Start( );
end;

class procedure TThreadHelper.ExecLater<T1, T2>( AProc: TProc<T1, T2>; AArg1: T1; AArg2: T2 );
begin
  TThread.CreateAnonymousThread(
    procedure
    begin
      TThread.Current.Synchronize(
        procedure
        begin
          AProc( AArg1, AArg2 );
        end );
    end ).Start( );
end;

class procedure TThreadHelper.ExecLater<T>( AProc: TProc<T>; AArg: T );
begin
  TThread.CreateAnonymousThread(
    procedure
    begin
      TThread.Current.Synchronize(
        procedure
        begin
          AProc( AArg );
        end );
    end ).Start( );
end;

end.

Ich habe mir erlaubt, den Themen-Titel anzupassen.
Vermutlich geht es eher um "vermeiden" als "vernichten".

Zitat von Der schöne Günther:

Ja. Zugegeben, man muss man sich einmal merken ob das OnActivate nun schon mal stattgefunden hat oder nicht:

zusammenfalten · markieren

Delphi-Quellcode:

type
   TBaseForm = class(TForm)
      procedure FormActivate(Sender: TObject);
      private var
         firstActivateHappened: Boolean;
      public
         procedure initGUI(); virtual;
   end;

procedure TBaseForm.initGUI();
begin
   // Empty
end;

procedure TBaseForm.FormActivate(Sender: TObject);
begin
   if (not firstActivateHappened) then begin
      initGUI();
      firstActivateHappened := True;
   end;
   inherited;
end;

Die Hilfsvariablensteuerung kann man sich sparen, wenn sich die Ereignis- Routine selbst vom Objekt/Instanz abkoppelt.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TBaseForm = class(TForm)
    procedure FormActivate(Sender: TObject);
  public
    procedure initGUI(); virtual;
  end;

procedure TBaseForm.initGUI();
begin
   // Empty
end;

procedure TBaseForm.FormActivate(Sender: TObject);
begin
   OnActivate = nil;
   initGUI();
   firstActivateHappened := True;
   inherited;
end;

Die selbe Funktionalität wie oben, nur mit weniger Code.