shockwavelist.pas

delphi中TShockwaveFlash的扩展

    WM_LBUTTONUP,
    WM_RBUTTONDOWN,
    WM_RBUTTONUP,
    WM_MOUSEMOVE,
    WM_MBUTTONDOWN,
    WM_MBUTTONUP: Result:=true;
  end;
end;

procedure TShockwaveFlashList.Pan(x, y: Integer; mode: SYSINT);
begin
  if fCurentMovie<>nil Then fCurentMovie.Pan(x,y,mode);
end;

procedure TShockwaveFlashList.Play;
begin
  if fCurentMovie<>nil Then fCurentMovie.Play;
end;

procedure TShockwaveFlashList.RefreshMoviesLayout;
Var i: integer;
    Kw,Kh,W,H,n,Col,Row: integer;
begin
  if (csLoading in ComponentState) Then exit;
  if fItems.Count=0 Then exit;
  for i:=0 to fItems.Count-1 do
    begin
      fItems.Items[i].SWF.Visible:=false;
      fItems.Items[i].SWF.CreateWnd;
    end;
  if fMovieWidthToHeight<=0 Then fMovieWidthToHeight:=100;
  if (fCountForLayout=0) or (fCountForLayout>fItems.Count) Then n:=fItems.Count-fItemIndex
    Else n:=fCountForLayout;
  Case fMoviesLayout of
    mlSingle:
      begin
        if fItems.Items[ItemIndex].SWF=nil Then exit;
        With fItems.Items[ItemIndex].SWF do
          begin
            Align:=alNone;
            SetBounds(fGleam,fGleam,self.Width-2*fGleam,self.Height-2*fGleam);
            Visible:=true;
            CreateWnd;
          end;
      end;
    mlMatrixLR, mlMatrixTB:
      begin
        if fKeepMoviesSize Then
          begin
            W:=fMoviesWidth;
            H:=fMoviesHeight;
          end
         Else
          begin
            H:=Trunc(Sqrt(Width*Height*100/(fMovieWidthToHeight*n)));
            W:=Trunc(H*fMovieWidthToHeight/100);
          end;
        Kw:=Trunc((Width-fGleam)/(W+fGleam));
        Kh:=Trunc((Height-fGleam)/(H+fGleam));
        if not fKeepMoviesSize Then
          begin
            if Kw*Kh<n Then Inc(Kw);
            if Kw*Kh<n Then Inc(Kh);
            H:=Trunc((Height-fGleam*(Kh+1))/Kh);
            W:=Trunc((Width-fGleam*(Kw+1))/Kw);
            if W>=Round(H*fMovieWidthToHeight/100) Then W:=Round(H*fMovieWidthToHeight/100)
                                                   Else H:=Round(W*100/fMovieWidthToHeight);
          end;
        Col:=1;
        Row:=1;
        i:=fItemIndex;
        While i<=fItemIndex+n-1 do
          begin
            if Items.Items[i].SWF<>nil Then With Items.Items[i].SWF do
              begin
                Align:=alNone;
                SetBounds(W*(Col-1)+fGleam*Col,H*(Row-1)+fGleam*Row,W,H);
                Visible:=true;
                CreateWnd;
              end;
            if fMoviesLayout=mlMatrixLR Then
              begin
                Inc(Col);
                if Col>Kw Then begin Col:=1; Inc(Row) end;
              end;
            if fMoviesLayout=mlMatrixTB Then
              begin
                Inc(Row);
                if Row>Kh Then begin Row:=1; Inc(Col) end;
              end;
            Inc(i);
          end;
      end;
    mlDiagonal:
      begin
        if fKeepMoviesSize Then
          begin
            W:=fMoviesWidth;
            H:=fMoviesHeight;
          end
         Else
          begin
            W:=Trunc((Width-fGleam*(n+1))/n);
            H:=Trunc((Height-fGleam*(n+1))/n);
            if (W*100/fMovieWidthToHeight)<H Then H:=Round(W*100/fMovieWidthToHeight)
              Else W:=Round(H*fMovieWidthToHeight/100);
          end;
        i:=0;
        While i<=n-1 do
          begin
            if Items.Items[i].SWF<>nil Then With Items.Items[i+fItemIndex].SWF do
              begin
                Align:=alNone;
                SetBounds(W*i+fGleam*(i+1),H*i+fGleam*(i+1),W,H);
                Visible:=true;
                CreateWnd;
                Inc(i);
              end;
          end;
      end;
  end; {Case}
end;

procedure TShockwaveFlashList.Rewind;
begin
  if fCurentMovie<>nil Then fCurentMovie.Rewind;
end;

procedure TShockwaveFlashList.SetAlignMode(const Value: Integer);
Var i: integer;
begin
  fAlignMode:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.AlignMode:=Value;
end;

