19 respuestas en este tema

[Fleon]

Hola a todos, tengo un panel que crea x cantidad de panels dentro de ellas (Asignandoles un tamaño de ancho de acuerdo al ancho del panel contenedor), hasta aquí todo bien, salvo dos detalles que no sé cómo atacar, dejo el código y expongo mis dudas más abajo:

delphi

 
procedure TForm1.FormCreate(Sender: TObject);
 
var
 
  b: Integer;
 
  Barra: TPanel;
 
begin
 
  for b := 0 to 39 do
 
  begin
 
    Barra := TPanel.Create(Self);
 
    Barra.Parent := pnBarras;
 
    Barra.Name := 'Bar' + IntToStr((b + 1)); //Bar1, Bar2, Bar3, etc..
 
    Barra.Caption := '';
 
    Barra.ParentBackground := False;
 
 
 
    case b of
 
      0..22:  Barra.Color := clLime;
 
      23..34: Barra.Color := clYellow;
 
      35..40: Barra.Color := clRed;
 
    end;
 
 
 
    Barra.Align := alLeft;
 
    Barra.Width := round(pnBarras.Width div 40);
 
    //Barra.Free;
 
  end;
 
end;

1. En este caso creo 40 panels dentro de otro panel pero no queda ajustado, deja un espacio al final equivalente a 3 o cuatro panels, ¿ cómo llenar los 40 panels y que ocupe el panel contenedor por completo?.

 

2. Haciendo uso de TTimer quiero lograr que cada segundo que pase cada panel creado en ejecución cambie a color negro por ejemplo, pero como los paneles no están creados sino después no sé cómo ordenar al componente 'tal' cambie de color.

 

lo que estoy haciendo es mi propio Barra de progreso, ya que por defecto trae delphi no satisface mis necesidades.

 

Fleon xDD

 

 

Archivos adjuntos

•  espacio.png   4,17KB   1 descargas

[Wilson]

Para resolver lo del ancho de la barra intenta con esto:

delphi

procedure TForm1.FormCreate(Sender: TObject);
 
var
 
  b: Integer;
 
  Barra: TPanel;
 
begin
 pnBarras.Width := 0;
 
  for b := 0 to 39 do
 
  begin
 
    Barra := TPanel.Create(pnBarras);
 
    Barra.Parent := pnBarras;
 
    Barra.Name := 'Bar' + IntToStr((b + 1)); //Bar1, Bar2, Bar3, etc..
 
    Barra.Caption := '';
 
    Barra.ParentBackground := False;
 
 
 
    case b of
 
      0..22:  Barra.Color := clLime;
 
      23..34: Barra.Color := clYellow;
 
      35..40: Barra.Color := clRed;
 
    end;
 
 
 
    Barra.Align := alLeft;
 
    Barra.Width := 7;// o lo que quieras
 
    pnBarras.Width :=pnBarras.Width + Barra.Width;
 
    //Barra.Free;
 
  end;
 
end;

Y lo del Timer, prueba con esto:

delphi

procedure TForm1.CambiarColores(APanel: TPanel);
begin
  if APanel.Color = clBlack then
    APanel.Color := clRed
  else
    APanel.Color := clGreen; // o cualquier otra cosa que se te ocurra
//Más colores, más condiciones
end;
 
procedure TForm1.Timer1Timer(Sender: TObject);
var
  i: integer;
begin
  for i := 0 to pnBarras.ComponentCount - 1 do
    if pnBarras.Components[i].ClassType = TPanel then
      CambiarColores(TPanel(pnBarras.Components[i]));
end;

Saludos.

[Agustin Ortu]

Cuando se trata de crear controles en tiempo de ejecucion y luego necesito hacer alguna operacion con/sobre ellos, lo que suelo hacer es guardarlos en una estructura adicional: la de facto es una lista, pero bien podria ser un diccionario, un array.. lo que mas te guste / necesites

 

Esa estructura la dejo como una variable privada del form

 

