Panel geschmeidig ein- und ausblenden?

[Glados]

Ich glaube ich bin zu dumm dafür das umzukehren

Delphi-Quellcode:

   while (D < Duration) do
    begin
     Button1.Left := Button1.Left - Round(POS_START * CalculateEasingCurveOut(D, Duration));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;

[jaenicke]

Es gibt übrigens auch noch die API Funktion AnimateWindow... Damit geht so etwas auch und sieht meistens auch besser aus als eigene Funktionen:
https://msdn.microsoft.com/de-de/lib...%3Dvs.85).aspx

[Glados]

Das ist nicht genau das was ich suche.
Manuell ist in meinem Fall definitiv besser. AnimateWindow macht nicht das was ich möchte.

Zacherl Lösung ist wirklich sehr gut und sieht gut aus. Nur verstehe ich nicht die Logik wie man es umkehrt.

Verstanden habe ich es zwar nicht, aber so läuft es fast. Er fährt von 20 (START) bis 200 (END). Umgekehrt funktioniert es nicht.

Delphi-Quellcode:

const
 Duration = 3000;
 POS_START = 20;
 POS_END = 200;

 if Button1.Left = POS_START then
  begin
   while (D < Duration) do
    begin
     Button1.Left := POS_START + Round(POS_END * CalculateEasingCurve(D, Duration));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;
  end
 else
  begin
   while (D < Duration) do
    begin
     Button1.Left := POS_END - Round(POS_END * CalculateEasingCurve(D, Duration));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;
  end;

Vorzeitige Lösung

Delphi-Quellcode:

     if Panel1.Width = POS_START then
      begin
       iNegative := 1;
       iTmp := POS_START
      end
     else
      begin
       iNegative := -1;
       iTmp := POS_START + POS_END;
      end;

     while (D < Duration) do
      begin
       Panel1.Width := iTmp + (Round(POS_END * CalculateEasingCurve(D, Duration)) * iNegative);
       Application.ProcessMessages;
       D := GetTickCount - C;
      end;

[Glados]

Ich muss leider noch einmal nerven. Irgendwas stimmt hier leider noch nicht.
Es hat irgendwas mit der markierten Zeile zu tun

Delphi-Quellcode:

 if Control.Height >= iMaxHeight then
  begin
   iNegative := -1;
   iTmp := iMinHeight + iMaxHeight; // DIESE ZEILE
  end
 else // if Control.Height <= iMinHeight then
  begin
   iNegative := 1;
   iTmp := iMinHeight
  end;

 while (D < 3000) do
  begin
   Control.Height := iTmp + (Round(iMaxHeight * Easing(D, 3000)) * iNegative);
   Application.ProcessMessages;
   D := GetTickCount - C;
  end;

Das ist bei mir jetzt eine Prozedur. Control ist ein TWinControl. Wenn ich dort als Control ein Formular TForm (aktuell 350 Height) übergebe mit Minimum 220 (iMinHeight) und Maximum 350 (iMaxHeight), dann wird das Formular erst einmal komplett lang gezogen (Min + Max). Bei anderen Controls funktioniert das ohne Probleme und ohne dieses initiale Langziehen.

Meine Grundfrage wäre also... wie sieht das da unten umgekehrt aus?

Delphi-Quellcode:

   while (D < Duration) do
    begin
     Button1.Left := POS_START + Round(POS_END * CalculateEasingCurve(D, DURATION));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;

[stahli]

Müsste es vielleicht so sein?
 iTmp := iMaxHeight Es würde dann die maximale Höhe eingestellt (wenn ich das richtig interpretiere).
Sonst startest Du mit der maximalen+minimalen Höhe.

[Glados]

Ich habe dir hier mal ein Beispiel gebastelt. Einfach in einen Button packen (Form sollte initial ~500 hoch sein) und die Caption beobachten.

Delphi-Quellcode:

function QuintEasing(TimePassed, Duration: DWord): Single;
var
 P: Double;
begin
 P := TimePassed / (Duration / 2);
 if (P < 1) then
  begin
   Result := 1 / 2 * P * P * P * P * P;
  end
 else
  begin
   P := P - 2;
   Result := 1 / 2 * (P * P * P * P * P + 2);
  end;
end;


Button
var
 C, D: Cardinal;
const
 Duration = 3000;
 POS_START = 200; // Größe eingeklappt
 POS_END = 500; // Größe ausgeklappt
begin
 C := GetTickCount;
 D := 0;
 if Height >= POS_END then
  begin
   // EDIT
   // Mit diesem Spagetti-Code funktioniert es auch. Aber das ist sicherlich alles mehr als falsch
   // POS_END := POS_END - POS_START - (POS_END - Height);
   // POS_START := Height; 

   while (D < Duration) do
    begin
     Height := POS_START - Round(POS_END * QuintEasing(D, Duration));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;

   Caption := '1. ' + Height.ToString;

   // Formular wird beim ersten Klick erst einmalig 700px hoch eingestellt (falsch) und fährt dann auf 200px runter (richtig)
  end
 else
  begin
   // POS_START := Height;
   // POS_END := POS_END - POS_START;
   // Diese beiden Zeilen reparieren dieses If-Statement. Oben verstehe ich die umgekehrte Logik aber nicht und finde keine Lösung.

   while (D < Duration) do
    begin
     Height := POS_START + Round(POS_END * QuintEasing(D, Duration));
     Application.ProcessMessages;
     D := GetTickCount - C;
    end;

   Caption := '2. ' + Height.ToString;

   // Ein anschließender Klick hier stellt das Formular 700px hoch ein (falsch)
  end;

Edit: siehe Kommentar bei Height >= POS_END

[stahli]

Die Funktion ermittelt nicht, welche Höhe beim Start vorliegt, sondern entscheidet nur, ob von groß nach klein oder von klein nach groß animiert wird.

Fixen kannst Du das ggf. so:

Delphi-Quellcode:

    while (D < Duration) do
    begin
      H := POS_START + POS_END - Round(POS_END * QuintEasing(D, Duration));
      if (H < Height) then
        Height := H;
      Application.ProcessMessages;
      D := GetTickCount - C;
    end;

So entsteht allerdings am Anfang eine Verzögerung, da ja die getimeten Berechnungen trotzdem erfolgen.
Um das zu Verhindern müsstest Du die Berechnungsdauer (Duration) verkürzen oder besser in die Berechnung die Starthöhe einbeziehen.