Recorrer TreeView y calcular totales

[[Lepe]]

Estás mezclando la interfaz con la lógica de la aplicación... no es buena idea porque te complica todo lo demás.

En teoría, deberías tener una jerarquía de clases, o al menos varias listas unas dentro de otras formando el arbol... pero con TObject y TObjectList. Eso ya te da toda la potencia para calcular los totales y lo que quieras.

Pasarlo al Treeview, es sólo recorrer las listas y crear nodos... cosa de poca monta, vamos.

Código Delphi [-]
type 
Tcuenta = TObject;
Tcuentas = class (TObjecList)
  public 
      property items[index:integer]:Tcuenta read getItem write SetItem;
      property Total :Extended read GetTotal;
end;

Con una definición así puedes hacer todas las virguerías que quieras, sumas, eventos al modificar una cuenta y un total... etc.

Saludos

[[Delphius]]

Empezado por Lepe

Estás mezclando la interfaz con la lógica de la aplicación... no es buena idea porque te complica todo lo demás.

En teoría, deberías tener una jerarquía de clases, o al menos varias listas unas dentro de otras formando el arbol... pero con TObject y TObjectList. Eso ya te da toda la potencia para calcular los totales y lo que quieras.

Pasarlo al Treeview, es sólo recorrer las listas y crear nodos... cosa de poca monta, vamos.

Código Delphi [-]
type  
 Tcuenta = TObject; 
 Tcuentas = class (TObjecList)  
  public property items[index:integer]:Tcuenta read getItem write SetItem;
  property Total :Extended read GetTotal; end;

Con una definición así puedes hacer todas las virguerías que quieras, sumas, eventos al modificar una cuenta y un total... etc.

Saludos

Me gusta tu diseño amigo,
Si no es molestia, yo me meto también. Yo me imagino un esquemita más complicado. Si me disculpan, he aquí un Composite:

Código Delphi [-]
unit UCuentas;

interface

uses classes, Contnrs;

type
  TCuentaAbstracta = class(Tobject)
  public
    function GetTotal: integer; virtual; abstract; // es necesario abstracto
    // cada tipo de cuenta implementará SetTotal según a "convenir"
  end;

  TCuenta = class (TCuentaAbstracta) // una simple cuenta
  private
    FTotal: integer;
  public
    procedure SetTotal(Value: integer);
    function GetTotal: integer; override;
  end;

  TCuentaCompuesta = class (TCuentaAbstracta) // una cuenta compuesta por una o más
  private
    FListaCuentas: TObjectList; // El listado de cuentas
  public
    function GetTotal: integer; override;
    function AddCuenta(Cuenta: TCuentaAbstracta): integer;
  end;


implementation

{ TCuentaCompuesta }

function TCuentaCompuesta.AddCuenta(Cuenta: TCuentaAbstracta): integer;
begin
  result := FListaCuentas.Add(Cuenta);
end;

function TCuentaCompuesta.GetTotal: integer;
var i: integer;
begin
  result := 0;
  // calculamos el total desde la lista de cuentas
  // como se ve... se invoca al método GetTotal según la clase que lo implementa.

  // una clase compuesta en su lista puede tener tantas clases compuestas
  // como "simples" se desee. De este modo, SetTotal siempre devolverá el total
  // de las cuentas que la componen.
  for i := 0 to FListaCuentas.Count - 1 do
    inc(result,TCuentaAbstracta(FListaCuentas.Items[i]).GetTotal);
end;

{ TCuenta }

function TCuenta.GetTotal: integer;
begin
  result := FTotal;
end;

procedure TCuenta.SetTotal(Value: integer);
begin
  FTotal := Value;
end;

end.

Se que es muy simple pero creo que se entiende el principio. La clase TCuentaCompuesta tiene un lista de cuentas. Este listado puede estar formado por cuentas simples, o incluso otras cuentas compuestas.

Básicamente el método SetTotal de una clase TCuentaCompuesta iterará recursivamente por todas las TCuentaCompuesta que componen el listado, hasta llegar a las cuentas simples. Fíjese que TCuentaCompuesta posee un método AddCuenta y por tanto pueden añadirse ambos tipos de cuenta.

