temasked.pas

delphi2007界面效果控件源码

function TMaskedTransition.SubStyleToUse: Word;
begin
  if FSubStyle = 0
  then
  begin
    if RandomSubStyle = 0 then
      RandomSubStyle := Random(CountOfSubStyles(StyleToUse)) + 1;
    Result := RandomSubStyle;
  end
  else Result := FSubStyle;

  if Reversed then
    Result := CalculateReversedSubStyle(StyleToUse, Result);
end;

function TMaskedTransition.CalculateReversedSubStyle(
  const StyleValue, SubStyleValue: Word): Word;
begin
  Result := SubStyleValue;
end;

procedure TMaskedTransition.ExecuteFrame(Data: TTETransitionData;
  CurrentFrame, Step, LastExecutedFrame: Longint);
begin
  if not IsSmooth
  then ExecuteFrame1bpp(Data, CurrentFrame, Step, LastExecutedFrame,
         Frame1bppMaskBmp, Frame1bppMaskBmp2, False, True, True)
  else ExecuteFrame8bpp(Data, CurrentFrame, Step, LastExecutedFrame);
end;

function TMaskedTransition.ExecuteFrame1bpp(Data: TTETransitionData;
  CurrentFrame, Step, LastExecutedFrame: Longint; CurrentMask, PreviousMask:
  TBitmap; SmoothValue, Draw, CalcDirtyRects: Boolean): Boolean;
var
  Dst,
  Work,
  Mask: PDWordArray;
  j,
  k: Longint;
  ScanLineSize,
  MaskScanLineSize: Integer;
begin
  Assert(CurrentFrame >= 1);
  Assert(CurrentFrame <= Data.Frames);
  if not Data.AllowDeviceUpdate then
  begin
    MaskFrame(CurrentMask, CurrentFrame, Step, LastExecutedFrame, Data, Draw,
      CalcDirtyRects);
  end
  else
  begin
    MaskScanLineSize := GetBytesPerScanline(CurrentMask, pf1bit, 32);

    Data.UpdateRect   := Rect(0, 0, Data.Width, Data.Height);
    Data.UnUpdateRect := Rect(0, 0, 0, 0);
    MaskFrame(CurrentMask, CurrentFrame, Step, LastExecutedFrame, Data, Draw,
      CalcDirtyRects);
    IntersectRect(Data.UpdateRect, Data.UpdateRect, Rect(0, 0, Data.Width, Data.Height));
    IntersectRect(Data.UnUpdateRect, Data.UnUpdateRect, Data.UpdateRect);

    if not SmoothValue then
    begin
      if InversePaint then
      begin
        Mask := PDWordArray(PChar(CurrentMask.ScanLine[0]) + MaskScanLineSize);
        k    := -((CurrentMask.Width * (Data.Height)) div 32);
        InvertMask(Mask, k);
      end;

      if OptimizeMask then
      begin
        if Assigned(Data.DirtyRects) and (Data.DirtyRects.Count > 1)
        then
        begin
          for j := 0 to Data.DirtyRects.Count-1 do
            DoMaskOptimization(CurrentMask, PreviousMask, MaskScanLineSize,
              Data.DirtyRects[j], Rect(0, 0, 0, 0));
        end
        else DoMaskOptimization(CurrentMask, PreviousMask, MaskScanLineSize,
               Data.UpdateRect, Data.UnUpdateRect);
      end;

      ScanLineSize := GetBytesPerScanline(Data.DstBmp, Data.PixelFormat, 32);
      Work := PDWordArray(PChar(Data.Bitmap.ScanLine[0]) + ScanlineSize);
      Dst  := PDWordArray(PChar(Data.DstBmp.ScanLine[0]) + ScanlineSize);
      Mask := PDWordArray(PChar(CurrentMask.ScanLine[0]) + MaskScanlineSize);
      if Assigned(Data.DirtyRects) and (Data.DirtyRects.Count > 1)
      then
      begin
        for j := 0 to Data.DirtyRects.Count-1 do
          Apply1bppMask(Work, Dst, Mask, CurrentMask.Width, ScanLineSize,
            MaskScanLineSize, Data.PixelFormat, Data.DirtyRects[j],
            Rect(0, 0, 0, 0))
      end
      else
        Apply1bppMask(Work, Dst, Mask, CurrentMask.Width, ScanLineSize,
          MaskScanLineSize, Data.PixelFormat, Data.UpdateRect, Data.UnUpdateRect);
    end;
  end;
  if(not SmoothValue) and ResetMaskBmp(Data.Device) then
    FillRect(CurrentMask.Canvas.Handle, Data.UpdateRect, GetStockObject(WHITE_BRUSH));
  Result := True;
