jvqinterpreter_comctrls.pas

East make Tray Icon in delphi

procedure TTreeNode_Read_AbsoluteIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).AbsoluteIndex;
end;

{ property Read Count: Integer }

procedure TTreeNode_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Count;
end;

{ property Read Cut: Boolean }

procedure TTreeNode_Read_Cut(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Cut;
end;

{ property Write Cut(Value: Boolean) }

procedure TTreeNode_Write_Cut(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Cut := Value;
end;

{ property Read Data: Pointer }

procedure TTreeNode_Read_Data(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TTreeNode(Args.Obj).Data);
end;

{ property Write Data(Value: Pointer) }

procedure TTreeNode_Write_Data(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Data := V2P(Value);
end;

{ property Read Deleting: Boolean }

procedure TTreeNode_Read_Deleting(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Deleting;
end;

{ property Read Focused: Boolean }

procedure TTreeNode_Read_Focused(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Focused;
end;

{ property Write Focused(Value: Boolean) }

procedure TTreeNode_Write_Focused(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Focused := Value;
end;

{ property Read DropTarget: Boolean }

procedure TTreeNode_Read_DropTarget(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).DropTarget;
end;

{ property Write DropTarget(Value: Boolean) }

procedure TTreeNode_Write_DropTarget(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).DropTarget := Value;
end;

{ property Read Selected: Boolean }

procedure TTreeNode_Read_Selected(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Selected;
end;

{ property Write Selected(Value: Boolean) }

procedure TTreeNode_Write_Selected(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Selected := Value;
end;

{ property Read Expanded: Boolean }

procedure TTreeNode_Read_Expanded(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Expanded;
end;

{ property Write Expanded(Value: Boolean) }

procedure TTreeNode_Write_Expanded(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Expanded := Value;
end;

{ property Read Handle: HWND }

procedure TTreeNode_Read_Handle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TTreeNode(Args.Obj).Handle);
end;

{ property Read HasChildren: Boolean }

procedure TTreeNode_Read_HasChildren(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).HasChildren;
end;

{ property Write HasChildren(Value: Boolean) }

procedure TTreeNode_Write_HasChildren(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).HasChildren := Value;
end;

{ property Read ImageIndex: Integer }

procedure TTreeNode_Read_ImageIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).ImageIndex;
end;

{ property Write ImageIndex(Value: Integer) }

procedure TTreeNode_Write_ImageIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).ImageIndex := Value;
end;

{ property Read Index: Integer }

procedure TTreeNode_Read_Index(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Index;
end;

{ property Read IsVisible: Boolean }

procedure TTreeNode_Read_IsVisible(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).IsVisible;
end;

{ property Read Item[Integer]: TTreeNode }

procedure TTreeNode_Read_Item(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).Item[Args.Values[0]]);
end;

{ property Write Item[Integer]: TTreeNode }

procedure TTreeNode_Write_Item(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Item[Args.Values[0]] := V2O(Value) as TTreeNode;
end;

{ property Read ItemId: HTreeItem }

procedure TTreeNode_Read_ItemId(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TTreeNode(Args.Obj).ItemId);
end;

{ property Read Level: Integer }

procedure TTreeNode_Read_Level(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Level;
end;

{ property Read OverlayIndex: Integer }

procedure TTreeNode_Read_OverlayIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).OverlayIndex;
end;

{ property Write OverlayIndex(Value: Integer) }

procedure TTreeNode_Write_OverlayIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).OverlayIndex := Value;
end;

{ property Read Owner: TTreeNodes }

procedure TTreeNode_Read_Owner(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).Owner);
end;

{ property Read Parent: TTreeNode }

procedure TTreeNode_Read_Parent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).Parent);
end;

{ property Read SelectedIndex: Integer }

procedure TTreeNode_Read_SelectedIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).SelectedIndex;
end;

{ property Write SelectedIndex(Value: Integer) }

procedure TTreeNode_Write_SelectedIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).SelectedIndex := Value;
end;

{ property Read StateIndex: Integer }

procedure TTreeNode_Read_StateIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).StateIndex;
end;

{ property Write StateIndex(Value: Integer) }

procedure TTreeNode_Write_StateIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).StateIndex := Value;
end;

{ property Read Text: string }

procedure TTreeNode_Read_Text(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).Text;
end;

{ property Write Text(Value: string) }

procedure TTreeNode_Write_Text(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Text := Value;
end;

{ property Read TreeView: TCustomTreeView }

procedure TTreeNode_Read_TreeView(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).TreeView);
end;

{ TTreeNodes }

{ constructor Create(AOwner: TCustomTreeView) }

procedure TTreeNodes_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes.Create(V2O(Args.Values[0]) as TCustomTreeView));
end;

