jvqinterpreter_comctrls.pas

East make Tray Icon in delphi

{**************************************************************************************************}
{  WARNING:  JEDI preprocessor generated unit.  Do not edit.                                       }
{**************************************************************************************************}

{-----------------------------------------------------------------------------
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/MPL-1.1.html

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is: JvInterpreter_ComCtrls.PAS, released on 2002-07-04.

The Initial Developers of the Original Code are: Andrei Prygounkov <a dott prygounkov att gmx dott de>
Copyright (c) 1999, 2002 Andrei Prygounkov
All Rights Reserved.

Contributor(s):

You may retrieve the latest version of this file at the Project JEDI's JVCL home page,
located at http://jvcl.sourceforge.net

Description : adapter unit - converts JvInterpreter calls to delphi calls

Known Issues:
-----------------------------------------------------------------------------}
// $Id: JvQInterpreter_ComCtrls.pas,v 1.1 2004/05/16 00:41:48 asnepvangers Exp $

{$I jvcl.inc}

unit JvQInterpreter_ComCtrls;

interface

uses
  JvQInterpreter;

procedure RegisterJvInterpreterAdapter(JvInterpreterAdapter: TJvInterpreterAdapter);

implementation

uses
  QWindows, Classes, QControls, QGraphics, QComCtrls,
  JvQInterpreter_Windows;

{ TTabControl }

{ constructor Create(AOwner: TComponent) }

procedure TTabControl_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTabControl.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TTabSheet }

{ constructor Create(AOwner: TComponent) }

procedure TTabSheet_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTabSheet.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read PageControl: TPageControl }

procedure TTabSheet_Read_PageControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTabSheet(Args.Obj).PageControl);
end;

{ property Write PageControl(Value: TPageControl) }

procedure TTabSheet_Write_PageControl(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTabSheet(Args.Obj).PageControl := V2O(Value) as TPageControl;
end;

{ property Read TabIndex: Integer }

procedure TTabSheet_Read_TabIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTabSheet(Args.Obj).TabIndex;
end;

{ TPageControl }

{ constructor Create(AOwner: TComponent) }

procedure TPageControl_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPageControl.Create(V2O(Args.Values[0]) as TComponent));
end;

{ function FindNextPage(CurPage: TTabSheet; GoForward, CheckTabVisible: Boolean): TTabSheet; }

procedure TPageControl_FindNextPage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPageControl(Args.Obj).FindNextPage(V2O(Args.Values[0]) as TTabSheet, Args.Values[1], Args.Values[2]));
end;

{ procedure SelectNextPage(GoForward: Boolean); }

procedure TPageControl_SelectNextPage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPageControl(Args.Obj).SelectNextPage(Args.Values[0]);
end;

{ property Read PageCount: Integer }

procedure TPageControl_Read_PageCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TPageControl(Args.Obj).PageCount;
end;

{ property Read Pages[Integer]: TTabSheet }

procedure TPageControl_Read_Pages(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPageControl(Args.Obj).Pages[Args.Values[0]]);
end;

{ TStatusPanel }

{ constructor Create(Collection: TCollection) }

procedure TStatusPanel_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusPanel.Create(V2O(Args.Values[0]) as TCollection));
end;

{ procedure Assign(Source: TPersistent); }

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

{ TStatusPanels }

{ constructor Create(StatusBar: TStatusBar) }

procedure TStatusPanels_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusPanels.Create(V2O(Args.Values[0]) as TStatusBar));
end;

{ function Add: TStatusPanel; }

procedure TStatusPanels_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusPanels(Args.Obj).Add);
end;

{ property Read Items[Integer]: TStatusPanel }

procedure TStatusPanels_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusPanels(Args.Obj).Items[Args.Values[0]]);
end;

{ property Write Items[Integer]: TStatusPanel }

procedure TStatusPanels_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStatusPanels(Args.Obj).Items[Args.Values[0]] := V2O(Value) as TStatusPanel;
end;

{ TStatusBar }

{ constructor Create(AOwner: TComponent) }

procedure TStatusBar_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusBar.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Canvas: TCanvas }

procedure TStatusBar_Read_Canvas(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStatusBar(Args.Obj).Canvas);
end;

{ THeaderSection }

