source: trunk/Packages/Kernel/Kernel.Core.pas

unit Kernel.Core;

interface

uses
  Classes, SysUtils, Kernel.List, Kernel.FileSystem, Kernel.Memory,
  Kernel.Screen, Kernel.Device, Kernel.App, Kernel.Scheduler, Kernel.Api,
  Kernel.Graphics, Generics.Collections, Kernel.IPC;

type
  { TDrive }

  TDrive = class(TNamedObject)
    FileSystem: TFileSystem;
    constructor Create;
    destructor Destroy; override;
  end;

//  TTimer = class
//    Period: TDateTime;
//  end;

  { TKernel }

  TKernel = class
  private
    Api: TSystemApi;
    procedure InitVideo;
    function KernelApiExecute(Command: TApiCommand; Data: Pointer): Pointer;
  public
    Apps: TNamedObjects<TApp>;
    Drives: TNamedObjects<TDrive>;
    Scheduler: TScheduler;
    SchedulerClass: TSchedulerClass;
    FileSystemClass: TFileSystemClass;
    Devices: TNamedObjects<TDevice>;
    Screens: TObjectList<TScreen>;
    Desktop: TDesktop;
    procedure AppExecute(AFile: TFile);
    procedure Init;
    procedure Run;
    procedure Terminate;
    constructor Create;
    destructor Destroy; override;
  end;


implementation

uses
  Kernel.KernelAPI;

{ TDrive }

constructor TDrive.Create;
begin
end;

destructor TDrive.Destroy;
begin
  FreeAndNil(FileSystem);
  inherited;
end;

{ TKernel }

procedure TKernel.InitVideo;
var
  NewScreen: TScreen;
  VideoDevice: TDeviceVideo;
  VideoMode: TVideoMode;
  Modes: TVideoModes;
begin
  VideoDevice := TDeviceVideo(Devices.FindByName('Video0'));
  if Assigned(VideoDevice) then begin
    NewScreen := TScreen.Create;
    Modes := TVideoModes.Create;
    VideoDevice.GetSupportedModes(Modes);
    if Modes.Count > 0 then begin
      VideoMode := TVideoMode(Modes.Last);
      VideoDevice.VideoMode := VideoMode;
      NewScreen.Size := VideoMode.Size;
      NewScreen.ColorFormat := VideoMode.ColorFormat;
      NewScreen.Device := VideoDevice;
      NewScreen.Canvas := TScreenCanvas.Create;
      TScreenCanvas(NewScreen.Canvas).Screen := NewScreen;
      Screens.Add(NewScreen);
      Desktop.ParentCanvas := Screens.First.Canvas;
    end;
    Modes.Free;
  end;
end;

function TKernel.KernelApiExecute(Command: TApiCommand;
  Data: Pointer): Pointer;
begin
  Result := Api.Call(Command, Data);
end;

procedure TKernel.AppExecute(AFile: TFile);
var
  App: TApp;
begin
  App := TApp(Apps.FindByName(AFile.Name));
  if Assigned(App) then begin
    App.API.KernelApiCallback := KernelApiExecute;
    Scheduler.AddTask(App.Name, App.Run);
  end else raise Exception.Create('Application ''' + AFile.Name + ''' no found');
end;

procedure TKernel.Init;
var
  NewDrive: TDrive;
  NewFile: TFile;
begin
  Scheduler.Free;
  Scheduler := SchedulerClass.Create;

  NewDrive := TDrive.Create;
  NewDrive.Name := 'System';
  NewDrive.FileSystem := FileSystemClass.Create;
  Drives.Add(NewDrive);

  NewFile := TFile.Create;
  NewFile.Name := 'Clock';
  NewDrive.FileSystem.TopDirectory.Items.Add(NewFile);

  NewFile := TFile.Create;
  NewFile.Name := 'Clock2';
  NewDrive.FileSystem.TopDirectory.Items.Add(NewFile);
  InitVideo;
end;

procedure TKernel.Run;
var
  SystemDrive: TDrive;
  SystemFileSystem: TFileSystem;
  AppFile: TFile;
begin
  Init;
  SystemDrive := TDrive(Drives.FindByName('System'));
  if Assigned(SystemDrive) then begin
    SystemFileSystem := SystemDrive.FileSystem;
    AppFile := TFile(SystemFileSystem.TopDirectory.Items.FindByName('Clock'));
    if Assigned(AppFile) then AppExecute(AppFile)
      else raise Exception.Create('Cannot start first application');
    AppFile := TFile(SystemFileSystem.TopDirectory.Items.FindByName('Clock2'));
    if Assigned(AppFile) then AppExecute(AppFile)
      else raise Exception.Create('Cannot start first application');
    Scheduler.Start;
  end else raise Exception.Create('Missing System drive');
end;

procedure TKernel.Terminate;
begin
  if Scheduler.Running then Scheduler.Stop;
end;

constructor TKernel.Create;
begin
  Devices := TNamedObjects<TDevice>.Create;
  Drives := TNamedObjects<TDrive>.Create;
  Apps := TNamedObjects<TApp>.Create;
  Scheduler := TScheduler.Create;
  Screens := TObjectList<TScreen>.Create;
  Api := TKernelApi.Create;
  TKernelApi(Api).Kernel := Self;
  Desktop := TDesktop.Create;
end;

destructor TKernel.Destroy;
begin
  Terminate;
  FreeAndNil(Desktop);
  FreeAndNil(Api);
  FreeAndNil(Screens);
  FreeAndNil(Scheduler);
  FreeAndNil(Apps);
  FreeAndNil(Drives);
  FreeAndNil(Devices);
  inherited;
end;

end.