Procedure doble Boolean case
 

Muy bien día a todos y felices fiestas, alguien de ustedes ya resolvió el dilema de como hacer

Digamos tengo 5 o 4 controles y por determinado evento un control queda visible y los demás ocultos, pero para que no se haga extenso el código a ocupar, pensé si existe la forma de crear un Procedure o función de doble Boolean en dónde 1 sea a true o false y el otro su contrario dentro del Procedure con un CASE, dónde lo que esté en 1 opción sea visible y en la otra opción no visible, espero haber sido claro, saludos

Yo reconozco que no te acabo de entender...
No se si quieres hacer un procedimiento para escribir menos y activar/desactivar todos los botones "de golpe".

Buen día más o menos, desactivar todos menos 1, o activar 1 menos lo demás algo así, ejemplo: tengo 4 panel uno sobre otro, al entrar al formulario solo mostrar 1 y los demás ocultos, al precionar 1 Burton, ahora ocultar el visible y activar el 2 un ejemplo, osea el Procedure tendría la opción de colocar cuál panel será el true y los demás estarán en false, espero allá Sido claro

Hay varias formas de hacerlo de forma simple, de forma que puedas identificar todos los elementos del grupo.

• Todos dentro de un panel (que no tiene porqué ser visible)
• Todos los elementos con el mismo TAG
• ...

Si tienes definidos una serie de paneles en el formulario TODOS con la propiedad TAG=1 como estos:





Con un procedimiento como este:

Código Delphi [-]
procedure TForm2.OcultarVisualizarPaneles(APanel: TPanel);
var
  i:integer;
begin
  // Recorre todos los paneles
  for i := 0 to (ComponentCount - 1) do begin
    // Está marcado con el TAG=1
    if TPanel(Components[i]).Tag = 1 then begin
      // El del parámetro lo dejamos visible
      if (TPanel(Components[i]) = APanel) then
        TPanel(Components[i]).Visible := True
      // el resto los ocultamos...
      else
        TPanel(Components[i]).Visible := False;
    end;
  end;
end;

Puedes visualizar uno y ocultar el resto.

Código Delphi [-]
procedure TForm2.Button1Click(Sender: TObject);
begin
  OcultarVisualizarPaneles(Panel1)
end;

procedure TForm2.Button2Click(Sender: TObject);
begin
  OcultarVisualizarPaneles(Panel2)
end;

procedure TForm2.Button3Click(Sender: TObject);
begin
  OcultarVisualizarPaneles(Panel3)
end;

En ejecución será algo así:

muchas gracias es lo que buscaba te lo agradesco
Neftali [Germán.Estévez]
[becario]

lo que aun no logro comprender es como dejar a todos los paneles ocultos con un boton? o simplemente pondria
OcultarVisualizarPaneles(); asi, pero no funciono y otro problema que tuve es si son 20 paneles y ocupo el panel1 y el panel 5 visbles y los demas no visibles? como podria controlar los que se ven y por ende todos los demas ocultos o enabled les agradesco

Hola.

Código Delphi [-]
procedure TForm1.btnHidePanelsClick(Sender: TObject);
var
  i: Integer;
begin
  for i := 0 to ControlCount-1 do
    if Controls[i] is TPanel then
       Controls[i].Visible := False;
end;

Código Delphi [-]
procedure TForm1.SomePanelsVisible(const Panels: array of TPanel);
var
  i: Integer;
begin
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible := True;
end;

Ejemplo de uso:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
begin
   SomePanelsVisible([Panel1, Panel5, Panel9, Panel17]);
end;

Saludos :)

comprendo que seria facil ese codigo pero mi idea era ampliar el codigo anterior, no se complementarlo para poder ejecutar el ocultar todo, o mostrar los paneles requeridos y los demas ocultos. aun sigo buscando la forma de ue sea en un solo procedimiento, se que hay muchos capaces de eso y mas

Hola.

No te entiendo... ¿ Lo que quieres es que solo se muestren algunos y otros permanezcan ocultos ?

Pues oculta todos y muestra luego los que desees:

Código Delphi [-]
procedure TForm1.SomePanelsVisible(const Panels: array of TPanel);
var
  i: Integer;
begin
  // Ocultar todos
  for i := 0 to ControlCount-1 do
    if Controls[i] is TPanel then
       Controls[i].Visible := False;
  // Mostrar los deseados
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible := True;
end;

Saludos :)

tenia pensado algo as como tu procedimiento, pero con la opcion de ocultar todos

Código Delphi [-]
SomePanelsVisible([]);

que pudiece quedar algo asi para definir que todos esten ocultos y asi para solo mostar los indicados y todos los demas ocultos

Código Delphi [-]
SomePanelsVisible([panel1,panel2]);

pero en un solo procedimiento se podra ?

Eso es un solo procedimiento :confused:

Código Delphi [-]
procedure TForm1.SomePanelsVisible(const Panels: array of TPanel);
var
  i: Integer;
begin
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible := True;
end;

