BillsEditor/CU/ScKindsOfTrees.pas

unit ScKindsOfTrees;

interface

uses
  Contnrs,
  Classes,
  DB,
  ZjIDTree,
  ADODB,
  DBClient,
  ConstVarUnit,
  Windows;

type

  TDrawingQuantityItem = class
  private
    FID: Integer;
    FBillsID: Integer;
    FSerinalNo: Integer;
    FName: string;
    FUnits: string;
    FDesignQuantity1: Double;
    FDesignQuantity2: Double;
    FMemoContext: string;
  public
    procedure Assign(aSrcItem: TDrawingQuantityItem);

    property ID: Integer read FID write FID;
    property BillsID: Integer read FBillsID write FBillsID;
    property SerinalNo: Integer read FSerinalNo write FSerinalNo;
    property Name: string read FName write FName;
    property Units: string read FUnits write FUnits;
    property DesignQuantity1: Double read FDesignQuantity1 write FDesignQuantity1;
    property DesignQuantity2: Double read FDesignQuantity2 write FDesignQuantity2;
    property MemoContext: string read FMemoContext write FMemoContext;
  end;

  TExprsNode = class
  private
    FMajorID: Integer;
    FMinorID: Integer;
    FRecdID: Integer;
    FExprs: string;
    FExprs1: string;
  public

  end;

  {导入Excel用的树}
  TScExcelItem = class
  private
    FID: Integer;
    FParent: TScExcelItem;
    FNextSibling: TScExcelItem;
    FFirstChild: TScExcelItem;
    FLastChild: TScExcelItem;

    FCode: string;
    FBCode: string;
    FName: string;
    FUnits: string;
    FQuantity: Double;
    FQuantity1: Double;
    FQuantity2: Double;
    FPrice: Double;
    FTotalPrice: Double;
    FMemoString: string;

    {父节点的编号, 以'－'结尾的字符串, 如：'1-1-'}
    FParentCode: string;
    function GetParentID: Integer;
    function GetNextSiblingID: Integer;
  public
    function HasChildren: Boolean;
    procedure AssignFirstChild(ANode: TScExcelItem);
    procedure MoveLastChild(ANode: TScExcelItem);
    property ParentCode: string read FParentCode write FParentCode;

    property ID: Integer read FID write FID;
    property ParentID: Integer read GetParentID;
    property NextSiblingID: Integer read GetNextSiblingID;
    property Parent: TScExcelItem read FParent write FParent;
    property NextSibling: TScExcelItem read FNextSibling write FNextSibling;
    property FirstChild: TScExcelItem read FFirstChild;
    property LastChild: TScExcelItem read FLastChild;

    property Code: string read FCode write FCode;
    property BCode: string read FBCode write FBCode;
    property Name: string read FName write FName;
    property Units: string read FUnits write FUnits;
    property Quantity: Double read FQuantity write FQuantity;
    property Quantity1: Double read FQuantity1 write FQuantity1;
    property Quantity2: Double read FQuantity2 write FQuantity2;
    property Price: Double read FPrice write FPrice;
    property TotalPrice: Double read FTotalPrice write FTotalPrice;
    property MemoString: string read FMemoString write FMemoString;
  end;

  TScExcelItemTree = class
  private
    FRoot: TScExcelItem;
    FList: TObjectList;
    FDrawQList: TObjectList;
    FBillsData: TObject;
    FPartID: Integer;
    {指向项目列的最后一个节点}
    FPNode: TScExcelItem;
    {指向清单列的最后一个节点}
    FBNode: TScExcelItem;
    FMaxNodeID: Integer;
    FMaxDrawQID: Integer;
    // 保存所有子节点列表
    FPartOne: TStringList;
    FPartTwo: TStringList;
    FPartThree: TStringList;
    function GetFirstNode: TScExcelItem;
    function InsertOmissionCode(const ACode: string): TScExcelItem;
    function InsertOmissionBCode(const ABCode: string): TScExcelItem;
    function InsertCode(const ACode: string): TScExcelItem;
    function InsertBCode(const ABCode: string): TScExcelItem;
    function InsertNull(const AIsPreDefine: Boolean = False): TScExcelItem;
    function FindNode(const AID: Integer): TScExcelItem;
    procedure ModifyNodePosition(ANode: TScExcelItem; const AParentID, ANextSiblingID: Integer);
    function Add(const AID, AParentID, ANextSiblingID: Integer): TScExcelItem;
    procedure InternalInsertNode(ANode: TScExcelItem);
    procedure RefreshBills;
    procedure RefreshDrawingQuantity;
  public
    constructor Create(aBillsData: TObject);
    destructor Destroy; override;

    function AddNodeByCode(const ACode: string; const ABCode: string = '';
      const AName: string = ''): TScExcelItem;
    function AddDrawQuantity: TDrawingQuantityItem;
    procedure RefreshDataBase;

    {添加一二三部分高端节点}
    procedure AddFirstNode(const AID: Integer);
    function LastNextSiblingID: Integer;
    procedure ViewBillTreeParts;
    procedure DeleteNode(AObject: TObject);

    property FirstNode: TScExcelItem read GetFirstNode;
    property PNode: TScExcelItem read FPNode write FPNode;
    property BNode: TScExcelItem read FBNode write FBNode;
    property MaxNodeID: Integer read FMaxNodeID write FMaxNodeID;
    property MaxDrawQID: Integer read FMaxDrawQID write FMaxDrawQID;
    property PartOne: TStringList read FPartOne;
    property PartTwo: TStringList read FPartTwo;
    property PartThree: TStringList read FPartThree;
  end;

  
  {汇总用的树}

  TCacheGatherTree = class;

  TCacheGatherNode = class
  private
    FID: Integer;
    FCode: string;
    FBCode: string;
    FName: string;
    FUnits: string;
    FUnitPrice: Double;
    FTotalPrice: Double;
    FMemostring: string;
    FQuantity: Double;
    FDesignPrice: Double;
    FDesignQuantity1: Double;
    FDesignQuantity2: Double;
    FOldCode: string;
    FOldBCode: string;
    FIsPreDefine: Boolean;

    FOwner: TCacheGatherTree;
    FDQList: TList;
    FExprsList: TList;

    FParent: TCacheGatherNode;
    FNextSibling: TCacheGatherNode;
    FPreSibling: TCacheGatherNode;
    FFirstChild: TCacheGatherNode;
    FLastChild: TCacheGatherNode;
    procedure DeleteDQItems;
    function GetParentID: Integer;
    function GetNextSiblingID: Integer;
  public
    constructor Create(aOwner: TCacheGatherTree);
    destructor Destroy; override;

    procedure DeleteChildren;
    procedure RemoveFromParent;
    { Assign }
    procedure AssignDraw(aNode: TCacheGatherNode);
    procedure Assign(aNode: TCacheGatherNode; aIncludeDraw: Boolean = True);

    procedure MoveFirstChild(ANode: TCacheGatherNode);
    procedure MoveLastChild(ANode: TCacheGatherNode);
    procedure MovePreSibling(ANode: TCacheGatherNode);
    function HasChildren: Boolean;

    property Parent: TCacheGatherNode read FParent;
    property NextSibling: TCacheGatherNode read FNextSibling;
    property FirstChild: TCacheGatherNode read FFirstChild;
    property LastChild: TCacheGatherNode read FLastChild;
    property DQList: TList read FDQList write FDQList;

    property ID: Integer read FID write FID;
    property ParentID: Integer read GetParentID;
    property NextSiblingID: Integer read GetNextSiblingID;
    property Code: string read FCode write FCode;
    property BCode: string read FBCode write FBCode;
    property Name: string read FName write FName;
    property Units: string read FUnits write FUnits;
    property Quantity: Double read FQuantity write FQuantity;
    property DesignQuantity1: Double read FDesignQuantity1 write FDesignQuantity1;
    property DesignQuantity2: Double read FDesignQuantity2 write FDesignQuantity2;
    property UnitPrice: Double read FUnitPrice write FUnitPrice;
    property DesignPrice: Double read FDesignPrice write FDesignPrice;
    property TotalPrice: Double read FTotalPrice write FTotalPrice;
    property MemoString: string read FMemostring write FMemostring;
    property OldCode: string read FOldCode write FOldCode;
    property OldBCode: string read FOldBCode write FOldBCode;
    property IsPreDefined: Boolean read FIsPreDefine write FIsPreDefine;
  end;

  TCacheGatherTree = class
  private
    FMinIDList: TList;
    FCacheList: TObjectList;
    FRoot: TCacheGatherNode;
    FProject: TObject;
    FMaxID: Integer;
    FMaxDQID: Integer;
    FBillsCode: string;
    FTokenID: Integer;
    function GetFirstNode: TCacheGatherNode;
    procedure MergeCacheList;
    function SerialSearch(const AID: Integer): TCacheGatherNode;
    function DichotomySearch(const AID: Integer): TCacheGatherNode;
    function FindCacheNode(const AID: Integer): TCacheGatherNode;
    // 按编号排序节点  [Litao 2012.1.12]
    procedure SortCacheTreeNodes(AParent: TCacheGatherNode);
    procedure AddChildren(AParent: TCacheGatherNode; AList: TList);
    procedure MoveChildren(AParent: TCacheGatherNode; AList: TList);
    procedure SortChildren(AParent: TCacheGatherNode);

    procedure DeleteBySerialSearch(const ANode: TCacheGatherNode);
    procedure DeleteByDichotomySearch(const ANode: TCacheGatherNode);
    procedure DeleteNode(ANode: TCacheGatherNode);
    {合并两个节点}
    procedure CombineDrawQ(ASrcQList, ADestQList: TList; aDestID: Integer);
    procedure CombineNodeQuantity(ASrc, ADest: TCacheGatherNode);
    {Asrc移到ADest前面}
    procedure MovePreNode(ASrc, ADest: TCacheGatherNode);

    function IncludeToken(const aCode: string): Boolean;
    function ConvertCode(const aCode, aGCode: string): string;
    function SplitAndConvertCode(const aCode, aGCode: string; ASpliter: Char = '-'): string;
    procedure AddBillsExprs(ABillsID: Integer; ACacheNode: TCacheGatherNode);
    {汇总部分}
    function ModifyBillsCode(const ACode: string): string; overload;
    procedure ModifyBillsCode(GNode: TCacheGatherNode; const aParentCode: string); overload;
    procedure PlusItems(xNode: TZjIDTreeNode; GNode: TCacheGatherNode; aLevel: Integer; IsCode: Boolean);
    procedure InternalDetail(AGNode: TCacheGatherNode; ANode: TZjIDTreeNode; const AParentCode: string);
    procedure AddGatherNode(AGatherNode: TCacheGatherNode;
      AZjNode: TZjIDTreeNode; aLevel: Integer; const aBCode, aName: string);
    procedure AdjustStructor(AParNode, AChdNode: TCacheGatherNode);
    procedure AddBillsNode(ANode: TZjIDTreeNode; AGatherParent: TCacheGatherNode);
    procedure GatherCurNode(ANode: TZjIDTreeNode; AGatherParent: TCacheGatherNode; aLevel: Integer);
  public
    constructor Create;
    destructor Destroy; override;

    function AddCacheNode(const AID, AParentID, ANextSiblingID: Integer): TCacheGatherNode;
    function TraverseDBIntoSelf(AProject: TObject): Boolean;
    procedure TraverseOwnerIntoDB(AProject: TObject);

    property FirstNode: TCacheGatherNode read GetFirstNode;
  end;

  { Merge Gather Tree }

  TMergeGatherTree = class(TCacheGatherTree)
  private
    FIsOpen1: Boolean;
    FIsOpen2: Boolean;
    FBillsTree1: TZjIDTree;
    FBillsTree2: TZjIDTree;
    FCdsDraw1: TClientDataSet;
    FCdsDraw2: TClientDataSet;
    FCdsExprs: TClientDataSet;
    FMergeByCode: Boolean;

    procedure InitMaxID;
    // 为桩号重新编号
    procedure ReCodeNode(ANode: TCacheGatherNode);
    { Add Bills }
    procedure AddDrawItems(aCdsDraw: TClientDataSet; aBillsID: Integer; aCGNode: TCacheGatherNode);
    procedure AddExprs(AORecID: Integer; AGNode: TCacheGatherNode);
    procedure AssignTo(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode);
    procedure AssignByOpened(aBillsTree: TObject; aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode);
    procedure AddNode(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode; aBillsTree: TZjIDTree;
      aCdsDraw: TClientDataSet; aIsOpened: Boolean);
    function AddSingleNode(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode; aBillsTree: TZjIDTree;
      aCdsDraw: TClientDataSet; aIsOpened: Boolean): TCacheGatherNode;
    { Update Bills }
    procedure UpdateDrawItems(aBillsID: Integer; aCGNode: TCacheGatherNode);
    procedure UpdateQuantity(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode);
    procedure UpdateQuantityByOpened(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode);
    procedure UpdateNode(aNode: TZjIDTreeNode; aGatherNode: TCacheGatherNode);
    { Update Gather }
    function AddSingleGatherNode(aSrcNode, aDstNode: TCacheGatherNode): TCacheGatherNode;
    procedure AddGatherNode(aSrcNode, aDstNode: TCacheGatherNode);
    procedure UpdateGatherDrawItems(aSrcNode, aDstNode: TCacheGatherNode);
    procedure UpdateGatherQuantity(aSrcNode, aDstNode: TCacheGatherNode);
    procedure UpdateGatherNode(aSrcNode, aDstNode: TCacheGatherNode);
    { write }
    procedure WriteBills(aNode: TCacheGatherNode; aTable: TDataSet);
    procedure WriteDraw(aNode: TCacheGatherNode; aTable: TDataSet);
    procedure WriteExprs(aNode: TCacheGatherNode; ADataset: TDataSet);
  public
    procedure GatherBillsTree(aBillsTree: TZjIDTree);
    procedure UpdateBillsTree(aBillsTree: TZjIDTree);
    procedure GatherTree(aGatherTree: TMergeGatherTree);

    procedure WriteTo(aBillsTable, aDrawTable, aExprsTable: TDataSet);

    property IsOpen1: Boolean read FIsOpen1 write FIsOpen1;
    property IsOpen2: Boolean read FIsOpen2 write FIsOpen2;
    property CdsDraw1: TClientDataSet read FCdsDraw1 write FCdsDraw1;
    property CdsDraw2: TClientDataSet read FCdsDraw2 write FCdsDraw2;
    property BillsTree1: TZjIDTree read FBillsTree1 write FBillsTree1;
    property BillsTree2: TZjIDTree read FBillsTree2 write FBillsTree2;
    property CdsExprs: TClientDataSet read FCdsExprs write FCdsExprs;
    property MergeByCode: Boolean read FMergeByCode write FMergeByCode;
  end;

  TSplitGatherTree = Class(TMergeGatherTree)
  private
    FOwnerName: string;

    procedure SearchParents(aNode: TZjIDTreeNode; aParList: TList);
    function FindChildNode(aNode: TZjIDTreeNode; aCgnNode: TCacheGatherNode): TCacheGatherNode;
    function AddSingleNode(aNode: TZjIDTreeNode; aCgnNode: TCacheGatherNode): TCacheGatherNode; overload;
    function AddParent(aNode: TZjIDTreeNode): TCacheGatherNode;
    procedure GenerateGatherTree(aNode: TZjIDTreeNode);
  public
    procedure SplitBillsTree(aBillsTree: TZjIDTree; aCdsDraw: TClientDataSet; const aOwnerName: string);
  end;

