а у меня есть компонентик

ClientDBTreeView.PASunit ClientDBTreeView;

interface

uses
Variants,
Windows, Messages, SysUtils, Classes, Controls, ComCtrls,
DB, DBCtrls, DBClient, Graphics ;

type

{ TClientDBTreeView }

TOnGetDisplayText = procedure(DataSet: TClientDataSet; var Text: string) of object;
TOnGetDisplayParams = procedure(Node: TTreeNode; DataSet: TClientDataSet; Canvas: TCanvas) of object;
TOnGetAdditionalNodes = procedure(ANode: TTreeNode) of object;
TOnGetAdditionalNodeParam = procedure(ANode: TTreeNode) of object;
TOnAcceptNode = procedure(DataSet: TClientDataSet; var Accept: boolean) of object;

TClientDBTreeView = class(TTreeView)
private

FSyncLockCount: integer;

FClientDataSet: TClientDataSet;

FParentIDField: string;
FIDField: string;
FStartWithIDField: integer;

FDataLink: TFieldDataLink;

FOnGetDisplayText: TOnGetDisplayText;
FOnGetAdditionalNodes: TOnGetAdditionalNodes;
FOnGetAdditionalNodeParam: TOnGetAdditionalNodeParam;
FOnGetDisplayParams: TOnGetDisplayParams;
FOnAcceptNode: TOnAcceptNode;

FSyncChangesToDataSet: boolean;
FSyncChangesFromDataSet: boolean;

procedure CNNotify(var Message: TWMNotify); message CN_NOTIFY;

procedure DataChange(Sender: TObject);
procedure UpdateData(Sender: TObject);
procedure ActiveChange(Sender: TObject);

function GetDataField: string;
procedure SetDataField(const Value: string);
function GetDataSource: TDataSource;
procedure SetDataSource(Value: TDataSource);

function GetIDFieldFld: TField;
property IDFieldFld: TField read GetIDFieldFld;

function GetParentIDFieldFld: TField;
property ParentIDFieldFld: TField read GetParentIDFieldFld;

function GetDataFieldFld: TField;
property DataFieldFld: TField read GetDataFieldFld;

function GetDisplayText: string;
property DisplayText: string read GetDisplayText;

function FillNode(ATreeNode: TTreeNode): TTreeNode;
procedure CMGetDataLink(var Message: TMessage); message CM_GETDATALINK;

protected
procedure DoAddNode(AParent: TTreeNode; Data: Integer);
protected
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
protected
procedure DoGetAdditionalNodesEvent(ANode: TTreeNode);
procedure DoGetAdditionalNodeParamEvent(ANode: TTreeNode);
procedure DoGetDisplayParams(Node: TTreeNode);
protected
procedure Change(Node: TTreeNode); override;
function CustomDrawItem(Node: TTreeNode; State: TCustomDrawState;
Stage: TCustomDrawStage; var PaintImages: Boolean): Boolean; override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;

function GetTreeNodeByData(AData: integer): TTreeNode;
function GetTopParent(ATreeNode: TTreeNode): TTreeNode;
function GetRecordStatus(ANode: TTreeNode): TUpdateStatus;
function GetRecordClientDataSet(ANode: TTreeNode): boolean;
procedure RefreshAll;
procedure RefreshCurrent;
procedure DeleteNode(AIDField: integer);

// óñòàíîâêà ïîçèöèé
procedure TreeViewToDataSet;
procedure DataSetToTreeView;

property ClientDataSet: TClientDataSet read FClientDataSet;

function ExecuteAction(Action: TBasicAction): Boolean; override;
function UpdateAction(Action: TBasicAction): Boolean; override;

property StartWithIDField: integer read FStartWithIDField write FStartWithIDField;

published
property IDField: string read FIDField write FIDField;
property ParentIDField: string read FParentIDField write FParentIDField;

property SyncChangesToDataSet: boolean read FSyncChangesToDataSet write FSyncChangesToDataSet;
property SyncChangesFromDataSet: boolean read FSyncChangesFromDataSet write FSyncChangesFromDataSet;

property DataField: string read GetDataField write SetDataField;
property DataSource: TDataSource read GetDataSource write SetDataSource;

property OnGetDisplayText: TOnGetDisplayText read FOnGetDisplayText write FOnGetDisplayText;
property OnGetAdditionalNodes: TOnGetAdditionalNodes read FOnGetAdditionalNodes write FOnGetAdditionalNodes;
property OnGetAdditionalNodeParam: TOnGetAdditionalNodeParam read FOnGetAdditionalNodeParam write FOnGetAdditionalNodeParam;
property OnGetDisplayParams: TOnGetDisplayParams read FOnGetDisplayParams write FOnGetDisplayParams;
property OnAcceptNode: TOnAcceptNode read FOnAcceptNode write FOnAcceptNode;

property Items stored False;
end;

implementation

uses
CommCtrl;

{ TClientDBTreeView }

constructor TClientDBTreeView.Create(AOwner: TComponent);
begin
inherited;