hola se que es raro pero me puse a pensar un poco y no se pero creo existe una forma mm deja ver si me doy a entender

Código Delphi [-]
//esto para que NO se vean todos los panel
procedure visor(false,);

Código Delphi [-]
// podria ser la forma de representar que quiero que se vean todos
procedure visor(true,);

Código Delphi [-]
//y esta la forma de representar que no se vean todos, solo el panel 1 y el panel2,
procedure visor(true,panel1,panel2);

no se, quiero pensar que puede contener el procedure un if anidado o algo asi

si es false no se ve nada

si es true se ven todos
pero si es true saber cuales no se ocultaran
si no se define nada entonces todos se veran

mmmmmm se prodra en un solo procedure, creo por algo desde el principo puse doble boolean sera para mi un crack quien pueda ayudarme, y pueden explicarme como subir mi proyecto completo en el foro? muchisimas gracias

A ver, estás confundido como cualquier novato, a todos nos ha pasado.
Lee y prueba con atención el ejemplo que te ha dado el compañero ecfisa.

Tu problema lo puedes dividir en tantas subrutinas como sea necesario para que sea más sencillo de programar y luego puedes agrupar todas esas en un único procedimiento que se comporte como tu quieres e internamente llame a cada una de las opciones que te han propuesto según lo necesites.
Así en tu código verás una única línea con la sintaxis que quieres e internamente usará cualquiera de las opciones que te han propuesto.

Si que se puede hacer en un procedimiento, con una cabecera similar a esta:

Código Delphi [-]

procedure Visor(const aVisualizarOcultarTodos:boolean; aArrayPanels: array of TPanel);

La duda es si debe hacerse así o no (yo creo que no).
No siempre "juntar" todo en un procedimniento acaba siendo mejor. Lo que quiero decir es que juntar en un procedimiento "cosas distintas" utilizando más parámetros, aunque a primeras puede parecer mejor, a la larga puede resultar peor.

Mezclas cóodigo de cosas distintas y aunque es más corto en líneas, acaba siendo más complejo de programar, de depurar, de leer,...

En este caso, en lugar de una cabecera como la anterior, yo optaría por hacer 2 procedimientos (2 cabeceras):

Código Delphi [-]
procedure Visor(aArrayPanels: array of TPanel);
procedure VisorAll(const aVisualizarOcultarTodos:boolean);

Es posible que luego uno utilice internamente el otro, pero de esta forma es más sencillo de entender y de utilizar.
2 trozos de código pueden dar el mismo resultado, pero no necesariamente quiere dec¡r que sean igual de correctos.


No se si me explico...

Muy buenas tardes, hice una mescolanza de codigos que me funcionaron, pero me gustaria saber si existe forma de reducir el codigo, este es el codigo que gracias a todos ustedes agrupe de esta forma, espero tengan tiempo para echarme la mano.

Código Delphi [-]

procedure TForm1.SomePanelsVisible(TSN:Boolean;const Panels: array of TPanel;SiNo:Boolean);
var
  i,ii: Integer;
begin // arreglo 1
      // Ocultar todos  o Mostrar Todos los Panel
     // independientemente del arreglo 2
  For ii := 0 To ComponentCount - 1 Do
  If Components[ii] Is TPanel Then
     TPanel(Components[ii]).Visible:= TSN;  //todos visibles o no
 begin
   //arreglo 2
   //independiente al arreglo 1
   //este arreglo sera lo contrario al arreglo 3
  For i := 0 To ComponentCount - 1 Do
  If Components[i] Is TPanel Then
  TPanel(Components[i]).Visible:= Not SiNo; //False
  // Mostrar los deseados
  //arreglo 3 el cual sera para nostrar o no un grupo determinado
  //de controles TPanel
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible :=SiNo;
end;end;

y de esta forma llamo el proceso,con estas opciones

Código Delphi [-]

procedure TForm1.Button1Click(Sender: TObject);
begin
SomePanelsVisible(False,[],True);   //ocultar todos
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
SomePanelsVisible(False,[],False);    //mostrar todos
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
SomePanelsVisible(False,[Panel1, Panel10],true);   //mostrar 1 y 10
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
SomePanelsVisible(False,[Panel1,Panel3,Panel5,Panel7],true); //Mostrar 1,3,5 y 7
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
SomePanelsVisible(True,[Panel1, Panel10],False);  //ocultar 1 y 10
end;

que tal pues ste es el final del codigo, creen que se puede comprimir mas o ya no se puede, algun aporte para optimizarlo un poco mas, gracias a todos y felices fiestas

Código Delphi [-]
procedure TForm1.Paneles(TSN:Boolean;const Panels: array of TPanel;SiNo:Boolean);
var
  i,ii: Integer;