implementation

uses
  SysUtils,
  DataBase,
  ScProjectManager,
  ConstMethodUnit,
  Math,
  ScBillsTree,
  ScExprsDM,
  ScConfig,
  ScProgressFrm;

const
  TokenArray: array [0..10] of Char = ('N', 'M', 'Q', 'L', 'P', 'R', 'S', 'T', 'X', 'Y', 'Z');

{ TScExcelItemTree }

function TScExcelItemTree.Add(const AID, AParentID,
  ANextSiblingID: Integer): TScExcelItem;
var
  paNode: TScExcelItem;
begin
  Result := TScExcelItem.Create;
  Result.ID := AID;
  {修改节点关系}
  ModifyNodePosition(Result, AParentID, ANextSiblingID);
  FList.Add(Result);
end;

function TScExcelItemTree.AddDrawQuantity: TDrawingQuantityItem;
begin
  Result := TDrawingQuantityItem.Create;
  Result.ID := FMaxDrawQID;
  if Assigned(FBNode) then
    Result.BillsID := FBNode.ID
  else Result.BillsID := FPNode.ID;
  FDrawQList.Add(Result);
  Inc(FMaxDrawQID);
end;

procedure TScExcelItemTree.AddFirstNode(const AID: Integer);
  function AddPartNode(const ID: Integer): TScExcelItem;
  begin
    Result := Add(ID, -1, -1);
    Result.ParentCode := '';
    Result.Code := IntToStr(ID);
  end;
begin
  PNode := AddPartNode(1);
  AddPartNode(2);
  AddPartNode(3);
  FPartID := 2;
end;

function TScExcelItemTree.AddNodeByCode(const ACode,
  ABCode, AName: string): TScExcelItem;
begin
  if not SameText(ACode, '') then {Code}
  begin
    if Pos('…', ACode) = 0 then
    begin
      if FPNode = nil then
      begin
        Result := nil;
        Exit;
      end;
      Result := InsertCode(ACode);
      if Assigned(FBNode) then FBNode := nil;
    end
    else Result := nil;
  end
  else if not SameText(ABCode, '') then  {BCode}
  begin
    if Pos('…', ABCode) = 0 then
      Result := InsertBCode(ABCode) 
    else Result := nil;
  end
  else {...}
  begin
    Result := InsertNull;
    if Assigned(FBNode) then FBNode := nil;
  end;
  
  Inc(FMaxNodeID);
end;

constructor TScExcelItemTree.Create(aBillsData: TObject);
begin
  FBillsData := aBillsData;
  FList := TObjectList.Create;
  FRoot := TScExcelItem.Create;
  FRoot.ID := -1;
  FPartOne := TStringList.Create;
  FPartTwo := TStringList.Create;
  FPartThree := TStringList.Create;
  FPartID := 1;
  FDrawQList := TObjectList.Create;
end;

procedure TScExcelItemTree.DeleteNode(AObject: TObject);
begin
  FList.Remove(AObject);
  AObject.Free;
end;

destructor TScExcelItemTree.Destroy;
begin
  FreeAndNil(FDrawQList);
  FreeAndNil(FList);
  FreeAndNil(FRoot);
  FreeAndNil(FPartOne);
  FreeAndNil(FPartTwo);
  FreeAndNil(FPartThree);
  inherited;
end;

function TScExcelItemTree.FindNode(const AID: Integer): TScExcelItem;
var
  ilow, ihigh, imid: Integer;
  eNode: TScExcelItem;
begin
  Result := nil;
  ilow := 0;
  ihigh := FList.Count - 1;
  while ilow <= ihigh do
  begin
    imid := (ilow + ihigh) div 2;
    eNode := TScExcelItem(FList[imid]);
    if eNode.ID = AID then
    begin
      Result := eNode;
      Break;
    end;
    if eNode.ID < AID then ilow := imid + 1
    else ihigh := imid - 1;
  end;
end;

function TScExcelItemTree.GetFirstNode: TScExcelItem;
begin
  Result := FRoot.FirstChild;
end;

function TScExcelItemTree.InsertBCode(const ABCode: string): TScExcelItem;
begin
  if not Assigned(FBNode) or (FBNode = FPNode) then
  begin
    Result := Add(FMaxNodeID, FPNode.ID, -1);
    Result.ParentCode := Format('%s-', [ABCode]);
    Result.BCode := ABCode;
    FBNode := Result;
  end
  else
  begin
    if Pos(FBNode.ParentCode, ABCode) = 1 then
    begin
      if Pos(Format('%s-', [FBNode.BCode]), ABCode) <> 1 then
      begin
        Result := Add(FMaxNodeID, FBNode.ParentID, -1);
        Result.ParentCode := FBNode.ParentCode;
        Result.BCode := ABCode;
        FBNode := Result;
      end
      else
      begin
        Result := Add(FMaxNodeID, FBNode.ID, -1);
        Result.ParentCode := Format('%s-', [FBNode.BCode]);
        Result.BCode := ABCode;
        FBNode := Result;
      end;
    end
    else
    begin
      FBNode := FBNode.Parent;
      Result := InsertBCode(ABCode);
    end;
  end;
end;

function TScExcelItemTree.InsertCode(const ACode: string): TScExcelItem;
var
  iErr: Integer;
  sCode: string;
begin
  if Pos(FPNode.ParentCode, ACode) = 1 then
  begin
    if (Pos(FPNode.Code + '-', ACode) <> 1) or (FPNode.Code = ACode) then
    begin
      Result := Add(FMaxNodeID, FPNode.ParentID, -1);
      Result.ParentCode := FPNode.ParentCode;
      Result.Code := ACode;
      FPNode := Result;
    end
    else
    begin
      Result := Add(FMaxNodeID, FPNode.ID, -1);
      Result.ParentCode := Format('%s-', [FPNode.Code]);
      Result.Code := ACode;
      FPNode := Result;
    end;
  end
  else
  begin
    if SameText(FPNode.ParentCode, '') then
    begin
      if Pos('-', ACode) <> 0 then
      begin
        Result := Add(FMaxNodeID, FPNode.ID, -1);
        sCode := Format('%s-', [FPNode.Code]);
        {1部分下面有3-1时情况}
        if Pos(sCode, ACode) = 0 then
          sCode := Format('%s-', [ACode]);
        Result.ParentCode := sCode;
        Result.Code := ACode;
        FPNode := Result;
      end
      else
      begin
        Val(ACode, FPartID, iErr);
        Result := FindNode(FPartID);
        FPNode := Result;
        Inc(FPartID);
      end;
    end
    else
    begin
      FPNode := FPNode.Parent;
      Result := InsertCode(ACode);
    end;
  end;
end;

function TScExcelItemTree.InsertNull(
  const AIsPreDefine: Boolean): TScExcelItem;
begin
  case AIsPreDefine of
  False:
    if Assigned(FBNode) then
      Result := Add(FMaxNodeID, FBNode.ParentID, -1)
    else
      Result := Add(FMaxNodeID, FPNode.ID, -1);
  True: Result := Add(FMaxNodeID, -1, -1);
  end;
end;

function TScExcelItemTree.InsertOmissionBCode(
  const ABCode: string): TScExcelItem;
begin
  if Assigned(FBNode) then
    Result := Add(FMaxNodeID, FBNode.ParentID, -1)
  else Result := Add(FMaxNodeID, FPNode.ID, -1);
  Result.ParentCode := '…';
  Result.Code := ABCode;
  FBNode := Result;
end;

function TScExcelItemTree.InsertOmissionCode(
  const ACode: string): TScExcelItem;
begin
  Result := Add(FMaxNodeID, FPNode.ParentID, -1);
  Result.ParentCode := '…';
  Result.Code := ACode;
  FPNode := Result;
end;

procedure TScExcelItemTree.InternalInsertNode(ANode: TScExcelItem);
begin
  TDMDataBase(FBillsData).AddBillsItem(ANode);
  if ANode.HasChildren then
    InternalInsertNode(ANode.FirstChild);
  if Assigned(ANode.NextSibling) then
    InternalInsertNode(ANode.NextSibling);
end;

function TScExcelItemTree.LastNextSiblingID: Integer;
var
  xlsItem: TScExcelItem;