end;

procedure TMaskedTransition.ExecuteFrame8bpp(Data: TTETransitionData;
  CurrentFrame, Step, LastExecutedFrame: Longint);
const
  Optimize = True;
var
  aux: TBitmap;
  Work,
  Dst,
  Src,
  Mask,
  Mask2: Pointer;
  ScanLineSize,
  MaskScanLineSize,
  i,
  Frame,
  StartLevel,
  EndLevel,
  TopFrame,
  LowFrame,
  DecValue,
  Increment,
  FillFrames: Longint;
  DirtyRect,
  EmptyRect: TRect;

  procedure DrawFrame(Color, Frame, Step: Integer);
  begin
    Frame8bppMaskBmp.Canvas.Pen  .Color := $02000000 or RGB(Color, Color, Color);
    Frame8bppMaskBmp.Canvas.Brush.Color := Frame8bppMaskBmp.Canvas.Pen.Color;
    ExecuteFrame1bpp(Data, Frame, Step, Frame-Step, Frame8bppMaskBmp, nil,
      True, True, False);
  end;

  // Get the params
  procedure GetDecValue;
  begin
    if(LastExecutedFrame <> 0) 
    then
    begin
      DecValue := Step * StepLevel;
      if DecValue > MaxLevel then
        DecValue := MaxLevel;
    end
    else DecValue := 0;

    EndLevel := MaxLevel;
    if CurrentFrame > (Data.Frames + 1) then
      Dec(EndLevel, (CurrentFrame - (Data.Frames + 1)) * StepLevel);

    StartLevel := EndLevel - ((Step - 1) * StepLevel);
    if StartLevel < MinLevel
    then
    begin
      StartLevel := MinLevel;
      FillFrames := Step - (((EndLevel - StartLevel) div StepLevel) + 1 );
    end
    else
    begin
      FillFrames := 0;
      if StartLevel > EndLevel then
        StartLevel := EndLevel;
    end;

    TopFrame := CurrentFrame + ((EndLevel - MaxLevel) div StepLevel);
    if TopFrame > Data.Frames + 1 then
      TopFrame := Data.Frames;
    LowFrame := LastExecutedFrame - Levels;
    if LowFrame < 0 then
      LowFrame := 0;
  end;