FSyncLockCount := 0;

FClientDataSet := TClientDataSet.Create(nil);
FClientDataSet.FetchOnDemand := false;

FDataLink := TFieldDataLink.Create;
FDataLink.Control := Self;
FDataLink.OnDataChange := DataChange;
FDataLink.OnUpdateData := UpdateData;
FDataLink.OnActiveChange := ActiveChange;
end;

destructor TClientDBTreeView.Destroy;
begin
FClientDataSet.Free;
FDataLink.Free;
FDataLink := nil;
inherited;
end;

procedure TClientDBTreeView.CMGetDataLink(var Message: TMessage);
begin
Message.Result := Integer(FDataLink);
end;

procedure TClientDBTreeView.DataChange(Sender: TObject);
begin
if FSyncChangesFromDataSet then
if FSyncLockCount = 0 then
if FDataLink.DataSet <> nil then
if FDataLink.DataSet.State = dsBrowse then
TreeViewToDataSet;
end;

procedure TClientDBTreeView.UpdateData(Sender: TObject);
begin
end;

procedure TClientDBTreeView.ActiveChange(Sender: TObject);
begin
if not FDataLink.Active then
Items.Clear
else
begin
FClientDataSet.CloneCursor(TClientDataSet(FDataLink.DataSet), True);
FClientDataSet.AddIndex('IDField', IDField, []);
FClientDataSet.AddIndex('ParentIDField', ParentIDField, []);
RefreshAll;
end;
end;

function TClientDBTreeView.GetDataField: string;
begin
result := FDataLink.FieldName;
end;

procedure TClientDBTreeView.SetDataField(const Value: string);
begin
FDataLink.FieldName := Value;
end;

function TClientDBTreeView.GetDataSource: TDataSource;
begin
result := FDataLink.DataSource;
end;

procedure TClientDBTreeView.SetDataSource(Value: TDataSource);
begin
FDataLink.DataSource := Value;
end;

function TClientDBTreeView.GetIDFieldFld: TField;
begin
result := FClientDataSet.FieldByName(FIDField);
end;

function TClientDBTreeView.GetParentIDFieldFld: TField;
begin
result := FClientDataSet.FieldByName(FParentIDField);
end;

function TClientDBTreeView.GetDataFieldFld: TField;
begin
result := FClientDataSet.FieldByName(FDataLink.FieldName);
end;

procedure TClientDBTreeView.DoGetAdditionalNodesEvent(ANode: TTreeNode);
begin
if Assigned(FOnGetAdditionalNodes) then FOnGetAdditionalNodes(ANode);
end;

procedure TClientDBTreeView.DoGetAdditionalNodeParamEvent(ANode: TTreeNode);
begin
if Assigned(FOnGetAdditionalNodeParam) then FOnGetAdditionalNodeParam(ANode);
end;

function TClientDBTreeView.GetTreeNodeByData(AData: integer): TTreeNode;
var
I: integer;
begin
result := nil;
for I := 0 to Items.Count - 1 do
if integer(Items.Item .Data) = AData then
begin
result := Items.Item;
break;
end;
end;

function TClientDBTreeView.GetTopParent(ATreeNode: TTreeNode): TTreeNode;
begin
result := ATreeNode;
while result.Parent <> nil do
result := result.Parent;
end;

function TClientDBTreeView.GetRecordStatus(ANode: TTreeNode): TUpdateStatus;
begin
result := usUnModified;
FClientDataSet.IndexName := 'IDField';
if FClientDataSet.FindKey([integer(ANode.Data)]) then
result := FClientDataSet.UpdateStatus;
end;

function TClientDBTreeView.GetRecordClientDataSet(ANode: TTreeNode): boolean;
begin
FClientDataSet.IndexName := 'IDField';
result := FClientDataSet.FindKey([integer(ANode.Data)]);
end;

function TClientDBTreeView.FillNode(ATreeNode: TTreeNode): TTreeNode;
var
AID: variant;
TN: TTreeNode;
begin

if ATreeNode = nil then
begin
if FStartWithIDField <> 0 then
AID := FStartWithIDField
else
AID := null;
end
else
AID := integer(ATreeNode.Data);

if (ATreeNode = nil) and (not VarIsNull(AID)) then
begin
FClientDataSet.IndexName := 'IDField';
FClientDataSet.SetRange([AID], [AID]);
end
else
begin
FClientDataSet.IndexName := 'ParentIDField';
FClientDataSet.SetRange([AID], [AID]);
end;

FClientDataSet.First;
while not FClientDataSet.Eof do
begin
DoAddNode(ATreeNode, IDFieldFld.AsInteger);
FClientDataSet.Next;
end;

if ATreeNode <> nil then
result := ATreeNode.GetFirstChild
else
result := Items.GetFirstNode;
end;

procedure TClientDBTreeView.RefreshAll;

procedure FILLTREE(ATreeNode: TTreeNode);
begin
ATreeNode := FillNode(ATreeNode);
while ATreeNode <> nil do
begin
FILLTREE(ATreeNode);
ATreeNode := ATreeNode.GetNextSibling;
end;
end;