begin
  xlsItem := FirstNode;
  Result := -1;
  while Assigned(xlsItem) do
  begin
    Result := xlsItem.FID;
    xlsItem := xlsItem.NextSibling;
  end;
end;

procedure TScExcelItemTree.ModifyNodePosition(ANode: TScExcelItem;
  const AParentID, ANextSiblingID: Integer);
var
  atNode, etNode: TScExcelItem;
begin
  {没考滤NextSibling为非－1情况}
  if AParentID = -1 then
  begin
    if Assigned(FRoot.FFirstChild) then
      FRoot.MoveLastChild(ANode)
    else
      FRoot.AssignFirstChild(ANode);
  end
  else
  begin
    atNode := FindNode(AParentID);
    ANode.Parent := atNode;
    if Assigned(atNode.FirstChild) then
      atNode.MoveLastChild(ANode)
    else atNode.AssignFirstChild(ANode);
  end;
end;

procedure TScExcelItemTree.RefreshBills;
var
  xlsNode, temNode: TScExcelItem;
begin
  {取第一个节点，即建安费节点}
  xlsNode := FirstNode;
  {如果第一个节点不为空，并且有子节点，则读取并写入数据}
  if Assigned(xlsNode) then
  begin
    TDMDataBase(FBillsData).EnabledUITreeEvt(False);
    TDMDataBase(FBillsData).DisconnectBillsTree;
    try
      if xlsNode.HasChildren then
      begin
        TDMDataBase(FBillsData).DeletePartSubItem(PartOne);
        InternalInsertNode(xlsNode.FirstChild);
      end;
      temNode := xlsNode;
      xlsNode := xlsNode.NextSibling;
      // 添加兄弟节点情况
      while Assigned(xlsNode) do
      begin
        if xlsNode.HasChildren then
        begin
          if xlsNode.ID = 2 then
          begin
            TDMDataBase(FBillsData).DeletePartSubItem(PartTwo);
          end
          else if xlsNode.ID = 3 then
          begin
            TDMDataBase(FBillsData).DeletePartSubItem(PartThree);
          end;
          InternalInsertNode(TScExcelItem(xlsNode).FirstChild);
        end;
        temNode := xlsNode;
        xlsNode := xlsNode.NextSibling;
      end;
    finally
      TDMDataBase(FBillsData).ConnectionBillsTree;
      TDMDataBase(FBillsData).EnabledUITreeEvt(True);
    end;
  end;
end;

procedure TScExcelItemTree.RefreshDataBase;
begin
  RefreshBills;
  RefreshDrawingQuantity;
end;

procedure TScExcelItemTree.RefreshDrawingQuantity;
var
  I: Integer;
  DQItem: TDrawingQuantityItem;
begin
  with TDMDataBase(FBillsData) do
  begin
    for I := 0 to FDrawQList.Count - 1 do
    begin
      DQItem := TDrawingQuantityItem(FDrawQList[I]);
      AddDrawQItem(DQItem);
    end;
  end;
end;

procedure TScExcelItemTree.ViewBillTreeParts;
var
  I: Integer;
  strIDList: string;
  
  procedure AddToList(ANode: TZjIDTreeNode; AStrList: TStringList);
  begin
    if not SameText(strIDList, '') then
    begin
      strIDList := Format('%s or ID=%d', [strIDList, ANode.ID]);
      Inc(I);
      if I = 500 then
      begin
        AStrList.Add(strIDList);
        strIDList := '';
        I := 1;
      end;
    end
    else
    begin
      strIDList := Format('ID=%d', [ANode.ID]);
      Inc(I);
    end;
    if Assigned(ANode.FirstChild) then AddToList(ANode.FirstChild, AStrList);
    if Assigned(ANode.NextSibling) then AddToList(ANode.NextSibling, AStrList);
  end;

  procedure AddIDToList(ANode: TZjIDTreeNode; AID: Integer);
  begin
    case AID of
      1: if Assigned(ANode.FirstChild) then AddToList(ANode.FirstChild, FPartOne);
      2: if Assigned(ANode.FirstChild) then AddToList(ANode.FirstChild, FPartTwo);
      3: if Assigned(ANode.FirstChild) then AddToList(ANode.FirstChild, FPartThree);
    end;
  end;
var
  zNode: TZjIDTreeNode;
begin
  with TDMDataBase(FBillsData) do
  begin
    zNode := BillsTree.FirstNode;
    if Assigned(zNode) then
    begin
      // 1
      I := 1;
      strIDList := '';
      AddIDToList(zNode, 1);
      if not SameText(strIDList, '') then FPartOne.Add(strIDList);
      // 2
      if Assigned(zNode.NextSibling) then
      begin
        I := 1;
        strIDList := '';
        AddIDToList(zNode.NextSibling, 2);
        if not SameText(strIDList, '') then FPartTwo.Add(strIDList);
        zNode := zNode.NextSibling;
      end;
      // 3
      if Assigned(zNode.NextSibling) then
      begin
        I := 1;
        strIDList := '';
        AddIDToList(zNode.NextSibling, 3);
        if not SameText(strIDList, '') then FPartThree.Add(strIDList);
      end;      
    end;
  end;
end;

{ TScExcelItem }

procedure TScExcelItem.AssignFirstChild(ANode: TScExcelItem);
begin
  FFirstChild := ANode;
  FLastChild := ANode;
end;

function TScExcelItem.GetNextSiblingID: Integer;
begin
  if Assigned(FNextSibling) then Result := FNextSibling.ID
  else Result := -1;
end;

function TScExcelItem.GetParentID: Integer;
begin
  if Assigned(FParent) then Result := FParent.ID
  else Result := -1;
end;

function TScExcelItem.HasChildren: Boolean;
begin
  if Assigned(FirstChild) then Result := True
  else Result := False;
end;

procedure TScExcelItem.MoveLastChild(ANode: TScExcelItem);
begin
  FLastChild.NextSibling := ANode;
  FLastChild := ANode;
end;

{ TCacheGatherNode }

procedure TCacheGatherNode.Assign(aNode: TCacheGatherNode; aIncludeDraw: Boolean);
begin
  FCode            := aNode.FCode;
  FBCode           := aNode.FBCode;
  FName            := aNode.FName;
  FUnits           := aNode.FUnits;
  FUnitPrice       := aNode.FUnitPrice;
  FTotalPrice      := aNode.FTotalPrice;
  FMemostring      := aNode.FMemostring;
  FQuantity        := aNode.FQuantity;
  FDesignPrice     := aNode.FDesignPrice;
  FDesignQuantity1 := aNode.FDesignQuantity1;
  FDesignQuantity2 := aNode.FDesignQuantity2;

  if aIncludeDraw then AssignDraw(aNode);
end;

procedure TCacheGatherNode.AssignDraw(aNode: TCacheGatherNode);
var
  I: Integer;
  dqiItem: TDrawingQuantityItem;
  dqiNewItem: TDrawingQuantityItem;
begin
  for I := 0 to aNode.DQList.Count - 1 do
  begin
    dqiItem := TDrawingQuantityItem(aNode.DQList.List^[I]);

    dqiNewItem := TDrawingQuantityItem.Create;

    dqiNewItem.ID := FOwner.FMaxDQID;
    dqiNewItem.FBillsID := FID;
    dqiNewItem.Assign(dqiItem);

    FDQList.Add(dqiNewItem);
    Inc(FOwner.FMaxDQID);
  end;
end;

constructor TCacheGatherNode.Create(aOwner: TCacheGatherTree);
begin
  FOwner := aOwner;
  FDQList := TList.Create;
  FExprsList := TList.Create;
end;

procedure TCacheGatherNode.DeleteChildren;
var
  vNode, xNode: TCacheGatherNode;
begin
  vNode := FirstChild;
  while Assigned(vNode) do
  begin
    xNode := vNode.NextSibling;
    vNode.DeleteChildren;
    vNode.DeleteDQItems;
    vNode.Free;
    vNode := xNode;
  end;
end;

procedure TCacheGatherNode.DeleteDQItems;
var
  I: Integer;
  DQItem: TDrawingQuantityItem;
begin
  for I := 0 to FDQList.Count - 1 do
  begin
    DQItem := TDrawingQuantityItem(FDQList.List^[I]);
    DQItem.Free;
  end;
end;

destructor TCacheGatherNode.Destroy;
begin
  ClearObjectList(FDQList);
  FDQList.Free;
  ClearObjectList(FExprsList);
  FExprsList.Free;
  inherited;
end;

function TCacheGatherNode.GetNextSiblingID: Integer;
begin
  if Assigned(FNextSibling) then
    Result := FNextSibling.ID
  else Result := -1;
end;

function TCacheGatherNode.GetParentID: Integer;
begin
  if Assigned(FParent) then
    Result := FParent.ID
  else Result := -1;
end;

function TCacheGatherNode.HasChildren: Boolean;
begin
  Result := Assigned(FFirstChild);
end;

procedure TCacheGatherNode.MoveFirstChild(ANode: TCacheGatherNode);
begin
  FFirstChild := ANode;
  ANode.FParent := Self;
  FFirstChild.FParent := Self;
  if not Assigned(FLastChild) then
    FLastChild := FFirstChild;
end;

procedure TCacheGatherNode.MoveLastChild(ANode: TCacheGatherNode);
begin
  FLastChild.FNextSibling := ANode;
  ANode.FParent := Self;
  ANode.FPreSibling := FLastChild;
  FLastChild := ANode;
end;

procedure TCacheGatherNode.MovePreSibling(ANode: TCacheGatherNode);
begin
  if Assigned(FPreSibling) then
  begin
    FPreSibling.FNextSibling := ANode;
    ANode.FPreSibling := FPreSibling;
  end
  else if Assigned(FParent) then
    FParent.MoveFirstChild(ANode);
  FPreSibling := ANode;
  ANode.FParent := Self.FParent;
end;

procedure TCacheGatherNode.RemoveFromParent;
begin
  if FParent <> nil then
  begin
    if FParent.FFirstChild = Self then
      FParent.FFirstChild := FNextSibling;
    if FParent.FLastChild = Self then
      FParent.FLastChild := FPreSibling;
  end;

  if Assigned(FPreSibling) then
    FPreSibling.FNextSibling := FNextSibling;

  if Assigned(FNextSibling) then
    FNextSibling.FPreSibling := FPreSibling;

  FPreSibling := nil;
  FNextSibling := nil;
  FParent := nil;
end;

{ TCacheGatherTree }

procedure TCacheGatherTree.AddBillsNode(ANode: TZjIDTreeNode; AGatherParent: TCacheGatherNode);
var
  iID: Integer;
  blSelected: Boolean;
  gNode: TCacheGatherNode;
begin
  blSelected := False;
  if TScBillsItem(ANode).Selected then 
  begin
    if Assigned(AGatherParent) then
    begin
      FTokenID := 0;
      GatherCurNode(ANode, AGatherParent, 0);
      blSelected := True;
    end
    else Abort; 
  end
  else
  begin
    iID := ANode.ID;
    if iID >= 100 then iID := FMaxID;
    if ANode.ParentID = -1 then
      gNode := AddCacheNode(iID, -1, -1)
    else
    begin
      if not Assigned(AGatherParent) then
        gNode := AddCacheNode(iID, -1, -1)
      else
        gNode := AddCacheNode(iID, AGatherParent.ID, -1);
    end;

    TProject(FProject).BillsData.ExtractBillsRecord(ANode.ID, gNode);
    if ANode.ID < 100 then
      AddBillsExprs(ANode.ID, gNode);
    if not ANode.HasChildren then
      TProject(FProject).BillsData.GetDQListByBillsID(ANode.ID, gNode, FMaxDQID);

    Inc(FMaxID);
  end;

  if Assigned(ANode.FirstChild) and not blSelected then AddBillsNode(ANode.FirstChild, gNode);
  if Assigned(ANode.NextSibling) then AddBillsNode(ANode.NextSibling, AGatherParent);
