fctreeview.pas

一套及时通讯的原码

begin
   Owner.ClearCache;
   FDeleting := True;

   // 6/30/03 - Clear LastMouseMoveNode
   if fcUseThemes(TreeView) then
   begin
      if TfcCustomTreeView(TreeView).LastMouseMoveNode = Self then
         TfcCustomTreeView(TreeView).LastMouseMoveNode:= nil;
   end;

   if FMultiSelected then begin
      if TfcCustomTreeView(TreeView).LastSelectedNode= self then
         TfcCustomTreeView(TreeView).LastSelectedNode:= nil;

      MultiSelectList:= (TreeView as TfcCustomTreeView).FMultiSelectList;
      for i:= 0 to MultiSelectList.count-1 do begin  { Bad code }
         if self=TfcTreeNode(MultiSelectList[i]) then
         begin
            MultiSelectList.delete(i);
            break;
         end
      end
   end;

   if Owner.Owner.FLastDropTarget = Self then
      Owner.Owner.FLastDropTarget := nil;
   Node := Parent;
   if (Node <> nil) and (not Node.Deleting) then
   begin
      if Node.IndexOf(Self) <> -1 then CheckValue := 1
      else CheckValue := 0;
      if Node.CompareCount(CheckValue) then
      begin
         Expanded := False;
         Node.HasChildren := False;
      end;
   end;
   if ItemId <> nil then TreeView_DeleteItem(Handle, ItemId);
   Data := nil;
   inherited Destroy;
end;

function TfcTreeNode.GetHandle: HWND;
begin
  Result := TreeView.Handle;
end;

function TfcTreeNode.GetTreeView: TfcCustomTreeView;
begin
  Result := Owner.Owner;
end;

function TfcTreeNode.HasAsParent(Value: TfcTreeNode): Boolean;
begin
  if Value <> Nil then
  begin
    if Parent = nil then Result := False
    else if Parent = Value then Result := True
    else Result := Parent.HasAsParent(Value);
  end
  else Result := True;
end;

procedure TfcTreeNode.SetText(const S: string);
var
  Item: TTVItem;
  AVariant: Variant;
begin
  if s = '' then AVariant := NULL else AVariant := s;
  if Assigned(TreeView.OnItemChange) then TreeView.OnItemChange(TreeView, self, icaText, AVariant);
  FText := S;
  with Item do
  begin
    mask := TVIF_TEXT;
    hItem := ItemId;
    pszText := LPSTR_TEXTCALLBACK;
  end;
  TreeView_SetItem(Handle, Item);
  if (TreeView.SortType in [fcstText, fcstBoth]) and FInTree then
  begin
    if (Parent <> nil) then Parent.AlphaSort
    else TreeView.AlphaSort;
  end;
end;

procedure TfcTreeNode.SetData(Value: Pointer);
begin
  FData := Value;
  if (TreeView.SortType in [fcstData, fcstBoth]) and Assigned(TreeView.OnCompare)
    and (not Deleting) and FInTree then
  begin
    if Parent <> nil then Parent.AlphaSort
    else TreeView.AlphaSort;
  end;
end;

function TfcTreeNode.GetState(NodeState: TfcNodeState): Boolean;
var
  Item: TTVItem;
begin
  Result := False;
  with Item do
  begin
    mask := TVIF_STATE;
    hItem := ItemId;
    if TreeView_GetItem(Handle, Item) then
      case NodeState of
        fcnsCut: Result := (state and TVIS_CUT) <> 0;
        fcnsFocused: Result := (state and TVIS_FOCUSED) <> 0;
        fcnsSelected: Result := (state and TVIS_SELECTED) <> 0;
        fcnsExpanded: Result := (state and TVIS_EXPANDED) <> 0;
        fcnsDropHilited: Result := (state and TVIS_DROPHILITED) <> 0;
      end;
  end;
end;

procedure TfcTreeNode.SetImageIndex(Value: Integer);
var
  Item: TTVItem;