{ function AddChildFirst(Node: TTreeNode; const S: string): TTreeNode; }

procedure TTreeNodes_AddChildFirst(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddChildFirst(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]));
end;

{ function AddChild(Node: TTreeNode; const S: string): TTreeNode; }

procedure TTreeNodes_AddChild(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddChild(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]));
end;

{ function AddChildObjectFirst(Node: TTreeNode; const S: string; Ptr: Pointer): TTreeNode; }

procedure TTreeNodes_AddChildObjectFirst(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddChildObjectFirst(V2O(Args.Values[0]) as TTreeNode, Args.Values[1],
    V2P(Args.Values[2])));
end;

{ function AddChildObject(Node: TTreeNode; const S: string; Ptr: Pointer): TTreeNode; }

procedure TTreeNodes_AddChildObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddChildObject(V2O(Args.Values[0]) as TTreeNode, Args.Values[1],
    V2P(Args.Values[2])));
end;

{ function AddFirst(Node: TTreeNode; const S: string): TTreeNode; }

procedure TTreeNodes_AddFirst(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddFirst(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]));
end;

{ function Add(Node: TTreeNode; const S: string): TTreeNode; }

procedure TTreeNodes_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).Add(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]));
end;

{ function AddObjectFirst(Node: TTreeNode; const S: string; Ptr: Pointer): TTreeNode; }

procedure TTreeNodes_AddObjectFirst(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddObjectFirst(V2O(Args.Values[0]) as TTreeNode, Args.Values[1],
    V2P(Args.Values[2])));
end;

{ function AddObject(Node: TTreeNode; const S: string; Ptr: Pointer): TTreeNode; }

procedure TTreeNodes_AddObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).AddObject(V2O(Args.Values[0]) as TTreeNode, Args.Values[1], V2P(Args.Values[2])));
end;

{ procedure Assign(Source: TPersistent); }

procedure TTreeNodes_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNodes(Args.Obj).Assign(V2O(Args.Values[0]) as TPersistent);
end;

{ procedure BeginUpdate; }

procedure TTreeNodes_BeginUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNodes(Args.Obj).BeginUpdate;
end;

{ procedure Clear; }

procedure TTreeNodes_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNodes(Args.Obj).Clear;
end;

{ procedure Delete(Node: TTreeNode); }

procedure TTreeNodes_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNodes(Args.Obj).Delete(V2O(Args.Values[0]) as TTreeNode);
end;

{ procedure EndUpdate; }

procedure TTreeNodes_EndUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNodes(Args.Obj).EndUpdate;
end;

{ function GetFirstNode: TTreeNode; }

procedure TTreeNodes_GetFirstNode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).GetFirstNode);
end;

{ function GetNode(ItemId: HTreeItem): TTreeNode; }

procedure TTreeNodes_GetNode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).GetNode(V2P(Args.Values[0])));
end;

{ function Insert(Node: TTreeNode; const S: string): TTreeNode; }

procedure TTreeNodes_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).Insert(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]));
end;

{ function InsertObject(Node: TTreeNode; const S: string; Ptr: Pointer): TTreeNode; }

procedure TTreeNodes_InsertObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).InsertObject(V2O(Args.Values[0]) as TTreeNode, Args.Values[1],
    V2P(Args.Values[2])));
end;

{ property Read Count: Integer }

procedure TTreeNodes_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNodes(Args.Obj).Count;
end;

{ property Read Handle: HWND }

procedure TTreeNodes_Read_Handle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TTreeNodes(Args.Obj).Handle);
end;

{ property Read Item[Integer]: TTreeNode }

procedure TTreeNodes_Read_Item(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).Item[Args.Values[0]]);
end;

{ property Read Owner: TCustomTreeView }

procedure TTreeNodes_Read_Owner(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNodes(Args.Obj).Owner);
end;

{ TCustomTreeView }

{ function AlphaSort: Boolean; }

procedure TCustomTreeView_AlphaSort(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCustomTreeView(Args.Obj).AlphaSort;
end;

{ function CustomSort(SortProc: TTVCompare; Data: Longint): Boolean; }

procedure TCustomTreeView_CustomSort(var Value: Variant; Args: TJvInterpreterArgs);
begin
//  Value := TCustomTreeView(Args.Obj).CustomSort(Args.Values[0], Args.Values[1]);
  NotImplemented('TCustomTreeView.CustomSort');
end;

{ procedure FullCollapse; }

procedure TCustomTreeView_FullCollapse(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomTreeView(Args.Obj).FullCollapse;
end;

{ procedure FullExpand; }

procedure TCustomTreeView_FullExpand(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomTreeView(Args.Obj).FullExpand;
end;

{ function GetHitTestInfoAt(X, Y: Integer): THitTests; }