procedure TShockwaveFlashList.SetBackgroundColor(const Value: TColor);
Var i: integer;
begin
  fBackgroundColor:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.BackgroundColor:=TColorToSWFColor(Value);
end;

procedure TShockwaveFlashList.SetCountForLayout(const Value: integer);
begin
  fCountForLayout:=Value;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetGleam(const Value: integer);
begin
  fGleam:=Value;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetItem(const Value: integer);
begin
  if Value>fItems.Count-1 Then exit;
  fItemIndex:=Value;
  fCurentMovie:=fItems.Items[Value].fSWF;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetItems(const Value: TSWFCollection);
begin
  fItems.Assign(Value);
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetKeepMoviesSize(const Value: boolean);
begin
  fKeepMoviesSize:=Value;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetLockMouseClick(const Value: boolean);
Var i: integer;
begin
  fLockMouseClick:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems.Items[i].fSWF<>nil Then fItems.Items[i].fSWF.LockMouseClick:=Value;
end;

procedure TShockwaveFlashList.SetMenu(const Value: boolean);
Var i: integer;
begin
  fMenu:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.Menu:=Value;
end;

procedure TShockwaveFlashList.SetMoviesHeight(const Value: integer);
begin
  fMoviesHeight:=Value;
  if fKeepMoviesSize Then RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetMoviesLayout(const Value: TMoviesLayout);
begin
  fMoviesLayout:=Value;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetMoviesWidth(const Value: integer);
begin
  fMoviesWidth:=Value;
  if fKeepMoviesSize Then RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetMovieWidthToHeight(const Value: integer);
begin
  fMovieWidthToHeight:=Value;
  RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.SetPlaying(const Value: boolean);
Var i: integer;
begin
  fPlaying := Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.Playing:=Value;
end;

procedure TShockwaveFlashList.SetQuality(const Value: Integer);
Var i: integer;
begin
  fQuality:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.Quality:=Value;
end;

procedure TShockwaveFlashList.SetScaleMode(const Value: Integer);
Var i: integer;
begin
  fScaleMode:=Value;
  for i:=0 to fItems.Count-1 do
    if fItems[i].fSWF<>nil Then fItems[i].fSWF.ScaleMode:=Value;
end;

procedure TShockwaveFlashList.SetZoomRect(left, top, right, bottom: Integer);
begin
  if fCurentMovie<>nil Then fCurentMovie.SetZoomRect(left,top,right,bottom);
end;

procedure TShockwaveFlashList.Stop;
begin
  if fCurentMovie<>nil Then fCurentMovie.Stop;
end;

procedure TShockwaveFlashList.StopPlay;
begin
  if fCurentMovie<>nil Then fCurentMovie.StopPlay;
end;

function TShockwaveFlashList.TColorToSWFColor(Value: TColor): integer;
Var R,G,B: byte;
begin
  B:=Trunc(Value/sqr(256));
  G:=Trunc((Value-B*sqr(256))/256);
  R:=Trunc(Value-B*sqr(256)-G*256);
  Result:=R shl 16 + G shl 8 + B;
end;

procedure TShockwaveFlashList.WndProc(var Message: TMessage);
begin
  inherited;
  if Message.Msg=WM_SIZE Then RefreshMoviesLayout;
end;

procedure TShockwaveFlashList.Zoom(factor: SYSINT);
begin
  if fCurentMovie<>nil Then fCurentMovie.Zoom(factor);
end;

{ TSWFChildren }

constructor TSWFChildren.Create(AOwner: TComponent; AHost:TShockwaveFlashList);
Var i: integer;
    p: pointer;
    s: string;
    AParent: TWinControl;
begin
  Host:=AHost;
  i:=1;
  Repeat
    s:=self.ClassName+IntToStr(i);
    p:=nil;
    AParent:=Host;
    While (p=nil) and (AParent<>nil) do
      begin
        p:=AParent.FindComponent(s);
        AParent:=AParent.Parent;
      end;
    Inc(i);
  Until p=nil;
  self.Name:=s;
  inherited Create(AOwner);
end;

procedure TSWFChildren.WndProc(var Message: TMessage);
Var oldX,oldY: integer;
begin
  if Host<>nil Then
    begin
      if Host.MessageSwfNeed(self,Message) Then
        begin
          oldX:=TSmallPoint(Message.LParam).x;
          oldY:=TSmallPoint(Message.LParam).y;
          TSmallPoint(Message.LParam).x:=oldX+Left;
          TSmallPoint(Message.LParam).y:=oldY+Top;
          Host.WndProc(Message);
          TSmallPoint(Message.LParam).x:=oldX;
          TSmallPoint(Message.LParam).y:=oldY;
        end;
      if (csDesigning in ComponentState) and (Host.MessageSwfNeed(self,Message)) Then
        begin
          Message.Result:=0;
          exit;
        end;
    end;
  inherited WndProc(Message);
end;


end.