{ constructor Create(Collection: TCollection) }

procedure THeaderSection_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderSection.Create(V2O(Args.Values[0]) as TCollection));
end;

{ procedure Assign(Source: TPersistent); }

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

{ property Read Left: Integer }

procedure THeaderSection_Read_Left(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := THeaderSection(Args.Obj).Left;
end;

{ property Read Right: Integer }

procedure THeaderSection_Read_Right(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := THeaderSection(Args.Obj).Right;
end;

{ THeaderSections }

{ constructor Create(HeaderControl: THeaderControl) }

procedure THeaderSections_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderSections.Create(V2O(Args.Values[0]) as THeaderControl));
end;

{ function Add: THeaderSection; }

procedure THeaderSections_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderSections(Args.Obj).Add);
end;

{ property Read Items[Integer]: THeaderSection }

procedure THeaderSections_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderSections(Args.Obj).Items[Args.Values[0]]);
end;

{ property Write Items[Integer]: THeaderSection }

procedure THeaderSections_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  THeaderSections(Args.Obj).Items[Args.Values[0]] := V2O(Value) as THeaderSection;
end;

{ THeaderControl }

{ constructor Create(AOwner: TComponent) }

procedure THeaderControl_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderControl.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Canvas: TCanvas }

procedure THeaderControl_Read_Canvas(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(THeaderControl(Args.Obj).Canvas);
end;

{ TTreeNode }

{ constructor Create(AOwner: TTreeNodes) }

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

{ function AlphaSort: Boolean; }

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

{ procedure Assign(Source: TPersistent); }

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

{ procedure Collapse(Recurse: Boolean); }

procedure TTreeNode_Collapse(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Collapse(Args.Values[0]);
end;

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

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

{ procedure Delete; }

procedure TTreeNode_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Delete;
end;

{ procedure DeleteChildren; }

procedure TTreeNode_DeleteChildren(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).DeleteChildren;
end;

{ function DisplayRect(TextOnly: Boolean): TRect; }

procedure TTreeNode_DisplayRect(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Rect2Var(TTreeNode(Args.Obj).DisplayRect(Args.Values[0]));
end;

{ function EditText: Boolean; }

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

{ procedure EndEdit(Cancel: Boolean); }

procedure TTreeNode_EndEdit(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).EndEdit(Args.Values[0]);
end;

{ procedure Expand(Recurse: Boolean); }

procedure TTreeNode_Expand(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).Expand(Args.Values[0]);
end;

{ function GetFirstChild: TTreeNode; }

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

{ function GetHandle: HWND; }

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

{ function GetLastChild: TTreeNode; }

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

{ function GetNext: TTreeNode; }

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

{ function GetNextChild(Value: TTreeNode): TTreeNode; }

procedure TTreeNode_GetNextChild(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).GetNextChild(V2O(Args.Values[0]) as TTreeNode));
end;

{ function GetNextSibling: TTreeNode; }

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

{ function GetNextVisible: TTreeNode; }

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

{ function GetPrev: TTreeNode; }

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

{ function GetPrevChild(Value: TTreeNode): TTreeNode; }

procedure TTreeNode_GetPrevChild(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTreeNode(Args.Obj).GetPrevChild(V2O(Args.Values[0]) as TTreeNode));
end;

{ function GetPrevSibling: TTreeNode; }

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

{ function GetPrevVisible: TTreeNode; }

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

{ function HasAsParent(Value: TTreeNode): Boolean; }

procedure TTreeNode_HasAsParent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).HasAsParent(V2O(Args.Values[0]) as TTreeNode);
end;

{ function IndexOf(Value: TTreeNode): Integer; }

procedure TTreeNode_IndexOf(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTreeNode(Args.Obj).IndexOf(V2O(Args.Values[0]) as TTreeNode);
end;

{ procedure MakeVisible; }

procedure TTreeNode_MakeVisible(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).MakeVisible;
end;

{ procedure MoveTo(Destination: TTreeNode; Mode: TNodeAttachMode); }

procedure TTreeNode_MoveTo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTreeNode(Args.Obj).MoveTo(V2O(Args.Values[0]) as TTreeNode, Args.Values[1]);
end;

{ property Read AbsoluteIndex: Integer }