[[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,