begin
  if Assigned(TreeView.OnItemChange) then TreeView.OnItemChange(TreeView, self, icaImageIndex, Value);
  FImageIndex := Value;
  with Item do
  begin
    mask := TVIF_IMAGE or TVIF_HANDLE;
    hItem := ItemId;
    iImage := I_IMAGECALLBACK;
  end;
  TreeView_SetItem(Handle, Item);
end;

procedure TfcTreeNode.SetSelectedIndex(Value: Integer);
var
  Item: TTVItem;
begin
  FSelectedIndex := Value;
  with Item do
  begin
    mask := TVIF_SELECTEDIMAGE or TVIF_HANDLE;
    hItem := ItemId;
    iSelectedImage := I_IMAGECALLBACK;
  end;
  TreeView_SetItem(Handle, Item);
end;

procedure TfcTreeNode.SetOverlayIndex(Value: Integer);
var
  Item: TTVItem;
begin
  FOverlayIndex := Value;
  with Item do
  begin
    mask := TVIF_STATE or TVIF_HANDLE;
    stateMask := TVIS_OVERLAYMASK;
    hItem := ItemId;
    state := IndexToOverlayMask(OverlayIndex + 1);
  end;
  TreeView_SetItem(Handle, Item);
end;

procedure TfcTreeNode.SetStateIndex(Value: Integer);
var
  Item: TTVItem;
begin
  if Value=0 then Value:= -1;  // 11/21/98 - (RSW) Don't allow 0 as state index
  if (CheckboxType = tvctCheckbox) and (Value<>-1) and (Value<>1) then exit; { 3/8/99}

  FStateIndex := Value;
  if Value >= 0 then Dec(Value);
  with Item do
  begin
    mask := TVIF_STATE or TVIF_HANDLE;
    stateMask := TVIS_STATEIMAGEMASK;
    hItem := ItemId;
    state := IndexToStateImageMask(Value + 1);
  end;
  TreeView_SetItem(Handle, Item);
end;

function TfcTreeNode.CompareCount(CompareMe: Integer): Boolean;
var
  Count: integer;
  Node: TfcTreeNode;
Begin
  Count := 0;
  Result := False;
  Node := GetFirstChild;
  while Node <> nil do
  begin
    Inc(Count);
    Node := Node.GetNextChild(Node);
    if Count > CompareMe then Exit;
  end;
  if Count = CompareMe then Result := True;
end;

function TfcTreeNode.DoCanExpand(Expand: Boolean): Boolean;
begin
  Result := False;
  if HasChildren then
  begin
    if Expand then Result := TreeView.CanExpand(Self)
    else Result := TreeView.CanCollapse(Self);
  end;
end;

procedure TfcTreeNode.DoExpand(Expand: Boolean);
begin
  if HasChildren then
  begin
    if Expand then TreeView.Expand(Self)
    else TreeView.Collapse(Self);
  end;
end;

procedure TfcTreeNode.ExpandItem(Expand: Boolean; Recurse: Boolean);
var
  Flag: Integer;
  Node: TfcTreeNode;
begin
  if Recurse then
  begin
    Node := Self;
    repeat
      Node.ExpandItem(Expand, False);
      Node := Node.GetNext;
    until (Node = nil) or (not Node.HasAsParent(Self));
  end
  else begin
    TreeView.FManualNotify := True;
    try
      Flag := 0;
      if Expand then
      begin
        if DoCanExpand(True) then
        begin
          Flag := TVE_EXPAND;
          DoExpand(True);
        end;
      end
      else begin
        if DoCanExpand(False) then
        begin
          Flag := TVE_COLLAPSE;
          DoExpand(False);
        end;
      end;
      if Flag <> 0 then TreeView_Expand(Handle, ItemId, Flag);
    finally
      TreeView.FManualNotify := False;
    end;
  end;
end;

procedure TfcTreeNode.Expand(Recurse: Boolean);
begin
  ExpandItem(True, Recurse);
end;

procedure TfcTreeNode.Collapse(Recurse: Boolean);
begin
  ExpandItem(False, Recurse);
