const
  FACILITY_PROGRAM = $F;

  { Sent when hold is added.

    Remarks: this is not sent to plug-ins and used internally to update undo/redo lists. }
  NOTIFY_PROGRAM_HOLD = HEVENT($000F0010);

  { Sent when mode is changed.
    CallParam is BOOL value:
    • The value TRUE hints plug-ins to start its any work.
    • The value FALSE hints plug-ins to stop its any work. }
  NOTIFY_PROGRAM_MODE = HEVENT($000F0011);

  { Sent when plug-in is loaded.
    CallParam is IPlugin interface:
    • Already registered actual plug-ins may query other interfaces from it for own purposes. }
  NOTIFY_PROGRAM_PLUGIN = HEVENT($000F0012);

  { Sent when modified is updated.

    Remarks: this is not sent to plug-ins and used internally to control * in a scene's name. }
  NOTIFY_PROGRAM_MODIFY = HEVENT($000F0013);

  { Sent when New operation is performed.
    CallParam is empty.
    • The notification hints plug-ins to reset its any data. }
  NOTIFY_PROGRAM_NEW = HEVENT($000F0020);

  { Sent when Open operation is performed.
    CallParam is IStream interface.
    • Loading file from disk, hints plug-ins to load its any data from this stream. }
  NOTIFY_PROGRAM_OPEN = HEVENT($000F0021);

  { Sent when Save operation is performed.
    CallParam is IStream interface.
    • Saving file to disk, hints plug-ins to save its any data to this stream. }
  NOTIFY_PROGRAM_SAVE = HEVENT($000F0022);

  { Sent when Undo operation is performed.

    Remarks: UNDEFINED YET. }
  NOTIFY_PROGRAM_UNDO = HEVENT($000F0023);

  { Sent when Redo operation is performed.

    Remarks: UNDEFINED YET. }
  NOTIFY_PROGRAM_REDO = HEVENT($000F0024);

  { Sent when Project Folder button is clicked.
    CallParam is empty.
    • This is the "Project Folder" button that has no implementation. }
  NOTIFY_PROGRAM_PROJ = HEVENT($000F0025);

  { Sent when file params are required.
    CallParam is PProgramFile structure pointer.
    • Used in open/save dialogs. Note that only the first extension passed to Filter is used. }
  NOTIFY_PROGRAM_FILE = HEVENT($000F0026);

  { Sent when Search Help is performed.

    Remarks: UNDEFINED YET. }
  NOTIFY_PROGRAM_HELP = HEVENT($000F0027);

  { Sent when a hint string is required.
    CallParam is PWideString pointer.
    • Used in the "Project Folder" button. }
  NOTIFY_PROGRAM_HINT = HEVENT($000F0028);

type
  PProgramFile = ^TProgramFile;
  TProgramFile = record
    Title  : WideString;
    Filter : WideString;
  end;

  PProgramHelp = ^TProgramHelp;
  TProgramHelp = record
    Keyword  : WideString;
    Found    : WideString;
    HelpFile : WideString;
  end;

type
  IHold = interface;
  IRestoreObj = interface;
  TRestoreObjProc = procedure (const Data:IInterface) of object;

  IProgram = interface
  ['{1A01E0DC-51AB-43D1-99FC-D0B5BCD4CE3D}']
    function Handle:THandle;
    function Mode:TGUID;
    function Modified(const Make:BOOL=True):BOOL;
    procedure New;
    procedure Open;
    procedure Save;
    procedure SaveAs;
    function Undo(const Count:Integer;const Execute:BOOL):BOOL;
    function Redo(const Count:Integer;const Execute:BOOL):BOOL;
    procedure Shutdown;
    function Hold(const Proc:TRestoreObjProc):IHold;
    function Message(const Text:WideString;const Flags:DWORD):Integer;
  end;

  //UNDEFINED YET
  IHolding = interface
  ['{800EFAB5-B286-4439-9D34-865161B6EF14}']
    function Hold(const Proc:TRestoreObjProc):IHold;
  end;

  IHold = interface
  ['{54BAA75C-BF45-4B4A-97E4-6A52B3E7FDBA}']
    procedure Accept(const Name:WideString;const Data:IInterface);
    procedure Cancel;
  end;

  //UNDEFINED YET
  IRestoreObj = interface
  ['{17703F5D-7836-4ADB-98DB-20D597F888AA}']
    function Holding:Byte;
    function Name:WideString;
    procedure Restore;
  end;

  TPluginFunc = function:IInterface;
  IPlugin = interface
  ['{C800BE91-C6CF-4F95-B4B5-18CC7B08D298}']
    function ClassName:WideString;
    function ClassInfo:WideString;
    function ClassGuid:TGUID;
  end;

  IPluginMode = interface
  ['{45BFBB9A-C9FF-48EA-9236-E6C530E1F0A1}']
    procedure Place(const Handle:THandle);
    procedure Placement(const Left,Top,Height,Width:Integer);
    procedure Activate;   //does not work?
    procedure Deactivate; //does not work?
    procedure Notify(const Event:HEVENT;const CallParam:Pointer);
  end;

function _IProgram:IProgram;external 'Program.exe';

  TProgram = class(TInterfacedObject, IProgram, IPlugin)
  public type

    THold = class(TInterfacedObject, IHold, IRestoreObj)
    strict private
      FName : WideString;
      FData : IInterface;
      FProc : TRestoreObjProc;
      FPuts : IVector<IRestoreObj>;
      FEdit : Int64;
      FFlag : Byte;
    public
      constructor Create(const Proc:TRestoreObjProc;const Edit:Int64);
      procedure Accept(const Name:WideString;const Data:IInterface);
      procedure Cancel;
      function Holding:Byte;
      function Name:WideString;
      procedure Restore;
    end;

    TPlugin = class
    strict private
      FPlugin  : IPlugin;
      FModule  : HMODULE;
      FModFull : WideString;
      FModPath : WideString;
      FModName : WideString;
      FName    : WideString;
      FInfo    : WideString;
      FGuid    : TGUID;
      FMode    : IPluginMode;
    public
      constructor Create(const Module:HMODULE;const Plugin:IPlugin);
      destructor Destroy;override;
      procedure Place(const Handle:THandle);
      procedure Placement(const Left,Top,Height,Width:Integer);
      procedure Activate;
      procedure Deactivate;
      procedure Notify(const Event:HEVENT;const CallParam:Pointer);
      property ModFull:WideString read FModFull;
      property ModPath:WideString read FModPath;
      property ModName:WideString read FModName;
      property Name:WideString read FName;
      property Info:WideString read FInfo;
      property Guid:TGUID read FGuid;
    end;

  strict private
    FNotify       : INotify;
    FIDs          : IVector<TGUID>;
    FCurrent      : TPlugin;
    FModes        : IVector<TPlugin>;
    FPlugins      : IVector<TPlugin>;
    FHolding      : IVector<IRestoreObj>;
    FHistory      : IHistory<IRestoreObj>;
    FScene        : WideString;
    FSaveDialog   : BOOL;
    FSaveRequired : BOOL;
  strict private
    class constructor Create;
    class destructor Destroy;
    function ClassName:WideString;
    function ClassInfo:WideString;
    function ClassGuid:TGUID;
  protected
    function _AddRef:Integer;stdcall;
    function _Release:Integer;stdcall;
    function GetScene(const FileName,Filter:WideString):WideString;
  public
    constructor Create;
    destructor Destroy;override;
    procedure ChangeMode(const ID:TGUID);
    procedure LoadPlugin(const FileName,FuncName:WideString);
    function Handle:THandle;
    function Mode:TGUID;
    function Modified(const Make:BOOL=True):BOOL;
    procedure Shutdown;
    function Hold(const Proc:TRestoreObjProc):IHold;
    procedure New;
    procedure Open;
    procedure Save;
    procedure SaveAs;
    function Undo(const Count:Integer;const Execute:BOOL):BOOL;
    function Redo(const Count:Integer;const Execute:BOOL):BOOL;
    function Message(const Text:WideString;const Flags:DWORD):Integer;
    procedure Broadcast(const Event:HEVENT;const CallParam:Pointer);
    procedure Register(const Event:HEVENT;const Param:NativeUInt;const Proc:TNotifyProc);
    procedure Unregister(const Event:HEVENT;const Param:NativeUInt;const Proc:TNotifyProc);
    procedure Subscribe(const Facility:Word;const Param:NativeUInt;const Proc:TNotifyProcEx);
    procedure Unsubscribe(const Facility:Word;const Param:NativeUInt;const Proc:TNotifyProcEx);
    property Current:TPlugin read FCurrent;
    property Modes:IVector<TPlugin> read FModes;
    property Plugins:IVector<TPlugin> read FPlugins;
    property History:IHistory<IRestoreObj> read FHistory;
    property Scene:WideString read FScene;
  end;

const
  Prog : TProgram = nil;

implementation

uses
  FMode, FReport, FReport2;

{$REGION 'TProgram'}
class constructor TProgram.Create;
begin
PPointer(@Prog)^ := TProgram.Create;
end;

class destructor TProgram.Destroy;
begin
MIFreeAndNil(PPointer(@Prog)^);
end;

function TProgram.ClassName:WideString;
begin
Result := 'PROGRAM';
end;

function TProgram.ClassInfo:WideString;
begin
Result := '';
end;

function TProgram.ClassGuid:TGUID;
begin
Result := IProgram;
end;

constructor TProgram.Create;
begin

{ Constructing. }
FNotify := _INotify;
FIDs := IVector<TGUID>(_IVector(_IT(TYPE_GUID)));
FModes := IVector<TPlugin>(_IVector(_IT(TYPE_CLASS)));
FPlugins := IVector<TPlugin>(_IVector(_IT(TYPE_CLASS)));
FHolding := IVector<IRestoreObj>(_IVector(_IT(TYPE_INTF)));
FHistory := IHistory<IRestoreObj>(_IHistory(_IT(TYPE_INTF)));

{ Making standard mode. }
FIDs.Add(IProgram);
FCurrent := FModes[FModes.Add(TPlugin.Create(HInstance,Self as IPlugin))];
end;

destructor TProgram.Destroy;
var
I : NativeInt;
P : TPlugin;
begin

{ Removing plug-ins. }
for I := FPlugins.Count-1 downto 0 do
begin
  P := FPlugins.Extract(I);
  FPlugins.Remove(P);
  P.Free;
end;

{ Setting current mode in zero position. }
FModes.Exchange(0,FModes.IndexOf(FCurrent));

{ Removing mode plug-ins. }
for I := FModes.Count-1 downto 0 do
  FModes.Extract(I).Free;

FCurrent := nil;
end;

function TProgram._AddRef:Integer;
begin
Result := -1;
end;

function TProgram._Release:Integer;
begin
Result := -1;
end;

function TProgram.GetScene(const FileName,Filter:WideString):WideString;
var
Extension : WideString;
begin
Extension := MIFileExtW(Filter);
if MISameText(MIFileExtW(FileName), Extension) then
  Result := FileName else
  Result := FileName + Extension;
end;

procedure TProgram.ChangeMode(const ID:TGUID);
var
M : TPlugin;
begin
if FCurrent.Guid <> ID then
  for M in FModes do
    if M.Guid = ID then
      if Modified(False) then
      begin
        Broadcast(NOTIFY_PROGRAM_MODE,Pointer(BOOL(False)));

        FScene := '';
        FSaveRequired := False;
        FCurrent := M;
        FHistory.Delete;
        FHolding.Clear;

        Broadcast(NOTIFY_PROGRAM_MODE,Pointer(BOOL(True)));
        Break;
      end
      else
        Break;
end;

procedure TProgram.LoadPlugin(const FileName,FuncName:WideString);
var
P      : TPlugin;
ID     : TGUID;
Module : HMODULE;
Plugin : IPlugin;
begin
Module := LoadLibrary(PWideChar(FileName));
if Module <> 0 then
try
  { Rapid approach. }
  if TPluginFunc(GetProcAddress(Module,PWideChar(FuncName))).QueryInterface(IPlugin,Plugin) <> S_OK then
  begin
    FreeLibrary(Module);
    Exit;
  end;

  P := TPlugin.Create(Module,Plugin);
  ID := P.Guid;

  { Looking for plug-in id duplicates. }
  if FIDs.Contains(ID) then
  begin
    MessageBox(Application.MainFormHandle,
      PWideChar('Plug-in '+MIGuidToStrW(ID,'<')+' from <'+MIFileNameW(FileName)+
      '> has duplicate plug-in ID: not loading.'),PWideChar('Error Loading Plug-In'),
      MB_OK or MB_ICONWARNING or MB_TOPMOST or MB_SETFOREGROUND);
    FreeLibrary(Module);
    Exit;
  end;

except
  MessageBox(GetDesktopWindow,
    PWideChar('Failed to load plug-in from <'+MIFileNameW(FileName)+'>.'),
    PWideChar('Error Loading Plug-In'),
    MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND);
  if Module <> 0 then
    FreeLibrary(Module);
  Exit;
end else
begin
  MessageBox(GetDesktopWindow,
    PWideChar('Could not load module <'+MIFileNameW(FileName)+'>.'),
    PWideChar('Error Loading DLL'),
    MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND);
  Exit;
end;

{ Registering. }
FIDs.Add(ID);

if MISupports(Plugin,IPluginMode) then
  FModes.Add(P) else
  FPlugins.Add(P);

Broadcast(NOTIFY_PROGRAM_PLUGIN,Pointer(Plugin));
end;

function TProgram.Handle:THandle;
begin
Result := Application.Handle;
end;

function TProgram.Mode:TGUID;
begin
Result := FCurrent.Guid;
end;

function TProgram.Modified(const Make:BOOL=True):BOOL;
begin
if Make then
begin
  Result := FSaveRequired;
  if not FSaveRequired then
  begin
    FSaveRequired := True;
    Broadcast(NOTIFY_PROGRAM_MODIFY,Pointer(BOOL(True)));
  end;
end else
begin
  if FSaveRequired then
    case Message('The scene has been modified.'+#13#10+'Do you want to save your changes?',MB_YESNOCANCEL or MB_ICONQUESTION or MB_TOPMOST) of
    ID_YES:
      begin
        Save;
        Result := not FSaveRequired;
      end;
    ID_NO:  Result := True;
    else    Result := False;
    end
  else Result := True;
end;
end;

procedure TProgram.Shutdown;
begin
Application.MainForm.Close;
end;

function TProgram.Hold(const Proc:TRestoreObjProc):IHold;
begin
Modified;
Result := FHolding[FHolding.Add(THold.Create(Proc,FHolding.Count) as IRestoreObj)] as IHold;
end;

procedure TProgram.New;
begin
if FSaveRequired then
begin
  case Message('The scene has been modified.'+#13#10+'Do you want to save your changes?',MB_YESNOCANCEL or MB_ICONQUESTION or MB_TOPMOST) of
  ID_YES:
    begin
      Save;
      if FSaveRequired then
        Exit;
    end;
  ID_NO:  FSaveDialog := False;
  else    Exit;
  end;
end;
FScene := '';
FSaveRequired := False;
Broadcast(NOTIFY_PROGRAM_NEW,nil);
end;

procedure TProgram.Open;
var
Dlg    : TProgramFile;
Stream : IStreamMemory;
begin

{ Save confirm. }
if FSaveRequired then
begin
  case Message('The scene has been modified.'+#13#10+'Do you want to save your changes?',MB_YESNOCANCEL or MB_ICONQUESTION or MB_TOPMOST) of
  ID_YES: Save;
  ID_NO:  FSaveDialog := False;
  else    Exit;
  end;
  if FSaveDialog then
    Exit;
end;

{ Requesting title and filter for open/save dialogs. }
Dlg.Title := 'File';
Broadcast(NOTIFY_PROGRAM_FILE,@Dlg);
with TOpenDialog.Create(nil) do
try

  { Building. }
  Options := Options + [ofPathMustExist, ofFileMustExist];
  Title := 'Open ' + Dlg.Title;
  Filter := Dlg.Filter;
  FileName := FScene;

  { Reexecute until break. }
  while True do
    if Execute(Application.MainFormHandle) and (FileName <> '') then
      if Succeeded(MIFileExists(FileName)) then
      begin
        New;
        FScene := FileName;
        Stream := _IStreamMemory;
        if Succeeded(Stream.Load(FileName)) then
          Broadcast(NOTIFY_PROGRAM_OPEN,Pointer(Stream)) else
          Message('Access denined.', MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND);
        Break;
      end else Message('File '+FileName+' not found.'+#13#10+'Please verify that the correct file name was given.',MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND)
    else Break;
finally
  Free;
end;

end;

procedure TProgram.Save;
begin
if (FScene <> '') and not MIDirExists(MIFilePathW(FScene)) then
begin
  FSaveDialog := True;
  MessageBox(Application.MainFormHandle,PWideChar('Path '+MIFilePathW(Scene)+' is missing.'),'Attention',MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND);
end else
  FSaveDialog := Failed(MIFileExists(FScene));
if FSaveDialog then SaveAs;
end;

procedure TProgram.SaveAs;
var
Dlg     : TProgramFile;
Stream  : IStreamMemory;
Aborted : BOOL;
begin

Aborted := True;

{ Requesting title and filter for open/save dialogs. }
Dlg.Title := 'File';
Broadcast(NOTIFY_PROGRAM_FILE,@Dlg);

with TSaveDialog.Create(nil) do
try

  { Building. }
  Options := Options + [ofPathMustExist];
  Title := 'Save ' + Dlg.Title;
  Filter := Dlg.Filter;
  FileName := MIFileNameW(FScene);

  { Reexecute until break. }
  while True do
    if Execute(Application.MainFormHandle) and (FileName <> '') then
    begin
      if Succeeded(MIFileExists(FileName)) then
        case Message(FileName+' already exists.'+#13#10+'Do you want to replace it?',MB_YESNO or MB_ICONWARNING or MB_TOPMOST or MB_SETFOREGROUND) of
        ID_YES: ;
        ID_NO:
          begin
            FileName := MIFileNameW(FileName);
            Continue;
          end;
        else    Break;
        end;
      FScene := GetScene(FileName,Dlg.Filter);
      Aborted := False;
      Break;
    end else Break;

finally
  Free;
end;

if Aborted then
  Exit;

{ Saving. }
Stream := _IStreamMemory;
Broadcast(NOTIFY_PROGRAM_SAVE,Pointer(Stream));
if Succeeded(Stream.Save(FScene)) then
begin
  FSaveRequired := False;
  Broadcast(NOTIFY_PROGRAM_MODIFY,Pointer(BOOL(False)));
end else
begin
  FSaveRequired := True;
  Broadcast(NOTIFY_PROGRAM_MODIFY,Pointer(BOOL(True)));
  Message('Access denied.',MB_OK or MB_ICONERROR or MB_TOPMOST or MB_SETFOREGROUND);
end;
end;

function TProgram.Undo(const Count:Integer;const Execute:BOOL):BOOL;
begin
Result := (Count > 0) and (Count <= FHistory.Undo.Count);
if Result and Execute then
  Broadcast(NOTIFY_PROGRAM_UNDO,Pointer(Count));
end;

function TProgram.Redo(const Count:Integer;const Execute:BOOL):BOOL;
begin
Result := (Count > 0) and (Count <= FHistory.Redo.Count);
if Result and Execute then
  Broadcast(NOTIFY_PROGRAM_UNDO,Pointer(Count));
end;

function TProgram.Message(const Text:WideString;const Flags:DWORD):Integer;
begin Result := MessageBox(Application.MainFormHandle,PWideChar(Text), PWideChar(FCurrent.Name),Flags)end;

procedure TProgram.Broadcast(const Event:HEVENT;const CallParam:Pointer);
begin FNotify.Broadcast(Event,CallParam);end;

procedure TProgram.Register(const Event:HEVENT;const Param:NativeUInt;const Proc:TNotifyProc);
begin FNotify.Register(Event,Param,Proc);end;

procedure TProgram.Unregister(const Event:HEVENT;const Param:NativeUInt;const Proc:TNotifyProc);
begin FNotify.Unregister(Event,Param,Proc);end;

procedure TProgram.Subscribe(const Facility:Word;const Param:NativeUInt;const Proc:TNotifyProcEx);
begin FNotify.Subscribe(Facility,Param,Proc);end;

procedure TProgram.Unsubscribe(const Facility:Word;const Param:NativeUInt;const Proc:TNotifyProcEx);
begin FNotify.Unsubscribe(Facility,Param,Proc);end;
{$ENDREGION}

{$REGION 'TProgram.THold'}
constructor TProgram.THold.Create(const Proc:TRestoreObjProc;const Edit:Int64);
begin
FProc := Proc;
FEdit := Edit;
end;

procedure TProgram.THold.Accept(const Name:WideString;const Data:IInterface);
var
i : NativeInt;
r : IRestoreObj;
begin

{ Multiple accepting is not allowed. }
if FFlag > 0 then
  Exit;

{ Assigning information about this hold. }
FName := Name;
FData := Data;
FFlag := 1;

{ Super / Simple hold. }
if FEdit > 0 then
  Exit;

with Prog do
begin
  FPuts := IVector<IRestoreObj>(_IVector(_IT(TYPE_INTF)));
  for i := 0 to FHolding.Count-1 do
  begin
    r := FHolding[i];
    if r.Holding = 1 then
      FPuts.Add(r);
  end;
  FHistory.Store(Self as IRestoreObj);
  FHolding.Clear;
  Broadcast(NOTIFY_PROGRAM_HOLD,nil);
end;
end;

procedure TProgram.THold.Cancel;
var
i : NativeInt;
begin

{ Multiple canceling is not allowed. }
if FFlag = 2 then
  Exit;
with Prog do
  for i := FHolding.Count-1 downto FEdit do
    FHolding.Extract(i).Restore;
FFlag := 2;
end;

function TProgram.THold.Holding:Byte;
begin
Result := FFlag;
end;

function TProgram.THold.Name:WideString;
begin
Result := FName;
end;

procedure TProgram.THold.Restore;
var
I : NativeInt;
begin
{ Super hold. }
if Assigned(FPuts) then
  for I := 0 to FPuts.Count-1 do
    FPuts[I].Restore
else
{ Simple hold. }
if (FFlag = 1) and Assigned(FProc) then
  FProc(FData);
end;
{$ENDREGION}

{$REGION 'TProgram.TPlugin'}
constructor TProgram.TPlugin.Create(const Module:HMODULE;const Plugin:IPlugin);
begin
{ Module. }
FModule := Module;
SetLength(FModFull,MAX_PATH);
SetLength(FModFull,GetModuleFileName(Module,PWideChar(FModFull),MAX_PATH));
MIFilePathNtW(FModFull,FModPath);
MIFileNameNtW(FModFull,FModName);

{ Plugin. }
FPlugin := Plugin;
FName := FPlugin.ClassName;
FInfo := FPlugin.ClassInfo;
FGuid := FPlugin.ClassGuid;
if FPlugin.QueryInterface(IPluginMode,FMode) <> S_OK then FMode := nil;
end;

destructor TProgram.TPlugin.Destroy;
begin

end;

procedure TProgram.TPlugin.Place(const Handle:THandle);
begin
if Assigned(FMode) then
try
  FMode.Place(Handle);
except

end;
end;

procedure TProgram.TPlugin.Placement(const Left,Top,Height,Width:Integer);
begin
if Assigned(FMode) then
try
  FMode.Placement(Left,Top,Height,Width);
except

end;
end;

procedure TProgram.TPlugin.Activate;
begin
if Assigned(FMode) then
try
  FMode.Activate;
except

end;
end;

procedure TProgram.TPlugin.Deactivate;
begin
if Assigned(FMode) then
try
  FMode.Deactivate;
except

end;
end;

procedure TProgram.TPlugin.Notify(const Event:HEVENT;const CallParam:Pointer);
begin
if Assigned(FMode) then
try
  FMode.Notify(Event,CallParam);
except

end;
end;
{$ENDREGION}

function _IProgram:IProgram;
begin Result := Prog as IProgram;end;

exports
_IProgram;

procedure TMain.WndProg(const Event:HEVENT;const Param:NativeUInt;const CallParam:Pointer);
var
M : TProgram.TPlugin;
H : WideString;
V : Boolean;
I : Integer;
begin
case Event of
NOTIFY_PROGRAM_MODE:
begin
  if BOOL(CallParam) then
  begin
    { In "PROGRAM" (standard) mode no quick access controls appear by design. Empty mode. }
    V := Prog.Mode <> IProgram;
    QATNew.Visible := V;
    QATOpen.Visible := V;
    QATSave.Visible := V;
    QATUndo.Visible := V;
    QATUndoArrow.Visible := V;
    QATRedo.Visible := V;
    QATRedoArrow.Visible := V;
    QATProj.Visible := V;
    QATMode.Visible := True;
    Menu.Visible := not V;
    Platform.Visible := V;
    if not V then
    begin
      QATL.Constraints.MaxWidth := 17;
      NcCaption := '';
      NcDocument := '';
    end else
    begin
      Prog.Current.Notify(NOTIFY_PROGRAM_HINT,@H);
      QATProj.Hint := H;
      QATL.Constraints.MaxWidth := 185;
      NcCaption := Prog.Current.Name;
      NcDocument := 'Untitled';
    end;
    Resize;
    Repaint;
  end else
  begin
    FUndo.Tree.Items.Clear;
    FRedo.Tree.Items.Clear;
    with Screen do
      for I := 0 to FormCount-1 do
        if Forms[I].InheritsFrom(TPopup) then
          Forms[I].Hide;
    Prog.Current.Place(0);
  end;
  Prog.Current.Notify(NOTIFY_PROGRAM_MODE,CallParam);
end;
NOTIFY_PROGRAM_PLUGIN:
  begin
    for M in Prog.Modes do
      M.Notify(NOTIFY_PROGRAM_PLUGIN,CallParam);
  end;
NOTIFY_PROGRAM_MODIFY:
  begin
    I := Length(NcDocument);
    if BOOL(CallParam) and ((I = 0) or (NcDocument[1] <> '*')) then
      NcDocument := '*' + NcDocument  else
    if not BOOL(CallParam) and (I > 0) and (NcDocument[1] = '*') then
      if I = 1 then
        NcDocument := '' else
        NcDocument := Copy(NcDocument,2,I-1);
    Resize;
  end;
NOTIFY_PROGRAM_NEW:
  begin
    NcDocument := 'Untitled';
    Resize;
    Prog.Current.Notify(NOTIFY_PROGRAM_NEW,CallParam);
  end;
NOTIFY_PROGRAM_OPEN:
  begin
    NcDocument := MIFileNameW(Prog.Scene);
    Resize;
    Prog.Current.Notify(NOTIFY_PROGRAM_OPEN,CallParam);
  end;
NOTIFY_PROGRAM_SAVE:
  begin
    NcDocument := MIFileNameW(Prog.Scene);
    Resize;
    Prog.Current.Notify(NOTIFY_PROGRAM_SAVE,CallParam);
  end;
NOTIFY_PROGRAM_UNDO:
  begin
    Revert(FUndo,Integer(CallParam));
  end;
NOTIFY_PROGRAM_REDO:
  begin
    Revert(FRedo,Integer(CallParam));
  end;
NOTIFY_PROGRAM_FILE:
  begin
    Prog.Current.Notify(NOTIFY_PROGRAM_FILE,CallParam);
  end;
end;
end;

procedure TPlugin.Notify(const Event:HEVENT;const CallParam:Pointer);
var
PFile : PProgramFile absolute CallParam;
begin
case Event of
NOTIFY_PROGRAM_MODE:
  begin
    if BOOL(CallParam) then
    begin
      //Resume
    end else
    begin
      //Suspend
    end;
  end;
NOTIFY_PROGRAM_NEW:
  begin
    //Nothing to reset yet
  end;
NOTIFY_PROGRAM_OPEN:
  begin
    //Nothing to load yet
  end;
NOTIFY_PROGRAM_SAVE:
  begin
    //Nothing to save yet
  end;
NOTIFY_PROGRAM_PROJ:
  begin
    Prog.Modified(True); //just for fun, putting scene into modified state so
                         //user is asked about saving
  end;
NOTIFY_PROGRAM_FILE:
  begin
    PFile.Title := 'Sql scene';
    PFile.Filter := 'Sql scene|*.sqlscene';
  end;
NOTIFY_PROGRAM_HINT:
  begin
    PWideString(CallParam)^ := 'Sql Forum.';
  end;
end;
end;

procedure TSql.ManagerExecute(Action: TBasicAction; var Handled: Boolean);
var
A : TAction;
begin
try
  Handled := Assigned(Action) and (Action is TAction);
  if not Handled then Exit;
  A := Action as TAction;
except
  Handled := False;
  Exit;
end;
if A = actNew then
  Prog.New else
if A = actOpen then
  Prog.Open else
if A = actSave then
  Prog.Save else
if A = actSaveAs then
  Prog.SaveAs else
if A = actExit then
  Prog.Shutdown else
if A = actUndo then
  Prog.Undo(1,True) else
if A = actRedo then
  Prog.Redo(1,True)
else
  Handled := False;
end;

procedure TSql.ManagerUpdate(Action: TBasicAction; var Handled: Boolean);
var
A : TAction;
begin
try
  Handled := Assigned(Action) and (Action is TAction);
  if not Handled then Exit;
  A := Action as TAction;
except
  Handled := False;
  Exit;
end;
if Action = actNew then
  A.Enabled := True else
if Action = actOpen then
  A.Enabled := True else
if Action = actSave then
  A.Enabled := True else
if Action = actSaveAs then
  A.Enabled := True else
if A = actExit then
  A.Enabled := True else
if A = actUndo then
  A.Enabled := Prog.Undo(1,False) else
if A = actRedo then
  A.Enabled := Prog.Redo(1,False)
else
  Handled := False;
end;