end;

function TCacheGatherTree.AddCacheNode(const AID, AParentID,
  ANextSiblingID: Integer): TCacheGatherNode;
var
  vNode: TCacheGatherNode;
begin
   Result := TCacheGatherNode.Create(Self);
   Result.ID := AID;

   if AParentID <> -1 then
   begin
     vNode := FindCacheNode(AParentID);
     Result.FParent := vNode;
     if (ANextSiblingID = -1) and vNode.HasChildren then vNode.MoveLastChild(Result)
     else if not vNode.HasChildren or (vNode.FirstChild.ID = ANextSiblingID) then
       vNode.MoveFirstChild(Result);
   end
   else
   begin
     Result.FParent := nil;
     if (ANextSiblingID = -1) and FRoot.HasChildren then FRoot.MoveLastChild(Result)
     else if not FRoot.HasChildren or (FRoot.FirstChild.ID = ANextSiblingID) then
       FRoot.MoveFirstChild(Result);
   end;
   
   if ANextSiblingID = -1 then
     Result.FNextSibling := nil
   else
   begin
     vNode := FindCacheNode(ANextSiblingID);
     Result.FNextSibling := vNode;
     vNode.MovePreSibling(Result);
   end;
   if AID < 100 then FMinIDList.Add(Result)
   else FCacheList.Add(Result);
end;

procedure TCacheGatherTree.CombineNodeQuantity(ASrc,
  ADest: TCacheGatherNode);
begin
  ADest.Quantity := ADest.Quantity + ASrc.Quantity;
  ADest.DesignQuantity1 := ADest.DesignQuantity1 + ASrc.DesignQuantity1;
  ADest.DesignQuantity2 := ADest.DesignQuantity2 + ASrc.DesignQuantity2;
  ADest.TotalPrice := ADest.TotalPrice + ASrc.TotalPrice;
  // 2012.3.5 16:20 何晓勇修改
  ADest.Name := ASrc.Name;
  if Assigned(ASrc.DQList) and Assigned(ADest.DQList) then
    CombineDrawQ(ASrc.DQList, ADest.DQList, ADest.ID);
end;

constructor TCacheGatherTree.Create;
begin
  FCacheList := TObjectList.Create;
  FMinIDList := TList.Create;
  FRoot := TCacheGatherNode.Create(Self);
  FRoot.ID := -1;
  FMaxID := 400;
  FMaxDQID := 1;
end;

procedure TCacheGatherTree.DeleteNode(ANode: TCacheGatherNode);
var
  vNext, vPre: TCacheGatherNode;
begin
{  ANode.RemoveFromParent;
  if Assigned(ANode.FPreSibling) then
    ANode.FPreSibling.FNextSibling := ANode.NextSibling;
  if Assigned(ANode.FNextSibling) then
    ANode.FNextSibling.FPreSibling := ANode.FPreSibling; }

  ANode.DeleteChildren;
  if ANode.ID < 100 then
  begin
    DeleteBySerialSearch(ANode);
    ANode.Free;
  end
  else DeleteByDichotomySearch(ANode);
end;

destructor TCacheGatherTree.Destroy;
begin
  FCacheList.Free;
  FMinIDList.Free;
  FRoot.Free;
  inherited;
end;

function TCacheGatherTree.DichotomySearch(
  const AID: Integer): TCacheGatherNode;
var
  ilow, ihigh, imid: Integer;
  eNode: TCacheGatherNode;
begin
  Result := nil;
  ilow := 0;
  ihigh := FCacheList.Count - 1;
  while ilow <= ihigh do
  begin
    imid := (ilow + ihigh) div 2;
    eNode := TCacheGatherNode(FCacheList[imid]);
    if eNode.ID = AID then
    begin
      Result := eNode;
      Break;
    end;
    if eNode.ID < AID then ilow := imid + 1
    else ihigh := imid - 1;
  end;
end;

procedure TCacheGatherTree.DeleteByDichotomySearch(const ANode: TCacheGatherNode);
var
  ilow, ihigh, imid: Integer;
  eNode: TCacheGatherNode;
begin
  ilow := 0;
  ihigh := FCacheList.Count - 1;
  while ilow <= ihigh do
  begin
    imid := (ilow + ihigh) div 2;
    eNode := TCacheGatherNode(FCacheList[imid]);
    if eNode.ID = ANode.ID then
    begin
      FCacheList.Delete(imid);
      Break;
    end;
    if eNode.ID < ANode.ID then ilow := imid + 1
    else ihigh := imid - 1;
  end;
end;

function TCacheGatherTree.FindCacheNode(
  const AID: Integer): TCacheGatherNode;
begin
  if AID < 100 then Result := SerialSearch(AID)
  else Result := DichotomySearch(AID);
end;

procedure TCacheGatherTree.GatherCurNode(ANode: TZjIDTreeNode;
  AGatherParent: TCacheGatherNode; aLevel: Integer);
var
  I, cValue: Integer;
  sCode, sBCode, sName, sParentCode: string;
  blHasOldCode, blIsCode, blFlag: Boolean;
  cNode, zNode: TZjIDTreeNode;
  gNode, gNextNode, gParNode: TCacheGatherNode;
begin
  for I := 0 to ANode.ChildCount - 1 do
  begin
    blHasOldCode := False;
    blFlag := False;
    cNode := ANode.ChildNodes[I];

    if Assigned(AGatherParent) then
    begin
      sBCode := AGatherParent.BCode;
      if (aLevel = 0) and Assigned(ANode.Parent) and
        TScBillsItem(ANode.Parent).Selected then
      begin
        sParentCode := FBillsCode + '-' + TokenArray[FTokenID];
      end
      else
      begin
        sParentCode := AGatherParent.Code;

        if (aLevel = 0) and (AGatherParent.Code <> '') then
        begin
          if IncludeToken(AGatherParent.Code) then
            sParentCode := AGatherParent.Code + '-' + TokenArray[FTokenID]
          else
            TProject(FProject).BillsData.ExtractBillsCode(ANode.ID, sParentCode, sBCode, sName);

          sParentCode := ModifyBillsCode(sParentCode);
        end;

      end;
    end
    else
      TProject(FProject).BillsData.ExtractBillsCode(ANode.ID, sParentCode, sBCode, sName);


    if TScBillsItem(cNode).Selected then
    begin
      Inc(FTokenID);
      FBillsCode := sParentCode;
      GatherCurNode(cNode, AGatherParent, 0);       
      Dec(FTokenID);

      Continue;
    end;

    TProject(FProject).BillsData.ExtractBillsCode(cNode.ID, sCode, sBCode, sName);

    gNode := AGatherParent.FirstChild;
    while Assigned(gNode) do
    begin
//      if (gNode.Code <> '') or (gNode.BCode <> '') then
//      begin
        if (gNode.Code <> '') and (sCode <> '') then
        begin
          // 1-6-1-2-1 : 1-6-1-N-1
          //sCode := ConvertCode(sCode, gNode.Code);
          sCode := SplitAndConvertCode(sCode, gNode.Code);
          if ScConfigInfo.MatchCodeOnly then
            cValue := CompareCodes(sCode, '', '', gNode.Code, '', '')
          else
            cValue := CompareCodes(sCode, '', sName, gNode.Code, '', gNode.Name);
          blIsCode := True;
        end
        else if (gNode.BCode <> '') and (sBCode <> '') then
        begin
          blIsCode := False;
          if ScConfigInfo.MatchCodeOnly then
            cValue := CompareCodes('', sBCode, '', '', gNode.BCode, '')
          else
            cValue := CompareCodes('', sBCode, sName, '', gNode.BCode, gNode.Name);

          if cValue <> 0 then
          begin
            if Pos(gNode.BCode + '-', sBCode) = 1 then
            begin
              // 101-1与101-1-1  cNode作为gnode的子项添加
              //GatherCurNode(cNode, gNode, aLevel + 1);
              AddGatherNode(gNode, cNode, aLevel + 1, sBCode, sName);
              blHasOldCode := True;
              Break;
            end;
          end;

        end
        { TODO : gnode.code = scode = gnode.bcode = sbcode = '' }
        else if (gNode.Code = sCode) and (gNode.BCode = sBCode) then
        begin
          { TODO : 只有名称的默认当清单加设计数量 }
          blIsCode := False;
          cValue := CompareCodes('', '', sName, '', '', gNode.Name);
        end
        else cValue := 1;

        if cValue = 0 then
        begin
          PlusItems(cNode, gNode, aLevel + 1, blIsCode);
          blHasOldCode := True;
          Break;
        end
        else if cValue < 0 then
        begin
          if ((sBCode <> '') and (Pos(sBCode + '-', gNode.BCode) = 1)) or
            ((sCode <> '') and (Pos(sCode + '-', gNode.Code) = 1)) then
          begin
            gParNode := gNode;
            blFlag := True;
            Break;
          end;
        end;
//      end;
      gNode := gNode.NextSibling;
    end;

    if not blHasOldCode then
    begin
      gNode := AddCacheNode(FMaxID, AGatherParent.ID, -1);
      InternalDetail(gNode, cNode, sParentCode);
      Inc(FMaxID);

      if cNode.HasChildren then
        GatherCurNode(cNode, gNode, aLevel + 1);

      {调整结构，如：207-1-6在207-1前面, 把207-1-6调整为207-1的子节点}
      if blFlag then
      begin
        while Assigned(gParNode) do
        begin
          gNextNode := gParNode.NextSibling;
          if (gNode.ID <> gParNode.ID)
              and
             (
               (Pos(gNode.BCode + '-', gParNode.BCode) = 1)
                or
               (Pos(gNode.Code + '-', gParNode.Code) = 1)
             )
          then
            AdjustStructor(gNode, gParNode);
          gParNode := gNextNode;
        end;
      end;

    end;
  end;
end;

function TCacheGatherTree.GetFirstNode: TCacheGatherNode;
begin
  Result := FRoot.FirstChild;
end;

procedure TCacheGatherTree.MergeCacheList;
var
  I: Integer;
  vNode: TCacheGatherNode;
begin
  for I := FMinIDList.Count -1 downto 0 do
  begin
    vNode := TCacheGatherNode(FMinIDList[I]);
    FCacheList.Add(vNode);
  end;
end;

procedure TCacheGatherTree.MovePreNode(ASrc, ADest: TCacheGatherNode);
begin
  ASrc.FPreSibling := ADest.FPreSibling;
  if Assigned(ADest.FPreSibling) then
    ADest.FPreSibling.FNextSibling := ASrc;

  ASrc.FParent := ADest.FParent;
  ASrc.FNextSibling := ADest;
  ADest.FPreSibling := ASrc;
end;

function TCacheGatherTree.SerialSearch(
  const AID: Integer): TCacheGatherNode;
var
  I: Integer;
  vNode: TCacheGatherNode;
begin
  Result := nil;
  for I := 0 to FMinIDList.Count - 1 do
  begin
    vNode := TCacheGatherNode(FMinIDList[I]);
    if vNode.ID = AID then
    begin
      Result := vNode;
      Break;
    end;
  end;
end;

procedure TCacheGatherTree.DeleteBySerialSearch(const ANode: TCacheGatherNode);
var
  I: Integer;
  vNode: TCacheGatherNode;
begin
  for I := 0 to FMinIDList.Count - 1 do
  begin
    vNode := TCacheGatherNode(FMinIDList[I]);
    if vNode.ID = ANode.ID then
    begin
      FMinIDList.Delete(I);
      Break;
    end;
  end;
end;

function TCacheGatherTree.TraverseDBIntoSelf(AProject: TObject): Boolean;
begin
  Result := True;
  FProject := AProject;
  if TProject(FProject).BillsData.BillsTree.FirstNode <> nil then
  begin
    try
      AddBillsNode(TProject(FProject).BillsData.BillsTree.FirstNode, nil);
    except
      Result := False;
    end;
  end;