// procedure RUNTREE(ATreeNode: TTreeNode);
// begin
// if ATreeNode.Data <> nil then DoGetAdditionalNodesEvent(ATreeNode);
// if ATreeNode.GetFirstChild <> nil then RUNTREE(ATreeNode.GetFirstChild);
// if ATreeNode.GetNextSibling <> nil then RUNTREE(ATreeNode.GetNextSibling);
// end;

begin
Inc(FSyncLockCount);
try
Items.Clear;
FILLTREE(nil);
// if Items.Count > 0 then RUNTREE(Items.GetFirstNode);
finally
Dec(FSyncLockCount);
end;
end;

procedure TClientDBTreeView.RefreshCurrent;
var
TN: TTreeNode;
I: integer;
begin

FClientDataSet.CancelRange;
if FClientDataSet.IsEmpty then exit;

FClientDataSet.CancelRange;
FClientDataSet.GotoCurrent(TClientDataSet(FDataLink.DataSet));

TN := GetTreeNodeByData(IDFieldFld.AsInteger);
if TN <> nil then
begin

TN.Text := DisplayText;
DoGetAdditionalNodesEvent(TN);

end
else
begin

TN := GetTreeNodeByData(ParentIDFieldFld.AsInteger);

DoAddNode(TN, IDFieldFld.AsInteger);

end;

end;

procedure TClientDBTreeView.DeleteNode(AIDField: integer);
var
TN: TTreeNode;
begin
TN := GetTreeNodeByData(AIDField);
if TN <> nil then TN.Delete;
end;

procedure TClientDBTreeView.TreeViewToDataSet;
begin
Selected := GetTreeNodeByData(FDataLink.DataSet.FieldByName(IDField).AsInteger);
end;

procedure TClientDBTreeView.DataSetToTreeView;
begin
if Selected = nil then exit;
if not FClientDataSet.Active then exit;
if not FDataLink.DataSet.Active then exit;
if FDataLink.DataSet.State <> dsBrowse then
FDataLink.DataSet.Post;

FClientDataSet.IndexName := 'IDField';
if FClientDataSet.FindKey([integer(Selected.Data)]) then
TClientDataSet(FDataLink.DataSet).GotoCurrent(FClientDataSet);
end;


procedure TClientDBTreeView.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
TN: TTreeNode;
begin
if Button = mbRight then
begin
TN := GetNodeAt(X, Y);
if TN <> nil then TN.Selected := True;
end;
inherited;
end;

procedure TClientDBTreeView.CNNotify(var Message: TWMNotify);
begin
inherited;
{
with Message do
case NMHdr^.code of
// íå äàäèì äâîéíîìó êëèêó ïåðåêëþ÷àòü îòêðûòèå/çàêðûòèå óçëîâ
NM_DBLCLK, NM_RDBLCLK:
begin
Message.Result := 1;
end;
end;
}
end;

function TClientDBTreeView.GetDisplayText: string;
begin
result := DataFieldFld.DisplayText;
if Assigned(FOnGetDisplayText) then
FOnGetDisplayText(FClientDataSet, result);
end;

function TClientDBTreeView.ExecuteAction(Action: TBasicAction): Boolean;
begin
Result := inherited ExecuteAction(Action) or (FDataLink <> nil) and
FDataLink.ExecuteAction(Action);
end;

function TClientDBTreeView.UpdateAction(Action: TBasicAction): Boolean;
begin
Result := inherited UpdateAction(Action) or (FDataLink <> nil) and
FDataLink.UpdateAction(Action);
end;

//

function TClientDBTreeView.CustomDrawItem(Node: TTreeNode;
State: TCustomDrawState; Stage: TCustomDrawStage;
var PaintImages: Boolean): Boolean;
begin
result := inherited CustomDrawItem(Node, State, Stage, PaintImages);
DoGetDisplayParams(Node);
end;

procedure TClientDBTreeView.DoGetDisplayParams(Node: TTreeNode);
begin
if Assigned(FOnGetDisplayParams) then
begin
FClientDataSet.IndexName := 'IDField';
if ClientDataSet.FindKey([integer(Node.Data)]) then
FOnGetDisplayParams(Node, FClientDataSet, Canvas);
end;
end;

procedure TClientDBTreeView.Change(Node: TTreeNode);
begin
inherited;
if FSyncChangesToDataSet and (FSyncLockCount = 0) then DataSetToTreeView;
end;

procedure TClientDBTreeView.DoAddNode(AParent: TTreeNode; Data: Integer);
var
Accept: boolean;
TN: TTreeNode;
begin
Accept := True;
if Assigned(FOnAcceptNode) then FOnAcceptNode(FClientDataSet, Accept);
if Accept then
begin
TN := Items.AddChildObject(AParent, DisplayText, pointer(Data));
//
DoGetAdditionalNodesEvent(TN);
DoGetAdditionalNodeParamEvent(TN);
end;
end;

end.