Nunca me gusto lo de recorrer Controls o Components, a menos que sea para "hacer algo con todo", ya que tengo que agregar logica adicional para ver si el elemento i-esimo es el que quiero, y luego tendria que distinguirlo de otros potenciales objetos que fueron creados en diseño

 

Ademas te termina llevando a codigo como esto, el cual es super sucio:

 

delphi

var
  I: Integer;
  AComponent: TComponent;
  APanel: TPanel;
  ALabel: TLabel;
  AButton: TButton;
begin
  for I := 0 to ComponentCount - 1 do
  begin
    AComponent := Components[I];
    if AComponent is TPanel then
   begin
     APanel := TPanel(AComponent);
    // hacer algo con el panel
   end;
 
    if AComponent is TButton then
   begin
     AButton := TButton (AComponent);
    // hacer algo con el button
   end;
 
  // mas y mas logica..
  end;
end;

Saludos

[genriquez]

Definitivamente la mejor estrategia es utilizar una estructura para guardar cada elemento,  usualmente las listas o diccionarios son buenísimos para eso. 

 

Igualmente para ajustar los tamaños y tener en cuenta que el panel principal puede cambiar de tamaño, si no usas alineaciones en los paneles, puedes agregar un evento en el onresize del panel principal, para recalcular  todos los tamaños de los paneles internos.

 

Saludos.

[Fleon]

Gracias amigo Wilson, he probado tu propuesta y sigue mostrando el espacio, cabe aclarar que el panel donde se crean los paneles tiene la propiedad Align en alCLient.

 

Fleon xDD

[egostar]

Me parece que es un tema de porcentajes, o calculas la anchura de cada panel o calculas cuantos paneles vas a necesitar.

Hay algo que me falta en tu explicación, es por tiempo o es por algo cuantificable.

Saludos.

[Fleon]

En realidad necesito crear 40 paneles dentro de otro panel y que se adapten por completo sin espacio (como si se tratara de adaptar la columnas de un DBGrid) dinamicamente, y con el timer cada segundo que pase coloree los paneles creados de color negro, o sea:

 

1 segundo = coloree el panel 1

2 segundo = coloree el panel 2

y así sucesivamente.

 

Espero haberme hecho entender

[Agustin Ortu]

Vamos por partes, tenes dos problemas:

 

1. Cada un segundo colorear un panel

2. Posicionamiento/redimensionamiento de los paneles

 

1. El problema 1 es facilmente solucionable con una lista:

 

Creas los paneles en tiempo de ejecucion, y los vas agregando en una lista; luego en el evento OnTimer, tomas el siguiente panel a colorear y lo pintas. Accediendo por un indice es bastante sencillo, pero te va a requerir usar una variable adicional

 

Esta implementacion la hice de memoria pero creo que deberia andar:

delphi

interface
 
uses
  Generics.Collections;
 
type
  TForm1 = class(TForm);
    Timer1: TTimer;
 
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  strict private
    IndiceUltimoPanel: TPanel;
    Paneles: TList<TPanel>;
  end;
 
procedure TForm1.FomCreate(Sender: TObject);
begin
  IndiceUltimoPanel := 0;
  Paneles := TList<TPanel>.Create;
  CrearPaneles;
end;
 
procedure TForm1.FomCreate(Sender: TObject);
begin
  Paneles.Free;
end;
 
procedure TForm1.Timer1Timer(Sender: TObject);
var
  APanel: TPanel;
begin
  Inc(IndiceUltimoPanel);
  if IndiceUltimoPanel > Paneles.Count then
    IndiceUltimoPanel := 1;
 
  APanel := Paneles[IndiceUltimoPanel] as TPanel;
  APanel.Color := clRed;    
end;
 
procedure TForm1.CrearPaneles(const APanelCount: Integer);
var
  APanel: TPanel;
  I: Integer;