end;

function TfcTreeNode.GetExpanded: Boolean;
begin
  Result := GetState(fcnsExpanded);
end;

procedure TfcTreeNode.SetExpanded(Value: Boolean);
begin
  if Value then Expand(False)
  else Collapse(False);
end;

function TfcTreeNode.GetSelected: Boolean;
begin
  Result := GetState(fcnsSelected);
end;

procedure TfcTreeNode.SetSelected(Value: Boolean);
begin
  if Value then TreeView_SelectItem(Handle, ItemId)
  else if Selected then TreeView_SelectItem(Handle, nil);
end;

function TfcTreeNode.GetCut: Boolean;
begin
  Result := GetState(fcnsCut);
end;

procedure TfcTreeNode.SetCut(Value: Boolean);
var
  Item: TTVItem;
  Template: DWORD;
begin
  if Value then Template := DWORD(-1)
  else Template := 0;
  with Item do
  begin
    mask := TVIF_STATE;
    hItem := ItemId;
    stateMask := TVIS_CUT;
    state := stateMask and Template;
  end;
  TreeView_SetItem(Handle, Item);
end;

function TfcTreeNode.GetDropTarget: Boolean;
begin
  Result := GetState(fcnsDropHilited);
end;

procedure TfcTreeNode.SetDropTarget(Value: Boolean);
begin
  if Value then TreeView_SelectDropTarget(Handle, ItemId)
  else if DropTarget then TreeView_SelectDropTarget(Handle, nil);
end;

function TfcTreeNode.GetChildren: Boolean;
var
  Item: TTVItem;
begin
  Item.mask := TVIF_CHILDREN;
  Item.hItem := ItemId;
  if TreeView_GetItem(Handle, Item) then Result := Item.cChildren > 0
  else Result := False;
end;

procedure TfcTreeNode.SetFocused(Value: Boolean);
var
  Item: TTVItem;
  Template: DWORD;
begin
  if Value then Template := DWORD(-1)
  else Template := 0;
  with Item do
  begin
    mask := TVIF_STATE;
    hItem := ItemId;
    stateMask := TVIS_FOCUSED;
    state := stateMask and Template;
  end;
  TreeView_SetItem(Handle, Item);
end;

function TfcTreeNode.GetFocused: Boolean;
begin
  Result := GetState(fcnsFocused);
end;

procedure TfcTreeNode.SetChildren(Value: Boolean);
var
  Item: TTVItem;
begin
  with Item do
  begin
    mask := TVIF_CHILDREN;
    hItem := ItemId;
    cChildren := Ord(Value);
  end;
  TreeView_SetItem(Handle, Item);
end;

function TfcTreeNode.GetParent: TfcTreeNode;
begin
  with FOwner do
    Result := GetNode(TreeView_GetParent(Handle, ItemId));
end;

function TfcTreeNode.GetNextSibling: TfcTreeNode;
begin
  with FOwner do
    Result := GetNode(TreeView_GetNextSibling(Handle, ItemId));
end;

function TfcTreeNode.GetPrevSibling: TfcTreeNode;
begin
  with FOwner do
    Result := GetNode(TreeView_GetPrevSibling(Handle, ItemId));
end;

function TfcTreeNode.GetNextVisible: TfcTreeNode;
begin
  if IsVisible then
    with FOwner do
      Result := GetNode(TreeView_GetNextVisible(Handle, ItemId))
  else Result := nil;
end;

function TfcTreeNode.GetPrevVisible: TfcTreeNode;
begin
  with FOwner do
    Result := GetNode(TreeView_GetPrevVisible(Handle, ItemId));
end;

function TfcTreeNode.GetNextChild(Value: TfcTreeNode): TfcTreeNode;
begin
  if Value <> nil then Result := Value.GetNextSibling
  else Result := nil;
end;

function TfcTreeNode.GetPrevChild(Value: TfcTreeNode): TfcTreeNode;
begin
  if Value <> nil then Result := Value.GetPrevSibling
  else Result := nil;
end;