Hay un deslizamiento (animado) en el panel de componentes para Delphi?

Por ejemplo se puede encontrar en Raize Componentes (un panel de la izquierda con un «Punto Caliente» o mostrar/ocultar el botón).

No necesito un resizeable panel, pero un panel que se puede deslizar horizontalmente y sin problemas desde la izquierda a la derecha + que tiene un mostrar/ocultar el botón (no es gran cosa si sin ese botón).

Gracias!

Este artículo podría ser de uso: delphi.about.com/od/delphi-tips-2011/qt/…
Ver FoldingPanel v1.3 aquí: torry.net/authorsmore.php?id=2386 la he usado durante años. Tiene un bonito chevron de mapa de bits.

OriginalEl autor maxfax | 2011-09-01

5 Comentarios

  1. 21

    Intentar NLDSideBar, un componente contenedor escrito por mí mismo que es plegable y alineados a lo largo del lado izquierdo o derecho de su padre.

    Interfaz:

    property Align: TSideBarAlign default alLeft;
    property AutoHide: Boolean default False;
    property Hint: String;
    property MinWidth: Integer default DefWidth;
    property OnAutoHideChanged: TNotifyEvent;
    property OnHide: TNotifyEvent;
    property PinButtonDownHint: String;
    property PinButtonUpHint: String;
    property PinButtonVisible: Boolean default True;
    property Resizable: Boolean default True;
    property SideButtonWidth: Integer default DefSideButtonWidth;
    property Caption;
    property Color default clBtnFace;
    property Font;
    property ParentColor default False;
    property ParentFont;
    property ParentShowHint;
    property PopupMenu;
    property TabOrder;
    property TabStop;

    Delphi: deslizamiento (animado) en el panel de

    O tal vez esta versión anterior que está animado. De uso libre, libre de modificar.

    lo Siento por ser auto-promocionales, pero creo que es una respuesta a la pregunta.

    Usted no tiene que pedir perdón por la auto-promoción, es perfectamente aceptable siempre y cuando usted revele su participación.
    Yo siempre upvote la auto-promoción de fuente abierta cosas!
    Yo siempre upvote la auto-promoción si la respuesta a la pregunta a la perfección.
    y parece que nunca para actualizar más allá de Delphi 7 🙂 lo he probado en xe2, poner dos paneles laterales y comportamiento del tristemente menos intuitiva… Supongo que siempre sólo había un panel a un lado 🙂
    Gracias! Es un bug. Agregar BringToFront al final de cada bloque en UpdatePlacement.

    OriginalEl autor NGLN

  2. 10

    Terminamos la construcción de nuestro propio control. No hemos podido encontrar nada que funcionó bastante de cómo queríamos. Se terminó por no ser tan difícil. Estoy seguro de que hay situaciones que no están manejando correctamente, pero para esto está funcionando bien para nosotros.

    El siguiente código es el uso de cxGroupBox porque teníamos que buscar para que coincida con el resto de nuestra aplicación. Que pueden cambiar para un normal GroupBox.

    Estamos utilizando este en dos lugares. En un caso tenemos un número de estos paneles en el interior de un estándar de Delphi Panel de Flujo (no estoy seguro de qué versión de que fue agregado). Cuando nuestro DynPanel se derrumba todo lo que se mueve automáticamente hacia arriba y llena el espacio.

    Que en el otro caso tenemos una ventana que se divide entre una sección principal y una caja de herramientas. Los dos están separados por un estándar de splitter. La ventana principal se establece para alinear al cliente. Cuando nuestro panel contrae o se expande. el divisor se mueve automáticamente y se expande la sección principal.

    Nunca nos hizo bastante conseguir el «contenedor» de control de la materia a trabajar por lo que los elementos que se agregan al panel se puede mover fuera de los límites normalmente se esperaría en un cuadro de grupo. Pero que no nos cause problemas, así que simplemente se dejó. Esto también no tiene en cuenta DPI cambios en relación con el tamaño del botón. El título se hará más grande, pero el botón no.

    
    unit DynPanel;
    interface
    uses
    Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
    ExtCtrls, cxGroupBox;
    const
    DEFAULTBUTTONWIDTH = 16;
    DEFAULTWIDTH  = 161;
    DEFAULTHEIGHT = 81;
    cButtonPadding = 8;
    cCollapsePadding = 3;
    cCaptionPadding = '       ';
    cCollapsedSize = DEFAULTBUTTONWIDTH + cCollapsePadding;
    cAutoCollapseSize = DEFAULTBUTTONWIDTH + cButtonPadding;
    type
    TCollapseDirection = (cdUp, cdRight, cdLeft);
    TMinDemension = cAutoCollapseSize..High(Integer);
    TDynPanel = class(TPanel)
    private
    FGroupBox: TcxGroupBox;
    FButtonPanel: TPanel;
    FButtonImage: TImage;
    FExpand: Boolean;
    FOldHeight: Integer;
    FOldWidth: Integer;
    FCollapseDirection: TCollapseDirection;
    FOrigGroupBoxCaption: String;
    FAutoCollapseHeight: TMinDemension;
    FAutoCollapseWidth: TMinDemension;
    FButtonPadding: integer;
    FCollapsePadding: integer;
    FCollapsedSize: integer;
    procedure SetExpand(Value: Boolean);
    procedure SetGroupBoxCaption(Value: string);
    procedure ButtonMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure CMShowingChanged(var Message: TMessage); message CM_SHOWINGCHANGED;
    procedure EnableControls(Value: Boolean);
    procedure SetCollapseDirection(Value: TCollapseDirection);
    procedure ConfigurePanel;
    procedure SetMinHeight(Value: TMinDemension);
    procedure SetMinWidth(Value: TMinDemension);
    procedure UpdateImage();
    protected
    procedure Resize; override;
    procedure ChangeScale(M, D: Integer); override;
    public
    constructor Create(AOwner: TComponent); override;
    property OldHeight: Integer read FOldHeight write FOldHeight;
    property OldWidth: Integer read FOldWidth write FOldWidth;
    property GroupBox: TcxGroupBox read FGroupBox;
    published
    property Caption: string read FOrigGroupBoxCaption write SetGroupBoxCaption;
    property Expand: Boolean read FExpand write SetExpand;
    property BevelOuter default bvNone;
    property CollapseDirection: TCollapseDirection read FCollapseDirection write SetCollapseDirection default cdUp;
    property AutoCollapseHeight: TMinDemension read FAutoCollapseHeight write SetMinHeight default cAutoCollapseSize;
    property AutoCollapseWidth: TMinDemension read FAutoCollapseWidth write SetMinWidth default cAutoCollapseSize;
    end;
    procedure Register;
    implementation
    {$R 'ButtonImages\ButtonImages.res' 'ButtonImages\ButtonImages.rc'}
    uses cxEdit;
    procedure Register;
    begin
    RegisterComponents('AgWare', [TDynPanel]);
    end;
    { TDynPanel }
    {
    TDynPanel.Create
    ---------------------------------------------------------------------------
    }
    constructor TDynPanel.Create(AOwner: TComponent);
    begin
    inherited Create(AOwner);
    Self.ControlStyle := ControlStyle - [csSetCaption];
    Self.Width := DEFAULTWIDTH;
    Self.Height := DEFAULTHEIGHT;
    BevelOuter := bvNone;
    FExpand := True;
    FOldHeight := Self.Height;
    FOldWidth := Self.Width;
    FOrigGroupBoxCaption := 'AgDynPanel';
    FCollapseDirection := cdUp;
    FAutoCollapseHeight := cAutoCollapseSize;
    FAutoCollapseWidth := cAutoCollapseSize;
    FGroupBox := TcxGroupBox.Create(Self);
    FGroupBox.Parent := Self;
    FGroupBox.Align := alClient;
    FGroupBox.Alignment := alTopLeft;
    FButtonPanel := TPanel.Create(Self);
    FButtonPanel.Parent := Self;
    FButtonPanel.Top := 0;
    FButtonPanel.Width := DEFAULTBUTTONWIDTH;
    FButtonPanel.Height := DEFAULTBUTTONWIDTH;
    FButtonPanel.Left := Width - DEFAULTBUTTONWIDTH - FButtonPadding;
    FButtonPanel.OnMouseDown := ButtonMouseDown;
    FButtonImage := TImage.Create(Self);
    FButtonImage.Parent := FButtonPanel;
    FButtonImage.Align := alClient;
    FButtonImage.Stretch := false;
    FButtonImage.Center := true;
    FButtonImage.OnMouseDown := ButtonMouseDown;
    UpdateImage;
    // The click should also work for the entire top of the group box.
    FGroupBox.OnMouseDown := ButtonMouseDown;
    FGroupBox.Caption := FOrigGroupBoxCaption;
    FGroupBox.Style.Font.Style := FGroupBox.Style.Font.Style + [fsBold];
    FButtonPadding := cButtonPadding;
    FCollapsePadding := cCollapsePadding;
    FCollapsedSize := cCollapsedSize;
    end;
    {
    TDynPanel.SetGroupBoxCaption
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.SetGroupBoxCaption(Value: String);
    begin
    FOrigGroupBoxCaption := Value;
    ConfigurePanel;
    end;
    {
    TDynPanel.SetMinHeight
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.SetMinHeight(Value: TMinDemension);
    begin
    if Value = FAutoCollapseHeight then
    Exit; // >>----->
    FAutoCollapseHeight := Value;
    if Showing then
    Resize;
    end;
    {
    TDynPanel.SetMinWidth
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.SetMinWidth(Value: TMinDemension);
    begin
    if Value = FAutoCollapseWidth then
    Exit; // >>----->
    FAutoCollapseWidth := Value;
    if Showing then
    Resize;
    end;
    {
    TDynPanel.ButtonMouseDown
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.ButtonMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    begin
    if Button  mbLeft then
    Exit; // >>----->
    if ((FExpand = True) and (Y  FCollapsePadding)) or
    ((FExpand = False) and (FCollapseDirection = cdLeft) and (X >----->
    FExpand := Value;
    //ConfigurePanel;
    //--------------------------------------------------------------------------
    // Set the group box size
    //--------------------------------------------------------------------------
    //
    // I chose to do the resizing of the control here rather than in
    // ConfigurePanel because if you do it there the SetBounds will call ReSize
    // which will call ConfigurePanel again so that you would need to keep track
    // of a boolean variable to determine if you are making recursive calls into
    // ConfigurePanel. That is one reason. Another is that when the dfm values
    // are streamed in and the properties get set you will resize the control
    // before the actual Height and Width properties are set. This will cause
    // bogus default values to be stored for FOldHeight and FOldWidth and when
    // the control is displayed the dimensions will be wrong. If you size the
    // control here then, on creation, Resize will not get called and the
    // FOldHeight and FOldWidth values will not get saved off until
    // CMShowingChanged will explicitly call ReSize after the dimensions are
    // properly set. If you move this code into ConfigurePanel then when the
    // caption is streamed in and set from the dfm then ConfigurePanel would get
    // called, we would SetBounds there and then Resize would fire storing off the
    // default invalid values for the FOld variables as mentioned above.
    // Hope this makes sense. Leave the SetBounds calls here and make your life
    // easier. :)
    //--------------------------------------------------------------------------
    // Changing to Expanded
    if FExpand = True then
    begin
    // Up
    if FCollapseDirection = cdUp then
    SetBounds(Left, Top, Width, FOldHeight)
    // Right
    else if FCollapseDirection = cdRight then
    SetBounds((Left + Width) - FOldWidth, Top, FOldWidth, Height)
    // Left
    else if FCollapseDirection = cdLeft then
    SetBounds(Left, Top, FOldWidth, Height);
    end
    // Changing to Collapsed
    else
    begin
    // Up
    if FCollapseDirection = cdUp then
    begin
    // Reset the AutoCollapseHeight just to make sure we don't try to
    // recollapse on resize.
    if FAutoCollapseHeight  FGroupBox) and
    (Self.Controls[i]  FButtonPanel) then
    begin
    Self.Controls[i].Enabled := Value;
    Self.Controls[i].Visible := Value;
    end;
    end;
    end;
    {
    TDynPanel.CMShowingChanged
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.CMShowingChanged(var Message: TMessage);
    begin
    inherited;
    if Showing then
    Resize;
    end;
    {
    TDynPanel.Resize
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.Resize;
    begin
    if FExpand = True then
    begin
    if (FCollapseDirection = cdUp) and (Height  FAutoCollapseHeight then
    begin
    FOldHeight := Height;
    Expand := True;
    end
    else
    Height := FCollapsedSize;
    end
    else if (FCollapseDirection = cdLeft) or (FCollapseDirection = cdRight) then
    begin
    if (Width > FAutoCollapseWidth) then
    begin
    FOldWidth := Width;
    Expand := True;
    end
    else
    Width := FCollapsedSize;
    end;
    end;
    ConfigurePanel;
    end;
    {
    TDynPanel.ChangeScale
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.ChangeScale(M, D: Integer);
    begin
    FAutoCollapseHeight := MulDiv(FAutoCollapseHeight, M, D);
    FAutoCollapseWidth := MulDiv(FAutoCollapseWidth, M, D);
    FButtonPadding := MulDiv(FButtonPadding, M, D);
    FCollapsePadding := MulDiv(FCollapsePadding, M, D);
    FCollapsedSize := MulDiv(FCollapsedSize, M, D);
    FOldHeight := MulDiv(FOldHeight, M, D);
    FOldWidth := MulDiv(FOldWidth, M, D);
    // inherited will cause resize to be called.  I need to update
    // my internal values before that happens, otherwise I will resize based
    // on the old values.
    inherited;
    end;
    {
    TDynPanel.SetCollapseDirection
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.SetCollapseDirection(Value: TCollapseDirection);
    begin
    if Value = FCollapseDirection then
    Exit; // >>----->
    FCollapseDirection := Value;
    ConfigurePanel;
    end;
    {
    TDynPanel.ConfigurePanel
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.ConfigurePanel;
    begin
    //--------------------------------------------------------------------------
    // Set the group box style, caption alignment, caption, button position, and
    // button image
    //--------------------------------------------------------------------------
    // Changing to Expanded
    if FExpand = True then
    begin
    FGroupBox.Style.Color := clWhite;
    // Up
    if FCollapseDirection = cdUp then
    begin
    FGroupBox.Alignment := alTopLeft;
    FGroupBox.Caption := FOrigGroupBoxCaption;
    FButtonPanel.Top := 0;
    FButtonPanel.Left := Width - FButtonPanel.Width - FButtonPadding;
    end
    // Right
    else if FCollapseDirection = cdRight then
    begin
    FGroupBox.Alignment := alTopLeft;
    FGroupBox.Caption := '       ' + FOrigGroupBoxCaption;
    FButtonPanel.Top := 0;
    FButtonPanel.Left := FButtonPadding;
    end
    // Left
    else if FCollapseDirection = cdLeft then
    begin
    FGroupBox.Alignment := alTopLeft;
    FGroupBox.Caption := FOrigGroupBoxCaption;
    FButtonPanel.Top := 0;
    FButtonPanel.Left := Width - FButtonPanel.Width - FButtonPadding;
    end;
    end
    // Changing to Collapsed
    else
    begin
    FGroupBox.Style.Color := clGradientActiveCaption;
    // Up
    if FCollapseDirection = cdUp then
    begin
    FGroupBox.Alignment := alTopLeft;
    FGroupBox.Caption := FOrigGroupBoxCaption;
    FButtonPanel.Top := 0;
    FButtonPanel.Left := Width - FButtonPanel.Width - FButtonPadding;
    end
    // Right
    else if FCollapseDirection = cdRight then
    begin
    FGroupBox.Alignment := alRightTop;
    FGroupBox.Caption := '       ' + FOrigGroupBoxCaption;
    FButtonPanel.Top := FButtonPadding;
    FButtonPanel.Left := FCollapsePadding;
    end
    // Left
    else if FCollapseDirection = cdLeft then
    begin
    FGroupBox.Alignment := alLeftTop;
    FGroupBox.Caption := FOrigGroupBoxCaption + '       ';
    FButtonPanel.Top := FButtonPadding;
    FButtonPanel.Left := 0;
    end;
    end;
    UpdateImage;
    // Now draw the button and invalidate Self
    Self.Invalidate;
    end;
    {
    TDynPanel.UpdateImage
    ---------------------------------------------------------------------------
    }
    procedure TDynPanel.UpdateImage();
    begin
    case FCollapseDirection of
    cdUp:
    begin
    if FExpand = true then
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageUp')
    else
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageDown');
    end;
    cdLeft:
    begin
    if FExpand = true then
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageLeft')
    else
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageRight');
    end;
    cdRight:
    begin
    if FExpand = true then
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageRight')
    else
    FButtonImage.Picture.Bitmap.LoadFromResourceName(HInstance, 'ButtonImageLeft');
    end;
    end;
    end;
    end.
    

    Cerca de la Izquierda

    Delphi: deslizamiento (animado) en el panel de

    Cerca de la parte Superior

    Delphi: deslizamiento (animado) en el panel de


    Delphi: deslizamiento (animado) en el panel de

    Se ve bonito. Sin embargo no se especifica la licencia : -) ¿se cuenta para una opción a tener dos o tres barras laterales de lado a lado ?
    Pensé que el código estaba cubierto bajo el valor predeterminado de StackOverflow licencia CC. Si necesitas algo diferente de mí se puede utilizar bajo «»unlicense «» unlicense.org. No he probado con varios elementos de un lado a otro. La usamos en forma vertical con un panel de flujo. Nuestro principal en la pantalla de edición como 10+ de estos apiladas en un Panel de Flujo que se haga dentro de un Scrollbox.
    CC también tiene muchos «ediciones». «Pensé que el código estaba cubierto bajo el valor predeterminado de StackOverflow licencia CC» – bueno, usted podría PENSAR eso, pero cualquier persona que intente utilizar se tendría que enfrentar el «mejor prevenir que curar» el problema. Me siento bien con cualquier no-virales HILO de la licencia, aunque, debido a la falta de tiempo me gustaría tal vez el palo con TCategoryPnel, a pesar de no carne de todos mis deseos….

    OriginalEl autor Mark Elder

  3. 4

    La nueva versión de Delphi se incluyen este tipo de paneles deslizantes ( a través de la integración de FireMonkey, antes vgScene/dxScene ). Usted sólo tendrá que hacer clic en la altura o la posición de objetos y una opción permitirá crear una animación de esta, con diversas opciones ( interpolación tipo, duración, etc).

    Delphi: deslizamiento (animado) en el panel de

    Esta sería una buena respuesta, si OP fue el uso de Firemonkey. Usted no puede utilizar FMX controles en un VCL aplicación muy fácil 🙂
    Estoy de acuerdo con JD. Mencionar Firemonkey aquí no ayuda.

    OriginalEl autor az01

  4. 4

    Desde la versión 2009, hay un TCategoryPanelGroup donde agregar TCategoryPanel.

    Delphi: deslizamiento (animado) en el panel de

    Gracias! «No necesito un resizeable panel, pero un panel que se puede deslizar horizontalmente»
    Este no es el resizeable… pero, es sólo vertical ;o(

    OriginalEl autor Whiler

  5. 0

    FoldingPanel

    Ver FoldingPanel v1.3 aquí: http://www.torry.net/authorsmore.php?id=2386
    La he usado durante años.

    Viene con un bonito chevron de mapa de bits también.

    Pequeño problema: no admite controles compuestos (como TLabeledEdit).

    Ventaja: El componente viene como un solo PAS archivo (fácil de instalar en la Paleta). Dicen que es para Delphi 5, pero lo he instalado en XE7 y funciona sin problemas (lo que indica la calidad).

    Freeware

    TSplitView

    Si usted tiene una nueva versión de Delphi (como Tokio) puede utilizar TSplitView.
    Nota: La propiedad Align perdiendo. Y al principio puede parece que no, que sólo puede ser alineado a la Izquierda. Pero no es cierto. En lugar de una propiedad Align tiene una propiedad de Colocación (con dos valores: svpRight /svpLeft).

    Nota: tiene algunos pequeños problemas relacionados con el control de tamaño y colocación.

    Nota: no es (ni de LEJOS) tan completa como FoldingPanel. Usted todavía tiene que escribir algunas de bacalao eto implementar algún tipo de chevron para contraer/gastar el panel.
    Freeware (si usted tiene Delphi Tokio)

    TCategoryPanelGroup

    También echa un vistazo a TCategoryPanelGroup. Se puede o no funcionar, dependiendo de lo que usted necesita para.

    Freeware (si usted tiene Delphi XE7)

    OriginalEl autor Rigel

Dejar respuesta

Please enter your comment!
Please enter your name here