begin
  for I := 1 to APanelCount do
  begin
    APanel := TPanel.Create(Self);
    Paneles.Add(APanel);
    APanel.Name := 'Panel' + IntToStr(I);
    // otras propiedades...   
  end;
end;

[Agustin Ortu]

Como ultima recomendacion, este tipo de problemas siempre suelo encapsularlos dentro de una clase; (un pequeño off-topic  ) hace poco diseñe una clase similar para un programa que ya tenia que se encargaba de gestionar una lista de descendientes de una clase "Base", la cual era un descendiente de TFrame; la idea de estos frames es mostrar una pequeña ventanita con algun dibujo/pequeño listview/grafico de torta/etc con informacion estadistica, que venia de una DB

 

Entonces uno de los problemas era que tenia que existir una forma de "refrescar" cada x tiempo el contenido; por ello en la clase abstracta y padre se dispone del metodo RefreshData, entonces la solucion era, similar a la de este hilo, poner un timer y cuando se dispara el evento OnTimer, recorrer un contenedor de estos Frames e invocar al metodo RefreshData.

 

Es un monton de codigo que tiene que estar dentro del form Principal, que ya de por si tiene bastantes cosas, ahi ensuciando, hasta que decidi meterlo todo dentro de una clase. No solo que queda mas limpio, desacoplado, reusable y extensible, sino que tambien te permite tener mayor control. Por ejemplo se pueden crear eventos propios dentro de la clase, descartar un Refrescado (imaginen un evento OnBeforeRefresh)

 

Asi que cree una clase TWidgetManager, que es lo unico que paso a conocer mi Main form: toda la interaccion ahora ocurre entre propiedades, metodos y eventos. De hecho, esta clase es la que se hace cargo de controlar el Timer, y no el Form, puedo obtener una lista de todos los Widget, los Widgets "Visibles", los "Invisibles" (collapsed, que vendria a ser "contraido", y expanded); tengo un metodo Refresh publico, otro privado, puedo distinguir si es un Refresh "forzado", o uno privado (disparado por el timer), puedo invalidar un Refresh, y podria seguir agregando mas y mas funcionalidad

 

Dejo la parte interface de la clase para que se tenga un panorama mas completo..

delphi

type
  TRefreshEvent = procedure(const IsUserRefresh: Boolean; var CanRefresh: Boolean) of object;
 
  TWidgetManager = class
  strict private
    FWidgets: IList<TWidgetBase>;
    FOwnsWidgets: Boolean;
    FTimer: TTimer;
    FBeforeRefresh: TRefreshEvent;
    function GetWidgets: IEnumerable<TWidgetBase>;
    function GetExpandedWidgets: IEnumerable<TWidgetBase>;
    function GetCollapsedWidgets: IEnumerable<TWidgetBase>;
    function GetCount: Integer;
 
    function GetRefreshInterval: Cardinal;
    function GetRefreshEnabled: Boolean;
 
    procedure SetRefreshInterval(const Value: Cardinal);
    procedure SetRefreshEnabled(const Value: Boolean);
    procedure SetBeforeRefresh(const Value: TRefreshEvent);
 
    procedure Refresh(const IsUserRefresh: Boolean); overload;
    procedure AutoRefresh;
    procedure OnTimerNotify(Sender: TObject);
  public
    constructor Create(const AOwnsWidgets: Boolean; const ARefreshInterval: Cardinal = 5000);
    destructor Destroy; override;
    function Add(AWidget: TWidgetBase): Integer;
    procedure Delete(const AIndex: Integer); overload;
    procedure Delete(AWidget: TWidgetBase); overload;
    procedure Refresh; overload;
    property Widgets: IEnumerable<TWidgetBase> read GetWidgets;
    property ExpandedWidgets: IEnumerable<TWidgetBase> read GetExpandedWidgets;
    property CollapsedWidgets: IEnumerable<TWidgetBase> read GetCollapsedWidgets;
    property Count: Integer read GetCount;
    property RefreshInterval: Cardinal read GetRefreshInterval write SetRefreshInterval;
    property RefreshEnabled: Boolean read GetRefreshEnabled write SetRefreshEnabled;
    property BeforeRefresh: TRefreshEvent read FBeforeRefresh write SetBeforeRefresh;
  end;