begin // arreglo 1
      // Ocultar todos  o Mostrar Todos los Panel
     // independientemente del arreglo 2
  For ii := 0 To ComponentCount - 1 Do
  If Components[ii] Is TPanel Then
     TPanel(Components[ii]).Visible:= TSN;  //todos visibles o no
 begin
   //arreglo 2
   //independiente al arreglo 1
   //este arreglo sera lo contrario al arreglo 3
  For i := 0 To ComponentCount - 1 Do
  If Components[i] Is TPanel Then
  TPanel(Components[i]).Visible:= Not SiNo; //False
  // Mostrar los deseados
  //arreglo 3 el cual sera para nostrar o no un grupo determinado
  //de controles TPanel
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible :=SiNo;
end;end;

y de esta forma lo ejecuto, sus distintas variantes

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
begin
Paneles(False,[],True);   //ocultar todos
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
Paneles(False,[],False);    //mostrar todos
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
Paneles(False,[Panel1, Panel10],true);   //mostrar 1 y 10
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
Paneles(False,[Panel1,Panel3,Panel5,Panel7],true); //Mostrar 1,3,5 y 7
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
Paneles(True,[Panel1, Panel10],False);  //ocultar 1 y 10
end;

hola!

En tu código veo que hay una estructura begin/end que queda fuera de todos los bucles, y se puede eliminar (lo he marcado con //* *//), salvo que sea un error y pertenezca a alguno de los bucles.

Código Delphi [-]
procedure TForm2.Paneles(TSN: Boolean; const Panels: array of TPanel; SiNo: Boolean);
var
  i, ii: Integer;
begin
  // arreglo 1
  // Ocultar todos  o Mostrar Todos los Panel
  // independientemente del arreglo 2
  for ii := 0 to ComponentCount - 1 do
    if Components[ii] is TPanel then
      TPanel(Components[ii]).Visible := TSN;  //todos visibles o no
  //* begin *//
     //arreglo 2
     //independiente al arreglo 1
     //este arreglo sera lo contrario al arreglo 3
    for i := 0 to ComponentCount - 1 do
      if Components[i] is TPanel then
        TPanel(Components[i]).Visible := not SiNo; //False
    // Mostrar los deseados
    //arreglo 3 el cual sera para nostrar o no un grupo determinado
    //de controles TPanel
    for i := Low(Panels) to High(Panels) do
      Panels[i].Visible := SiNo;
//* end *//
end;

Por otra parte el primer for ii establece todos los paneles con el valor Visible a TSN, e inmediatamente el segundo for i establece de nuevo los valores Visible a not SiNo, con lo que al final el primer for sería innecesario.

En cuanto a la parte lógica del proceso veo lo siguiente:

-Si no pasas una lista de paneles, (array de paneles esta vacío), estas actuando sobre todos los paneles y entonces el valor del campo SiNo es irrelevante, puesto que solo se aplica al array de paneles, y en este caso al estar vacío no se va aplicar a ningún panel.
-Si por el contrario si se pasa una lista de Paneles, entonces la opción donde el valor de TSN y el valor de SiNo son iguales, es lo mismo que aplicar el valor a todos los paneles, independientemente de la lista que se ha pasado. Por tanto lo ideal es que TSN sea distinto de SiNO y al ser de tipo boolean la única opción es que TSN:=not SiNO y de esta forma solo necesitas pasar una variable con el valor deseado al procedimiento.


Y el código puede quedar de esta forma:

Código Delphi [-]
procedure TForm2.SetPanelsVisible(const Panels: array of TPanel; const Value: Boolean = true);
var
  i: Integer;
begin
  // Ocultar todos  o Mostrar Todos los Panel
  for i := 0 to ComponentCount - 1 do
    if Components[i] is TPanel then
      TPanel(Components[i]).Visible := Not Value;  //todos visibles o no

  // Mostrar los deseados
  // arreglo 3 el cual sera para nostrar o no un grupo determinado
  // de controles TPanel
  for i := Low(Panels) to High(Panels) do
    Panels[i].Visible := Value;
end;

y yo añadiría un overload al procedimiento para poder utilizarlo de forma mas fácil cuando no quieras pasar el array:

Código Delphi [-]
  TForm2 = class(Tform)
  ...  
  public
    procedure SetPanelsVisible(const Value: Boolean); overload;
    procedure SetPanelsVisible(const Panels: array of TPanel; const Value: Boolean = true); overload;
    ...
  end;
...

procedure TForm2.SetPanelsVisible(const Value: Boolean);
begin
  // establecer el valor a todos los paneles
  SetPanelsVisible([], not Value);
end;

Y la forma de uso es muy similar a la que ya tenias anteriormente:

Código Delphi [-]
procedure TForm2.Button1Click(Sender: TObject);
begin
  SetPanelsVisible(False);   //ocultar todos
end;

procedure TForm2.Button2Click(Sender: TObject);
begin
  SetPanelsVisible(true);    //mostrar todos
end;

procedure TForm2.Button3Click(Sender: TObject);
begin
  SetPanelsVisible([Panel1, Panel5], true);   //mostrar 1 y 10
end;

procedure TForm2.Button4Click(Sender: TObject);
begin
  SetPanelsVisible([Panel1, Panel5], False);  //ocultar 1 y 10
end;