Bajo este patrón Composite, se puede trabajar en forma análoga al esquema "árbol".
Si bien es un diseño un tantito más complejo debido a que introduce nuevas clases, en ocasiones este diseño es útil puesta que aclara mejor como el dominio. Se ve claramente como se tratan las cuentas simples de las compuestas.

Bueno, es sólo otra opción. Desde lo lógico. Como menciona Lepe.

Saludos compuestos,

[javier7ar]

Esta como para poner en el libro jeje Iba a sugerir una funcion recursiva para calcular los totales recorriendo el TreeView, pero me parece que esto que proponen es mas elegante
Saludos

[DANY]

Perfecto amigo lepe, en mi objeto cuentaContable tengo asociada CuentaMadre que hace referencia por supuesto a la cuenta que la agrupa (aca la jerarquia es entre madres , abuelas, etc. las mujeres dominan ). es simple para cada cuenta voy recorriendo y obteniendo los totales con una funcion recursiva. Cuando tenga el codigo lo posteo, pero con la idea de base no tendra mucho valor.
Gracias por aclararme los tantos, estaba por "ensuciar" mi clase, encima no se me ocurría como.
Saludos.

[DANY]

Metodos de mi clase :

Código Delphi [-]
function TCuentasContables.DevuelveSaldoCuenta: Double;
begin

  //Si la cuenta es imputable devuelvo el valor saldo cuenta cargado de la BD una vez creada la cuenta
  if CuentaImputable  then
    Result := SaldoCuenta
 //Si no lo es itero hasta llegar a cuentas imputables.
  Else
    Result := Result + DevuelveSaldoCuentasHijas ;

end;

Código Delphi [-]
function TCuentasContables.DevuelveSaldoCuentasHijas: Double;
var
  I : Integer;
begin
  if not Assigned(CuentasHijas) then
  Begin
    Result :=0;
    Exit;
  End;

  for I := 0 to CuentasHijas.Count-1 do
    Result := Result +TCuentasContables(CuentasHijas.Items[i]).DevuelveSaldoCuenta ;

end;

Luego desde el form para mostrar en el arbol:

Código Delphi [-]
  for N :=1  to tvArbol.Items.Count -1 do
    tvArbol.Items [N].Text := tvArbol.Items [N].Text +' ( '+ FormatFloat ('$0.00', TCuentasContables (tvArbol.Items [N].Data ).DevuelveSaldoCuenta )+' )';

Gracias a todos.
Mision Cumplida!!!

[[Lepe]]

Te voy a comentar una chapuza (con la esperanza de que alguien me de soluciones... ¿por qué no? ) para evitar los moldeos de tipos.

Desde luego el código se hace más legible y es muy muy fácil hacerlo.

En Tcuentascontables defines una función:

Código Delphi [-]

TCuentasContables = class(TObject)
public
 function AsCuentaContable:TCuentasContables;
end;

function AsCuentasContable:TCuentasContables;
begin
  result := TCuentasContables(self);
end;

De forma que tu linea:

Código Delphi [-]
TCuentasContables (tvArbol.Items [N].Data ).DevuelveSaldoCuenta

quedaría como :

Código Delphi [-]
tvArbol.Items[N].Data.AsCuentaContables.DevuelveSaldoCuenta

Este truquito lo he usado en una sóla ocasión, y la verdad el código se aclaró bastante en legibilidad. No sé si hay otra solución, espero que sí .

En mi caso, tanto Talbaran, TFactura y TCliente heredaban de TBaseObject y en TBaseObject creé esas 3 funciones asAlbaran, AsFactura, AsCliente. Por supuesto en la aplicación siempre usaba TBaseObject para crear los objetos:

Código Delphi [-]
var
  nuevo :TBaseObject;
begin
   nuevo := TAlbaran.Create(...);
end;

A partir de ahora, uso nuevo.asAlbaran y elimino todos los moldeos de tipos que usaba en la aplicación final.

Por supuesto debes saber lo que haces, porque si tienes un Talbaran y pides asCliente tendrás errores de ejecución (probablemente...).

Como ves, realmente el moldeo de tipos no hay quien lo quite, está presente en las funciones, pero en la aplicación final no tienes ninguno.

Saludos.