Fin off-topic

 

Saludos

 

[Fleon]

Gragias Agustín, es más hacer el recorrido de los paneles a través de una lista, todo me ha quedado perfecto, el código queda así:
 

delphi

unit Unit1;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Generics.collections, Vcl.ExtCtrls;
type
  TForm1 = class(TForm)
    pnBarras: TPanel;
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure CrearPaneles(const APanelCount: Integer);
    procedure Timer1Timer(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  strict private
    IndiceUltimoPanel: Integer;
    Paneles: TList<TPanel>;
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  Paneles.Free;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  IndiceUltimoPanel := 0;
  Paneles := TList<TPanel>.Create;
  CrearPaneles(40);
end;
 
procedure TForm1.Timer1Timer(Sender: TObject);
var
  APanel: TPanel;
begin
  Inc(IndiceUltimoPanel);
  if IndiceUltimoPanel > Paneles.Count then
    IndiceUltimoPanel := 1;
 
  APanel := Paneles[IndiceUltimoPanel - 1] as TPanel;
  APanel.Color := clBlack;
end;
 
procedure TForm1.CrearPaneles(const APanelCount: Integer);
var
  APanel: TPanel;
  I: Integer;
begin
  for I := 1 to APanelCount do
  begin
    APanel := TPanel.Create(Self);
    Paneles.Add(APanel);
    APanel.Name := 'Panel' + IntToStr(I);
    APanel.Parent := pnBarras;
    APanel.Width := pnBarras.Width div APanelCount;
    APanel.Align := alLeft;
    APanel.ParentBackground := False;
    APanel.ShowCaption := False;
 
    case i of
      1..24: APanel.Color := clLime;
      25..33: APanel.Color := clYellow;
      34..40: APanel.Color := clRed;
    end;
  end;
end;
 
end.

Sólo quedaría como ajustar los paneles dentro del panel contenedor, la pega que la propiedad width sólo acepta números enteros

Fleon xDD

[genriquez]

Pocas veces te quedarán todos los paneles del mismo ancho, si son 40 paneles, probablemente te sobrará un espacio de 39 pixeles al final en el mejor de los casos, allí toca escoger como repartir esa diferencia ente los paneles,  ej. el último panel se alinea alClient.

 

O se hace un barrido y se van sumando esas diferencias a los paneles, hasta que se completen el total o finalmente lograr que falte o que sobre un espacio y dejar un scrollbar para desplazarse.

 

y si, es que solo se pueden manejar números enteros en el ancho de cada panel.

 

Saludos.

[egostar]

Hola

Lo que se puede hacer es definir el tamaño del Panel Maestro en un valor proporcional, por ejemplo 600, para que al momento de realizar el calculo tenga la misma proporción entre todos los paneles hijos.

Saludos

[Delphius]

Hola

Lo que se puede hacer es definir el tamaño del Panel Maestro en un valor proporcional, por ejemplo 600, para que al momento de realizar el calculo tenga la misma proporción entre todos los paneles hijos.

Saludos

 

No he leído con mucha atención a todo el hilo. Pensé en lo mismo que vos, pero creo que esto no funciona si justo el Panel Maestro tiene una alineación definida, ya que el tamaño se adaptará a ésta. Si por tal alineación y cosas de la vida da el valor proporcional es una pura coincidencia... ¿pero y si no?

 

Saludos,

[egostar]

No he leído con mucha atención a todo el hilo. Pensé en lo mismo que vos, pero creo que esto no funciona si justo el Panel Maestro tiene una alineación definida, ya que el tamaño se adaptará a ésta. Si por tal alineación y cosas de la vida da el valor proporcional es una pura coincidencia... ¿pero y si no?

 

Saludos,

 

Bueno es que está definido por la constante 40, la cual nos permitiría adaptar el Panel Maestro a nuestras necesidades.

 

Saludos

[Agustin Ortu]

O sino se puede usar un GridPanel, y le pones la propiedad que controla el comportamiento al agregar mas elementos para que agregue columnas; siempre usarias una sola fila (la fila indice = 0)
 
Lo unico que hay que asegurarse es que el GridPanel todas las columnas esten configuradas para trabajar por porcentaje y hacer el calculo para que todas tengan el mismo valor
 
Por cierto, en el codigo que pusiste como te quedo (y cuando yo postie el mio) tenes un pequeño detalle:
 
Yo no pondria la liberacion de la lista de paneles en el evento OnClose del form; yo lo pondria en el evento OnDestroy del form (ese fue el que quise poner en mi ejemplo); aunque tambien podrias usar un destructor
 
 
De nuevo, de memoria

delphi

TForm1 = class(TForm)
  FormDestroy(Sender: TObject);
  public
   destructor Destroy; override;
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  Paneles.Free;
end;
 
destructor TForm1.Destroy;
begin
  Paneles.Free;
  inherited;
end;

Cuidado! de esas dos opciones (destructor u OnDestroy) solo usar una, nunca las dos a la vez

[Agustin Ortu]

Otro detalle bastante tonto de mi parte es este metodo:
 

delphi

procedure TForm1.Timer1Timer(Sender: TObject);
var
  APanel: TPanel;
begin
  Inc(IndiceUltimoPanel);
  if IndiceUltimoPanel > Paneles.Count then
    IndiceUltimoPanel := 1;
 
  APanel := Paneles[IndiceUltimoPanel - 1] as TPanel;
  APanel.Color := clBlack;
end;

 
 
Tenemos una lista generica definida como TList<TPanel>; esto significa que la lista es type-safe, es decir, no podra haber en esta lista algo que no sea un TPanel o descendiente
 
Por lo tanto el casteo usando el operador AS en este caso no es necesario; es una operacion bastante costosa y ademas enturbia el codigo
 
El metodo correcto seria:

delphi

procedure TForm1.Timer1Timer(Sender: TObject);
var
  APanel: TPanel;
begin
  Inc(IndiceUltimoPanel);
  if IndiceUltimoPanel > Paneles.Count then
    IndiceUltimoPanel := 1;
 
  APanel := Paneles[IndiceUltimoPanel - 1];
  APanel.Color := clBlack;
end;

[Fleon]

Hey, no se me había ocurrido el uso del TGridPanel es una excelente opción, me asalta la duda, creo las columnas y le asigno el porcentaje, perfecto, pero como colocaría los paneles en cada columna todo eso en tiempo de ejecución?.

[Agustin Ortu]

Fijate de esta manera.

 

Lo unico que toque en tiempo de diseño es, del GridPanel, en la coleccion de Filas (RowCollection) elimine una, asi me queda solamente una fila

 

el resto esta todo por codigo

delphi

type
  TForm1 = class(TForm)
    GridPanel1: TGridPanel;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.Button1Click(Sender: TObject);
var
  I: Integer;
  APanel: TPanel;
begin
  for I := 1 to 10 do
  begin
    APanel := TPanel.Create(GridPanel1);
    APanel.Parent := GridPanel1;
    APanel.Align := alClient;
    APanel.BorderStyle := bsNone;
    APanel.BevelOuter := bvNone;
    APanel.ParentBackground := False;
    APanel.ParentColor := False;
    APanel.Color := RGB(Random(255), Random(255), Random(255));
  end;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Randomize;
  GridPanel1.ExpandStyle := emAddColumns;
  GridPanel1.ShowCaption := False;
end;

Salida

 

[Agustin Ortu]

Se puede seguir mejorando la implementacion...

El problema va a ser ahora el "cuando" acomodar todo los paneles; por suerte, ahora tenemos una lista
 
Dentro de esta lista, tenemos acceso al evento OnNotify que se dispara cuando se produce algun cambio en la lista: agregar, quitar..
 
O mejor aun, podemos usar herencia y crear un evento que se ejecuta cuando terminamos de cargar todos los paneles; seria medio ineficiente que por cada panel que agreguemos, se ejecute todo el proceso Resize
 
La implementacion completa seria asi:

delphi

unit Unit1;
 
interface
 
uses
  Winapi.Windows,
  Winapi.Messages,
  System.SysUtils,
  System.Variants,
  System.Classes,
  System.Generics.Collections,
  Vcl.Graphics,
  Vcl.Controls,
  Vcl.Forms,
  Vcl.Dialogs,
  Vcl.ExtCtrls,
  Vcl.StdCtrls;
 
type
  TPanelList = class(TList<TPanel>)
  strict private
    FIsUpdating: Boolean;
  strict protected
    FOnFinishedUpdating: TNotifyEvent;
    procedure SetOnFinishedUpdating(const Value: TNotifyEvent);
    property IsUpdating: Boolean read FIsUpdating;
  public
    procedure BeginUpdate;
    procedure EndUpdate;
    property OnFinishedUpdating: TNotifyEvent read FOnFinishedUpdating write SetOnFinishedUpdating;
  end;
 
  TForm1 = class(TForm)
    GridPanel1: TGridPanel;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  strict private
    Paneles: TPanelList;
    procedure OnPanelsUpdated(Sender: TObject);
    procedure ResizeColumns(const ASizeStyle: TSizeStyle; const AValue: Double);
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.Button1Click(Sender: TObject);
var
  I: Integer;
  APanel: TPanel;
begin
  Paneles.BeginUpdate;
  try
    for I := 1 to 10 do
    begin
      APanel := TPanel.Create(GridPanel1);
      APanel.Parent := GridPanel1;
      APanel.Align := alClient;
      APanel.BorderStyle := bsNone;
      APanel.BevelOuter := bvNone;
      APanel.ParentBackground := False;
      APanel.ParentColor := False;
      APanel.Color := RGB(Random(255), Random(255), Random(255));
      Paneles.Add(APanel);
    end;
  finally
    Paneles.EndUpdate;
  end;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Paneles := TPanelList.Create;
  Paneles.OnFinishedUpdating := OnPanelsUpdated;
  Randomize;
  GridPanel1.ExpandStyle := emAddColumns;
  GridPanel1.ShowCaption := False;
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  Paneles.Free;
end;
 
procedure TForm1.OnPanelsUpdated(Sender: TObject);
begin
  ResizeColumns(ssAbsolute, 40);
end;
 
procedure TForm1.ResizeColumns(const ASizeStyle: TSizeStyle; const AValue: Double);
var
  I: Integer;
  LColumn: TCellItem;
begin
  for I := 0 to GridPanel1.ColumnCollection.Count - 1 do
  begin
    LColumn := GridPanel1.ColumnCollection[I];
    LColumn.SizeStyle := ASizeStyle;
    LColumn.Value := AValue;
  end;
end;
 
{ TPanelList }
 
procedure TPanelList.BeginUpdate;
begin
  FIsUpdating := True;
end;
 
procedure TPanelList.EndUpdate;
begin
  FIsUpdating := False;
  if Assigned(FOnFinishedUpdating) then
    FOnFinishedUpdating(Self);
end;
 
procedure TPanelList.SetOnFinishedUpdating(const Value: TNotifyEvent);
begin
  FOnFinishedUpdating := Value;
end;
 
end.

En el metodo resize se puede especificar por parametro el tipo de columna: por porcentaje, valor fijo (un valor constante para todas las columnas, creo que este es el que mas te sirve) y el valor en si
 
Creo que de esta manera tenes flexibilidad absoluta

[Agustin Ortu]

Doble post sin querer