end;

procedure TCacheGatherTree.TraverseOwnerIntoDB(AProject: TObject);
var
  project: TProject;

  procedure AddDQItem(ANode: TCacheGatherNode);
  var
    I: Integer;
    DQItem: TDrawingQuantityItem;
  begin
    for I := 0 to ANode.FDQList.Count - 1 do
    begin
      DQItem := TDrawingQuantityItem(ANode.FDQList[I]);
      project.BillsData.AddDrawQItem(DQItem, I + 1);
    end;
  end;

  procedure AddExprs(ANode: TCacheGatherNode);
  var
    I: Integer;
    expNode: TExprsNode;
  begin
    for I := 0 to ANode.FExprsList.Count - 1 do
    begin
      expNode := TExprsNode(ANode.FExprsList[I]);
      with project.BillsData.DMExprs do
      begin
        cdsExprs.Append;
        cdsExprsMajorID.Value := expNode.FMajorID;
        cdsExprsMinorID.Value := expNode.FMinorID;
        cdsExprsRecdID.Value := expNode.FRecdID;
        cdsExprsExprs.Value := expNode.FExprs;
        cdsExprsExprs1.Value := expNode.FExprs1;
        cdsExprs.Post;
      end;
    end;
  end;

  procedure AddBillsAndDrawingItemAndExprs(ANode: TCacheGatherNode);
  begin
    project.BillsData.AddBillsItem(ANode);
    AddDQItem(ANode);
    AddExprs(ANode);
  end;

  procedure AddCacheNodes;
  var
    I: Integer;
  begin
    for I := 0 to FCacheList.Count - 1 do
      AddBillsAndDrawingItemAndExprs(TCacheGatherNode(FCacheList.List^[I]));
  end;

begin
  project := TProject(AProject);
  project.BillsData.DisconnectBillsTree;
  try
    project.BillsData.DeleteAllBills;
    MergeCacheList;
    SortCacheTreeNodes(FRoot.FFirstChild);
    AddCacheNodes;
    project.Save(False);
  finally
    project.BillsData.ConnectionBillsTree;
    project.BillsData.SaveSerialNo;
  end;
end;

function TCacheGatherTree.ModifyBillsCode(const ACode: string): string;
var
  I: Integer;
begin
  Result := ACode;
  for I := Length(ACode) downto 1 do
  begin
    if ACode[I] = '-' then
    begin
      Result := Copy(Result, 1, I);
      Break;
    end;
  end;

  if Result[Length(Result)] = '-' then
    Result := Result + TokenArray[FTokenID]
  else
    Result := Result + '-' + TokenArray[FTokenID];
end;

procedure TCacheGatherTree.ModifyBillsCode(GNode: TCacheGatherNode;
  const aParentCode: string);
var
  I, iLen: Integer;
  sCode: string;
begin
  iLen := 0;
  for I := 1 to Length(aParentCode) do
  begin
    if aParentCode[I] = '-' then Inc(iLen);
  end;
  Inc(iLen);

  sCode := GNode.Code;
  for I := 1 to Length(sCode) do
  begin
    if sCode[I] = '-' then
    begin
      Dec(iLen);
      if iLen = 0 then
      begin
        Delete(sCode, 1, I - 1);
        Break;
      end;
    end;
  end;

  GNode.Code := aParentCode + sCode;
end;

procedure TCacheGatherTree.PlusItems(xNode: TZjIDTreeNode;
  GNode: TCacheGatherNode; aLevel: Integer; IsCode: Boolean);
begin
  with TProject(FProject).BillsData do
  begin
    if IsCode then
      PlusDesignQuantitys(xNode.ID, GNode)
    else
    begin
      PlusBillsQuantity(xNode.ID, GNode);
      if not xNode.HasChildren then
        PlusDQDesignQuantitys(xNode.ID, GNode, FMaxDQID);
    end;

    if xNode.HasChildren then GatherCurNode(xNode, GNode, aLevel); 
  end;
end;

procedure TCacheGatherTree.InternalDetail(
  AGNode: TCacheGatherNode; ANode: TZjIDTreeNode;
  const AParentCode: string);
begin
  TProject(FProject).BillsData.ExtractBillsRecord(ANode.ID, AGNode);

  if Assigned(ANode) and (AGNode.Code <> '') then
    ModifyBillsCode(AGNode, AParentCode);

  if not ANode.HasChildren then
    TProject(FProject).BillsData.GetDQListByBillsID(ANode.ID, AGNode, FMaxDQID);
end;

procedure TCacheGatherTree.AddGatherNode(AGatherNode: TCacheGatherNode;
  AZjNode: TZjIDTreeNode; aLevel: Integer; const aBCode, aName: string);
var
  cValue: Integer;
  blFlag: Boolean;
  gNode: TCacheGatherNode;
