jvinterpreter_menus.pas

East make Tray Icon in delphi

{-----------------------------------------------------------------------------
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_Menus.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: JvInterpreter_Menus.pas,v 1.9 2005/02/17 10:20:40 marquardt Exp $

unit JvInterpreter_Menus;

{$I jvcl.inc}

interface

uses
  {$IFDEF UNITVERSIONING}
  JclUnitVersioning,
  {$ENDIF UNITVERSIONING}
  JvInterpreter;

procedure RegisterJvInterpreterAdapter(JvInterpreterAdapter: TJvInterpreterAdapter);

{$IFDEF UNITVERSIONING}
const
  UnitVersioning: TUnitVersionInfo = (
    RCSfile: '$RCSfile: JvInterpreter_Menus.pas,v $';
    Revision: '$Revision: 1.9 $';
    Date: '$Date: 2005/02/17 10:20:40 $';
    LogPath: 'JVCL\run'
  );
{$ENDIF UNITVERSIONING}

implementation

uses
  Classes, Menus;

{ EMenuError }

{ TMenuItem }

{ constructor Create(AOwner: TComponent) }

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

{ procedure Insert(Index: Integer; Item: TMenuItem); }

procedure TMenuItem_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Insert(Args.Values[0], V2O(Args.Values[1]) as TMenuItem);
end;

{ procedure Delete(Index: Integer); }

procedure TMenuItem_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Delete(Args.Values[0]);
end;

{ procedure Click; }

procedure TMenuItem_Click(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Click;
end;

{ function IndexOf(Item: TMenuItem): Integer; }

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

{ procedure Add(Item: TMenuItem); }

procedure TMenuItem_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Add(V2O(Args.Values[0]) as TMenuItem);
end;

{ procedure Remove(Item: TMenuItem); }

procedure TMenuItem_Remove(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Remove(V2O(Args.Values[0]) as TMenuItem);
end;

{ property Read Command: Word }

procedure TMenuItem_Read_Command(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Command;
end;

{ property Read Handle: HMENU }

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

{ property Read Count: Integer }

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

{ property Read Items[Integer]: TMenuItem }

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

{ property Read MenuIndex: Integer }

procedure TMenuItem_Read_MenuIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).MenuIndex;
end;

{ property Write MenuIndex(Value: Integer) }

procedure TMenuItem_Write_MenuIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).MenuIndex := Value;
end;

{ property Read Parent: TMenuItem }

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

{ property Read Break: TMenuBreak }

procedure TMenuItem_Read_Break(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Break;
end;

{ property Write Break(Value: TMenuBreak) }

procedure TMenuItem_Write_Break(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Break := Value;
end;

{ property Read Caption: string }

procedure TMenuItem_Read_Caption(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Caption;
end;

{ property Write Caption(Value: string) }

procedure TMenuItem_Write_Caption(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Caption := Value;
end;

{ property Read Checked: Boolean }

procedure TMenuItem_Read_Checked(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Checked;
end;

{ property Write Checked(Value: Boolean) }

procedure TMenuItem_Write_Checked(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Checked := Value;
end;

{ property Read Default: Boolean }

procedure TMenuItem_Read_Default(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Default;
end;

{ property Write Default(Value: Boolean) }

procedure TMenuItem_Write_Default(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Default := Value;
end;

{ property Read Enabled: Boolean }

procedure TMenuItem_Read_Enabled(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Enabled;
end;

{ property Write Enabled(Value: Boolean) }

procedure TMenuItem_Write_Enabled(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Enabled := Value;
end;

{ property Read GroupIndex: Byte }

procedure TMenuItem_Read_GroupIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).GroupIndex;
end;

{ property Write GroupIndex(Value: Byte) }

procedure TMenuItem_Write_GroupIndex(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).GroupIndex := Value;
end;

{ property Read HelpContext: THelpContext }

procedure TMenuItem_Read_HelpContext(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).HelpContext;
end;

{ property Write HelpContext(Value: THelpContext) }

procedure TMenuItem_Write_HelpContext(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).HelpContext := Value;
end;

{ property Read Hint: string }

procedure TMenuItem_Read_Hint(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Hint;
end;

{ property Write Hint(Value: string) }

procedure TMenuItem_Write_Hint(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Hint := Value;
end;

{ property Read RadioItem: Boolean }

procedure TMenuItem_Read_RadioItem(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).RadioItem;
end;

{ property Write RadioItem(Value: Boolean) }

procedure TMenuItem_Write_RadioItem(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).RadioItem := Value;
end;

{ property Read ShortCut: TShortCut }

procedure TMenuItem_Read_ShortCut(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).ShortCut;
end;

{ property Write ShortCut(Value: TShortCut) }

procedure TMenuItem_Write_ShortCut(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).ShortCut := Value;
end;

{ property Read Visible: Boolean }

procedure TMenuItem_Read_Visible(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenuItem(Args.Obj).Visible;
end;

{ property Write Visible(Value: Boolean) }

procedure TMenuItem_Write_Visible(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMenuItem(Args.Obj).Visible := Value;
end;

{ TMenu }

{ function DispatchCommand(ACommand: Word): Boolean; }

procedure TMenu_DispatchCommand(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenu(Args.Obj).DispatchCommand(Args.Values[0]);
end;

{ function DispatchPopup(AHandle: HMENU): Boolean; }

procedure TMenu_DispatchPopup(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMenu(Args.Obj).DispatchPopup(Args.Values[0]);
end;