home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / tvision / gravis / gv / gvdialog.int < prev    next >
Encoding:
Text File  |  1994-05-23  |  17.9 KB  |  667 lines
  1. Unit GVDialog;
  2.  
  3.  
  4. interface
  5.  
  6. uses Objects, Drivers, Views, GVViews
  7.  
  8. , Validate
  9. ;
  10.  
  11. Const
  12.  
  13. { Color Palettes }
  14.  
  15.   CDialog = #76#77#78#79#80#81#82#83#84#85#86#87#88#89#90#91#92#93;
  16.  
  17.   CInputLine  = #125#126#127#128#129#130#131;
  18.   CArrowField = #132#133;
  19.   CButton     = #103#104#105#106#107#108#109#110#111#112;
  20.   CRegler     = #113#114#115#116;
  21.   CCluster    = #117#118#119#120#121#122#123#124;
  22.   CStaticText = #94;
  23.   CStaticSign = #94;
  24.   CLabel      = #95#96#97#98#99#100;
  25.   CIcon       = #101#102;
  26.   CHistory    = #103#111#112;
  27.  
  28. { TArrowField commands }
  29.  
  30.   cmArrowUp = 60;
  31.   cmArrowDn = 61;
  32.  
  33. { TMultiCheckboxes flags }
  34. { hibyte = number of bits }
  35. { lobyte = bit mask }
  36.  
  37.   cfOneBit       = $0101;
  38.   cfTwoBits      = $0203;
  39.   cfFourBits     = $040F;
  40.   cfEightBits    = $08FF;
  41.  
  42. { Dialog broadcast commands }
  43.  
  44.   cmRecordHistory = 60;
  45.  
  46. Type
  47.  
  48. { TDialog object }
  49.  
  50.   { Palette layout }
  51.   { 1  = Background }
  52.   { 2  = Frame active }
  53.   { 3  = Frame not active }
  54.   { 4  = Frame modal }
  55.   { 5  = Zoomfield }
  56.   { 6  = Title background normal}
  57.   { 7  = Title background selected }
  58.   { 8  = Title normal}
  59.   { 9  = Title selected }
  60.   { 10 = Close- and Zoomfield outside }
  61.   { 11 = Closefield frame }
  62.   { 12 = Closefield inside }
  63.   { 13 = Closefield shadow }
  64.   { 14 = Scrollbar background }
  65.   { 15 = Scrollbar frame }
  66.   { 16 = Scrollbar buttons }
  67.   { 17 = Scrollbar button shadows }
  68.   { 18 = Scrollbar page area }
  69.  
  70.   PDialog = ^TDialog;
  71.   TDialog = object(TWindow)
  72.     constructor Init (Bounds: TRect; ATitle: String);
  73.     procedure HandleEvent (var Event: TEvent); virtual;
  74.     function GetPalette: PPalette; virtual;
  75.     function Valid (Command: Word):Boolean; virtual;
  76.   end;
  77.  
  78. { TInputLine object }
  79.  
  80.   { Palette layout }
  81.   { 1 = Passive }
  82.   { 2 = Active }
  83.   { 3 = Selected }
  84.   { 4 = Arrows }
  85.   { 5 = Frame }
  86.   { 6 = Text }
  87.   { 7 = Cursor }
  88.  
  89.   PValidator = Pointer;
  90.  
  91.   PInputLine = ^TInputLine;
  92.   TInputLine = object(TGView)
  93.     Data: PString;
  94.     MaxLen: Integer;
  95.     CurPos: Integer;
  96.     FirstPos: Integer;
  97.     SelStart: Integer;
  98.     SelEnd: Integer;
  99.     EndPos: Integer;
  100.     Validator: PValidator;
  101.     constructor Init(var Bounds: TRect; AMaxLen: Integer);
  102.     constructor Load(var S: TStream);
  103.     destructor Done; virtual;
  104.     procedure ChMCursor; virtual;
  105.     function DataSize: Word; virtual;
  106.     procedure Draw; virtual;
  107.     procedure DrawText (APos, EPos: Integer); virtual;
  108.     procedure GetData(var Rec); virtual;
  109.     function GetPalette: PPalette; virtual;
  110.     procedure HandleEvent(var Event: TEvent); virtual;
  111.     procedure SelectAll(Enable: Boolean);
  112.     procedure SetCurPos (ACurPos: Integer; DoSelect: Boolean);
  113.     procedure SetData(var Rec); virtual;
  114.     procedure SetSelect(NewStart, NewEnd: Integer);
  115.     procedure SetState(AState: Word; Enable: Boolean); virtual;
  116.     procedure SetValidator(AValid: PValidator);
  117.     procedure Store(var S: TStream);
  118.     function Valid(Command: Word): Boolean; virtual;
  119.   end;
  120.  
  121. { TArrowField object }
  122.  
  123.   { Palette layout }
  124.   { 1 = Background }
  125.   { 2 = Icon }
  126.  
  127.   PArrowField = ^TArrowField;
  128.   TArrowField = object (TGView)
  129.                   constructor Init (var Bounds: TRect);
  130.                   procedure Draw; virtual;
  131.                   function GetPalette: PPalette; virtual;
  132.                   procedure HandleEvent (var Event: TEvent); virtual;
  133.                 end;
  134.  
  135. { TNumInput object }
  136.  
  137.   { Palette layout = TInputLine }
  138.  
  139.   PNumInput = ^TNumInput;
  140.   TNumInput = object (TInputLine)
  141.                 LimitHi, LimitLo, Value: Integer;
  142.                 Arrows: PArrowField;
  143.                 constructor Init (var Bounds: TRect; ALimitLo, ALimitHi: Integer;
  144.                    AArrows: PArrowField);
  145.                 constructor Load (var S: TStream);
  146.                 function DataSize: Word; virtual;
  147.                 procedure GetData (var Rec); virtual;
  148.                 procedure HandleEvent (var Event: TEvent); virtual;
  149.                 procedure SetData (var Rec); virtual;
  150.                 procedure SetLimit (ALimitLo, ALimitHi: Integer);
  151.                 procedure Store (var S: TStream);
  152.               end;
  153.  
  154. { TButton object }
  155.  
  156.   { Palette layout }
  157.   { 1 = Background }
  158.   { 2 = Normal text }
  159.   { 3 = Default text }
  160.   { 4 = Selected text }
  161.   { 5 = Disabled text }
  162.   { 6 = Normal shortcut }
  163.   { 7 = Default shortcut }
  164.   { 8 = Selected shortcut }
  165.   { 9 = Borders }
  166.   {10 = Lines }
  167.  
  168.   PButton = ^TButton;
  169.   TButton = Object (TGView)
  170.     Title: PString;
  171.     Command: Word;
  172.     Flags: Byte;
  173.     AmDefault: Boolean;
  174.     constructor Init(var Bounds: TRect; ATitle: TTitleStr; ACommand: Word;
  175.       AFlags: Word);
  176.     constructor Load (var S: TStream);
  177.     destructor Done; virtual;
  178.     procedure Draw; virtual;
  179.     procedure DrawState(Down: Boolean); virtual;
  180.     procedure DrawText (Down: Boolean); virtual;
  181.     procedure CondDrawState(Down:Boolean);
  182.     function GetPalette: PPalette; virtual;
  183.     procedure HandleEvent(var Event: TEvent); virtual;
  184.     procedure MakeDefault(Enable: Boolean);
  185.     procedure Press; virtual;
  186.     procedure SetState(AState: Word; Enable: Boolean); virtual;
  187.     procedure Store (var S: TStream);
  188.   private
  189.     Pressed: Boolean;
  190.   end;
  191.  
  192. { TGButton object }
  193.  
  194.   { Palette layout }
  195.   { 1 = Background }
  196.   { 2 = Normal sign }
  197.   { 3 = Default sign }
  198.   { 4 = Selected sign }
  199.   { 5 = Disabled sign }
  200.   { 6 = nicht benutzt }
  201.   { 7 = nicht benutzt }
  202.   { 8 = nicht benutzt }
  203.   { 9 = Borders }
  204.   {10 = Lines }
  205.  
  206.   PGButton = ^TGButton;
  207.   TGButton = Object (TButton)
  208.     Sign : Pointer;
  209.     constructor Init (var Bounds: TRect; ASign: Pointer; ACommand: Word;
  210.       AFlags: Word);
  211.     constructor Load (var S: TStream);
  212.     procedure Store (var S: TStream);
  213.     destructor Done; virtual;
  214.     procedure DrawText (Down: Boolean); virtual;
  215.   end;
  216.  
  217. { TRegler object }
  218.  
  219.   { Palette layout }
  220.   { 1 = selected frame }
  221.   { 2 = normal frame }
  222.   { 3 = disabled frame }
  223.   { 4 = background }
  224.  
  225.   PRegler = ^TRegler;
  226.   TRegler = Object (TGView)
  227.     Value:Real;
  228.     Constructor Init (var Bounds:TRect; AMinValue, AMaxValue:Real;
  229.       ABezeichnung, AMinBez, AMidBez, AMaxBez:String);
  230.     destructor Done; virtual;
  231.     constructor Load (var S: TStream);
  232.     Function GetPalette:PPalette; virtual;
  233.     Procedure HandleEvent (Var Event:TEvent); virtual;
  234.     Procedure Draw; virtual;
  235.     Procedure SetState(AState: Word; Enable: Boolean); virtual;
  236.     Procedure SetData (var Rec); virtual;
  237.     Procedure GetData (var Rec); virtual;
  238.     Function DataSize: Word; virtual;
  239.     procedure Store (var S: TStream);
  240.   private
  241.     MinValue, MaxValue, OldValue:Real;
  242.     Bezeichnung, MinBez, MidBez, MaxBez:PString;
  243.     OldY:Word;
  244.     Selected:Boolean;
  245.     Procedure UpDate;
  246.     Function Position (XValue:Real): Integer;
  247.     Function ToValue (XPosition:Integer): Real;
  248.   End;
  249.  
  250. { TSItem record }
  251.  
  252.   PSItem = ^TSItem;
  253.   TSItem = record
  254.     Value: PString;
  255.     Next: PSItem;
  256.   end;
  257.  
  258. { TCluster object }
  259.  
  260.   { Palette layout }
  261.   { 1 = Normal text }
  262.   { 2 = Selected text }
  263.   { 3 = Normal shortcut }
  264.   { 4 = Selected shortcut }
  265.   { 5 = Normal background }
  266.   { 6 = Selected background }
  267.   { 7 = Disabled background }
  268.   { 8 = Disabled text }
  269.  
  270.   PCluster = ^TCluster;
  271.   TCluster = object(TGView)
  272.     Value: LongInt;
  273.     Sel: Integer;
  274.     EnableMask: LongInt;
  275.     Strings: TStringCollection;
  276.     constructor Init(var Bounds: TRect; AStrings: PSItem);
  277.     constructor Load(var S: TStream);
  278.     destructor Done; virtual;
  279.     function ButtonState(Item: Integer): Boolean;
  280.     function DataSize: Word; virtual;
  281.     procedure Draw; virtual;
  282.     procedure DrawItem (Item: Integer; Down: Boolean); virtual;
  283.     procedure GetData(var Rec); virtual;
  284.     function GetHelpCtx: Word; virtual;
  285.     function GetIconNum (Id: Byte): Integer; virtual;
  286.     procedure GetItemRect (Item: Integer; var Extent: TRect); virtual;
  287.     function GetPalette: PPalette; virtual;
  288.     procedure HandleEvent(var Event: TEvent); virtual;
  289.     function Mark(Item: Integer): Boolean; virtual;
  290.     function MultiMark(Item: Integer): Byte; virtual;
  291.     procedure Press(Item: Integer); virtual;
  292.     procedure MovedTo(Item: Integer); virtual;
  293.     procedure SetButtonState(AMask: Longint; Enable: Boolean);
  294.     procedure SetData(var Rec); virtual;
  295.     procedure SetState(AState: Word; Enable: Boolean); virtual;
  296.     procedure Store(var S: TStream);
  297.   end;
  298.  
  299. { TRadioButtons object }
  300.  
  301.   { Palette layout }
  302.   { 1 = Normal text }
  303.   { 2 = Selected text }
  304.   { 3 = Normal shortcut }
  305.   { 4 = Selected shortcut }
  306.   { 5 = Normal background }
  307.   { 6 = Selected background }
  308.   { 7 = Disabled background }
  309.   { 8 = Disabled text }
  310.  
  311.   PRadioButtons = ^TRadioButtons;
  312.   TRadioButtons = object(TCluster)
  313.     function GetIconNum (Id: Byte): Integer; virtual;
  314.     function Mark (Item: Integer): Boolean; virtual;
  315.     procedure MovedTo (Item: Integer); virtual;
  316.     procedure Press (Item: Integer); virtual;
  317.     procedure SetData (var Rec); virtual;
  318.   end;
  319.  
  320. { TCheckBoxes object }
  321.  
  322.   { Palette layout }
  323.   { 1 = Normal text }
  324.   { 2 = Selected text }
  325.   { 3 = Normal shortcut }
  326.   { 4 = Selected shortcut }
  327.   { 5 = Normal background }
  328.   { 6 = Selected background }
  329.   { 7 = Disabled background }
  330.   { 8 = Disabled text }
  331.  
  332.   PCheckBoxes = ^TCheckBoxes;
  333.   TCheckBoxes = object(TCluster)
  334.     function GetIconNum (Id: Byte): Integer; virtual;
  335.     function Mark(Item: Integer): Boolean; virtual;
  336.     procedure Press(Item: Integer); virtual;
  337.   end;
  338.  
  339. { TMultiCheckBoxes object }
  340.  
  341.   { Palette layout }
  342.   { 1 = Normal text }
  343.   { 2 = Selected text }
  344.   { 3 = Normal shortcut }
  345.   { 4 = Selected shortcut }
  346.   { 5 = Normal background }
  347.   { 6 = Selected background }
  348.   { 7 = Disabled background }
  349.   { 8 = Disabled text }
  350.  
  351.   PMultiCheckBoxes = ^TMultiCheckBoxes;
  352.   TMultiCheckBoxes = object(TCluster)
  353.     SelRange: Byte;
  354.     Flags: Word;
  355.     States: Pointer;
  356.     MyData: Boolean;
  357.     constructor Init(var Bounds: TRect; AStrings: PSItem;
  358.       ASelRange: Byte; AFlags: Word; AStates: Pointer);
  359.     constructor Load(var S: TStream);
  360.     destructor Done; virtual;
  361.     procedure DrawItem(Item: Integer; Down: Boolean); virtual;
  362.     function GetIconNum (Id: Byte): Integer; virtual;
  363.     function MultiMark(Item: Integer): Byte; virtual;
  364.     procedure Press(Item: Integer); virtual;
  365.     procedure Store(var S: TStream);
  366.   private
  367.     function GetIcon (Index: Integer): Pointer;
  368.   end;
  369.  
  370. { TListBoxRec Record }
  371.  
  372.   PListBoxRec = ^TListBoxRec;
  373.   TListBoxRec = Record
  374.                   List: PCollection;
  375.                   Index: Integer;
  376.                 End;
  377.  
  378. { TListBox object }
  379.  
  380.   { Palette layout }
  381.   { 1 = Background }
  382.   { 2 = Frame }
  383.   { 3 = Normal Text }
  384.   { 4 = Selected Text }
  385.   { 5 = Normal Background }
  386.   { 6 = Selected Background }
  387.  
  388.   PListBox = ^TListBox;
  389.   TListBox = object(TListViewer)
  390.     List: PCollection;
  391.     constructor Init(var Bounds: TRect; AScrollBar: PScrollBar);
  392.     constructor Load(var S: TStream);
  393.     function DataSize: Word; virtual;
  394.     procedure GetData(var Rec); virtual;
  395.     function GetText(Item: Integer; MaxLen: Integer): String; virtual;
  396.     procedure NewList(AList: PCollection); virtual;
  397.     procedure SetData(var Rec); virtual;
  398.     procedure Store(var S: TStream);
  399.   end;
  400.  
  401. { TStaticText object }
  402.  
  403.   { Palette layout }
  404.   { 1 = Text }
  405.  
  406.   PStaticText = ^TStaticText;
  407.   TStaticText = Object (TGView)
  408.     Text: PString;
  409.     Constructor Init (var Bounds:TRect; AText:String);
  410.     constructor Load (var S: TStream);
  411.     procedure Store (var S: TStream);
  412.     function GetPalette:PPalette; virtual;
  413.     procedure GetText (var S: String); virtual;
  414.     Procedure Draw; virtual;
  415.     Destructor Done; virtual;
  416.   End;
  417.  
  418. { TParamText object }
  419.  
  420.   { Palette layout }
  421.   { 1 = Text }
  422.  
  423.   PParamText = ^TParamText;
  424.   TParamText = object(TStaticText)
  425.     ParamCount: Integer;
  426.     ParamList: Pointer;
  427.     constructor Init(var Bounds: TRect; AText: String; AParamCount: Integer);
  428.     constructor Load(var S: TStream);
  429.     function DataSize: Word; virtual;
  430.     procedure GetText(var S: String); virtual;
  431.     procedure SetData(var Rec); virtual;
  432.     procedure Store(var S: TStream);
  433.   end;
  434.  
  435. { TStaticSign object }
  436.  
  437.   { Palette layout }
  438.   { 1 = Background }
  439.  
  440.   PStaticSign = ^TStaticSign;
  441.   TStaticSign = object (TGView)
  442.     Sign:Pointer;
  443.     Constructor Init (var Bounds:TRect; ASign:Pointer);
  444.     constructor Load (var S: TStream);
  445.     procedure Store (var S: TStream);
  446.     Procedure Draw; virtual;
  447.     function GetPalette: PPalette; virtual;
  448.     Destructor Done; virtual;
  449.   End;
  450.  
  451. { TLabel object }
  452.  
  453.   { Palette layout }
  454.   { 1 = Normal text }
  455.   { 2 = Selected text }
  456.   { 3 = Normal shortcut }
  457.   { 4 = Selected shortcut }
  458.   { 5 = Normal Background }
  459.   { 6 = Selected Background }
  460.  
  461.   PLabel = ^TLabel;
  462.   TLabel = object(TStaticText)
  463.     Link: PGView;
  464.     Light: Boolean;
  465.     constructor Init(var Bounds: TRect; AText: String; ALink: PGView);
  466.     constructor Load(var S: TStream);
  467.     procedure Draw; virtual;
  468.     function GetPalette: PPalette; virtual;
  469.     procedure HandleEvent(var Event: TEvent); virtual;
  470.     procedure Store(var S: TStream);
  471.   end;
  472.  
  473. { TIcon object }
  474.  
  475.   { Palette layout }
  476.   { 1 = Normal Background }
  477.   { 2 = Selected Background }
  478.  
  479.   PIcon = ^TIcon;
  480.   TIcon = object(TStaticSign)
  481.     Link: PGView;
  482.     Light: Boolean;
  483.     constructor Init(var Bounds: TRect; ASign: Pointer; ALink: PGView);
  484.     constructor Load(var S: TStream);
  485.     procedure Draw; virtual;
  486.     function GetPalette: PPalette; virtual;
  487.     procedure HandleEvent(var Event: TEvent); virtual;
  488.     procedure Store(var S: TStream);
  489.   end;
  490.  
  491. { THistoryViewer object }
  492.  
  493.   { Palette layout = TListBox }
  494.  
  495.   PHistoryViewer = ^THistoryViewer;
  496.   THistoryViewer = object(TListViewer)
  497.     HistoryId: Word;
  498.     constructor Init(var Bounds: TRect; AScrollBar: PScrollBar;
  499.        AHistoryId: Word);
  500.     function GetText(Item: Integer; MaxLen: Integer): String; virtual;
  501.     procedure HandleEvent(var Event: TEvent); virtual;
  502.     function HistoryWidth: Integer;
  503.   end;
  504.  
  505. { THistoryWindow object }
  506.  
  507.   { Palette layout = TWindow }
  508.  
  509.   PHistoryWindow = ^THistoryWindow;
  510.   THistoryWindow = object(TWindow)
  511.     Viewer: PListViewer;
  512.     constructor Init(var Bounds: TRect; HistoryId: Word);
  513.     function GetSelection: String; virtual;
  514.     procedure InitViewer(HistoryId: Word); virtual;
  515.   end;
  516.  
  517. { THistory object }
  518.  
  519.   { Palette layout }
  520.   { 1 = Button }
  521.   { 2 = Button shadow }
  522.   { 3 = Button frame }
  523.  
  524.   PHistory = ^THistory;
  525.   THistory = object(TGView)
  526.     Link: PInputLine;
  527.     HistoryId: Word;
  528.     constructor Init(var Bounds: TRect; ALink: PInputLine; AHistoryId: Word);
  529.     constructor Load(var S: TStream);
  530.     procedure Draw; virtual;
  531.     function GetPalette: PPalette; virtual;
  532.     procedure HandleEvent(var Event: TEvent); virtual;
  533.     function InitHistoryWindow(var Bounds: TRect): PHistoryWindow; virtual;
  534.     procedure RecordHistory(S: String); virtual;
  535.     procedure Store(var S: TStream);
  536.   private
  537.     Down: Boolean;
  538.   end;
  539.  
  540. { SItem routines }
  541.  
  542. function NewSItem(Str: String; ANext: PSItem): PSItem;
  543.  
  544. procedure FreeSItem (ASItem: PSItem);
  545.  
  546. { GVDialog registration procedure }
  547.  
  548.   procedure RegisterGVDialog;
  549.  
  550. { GVDialog MouseCursor procedure }
  551.  
  552.   procedure GetGVDialogCursor (n: Integer);
  553.  
  554. { Stream registration records }
  555.  
  556. const
  557.  
  558.   RDialog: TStreamRec = (
  559.     ObjType: 16;
  560.     VmtLink: Ofs(TypeOf(TDialog)^);
  561.     Load: @TDialog.Load;
  562.     Store: @TDialog.Store);
  563.  
  564.   RInputLine: TStreamRec = (
  565.     ObjType: 17;
  566.     VmtLink: Ofs(TypeOf(TInputLine)^);
  567.     Load: @TInputLine.Load;
  568.     Store: @TInputLine.Store);
  569.  
  570.   RArrowField: TStreamRec = (
  571.     ObjType: 18;
  572.     VmtLink: Ofs(TypeOf(TArrowField)^);
  573.     Load: @TArrowField.Load;
  574.     Store: @TArrowField.Store);
  575.  
  576.   RNumInput: TStreamRec = (
  577.     ObjType: 19;
  578.     VmtLink: Ofs(TypeOf(TNumInput)^);
  579.     Load: @TNumInput.Load;
  580.     Store: @TNumInput.Store);
  581.  
  582.   RButton: TStreamRec = (
  583.     ObjType: 20;
  584.     VmtLink: Ofs(TypeOf(TButton)^);
  585.     Load: @TButton.Load;
  586.     Store: @TButton.Store);
  587.  
  588.   RGButton: TStreamRec = (
  589.     ObjType: 21;
  590.     VmtLink: Ofs(TypeOf(TGButton)^);
  591.     Load: @TGButton.Load;
  592.     Store: @TGButton.Store);
  593.  
  594.   RRegler: TStreamRec = (
  595.     ObjType: 22;
  596.     VmtLink: Ofs(TypeOf(TRegler)^);
  597.     Load: @TRegler.Load;
  598.     Store: @TRegler.Store);
  599.  
  600.   RCluster: TStreamRec = (
  601.     ObjType: 23;
  602.     VmtLink: Ofs(TypeOf(TCluster)^);
  603.     Load: @TCluster.Load;
  604.     Store: @TCluster.Store);
  605.  
  606.   RRadioButtons: TStreamRec = (
  607.      ObjType: 24;
  608.      VmtLink: Ofs(TypeOf(TRadioButtons)^);
  609.      Load:    @TRadioButtons.Load;
  610.      Store:   @TRadioButtons.Store);
  611.  
  612.   RCheckBoxes: TStreamRec = (
  613.      ObjType: 25;
  614.      VmtLink: Ofs(TypeOf(TCheckBoxes)^);
  615.      Load:    @TCheckBoxes.Load;
  616.      Store:   @TCheckBoxes.Store);
  617.  
  618.   RMultiCheckBoxes: TStreamRec = (
  619.      ObjType: 26;
  620.      VmtLink: Ofs(TypeOf(TMultiCheckBoxes)^);
  621.      Load:    @TMultiCheckBoxes.Load;
  622.      Store:   @TMultiCheckBoxes.Store);
  623.  
  624.   RListBox: TStreamRec = (
  625.     ObjType: 27;
  626.     VmtLink: Ofs(TypeOf(TListBox)^);
  627.     Load: @TListBox.Load;
  628.     Store: @TListBox.Store);
  629.  
  630.   RStaticText: TStreamRec = (
  631.     ObjType: 28;
  632.     VmtLink: Ofs(TypeOf(TStaticText)^);
  633.     Load: @TStaticText.Load;
  634.     Store: @TStaticText.Store);
  635.  
  636.   RParamText: TStreamRec = (
  637.     ObjType: 29;
  638.     VmtLink: Ofs(TypeOf(TParamText)^);
  639.     Load: @TParamText.Load;
  640.     Store: @TParamText.Store);
  641.  
  642.   RStaticSign: TStreamRec = (
  643.     ObjType: 30;
  644.     VmtLink: Ofs(TypeOf(TStaticSign)^);
  645.     Load: @TStaticSign.Load;
  646.     Store: @TStaticSign.Store);
  647.  
  648.   RLabel: TStreamRec = (
  649.     ObjType: 31;
  650.     VmtLink: Ofs(TypeOf(TLabel)^);
  651.     Load: @TLabel.Load;
  652.     Store: @TLabel.Store);
  653.  
  654.   RIcon: TStreamRec = (
  655.     ObjType: 32;
  656.     VmtLink: Ofs(TypeOf(TIcon)^);
  657.     Load: @TIcon.Load;
  658.     Store: @TIcon.Store);
  659.  
  660.   RHistory: TStreamRec = (
  661.     ObjType: 33;
  662.     VmtLink: Ofs(TypeOf(THistory)^);
  663.     Load: @THistory.Load;
  664.     Store: @THistory.Store);
  665.  
  666. implementation
  667.