begin
  blFlag := False;
  gNode := AGatherNode.FirstChild;
  while Assigned(gNode) do
  begin
    if ScConfigInfo.MatchCodeOnly then
      cValue := CompareCodes('', aBCode, '', '', gNode.BCode, '')
    else
      cValue := CompareCodes('', aBCode, aName, '', gNode.BCode, gNode.Name);
    if cValue = 0 then
    begin
      PlusItems(AZjNode, gNode, aLevel, False);
      blFlag := True;
      Break;
    end;

    if Pos(gNode.BCode + '-', aBCode) = 1 then
    begin
      AddGatherNode(gNode, AZjNode, aLevel, aBCode, aName);
      blFlag := True;
      Break;
    end;

    gNode := gNode.NextSibling;
  end;

  if not blFlag then
  begin
    gNode := AddCacheNode(FMaxID, AGatherNode.ID, -1);
    InternalDetail(gNode, AZjNode, '');
    Inc(FMaxID);
    if AZjNode.HasChildren then
      {GatherCurNode(AZjNode, gNode, aLevel);//} AddBillsNode(AZjNode.FirstChild, gNode);
  end;
end;

procedure TCacheGatherTree.AdjustStructor(AParNode,
  AChdNode: TCacheGatherNode);
var
  xValue: Integer;
  blFlag: Boolean;
  ChildNode, SecChdNode, SecNextNode: TCacheGatherNode;
begin
  AChdNode.RemoveFromParent;
  if Assigned(AChdNode) then
  begin
    blFlag := False;
    ChildNode := AParNode.FirstChild;
    while Assigned(ChildNode) do
    begin
      xValue := CompareCodes('', AChdNode.BCode, '', '', ChildNode.BCode, '');
      if xValue = 0 then
      begin
        {两节点相加数据，合并}
        CombineNodeQuantity(AChdNode, ChildNode);

        SecChdNode := AChdNode.FirstChild;
        while Assigned(SecChdNode) do
        begin
          SecNextNode := SecChdNode.NextSibling;
          AdjustStructor(ChildNode, SecChdNode);
          SecChdNode := SecNextNode;
        end;
        // 这里2012.3.5.16.20
         DeleteNode(AChdNode);
        //DeleteNode(ChildNode);
        blFlag := True;
        Break;
      end;

      if Pos(ChildNode.BCode + '-', AChdNode.BCode) = 1 then
      begin
        AdjustStructor(ChildNode, AChdNode);
        blFlag := True;
        Break;
      end;

      ChildNode := ChildNode.NextSibling;
    end;

    if not blFlag then
    begin
//      AChdNode.RemoveFromParent;
      if AParNode.HasChildren then
        AParNode.MoveLastChild(AChdNode)
      else
        AParNode.MoveFirstChild(AChdNode);
    end;

  end;  
end;

function TCacheGatherTree.IncludeToken(const aCode: string): Boolean;
var
  I: Integer;
begin
  Result := False;
  for I := 1 to Length(aCode) do
  begin
    if aCode[I] in ['N', 'M', 'Q', 'L', 'P', 'R', 'S', 'T', 'X', 'Y', 'Z'] then
    begin
      Result := True;
      Break;
    end;
  end;
end;

function TCacheGatherTree.ConvertCode(const aCode, aGCode: string): string;
var
  I, J, iDelLen: Integer;
begin
  Result := aCode;
  for I := 1 to Length(aGCode) do
  begin
    if aGCode[I] in ['N', 'M', 'Q', 'L', 'P', 'R', 'S', 'T', 'X', 'Y', 'Z'] then
    begin
      if I >= Length(Result) then Exit;
      
      Result[I] := aGCode[I];
      J := I + 1;
      iDelLen := 0;
      while Result[J] <> '-' do
      begin
        Inc(iDelLen);
        Inc(J);
      end;
      Delete(Result, I + 1, iDelLen);
    end;
  end;
end;

procedure TCacheGatherTree.CombineDrawQ(ASrcQList, ADestQList: TList; aDestID: Integer);
var
  I, J: Integer;
  blFlag: Boolean;
  srcQItem, destQItem, newItem: TDrawingQuantityItem;
begin
  for I := 0 to ASrcQList.Count - 1 do
  begin
    blFlag := False;
    srcQItem := TDrawingQuantityItem(ASrcQList.List^[I]);
    for J := 0 to ADestQList.Count - 1 do
    begin
      destQItem := TDrawingQuantityItem(ADestQList.List^[J]);
      if SameText(destQItem.Name, srcQItem.Name) then
      begin
        destQItem.DesignQuantity1 := srcQItem.DesignQuantity1 + destQItem.DesignQuantity1;
        destQItem.DesignQuantity2 := srcQItem.DesignQuantity2 + destQItem.DesignQuantity2;
        blFlag := True;
        Break;
      end;
    end;

    if not blFlag then
    begin
      newItem := TDrawingQuantityItem.Create;
      newItem.ID := srcQItem.ID;
      newItem.BillsID := aDestID;
      newItem.Name := srcQItem.Name;
      newItem.Units := srcQItem.Units;
      newItem.DesignQuantity1 := srcQItem.DesignQuantity1;
      newItem.DesignQuantity2 := srcQItem.DesignQuantity2;
      newItem.MemoContext := srcQItem.MemoContext;

      ADestQList.Add(newItem);
    end;
  end;
end;

procedure TCacheGatherTree.AddBillsExprs(ABillsID: Integer;
  ACacheNode: TCacheGatherNode);
var
  expNode: TExprsNode;
begin
  if ACacheNode.FExprsList.Count > 0 then Exit;
  with TProject(FProject).BillsData.DMExprs do
  begin
    if cdsExprs.FindKey([1, 3, ABillsID]) then
    begin
      expNode := TExprsNode.Create;
      expNode.FMajorID := 1;
      expNode.FMinorID := 3;
      expNode.FRecdID := ACacheNode.FID;
      expNode.FExprs := cdsExprsExprs.AsString;
      expNode.FExprs1 := cdsExprsExprs1.AsString;
      ACacheNode.FExprsList.Add(expNode);
    end;
  end;
end;

function CompareCacheNode(AItem1, AItem2: Pointer): Integer;
var
  Node1: TCacheGatherNode absolute AItem1;
  Node2: TCacheGatherNode absolute AItem2;
begin
  if Node1.FCode <> '' then
    Result := CompareCode(Node1.FCode, Node2.FCode)
  else
    Result := CompareCode(Node1.FBCode, Node2.FBCode);
end;

procedure TCacheGatherTree.SortCacheTreeNodes(AParent: TCacheGatherNode);
var
  lstChildren: TList;
begin
  if AParent = nil then Exit;
  
  lstChildren := TList.Create;
  try
    AddChildren(AParent, lstChildren);
    lstChildren.Sort(CompareCacheNode);
    MoveChildren(AParent, lstChildren);
    SortChildren(AParent);
  finally
    lstChildren.Free;
  end;
end;

procedure TCacheGatherTree.AddChildren(AParent: TCacheGatherNode;
  AList: TList);
var
  Node: TCacheGatherNode;
begin
  Node := AParent.FirstChild;
  while Assigned(Node) do
  begin
    AList.Add(Node);
    Node := Node.NextSibling;
  end;
end;

procedure TCacheGatherTree.MoveChildren(AParent: TCacheGatherNode;
  AList: TList);
var
  iIndex: Integer;
  Node, NextNode: TCacheGatherNode;
begin
  iIndex := 0;
  while iIndex < AList.Count do
  begin
    Node := TCacheGatherNode(AList[iIndex]);
    if iIndex = 0 then
    begin
      AParent.FFirstChild := Node;
      Node.FPreSibling := nil;
    end;
    if iIndex = AList.Count - 1 then
    begin
      AParent.FLastChild := Node;
      Node.FNextSibling := nil;
    end;
    if iIndex + 1 < AList.Count then
    begin
      NextNode := TCacheGatherNode(AList[iIndex + 1]);
      Node.FNextSibling := NextNode;
      NextNode.FPreSibling := Node;
    end;
    Inc(iIndex);
  end;
end;

procedure TCacheGatherTree.SortChildren(AParent: TCacheGatherNode);
var
  Node: TCacheGatherNode;
begin
  Node := AParent.FirstChild;
  while Assigned(Node) do
  begin
    SortCacheTreeNodes(Node);
    Node := Node.NextSibling;
  end;
end;

function TCacheGatherTree.SplitAndConvertCode(const aCode, aGCode: string;
  ASpliter: Char): string;
var
  sgsCode, sgsGCode: TStrings;
  iNum: Integer;
  sCurCodeNum: string;
begin
  sgsCode := TStringList.Create;
  sgsGCode := TStringList.Create;
  try
    sgsCode.Delimiter := ASpliter;
    sgsCode.DelimitedText := aCode;
    sgsGCode.Delimiter := ASpliter;
    sgsGCode.DelimitedText := aGCode;
    for iNum := 0 to Min(sgsGCode.Count, sgsCode.Count) - 1 do
    begin
      sCurCodeNum := sgsGCode[iNum];
      if sCurCodeNum[1] in ['N', 'M', 'Q', 'L', 'P', 'R', 'S', 'T', 'X', 'Y', 'Z'] then
        sgsCode[iNum] := sgsGCode[iNum];
    end;
  finally
    Result := sgsCode.DelimitedText;
    sgsCode.Free;
    sgsGCode.Free;
  end;
end;

{ TMergeGatherTree }

procedure TMergeGatherTree.AddDrawItems(aCdsDraw: TClientDataSet; aBillsID: Integer;
  aCGNode: TCacheGatherNode);
var
  dqiItem: TDrawingQuantityItem;
begin
  with aCdsDraw do
  begin
    SetRange([aBillsID], [aBillsID]);
    while not Eof do
    begin
      dqiItem := TDrawingQuantityItem.Create;

      dqiItem.ID := FMaxDQID;
      dqiItem.BillsID := aCGNode.ID;
      dqiItem.Name := FieldByName(sName).AsString;
      dqiItem.Units := FieldByName(sUnits).AsString;
      dqiItem.DesignQuantity1 := FieldByName(sDQuantity1).AsFloat;
      dqiItem.DesignQuantity2 := FieldByName(sDQuantity2).AsFloat;
      dqiItem.MemoContext := FieldByName(sMemoContext).AsString;

      aCGNode.DQList.Add(dqiItem);
      Inc(FMaxDQID);

      Next;
    end;
    CancelRange;
  end;
end;

procedure TMergeGatherTree.AddExprs(AORecID: Integer; AGNode: TCacheGatherNode);
var
  expNode: TExprsNode;
begin
  if AGNode.FExprsList.Count > 0 then Exit;
  if CdsExprs.FindKey([1, 3, AORecID]) then
  begin
    expNode := TExprsNode.Create;
    expNode.FMajorID := 1;
    expNode.FMinorID := 3;
    expNode.FRecdID := AGNode.FID;
    expNode.FExprs := CdsExprs.FieldByName('Exprs').AsString;
    expNode.FExprs1 := CdsExprs.FieldByName('Exprs1').AsString;
    AGNode.FExprsList.Add(expNode);
  end;
end;

procedure TMergeGatherTree.AddGatherNode(aSrcNode,
  aDstNode: TCacheGatherNode);
var
  cgnNode: TCacheGatherNode;
begin
  cgnNode := AddSingleGatherNode(aSrcNode, aDstNode);

  if cgnNode = nil then Exit;

  AddGatherNode(aSrcNode.FirstChild, cgnNode);
  AddGatherNode(aSrcNode.NextSibling, aDstNode);
end;

procedure TMergeGatherTree.AddNode(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode; aBillsTree: TZjIDTree;
  aCdsDraw: TClientDataSet;
  aIsOpened: Boolean);
var
  cgnNode: TCacheGatherNode;
begin
  cgnNode := AddSingleNode(aNode, aGatherNode, aBillsTree, aCdsDraw, aIsOpened);

  if cgnNode = nil then Exit;

  AddNode(aNode.FirstChild, cgnNode, aBillsTree, aCdsDraw, aIsOpened);
  AddNode(aNode.NextSibling, aGatherNode, aBillsTree, aCdsDraw, aIsOpened);
end;

function TMergeGatherTree.AddSingleGatherNode(aSrcNode,
  aDstNode: TCacheGatherNode): TCacheGatherNode;
var
  iID: Integer;
begin
  Result := nil;
  if aSrcNode = nil then Exit;

  if aSrcNode.ID < 100 then
    iID := aSrcNode.ID
  else
  begin
    iID := FMaxID;
    Inc(FMaxID);
  end;

  if Assigned(aDstNode) then
    Result := AddCacheNode(iID, aDstNode.ID, -1)
  else
    Result := AddCacheNode(iID, -1, -1);

  Result.Assign(aSrcNode);
end;

function TMergeGatherTree.AddSingleNode(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode; aBillsTree: TZjIDTree;
  aCdsDraw: TClientDataSet; aIsOpened: Boolean): TCacheGatherNode;
var
  iID: Integer;
begin
  Result := nil;
  if aNode = nil then Exit;

  if aNode.ID < 100 then
    iID := aNode.ID
  else
  begin
    iID := FMaxID;
    Inc(FMaxID);
  end;

  if Assigned(aGatherNode) then
    Result := AddCacheNode(iID, aGatherNode.ID, -1)
  else
    Result := AddCacheNode(iID, -1, -1);

  if aIsOpened then
  begin
    AssignByOpened(aBillsTree, aNode, Result);
    TDMDataBase(TAdditinalTree(aBillsTree).Bills).GetDQListByBillsID(aNode.ID, Result, FMaxDQID);
  end
  else
  begin
    AssignTo(aNode, Result);
    AddDrawItems(aCdsDraw, aNode.ID, Result);
  end;
  AddExprs(aNode.ID, Result);
  ReCodeNode(Result);
end;

procedure TMergeGatherTree.AssignByOpened(aBillsTree: TObject; aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode);
begin
  with TDMDataBase(TAdditinalTree(aBillsTree).Bills) do
  begin
    if cdsBills.FindKey([aNode.ID]) then
    begin
      aGatherNode.FCode            := cdsBillsCode.AsString;
      aGatherNode.FBCode           := cdsBillsB_Code.AsString;
      aGatherNode.FName            := cdsBillsName.AsString;
      aGatherNode.FUnits           := cdsBillsUnits.AsString;
      aGatherNode.FUnitPrice       := cdsBillsUnitPrice.AsFloat;
      aGatherNode.FTotalPrice      := cdsBillsTotalPrice.AsFloat;
      aGatherNode.FMemostring      := cdsBillsMemoStr.AsString;
      aGatherNode.FQuantity        := cdsBillsQuantity.AsFloat;
      aGatherNode.FDesignQuantity1 := cdsBillsDesignQuantity.AsFloat;
      aGatherNode.FDesignQuantity2 := cdsBillsDesignQuantity2.AsFloat;
      aGatherNode.FDesignPrice     := cdsBillsDesignPrice.AsFloat;
    end;
  end;
end;

procedure TMergeGatherTree.AssignTo(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode);
begin
  aGatherNode.FCode            := TAdditionalItem(aNode).Code;
  aGatherNode.FBCode           := TAdditionalItem(aNode).B_Code;
  aGatherNode.FName          := TAdditionalItem(aNode).Name;
  aGatherNode.FUnits           := TAdditionalItem(aNode).Units;
  aGatherNode.FUnitPrice       := TAdditionalItem(aNode).UnitPrice;
  aGatherNode.FTotalPrice      := TAdditionalItem(aNode).TotalPrice;
  aGatherNode.FMemostring      := TAdditionalItem(aNode).MemoStr;
  aGatherNode.FQuantity        := TAdditionalItem(aNode).Quantity;
  aGatherNode.FDesignQuantity1 := TAdditionalItem(aNode).DesignQuantity;
  aGatherNode.FDesignQuantity2 := TAdditionalItem(aNode).DesignQuantity2;
  aGatherNode.FDesignPrice     := TAdditionalItem(aNode).DesignPrice;
end;

procedure TMergeGatherTree.GatherBillsTree(aBillsTree: TZjIDTree);
begin
  FBillsTree1 := aBillsTree;
  
  InitMaxID;

  if Assigned(FBillsTree1) then
    AddNode(FBillsTree1.FirstNode, nil, FBillsTree1, FCdsDraw1, FIsOpen1);

{  if Assigned(FBillsTree2) and (FBillsTree1 <> FBillsTree2) then
    UpdateNode(FBillsTree2.FirstNode, nil);  }
end;

procedure TMergeGatherTree.GatherTree(aGatherTree: TMergeGatherTree);
begin
  if Self <> aGatherTree then
    UpdateGatherNode(aGatherTree.FirstNode, nil);
end;

procedure TMergeGatherTree.InitMaxID;
begin
  FMaxID   := 100;
  FMaxDQID := 1;
end;

procedure TMergeGatherTree.ReCodeNode(ANode: TCacheGatherNode);

  function GetPreSiblingCount: Integer;
  var
    cgnNode: TCacheGatherNode;
  begin
    Result := 0;
    cgnNode := ANode.FPreSibling;
    while Assigned(cgnNode) do
    begin
      Inc(Result);
      cgnNode := cgnNode.FPreSibling;
    end;
  end;

  function GetPosition(const AName, AStr, AStrSpare: string): Integer;
  begin
    Result := Pos(AStr, AName);
    if Result = 0 then
      Result := Pos(AStrSpare, AName);
  end;

  function CheckNameIsPeg(const AName: string): Boolean;
  var
    iPosK, iPosPlus: Integer;
    fNum: Double;
  begin
    Result := False;
    iPosK := GetPosition(AName, 'K', 'k');
    iPosPlus := GetPosition(AName, '+', '＋');
    if (iPosK = 0) or (iPosPlus = 0) or (iPosPlus < iPosK) then Exit;
    Result := TryStrToFloat(Copy(AName, iPosK + 1, iPosPlus - iPosK - 1), fNum);
  end;

var
  cgnNode: TCacheGatherNode;
  strCode: string;
begin
  if ANode = nil then Exit;

  if CheckNameIsPeg(ANode.FName) then
  begin
    cgnNode := ANode.FParent;
    if cgnNode <> nil then
    begin
      strCode := cgnNode.FCode;
      ANode.FCode := strCode + '-' + IntToStr(GetPreSiblingCount + 1);
    end
    else
      ANode.FCode := IntToStr(GetPreSiblingCount + 1);
  end;
end;

procedure TMergeGatherTree.UpdateBillsTree(aBillsTree: TZjIDTree);
begin
  FBillsTree2 := aBillsTree;
  
  if Assigned(FBillsTree2) and (FBillsTree1 <> FBillsTree2) then
    UpdateNode(FBillsTree2.FirstNode, nil);
end;

procedure TMergeGatherTree.UpdateDrawItems(aBillsID: Integer;
  aCGNode: TCacheGatherNode);
var
  I: Integer;
  bFounded: Boolean;
  dqiItem: TDrawingQuantityItem;
begin
  with FCdsDraw2 do
  begin
    SetRange([aBillsID], [aBillsID]);
    while not Eof do
    begin
      bFounded := False;

      for I := 0 to aCGNode.DQList.Count - 1 do
      begin
        dqiItem := TDrawingQuantityItem(aCGNode.DQList.List^[I]);
        if SameText(dqiItem.Name, FieldByName(sName).AsString) then
        begin
          dqiItem.DesignQuantity1 := dqiItem.DesignQuantity1 + FieldByName(sDQuantity1).AsFloat;
          dqiItem.DesignQuantity2 := dqiItem.DesignQuantity2 + FieldByName(sDQuantity2).AsFloat;
          bFounded := True;
          Break;
        end;
      end;

      if not bFounded then
      begin
        dqiItem := TDrawingQuantityItem.Create;

        dqiItem.ID := FMaxDQID;
        dqiItem.BillsID := aCGNode.ID;
        dqiItem.Name := FieldByName(sName).AsString;
        dqiItem.Units := FieldByName(sUnits).AsString;
        dqiItem.DesignQuantity1 := FieldByName(sDQuantity1).AsFloat;
        dqiItem.DesignQuantity2 := FieldByName(sDQuantity2).AsFloat;
        dqiItem.MemoContext := FieldByName(sMemoContext).AsString;

        aCGNode.DQList.Add(dqiItem);
        Inc(FMaxDQID);
      end;

      Next;
    end;
    CancelRange;
  end;
end;

procedure TMergeGatherTree.UpdateGatherDrawItems(aSrcNode,
  aDstNode: TCacheGatherNode);
var
  I         : Integer;
  J         : Integer;
  bFounded  : Boolean;
  dqiSrcItem: TDrawingQuantityItem;
  dqiDstItem: TDrawingQuantityItem;
begin
  for I := 0 to aSrcNode.DQList.Count - 1 do
  begin
    bFounded := False;
    dqiSrcItem := TDrawingQuantityItem(aSrcNode.DQList.List^[I]);
    for J := 0 to aDstNode.DQList.Count - 1 do
    begin
      dqiDstItem := TDrawingQuantityItem(aDstNode.DQList.List^[J]);
      if SameText(dqiSrcItem.FName, dqiDstItem.FName) then
      begin
        dqiDstItem.DesignQuantity1 := dqiDstItem.DesignQuantity1 + dqiSrcItem.DesignQuantity1;
        dqiDstItem.DesignQuantity2 := dqiDstItem.DesignQuantity2 + dqiSrcItem.DesignQuantity2;
        bFounded := True;
        Break;
      end;
    end;

    if not bFounded then
    begin
      dqiDstItem := TDrawingQuantityItem.Create;
      
      dqiDstItem.ID := FMaxDQID;
      dqiDstItem.FBillsID := aDstNode.ID;
      dqiDstItem.Assign(dqiSrcItem);

      aDstNode.DQList.Add(dqiDstItem);
      Inc(FMaxDQID);
    end;
  end;
end;

procedure TMergeGatherTree.UpdateGatherNode(aSrcNode,
  aDstNode: TCacheGatherNode);
var
  bAdd: Boolean;
  iParentID: Integer;
  iCompare: Integer;
  cgnTemNode: TCacheGatherNode;
  cgnParNode: TCacheGatherNode;
  cgnNode: TCacheGatherNode;
begin
  if aSrcNode = nil then Exit;

  if aDstNode = nil then
  begin
    cgnNode := FirstNode;
    iParentID := -1;
  end
  else
  begin
    cgnNode := aDstNode.FirstChild;
    iParentID := aDstNode.ID;
  end;

  bAdd := True;
  while Assigned(cgnNode) do
  begin
    if aSrcNode.FCode <> '' then
      iCompare := CompareCodes(aSrcNode.FCode, '', aSrcNode.FName, cgnNode.FCode, '', cgnNode.FName)
    else if aSrcNode.FBCode <> '' then
      iCompare := CompareCodes('', aSrcNode.FBCode, aSrcNode.FName, '', cgnNode.FBCode, cgnNode.FName)
    else
      iCompare := CompareCodes('', '', aSrcNode.FName, '', '', cgnNode.FName);

    if iCompare = 0 then
    begin
      UpdateGatherQuantity(aSrcNode, cgnNode);
      UpdateGatherDrawItems(aSrcNode, cgnNode);

      bAdd := False;
      Break;
    end
    else if iCompare > 0 then
    begin
      if ((cgnNode.FCode <> '') and (Pos(cgnNode.FCode + '-', aSrcNode.FCode) = 1)) or
        ((cgnNode.FBCode <> '') and (Pos(cgnNode.FBCode + '-', aSrcNode.FBCode) = 1))
      then
      begin
        UpdateGatherNode(aSrcNode, cgnNode);
        UpdateGatherNode(aSrcNode.NextSibling, aDstNode);
        Exit;
      end;
    end
    else
    begin
      if ((aSrcNode.FCode <> '') and (Pos(aSrcNode.FCode + '-', cgnNode.FCode) = 1)) or
        ((aSrcNode.FBCode <> '') and (Pos(aSrcNode.FBCode + '-', cgnNode.FBCode) = 1)) then
      begin
        cgnTemNode := cgnNode.NextSibling;
        cgnParNode := AddSingleGatherNode(aSrcNode, aDstNode);
        AddGatherNode(aSrcNode.FirstChild, cgnParNode);
        AdjustStructor(cgnParNode, cgnNode);
        while Assigned(cgnTemNode) do
        begin
          cgnNode := cgnTemNode;
          cgnTemNode := cgnTemNode.NextSibling;
          if (cgnNode.FBCode <> '') and (Pos(cgnParNode.FBCode + '-', cgnNode.FBCode) = 1) then
            AdjustStructor(cgnParNode, cgnNode);
        end;
        UpdateGatherNode(aSrcNode.NextSibling, aDstNode);
        Exit;
      end;
    end;

    cgnNode := cgnNode.NextSibling;
  end;

  if bAdd then
  begin
    if aSrcNode.ID < 100 then
      cgnNode := AddCacheNode(aSrcNode.ID, iParentID, -1)
    else
    begin
      cgnNode := AddCacheNode(FMaxID, iParentID, -1);
      Inc(FMaxID);
    end;
    
    cgnNode.Assign(aSrcNode);

    AddGatherNode(aSrcNode.FirstChild, cgnNode);
  end
  else
    UpdateGatherNode(aSrcNode.FirstChild, cgnNode);
    
  UpdateGatherNode(aSrcNode.NextSibling, aDstNode);
end;

procedure TMergeGatherTree.UpdateGatherQuantity(aSrcNode,
  aDstNode: TCacheGatherNode);
begin
  aDstNode.FQuantity        := aDstNode.FQuantity + aSrcNode.Quantity;
  aDstNode.FTotalPrice      := aDstNode.FTotalPrice + aSrcNode.TotalPrice;
  aDstNode.FDesignQuantity1 := aDstNode.FDesignQuantity1 + aSrcNode.DesignQuantity1;
  aDstNode.FDesignQuantity2 := aDstNode.FDesignQuantity2 + aSrcNode.DesignQuantity2;

  if aDstNode.FCode <> '' then
  begin
    if aDstNode.FDesignQuantity1 = 0 then
      aDstNode.FDesignPrice := 0
    else
      aDstNode.FDesignPrice := RoundTo(aDstNode.FTotalPrice / aDstNode.FDesignQuantity1, -3);
  end
  else
  begin
    if aDstNode.FQuantity = 0 then
      aDstNode.FUnitPrice := 0
    else
      aDstNode.FUnitPrice := RoundTo(aDstNode.FTotalPrice / aDstNode.FQuantity, -3);
  end;
end;

procedure TMergeGatherTree.UpdateNode(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode);

  function CompareNode(SrcNode: TScBillsItem; DestNode: TCacheGatherNode): Integer;
  var
    strSrcName, strDestName: string;
  begin
    if (not FMergeByCode) or ((SrcNode.SBillCode = '') and
      (SrcNode.SBillBCode = '') and (DestNode.FCode = '') and (DestNode.FBCode = '')) then
    begin
      strSrcName := SrcNode.SBillName;
      strDestName := DestNode.FName;
    end;

    Result := CompareCodes(SrcNode.SBillCode, SrcNode.SBillBCode, strSrcName,
                           DestNode.FCode, DestNode.FBCode, strDestName);
  end;

var
  bAdd: Boolean;
  iCompare: Integer;
  cgnNode: TCacheGatherNode;
  cgnTemNode: TCacheGatherNode;
  cgnParNode: TCacheGatherNode;
begin
  if aNode = nil then Exit;

  if aGatherNode = nil then
    cgnNode := FirstNode
  else
    cgnNode := aGatherNode.FirstChild;

  bAdd := True;
  while Assigned(cgnNode) do
  begin
    iCompare := CompareNode(TScBillsItem(aNode), cgnNode);
    {if TScBillsItem(aNode).SBillCode <> '' then
      iCompare := CompareCodes(TScBillsItem(aNode).SBillCode, '', TScBillsItem(aNode).SBillName, cgnNode.FCode, '', cgnNode.FName)
    else if TScBillsItem(aNode).SBillBCode <> '' then
      iCompare := CompareCodes('', TScBillsItem(aNode).SBillBCode, TScBillsItem(aNode).SBillName, '', cgnNode.FBCode, cgnNode.FName)
    else
      iCompare := CompareCodes('', '', TScBillsItem(aNode).SBillName, '', '', cgnNode.FName);  }

    if iCompare = 0 then
    begin
      if FIsOpen2 then
      begin
        UpdateQuantityByOpened(aNode, cgnNode);
        TDMDataBase(TAdditinalTree(FBillsTree2).Bills).PlusDQDesignQuantitys(aNode.ID, cgnNode, FMaxDQID);
      end
      else
      begin
        UpdateQuantity(aNode, cgnNode);
        UpdateDrawItems(aNode.ID, cgnNode);
      end;

      bAdd := False;
      Break;
    end
    else if iCompare > 0 then
    begin
      if ((cgnNode.FCode <> '') and (Pos(cgnNode.FCode + '-', TScBillsItem(aNode).SBillCode) = 1)) or
        ((cgnNode.FBCode <> '') and (Pos(cgnNode.FBCode + '-', TScBillsItem(aNode).SBillBCode) = 1)) then
      begin
        UpdateNode(aNode, cgnNode);
        // 去掉,重复计算了.  2011.6.17
        //UpdateNode(aNode.NextSibling, aGatherNode);
        Exit;
      end;

    end
    else
    begin
      if ((TScBillsItem(aNode).SBillCode <> '') and (Pos(TScBillsItem(aNode).SBillCode + '-', cgnNode.FCode) = 1)) or
        ((TScBillsItem(aNode).SBillBCode <> '') and (Pos(TScBillsItem(aNode).SBillBCode + '-', cgnNode.FBCode) = 1)) then
      begin
        cgnTemNode := cgnNode.NextSibling;
        cgnParNode := AddSingleNode(aNode, aGatherNode, FBillsTree2, FCdsDraw2, FIsOpen2);
        AddNode(aNode.FirstChild, cgnParNode, FBillsTree2, FCdsDraw2, FIsOpen2);
        AdjustStructor(cgnParNode, cgnNode);
        while Assigned(cgnTemNode) do
        begin
          cgnNode := cgnTemNode;
          cgnTemNode := cgnTemNode.NextSibling;
          if (cgnNode.FBCode <> '') then
          begin
            if (Pos(cgnParNode.FBCode + '-', cgnNode.FBCode) = 1) then
              AdjustStructor(cgnParNode, cgnNode);
          end;
        end;
        UpdateNode(aNode.NextSibling, aGatherNode);
        Exit;
      end;

    end; 

    cgnNode := cgnNode.NextSibling;
  end;

  if bAdd then
  begin
    cgnNode := AddSingleNode(aNode, aGatherNode, FBillsTree2, FCdsDraw2, FIsOpen2);
    AddNode(aNode.FirstChild, cgnNode, FBillsTree2, FCdsDraw2, FIsOpen2);
  end
  else
    UpdateNode(aNode.FirstChild, cgnNode);
    
  UpdateNode(aNode.NextSibling, aGatherNode);
end;

procedure TMergeGatherTree.UpdateQuantity(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode);
begin
  aGatherNode.FQuantity        := aGatherNode.FQuantity + TAdditionalItem(aNode).Quantity;
  aGatherNode.FTotalPrice      := aGatherNode.FTotalPrice + TAdditionalItem(aNode).TotalPrice;
  aGatherNode.FDesignQuantity1 := aGatherNode.FDesignQuantity1 + TAdditionalItem(aNode).DesignQuantity;
  aGatherNode.FDesignQuantity2 := aGatherNode.FDesignQuantity2 + TAdditionalItem(aNode).DesignQuantity2;

  if aGatherNode.FCode <> '' then
  begin
    if aGatherNode.FDesignQuantity1 = 0 then
      aGatherNode.FDesignPrice := 0
    else
      aGatherNode.FDesignPrice := RoundTo(aGatherNode.FTotalPrice / aGatherNode.FDesignQuantity1, -3);
  end
  else
  begin
    if aGatherNode.FQuantity = 0 then
      aGatherNode.FUnitPrice := 0
    else
      aGatherNode.FUnitPrice := RoundTo(aGatherNode.FTotalPrice / aGatherNode.FQuantity, -3);
  end;
end;

procedure TMergeGatherTree.UpdateQuantityByOpened(aNode: TZjIDTreeNode;
  aGatherNode: TCacheGatherNode);
begin
  with TDMDataBase(TAdditinalTree(FBillsTree2).Bills) do
  begin
    if cdsBills.FindKey([aNode.ID]) then
    begin
      aGatherNode.FTotalPrice      := aGatherNode.FTotalPrice + cdsBillsTotalPrice.AsFloat;
      aGatherNode.FQuantity        := aGatherNode.FQuantity + cdsBillsQuantity.AsFloat;
      aGatherNode.FDesignQuantity1 := aGatherNode.FDesignQuantity1 + cdsBillsDesignQuantity.AsFloat;
      aGatherNode.FDesignQuantity2 := aGatherNode.FDesignQuantity2 + cdsBillsDesignQuantity2.AsFloat;

      if aGatherNode.FCode <> '' then
      begin
        if aGatherNode.FDesignQuantity1 = 0 then
          aGatherNode.FDesignPrice := 0
        else
          aGatherNode.FDesignPrice := RoundTo(aGatherNode.FTotalPrice / aGatherNode.FDesignQuantity1, -3);
      end
      else
      begin
        if aGatherNode.FQuantity = 0 then
          aGatherNode.FUnitPrice := 0
        else
          aGatherNode.FUnitPrice := RoundTo(aGatherNode.FTotalPrice / aGatherNode.FQuantity, -3);
      end;
    end;
  end;
end;

procedure TMergeGatherTree.WriteBills(aNode: TCacheGatherNode;
  aTable: TDataSet);
begin
  with aTable do
  begin
    Append;
    FieldByName(SID).AsInteger := aNode.ID;
    FieldByName(sParentID).AsInteger := aNode.ParentID;
    FieldByName(sNextSiblingID).AsInteger := aNode.NextSiblingID;
    FieldByName(sCode).AsString := aNode.Code;
    if SameText(aNode.Code, '') then
    begin
      if aNode.Quantity <> 0 then
        FieldByName(sQuantity).AsFloat := aNode.Quantity;
    end
    else
    begin
      FieldByName(sDesignQuantity).AsFloat := aNode.DesignQuantity1;
      FieldByName(sDesignQuantity2).AsFloat := aNode.DesignQuantity2;
    end;
    FieldByName(sB_Code).AsString := aNode.BCode;
    FieldByName(sName).AsString := aNode.Name;
    FieldByName(sUnits).AsString := aNode.Units;
    FieldByName(sUnitPrice).AsFloat := aNode.UnitPrice;
    FieldByName(STotalPrice).AsFloat := aNode.TotalPrice;
    FieldByName(sMemoStr).AsString := aNode.MemoString;
    FieldByName(sIsPreDefine).AsBoolean := aNode.ParentID = -1;
    Post;
  end;
end;

procedure TMergeGatherTree.WriteDraw(aNode: TCacheGatherNode;
  aTable: TDataSet);
var
  I: Integer;
  DQItem: TDrawingQuantityItem;
begin
  for I := 0 to aNode.FDQList.Count - 1 do
  begin
    DQItem := TDrawingQuantityItem(ANode.FDQList.List^[I]);

    with aTable do
    begin
      Append;
      FieldByName(SID).AsInteger := DQItem.ID;
      FieldByName(sSerinalNo).AsInteger := I + 1;
      FieldByName(sBillsID).AsInteger := DQItem.BillsID;
      FieldByName(sName).AsString := DQItem.Name;
      FieldByName(sUnits).AsString := DQItem.Units;
      if DQItem.DesignQuantity1 <> 0 then
        FieldByName(sDQuantity1).AsFloat := DQItem.DesignQuantity1;
      if DQItem.DesignQuantity2 <> 0 then
        FieldByName(sDQuantity2).AsFloat := DQItem.DesignQuantity2;
      FieldByName(sMemoContext).AsString := DQItem.MemoContext;
      Post;
    end;
  end;
end;

procedure TMergeGatherTree.WriteExprs(aNode: TCacheGatherNode;
  ADataset: TDataSet);
var
  I: Integer;
  expNode: TExprsNode;
begin
  for I := 0 to aNode.FExprsList.Count - 1 do
  begin
    expNode := TExprsNode(aNode.FExprsList[I]);
    ADataset.Append;
    ADataset.FieldByName('MajorID').Value := expNode.FMajorID;
    ADataset.FieldByName('MinorID').Value := expNode.FMinorID;
    ADataset.FieldByName('RecdID').Value := expNode.FRecdID;
    ADataset.FieldByName('Exprs').Value := expNode.FExprs;
    ADataset.FieldByName('Exprs1').Value := expNode.FExprs1;
    ADataset.Post;
  end;
end;

procedure TMergeGatherTree.WriteTo(aBillsTable, aDrawTable, aExprsTable: TDataSet);
var
  I: Integer;
  cgnNode: TCacheGatherNode;
begin
  MergeCacheList;
  // Access 最后一次 Post 不能提交到数据库,以前也碰到过!
  // 所以不能用Table, Query
  // 改成 ClientDataSet 试试，结果是可以的。
  // 第二次碰到这个问题了。如果不用加密的Access,结果是正确的
  // 所以是加密的问题
  CreateProgressForm(FCacheList.Count, '正在写入数据！');
  for I := 0 to FCacheList.Count - 1 do
  begin
    // AddProgressForm(I, '正在写入数据…');
    cgnNode := TCacheGatherNode(FCacheList[I]);
    WriteBills(cgnNode, aBillsTable);
    WriteDraw(cgnNode, aDrawTable);
    WriteExprs(cgnNode, aExprsTable);
    RefreshProgressForm(I, cgnNode.FName);
  end;
  CloseProgressForm;
end;

{ TDrawingQuantityItem }

procedure TDrawingQuantityItem.Assign(aSrcItem: TDrawingQuantityItem);
begin
  FName             := aSrcItem.FName;
  FUnits            := aSrcItem.FUnits;
  FDesignQuantity1  := aSrcItem.FDesignQuantity1;
  FDesignQuantity2  := aSrcItem.FDesignQuantity2;
  FMemoContext      := aSrcItem.FMemoContext;
end;

{ TSplitGatherTree }

function TSplitGatherTree.AddParent(
  aNode: TZjIDTreeNode): TCacheGatherNode;
var
  I: Integer;
  ztnNode: TZjIDTreeNode;
  ParList: TList;
  cgnNode: TCacheGatherNode;
begin
  ParList := TList.Create;
  try
    SearchParents(aNode, ParList);

    Result := nil;
    for I := ParList.Count - 1 downto 0 do
    begin
      ztnNode := TZjIDTreeNode(ParList.List^[I]);
      cgnNode := FindChildNode(ztnNode, Result);
      if cgnNode = nil then
        Result := AddSingleNode(ztnNode, Result)
      else
        Result := cgnNode;
    end;
  finally
    ParList.Free;
  end;

end;

function TSplitGatherTree.AddSingleNode(aNode: TZjIDTreeNode;
  aCgnNode: TCacheGatherNode): TCacheGatherNode;
var
  iID: Integer;
  iParentID: Integer;
begin
  if aNode = nil then Exit;

  { parentID }
  if aCgnNode = nil then
    iParentID := -1
  else
    iParentID := aCgnNode.ID;

  { ID }
  if aNode.ID < 100 then
    iID := aNode.ID
  else
  begin
    iID := FMaxID;
    Inc(FMaxID);
  end;

  Result := AddCacheNode(iID, iParentID, -1);
  { Assign }
  AssignTo(aNode, Result);
  AddDrawItems(FCdsDraw1, aNode.ID, Result);
end;

function TSplitGatherTree.FindChildNode(aNode: TZjIDTreeNode;
  aCgnNode: TCacheGatherNode): TCacheGatherNode;
var
  iCompare: Integer;
begin
  if aCgnNode = nil then
    Result := FirstNode
  else
    Result := aCgnNode.FirstChild;

  while Assigned(Result) do
  begin
    if TAdditionalItem(aNode).Code <> '' then
      iCompare := CompareCodes(TAdditionalItem(aNode).Code, '', TAdditionalItem(aNode).Name, Result.FCode, '', Result.FName)
    else if TAdditionalItem(aNode).B_Code <> '' then
      iCompare := CompareCodes('', TAdditionalItem(aNode).B_Code, TAdditionalItem(aNode).Name, '', Result.FBCode, Result.FName)
    else
      iCompare := CompareCodes('', '', TAdditionalItem(aNode).Name, '', '', Result.FName);

    if iCompare = 0 then
    begin
      Break;
    end;

    Result := Result.NextSibling;
  end;
end;

procedure TSplitGatherTree.GenerateGatherTree(aNode: TZjIDTreeNode);
var
  cgnParent: TCacheGatherNode;
begin
  if aNode = nil then Exit;

  if not aNode.HasChildren and
    (SameText(TAdditionalItem(aNode).OwnerName, FOwnerName) or
    (TAdditionalItem(aNode).OwnerName = ''))
  then
  begin
    cgnParent := AddParent(aNode);
    AddSingleNode(aNode, cgnParent);
  end;

  GenerateGatherTree(aNode.FirstChild);
  GenerateGatherTree(aNode.NextSibling);
end;

procedure TSplitGatherTree.SearchParents(aNode: TZjIDTreeNode;
  aParList: TList);
begin
  while Assigned(aNode.Parent) do
  begin
    aParList.Add(aNode.Parent);
    aNode := aNode.Parent;
  end;
end;

procedure TSplitGatherTree.SplitBillsTree(aBillsTree: TZjIDTree;
  aCdsDraw: TClientDataSet; const aOwnerName: string);
begin
  FBillsTree1 := aBillsTree;
  FCdsDraw1   := aCdsDraw;
  FOwnerName  := aOwnerName; 

  InitMaxID; 

  GenerateGatherTree(FBillsTree1.FirstNode);
end;

end.