anchor.diff:  destructor TEasing.Destroy;
   begin
     FreeAndNil(FTimer);
  -  updater(StopValue);
     inherited;
   end; { TEasing }
   
  +procedure TEasing.Complete;
  +begin
  +  updater(StopValue);
  +  FTimer := nil;
  +end; { TEasing.Complete }
  +
  +procedure TEasing.InOutCubic;
  +begin
  +  FEasingFunc := InOutCubicEasing;
  +  StartTimer;
  +end; { TEasing.InOutCubic }
  +
  +function TEasing.InOutCubicEasing(delta_ms: integer): integer;
  +var
  +  t : real;
  +  ts: real;
  +begin
  +  t := delta_ms/Duration_ms;
  +  ts := t*t;
  +  Result := FStartValue + Round(FValueDiff * (-2 * ts * t + 3 * ts));
  +end; { TEasing.InOutCubicEasing }
  +
  +procedure TEasing.InOutQuintic;
  +begin
  +  FEasingFunc := InOutQuinticEasing;
  +  StartTimer;
  +end; { TEasing.InOutQuintic }
  +
  +function TEasing.InOutQuinticEasing(delta_ms: integer): integer;
  +var
  +  t: real;
  +begin
  +  t := delta_ms/Duration_ms;
  +  Result := FStartValue + Round(FValueDiff * t * t * t * t);
  +end;
  +
   procedure TEasing.Linear;
   begin
  +  FEasingFunc := LinearEasing;
     StartTimer;
   end; { TEasing.Linear }
   
  +function TEasing.LinearEasing(delta_ms: integer): integer;
  +begin
  +  Result := FStartValue + Round(FValueDiff / Duration_ms * delta_ms);
  +end; { TEasing.LinearEasing }
  +
   procedure TEasing.StartTimer;
   begin
  +  FValueDiff := FStopValue - FStartValue;
     FTimer := TTimer.Create(nil);
     FTimer.Interval := Tick_ms;
     FTimer.OnTimer := UpdateValue;
  
positive.code: unit GpEasing;
  
  interface
  
  
negative.code: 
  { Easing }
  
  function CreateEasing(start, stop, duration_ms, tick_ms: integer;
    updater: TProc<integer>): IEasing;
  var
    easing: TEasing;
  begin
    Result := TEasing.Create;
    easing := TEasing(Result);
    easing.StartValue := start;
    easing.StopValue := stop;
    easing.Duration_ms := duration_ms;
    easing.Tick_ms := tick_ms;
    easing.Updater := updater;
  end; { CreateEasing }
  
  class function Easing.InOutCubic(start, stop: integer; duration_ms, tick_ms: integer;
    updater: TProc<integer>): IEasing;
  begin
    Result := CreateEasing(start, stop, duration_ms, tick_ms, updater);
    TEasing(Result).InOutCubic;
  end; { Easing.InOutCubic }
  
  class function Easing.InOutQuintic(start, stop: integer; duration_ms, tick_ms: integer;
    updater: TProc<integer>): IEasing;
  begin
    Result := CreateEasing(start, stop, duration_ms, tick_ms, updater);
    TEasing(Result).InOutQuintic;
  end;
  
  class function Easing.Linear(start, stop, duration_ms, tick_ms: integer;
    updater: TProc<integer>): IEasing;
  begin
    Result := CreateEasing(start, stop, duration_ms, tick_ms, updater);
    TEasing(Result).Linear;
  end; { Easing }
  
  { TEasing }
  