begin
  {$ifdef LogTiming}
  if Assigned(Log) then
    Log.ChronoExtra.Start;
  {$endif LogTiming}

  MaskScanLineSize := GetBytesPerScanline(Frame8bppMaskBmp, pf8bit          , 32);
  ScanLineSize     := GetBytesPerScanline(Data.Bitmap     , Data.PixelFormat, 32);
  if AvoidPixelRepaint
  then
  begin
    aux               := Frame8bppMaskBmp;
    Frame8bppMaskBmp  := Frame8bppMaskBmp2;
    Frame8bppMaskBmp2 := aux;
    Mask2 := PChar(Frame8bppMaskBmp2.ScanLine[0]) + MaskScanLineSize;
  end
  else Mask2 := nil;
  Work := PChar(Data.Bitmap     .ScanLine[0]) + ScanlineSize;
  Dst  := PChar(Data.DstBmp     .ScanLine[0]) + ScanlineSize;
  Src  := PChar(Data.SrcBmp     .ScanLine[0]) + ScanlineSize;
  Mask := PChar(Frame8bppMaskBmp.ScanLine[0]) + MaskScanLineSize;

  GetDecValue;

  if(DecValue > 0) and (not AvoidPixelRepaint) then
  begin
    if Assigned(Data.DirtyRects) and (Data.DirtyRects.Count > 1)
    then
    begin
      for i := 0 to Data.DirtyRects.Count-1 do
        DoDecMask1(Mask, MaskScanLineSize, Frame8bppMaskBmp.Width, DecValue,
          DecValue = Levels, Data.DirtyRects[i], Rect(0, 0, 0, 0));
      
    end
    else DoDecMask1(Mask, MaskScanLineSize, Frame8bppMaskBmp.Width, DecValue,
           DecValue = Levels, Data.UpdateRectBak, Data.UnUpdateRectBak);
  end;
  if Assigned(Data.DirtyRects) then
    Data.DirtyRects.Clear;

  if AvoidPixelRepaint
  then
  begin
    if InversePaint then
      DrawFrame(255, CurrentFrame + ((EndLevel - MaxLevel) div StepLevel) + 1, 1);
    i          := EndLevel;
    EndLevel   := StartLevel;
    StartLevel := i;
    Increment  := -StepLevel;
  end
  else
  begin
    if FillFrames > 0 then
    begin
      if InversePaint
      then
      begin
        Frame8bppMaskBmp.Canvas.Pen  .Color := $02000000 or RGB(0, 0, 0);
        Frame8bppMaskBmp.Canvas.Brush.Color := Frame8bppMaskBmp.Canvas.Pen.Color;
        Frame8bppMaskBmp.Canvas.FillRect(Data.UpdateRectBak);
      end
      else DrawFrame(0, LowFrame + FillFrames, FillFrames);
    end;
    Increment := StepLevel;
  end;

  i := StartLevel;
  // Draw the new levels
  repeat
    Frame := CurrentFrame + ((i - MaxLevel) div StepLevel);
    DrawFrame(i, Frame, 1);
    Inc(i, Increment);
  until i = EndLevel + Increment;

  if(not AvoidPixelRepaint) and
    InversePaint            and
    (CurrentFrame < Data.Frames)
  then DrawFrame(255, CurrentFrame + ((EndLevel - MaxLevel) div StepLevel) + 1, 1)
  else if(FillFrames > 0) and (not InversePaint) then
    DrawFrame(0, LastExecutedFrame + FillFrames, FillFrames);

  // Get the dirty rects
  ExecuteFrame1bpp(Data, TopFrame, TopFrame - LowFrame, LowFrame,
    Frame8bppMaskBmp, nil, True, False, True);

  if(DecValue > 0) and AvoidPixelRepaint then
  begin
    if Assigned(Data.DirtyRects) and (Data.DirtyRects.Count > 1)
    then
    begin
      for i := 0 to Data.DirtyRects.Count-1 do
        DoDecMask2(Mask, Mask2, MaskScanLineSize, Frame8bppMaskBmp.Width,
          DecValue, DecValue = Levels, Data.DirtyRects[i], Rect(0, 0, 0, 0));
    end
    else DoDecMask2(Mask, Mask2, MaskScanLineSize, Frame8bppMaskBmp.Width,
           DecValue, DecValue = Levels, Data.UpdateRect, Data.UnUpdateRect);
  end;

  if Assigned(Data.DirtyRects) and (Data.DirtyRects.Count > 1)
  then
  begin
    EmptyRect := Rect(0, 0, 0, 0);
    for i := 0 to Data.DirtyRects.Count-1 do
    begin
      DirtyRect := Data.DirtyRects[i];
      Apply256MaskS(TApply256MaskSProc(Apply256MaskSProc), Work,
        Dst, Src, Mask, ScanLineSize, MaskScanLineSize, Frame8bppMaskBmp.Width,
        DirtyRect, EmptyRect);
      Data.DirtyRects[i] := DirtyRect;
    end
  end
  else
    Apply256MaskS(TApply256MaskSProc(Apply256MaskSProc), Work,
      Dst, Src, Mask, ScanLineSize, MaskScanLineSize, Frame8bppMaskBmp.Width,
      Data.UpdateRect, Data.UnUpdateRect);

  {$ifdef LogTiming}
  if Assigned(Log) then
  begin
    Log.ChronoExtra.Pause;
    Log.CurrentItem^.LogExTime := Log.ChronoExtra.Milliseconds;
    Log.ChronoExtra.Reset;
  end;
  {$endif LogTiming}
end;

function TMaskedTransition.GetInfo(Device: TTETransitionDevice):
  TTETransitionInfo;
begin
  Result := inherited GetInfo(Device) +
    [
      tetiMillisecondsCapable,
      tetiNeedOffScreenBmp,
      tetiOffScreenBmpCapable,
      tetiStaticSrcPixels
    ];
end;

function TMaskedTransition.MaxSmoothingLevel: Integer;
begin
  Result := 7;
end;

end.