text stringlengths 14 6.51M |
|---|
unit YOTM.Form;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ExtCtrls,
HGM.Button, Vcl.StdCtrls, Vcl.Mask, Vcl.ComCtrls, HGM.Controls.PanelExt;
type
TFormCustom = class(TForm)
DragBarTop: TDragPanel;
ButtonFlatClose: TButtonFlat;
LabelCaption: TLabel;
procedure FormPaint(Sender: TObject);
procedure ButtonFlatCloseClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormHide(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormActivate(Sender: TObject);
procedure LabelCaptionMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
private
function GetCaption: String;
procedure SetCaption(const Value: String);
public
property Caption:string read GetCaption write SetCaption;
end;
var
FormCustom: TFormCustom;
implementation
uses YOTM.Main;
{$R *.dfm}
procedure TFormCustom.ButtonFlatCloseClick(Sender: TObject);
begin
Close;
end;
procedure TFormCustom.FormActivate(Sender: TObject);
begin
SendMessage(Application.MainForm.Handle, WM_NCACTIVATE, Integer(True), 0);
end;
procedure TFormCustom.FormCreate(Sender: TObject);
const CS_DROPSHADOW = $00020000;
begin
SetClassLong(Handle, GCL_STYLE, GetWindowLong(Handle, GCL_STYLE) or CS_DROPSHADOW);
//Position:=poMainFormCenter;
Left:=Application.MainForm.Left + (Application.MainForm.Width div 2 - Width div 2);
Top:=Application.MainForm.Top + (Application.MainForm.Height div 2 - Height div 2);
end;
procedure TFormCustom.FormHide(Sender: TObject);
begin
AnimateWindow(Handle, 100, AW_BLEND or AW_HIDE);
end;
procedure TFormCustom.FormPaint(Sender: TObject);
begin
Canvas.Pen.Color:=$002E2E2E;
Canvas.Pen.Width:=3;
Canvas.Rectangle(ClientRect);
end;
procedure TFormCustom.FormShow(Sender: TObject);
begin
AnimateWindow(Handle, 100, AW_BLEND);
end;
function TFormCustom.GetCaption: String;
begin
Result:=inherited Caption;
end;
procedure TFormCustom.LabelCaptionMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
DragBarTop.DoDrag;
end;
procedure TFormCustom.SetCaption(const Value: String);
begin
inherited Caption:=Value;
LabelCaption.Caption:=Value;
end;
end.
|
unit UAuthenticatorImpl;
interface
uses InvokeRegistry
, Types
, XSBuiltIns
, UAuthenticatorIntf
, USessionsManager
, Windows
, Uni;
type
TAuthenticator = class(TInvokableClass, IAuthenticator)
private
FUniConnection: TUniConnection;
FUniTransaction: TUniTransaction;
{ métodos privados não precisam ser protegidos dentro de seções críticas
porque eles sempre são usados por outros métodos que obrigatoriamente usam
seções críticas }
function GetSessionByID(const aSessionID: String; out aSession: TSessionItem): Boolean;
function CreateSessionID: String;
public
constructor Create; override;
destructor Destroy; override;
function SetSessionData(const aSessionID, aData: String): Boolean; stdcall;
function GetSessionData(const aSessionID: String): String; stdcall;
function SessionExists(const aSessionID: String): Boolean; stdcall;
function Login(const aUserName: string; const aPassword: string; out aSessionID: string): Boolean; stdcall;
function Logout(const aSessionID: string): Boolean; stdcall;
function ChangePassword(const aSessionID, aOldPassword, aNewPassword: String): Byte; stdcall;
end;
implementation
uses SysUtils, KRK.Lib.Rtl.Common.StringUtils, KRK.Lib.DCPcrypt.Utilities
, KRK.Lib.DCPcrypt.Types, UServerConfiguration, UCommonTypes
, UExtraUtilities;
{ TAuthenticator }
{ 1: A sessão não existe
2: A senha antiga não confere }
function TAuthenticator.ChangePassword(const aSessionID, aOldPassword, aNewPassword: String): Byte;
const
SQLText = 'UPDATE USUARIOS'#13#10 +
' SET CH_SENHA = :CH_SENHA' +
' WHERE SM_USUARIOS_ID = :SM_USUARIOS_ID';
var
SessionData: TSessionData;
SessDataStr: String;
NewPassword: String;
begin
Result := 0;
SessionData := nil;
CS.Enter;
try
SessionData := TSessionData.Create(nil);
{ Obtém os dados da sessão do usuário }
SessDataStr := GetSessionData(aSessionID);
{ Se a sessão existir, ou melhor, se os dados da sessão existirem, continua }
if SessDataStr <> '' then
begin
SessionData.FromString(SessDataStr);
{ Compara a senha da sessão com a senha antiga, supostamente do usuário da
sessão, se as senhas forem iguais, continua criando uma transação e
atualizando o registro do usuário identificado pela sessão com a nova senha }
if SessionData.ch_senha = GetStringCheckSum(aOldPassword,[haSha512]) then
with TUniSQL.Create(nil) do
try
FUniConnection.StartTransaction;
try
SQL.Text := SQLText;
ParamByName('SM_USUARIOS_ID').AsInteger := SessionData.sm_usuarios_id;
NewPassword := GetStringCheckSum(aNewPassword,[haSha512]);
ParamByName('CH_SENHA').AsString := NewPassword;
Connection := FUniConnection;
Execute;
{ Atualizando a senha na sessão do usuário e salvando a sessão }
SessionData.ch_senha := NewPassword;
SetSessionData(aSessionID,SessionData.ToString);
FUniConnection.Commit;
except
FUniConnection.Rollback;
end;
finally
Free;
end
else
Result := 2;
end
else
Result := 1
finally
SessionData.Free;
CS.Leave;
end;
end;
constructor TAuthenticator.Create;
begin
inherited;
FUniConnection := TUniConnection.Create(nil);
FUniTransaction := TUniTransaction.Create(nil);
ConfigureConnection(FUniConnection,FUniTransaction);
FUniConnection.Connect;
end;
destructor TAuthenticator.Destroy;
begin
FUniTransaction.Free;
FUniConnection.Free;
inherited;
end;
function TAuthenticator.CreateSessionID: String;
begin
{ Poderia ser qualquer identificador único, mas optei por usar um simples GUID }
Result := GetStringGUID;
end;
function TAuthenticator.GetSessionByID(const aSessionID: String; out aSession: TSessionItem): Boolean;
begin
aSession := SessionsFile.Sessions[aSessionID];
Result := Assigned(aSession);
end;
function TAuthenticator.GetSessionData(const aSessionID: String): String;
var
SessionItem: TSessionItem;
begin
CS.Enter;
try
Result := '';
{ Obtém uma sessão a partir de seu ID e se esta sessão existir, retorna seus
dados. O formato dos dados pode ser qualquer um. Até mesmo um objeto DFM em
forma textual. XML e JSON podem ser usados também }
if GetSessionByID(aSessionID,SessionItem) then
Result := SessionItem.SessionData;
finally
CS.Leave;
end;
end;
function TAuthenticator.Login(const aUserName, aPassword: string; out aSessionID: string): Boolean;
const
SQLText = 'SELECT *'#13#10 +
' FROM USUARIOS'#13#10 +
' WHERE VA_LOGIN = :VA_LOGIN'#13#10 +
' AND CH_SENHA = :CH_SENHA';
var
SD: TSessionData;
begin
aSessionID := '';
SD := nil;
CS.Enter;
try
SD := TSessionData.Create(nil);
{ Faz uma busca dentro do banco de dados para saber se o par usuário/senha
existe }
with TUniQuery.Create(nil) do
try
Connection := FUniConnection;
ReadOnly := True;
SQL.Text := SQLText;
ParamByName('VA_LOGIN').AsString := aUserName;
ParamByName('CH_SENHA').AsString := GetStringCheckSum(aPassword,[haSha512]);
Open;
Result := RecordCount = 1;
if Result then
begin
SD.sm_usuarios_id := FieldByName('sm_usuarios_id').AsInteger;
SD.va_nome := FieldByName('va_nome').AsString;
SD.va_login := FieldByName('va_login').AsString;
SD.ch_senha := FieldByName('ch_senha').AsString;
SD.va_email := FieldByName('va_email').AsString;
SD.bo_superusuario := FieldByName('bo_superusuario').AsBoolean;
end;
finally
Free;
end;
{ Se o usuário/senha for válido, continua }
if Result then
begin
{ TODO -oCBFF : Ao ativar o IF abaixo, seria interessante remover a sessão do outro usuário impedindo-o de realizar qualquer operação subsequente }
// if Assigned(SessionsFile.Sessions.ItemByUser[aUser]) then
// raise Exception.Create('O usuário "' + aUser + '" já está logado no sistema. Logins múltiplos para o mesmo usuário não são permitidos');
{ Caso chegue neste ponto o login é permitido e já foi realizado. Devemos
criar a sessão }
aSessionID := CreateSessionID;
with SessionsFile.Sessions.Add do
begin
SessionID := aSessionID;
SessionData := SD.ToString;
SessionLastModified := Now;
end;
SessionsFile.SaveBinary;
end;
finally
SD.Free;
CS.Leave;
end;
end;
function TAuthenticator.Logout(const aSessionID: string): Boolean;
var
SessionItem: TSessionItem;
begin
CS.Enter;
try
{ Localizando a sessão pelo seu ID }
Result := GetSessionByID(aSessionID,SessionItem);
{ Se encontrou, então remove }
if Result then
begin
SessionsFile.Sessions.Delete(SessionItem.Index);
SessionsFile.SaveBinary;
end;
finally
CS.Leave;
end;
end;
function TAuthenticator.SessionExists(const aSessionID: String): Boolean;
begin
CS.Enter;
try
Result := Assigned(SessionsFile.Sessions[aSessionID]);
finally
CS.Leave;
end;
end;
function TAuthenticator.SetSessionData(const aSessionID, aData: String): Boolean;
var
SessionItem: TSessionItem;
begin
CS.Enter;
try
{ Obtém uma sessão a partir de seu ID }
Result := GetSessionByID(aSessionID,SessionItem);
{ Se a sessão existir, altera seus dados e salva os arquivos }
if Result then
begin
SessionItem.SessionData := aData;
SessionItem.SessionLastModified := Now;
SessionsFile.SaveBinary;
end;
finally
CS.Leave;
end;
end;
initialization
InvRegistry.RegisterInvokableClass(TAuthenticator);
end.
|
{ $HDR$}
{**********************************************************************}
{ Unit archived using Team Coherence }
{ Team Coherence is Copyright 2002 by Quality Software Components }
{ }
{ For further information / comments, visit our WEB site at }
{ http://www.TeamCoherence.com }
{**********************************************************************}
{}
{ $Log: 12439: EQDateEdit.pas
{
{ Rev 1.0 2003-03-19 17:34:40 peter
}
unit EQDateEdit;
interface
{$I VER.INC }
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, DB, DBCtrls;
type
TEQValidateEvent = procedure (Sender:TObject;var NewText:string;var AllowChange:boolean) of object;
TEQCustomDateEdit = class(TCustomEdit)
private
FValidate: boolean;
FOnValidate: TEQValidateEvent;
FDefaultText: string;
FSilent: boolean;
procedure SetValidate(const Value: boolean);
procedure SetDefaultText(const Value: string);
procedure SetSilent(const Value: boolean);
{ Private declarations }
protected
{ Protected declarations }
function DoValidate:boolean;virtual;
procedure DoExit;override;
procedure KeyDown(var Key: Word; Shift: TShiftState);override;
procedure KeyPress(var Key: Char); override;
public
{ Public declarations }
constructor Create(AOwner:TComponent);override;
property Silent:boolean read FSilent write SetSilent;
property Validate:boolean read FValidate write SetValidate default true;
property OnValidate:TEQValidateEvent read FOnValidate write FOnValidate;
property DefaultText:string read FDefaultText write SetDefaultText;
end;
TEQDateEdit = class(TEQCustomDateEdit)
published
property Silent;
property Validate;
property OnValidate;
property DefaultText;
property Text;
{$IFDEF D4_AND_UP }
property Anchors;
property BiDiMode;
property Constraints;
property DragKind;
property ImeMode;
property ImeName;
property ParentBiDiMode;
property OnEndDock;
property OnStartDock;
{$ENDIF }
property AutoSelect;
property AutoSize;
property BorderStyle;
property CharCase;
property Color;
property Ctl3D;
property DragCursor;
property DragMode;
property Enabled;
property Font;
property MaxLength;
property ParentColor;
property ParentCtl3D;
property ParentFont;
property ParentShowHint;
property PasswordChar;
property PopupMenu;
property ReadOnly;
property ShowHint;
property TabOrder;
property TabStop;
property Visible;
property OnChange;
property OnClick;
property OnDblClick;
property OnDragDrop;
property OnDragOver;
property OnEndDrag;
property OnEnter;
property OnExit;
property OnKeyDown;
property OnKeyPress;
property OnKeyUp;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnStartDrag;
end;
TDBEQDateEdit = class(TEQCustomDateEdit)
private
FDataLink:TFieldDataLink;
FNullValue: string;
function GetDataField: string;
function GetField: TField;
procedure SetDataField(const Value: string);
function GetDataSource: TDataSource;
procedure SetDataSource(const Value: TDataSource);
function GetReadOnly: boolean;
procedure SetReadOnly(const Value: boolean);
procedure ResetMaxLength;
procedure CMGetDataLink(var Message: TMessage); message CM_GETDATALINK;
procedure DataChange(Sender:TObject);
procedure UpdateData(Sender:TObject);
procedure ActiveChange(Sender:TObject);
protected
procedure Loaded;override;
procedure Notification(AComponent: TComponent; Operation: TOperation);override;
procedure Change;override;
procedure DoExit;override;
procedure KeyDown(var Key: Word; Shift: TShiftState);override;
function DoValidate: boolean;override;
public
constructor Create(AOwner:TComponent);override;
destructor Destroy;override;
property Field:TField read GetField;
property Text;
published
property NullValue:string read FNullValue write FNullValue;
property DataField:string read GetDataField write SetDataField;
property DataSource:TDataSource read GetDataSource write SetDataSource;
property Silent;
property Validate;
property OnValidate;
property DefaultText;
{$IFDEF D4_AND_UP }
property Anchors;
property BiDiMode;
property Constraints;
property DragKind;
property ImeMode;
property ImeName;
property ParentBiDiMode;
property OnEndDock;
property OnStartDock;
{$ENDIF }
property AutoSelect;
property AutoSize;
property BorderStyle;
property CharCase;
property Color;
property Ctl3D;
property DragCursor;
property DragMode;
property Enabled;
property Font;
property MaxLength;
property ParentColor;
property ParentCtl3D;
property ParentFont;
property ParentShowHint;
property PasswordChar;
property PopupMenu;
property ReadOnly:boolean read GetReadOnly write SetReadOnly;
property ShowHint;
property TabOrder;
property TabStop;
property Visible;
property OnChange;
property OnClick;
property OnDblClick;
property OnDragDrop;
property OnDragOver;
property OnEndDrag;
property OnEnter;
property OnExit;
property OnKeyDown;
property OnKeyPress;
property OnKeyUp;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnStartDrag;
end;
TEQDatePicker = class(TEQCustomDateEdit)
end;
procedure Register;
implementation
uses
utilsDateTime;
{ TEQCustomDateEdit }
constructor TEQCustomDateEdit.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FValidate := true;
end;
procedure TEQCustomDateEdit.DoExit;
begin
DoValidate;
inherited;
end;
function TEQCustomDateEdit.DoValidate:boolean;
var NewText:string;
begin
if not FValidate then Exit;
Result := true;
NewText := GetFormattedDate(Text,FDefaultText);
if Assigned(FOnValidate) then
FOnValidate(Self,Newtext,Result);
if Result then
Text := NewText;
if CanFocus then
SelectAll;
end;
procedure TEQCustomDateEdit.KeyDown(var Key: Word; Shift: TShiftState);
begin
inherited KeyDown(Key,Shift);
if (Key = VK_RETURN) then
DoValidate;
end;
procedure TEQCustomDateEdit.KeyPress(var Key: Char);
begin
inherited KeyPress(Key);
if FSilent and (Key = #13) then
Key := #0;
end;
procedure TEQCustomDateEdit.SetDefaultText(const Value: string);
begin
FDefaultText := Value;
end;
procedure TEQCustomDateEdit.SetSilent(const Value: boolean);
begin
if FSilent <> Value then
FSilent := Value;
end;
procedure TEQCustomDateEdit.SetValidate(const Value: boolean);
begin
if FValidate <> Value then
FValidate := Value;
end;
{ TDBEQDateEdit }
constructor TDBEQDateEdit.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
ControlStyle := ControlStyle + [csReplicatable];
FDataLink := TFieldDataLink.Create;
FDataLink.Control := self;
FDataLink.OnDataChange := DataChange;
FDataLink.OnUpdateData := UpdateData;
FDataLink.OnActiveChange := ActiveChange;
Enabled := false;
end;
destructor TDBEQDateEdit.Destroy;
begin
FDataLink.Free;
FDataLink := nil;
inherited Destroy;
end;
procedure TDBEQDateEdit.ActiveChange(Sender: TObject);
begin
Enabled := FDataLink.Active and Assigned(FDataLink.Field) and not FDataLink.Field.ReadOnly;
if not FDataLink.Active then
Text := Name;
end;
procedure TDBEQDateEdit.DataChange(Sender: TObject);
var tmp:string;
begin
if Assigned(FDataLink.Field) then
tmp := FDataLink.Field.Text
else
tmp := FNullValue;
if tmp = FNullValue then
tmp := DefaultText;
Text := tmp;
end;
procedure TDBEQDateEdit.UpdateData(Sender: TObject);
begin
if Assigned(FDataLink.Field) then
begin
if (Text <> DefaultText) then
FDataLink.Field.Text := Text
else
FDataLink.Field.Text := NullValue;
end;
end;
function TDBEQDateEdit.DoValidate: boolean;
begin
FDataLink.Edit;
Result := inherited DoValidate;
if Result then
FDataLink.Modified;
end;
function TDBEQDateEdit.GetField: TField;
begin
Result := FDataLink.Field;
end;
function TDBEQDateEdit.GetDataField: string;
begin
Result := FDataLink.FieldName;
end;
procedure TDBEQDateEdit.SetDataField(const Value: string);
begin
try
FDataLink.FieldName := Value;
finally
Enabled := FDataLink.Active and Assigned(FDataLink.Field) and
not FDataLink.Field.ReadOnly;
end;
end;
function TDBEQDateEdit.GetDataSource: TDataSource;
begin
Result := FDataLink.DataSource;
end;
procedure TDBEQDateEdit.SetDataSource(const Value: TDataSource);
begin
FDataLink.DataSource := Value;
Enabled := FDataLink.Active and Assigned(FDataLink.Field) and
not FDataLink.Field.ReadOnly;
end;
procedure TDBEQDateEdit.DoExit;
begin
FDataLink.Edit;
inherited;
try
FDataLink.UpdateRecord;
except
SelectAll;
SetFocus;
raise;
end;
end;
procedure TDBEQDateEdit.Change;
begin
FDataLink.Modified;
inherited Change;
end;
procedure TDBEQDateEdit.KeyDown(var Key: Word; Shift: TShiftState);
var tmp:word;
begin
tmp := Key;
FDataLink.Edit;
inherited;
if tmp = VK_RETURN then
try
FDataLink.UpdateRecord;
except
SetFocus;
raise;
end;
end;
function TDBEQDateEdit.GetReadOnly: boolean;
begin
Result := FDataLink.ReadOnly;
end;
procedure TDBEQDateEdit.SetReadOnly(const Value: boolean);
begin
FDataLink.ReadOnly := Value;
end;
procedure TDBEQDateEdit.Loaded;
begin
inherited Loaded;
ResetMaxLength;
if (csDesigning in ComponentState) then
DataChange(Self);
end;
procedure TDBEQDateEdit.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited Notification(AComponent, Operation);
if (Operation = opRemove) and (FDataLink <> nil) and
(AComponent = DataSource) then DataSource := nil;
end;
procedure TDBEQDateEdit.ResetMaxLength;
var
F: TField;
begin
if (MaxLength > 0) and Assigned(DataSource) and Assigned(DataSource.DataSet) then
begin
F := DataSource.DataSet.FindField(DataField);
if Assigned(F) and (F.DataType = ftString) and (F.Size = MaxLength) then
MaxLength := 0;
end;
end;
procedure TDBEQDateEdit.CMGetDataLink(var Message: TMessage);
begin
Message.Result := Integer(FDataLink);
end;
procedure Register;
begin
RegisterComponents('EQ-Soft', [TEQDateEdit, TDBEQDateEdit]);
end;
end.
|
unit IPGeoLocation.Providers.IPAPI;
interface
uses
IPGeoLocation.Interfaces, IPGeoLocation.Core, System.Net.HttpClient;
type
{$REGION 'TIPGeoLocationProviderIPAPI'}
TIPGeoLocationProviderIPAPI = class sealed(TIPGeoLocationProviderCustom)
private
{ private declarations }
protected
{ protected declarations }
function GetRequest: IIPGeoLocationRequest; override;
public
{ public declarations }
constructor Create(pParent: IIPGeoLocation; const pIP: string); override;
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationResponseIPAPI'}
TIPGeoLocationResponseIPAPI = class sealed(TIPGeoLocationResponseCustom)
private
{ private declarations }
protected
{ protected declarations }
procedure Parse; override;
public
{ public declarations }
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationRequestIPAPI'}
TIPGeoLocationRequestIPAPI = class sealed(TIPGeoLocationRequestCustom)
private
{ private declarations }
protected
{ protected declarations }
function InternalExecute: IHTTPResponse; override;
function GetResponse(pIHTTPResponse: IHTTPResponse): IGeoLocation; override;
function GetMessageExceptionAPI(const pJSON: string): string; override;
public
{ public declarations }
constructor Create(pParent: IIPGeoLocationProvider; const pIP: string); override;
end;
{$ENDREGION}
implementation
uses
System.JSON, System.SysUtils, System.Net.URLClient, IPGeoLocation.Types;
{$I APIKey.inc}
{$REGION 'TIPGeoLocationProviderIPAPI'}
constructor TIPGeoLocationProviderIPAPI.Create(pParent: IIPGeoLocation;
const pIP: string);
begin
inherited Create(pParent, pIP);
FID := '#IPAPI';
FURL := 'http://api.ipapi.com';
FAPIKey := APIKey_IPAPI; //TOKEN FROM APIKey.inc
end;
function TIPGeoLocationProviderIPAPI.GetRequest: IIPGeoLocationRequest;
begin
Result := TIPGeoLocationRequestIPAPI.Create(Self, FIP);
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationResponseIPAPI'}
procedure TIPGeoLocationResponseIPAPI.Parse;
var
lJSONObject: TJSONObject;
begin
lJSONObject := nil;
try
lJSONObject := TJSONObject.ParseJSONValue(FJSON) as TJSONObject;
if not Assigned(lJSONObject) then
Exit;
lJSONObject.TryGetValue('hostname', FHostName);
lJSONObject.TryGetValue('country_code', FCountryCode);
lJSONObject.GetValue('location').TryGetValue('country_flag', FCountryFlag);
lJSONObject.TryGetValue('country_name', FCountryName);
lJSONObject.TryGetValue('region_name', FState);
lJSONObject.TryGetValue('city', FCity);
lJSONObject.TryGetValue('zip', FZipCode);
lJSONObject.TryGetValue('isp', FISP);
lJSONObject.TryGetValue('latitude', FLatitude);
lJSONObject.TryGetValue('longitude', FLongitude);
finally
lJSONObject.Free;
end;
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationRequestIPAPI'}
constructor TIPGeoLocationRequestIPAPI.Create(
pParent: IIPGeoLocationProvider; const pIP: string);
begin
inherited Create(pParent, pIP);
FResponseLanguageCode := 'en';
end;
function TIPGeoLocationRequestIPAPI.GetMessageExceptionAPI(
const pJSON: string): string;
var
lMessage: TStringBuilder;
lJSONMessage: TJSONValue;
lText: string;
begin
lJSONMessage := nil;
lMessage := nil;
try
lMessage := TStringBuilder.Create;
lJSONMessage := TJSONObject.ParseJSONValue(pJSON);
if not Assigned(lJSONMessage) then
Exit(pJSON);
(lJSONMessage as TJSONObject).TryGetValue('code', lText);
lMessage.AppendFormat('Code: %s%s', [lText, sLineBreak]);
(lJSONMessage as TJSONObject).TryGetValue('type', lText);
lMessage.AppendFormat('Type: %s%s', [lText, sLineBreak]);
(lJSONMessage as TJSONObject).TryGetValue('info', lText);
lMessage.AppendFormat('Info: %s%s', [lText, sLineBreak]);
Result := lMessage.ToString;
finally
lMessage.Free;
lJSONMessage.Free;
end;
end;
function TIPGeoLocationRequestIPAPI.GetResponse(
pIHTTPResponse: IHTTPResponse): IGeoLocation;
begin
Result := TIPGeoLocationResponseIPAPI.Create(pIHTTPResponse.ContentAsString, FIP, FProvider);
end;
function TIPGeoLocationRequestIPAPI.InternalExecute: IHTTPResponse;
var
lURL: TURI;
lJSONObject: TJSONObject;
lRequestSuccessAPI: Boolean;
lMessageError: string;
begin
//CONFORME A DOCUMENTAÇÃO DA API
lURL := TURI.Create(Format('%s/%s/%s', [FIPGeoLocationProvider.URL, 'api', FIP]));
lURL.AddParameter('access_key', FIPGeoLocationProvider.APIKey);
lURL.AddParameter('language', FResponseLanguageCode);
lURL.AddParameter('output', 'json');
lURL.AddParameter('hostname', '1');
FHttpRequest.URL := lURL.ToString;
//REQUISIÇÃO
Result := inherited InternalExecute;
lJSONObject := nil;
try
lJSONObject := TJSONObject.ParseJSONValue(Result.ContentAsString) as TJSONObject;
//CONFORME A DOCUMENTAÇÃO DA API
if not lJSONObject.TryGetValue('success', lRequestSuccessAPI) then
Exit;
if (lRequestSuccessAPI = False) then
begin
if Assigned(lJSONObject.GetValue('error')) then
begin
lMessageError := GetMessageExceptionAPI(lJSONObject.GetValue('error').ToJSON);
raise EIPGeoLocationException.Create(TIPGeoLocationExceptionKind.EXCEPTION_API,
FIP,
FProvider,
Now(),
lMessageError);
end;
end;
finally
lJSONObject.Free;
end;
end;
{$ENDREGION}
end.
|
unit TSTOBCellIntf;
interface
Uses {$If CompilerVersion < 18.5}HsStreamEx{$Else}SysUtils{$IfEnd}, HsInterfaceEx;
Type
IBCellSubItem = Interface(IInterfaceEx)
['{4B61686E-29A0-2112-8346-E191F686FC84}']
Function GetString1() : AnsiString;
Procedure SetString1(Const AString1 : AnsiString);
Function GetString2() : AnsiString;
Procedure SetString2(Const AString2 : AnsiString);
Function GetPadding() : TBytes;
Procedure Assign(ASource : IInterface);
Property String1 : AnsiString Read GetString1 Write SetString1;
Property String2 : AnsiString Read GetString2 Write SetString2;
Property Padding : TBytes Read GetPadding;
End;
IBCellSubItems = Interface(IInterfaceListEx)
['{4B61686E-29A0-2112-BF1E-2F0BCE8852DB}']
Function Get(Index : Integer) : IBCellSubItem;
Procedure Put(Index : Integer; Const Item : IBCellSubItem);
Function Add() : IBCellSubItem; OverLoad;
Function Add(Const AItem : IBCellSubItem) : Integer; OverLoad;
Procedure Assign(ASource : IInterface);
Property Items[Index : Integer] : IBCellSubItem Read Get Write Put; Default;
End;
IBCellItem = Interface(IInterfaceEx)
['{4B61686E-29A0-2112-8D45-FEEC8868D302}']
Function GetRgbFileName() : AnsiString;
Procedure SetRgbFileName(Const ARgbFileName : AnsiString);
Function GetxDiffs() : Double;
Procedure SetxDiffs(Const AxDiffs : Double);
Function GetNbSubItems() : Word;
Function GetSubItems() : IBCellSubItems;
Procedure Assign(ASource : IInterface);
Property RgbFileName : AnsiString Read GetRgbFileName Write SetRgbFileName;
Property xDiffs : Double Read GetxDiffs Write SetxDiffs;
Property NbSubItems : Word Read GetNbSubItems;
Property SubItems : IBCellSubItems Read GetSubItems;
End;
IBCellItems = Interface(IInterfaceListEx)
['{4B61686E-29A0-2112-87EC-A493DC9A5B7F}']
Function Get(Index : Integer) : IBCellItem;
Procedure Put(Index : Integer; Const Item : IBCellItem);
Function Add() : IBCellItem; OverLoad;
Function Add(Const AItem : IBCellItem) : Integer; OverLoad;
Procedure Assign(ASource : IInterface);
Property Items[Index : Integer] : IBCellItem Read Get Write Put; Default;
End;
ITSTOBCellFile = Interface(IInterfaceEx)
['{4B61686E-29A0-2112-8A07-3772A4BD0D2F}']
Function GetFileSig() : AnsiString;
Procedure SetFileSig(Const AFileSig : AnsiString);
Function GetNbItem() : Word;
Function GetItems() : IBCellItems;
Procedure Assign(ASource : IInterface);
Property FileSig : AnsiString Read GetFileSig Write SetFileSig;
Property NbItem : Word Read GetNbItem;
Property Items : IBCellItems Read GetItems;
End;
TTSTOBCellFile = Class(TObject)
Public
Class Function CreateBCellFile() : ITSTOBCellFile;
Class Function CreateBCellItems() : IBCellItems;
Class Function CreateBCellSubItems() : IBCellSubItems;
End;
implementation
Uses TSTOBCellImpl;
Class Function TTSTOBCellFile.CreateBCellFile() : ITSTOBCellFile;
Begin
Result := TSTOBCellImpl.TTSTOBCellFile.Create();
End;
Class Function TTSTOBCellFile.CreateBCellItems() : IBCellItems;
Begin
Result := TBCellItems.Create();
End;
Class Function TTSTOBCellFile.CreateBCellSubItems() : IBCellSubItems;
Begin
Result := TBCellSubItems.Create();
End;
end.
|
unit Model.Components.Connections.FireDac;
interface
uses Model.Components.Connections.interfaces, Data.DB,
FireDAC.Stan.Intf, FireDAC.Stan.Option,
FireDAC.Stan.Error, FireDAC.UI.Intf, FireDAC.Phys.Intf, FireDAC.Stan.Def,
FireDAC.Stan.Pool, FireDAC.Stan.Async, FireDAC.Phys, FireDAC.Phys.MySQL,
FireDAC.Phys.MySQLDef, FireDAC.VCLUI.Wait, FireDAC.Stan.Param, FireDAC.DatS,
FireDAC.DApt.Intf, FireDAC.DApt, FireDAC.Comp.DataSet, FireDAC.Comp.Client;
type
TModelComponentsConnectionsFireDac = class(TInterfacedObject,IModelComponentsConnectionsGeneric)
private
FDataSouce:TDataSource;
FQuery:TFDQuery;
FConnection:TFDConnection;
public
constructor Create;
Destructor Destroy;override;
class function New : IModelComponentsConnectionsGeneric;
function Close:IModelComponentsConnectionsGeneric;
function CommitTrasaction:IModelComponentsConnectionsGeneric;
function DataSet:TDataSet;
function ExecSQL:IModelComponentsConnectionsGeneric;
function FielByName(aField:string):Variant;
function Open:IModelComponentsConnectionsGeneric;
function ParamByName(aParam:String;aValue:Variant):IModelComponentsConnectionsGeneric;
function RollbackTrasaction:IModelComponentsConnectionsGeneric;
function StartTransaction:IModelComponentsConnectionsGeneric;
function SQLClear:IModelComponentsConnectionsGeneric;
function SQLAdd(aSQL:string):IModelComponentsConnectionsGeneric;
end;
implementation
{ TModelComponentsConnectionsFireDac }
function TModelComponentsConnectionsFireDac.Close: IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.Close;
end;
function TModelComponentsConnectionsFireDac.CommitTrasaction: IModelComponentsConnectionsGeneric;
begin
FConnection.Commit;
end;
constructor TModelComponentsConnectionsFireDac.Create;
begin
FConnection := TFDConnection.Create(nil);
FConnection.Params.DriverID := 'MySQL';
FConnection.Params.Database := 'wktechnology';
FConnection.Params.UserName := 'root';
FConnection.Params.Add('port=3306');
FConnection.Params.Add('server=LOCALHOST');
FQuery := TFDQuery.Create(nil);
FQuery.Connection := FConnection;
end;
function TModelComponentsConnectionsFireDac.DataSet:TDataSet;
begin
Result := FQuery;
FQuery.RecordCount;
end;
destructor TModelComponentsConnectionsFireDac.Destroy;
begin
FQuery.Free;
FConnection.Free;
inherited;
end;
function TModelComponentsConnectionsFireDac.ExecSQL: IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.ExecSQL;
end;
function TModelComponentsConnectionsFireDac.FielByName(aField: string): Variant;
begin
Result := FQuery.FieldByName(aField).Value;
end;
class function TModelComponentsConnectionsFireDac.New: IModelComponentsConnectionsGeneric;
begin
Result := Self.Create;
end;
function TModelComponentsConnectionsFireDac.Open: IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.Open();
end;
function TModelComponentsConnectionsFireDac.ParamByName(aParam: String;
aValue: Variant): IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.ParamByName(aParam).Value := aValue;
end;
function TModelComponentsConnectionsFireDac.RollbackTrasaction: IModelComponentsConnectionsGeneric;
begin
FConnection.RollbackRetaining;
end;
function TModelComponentsConnectionsFireDac.SQLAdd(
aSQL: string): IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.SQL.Add(aSQL);
end;
function TModelComponentsConnectionsFireDac.SQLClear: IModelComponentsConnectionsGeneric;
begin
Result := Self;
FQuery.SQL.Clear;
end;
function TModelComponentsConnectionsFireDac.StartTransaction: IModelComponentsConnectionsGeneric;
begin
FConnection.StartTransaction;
end;
end.
|
unit RepositorioContador;
interface
uses DB, Repositorio, RepositorioPessoa;
type
TRepositorioContador = class(TRepositorioPessoa)
protected
function Get (Dataset :TDataSet) :TObject; overload; override;
function GetNomeDaTabela :String; override;
function GetIdentificador(Objeto :TObject) :Variant; override;
function GetRepositorio :TRepositorio; override;
protected
function SQLGet :String; override;
function SQLSalvar :String; override;
function SQLGetAll :String; override;
function SQLRemover :String; override;
function SQLGetExiste(campo: String): String; override;
protected
function IsInsercao(Objeto :TObject) :Boolean; override;
protected
procedure SetParametros (Objeto :TObject ); override;
function IsComponente :Boolean; override;
public
function Salvar (Objeto :TObject) :Boolean; override;
function Remover(Objeto :TObject) :Boolean; override;
end;
implementation
uses SysUtils, Contador, FabricaRepositorio, Pessoa;
{ TRepositorioContador }
function TRepositorioContador.Get(Dataset: TDataSet): TObject;
var
Pessoa :TPessoa;
Contador :TContador;
begin
Pessoa:= TPessoa(inherited Get(Dataset));
result := nil;
if not assigned(Pessoa) then
exit;
Contador := TContador.Create;
Contador.Codigo := Pessoa.Codigo;
Contador.Razao := Pessoa.Razao;
Contador.CPF_CNPJ := Pessoa.CPF_CNPJ;
Contador.RG_IE := Pessoa.RG_IE;
Contador.DtCadastro := Pessoa.DtCadastro;
Contador.Fone1 := Pessoa.Fone1;
Contador.Fone2 := Pessoa.Fone2;
Contador.Email := Pessoa.Email;
Contador.codigo_pessoa := Pessoa.Codigo;
Contador.cnpj := self.FQuery.FieldByName('cnpj').AsString;
Contador.crc := self.FQuery.FieldByName('crc').AsString;
result := Contador;
FreeAndNil(Pessoa);
end;
function TRepositorioContador.GetIdentificador(Objeto: TObject): Variant;
begin
result := TContador(Objeto).codigo;
end;
function TRepositorioContador.GetNomeDaTabela: String;
begin
result := 'CONTADOR';
end;
function TRepositorioContador.GetRepositorio: TRepositorio;
begin
result := TRepositorioContador.Create;
end;
function TRepositorioContador.IsComponente: Boolean;
begin
result := true;
end;
function TRepositorioContador.IsInsercao(Objeto: TObject): Boolean;
begin
result := true;
end;
function TRepositorioContador.Remover(Objeto: TObject): Boolean;
var
RepositorioPessoa :TRepositorio;
begin
RepositorioPessoa := TFabricaRepositorio.GetRepositorio(TPessoa.ClassName);
try
result := inherited Remover(Objeto);
RepositorioPessoa.Remover(Objeto);
finally
FreeAndNil(RepositorioPessoa);
end;
end;
function TRepositorioContador.Salvar(Objeto: TObject): Boolean;
var
RepositorioPessoa :TRepositorio;
begin
RepositorioPessoa := TFabricaRepositorio.GetRepositorio(TPessoa.ClassName);
try
RepositorioPessoa.Salvar(Objeto);
Result := inherited Salvar(Objeto);
finally
FreeAndNil(RepositorioPessoa);
end;
end;
procedure TRepositorioContador.SetParametros(Objeto: TObject);
var
Contador :TContador;
begin
Contador := (Objeto as TContador);
// inherited SetParametro('codigo', Contador.codigo);
self.FQuery.ParamByName('codigo_pessoa').AsInteger := Contador.codigo;
self.FQuery.ParamByName('cnpj').AsString := Contador.cnpj;
self.FQuery.ParamByName('crc').AsString := Contador.crc;
end;
function TRepositorioContador.SQLGet: String;
begin
result := ' select p.*, C.CNPJ, C.CRC '+
' from CONTADOR C '+
' inner join pessoas p on (C.codigo_pessoa = p.codigo) '+
' where C.codigo_PESSOA = :nCodigo ';
end;
function TRepositorioContador.SQLGetAll: String;
begin
result := 'select p.*, C.CNPJ, C.CRC from CONTADOR C inner join pessoas p on (C.codigo_pessoa = p.codigo) order by CODIGO';
end;
function TRepositorioContador.SQLGetExiste(campo: String): String;
begin
result := 'select '+ campo +' from CONTADOR where '+ campo +' = :ncampo';
end;
function TRepositorioContador.SQLRemover: String;
begin
result := ' delete from CONTADOR where codigo_pessoa = :codigo ';
end;
function TRepositorioContador.SQLSalvar: String;
begin
result := 'update or insert into CONTADOR (CODIGO_PESSOA ,CNPJ ,CRC) '+
' values ( :CODIGO_PESSOA , :CNPJ , :CRC) ';
end;
end.
|
unit UAMC_UserID_TitleSource;
{ ClickForms Application }
{ Bradford Technologies, Inc. }
{ All Rights Reserved }
{ Source Code Copyrighted © 1998-2011 by Bradford Technologies, Inc. }
{ This is the unit that takes the userID and password and queries the }
{ TitleSource System and, if valid, retrieves the user orders. }
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, MSXML6_TLB, WinHTTP_TLB, ComCtrls, comObj,
UBase64, Grids, HTTPApp, Grids_ts, TSGrid, osAdvDbGrid,
UWindowsInfo, UContainer, UAMC_Globals, UAMC_Base, UAMC_WorkflowBaseFrame,
Registry, UGlobals, uLkJSON, UUtil2, UMain;
type
TAMC_UserID_TitleSource = class(TWorkflowBaseFrame)
edtUserID: TEdit;
edtUserPassword: TEdit;
sTxTitle: TStaticText;
stxUserID: TStaticText;
btnLogin: TButton;
tgPendingOrders: TosAdvDbGrid;
stxAddress: TStaticText;
stxSelectedOrderID: TStaticText;
stxOrderID: TStaticText;
procedure btnLoginClick(Sender: TObject);
procedure tgPendingOrdersClickCell(Sender: TObject; DataColDown,
DataRowDown, DataColUp, DataRowUp: Integer; DownPos,
UpPos: TtsClickPosition);
procedure LoginEntered(Sender: TObject);
procedure tgPendingOrdersSelectChanged(Sender: TObject;
SelectType: TtsSelectType; ByUser: Boolean);
private
FUserLogin: Boolean; //can be OfficeLogin
FAppraiserHash: String; //session ID for appraiser
FOrderID: String;
FOrderSelected: Boolean;
public
procedure InitPackageData; override;
procedure DoProcessData; override;
function CreateLoginRequestXML(ID, PSW: String): String;
procedure Login;
function ParseToken(respStr: String; var sessionToken, sessionTokenType: String): Boolean;
function GetPendingOrdersFor(sessionToken: String): String;
procedure DisplayPendingOrders(jsonOrders: String);
procedure AutoSelectOrderID; //tries to find the order ID
procedure LoadTestFiles;
procedure SetPackageContents(thisOrder: Integer); //sets the package contents
function GetTitleSourceUserRegistryInfo: String;
procedure SetTitleSourceUserRegistryInfo(AUserID:String);
end;
implementation
{$R *.dfm}
Uses
UWebConfig, UStatus;
const
//column IDs for displaying the pending order information
colOrderID = 1;
colAddress = 2;
colCity = 3;
colState = 4;
colZip = 5;
colReportType = 6;
//report format identifiers
fmtPDF = 'PDF';
fmtMISMO26 = 'MISMO';
fmtMISMO26GSE = 'MISMOGSE';
fmtENV = 'ENV';
fmtTotalXML = 'TOTALXML';
fmtAciXML = 'ACIXML';
//XML Xpaths
xpToken = '/access_token';
xpTokenType = '/token_type';
xpOrders = '/items';
xpOrderFormats = '/orders/order[orderId="%s"]/appraisalFormats/appraisalFormat';
//XML element names
tagOrderId = 'OrderDetailId';
tagAppraisalFormats = 'appraisalFormats';
tagAppraisalFormat = 'appraisalFormat';
tagStreetAddr1 = 'StreetAddress1';
tagStreetAddr2 = 'StreetAddress2';
tagCity = 'City';
tagState = 'StateCode';
tagZip = 'Zip';
//HTTP Parameter names
parUsername = 'username=';
parPassword = 'password=';
parGrantType = 'grant_type=';
parPartnerNum = 'partnerNumber=';
//HTTP function names
fnToken = 'Token';
fnGetOrders = 'api/v1/AppraisalQueue/GetReportReadyQueue';
TitleSourceRegKey = '\AMC\TitleSource';
{ TAMC_PackageDef }
function TAMC_UserID_TitleSource.GetTitleSourceUserRegistryInfo: String;
var
reg: TRegistry;
regKey: String;
begin
result := '';
reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CURRENT_USER;
regKey := LocMachClickFormBaseSection + TitleSourceRegKey;
if reg.OpenKey(regKey, False) then
result := reg.ReadString('UserID');
finally
reg.Free;
end;
end;
procedure TAMC_UserID_TitleSource.SetTitleSourceUserRegistryInfo(aUserID: String);
var
reg: TRegistry;
begin
reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CURRENT_USER;
if reg.OpenKey(LocMachClickFormBaseSection + TitleSourceRegKey, True) then
begin
reg.WriteString('UserID', aUserID);
end;
finally
reg.Free;
end;
end;
procedure TAMC_UserID_TitleSource.InitPackageData;
begin
inherited;
//init vars
LoginEntered(nil); //set state of Login button
FOrderSelected := False;
FOrderID := ''; //orderID
FAppraiserHash := ''; //session ID for appraiser
btnLogin.Enabled := false;
stxAddress.Caption := PackageData.SubjectAddress; //display the subject address to user
//defaults for TitleSource
PackageData.FForceContents := True; //user can change package contents
PackageData.FNeedPDF := False; //PDF is not necessarily a separate file
PackageData.FEmbbedPDF := True; //PDF is always imbedded
edtUserID.Text := GetTitleSourceUserRegistryInfo;
end;
procedure TAMC_UserID_TitleSource.btnLoginClick(Sender: TObject);
begin
Login;
end;
procedure TAMC_UserID_TitleSource.LoginEntered(Sender: TObject);
begin
if (length(edtUserPassword.text)> 0) and (Length(edtUserID.Text) > 0) then
btnLogin.Enabled := true
else
btnLogin.Enabled := false;
end;
function TAMC_UserID_TitleSource.CreateLoginRequestXML(ID, PSW: String): String;
const
tagFieldSet = 'fieldset';
tagUsername = 'username';
tagPassword = 'password';
tagGrantType = 'grant_type';
var
xmlDoc: IXMLDOMDocument2;
PasswordNode, UserNameNode, GrantTypeNode: IXMLDOMNode;
begin
xmlDoc := CoDomDocument60.Create;
try
with xmlDoc do
begin
documentElement := CreateElement(tagFieldSet); //root element
//add in the login nodes
UserNameNode := CreateNode(NODE_ELEMENT,tagUsername,'');
UserNameNode.appendChild(xmlDoc.CreateTextNode(ID));
documentElement.appendChild(UserNameNode);
PasswordNode := CreateNode(NODE_ELEMENT,tagPassword,'');
PasswordNode.appendChild(xmlDoc.CreateTextNode(PSW));
documentElement.appendChild(PasswordNode);
GrantTypeNode := CreateNode(NODE_ELEMENT,tagGrantType,'');
GrantTypeNode.appendChild(xmlDoc.CreateTextNode(tagPassword));
documentElement.appendChild(GrantTypeNode);
result := xmlDoc.xml;
end;
except
ShowNotice('There is a problem creating the LoginRequest XML');
end;
end;
procedure TAMC_UserID_TitleSource.Login;
const
grType = 'password';
var
id, psw, url, requestStr: String;
httpRequest: IWinHTTPRequest;
sessionToken, sessionTokenType: String;
jsonOrders: String;
begin
//initialize
FAppraiserHash := '';
FUserLogin := False;
id := edtUserID.Text;
psw := edtUserPassword.Text;
url := GetURLForTitleSourceServer + fnToken;
requestStr := parUsername + urlEncode(id) + '&'
+ parPassword + urlEncode(psw) + '&'
+ parGrantType + urlEncode(grType);
if edtUserID.Text<>'' then
SetTitleSourceUserRegistryInfo(edtUserID.Text);
httpRequest := CoWinHTTPRequest.Create;
with httpRequest do
begin
Open('POST',url,False);
SetTimeouts(60000,60000,60000,60000); //1 minute for everything
SetRequestHeader('Content-type','application/x-www-form-urlencoded');
SetRequestHeader('Content-Length', IntTostr(length(requestStr)));
PushMouseCursor(crHourGlass);
try
try
HTTPRequest.send(requestStr);
except
on e:Exception do
ShowAlert(atWarnAlert, e.Message);
end;
if Status <> httpRespOK then
ShowAlert(atWarnAlert, 'Cannot login. The server returned error code '+ IntToStr(status) + ':'+ResponseText)
else
begin
if not ParseToken(ResponseText, sessionToken, sessionTokenType) then
ShowAlert(atWarnAlert, 'Login authentication failed. Your User ID or Password may be incorrect.')
else
begin
FAppraiserHash := sessionTokenType + ' ' + sessionToken;
jsonOrders := GetPendingOrdersFor(FAppraiserHash);
DisplayPendingOrders(jsonOrders);
end;
end;
finally
PopMouseCursor;
end;
end;
end;
function TAMC_UserID_TitleSource.ParseToken(respStr: String; var sessionToken, sessionTokenType: String): Boolean;
var
baseJSON: TlkJSONbase;
begin
baseJSON := TlkJSON.ParseText(respStr);
sessionToken := baseJSON.Field['access_token'].Value;
sessionTokenType := baseJSON.Field['token_type'].Value;
if Length(sessionToken) = 0 then
begin
ShowNotice('There is a problem retrieving login token.');
result := False;
end
else if Length(sessionTokenType) = 0 then
begin
ShowNotice('There is a problem retrieving login token type.');
result := False;
end
else
result := True;
end;
function TAMC_UserID_TitleSource.GetPendingOrdersFor(sessionToken: String): String;
var
url: String;
httpRequest: IWinHTTPRequest;
begin
url := GetURLForTitleSourceServer + fnGetOrders;
result := '';
httpRequest := CoWinHTTPRequest.Create;
with httpRequest do
begin
Open('GET',url,False);
SetTimeouts(60000,60000,60000,60000); //1 minute for everything
SetRequestHeader('Authorization', sessionToken);
PushMouseCursor(crHourGlass);
try
try
httpRequest.send('');
except
on e:Exception do
begin
PopMouseCursor;
ShowAlert(atWarnAlert, e.Message);
end;
end;
finally
PopMouseCursor;
end;
if status <> httpRespOK then
begin
ShowAlert(atWarnAlert, 'Cannot retrieve your orders. The server returned error code '+ IntToStr(status));
exit;
end;
result := ResponseText;
end;
end;
procedure TAMC_UserID_TitleSource.DisplayPendingOrders(jsonOrders: String);
var
orderJSON: TlkJSONobject;
orderList: TlkJSONlist;
index: Integer;
begin
orderJSON := TlkJSON.ParseText(jsonOrders) as TlkJSONobject;
orderList := orderJSON.Field['Items'] as TlkJSONlist;
//always start clean
tgPendingOrders.GridData.Clear;
tgPendingOrders.Rows := 0;
if orderList.Count = 0 then
ShowAlert(atWarnAlert, 'There are no open or pending orders. Please contact TitleSource to activate your orders.')
else
for index := 0 to orderList.Count - 1 do
with tgPendingOrders do
begin
Rows := Rows + 1;
Cell[colOrderID, Rows] := VarToStr(orderList.Child[index].Field['OrderDetailId'].Value);
Cell[colAddress, Rows] := VarToStr(orderList.Child[index].Field['StreetAddress1'].Value);
Cell[colCity, Rows] := VarToStr(orderList.Child[index].Field['City'].Value);
Cell[colState, Rows] := VarToStr(orderList.Child[index].Field['StateCode'].Value);
Cell[colZip, Rows] := VarToStr(orderList.Child[index].Field['Zip'].Value);
Cell[colreportType,Rows] := VarToStr(orderList.Child[index].Field['ProductTypeName'].Value);
end;
//attempt to preselect the order ID for user
AutoSelectOrderID;
end;
procedure TAMC_UserID_TitleSource.tgPendingOrdersClickCell(Sender: TObject;
DataColDown, DataRowDown, DataColUp, DataRowUp: Integer; DownPos,
UpPos: TtsClickPosition);
begin
if DataRowDown > 0 then
begin
tgPendingOrders.RowSelected[DataRowDown] := True;
stxOrderID.caption := tgPendingOrders.Cell[colOrderID, DataRowDown];
FOrderID := tgPendingOrders.Cell[colOrderID, DataRowDown];
SetPackageContents(DataRowDown);
FOrderSelected := True;
end;
end;
procedure TAMC_UserID_TitleSource.AutoSelectOrderID;
var
N: Integer;
begin
if tgPendingOrders.Rows > 0 then
with tgPendingOrders do
for N := 1 to tgPendingOrders.Rows do
begin
if CompareText(FData.FZip, Cell[colZip, N]) = 0 then //match zip
if CompareText(FData.FAddress, Cell[colAddress, N]) = 0 then //match address
begin
RowSelected[N] := True;
stxOrderID.caption := Cell[colOrderID, N];
FOrderID := Cell[colOrderID, N];
SetPackageContents(N);
FOrderSelected := True;
break;
end;
end;
end;
procedure TAMC_UserID_TitleSource.tgPendingOrdersSelectChanged(
Sender: TObject; SelectType: TtsSelectType; ByUser: Boolean);
var
selectedRow: Integer;
begin
selectedRow := tgPendingOrders.SelectedRows.First;
stxOrderID.caption := tgPendingOrders.Cell[colOrderID, selectedRow];
FOrderID := tgPendingOrders.Cell[colOrderID, selectedRow];
SetPackageContents(selectedRow);
FOrderSelected := True;
end;
procedure TAMC_UserID_TitleSource.SetPackageContents(thisOrder: Integer); //thisOrder is the row the order is in
var
dataFile: TDataFile;
AMCData: TAMCData_TitleSource;
Begin
PackageData.FDataFiles.Clear; //delete all previous DataObjs
if FDoc.UADEnabled then //send just the report with embedded PDF
dataFile := TDataFile.Create(fTypXML26GSE)
else
dataFile := TDataFile.Create(fTypXML26);
PackageData.FDataFiles.add(dataFile);
if Assigned(PackageData.FAMCData) then //Init the AMC Specific data object
PackageData.FAMCData.free;
//AMCData := TAMCData_StreetLinks.Create; //Create a new StreetLinks Data Object
AMCData := TAMCData_TitleSource.Create; //Create the new TitleSource Data Object
AMCData.FAppraiserHash := FAppraiserHash; //set the appraiser Hash (session identifier)
AMCData.FOrderID := FOrderID; //set the order identifier
PackageData.FAMCData := AMCData;
end;
procedure TAMC_UserID_TitleSource.DoProcessData;
begin
inherited;
PackageData.FGoToNextOk := FOrderSelected;
PackageData.FHardStop := not FOrderSelected;
PackageData.FAlertMsg := '';
if not FOrderSelected then
if tgPendingOrders.Rows > 0 then
PackageData.FAlertMsg := 'You need to select the Order ID associated with this appraisal.'
else
PackageData.FAlertMsg := 'You cannot proceed. There are no pending orders to associate with this appraisal.';
end;
//just for testing
procedure TAMC_UserID_TitleSource.LoadTestFiles;
const
envFilePath = 'C:\\workflowSampleUploadFiles\UAD_1004_TEST.ENV';
pdfFilePath = 'C:\\workflowSampleUploadFiles\UAD_1004_TEST.PDF';
xmlFilePath = 'C:\\workflowSampleUploadFiles\UAD_1004_TEST.XML';
var
// PDFStream: TFileStream;
// ENVStream: TFileStream;
// XMLStream: TFileStream;
// streamLen: LongInt;
dataFile: TDataFile;
begin
If PackageData.DataFiles.NeedsDataFile(fTypXML26GSE) then
begin
dataFile := PackageData.DataFiles.GetDataFileObj(fTypXML26GSE, False);
dataFile.LoadFromFile(xmlFilePath);
end;
if PackageData.DataFiles.NeedsDataFile(fTypXML26) then
begin
dataFile := PackageData.DataFiles.GetDataFileObj(fTypXML26, False);
dataFile.LoadFromFile(xmlFilePath);
end;
if PackageData.DataFiles.NeedsDataFile(fTypENV) then
begin
dataFile := PackageData.DataFiles.GetDataFileObj(fTypENV, False);
dataFile.LoadFromFile(envFilePath);
end;
if PackageData.DataFiles.NeedsDataFile(fTypPDF) then
begin
dataFile := PackageData.DataFiles.GetDataFileObj(fTypPDF, False); //get ref to object
dataFile.LoadFromFile(pdfFilePath);
end;
end;
end.
|
program ejercicio_11;
const
dimF=10000;
type
computadoras=record
version:double;
cant_paquetes:integer;
cant_cuentas:integer;
end;
vector=array [1..dimF] of computadoras;
procedure Leer(var reg:computadoras);
var
corte:double;
begin
corte:=4.10;
write('Ingrese la version de Ubuntu de la computadora: ');
readln(reg.version);
if(reg.version<> corte) then begin
write('Ingrese la cantidad de paquetes de la compu: ');
readln(reg.cant_paquetes);
write('Ingrese la cantidad de cuentas de la compu: ');
readln(reg.cant_cuentas);
end;
end;
procedure cargarVector(var vec:vector;var dimL:integer);
var
reg:computadoras;
num:double;
begin
dimL:=0;
num:=4.10;
writeln('Ingrese la informacion de la computadora: ');
Leer(reg);
while(dimL<dimF) and (reg.version <> num) do begin
dimL:=dimL +1;
vec[dimL]:=reg;
Leer(reg);
end;
end;
procedure informar_cantCompus(vec:vector;dimL:integer);
var
cantVersiones:integer;
i:integer;
version1,version2:double;
begin
cantVersiones:=0;
i:=1;
version1:=18.04; //Para mejorar el algoritmo pasarlos por parametros :)
version2:=16.04;
while(i<=dimL)do begin
if((vec[i].version = version1) or (vec[i].version = version2)) then
cantVersiones:=cantVersiones + 1;
i:=i+1;
end;
writeln('La cantidad de computadoras que usan la version 18.04 o 16.04 es: ',cantVersiones);
end;
procedure calcular_promedio(vec:vector;dimL:integer);
var
suma:integer;
i:integer;
begin
suma:=0;
for i:=1 to dimL do
suma:=vec[i].cant_cuentas + suma;
writeln('El promedio de cuentas de usuario por computadora es: ',(suma/dimL):1:2);
end;
procedure versionMayorCantPaquetes(vec:vector;dimL:integer);
var
i:integer;
max:integer;
maxPos:integer;
begin
max:=-999;
maxPos:=-1;
for i:=1 to dimL do begin
if(vec[i].cant_paquetes>max)then begin
max:=vec[i].cant_paquetes;
maxPos:=i;
end;
end;
writeln('La version de Ubuntu de la computadora con mayor cantidad de paquetes instalados es: ',(vec[maxPos].version):1:2);
end;
var
dimL:integer;
vec:vector;
begin
cargarVector(vec,dimL);
informar_cantCompus(vec,dimL);
calcular_promedio(vec,dimL);
versionMayorCantPaquetes(vec,dimL);
readln;
end.
|
unit win.registry;
interface
uses
Windows;
type
TRegDataType = (rdUnknown, rdString, rdExpandString, rdInteger, rdBinary);
TRegDataInfo = record
RegDataType : TRegDataType;
DataSize : Integer;
end;
PRegistryUrl = ^TRegistryUrl;
TRegistryUrl = record
Path : AnsiString;
end;
PRegistryKey = ^TRegistryKey;
TRegistryKey = record
CurrentKey : HKEY;
RootKey : HKEY;
Access : LongWord;
Url : PRegistryUrl;
end;
procedure CloseRegistryKey(AKey: PRegistryKey);
function OpenRegistryKey(AKey: PRegistryKey; AKeyUrl: PRegistryUrl; AIsCanCreate: Boolean): Boolean;
function GetRegistryData(AKey: PRegistryKey; const AKeyName: AnsiString; Buffer: Pointer; BufSize: Integer; var RegData: TRegDataType): Integer;
function DataTypeToRegData(Value: Integer): TRegDataType;
function RegistryReadInteger(AKey: PRegistryKey; const AKeyName: AnsiString): Integer;
implementation
procedure CloseRegistryKey(AKey: PRegistryKey);
begin
if AKey.CurrentKey <> 0 then
begin
//if not LazyWrite then
//RegFlushKey(AKey.CurrentKey);
RegCloseKey(AKey.CurrentKey);
AKey.CurrentKey := 0;
AKey.Url := nil;
end;
end;
function OpenRegistryKey(AKey: PRegistryKey; AKeyUrl: PRegistryUrl; AIsCanCreate: Boolean): Boolean;
var
TempKey: HKey;
S: string;
Disposition: Integer;
Relative: Boolean;
begin
// S := Key;
// Relative := IsRelative(S);
// if not Relative then
// begin
// Delete(S, 1, 1);
// end;
TempKey := 0;
if not AIsCanCreate or (S = '') then
begin
Result := Windows.RegOpenKeyExA(AKey.RootKey, PAnsiChar(AKeyUrl.Path), 0, AKey.Access, TempKey) = ERROR_SUCCESS;
// Result := RegOpenKeyEx(GetBaseKey(Relative), PChar(S), 0, FAccess, TempKey) = ERROR_SUCCESS;
end else
begin
// Result := RegCreateKeyEx(GetBaseKey(Relative), PChar(S), 0, nil,
// REG_OPTION_NON_VOLATILE, FAccess, nil, TempKey, @Disposition) = ERROR_SUCCESS;
end;
if Result then
begin
if (0 <> AKey.CurrentKey) then
begin
//S := CurrentPath + '\' + S;
end;
//ChangeKey(TempKey, S);
end;
end;
function DataTypeToRegData(Value: Integer): TRegDataType;
begin
if Value = REG_SZ then Result := rdString
else if Value = REG_EXPAND_SZ then Result := rdExpandString
else if Value = REG_DWORD then Result := rdInteger
else if Value = REG_BINARY then Result := rdBinary
else Result := rdUnknown;
end;
function GetRegistryData(AKey: PRegistryKey; const AKeyName: AnsiString; Buffer: Pointer; BufSize: Integer; var RegData: TRegDataType): Integer;
var
tmpDataType: Integer;
begin
tmpDataType := REG_NONE;
if RegQueryValueExA(AKey.CurrentKey, PAnsiChar(AKeyName), nil, @tmpDataType, PByte(Buffer), @BufSize) <> ERROR_SUCCESS then
begin
//raise ERegistryException.CreateResFmt(@SRegGetDataFailed, [Name]);
end;
Result := BufSize;
RegData := DataTypeToRegData(tmpDataType);
end;
function RegistryReadInteger(AKey: PRegistryKey; const AKeyName: AnsiString): Integer;
var
tmpRegData: TRegDataType;
begin
GetRegistryData(AKey, AKeyName, @Result, SizeOf(Integer), tmpRegData);
if tmpRegData <> rdInteger then
begin
//ReadError(Name);
end;
end;
function RegistryGetDataInfo(AKey: PRegistryKey; const ValueName: AnsiString; var Value: TRegDataInfo): Boolean;
var
tmpDataType: Integer;
begin
FillChar(Value, SizeOf(TRegDataInfo), 0);
Result := RegQueryValueExA(AKey.CurrentKey, PAnsiChar(ValueName), nil, @tmpDataType, nil, @Value.DataSize) = ERROR_SUCCESS;
Value.RegDataType := DataTypeToRegData(tmpDataType);
end;
function RegistryGetDataSize(AKey: PRegistryKey; const ValueName: AnsiString): Integer;
var
tmpInfo: TRegDataInfo;
begin
if RegistryGetDataInfo(AKey, ValueName, tmpInfo) then
Result := tmpInfo.DataSize
else
Result := -1;
end;
function RegistryReadString(AKey: PRegistryKey; const AKeyName: AnsiString): AnsiString;
var
tmpLen: Integer;
tmpRegData: TRegDataType;
begin
tmpLen := RegistryGetDataSize(AKey, AKeyName);
if tmpLen > 0 then
begin
SetString(Result, nil, tmpLen);
GetRegistryData(AKey, AKeyName, PAnsiChar(Result), tmpLen, tmpRegData);
if (tmpRegData = rdString) or (tmpRegData = rdExpandString) then
begin
//SetLength(Result, StrLen(PAnsiChar(Result)))
end else
begin
//ReadError(Name);
end;
end else
begin
Result := '';
end;
end;
end.
|
unit OEncoding;
interface
{$I OBufferedStreams.inc}
{
LICENSE
Author: Ondrej Pokorny, http://www.kluug.net
License: MPL / GPL / LGPL
}
{$IFDEF O_DELPHI_XE4}
{$ZEROBASEDSTRINGS OFF}
{$ENDIF}
uses SysUtils, OmniXML_Types;
const
//see http://msdn.microsoft.com/en-us/library/windows/desktop/dd317756%28v=vs.85%29.aspx
CP_UNICODE = 1200; // Unicode pseudo-codepage,
CP_UNICODEBE = 1201; // Big-Endian Unicode pseudo-codepage,
WIN_1250 = 1250; // Central European Alphabet (Windows)
WIN_1251 = 1251; // Cyrillic Alphabet (Windows)
WIN_1252 = 1252; // Western Alphabet
WIN_1253 = 1253; // Greek Alphabet (Windows)
WIN_1254 = 1254; // Turkish Alphabet
WIN_1255 = 1255; // Hebrew Alphabet (Windows)
WIN_1256 = 1256; // Arabic Alphabet (Windows)
WIN_1257 = 1257; // Baltic Alphabet (Windows)
WIN_1258 = 1258; // Vietnamese Alphabet (Windows)
ISO_8859_1 = 28591; // Western Alphabet (ISO)
ISO_8859_2 = 28592; // Central European Alphabet (ISO)
ISO_8859_3 = 28593; // Latin 3 Alphabet (ISO)
ISO_8859_4 = 28594; // Baltic Alphabet (ISO)
ISO_8859_5 = 28595; // Cyrillic Alphabet (ISO)
ISO_8859_6 = 28596; // Arabic Alphabet (ISO)
ISO_8859_7 = 28597; // Greek Alphabet (ISO)
ISO_8859_8 = 28598; // Hebrew Alphabet (ISO)
ISO_8859_9 = 28599; // Turkish Alphabet (ISO)
KOI8_R = 20866; // Cyrillic Alphabet (Russian)
KOI8_U = 21866; // Cyrillic Alphabet (Ukrainian)
CP_UTF16 = CP_UNICODE;
CP_UTF16BE = CP_UNICODEBE;
CP_UTF7 = 65000;
CP_UTF8 = 65001;// = 65001; // UTF-8 translation
HEADER_UTF16: WideChar = WideChar($FEFF); // don't change!
type
TCodePage = record
CodePage: Word;
Alias: XmlString;
end;
TCodePages = array[1..26] of TCodePage;
const
CodePages: TCodePages = (
(CodePage: 932; Alias: 'shift-jis'), // Japanese (Shift-JIS)
(CodePage: CP_UTF16; Alias: 'utf-16'), //
(CodePage: CP_UTF16BE; Alias: 'utf-16be'), //
(CodePage: WIN_1250; Alias: 'windows-1250'), // Central European Alphabet (Windows)
(CodePage: WIN_1251; Alias: 'windows-1251'), // Cyrillic Alphabet (Windows)
(CodePage: WIN_1252; Alias: 'windows-1252'), // Western Alphabet
(CodePage: WIN_1253; Alias: 'windows-1253'), // Greek Alphabet (Windows)
(CodePage: WIN_1254; Alias: 'windows-1254'), // Turkish Alphabet
(CodePage: WIN_1255; Alias: 'windows-1255'), // Hebrew Alphabet (Windows)
(CodePage: WIN_1256; Alias: 'windows-1256'), // Arabic Alphabet (Windows)
(CodePage: WIN_1257; Alias: 'windows-1257'), // Baltic Alphabet (Windows)
(CodePage: WIN_1258; Alias: 'windows-1258'), // Vietnamese Alphabet (Windows)
(CodePage: ISO_8859_1; Alias: 'iso-8859-1'), // Western Alphabet (ISO)
(CodePage: ISO_8859_2; Alias: 'iso-8859-2'), // Central European Alphabet (ISO)
(CodePage: ISO_8859_3; Alias: 'iso-8859-3'), // Latin 3 Alphabet (ISO)
(CodePage: ISO_8859_4; Alias: 'iso-8859-4'), // Baltic Alphabet (ISO)
(CodePage: ISO_8859_5; Alias: 'iso-8859-5'), // Cyrillic Alphabet (ISO)
(CodePage: ISO_8859_6; Alias: 'iso-8859-6'), // Arabic Alphabet (ISO)
(CodePage: ISO_8859_7; Alias: 'iso-8859-7'), // Greek Alphabet (ISO)
(CodePage: ISO_8859_8; Alias: 'iso-8859-8'), // Hebrew Alphabet (ISO)
(CodePage: ISO_8859_9; Alias: 'iso-8859-9'), // Turkish Alphabet (ISO)
(CodePage: KOI8_R; Alias: 'koi8-r'), // Cyrillic Alphabet (Russian)
(CodePage: KOI8_U; Alias: 'koi8-u'), // Cyrillic Alphabet (Ukrainian)
(CodePage: 50220; Alias: 'iso-2022-jp'), // Japanese (JIS)
(CodePage: 51932; Alias: 'euc-jp'), // Japanese (EUC)
(CodePage: CP_UTF8; Alias: 'utf-8') // Universal Alphabet (UTF-8)
);
{$IFDEF O_DELPHI_2009}
type
TEncodingBuffer = TBytes;
const
TEncodingBuffer_FirstElement = 0;
{$ELSE}
type
TEncodingBuffer = AnsiString;
const
TEncodingBuffer_FirstElement = 1;
type
TEncoding = class(TObject)
public
class function GetBufferEncoding(const Buffer: TEncodingBuffer; var AEncoding: TEncoding): Integer; overload;
class function GetBufferEncoding(const Buffer: TEncodingBuffer; var AEncoding: TEncoding;
ADefaultEncoding: TEncoding): Integer; overload;
function GetPreamble: TEncodingBuffer; virtual; abstract;
function GetString(const Bytes: TEncodingBuffer): XmlString; virtual; abstract;
function GetBytes(const S: XmlString): TEncodingBuffer; virtual; abstract;
class function GetEncoding(CodePage: Integer): TEncoding;
public
class function IsSingleByte: Boolean; virtual; abstract;
class function IsStandardEncoding(AEncoding: TEncoding): Boolean;
function EncodingName: XmlString; virtual; abstract;
function EncodingAlias: XmlString;
public
class function Default: TEncoding;
class function Unicode: TEncoding;
class function UTF8: TEncoding;
class function ANSI: TEncoding;
class function ASCII: TEncoding;
public
destructor Destroy; override;
end;
TUnicodeEncoding = class(TEncoding)
public
function GetPreamble: TEncodingBuffer; override;
function GetString(const Bytes: TEncodingBuffer): XmlString; override;
function GetBytes(const S: XmlString): TEncodingBuffer; override;
class function IsSingleByte: Boolean; override;
function EncodingName: XmlString; override;
end;
TUTF8Encoding = class(TEncoding)
public
function GetPreamble: TEncodingBuffer; override;
function GetString(const Bytes: TEncodingBuffer): XmlString; override;
function GetBytes(const S: XmlString): TEncodingBuffer; override;
class function IsSingleByte: Boolean; override;
function EncodingName: XmlString; override;
end;
TMBCSEncoding = class(TEncoding)
private
fCodePage: Cardinal;
public
constructor Create(aCodePage: Cardinal);
public
function GetPreamble: TEncodingBuffer; override;
function GetString(const Bytes: TEncodingBuffer): XmlString; override;
function GetBytes(const S: XmlString): TEncodingBuffer; override;
class function IsSingleByte: Boolean; override;
function EncodingName: XmlString; override;
public
property CodePage: Cardinal read fCodePage;
end;
{$ENDIF O_DELPHI_2009}
{$IF NOT DEFINED(FPC) AND (DEFINED(O_DELPHI_2009))}
//Delphi 2009 to 2010
type
TEncodingHelper = class helper for TEncoding
public
{$IF NOT DEFINED(O_DELPHI_XE)}
function EncodingName: String;
{$IFEND}
function EncodingAlias: String;
end;
TMBCSEncodingHelper = class helper for TMBCSEncoding
public
function GetCodePage: Integer;
end;
{$IFEND}
function GetCreateCodePage(const aCodePage: Word): TEncoding; overload;
function GetCreateCodePage(const Alias: string; var aEncoding: TEncoding): Boolean; overload;
function OEncoding_Unicode: TEncoding;
function OEncoding_UTF8: TEncoding;
function OEncoding_Ansi: TEncoding;
implementation
{$IFNDEF O_DELPHI_2009}
{$IF DEFINED(MSWINDOWS)}
uses Windows;
{$ELSEIF DEFINED(FPC)}
uses LConvEncoding;
{$IFEND}
var
fxANSIEncoding: TEncoding = nil;
fxUTF8Encoding: TEncoding = nil;
fxUnicodeEncoding: TEncoding = nil;
fxASCIIEncoding: TEncoding = nil;
{$IF DEFINED(MSWINDOWS) AND NOT DEFINED(O_DELPHI_2009)}
type
_cpinfoExW = record
MaxCharSize: UINT; { max length (bytes) of a char }
DefaultChar: array[0..MAX_DEFAULTCHAR - 1] of Byte; { default character }
LeadByte: array[0..MAX_LEADBYTES - 1] of Byte; { lead byte ranges }
UnicodeDefaultChar: WideChar;
Codepage: UINT;
CodePageName: array[0..MAX_PATH -1] of WideChar;
end;
TCPInfoExW = _cpinfoExW;
function GetCPInfoExW(CodePage: UINT; dwFlags: DWORD; var lpCPInfoEx: TCPInfoExW): BOOL; stdcall; external kernel32 name 'GetCPInfoExW';
{$IFEND}
{$IF DEFINED(FPC) AND NOT DEFINED(MSWINDOWS)}
function UTF8ToCodePage(const S: XmlString; aCodePage: Cardinal): AnsiString;
begin
case aCodePage of
932: Result := UTF8ToCP932(S);
1250: Result := UTF8ToCP1250(S);
1251: Result := UTF8ToCP1251(S);
1252: Result := UTF8ToCP1252(S);
1253: Result := UTF8ToCP1253(S);
1254: Result := UTF8ToCP1254(S);
1255: Result := UTF8ToCP1255(S);
1256: Result := UTF8ToCP1256(S);
1257: Result := UTF8ToCP1257(S);
1258: Result := UTF8ToCP1258(S);
ISO_8859_1: Result := UTF8ToISO_8859_1(S);
ISO_8859_2: Result := UTF8ToISO_8859_2(S);
KOI8_R, KOI8_U: Result := UTF8ToKOI8(S);
else
Result := S;//Encoding not supported by lazarus
end;
end;
function CodePageToUTF8(const S: AnsiString; aCodePage: Cardinal): XmlString;
begin
case aCodePage of
932: Result := CP932ToUTF8(S);
1250: Result := CP1250ToUTF8(S);
1251: Result := CP1251ToUTF8(S);
1252: Result := CP1252ToUTF8(S);
1253: Result := CP1253ToUTF8(S);
1254: Result := CP1254ToUTF8(S);
1255: Result := CP1255ToUTF8(S);
1256: Result := CP1256ToUTF8(S);
1257: Result := CP1257ToUTF8(S);
1258: Result := CP1258ToUTF8(S);
ISO_8859_1: Result := ISO_8859_1ToUTF8(S);
ISO_8859_2: Result := ISO_8859_2ToUTF8(S);
KOI8_R, KOI8_U: Result := KOI8ToUTF8(S);
else
Result := S;//Encoding not supported by lazarus
end;
end;
{$IFEND}
{ TEncoding }
class function TEncoding.ANSI: TEncoding;
begin
if not Assigned(fxANSIEncoding) then begin
{$IFDEF MSWINDOWS}
fxANSIEncoding := TMBCSEncoding.Create(GetACP);
{$ELSE}
fxANSIEncoding := TMBCSEncoding.Create(ISO_8859_1);
{$ENDIF}
end;
Result := fxANSIEncoding;
end;
class function TEncoding.ASCII: TEncoding;
begin
if not Assigned(fxASCIIEncoding) then
fxASCIIEncoding := TMBCSEncoding.Create(1252);
Result := fxASCIIEncoding;
end;
class function TEncoding.Default: TEncoding;
begin
{$IFDEF MSWINDOWS}
Result := ANSI;
{$ELSE}
Result := UTF8;
{$ENDIF}
end;
class function TEncoding.GetBufferEncoding(const Buffer: TEncodingBuffer;
var AEncoding: TEncoding): Integer;
begin
Result := GetBufferEncoding(Buffer, AEncoding, Default);
end;
class function TEncoding.GetBufferEncoding(const Buffer: TEncodingBuffer;
var AEncoding: TEncoding; ADefaultEncoding: TEncoding): Integer;
begin
if (Length(Buffer) >= 3) and (Buffer[1] = #$EF) and (Buffer[2] = #$BB) and (Buffer[3] = #$BF) then begin
AEncoding := UTF8;
Result := 3;
end else if (Length(Buffer) >= 2) and (Buffer[1] = #$FF) and (Buffer[2] = #$FE) then begin
AEncoding := Unicode;
Result := 2;
end else begin
AEncoding := ADefaultEncoding;
Result := 0;
end;
end;
class function TEncoding.Unicode: TEncoding;
begin
if not Assigned(fxUnicodeEncoding) then
fxUnicodeEncoding := TUnicodeEncoding.Create;
Result := fxUnicodeEncoding;
end;
class function TEncoding.UTF8: TEncoding;
begin
if not Assigned(fxUTF8Encoding) then
fxUTF8Encoding := TUTF8Encoding.Create;
Result := fxUTF8Encoding;
end;
class function TEncoding.IsStandardEncoding(AEncoding: TEncoding): Boolean;
begin
Result :=
(AEncoding <> nil) and
((AEncoding = fxANSIEncoding) or
(AEncoding = fxUTF8Encoding) or
(AEncoding = fxUnicodeEncoding) or
(AEncoding = fxASCIIEncoding));
end;
function TEncoding.EncodingAlias: XmlString;
var
xCodePage, I: Integer;
begin
if Self is TMBCSEncoding then
xCodePage := TMBCSEncoding(Self).CodePage
else if Self is TUnicodeEncoding then
xCodePage := CP_UNICODE
else if Self is TUTF8Encoding then
xCodePage := CP_UTF8
else
xCodePage := 0;
for I := Low(CodePages) to High(CodePages) do
if CodePages[I].CodePage = xCodePage then begin
Result := CodePages[I].Alias;
Exit;
end;
Result := IntToStr(xCodePage);
end;
class function TEncoding.GetEncoding(CodePage: Integer): TEncoding;
begin
case CodePage of
CP_UNICODE: Result := TUnicodeEncoding.Create;
//CP_UNICODEBE: Result := TBigEndianUnicodeEncoding.Create;
//CP_UTF7: Result := TUTF7Encoding.Create;
CP_UTF8: Result := TUTF8Encoding.Create;
else
Result := TMBCSEncoding.Create(CodePage);
end;
end;
destructor TEncoding.Destroy;
begin
if (Self = fxANSIEncoding) then
fxANSIEncoding := nil
else if (Self = fxUTF8Encoding) then
fxUTF8Encoding := nil
else if (Self = fxUnicodeEncoding) then
fxUnicodeEncoding := nil
else if (Self = fxASCIIEncoding) then
fxASCIIEncoding := nil;
inherited;
end;
{ TMBCSEncoding }
constructor TMBCSEncoding.Create(aCodePage: Cardinal);
begin
inherited Create;
fCodePage := aCodePage;
end;
function TMBCSEncoding.EncodingName: XmlString;
{$IFDEF MSWINDOWS}
var
LCPInfo: TCPInfoExW;
begin
if GetCPInfoExW(FCodePage, 0, LCPInfo{%H-}) then
Result := LCPInfo.CodePageName
else
Result := IntToStr(fCodePage);
end;
{$ELSE}
begin
Result := IntToStr(fCodePage);
end;
{$ENDIF}
function TMBCSEncoding.GetBytes(const S: XmlString): TEncodingBuffer;
{$IFDEF MSWINDOWS}
var
xLength: integer;
{$IFDEF FPC}
xUS: UnicodeString;
{$ENDIF}
{$ENDIF}
begin
if S = '' then begin
Result := '';
Exit;
end;
{$IFDEF MSWINDOWS}
{$IFDEF FPC}
xUS := UTF8Decode(S);
xLength := WideCharToMultiByte(fCodePage,
WC_COMPOSITECHECK or WC_DISCARDNS or WC_SEPCHARS or WC_DEFAULTCHAR,
PWideChar(@xUS[1]), -1, nil, 0, nil, nil);
SetLength(Result, xLength-1);
if xLength > 1 then
WideCharToMultiByte(codePage,
WC_COMPOSITECHECK or WC_DISCARDNS or WC_SEPCHARS or WC_DEFAULTCHAR,
PWideChar(@xUS[1]), -1, @Result[1], xLength-1, nil, nil);
{$ELSE}
xLength := WideCharToMultiByte(fCodePage,
WC_COMPOSITECHECK or WC_DISCARDNS or WC_SEPCHARS or WC_DEFAULTCHAR,
PWideChar(@S[1]), -1, nil, 0, nil, nil);
SetLength(Result, xLength-1);
if xLength > 1 then
WideCharToMultiByte(codePage,
WC_COMPOSITECHECK or WC_DISCARDNS or WC_SEPCHARS or WC_DEFAULTCHAR,
PWideChar(@S[1]), -1, @Result[1], xLength-1, nil, nil);
{$ENDIF}
{$ELSE}
Result := UTF8ToCodePage(S, fCodePage);
{$ENDIF}
end;
function TMBCSEncoding.GetPreamble: TEncodingBuffer;
begin
Result := '';
end;
function TMBCSEncoding.GetString(const Bytes: TEncodingBuffer): XmlString;
{$IFDEF MSWINDOWS}
var
xLength: integer;
{$IFDEF FPC}
xUS: UnicodeString;
{$ENDIF}
{$ENDIF}
begin
if Bytes = '' then begin
Result := '';
Exit;
end;
{$IFDEF MSWINDOWS}
{$IFDEF FPC}
xLength := MultiByteToWideChar(fCodePage, MB_PRECOMPOSED, PAnsiChar(@Bytes[1]), -1, nil, 0);
SetLength(xUS, xLength-1);
if xLength > 1 then
MultiByteToWideChar(CodePage, MB_PRECOMPOSED, PAnsiChar(@Bytes[1]), -1, PWideChar(@xUS[1]), xLength-1);
Result := UTF8Encode(xUS);
{$ELSE}
xLength := MultiByteToWideChar(fCodePage, MB_PRECOMPOSED, PAnsiChar(@Bytes[1]), -1, nil, 0);
SetLength(Result, xLength-1);
if xLength > 1 then
MultiByteToWideChar(CodePage, MB_PRECOMPOSED, PAnsiChar(@Bytes[1]), -1, PWideChar(@Result[1]), xLength-1);
{$ENDIF}
{$ELSE}
Result := CodePageToUTF8(Bytes, fCodePage);
{$ENDIF}
end;
class function TMBCSEncoding.IsSingleByte: Boolean;
begin
Result := True;
end;
{ TUnicodeEncoding }
function TUnicodeEncoding.EncodingName: XmlString;
begin
{$IFDEF MSWINDOWS}
Result := '1200 (Unicode)';
{$ELSE}
Result := 'Unicode (UTF-16LE)';
{$ENDIF}
end;
function TUnicodeEncoding.GetBytes(const S: XmlString): TEncodingBuffer;
var xCharCount: Integer;
{$IFDEF FPC}
xUS: UnicodeString;
{$ENDIF}
begin
{$IFDEF FPC}
//FPC
xUS := UTF8Decode(S);
xCharCount := Length(xUS);
SetLength(Result, xCharCount*2);
if xCharCount > 0 then begin
Move(xUS[1], Result[1], xCharCount*2);
end;
{$ELSE}
//DELPHI
xCharCount := Length(S);
SetLength(Result, xCharCount*2);
if xCharCount > 0 then begin
Move(S[1], Result[1], xCharCount*2);
end;
{$ENDIF}
end;
function TUnicodeEncoding.GetPreamble: TEncodingBuffer;
begin
SetLength(Result, 2);
Result[1] := #$FF;
Result[2] := #$FE;
end;
function TUnicodeEncoding.GetString(const Bytes: TEncodingBuffer): XmlString;
var
xByteCount: Integer;
{$IFDEF FPC}
xUS: UnicodeString;
{$ENDIF}
begin
xByteCount := Length(Bytes);
if xByteCount = 0 then begin
Result := '';
Exit;
end;
{$IFDEF FPC}
//FPC
SetLength(xUS, xByteCount div 2);
Move(Bytes[1], xUS[1], xByteCount);
Result := UTF8Encode(xUS);
{$ELSE}
//DELPHI
SetLength(Result, xByteCount div 2);
Move(Bytes[1], Result[1], xByteCount);
{$ENDIF}
end;
class function TUnicodeEncoding.IsSingleByte: Boolean;
begin
Result := False;
end;
{ TUTF8Encoding }
function TUTF8Encoding.EncodingName: XmlString;
{$IFDEF MSWINDOWS}
var
LCPInfo: TCPInfoExW;
begin
if GetCPInfoExW(CP_UTF8, 0, LCPInfo{%H-}) then
Result := LCPInfo.CodePageName
else
Result := '65001 (UTF-8)';
end;
{$ELSE}
begin
Result := 'UTF-8';
end;
{$ENDIF}
function TUTF8Encoding.GetBytes(const S: XmlString): TEncodingBuffer;
{$IFNDEF FPC}
var
xCharCount: Integer;
xBuffer: AnsiString;
{$ENDIF}
begin
{$IFDEF FPC}
Result := S;
{$ELSE}
//DELPHI
xBuffer := UTF8Encode(S);
xCharCount := Length(xBuffer);
SetLength(Result, xCharCount);
if xCharCount > 0 then begin
Move(xBuffer[1], Result[TEncodingBuffer_FirstElement], xCharCount);
end;
{$ENDIF}
end;
function TUTF8Encoding.GetPreamble: TEncodingBuffer;
begin
SetLength(Result, 3);
Result[1] := #$EF;
Result[2] := #$BB;
Result[3] := #$BF;
end;
function TUTF8Encoding.GetString(const Bytes: TEncodingBuffer): XmlString;
{$IFNDEF FPC}
var
xBuffer: AnsiString;
xByteCount: Integer;
{$ENDIF}
begin
{$IFDEF FPC}
Result := Bytes;
{$ELSE}
//DELPHI
xByteCount := Length(Bytes);
if xByteCount > 0 then begin
SetLength(xBuffer, xByteCount);
Move(Bytes[1], xBuffer[1], xByteCount);
Result := UTF8Decode(xBuffer);
end else begin
Result := '';
end;
{$ENDIF}
end;
class function TUTF8Encoding.IsSingleByte: Boolean;
begin
Result := False;
end;
{$ENDIF O_DELPHI_2009}
{$IF NOT DEFINED(FPC) AND (DEFINED(O_DELPHI_2009))}
{ TEncodingHelper }
{$IF NOT DEFINED(O_DELPHI_XE)}
function TEncodingHelper.EncodingName: String;
begin
if Self is TMBCSEncoding then
Result := IntToStr(TMBCSEncoding(Self).GetCodePage)
else if Self is TUnicodeEncoding then
Result := IntToStr(CP_UNICODE)
else if Self is TBigEndianUnicodeEncoding then
Result := IntToStr(CP_UNICODEBE)
else
Result := '';
end;
{$IFEND}
function TEncodingHelper.EncodingAlias: String;
var
xCodePage, I: Integer;
begin
if Self is TMBCSEncoding then
xCodePage := TMBCSEncoding(Self).GetCodePage
else if Self is TUnicodeEncoding then
xCodePage := CP_UNICODE
else if Self is TBigEndianUnicodeEncoding then
xCodePage := CP_UNICODEBE
else
xCodePage := 0;
for I := Low(CodePages) to High(CodePages) do
if CodePages[I].CodePage = xCodePage then begin
Result := CodePages[I].Alias;
Exit;
end;
Result := IntToStr(xCodePage);
end;
{ TMBCSEncodingHelper }
function TMBCSEncodingHelper.GetCodePage: Integer;
begin
Result := Self.FCodePage;
end;
{$IFEND}
function OEncoding_Unicode: TEncoding;
begin
Result := TEncoding.Unicode;
end;
function OEncoding_UTF8: TEncoding;
begin
Result := TEncoding.UTF8;
end;
function OEncoding_Ansi: TEncoding;
begin
Result := TEncoding.{$IF DEFINED(O_DELPHI_XE2) OR DEFINED(FPC)}ANSI{$ELSE}ASCII{$IFEND};
end;
function GetCreateCodePage(const aCodePage: Word): TEncoding;
begin
case aCodePage of
CP_UTF8: Result := OEncoding_UTF8;
CP_UTF16: Result := OEncoding_Unicode;
else
Result := TEncoding.GetEncoding(aCodePage);//TMBCSEncoding.Create(aCodePage);
end;
end;
function GetCreateCodePage(const Alias: string; var aEncoding: TEncoding): Boolean;
var
i: Integer;
begin
Result := False;
i := Low(TCodePages);
while (not Result) and (i <= High(TCodePages)) do
begin
Result := CompareText(Alias, CodePages[i].Alias) = 0;
if Result then
aEncoding := GetCreateCodePage(CodePages[i].CodePage)
else
Inc(i);
end;
end;
{$IFNDEF O_DELPHI_2009}
initialization
finalization
fxANSIEncoding.Free;
fxUTF8Encoding.Free;
fxUnicodeEncoding.Free;
fxASCIIEncoding.Free;
{$ENDIF O_DELPHI_2009}
end.
|
unit Unit2;
interface
uses
System.Classes;
type
TMyPropertyRecorder = class
private
FItems: TStringList;
public
constructor Create;
destructor Destroy;
function GetIndexByClass(const AClass: TClass): Integer;
function FindClassByName(const AClassName: string): TClass;
property Items: TStringList read FItems;
procedure Register(const AClass: TClass);
procedure UnRegister(const AClass: TClass);
end;
implementation
{ TMyPropertyRecorder }
function TMyPropertyRecorder.GetIndexByClass(const AClass: TClass): Integer;
begin
Result := FItems.IndexOfObject(TObject(AClass));
end;
constructor TMyPropertyRecorder.Create;
begin
inherited Create;
FItems := TStringList.Create;
end;
destructor TMyPropertyRecorder.Destroy;
begin
FItems.Free;
inherited Destroy;
end;
function TMyPropertyRecorder.FindClassByName(const AClassName: string): TClass;
var
i: Integer;
begin
Result := nil;
for i := 0 to (FItems.Count - 1) do
if (FItems[i] = AClassName) then
begin
Result := TClass(FItems.Objects[i]);
Break;
end;
end;
procedure TMyPropertyRecorder.Register(const AClass: TClass);
begin
if (GetIndexByClass(AClass) = -1) then
FItems.AddObject(AClass.ClassName, TObject(AClass));
end;
procedure TMyPropertyRecorder.UnRegister(const AClass: TClass);
var
i: Integer;
begin
i := GetIndexByClass(AClass);
if (i > -1) then
FItems.Delete(i);
end;
end.
|
// ******************************************************************
//
// Program Name : $ProgramName$
// Platform(s) : $Platforms$
// Framework : VCL
//
// Filename : AT.$ShortName$.DM.ScreenTips.pas/.dfm
// File Version : 1.00
// Date Created : $CreateDate$
// Author : Matthew Vesperman
//
// Description:
//
// $ProgramName$'s global screen tips.
//
// Revision History:
//
// v1.00 : Initial version
//
// ******************************************************************
//
// COPYRIGHT © $Year$ - PRESENT Angelic Technology
// ALL RIGHTS RESERVED WORLDWIDE
//
// ******************************************************************
/// <summary>
/// $ProgramName$'s global screen tips.
/// </summary>
unit AT.ShortName.DM.ScreenTips;
interface
uses
System.Classes, cxClasses, dxScreenTip;
type
/// <summary>
/// Global screen tips data module class.
/// </summary>
TdmScreenTips = class(TDataModule)
stipClipCopy: TdxScreenTip;
stipClipCut: TdxScreenTip;
stipClipPaste: TdxScreenTip;
stipEditRedo: TdxScreenTip;
stipEditUndo: TdxScreenTip;
stipHelpContents: TdxScreenTip;
stipSearchFind: TdxScreenTip;
stipSearchReplace: TdxScreenTip;
stipSelect: TdxScreenTip;
stipSelectAll: TdxScreenTip;
stipSelectInvert: TdxScreenTip;
stipSelectNone: TdxScreenTip;
stipTouchMode: TdxScreenTip;
stipUIRibbon: TdxScreenTip;
stipUIRibModeAH: TdxScreenTip;
stipUIRibModeTC: TdxScreenTip;
stipUIRibModeTO: TdxScreenTip;
stipUIStatusBar: TdxScreenTip;
strepo1: TdxScreenTipRepository;
/// <summary>
/// Data module's OnCreate event handler.
/// </summary>
/// <remarks>
/// Initializes the Screen Tips data module.
/// </remarks>
procedure DataModuleCreate(Sender: TObject);
end;
var
/// <summary>
/// Holds a reference to the global Screen Tips data module.
/// </summary>
dmScreenTips: TdmScreenTips;
/// <summary>
/// Returns a reference to the global Screen Tips data module.
/// </summary>
function ScreenTips: TdmScreenTips
;
implementation
{%CLASSGROUP 'Vcl.Controls.TControl'}
uses
AT.GarbageCollector, AT.ShortName.ResourceStrings,
AT.ShortName.Vcl.Dialogs.SplashDX;
{$R *.dfm}
var
/// <summary>
/// Module level garbage collector object.
/// </summary>
MGC: IATGarbageCollector;
function ScreenTips: TdmScreenTips;
begin
if (NOT Assigned(dmScreenTips)) then
begin
dmScreenTips := TATGC.Collect(TdmScreenTips.Create(NIL), MGC);
end;
Result := dmScreenTips;
end;
procedure TdmScreenTips.DataModuleCreate(Sender: TObject);
begin
//Display startup message in splash screen...
TdlgSplashDX.ChangeStartMessage(rstrStartInitScrTips, 500);
end;
end.
|
{$optimize 7}
{---------------------------------------------------------------}
{ }
{ CCommon }
{ }
{ Common declarations and global data for the compiler. }
{ }
{ Variables: }
{ }
{ bofPtr - pointer to the start of sourceFile }
{ chPtr - pointer to the next character in the file }
{ codegenStarted - have we started the code generator? }
{ debugType - line number debug types }
{ doingFunction - true if processing a function }
{ doingParameters - are we processing parm definitions? }
{ doingPartial - are we doing a partial compile? }
{ enterEditor - enter editor on terminal errors? }
{ expandMacros - should macros be expanded? }
{ firstPtr - points to first char in current line }
{ gotoList - list of goto labels }
{ includeFile - include file name (for return from includes) }
{ infoString - language specific command line info }
{ lastLine - last line number used by pc_nam }
{ liDCB - get/set LInfo DCB }
{ lineNumber - source line number }
{ lint - lint flags }
{ list - generate source listing? }
{ memoryCompile - memory based compile? }
{ nameFound - has a pc_nam been generated? }
{ numErrors - number of errors in the program }
{ objFile - object file name }
{ oldincludeFile - previous includeFile value }
{ partialFile - partial compile list }
{ sourceFile - source file name }
{ terminalErrors - are all errors terminal? }
{ traceBack - generate traceback code? }
{ useGlobalPool - use global (or local) string pool? }
{ wait - wait for keypress after errors? }
{ }
{ doDispose - dispose of the expression tree as we go? }
{ expressionValue - the expression evaluator returns the }
{ value of constant expressions in this variable }
{ expressionType - the type of the expression }
{ expressionTree - for non-constant initializers }
{ isConstant - is the initializer expression constant? }
{ typeSpec - type given by the last declaration specifiers, }
{ specifier-qualifier list, or type name evaluated }
{ }
{ External Subroutines: }
{ }
{ CheckGotoList - Make sure all labels have been defined }
{ ClearHourGlass - Erase the hourglass from the screen }
{ CopyLongString - copy a long string }
{ CopyString - copy a string }
{ DrawHourGlass - Draw the hourglass on the screen }
{ ExitToEditor - do an error exit to the editor }
{ GetLocalLabel - get the next local label number }
{ Hash - find hash displacement }
{ InitCCommon - Initialize this module }
{ ReadFile - read a file }
{ Spin - Spin the spinner }
{ StopSpin - Stop the spinner }
{ SystemError - intercept run time compiler errors }
{ TermError - flag a terminal error }
{ }
{---------------------------------------------------------------}
unit CCommon;
interface
{$segment 'CC'}
const
{hashsize appears in CCOMMON.ASM}
hashSize = 876; {# hash buckets - 1}
hashSize2 = 1753; {# hash buckets * 2 - 1}
maxLine = 255; {max length of a line}
maxPath = 255; {max length of a path name}
{NOTE: maxPath is used in Scanner.asm}
longstringlen = 4000; {max length of a string constant}
minChar = 0; {min ordinal value of source character}
maxChar = 255; {max ordinal value of source character}
{lint masks}
{----------}
lintUndefFn = $0001; {flag use of undefined functions}
lintNoFnType = $0002; {flag functions with no type}
lintNotPrototyped = $0004; {flag functions with no prototypes}
lintPragmas = $0008; {flag unknown pragmas}
lintPrintf = $0010; {check printf/scanf format flags}
lintOverflow = $0020; {check for overflows}
lintC99Syntax = $0040; {check for syntax that C99 disallows}
lintReturn = $0080; {flag issues with how functions return}
{bit masks for GetLInfo flags}
{----------------------------}
flag_d = $10000000; {generate debug code?}
flag_e = $08000000; {abort to editor on terminal error?}
flag_i = $00800000; {ignore symbol files?}
flag_l = $00100000; {list source lines?}
flag_m = $00080000; {memory based compile?}
flag_o = $00020000; {optimize?}
flag_p = $00010000; {print progress info?}
flag_r = $00004000; {rebuild symbol files?}
flag_s = $00002000; {list symbol tables?}
flag_t = $00001000; {treat all errors as terminal?}
flag_w = $00000200; {wait when an error is found?}
versionStr = '2.2.0 B5'; {compiler version}
type
{Misc.}
{-----}
long = record lsw,msw: integer; end; {for extracting words from longints}
longlong = record lo,hi: longint; end; {64-bit integer representation}
cString = packed array [1..256] of char; {null terminated string}
cStringPtr = ^cString;
longString = record {long null terminated string}
length: integer;
str: packed array [1..longstringlen] of char;
end;
longStringPtr = ^longString;
pString = packed array [0..maxLine] of char; {length string}
stringPtr = ^pString;
ptr = ^byte; {general purpose pointer}
handle = ^ptr; {general purpose handle}
gsosInString = record
size: integer;
theString: packed array [1..maxPath] of char;
end;
gsosInStringPtr = ^gsosInString;
{GS/OS class 1 output string}
gsosOutString = record
maxSize: integer;
theString: gsosInString;
end;
gsosOutStringPtr = ^gsosOutString;
{ The base types include two main categories. The values starting }
{ with cg are defined in the code generator, and may be passed to the }
{ code generator for resolution. The cc types are used internally in }
{ the compiler. Any values whose type is cc must be resolved to one }
{ of the cg types before the code generator is called. }
baseTypeEnum = (cgByte,cgUByte,cgWord,cgUWord,cgLong,cgULong,
cgReal,cgDouble,cgComp,cgExtended,cgString,
cgVoid,cgQuad,cgUQuad,ccPointer);
{ Basic types (plus the void type) as defined by the C language. }
{ This differs from baseTypeEnum in that different types with the }
{ same representation are distinguished from each other. }
{ (ctInt32/ctUInt32 are 32-bit int types when using #pragma unix 1.) }
cTypeEnum = (ctChar, ctSChar, ctUChar, ctShort, ctUShort, ctInt, ctUInt,
ctLong, ctULong, ctFloat, ctDouble, ctLongDouble, ctComp,
ctVoid, ctInt32, ctUInt32, ctBool, ctLongLong, ctULongLong);
{tokens}
{------}
{Note: tokenEnum is duplicated in }
{ Table.asm }
tokenEnum = ( {enumeration of the tokens}
ident, {identifiers}
{constants}
{Note: compconst and charconst, etc. }
{ are not found in program code. }
{ They are created only by casts. }
intconst,uintconst,longconst,ulongconst,longlongconst,
ulonglongconst,floatconst,doubleconst,extendedconst,compconst,
charconst,scharconst,ucharconst,stringconst,
{reserved words}
_Alignassy,_Alignofsy,_Atomicsy,_Boolsy,_Complexsy,
_Genericsy,_Imaginarysy,_Noreturnsy,_Static_assertsy,_Thread_localsy,
autosy,asmsy,breaksy,casesy,charsy,
continuesy,constsy,compsy,defaultsy,dosy,
doublesy,elsesy,enumsy,externsy,extendedsy,
floatsy,forsy,gotosy,ifsy,intsy,
inlinesy,longsy,pascalsy,registersy,restrictsy,
returnsy,shortsy,sizeofsy,staticsy,structsy,
switchsy,segmentsy,signedsy,typedefsy,unionsy,
unsignedsy,voidsy,volatilesy,whilesy,
{reserved symbols}
excch,percentch,carotch,andch,asteriskch,
minusch,plusch,eqch,tildech,barch,
dotch,ltch,gtch,slashch,questionch,
lparench,rparench,lbrackch,rbrackch,lbracech,
rbracech,commach,semicolonch,colonch,poundch,
minusgtop,plusplusop,minusminusop,ltltop,gtgtop,
lteqop,gteqop,eqeqop,exceqop,andandop,
barbarop,pluseqop,minuseqop,asteriskeqop,slasheqop,
percenteqop,ltlteqop,gtgteqop,andeqop,caroteqop,
bareqop,poundpoundop,
eolsy,eofsy, {control characters}
typedef, {user types}
uminus,uand,uasterisk, {converted operations}
parameteroper,castoper,opplusplus,opminusminus,
macroParm); {macro language}
{Note: this enumeration also }
{ appears in TABLE.ASM, }
{ SCANNER.asm }
charEnum = {character kinds}
(illegal,ch_special,ch_dash,ch_plus,ch_lt,ch_gt,ch_eq,ch_exc,
ch_and,ch_bar,ch_dot,ch_white,ch_eol,ch_eof,ch_char,ch_string,
ch_asterisk,ch_slash,ch_percent,ch_carot,ch_pound,ch_colon,
ch_backslash,letter,digit);
tokenSet = set of tokenEnum;
tokenClass = (reservedWord,reservedSymbol,identifier,intConstant,longConstant,
longlongConstant,realConstant,stringConstant,macroParameter);
identPtr = ^identRecord; {^ to a symbol table entry}
tokenType = record {a token}
kind: tokenEnum; {kind of token}
numString: stringPtr; {chars in number (macros only)}
case class: tokenClass of {token info}
reservedWord : ();
reservedSymbol: (isDigraph: boolean);
identifier : (name: stringPtr;
symbolPtr: identPtr);
intConstant : (ival: integer);
longConstant : (lval: longint);
longlongConstant: (qval: longlong);
realConstant : (rval: extended);
stringConstant: (sval: longstringPtr;
ispstring: boolean);
macroParameter: (pnum: integer);
end;
{expressions}
{-----------}
expressionKind = ( {kinds of expressions}
preprocessorExpression, {used by preprocessor commands}
arrayExpression, {array subscripts, case labels,
bit-field lengths, enum values}
initializerExpression, {static variable initializers}
autoInitializerExpression, {auto variable initializers}
normalExpression); {for run-time evaluation}
typePtr = ^typeRecord;
tokenPtr = ^tokenRecord;
tokenRecord = record {for operation, operand stacks}
next: tokenPtr; {next token on the stack}
left,middle,right: tokenPtr; {operand paths for operations}
token: tokenType; {token at this node/leaf}
case boolean of
true : (id: identPtr;); {^symbol table entry for this operand}
false: (castType: typePtr;); {cast type (for type casts only)}
end;
{goto label list}
{---------------}
gotoPtr = ^gotoRecord;
gotoRecord = record
{Note: if the size changes, see gotoSize}
next: gotoPtr;
name: stringPtr;
lab: integer;
defined: boolean;
end;
{symbol tables}
{-------------}
{classes of variables in the sym. tbl}
spaceType = (tagSpace,variableSpace,allSpaces,fieldListSpace);
parameterPtr = ^parameterRecord; {prototype parameter list}
parameterRecord = record
next: parameterPtr;
parameter: identPtr;
parameterType: typePtr;
end;
typeQualifierEnum = (tqConst, tqVolatile, tqRestrict);
typeQualifierSet = set of typeQualifierEnum;
typeKind = (scalarType,arrayType,pointerType,functionType,enumType,
enumConst,structType,unionType,definedType);
typeRecord = record {type}
size: longint; {size of the type in bytes}
qualifiers: typeQualifierSet; {type qualifiers}
saveDisp: longint; {disp in symbol file}
case kind: typeKind of {NOTE: aType,pType and fType must overlap}
scalarType : (baseType: baseTypeEnum; {our internal type representation}
cType: cTypeEnum); {type in the C type system}
arrayType : (aType: typePtr;
elements: longint;
);
pointerType : (pType: typePtr;);
functionType: (fType: typePtr; {return type}
varargs, {are there a variable # of args?}
prototyped: boolean; {is it prototyped?}
overrideKR: boolean; {K&R overrides to prototypes?}
parameterList: parameterPtr; {prototyped parameter list}
isPascal: boolean; {pascal parameters?}
toolNum: integer; {non-zero for tool functions}
dispatcher: longint; {dispatch addr}
);
enumConst : (eval: integer;);
enumType : ();
definedType : (dType: typePtr;);
structType,
unionType : (fieldList: identPtr; {field list}
sName: stringPtr; {struct name; for forward refs}
constMember: boolean; {does it have a const member?}
);
end;
initializerPtr = ^initializerRecord; {initializers}
initializerRecord = record
next: initializerPtr; {next record in the chain}
count: integer; {# of duplicate records}
bitdisp: integer; {disp in byte (field lists only)}
bitsize: integer; {width in bits; 0 for byte sizes}
isStructOrUnion: boolean; {is this a struct or union initializer?}
case isConstant: boolean of {is this a constant initializer?}
false: (iTree: tokenPtr);
true : ( {Note: qVal.lo must overlap iVal}
case itype: baseTypeEnum of
cgByte,
cgUByte,
cgWord,
cgUWord,
cgLong,
cgULong : (iVal: longint);
cgQuad,
cgUQuad : (qVal: longlong);
cgString : (sVal: longstringPtr);
cgReal,
cgDouble,
cgComp,
cgExtended: (rVal: extended);
cgVoid,
ccPointer: (
pVal: longint;
pPlus: boolean;
case isName: boolean of
true : (pName: stringPtr);
false: (pStr : longstringPtr);
);
);
end;
storageType = (stackFrame,parameter,external,global,none,private);
stateKind = (declared,defined,initialized);
identRecord = record {identifier}
next: identPtr; {next symbol in this hash bucket}
saved: boolean; {has the symbol been saved (hashed) in the symbol file?}
name: stringPtr; {symbol name}
itype: typePtr; {symbol type}
disp: longint; {disp past start of struct (field lists only)}
bitDisp: integer; {disp in byte (field lists only)}
{parameter number (K&R parms only)}
bitsize: integer; {width in bits; 0 for byte sizes}
state: stateKind; {state of the definition}
iPtr: initializerPtr; {pointer to the first initializer}
isForwardDeclared: boolean; {does this var use a forward declared type?}
class: tokenEnum; {storage class}
case storage: storageType of
stackFrame: (lln: integer); {local label #}
parameter: (pln: integer; {paramater label #}
pdisp: integer; {disp of parameter}
pnext: identPtr); {next parameter}
external: ();
global,private: ();
none: ();
end;
{mini-assembler}
{--------------}
{opcodes}
opcode = (o_adc,o_and,o_asl,o_bit,o_cmp,o_cop,o_cpx,o_cpy,o_dec,o_eor,
o_inc,o_jml,o_jmp,o_jsl,o_jsr,o_lda,o_ldx,o_ldy,o_lsr,o_ora,
o_pea,o_pei,o_rep,o_rol,o_ror,o_sbc,o_sep,o_sta,o_stx,o_sty,
o_stz,o_trb,o_tsb,
o_dcb,o_dcw,o_dcl,
o_brk,o_wdm,
o_mvn,o_mvp,
o_bcc,o_bcs,o_beq,o_bmi,o_bne,o_bpl,o_bra,o_brl,o_per,o_bvc,
o_bvs,
o_clc,o_cld,o_cli,o_clv,o_dex,o_dey,o_inx,o_iny,o_nop,o_pha,
o_phb,o_phd,o_phk,o_php,o_phx,o_phy,o_pla,o_plb,o_pld,o_plp,
o_plx,o_ply,o_rti,o_rtl,o_rts,o_sec,o_sed,o_sei,o_stp,o_tax,
o_tay,o_tcd,o_tcs,o_tdc,o_tsc,o_tsx,o_txa,o_txs,o_txy,o_tya,
o_tyx,o_wai,o_xba,o_xce);
{addressing modes}
operands = (acc,imm,dp,dp_x,dp_y,op,op_x,op_y,i_dp_x,i_dp_y,dp_s,li_dp,la,
i_dp,i_op,i_la,i_op_x,i_dp_s_y,li_dp_y,long_x);
{work variables}
{--------------}
tempPtr = ^tempRecord;
tempRecord = record
last,next: tempPtr; {doubly linked list}
labelNum: integer; {label number}
size: integer; {size of the variable}
end;
{ORCA Shell and ProDOS}
{---------------------}
timeField = array[1..8] of byte;
optionListRecord = record
totalSize: integer;
requiredSize: integer;
fileSysID: integer;
theData: packed array [1..100] of char;
end;
optionListPtr = ^optionListRecord;
fastFileDCBGS = record
pcount: integer;
action: integer;
index: integer;
flags: integer;
fileHandle: handle;
pathName: gsosInStringPtr;
access: integer;
fileType: integer;
auxType: longint;
storageType: integer;
createDate: timeField;
modDate: timeField;
option: optionListPtr;
fileLength: longint;
blocksUsed: longint;
end;
getLInfoDCBGS = record
pcount: integer;
sFile: gsosOutStringPtr;
dFile: gsosOutStringPtr;
namesList: gsosOutStringPtr;
iString: gsosOutStringPtr;
merr: byte;
merrf: byte;
lops: byte;
kFlag: byte;
mFlags: longint;
pFlags: longint;
org: longint;
end;
getPrefixOSDCB = record
pcount: integer;
prefixNum: integer;
prefix: gsosOutStringPtr;
end;
versionDCBGS = record
pcount: integer;
version: packed array[1..4] of char;
end;
{---------------------------------------------------------------}
var
{misc}
{----}
bofPtr: ptr; {pointer to the start of sourceFile}
chPtr: ptr; {pointer to the next character in the file}
{debugType is also in SCANNER.ASM}
debugType: (stop,break,autogo); {line number debug types}
doingParameters: boolean; {are we processing parm definitions?}
expandMacros: boolean; {should macros be expanded?}
ffDCBGS: fastFileDCBGS; {fast file DCB}
firstPtr: ptr; {points to first char in current line}
gotoList: gotoPtr; {list of goto labels}
includeFileGS: gsosOutString; {include file name (for return from includes)}
infoStringGS: gsosOutString; {language specific command line info}
intLabel: integer; {last used label number}
languageNumber: integer; {our language number}
lastLine: 0..maxint; {last line number used by pc_nam}
liDCBGS: getLInfoDCBGS; {get/set LInfo DCB}
lineNumber: 0..maxint; {source line number}
nameFound: boolean; {has a pc_nam been generated?}
nextLocalLabel: integer; {next available local data label number}
numErrors: integer; {number of errors in the program}
objFile: gsosOutString; {object file name}
oldincludeFileGS: gsosOutString; {previous includeFile value}
outFileGS: gsosOutString; {keep file name}
partialFileGS: gsosOutString; {partial compile list}
sourceFileGS: gsosOutString; {debug source file name}
tempList: tempPtr; {list of temp work variables}
longlong0: longlong; {the value 0 as a longlong}
longlong1: longlong; {the value 1 as a longlong}
{expression results}
{------------------}
doDispose: boolean; {dispose of the expression tree as we go?}
realExpressionValue: extended; {value of the last real constant expression}
llExpressionValue: longlong; {value of the last long long constant expression}
expressionValue: longint; {value of the last constant expression}
expressionType: typePtr; {the type of the expression}
initializerTree: tokenPtr; {for non-constant initializers}
isConstant: boolean; {is the initializer expression constant?}
expressionIsLongLong: boolean; {is the last constant expression long long?}
{type specifier results}
{----------------------}
typeSpec: typePtr; {type specifier}
{flags}
{-----}
codegenStarted: boolean; {have we started the code generator?}
doingFunction: boolean; {are we processing a function?}
doingPartial: boolean; {are we doing a partial compile?}
enterEditor: boolean; {enter editor on terminal errors?}
foundFunction: boolean; {has a function been found?}
lint: integer; {lint flags}
list: boolean; {generate source listing?}
ignoreSymbols: boolean; {ignore .sym file?}
memoryCompile: boolean; {memory based compile?}
printSymbols: boolean; {+s flag set?}
progress: boolean; {write progress info?}
rebuildSymbols: boolean; {rebuild .sym file?}
switchLanguages: boolean; {switch languages on exit?}
terminalErrors: boolean; {are all errors terminal?}
traceBack: boolean; {generate traceback code?}
unix_1: boolean; {is int 32 bits? (or 16 bits)}
useGlobalPool: boolean; {use global (or local) string pool?}
wait: boolean; {wait for keypress after errors?}
lintIsError: boolean; {treat lint messages as errors?}
fIsNoreturn: boolean; {is the current function _Noreturn?}
doingMain: boolean; {are we processing the main function?}
fenvAccess: boolean; {is the FENV_ACCESS pragma on?}
fenvAccessInFunction: boolean; {was FENV_ACCESS on anywhere in current function?}
{syntactic classes of tokens}
{---------------------------}
specifierQualifierListElement: tokenSet;
topLevelDeclarationStart: tokenSet;
{---------------------------------------------------------------}
{ORCA Shell and ProDOS}
{---------------------}
procedure GetLInfoGS (var parms: getLInfoDCBGS); prodos ($0141);
procedure FastFileGS (var parms: fastFileDCBGS); prodos ($014E);
procedure SetLInfoGS (var parms: getLInfoDCBGS); prodos ($0142);
procedure GetPrefixGS (var parms: getPrefixOSDCB); prodos ($200A);
procedure VersionGS (var parms: versionDCBGS); prodos ($0147);
{---------------------------------------------------------------}
procedure CheckGotoList;
{ Make sure all labels have been defined }
procedure ClearHourGlass;
{ Erase the hourglass from the screen }
procedure CopyLongString (toPtr, fromPtr: longStringptr);
{ copy a long string }
{ }
{ parameters: }
{ toPtr - location to copy to }
{ fromPtr - location to copy from }
procedure CopyString (toPtr, fromPtr: ptr); extern;
{ copy a string }
{ }
{ parameters: }
{ toPtr - location to copy to }
{ fromPtr - location to copy from }
procedure DrawHourGlass;
{ Draw the hourglass on the screen }
procedure ExitToEditor (msg: stringPtr; disp: longint);
{ do an error exit to the editor }
{ }
{ parameters: }
{ msg - pointer to the error message }
{ disp - displacement into the error file }
{ }
{ variables: }
{ includeFile - source file name }
function GenLabel: integer;
{ generate the next local label, checking for too many }
function GetLocalLabel: integer;
{ get the next local label number }
function Hash (sPtr: stringPtr): integer; extern;
{ find hash displacement }
{ }
{ Finds the displacement into an array of pointers using a }
{ hash function. }
{ }
{ parameters: }
{ sPtr - points to string to find hash for }
procedure InitCCommon;
{ Initialize this module }
procedure ReadFile;
{ read a file }
{ }
{ variables: }
{ bofPtr - pointer to the start of the file }
{ ffDCB.file_length - length of the file }
{ includeFile - source file name }
procedure Spin;
{ Spin the spinner }
{ }
{ Notes: Starts the spinner if it is not already in use }
procedure StopSpin;
{ Stop the spinner }
{ }
{ Notes: The call is safe, and ignored, if the spinner is }
procedure SystemError (errNo: integer);
{ intercept run time compiler errors }
procedure TermError (errnum: integer);
{ flag a terminal error }
{---------------------------------------------------------------}
implementation
const
{Note: maxLabel is also defined in cgi.pas}
{Note: maxlabel is also defined in CGC.asm}
maxLabel = 3200; {max # compiler generated labels}
{spinner}
{-------}
spinSpeed = 8; {calls before one spinner move}
type
consoleOutDCBGS = record
pcount: integer;
ch: char;
end;
var
{spinner}
{-------}
spinning: boolean; {are we spinning now?}
spinDisp: integer; {disp to the spinner character}
spinCount: integer; {spin loop counter}
spinner: array[0..3] of char; {spinner characters}
procedure Error (err: integer); extern; {in scanner.pas}
{ flag an error }
{ }
{ err - error number }
{procedure Error2 (loc, err: integer); extern; {debug} {in scanner.pas}
{ flag an error }
{ }
{ loc - error location }
{ err - error number }
procedure MMQuit; extern; {in mm.pas}
{ Dispose of memory allocated with private user IDs }
procedure ConsoleOutGS (var parms: consoleOutDCBGS); prodos ($015A);
{---------------------------------------------------------------}
procedure CheckGotoList;
{ Make sure all labels have been defined }
var
gt: gotoPtr; {work pointer}
msg: stringPtr; {work string}
begin {CheckGotoList}
gt := gotoList;
while gt <> nil do begin
if not gt^.defined then begin
numErrors := numErrors+1;
new(msg);
msg^ := concat('Undefined label: ', gt^.name^);
writeln(msg^);
if terminalErrors then begin
if enterEditor then
ExitToEditor(msg, ord4(firstPtr)-ord4(bofPtr))
else
TermError(0);
end; {if}
dispose(msg);
end; {if}
gt := gt^.next;
end; {while}
end; {CheckGotoList}
procedure ClearHourGlass;
{ Erase the hourglass from the screen }
var
coRec: consoleOutDCBGS; {Console out record}
begin {ClearHourGlass}
coRec.pcount := 1;
coRec.ch := ' '; ConsoleOutGS(coRec);
coRec.ch := chr(8); ConsoleOutGS(coRec);
end; {ClearHourGlass}
procedure CopyLongString {toPtr, fromPtr: longStringPtr};
{ copy a long string }
{ }
{ parameters: }
{ toPtr - location to copy to }
{ fromPtr - location to copy from }
var
i: integer; {loop variable}
begin {CopyLongString}
toPtr^.length := fromPtr^.length; {set the length}
for i := 1 to fromPtr^.length do
toPtr^.str[i] := fromPtr^.str[i];
end; {CopyLongString}
procedure DrawHourGlass;
{ Draw the hourglass on the screen }
var
coRec: consoleOutDCBGS; {Console out record}
begin {DrawHourGlass}
coRec.pcount := 1;
coRec.ch := chr(27); ConsoleOutGS(coRec);
coRec.ch := chr(15); ConsoleOutGS(coRec);
coRec.ch := 'C'; ConsoleOutGS(coRec);
coRec.ch := chr(24); ConsoleOutGS(coRec);
coRec.ch := chr(14); ConsoleOutGS(coRec);
coRec.ch := chr(8); ConsoleOutGS(coRec);
end; {DrawHourGlass}
procedure ExitToEditor {msg: stringPtr; disp: longint};
{ do an error exit to the editor }
{ }
{ parameters: }
{ msg - pointer to the error message }
{ disp - displacement into the error file }
{ }
{ variables: }
{ includeFile - source file name }
var
msgGS: gsosInString; {message}
begin {ExitToEditor}
msgGS.size := length(msg^); {set up the error message}
msgGS.theString := msg^;
liDCBGS.org := disp; {mark the error}
liDCBGS.namesList := @msgGS;
liDCBGS.lops := 0; {prevent re-entry}
liDCBGS.merrf := 255;
with liDCBGS do begin
sFile := pointer(ord4(sFile)+2);
dFile := pointer(ord4(dFile)+2);
iString := pointer(ord4(iString)+2);
end; {with}
SetLInfoGS(liDCBGS);
StopSpin; {stop the spinner}
MMQuit; {dispose of the memory pools}
halt(-1); {return to the shell}
end; {ExitToEditor}
function GenLabel{: integer};
{ generate the next local label, checking for too many }
begin {GenLabel}
if intLabel < maxLabel then
intLabel := intLabel+1
else begin
intLabel := 0;
Error(58);
end;
GenLabel := intLabel;
end; {GenLabel}
function GetLocalLabel{: integer};
{ get the next local label number }
begin {GetLocalLabel}
GetLocalLabel := nextLocalLabel;
nextLocalLabel := nextLocalLabel+1;
end; {GetLocalLabel}
procedure InitCCommon;
{ Initialize this module }
begin {InitCCommon}
spinning := false; {not spinning the spinner}
spinDisp := 0; {start spinning with the first character}
spinner[0] := '|'; {set up the spinner characters}
spinner[1] := '/';
spinner[2] := '-';
spinner[3] := '\';
longlong0.hi := 0;
longlong0.lo := 0;
longlong1.hi := 0;
longlong1.lo := 1;
end; {InitCCommon}
procedure ReadFile;
{ read a file }
{ }
{ variables: }
{ bofPtr - pointer to the start of the file }
{ ffDCB.file_length - length of the file }
{ includeFile - source file name }
const
SRC = $B0; {source file type}
begin {ReadFile}
with ffDCBGS do begin {read the source file}
pCount := 14;
action := 0;
flags := $C000;
pathName := @includeFileGS.theString;
end; {with}
FastFileGS(ffDCBGS);
if ToolError <> 0 then begin
sourceFileGS := includeFileGS;
includeFileGS := oldincludeFileGS;
TermError(1);
end; {if}
if ffDCBGS.fileType <> SRC then begin
includeFileGS := oldincludeFileGS;
TermError(6);
end; {if}
bofPtr := ffDCBGS.fileHandle^; {set beginning of file pointer}
end; {ReadFile}
procedure Spin;
{ Spin the spinner }
{ }
{ Notes: Starts the spinner if it is not already in use }
var
coRec: consoleOutDCBGS; {Console out record}
begin {Spin}
if not spinning then begin
spinning := true;
spinCount := spinSpeed;
end; {if}
spinCount := spinCount - 1;
if spinCount = 0 then begin
spinCount := spinSpeed;
spinDisp := spinDisp - 1;
if spinDisp < 0 then
spinDisp := 3;
coRec.pcount := 1;
coRec.ch := spinner[spinDisp];
ConsoleOutGS(coRec);
coRec.ch := chr(8);
ConsoleOutGS(coRec);
end; {if}
end; {Spin}
procedure StopSpin;
{ Stop the spinner }
{ }
{ Notes: The call is safe, and ignored, if the spinner is }
{ inactive. }
var
coRec: consoleOutDCBGS; {Console out record}
begin {StopSpin}
if spinning then begin
spinning := false;
coRec.pcount := 1;
coRec.ch := ' ';
ConsoleOutGS(coRec);
coRec.ch := chr(8);
ConsoleOutGS(coRec);
end; {if}
end; {StopSpin}
procedure SystemError {errNo: integer};
{ intercept run time compiler errors }
begin {SystemError}
if errNo = 5 then
TermError(5)
else
TermError(3);
end; {SystemError}
procedure TermError {errnum: integer};
{ flag a terminal error }
var
msg: pString; {terminal error message}
begin {TermError}
case errnum of {print the error}
0 : msg := '' ;
1 : msg := concat('Error reading ', sourceFileGS.theString.theString);
2 : msg := concat('Error purging ', sourceFileGS.theString.theString);
3 : msg := 'terminal compiler error';
4 : msg := 'user termination';
5 : msg := 'out of memory';
6 : msg := 'source files must have a file type of SRC';
7 : msg := 'you cannot change languages with an include directive';
8 : msg := 'you cannot change languages from an included file';
9 : msg := concat('Error writing ', objFile.theString.theString);
10: msg := 'ORCA/C requires version 2.0 or later of the shell';
11: msg := 'The program is too large to compile to memory -- use Compile to Disk';
12: msg := 'Invalid sym file detected. Re-run ORCA/C to proceed.';
otherwise: begin
msg := '';
Error(57);
end;
end; {case}
with ffDCBGS do begin {purge the source file}
pCount := 5;
action := 7;
pathName := @includeFileGS.theString;
end; {with}
FastFileGS(ffDCBGS);
writeln('Terminal error: ', msg); {write the error to stdout}
if enterEditor then {error exit to editor}
ExitToEditor(@msg, ord4(chPtr) - ord4(bofPtr))
else begin
liDCBGS.lops := 0; {prevent re-entry}
liDCBGS.merrf := 127;
with liDCBGS do begin
sFile := pointer(ord4(sFile)+2);
dFile := pointer(ord4(dFile)+2);
namesList := pointer(ord4(namesList)+2);
iString := pointer(ord4(iString)+2);
end; {with}
SetLInfoGS(liDCBGS);
StopSpin; {stop the spinner}
MMQuit; {dispose of the memory pools}
halt(-1); {return to the shell}
end; {else}
end; {TermError}
end.
{$append 'ccommon.asm'}
|
{
mteBase Tests
Tests for functions in mteBase
}
unit mteBaseTests;
uses 'lib\mteBase', 'lib\jvTest';
const
mteTestVersion = '0.0.0.1';
{
mteVersionTest:
Raises an exception if the testing suite is not
built to target the version of mteFunctions the
user is running.
}
procedure mteVersionTest;
begin
if mteVersion <> mteTestVersion then
raise Exception.Create('mteBaseTests - These tests are meant to be '+
'run on mteFunctions v'+mteTestVersion+', you are running '+
mteVersion+'. Testing terminated.');
end;
{
TestMteBase:
Tests the functions in mteBase using the jvTest
framework.
}
procedure TestMteBase;
var
bCaughtException: boolean;
xEditVersion: string;
begin
(*** VersionCompare Tests ***)
Describe('VersionCompare');
try
// Test with an empty string
Describe('Empty string input for version');
try
bCaughtException := false;
try
VersionCompare('0', '');
except
on x: Exception do begin
bCaughtException := true;
ExpectEqual(x.Message, 'VersionCompare: Version is empty string',
'Should raise the correct exception');
end;
end;
Expect(bCaughtException, 'Should have raised an exception');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with non-numeric characters
Describe('Non-numeric version');
try
bCaughtException := false;
try
VersionCompare('0.1a', '0.2');
except
on x: Exception do begin
bCaughtException := true;
ExpectEqual(x.Message, '''''1a'''' is not a valid integer value',
'Should raise the correct exception');
end;
end;
Expect(bCaughtException, 'Should have raised an exception');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with equal versions
Describe('Equal versions');
try
bCaughtException := false;
ExpectEqual(VersionCompare('62', '62'), 0, '1 clause version: Should return 0');
ExpectEqual(VersionCompare('0.1.2.3', '0.1.2.3'), 0, '4 clause version: Should return 0');
ExpectEqual(VersionCompare('0.1.2.3.4.5.6.7.8.9', '0.1.2.3.4.5.6.7.8.9'), 0, '10 clause version: Should return 0');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with second version newer than first
Describe('Second version newer than first');
try
bCaughtException := false;
ExpectEqual(VersionCompare('0.1.2.3', '0.1.2.4'), 1, 'Difference in first clause from right should return 1');
ExpectEqual(VersionCompare('0.1.2.3', '0.1.3.3'), 2, 'Difference in second clause from right should return 2');
ExpectEqual(VersionCompare('0.1.2.3', '0.2.2.3'), 3, 'Difference in third clause from right should return 3');
ExpectEqual(VersionCompare('0.1.2.3', '1.1.2.3'), 4, 'Difference in fourth clause from right should return 4');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with second version older than first
Describe('Second version older than first');
try
bCaughtException := false;
ExpectEqual(VersionCompare('0.1.2.4', '0.1.2.3'), -1, 'Difference in first clause from right should return -1');
ExpectEqual(VersionCompare('0.1.3.3', '0.1.2.3'), -2, 'Difference in second clause from right should return -2');
ExpectEqual(VersionCompare('0.2.2.3', '0.1.2.3'), -3, 'Difference in third clause from right should return -3');
ExpectEqual(VersionCompare('1.1.2.3', '0.1.2.3'), -4, 'Difference in fourth clause from right should return -4');
Pass;
except
on x: Exception do Fail(x);
end;
// All tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** VersionToString Tests ***)
Describe('VersionToString');
try
// Test with version = 0
Describe('Version = 0');
try
ExpectEqual(VersionToString(0), '0.0.0', 'Should return 0.0.0');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with build = 255
Describe('Version = 255');
try
ExpectEqual(VersionToString(255), '0.0.0', 'Should return 0.0.0');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with version = $FFFFFFFF
Describe('Version = $FFFFFFFF');
try
ExpectEqual(VersionToString($FFFFFFFF), '255.255.255', 'Should return 255.255.255');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with version = $FF804020
Describe('Version = $FF804020');
try
ExpectEqual(VersionToString($FF804020), '255.128.64', 'Should return 255.128.64');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** ShortenVersion Tests ***)
Describe('ShortenVersion');
try
// Test with empty version
Describe('Empty string input for version');
try
ExpectEqual(ShortenVersion('', 4), '', 'Should return an empty string');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with too many clauses
Describe('Too many clauses');
try
ExpectEqual(ShortenVersion('1.2.3', 4), '1.2.3', 'Should return input version');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with zero clauses
Describe('Zero clauses');
try
ExpectEqual(ShortenVersion('1.2.3', 0), '', 'Should return an empty string');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with zero clauses
Describe('Equal clauses');
try
ExpectEqual(ShortenVersion('1.2.3', 3), '1.2.3', 'Should return input version');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with an empty clause
Describe('Empty clause');
try
ExpectEqual(ShortenVersion('1..3.4', 3), '1..3', 'Should return empty clause');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with multi-digit clauses
Describe('Multi-digit clauses');
try
ExpectEqual(ShortenVersion('102.304.506.708.9010.11012.13014.15016', 6),
'102.304.506.708.9010.11012', 'Should return multi-digit clauses');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** xEditVersionCheck Tests ***)
Describe('xEditVersionCheck');
try
// Test with empty version
Describe('Empty string input for version');
try
bCaughtException := false;
try
xEditVersionCheck('', '255.0.0');
except
on x: Exception do begin
bCaughtException := true;
ExpectEqual(x.Message, 'VersionCompare: Version is empty string',
'Should raise the correct exception');
end;
end;
Expect(bCaughtException, 'Should have raised an exception');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with version with invalid number of clauses
Describe('Invalid number of clauses');
try
bCaughtException := false;
try
xEditVersionCheck('3.0.1.1', '255.255.255.0');
except
on x: Exception do begin
bCaughtException := true;
ExpectEqual(x.Message, 'VersionCompare: Versions have a different number of version clauses',
'Should raise the correct exception');
end;
end;
Expect(bCaughtException, 'Should have raised an exception');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with minVersion = xEditVersion = maxVersion
Describe('minVersion = xEditVersion = maxVersion');
try
xEditVersion := VersionToString(wbVersionNumber);
ExpectEqual(xEditVersionCheck(xEditVersion, xEditVersion), true, 'Should return true');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with minVersion > xEditVersion
Describe('minVersion > xEditVersion');
try
xEditVersion := VersionToString(wbVersionNumber);
ExpectEqual(xEditVersionCheck(VersionToString(wbVersionNumber + $100), xEditVersion), false, 'Should return false');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with maxVersion < xEditVersion
Describe('maxVersion < xEditVersion');
try
xEditVersion := VersionToString(wbVersionNumber);
ExpectEqual(xEditVersionCheck(xEditVersion, VersionToString(wbVersionNumber - $100)), false, 'Should return false');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with maxVersion < xEditVersion
Describe('minVersion > xEditVersion > maxVersion');
try
ExpectEqual(xEditVersionCheck(VersionToString(wbVersionNumber - $200),
VersionToString(wbVersionNumber + $200)), true, 'Should return true');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** xEditGameCheck Tests ***)
Describe('xEditGameCheck');
try
// No supported games
Describe('No supported games');
try
Expect(not xEditGameCheck(''), 'Should return false');
Pass;
except
on x: Exception do Fail(x);
end;
// Only current game mode supported
Describe('Only current game mode supported');
try
Expect(xEditGameCheck(wbAppName), 'Should return true');
Pass;
except
on x: Exception do Fail(x);
end;
// Other game modes supported
Describe('Other game modes supported');
try
Expect(xEditGameCheck('Example,'+wbAppName), 'Should return true');
Pass;
except
on x: Exception do Fail(x);
end;
// Other game modes supported
Describe('Game modes supported, but not current game mode');
try
Expect(not xEditGameCheck(wbAppName+'1,2'+wbAppName), 'Should return false');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** VersionCheck Tests ***)
Describe('VersionCheck');
try
// same versions
Describe('Equal versions');
try
ExpectEqual(VersionCheck('2', '2'), vcEqual, '1 clause version: Should return vcEqual');
ExpectEqual(VersionCheck('0.1.2.3', '0.1.2.3'), vcEqual, '4 clause version: Should return vcEqual');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.7.8.9', '0.1.2.3.4.5.6.7.8.9'), vcEqual, '10 clause version: Should return vcEqual');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with second version newer than first
Describe('Second version newer than first');
try
ExpectEqual(VersionCheck('2', '3'), vcNewer, '1 clause version: Should return vcNewer');
ExpectEqual(VersionCheck('0.1.2.3', '0.1.2.4'), vcNewer, '4 clause version: Difference in first clause should return vcNewer');
ExpectEqual(VersionCheck('0.1.2.3', '0.1.3.3'), vcNewer, '4 clause version: Difference in second clause should return vcNewer');
ExpectEqual(VersionCheck('0.1.2.3', '0.2.2.3'), vcNewerBroken, '4 clause version: Difference in third clause should return vcNewerBroke');
ExpectEqual(VersionCheck('0.1.2.3', '1.1.2.3'), vcNewerBroken, '4 clause version: Difference in fourth clause should return vcNewerBroke');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.7.8.9', '0.1.2.3.4.5.6.7.8.10'), vcNewer,
'10 clause version: Difference in first clause should return vcNewer');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.7.8.9', '0.1.2.3.4.5.6.8.8.9'), vcNewerBroken,
'10 clause version: Difference in third clause should return vcNewerBroke');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.7.8.9', '1.1.2.3.4.5.6.7.8.9'), vcNewerBroken,
'10 clause version: Difference in tenth clause should return vcNewerBroke');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with second version newer than first
Describe('Second version older than first');
try
ExpectEqual(VersionCheck('3', '2'), vcOlder, '1 clause version: Should return vcOlder');
ExpectEqual(VersionCheck('0.1.2.4', '0.1.2.3'), vcOlder, '4 clause version: Difference in first clause should return vcOlder');
ExpectEqual(VersionCheck('0.1.3.3', '0.1.2.3'), vcOlder, '4 clause version: Difference in second clause should return vcOlder');
ExpectEqual(VersionCheck('0.2.2.3', '0.1.2.3'), vcOlderBroken, '4 clause version: Difference in third clause should return vcOlderBroke');
ExpectEqual(VersionCheck('1.1.2.3', '0.1.2.3'), vcOlderBroken, '4 clause version: Difference in fourth clause should return vcOlderBroke');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.7.8.10', '0.1.2.3.4.5.6.7.8.9'), vcOlder,
'10 clause version: Difference in first clause should return vcOlder');
ExpectEqual(VersionCheck('0.1.2.3.4.5.6.8.8.9', '0.1.2.3.4.5.6.7.8.9'), vcOlderBroken,
'10 clause version: Difference in third clause should return vcOlderBroke');
ExpectEqual(VersionCheck('1.1.2.3.4.5.6.7.8.9', '0.1.2.3.4.5.6.7.8.9'), vcOlderBroken,
'10 clause version: Difference in tenth clause should return vcOlderBroke');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
(*** mteVersionCheck Tests ***)
Describe('mteVersionCheck');
try
// Test with mteVersion
Describe('Target version = mteVersion');
try
ExpectEqual(mteVersionCheck(mteVersion), vcEqual, 'Should return vcEqual');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with 0.0.0.0
Describe('Target version = -255.-255.-255.-255');
try
ExpectEqual(mteVersionCheck('-255.-255.-255.-255'), vcNewerBroken, 'Should return vcNewerBroken');
Pass;
except
on x: Exception do Fail(x);
end;
// Test with 255.255.255.255
Describe('Target version = 255.255.255.255');
try
ExpectEqual(mteVersionCheck('255.255.255.255'), vcOlderBroken, 'Should return vcOlderBroken');
Pass;
except
on x: Exception do Fail(x);
end;
// all tests passed?
Pass;
except
on x: Exception do Fail(x);
end;
end;
{******************************************************************************}
{ ENTRY POINTS
Entry points for when the script is run in xEdit.
- Initialize
}
{******************************************************************************}
function Initialize: Integer;
begin
// don't perform tests if on wrong version
mteVersionTest;
jvtInitialize;
// perform tests
TestMteBase;
// finalize jvt
jvtPrintReport;
jvtFinalize;
end;
end. |
unit ResultPoint;
{
* Copyright 2008 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* Implemented by E. Spelt for Delphi
}
interface
uses SysUtils, MathUtils;
type
byteArray = array of byte;
TResultPoint = class
private
Fx, Fy: single;
bytesX, bytesY: byteArray;
FToString: string;
class function crossProductZ(pointA, pointB, pointC: TResultPoint)
: single; static;
public
constructor Create(pX, pY: single);
destructor Destroy(); override;
function Equals(other: TObject): Boolean; override;
function GetHashCode(): Integer; override;
function ToString(): String; override;
class procedure OrderBestPatterns(patterns: TArray<TResultPoint>); static;
class function Distance(pattern1, pattern2: TResultPoint): single; static;
property x: single read Fx write Fx;
property y: single read Fy write Fy;
end;
/// <summary> Callback which is invoked when a possible result point (significant
/// point in the barcode image such as a corner) is found.
///
/// </summary>
/// <seealso cref="DecodeHintType.NEED_RESULT_POINT_CALLBACK">
/// </seealso>
type
TResultPointCallback = procedure(point: TResultPoint) of Object;
// The method- pointer
implementation
{ TResultPoint }
constructor TResultPoint.Create(pX, pY: single);
begin
Fx := pX;
Fy := pY;
SetLength(bytesX,4);
SetLength(bytesY,4);
//bytesX := byteArray(pX);
//bytesY := byteArray(pY);
end;
destructor TResultPoint.Destroy;
begin
bytesX := nil;
bytesY := nil;
inherited;
end;
class function TResultPoint.crossProductZ(pointA, pointB,
pointC: TResultPoint): single;
var
bX, bY: single;
begin
bX := pointB.x;
bY := pointB.y;
result := ((pointC.x - bX) * (pointA.y - bY)) -
((pointC.y - bY) * (pointA.x - bX));
end;
class function TResultPoint.Distance(pattern1, pattern2: TResultPoint): single;
begin
result := TMathUtils.Distance(pattern1.x, pattern1.y, pattern2.x, pattern2.y);
end;
function TResultPoint.Equals(other: TObject): Boolean;
var
otherPoint: TResultPoint;
begin
otherPoint := other as TResultPoint;
if (otherPoint = nil) then
begin
result := false;
Exit;
end;
result := ((otherPoint.x = Fx) and (otherPoint.y = Fy));
FreeAndNil(otherPoint);
end;
function TResultPoint.GetHashCode: Integer;
begin
result := 31 * ((bytesX[0] shl 24) + (bytesX[1] shl 16) + (bytesX[2] shl 8) +
bytesX[3]) + (bytesY[0] shl 24) + (bytesY[1] shl 16) + (bytesY[2] shl 8) +
bytesY[3];
end;
class procedure TResultPoint.OrderBestPatterns(patterns: TArray<TResultPoint>);
var
zeroOneDistance, oneTwoDistance, zeroTwoDistance: single;
pointA, pointB, pointC, temp: TResultPoint;
begin
// Find distances between pattern centers
zeroOneDistance := Distance(patterns[0], patterns[1]);
oneTwoDistance := Distance(patterns[1], patterns[2]);
zeroTwoDistance := Distance(patterns[0], patterns[2]);
// Assume one closest to other two is B; A and C will just be guesses at first
if ((oneTwoDistance >= zeroOneDistance) and
(oneTwoDistance >= zeroTwoDistance)) then
begin
pointB := patterns[0];
pointA := patterns[1];
pointC := patterns[2];
end
else if ((zeroTwoDistance >= oneTwoDistance) and
(zeroTwoDistance >= zeroOneDistance)) then
begin
pointB := patterns[1];
pointA := patterns[0];
pointC := patterns[2];
end
else
begin
pointB := patterns[2];
pointA := patterns[0];
pointC := patterns[1];
end;
// Use cross product to figure out whether A and C are correct or flipped.
// This asks whether BC x BA has a positive z component, which is the arrangement
// we want for A, B, C. If it's negative, then we've got it flipped around and
// should swap A and C.
if (crossProductZ(pointA, pointB, pointC) < 0) then
begin
temp := pointA;
pointA := pointC;
pointC := temp;
end;
patterns[0] := pointA;
patterns[1] := pointB;
patterns[2] := pointC;
end;
function TResultPoint.ToString: String;
begin
if (FToString = '') then
begin
FToString := Format('(%g),(%g)', [Fx, Fy]);
end;
result := FToString;
end;
end.
|
unit DataModule.Main;
interface
{--$Define FULL_FIREDAC_ACCESS} // avaliable only in Delphi Entrprise version
uses
System.SysUtils,
System.Classes,
System.Types,
Data.DB,
FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Error,
FireDAC.Stan.Pool, FireDAC.Stan.Async, FireDAC.Stan.Def,
FireDAC.Stan.ExprFuncs,
FireDAC.Stan.Param,
FireDAC.Comp.DataSet, FireDAC.Comp.Client,
FireDAC.DatS, FireDAC.DApt.Intf, FireDAC.DApt,
FireDAC.UI.Intf, FireDAC.VCLUI.Wait,
FireDAC.Phys.Intf, FireDAC.Phys,
FireDAC.Phys.MySQLDef, FireDAC.Phys.MySQL,
FireDAC.Phys.IBBase,
FireDAC.Phys.IBDef, FireDAC.Phys.IB,
FireDAC.Phys.FBDef, FireDAC.Phys.FB,
FireDAC.Phys.PGDef, FireDAC.Phys.PG,
FireDAC.Phys.SQLiteDef, FireDAC.Phys.SQLite,
{$IFDEF FULL_FIREDAC_ACCESS}
FireDAC.Phys.OracleDef, FireDAC.Phys.Oracle,
FireDAC.Phys.DB2Def, FireDAC.Phys.DB2,
FireDAC.Phys.MSSQLDef, FireDAC.Phys.MSSQL,
{$ENDIF}
FireDAC.Phys.ODBCBase;
type
// -----------------------------
// TODO: Convert to class accesed by singleton factory method
// class: TDatabaseModule
// interface: GetDatabaseModule: IDatabaseModule;
// -----------------------------
TDataModule1 = class(TDataModule)
FDConnection1: TFDConnection;
FDQuery1: TFDQuery;
private
public
function GetMainDataQuery : TDataSet;
procedure ExecuteSQL (const TextSQL: String);
function GetConnection: TFDConnection;
end;
var
DataModule1: TDataModule1;
implementation
{%CLASSGROUP 'Vcl.Controls.TControl'}
{$R *.dfm}
function TDataModule1.GetConnection: TFDConnection;
begin
Result := FDConnection1;
end;
function TDataModule1.GetMainDataQuery: TDataSet;
begin
Result := FDQuery1;
end;
procedure TDataModule1.ExecuteSQL(const TextSQL: String);
begin
FDQuery1.SQL.Text := '';
FDQuery1.Open(TextSQL);
end;
end.
|
unit dblib;
interface
uses windows,SysUtils,Dialogs;
const
DBRPCRETURN =1;
DBRPCDEFAULT=2;
DBRPCRECOMPILE=1;
DBRPCRESET =4;
DBRPCCURSOR =8;
NO_MORE_RPC_RESULTS = 3;
DBVER60= 9;
DBSETHOST =1;
DBSETUSER =2;
DBSETPWD =3;
DBSETAPP =4;
DBNOERR =-1;
INT_EXIT =0;
INT_CONTINUE=1;
INT_CANCEL =2;
SQLVOID =$1f;
SQLTEXT =$23;
SQLVARBINARY=$25;
SQLINTN =$26;
SQLVARCHAR =$27;
SQLBINARY =$2d;
SQLIMAGE =$22;
SQLCHAR =$2f;
SQLINT1 =$30;
SQLBIT =$32;
SQLINT2 =$34;
SQLINT4 =$38;
SQLMONEY =$3c;
SQLDATETIME =$3d;
SQLFLT8 =$3e;
SQLFLTN =$6d;
SQLMONEYN =$6e;
SQLDATETIMN =$6f;
SQLFLT4 =$3b;
SQLMONEY4 =$7a;
SQLDATETIM4 =$3a;
SQLDECIMAL =$6a;
SQLNUMERIC =$6c;
SUCCEED =1;
NO_MORE_ROWS =-2;
NO_MORE_RESULTS =2;
type
ESQLERROR=class(Exception);
dbrec=record
host:array[0..80] of char;
lock:boolean;
end;
tdblib = class
public
login:pointer;
dbproc:pointer;
newresult:boolean;
cmdstring:string;
dbeof:boolean;
dbrecdata:dbrec;
lserver,luser,ldata,lpass,lhost:string;
function sqllogin:boolean;
function sqlconnect(server,user,data,pass,host:string):boolean;
procedure sqlclose;
function sqlcmd(cmd:string):boolean;
function sqladd(cmd:string):boolean;
function eof:integer;
function sqldata(colin:integer):string;
function sqlopen:boolean;
function sqlexec:boolean;
function sqloutdata(colin:integer):string;
function sqlretdata:integer;
function sqlnumrets:integer;
procedure processcmd(cmd:string);
procedure processopen;
procedure processpara(paramname:string;status:integer;stype:integer;maxlen:integer;datalen:integer;value:pbyte);
procedure next;
end;
function errhandle(PDBPROCESS:pointer;severity:integer;dberr:integer;oserr:integer;dberrstr:lpcstr;oserrstr:lpcstr):integer;cdecl;
function msghandle(PDBPROCESS:pointer;msgno:integer;msgstate:integer;severity:integer;msgtext:lpcstr):integer;cdecl;
function dbinit:lpcstr;far;external 'ntwdblib.dll';
function dblogin:pointer;far;external 'ntwdblib.dll';
function dberrhandle(errhandle:farproc):farproc;cdecl;external 'ntwdblib.dll';
function dbmsghandle(msghandle:farproc):farproc;cdecl;external 'ntwdblib.dll';
function dbprocerrhandle(PLOGINREC:pointer;errhandle:farproc):farproc;cdecl;external 'ntwdblib.dll';
function dbprocmsghandle(PLOGINREC:pointer;msghandle:farproc):farproc;cdecl;external 'ntwdblib.dll';
function dbsetlname(PLOGINREC:pointer; value:LPCSTR; mode:integer):integer;cdecl;external 'ntwdblib.dll';
function dbopen(PLOGINREC:pointer; server:LPCSTR):pointer;cdecl;external 'ntwdblib.dll';
function dbdead(PDBPROCESS:pointer):boolean;cdecl;external 'ntwdblib.dll';
function dbuse(PDBPROCESS:pointer; data:LPCSTR):integer;cdecl;external 'ntwdblib.dll';
function dbcmd(PDBPROCESS:pointer; cmd:LPCSTR):integer;cdecl;external 'ntwdblib.dll';
procedure dbexit;cdecl;external 'ntwdblib.dll';
function dbsqlexec(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbcoltype(PDBPROCESS:pointer;col:integer):integer;cdecl;external 'ntwdblib.dll';
function dbdata(PDBPROCESS:pointer;col:integer):pbyte;cdecl;external 'ntwdblib.dll';
function dbprtype(datatype:integer):lpcstr;cdecl;external 'ntwdblib.dll';
function dbresults(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbnextrow(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
procedure dbfreebuf(PDBPROCESS:pointer);cdecl;external 'ntwdblib.dll';
function dblastrow(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbclose( PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbconvert(PDBPROCESS:pointer;srctype:integer;src:pbyte;srclen:integer;desttype:integer;dest:pbyte;destlen:integer):integer;cdecl;external 'ntwdblib.dll';
function dbdatlen(PDBPROCESS:pointer;col:integer):integer;cdecl;external 'ntwdblib.dll';
function dbcanquery(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbcancel(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbisavail(PDBPROCESS:pointer):boolean;cdecl;external 'ntwdblib.dll';
procedure dbsetuserdata(PDBPROCESS:pointer;LPVOID:pointer);cdecl;external 'ntwdblib.dll';
function dbgetuserdata(PDBPROCESS:pointer):pointer;cdecl;external 'ntwdblib.dll';
function dbstrlen(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbstrcpy(PDBPROCESS:pointer;start:integer;numbytes:integer;dest:lpcstr):integer;cdecl;external 'ntwdblib.dll';
procedure dbwinexit;cdecl;external 'ntwdblib.dll';
function dbretdata(PDBPROCESS:pointer;retnum:integer):pbyte;cdecl;external 'ntwdblib.dll';
function dbretlen(PDBPROCESS:pointer;retnum:integer):integer;cdecl;external 'ntwdblib.dll';
function dbretname(PDBPROCESS:pointer;retnum:integer):LPCSTR;cdecl;external 'ntwdblib.dll';
function dbretstatus(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbrettype(PDBPROCESS:pointer;retnum:integer):integer;cdecl;external 'ntwdblib.dll';
function dbrpcinit(PDBPROCESS:pointer;rpcname:LPCSTR;options:word):integer;cdecl;external 'ntwdblib.dll';
function dbrpcparam(PDBPROCESS:pointer;paramname:LPCSTR;status:byte;stype:integer;maxlen:integer;datalen:integer;value:pbyte):integer;cdecl;external 'ntwdblib.dll';
function dbrpcsend(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbrpcexec(PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbnumrets( PDBPROCESS:pointer):integer;cdecl;external 'ntwdblib.dll';
function dbsettime(seconds:integer):integer;cdecl;external 'ntwdblib.dll';
function dbsetlogintime(seconds:integer):integer;cdecl;external 'ntwdblib.dll';
implementation
uses spx_main,ustru;
function errhandle(PDBPROCESS:pointer;severity:integer;dberr:integer;oserr:integer;dberrstr:lpcstr;oserrstr:lpcstr):integer;
var s:string;
host:string;
cmdlen:integer;
cmdbuf:array[0..1024] of char;
begin
if ((PDBPROCESS = nil) or (DBDEAD(PDBPROCESS))) then
begin
result:=INT_CANCEL;
main_form.logmess(LOGT_MESSAGE,0,'与数据库的连接断开');
exit;
end;
result:=INT_CANCEL;
host:=dbrec(dbgetuserdata(PDBPROCESS)^).host;
cmdlen:=dbstrlen(PDBPROCESS);
dbstrcpy(PDBPROCESS,0,cmdlen+2,cmdbuf);
s:=strpas(cmdbuf);
main_form.logmess(LOGT_MESSAGE,0,s);
s:=format('DB-LIBRARY error:%s', [dberrstr]);
main_form.logmess(LOGT_MESSAGE,0,s);
if (oserr <> DBNOERR) then
begin
s:=format('Operating-system error:%s', [oserrstr]);
main_form.logmess(LOGT_MESSAGE,0,s);
end;
end;
function msghandle(PDBPROCESS:pointer;msgno:integer;msgstate:integer;severity:integer;msgtext:lpcstr):integer;
var s:string;
host:string;
cmdlen:integer;
cmdbuf:array[0..1024] of char;
begin
if (msgno <> 5701) then
begin
host:=dbrec(dbgetuserdata(PDBPROCESS)^).host;
cmdlen:=dbstrlen(PDBPROCESS);
dbstrcpy(PDBPROCESS,0,cmdlen+2,cmdbuf);
s:=strpas(cmdbuf);
main_form.logmess(LOGT_MESSAGE,0,s);
s:=format('SQL Server message %d, state %d, severity %d:%s',
[msgno, msgstate, severity, string(msgtext)]);
main_form.logmess(LOGT_MESSAGE,0,s);
if msgno = 1205 then
begin
result:=INT_CANCEL;
dbclose(PDBPROCESS);
exit;
end;
end;
result:=0;
end;
function tdblib.sqllogin:boolean;
begin
login:=dblogin;
end;
procedure tdblib.processcmd(cmd:string);
var sqlerror:esqlerror;
begin
if dbproc <> nil then
begin
dbcanquery(dbproc);
dbcancel(dbproc);
dbfreebuf(dbproc);
if dbrpcinit(dbproc,pchar(cmd),DBRPCRESET) = 0 then
begin
dbclose(dbproc);
dbproc:=nil;
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
end
else
begin
sqlconnect(lserver,luser,ldata,lpass,lhost);
if dbproc = nil then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
sqlerror:=esqlerror.create('SQLERROR');
raise sqlerror;
end;
end;
procedure tdblib.processopen;
var sqlerror:esqlerror;
begin
if dbrpcexec(dbproc) = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
newresult:=true;
next;
end;
function tdblib.sqlnumrets:integer;
begin
result:=dbnumrets(dbproc);
end;
procedure tdblib.processpara(paramname:string;status:integer;stype:integer;maxlen:integer;datalen:integer;value:pbyte);
var sqlerror:esqlerror;
begin
if dbrpcparam(dbproc,pchar(paramname),status,stype,maxlen,datalen,value)=0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
end;
end;
function tdblib.sqlretdata:integer;
begin
result:=dbretstatus(dbproc);
end;
function tdblib.sqlconnect(server,user,data,pass,host:string):boolean;
var sqlerror:esqlerror;
begin
lserver:=server;
luser:=user;
ldata:=data;
lpass:=pass;
lhost:=host;
dbsetlname(login,pchar(user),DBSETUSER);
dbsetlname(login,pchar(pass),DBSETPWD);
dbsetlname(login,pchar(host),DBSETHOST);
dbsetlname(login,nil,DBVER60);
dbproc:=dbopen(login,pchar(server));
if dbproc = nil then
begin
result:=false;
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end
else
begin
dbuse(dbproc,pchar(data));
strpcopy(dbrecdata.host,host);
dbsetuserdata(dbproc,@dbrecdata);
result:=true;
end;
end;
procedure tdblib.sqlclose;
begin
dbclose(dbproc);
end;
function tdblib.sqlcmd(cmd:string):boolean;
var sqlerror:esqlerror;
begin
if dbproc <> nil then
begin
dbcanquery(dbproc);
dbcancel(dbproc);
dbfreebuf(dbproc);
if dbcmd(dbproc,pchar(cmd)) = 0 then
begin
dbclose(dbproc);
dbproc:=nil;
sqlerror:=esqlerror.create('SQLERROR');
raise sqlerror;
exit;
end;
cmdstring:=cmd;
end
else
begin
sqlconnect(lserver,luser,ldata,lpass,lhost);
if dbproc = nil then
begin
sqlerror:=esqlerror.create('SQLERROR');
raise sqlerror;
exit;
end;
sqlerror:=esqlerror.create('SQLERROR');
raise sqlerror;
end;
end;
function tdblib.sqladd(cmd:string):boolean;
begin
dbcmd(dbproc,pchar(cmd));
cmdstring:=cmdstring+cmd;
end;
function tdblib.eof:integer;
begin
if dbeof = true then
begin
result:=1;
end
else
begin
result:=0;
end;
end;
function tdblib.sqldata(colin:integer):string;
var dest:pbyte;
ds:array [0..512] of char;
dfest:pbyte;
fds:array[0..64] of char;
i:integer;
s:string;
ctype:integer;
col:integer;
begin
col:=colin+1;
dest:=@ds;
dfest:=@fds;
ctype:=dbcoltype(dbproc,col);
if ((ctype = SQLMONEYN) or (ctype = SQLMONEY) or (ctype = SQLMONEY4)) then
begin
i:=dbconvert(dbproc,ctype,dbdata(dbproc,col),dbdatlen(dbproc,col),SQLFLT8,dfest,80);
i:=dbconvert(dbproc,SQLFLT8,dfest,i,SQLCHAR,dest,80);
end
else
begin
i:=dbconvert(dbproc,ctype,dbdata(dbproc,col),dbdatlen(dbproc,col),SQLCHAR,dest,80);
end;
ds[i]:=char(0);
if ((ctype = SQLMONEYN) or (ctype = SQLMONEY) or (ctype = SQLMONEY4) or (ctype = SQLFLTN) or (ctype = SQLFLT8)) then
begin
s:=trim(strpas(ds));
if s = '' then
begin
result:='0.00';
end
else
begin
result:=s;
end;
end
else
begin
if (i > 1) then
begin
result:=trim(strpas(ds));
end
else
begin
result:=strpas(ds);
end;
end;
end;
function tdblib.sqloutdata(colin:integer):string;
var dest:pbyte;
ds:array [0..512] of char;
dfest:pbyte;
fds:array[0..64] of char;
i:integer;
s:string;
ctype:integer;
col:integer;
begin
col:=colin+1;
dest:=@ds;
dfest:=@fds;
ctype:=dbrettype(dbproc,col);
if ((ctype = SQLMONEYN) or (ctype = SQLMONEY) or (ctype = SQLMONEY4)) then
begin
i:=dbconvert(dbproc,ctype,dbretdata(dbproc,col),dbretlen(dbproc,col),SQLFLT8,dfest,80);
i:=dbconvert(dbproc,SQLFLT8,dfest,i,SQLCHAR,dest,80);
end
else
begin
i:=dbconvert(dbproc,ctype,dbretdata(dbproc,col),dbretlen(dbproc,col),SQLCHAR,dest,80);
end;
ds[i]:=char(0);
if ((ctype = SQLMONEYN) or (ctype = SQLMONEY) or (ctype = SQLMONEY4) or (ctype = SQLFLTN) or (ctype = SQLFLT8)) then
begin
s:=trim(strpas(ds));
if s = '' then
begin
result:='0.00';
end
else
begin
result:=s;
end;
end
else
begin
if (i > 1) then
begin
result:=trim(strpas(ds));
end
else
begin
result:=strpas(ds);
end;
end;
end;
function tdblib.sqlopen:boolean;
var sqlerror:esqlerror;
begin
if dbsqlexec(dbproc) = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
newresult:=true;
exit;
end;
newresult:=true;
next;
end;
function tdblib.sqlexec:boolean;
var sqlerror:esqlerror;
begin
if dbsqlexec(dbproc) = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
end;
newresult:=true;
end;
procedure tdblib.next;
label start;
var retcode:integer;
sqlerror:esqlerror;
begin
start:
if newresult = true then
begin
newresult:=false;
retcode:=dbresults(dbproc);
if retcode = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
if (retcode <> NO_MORE_RESULTS) and (retcode <> NO_MORE_RPC_RESULTS) then
begin
if (retcode = SUCCEED) then
begin
retcode:=dbnextrow(dbproc);
if retcode = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
if (retcode <> NO_MORE_ROWS) then
begin
dbeof:=false;
exit;
end
else
begin
newresult:=true;
goto start;
end;
end;
end
else
begin
dbeof:=true;
exit;
end;
end
else
begin
retcode:=dbnextrow(dbproc);
if retcode = 0 then
begin
sqlerror:=esqlerror.Create('SQLERROR');
raise sqlerror;
exit;
end;
if (retcode <> NO_MORE_ROWS) then
begin
dbeof:=false;
exit;
end
else
begin
newresult:=true;
goto start;
end;
end;
end;
end.
|
unit SHG;
interface
uses
NLO, SignalField, Func1D, Numerics, FrogTrace;
type
TSHG = class(TNLOInteraction)
public
procedure MakeSignalField(pEk: TEField; pEsig: TSignalField); override;
procedure MakeXSignalField(pEk, pERef: TEField; pEsig: TSignalField); override;
function Z(pEx: PArray; pEsig: TSignalField): double; override;
procedure GDerivative(pEk: TEField; pEsig: TSignalField; pFrogI: TFrogTrace; Derivs: PArray); override;
procedure ZDerivative(pEk: TEField; pEsig: TSignalField; Derivs: PArray); override;
function XFrogZ(pEx: PArray; pERef: TEField; pEsig: TSignalField): double; override;
procedure XFrogZDerivative(pEk, pERef: TEField; pEsig: TSignalField; Derivs: PArray); override;
procedure BasicField(pEsig: TSignalField; pEk: TEField); override;
procedure GateField(pEsig: TSignalField; pEk: TEField); override;
function CalculateMarginal(pSpec: TSpectrum; pAuto: TAutocorrelation; pSHGSpec: TSpectrum): TMarginal; override;
function Name: string; override;
function SpectrumMultiplier: double; override;
function NeedSpectrum: Boolean; override;
function NeedAutocorrelation: Boolean; override;
function NeedSHGSpectrum: Boolean; override;
function XTestLam(frogLam, refLam: double): double; override;
function XFrogLam(refLam, testLam: double): double; override;
constructor Create; override;
end;
implementation
uses TestPlot, ReadIn, sysutils;
constructor TSHG.Create;
begin
inherited;
mNLOType := nlSHG;
end;
function TSHG.Name: string;
begin
Name := 'SHG';
end;
function TSHG.SpectrumMultiplier: double;
begin
SpectrumMultiplier := 2.0;
end;
procedure TSHG.BasicField(pEsig: TSignalField; pEk: TEField);
var
w, tau, N: integer;
begin
N := pEsig.N;
for w := 0 to N - 1 do
begin
pEk.Re^[w] := 0.0;
pEk.Im^[w] := 0.0;
end;
for tau := 0 to N - 1 do
begin
for w := 0 to N - 1 do
begin
pEk.Re^[w] := pEk.Re^[w] + pEsig.Re^[tau*N + w];
pEk.Im^[w] := pEk.Im^[w] + pEsig.Im^[tau*N + w];
end;
end;
// Back to the Time domain
pEk.InverseTransform;
// Might want to do the Java-style normalization here.
end;
procedure TSHG.GateField(pEsig: TSignalField; pEk: TEField);
var
w, N, tau, minusT: integer;
re, im: double;
begin
N := pEk.N;
for tau := 0 to N - 1 do
begin
re := 0;
im := 0;
for w := 0 to N - 1 do
begin
re := re + pEsig.Re^[tau*N + w];
im := im + pEsig.Im^[tau*N + w];
end;
minusT := N - 1 - tau;
pEk.Re^[minusT] := re;
pEk.Im^[minusT] := im;
end;
end;
procedure TSHG.MakeSignalField(pEk: TEField; pEsig: TSignalField);
var
tau, t, t0, N, tp: integer;
begin
N := pEk.N;
t0 := N div 2;
for tau := 0 to N - 1 do
begin
for t := 0 to N - 1 do
begin
tp := t - (tau - t0);
if (tp < 0) or (tp >= N) then
begin
pEsig.Re^[tau*N + t] := 0.0;
pEsig.Im^[tau*N + t] := 0.0;
Continue;
end;
pEsig.Re^[tau*N + t] := pEk.Re^[t]*pEk.Re^[tp] - pEk.Im^[t]*pEk.Im^[tp];
pEsig.Im^[tau*N + t] := pEk.Re^[t]*pEk.Im^[tp] + pEk.Im^[t]*pEk.Re^[tp];
end;
end;
// To the w domain
pEsig.TransformToFreq;
end;
procedure TSHG.MakeXSignalField(pEk, pERef: TEField; pEsig: TSignalField);
var
tau, t, t0, N, tp: integer;
begin
N := pEk.N;
// Fix XFROG bug
if not (N = pERef.N) then
begin
for tau := 0 to N*N - 1 do
begin
pESig.Re^[tau] := 0.1;
pESig.Im^[tau] := 0.0;
end;
// To the w domain
pEsig.TransformToFreq;
Exit;
end;
t0 := N div 2;
for tau := 0 to N - 1 do
begin
for t := 0 to N - 1 do
begin
tp := t - (tau - t0);
if (tp < 0) or (tp >= N) then
begin
pEsig.Re^[tau*N + t] := 0.0;
pEsig.Im^[tau*N + t] := 0.0;
Continue;
end;
pEsig.Re^[tau*N + t] := pEk.Re^[t]*pERef.Re^[tp] - pEk.Im^[t]*pERef.Im^[tp];
pEsig.Im^[tau*N + t] := pEk.Re^[t]*pERef.Im^[tp] + pEk.Im^[t]*pERef.Re^[tp];
end;
end;
// To the w domain
pEsig.TransformToFreq;
end;
function TSHG.Z(pEx: PArray; pEsig: TSignalField): double;
var
t, tau, tp, N, N2, tr, ti, tpr, tpi: integer;
sum, sigr, sigi, re, im: double;
begin
N := pEsig.N;
N2 := N div 2;
sum := 0.0;
for t := 0 to N - 1 do
for tau := 0 to N - 1 do
begin
tp := t - (tau - N2);
if (tp >= 0) and (tp < N) then
begin
tr := 2*t;
ti := tr + 1;
tpr := 2*tp;
tpi := tpr + 1;
sigr := pEx^[tr]*pEx^[tpr] - pEx^[ti]*pEx^[tpi];
sigi := pEx^[tr]*pEx^[tpi] + pEx^[ti]*pEx^[tpr];
end
else
begin
sigr := 0.0;
sigi := 0.0;
end;
re := pEsig.Re^[tau*N + t] - sigr;
im := pEsig.Im^[tau*N + t] - sigi;
sum := sum + re*re + im*im;
end;
Z := sum;
end;
procedure TSHG.ZDerivative(pEk: TEField; pEsig: TSignalField; Derivs: PArray);
var
t, tp, tau, N, N2, vr, vi: integer;
sigr, sigi, brakr, braki, re, im: double;
begin
N := pEk.N;
N2 := N div 2;
for t := 0 to N - 1 do
begin
vr := t*2;
vi := vr + 1;
Derivs^[vr] := 0.0;
Derivs^[vi] := 0.0;
for tau := 0 to N - 1 do
begin
tp := t - (tau - N2);
if (tp >= 0) and (tp < N) then
begin
sigr := pEk.Re^[t]*pEk.Re^[tp] - pEk.Im^[t]*pEk.Im^[tp];
sigi := pEk.Re^[t]*pEk.Im^[tp] + pEk.Im^[t]*pEk.Re^[tp];
re := pEk.Re^[tp];
im := pEk.Im^[tp];
end
else
begin
sigr := 0.0;
sigi := 0.0;
re := 0.0;
im := 0.0;
end; // End of check tp
brakr := pEsig.Re^[tau*N + t] - sigr;
braki := pEsig.Im^[tau*N + t] - sigi;
Derivs^[vr] := Derivs^[vr] - 2*(re*brakr + im*braki);
Derivs^[vi] := Derivs^[vi] + 2*(im*brakr - re*braki);
tp := t + tau - N2;
if (tp < 0) or (tp >= N) then
begin
re := 0.0;
im := 0.0;
end
else
begin
re := pEk.Re^[tp];
im := pEk.Im^[tp];
sigr := pEk.Re^[t]*pEk.Re^[tp] - pEk.Im^[t]*pEk.Im^[tp];
sigi := pEk.Re^[t]*pEk.Im^[tp] + pEk.Im^[t]*pEk.Re^[tp];
brakr := pEsig.Re^[tau*N + tp] - sigr;
braki := pEsig.Im^[tau*N + tp] - sigi;
end;
Derivs^[vr] := Derivs^[vr] - 2*(re*brakr + im*braki);
Derivs^[vi] := Derivs^[vi] + 2*(im*brakr - re*braki);
end; // end of tau loop
Derivs^[vr] := Derivs^[vr]/(1.0*N);
Derivs^[vi] := Derivs^[vi]/(1.0*N);
end; // end of t loop
end;
function TSHG.XFrogZ(pEx: PArray; pERef: TEField; pEsig: TSignalField): double;
var
t, tau, tp, N, N2, tr, ti: integer;
sum, sigr, sigi, re, im: double;
begin
N := pEsig.N;
N2 := N div 2;
sum := 0.0;
for t := 0 to N - 1 do
for tau := 0 to N - 1 do
begin
tp := t - (tau - N2);
if (tp >= 0) and (tp < N) then
begin
tr := 2*t;
ti := tr + 1;
sigr := pEx^[tr]*pERef.Re^[tp] - pEx^[ti]*pERef.Im^[tp];
sigi := pEx^[tr]*pERef.Im^[tp] + pEx^[ti]*pERef.Re^[tp];
end
else
begin
sigr := 0.0;
sigi := 0.0;
end;
re := pEsig.Re^[tau*N + t] - sigr;
im := pEsig.Im^[tau*N + t] - sigi;
sum := sum + re*re + im*im;
end;
XFrogZ := sum;
end;
procedure TSHG.XFrogZDerivative(pEk, pERef: TEField; pEsig: TSignalField; Derivs: PArray);
var
t, tp, tau, N, N2, vr, vi: integer;
sigr, sigi, brakr, braki, re, im: double;
begin
N := pEk.N;
N2 := N div 2;
for t := 0 to N - 1 do
begin
vr := t*2;
vi := vr + 1;
Derivs^[vr] := 0.0;
Derivs^[vi] := 0.0;
for tau := 0 to N - 1 do
begin
tp := t - (tau - N2);
if (tp >= 0) and (tp < N) then
begin
sigr := pEk.Re^[t]*pERef.Re^[tp] - pEk.Im^[t]*pERef.Im^[tp];
sigi := pEk.Re^[t]*pERef.Im^[tp] + pEk.Im^[t]*pERef.Re^[tp];
re := pERef.Re^[tp];
im := pERef.Im^[tp];
end
else
begin
sigr := 0.0;
sigi := 0.0;
re := 0.0;
im := 0.0;
end; // End of check tp
brakr := pEsig.Re^[tau*N + t] - sigr;
braki := pEsig.Im^[tau*N + t] - sigi;
Derivs^[vr] := Derivs^[vr] - 2*(re*brakr - im*braki);
Derivs^[vi] := Derivs^[vi] - 2*(im*brakr + re*braki);
end; // end of tau loop
Derivs^[vr] := Derivs^[vr]/(1.0*N);
Derivs^[vi] := Derivs^[vi]/(1.0*N);
end; // end of t loop
end;
procedure TSHG.GDerivative(pEk: TEField; pEsig: TSignalField; pFrogI: TFrogTrace; Derivs: PArray);
var
N, t, tau, w, tp, N2, tpw, tw, tauw: integer;
fact, fmax, fkmax, cc, ss, re, im: double;
tFrogIk: TFrogTrace;
begin
N := pEk.N;
SetUpMinArrays(N);
N2 := N div 2;
pEk.SetIntensityAndPhase;
tFrogIk := TRetrievedFrogTrace.Create(N);
try
tFrogIk.MakeTraceFrom(pEsig);
fmax := pFrogI.Max;
fkmax := tFrogIk.Max;
for t := 0 to N - 1 do
begin
Derivs^[2*t] := 0.0;
Derivs^[2*t + 1] := 0.0;
for w := 0 to N - 1 do
for tau := 0 to N - 1 do
begin
fact := pFrogI.Vals^[tau*N + w]/fmax - tFrogIk.Vals^[tau*N + w]/fkmax;
tw := t*N + w;
tauw := tau*N + w;
// The deriv wrt the real part of the field
tp := t - (tau - N2);
if (tp < 0) or (tp >= N) then
begin
re := 0.0;
im := 0.0;
end
else
begin
cc := mC[tw]; ss := mS[tw];
re := pEk.Re^[tp]*cc - pEk.Im^[tp]*ss;
im := pEk.Re^[tp]*ss + pEk.Im^[tp]*cc;
end;
tp := t + tau - N2;
if not ((tp < 0) or (tp >= N)) then
begin
tpw := tp*N + w;
cc := mC[tpw]; ss := mS[tpw];
re := re + pEk.Re^[tp]*cc - pEk.Im^[tp]*ss;
im := im + pEk.Re^[tp]*ss + pEk.Im^[tp]*cc;
end;
Derivs^[2*t] := Derivs^[2*t] - fact*(re*pEsig.Re^[tauw]
+ im*pEsig.Im^[tauw]);
Derivs^[2*t+1] := Derivs^[2*t + 1] - fact*(re*pEsig.Im^[tauw]
- im*pEsig.Re^[tauw]);
end; // end of tau loop
end;
finally
tFrogIk.Free;
end;
for t := 0 to N - 1 do
begin
Derivs^[2*t] := Derivs^[2*t]/(1.0*N*N);
Derivs^[2*t+1] := Derivs^[2*t+1]/(1.0*N*N);
end;
end;
function TSHG.NeedSpectrum: Boolean;
begin
NeedSpectrum := True;
end;
function TSHG.NeedAutocorrelation: Boolean;
begin
NeedAutocorrelation := False;
end;
function TSHG.NeedSHGSpectrum: Boolean;
begin
NeedSHGSpectrum := False;
end;
function TSHG.CalculateMarginal(pSpec: TSpectrum; pAuto: TAutocorrelation; pSHGSpec: TSpectrum): TMarginal;
var
i, NSpec: integer;
re, im, newDelT: double;
Spectrum: TEField;
Marginal: TMarginal;
readIn: TReadIn;
tempSpec: TSpectrum;
begin
Spectrum := nil;
Marginal := nil;
NSpec := 2;
while NSpec < pSpec.N do
NSpec := NSpec*2;
// This next line ensures that the marginal will fit on the grid - if the
// original spectrum fills pSpec, then the autoconvolution will be about
// root(2) bigger, and it aliases
NSpec := NSpec*2;
Marginal := TMarginal.Create(NSpec);
try
readIn := TReadIn.Create;
tempSpec := TSpectrum.Create(NSpec);
Spectrum := TEField.Create(NSpec);
newDelT := pSpec.DelT*(pSpec.N/NSpec);
Spectrum.SetMyUnits(newDelT, pSpec.Lam0);
tempSpec.SetMyUnits(newDelT, pSpec.Lam0);
Marginal.SetMyUnits(newDelT, pSpec.Lam0);
readIn.GridSpectrum(pSpec, tempSpec);
for i := 0 to Spectrum.N - 1 do
begin
Spectrum.Re^[i] := tempSpec.Intensity^[i];
Spectrum.Im^[i] := 0;
end;
Spectrum.InverseTransform;
for i := 0 to NSpec - 1 do
begin
re := Spectrum.Re^[i]*Spectrum.Re^[i] - Spectrum.Im^[i]*Spectrum.Im^[i];
im := 2.0*Spectrum.Re^[i]*Spectrum.Im^[i];
Spectrum.Re^[i] := re;
Spectrum.Im^[i] := im;
end;
Spectrum.Transform;
//frmTestPlot.SetTitle('Afer transform');
//frmTestPlot.PlotRealAndIm(Spectrum);
for i := 0 to NSpec - 1 do
begin
Marginal.Intensity^[i] := Spectrum.Re^[i];
end;
finally
Spectrum.Free;
tempSpec.Free;
readIn.Free;
end;
Marginal.SetMyUnits(Marginal.DelT, pSpec.Lam0/2.0);
CalculateMarginal := Marginal;
end;
function TSHG.XTestLam(frogLam, refLam: double): double;
var
denom: double;
begin
denom := 1.0/frogLam - 1.0/refLam;
if denom = 0.0 then
raise Exception.Create('Reference field at ' + FloatToStrF(refLam, ffGeneral, 4, 0) +
' nm and XFROG field at ' + FloatToStrF(frogLam, ffGeneral, 4, 0) +
' nm implies an infinite test beam wavelength.');
if denom < 0.0 then
raise Exception.Create('Reference field at ' + FloatToStrF(refLam, ffGeneral, 4, 0) +
' nm and XFROG field at ' + FloatToStrF(frogLam, ffGeneral, 4, 0) +
' nm implies a negative test beam wavelength.');
XTestLam := 1.0/(denom);
end;
function TSHG.XFrogLam(refLam, testLam: double): double;
begin
XFrogLam := 1.0/(1.0/testLam + 1.0/refLam);
end;
end. |
unit ormbr.model.detail;
interface
uses
Classes,
DB,
SysUtils,
Generics.Collections,
/// orm
ormbr.mapping.attributes,
ormbr.types.mapping,
ormbr.types.lazy,
ormbr.types.nullable,
ormbr.model.lookup,
ormbr.mapping.register;
type
[Entity]
[Table('detail','')]
[PrimaryKey('detail_id; master_id', 'Chave primária')]
[AggregateField('AGGPRICE', 'SUM(PRICE)', taRightJustify, '#,###,##0.00')]
Tdetail = class
private
{ Private declarations }
Fdetail_id: Integer;
Fmaster_id: Integer;
Flookup_id: Integer;
Flookup_description: String;
Fprice: Double;
public
{ Public declarations }
[Restrictions([NoUpdate, NotNull])]
[Column('detail_id', ftInteger)]
[Dictionary('ID Detalhe','Mensagem de validação','','','',taCenter)]
property detail_id: Integer read Fdetail_id write Fdetail_id;
[Restrictions([NotNull])]
[Column('master_id', ftInteger)]
[ForeignKey('FK_IDMASTER', 'master_id', 'master', 'master_id', Cascade, Cascade)]
[Dictionary('ID Mestre','Mensagem de validação','','','',taCenter)]
property master_id: Integer read Fmaster_id write Fmaster_id;
[Restrictions([NotNull])]
[Column('lookup_id', ftInteger)]
[ForeignKey('FK_IDLOOKUP', 'lookup_id', 'lookup', 'lookup_id', None, None)]
[Dictionary('ID Lookup','Mensagem de validação','0','','',taCenter)]
property lookup_id: Integer read Flookup_id write Flookup_id;
[Column('lookup_description', ftString, 30)]
[Dictionary('Descrição Lookup','Mensagem de validação','','','',taLeftJustify)]
property lookup_description: String read Flookup_description write Flookup_description;
[Restrictions([NotNull])]
[Column('price', ftFloat, 18, 3)]
[Dictionary('Preço Unitário','Mensagem de validação','','#,###,##0.00','',taRightJustify)]
property price: Double read Fprice write Fprice;
end;
implementation
initialization
TRegisterClass.RegisterEntity(Tdetail);
end.
|
unit fStartLive;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, DanHexEdit, BCData;
type
TfrmLives = class(TForm)
lblLives: TLabel;
cmdOK: TButton;
cmdCancel: TButton;
txtLives: TEdit;
procedure FormShow(Sender: TObject);
procedure cmdOKClick(Sender: TObject);
private
{ Private declarations }
_BattleCityROM : TBattleCityROM;
public
{ Public declarations }
constructor Create(AOwner: TComponent; ROMData: TBattleCityROM);
end;
var
frmLives: TfrmLives;
implementation
{$R *.dfm}
constructor TfrmLives.Create(AOwner: TComponent; ROMData: TBattleCityROM);
begin
inherited Create(AOwner);
_BattleCityROM := ROMData;
end;
procedure TfrmLives.FormShow(Sender: TObject);
begin
txtLives.Text := IntToStr(_BattleCityROM.GetStartingLives());
end;
procedure TfrmLives.cmdOKClick(Sender: TObject);
begin
_BattleCityROM.SetStartingLives(StrToInt(txtLives.Text));
end;
end.
|
unit Builder.Concretes.Builder.Manual;
interface
uses
Builder.Interfaces.IBuilder, Builder.Interfaces.IEngine,
Builder.Interfaces.IGPS, Builder.Interfaces.ITripComputer;
type
TManual = class(TInterfacedObject, IBuilder)
private
FEngine: IEngine;
FGPS: IGPS;
FSeats: Integer;
FTripComputer: ITripComputer;
FEntityName: string;
public
function GetDescription: string;
function SetSeats(ANumberOfSeats: Integer): IBuilder;
function SetEngine(AEngine: IEngine): IBuilder;
function SetTripComputer(ATripComputer: ITripComputer): IBuilder;
function SetGPS(AGPS : IGPS): IBuilder;
function GetResult: IBuilder;
function SetEntityName(Const AValue: string): IBuilder;
class function New: TManual;
end;
implementation
uses
Builder.ProductParts.TripComputer, Builder.ProductParts.GPS, System.Classes,
System.SysUtils;
{ TManual }
function TManual.GetDescription: string;
begin
Result := 'Manual do carro: ' + FEntityName;
end;
function TManual.GetResult: IBuilder;
begin
Result := Self;
end;
class function TManual.New: TManual;
begin
Result := Self.Create;
end;
function TManual.SetSeats(ANumberOfSeats: Integer): IBuilder;
begin
Result := Self;
FSeats := ANumberOfSeats;
end;
function TManual.SetEngine(AEngine: IEngine): IBuilder;
begin
Result := Self;
FEngine := AEngine;
end;
function TManual.SetEntityName(const AValue: string): IBuilder;
begin
Result := Self;
FEntityName := AValue;
end;
function TManual.SetGPS(AGPS : IGPS): IBuilder;
begin
Result := Self;
FGPS := AGPS;
end;
function TManual.SetTripComputer(ATripComputer: ITripComputer): IBuilder;
begin
Result := Self;
FTripComputer := ATripComputer;
end;
end.
|
unit Ai08;
{
ULAI08.DPR================================================================
File: AI08.PAS
Library Call Demonstrated: cbAPretrig()
Purpose: Waits for a trigger, then returns a specified
number of analog samples before and after
the trigger.
Demonstration: Displays the analog input on one channel and
waits for the trigger.
Other Library Calls: cbErrHandling()
Special Requirements: Board 0 must support cbAPretrig.
Analog signal on an input channel.
(c) Copyright 1995 - 2002, Measurement Computing Corp.
All rights reserved.
***************************************************************************/
}
interface
uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
Forms, Dialogs, StdCtrls, ExtCtrls, cbw;
type
TfrmAInScan = class(TForm)
cmdStart: TButton;
cmdQuit: TButton;
Memo1: TMemo;
Memo2: TMemo;
procedure cmdQuitClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure cmdStartClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
frmAInScan: TfrmAInScan;
implementation
{$R *.DFM}
var
ULStat: Integer;
MemHandle: Integer;
ADData: array[0..2000] of Word;
{
array must be dimensioned at least TotalCount + 512
}
ErrReporting: Integer;
ErrHandling: Integer;
RevLevel: Single;
Rate: LongInt;
PretrigCount: LongInt;
TotalCount: LongInt;
const
BoardNum: Integer = 0;
Count: LongInt = 600;
FirstPoint: LongInt = 0;
TargetRate: LongInt = 2000;
LowChan: Integer = 0;
HighChan: Integer = 0;
Range: Integer = BIP5VOLTS;
Options: Integer = CONVERTDATA;
TargetPretrigCount: LongInt = 10;
DefaultCount: LongInt = 700;
BufferSize: LongInt = 2000;
procedure TfrmAInScan.FormCreate(Sender: TObject);
begin
{declare Revision Level}
RevLevel := CURRENTREVNUM;
ULStat := cbDeclareRevision(RevLevel);
{
set up internal error handling for the Universal Library
}
ErrReporting := PRINTALL; {set Universal Library to print all errors}
ErrHandling := STOPALL; {set Universal Library to stop on errors}
ULStat := cbErrHandling(ErrReporting, ErrHandling);
{
set up a buffer in Windows to contain the data
}
MemHandle := cbWinBufAlloc (BufferSize);
Memo1.Text := 'Make sure trig in is at TTL low, then click "Start" to acquire data.';
end;
procedure TfrmAInScan.cmdStartClick(Sender: TObject);
var
index: Integer;
begin
Memo1.Text := 'Waiting for trigger....';
Memo2.Text := ' ';
Application.ProcessMessages;
{
Collect the values after the trigger
Parameters:
BoardNum :the number used by CB.CFG to describe this board
LowChan :low channel of the scan
HighChan :high channel of the scan
PretrigCount:number of pre-trigger A/D samples to collect
TotalCount :the total number of A/D samples to collect
Rate :sample rate in samples per second per channel
Gain :the gain for the board
MemHandle :the memory buffer for the collected data values
Options :data collection options
}
PreTrigCount := TargetPretrigCount;
TotalCount := DefaultCount;
Rate := TargetRate;
ULStat := cbAPretrig (BoardNum, LowChan, HighChan,
PreTrigCount, TotalCount, Rate, Range, MemHandle, Options);
If ULStat <> 0 then exit;
Memo1.Text := 'Pre-trigger data:';
Memo1.Lines.Add (' ');
{
Transfer the data from the Windows buffer to an array. This data
could also be accessed directly using a pointer.
}
ULStat := cbWinBufToArray (MemHandle, ADData[0], FirstPoint, Count);
If ULStat <> 0 then exit;
For index := 0 to 9 do
begin
Memo1.Lines.Add (Format('Trigger - %d: %d', [10 - index, ADData[index]]));
end;
Memo2.Text := 'Post-trigger data:';
Memo2.Lines.Add (' ');
For index := 10 to 19 do
begin
Memo2.Lines.Add (Format('Trigger + %d: %d', [10 - index, ADData[index]]));
end;
end;
procedure TfrmAInScan.cmdQuitClick(Sender: TObject);
begin
ULStat := cbWinBufFree (MemHandle);
Close;
end;
end.
|
unit SimThyrLog;
{ SimThyr Project }
{ A numerical simulator of thyrotropic feedback control }
{ Version 4.0.2 (Merlion) }
{ (c) J. W. Dietrich, 1994 - 2020 }
{ (c) Ludwig Maximilian University of Munich 1995 - 2002 }
{ (c) Ruhr University of Bochum 2005 - 2020 }
{ This unit draws a spreadsheet-like grid with simulation results }
{ Source code released under the BSD License }
{ See http://simthyr.sourceforge.net for details }
{$mode objfpc}{$R+}
interface
uses
Classes, SysUtils, FileUtil, LResources, Forms, Controls, Graphics, Dialogs,
Grids, clipbrd, ComCtrls, ExtCtrls, Menus,
SimThyrTypes, SimThyrServices, DIFSupport;
type
{ TSimThyrLogWindow }
TSimThyrLogWindow = class(TForm)
CopyItem: TMenuItem;
CutItem: TMenuItem;
DeleteItem: TMenuItem;
Divider1: TMenuItem;
PasteItem: TMenuItem;
PopupMenu1: TPopupMenu;
ProgressBar1: TProgressBar;
StatusBar1: TStatusBar;
UndoItem: TMenuItem;
ValuesGrid: TStringGrid;
procedure CopyCells;
procedure CopyItemClick(Sender: TObject);
procedure FormPaint(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure RedrawGrid(Sender: TObject);
procedure FormActivate(Sender: TObject);
procedure InitGrid;
procedure PopupMenu1Popup(Sender: TObject);
procedure SaveGrid(theFileName: string; theDelimiter: char);
private
{ private declarations }
public
{ public declarations }
end;
var
SimThyrLogWindow: TSimThyrLogWindow;
implementation
uses
SimThyrMain;
procedure CutorCopyfromGrid(theGrid: TStringGrid; cut: boolean = False);
{supports cutting or copying cells from the grid}
var
theSelection: TGridRect;
r, c: integer;
textfromSelection: ansistring;
begin
theSelection := theGrid.Selection;
textfromSelection := '';
for r := theSelection.Top to theSelection.Bottom do
begin
for c := theSelection.Left to theSelection.Right do
begin
textfromSelection := textfromSelection + theGrid.Cells[c, r];
if cut then
begin
theGrid.Cells[c, r] := '';
end;
if c < theSelection.Right then
textfromSelection := textfromSelection + kTAB;
end;
if r < theSelection.Bottom then
textfromSelection := textfromSelection + kCRLF;
end;
ClipBoard.AsText := textfromSelection;
end;
procedure TSimThyrLogWindow.CopyCells;
begin
CutorCopyfromGrid(valuesGrid, False);
end;
procedure TSimThyrLogWindow.CopyItemClick(Sender: TObject);
begin
CopyCells;
end;
procedure TSimThyrLogWindow.FormPaint(Sender: TObject);
begin
if DarkTheme then
begin
Color := BACKCOLOUR;
ValuesGrid.Color := BACKCOLOUR;
end
else
begin
Color := clWhite;
ValuesGrid.Color := clWhite;
end
end;
procedure TSimThyrLogWindow.FormShow(Sender: TObject);
begin
FormPaint(Sender);
end;
procedure TSimThyrLogWindow.RedrawGrid(Sender: TObject);
{ (Re)draws grid after activating the form and after change of UOMs }
var
i, j, k: integer;
begin
for i := t_pos to cT3_pos do
begin
ValuesGrid.Cells[i, 1] := gParameterUnit[i];
end;
for j := 1 to length(gResultMatrix) do
begin
ValuesGrid.Cells[t_pos, j + 1] := FormattedTime(gResultMatrix[j - 1, t_pos]);
for k := TRH_pos to cT3_pos do
begin
ValuesGrid.Cells[k, j + 1] :=
FormatFloat(gNumberFormat, gResultMatrix[j - 1, k] * gParameterFactor[k]);
end;
end;
end;
procedure TSimThyrLogWindow.FormActivate(Sender: TObject);
begin
if Screen.Width < SimThyrLogWindow.Left + SimThyrLogWindow.Width then
SimThyrLogWindow.Width := Screen.Width - SimThyrLogWindow.Left - 13;
SimThyrToolbar.SelectAllMenuItem.Enabled := True;
RedrawGrid(Sender);
gLastActiveCustomForm := SimThyrLogWindow; {stores window as last active form}
end;
procedure TSimThyrLogWindow.InitGrid; {initializes empty table}
begin
GridRows := RES_BLANK_ROWS;
ValuesGrid.RowCount := GridRows;
ValuesGrid.Tag := 1;
end;
procedure TSimThyrLogWindow.PopupMenu1Popup(Sender: TObject);
begin
end;
procedure TSimThyrLogWindow.SaveGrid(theFileName: string; theDelimiter: char);
{saves the contents of the log window}
{file type and, where applicable, delimiter are defined by variable theDelimiter}
var
theCode: integer;
begin
SaveGridToFile(SimThyrLogWindow.ValuesGrid, theFileName, theDelimiter, true, true, theCode);
if theCode = 0 then
SetFileName(SimThyrLogWindow, theFileName)
else
ShowSaveError;
end;
initialization
{$I simthyrlog.lrs}
end.
|
unit PersonalTest;
interface
uses dbTest, dbObjectTest, ObjectTest;
type
TPersonalTest = class (TdbObjectTestNew)
published
procedure ProcedureLoad; override;
procedure Test; override;
end;
TPersonal = class(TObjectTest)
private
function InsertDefault: integer; override;
public
function InsertUpdatePersonal(const Id: integer;
MemberId, PositionId, UnitId, PersonalGroupId: integer; DateIn, DateOut: TDateTime): integer;
constructor Create; override;
end;
implementation
uses DB, dbObjectMeatTest, UtilConst, TestFramework, SysUtils, UnitsTest,
MemberTest, PositionTest;
{ TdbUnitTest }
procedure TPersonalTest.ProcedureLoad;
begin
ScriptDirectory := ProcedurePath + 'OBJECTS\Personal\';
inherited;
end;
procedure TPersonalTest.Test;
var Id: integer;
RecordCount: Integer;
ObjectTest: TPersonal;
begin
ObjectTest := TPersonal.Create;
// Получим список
RecordCount := ObjectTest.GetDataSet.RecordCount;
// Вставка
Id := ObjectTest.InsertDefault;
try
// Получение данных
with ObjectTest.GetRecord(Id) do begin
Check((FieldByName('MemberCode').AsInteger = -1), 'Не сходятся данные Id = ' + IntToStr(Id));
Check((FieldByName('MemberName').AsString = 'Физические лица'), 'Не сходятся данные Id = ' + IntToStr(Id));
end;
finally
ObjectTest.Delete(Id);
end;
end;
{TPersonal}
constructor TPersonal.Create;
begin
inherited;
spInsertUpdate := 'gpInsertUpdate_Object_Personal';
spSelect := 'gpSelect_Object_Personal';
spGet := 'gpGet_Object_Personal';
end;
function TPersonal.InsertDefault: integer;
var
MemberId: Integer;
PositionId: Integer;
UnitId: Integer;
PersonalGroupId: Integer;
begin
MemberId := TMember.Create.GetDefault;
PositionId := TPosition.Create.GetDefault;
UnitId := TUnit.Create.GetDefault;
PersonalGroupId:= 0;
result := InsertUpdatePersonal(0, MemberId, PositionId, UnitId, PersonalGroupId, Date,Date);
end;
function TPersonal.InsertUpdatePersonal(const Id: integer;
MemberId, PositionId, UnitId, PersonalGroupId: integer; DateIn, DateOut: TDateTime): integer;
begin
FParams.Clear;
FParams.AddParam('ioId', ftInteger, ptInputOutput, Id);
FParams.AddParam('inMemberId', ftInteger, ptInput, MemberId);
FParams.AddParam('inPositionId', ftInteger, ptInput, PositionId);
FParams.AddParam('inUnitId', ftInteger, ptInput, UnitId);
FParams.AddParam('inPersonalGroupId', ftInteger, ptInput, PersonalGroupId);
FParams.AddParam('inDateIn', ftDateTime, ptInput, DateIn);
FParams.AddParam('inDateOut', ftDateTime, ptInput, DateOut);
result := InsertUpdate(FParams);
end;
initialization
TestFramework.RegisterTest('Объекты', TPersonalTest.Suite);
end.
|
{
Sobre o autor:
Guinther Pauli
Delphi Certified Professional - 3,5,6,7,2005,2006,Delphi Web,Kylix,XE
Microsoft Certified Professional - MCP,MCAD,MCSD.NET,MCTS,MCPD (C#, ASP.NET, Arquitetura)
Colaborador Editorial Revistas .net Magazine e ClubeDelphi
MVP (Most Valuable Professional) - Embarcadero Technologies - US
http://gpauli.com
http://www.facebook.com/guintherpauli
http://www.twitter.com/guintherpauli
http://br.linkedin.com/in/guintherpauli
}
unit uFramework;
interface
uses
Generics.Collections;
type
// Observer
Observador = class abstract
public procedure Update(); virtual; abstract;
end;
// Subject
Observado = class abstract
private _observadores: TList<Observador>;
public procedure Attach(obs: Observador);
public constructor Create();
public destructor Destroy(); override;
public procedure Notity();
end;
// Concrete Subject
Balanco = class (Observado)
// state é true se balanco está em andamento
private _state: Boolean;
public property State: boolean read _state write _state;
public constructor Create();
public procedure Iniciar();
public procedure Finalizar();
end;
// Concrete Observer
Venda = class (Observador)
private _state: boolean;
private _balanco: Balanco;
public procedure Iniciar();
public procedure Update(); override;
public constructor Create(b: Balanco);
end;
implementation
{ Subject }
procedure Observado.Attach(obs: Observador);
begin
Self._observadores.Add(obs);
end;
constructor Observado.Create();
begin
Self._observadores := TList<Observador>.Create();
end;
destructor Observado.Destroy();
begin
Self._observadores.Free();
inherited;
end;
procedure Observado.Notity();
var
obs: Observador;
begin
// broadcast (avisar todos os observadores)
for obs in _observadores do
obs.Update();
end;
{ Balanco }
constructor Balanco.Create();
begin
inherited Create();
Self._state := false;
end;
procedure Balanco.Finalizar();
begin
_state := false;
WriteLn('Balanço finalizado...');
// notifica os observadores
Notity();
end;
procedure Balanco.Iniciar();
begin
_state := true;
WriteLn('Balanço iniciado...');
// notifica os observadores
Notity();
end;
{ Venda }
constructor Venda.Create(b: Balanco);
begin
self._balanco := b;
end;
procedure Venda.Iniciar();
begin
// state = true se balanço foi iniciado
if (not _state) then
Writeln('Venda iniciada')
else
Writeln('Não pode iniciar venda pois balanço está em andamento');
end;
procedure Venda.Update();
begin
_state := _balanco.State;
end;
end.
|
(***************************************************************************)
(* *)
(* Acorn Atom Emulator v1.33 (c) by Wouter Ras, Delft, Oct 1997 - May 1999 *)
(* ----------------------------------------------------------------------- *)
(* *)
(* This source code may be distributed freely within the following *)
(* restrictions *)
(* 1. You may not charge for this program or for any part of it. *)
(* 2. This copyright message may not be removed from it. *)
(* 3. You may use sections of code from this program in your applications, *)
(* but you must acknowledge its use. I'd appreciate it if you'd let me *)
(* know, i.e. send me a copy of your work. *)
(* *)
(* Please report any problems, questions, comments to me at one or both of *)
(* these addresses: avio@casema.net *)
(* wouterras@hotmail.com *)
(* *)
(* The latest version of the emulator can be downloaded from my Atom-page: *)
(* http://www.casema.net/~avio/atom.htm *)
(* *)
(***************************************************************************)
{$g+,f-,i-,r-,s-,m 16384,273500,273500}
PROGRAM ACORN_ATOM;
USES DOS,ATOMROM,FDC8271,LEENDERT;
CONST FOUTBUFSIZE = $1000;
MAXAANTFILES = 400;
TYPE STR2 = STRING[2];
STR4 = STRING[4];
STR8 = STRING[8];
FILELISTTYPE = ARRAY[0..PRED(MAXAANTFILES)] OF STR8;
ATMFILEREC = RECORD
ATMNAME : ARRAY[$00..$0F] OF CHAR;
STARTADRS : WORD;
EXECADRS : WORD;
DATASIZE : WORD;
END;
ATMFILETYPE = ARRAY[0..PRED(MAXAANTFILES)] OF ATMFILEREC;
FINBUFTYPE = ARRAY[$0000..$FFF8] OF BYTE;
FOUTBUFTYPE = ARRAY[$0000..PRED(FOUTBUFSIZE)] OF BYTE;
TEMPMOUSETYPE = RECORD
B_BFE0 : BYTE;
B_BFE1 : BYTE;
B_MOUSENR : BYTE;
MOUSEX : WORD;
MOUSEY : WORD;
END;
CONST NMI_VECTOR = $FFFA;
RES_VECTOR = $FFFC; {reset}
IRQ_VECTOR = $FFFE;
BRK_VECTOR = $FFFE;
STACKBASE = $0100;
CYCLESFLYBACK = +2040; {number of cycles during flyback}
COUNTER = $BFF4; {WORD: counter for checking F9, F12 etc.}
IRQ_NMI = $BFF6; {BYTE: NMI or IRQ request, see also FDC8271}
INSTRCYCLES = $BFF7; {BYTE: number of cycles for an instruction}
PCCYCLES = $BFF8; {WORD: number of cycles that the PC needs to execute an instruction}
AANTCYCLES = $BFFA; {WORD: keep track of the cycles}
WACHTSCHULD = $BFFC; {WORD: built-up debt, e.g. because of screenupdates}
SCHAKELBYTE = $BFFF; {BYTE: switchbyte for EPROM at A000h}
LOADVEC = $020C;
SAVEVEC = $020E;
GETBYTEVEC = $0214;
PUTBYTEVEC = $0216;
FINDVEC = $0218;
FLIPFLOP = $BF7F;
STR8GROOTTE = SIZEOF(STR8);
ATMRECGROOTTE = SIZEOF(ATMFILEREC);
HEXSTR : ARRAY[$00..$0F] OF CHAR = '0123456789ABCDEF';
VAR ATOMMEM1 : POINTER;
ATOMMEM2 : POINTER;
ATOMMEM3 : POINTER;
BOXNAMES : ARRAY[0..15,0..15] OF CHAR;
DISKIMAGES : FILELISTTYPE;
AANTALDISKIMAGES: INTEGER; {number of disk images}
TAPEIMAGES : FILELISTTYPE;
AANTALTAPEIMAGES: INTEGER; {number of tape images}
IMPFILES : ATMFILETYPE;
AANTALIMPFILES : INTEGER; {number of importable files}
ATOMFILES : ATMFILETYPE;
AANTALATOMFILES : INTEGER; {number of atom files in an image}
ATOMMEMSEG : WORD;
IOPORT : WORD; {soundblaster base i/o port}
CHARDATA : ARRAY[$00..$BF,$00..$0F] OF BYTE;
MONOGRAPHTABLE : ARRAY[$00..$FF,$00..$03] OF WORD;
GREYGRAPHTABLE : ARRAY[$00..$FF,$00..$03] OF WORD;
COLORGRAPHTABLE : ARRAY[$00..$FF,$00..$03] OF WORD;
TAPEIMAGENAME : STRING[8];
EXTROMFILE : STRING[12];
FOUTNAME : STRING[16];
IMAGEFOUTNAME : STRING[8];
CATSEARCH : ARRAY[0..15] OF CHAR;
FINBUF : ^FINBUFTYPE;
FINBUFPTR : WORD;
FINBUFOFS : WORD;
FINBUFSEG : WORD;
FINSIZE : WORD;
FOUTBUF : ^FOUTBUFTYPE;
FOUTBUFPTR : WORD;
FOUTBUFOFS : WORD;
FOUTBUFSEG : WORD;
FOUTOPEN : BYTE;
BMPHEADER : ARRAY[$0000..$0075] OF BYTE;
MOUSEBACKGROUND : ARRAY[0..7,0..7] OF WORD;
MOUSEPOINTER : ARRAY[0..7,0..7] OF WORD;
TEMPMOUSEDAT : TEMPMOUSETYPE;
{===========================================================================}
{A number of variables will be declared here as procedures. This was to only}
{way that I could think of to have them reside in the CSEG and keeping them}
{global. During emulation the DS register is pointing to the Atom memory}
{segment, the ES register is A000h, i.e. the video bank; Reading/writing a}
{variable using the CS: prefix takes much less time than swapping the DS or}
{ES registers all the time. }
{Every procedure with this purpose has the ASSEMBLER directive, meaning that}
{no stackframe is generated. The RETN instruction (C3h) is generated at the}
{end of the proc. automatically and takes one byte (sometimes used as data).}
{===========================================================================}
{---[toets (english: key)]--------------------------------------------------}
PROCEDURE TOETS; ASSEMBLER;
ASM;
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DW 0
END;
{---[filenamebuf]-----------------------------------------------------------}
PROCEDURE FILENAMEBUF; ASSEMBLER;
ASM;
DD 0,0,0,0
END;
{---[widertable]------------------------------------------------------------}
PROCEDURE WIDERTABLE; ASSEMBLER;
ASM;
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
END;
{---[wider1atable]----------------------------------------------------------}
PROCEDURE WIDER1aTABLE; ASSEMBLER;
ASM;
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
DD 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
END;
{---[opcodes (used for disassembling)]--------------------------------------}
PROCEDURE OPCODES; ASSEMBLER;
{ first digit = mnemonic }
{ second digit = 1 Accumulator ³ 8 Absolute, Y }
{ 2 Immediate ³ 9 Implied }
{ 3 Zero Page ³10 Relative }
{ 4 Zero Page, X ³11 (Indirect, X) }
{ 5 Zero Page, Y ³12 (Indirect), Y }
{ 6 Absolute ³13 Absolute Indirect }
{ 7 Absolute, X ³14 (Indirect) }
{ ³15 (Abs.Indirect, X) }
ASM;
DB 11, 9, 35,11, 70, 9, 34, 9, 64, 3, 35, 3, 3, 3, 34, 9
DB 37, 9, 35, 2, 3, 1, 34, 9, 64, 6, 35, 6, 3, 6, 34, 9
{10} DB 10,10, 35,12, 35,14, 34, 9, 63, 3, 35, 4, 3, 4, 34, 9
DB 14, 9, 35, 8, 25, 1, 66, 9, 63, 6, 35, 7, 3, 7, 34, 9
{20} DB 29, 6, 2,11, 34, 3, 34, 9, 7, 3, 2, 3, 40, 3, 34, 9
DB 39, 9, 2, 2, 40, 1, 34, 9, 7, 6, 2, 6, 40, 6, 34, 9
{30} DB 8,10, 2,12, 2,14, 34, 9, 7, 4, 2, 4, 40, 4, 34, 9
DB 45, 9, 2, 8, 21, 1, 67, 9, 7, 7, 2, 7, 40, 7, 34, 9
{40} DB 42, 9, 24,11, 34, 3, 34, 9, 34, 3, 24, 3, 33, 3, 34, 9
DB 36, 9, 24, 2, 33, 1, 34, 9, 28, 6, 24, 6, 33, 6, 34, 9
{50} DB 12,10, 24,12, 24,14, 34, 9, 34, 3, 24, 4, 33, 4, 34, 9
DB 16, 9, 24, 8, 59, 9, 34, 9, 34, 6, 24, 7, 33, 7, 34, 9
{60} DB 43, 9, 1,11, 34, 3, 34, 9, 62, 3, 1, 3, 41, 3, 34, 9
DB 38, 9, 1, 2, 41, 1, 34, 9, 28,13, 1, 6, 41, 6, 34, 9
{70} DB 13,10, 1,12, 1,14, 34, 9, 62, 4, 1, 4, 41, 4, 34, 9
DB 47, 9, 1, 8, 61, 9, 34, 9, 28,15, 1, 7, 41, 7, 34, 9
{80} DB 57,10, 48,11, 34, 3, 34, 9, 50, 3, 48, 3, 49, 3, 34, 9
DB 23, 9, 7, 2, 54, 9, 34, 9, 50, 6, 48, 6, 49, 6, 34, 9
{90} DB 4,10, 48,12, 48,14, 34, 9, 50, 4, 48, 4, 49, 5, 34, 9
DB 56, 9, 48, 8, 55, 9, 68, 9, 62, 6, 48, 7, 62, 7, 34, 9
{A0} DB 32, 2, 30,11, 31, 2, 34, 9, 32, 3, 30, 3, 31, 3, 34, 9
DB 52, 9, 30, 2, 51, 9, 34, 9, 32, 6, 30, 6, 31, 6, 34, 9
{B0} DB 5,10, 30,12, 30,14, 34, 9, 32, 4, 30, 4, 31, 5, 34, 9
DB 17, 9, 30, 8, 53, 9, 69, 9, 32, 7, 30, 7, 31, 8, 34, 9
{C0} DB 20, 2, 18,11, 34, 3, 34, 9, 20, 3, 18, 3, 21, 3, 34, 9
DB 27, 9, 18, 2, 22, 9, 34, 9, 20, 6, 18, 6, 21, 6, 34, 9
{D0} DB 9,10, 18,12, 18,14, 34, 9, 34, 3, 18, 4, 21, 4, 34, 9
DB 15, 9, 18, 8, 58, 9, 34, 9, 34, 6, 18, 7, 21, 7, 34, 9
{E0} DB 19, 2, 44,11, 34, 3, 34, 9, 19, 3, 44, 3, 25, 3, 34, 9
DB 26, 9, 44, 2, 34, 9, 65, 9, 19, 6, 44, 6, 25, 6, 34, 9
{F0} DB 6,10, 44,12, 44,14, 34, 9, 34, 3, 44, 4, 25, 4, 34, 9
DB 46, 9, 44, 8, 60, 9, 34, 9, 29,15, 44, 7, 25, 7, 34, 9
END;
{---[mnemonics]-------------------------------------------------------------}
PROCEDURE MNEMONICS; ASSEMBLER;
ASM;
DB '???','ADC','AND','ASL','BCC','BCS','BEQ','BIT','BMI','BNE'{ 0}
DB 'BPL','BRK','BVC','BVS','CLC','CLD','CLI','CLV','CMP','CPX'{10}
DB 'CPY','DEC','DEX','DEY','EOR','INC','INX','INY','JMP','JSR'{20}
DB 'LDA','LDX','LDY','LSR','NOP','ORA','PHA','PHP','PLA','PLP'{30}
DB 'ROL','ROR','RTI','RTS','SBC','SEC','SED','SEI','STA','STX'{40}
DB 'STY','TAX','TAY','TSX','TXA','TXS','TYA','BRA','PHX','PHY'{50}
DB 'PLX','PLY','STZ','TRB','TSB','SWA','TAS','TSA','TXY','TYX'{60}
DB 'COP' {70}
END;
{---[decnum]----------------------------------------------------------------}
PROCEDURE DECNUM; ASSEMBLER;
ASM;
DB $00,$00,$00,$00,$00,$00
END;
{---[characters (need to be ROLled left 1 bit)]-----------------------------}
PROCEDURE CHARACTERS; ASSEMBLER;
ASM;
DB $0E,$11,$01,$0D,$15,$15,$0E {@}
DB $04,$0A,$11,$11,$1F,$11,$11 {A}
DB $1E,$09,$09,$0E,$09,$09,$1E {B}
DB $0E,$11,$10,$10,$10,$11,$0E {C}
DB $1E,$09,$09,$09,$09,$09,$1E {D}
DB $1F,$10,$10,$1C,$10,$10,$1F {E}
DB $1F,$10,$10,$1E,$10,$10,$10 {F}
DB $0F,$10,$10,$13,$11,$11,$0F {G}
DB $11,$11,$11,$1F,$11,$11,$11 {H}
DB $0E,$04,$04,$04,$04,$04,$0E {I}
DB $01,$01,$01,$01,$11,$11,$0E {J}
DB $11,$12,$14,$18,$14,$12,$11 {K}
DB $10,$10,$10,$10,$10,$10,$1F {L}
DB $11,$1B,$15,$15,$11,$11,$11 {M}
DB $11,$19,$15,$13,$11,$11,$11 {N}
DB $1F,$11,$11,$11,$11,$11,$1F {O}
DB $1E,$11,$11,$1E,$10,$10,$10 {P}
DB $0E,$11,$11,$11,$15,$12,$0D {Q}
DB $1E,$11,$11,$1E,$14,$12,$11 {R}
DB $0E,$11,$08,$04,$02,$11,$0E {S}
DB $1F,$04,$04,$04,$04,$04,$04 {T}
DB $11,$11,$11,$11,$11,$11,$0E {U}
DB $11,$11,$11,$11,$0A,$0A,$04 {V}
DB $11,$11,$11,$15,$15,$1B,$11 {W}
DB $11,$11,$0A,$04,$0A,$11,$11 {X}
DB $11,$11,$0A,$04,$04,$04,$04 {Y}
DB $1F,$01,$02,$04,$08,$10,$1F {Z}
DB $0E,$08,$08,$08,$08,$08,$0E {[}
DB $10,$10,$08,$04,$02,$01,$01 {\}
DB $0E,$02,$02,$02,$02,$02,$0E {]}
DB $04,$0E,$15,$04,$04,$04,$04 {^}
DB $00,$04,$08,$1F,$08,$04,$00 {<-}
DB $00,$00,$00,$00,$00,$00,$00 {space}
DB $04,$04,$04,$04,$04,$00,$04 {!}
DB $0A,$0A,$00,$00,$00,$00,$00 {"}
DB $0A,$0A,$1B,$00,$1B,$0A,$0A {#}
DB $04,$0F,$10,$0E,$01,$1E,$04 {"$"}
DB $19,$19,$02,$04,$08,$13,$13 {%}
DB $08,$14,$14,$08,$15,$12,$0D {&}
DB $06,$06,$06,$00,$00,$00,$00 {'}
DB $02,$04,$08,$08,$08,$04,$02 {(}
DB $08,$04,$02,$02,$02,$04,$08 {)}
DB $00,$04,$0E,$1F,$0E,$04,$00 {*}
DB $00,$04,$04,$1F,$04,$04,$00 {+}
DB $00,$00,$00,$06,$06,$02,$04 {,}
DB $00,$00,$00,$1F,$00,$00,$00 {-}
DB $00,$00,$00,$00,$00,$06,$06 {.}
DB $01,$01,$02,$04,$08,$10,$10 {/}
DB $0C,$12,$12,$12,$12,$12,$0C {0}
DB $04,$0C,$04,$04,$04,$04,$0E {1}
DB $0E,$11,$01,$0E,$10,$10,$1F {2}
DB $0E,$11,$01,$06,$01,$11,$0E {3}
DB $02,$06,$0A,$1F,$02,$02,$02 {4}
DB $1F,$10,$1E,$01,$01,$11,$0E {5}
DB $0E,$10,$10,$1E,$11,$11,$0E {6}
DB $1F,$01,$02,$04,$08,$10,$10 {7}
DB $0E,$11,$11,$0E,$11,$11,$0E {8}
DB $0E,$11,$11,$0F,$01,$01,$0E {9}
DB $00,$06,$06,$00,$06,$06,$00 {:}
DB $06,$06,$00,$06,$06,$02,$04 {;}
DB $02,$04,$08,$10,$08,$04,$02 {<}
DB $00,$00,$1F,$00,$1F,$00,$00 {=}
DB $10,$08,$04,$02,$04,$08,$10 {>}
DB $0C,$12,$02,$04,$04,$00,$04 {?}
END;
{---[mousecursors]----------------------------------------------------------}
PROCEDURE MOUSECURSORS; ASSEMBLER;
ASM;
{00h} DB 11111111b
DB 10000010b
DB 10000100b
DB 10000100b
DB 10000010b
DB 10110001b
DB 11001010b
DB 10000100b
{01h} DB 11111100b
DB 11111000b
DB 11110000b
DB 11111000b
DB 11011100b
DB 10001110b
DB 00000111b
DB 00000010b
{02h} DB 00111100b
DB 01010010b
DB 10010001b
DB 10010001b
DB 10011101b
DB 10000001b
DB 01000010b
DB 00111100b
{03h} DB 11110000b
DB 11000000b
DB 10100000b
DB 10010000b
DB 00001000b
DB 00000100b
DB 00000000b
DB 00000000b
{04h} DB 00010000b
DB 00101000b
DB 01000100b
DB 11000110b
DB 01000100b
DB 01000100b
DB 01000100b
DB 01111100b
{05h} DB 01111100b
DB 01000100b
DB 01000100b
DB 01000100b
DB 11000110b
DB 01000100b
DB 00101000b
DB 00010000b
{06h} DB 00001000b
DB 11111100b
DB 10000010b
DB 10000001b
DB 10000010b
DB 11111100b
DB 00001000b
DB 00000000b
{07h} DB 00010000b
DB 00111111b
DB 01000001b
DB 10000001b
DB 01000001b
DB 00111111b
DB 00010000b
DB 00000000b
{08h} DB 00111100b
DB 01000110b
DB 10001101b
DB 10001101b
DB 10011001b
DB 10011001b
DB 01110010b
DB 00111100b
{09h} DB 00111000b
DB 01000100b
DB 01010100b
DB 01110100b
DB 00101000b
DB 00111000b
DB 00101000b
DB 00111000b
{0Ah} DB 01111100b
DB 01000100b
DB 01101100b
DB 00101000b
DB 00101000b
DB 01101100b
DB 01000100b
DB 01111100b
{0Bh} DB 00111000b
DB 00101000b
DB 11101110b
DB 10000010b
DB 11101110b
DB 00101000b
DB 00111000b
DB 00000000b
{0Ch} DB 01000000b
DB 10100000b
DB 10100000b
DB 10111110b
DB 10101011b
DB 10000001b
DB 11111111b
DB 01111110b
{0Dh} DB 01111110b
DB 11111111b
DB 10000001b
DB 10101011b
DB 10111110b
DB 10100000b
DB 10100000b
DB 01000000b
{0Eh} DB 01111110b
DB 11000001b
DB 11011110b
DB 11001000b
DB 11011000b
DB 11001000b
DB 11011000b
DB 01110000b
{0Fh} DB 01111110b
DB 10000011b
DB 01111011b
DB 00010011b
DB 00011011b
DB 00010011b
DB 00011011b
DB 00001110b
{10h} DB 01111110b
DB 01111110b
DB 00111100b
DB 00011000b
DB 00011000b
DB 00100100b
DB 01000010b
DB 01111110b
{11h} DB 01111110b
DB 01100110b
DB 00111100b
DB 00011000b
DB 00011000b
DB 00100100b
DB 01011010b
DB 01111110b
{12h} DB 01111110b
DB 01000010b
DB 00111100b
DB 00011000b
DB 00011000b
DB 00100100b
DB 01111110b
DB 01111110b
{13h} DB 01111110b
DB 01000010b
DB 00100100b
DB 00011000b
DB 00011000b
DB 00111100b
DB 01111110b
DB 01111110b
{14h} DB 11100000b
DB 10011000b
DB 01000110b
DB 00110001b
DB 01101011b
DB 01010101b
DB 00101001b
DB 00011110b
{15h} DB 00000111b
DB 00011001b
DB 01100010b
DB 10001100b
DB 11010110b
DB 10101010b
DB 10010100b
DB 01111000b
{16h} DB 00011110b
DB 00101001b
DB 01010101b
DB 01101011b
DB 00110001b
DB 01000110b
DB 10011000b
DB 11100000b
{17h} DB 01111000b
DB 10010100b
DB 10101010b
DB 11010110b
DB 10001100b
DB 01100010b
DB 00011001b
DB 00000111b
{18h} DB 01100110b
DB 10011001b
DB 10011001b
DB 11011101b
DB 11011101b
DB 10011001b
DB 10011001b
DB 01100110b
{19h} DB 01100110b
DB 11111111b
DB 11111111b
DB 10011001b
DB 10011001b
DB 10011001b
DB 10011001b
DB 01100110b
{1Ah} DB 01100110b
DB 10011001b
DB 10011001b
DB 10111011b
DB 10111011b
DB 10011001b
DB 10011001b
DB 01100110b
{1Bh} DB 01100110b
DB 10011001b
DB 10011001b
DB 10011001b
DB 10011001b
DB 11111111b
DB 11111111b
DB 01100110b
{1Ch} DB 11111111b
DB 10000010b
DB 10000100b
DB 10001000b
DB 10010000b
DB 10100000b
DB 11000000b
DB 10000000b
{1Dh} DB 10000000b
DB 11000000b
DB 10100000b
DB 10010000b
DB 10001000b
DB 10000100b
DB 10000010b
DB 11111111b
{1Eh} DB 00000001b
DB 00000011b
DB 00000101b
DB 00001001b
DB 00010001b
DB 00100001b
DB 01000001b
DB 11111111b
{1Fh} DB 11111111b
DB 01000001b
DB 00100001b
DB 00010001b
DB 00001001b
DB 00000101b
DB 00000011b
DB 00000001b
END;
{---[keyscan]---------------------------------------------------------------}
PROCEDURE KEYSCAN; ASSEMBLER;
ASM;
DB $00,$04,$0C,$22,$10,$01,$00,$00 {0: ±,3,-,g,q,esc}
DB $00,$03,$33,$21,$19,$2C,$00,$00 {1: ±,2,<,f,p,z}
DB $80,$02,$27,$12,$18,$15,$00,$00 {2: up,1,+(;),e,o,y}
DB $81,$0B,$0D,$20,$31,$2D,$00,$00 {3: rt,0,:(=),d,n,x}
DB $3A,$0E,$0A,$2E,$32,$11,$00,$00 {4: lock,del,9,c,m,w}
DB $29,$0F,$09,$30,$26,$2F,$00,$00 {5: ~,copy(tab),8,b,l,v}
DB $1B,$1C,$08,$1E,$25,$16,$00,$00 {6: ],ret,7,a,k,u}
DB $2B,$00,$07,$28,$24,$14,$00,$00 {7: \,±,6,@('),j,t}
DB $1A,$00,$06,$35,$17,$1F,$00,$00 {8: [,±,5,/,i,s}
DB $39,$00,$05,$34,$23,$13,$00,$00 {9: space,±,4,>,h,r}
END;
{---[altkeyscan]------------------------------------------------------------}
PROCEDURE ALTKEYSCAN; ASSEMBLER;
ASM;
DB $00,$04,$0C,$22,$10,$01,$00,$00 {0: ±,3,-,g,q,esc}
DB $00,$03,$33,$21,$19,$2C,$00,$00 {1: ±,2,<,f,p,z}
DB $3A,$02,$27,$12,$18,$15,$00,$00 {2: up,1,+(;),e,o,y}
DB $0F,$0B,$0D,$20,$31,$2D,$00,$00 {3: rt,0,:(=),d,n,x}
DB $4B,$0E,$0A,$2E,$32,$11,$00,$00 {4: lock,del,9,c,m,w}
DB $29,$4D,$09,$30,$26,$2F,$00,$00 {5: ~,copy,8,b,l,v}
DB $1B,$1C,$08,$1E,$25,$16,$00,$00 {6: ],ret,7,a,k,u}
DB $2B,$00,$07,$28,$24,$14,$00,$00 {7: \,±,6,@('),j,t}
DB $1A,$00,$06,$35,$17,$1F,$00,$00 {8: [,±,5,/,i,s}
DB $39,$00,$05,$34,$23,$13,$00,$00 {9: space,±,4,>,h,r}
END;
{---[bioscode]--------------------------------------------------------------}
PROCEDURE BIOSCODE; ASSEMBLER;
ASM;
DW $FFFF,$1B1B,'!1','@2','#3','$4','%5','^6' {00}
DW '&7','*8','(9',')0','_-','+=',$0808,$0909 {08}
DW 'QQ','WW','EE','RR','TT','YY','UU','II' {10}
DW 'OO','PP','{[','}]',$0D0D,$FFFF,'AA','SS' {18}
DW 'DD','FF','GG','HH','JJ','KK','LL',':;' {20}
DW '"''','~`',$FFFF,'|\','ZZ','XX','CC','VV' {28}
DW 'BB','NN','MM','<,','>.','?/',$FFFF,'**' {30}
DW $FFFF,' ',$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {38}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {40}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {48}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {50}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {58}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {60}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {68}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {70}
DW $FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF,$FFFF {78}
END;
{---[debugtxt]--------------------------------------------------------------}
PROCEDURE DEBUGTXT; ASSEMBLER;
ASM;
DB 00000000b,00000000b,00000000b,00000000b
DB 01111001b,11110111b,10010001b,00111000b
DB 01000101b,00000100b,01010001b,01000100b
DB 01000101b,00000100b,01010001b,01000000b
DB 01000101b,11100111b,10010001b,01011100b
DB 01000101b,00000100b,01010001b,01000100b
DB 01000101b,00000100b,01010001b,01000100b
DB 01111001b,11110111b,10001111b,00111000b
DB 00000000b,00000000b,00000000b,00000000b
DB 00001000b,10011100b,11110011b,11100000b
DB 00001101b,10100010b,10001010b,00000000b
DB 00001010b,10100010b,10001010b,00000000b
DB 00001010b,10100010b,10001011b,11000000b
DB 00001000b,10100010b,10001010b,00000000b
DB 00001000b,10100010b,10001010b,00000000b
DB 00001000b,10011100b,11110011b,11100000b
DB 00000000b,00000000b,00000000b,00000000b
END;
{---[emulcolors]------------------------------------------------------------}
PROCEDURE EMULCOLORS; ASSEMBLER;
ASM;
DB $00,$00,$00 {00h: backgr}
DB $00,$2A,$00 {01h: foregr}
DB $00,$15,$00 {02h: greysb}
DB $00,$2A,$00 {03h: color0}
DB $3F,$3F,$2A {04h: color1}
DB $00,$00,$00 {05h: color2}
DB $0A,$0A,$0A {06h: color3}
DB $00,$00,$00 {07h: randkleur}
DB $00,$00,$2A {08h: blauw}
DB $34,$00,$00 {09h: rood}
DB $20,$10,$00 {0Ah: bruin}
DB $20,$20,$20 {0Bh: grijs}
DB $15,$3F,$15 {0Ch: licht groen}
DB $00,$00,$00 {0Dh: zwart}
DB $3F,$3F,$15 {0Eh: geel}
DB $3F,$3F,$3F {0Fh: wit}
END;
{---[intensmono]------------------------------------------------------------}
PROCEDURE INTENSMONO; ASSEMBLER;
ASM;
DB $00,$3F,$00
END;
{---[intenscolor]-----------------------------------------------------------}
PROCEDURE INTENSCOLOR; ASSEMBLER;
ASM;
DB $00,$1C,$00
END;
{---[pcwaittable (filled depending on CPU speed)]---------------------------}
PROCEDURE PCWAITTABLE; ASSEMBLER;
ASM;
DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
END;
{---[wachtconst (if specified in .INI file)]--------------------------------}
PROCEDURE WACHTCONST; ASSEMBLER;
ASM;
DW $0000
END;
{---[cursorx]---------------------------------------------------------------}
PROCEDURE CURSORX; ASSEMBLER;
ASM;
END;
{---[cursory]---------------------------------------------------------------}
PROCEDURE CURSORY; ASSEMBLER;
ASM;
END;
{---[dataseg (word)]--------------------------------------------------------}
PROCEDURE DATASEG; ASSEMBLER;
ASM;
DB $00
END;
{---[sortdir]---------------------------------------------------------------}
PROCEDURE SORTDIR (VAR A:FILELISTTYPE; LO,HI:INTEGER);
VAR X,Y:STR8;
PROCEDURE SORTEER (L,R:INTEGER);
VAR I,J:INTEGER;
BEGIN
I := L;
J := R;
X := A[(L+R) DIV 2];
REPEAT
WHILE A[I] < X DO INC (I);
WHILE X < A[J] DO DEC (J);
IF I <= J THEN
BEGIN
Y := A[I];
A[I] := A[J];
A[J] := Y;
INC (I);
DEC (J);
END;
UNTIL I > J;
IF L < J THEN SORTEER (L,J);
IF I < R THEN SORTEER (I,R);
END;
BEGIN
SORTEER (LO,HI);
END;
{---[readdirectory]---------------------------------------------------------}
PROCEDURE READDIRECTORY;
VAR D:SEARCHREC;
I:WORD;
BEGIN
AANTALATOMFILES := 0;
AANTALTAPEIMAGES := 0;
FINDFIRST ('*.TAP',ANYFILE,D);
WHILE (DOSERROR = 0) AND (AANTALTAPEIMAGES < MAXAANTFILES) DO
BEGIN
IF D.ATTR AND $18 = $00 THEN
BEGIN
D.NAME := COPY(D.NAME,1,LENGTH(D.NAME)-4);
TAPEIMAGES[AANTALTAPEIMAGES] := D.NAME;
INC (AANTALTAPEIMAGES);
END;
FINDNEXT (D);
END;
IF AANTALTAPEIMAGES > 0 THEN SORTDIR (TAPEIMAGES,0,PRED(AANTALTAPEIMAGES));
AANTALDISKIMAGES := 0;
FINDFIRST ('*.DSK',ANYFILE,D);
WHILE (DOSERROR = 0) AND (AANTALDISKIMAGES < MAXAANTFILES) DO
BEGIN
IF (D.ATTR AND (VOLUMEID OR DIRECTORY) = $00) AND (D.SIZE=40*10*256) THEN
BEGIN
D.NAME := COPY(D.NAME,1,LENGTH(D.NAME)-4);
DISKIMAGES[AANTALDISKIMAGES] := D.NAME;
INC (AANTALDISKIMAGES);
END;
FINDNEXT (D);
END;
IF AANTALDISKIMAGES > 0 THEN SORTDIR (DISKIMAGES,0,PRED(AANTALDISKIMAGES));
END;
{---[copywriteprot]---------------------------------------------------------}
PROCEDURE COPYWRITEPROT;
CONST WP:ARRAY[0..1] OF BYTE = ($0F,$F0);
VAR I,J:BYTE;
D:SEARCHREC;
BEGIN
WRITEPROTECT[$00] := $00;
WRITEPROTECT[$01] := $00;
FOR I := 0 TO 3 DO
BEGIN
IF DISKETTENAMES[I] <> '' THEN
BEGIN
FINDFIRST (DISKETTENAMES[I]+'.DSK',ANYFILE,D);
IF DOSERROR=0 THEN
BEGIN
J := D.ATTR AND READONLY;
IF J <> 0 THEN
WRITEPROTECT[I AND 1] := WRITEPROTECT[I AND 1] OR WP[I SHR 1]
END ELSE
BEGIN
DISKETTENAMES[I] := '';
END;
END;
END;
END;
{---[readfilesintapeimage]--------------------------------------------------}
PROCEDURE READFILESINTAPEIMAGE;
VAR FROMF : FILE;
TAPESIZE : LONGINT;
FPOS : LONGINT;
NR : WORD;
DUMMY : INTEGER;
BEGIN
DUMMY := IORESULT;
AANTALATOMFILES := 0;
IF LENGTH(TAPEIMAGENAME) = 0 THEN EXIT;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN EXIT;
TAPESIZE := FILESIZE (FROMF);
FPOS := 0;
WHILE FPOS < TAPESIZE DO
BEGIN
SEEK (FROMF,FPOS);
BLOCKREAD (FROMF,ATOMFILES[AANTALATOMFILES],SIZEOF(ATMFILEREC),NR);
IF NR <> SIZEOF(ATMFILEREC) THEN
BEGIN
CLOSE (FROMF);
EXIT;
END;
INC (FPOS,SIZEOF(ATMFILEREC)+LONGINT(ATOMFILES[AANTALATOMFILES].DATASIZE));
INC (AANTALATOMFILES);
END;
CLOSE (FROMF);
END;
{---[tempdosprompt]---------------------------------------------------------}
PROCEDURE TEMPDOSPROMPT;
VAR CURDIR:STRING;
I:BYTE;
J:WORD;
BEGIN
GETDIR (0,CURDIR);
ASM;
MOV AX,$0003
INT $10
END;
WRITELN;
WRITELN (' Type EXIT to return to the Acorn Atom Emulator...');
ASM;
MOV AX,$B800
MOV ES,AX
MOV BX,$0001
@TDP1: MOV BYTE PTR [ES:BX],$1E
ADD BX,+$02
CMP BX,+481
JB @TDP1
END;
EXEC (GETENV('COMSPEC'),'');
CHDIR (CURDIR);
READDIRECTORY;
COPYWRITEPROT;
READFILESINTAPEIMAGE;
END;
{---[nextline]--------------------------------------------------------------}
PROCEDURE NEXTLINE; ASSEMBLER;
ASM;
MOV BYTE PTR [CS:CURSORX],$00
INC BYTE PTR [CS:CURSORY]
CMP BYTE PTR [CS:CURSORY],+19
JB @NEXTLINE1
PUSHA
DEC BYTE PTR [CS:CURSORY]
CLI
MOV DI,+20*$0120
MOV SI,+30*$0120
MOV CX,(200-30)*$0120/2
REPZ
MOVSW
MOV CX,+10*$0120/2
SUB AX,AX
REPZ
STOSW
STI
POPA
@NEXTLINE1:
END;
{---[printchar; AL=char; BL=color (used by desktop)]------------------------}
PROCEDURE PRINTCHAR; ASSEMBLER;
ASM;
PUSH DS
PUSHA
MOV DI,SEG CHARDATA
MOV DS,DI
MOV AH,$00
SHL AX,4
ADD AX,OFFSET CHARDATA
ADD AX,+2
MOV SI,AX
MOV AL,BYTE PTR [CS:CURSORY]
MOV AH,$00
MOV CX,10*$0120
MUL CX
ADD AX,$0140
MOV DI,AX
MOV AL,BYTE PTR [CS:CURSORX]
ADD AL,+12
MOV AH,$00
SHL AX,2
ADD DI,AX
MOV CH,+10
@PRINTCH4: LODSB
MOV AH,$01
@PRINTCH5: TEST BL,AH
JZ @PRINTCH1
CMP AH,$02
JNZ @PRINTCH6
STOSB
JMP @PRINTCH2
@PRINTCH6: MOV BYTE PTR [ES:DI],$FF
INC DI
JMP @PRINTCH2
@PRINTCH1: CMP AH,$02
JNZ @PRINTCH7
MOV BYTE PTR [ES:DI],$00
INC DI
JMP @PRINTCH2
@PRINTCH7: NOT AL
STOSB
NOT AL
@PRINTCH2: SHL AH,1
CMP AH,$10
JB @PRINTCH5
ADD DI,$011C
DEC CH
JNZ @PRINTCH4
INC BYTE PTR [CS:CURSORX]
CMP BYTE PTR [CS:CURSORX],+40
JB @PRINTCH3
CALL NEXTLINE
@PRINTCH3: POPA
POP DS
END;
{---[xorput; DI=screenpos; AL=color (00h-0Fh); CX=length]-------------------}
PROCEDURE XORPUT; ASSEMBLER;
ASM;
PUSH AX
PUSH BX
PUSH CX
PUSH DX
MOV BYTE PTR @XORPKLR,AL
MOV DL,+9
@XORP6: PUSH DX
PUSH DI
PUSH CX
@XORP5: PUSH CX
MOV DL,BYTE PTR @XORPKLR
MOV CL,$0D
MOV AX,$FFFF
SUB BX,BX
@XORP2: MOV DH,BYTE PTR [ES:DI+BX]
SHR DL,1
JC @XORP1
NOT DH
@XORP1: AND AL,DH
MOV DH,BYTE PTR [ES:DI+BX]
SHR CL,1
JC @XORP7
NOT DH
@XORP7: AND AH,DH
INC BL
CMP BL,$04
JNZ @XORP2
POP CX
{AL geeft posities van kleur aan; AH van zwart (0Dh)}
OR BYTE PTR [ES:DI],AL
NOT AL
AND BYTE PTR [ES:DI+$01],AL
NOT AL
OR BYTE PTR [ES:DI+$02],AL
OR BYTE PTR [ES:DI+$03],AL
MOV AL,AH
NOT AL
MOV DL,BYTE PTR @XORPKLR
SUB BX,BX
@XORP4: AND BYTE PTR [ES:DI+BX],AL
SHR DL,1
JNC @XORP3
OR BYTE PTR [ES:DI+BX],AH
@XORP3: INC BL
CMP BL,$04
JNZ @XORP4
ADD DI,+$04
LOOP @XORP5
POP CX
POP DI
POP DX
ADD DI,$0120
DEC DL
JNZ @XORP6
POP DX
POP CX
POP BX
POP AX
RETN
@XORPKLR:
END;
{---[altkeyb (one byte)]----------------------------------------------------}
PROCEDURE ALTKEYB; ASSEMBLER;
ASM;
END;
{---[swapkeyboard]----------------------------------------------------------}
PROCEDURE SWAPKEYBOARD; ASSEMBLER;
ASM;
PUSHA
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+8
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@SWAP1: CALL PRINTCHAR
LOOP @SWAP1
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
MOV SI,OFFSET @STANDARDTXT
XOR BYTE PTR [CS:ALTKEYB],$01
JZ @SWAP3
MOV SI,OFFSET @ALTERNATETXT
@SWAP3: MOV BL,$0C
@SWAP5: MOV AL,BYTE PTR [CS:SI]
INC SI
AND AL,$3F
JZ @SWAP4
CALL PRINTCHAR
JMP @SWAP5
@SWAP4: MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@SWAP2: CALL PRINTCHAR
LOOP @SWAP2
MOV AL,01101000b
CALL PRINTCHAR
POPA
RETN
@ALTERNATETXT: DB ' ALTERNATE KEYBOARD ',$00
@STANDARDTXT: DB ' STANDARD KEYBOARD ',$00
END;
{---[cpuspeedmode]----------------------------------------------------------}
PROCEDURE CPUSPEEDMODE; ASSEMBLER;
ASM;
END;
{---[asmlayout]-------------------------------------------------------------}
PROCEDURE ASMLAYOUT; ASSEMBLER;
ASM;
END;
{---[soundoutput]-----------------------------------------------------------}
PROCEDURE SOUNDOUTPUT; ASSEMBLER;
ASM;
END;
{---[boxswitch (byte)]------------------------------------------------------}
PROCEDURE BOXSWITCH; ASSEMBLER; {use boxswitching; 00h=no; 01h=yes}
ASM;
END;
{---[box0onbreak (byte)]----------------------------------------------------}
PROCEDURE BOX0ONBREAK; ASSEMBLER; {restore box 0 on break; 00h=no; 01h=yes}
ASM;
END;
{---[ignorezpFEh (byte)]----------------------------------------------------}
PROCEDURE IGNOREzpFEh; ASSEMBLER; {ignore check char not sent to printer}
ASM;
END;
{---[nmiresponse (byte)]----------------------------------------------------}
PROCEDURE NMIRESPONSE; ASSEMBLER;
ASM;
END;
{---[leendertsrom (byte): use 80x87 or not]---------------------------------}
PROCEDURE LEENDERTSROM; ASSEMBLER;
ASM;
END;
{---[abloksprong (word): offset for JMP A002h in D-block]-------------------}
PROCEDURE ABLOKSPRONG; ASSEMBLER;
ASM;
DB $00
END;
{---[fppc_addr (dword)]-----------------------------------------------------}
PROCEDURE FPPC_ADDR; ASSEMBLER;
ASM;
DB 0,0,0
END;
{---[swapcpuspeed]----------------------------------------------------------}
PROCEDURE SWAPCPUSPEED; ASSEMBLER;
ASM;
PUSHA
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+8
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@SWAP1: CALL PRINTCHAR
LOOP @SWAP1
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
MOV SI,OFFSET @ORIGINALTXT
XOR BYTE PTR [CS:CPUSPEEDMODE],$01
JZ @SWAP3
MOV SI,OFFSET @MAXIMUMTXT
@SWAP3: MOV BL,$0C
@SWAP5: MOV AL,BYTE PTR [CS:SI]
INC SI
AND AL,$3F
JZ @SWAP4
CALL PRINTCHAR
JMP @SWAP5
@SWAP4: MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@SWAP2: CALL PRINTCHAR
LOOP @SWAP2
MOV AL,01101000b
CALL PRINTCHAR
POPA
RETN
@MAXIMUMTXT: DB ' MAXIMUM CPU SPEED ',$00
@ORIGINALTXT: DB ' ORIGINAL CPU SPEED ',$00
END;
{---[hex (byte)]------------------------------------------------------------}
FUNCTION HEX (B:BYTE):STR2;
BEGIN
HEX := HEXSTR[B SHR 4] + HEXSTR[B AND $0F];
END;
{---[hexw (word)]-----------------------------------------------------------}
FUNCTION HEXW (W:WORD):STR4;
BEGIN
HEXW := HEXSTR[HI(W) SHR 4] + HEXSTR[HI(W) AND $0F] +
HEXSTR[LO(W) SHR 4] + HEXSTR[LO(W) AND $0F];
END;
{---[readinifile]-----------------------------------------------------------}
PROCEDURE READINIFILE;
LABEL 1;
CONST INI_BYTE : ARRAY[1..8] OF STRING[11] =
('ASMLAYOUT','SOUND','SPEEDINDEX','BOXSWITCH',
'BOX0ONBREAK','IGNOREZPFEH','NMIRESPONSE','USE80X87');
INI_STR : ARRAY[1..9] OF STRING[10] =
('EXTROMFILE','BACKGR','FOREGR','GREYSB',
'COLOR0','COLOR1','COLOR2','COLOR3','DRIVE');
PCHARMESTR = 'P-CHARME'+#0+#0+#0+#0+#0+#0+#0+#0;
VAR F:TEXT;
S:STRING;
R,G,I:BYTE;
B:WORD;
CODE:INTEGER;
FROMF:FILE;
NR:WORD;
DUMMY:INTEGER;
P,Q:POINTER;
ATMHEADER:ATMFILEREC;
BEGIN
WRITE ('Seaching for INI-file.');
ASM;
MOV BYTE PTR [CS:ASMLAYOUT],$00
MOV BYTE PTR [CS:SOUNDOUTPUT],$01
MOV WORD PTR [CS:WACHTCONST],$0000
MOV BYTE PTR [CS:BOXSWITCH],$01
MOV BYTE PTR [CS:BOX0ONBREAK],$01
MOV BYTE PTR [CS:IGNOREzpFEh],$01
MOV BYTE PTR [CS:NMIRESPONSE],+15
MOV BYTE PTR [CS:LEENDERTSROM],$00
MOV WORD PTR [CS:ABLOKSPRONG],$D4BE
END;
EXTROMFILE := 'EXTROM.TAP';
DUMMY := IORESULT;
ASSIGN (F,'ATOM.INI');
RESET (F);
IF IORESULT <> 0 THEN
BEGIN
WRITELN (' Not found.');
GOTO 1;
END ELSE
BEGIN
WRITELN (' Reading.');
END;
WHILE NOT EOF(F) DO
BEGIN
READLN (F,S);
FOR I := 1 TO LENGTH(S) DO S[I] := UPCASE(S[I]);
FOR I := 1 TO 8 DO
BEGIN
IF COPY(S,1,LENGTH(INI_BYTE[I]))=INI_BYTE[I] THEN
BEGIN
DELETE (S,1,SUCC(LENGTH(INI_BYTE[I])));
VAL (S,B,CODE);
IF CODE = 0 THEN
BEGIN
CASE I OF 1: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R1
MOV AL,$01
@R1: MOV BYTE PTR [CS:ASMLAYOUT],AL
END;
2: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R2
MOV AL,$01
@R2: MOV BYTE PTR [CS:SOUNDOUTPUT],AL
END;
3: ASM;
MOV AX,WORD PTR B
MOV WORD PTR [CS:WACHTCONST],AX
END;
4: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R4
MOV AL,$01
@R4: MOV BYTE PTR [CS:BOXSWITCH],AL
END;
5: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R5
MOV AL,$01
@R5: MOV BYTE PTR [CS:BOX0ONBREAK],AL
END;
6: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R6
MOV AL,$01
MOV ES,WORD PTR ATOMMEMSEG
MOV BYTE PTR [ES:$FF07],$00
@R6: MOV BYTE PTR [CS:IGNOREzpFEh],AL
END;
7: ASM;
MOV AX,WORD PTR B
CMP AL,+15
JAE @R7
MOV AL,+15
@R7: MOV BYTE PTR [CS:NMIRESPONSE],AL
END;
8: ASM;
MOV AX,WORD PTR B
OR AX,AX
JZ @R8
MOV AL,$01
@R8: MOV BYTE PTR [CS:LEENDERTSROM],AL
END;
END;
END;
END;
END;
FOR I := 1 TO 9 DO
BEGIN
IF COPY(S,1,LENGTH(INI_STR[I]))=INI_STR[I] THEN
BEGIN
DELETE (S,1,LENGTH(INI_STR[I]));
IF I=1 THEN
BEGIN
DELETE (S,1,1);
IF LENGTH(S) > 0 THEN EXTROMFILE := S;
END ELSE
IF I=9 THEN
BEGIN
G := ORD(S[1]);
DEC (G,48);
IF G <= 3 THEN
BEGIN
DELETE (S,1,2);
IF COPY (S,LENGTH(S)-3,4)='.DSK' THEN DEC (S[0],4);
IF (S <> '') AND (AANTALDISKIMAGES > 0) THEN
BEGIN
B := 0;
WHILE (DISKETTENAMES[G] = '') AND (B < AANTALDISKIMAGES) DO
BEGIN
IF S=DISKIMAGES[B] THEN DISKETTENAMES[G] := S;
INC (B);
END;
END;
END;
END ELSE
BEGIN
DELETE (S,1,1);
IF LENGTH(S)=6 THEN
BEGIN
FOR B := 1 TO LENGTH(S) DO
BEGIN
S[B] := CHR(ORD(S[B])-48);
IF ORD(S[B]) > 9 THEN S[B] := CHR(ORD(S[B])-7);
END;
R := (ORD(S[1]) SHL 4) + ORD(S[2]);
G := (ORD(S[3]) SHL 4) + ORD(S[4]);
B := (ORD(S[5]) SHL 4) + ORD(S[6]);
ASM;
MOV AL,BYTE PTR I
SUB AL,$02
MOV AH,$00
MOV BX,AX
SHL AX,1
ADD BX,AX
MOV AL,BYTE PTR R
AND AL,$3F
MOV BYTE PTR EMULCOLORS[CS:BX],AL
MOV AL,BYTE PTR G
AND AL,$3F
MOV BYTE PTR EMULCOLORS[CS:BX+$01],AL
MOV AL,BYTE PTR B
AND AL,$3F
MOV BYTE PTR EMULCOLORS[CS:BX+$02],AL
END;
END;
END;
END;
END;
END;
CLOSE (F);
FOR I := 3 DOWNTO 1 DO
FOR G := I-1 DOWNTO 0 DO
IF DISKETTENAMES[I] = DISKETTENAMES[G] THEN DISKETTENAMES[I] := '';
1:ASM;
PUSH DS
POP ES
MOV DI,OFFSET BOXNAMES
MOV AL,$00
MOV CX,+16*16
CLD
REPZ
STOSB
END;
IF MEM[CSEG:OFS(LEENDERTSROM)] <> $00 THEN
BEGIN
ASM;
CLD
MOV ES,WORD PTR ATOMMEMSEG
MOV SI,OFFSET LEENDERTS_FPROM_DAT
MOV DI,$D000
MOV CX,LEENDERTS_FPROM_SIZE
REPZ
MOVSB
END;
GETMEM (P,SIZEOF(FPPC_DAT)+$0010);
B := SEG(P^);
IF OFS(P^) <> $0000 THEN INC (B);
MOVE (FPPC_DAT,MEM[B:$0000],SIZEOF(FPPC_DAT));
ASM;
MOV WORD PTR FPPC_ADDR[CS:$00],$0000
MOV AX,WORD PTR B
MOV WORD PTR FPPC_ADDR[CS:$02],AX
END;
END;
DUMMY := IORESULT;
ASSIGN (FROMF,EXTROMFILE);
RESET (FROMF,1);
IF IORESULT = 0 THEN
BEGIN
B := 0;
WHILE (B < 16) AND (NOT EOF(FROMF)) DO
BEGIN
BLOCKREAD (FROMF,ATMHEADER,SIZEOF(ATMHEADER),NR);
IF (IORESULT = 0) AND (NR=$16) THEN
BEGIN
IF (ATMHEADER.STARTADRS = $A000) AND (ATMHEADER.DATASIZE = $1000) THEN
BEGIN
MOVE (ATMHEADER.ATMNAME,BOXNAMES[B],$10);
P := PTR (ATOMMEMSEG+$1000,B*$1000);
BLOCKREAD (FROMF,P^,$1000,NR);
IF (MEM[CSEG:OFS(LEENDERTSROM)] <> 0) AND (BOXNAMES[B] = PCHARMESTR) THEN
BEGIN
ASM;
{---initialize the P-Charme for Leendert's FP-ROM---}
PUSH DS
MOV AX,WORD PTR ATOMMEMSEG
MOV DS,AX
MOV BH,BYTE PTR B
MOV BL,$00
ADD AX,BX
ADD AX,$1000-$0A00
MOV ES,AX {segment of p-charme, when offset = A000h}
MOV SI,$DEF0
MOV AX,WORD PTR [SI]
MOV WORD PTR [CS:ABLOKSPRONG],AX
MOV AX,WORD PTR [SI+$02]
MOV WORD PTR [ES:$A591+1],AX
MOV WORD PTR [ES:$A66E+1],AX
SUB AX,$000A
MOV WORD PTR [ES:$A79A+1],AX
SUB AX,$003C-$000A
MOV WORD PTR [ES:$A9D4+1],AX
SUB AX,$0015-$003C
MOV WORD PTR [ES:$AB07+1],AX
MOV WORD PTR [ES:$AB25+1],AX
MOV AX,WORD PTR [SI+$04]
MOV WORD PTR [ES:$A598+1],AX
MOV WORD PTR [ES:$AB1F+1],AX
SUB AX,$0007
MOV WORD PTR [ES:$A9C8+1],AX
MOV AX,WORD PTR [SI+$06]
MOV WORD PTR [ES:$A952+1],AX
MOV AX,WORD PTR [SI+$08]
MOV WORD PTR [ES:$AB04+1],AX
ADD AX,$0061
MOV WORD PTR [ES:$AB19+1],AX
MOV AX,WORD PTR [SI+$0A]
MOV WORD PTR [ES:$AB22+1],AX
MOV AX,WORD PTR [SI+$0C]
MOV WORD PTR [ES:$AD86+1],AX
MOV AX,WORD PTR [SI+$0E]
MOV WORD PTR [ES:$AF09+1],AX
MOV AX,WORD PTR [SI+$10]
MOV WORD PTR [ES:$AF10+1],AX
POP DS
END;
END;
INC (B);
END ELSE
BEGIN
SEEK (FROMF,FILEPOS(FROMF)+LONGINT(ATMHEADER.DATASIZE));
NR := $1000;
END;
END ELSE
BEGIN
NR := 0;
END;
IF NR <> $1000 THEN
BEGIN
WRITELN ('Error while loading extension ROMs.');
CLOSE (FROMF);
HALT (1);
END;
END;
CLOSE (FROMF);
{---load EPROM box 0 into Atom memory---}
P := PTR (ATOMMEMSEG+$1000,$0000);
Q := PTR (ATOMMEMSEG,$A000);
MOVE (P^,Q^,$1000);
END ELSE
BEGIN
WRITELN ('No extension ROMs loaded.');
{---only AXR1 available---}
P := PTR (ATOMMEMSEG,$A000);
Q := PTR (ATOMMEMSEG+$1000,$0000);
MOVE (P^,Q^,$1000);
BOXNAMES[0,0] := 'A';
BOXNAMES[0,1] := 'X';
BOXNAMES[0,2] := 'R';
BOXNAMES[0,3] := '1';
END;
END;
{---[writeinifile]----------------------------------------------------------}
PROCEDURE WRITEINIFILE;
VAR F:TEXT;
B:BYTE;
W:WORD;
S:STRING[6];
DUMMY:INTEGER;
BEGIN
DUMMY := IORESULT;
ASSIGN (F,'ATOM.INI');
REWRITE (F);
IF IORESULT <> 0 THEN EXIT;
WRITELN (F,'[Config]');
B := MEM[CSEG:OFS(ASMLAYOUT)];
IF B > 0 THEN B := 1;
WRITELN (F,'ASMLayout=',B);
B := MEM[CSEG:OFS(SOUNDOUTPUT)];
IF B > 0 THEN B := 1;
WRITELN (F,'Sound=',B);
W := MEMW[CSEG:OFS(WACHTCONST)];
WRITE (F,'SpeedIndex=');
IF W > 0 THEN WRITELN (F,W)
ELSE WRITELN (F);
WRITELN (F,'ExtROMFile=',EXTROMFILE);
B := MEM[CSEG:OFS(LEENDERTSROM)];
IF B > 0 THEN B := 1;
WRITELN (F,'Use80x87=',B);
WRITELN (F);
WRITELN (F,'[Emulation]');
B := MEM[CSEG:OFS(IGNOREzpFEh)];
IF B > 0 THEN B := 1;
WRITELN (F,'IgnoreZpFEh=',B);
B := MEM[CSEG:OFS(BOXSWITCH)];
IF B > 0 THEN B := 1;
WRITELN (F,'BoxSwitch=',B);
B := MEM[CSEG:OFS(BOX0ONBREAK)];
IF B > 0 THEN B := 1;
WRITELN (F,'Box0onBreak=',B);
B := MEM[CSEG:OFS(NMIRESPONSE)];
IF B < 15 THEN B := 15;
WRITELN (F,'NMIResponse=',B);
WRITELN (F);
WRITELN (F,'[Colors]');
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+0*3+B]);
WRITELN (F,'BackGr=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+1*3+B]);
WRITELN (F,'ForeGr=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+2*3+B]);
WRITELN (F,'GreySb=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+3*3+B]);
WRITELN (F,'Color0=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+4*3+B]);
WRITELN (F,'Color1=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+5*3+B]);
WRITELN (F,'Color2=',S);
S := '';
FOR B := 0 TO 2 DO
S := S + HEX(MEM[CSEG:OFS(EMULCOLORS)+6*3+B]);
WRITELN (F,'Color3=',S);
WRITELN (F);
WRITELN (F,'[Disk]');
FOR B := 0 TO 3 DO
BEGIN
WRITE (F,'Drive',B,'=');
IF DISKETTENAMES[B] <> '' THEN WRITE (F,DISKETTENAMES[B],'.DSK');
WRITELN (F);
END;
CLOSE (F);
END;
{---[outbyte (output byte to dsp)]------------------------------------------}
PROCEDURE OUTBYTE; ASSEMBLER;
ASM;
MOV AH,AL
@OUTB1: IN AL,DX
OR AL,AL
JS @OUTB1
MOV AL,AH
OUT DX,AL
END;
{---[sbsound]---------------------------------------------------------------}
PROCEDURE SBSOUND; ASSEMBLER;
ASM;
PUSH DS
PUSH DX
MOV AX,SEG IOPORT
MOV DS,AX
MOV DX,WORD PTR IOPORT
ADD DL,$0C
MOV AL,$10
CALL OUTBYTE
MOV AL,BYTE PTR @SOUNDBYTE
CALL OUTBYTE
XOR BYTE PTR @SOUNDBYTE,11000000b
POP DX
POP DS
RETN
@SOUNDBYTE: DB 01100000b
END;
{---[errorsnd]--------------------------------------------------------------}
PROCEDURE ERRORSND; ASSEMBLER;
ASM;
PUSH DS
PUSH DX
MOV DX,WORD PTR IOPORT
ADD DL,$0C
MOV DS,WORD PTR ATOMMEMSEG
MOV CX,$0800
@ERRORSND3: PUSH CX
@ERRORSND2: MOV AX,WORD PTR PCWAITTABLE[CS:$0002]
@ERRORSND1: DEC AX
JNZ @ERRORSND1
LOOP @ERRORSND2
CMP DX,+$0C
JNZ @ERRORSND4
IN AL,$61
XOR AL,$02
OUT $61,AL
JMP @ERRORSND5
@ERRORSND4: CALL SBSOUND
@ERRORSND5: POP CX
SUB CX,+$10
CMP CX,$0020
JAE @ERRORSND3
POP DX
POP DS
END;
{---[fouterrorsnd]----------------------------------------------------------}
PROCEDURE FOUTERRORSND; ASSEMBLER;
ASM;
PUSH DS
PUSH BX
PUSH DX
MOV BL,$03
@ERRORSND6: MOV DX,WORD PTR IOPORT
ADD DL,$0C
MOV DS,WORD PTR ATOMMEMSEG
MOV CX,$0040
@ERRORSND3: PUSH CX
@ERRORSND2: MOV AX,WORD PTR PCWAITTABLE[CS:$0002]
@ERRORSND1: DEC AX
JNZ @ERRORSND1
LOOP @ERRORSND2
CMP DX,+$0C
JNZ @ERRORSND4
IN AL,$61
XOR AL,$02
OUT $61,AL
JMP @ERRORSND5
@ERRORSND4: CALL SBSOUND
@ERRORSND5: POP CX
ADD CX,+$20
CMP CX,$0700
JB @ERRORSND3
DEC BL
JNZ @ERRORSND6
POP DX
POP BX
POP DS
END;
{---[makewider; AL=byte; return: AX=word]-----------------------------------}
PROCEDURE MAKEWIDER; ASSEMBLER;
ASM;
PUSH BX
MOV BL,AL
SUB AX,AX
MOV BH,$08
@MAKEW1: SHL BL,1
JNC @MAKEW2
RCL AX,1
STC
RCL AX,1
JMP @MAKEW3
@MAKEW2: SHL AX,2
@MAKEW3: DEC BH
JNZ @MAKEW1
POP BX
END;
{---[initialize]------------------------------------------------------------}
PROCEDURE INITIALIZE;
CONST EMUDETECT : ARRAY[0..64] OF CHAR =
'ACORN ATOM EMULATOR V1.33 (C) BYWOUTER RAS, DELFT, OCT''97-MAY''99'+#$0D;
VAR I:WORD;
BEGIN
{---reset dsp---}
ASM;
MOV WORD PTR IOPORT,$0210
@RESDSP7: MOV DX,WORD PTR IOPORT
ADD DL,$06
MOV AL,$01
OUT DX,AL
MOV CX,$0400
@RESDSP1: LOOP @RESDSP1
MOV AL,$00
OUT DX,AL
MOV BL,$10
@RESDSP3: MOV DX,WORD PTR IOPORT
ADD DL,$0E
MOV CX,$0100
@RESDSP2: IN AL,DX
TEST AL,$80
JNZ @RESDSP4
LOOP @RESDSP2
JMP @RESDSP5
@RESDSP4: SUB DL,$04
IN AL,DX
CMP AL,$AA
JZ @RESDSP6
DEC BL
JNZ @RESDSP3
@RESDSP5: ADD WORD PTR IOPORT,+$10
CMP WORD PTR IOPORT,$0270
JBE @RESDSP7
MOV WORD PTR IOPORT,$0000
@RESDSP6:
END;
IF IOPORT <> 0 THEN
BEGIN
WRITELN ('SoundBlaster found at port ',HEXW(IOPORT),'h.');
END ELSE
BEGIN
WRITELN ('No SoundBlaster detected. Sound output set to PC-speaker.');
END;
WRITELN ('Allocating Atom memory.');
GETMEM (ATOMMEM1,$FFF8);
GETMEM (ATOMMEM2,$FFF8);
GETMEM (ATOMMEM3,$0200);
ATOMMEMSEG := SEG(ATOMMEM1^);
IF OFS(ATOMMEM1^) <> $0000 THEN INC (ATOMMEMSEG);
GETMEM (FINBUF,SIZEOF(FINBUFTYPE));
FINBUFOFS := OFS(FINBUF^);
FINBUFSEG := SEG(FINBUF^);
FINSIZE := 0;
FOUTOPEN := 0;
GETMEM (FOUTBUF,SIZEOF(FOUTBUFTYPE));
FOUTBUFOFS := OFS(FOUTBUF^);
FOUTBUFSEG := SEG(FOUTBUF^);
ASM;
CLD
MOV WORD PTR [CS:DATASEG],DS
{---clear extROMmem---}
SUB AX,AX
SUB DI,DI
MOV BX,WORD PTR ATOMMEMSEG
ADD BX,$1000
MOV ES,BX
MOV CX,$8000
REPZ
STOSW
MOV BX,ES
ADD BX,$1000
MOV ES,BX
MOV CX,$0140/2
REPZ
STOSW
{---clear atom memory---}
SUB DI,DI
MOV ES,WORD PTR ATOMMEMSEG
MOV CX,$8000
REPZ
STOSW
{---store EMU detection---}
MOV SI,OFFSET EMUDETECT
MOV DI,$BF80
MOV CX,+65
REPZ
MOVSB
{---store atom rom memory---}
MOV SI,OFFSET ATOMROMMEM
MOV DI,$A000
MOV CX,$0800
REPZ
MOVSW
MOV DI,$C000
MOV CX,$2000
REPZ
MOVSW
{---store random seed---}
PUSHF
PUSHA
MOV AH,$2C
INT $21
XOR CL,CH
ROL CL,4
ADD DH,CL
MOV WORD PTR [ES:$0008],DX
MOV AX,DX
AND CX,$00FF
MUL CX
MOV WORD PTR [ES:$000A],AX
MOV BYTE PTR [ES:$000C],DL
POPA
POPF
{---make graphtables---}
SUB DI,DI
MOV BL,$00
@INIT2: MOV AL,BL
CALL MAKEWIDER
MOV BYTE PTR MONOGRAPHTABLE[DI ],AH
MOV BYTE PTR MONOGRAPHTABLE[DI+$01],$00
MOV WORD PTR MONOGRAPHTABLE[DI+$02],$0000
MOV BYTE PTR MONOGRAPHTABLE[DI+$04],AL
MOV BYTE PTR MONOGRAPHTABLE[DI+$05],$00
MOV WORD PTR MONOGRAPHTABLE[DI+$06],$0000
MOV BYTE PTR GREYGRAPHTABLE[DI ],$00
MOV BYTE PTR GREYGRAPHTABLE[DI+$01],AH
MOV WORD PTR GREYGRAPHTABLE[DI+$02],$0000
MOV BYTE PTR GREYGRAPHTABLE[DI+$04],$00
MOV BYTE PTR GREYGRAPHTABLE[DI+$05],AL
MOV WORD PTR GREYGRAPHTABLE[DI+$06],$0000
ADD DI,+$08
INC BL
JNZ @INIT2
SUB DI,DI
MOV BL,$00
@INIT3: MOV WORD PTR COLORGRAPHTABLE[DI ],+$00
MOV WORD PTR COLORGRAPHTABLE[DI+$02],+$00
MOV WORD PTR COLORGRAPHTABLE[DI+$04],+$00
MOV WORD PTR COLORGRAPHTABLE[DI+$06],+$00
MOV AL,BL
MOV CX,$0004
@INIT8: MOV AH,$00
SHL AX,2
CMP AH,$00
JNZ @INIT4
OR BYTE PTR COLORGRAPHTABLE[DI+$04],$0F
OR BYTE PTR COLORGRAPHTABLE[DI+$05],$0F
JMP @INIT7
@INIT4: CMP AH,$01
JNZ @INIT5
OR BYTE PTR COLORGRAPHTABLE[DI+$06],$0F
JMP @INIT7
@INIT5: CMP AH,$02
JNZ @INIT6
OR BYTE PTR COLORGRAPHTABLE[DI+$04],$0F
OR BYTE PTR COLORGRAPHTABLE[DI+$06],$0F
JMP @INIT7
@INIT6: OR BYTE PTR COLORGRAPHTABLE[DI+$05],$0F
OR BYTE PTR COLORGRAPHTABLE[DI+$06],$0F
@INIT7: CMP CX,+$01
JZ @INIT10
PUSH CX
MOV CX,$0004
@INIT9: SHL BYTE PTR COLORGRAPHTABLE[DI+$04],1
RCL BYTE PTR COLORGRAPHTABLE[DI ],1
SHL BYTE PTR COLORGRAPHTABLE[DI+$05],1
RCL BYTE PTR COLORGRAPHTABLE[DI+$01],1
SHL BYTE PTR COLORGRAPHTABLE[DI+$06],1
RCL BYTE PTR COLORGRAPHTABLE[DI+$02],1
SHL BYTE PTR COLORGRAPHTABLE[DI+$07],1
RCL BYTE PTR COLORGRAPHTABLE[DI+$03],1
LOOP @INIT9
POP CX
LOOP @INIT8
@INIT10: ADD DI,+$08
INC BL
JNZ @INIT3
END;
FOUTNAME := '';
END;
{---[timer (for determining the CPU speed)]---------------------------------}
PROCEDURE TIMER;
LABEL 1;
VAR P:POINTER;
POFS,PSEG:WORD;
T:LONGINT;
W:WORD;
I:BYTE;
BEGIN
IF MEMW[CSEG:OFS(WACHTCONST)] <> 0 THEN
BEGIN
W := MEMW[CSEG:OFS(WACHTCONST)];
GOTO 1;
END;
WRITE ('Determining CPU-speed. ');
GETMEM (P,$FFF8);
POFS := OFS(P^);
PSEG := SEG(P^);
T := 0;
FOR I := 1 TO 20 DO
BEGIN
ASM;
MOV DI,WORD PTR POFS
MOV WORD PTR @SUBR[$00],DI
MOV ES,WORD PTR PSEG
MOV WORD PTR @SUBR[$02],ES
CLD
MOV AX,$F8F8
MOV CX,$FFF0/2
REPZ
STOSW
MOV AL,$CB
STOSB
NOP
IN AL,$61
PUSH AX
CLI
AND AL,$FE
OUT $61,AL
MOV AL,$B2
OUT $43,AL
MOV AL,$00
OUT $42,AL
OUT $42,AL
IN AL,$61
OR AL,$01
AND AL,$FD
OUT $61,AL
MOV CX,$0003
@TIMER2: NOP
DB $2E,$FF,$1E
DW OFFSET @SUBR
NOP
LOOP @TIMER2
IN AL,$61
AND AL,$FE
OUT $61,AL
MOV AL,$B0
OUT $43,AL
IN AL,$42
MOV AH,AL
IN AL,$42
XCHG AL,AH
NEG AX
MOV WORD PTR W,AX
POP AX
OUT $61,AL
STI
JMP @TIMER1
@SUBR: DD $00000000
@TIMER1:
END;
INC (T,LONGINT(W));
END;
FREEMEM (P,$FFF8);
T := T DIV 20; {P120: 3839}
W := 460680 DIV T;
1:ASM;
MOV AX,WORD PTR W
MOV BX,AX
@TIMER5: SUB BX,+33
JC @TIMER4
INC AX
JMP @TIMER5
@TIMER4: MOV WORD PTR PCWAITTABLE[CS:$0002],AX
MOV DI,$0004
MOV CX,$0002
@TIMER3: MOV AX,WORD PTR PCWAITTABLE[CS:$0002]
MUL CX
MOV WORD PTR PCWAITTABLE[CS:DI],AX
ADD DI,+$02
INC CX
CMP CX,+$08
JBE @TIMER3
END;
WRITELN ('SpeedIndex set to ',MEMW[CSEG:OFS(PCWAITTABLE)+2],'.');
END;
{---[graphmode]-------------------------------------------------------------}
PROCEDURE GRAPHMODE; ASSEMBLER;
ASM;
DB $00 {00=0;01=1;02=2;03=3;04=4;05=1a;06=2a;07=3a;08=4a}
END;
{---[programcnt (word)]-----------------------------------------------------}
PROCEDURE PROGRAMCNT; ASSEMBLER;
ASM;
DB $00
END;
{---[stackpointer (word)]---------------------------------------------------}
PROCEDURE STACKPOINTER; ASSEMBLER;
ASM;
DB $00
END;
{---[accu_b (byte)]---------------------------------------------------------}
PROCEDURE ACCU_B; ASSEMBLER;
ASM;
END;
{---[accumulator (byte)]----------------------------------------------------}
PROCEDURE ACCUMULATOR; ASSEMBLER;
ASM;
END;
{---[flagregister (byte)]---------------------------------------------------}
PROCEDURE FLAGREGISTER; ASSEMBLER;
ASM;
END;
{---[xregister (byte)]------------------------------------------------------}
PROCEDURE XREGISTER; ASSEMBLER;
ASM;
END;
{---[yregister (byte)]------------------------------------------------------}
PROCEDURE YREGISTER; ASSEMBLER;
ASM;
END;
{---[t2l_l (VIA timer 2 low latch register)]--------------------------------}
PROCEDURE T2L_L; ASSEMBLER;
ASM;
END;
{---[mousenr]---------------------------------------------------------------}
PROCEDURE MOUSENR; ASSEMBLER;
ASM;
END;
{---[mousebackgrpos (word)]-------------------------------------------------}
PROCEDURE MOUSEBACKGRPOS; ASSEMBLER;
ASM;
DB $00
END;
{---[irqdelay (VIA interrupt delay count)]----------------------------------}
PROCEDURE IRQDELAY; ASSEMBLER;
ASM;
END;
{---[nmidelay]--------------------------------------------------------------}
PROCEDURE NMIDELAY; ASSEMBLER;
ASM;
END;
{---[graphtop (depending on graphics mode)]---------------------------------}
PROCEDURE GRAPHTOP; ASSEMBLER;
ASM;
DW $8200
DW $8400
DW $8600
DW $8C00
DW $9800
DW $8400
DW $8800
DW $8C00
DW $9800
END;
{---[brkpnton (bit 7 reserved for TRACE/STEP/HERE)]-------------------------}
PROCEDURE BRKPNTON; ASSEMBLER;
ASM;
DB $00
END;
{---[brkpnts]---------------------------------------------------------------}
PROCEDURE BRKPNTS; ASSEMBLER;
ASM;
DW $0000
DW $0000
DW $0000
DW $0000
END;
{---[aantboxret (byte)]-----------------------------------------------------}
PROCEDURE AANTBOXRET; ASSEMBLER; {---max.20h---}
ASM;
DB $00
END;
{---[boxreturns]------------------------------------------------------------}
PROCEDURE BOXRETURNS; ASSEMBLER;
ASM;
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
DW $0000,$0000,$0000,$0000
END;
{---[boxinfo]---------------------------------------------------------------}
PROCEDURE BOXINFO; ASSEMBLER;
ASM;
PUSH DS
PUSHA
MOV BH,BYTE PTR [SCHAKELBYTE]
AND BH,$0F
MOV DS,WORD PTR [CS:DATASEG]
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+1
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+21
MOV AL,01001100b
@BOXINF1: CALL PRINTCHAR
LOOP @BOXINF1
MOV AL,01001010b
CALL PRINTCHAR
MOV DL,$00
@BOXINF2: MOV BYTE PTR [CS:CURSORX],+9
MOV AL,DL
ADD AL,$02
MOV BYTE PTR [CS:CURSORY],AL
MOV AL,01010101b
CALL PRINTCHAR
MOV CX,+21
MOV AL,' '
@BOXINF3: CALL PRINTCHAR
LOOP @BOXINF3
MOV AL,01101010b
CALL PRINTCHAR
INC DL
CMP DL,$10
JB @BOXINF2
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+18
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+21
MOV AL,01001100b
@BOXINF8: CALL PRINTCHAR
LOOP @BOXINF8
MOV AL,01101000b
CALL PRINTCHAR
MOV DL,$00
@BOXINF4: MOV BL,$0E
CMP BH,DL
JNZ @BOXINF7
MOV BL,$0F
@BOXINF7: MOV BYTE PTR [CS:CURSORX],+11
MOV AL,DL
ADD AL,$02
MOV BYTE PTR [CS:CURSORY],AL
MOV AL,DL
ADD AL,'0'
CMP AL,'9'
JBE @BOXINF9
ADD AL,$07
AND AL,$3F
@BOXINF9: CALL PRINTCHAR
MOV AL,':'
CALL PRINTCHAR
INC BYTE PTR [CS:CURSORX]
MOV SI,DX
AND SI,$000F
SHL SI,4
ADD SI,OFFSET BOXNAMES
MOV CX,$0010
@BOXINF5: LODSB
AND AL,$3F
JZ @BOXINF6
CALL PRINTCHAR
LOOP @BOXINF5
@BOXINF6: INC DL
CMP DL,$10
JB @BOXINF4
POPA
POP DS
END;
{---[atomseg (word)]--------------------------------------------------------}
PROCEDURE ATOMSEG; ASSEMBLER;
ASM;
DB $00
END;
{---[tapescreen (byte)]-----------------------------------------------------}
PROCEDURE TAPESCREEN; ASSEMBLER;
ASM;
DB $00
END;
{---[putbyte_part2]---------------------------------------------------------}
PROCEDURE PUTBYTE_PART2; ASSEMBLER;
ASM;
TEST BYTE PTR [CS:MOUSENR],$80
JNZ @PUTBYTE1
MOV AX,DI
SUB AX,WORD PTR [CS:MOUSEBACKGRPOS]
JC @PUTBYTE1
CMP AX,$07F0
JAE @PUTBYTE1
MOV BX,AX
SHR AX,4
PUSH CX
MOV CL,$12
DIV CL
POP CX
OR AH,AH
JNZ @PUTBYTE1
{---under mousecursor---}
AND BX,$0008
SHL AX,4
ADD BX,AX
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR [SI]
MOV WORD PTR MOUSEBACKGROUND[BX],AX
OR AX,WORD PTR MOUSEPOINTER[BX]
MOV WORD PTR [ES:DI],AX
MOV AX,WORD PTR [SI+2]
MOV WORD PTR MOUSEBACKGROUND[BX+2],AX
OR AX,WORD PTR MOUSEPOINTER[BX+2]
MOV WORD PTR [ES:DI+2],AX
MOV AX,WORD PTR [SI+4]
MOV WORD PTR MOUSEBACKGROUND[BX+4],AX
OR AX,WORD PTR MOUSEPOINTER[BX+4]
MOV WORD PTR [ES:DI+4],AX
MOV AX,WORD PTR [SI+6]
MOV WORD PTR MOUSEBACKGROUND[BX+6],AX
OR AX,WORD PTR MOUSEPOINTER[BX+6]
MOV WORD PTR [ES:DI+6],AX
RETN
@PUTBYTE1: MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR [SI]
MOV WORD PTR [ES:DI],AX
MOV AX,WORD PTR [SI+2]
MOV WORD PTR [ES:DI+2],AX
MOV AX,WORD PTR [SI+4]
MOV WORD PTR [ES:DI+4],AX
MOV AX,WORD PTR [SI+6]
MOV WORD PTR [ES:DI+6],AX
END;
{---[putmode0byte; AL=byte; AH=00:white/01:grey; DI=screenpos]--------------}
PROCEDURE PUTMODE0BYTE; ASSEMBLER;
ASM;
@PUTMODE0BYTE: PUSH DS
PUSH SI
PUSH BX
PUSH DI
PUSH AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
OR AH,AH
JNZ @PUTMODE0_1
ADD SI,OFFSET MONOGRAPHTABLE
JMP @PUTMODE0_2
@PUTMODE0_1: ADD SI,OFFSET GREYGRAPHTABLE
@PUTMODE0_2: CALL PUTBYTE_PART2
POP AX
POP DI
POP BX
POP SI
POP DS
END;
{---[putmonobyte; AL=byte; DI=screenpos]------------------------------------}
PROCEDURE PUTMONOBYTE; ASSEMBLER;
ASM;
PUSH DS
PUSH SI
PUSH BX
PUSH DI
PUSH AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET MONOGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
POP BX
POP SI
POP DS
END;
{---[putmonoword; AX=word; DI=screenpos]------------------------------------}
PROCEDURE PUTMONOWORD; ASSEMBLER;
ASM;
PUSH DS
PUSH SI
PUSH BX
PUSH DI
PUSH AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET MONOGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
PUSH DI
PUSH AX
ADD DI,+$08
MOV AL,AH
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET MONOGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
POP BX
POP SI
POP DS
END;
{---[putcolorbyte; AL=byte; DI=screenpos]-----------------------------------}
PROCEDURE PUTCOLORBYTE; ASSEMBLER;
ASM;
PUSH DS
PUSH SI
PUSH BX
PUSH DI
PUSH AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET COLORGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
POP BX
POP SI
POP DS
END;
{---[putcolorword; AX=word; DI=screenpos]-----------------------------------}
PROCEDURE PUTCOLORWORD; ASSEMBLER;
ASM;
PUSH DS
PUSH SI
PUSH BX
PUSH DI
PUSH AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET COLORGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
PUSH DI
PUSH AX
ADD DI,+$08
MOV AL,AH
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET COLORGRAPHTABLE
CALL PUTBYTE_PART2
POP AX
POP DI
POP BX
POP SI
POP DS
END;
{---[updatem0]--------------------------------------------------------------}
PROCEDURE UPDATEM0; ASSEMBLER;
ASM;
PUSHF
ADD WORD PTR [PCCYCLES],+750
CLI
PUSH DS
PUSH SI
MOV AH,$00
MOV AL,BYTE PTR [DI]
CMP AL,$C0
JB @UPDM0_1
{---grey graphics symbols---}
AND AL,$7F
MOV AH,$01
@UPDM0_1: PUSH AX
PUSH AX
MOV AX,DI
PUSH AX
AND AX,$01E0
SHL AX,2
MOV DI,AX
SHL AX,1
ADD DI,AX
SHL AX,2
ADD DI,AX
SHL AX,1
ADD DI,AX
POP AX
AND AX,$001F
SHL AX,3
ADD AX,$0140
ADD DI,AX
POP AX
MOV AH,$00
SHL AX,4
ADD AX,OFFSET CHARDATA
MOV SI,AX
MOV DS,WORD PTR [CS:DATASEG]
POP AX
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
INC SI
CALL PUTMODE0BYTE
ADD DI,$0120
MOV AL,BYTE PTR [SI]
CALL PUTMODE0BYTE
POP SI
POP DS
POPF
END;
{---[updatem1]--------------------------------------------------------------}
PROCEDURE UPDATEM1; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+337
PUSH BX
MOV BL,BYTE PTR [DI]
PUSH DI
AND DI,$03F0
SHL DI,1
MOV AX,DI
SHL AX,1
ADD DI,AX
SHL AX,2
ADD DI,AX
SHL AX,1
ADD DI,AX
POP AX
AND AX,$000F
SHL AX,4
ADD AX,$0140
ADD DI,AX
MOV BH,$00
SHL BX,1
MOV AX,WORD PTR WIDERTABLE[CS:BX]
CALL PUTMONOWORD
ADD DI,$0120
CALL PUTMONOWORD
ADD DI,$0120
CALL PUTMONOWORD
POP BX
POPF
END;
{---[updatem1a]-------------------------------------------------------------}
PROCEDURE UPDATEM1a; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+310
PUSH BX
MOV BL,BYTE PTR [DI]
PUSH DI
AND DI,$03F0
SHL DI,1
MOV AX,DI
SHL AX,1
ADD DI,AX
SHL AX,2
ADD DI,AX
SHL AX,1
ADD DI,AX
POP AX
AND AX,$000F
SHL AX,4
ADD AX,$0140
ADD DI,AX
MOV BH,$00
SHL BX,1
MOV AX,WORD PTR WIDER1aTABLE[CS:BX]
CALL PUTCOLORWORD
ADD DI,$0120
CALL PUTCOLORWORD
ADD DI,$0120
CALL PUTCOLORWORD
POP BX
POPF
END;
{---[updatem2]--------------------------------------------------------------}
PROCEDURE UPDATEM2; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+254
PUSH BX
MOV BL,BYTE PTR [DI]
PUSH DI
AND DI,$0FF0
SHL DI,2
MOV AX,DI
SHL AX,3
ADD DI,AX
POP AX
AND AX,$000F
SHL AX,4
ADD AX,$0140
ADD DI,AX
MOV BH,$00
SHL BX,1
MOV AX,WORD PTR WIDERTABLE[CS:BX]
CALL PUTMONOWORD
ADD DI,$0120
CALL PUTMONOWORD
POP BX
POPF
END;
{---[updatem2a]-------------------------------------------------------------}
PROCEDURE UPDATEM2a; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+217
MOV AL,BYTE PTR [DI]
PUSH AX
PUSH DI
AND DI,$07E0
MOV AX,DI
SHL AX,1
ADD DI,AX
SHL AX,2
ADD DI,AX
SHL AX,1
ADD DI,AX
POP AX
AND AX,$001F
SHL AX,3
ADD AX,$0140
ADD DI,AX
POP AX
CALL PUTCOLORBYTE
ADD DI,$0120
CALL PUTCOLORBYTE
ADD DI,$0120
CALL PUTCOLORBYTE
POPF
END;
{---[updatem3]--------------------------------------------------------------}
PROCEDURE UPDATEM3; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+178
PUSH BX
MOV BL,BYTE PTR [DI]
PUSH DI
AND DI,$0FF0
SHL DI,1
MOV AX,DI
SHL AX,3
ADD DI,AX
POP AX
AND AX,$000F
SHL AX,4
ADD AX,$0140
ADD DI,AX
MOV BH,$00
SHL BX,1
MOV AX,WORD PTR WIDERTABLE[CS:BX]
CALL PUTMONOWORD
POP BX
POPF
END;
{---[updatem3a]-------------------------------------------------------------}
PROCEDURE UPDATEM3a; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+177
MOV AL,BYTE PTR [DI]
PUSH AX
PUSH DI
AND DI,$0FE0
SHL DI,1
MOV AX,DI
SHL AX,3
ADD DI,AX
POP AX
AND AX,$001F
SHL AX,3
ADD AX,$0140
ADD DI,AX
POP AX
CALL PUTCOLORBYTE
ADD DI,$0120
CALL PUTCOLORBYTE
POPF
END;
{---[updatem4]--------------------------------------------------------------}
PROCEDURE UPDATEM4; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+139
MOV AL,BYTE PTR [DI]
PUSH AX
PUSH DI
AND DI,$1FE0
MOV AX,DI
SHL AX,3
ADD DI,AX
POP AX
AND AX,$001F
SHL AX,3
ADD AX,$0140
ADD DI,AX
POP AX
CALL PUTMONOBYTE
POPF
END;
{---[updatem4a]-------------------------------------------------------------}
PROCEDURE UPDATEM4a; ASSEMBLER;
ASM;
PUSHF
CLI
ADD WORD PTR [PCCYCLES],+134
MOV AL,BYTE PTR [DI]
PUSH AX
PUSH DI
AND DI,$1FE0
MOV AX,DI
SHL AX,3
ADD DI,AX
POP AX
AND AX,$001F
SHL AX,3
ADD AX,$0140
ADD DI,AX
POP AX
CALL PUTCOLORBYTE
POPF
END;
{---[updatetable]-----------------------------------------------------------}
PROCEDURE UPDATETABLE; ASSEMBLER;
ASM;
DW OFFSET UPDATEM0
DW OFFSET UPDATEM1
DW OFFSET UPDATEM2
DW OFFSET UPDATEM3
DW OFFSET UPDATEM4
DW OFFSET UPDATEM1a
DW OFFSET UPDATEM2a
DW OFFSET UPDATEM3a
DW OFFSET UPDATEM4a
END;
{---[updategraph DI=dest.address]-------------------------------------------}
PROCEDURE UPDATEGRAPH; ASSEMBLER;
ASM;
PUSHF
CMP DI,$8000
JAE @UPDATEG1
ADD WORD PTR [PCCYCLES],+21
POPF
RETN
@UPDATEG1: PUSH BX
MOV BL,BYTE PTR [CS:GRAPHMODE]
MOV BH,$00
SHL BX,1
CMP DI,WORD PTR GRAPHTOP[CS:BX]
JB @UPDATEG2
POP BX
ADD WORD PTR [PCCYCLES],+40
POPF
RETN
@UPDATEG2: MOV AX,WORD PTR UPDATETABLE[CS:BX]
POP BX
POPF
JMP AX
END;
{---[setmousecursor (AL=waarde)]--------------------------------------------}
PROCEDURE SETMOUSECURSOR; ASSEMBLER;
ASM;
TEST BYTE PTR [CS:MOUSENR],$80
JNZ @SETMOUSE2
@SETMOUSE3: RETN
@SETMOUSE2: OR AL,AL
JS @SETMOUSE3
MOV BYTE PTR [CS:MOUSENR],AL
PUSH DS
PUSHA
MOV DS,WORD PTR [CS:ATOMSEG]
MOV AL,+255
SUB AL,BYTE PTR [$BFE1]
MOV AH,$00
SHL AX,5
MOV DI,AX
SHL AX,3
ADD DI,AX
MOV AL,BYTE PTR [$BFE0]
MOV CL,AL
AND CL,$07
AND AX,$00F8
ADD DI,AX
ADD DI,$0140
MOV AL,BYTE PTR [CS:MOUSENR]
AND AX,$001F
SHL AX,3
MOV SI,AX
SUB BX,BX
MOV DS,WORD PTR [CS:DATASEG]
MOV WORD PTR [CS:MOUSEBACKGRPOS],DI
@SETMOUSE1: MOV AH,BYTE PTR MOUSECURSORS[CS:SI]
MOV AL,$00
SHR AX,CL
XCHG AL,AH
PUSH SI
PUSH AX
MOV AX,WORD PTR [ES:DI]
MOV WORD PTR MOUSEBACKGROUND[BX],AX
MOV AX,WORD PTR [ES:DI+2]
MOV WORD PTR MOUSEBACKGROUND[BX+2],AX
MOV AX,WORD PTR [ES:DI+4]
MOV WORD PTR MOUSEBACKGROUND[BX+4],AX
MOV AX,WORD PTR [ES:DI+6]
MOV WORD PTR MOUSEBACKGROUND[BX+6],AX
MOV AX,WORD PTR [ES:DI+8]
MOV WORD PTR MOUSEBACKGROUND[BX+8],AX
MOV AX,WORD PTR [ES:DI+10]
MOV WORD PTR MOUSEBACKGROUND[BX+10],AX
MOV AX,WORD PTR [ES:DI+12]
MOV WORD PTR MOUSEBACKGROUND[BX+12],AX
MOV AX,WORD PTR [ES:DI+14]
MOV WORD PTR MOUSEBACKGROUND[BX+14],AX
POP AX
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET MONOGRAPHTABLE
PUSH AX
MOV AL,BYTE PTR [SI]
MOV AH,AL
MOV WORD PTR MOUSEPOINTER[BX],AX
OR WORD PTR [ES:DI],AX
MOV WORD PTR MOUSEPOINTER[BX+2],AX
OR WORD PTR [ES:DI+2],AX
MOV AL,BYTE PTR [SI+4]
MOV AH,AL
MOV WORD PTR MOUSEPOINTER[BX+4],AX
OR WORD PTR [ES:DI+4],AX
MOV WORD PTR MOUSEPOINTER[BX+6],AX
OR WORD PTR [ES:DI+6],AX
POP AX
XCHG AL,AH
MOV SI,AX
AND SI,$00FF
SHL SI,3
ADD SI,OFFSET MONOGRAPHTABLE
MOV AL,BYTE PTR [SI]
MOV AH,AL
MOV WORD PTR MOUSEPOINTER[BX+8],AX
OR WORD PTR [ES:DI+8],AX
MOV WORD PTR MOUSEPOINTER[BX+10],AX
OR WORD PTR [ES:DI+10],AX
MOV AL,BYTE PTR [SI+4]
MOV AH,AL
MOV WORD PTR MOUSEPOINTER[BX+12],AX
OR WORD PTR [ES:DI+12],AX
MOV WORD PTR MOUSEPOINTER[BX+14],AX
OR WORD PTR [ES:DI+14],AX
POP SI
ADD BX,+16
ADD DI,$0120
INC SI
TEST SI,$0007
JNZ @SETMOUSE1
POPA
POP DS
END;
{---[clrmousecursor]--------------------------------------------------------}
PROCEDURE CLRMOUSECURSOR; ASSEMBLER;
ASM;
TEST BYTE PTR [CS:MOUSENR],$80
JZ @CLRMOUSE2
RETN
@CLRMOUSE2: OR BYTE PTR [CS:MOUSENR],$80
PUSH DS
PUSHA
MOV DS,WORD PTR [CS:ATOMSEG]
MOV AL,+255
SUB AL,BYTE PTR [$BFE1]
MOV AH,$00
SHL AX,5
MOV DI,AX
SHL AX,3
ADD DI,AX
MOV AL,BYTE PTR [$BFE0]
AND AX,$00F8
ADD DI,AX
ADD DI,$0140
MOV DS,WORD PTR [CS:DATASEG]
MOV SI,OFFSET MOUSEBACKGROUND
MOV CX,$0008
@CLRMOUSE1: MOV AX,WORD PTR [SI]
MOV WORD PTR [ES:DI],AX
MOV AX,WORD PTR [SI+2]
MOV WORD PTR [ES:DI+2],AX
MOV AX,WORD PTR [SI+4]
MOV WORD PTR [ES:DI+4],AX
MOV AX,WORD PTR [SI+6]
MOV WORD PTR [ES:DI+6],AX
MOV AX,WORD PTR [SI+8]
MOV WORD PTR [ES:DI+8],AX
MOV AX,WORD PTR [SI+10]
MOV WORD PTR [ES:DI+10],AX
MOV AX,WORD PTR [SI+12]
MOV WORD PTR [ES:DI+12],AX
MOV AX,WORD PTR [SI+14]
MOV WORD PTR [ES:DI+14],AX
ADD SI,+16
ADD DI,$0120
LOOP @CLRMOUSE1
POPA
POP DS
END;
{---[disablemouse (called whenever desktop opened)]-------------------------}
PROCEDURE DISABLEMOUSE; ASSEMBLER;
ASM;
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:ATOMSEG]
MOV ES,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR [$BFE0]
MOV WORD PTR TEMPMOUSEDAT[ES:$00],AX
MOV AL,BYTE PTR [CS:MOUSENR]
MOV BYTE PTR TEMPMOUSEDAT[ES:$02],AL
MOV AX,$0003
INT $33
MOV WORD PTR TEMPMOUSEDAT[ES:$03],CX
MOV WORD PTR TEMPMOUSEDAT[ES:$05],DX
POPA
POP ES
POP DS
CALL CLRMOUSECURSOR
END;
{---[enablemouse (called when resuming emulation)]--------------------------}
PROCEDURE ENABLEMOUSE; ASSEMBLER;
ASM;
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
MOV ES,WORD PTR [CS:ATOMSEG]
MOV AX,WORD PTR TEMPMOUSEDAT[$00]
MOV WORD PTR [ES:$BFE0],AX
MOV AL,BYTE PTR TEMPMOUSEDAT[$02]
MOV BYTE PTR [CS:MOUSENR],AL
MOV AX,$0004
MOV CX,WORD PTR TEMPMOUSEDAT[$03]
MOV DX,WORD PTR TEMPMOUSEDAT[$05]
INT $33
MOV AX,$0003
INT $33
XOR BL,$07
MOV BYTE PTR [ES:$BFE2],BL
POPA
POP ES
POP DS
TEST BYTE PTR [CS:MOUSENR],$80
JNZ @ENABLE1
MOV AL,BYTE PTR [CS:MOUSENR]
OR BYTE PTR [CS:MOUSENR],$80
CALL SETMOUSECURSOR
@ENABLE1:
END;
{---[savezp90]--------------------------------------------------------------}
PROCEDURE SAVEZP90; ASSEMBLER;
ASM;
TEST BYTE PTR [CS:BOXSWITCH],$FF
JZ @SAVEZP1
PUSH ES
PUSH BX
PUSH SI
MOV AX,DS
ADD AX,$2000
MOV ES,AX
MOV AL,BYTE PTR [SCHAKELBYTE]
AND AX,$000F
SHL AX,4
MOV SI,AX
SUB BX,BX
@SAVEZP2: MOV AX,WORD PTR [BX+$0090]
MOV WORD PTR [ES:SI+BX],AX
ADD BL,$02
CMP BL,$0A
JB @SAVEZP2
SUB BX,BX
@SAVEZP4: MOV AX,WORD PTR [BX+$0200]
PUSH AX
AND AH,$F0
CMP AH,$A0
POP AX
JNZ @SAVEZP3
CMP AX,WORD PTR [ES:BX+$0100]
JZ @SAVEZP3
MOV WORD PTR [ES:BX+$0100],AX
MOV AL,BYTE PTR [SCHAKELBYTE]
AND AX,$000F
MOV WORD PTR [ES:BX+$0120],AX
@SAVEZP3: ADD BL,$02
CMP BL,$1C
JB @SAVEZP4
MOV AX,WORD PTR [$03FE]
MOV BL,AH
AND BL,$F0
CMP BL,$A0
JNZ @SAVEZP5
CMP AX,WORD PTR [ES:$011C]
JZ @SAVEZP5
MOV WORD PTR [ES:$011C],AX
MOV AL,BYTE PTR [SCHAKELBYTE]
AND AX,$000F
MOV WORD PTR [ES:$013C],AX
@SAVEZP5: POP SI
POP BX
POP ES
@SAVEZP1:
END;
{---[setA000mem]------------------------------------------------------------}
PROCEDURE SETA000MEM; ASSEMBLER;
ASM;
TEST BYTE PTR [CS:BOXSWITCH],$FF
JZ @SETA000_1
PUSH DS
PUSH ES
PUSH BX
PUSH CX
PUSH SI
MOV AH,BYTE PTR [SCHAKELBYTE]
AND AX,$0F00
SHL AH,4
MOV SI,AX
MOV DI,$A000
MOV AX,DS
MOV ES,AX
ADD AX,$1000
MOV DS,AX
MOV CX,$0800
REPZ
MOVSW
MOV AL,BYTE PTR [ES:SCHAKELBYTE]
AND AX,$000F
SHL AX,4
MOV SI,AX
MOV AX,DS
ADD AX,$1000
MOV DS,AX
SUB BX,BX
@SETA000_2: MOV AX,WORD PTR [SI+BX]
MOV WORD PTR [ES:BX+$0090],AX
ADD BL,$02
CMP BL,$0A
JB @SETA000_2
POP SI
POP CX
POP BX
POP ES
POP DS
@SETA000_1:
END;
{---[setbordercol]----------------------------------------------------------}
PROCEDURE SETBORDERCOL; ASSEMBLER;
ASM;
MOV AL,BYTE PTR [CS:GRAPHMODE]
OR AL,AL
JZ @BORDERCOL1
CMP AL,$05
JAE @BORDERCOL2
{---hires mode---}
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3)]
MOV BYTE PTR EMULCOLORS[CS:(7*3)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3+1)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+1)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3+2)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+2)],AL
TEST BYTE PTR [$B002],$08
JZ @BORDERCOL3
PUSH DX
CLI
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSMONO[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$02]
OUT DX,AL
STI
POP DX
RETN
@BORDERCOL1: {---lores mode---}
MOV AL,BYTE PTR EMULCOLORS[CS:(0*3)]
MOV BYTE PTR EMULCOLORS[CS:(7*3)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(0*3+1)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+1)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(0*3+2)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+2)],AL
@BORDERCOL3: PUSH DX
CLI
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+1)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+2)]
OUT DX,AL
STI
POP DX
RETN
@BORDERCOL2: {---hires colour mode---}
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3)]
MOV BYTE PTR EMULCOLORS[CS:(7*3)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3+1)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+1)],AL
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3+2)]
MOV BYTE PTR EMULCOLORS[CS:(7*3+2)],AL
TEST BYTE PTR [$B002],$08
JZ @BORDERCOL3
PUSH DX
CLI
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSCOLOR[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$02]
OUT DX,AL
STI
POP DX
END;
{---[setintenscol]----------------------------------------------------------}
PROCEDURE SETINTENSCOL; ASSEMBLER;
ASM;
PUSHA
SUB BX,BX
@SETINT2: MOV AL,BYTE PTR EMULCOLORS[CS:BX+$03]
MOV AH,AL
SHR AH,1
ADD AL,AH
CMP AL,$3F
JBE @SETINT1
MOV AL,$3F
@SETINT1: MOV BYTE PTR INTENSMONO[CS:BX],AL
INC BL
CMP BL,$02
JBE @SETINT2
SUB BX,BX
@SETINT4: MOV AL,BYTE PTR EMULCOLORS[CS:BX+$09]
MOV AH,AL
SHR AH,1
ADD AL,AH
CMP AL,$3F
JBE @SETINT3
MOV AL,$3F
@SETINT3: MOV BYTE PTR INTENSCOLOR[CS:BX],AL
INC BL
CMP BL,$02
JBE @SETINT4
POPA
END;
{---[sortimp]---------------------------------------------------------------}
PROCEDURE SORTIMP (VAR A:ATMFILETYPE; LO,HI:INTEGER);
VAR X,Y:ATMFILEREC;
PROCEDURE SORTEER (L,R:INTEGER);
VAR I,J:INTEGER;
BEGIN
I := L;
J := R;
X := A[(L+R) DIV 2];
REPEAT
WHILE A[I].ATMNAME < X.ATMNAME DO INC (I);
WHILE X.ATMNAME < A[J].ATMNAME DO DEC (J);
IF I <= J THEN
BEGIN
Y := A[I];
A[I] := A[J];
A[J] := Y;
INC (I);
DEC (J);
END;
UNTIL I > J;
IF L < J THEN SORTEER (L,J);
IF I < R THEN SORTEER (I,R);
END;
BEGIN
SORTEER (LO,HI);
END;
{---[readimportablefiles]---------------------------------------------------}
PROCEDURE READIMPORTABLEFILES;
VAR D:SEARCHREC;
F:FILE;
NR:WORD;
DUMMY:INTEGER;
BEGIN
AANTALIMPFILES := 0;
FINDFIRST ('*.ATM',ANYFILE,D);
WHILE (DOSERROR = 0) AND (AANTALIMPFILES < MAXAANTFILES) DO
BEGIN
IF D.ATTR AND $18 = $00 THEN
BEGIN
DUMMY := IORESULT;
ASSIGN (F,D.NAME);
RESET (F,1);
BLOCKREAD (F,IMPFILES[AANTALIMPFILES],SIZEOF(ATMFILEREC),NR);
CLOSE (F);
FOR NR := 0 TO 15 DO IMPFILES[AANTALIMPFILES].ATMNAME[NR] := #$00;
FOR NR := 1 TO LENGTH(D.NAME) DO
IMPFILES[AANTALIMPFILES].ATMNAME[PRED(NR)] := D.NAME[NR];
INC (AANTALIMPFILES);
END;
FINDNEXT (D);
END;
IF AANTALIMPFILES > 0 THEN SORTIMP (IMPFILES,0,PRED(AANTALIMPFILES));
END;
{---[load]------------------------------------------------------------------}
PROCEDURE LOAD (TABLEOFS:WORD; FILEPOINTER:INTEGER; VAR NEWFP:WORD);
LABEL 1;
CONST BUFSIZE = $FFF8;
VAR FROMF : FILE;
TAPESIZE : LONGINT;
FILENAME : STRING[16];
CURNAME : STRING[16];
W,I,NR : WORD;
ATMHEADER : ATMFILEREC;
STARTADRS : WORD;
DEST : POINTER;
FPOS : LONGINT;
INITPOS : LONGINT;
BUF : POINTER;
BUFSEG : WORD;
DUMMY : INTEGER;
FRZVERSION: WORD;
BEGIN
ASM;
PUSH DS
MOV DS,WORD PTR ATOMMEMSEG
CALL SAVEZP90
POP DS
END;
IF LENGTH(TAPEIMAGENAME) = 0 THEN
BEGIN
NEWFP := $8000; {---no tape image selected---}
EXIT;
END;
W := MEMW[ATOMMEMSEG:TABLEOFS];
FILENAME := '';
I := 0;
WHILE (I < 16) AND (MEM[ATOMMEMSEG:W+I] <> $0D) DO
BEGIN
FILENAME := FILENAME + CHR(MEM[ATOMMEMSEG:W+I]);
INC(I);
END;
IF LENGTH(FILENAME) = 0 THEN FILENAME := '*';
DUMMY := IORESULT;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN
BEGIN
NEWFP := $8000; {---tape image not found---}
EXIT;
END;
TAPESIZE := FILESIZE(FROMF);
NEWFP := 0;
FPOS := 0;
WHILE (FPOS < TAPESIZE) AND (FILEPOINTER > 0) DO
BEGIN
ATMHEADER := ATOMFILES[NEWFP];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
DEC (FILEPOINTER);
INC (NEWFP);
END;
INITPOS := FPOS;
IF INITPOS = 0 THEN INITPOS := TAPESIZE;
1:IF FPOS >= TAPESIZE THEN
BEGIN
NEWFP := 0;
FPOS := 0;
END;
ATMHEADER := ATOMFILES[NEWFP];
INC (FPOS,SIZEOF(ATMHEADER));
CURNAME := '';
I := 0;
WHILE (I < 16) AND (ATMHEADER.ATMNAME[I] <> #$00) DO
BEGIN
CURNAME := CURNAME + ATMHEADER.ATMNAME[I];
INC (I);
END;
IF (FILENAME[LENGTH(FILENAME)] = '*') THEN
BEGIN
IF (LENGTH(FILENAME) = 1) OR
(COPY(FILENAME,1,PRED(LENGTH(FILENAME))) =
COPY (CURNAME,1,PRED(LENGTH(FILENAME)))) THEN FILENAME := CURNAME;
END;
IF FILENAME <> CURNAME THEN
BEGIN
INC (NEWFP);
INC (FPOS,LONGINT(ATMHEADER.DATASIZE));
IF FPOS <> INITPOS THEN GOTO 1;
CLOSE (FROMF);
NEWFP := $8000; {---atom file not on this image---}
EXIT;
END;
FRZVERSION := NOT(ATMHEADER.STARTADRS AND ATMHEADER.EXECADRS);
IF FRZVERSION > 3 THEN
BEGIN {---normal file---}
IF MEM[ATOMMEMSEG:TABLEOFS+$04] AND $80 <> $00 THEN
BEGIN
STARTADRS := MEMW[ATOMMEMSEG:TABLEOFS+$02];
END ELSE
BEGIN
STARTADRS := ATMHEADER.STARTADRS;
END;
MEM[ATOMMEMSEG:$00DD] := $00;
MEMW[ATOMMEMSEG:$00D6] := ATMHEADER.EXECADRS;
{---no unnamed files, so no JMP ($00CB) will occur when *RUN---}
DEST := PTR(ATOMMEMSEG,STARTADRS);
SEEK (FROMF,FPOS);
IF LONGINT(STARTADRS)+LONGINT(PRED(ATMHEADER.DATASIZE)) > $FFFF THEN
BEGIN
NR := 0;
END ELSE
BEGIN
BLOCKREAD (FROMF,DEST^,ATMHEADER.DATASIZE,NR);
END;
IF NR <> ATMHEADER.DATASIZE THEN
BEGIN
CLOSE (FROMF);
NEWFP := $8000; {---dos read error---}
EXIT;
END;
{---ok, atom file loaded---}
CLOSE (FROMF);
INC (NEWFP);
END ELSE
BEGIN {---frozen file---}
GETMEM (BUF,BUFSIZE);
BUFSEG := SEG(BUF^);
IF OFS(BUF^) <> $0000 THEN INC (BUFSEG);
DEST := PTR(BUFSEG,$0000);
SEEK (FROMF,FPOS);
BLOCKREAD (FROMF,DEST^,ATMHEADER.DATASIZE,NR);
IF NR <> ATMHEADER.DATASIZE THEN
BEGIN
CLOSE (FROMF);
FREEMEM (BUF,BUFSIZE);
NEWFP := $8000; {---dos read error---}
EXIT;
END;
CLOSE (FROMF);
ASM;
MOV BX,WORD PTR FRZVERSION
PUSH DS
MOV ES,WORD PTR ATOMMEMSEG
SUB DI,DI
MOV DS,WORD PTR BUFSEG
SUB SI,SI
LODSW
ADD AX,SI
MOV DX,AX
@UNPACK3: CMP SI,DX
JZ @UNPACK2
MOVSB
JMP @UNPACK3
@UNPACK2: LODSW
CMP AX,$FFFF
JZ @UNPACK1
ADD AX,SI
MOV DX,AX
LODSW
MOV CX,AX
LODSB
REPZ
STOSB
JMP @UNPACK3
@UNPACK1: MOV DI,$B000
MOVSW
MOVSW
MOV DI,$B800
MOV CX,$0008
REPZ
MOVSW
PUSH ES
MOV AX,$A000
MOV ES,AX
CALL CLRMOUSECURSOR
POP ES
CMP BX,$0001
JB @UNPACK4
{freeze version 1, from emulator v1.30 and higher}
PUSH ES
MOV ES,WORD PTR [CS:DATASEG]
LODSW
MOV WORD PTR TEMPMOUSEDAT[ES:$00],AX
LODSB
MOV BYTE PTR TEMPMOUSEDAT[ES:$02],AL
LODSW
MOV WORD PTR TEMPMOUSEDAT[ES:$03],AX
LODSW
MOV WORD PTR TEMPMOUSEDAT[ES:$05],AX
MOV AX,$A000
MOV ES,AX
CALL ENABLEMOUSE
POP ES
PUSH ES
MOV AX,ES
ADD AX,$2000
MOV ES,AX
SUB DI,DI
CMP BX,$0002
JAE @UNPACK6
{freeze version 1: up to 8 toolboxes}
MOV CX,$0080
REPZ
MOVSB
MOV CX,$0080
MOV AL,$00
REPZ
STOSB
MOV CX,$0040
REPZ
MOVSB
JMP @UNPACK7
@UNPACK6: {freeze version 2 and higher: up to 16 toolboxes}
MOV CX,$0140
REPZ
MOVSB
@UNPACK7: LODSB
MOV BYTE PTR [CS:AANTBOXRET],AL
MOV AX,CS
MOV ES,AX
MOV DI,OFFSET BOXRETURNS
MOV CX,$0020
REPZ
MOVSW
POP ES
JMP @UNPACK5
@UNPACK4: {freeze version 0, until emulator v1.30}
MOV DI,$BFE0
SUB AX,AX
STOSW
STOSB
MOV BYTE PTR [CS:MOUSENR],$80
@UNPACK5: MOV DI,$BFF6
MOVSW
MOVSW
MOVSW
MOVSW
MOVSW
MOV AX,CS
MOV ES,AX
MOV DI,OFFSET GRAPHMODE
MOVSB
MOV DI,OFFSET PROGRAMCNT
MOVSW
MOV DI,OFFSET STACKPOINTER
MOVSW
MOV DI,OFFSET ACCUMULATOR
MOVSB
MOV DI,OFFSET FLAGREGISTER
MOVSB
CMP BX,$0003
JB @UNPACK8
{freeze version 3 and higher: extra accumulator}
MOV DI,OFFSET XREGISTER
MOVSB
MOV DI,OFFSET YREGISTER
MOVSB
MOV DI,OFFSET ACCU_B
MOVSB
JMP @UNPACK9
@UNPACK8: MOV DI,OFFSET XREGISTER
MOVSB
INC SI
MOV DI,OFFSET YREGISTER
MOVSB
INC SI
@UNPACK9: MOV DI,OFFSET CPUSPEEDMODE
MOVSB
MOV DI,OFFSET ALTKEYB
MOVSB
MOV DI,OFFSET T2L_L
MOVSB
MOV DI,OFFSET IRQDELAY
MOVSB
POP DS
MOV AX,CS
MOV ES,AX
MOV DI,OFFSET TOETS
MOV CX,$0082
MOV AL,$00
REPZ
STOSB
END;
FREEMEM (BUF,BUFSIZE);
INC (NEWFP,$4001);
END;
ASM;
MOV ES,WORD PTR ATOMMEMSEG
MOV BYTE PTR [ES:FLIPFLOP],$55
MOV SI,OFFSET ATOMROMMEM + $1000
MOV DI,$C000
MOV CX,$2000
REPZ
MOVSW
TEST BYTE PTR [CS:LEENDERTSROM],$FF
JZ @SK2
MOV SI,OFFSET LEENDERTS_FPROM_DAT
MOV DI,$D000
MOV CX,LEENDERTS_FPROM_SIZE
REPZ
MOVSB
@SK2: TEST BYTE PTR [CS:IGNOREzpFEh],$FF
JZ @SK1
MOV BYTE PTR [ES:$FF07],$00
@SK1: PUSH DS
MOV DS,WORD PTR ATOMMEMSEG
PUSH WORD PTR [$0090]
PUSH WORD PTR [$0092]
PUSH WORD PTR [$0094]
PUSH WORD PTR [$0096]
PUSH WORD PTR [$0098]
CALL SETA000MEM
POP WORD PTR [$0098]
POP WORD PTR [$0096]
POP WORD PTR [$0094]
POP WORD PTR [$0092]
POP WORD PTR [$0090]
POP DS
END;
END;
{---[readfinbuf]------------------------------------------------------------}
PROCEDURE READFINBUF (NAMEOFFSET:WORD; FILEPOINTER:INTEGER; VAR NEWFP: WORD);
LABEL 1;
VAR FROMF : FILE;
TAPESIZE : LONGINT;
FILENAME : STRING[16];
CURNAME : STRING[16];
ATMHEADER : ATMFILEREC;
FPOS : LONGINT;
INITPOS : LONGINT;
I : WORD;
NR : WORD;
DUMMY : INTEGER;
BEGIN
FINBUFPTR := $0000;
FINSIZE := 0;
IF LENGTH(TAPEIMAGENAME) = 0 THEN
BEGIN
NEWFP := $8000; {---no tape image selected---}
EXIT;
END;
FILENAME := '';
I := 0;
WHILE (I < 16) AND (MEM[ATOMMEMSEG:NAMEOFFSET+I] <> $0D) DO
BEGIN
FILENAME := FILENAME + CHR(MEM[ATOMMEMSEG:NAMEOFFSET+I]);
INC(I);
END;
IF LENGTH(FILENAME) = 0 THEN FILENAME := '*';
DUMMY := IORESULT;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN
BEGIN
NEWFP := $8000; {---tape image not found---}
EXIT;
END;
TAPESIZE := FILESIZE(FROMF);
NEWFP := 0;
FPOS := 0;
WHILE (FPOS < TAPESIZE) AND (FILEPOINTER > 0) DO
BEGIN
ATMHEADER := ATOMFILES[NEWFP];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
DEC (FILEPOINTER);
INC (NEWFP);
END;
INITPOS := FPOS;
IF INITPOS = 0 THEN INITPOS := TAPESIZE;
1:IF FPOS >= TAPESIZE THEN
BEGIN
NEWFP := 0;
FPOS := 0;
END;
ATMHEADER := ATOMFILES[NEWFP];
INC (FPOS,SIZEOF(ATMHEADER));
CURNAME := '';
I := 0;
WHILE (I < 16) AND (ATMHEADER.ATMNAME[I] <> #$00) DO
BEGIN
CURNAME := CURNAME + ATMHEADER.ATMNAME[I];
INC (I);
END;
IF (FILENAME[LENGTH(FILENAME)] = '*') THEN
BEGIN
IF (LENGTH(FILENAME) = 1) OR
(COPY(FILENAME,1,PRED(LENGTH(FILENAME))) =
COPY (CURNAME,1,PRED(LENGTH(FILENAME)))) THEN FILENAME := CURNAME;
END;
IF FILENAME <> CURNAME THEN
BEGIN
INC (NEWFP);
INC (FPOS,LONGINT(ATMHEADER.DATASIZE));
IF FPOS <> INITPOS THEN GOTO 1;
CLOSE (FROMF);
NEWFP := $8000; {---file not on this image---}
EXIT;
END;
SEEK (FROMF,FPOS);
BLOCKREAD (FROMF,FINBUF^,ATMHEADER.DATASIZE,NR);
IF NR <> ATMHEADER.DATASIZE THEN
BEGIN
CLOSE (FROMF);
NEWFP := $8000; {---dos read error---}
EXIT;
END;
{---ok, file loaded into finbuf---}
CLOSE (FROMF);
FINSIZE := ATMHEADER.DATASIZE;
INC (NEWFP);
END;
{---[createfout]------------------------------------------------------------}
PROCEDURE CREATEFOUT;
VAR TOF : FILE;
ATMHEADER : ATMFILEREC;
I : BYTE;
NW : WORD;
DUMMY : INTEGER;
BEGIN
IF LENGTH(TAPEIMAGENAME) = 0 THEN EXIT;
DUMMY := IORESULT;
ASSIGN (TOF,TAPEIMAGENAME+'.TAP');
RESET (TOF,1);
IF IORESULT <> 0 THEN EXIT;
SEEK (TOF,FILESIZE(TOF));
FOR I := 0 TO 15 DO ATMHEADER.ATMNAME[I] := #$00;
FOR I := 1 TO LENGTH(FOUTNAME) DO ATMHEADER.ATMNAME[PRED(I)] := FOUTNAME[I];
ATMHEADER.STARTADRS := $8200;
ATMHEADER.EXECADRS := $C2B2;
ATMHEADER.DATASIZE := 0;
BLOCKWRITE (TOF,ATMHEADER,SIZEOF(ATMHEADER),NW);
CLOSE (TOF);
READFILESINTAPEIMAGE;
END;
{---[writefoutbuf]----------------------------------------------------------}
PROCEDURE WRITEFOUTBUF;
VAR TOF : FILE;
TAPESIZE : LONGINT;
CURNAME : STRING[16];
ATMHEADER : ATMFILEREC;
FPOS : LONGINT;
PREV : LONGINT;
I : WORD;
NW : WORD;
DUMMY : INTEGER;
BEGIN
IF (FOUTOPEN=0) OR (FOUTBUFPTR=0) THEN EXIT;
IF LENGTH(TAPEIMAGENAME) = 0 THEN
BEGIN
FOUTERRORSND;
FOUTOPEN := 0;
EXIT;
END;
DUMMY := IORESULT;
ASSIGN (TOF,TAPEIMAGENAME+'.TAP');
RESET (TOF,1);
IF IORESULT <> 0 THEN
BEGIN
FOUTERRORSND;
FOUTOPEN := 0;
EXIT;
END;
TAPESIZE := FILESIZE(TOF);
FPOS := 0;
PREV := 0;
I := 0;
WHILE FPOS < TAPESIZE DO
BEGIN
PREV := FPOS;
ATMHEADER := ATOMFILES[I];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
INC (I);
END;
FPOS := PREV;
CURNAME := '';
I := 0;
WHILE (I < 16) AND (ATMHEADER.ATMNAME[I] <> #$00) DO
BEGIN
CURNAME := CURNAME + ATMHEADER.ATMNAME[I];
INC (I);
END;
IF (CURNAME <> FOUTNAME) OR (TAPEIMAGENAME <> IMAGEFOUTNAME) THEN
BEGIN
CLOSE (TOF);
FOUTERRORSND;
FOUTOPEN := 0;
EXIT;
END;
INC (ATMHEADER.DATASIZE,FOUTBUFPTR);
SEEK (TOF,FPOS);
BLOCKWRITE (TOF,ATMHEADER,SIZEOF(ATMHEADER),NW);
SEEK (TOF,TAPESIZE);
BLOCKWRITE (TOF,FOUTBUF^,FOUTBUFPTR,NW);
CLOSE (TOF);
FOUTBUFPTR := 0;
READFILESINTAPEIMAGE;
END;
{---[writebmp]--------------------------------------------------------------}
PROCEDURE WRITEBMP;
LABEL 1,2;
CONST BUFSIZE = $6000;
VAR TOF : FILE;
BMPNR : ARRAY[1..4] OF CHAR;
I : BYTE;
BUF : POINTER;
BUFOFS : WORD;
BUFSEG : WORD;
NR : WORD;
BEGIN
FOR I := 0 TO SIZEOF(BMPHEADER) DO BMPHEADER[I] := $00;
BMPHEADER[$00] := $42; BMPHEADER[$01] := $4D; BMPHEADER[$02] := $76;
BMPHEADER[$03] := $70; BMPHEADER[$0A] := $76; BMPHEADER[$0E] := $28;
BMPHEADER[$13] := $01; BMPHEADER[$16] := $C0; BMPHEADER[$1A] := $01;
BMPHEADER[$1C] := $04; BMPHEADER[$23] := $60; BMPHEADER[$2E] := $10;
BMPHEADER[$32] := $10;
ASM;
MOV CX,$0010
SUB SI,SI
SUB DI,DI
@LP1: MOV AL,BYTE PTR EMULCOLORS[CS:SI]
SHL AL,2
MOV BYTE PTR BMPHEADER[DI+$0038],AL
MOV AL,BYTE PTR EMULCOLORS[CS:SI+$01]
SHL AL,2
MOV BYTE PTR BMPHEADER[DI+$0037],AL
MOV AL,BYTE PTR EMULCOLORS[CS:SI+$02]
SHL AL,2
MOV BYTE PTR BMPHEADER[DI+$0036],AL
ADD SI,+$03
ADD DI,+$04
LOOP @LP1
END;
GETMEM (BUF,BUFSIZE);
BUFOFS := OFS(BUF^);
BUFSEG := SEG(BUF^);
ASM;
PUSH DS
MOV DI,WORD PTR BUFOFS
MOV ES,WORD PTR BUFSEG
MOV SI,$0140+191*$0120
MOV AX,$A000
MOV DS,AX
MOV DL,+192
@LP1: MOV DH,$40
@LP2: MOV BX,$C0C0
SUB CX,CX
@LP3: MOV AX,WORD PTR [SI]
AND AX,BX
TEST AH,$FF
JZ @SK1
OR CL,$02
@SK1: TEST AL,$FF
JZ @SK2
OR CL,$01
@SK2: MOV AX,WORD PTR [SI+$02]
AND AX,BX
TEST AH,$FF
JZ @SK3
OR CL,$08
@SK3: TEST AL,$FF
JZ @SK4
OR CL,$04
@SK4: ROL CX,4
SHR BX,2
JNZ @LP3
ROR CX,4
XCHG CL,CH
MOV WORD PTR [ES:DI],CX
ADD SI,+$04
ADD DI,+$02
DEC DH
JNZ @LP2
SUB SI,$40*4+$0120
DEC DL
JNZ @LP1
POP DS
END;
BMPNR := '0000';
1:ASSIGN (TOF,'ATOM'+BMPNR+'.BMP');
RESET (TOF,1);
IF IORESULT = 0 THEN
BEGIN
CLOSE (TOF);
I := 4;
2: INC (BMPNR[I]);
IF BMPNR[I] > '9' THEN
BEGIN
BMPNR[I] := '0';
DEC (I);
IF I >= 1 THEN GOTO 2;
FREEMEM (BUF,BUFSIZE);
EXIT;
END;
GOTO 1;
END;
REWRITE (TOF,1);
BLOCKWRITE (TOF,BMPHEADER,SIZEOF(BMPHEADER),NR);
BLOCKWRITE (TOF,BUF^,BUFSIZE,NR);
CLOSE (TOF);
FREEMEM (BUF,BUFSIZE);
END;
{---[insertinimage]---------------------------------------------------------}
PROCEDURE INSERTINIMAGE (FILEPTR:INTEGER; HEADER:ATMFILEREC; DATA:POINTER;
VAR CODE:WORD);
CONST BUFSIZE = $1000;
VAR FROMF,TOF : FILE;
I : WORD;
NR,NW : WORD;
FPOS : LONGINT;
AANT : LONGINT;
MAX : WORD;
BUF : POINTER;
TMPHEADER : ATMFILEREC;
DUMMY : INTEGER;
BEGIN
IF LENGTH(TAPEIMAGENAME) = 0 THEN
BEGIN
CODE := $8000; {---no tape image selected---}
EXIT;
END;
DUMMY := IORESULT;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN
BEGIN
CODE := $8000; {---tape image not found---}
EXIT;
END;
ASSIGN (TOF,'ATOMTEMP.TMP');
REWRITE (TOF,1);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (FROMF);
CODE := $8000; {---dos write error---}
EXIT;
END;
FPOS := 0;
I := 0;
WHILE I < FILEPTR DO
BEGIN
TMPHEADER := ATOMFILES[I];
INC (FPOS,SIZEOF(TMPHEADER)+LONGINT(TMPHEADER.DATASIZE));
INC (I);
END;
AANT := FPOS;
GETMEM (BUF,BUFSIZE);
WHILE AANT > 0 DO
BEGIN
MAX := BUFSIZE;
IF MAX > AANT THEN MAX := AANT;
BLOCKREAD (FROMF,BUF^,MAX,NR);
BLOCKWRITE (TOF,BUF^,NR,NW);
IF NR<>NW THEN
BEGIN
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
ERASE (TOF);
CLOSE (FROMF);
CODE := $8000; {---dos read/write error---}
EXIT;
END;
DEC (AANT,LONGINT(NW));
END;
BLOCKWRITE (TOF,HEADER,SIZEOF(HEADER),NW);
IF NW <> SIZEOF(HEADER) THEN
BEGIN
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
ERASE (TOF);
CLOSE (FROMF);
CODE := $8000; {---dos write error---}
EXIT;
END;
BLOCKWRITE (TOF,DATA^,HEADER.DATASIZE,NW);
IF NW <> HEADER.DATASIZE THEN
BEGIN
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
ERASE (TOF);
CLOSE (FROMF);
CODE := $8000; {---dos write error---}
EXIT;
END;
IF FILEPTR < AANTALATOMFILES THEN
BEGIN
REPEAT
BLOCKREAD (FROMF,BUF^,BUFSIZE,NR);
BLOCKWRITE (TOF,BUF^,NR,NW);
UNTIL NR=0;
END;
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
CLOSE (FROMF);
ERASE (FROMF);
RENAME (TOF,TAPEIMAGENAME+'.TAP');
READFILESINTAPEIMAGE;
CODE := $0000;
END;
{---[save]------------------------------------------------------------------}
PROCEDURE SAVE (TABLEOFS:WORD; FILEPOINTER:INTEGER; VAR CODE:WORD);
VAR W : WORD;
I : WORD;
FILENAME : STRING[16];
ATMHEADER : ATMFILEREC;
SOURCE : POINTER;
BEGIN
W := MEMW[ATOMMEMSEG:TABLEOFS];
FILENAME := '';
I := 0;
WHILE (I < 16) AND (MEM[ATOMMEMSEG:W+I] <> $0D) DO
BEGIN
FILENAME := FILENAME + CHR(MEM[ATOMMEMSEG:W+I]);
INC(I);
END;
IF LENGTH(FILENAME)=0 THEN FILENAME := 'FILE';
FOR I := 0 TO 15 DO ATMHEADER.ATMNAME[I] := #$00;
FOR I := 1 TO LENGTH(FILENAME) DO ATMHEADER.ATMNAME[PRED(I)] := FILENAME[I];
ATMHEADER.STARTADRS := MEMW[ATOMMEMSEG:TABLEOFS+2];
ATMHEADER.EXECADRS := MEMW[ATOMMEMSEG:TABLEOFS+4];
W := MEMW[ATOMMEMSEG:TABLEOFS+8] - MEMW[ATOMMEMSEG:TABLEOFS+6];
ATMHEADER.DATASIZE := W;
SOURCE := PTR(ATOMMEMSEG,MEMW[ATOMMEMSEG:TABLEOFS+6]);
INSERTINIMAGE (FILEPOINTER,ATMHEADER,SOURCE,CODE);
END;
{---[freeze]----------------------------------------------------------------}
PROCEDURE FREEZE;
CONST BUFSIZE = $FFF8;
VAR TOF : FILE;
BUF : POINTER;
P : POINTER;
BUFSEG : WORD;
LASTOFS : WORD;
SRC : WORD;
DST : WORD;
AANT : WORD;
NR : WORD;
B : BYTE;
ATMHEADER : ATMFILEREC;
DUMMY : INTEGER;
BEGIN
IF AANTALATOMFILES >= MAXAANTFILES THEN EXIT;
ATMHEADER.ATMNAME := 'FROZEN FILE'+#0+#0+#0+#0+#0;
GETMEM (BUF,BUFSIZE);
BUFSEG := SEG(BUF^);
IF OFS(BUF^) <> $0000 THEN INC (BUFSEG);
LASTOFS := $0000;
DST := $0002;
SRC := $0000;
WHILE SRC <= $9FFF DO
BEGIN
B := MEM[ATOMMEMSEG:SRC];
IF SRC <= $9FFB THEN
BEGIN
IF (B = MEM[ATOMMEMSEG:SRC+1]) AND
(B = MEM[ATOMMEMSEG:SRC+2]) AND
(B = MEM[ATOMMEMSEG:SRC+3]) AND
(B = MEM[ATOMMEMSEG:SRC+4]) THEN
BEGIN
AANT := 5;
WHILE (SRC+AANT <= $9FFF) AND (B = MEM[ATOMMEMSEG:SRC+AANT]) DO INC (AANT);
MEMW[BUFSEG:LASTOFS] := DST-(LASTOFS+2);
LASTOFS := DST;
INC (DST,2);
MEMW[BUFSEG:DST] := AANT;
INC (DST,2);
MEM[BUFSEG:DST] := B;
INC (DST);
INC (SRC,AANT);
END ELSE
BEGIN
MEM[BUFSEG:DST] := B;
INC (DST);
INC (SRC);
END;
END ELSE
BEGIN
MEM[BUFSEG:DST] := B;
INC (DST);
INC (SRC);
END;
END;
MEMW[BUFSEG:LASTOFS] := DST-(LASTOFS+2);
MEMW[BUFSEG:DST] := $FFFF;
INC (DST,2);
FOR SRC := $B000 TO $B003 DO
BEGIN
MEM[BUFSEG:DST] := MEM[ATOMMEMSEG:SRC];
INC (DST);
END;
FOR SRC := $B800 TO $B80F DO
BEGIN
MEM[BUFSEG:DST] := MEM[ATOMMEMSEG:SRC];
INC (DST);
END;
MEM[BUFSEG:DST] := TEMPMOUSEDAT.B_BFE0;
INC (DST);
MEM[BUFSEG:DST] := TEMPMOUSEDAT.B_BFE1;
INC (DST);
MEM[BUFSEG:DST] := TEMPMOUSEDAT.B_MOUSENR;
INC (DST);
MEMW[BUFSEG:DST] := TEMPMOUSEDAT.MOUSEX;
INC (DST,2);
MEMW[BUFSEG:DST] := TEMPMOUSEDAT.MOUSEY;
INC (DST,2);
FOR SRC := $0000 TO $013F DO
BEGIN
MEM[BUFSEG:DST] := MEM[ATOMMEMSEG+$2000:SRC];
INC (DST);
END;
MEM[BUFSEG:DST] := MEM[CSEG:OFS(AANTBOXRET)];
INC (DST);
FOR SRC := $00 TO $3F DO
BEGIN
MEM[BUFSEG:DST] := MEM[CSEG:OFS(BOXRETURNS)+SRC];
INC (DST);
END;
FOR SRC := $BFF6 TO $BFFF DO
BEGIN
MEM[BUFSEG:DST] := MEM[ATOMMEMSEG:SRC];
INC (DST);
END;
MEM [BUFSEG:DST] := MEM [CSEG:OFS(GRAPHMODE)]; INC (DST);
MEMW[BUFSEG:DST] := MEMW[CSEG:OFS(PROGRAMCNT)]; INC (DST,2);
MEMW[BUFSEG:DST] := MEMW[CSEG:OFS(STACKPOINTER)]; INC (DST,2);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(ACCUMULATOR)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(FLAGREGISTER)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(XREGISTER)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(YREGISTER)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(ACCU_B)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(CPUSPEEDMODE)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(ALTKEYB)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(T2L_L)]; INC (DST);
MEM [BUFSEG:DST] := MEM [CSEG:OFS(IRQDELAY)]; INC (DST);
P := PTR (BUFSEG,$0000);
DUMMY := IORESULT;
ASSIGN (TOF,TAPEIMAGENAME+'.TAP');
RESET (TOF,1);
IF IORESULT <> 0 THEN
BEGIN
FREEMEM (BUF,BUFSIZE);
EXIT;
END;
SEEK (TOF,FILESIZE(TOF));
ATMHEADER.STARTADRS := $FFFF;
ATMHEADER.EXECADRS := $FFFC; {not (freeze version)}
ATMHEADER.DATASIZE := DST;
BLOCKWRITE (TOF,ATMHEADER,SIZEOF(ATMHEADER),NR);
BLOCKWRITE (TOF,P^,DST,NR);
CLOSE (TOF);
ATOMFILES[AANTALATOMFILES] := ATMHEADER;
INC (AANTALATOMFILES);
FREEMEM (BUF,BUFSIZE);
END;
{---[deletefile]------------------------------------------------------------}
PROCEDURE DELETEFILE (WHICHFILE:WORD);
CONST BUFSIZE = $8000;
VAR FROMF,TOF : FILE;
ATMHEADER : ATMFILEREC;
FPOS : LONGINT;
AANT : LONGINT;
I,MAX : WORD;
NR,NW : WORD;
BUF : POINTER;
DUMMY : INTEGER;
BEGIN
DUMMY := IORESULT;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN EXIT;
ASSIGN (TOF,'ATOMTEMP.TMP');
REWRITE (TOF,1);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (FROMF);
EXIT;
END;
FPOS := 0;
I := 0;
WHILE I < WHICHFILE DO
BEGIN
ATMHEADER := ATOMFILES[I];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
INC (I);
END;
AANT := FPOS;
GETMEM (BUF,BUFSIZE);
WHILE AANT > 0 DO
BEGIN
MAX := BUFSIZE;
IF MAX > AANT THEN MAX := AANT;
BLOCKREAD (FROMF,BUF^,MAX,NR);
BLOCKWRITE (TOF,BUF^,NR,NW);
IF NR<>NW THEN
BEGIN
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
ERASE (TOF);
CLOSE (FROMF);
EXIT;
END;
DEC (AANT,LONGINT(NW));
END;
ATMHEADER := ATOMFILES[I];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
SEEK (FROMF,FPOS);
IF WHICHFILE < AANTALATOMFILES THEN
BEGIN
REPEAT
BLOCKREAD (FROMF,BUF^,BUFSIZE,NR);
BLOCKWRITE (TOF,BUF^,NR,NW);
UNTIL (NR=0);
END;
FREEMEM (BUF,BUFSIZE);
CLOSE (TOF);
CLOSE (FROMF);
ERASE (FROMF);
RENAME (TOF,TAPEIMAGENAME+'.TAP');
READFILESINTAPEIMAGE;
END;
{---[export]----------------------------------------------------------------}
PROCEDURE EXPORT (WHICHFILE:WORD);
CONST BUFSIZE = $8000;
VAR FROMF,TOF : FILE;
ATMHEADER : ATMFILEREC;
FILENAME : STRING[16];
CH : CHAR;
I,AANT : WORD;
NR,NW : WORD;
FPOS : LONGINT;
BUF : POINTER;
DUMMY : INTEGER;
BEGIN
ATMHEADER := ATOMFILES[WHICHFILE];
FILENAME := '';
I := 0;
WHILE (I < 16) AND (ATMHEADER.ATMNAME[I] <> #$0D) DO
BEGIN
CH := ATMHEADER.ATMNAME[I];
IF ((CH >= '0') AND (CH <= '9')) OR ((CH >= 'A') AND (CH <= 'Z')) THEN
BEGIN
FILENAME := FILENAME + CH;
END;
INC(I);
END;
IF LENGTH(FILENAME) = 0 THEN FILENAME := 'FILE';
IF LENGTH(FILENAME) > 8 THEN
BEGIN
I := LENGTH(FILENAME);
WHILE (LENGTH(FILENAME) > 8) AND (I > 0) DO
BEGIN
IF ((FILENAME[I] <= 'A') OR (FILENAME[I] = 'E') OR
(FILENAME[I] = 'I') OR (FILENAME[I] = 'O') OR
(FILENAME[I] = 'U') OR (FILENAME[I] = 'Y') OR
(FILENAME[I] > 'Z'))
AND NOT ((FILENAME[I] >= '0') AND (FILENAME[I] <= '9')) THEN
BEGIN
DELETE (FILENAME,I,1);
I := LENGTH(FILENAME);
END ELSE
BEGIN
DEC (I);
END;
END;
IF LENGTH(FILENAME) > 8 THEN FILENAME := COPY(FILENAME,1,8);
END;
DUMMY := IORESULT;
ASSIGN (TOF,FILENAME+'.ATM');
RESET (TOF,1);
IF IORESULT = 0 THEN
BEGIN
CLOSE (TOF);
ERRORSND;
EXIT;
END;
REWRITE (TOF,1);
IF IORESULT <> 0 THEN EXIT;
BLOCKWRITE (TOF,ATMHEADER,SIZEOF(ATMHEADER),NW);
IF NW <> SIZEOF(ATMHEADER) THEN
BEGIN
CLOSE (TOF);
ERASE (TOF);
EXIT;
END;
ASSIGN (FROMF,TAPEIMAGENAME+'.TAP');
RESET (FROMF,1);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (TOF);
ERASE (TOF);
EXIT;
END;
FPOS := 0;
I := 0;
WHILE I < WHICHFILE DO
BEGIN
ATMHEADER := ATOMFILES[I];
INC (FPOS,SIZEOF(ATMHEADER)+LONGINT(ATMHEADER.DATASIZE));
INC (I);
END;
INC (FPOS,SIZEOF(ATMHEADER));
SEEK (FROMF,FPOS);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (FROMF);
CLOSE (TOF);
ERASE (TOF);
EXIT;
END;
I := ATOMFILES[WHICHFILE].DATASIZE;
GETMEM (BUF,BUFSIZE);
REPEAT
AANT := I;
IF AANT > BUFSIZE THEN AANT := BUFSIZE;
DEC (I,AANT);
BLOCKREAD (FROMF,BUF^,AANT,NR);
BLOCKWRITE (TOF,BUF^,NR,NW);
UNTIL I=0;
FREEMEM (BUF,BUFSIZE);
CLOSE (FROMF);
CLOSE (TOF);
END;
{---[import]----------------------------------------------------------------}
PROCEDURE IMPORT (ATMFILEPTR,IMPFILEPTR:INTEGER; VAR CODE:WORD);
CONST BUFSIZE = $FFF8;
VAR BUF : POINTER;
BUFOFS : WORD;
BUFSEG : WORD;
ATMHEADER : ATMFILEREC;
FILENAME : STRING[13];
FILEHANDLE: WORD;
FNOFS : WORD;
ATOFS : WORD;
NR : WORD;
RESULTAAT : BYTE;
CONST ATMSIZE = SIZEOF(ATMHEADER);
BEGIN
CODE := $8000;
FILENAME := '';
NR := 0;
WHILE (NR < 12) AND (IMPFILES[IMPFILEPTR].ATMNAME[NR] <> #$00) DO
BEGIN
FILENAME := FILENAME + IMPFILES[IMPFILEPTR].ATMNAME[NR];
INC (NR);
END;
FILENAME := FILENAME + #$00;
FNOFS := SUCC(OFS(FILENAME));
ATOFS := OFS(ATMHEADER);
GETMEM (BUF,BUFSIZE);
BUFOFS := OFS(BUF^);
BUFSEG := SEG(BUF^);
ASM;
MOV BYTE PTR RESULTAAT,$01
PUSH DS
MOV AX,$3D00
MOV DX,WORD PTR FNOFS
PUSH SS
POP DS
INT $21 {open file}
POP DS
JC @EINDE
MOV WORD PTR FILEHANDLE,AX
PUSH DS
MOV AH,$3F {read from file}
MOV BX,WORD PTR FILEHANDLE
MOV CX,ATMSIZE
MOV DX,WORD PTR ATOFS
PUSH SS
POP DS
INT $21
POP DS
JC @CLOSE
CMP AX,ATMSIZE
JNZ @CLOSE
PUSH DS
MOV AH,$3F {read from file}
MOV BX,WORD PTR FILEHANDLE
MOV CX,WORD PTR ATMHEADER[$0014] {atmheader.datasize}
MOV DX,WORD PTR BUFOFS
MOV DS,WORD PTR BUFSEG
INT $21
POP DS
JC @CLOSE
CMP AX,WORD PTR ATMHEADER[$0014]
JNZ @CLOSE
MOV BYTE PTR RESULTAAT,$00
@CLOSE: MOV AH,$3E {close file}
MOV BX,WORD PTR FILEHANDLE
INT $21
@EINDE:
END;
IF RESULTAAT = 0 THEN INSERTINIMAGE (ATMFILEPTR,ATMHEADER,BUF,CODE)
ELSE ERRORSND;
FREEMEM (BUF,BUFSIZE);
END;
{---[renamefile]------------------------------------------------------------}
PROCEDURE RENAMEFILE (WHICHFILE:INTEGER; SEGM,ADRS:WORD);
VAR F : FILE;
I : WORD;
NW : WORD;
FPOS : LONGINT;
SOURCE : POINTER;
DUMMY : INTEGER;
BEGIN
DUMMY := IORESULT;
ASSIGN (F,TAPEIMAGENAME+'.TAP');
RESET (F,1);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (F);
EXIT;
END;
FPOS := 0;
I := 0;
WHILE I < WHICHFILE DO
BEGIN
INC (FPOS,SIZEOF(ATMFILEREC)+LONGINT(ATOMFILES[I].DATASIZE));
INC (I);
END;
SEEK (F,FPOS);
IF IORESULT <> 0 THEN
BEGIN
CLOSE (F);
EXIT;
END;
SOURCE := PTR(SEGM,ADRS);
MOVE (SOURCE^,ATOMFILES[WHICHFILE].ATMNAME,$10);
BLOCKWRITE (F,ATOMFILES[WHICHFILE],SIZEOF(ATMFILEREC),NW);
CLOSE (F);
IF NW <> SIZEOF(ATMFILEREC) THEN READFILESINTAPEIMAGE;
END;
{---[createtapefile]--------------------------------------------------------}
PROCEDURE CREATETAPEFILE (SEGM,ADRS:WORD; VAR NEWTAPEPTR:WORD);
VAR F : FILE;
FILENAME : STRING[8];
I : WORD;
DUMMY : INTEGER;
BEGIN
FILENAME := '';
I := 0;
WHILE (I < 8) AND (MEM[SEGM:ADRS+I] <> $00) DO
BEGIN
FILENAME := FILENAME + CHR(MEM[SEGM:ADRS+I]);
INC (I);
END;
IF LENGTH(FILENAME) = 0 THEN FILENAME := 'NEWTAPE';
DUMMY := IORESULT;
ASSIGN (F,FILENAME+'.TAP');
RESET (F,1);
IF IORESULT = 0 THEN
BEGIN
CLOSE (F);
ERRORSND;
EXIT;
END;
REWRITE (F,1);
CLOSE (F);
READDIRECTORY;
COPYWRITEPROT;
NEWTAPEPTR := 0;
WHILE FILENAME <> TAPEIMAGES[NEWTAPEPTR] DO INC(NEWTAPEPTR);
TAPEIMAGENAME := FILENAME;
READFILESINTAPEIMAGE;
END;
{---[creatediskfile]--------------------------------------------------------}
PROCEDURE CREATEDISKFILE (SEGM,ADRS:WORD; VAR NEWDISKPTR:WORD);
TYPE BUFTYPE = ARRAY[$00..$FF] OF BYTE;
VAR F : FILE;
FILENAME : STRING[8];
I : WORD;
DUMMY : INTEGER;
BUF : ^BUFTYPE;
BEGIN
FILENAME := '';
I := 0;
WHILE (I < 8) AND (MEM[SEGM:ADRS+I] <> $00) DO
BEGIN
FILENAME := FILENAME + CHR(MEM[SEGM:ADRS+I]);
INC (I);
END;
IF LENGTH(FILENAME) = 0 THEN FILENAME := 'NEWDISK';
DUMMY := IORESULT;
ASSIGN (F,FILENAME+'.DSK');
RESET (F,1);
IF IORESULT = 0 THEN
BEGIN
CLOSE (F);
ERRORSND;
EXIT;
END;
REWRITE (F,1);
GETMEM (BUF,SIZEOF(BUFTYPE));
FOR I := $00 TO $07 DO BUF^[I] := $20;
FOR I := $08 TO PRED(SIZEOF(BUFTYPE)) DO BUF^[I] := $00;
BLOCKWRITE (F,BUF^,SIZEOF(BUFTYPE));
BUF^[$05] := $00;
BUF^[$06] := $01;
BUF^[$07] := $90;
BLOCKWRITE (F,BUF^,SIZEOF(BUFTYPE));
FOR I := $00 TO PRED(SIZEOF(BUFTYPE)) DO BUF^[I] := $E5;
FOR I := 2 TO PRED(40*10) DO BLOCKWRITE (F,BUF^,SIZEOF(BUFTYPE));
FREEMEM (BUF,SIZEOF(BUFTYPE));
CLOSE (F);
READDIRECTORY;
COPYWRITEPROT;
NEWDISKPTR := 0;
WHILE FILENAME <> DISKIMAGES[NEWDISKPTR] DO INC(NEWDISKPTR);
READFILESINTAPEIMAGE;
END;
{---[tijd]------------------------------------------------------------------}
FUNCTION TIJD:LONGINT;
VAR H,M,S,T:WORD;
BEGIN
GETTIME (H,M,S,T);
TIJD := LONGINT(T) + LONGINT(S)*100 + LONGINT(M)*100*60 +
LONGINT(H)*100*60*60;
END;
{---[wachteventjes (english: wait a moment)]--------------------------------}
PROCEDURE WACHTEVENTJES;
VAR STARTTIJD:LONGINT;
HUIDIGETIJD:LONGINT;
BEGIN
STARTTIJD := TIJD;
REPEAT
HUIDIGETIJD := TIJD;
UNTIL (HUIDIGETIJD > STARTTIJD+60) OR (HUIDIGETIJD < STARTTIJD);
END;
{---[speedloop (used during emulation for delay)]---------------------------}
{This procedure will be filled with bytes F8h (CLC) by SETUPSPEEDLOOP. }
{It is now filled with 0's because all the F8h's take up some much space. }
{Depending on various parameters, between every emulated 65C02 instruction,a}
{CALL will be made to this procedure in order to get the correct delay count}
{The shorter the wait period must be, the futher back in this procedure the }
{CALL address will be. This depends on the PC's CPU speed, the number of }
{cycles that a 65C02 instruction should take and the number of cycles the PC}
{needs to emulate this instruction. This procedure is filled with CLC for }
{four reasons: Firstly, it is a one-byte instruction; Secondly, it always }
{takes 2 cycles, regardless the CPU type; thirdly, it is not pairable with }
{the Pentium's V- nor U-pipe; therefore n CLCs always take n x 2 cycles; and}
{finally, the value of the carry flag is of no importance when calling this.}
{---------------------------------------------------------------------------}
PROCEDURE SPEEDLOOP; ASSEMBLER;
ASM;
{0} DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
{1000} DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
{2000} DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
{3000} DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
DD 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0
END;
{---[setupspeedloop (fill up with CLC)]-------------------------------------}
PROCEDURE SETUPSPEEDLOOP; ASSEMBLER;
ASM;
CLD
MOV AX,CS
MOV ES,AX
MOV DI,OFFSET SPEEDLOOP
MOV CX,+4000
MOV AL,$F8 {clc}
REPZ
STOSB
END;
{---[setcolors]-------------------------------------------------------------}
PROCEDURE SETCOLORS; ASSEMBLER;
ASM;
PUSH DS
PUSH DX
PUSH BX
CLI
MOV AX,CS
MOV DS,AX
MOV SI,OFFSET EMULCOLORS
SUB BX,BX
@SETCOL1: MOV DX,$03C8
MOV AL,BL
OUT DX,AL
INC DX
LODSB
OUT DX,AL
LODSB
OUT DX,AL
LODSB
OUT DX,AL
INC BL
INC BH
CMP BH,$10
JB @SETCOL1
STI
POP BX
POP DX
POP DS
END;
{---[initatomgraph]---------------------------------------------------------}
PROCEDURE INITATOMGRAPH; ASSEMBLER;
ASM;
MOV AX,$0012
INT $10
MOV DX,$03D4
MOV AL,$09
OUT DX,AL
INC DX
IN AL,DX
OR AL,$80
OUT DX,AL {double scan active}
MOV DX,$03C4
MOV AL,$04
OUT DX,AL
INC DX
IN AL,DX
OR AL,$08
OUT DX,AL {chain 4 linear graphics mode}
MOV DX,$03D4
MOV AL,$14
OUT DX,AL
INC DX
IN AL,DX
OR AL,$40
OUT DX,AL {dword mode}
DEC DX
MOV AX,$0908
OUT DX,AX {preset rowscan: top border}
MOV AX,$2413
OUT DX,AX {logical screen line width}
MOV AL,$11
OUT DX,AL
INC DX
IN AL,DX
AND AL,$F0
OR AL,$09
OUT DX,AL {vertical retrace end}
CALL SETCOLORS
MOV AX,$1001
MOV BH,$07
INT $10
MOV BL,$00
@INITATGR1: MOV AX,$1000
MOV BH,BL
PUSH BX
INT $10
POP BX
INC BL
CMP BL,$10
JNZ @INITATGR1
CLD
MOV AX,$A000
MOV ES,AX
MOV BYTE PTR [ES:$FFFF],$00
SUB DI,DI
MOV CX,$4000
@INITATGR2: MOV AX,$FFFF
STOSW
STOSB
MOV AL,$00
STOSB
LOOP @INITATGR2
END;
{---[printstring; prints text after CALL and resumes execution after text]--}
PROCEDURE PRINTSTRING; ASSEMBLER;
ASM;
PUSH BP
MOV BP,SP
MOV SI,WORD PTR [SS:BP+$02]
MOV AL,BYTE PTR [CS:SI]
INC SI
MOV BYTE PTR [CS:CURSORX],AL
MOV AL,BYTE PTR [CS:SI]
INC SI
MOV BYTE PTR [CS:CURSORY],AL
MOV AL,BYTE PTR [CS:SI]
INC SI
MOV BL,AL
@PRINTSTR2: MOV AL,BYTE PTR [CS:SI]
INC SI
AND AL,$3F
JZ @PRINTSTR1
CALL PRINTCHAR
JMP @PRINTSTR2
@PRINTSTR1: MOV WORD PTR [SS:BP+$02],SI
POP BP
END;
{---[printbyte; AL=byte; BL=color]------------------------------------------}
PROCEDURE PRINTBYTE; ASSEMBLER;
ASM;
PUSH AX
SHR AL,4
OR AL,$30
CMP AL,$3A
JB @PRINTBYTE1
SUB AL,$39
@PRINTBYTE1: CALL PRINTCHAR
POP AX
AND AL,$0F
OR AL,$30
CMP AL,$3A
JB @PRINTBYTE2
SUB AL,$39
@PRINTBYTE2: CALL PRINTCHAR
END;
{---[printword; AX=word; BL=color]------------------------------------------}
PROCEDURE PRINTWORD; ASSEMBLER;
ASM;
PUSH AX
MOV AL,AH
CALL PRINTBYTE
POP AX
CALL PRINTBYTE
END;
{---[printdec]; AX=word; BL=color]------------------------------------------}
PROCEDURE PRINTDEC; ASSEMBLER;
ASM;
MOV CX,+10
SUB DX,DX
DIV CX
OR DL,$30
MOV BYTE PTR DECNUM[CS:$04],DL
SUB DX,DX
DIV CX
OR DL,$30
MOV BYTE PTR DECNUM[CS:$03],DL
SUB DX,DX
DIV CX
OR DL,$30
MOV BYTE PTR DECNUM[CS:$02],DL
SUB DX,DX
DIV CX
OR DL,$30
MOV BYTE PTR DECNUM[CS:$01],DL
OR AL,$30
MOV BYTE PTR DECNUM[CS:$00],AL
MOV BYTE PTR DECNUM[CS:$05],$00
@PRINTDEC2: CMP BYTE PTR DECNUM[CS:$00],'0'
JNZ @PRINTDEC1
MOV AX,WORD PTR DECNUM[CS:$01]
MOV WORD PTR DECNUM[CS:$00],AX
MOV AX,WORD PTR DECNUM[CS:$03]
MOV WORD PTR DECNUM[CS:$02],AX
MOV AL,BYTE PTR DECNUM[CS:$05]
MOV BYTE PTR DECNUM[CS:$04],AL
JMP @PRINTDEC2
@PRINTDEC1: CMP BYTE PTR DECNUM[CS:$00],$00
JNZ @PRINTDEC3
MOV BYTE PTR DECNUM[CS:$00],'0'
@PRINTDEC3: PUSH SI
SUB SI,SI
@PRINTDEC5: MOV AL,BYTE PTR DECNUM[CS:SI]
OR AL,AL
JZ @PRINTDEC4
CALL PRINTCHAR
INC SI
JMP @PRINTDEC5
@PRINTDEC4: POP SI
END;
{---[upperlines]------------------------------------------------------------}
PROCEDURE UPPERLINES; ASSEMBLER;
ASM;
NOP
SUB AX,AX
SUB DI,DI
MOV CX,$4000
@UPPERL1: MOV AX,$00FF
STOSW
MOV AX,$FFFF
STOSW
LOOP @UPPERL1
STI
CALL PRINTSTRING
DB +0,+0,$0F,'ACORN ATOM EMULATOR V1.33 BY WOUTER RAS'
DB 'DISK TAPE OPTIONS MONITOR',$00
MOV AL,'D' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
MOV BYTE PTR [CS:CURSORY],+1
CALL PRINTCHAR
MOV AL,'T' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+6
CALL PRINTCHAR
MOV AL,'O' AND $3F
MOV BYTE PTR [CS:CURSORX],+12
CALL PRINTCHAR
MOV AL,'M' AND $3F
MOV BYTE PTR [CS:CURSORX],+21
CALL PRINTCHAR
MOV AX,$FFFF
MOV DI,+9*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
MOV DI,+19*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
END;
{---[printdebugtxt]---------------------------------------------------------}
PROCEDURE PRINTDEBUGTXT; ASSEMBLER;
ASM;
PUSH DS
PUSH BX
PUSH CX
PUSH SI
PUSH DI
MOV AX,CS
MOV DS,AX
MOV SI,OFFSET DEBUGTXT
MOV DI,$0240
MOV CH,+17
@DBGMDON2: MOV CL,$04
@DBGMDON1: MOV WORD PTR [ES:DI],$00FF
MOV WORD PTR [ES:DI+$02],$FF00
MOV WORD PTR [ES:DI+$04],$00FF
MOV WORD PTR [ES:DI+$06],$FF00
LODSB
CALL MAKEWIDER
SUB BX,BX
@DBGMDON3: OR BYTE PTR [ES:DI+BX],AH
OR BYTE PTR [ES:DI+$04+BX],AL
INC BL
CMP BL,$04
JNZ @DBGMDON3
ADD DI,+$08
DEC CL
JNZ @DBGMDON1
ADD DI,$0120-8*4
DEC CH
JNZ @DBGMDON2
POP DI
POP SI
POP CX
POP BX
POP DS
END;
{---[rebuildscreen]---------------------------------------------------------}
PROCEDURE REBUILDSCREEN; ASSEMBLER;
ASM;
PUSHF
CLI
PUSH BX
PUSH CX
PUSH DX
MOV BL,BYTE PTR [CS:GRAPHMODE]
MOV BH,$00
SHL BX,1
MOV CX,WORD PTR GRAPHTOP[CS:BX]
MOV DX,$8000
SUB CX,DX
MOV BX,WORD PTR UPDATETABLE[CS:BX]
@REBUILD1: MOV DI,DX
CALL BX
INC DX
LOOP @REBUILD1
TEST BYTE PTR [CS:BRKPNTON],$FF
JZ @REBUILD4
CALL PRINTDEBUGTXT
@REBUILD4: POP DX
POP CX
POP BX
SUB AX,AX
MOV WORD PTR [WACHTSCHULD],AX
MOV WORD PTR [PCCYCLES],AX
POPF
END;
{---[keyreleasetel (byte)]--------------------------------------------------}
PROCEDURE KEYRELEASETEL; ASSEMBLER;
ASM;
END;
{---[keyrelease; BL=key#]---------------------------------------------------}
PROCEDURE KEYRELEASE; ASSEMBLER;
ASM;
MOV BH,$00
MOV BYTE PTR [CS:KEYRELEASETEL],$00
@KEYREL1: CMP BYTE PTR [CS:KEYRELEASETEL],+3
JAE @KEYREL2
TEST BYTE PTR TOETS[CS:BX],$03
JNZ @KEYREL1
@KEYREL2:
END;
{---[getcharcode (for usage in desktop)]------------------------------------}
PROCEDURE GETCHARCODE; ASSEMBLER;
ASM;
NOP
CLI {shift,ctrl & alt not implemented yet}
SUB SI,SI
@CHARCODE2: CMP SI,$001D {---ctrl---}
JZ @CHARCODE7
CMP SI,$0038 {---alt---}
JZ @CHARCODE7
CMP SI,$002A {---left shift---}
JZ @CHARCODE7
CMP SI,$0036 {---right shift---}
JZ @CHARCODE7
TEST BYTE PTR TOETS[CS:SI],$03
JNZ @CHARCODE1
@CHARCODE7: INC SI
CMP SI,+$80
JB @CHARCODE2
@CHARCODE3: STI
PUSH CX
MOV CX,$0800
@CHARCODE4: DEC CX
JNZ @CHARCODE4
POP CX
JMP GETCHARCODE
@CHARCODE1: MOV BYTE PTR TOETS[CS:SI],$80
SHL SI,1
MOV AX,WORD PTR BIOSCODE[CS:SI]
CMP AL,$FF
JZ @CHARCODE3
TEST BYTE PTR TOETS[CS:$2A],$03 {---left shift---}
JNZ @CHARCODE5
TEST BYTE PTR TOETS[CS:$36],$03 {---right shift---}
JZ @CHARCODE6
@CHARCODE5: MOV AL,AH
@CHARCODE6: STI
END;
{---[inputword; ret carry clear if successful; AX=word]---------------------}
PROCEDURE INPUTWORD; ASSEMBLER;
ASM;
MOV BL,$0E
MOV AL,$7F
CALL PRINTCHAR
SUB BX,BX
@INPUTW2: CALL GETCHARCODE
CMP AL,$0D
JZ @INPUTW6
CMP AL,$1B
JZ @INPUTW7
CMP AL,$08
JNZ @INPUTW8
OR BL,BL
JZ @INPUTW2
PUSH BX
DEC BYTE PTR [CS:CURSORX]
MOV BL,$0E
MOV AL,' '
CALL PRINTCHAR
SUB BYTE PTR [CS:CURSORX],$02
MOV AL,$7F
CALL PRINTCHAR
POP BX
DEC BL
JMP @INPUTW2
@INPUTW8: MOV CL,AL
CMP AL,'0'
JB @INPUTW2
CMP AL,'9'
JBE @INPUTW5
CMP AL,'A'
JB @INPUTW2
CMP AL,'F'
JA @INPUTW2
SUB AL,$07
@INPUTW5: SUB AL,'0'
CMP BL,$04
JAE @INPUTW2
MOV BYTE PTR DECNUM[CS:BX],AL
PUSH BX
DEC BYTE PTR [CS:CURSORX]
MOV BL,$0E
MOV AL,CL
AND AL,$3F
CALL PRINTCHAR
MOV AL,$7F
CALL PRINTCHAR
POP BX
INC BL
JMP @INPUTW2
@INPUTW6: OR BL,BL
JZ @INPUTW7
SUB AX,AX
SUB DI,DI
@INPUTW10: SHL BYTE PTR DECNUM[CS:DI],4
MOV CX,$0004
@INPUTW9: SHL BYTE PTR DECNUM[CS:DI],1
RCL AX,1
LOOP @INPUTW9
INC DI
DEC BL
JNZ @INPUTW10
CLC
RETN
@INPUTW7: TEST BYTE PTR TOETS[CS:$01],$03
JNZ @INPUTW7
STC
END;
{---[inputstring; CL=length; DS:DI-->buf; ret carry clear if successful]----}
PROCEDURE INPUTSTRING; ASSEMBLER;
ASM;
PUSH ES
PUSH DI
PUSH CX
MOV CH,$00
MOV AX,DS
MOV ES,AX
MOV AL,$00
REPZ
STOSB
POP CX
POP DI
POP ES
MOV BL,$0E
MOV AL,$7F
CALL PRINTCHAR
SUB BX,BX
@INPUTS2: CALL GETCHARCODE
CMP AL,$0D
JZ @INPUTS6
CMP AL,$1B
JZ @INPUTS7
CMP AL,$08
JNZ @INPUTS8
OR BL,BL
JZ @INPUTS2
PUSH BX
DEC BYTE PTR [CS:CURSORX]
MOV BL,$0E
MOV AL,' '
CALL PRINTCHAR
SUB BYTE PTR [CS:CURSORX],$02
MOV AL,$7F
CALL PRINTCHAR
POP BX
DEC BL
JMP @INPUTS2
@INPUTS8: CMP AL,' '
JB @INPUTS2
CMP AL,$60
JAE @INPUTS2
CMP BL,CL
JAE @INPUTS2
MOV BYTE PTR [DI+BX],AL
PUSH BX
DEC BYTE PTR [CS:CURSORX]
MOV BL,$0E
AND AL,$3F
CALL PRINTCHAR
MOV AL,$7F
CALL PRINTCHAR
POP BX
INC BL
JMP @INPUTS2
@INPUTS6: OR BL,BL
JZ @INPUTS7
@INPUTS3: CMP BL,CL
JAE @INPUTS1
MOV BYTE PTR [DI+BX],$00
INC BL
JMP @INPUTS3
@INPUTS1: CLC
RETN
@INPUTS7: STC
END;
{---[checkexittape]---------------------------------------------------------}
PROCEDURE CHECKEXITTAPE; ASSEMBLER;
ASM;
TEST BYTE PTR TOETS[CS:$42],$03 {---f8---}
JNZ @TAPE93
TEST BYTE PTR TOETS[CS:$44],$03 {---f10---}
JNZ @TAPE91
TEST BYTE PTR TOETS[CS:$57],$03 {---f11---}
JNZ @TAPE92
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JZ @TAPE7
TEST BYTE PTR TOETS[CS:$18],$03 {---o---}
JZ @TAPE6
@TAPE91: MOV AL,$02
RETN
@TAPE6: TEST BYTE PTR TOETS[CS:$32],$03 {---m---}
JZ @TAPE94
@TAPE92: MOV AL,$03
RETN
@TAPE94: TEST BYTE PTR TOETS[CS:$20],$03 {---d---}
JZ @TAPE7
@TAPE93: MOV AL,$04
RETN
@TAPE7: TEST BYTE PTR TOETS[CS:$01],$03 {---escape---}
JZ @TAPE8
MOV AL,$00
RETN
@TAPE8: MOV AL,$FF
END;
{---[resetandload_ofs (word; holds offset for forward jump into main part)]-}
PROCEDURE RESETANDLOAD_OFS; ASSEMBLER;
ASM;
DB $00
END;
{---[lasttape (word)]-------------------------------------------------------}
PROCEDURE LASTTAPE; ASSEMBLER;
ASM;
DW $0000
END;
{---[vanaftape (word)]------------------------------------------------------}
PROCEDURE VANAFTAPE; ASSEMBLER;
ASM;
DW $0000
END;
{---[lastdisk (word)]-------------------------------------------------------}
PROCEDURE LASTDISK; ASSEMBLER;
ASM;
DW $0000
END;
{---[vanafdisk (word)]------------------------------------------------------}
PROCEDURE VANAFDISK; ASSEMBLER;
ASM;
DW $0000
END;
{---[vanafatm (word)]-------------------------------------------------------}
PROCEDURE VANAFATM; ASSEMBLER;
ASM;
DW $0000
END;
{---[lastatm (word)]--------------------------------------------------------}
PROCEDURE LASTATM; ASSEMBLER;
ASM;
DW $0000
END;
{---[vanafimp (word)]-------------------------------------------------------}
PROCEDURE VANAFIMP; ASSEMBLER;
ASM;
DW $0000
END;
{---[lastimp (word)]--------------------------------------------------------}
PROCEDURE LASTIMP; ASSEMBLER;
ASM;
DW $0000
END;
{---[importcode (word)]-----------------------------------------------------}
PROCEDURE IMPORTCODE; ASSEMBLER;
ASM;
DW $0000
END;
{---[showdir (AL=00:tape; AL=01:disk)]--------------------------------------}
PROCEDURE SHOWDIR; ASSEMBLER;
ASM;
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
OR AL,AL
JNZ @SHOWDIR6
MOV AX,WORD PTR [CS:VANAFTAPE]
MOV BX,WORD PTR AANTALTAPEIMAGES
MOV CX,OFFSET TAPEIMAGES
JMP @SHOWDIR5
@SHOWDIR6: MOV AX,WORD PTR [CS:VANAFDISK]
MOV BX,WORD PTR AANTALDISKIMAGES
MOV CX,OFFSET DISKIMAGES
@SHOWDIR5: MOV WORD PTR @VANAF,AX
MOV WORD PTR @AANTALIMAGES,BX
MOV WORD PTR @OFSIMAGES,CX
MOV BYTE PTR [CS:CURSORY],+3
MOV AX,WORD PTR @VANAF
@SHOWDIR4: PUSH AX
MOV BYTE PTR [CS:CURSORX],+0
CMP AX,WORD PTR @AANTALIMAGES
JAE @SHOWDIR1
MOV CX,STR8GROOTTE
MUL CX
ADD AX,WORD PTR @OFSIMAGES
MOV SI,AX
LODSB
OR AL,AL
JZ @SHOWDIR1
MOV AH,$00
MOV CX,AX
MOV BL,$0E
@SHOWDIR2: LODSB
AND AL,$3F
CALL PRINTCHAR
LOOP @SHOWDIR2
@SHOWDIR1: CMP BYTE PTR [CS:CURSORX],+8
JAE @SHOWDIR3
MOV AL,' '
CALL PRINTCHAR
JMP @SHOWDIR1
@SHOWDIR3: POP AX
INC AX
INC BYTE PTR [CS:CURSORY]
CMP BYTE PTR [CS:CURSORY],+18
JB @SHOWDIR4
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
POP DS
RETN
@VANAF: DW $0000
@AANTALIMAGES: DW $0000
@OFSIMAGES: DW $0000
END;
{---[showatmfiles]----------------------------------------------------------}
PROCEDURE SHOWATMFILES; ASSEMBLER;
ASM;
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV BYTE PTR [CS:CURSORY],+3
MOV AX,WORD PTR [CS:VANAFATM]
@SHOWATM4: PUSH AX
MOV BYTE PTR [CS:CURSORX],+9
CMP AX,WORD PTR AANTALATOMFILES
JAE @SHOWATM6
MOV CX,ATMRECGROOTTE
MUL CX
ADD AX,OFFSET ATOMFILES
MOV SI,AX
PUSH SI
MOV CX,$0010
@SHOWATM2: MOV BL,$0E
LODSB
OR AL,AL
JZ @SHOWATM1
CMP AL,'a'
JB @SHOWATM11
CMP AL,'z'
JA @SHOWATM11
SUB AL,'a'-'A'
MOV BL,$0C
@SHOWATM11: AND AL,$3F
CALL PRINTCHAR
LOOP @SHOWATM2
@SHOWATM1: MOV BL,$0E
CMP BYTE PTR [CS:CURSORX],+26
JAE @SHOWATM3
MOV AL,' '
CALL PRINTCHAR
JMP @SHOWATM1
@SHOWATM3: POP SI
ADD SI,+$10
LODSW
CMP AX,$FFFF
JZ @SHOWATM8
@SHOWATM10: CALL PRINTWORD
MOV AL,' '
CALL PRINTCHAR
LODSW
CALL PRINTWORD
JMP @SHOWATM9
@SHOWATM8: CMP WORD PTR [SI],$FFFC {not (freeze version)}
JB @SHOWATM10
MOV AL,'-'
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
MOV AL,' '
CALL PRINTCHAR
MOV AL,'-'
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
ADD SI,+$02
@SHOWATM9: MOV AL,' '
CALL PRINTCHAR
LODSW
CALL PRINTWORD
JMP @SHOWATM5
@SHOWATM6: MOV CX,+31
MOV AL,' '
@SHOWATM7: CALL PRINTCHAR
LOOP @SHOWATM7
@SHOWATM5: POP AX
INC AX
CMP BYTE PTR [CS:CURSORY],+18
JB @SHOWATM4
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
POP DS
END;
{---[showimpfiles]----------------------------------------------------------}
PROCEDURE SHOWIMPFILES; ASSEMBLER;
ASM;
MOV AX,WORD PTR [CS:LASTIMP]
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP AX,WORD PTR AANTALIMPFILES
POP DS
JBE @SHOWIMP11
SUB AX,AX
MOV WORD PTR [CS:LASTIMP],AX
@SHOWIMP11: CMP AX,WORD PTR [CS:VANAFIMP]
JAE @SHOWIMP12
MOV WORD PTR [CS:VANAFIMP],AX
JMP @SHOWIMP13
@SHOWIMP12: MOV AX,WORD PTR [CS:VANAFIMP]
ADD AX,+15
CMP WORD PTR [CS:LASTIMP],AX
JB @SHOWIMP13
INC WORD PTR [CS:VANAFIMP]
JMP @SHOWIMP12
@SHOWIMP13: PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV BYTE PTR [CS:CURSORY],+3
MOV AX,WORD PTR [CS:VANAFIMP]
@SHOWIMP4: PUSH AX
MOV BYTE PTR [CS:CURSORX],+9
CMP AX,WORD PTR AANTALIMPFILES
JAE @SHOWIMP6
MOV CX,ATMRECGROOTTE
MUL CX
ADD AX,OFFSET IMPFILES
MOV SI,AX
PUSH SI
MOV BL,$0E
MOV CX,$0010
@SHOWIMP2: LODSB
OR AL,AL
JZ @SHOWIMP1
AND AL,$3F
CALL PRINTCHAR
LOOP @SHOWIMP2
@SHOWIMP1: CMP BYTE PTR [CS:CURSORX],+26
JAE @SHOWIMP3
MOV AL,' '
CALL PRINTCHAR
JMP @SHOWIMP1
@SHOWIMP3: POP SI
ADD SI,+$10
LODSW
CMP AX,$FFFF
JZ @SHOWIMP8
@SHOWIMP10: CALL PRINTWORD
MOV AL,' '
CALL PRINTCHAR
LODSW
CALL PRINTWORD
JMP @SHOWIMP9
@SHOWIMP8: CMP WORD PTR [SI],$FFFF
JNZ @SHOWIMP10
MOV AL,'-'
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
MOV AL,' '
CALL PRINTCHAR
MOV AL,'-'
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
ADD SI,+$02
@SHOWIMP9: MOV AL,' '
CALL PRINTCHAR
LODSW
CALL PRINTWORD
JMP @SHOWIMP5
@SHOWIMP6: MOV CX,+31
MOV AL,' '
@SHOWIMP7: CALL PRINTCHAR
LOOP @SHOWIMP7
@SHOWIMP5: POP AX
INC AX
CMP BYTE PTR [CS:CURSORY],+18
JB @SHOWIMP4
POP DS
MOV AX,WORD PTR [CS:LASTIMP]
SUB AX,WORD PTR [CS:VANAFIMP]
MOV CX,+10*$0120
MUL CX
ADD AX,+30*$0120+$0140+12*4+9*4
MOV DI,AX
MOV CX,+31
MOV AL,$09
CALL XORPUT
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
END;
{---[bottomln2]-------------------------------------------------------------}
PROCEDURE BOTTOMLN2; ASSEMBLER;
ASM;
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
MOV DI,+20*$0120+$0140+12*4
MOV CX,+40
MOV AL,$0B
CALL XORPUT
END;
{---[tapebottomln]----------------------------------------------------------}
PROCEDURE TAPEBOTTOMLN; ASSEMBLER;
ASM;
CMP BYTE PTR [CS:TAPESCREEN],$00
JNZ @BOTTOMLN1
CALL PRINTSTRING
DB +0,+18,$0F,'OPEN NEW ',$00
MOV AL,'O' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
CALL PRINTCHAR
MOV AL,'N' AND $3F
MOV BYTE PTR [CS:CURSORX],+6
CALL PRINTCHAR
JMP BOTTOMLN2
@BOTTOMLN1: CALL PRINTSTRING
DB +0,+18,$0F,'SET LOAD REN IMPORT EXPORT DEL FREEZE',$00
MOV AL,'S' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
CALL PRINTCHAR
MOV AL,'L' AND $3F
MOV BYTE PTR [CS:CURSORX],+4
CALL PRINTCHAR
MOV AL,'R' AND $3F
MOV BYTE PTR [CS:CURSORX],+9
CALL PRINTCHAR
MOV AL,'I' AND $3F
MOV BYTE PTR [CS:CURSORX],+13
CALL PRINTCHAR
MOV AL,'E' AND $3F
MOV BYTE PTR [CS:CURSORX],+20
CALL PRINTCHAR
MOV AL,'D' AND $3F
MOV BYTE PTR [CS:CURSORX],+27
CALL PRINTCHAR
MOV AL,'F' AND $3F
MOV BYTE PTR [CS:CURSORX],+31
CALL PRINTCHAR
JMP BOTTOMLN2
END;
{---[newtapefile]-----------------------------------------------------------}
PROCEDURE NEWTAPEFILE; ASSEMBLER;
ASM;
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,DS
MOV ES,AX
MOV AX,WORD PTR [CS:LASTTAPE]
MOV CX,STR8GROOTTE
MUL CX
ADD AX,OFFSET TAPEIMAGES
MOV SI,AX
MOV DI,OFFSET TAPEIMAGENAME
MOV CX,STR8GROOTTE
REPZ
MOVSB
CALL READFILESINTAPEIMAGE
POP DS
POP ES
MOV WORD PTR [CS:LASTATM],$0000
END;
{---[showall1tape]----------------------------------------------------------}
PROCEDURE SHOWALL1TAPE; ASSEMBLER;
ASM;
MOV AX,WORD PTR [CS:LASTTAPE]
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP AX,WORD PTR AANTALTAPEIMAGES
POP DS
JBE @SHOWALL7
SUB AX,AX
MOV WORD PTR [CS:LASTTAPE],AX
@SHOWALL7: CMP AX,WORD PTR [CS:VANAFTAPE]
JAE @SHOWALL3
MOV WORD PTR [CS:VANAFTAPE],AX
JMP @SHOWALL4
@SHOWALL3: MOV AX,WORD PTR [CS:VANAFTAPE]
ADD AX,+15
CMP WORD PTR [CS:LASTTAPE],AX
JB @SHOWALL4
INC WORD PTR [CS:VANAFTAPE]
JMP @SHOWALL3
@SHOWALL4: MOV AL,$00
CALL SHOWDIR
MOV AX,WORD PTR [CS:LASTTAPE]
SUB AX,WORD PTR [CS:VANAFTAPE]
MOV CX,+10*$0120
MUL CX
ADD AX,+30*$0120+$0140+12*4
MOV DI,AX
MOV CX,+8
MOV AL,$08
CALL XORPUT
END;
{---[showall2]--------------------------------------------------------------}
PROCEDURE SHOWALL2; ASSEMBLER;
ASM;
MOV AX,WORD PTR [CS:LASTATM]
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP AX,WORD PTR AANTALATOMFILES
POP DS
JBE @SHOWALL8
SUB AX,AX
MOV WORD PTR [CS:LASTATM],AX
@SHOWALL8: CMP AX,WORD PTR [CS:VANAFATM]
JAE @SHOWALL5
MOV WORD PTR [CS:VANAFATM],AX
JMP @SHOWALL6
@SHOWALL5: MOV AX,WORD PTR [CS:VANAFATM]
ADD AX,+15
CMP WORD PTR [CS:LASTATM],AX
JB @SHOWALL6
INC WORD PTR [CS:VANAFATM]
JMP @SHOWALL5
@SHOWALL6: CALL SHOWATMFILES
CMP BYTE PTR [CS:TAPESCREEN],$00
JZ @SHOWALL9
MOV AX,WORD PTR [CS:LASTATM]
SUB AX,WORD PTR [CS:VANAFATM]
MOV CX,+10*$0120
MUL CX
ADD AX,+30*$0120+$0140+12*4+9*4
MOV DI,AX
MOV CX,+31
MOV AL,$0A
CALL XORPUT
@SHOWALL9:
END;
{---[showall1disk]----------------------------------------------------------}
PROCEDURE SHOWALL1DISK; ASSEMBLER;
ASM;
MOV AX,WORD PTR [CS:LASTDISK]
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP AX,WORD PTR AANTALDISKIMAGES
POP DS
JBE @SHOWALL7
SUB AX,AX
MOV WORD PTR [CS:LASTDISK],AX
@SHOWALL7: CMP AX,WORD PTR [CS:VANAFDISK]
JAE @SHOWALL3
MOV WORD PTR [CS:VANAFDISK],AX
JMP @SHOWALL4
@SHOWALL3: MOV AX,WORD PTR [CS:VANAFDISK]
ADD AX,+15
CMP WORD PTR [CS:LASTDISK],AX
JB @SHOWALL4
INC WORD PTR [CS:VANAFDISK]
JMP @SHOWALL3
@SHOWALL4: MOV AL,$01
CALL SHOWDIR
MOV AX,WORD PTR [CS:LASTDISK]
SUB AX,WORD PTR [CS:VANAFDISK]
MOV CX,+10*$0120
MUL CX
ADD AX,+30*$0120+$0140+12*4
MOV DI,AX
MOV CX,+8
MOV AL,$09
CALL XORPUT
END;
{---[disk (desktop)]--------------------------------------------------------}
PROCEDURE DISK; ASSEMBLER;
ASM;
MOV DS,WORD PTR [CS:DATASEG]
MOV DI,+10*$0120+$0140+12*4
MOV CX,+4
MOV AL,$0B
CALL XORPUT
@DISK28: MOV DI,+20*$0120+$0140
MOV CX,+168*$0120/4
@DISK1: MOV AX,$00FF
STOSW
MOV AX,$FFFF
STOSW
LOOP @DISK1
MOV AX,CS
MOV DS,AX
CALL PRINTSTRING
DB +0,+18,$0F,'OPEN NEW SAVE DRIVE PROTECT',$00
MOV AL,'O' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
MOV BYTE PTR [CS:CURSORY],+18
CALL PRINTCHAR
MOV AL,'N' AND $3F
MOV BYTE PTR [CS:CURSORX],+6
CALL PRINTCHAR
MOV AL,'S' AND $3F
MOV BYTE PTR [CS:CURSORX],+11
CALL PRINTCHAR
MOV AL,'P' AND $3F
MOV BYTE PTR [CS:CURSORX],+32
CALL PRINTCHAR
CALL PRINTSTRING
DB +23,+18,$09,'0 1 2 3',$00
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
CALL PRINTSTRING
DB +0,+2,$0C,'DISKIMG',$00
MOV DI,+20*$0120+12*4+8*4+$0140
MOV CX,+16*10-1
@DISK10: AND WORD PTR [ES:DI+$02],$FCFC
ADD DI,$0120
LOOP @DISK10
MOV AX,$FFFF
MOV DI,+29*$0120+$0140+12*4
MOV CX,+9
@DISK11: STOSW
INC AX
STOSW
DEC AX
LOOP @DISK11
CALL PRINTSTRING
DB +12,+5,$0C,'DRIVE 0:',$00
CALL PRINTSTRING
DB +12,+8,$0C,'DRIVE 1:',$00
CALL PRINTSTRING
DB +12,+11,$0C,'DRIVE 2:',$00
CALL PRINTSTRING
DB +12,+14,$0C,'DRIVE 3:',$00
CALL @XORPUTDRV
MOV AL,$01
CALL SHOWALL1DISK
CALL @SHOWDISKETTES
@DISK35: MOV AL,BYTE PTR TOETS[CS:$18] {---o---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
OR AL,BYTE PTR TOETS[CS:$19] {---p---}
AND AL,$03
JNZ @DISK35
@DISK2: TEST BYTE PTR TOETS[CS:$0B],$03 {---0---}
JZ @DISK12
CMP BYTE PTR @DRIVE,$00
JZ @DISK12
CALL @XORPUTDRV
MOV BYTE PTR @DRIVE,$00
CALL @XORPUTDRV
JMP @DISK2
@DISK12: MOV BX,$0001
@DISK14: TEST BYTE PTR TOETS[CS:BX+$01],$03 {---1/2/3---}
JZ @DISK13
CMP BYTE PTR @DRIVE,BL
JZ @DISK13
CALL @XORPUTDRV
MOV BYTE PTR @DRIVE,BL
CALL @XORPUTDRV
JMP @DISK2
@DISK13: INC BL
CMP BL,$03
JBE @DISK14
TEST BYTE PTR TOETS[CS:$0F],$03 {---tab---}
JZ @DISK36
MOV AL,BYTE PTR TOETS[CS:$2A] {---left shift---}
OR AL,BYTE PTR TOETS[CS:$36] {---right shift---}
AND AL,$03
JNZ @DISK37
CALL @XORPUTDRV
INC BYTE PTR @DRIVE
@DISK39: AND BYTE PTR @DRIVE,$03
CALL @XORPUTDRV
MOV BL,$0F {---tab---}
CALL KEYRELEASE
JMP @DISK2
@DISK37: CALL @XORPUTDRV
DEC BYTE PTR @DRIVE
JMP @DISK39
@DISK36: TEST BYTE PTR TOETS[CS:$1F],$03 {---s---}
JZ @DISK15
{---save ini-file---}
CALL PRINTSTRING
DB +24,+16,$0B,'WRITING INI-FILE',$00
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEINIFILE
POP DS
POP ES
@DISK16: TEST BYTE PTR TOETS[CS:$1F],$03 {---s---}
JNZ @DISK16
CALL PRINTSTRING
DB +24,+16,$0B,' ',$00
JMP @DISK2
@DISK15: TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @DISK17
CMP WORD PTR [CS:LASTDISK],+$00
JZ @DISK2
DEC WORD PTR [CS:LASTDISK]
MOV AL,$01
CALL SHOWALL1DISK
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @DISK2
@DISK17: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @DISK18
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALDISKIMAGES
POP DS
CMP WORD PTR [CS:LASTDISK],AX
JAE @DISK2
INC WORD PTR [CS:LASTDISK]
MOV AL,$01
CALL SHOWALL1DISK
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @DISK2
@DISK18: TEST BYTE PTR TOETS[CS:$49],$03 {---page up---}
JZ @DISK20
CMP WORD PTR [CS:LASTDISK],+$00
JZ @DISK2
SUB WORD PTR [CS:LASTDISK],+14
JNC @DISK19
MOV WORD PTR [CS:LASTDISK],$0000
@DISK19: MOV AL,$01
CALL SHOWALL1DISK
MOV BL,$49 {---page up---}
CALL KEYRELEASE
JMP @DISK2
@DISK20: TEST BYTE PTR TOETS[CS:$51],$03 {---page down---}
JZ @DISK22
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALDISKIMAGES
POP DS
CMP WORD PTR [CS:LASTDISK],AX
JAE @DISK2
ADD WORD PTR [CS:LASTDISK],+14
CMP WORD PTR [CS:LASTDISK],AX
JB @DISK21
MOV WORD PTR [CS:LASTDISK],AX
@DISK21: MOV AL,$01
CALL SHOWALL1DISK
MOV BL,$51 {---page down---}
CALL KEYRELEASE
JMP @DISK2
@DISK22: TEST BYTE PTR TOETS[CS:$31],$03 {---n---}
JZ @DISK23
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+8
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+16
MOV AL,01001100b
@DISK24: CALL PRINTCHAR
LOOP @DISK24
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +12,+9,$0C,' NEW DISK IMAGE ',$00
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010101b
CALL PRINTCHAR
MOV CX,+16
MOV AL,' '
@DISK25: CALL PRINTCHAR
LOOP @DISK25
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+11
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+16
MOV AL,01001100b
@DISK26: CALL PRINTCHAR
LOOP @DISK26
MOV AL,01101000b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+16
MOV BYTE PTR [CS:CURSORY],+10
MOV BL,$31 {---n---}
CALL KEYRELEASE
PUSH DS
MOV AX,CS
MOV DS,AX
MOV DI,OFFSET FILENAMEBUF
MOV CL,$08
CALL INPUTSTRING
POP DS
JC @DISK27
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH CS {---segment of newname---}
PUSH OFFSET FILENAMEBUF {---offset of newname---}
PUSH CS {---segment of [CS:LASTDISK]---}
PUSH OFFSET [CS:LASTDISK] {---offset of [CS:LASTDISK]---}
CALL CREATEDISKFILE
POP DS
POP ES
@DISK27: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @DISK27
JMP @DISK28
@DISK23: TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JNZ @DISK29
MOV AL,BYTE PTR TOETS[CS:$18] {---o---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JZ @DISK29
SUB DI,DI
MOV AX,WORD PTR [CS:LASTDISK]
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP AX,WORD PTR AANTALDISKIMAGES
POP DS
JZ @DISK38
@DISK32: MOV BX,DI
SHR BL,1
CMP BL,BYTE PTR @DRIVE
JZ @DISK31
PUSH AX
PUSH DI
CALL @COMPAREDRIVE
POP DI
POP AX
JZ @DISK34
@DISK31: ADD DI,+$02
CMP DI,+$06
JBE @DISK32
JMP @DISK33
@DISK34: CALL ERRORSND
JMP @DISK28
@DISK38: MOV AL,BYTE PTR @DRIVE
MOV CL,+14
MUL CL
MOV DI,AX
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
MOV BYTE PTR DISKETTENAMES[DI],$00
MOV AL,BYTE PTR @DRIVE
MOV AH,$00
PUSH AX {drive#}
CALL CLOSE_DISK_IMAGE
POPA
POP ES
POP DS
JMP @DISK28
@DISK33: MOV AL,BYTE PTR @DRIVE
MOV CL,+14
MUL CL
MOV DI,AX
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP BYTE PTR DISKETTENAMES[DI],$00
POP DS
JZ @DISK30
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
MOV AL,BYTE PTR @DRIVE
MOV AH,$00
PUSH AX {drive#}
CALL CLOSE_DISK_IMAGE
POPA
POP ES
POP DS
@DISK30: PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
MOV AL,BYTE PTR @DRIVE
MOV CL,+14
MUL CL
MOV BX,AX
MOV AX,WORD PTR [CS:LASTDISK]
MOV DI,AX
SHL AX,3
ADD AX,OFFSET DISKIMAGES
ADD DI,AX
MOV CX,+9
@DISK42: MOV AL,BYTE PTR [DI]
MOV BYTE PTR DISKETTENAMES[BX],AL
INC DI
INC BX
LOOP @DISK42
CALL COPYWRITEPROT
MOV CL,BYTE PTR @DRIVE
MOV CH,$00
PUSH CX {drive#}
MOV BL,CL
AND BX,$0001
MOV AL,BYTE PTR WRITEPROTECT[BX]
AND CL,$02
SHL CL,1
SHR AL,CL
AND AX,$0001
PUSH AX {read/write}
CALL OPEN_DISK_IMAGE
POPA
POP ES
POP DS
JMP @DISK28
@DISK29: TEST BYTE PTR TOETS[CS:$19],$03 {---p---}
JZ @DISK40
MOV AL,BYTE PTR @DRIVE
MOV CL,+14
MUL CL
MOV BX,AX
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CMP BYTE PTR DISKETTENAMES[BX],$00
POP DS
JZ @DISK40
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
MOV AL,BYTE PTR @DRIVE
MOV AH,$00
PUSH AX {drive#}
CALL CLOSE_DISK_IMAGE
MOV AL,BYTE PTR @DRIVE
MOV CL,+14
MUL CL
ADD AX,OFFSET DISKETTENAMES
MOV SI,AX
LODSB
MOV DX,SI
MOV AH,$00
ADD SI,AX
MOV WORD PTR [SI],'D.'
MOV WORD PTR [SI+$02],'KS'
MOV BYTE PTR [SI+$04],$00
MOV AX,$4300
PUSH DX
INT $21 {---get file attributes---}
POP DX
JC @DISK41
XOR CL,READONLY {---toggle read only---}
MOV AX,$4301
INT $21 {---set file attributes---}
@DISK41: CALL COPYWRITEPROT
MOV CL,BYTE PTR @DRIVE
MOV CH,$00
PUSH CX {drive#}
MOV BL,CL
AND BX,$0001
MOV AL,BYTE PTR WRITEPROTECT[BX]
AND CL,$02
SHL CL,1
SHR AL,CL
AND AX,$0001
PUSH AX {read/write}
CALL OPEN_DISK_IMAGE
POPA
POP ES
POP DS
JMP @DISK28
@DISK40: TEST BYTE PTR TOETS[CS:$43],$03 {---f9---}
JNZ @DISK3
TEST BYTE PTR TOETS[CS:$44],$03 {---f10---}
JNZ @DISK4
TEST BYTE PTR TOETS[CS:$57],$03 {---f11---}
JNZ @DISK5
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JZ @DISK6
TEST BYTE PTR TOETS[CS:$14],$03 {---t---}
JZ @DISK7
@DISK3: MOV AL,$01
JMP @DISK9
@DISK7: TEST BYTE PTR TOETS[CS:$18],$03 {---o---}
JZ @DISK8
@DISK4: MOV AL,$02
JMP @DISK9
@DISK8: TEST BYTE PTR TOETS[CS:$32],$03 {---m---}
JZ @DISK6
@DISK5: MOV AL,$03
JMP @DISK9
@DISK6: TEST BYTE PTR TOETS[CS:$01],$03 {---escape---}
JZ @DISK2
MOV AL,$00
@DISK9: PUSH AX
MOV DI,+10*$0120+$0140+12*4
MOV CX,+4
MOV AL,$0B
CALL XORPUT
POP AX
RETN
@XORPUTDRV: MOV AL,BYTE PTR @DRIVE
MOV CL,+30
MUL CL
MOV CX,$0120
MUL CX
ADD AX,+50*$0120+$0140+92
MOV DI,AX
MOV AL,$0A
MOV CX,+25
CALL XORPUT
RETN
@SHOWDISKETTES:CALL @XORPUTDRV
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
SUB DI,DI
@SHOWDSK1: MOV BYTE PTR [CS:CURSORX],+23
MOV AX,DI
MOV AH,AL
SHL AL,1
ADD AL,AH
ADD AL,+5
MOV BYTE PTR [CS:CURSORY],AL
MOV AX,DI
MOV CL,+14
MUL CL
ADD AX,OFFSET DISKETTENAMES
MOV SI,AX
LODSB
OR AL,AL
JZ @SHOWDSK4
MOV CL,AL
@SHOWDSK3: LODSB
AND AL,$3F
MOV BL,$0E
CALL PRINTCHAR
DEC CL
JNZ @SHOWDSK3
MOV CX,DI
MOV BL,CL
AND BX,$0001
MOV AL,BYTE PTR WRITEPROTECT[BX]
AND CL,$02
SHL CL,1
SHR AL,CL
AND AL,$01
MOV AL,' '
JZ @SHOWDSK7
MOV AL,'#'
@SHOWDSK7: MOV BYTE PTR [CS:CURSORX],+34
MOV BL,$0F
CALL PRINTCHAR
JMP @SHOWDSK2
@SHOWDSK4: MOV CX,$0008
@SHOWDSK5: MOV AL,'-'
MOV BL,$0E
CALL PRINTCHAR
LOOP @SHOWDSK5
@SHOWDSK2: INC DI
CMP DI,+$03
JBE @SHOWDSK1
POP DS
CALL @XORPUTDRV
RETN
@COMPAREDRIVE: {---BL=drive; AX=index in diskimages---}
PUSH DS
PUSH ES
MOV DS,WORD PTR [CS:DATASEG]
PUSH DS
POP ES
MOV SI,AX
SHL AX,3
ADD AX,OFFSET DISKIMAGES
ADD SI,AX
MOV AL,BL
MOV CL,+14
MUL CL
ADD AX,OFFSET DISKETTENAMES
MOV DI,AX
LODSB
SCASB
JNZ @COMPDR1
MOV CL,AL
@COMPDR2: CMPSB
JNZ @COMPDR1
DEC CL
JNZ @COMPDR2
@COMPDR1: POP ES
POP DS
RETN
@DRIVE: DB $00
END;
{---[tape (desktop)]--------------------------------------------------------}
PROCEDURE TAPE; ASSEMBLER;
ASM;
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEFOUTBUF
POPA
POP ES
POP DS
MOV DI,+20*$0120+$0140
MOV CX,+168*$0120/4
@TAPE5: MOV AX,$00FF
STOSW
MOV AX,$FFFF
STOSW
LOOP @TAPE5
MOV DI,+10*$0120+$0140+12*4+6*4
MOV CX,4
MOV AL,$0B
CALL XORPUT
CALL PRINTSTRING
DB +0,+2,$0C,'TAPEIMG ATOMFILE STRT EXEC SIZE',$00
MOV DI,+20*$0120+12*4+8*4+$0140
MOV CX,+16*10-1
@TAPE9: AND WORD PTR [ES:DI+$02],$FCFC
ADD DI,$0120
LOOP @TAPE9
MOV AX,$FFFF
MOV DI,+29*$0120+$0140+12*4
MOV CX,+40
@TAPE2: STOSW
INC AX
STOSW
DEC AX
LOOP @TAPE2
CMP BYTE PTR [CS:TAPESCREEN],$00
JNZ @TAPE10
MOV DI,+20*$0120+$0140+12*4+9*4
MOV CX,+31
JMP @TAPE11
@TAPE10: MOV DI,+20*$0120+$0140+12*4
MOV CX,+9
@TAPE11: MOV AL,$0B
CALL XORPUT
CALL SHOWALL1TAPE
CALL SHOWALL2
@TAPE19: CALL TAPEBOTTOMLN
CMP BYTE PTR [CS:TAPESCREEN],$00
JNZ @TAPE12
@TAPE15: {---cursor in directory screen---}
TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @TAPE14
CMP WORD PTR [CS:LASTTAPE],+$00
JZ @TAPE15
DEC WORD PTR [CS:LASTTAPE]
CALL NEWTAPEFILE
CALL SHOWALL1TAPE
CALL SHOWALL2
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @TAPE15
@TAPE14: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @TAPE13
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALTAPEIMAGES
POP DS
CMP WORD PTR [CS:LASTTAPE],AX
JAE @TAPE15
INC WORD PTR [CS:LASTTAPE]
CALL NEWTAPEFILE
CALL SHOWALL1TAPE
CALL SHOWALL2
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @TAPE15
@TAPE13: TEST BYTE PTR TOETS[CS:$49],$03 {---page up---}
JZ @TAPE68
CMP WORD PTR [CS:LASTTAPE],+$00
JZ @TAPE15
SUB WORD PTR [CS:LASTTAPE],+14
JNC @TAPE67
MOV WORD PTR [CS:LASTTAPE],$0000
@TAPE67: CALL NEWTAPEFILE
CALL SHOWALL1TAPE
CALL SHOWALL2
MOV BL,$49 {---page up---}
CALL KEYRELEASE
JMP @TAPE15
@TAPE68: TEST BYTE PTR TOETS[CS:$51],$03 {---page down---}
JZ @TAPE69
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALTAPEIMAGES
POP DS
CMP WORD PTR [CS:LASTTAPE],AX
JAE @TAPE15
ADD WORD PTR [CS:LASTTAPE],+14
CMP WORD PTR [CS:LASTTAPE],AX
JB @TAPE70
MOV WORD PTR [CS:LASTTAPE],AX
@TAPE70: CALL NEWTAPEFILE
CALL SHOWALL1TAPE
CALL SHOWALL2
MOV BL,$51 {---page down---}
CALL KEYRELEASE
JMP @TAPE15
@TAPE69: TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JNZ @TAPE18
MOV AL,BYTE PTR TOETS[CS:$18] {---o---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
OR AL,BYTE PTR TOETS[CS:$4D] {---right---}
AND AL,$03
JZ @TAPE18
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALTAPEIMAGES
POP DS
CMP WORD PTR [CS:LASTTAPE],AX
JAE @TAPE15
MOV BYTE PTR [CS:TAPESCREEN],$01
CALL SHOWALL1TAPE
CALL SHOWALL2
@TAPE20: MOV BL,$1C {---enter---}
CALL KEYRELEASE
JNZ @TAPE20
JMP @TAPE19
@TAPE18: TEST BYTE PTR TOETS[CS:$31],$03 {---n---}
JZ @TAPE85
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+8
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+16
MOV AL,01001100b
@TAPE86: CALL PRINTCHAR
LOOP @TAPE86
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +12,+9,$0C,' NEW TAPE IMAGE ',$00
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010101b
CALL PRINTCHAR
MOV CX,+16
MOV AL,' '
@TAPE87: CALL PRINTCHAR
LOOP @TAPE87
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+11
MOV BYTE PTR [CS:CURSORY],+11
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+16
MOV AL,01001100b
@TAPE88: CALL PRINTCHAR
LOOP @TAPE88
MOV AL,01101000b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+16
MOV BYTE PTR [CS:CURSORY],+10
MOV BL,$31 {---n---}
CALL KEYRELEASE
PUSH DS
MOV AX,CS
MOV DS,AX
MOV DI,OFFSET FILENAMEBUF
MOV CL,$08
CALL INPUTSTRING
POP DS
JC @TAPE89
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH CS {---segment of newname---}
PUSH OFFSET FILENAMEBUF {---offset of newname---}
PUSH CS {---segment of [CS:LASTTAPE]---}
PUSH OFFSET [CS:LASTTAPE] {---offset of [CS:LASTTAPE]---}
CALL CREATETAPEFILE
POP DS
POP ES
@TAPE89: CALL SHOWALL1TAPE
CALL SHOWALL2
@TAPE90: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @TAPE90
JMP @TAPE15
@TAPE85: CALL CHECKEXITTAPE
CMP AL,$FF
JZ @TAPE15
PUSH AX
MOV DI,+10*$0120+$0140+12*4+6*4
MOV CX,4
MOV AL,$0B
CALL XORPUT
POP AX
RETN
@TAPE12: {---cursor in atom files screen---}
TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @TAPE21
CMP WORD PTR [CS:LASTATM],+$00
JZ @TAPE12
DEC WORD PTR [CS:LASTATM]
CALL SHOWALL2
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE21: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @TAPE23
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALATOMFILES
POP DS
CMP WORD PTR [CS:LASTATM],AX
JAE @TAPE12
INC WORD PTR [CS:LASTATM]
CALL SHOWALL2
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE23: TEST BYTE PTR TOETS[CS:$49],$03 {---page up---}
JZ @TAPE27
CMP WORD PTR [CS:LASTATM],+$00
JZ @TAPE12
SUB WORD PTR [CS:LASTATM],+14
JNC @TAPE29
MOV WORD PTR [CS:LASTATM],$0000
@TAPE29: CALL SHOWALL2
MOV BL,$49 {---page up---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE27: TEST BYTE PTR TOETS[CS:$51],$03 {---page down---}
JZ @TAPE28
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALATOMFILES
POP DS
CMP WORD PTR [CS:LASTATM],AX
JAE @TAPE12
ADD WORD PTR [CS:LASTATM],+14
CMP WORD PTR [CS:LASTATM],AX
JB @TAPE31
MOV WORD PTR [CS:LASTATM],AX
@TAPE31: CALL SHOWALL2
MOV BL,$51 {---page down---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE28: TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JNZ @TAPE25
MOV AL,BYTE PTR TOETS[CS:$14] {---t---}
OR AL,BYTE PTR TOETS[CS:$4B] {---left---}
AND AL,$03
JZ @TAPE25
MOV BYTE PTR [CS:TAPESCREEN],$00
CALL SHOWALL1TAPE
CALL SHOWALL2
JMP @TAPE19
@TAPE25: TEST BYTE PTR TOETS[CS:$26],$03 {---l---}
JZ @TAPE33
TEST BYTE PTR [CS:BRKPNTON],$FF
JNZ @TAPE33
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV ES,WORD PTR [CS:ATOMSEG]
MOV AX,WORD PTR [CS:LASTATM]
CMP AX,WORD PTR AANTALATOMFILES
JB @TAPE38
SUB AX,AX
MOV WORD PTR [CS:LASTATM],AX
@TAPE38: MOV CX,ATMRECGROOTTE
MUL CX
ADD AX,OFFSET ATOMFILES
MOV SI,AX
MOV DI,$0100
CMP WORD PTR [SI+$0010],$2900
JNZ @TAPE36
CMP WORD PTR [SI+$0012],$C2B2
JNZ @TAPE54
MOV AL,'L'
STOSB
MOV AL,'O'
JMP @TAPE37
@TAPE36: CMP WORD PTR [SI+$0012],$C2B2
JNZ @TAPE54
MOV AL,'*'
STOSB
MOV AL,'L'
JMP @TAPE37
@TAPE54: MOV AL,'*'
STOSB
MOV AL,'R'
@TAPE37: STOSB
MOV AL,'.'
STOSB
MOV AL,'"'
STOSB
MOV CX,$0010
@TAPE34: LODSB
OR AL,AL
JZ @TAPE35
STOSB
LOOP @TAPE34
@TAPE35: MOV AL,'"'
STOSB
MOV AL,$0D
STOSB
MOV AL,$0A
STOSB
POP DS
POP ES
ADD SP,+$04 {call TAPE and call @SHOWMENU}
JMP WORD PTR [CS:RESETANDLOAD_OFS]
@TAPE33: MOV AL,BYTE PTR TOETS[CS:$1F] {---s---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JZ @TAPE39
@TAPE40: MOV AL,BYTE PTR TOETS[CS:$1F] {---s---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @TAPE40
MOV AL,$00
RETN
@TAPE39: TEST BYTE PTR TOETS[CS:$21],$03 {---f---}
JZ @TAPE16
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CALL FREEZE
MOV AX,WORD PTR AANTALATOMFILES
MOV WORD PTR [CS:LASTATM],AX
POP DS
POP ES
CALL SHOWALL1TAPE
CALL SHOWALL2
MOV BL,$21 {---f---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE16: TEST BYTE PTR TOETS[CS:$20],$FF {---d---}
JZ @TAPE41
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALATOMFILES
POP DS
CMP WORD PTR [CS:LASTATM],AX
JAE @TAPE41
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+7
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@TAPE42: CALL PRINTCHAR
LOOP @TAPE42
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+8
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +11,+8,$0E,' DELETE FILE: ',$00
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
MOV AL,' '
CALL PRINTCHAR
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR [CS:LASTATM]
MOV CX,ATMRECGROOTTE
MUL CX
ADD AX,OFFSET ATOMFILES
MOV SI,AX
SUB BX,BX
@TAPE45: CMP BYTE PTR [SI+BX],$00
JZ @TAPE44
INC BL
CMP BL,$10
JB @TAPE45
@TAPE44: SHR BL,1
PUSHF
ADC BL,$00
MOV CH,$00
MOV CL,$08
SUB CL,BL
PUSH CX
JZ @TAPE84
MOV AL,' '
@TAPE46: CALL PRINTCHAR
LOOP @TAPE46
@TAPE84: MOV CL,$10
@TAPE48: LODSB
OR AL,AL
JZ @TAPE47
AND AL,$3F
MOV BL,$09
CALL PRINTCHAR
LOOP @TAPE48
@TAPE47: POP CX
POPF
ADC CL,$00
INC CL
MOV AL,' '
@TAPE49: CALL PRINTCHAR
LOOP @TAPE49
POP DS
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +11,+10,$0C,' YES OR NO? ',$00
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+11
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@TAPE43: CALL PRINTCHAR
LOOP @TAPE43
MOV AL,01101000b
CALL PRINTCHAR
@TAPE50: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$15] {---y---}
OR AL,BYTE PTR TOETS[CS:$31] {---n---}
AND AL,$03
JNZ @TAPE50
@TAPE52: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$31] {---n---}
AND AL,$03
JNZ @TAPE51
TEST BYTE PTR TOETS[CS:$15],$03 {---y---}
JZ @TAPE52
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH WORD PTR [CS:LASTATM] {---filenumber to be deleted---}
CALL DELETEFILE
POP DS
POP ES
@TAPE51: CALL SHOWALL1TAPE
CALL SHOWALL2
@TAPE53: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$15] {---y---}
OR AL,BYTE PTR TOETS[CS:$31] {---n---}
AND AL,$03
JNZ @TAPE53
JMP @TAPE12
@TAPE41: TEST BYTE PTR TOETS[CS:$12],$03 {---e---}
JZ @TAPE55
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALATOMFILES
POP DS
CMP WORD PTR [CS:LASTATM],AX
JAE @TAPE55
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH WORD PTR [CS:LASTATM] {---filenumber to be exported---}
CALL EXPORT
POP DS
POP ES
MOV BL,$12 {---e---}
CALL KEYRELEASE
JMP @TAPE12
@TAPE55: TEST BYTE PTR TOETS[CS:$17],$03 {---i---}
JZ @TAPE56
CALL PRINTSTRING
DB +0,+18,$0F,'SELECT ',$00
MOV AL,'S' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
CALL PRINTCHAR
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CALL READIMPORTABLEFILES
POP DS
POP ES
MOV WORD PTR [CS:LASTIMP],$0000
CALL SHOWIMPFILES
@TAPE57: TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @TAPE58
CMP WORD PTR [CS:LASTIMP],+$00
JZ @TAPE57
DEC WORD PTR [CS:LASTIMP]
CALL SHOWIMPFILES
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @TAPE57
@TAPE58: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @TAPE59
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALIMPFILES
POP DS
CMP WORD PTR [CS:LASTIMP],AX
JAE @TAPE57
INC WORD PTR [CS:LASTIMP]
CALL SHOWIMPFILES
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @TAPE57
@TAPE59: TEST BYTE PTR TOETS[CS:$49],$03 {---page up---}
JZ @TAPE60
CMP WORD PTR [CS:LASTIMP],+$00
JZ @TAPE57
SUB WORD PTR [CS:LASTIMP],+14
JNC @TAPE61
MOV WORD PTR [CS:LASTIMP],$0000
@TAPE61: CALL SHOWIMPFILES
MOV BL,$49 {---page up---}
CALL KEYRELEASE
JMP @TAPE57
@TAPE60: TEST BYTE PTR TOETS[CS:$51],$03 {---page down---}
JZ @TAPE62
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALIMPFILES
POP DS
CMP WORD PTR [CS:LASTIMP],AX
JAE @TAPE57
ADD WORD PTR [CS:LASTIMP],+14
CMP WORD PTR [CS:LASTIMP],AX
JB @TAPE63
MOV WORD PTR [CS:LASTIMP],AX
@TAPE63: CALL SHOWIMPFILES
MOV BL,$51 {---page down---}
CALL KEYRELEASE
JMP @TAPE57
@TAPE62: TEST BYTE PTR TOETS[CS:$01],$03
JZ @TAPE64
@TAPE65: TEST BYTE PTR TOETS[CS:$01],$03
JNZ @TAPE65
CALL SHOWALL2
CALL BOTTOMLN2
JMP @TAPE19
@TAPE64: MOV AL,BYTE PTR TOETS[CS:$1F] {---s---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JZ @TAPE57
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALIMPFILES
POP DS
CMP WORD PTR [CS:LASTIMP],AX
JAE @TAPE57
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH WORD PTR [CS:LASTATM] {---filepointer:where to import---}
PUSH WORD PTR [CS:LASTIMP] {---file to be imported---}
PUSH CS {---segment exitcode---}
PUSH OFFSET [CS:IMPORTCODE] {---offset exitcode---}
CALL IMPORT
POP DS
POP ES
TEST WORD PTR [CS:IMPORTCODE],$8000
JNZ @TAPE66
INC WORD PTR [CS:LASTATM]
@TAPE66: MOV AL,BYTE PTR TOETS[CS:$1F] {---s---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @TAPE66
CALL SHOWALL2
CALL BOTTOMLN2
JMP @TAPE19
@TAPE56: TEST BYTE PTR TOETS[CS:$13],$03 {---r---}
JZ @TAPE71
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR AANTALATOMFILES
POP DS
CMP WORD PTR [CS:LASTATM],AX
JAE @TAPE71
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+7
MOV BL,$09
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@TAPE72: CALL PRINTCHAR
LOOP @TAPE72
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+8
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +11,+8,$0E,' RENAME FILE: ',$00
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010101b
CALL PRINTCHAR
MOV AL,' '
CALL PRINTCHAR
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
MOV AX,WORD PTR [CS:LASTATM]
MOV CX,ATMRECGROOTTE
MUL CX
ADD AX,OFFSET ATOMFILES
MOV SI,AX
SUB BX,BX
@TAPE75: CMP BYTE PTR [SI+BX],$00
JZ @TAPE74
INC BL
CMP BL,$10
JB @TAPE75
@TAPE74: SHR BL,1
PUSHF
ADC BL,$00
MOV CH,$00
MOV CL,$08
SUB CL,BL
PUSH CX
JZ @TAPE83
MOV AL,' '
@TAPE76: CALL PRINTCHAR
LOOP @TAPE76
@TAPE83: MOV CL,$10
@TAPE78: LODSB
OR AL,AL
JZ @TAPE77
AND AL,$3F
MOV BL,$09
CALL PRINTCHAR
LOOP @TAPE78
@TAPE77: POP CX
POPF
ADC CL,$00
INC CL
MOV AL,' '
@TAPE79: CALL PRINTCHAR
LOOP @TAPE79
POP DS
MOV BL,$09
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+10
MOV AL,01010101b
CALL PRINTCHAR
MOV CX,$12
MOV AL,' '
@TAPE81: CALL PRINTCHAR
LOOP @TAPE81
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+10
MOV BYTE PTR [CS:CURSORY],+11
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@TAPE73: CALL PRINTCHAR
LOOP @TAPE73
MOV AL,01101000b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+12
MOV BYTE PTR [CS:CURSORY],+10
MOV BL,$13 {---r---}
CALL KEYRELEASE
PUSH DS
MOV AX,CS
MOV DS,AX
MOV DI,OFFSET FILENAMEBUF
MOV CL,$10
CALL INPUTSTRING
POP DS
JC @TAPE82
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
PUSH WORD PTR [CS:LASTATM] {---filepointer---}
PUSH CS {---segment of newname---}
PUSH OFFSET FILENAMEBUF {---offset of newname---}
CALL RENAMEFILE
POP DS
POP ES
@TAPE82: CALL SHOWALL1TAPE
CALL SHOWALL2
@TAPE80: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @TAPE80
JMP @TAPE12
@TAPE71: CALL CHECKEXITTAPE
CMP AL,$FF
JZ @TAPE12
PUSH AX
MOV DI,+10*$0120+$0140+12*4+6*4
MOV CX,4
MOV AL,$0B
CALL XORPUT
POP AX
RETN
@FOUTEXITCODE: DW $0000
END;
{---[optcurs (byte)]--------------------------------------------------------}
PROCEDURE OPTCURS; ASSEMBLER;
ASM;
DB $00
END;
{---[xorputoptcurs]---------------------------------------------------------}
PROCEDURE XORPUTOPTCURS; ASSEMBLER;
ASM;
MOV BL,BYTE PTR [CS:OPTCURS]
MOV BH,$00
MOV AL,BYTE PTR @OPTYTABLE[CS:BX]
MOV AH,$00
MOV CX,+10*$0120
MUL CX
ADD AX,+$0140+12*4
MOV DI,AX
MOV AL,BYTE PTR @OPTXTABLE[CS:BX]
MOV AH,$00
SHL AX,2
ADD DI,AX
MOV CL,BYTE PTR @OPTLTABLE[CS:BX]
MOV CH,$00
MOV AL,$0B
CALL XORPUT
RETN
@OPTXTABLE: DB 0, 0,24,24, 7,10,13, 7,10,13, 7,10,13, 7,10,13
DB 7,10,13, 7,10,13, 7,10,13,24, 0, 0
@OPTYTABLE: DB 3, 4, 3, 4, 7, 7, 7, 8, 8, 8, 9, 9, 9,10,10,10
DB 11,11,11,12,12,12,13,13,13,15,16,17
@OPTLTABLE: DB 12,12,14,14, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
DB 2, 2, 2, 2, 2, 2, 2, 2, 2,12, 7, 7
END;
{---[options (desktop)]-----------------------------------------------------}
PROCEDURE OPTIONS; ASSEMBLER;
ASM;
MOV DI,+20*$0120+$0140
MOV CX,+168*$0120/4
@OPT3: MOV AX,$00FF
STOSW
MOV AX,$FFFF
STOSW
LOOP @OPT3
MOV DI,+10*$0120+$0140+12*4+12*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
MOV AX,CS
MOV DS,AX
CALL PRINTSTRING
DB +0,+2,$0C,'CPU SPEED',$00
CALL PRINTSTRING
DB +0,+3,$0E,'( ) ORIGINAL ( ) ACORN ATOM',$00
CALL PRINTSTRING
DB +0,+4,$0E,'( ) MAXIMUM ( ) REGULAR',$00
CALL PRINTSTRING
DB +24,+2,$0C,'ASSEMBLER LAYOUT',$00
CALL PRINTSTRING
DB +0,+6,$0C,'COLORS DURING EMULATION',$00
CALL PRINTSTRING
DB +0,+7,$0F,'BACKGR',$00
CALL PRINTSTRING
DB +0,+8,$0F,'FOREGR',$00
CALL PRINTSTRING
DB +0,+9,$0F,'GREYSB',$00
CALL PRINTSTRING
DB +0,+10,$0F,'COLOR0',$00
CALL PRINTSTRING
DB +0,+11,$0F,'COLOR1',$00
CALL PRINTSTRING
DB +0,+12,$0F,'COLOR2',$00
CALL PRINTSTRING
DB +0,+13,$0F,'COLOR3',$00
CALL PRINTSTRING
DB +0,+15,$0C,'SOUND OUTPUT',$00
CALL PRINTSTRING
DB +0,+16,$0E,'( ) YES',$00
CALL PRINTSTRING
DB +0,+17,$0E,'( ) NO',$00
CALL PRINTSTRING
DB +24,+15,$0E,'SAVE OPTIONS',$00
CALL PRINTSTRING
DB +0,+18,$0F,'CHANGE + INCREASE - DECREASE',$00
MOV AL,'C' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
MOV BYTE PTR [CS:CURSORY],+18
CALL PRINTCHAR
MOV AL,'+'
MOV BYTE PTR [CS:CURSORX],+8
CALL PRINTCHAR
MOV AL,'-'
MOV BYTE PTR [CS:CURSORX],+20
CALL PRINTCHAR
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
@OPT1: PUSH DS
MOV AX,CS
MOV DS,AX
MOV BYTE PTR [CS:CURSORY],+7
MOV SI,OFFSET EMULCOLORS
MOV CH,$00
@OPT11: MOV BYTE PTR [CS:CURSORX],+7
MOV CL,$03
@OPT10: LODSB
MOV BL,$0E
CALL PRINTBYTE
INC BYTE PTR [CS:CURSORX]
DEC CL
JNZ @OPT10
MOV BL,CH
MOV CL,$07
MOV AL,$7F
@OPT12: CALL PRINTCHAR
DEC CL
JNZ @OPT12
INC BYTE PTR [CS:CURSORY]
INC CH
CMP CH,$07
JB @OPT11
@OPT33: POP DS
MOV AX,' *'
TEST BYTE PTR [CS:CPUSPEEDMODE],$FF
JZ @OPT2
XCHG AL,AH
@OPT2: MOV BL,$0E
MOV BYTE PTR [CS:CURSORX],+1
MOV BYTE PTR [CS:CURSORY],+3
CALL PRINTCHAR
DEC BYTE PTR [CS:CURSORX]
INC BYTE PTR [CS:CURSORY]
MOV AL,AH
CALL PRINTCHAR
MOV AX,' *'
TEST BYTE PTR [CS:ASMLAYOUT],$FF
JZ @OPT4
XCHG AL,AH
@OPT4: MOV BYTE PTR [CS:CURSORX],+25
MOV BYTE PTR [CS:CURSORY],+3
CALL PRINTCHAR
DEC BYTE PTR [CS:CURSORX]
INC BYTE PTR [CS:CURSORY]
MOV AL,AH
CALL PRINTCHAR
MOV AX,' *'
TEST BYTE PTR [CS:SOUNDOUTPUT],$FF
JNZ @OPT35
XCHG AL,AH
@OPT35: MOV BYTE PTR [CS:CURSORX],+1
MOV BYTE PTR [CS:CURSORY],+16
CALL PRINTCHAR
DEC BYTE PTR [CS:CURSORX]
INC BYTE PTR [CS:CURSORY]
MOV AL,AH
CALL PRINTCHAR
MOV WORD PTR [ES:51924],$FFFF
MOV WORD PTR [ES:51926],$FFFF
CALL XORPUTOPTCURS
@OPT13: TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @OPT14
CALL XORPUTOPTCURS
MOV BL,BYTE PTR [CS:OPTCURS]
MOV BH,$00
MOV AL,BYTE PTR @OPTUPTABLE[CS:BX]
MOV BYTE PTR [CS:OPTCURS],AL
CALL XORPUTOPTCURS
MOV BL,$48
CALL KEYRELEASE
JMP @OPT13
@OPT14: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @OPT15
CALL XORPUTOPTCURS
MOV BL,BYTE PTR [CS:OPTCURS]
MOV BH,$00
MOV AL,BYTE PTR @OPTDNTABLE[CS:BX]
MOV BYTE PTR [CS:OPTCURS],AL
CALL XORPUTOPTCURS
MOV BL,$50
CALL KEYRELEASE
JMP @OPT13
@OPT15: TEST BYTE PTR TOETS[CS:$4B],$03 {---left---}
JZ @OPT16
CALL XORPUTOPTCURS
MOV BL,BYTE PTR [CS:OPTCURS]
MOV BH,$00
MOV AL,BYTE PTR @OPTLFTABLE[CS:BX]
MOV BYTE PTR [CS:OPTCURS],AL
CALL XORPUTOPTCURS
MOV BL,$4B
CALL KEYRELEASE
JMP @OPT13
@OPT16: TEST BYTE PTR TOETS[CS:$4D],$03 {---right---}
JZ @OPT17
CALL XORPUTOPTCURS
MOV BL,BYTE PTR [CS:OPTCURS]
MOV BH,$00
MOV AL,BYTE PTR @OPTRTTABLE[CS:BX]
MOV BYTE PTR [CS:OPTCURS],AL
CALL XORPUTOPTCURS
MOV BL,$4D
CALL KEYRELEASE
JMP @OPT13
@OPT17: MOV AL,BYTE PTR TOETS[CS:$39] {---space---}
OR AL,BYTE PTR TOETS[CS:$2E] {---c---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JZ @OPT18
CMP BYTE PTR [CS:OPTCURS],$04
JB @OPT19
CMP BYTE PTR [CS:OPTCURS],$19
JA @OPT34
JNZ @OPT18
{---save ini-file---}
CALL XORPUTOPTCURS
PUSH ES
PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEINIFILE
POP DS
POP ES
@OPT22: MOV AL,BYTE PTR TOETS[CS:$39] {---space---}
OR AL,BYTE PTR TOETS[CS:$2E] {---c---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @OPT22
JMP @OPT1
@OPT19: MOV AL,BYTE PTR [CS:OPTCURS]
TEST AL,$02
JNZ @OPT21
MOV BYTE PTR [CS:CPUSPEEDMODE],AL
JMP @OPT20
@OPT21: AND AL,$01
MOV BYTE PTR [CS:ASMLAYOUT],AL
@OPT20: MOV AL,BYTE PTR TOETS[CS:$39] {---space---}
OR AL,BYTE PTR TOETS[CS:$2E] {---c---}
OR AL,BYTE PTR TOETS[CS:$1C] {---enter---}
AND AL,$03
JNZ @OPT20
CALL XORPUTOPTCURS
JMP @OPT1
@OPT34: MOV AL,BYTE PTR [CS:OPTCURS]
XOR AL,$01
AND AL,$01
MOV BYTE PTR [CS:SOUNDOUTPUT],AL
JMP @OPT20
@OPT18: TEST BYTE PTR TOETS[CS:$0D],$03 {---plus---}
JZ @OPT23
MOV AL,BYTE PTR [CS:OPTCURS]
CMP AL,$04
JB @OPT13
CMP AL,$18
JA @OPT13
SUB AL,$04
MOV AH,$00
MOV BX,AX
INC BYTE PTR EMULCOLORS[CS:BX]
AND BYTE PTR EMULCOLORS[CS:BX],$3F
CALL SETCOLORS
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,$00
OUT DX,AL
OUT DX,AL
OUT DX,AL
MOV BL,$0D
CALL KEYRELEASE
CALL XORPUTOPTCURS
JMP @OPT1
@OPT23: TEST BYTE PTR TOETS[CS:$0C],$03 {---min---}
JZ @OPT24
MOV AL,BYTE PTR [CS:OPTCURS]
CMP AL,$04
JB @OPT13
CMP AL,$18
JA @OPT13
SUB AL,$04
MOV AH,$00
MOV BX,AX
DEC BYTE PTR EMULCOLORS[CS:BX]
AND BYTE PTR EMULCOLORS[CS:BX],$3F
CALL SETCOLORS
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,$00
OUT DX,AL
OUT DX,AL
OUT DX,AL
MOV BL,$0C
CALL KEYRELEASE
CALL XORPUTOPTCURS
JMP @OPT1
@OPT24: TEST BYTE PTR TOETS[CS:$42],$03 {---f8---}
JNZ @OPT43
TEST BYTE PTR TOETS[CS:$43],$03 {---f9---}
JNZ @OPT39
TEST BYTE PTR TOETS[CS:$57],$03 {---f11---}
JNZ @OPT40
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JZ @OPT25
TEST BYTE PTR TOETS[CS:$14],$03 {---t---}
JZ @OPT26
@OPT39: MOV AL,$01
JMP @OPT38
@OPT26: TEST BYTE PTR TOETS[CS:$32],$03 {---m---}
JZ @OPT44
@OPT40: MOV AL,$03
JMP @OPT38
@OPT44: TEST BYTE PTR TOETS[CS:$20],$03 {---d---}
JZ @OPT25
@OPT43: MOV AL,$04
JMP @OPT38
@OPT25: TEST BYTE PTR TOETS[CS:$01],$03 {---escape---}
JZ @OPT13
MOV AL,$00
@OPT38: PUSH AX
CALL SETCOLORS
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,$00
OUT DX,AL
OUT DX,AL
OUT DX,AL
MOV DI,+10*$0120+$0140+12*4+12*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
POP AX
RETN
@OPTUPTABLE: DB $1B,$00,$19,$02,$01,$01,$01,$04
DB $05,$06,$07,$08,$09,$0A,$0B,$0C
DB $0D,$0E,$0F,$10,$11,$12,$13,$14
DB $15,$03,$16,$1A
@OPTDNTABLE: DB $01,$04,$03,$19,$07,$08,$09,$0A
DB $0B,$0C,$0D,$0E,$0F,$10,$11,$12
DB $13,$14,$15,$16,$17,$18,$1A,$1A
DB $1A,$02,$1B,$00
@OPTLFTABLE: DB $02,$03,$00,$01,$06,$04,$05,$09
DB $07,$08,$0C,$0A,$0B,$0F,$0D,$0E
DB $12,$10,$11,$15,$13,$14,$18,$16
DB $17,$1A,$19,$19
@OPTRTTABLE: DB $02,$03,$00,$01,$05,$06,$04,$08
DB $09,$07,$0B,$0C,$0A,$0E,$0F,$0D
DB $11,$12,$10,$14,$15,$13,$17,$18
DB $16,$1A,$19,$19
END;
{---[monitormode (byte)]----------------------------------------------------}
PROCEDURE MONITORMODE; ASSEMBLER;
ASM;
DB $00 {00h=code; 01h=dump}
END;
{---[hexteken (word)]-------------------------------------------------------}
PROCEDURE HEXTEKEN; ASSEMBLER;
ASM;
DW $0000 {whether to print #$ or @#}
END;
{---[dmptxt]----------------------------------------------------------------}
PROCEDURE DMPTXT; ASSEMBLER;
ASM;
DW $0000,$0000,$0000,$0000
END;
{---[disasptr (word)]-------------------------------------------------------}
PROCEDURE DISASPTR; ASSEMBLER;
ASM;
DW $0100
END;
{---[dataptr (word)]--------------------------------------------------------}
PROCEDURE DATAPTR; ASSEMBLER;
ASM;
DW $0000
END;
{---[step_ofs (word; holds offset for forward jump into main part)]---------}
PROCEDURE STEP_OFS; ASSEMBLER;
ASM;
DB $00
END;
{---[traceorstep (byte)]----------------------------------------------------}
PROCEDURE TRACEORSTEP; ASSEMBLER;
ASM;
DB $00 {00h=trace;01h=step}
END;
{---[trace_ofs (word; holds offset for forward jump into main part)]--------}
PROCEDURE TRACE_OFS; ASSEMBLER;
ASM;
DB $00
END;
{---[untilcursor_ofs (word; holds offset for forward jump into main part)]--}
PROCEDURE UNTILCURSOR_OFS; ASSEMBLER;
ASM;
DB $00
END;
{---[breakpoint_ofs (word; holds offset for forward jump into main part)]---}
PROCEDURE BREAKPOINT_OFS; ASSEMBLER;
ASM;
DB $00
END;
{---[clreol (works only until column +30)]----------------------------------}
PROCEDURE CLREOL; ASSEMBLER;
ASM;
PUSH WORD PTR [CS:CURSORX]
@CLREOL2: CMP BYTE PTR [CS:CURSORX],+30
JA @CLREOL1
MOV AL,' '
CALL PRINTCHAR
JMP @CLREOL2
@CLREOL1: POP WORD PTR [CS:CURSORX]
END;
{---[disas; DS:SI=startofs; BX=endofs]--------------------------------------}
PROCEDURE DISAS; ASSEMBLER;
ASM;
PUSH BX
MOV AL,BYTE PTR [SI]
MOV BL,AL
MOV BH,$00
SHL BX,1
MOV CH,BYTE PTR OPCODES[CS:BX ]
MOV CL,BYTE PTR OPCODES[CS:BX+$01]
MOV BL,$0B
MOV AL,'.'
CALL PRINTCHAR
MOV AX,SI
CALL PRINTWORD
MOV AL,' '
CALL PRINTCHAR
MOV AL,BYTE PTR [SI]
CALL PRINTBYTE
MOV AL,' '
CALL PRINTCHAR
CMP CL,+1
JZ @DIS3
CMP CL,+9
JZ @DIS3
@DIS2: INC SI
MOV AL,BYTE PTR [SI]
DEC SI
CALL PRINTBYTE
JMP @DIS4
@DIS3: MOV AL,' '
CALL PRINTCHAR
CALL PRINTCHAR
@DIS4: MOV AL,' '
CALL PRINTCHAR
CMP CL,+13
JZ @DIS5
CMP CL,+15
JZ @DIS5
CMP CL,+6
JB @DIS6
CMP CL,+8
JA @DIS6
@DIS5: MOV AL,BYTE PTR [SI+$02]
CALL PRINTBYTE
JMP @DIS7
@DIS6: MOV AL,' '
CALL PRINTCHAR
CALL PRINTCHAR
@DIS7: MOV AL,' '
CALL PRINTCHAR
MOV AL,CH
MOV AH,$00
PUSH SI
MOV SI,AX
SHL AX,1
ADD SI,AX
MOV AL,BYTE PTR MNEMONICS[CS:SI]
AND AL,$3F
CALL PRINTCHAR
INC SI
MOV AL,BYTE PTR MNEMONICS[CS:SI]
AND AL,$3F
CALL PRINTCHAR
INC SI
MOV AL,BYTE PTR MNEMONICS[CS:SI]
AND AL,$3F
CALL PRINTCHAR
POP SI
MOV AL,' '
CALL PRINTCHAR
CMP CL,+11
JB @DIS8
MOV AL,'('
CALL PRINTCHAR
@DIS8: CMP CL,+2
JNZ @DIS9
MOV AL,BYTE PTR [CS:HEXTEKEN+$01]
CALL PRINTCHAR
@DIS9: CMP CL,+1
JB @DIS10
JA @DIS36
MOV AL,'A' AND $3F
JMP @DIS37
@DIS36: CMP CL,+9
JZ @DIS10
MOV AL,BYTE PTR [CS:HEXTEKEN]
@DIS37: CALL PRINTCHAR
@DIS10: CMP CL,+10
JNZ @DIS11
MOV AL,BYTE PTR [SI+$01]
TEST AL,$80
JZ @DIS12
NEG AL
MOV AH,$00
PUSH BX
MOV BX,AX
MOV AX,SI
ADD AX,+$02
SUB AX,BX
POP BX
JMP @DIS13
@DIS12: MOV AH,$00
ADD AX,SI
ADD AX,+$02
JMP @DIS13
@DIS11: CMP CL,+13
JZ @DIS14
CMP CL,+15
JZ @DIS14
CMP CL,+6
JB @DIS15
CMP CL,+8
JA @DIS15
@DIS14: MOV AX,WORD PTR [SI+$01]
JMP @DIS13
@DIS15: MOV AL,BYTE PTR [SI+$01]
MOV AH,$00
@DIS13: CMP CL,+1
JBE @DIS16
CMP CL,+9
JZ @DIS16
CMP CL,+10
JZ @DIS17
CMP CL,+13
JZ @DIS17
CMP CL,+15
JZ @DIS17
CMP CL,+6
JB @DIS18
CMP CL,+9
JBE @DIS17
@DIS18: CALL PRINTBYTE
JMP @DIS16
@DIS17: CALL PRINTWORD
@DIS16: CMP CL,+4
JZ @DIS19
CMP CL,+7
JZ @DIS19
CMP CL,+11
JZ @DIS19
CMP CL,+15
JNZ @DIS20
@DIS19: MOV AL,','
CALL PRINTCHAR
MOV AL,'X' AND $3F
CALL PRINTCHAR
@DIS20: CMP CL,+5
JZ @DIS21
CMP CL,+8
JNZ @DIS22
@DIS21: MOV AL,','
CALL PRINTCHAR
MOV AL,'Y' AND $3F
CALL PRINTCHAR
@DIS22: CMP CL,+11
JZ @DIS23
CMP CL,+13
JB @DIS24
@DIS23: MOV AL,')'
CALL PRINTCHAR
@DIS24: CMP CL,+12
JNZ @DIS25
MOV AL,')'
CALL PRINTCHAR
MOV AL,','
CALL PRINTCHAR
MOV AL,'Y' AND $3F
CALL PRINTCHAR
@DIS25: CALL CLREOL
CALL NEXTLINE
CMP CL,+1
JZ @DIS27
CMP CL,+9
JNZ @DIS28
@DIS27: INC SI
JZ @DIS35
JMP @DIS32
@DIS28: CMP CL,+6
JB @DIS29
CMP CL,+9
JBE @DIS30
CMP CL,+13
JNZ @DIS29
@DIS30: INC SI
JZ @DIS35
@DIS29: ADD SI,$0002
JC @DIS35
@DIS32: POP BX
CMP SI,BX
JA @DIS33
JMP DISAS
@DIS33: RETN
@DIS35: POP BX
END;
{---[dump; DS:SI=startofs; BX=endofs (moet veelvoud van 08h verder zijn)]---}
PROCEDURE DUMP; ASSEMBLER;
ASM;
INC BX
MOV CX,BX
@DUMP5: MOV AX,' '
MOV WORD PTR DMPTXT[CS:$0000],AX
MOV WORD PTR DMPTXT[CS:$0002],AX
MOV WORD PTR DMPTXT[CS:$0004],AX
MOV WORD PTR DMPTXT[CS:$0006],AX
MOV BL,$0B
MOV AL,':'
CALL PRINTCHAR
MOV AX,SI
CALL PRINTWORD
MOV AL,' '
CALL PRINTCHAR
CALL PRINTCHAR
SUB DI,DI
@DUMP3: LODSB
MOV AH,AL
AND AL,$7F
CMP AL,'A'
JB @DUMP12
CMP AL,'Z'
JA @DUMP12
AND AL,$3F
JMP @DUMP1
@DUMP12: CMP AL,$40
JAE @DUMP8
CMP AL,$20
JAE @DUMP1
@DUMP8: MOV AL,'.'
@DUMP1: OR AL,$80
MOV BYTE PTR DMPTXT[CS:DI],AL
INC DI
MOV AL,AH
CALL PRINTBYTE
MOV AL,' '
CALL PRINTCHAR
CMP DI,$0008
JB @DUMP3
@DUMP2: CMP BYTE PTR [CS:CURSORX],$20
JAE @DUMP4
MOV AL,' '
CALL PRINTCHAR
JMP @DUMP2
@DUMP4: SUB DI,DI
@DUMP6: MOV AL,BYTE PTR DMPTXT[CS:DI]
CALL PRINTCHAR
INC DI
CMP DI,$0008
JB @DUMP6
@DUMP10: CMP SI,CX
JNZ @DUMP5
END;
{---[showreg]---------------------------------------------------------------}
PROCEDURE SHOWREG; ASSEMBLER;
ASM;
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+2
MOV BL,$0E
MOV AL,'P' AND $3F
CALL PRINTCHAR
MOV AL,'C' AND $3F
CALL PRINTCHAR
MOV BL,$09
MOV AL,'='
CALL PRINTCHAR
MOV BL,$0E
MOV AL,BYTE PTR [CS:HEXTEKEN]
CALL PRINTCHAR
MOV AX,WORD PTR [CS:PROGRAMCNT]
CALL PRINTWORD
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+3
MOV BL,$0E
MOV AL,'A' AND $3F
CALL PRINTCHAR
MOV AL,' ' AND $3F
CALL PRINTCHAR
MOV BL,$09
MOV AL,'='
CALL PRINTCHAR
MOV BL,$0E
MOV AL,BYTE PTR [CS:HEXTEKEN]
CALL PRINTCHAR
MOV AH,BYTE PTR [CS:ACCU_B]
MOV AL,BYTE PTR [CS:ACCUMULATOR]
CALL PRINTWORD
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+4
MOV BL,$0E
MOV AL,'X' AND $3F
CALL PRINTCHAR
MOV AL,' ' AND $3F
CALL PRINTCHAR
MOV BL,$09
MOV AL,'='
CALL PRINTCHAR
MOV BL,$0E
MOV AL,BYTE PTR [CS:HEXTEKEN]
CALL PRINTCHAR
MOV AL,BYTE PTR [CS:XREGISTER]
CALL PRINTBYTE
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+5
MOV BL,$0E
MOV AL,'Y' AND $3F
CALL PRINTCHAR
MOV AL,' ' AND $3F
CALL PRINTCHAR
MOV BL,$09
MOV AL,'='
CALL PRINTCHAR
MOV BL,$0E
MOV AL,BYTE PTR [CS:HEXTEKEN]
CALL PRINTCHAR
MOV AL,BYTE PTR [CS:YREGISTER]
CALL PRINTBYTE
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+6
MOV BL,$0E
MOV AL,'S' AND $3F
CALL PRINTCHAR
MOV AL,'P' AND $3F
CALL PRINTCHAR
MOV BL,$09
MOV AL,'='
CALL PRINTCHAR
MOV BL,$0E
MOV AL,BYTE PTR [CS:HEXTEKEN]
CALL PRINTCHAR
MOV AX,WORD PTR [CS:STACKPOINTER]
CALL PRINTBYTE
CALL PRINTSTRING
DB +32,+7,$0E,'NV-BDIZC',$00
MOV BYTE PTR [CS:CURSORX],+32
MOV BYTE PTR [CS:CURSORY],+8
MOV CL,$80
@SHOWREG2: MOV AL,'0'
TEST BYTE PTR [CS:FLAGREGISTER],CL
JZ @SHOWREG1
MOV AL,'1'
@SHOWREG1: CALL PRINTCHAR
SHR CL,1
JNC @SHOWREG2
END;
{---[monitor (desktop)]-----------------------------------------------------}
PROCEDURE MONITOR; ASSEMBLER;
ASM;
MOV BL,BYTE PTR [CS:ASMLAYOUT]
MOV BH,$00
SHL BX,1
MOV AX,WORD PTR @WHICHHEXSIGN[BX]
MOV WORD PTR [CS:HEXTEKEN],AX
MOV DI,+20*$0120+$0140
MOV CX,+168*$0120/4
@MON48: MOV AX,$00FF
STOSW
MOV AX,$FFFF
STOSW
LOOP @MON48
MOV DI,+10*$0120+$0140+12*4+21*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
CALL PRINTSTRING
DB +0,+18,$0F,'TRACE STEP HERE BRKPNT GOTO WHERE MODE',$00
MOV AL,'T' AND $3F
MOV BL,$09
MOV BYTE PTR [CS:CURSORX],+0
MOV BYTE PTR [CS:CURSORY],+18
CALL PRINTCHAR
MOV AL,'S' AND $3F
MOV BYTE PTR [CS:CURSORX],+6
CALL PRINTCHAR
MOV AL,'H' AND $3F
MOV BYTE PTR [CS:CURSORX],+11
CALL PRINTCHAR
MOV AL,'B' AND $3F
MOV BYTE PTR [CS:CURSORX],+16
CALL PRINTCHAR
MOV AL,'G' AND $3F
MOV BYTE PTR [CS:CURSORX],+23
CALL PRINTCHAR
MOV AL,'W' AND $3F
MOV BYTE PTR [CS:CURSORX],+28
CALL PRINTCHAR
MOV AL,'M' AND $3F
MOV BYTE PTR [CS:CURSORX],+34
CALL PRINTCHAR
@MON5: SUB CX,CX
@MON52: MOV SI,CX
SHL SI,1
MOV AX,WORD PTR @BRKPNTCOORD[CS:SI]
MOV BYTE PTR [CS:CURSORX],AL
MOV BYTE PTR [CS:CURSORY],AH
MOV AL,$01
SHL AL,CL
TEST BYTE PTR [CS:BRKPNTON],AL
JNZ @MON53
MOV AL,' '
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
CALL PRINTCHAR
JMP @MON54
@MON53: MOV AX,WORD PTR BRKPNTS[CS:SI]
MOV BL,$09
CMP AX,WORD PTR [CS:DISASPTR]
JNZ @MON55
MOV BL,$0F
@MON55: CALL PRINTWORD
@MON54: INC CL
CMP CL,$04
JNZ @MON52
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON33
CALL PRINTSTRING
DB +36,+12,$0C,'DUMP',$00
JMP @MON57
@MON33: CALL PRINTSTRING
DB +36,+12,$0C,'CODE',$00
@MON57: MOV DS,WORD PTR [CS:ATOMSEG]
MOV BYTE PTR [CS:CURSORX],+0
MOV BYTE PTR [CS:CURSORY],+2
MOV SI,WORD PTR [CS:DISASPTR]
@MON3: MOV BX,SI
CALL DISAS
CMP BYTE PTR [CS:CURSORY],+13
JB @MON3
INC BYTE PTR [CS:CURSORY]
MOV SI,WORD PTR [CS:DATAPTR]
@MON2: MOV BX,SI
ADD BX,+$07
CALL DUMP
CMP BYTE PTR [CS:CURSORY],+18
JB @MON2
MOV AX,$FFFF
MOV DI,+(18*10-1)*$0120+$0140+12*4
MOV CX,+80
REPZ
STOSW
CALL SHOWREG
@MON26: TEST BYTE PTR TOETS[CS:$32],$03 {---m---}
JNZ @MON26
@MON6: TEST BYTE PTR TOETS[CS:$1F],$03 {---s---}
JZ @MON1
OR BYTE PTR [CS:BRKPNTON],$80
CALL WORD PTR [CS:STEP_OFS]
AND BYTE PTR [CS:BRKPNTON],$7F
MOV BL,$1F {---s---}
CALL KEYRELEASE
MOV AX,WORD PTR [CS:PROGRAMCNT]
MOV WORD PTR [CS:DISASPTR],AX
TEST BYTE PTR [CS:TRACEORSTEP],$FF
JZ @MON5
CALL UPPERLINES
JMP MONITOR
@MON1: TEST BYTE PTR TOETS[CS:$14],$03 {---t---}
JZ @MON7
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JNZ @MON7
OR BYTE PTR [CS:BRKPNTON],$80
CALL WORD PTR [CS:TRACE_OFS]
AND BYTE PTR [CS:BRKPNTON],$7F
MOV BL,$14 {---t---}
CALL KEYRELEASE
MOV AX,WORD PTR [CS:PROGRAMCNT]
MOV WORD PTR [CS:DISASPTR],AX
JMP @MON5
@MON7: TEST BYTE PTR TOETS[CS:$48],$03 {---up---}
JZ @MON9
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON34
SUB WORD PTR [CS:DATAPTR],+$08
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @MON5
@MON34: MOV SI,WORD PTR [CS:DISASPTR]
SUB SI,+$18
@MON15: MOV CX,SI
MOV BL,BYTE PTR [SI]
MOV BH,$00
SHL BX,1
MOV BL,BYTE PTR OPCODES[CS:BX+$01]
DEC BL
MOV BH,$00
MOV AL,BYTE PTR @SI_ERBIJ[BX]
MOV AH,$00
ADD SI,AX
CMP SI,WORD PTR [CS:DISASPTR]
JB @MON15
JA @MON18
MOV SI,CX
JMP @MON11
@MON18: MOV SI,WORD PTR [CS:DISASPTR]
SUB SI,+$03
MOV AL,$03
@MON12: MOV BL,BYTE PTR [SI]
MOV BH,$00
SHL BX,1
MOV BL,BYTE PTR OPCODES[CS:BX+$01]
DEC BL
MOV BH,$00
CMP BYTE PTR @SI_ERBIJ[BX],AL
JZ @MON11
INC SI
DEC AL
CMP AL,$01
JA @MON12
@MON11: MOV WORD PTR [CS:DISASPTR],SI
MOV BL,$48 {---up---}
CALL KEYRELEASE
JMP @MON5
@MON9: TEST BYTE PTR TOETS[CS:$50],$03 {---down---}
JZ @MON10
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON35
ADD WORD PTR [CS:DATAPTR],+$08
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @MON5
@MON35: MOV SI,WORD PTR [CS:DISASPTR]
MOV BL,BYTE PTR [SI]
MOV BH,$00
SHL BX,1
MOV BL,BYTE PTR OPCODES[CS:BX+$01]
DEC BL
MOV BH,$00
MOV AL,BYTE PTR @SI_ERBIJ[BX]
MOV AH,$00
ADD WORD PTR [CS:DISASPTR],AX
MOV BL,$50 {---down---}
CALL KEYRELEASE
JMP @MON5
@MON10: TEST BYTE PTR TOETS[CS:$4B],$03 {---left---}
JZ @MON21
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON41
DEC WORD PTR [CS:DATAPTR]
JMP @MON42
@MON41: DEC WORD PTR [CS:DISASPTR]
@MON42: MOV BL,$4B {---left---}
CALL KEYRELEASE
JMP @MON5
@MON21: TEST BYTE PTR TOETS[CS:$4D],$03 {---right---}
JZ @MON20
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON43
INC WORD PTR [CS:DATAPTR]
JMP @MON44
@MON43: INC WORD PTR [CS:DISASPTR]
@MON44: MOV BL,$4D {---right---}
CALL KEYRELEASE
JMP @MON5
@MON20: TEST BYTE PTR TOETS[CS:$49],$03 {---page up---}
JZ @MON22
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON36
SUB WORD PTR [CS:DATAPTR],+$20
JMP @MON37
@MON36: SUB WORD PTR [CS:DISASPTR],+$10
@MON37: MOV BL,$49 {---page up---}
CALL KEYRELEASE
JMP @MON5
@MON22: TEST BYTE PTR TOETS[CS:$51],$03 {---page down---}
JZ @MON28
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON38
ADD WORD PTR [CS:DATAPTR],+$20
JMP @MON39
@MON38: ADD WORD PTR [CS:DISASPTR],+$10
@MON39: MOV BL,$51 {---page down---}
CALL KEYRELEASE
JMP @MON5
@MON28: TEST BYTE PTR TOETS[CS:$22],$03 {---g---}
JZ @MON27
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+7
MOV BL,$0C
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@MON29: CALL PRINTCHAR
LOOP @MON29
MOV AL,01001010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+8
MOV AL,01010101b
CALL PRINTCHAR
CALL PRINTSTRING
DB +10,+8,$0E,' GOTO ADDRESS: ',$00
MOV BL,$0C
MOV AL,01101010b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+9
MOV BYTE PTR [CS:CURSORY],+9
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+20
MOV AL,01001100b
@MON30: CALL PRINTCHAR
LOOP @MON30
MOV AL,01101000b
CALL PRINTCHAR
MOV BYTE PTR [CS:CURSORX],+25
MOV BYTE PTR [CS:CURSORY],+8
CALL INPUTWORD
JC @MON5
TEST BYTE PTR [CS:MONITORMODE],$FF
JZ @MON40
MOV WORD PTR [CS:DATAPTR],AX
JMP @MON5
@MON40: MOV WORD PTR [CS:DISASPTR],AX
JMP @MON5
@MON27: TEST BYTE PTR TOETS[CS:$23],$03 {---h---}
JZ @MON56
OR BYTE PTR [CS:BRKPNTON],$80
CALL WORD PTR [CS:UNTILCURSOR_OFS]
AND BYTE PTR [CS:BRKPNTON],$7F
MOV AX,WORD PTR [CS:PROGRAMCNT]
MOV WORD PTR [CS:DISASPTR],AX
CALL UPPERLINES
JMP MONITOR
@MON56: TEST BYTE PTR TOETS[CS:$30],$03 {---b---}
JZ @MON31
CALL WORD PTR [CS:BREAKPOINT_OFS]
CALL UPPERLINES
JMP MONITOR
@MON31: TEST BYTE PTR TOETS[CS:$32],$03 {---m---}
JZ @MON32
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JNZ @MON32
XOR BYTE PTR [CS:MONITORMODE],$01
MOV BL,$32 {---m---}
CALL KEYRELEASE
JMP @MON5
@MON32: TEST BYTE PTR TOETS[CS:$11],$03 {---w---}
JZ @MON49
MOV AX,WORD PTR [CS:PROGRAMCNT]
MOV WORD PTR [CS:DISASPTR],AX
MOV BL,$11 {---w---}
CALL KEYRELEASE
JMP @MON5
@MON49: TEST BYTE PTR TOETS[CS:$42],$03 {---f8---}
JNZ @MON58
TEST BYTE PTR TOETS[CS:$43],$03 {---f9---}
JNZ @MON50
TEST BYTE PTR TOETS[CS:$44],$03 {---f10---}
JNZ @MON51
TEST BYTE PTR TOETS[CS:$38],$03 {---alt---}
JZ @MON25
@MON23: TEST BYTE PTR TOETS[CS:$14],$03 {---t---}
JZ @MON24
@MON50: MOV DI,+10*$0120+$0140+12*4+21*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
MOV AL,$01
RETN
@MON24: TEST BYTE PTR TOETS[CS:$18],$03 {---o---}
JZ @MON59
@MON51: MOV DI,+10*$0120+$0140+12*4+21*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
MOV AL,$02
RETN
@MON59: TEST BYTE PTR TOETS[CS:$20],$03 {---d---}
JZ @MON25
@MON58: MOV DI,+10*$0120+$0140+12*4+21*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
MOV AL,$04
RETN
@MON25: TEST BYTE PTR TOETS[CS:$01],$03 {---escape---}
JZ @MON6
MOV DI,+10*$0120+$0140+12*4+21*4
MOV CX,+7
MOV AL,$0B
CALL XORPUT
MOV AL,$00
RETN
@SI_ERBIJ: DB 1,2,2,2,2,3,3,3,1,2,2,2,3,2,3
@WHICHHEXSIGN: DB '#','@' AND $3F,'$#'
@BRKPNTCOORD: DB +36,+10
DB +31,+10
DB +36,+11
DB +31,+11
END;
{===[program]===============================================================}
VAR I:BYTE;
BEGIN
SETUPSPEEDLOOP;
WRITELN ('Acorn Atom Emulator v1.33 (c) by Wouter Ras.');
INITIALIZE;
WRITELN ('Seaching directory for tape and disk images.');
READDIRECTORY;
IF AANTALTAPEIMAGES > 0 THEN
BEGIN
TAPEIMAGENAME := TAPEIMAGES[0];
READFILESINTAPEIMAGE;
END;
READINIFILE;
IF MEM[CSEG:OFS(LEENDERTSROM)] <> 0 THEN
WRITELN ('Installing co-processor support (c) Roland Leurs/Leendert Bijnagte.');
COPYWRITEPROT;
TIMER;
FOR I := 0 TO 3 DO
BEGIN
IF DISKETTENAMES[I] <> '' THEN
OPEN_DISK_IMAGE (I,(WRITEPROTECT[I AND 1] SHR ((I AND $02) SHL 1))<>0);
END;
WACHTEVENTJES;
ASM;
{---[main]------------------------------------------------------------------}
MOV WORD PTR [CS:RESETANDLOAD_OFS],OFFSET @RESETANDLOAD
MOV WORD PTR [CS:STEP_OFS],OFFSET @STEP
MOV WORD PTR [CS:TRACE_OFS],OFFSET @TRACE
MOV WORD PTR [CS:UNTILCURSOR_OFS],OFFSET @UNTILCURSOR
MOV WORD PTR [CS:BREAKPOINT_OFS],OFFSET @BREAKPOINT
MOV AX,WORD PTR IOPORT
OR AX,AX
JZ @MAIN9
MOV AL,$01
@MAIN9: MOV BYTE PTR @SBAVAIL,AL
{---make widertable---}
SUB DI,DI
MOV BL,$00
@INIT11: MOV BH,BL
SUB AX,AX
MOV CX,$0008
@INIT10: SHL BH,1
JNC @INIT8
RCL AX,1
STC
RCL AX,1
JMP @INIT9
@INIT8: SHL AX,2
@INIT9: LOOP @INIT10
XCHG AL,AH
MOV WORD PTR WIDERTABLE[CS:DI],AX
ADD DI,+$02
INC BL
JNZ @INIT11
{---make wider1atable---}
SUB DI,DI
MOV BL,$00
@INIT7: MOV BH,BL
SUB AX,AX
MOV CX,$0004
@INIT6: MOV DL,$02
@INIT1: PUSH BX
SHL BH,1
JNC @INIT4
RCL AX,1
JMP @INIT5
@INIT4: SHL AX,1
@INIT5: SHL BX,1
JNC @INIT2
RCL AX,1
JMP @INIT3
@INIT2: SHL AX,1
@INIT3: POP BX
DEC DL
JNZ @INIT1
SHL BH,2
LOOP @INIT6
XCHG AL,AH
MOV WORD PTR WIDER1aTABLE[CS:DI],AX
ADD DI,+$02
INC BL
JNZ @INIT7
CLD
MOV AX,WORD PTR ATOMMEMSEG
MOV WORD PTR [CS:ATOMSEG],AX
MOV BYTE PTR [CS:GRAPHMODE],$00
PUSH DS
MOV AX,DS
MOV ES,AX
MOV AX,CS
MOV DS,AX
{---characters---}
MOV SI,OFFSET CHARACTERS
MOV DI,OFFSET CHARDATA
MOV BL,$40
@MAIN1: MOV AL,$00
STOSB
STOSB
STOSB
MOV CX,$0007
@MAIN3: LODSB
ROL AL,1
STOSB
LOOP @MAIN3
MOV AL,$00
STOSB
STOSB
ADD DI,+$04
DEC BL
JNZ @MAIN1
{---inverted characters---}
MOV SI,OFFSET CHARACTERS
MOV DI,OFFSET CHARDATA+$0800
MOV BL,$40
@MAIN2: MOV AL,$FF
STOSB
STOSB
STOSB
MOV CX,$0007
@MAIN4: LODSB
ROL AL,1
NOT AL
STOSB
LOOP @MAIN4
MOV AL,$FF
STOSB
STOSB
ADD DI,+$04
DEC BL
JNZ @MAIN2
{---white/grey graphics symbols---}
MOV DI,OFFSET CHARDATA+$0400
MOV BL,$40
@MAIN5: MOV BH,00100000b
@MAIN8: MOV AL,$00
TEST BL,BH
JZ @MAIN6
OR AL,$F0
@MAIN6: SHR BH,1
TEST BL,BH
JZ @MAIN7
OR AL,$0F
@MAIN7: STOSB
STOSB
STOSB
STOSB
SHR BH,1
JNC @MAIN8
ADD DI,+$04
INC BL
CMP BL,$80
JB @MAIN5
POP DS
CALL INITATOMGRAPH
MOV AX,$A000
MOV ES,AX
CALL @SETINT
MOV DS,WORD PTR ATOMMEMSEG
MOV BYTE PTR [$B001],$FF
MOV BYTE PTR [$B002],$40
MOV WORD PTR [INSTRCYCLES],$0000
MOV WORD PTR [PCCYCLES],$0000
MOV WORD PTR [WACHTSCHULD],$0000
CALL @VOLUMEON
CALL SETBORDERCOL
CALL SETINTENSCOL
PUSH DS
PUSH ES
PUSHA
PUSHF
MOV WORD PTR @PCSP,SP
JMP @BREAKKEY
@ENDOFEMUL: MOV SP,WORD PTR @PCSP
POPF
POPA
POP ES
POP DS
CALL @VOLUMEOFF
CALL @CLRINT
MOV AX,$0003
INT $10
MOV AX,CS
MOV DS,AX
MOV DX,OFFSET @BYEBYETXT
MOV AH,$09
INT $21
MOV DS,WORD PTR [CS:DATASEG]
JMP @ENDOFPRG
@BYEBYETXT: DB 'Acorn Atom Emulator v1.33 (c) Wouter Ras, Delft, '
DB 'Oct 1997 - May 1999.',$0D,$0A,$0A,'Bye bye!'
DB $0D,$0A,$0A,'$'
{---[00h: brk implied]------------------------------------------------------}
@OPCODE00: MOV WORD PTR [INSTRCYCLES],$1507
MOV AX,SI
INC AX
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AH
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
AND BP,$00FF
MOV AL,BH
OR AL,00010000b {set break flag}
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
OR BH,00000100b {set interrupt flag}
MOV SI,WORD PTR [BRK_VECTOR]
JMP @NEXTOPC
{---[01h: ora (indirect,x)]-------------------------------------------------}
@OPCODE01: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[02h: cop implied]------------------------------------------------------}
@OPCODE02: TEST BYTE PTR [CS:LEENDERTSROM],$FF
JNZ @OPC02_1
MOV WORD PTR [INSTRCYCLES],$0B03
INC SI
JMP @NEXTOPC
@OPC02_1: MOV WORD PTR [INSTRCYCLES],$4007
PUSH DS
PUSH ES
PUSHA
MOV AL,BL
MOV BL,CL
MOV BH,DL
PUSH DS
POP ES
DB $2E,$FF,$1E
DW OFFSET FPPC_ADDR
TEST AL,$01
JZ @OPC02_2
{---invalid operation: generate error 123---}
POPA
POP ES
POP DS
MOV SI,+122
JMP @OPCODE00
@OPC02_2: TEST AL,$04
JZ @OPC02_3
{---division by zero error; generate error 169---}
POPA
POP ES
POP DS
MOV SI,+168
JMP @OPCODE00
@OPC02_3: TEST AL,$40
JZ @OPC02_4
{---power of neg.number with non-int exp: error 191---}
POPA
POP ES
POP DS
MOV SI,+190
JMP @OPCODE00
@OPC02_4: POPA
POP ES
POP DS
JMP @NEXTOPC
{---[04h: tsb zero page]----------------------------------------------------}
@OPCODE04: MOV WORD PTR [INSTRCYCLES],$1205+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
TEST BL,BYTE PTR [DI]
LAHF
OR BYTE PTR [DI],BL
AND BH,11111101b
AND AH,01000000b
SHR AH,5
OR BH,AH {zero flag}
JMP @NEXTOPC
{---[05h: ora zero page]----------------------------------------------------}
@OPCODE05: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[06h: asl zero page]----------------------------------------------------}
@OPCODE06: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
SHL BYTE PTR [DI],1
JMP @UPDATECNZ
{---[08h: php implied]------------------------------------------------------}
@OPCODE08: MOV WORD PTR [INSTRCYCLES],$0903
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],BH
DEC BP
JMP @NEXTOPC
{---[09h: ora immediate]----------------------------------------------------}
@OPCODE09: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
OR BL,AL
JMP @UPDATENZ
{---[0Ah: asl accumulator]--------------------------------------------------}
@OPCODE0A: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
SHL BL,1
JMP @UPDATECNZ
{---[0Ch: tsb absolute]-----------------------------------------------------}
@OPCODE0C: MOV WORD PTR [INSTRCYCLES],$1206+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
TEST BL,BYTE PTR [DI]
LAHF
CMP DI,$A000
JAE @OPC0C_1
OR BYTE PTR [DI],BL
@OPC0C_1: AND BH,11111101b
AND AH,01000000b
SHR AH,5
OR BH,AH {zero flag}
JMP @NEXTOPC
{---[0Dh: ora absolute]-----------------------------------------------------}
@OPCODE0D: MOV WORD PTR [INSTRCYCLES],$0E04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[0Eh: asl absolute]-----------------------------------------------------}
@OPCODE0E: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
@ASL_ABS: MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC0E_1
SHL BYTE PTR [DI],1
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC0E_1: CMP DI,SCHAKELBYTE
JZ @OPC0E_2
MOV AL,BYTE PTR [DI]
SHL AL,1
JMP @UPDATECNZ
@OPC0E_2: CALL SAVEZP90
SHL BYTE PTR [DI],1
PUSHF
CALL SETA000MEM
POPF
JMP @UPDATECNZ
{---[10h: bpl relative]-----------------------------------------------------}
@OPCODE10: MOV AL,BH
SHL AL,1 {get negative}
JC @OPC10_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPC10_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[11h: ora (indirect),y]-------------------------------------------------}
@OPCODE11: MOV WORD PTR [INSTRCYCLES],$1705+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI]
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[12h: ora (indirect)]---------------------------------------------------}
@OPCODE12: MOV WORD PTR [INSTRCYCLES],$1305+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[14h: trb zero page]----------------------------------------------------}
@OPCODE14: MOV WORD PTR [INSTRCYCLES],$1405+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
TEST BL,BYTE PTR [DI]
LAHF
MOV AL,BL
NOT AL
AND BYTE PTR [DI],AL
AND BH,11111101b
AND AH,01000000b
SHR AH,5
OR BH,AH {zero flag}
JMP @NEXTOPC
{---[15h: ora zero page,x]--------------------------------------------------}
@OPCODE15: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[16h: asl zero page,x]--------------------------------------------------}
@OPCODE16: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
SHL BYTE PTR [DI],1
JMP @UPDATECNZ
{---[18h: clc]--------------------------------------------------------------}
@OPCODE18: MOV WORD PTR [INSTRCYCLES],$0802
AND BH,11111110b
JMP @NEXTOPC
{---[19h: ora absolute,y]---------------------------------------------------}
@OPCODE19: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[1Ah: inc accumulator]--------------------------------------------------}
@OPCODE1A: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
INC BL
JMP @UPDATENZ
{---[1Bh: tas implied]------------------------------------------------------}
@OPCODE1B: MOV WORD PTR [INSTRCYCLES],$0902
MOV AL,BL
MOV AH,$00
MOV BP,AX
JMP @NEXTOPC
{---[1Ch: trb absolute]-----------------------------------------------------}
@OPCODE1C: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
TEST BL,BYTE PTR [DI]
LAHF
CMP DI,$A000
JAE @OPC1C_1
MOV AL,BL
NOT AL
AND BYTE PTR [DI],AL
@OPC1C_1: AND BH,11111101b
AND AH,01000000b
SHR AH,5
OR BH,AH {zero flag}
JMP @NEXTOPC
{---[1Dh: ora absolute,x]---------------------------------------------------}
@OPCODE1D: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
OR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[1Eh: asl absolute,x]---------------------------------------------------}
@OPCODE1E: MOV WORD PTR [INSTRCYCLES],$1707+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @ASL_ABS
{---[20h: jsr absolute]-----------------------------------------------------}
@OPCODE20: MOV WORD PTR [INSTRCYCLES],$1306
MOV AX,SI
INC AX
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AH
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
MOV SI,WORD PTR [SI]
JMP @NEXTOPC
{---[21h: and (indirect,x)]-------------------------------------------------}
@OPCODE21: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[22h: nop zero page]----------------------------------------------------}
@OPCODE22:
@OPCODE42:
@OPCODE44:
@OPCODE54:
@OPCODE62:
@OPCODE82:
@OPCODEC2:
@OPCODED4:
@OPCODEE2:
@OPCODEF4: MOV WORD PTR [INSTRCYCLES],$0803
INC SI
JMP @NEXTOPC
{---[24h: bit zero page]----------------------------------------------------}
@OPCODE24: MOV WORD PTR [INSTRCYCLES],$1C03
MOV AL,BYTE PTR [SI]
INC SI
@OPC24_1: MOV AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI]
MOV AH,AL
AND BH,00111101b
AND AH,11000000b
OR BH,AH {get m6, m7 in flags}
TEST BL,AL {a & m}
LAHF
AND AH,01000000b
SHR AH,5
OR BH,AH
JMP @NEXTOPC
{---[25h: and zero page]----------------------------------------------------}
@OPCODE25: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[26h: rol zero page]----------------------------------------------------}
@OPCODE26: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AL,BH
SHR AL,1 {get carry}
RCL BYTE PTR [DI],1
JC @OPC26_1
OR BYTE PTR [DI],$00
CLC
JMP @UPDATECNZ
@OPC26_1: OR BYTE PTR [DI],$00
STC
JMP @UPDATECNZ
{---[28h: plp implied]------------------------------------------------------}
@OPCODE28: MOV WORD PTR [INSTRCYCLES],$0C04
CMP SI,$CFAE
JNZ @OPC28_1
{---finfoutcmd preparation---}
MOV WORD PTR @FILENAMEOFS,$0140
TEST BH,$01 {test carry}
JZ @OPC28_1
PUSH BX
MOV BL,BYTE PTR [$0004]
MOV BH,$00
MOV AL,BYTE PTR [BX+$0016]
MOV AH,BYTE PTR [BX+$0025]
MOV WORD PTR @FILENAMEOFS,AX
POP BX
@OPC28_1: INC BP
AND BP,$00FF
MOV BH,BYTE PTR [DS:BP+STACKBASE]
JMP @NEXTOPC
{---[29h: and immediate]----------------------------------------------------}
@OPCODE29: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
AND BL,AL
JMP @UPDATENZ
{---[2Ah: rol accumulator]--------------------------------------------------}
@OPCODE2A: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
MOV AL,BH
SHR AL,1 {get carry}
RCL BL,1
JC @OPC2A_1
OR BL,BL
CLC
JMP @UPDATECNZ
@OPC2A_1: OR BL,BL
STC
JMP @UPDATECNZ
{---[2Ch: bit absolute]-----------------------------------------------------}
@OPCODE2C: MOV WORD PTR [INSTRCYCLES],$2304
MOV AX,WORD PTR [SI]
ADD SI,+$02
@OPC2C_4: MOV DI,AX
MOV AL,AH
AND AL,$F0
CMP AL,$B0
JNZ @OPC2C_2
CMP DI,$B001
JB @OPC2C_2
JZ @BIT_B001
CMP DI,$B003
JB @BIT_B002
JZ @BIT_B003
CMP AH,$B8
JZ @BIT_VIA
CMP AH,$BA
JZ @OPC2C_3
@OPC2C_2: MOV AL,BYTE PTR [DI]
JMP @OPC2C_1
@BIT_B001: CALL @L_B001_1
JMP @OPC2C_1
@BIT_B002: CALL @L_B002_1
JMP @OPC2C_1
@BIT_B003: CALL @L_B003_1
@OPC2C_1: MOV AH,AL
AND BH,00111101b
AND AH,11000000b
OR BH,AH {get m6, m7 in flags}
TEST BL,AL {a & m}
LAHF
AND AH,01000000b
SHR AH,5
OR BH,AH
JMP @NEXTOPC
@OPC2C_3: CALL READ_FDC
JMP @OPC2C_1
{---[2Dh: and absolute]-----------------------------------------------------}
@OPCODE2D: MOV WORD PTR [INSTRCYCLES],$1204+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
CMP AX,$B001
JB @OPC2D_1
JZ @AND_B001
CMP AX,$B003
JB @AND_B002
JZ @AND_B003
CMP AH,$B8
JZ @OPC2D_2
CMP AH,$BA
JZ @OPC2D_3
@OPC2D_1: AND BL,BYTE PTR [DI]
JMP @UPDATENZ
@AND_B001: CALL @L_B001_1
AND BL,AL
JMP @UPDATENZ
@AND_B002: CALL @L_B002_1
AND BL,AL
JMP @UPDATENZ
@AND_B003: CALL @L_B003_1
AND BL,AL
JMP @UPDATENZ
@OPC2D_2: CALL @GETVIAREG
AND BL,AL
JMP @UPDATENZ
@OPC2D_3: CALL READ_FDC
AND BL,AL
JMP @UPDATENZ
{---[2Eh: rol absolute]-----------------------------------------------------}
@OPCODE2E: MOV WORD PTR [INSTRCYCLES],$2306+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC2E_1
MOV AL,BH
SHR AL,1 {get carry}
RCL BYTE PTR [DI],1
JC @OPC2E_3
OR BYTE PTR [DI],$00
CLC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC2E_3: OR BYTE PTR [DI],$00
STC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC2E_1: MOV AL,BH
SHR AL,1 {get carry}
MOV AL,BYTE PTR [DI]
RCL AL,1
JC @OPC2E_4
OR AL,AL
CLC
JMP @UPDATECNZ
@OPC2E_4: OR AL,AL
STC
JMP @UPDATECNZ
{---[30h: bmi relative]-----------------------------------------------------}
@OPCODE30: MOV AL,BH
SHL AL,1 {get negative}
JNC @OPC30_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPC30_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[31h: and (indirect),y]-------------------------------------------------}
@OPCODE31: MOV WORD PTR [INSTRCYCLES],$1705+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[32h: and (indirect)]---------------------------------------------------}
@OPCODE32: MOV WORD PTR [INSTRCYCLES],$1305+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[34h: bit zero page,x]--------------------------------------------------}
@OPCODE34: MOV WORD PTR [INSTRCYCLES],$1E04
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
JMP @OPC24_1
{---[35h: and zero page,x]--------------------------------------------------}
@OPCODE35: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[36h: rol zero page,x]--------------------------------------------------}
@OPCODE36: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV AL,BH
SHR AL,1 {get carry}
RCL BYTE PTR [DI],1
JC @OPC36_1
OR BYTE PTR [DI],$00
CLC
JMP @UPDATECNZ
@OPC36_1: OR BYTE PTR [DI],$00
STC
JMP @UPDATECNZ
{---[38h: sec implied]------------------------------------------------------}
@OPCODE38: MOV WORD PTR [INSTRCYCLES],$0802
OR BH,00000001h
JMP @NEXTOPC
{---[39h: and absolute,y]---------------------------------------------------}
@OPCODE39: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[3Ah: dec accumulator]--------------------------------------------------}
@OPCODE3A: MOV WORD PTR [INSTRCYCLES],$0802
DEC BL
JMP @UPDATENZ
{---[3Bh: tsa implied]------------------------------------------------------}
@OPCODE3B: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV AX,BP
MOV BL,AL
OR AL,AL
JMP @UPDATENZ
{---[3Ch: bit absolute,x]---------------------------------------------------}
@OPCODE3C: MOV WORD PTR [INSTRCYCLES],$2404
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @OPC2C_4
{---[3Dh: and absolute,x]---------------------------------------------------}
@OPCODE3D: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
AND BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[3Eh: rol absolute,x]---------------------------------------------------}
@OPCODE3E: MOV WORD PTR [INSTRCYCLES],$2407+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC3E_1
MOV AL,BH
SHR AL,1 {get carry}
RCL BYTE PTR [DI],1
JC @OPC3E_3
OR BYTE PTR [DI],$00
CLC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC3E_3: OR BYTE PTR [DI],$00
STC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC3E_1: MOV AL,BH
SHR AL,1 {get carry}
MOV AL,BYTE PTR [DI]
RCL AL,1
JC @OPC3E_4
OR AL,AL
CLC
JMP @UPDATECNZ
@OPC3E_4: OR AL,AL
STC
JMP @UPDATECNZ
{---[40h: rti implied]------------------------------------------------------}
@OPCODE40: MOV WORD PTR [INSTRCYCLES],$1706
CMP BYTE PTR [CS:AANTBOXRET],$00
JZ @OPC40_1
PUSH BX
MOV BL,BYTE PTR [CS:AANTBOXRET]
DEC BL
MOV BH,$00
SHL BX,1
MOV AX,BP
DEC AL {ivm met PHA voor ind. jmp, bij zowel IRQ als NMI}
CMP AL,BYTE PTR BOXRETURNS[CS:BX+$01]
MOV AL,BYTE PTR BOXRETURNS[CS:BX]
POP BX
JNZ @OPC40_1
{---return to previous box---}
DEC BYTE PTR [CS:AANTBOXRET]
PUSH AX
CALL SAVEZP90
POP AX
MOV BYTE PTR [SCHAKELBYTE],AL
CALL SETA000MEM
@OPC40_1: INC BP
AND BP,$00FF
MOV BH,BYTE PTR [DS:BP+STACKBASE]
INC BP
AND BP,$00FF
MOV AL,BYTE PTR [DS:BP+STACKBASE]
INC BP
AND BP,$00FF
MOV AH,BYTE PTR [DS:BP+STACKBASE]
MOV SI,AX
JMP @NEXTOPC
{---[41h: eor (indirect,x)]-------------------------------------------------}
@OPCODE41: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[45h: eor zero page]----------------------------------------------------}
@OPCODE45: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[46h: lsr zero page]----------------------------------------------------}
@OPCODE46: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
SHR BYTE PTR [DI],1
JMP @UPDATECNZ
{---[48h: pha implied]------------------------------------------------------}
@OPCODE48: MOV WORD PTR [INSTRCYCLES],$0903
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],BL
DEC BP
JMP @NEXTOPC
{---[49h: eor immediate]----------------------------------------------------}
@OPCODE49: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
XOR BL,AL
JMP @UPDATENZ
{---[4Ah: lsr accumulator]--------------------------------------------------}
@OPCODE4A: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
SHR BL,1
JMP @UPDATECNZ
{---[4Ch: jmp absolute]-----------------------------------------------------}
@OPCODE4C: MOV WORD PTR [INSTRCYCLES],$1003
CMP SI,WORD PTR [CS:ABLOKSPRONG]
JZ @OPC4C_1
@OPC4C_2: MOV SI,WORD PTR [SI]
JMP @NEXTOPC
@OPC4C_1: TEST BYTE PTR [CS:BOXSWITCH],$FF
JZ @OPC4C_2
MOV AL,BYTE PTR [SCHAKELBYTE]
AND AL,$0F
MOV BYTE PTR @SCHAKELSTART,AL
CMP WORD PTR [$A000],$BF40
JNZ @OPC4C_3
@OPC4C_4: MOV BP,$00FF
MOV SI,$A002
JMP @NEXTOPC
@OPC4C_3: CALL SAVEZP90
INC BYTE PTR [SCHAKELBYTE]
AND BYTE PTR [SCHAKELBYTE],$0F
PUSH ES
MOV AX,DS
ADD AX,$1000
MOV ES,AX
MOV AL,$00
MOV AH,BYTE PTR SCHAKELBYTE
SHL AH,4
MOV DI,AX
CMP WORD PTR [ES:DI],$BF40
POP ES
JNZ @OPC4C_5
CALL SETA000MEM
MOV AL,BYTE PTR [SCHAKELBYTE]
CMP AL,BYTE PTR @SCHAKELSTART
JNZ @OPC4C_4
JMP @JMPTOBRK
@OPC4C_5: MOV AL,BYTE PTR [SCHAKELBYTE]
CMP AL,BYTE PTR @SCHAKELSTART
JNZ @OPC4C_3
CALL SETA000MEM
JMP @JMPTOBRK
{---[schakel_brk]-----------------------------------------------------------}
@SCHAKEL_BRK: PUSH BX
MOV BX,BP
ADD BL,$02
AND BX,$00FF
CMP BYTE PTR [BX+STACKBASE],+94
POP BX
JZ @OPC4C_3
@JMPTOBRK: MOV AX,WORD PTR [$0202]
AND AH,$F0
CMP AH,$A0
JNZ @JMPBRK1
PUSH ES
MOV AX,DS
ADD AX,$2000
MOV ES,AX
MOV AL,BYTE PTR [ES:$0122]
POP ES
MOV AH,BYTE PTR [SCHAKELBYTE]
AND AX,$0F0F
CMP AL,AH
JZ @JMPBRK1
CALL SAVEZP90
PUSH ES
MOV AX,DS
ADD AX,$2000
MOV ES,AX
MOV AL,BYTE PTR [ES:$0122]
POP ES
MOV BYTE PTR [SCHAKELBYTE],AL
CALL SETA000MEM
@JMPBRK1: MOV SI,WORD PTR [$0202]
JMP @NEXTOPC
{---[4Dh: eor absolute]-----------------------------------------------------}
@OPCODE4D: MOV WORD PTR [INSTRCYCLES],$0E04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[4Eh: lsr absolute]-----------------------------------------------------}
@OPCODE4E: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
@LSR_ABS: MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC4E_1
SHR BYTE PTR [DI],1
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC4E_1: CMP DI,SCHAKELBYTE
JZ @OPC4E_2
MOV AL,BYTE PTR [DI]
SHR AL,1
JMP @UPDATECNZ
@OPC4E_2: CALL SAVEZP90
SHR BYTE PTR [DI],1
PUSHF
CALL SETA000MEM
POPF
JMP @UPDATECNZ
{---[50h: bvc relative]-----------------------------------------------------}
@OPCODE50: MOV AL,BH
SHL AL,2 {get overflow}
JC @OPC50_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPC50_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[51h: eor (indirect),y]-------------------------------------------------}
@OPCODE51: MOV WORD PTR [INSTRCYCLES],$1705+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[52h: eor (indirect)]---------------------------------------------------}
@OPCODE52: MOV WORD PTR [INSTRCYCLES],$1305+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI]
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[55h: eor zero page,x]--------------------------------------------------}
@OPCODE55: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[56h: lsr zero page,x]--------------------------------------------------}
@OPCODE56: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
SHR BYTE PTR [DI],1
JMP @UPDATECNZ
{---[58h: cli]--------------------------------------------------------------}
@OPCODE58: MOV WORD PTR [INSTRCYCLES],$0802
AND BH,11111011b
JMP @NEXTOPC
{---[59h: eor absolute,y]---------------------------------------------------}
@OPCODE59: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[5Ah: phy implied]------------------------------------------------------}
@OPCODE5A: MOV WORD PTR [INSTRCYCLES],$0903
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],DL
DEC BP
JMP @NEXTOPC
{---[5Ch: nop absolute]-----------------------------------------------------}
@OPCODE5C:
@OPCODEDC: MOV WORD PTR [INSTRCYCLES],$0804
ADD SI,+$02
JMP @NEXTOPC
{---[5Dh: eor absolute,x]---------------------------------------------------}
@OPCODE5D: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
XOR BL,BYTE PTR [DI]
JMP @UPDATENZ
{---[5Eh: lsr absolute,x]---------------------------------------------------}
@OPCODE5E: MOV WORD PTR [INSTRCYCLES],$1707+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @LSR_ABS
{---[60h: rts implied]------------------------------------------------------}
@OPCODE60: MOV WORD PTR [INSTRCYCLES],$1406
CMP BYTE PTR [CS:AANTBOXRET],$00
JZ @OPC60_1
PUSH BX
MOV BL,BYTE PTR [CS:AANTBOXRET]
DEC BL
MOV BH,$00
SHL BX,1
MOV AX,BP
CMP AL,BYTE PTR BOXRETURNS[CS:BX+$01]
MOV AL,BYTE PTR BOXRETURNS[CS:BX]
POP BX
JNZ @OPC60_1
{---return to previous box---}
DEC BYTE PTR [CS:AANTBOXRET]
PUSH AX
CALL SAVEZP90
POP AX
MOV BYTE PTR [SCHAKELBYTE],AL
CALL SETA000MEM
@OPC60_1: INC BP
AND BP,$00FF
MOV AL,BYTE PTR [DS:BP+STACKBASE]
INC BP
AND BP,$00FF
MOV AH,BYTE PTR [DS:BP+STACKBASE]
INC AX
MOV SI,AX
JMP @NEXTOPC
{---[61h: adc (indirect,x)]-------------------------------------------------}
@OPCODE61: MOV WORD PTR [INSTRCYCLES],$1E06+$1400
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[64h: stz zero page]----------------------------------------------------}
@OPCODE64: MOV WORD PTR [INSTRCYCLES],$0F03
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],$00
JMP @NEXTOPC
{---[65h: adc zero page]----------------------------------------------------}
@OPCODE65: MOV WORD PTR [INSTRCYCLES],$1A03+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[66h: ror zero page]----------------------------------------------------}
@OPCODE66: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AL,BH
SHR AL,1 {get carry}
RCR BYTE PTR [DI],1
JC @OPC66_1
OR BYTE PTR [DI],$00
CLC
JMP @UPDATECNZ
@OPC66_1: OR BYTE PTR [DI],$00
STC
JMP @UPDATECNZ
{---[68h: pla implied]------------------------------------------------------}
@OPCODE68: MOV WORD PTR [INSTRCYCLES],$0904+$0F00
INC BP
AND BP,$00FF
MOV BL,BYTE PTR [DS:BP+STACKBASE]
OR BL,BL
JMP @UPDATENZ
{---[69h: adc immediate]----------------------------------------------------}
@OPCODE69: MOV WORD PTR [INSTRCYCLES],$1502+$1400
MOV AL,BYTE PTR [SI]
INC SI
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[6Ah: ror accumulator]--------------------------------------------------}
@OPCODE6A: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
MOV AL,BH
SHR AL,1 {get carry}
RCR BL,1
JC @OPC6A_1
OR BL,BL
CLC
JMP @UPDATECNZ
@OPC6A_1: OR BL,BL
STC
JMP @UPDATECNZ
{---[6Ch: jmp (absolute indirect)]------------------------------------------}
@OPCODE6C: MOV WORD PTR [INSTRCYCLES],$4005
MOV SI,WORD PTR [SI]
MOV AX,WORD PTR [SI]
CMP SI,LOADVEC
JNZ @OPC6C_9
CMP AX,WORD PTR [$FFA2]
JNZ @OPC6C_2
JMP @LOADFILE
@OPC6C_9: CMP SI,SAVEVEC
JNZ @OPC6C_10
CMP AX,WORD PTR [$FFA4]
JNZ @OPC6C_2
JMP @SAVEFILE
@OPC6C_10: CMP SI,GETBYTEVEC
JNZ @OPC6C_11
CMP AX,WORD PTR [$FFAA]
JNZ @OPC6C_2
JMP @GETBYTE
@OPC6C_11: CMP SI,PUTBYTEVEC
JNZ @OPC6C_12
CMP AX,WORD PTR [$FFAC]
JNZ @OPC6C_2
JMP @PUTBYTE
@OPC6C_12: CMP SI,FINDVEC
JNZ @OPC6C_1
AND BP,$00FF
CMP WORD PTR [DS:BP+STACKBASE+1],$CFB0
JNZ @OPC6C_2
CMP AX,WORD PTR [$FFAE]
JNZ @OPC6C_2
JMP @FINFOUTCMD
@OPC6C_1: CMP SI,$00C9
JNZ @OPC6C_2
MOV SI,WORD PTR [SI]
CMP SI,$FA2A
JZ @TAPECAT
JMP @NEXTOPC
@OPC6C_2: CMP SI,$0200
JB @OPC6C_4
CMP SI,$021C
JAE @OPC6C_6
CMP SI,$0202
JNZ @OPC6C_8
TEST BYTE PTR [CS:BOXSWITCH],$FF
JZ @OPC6C_4
JMP @SCHAKEL_BRK
@OPC6C_6: CMP SI,$03FE
JNZ @OPC6C_4
AND AH,$F0
CMP AH,$A0
JNZ @OPC6C_4
MOV DI,$001C
JMP @OPC6C_3
@OPC6C_8: MOV AX,WORD PTR [SI]
AND AH,$F0
CMP AH,$A0
JNZ @OPC6C_4
MOV DI,SI
AND DI,$00FF
@OPC6C_3: PUSH ES
MOV AX,DS
ADD AX,$2000
MOV ES,AX
MOV AL,BYTE PTR [ES:DI+$0120]
POP ES
@OPC6C_7: MOV AH,BYTE PTR [SCHAKELBYTE]
AND AX,$0F0F
CMP AL,AH
JZ @OPC6C_4
CMP BYTE PTR [CS:AANTBOXRET],$20
JAE @OPC6C_5
{---jump into another box than currently at A000h---}
PUSH DI
PUSH AX
CALL SAVEZP90
POP AX
POP DI
PUSH BX
MOV BL,BYTE PTR [CS:AANTBOXRET]
MOV BH,$00
SHL BX,1
MOV BYTE PTR BOXRETURNS[CS:BX],AH
MOV AX,BP
MOV BYTE PTR BOXRETURNS[CS:BX+$01],AL
INC BYTE PTR [CS:AANTBOXRET]
POP BX
PUSH ES
MOV AX,DS
ADD AX,$2000
MOV ES,AX
MOV AL,BYTE PTR [ES:$0120+DI]
POP ES
MOV BYTE PTR [SCHAKELBYTE],AL
CALL SETA000MEM
@OPC6C_4: MOV SI,WORD PTR [SI]
JMP @NEXTOPC
@OPC6C_5: {---too many calls from one box to other; generate error 33---}
MOV BYTE PTR [CS:AANTBOXRET],$00
MOV SI,+32
JMP @OPCODE00
{---[6Dh: adc absolute]-----------------------------------------------------}
@OPCODE6D: MOV WORD PTR [INSTRCYCLES],$1804+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[6Eh: ror absolute]-----------------------------------------------------}
@OPCODE6E: MOV WORD PTR [INSTRCYCLES],$2306+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC6E_1
MOV AL,BH
SHR AL,1 {get carry}
RCR BYTE PTR [DI],1
JC @OPC6E_3
OR BYTE PTR [DI],$00
CLC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC6E_3: OR BYTE PTR [DI],$00
STC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC6E_1: MOV AL,BH
SHR AL,1 {get carry}
MOV AL,BYTE PTR [DI]
RCR AL,1
JC @OPC6E_4
OR AL,AL
CLC
JMP @UPDATECNZ
@OPC6E_4: OR AL,AL
STC
JMP @UPDATECNZ
{---[adc_dec]---------------------------------------------------------------}
@ADC_DEC: MOV AH,BH
SHR AH,1 {get carry}
ADC AL,BL
JO @ADCDEC1
DAA
LAHF
MOV BL,AL
AND BH,10111111b {clear overflow}
SAHF
JMP @UPDATECNZ
@ADCDEC1: DAA
LAHF
MOV BL,AL
OR BH,01000000b {set overflow}
SAHF
JMP @UPDATECNZ
{---[70h: bvs relative]-----------------------------------------------------}
@OPCODE70: MOV AL,BH
SHL AL,2 {get overflow}
JNC @OPC70_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPC70_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[71h: adc (indirect),y]-------------------------------------------------}
@OPCODE71: MOV WORD PTR [INSTRCYCLES],$2105+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[72h: adc (indirect)]---------------------------------------------------}
@OPCODE72: MOV WORD PTR [INSTRCYCLES],$1D05+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1
ADC BL,AL
JMP @UPDATECVNZ
{---[74h: stz zero page,x]--------------------------------------------------}
@OPCODE74: MOV WORD PTR [INSTRCYCLES],$1004
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],$00
JMP @NEXTOPC
{---[75h: adc zero page,x]--------------------------------------------------}
@OPCODE75: MOV WORD PTR [INSTRCYCLES],$1B04+$1400
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[76h: ror zero page,x]--------------------------------------------------}
@OPCODE76: MOV WORD PTR [INSTRCYCLES],$1306+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV AL,BH
SHR AL,1 {get carry}
RCR BYTE PTR [DI],1
JC @OPC76_1
OR BYTE PTR [DI],$00
CLC
JMP @UPDATECNZ
@OPC76_1: OR BYTE PTR [DI],$00
STC
JMP @UPDATECNZ
{---[78h: sei]--------------------------------------------------------------}
@OPCODE78: MOV WORD PTR [INSTRCYCLES],$0802
OR BH,00000100b
JMP @NEXTOPC
{---[79h: adc absolute,y]---------------------------------------------------}
@OPCODE79: MOV WORD PTR [INSTRCYCLES],$1B04+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[7Ah: ply implied]------------------------------------------------------}
@OPCODE7A: MOV WORD PTR [INSTRCYCLES],$0904+$0F00
INC BP
AND BP,$00FF
MOV DL,BYTE PTR [DS:BP+STACKBASE]
OR DL,DL
JMP @UPDATENZ
{---[7Ch: jmp (absolute,x)]-------------------------------------------------}
@OPCODE7C: MOV WORD PTR [INSTRCYCLES],$0806
MOV AX,WORD PTR [SI]
ADD AL,CL {add x-reg}
ADC AH,$00
MOV SI,AX
MOV SI,WORD PTR [SI]
JMP @NEXTOPC
{---[7Dh: adc absolute,x]---------------------------------------------------}
@OPCODE7D: MOV WORD PTR [INSTRCYCLES],$1B04+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @ADC_DEC
MOV AH,BH
SHR AH,1 {get carry}
ADC BL,AL
JMP @UPDATECVNZ
{---[7Eh: ror absolute,x]---------------------------------------------------}
@OPCODE7E: MOV WORD PTR [INSTRCYCLES],$2407+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPC7E_1
MOV AL,BH
SHR AL,1 {get carry}
RCR BYTE PTR [DI],1
JC @OPC7E_3
OR BYTE PTR [DI],$00
CLC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC7E_3: OR BYTE PTR [DI],$00
STC
CALL UPDATEGRAPH
JMP @UPDATECNZ
@OPC7E_1: MOV AL,BH
SHR AL,1 {get carry}
MOV AL,BYTE PTR [DI]
RCR AL,1
JC @OPC7E_4
OR AL,AL
CLC
JMP @UPDATECNZ
@OPC7E_4: OR AL,AL
STC
JMP @UPDATECNZ
{---[80h: bra relative]-----------------------------------------------------}
@OPCODE80: MOV WORD PTR [INSTRCYCLES],$0803
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
{---[81h: sta (indirect,x)]-------------------------------------------------}
@OPCODE81: MOV WORD PTR [INSTRCYCLES],$2506
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
JMP @STORE_A
{---[84h: sty zero page]----------------------------------------------------}
@OPCODE84: MOV WORD PTR [INSTRCYCLES],$0F03
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],DL
JMP @NEXTOPC
{---[85h: sta zero page]----------------------------------------------------}
@OPCODE85: MOV WORD PTR [INSTRCYCLES],$0F03
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],BL
JMP @NEXTOPC
{---[86h: stx zero page]----------------------------------------------------}
@OPCODE86: MOV WORD PTR [INSTRCYCLES],$0F03
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],CL
JMP @NEXTOPC
{---[88h: dey implied]------------------------------------------------------}
@OPCODE88: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
DEC DL
JMP @UPDATENZ
{---[89h: bit immediate (only affects zero flag)]---------------------------}
@OPCODE89: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
TEST BL,AL
LAHF
AND BH,11111101b
AND AH,01000000b
SHR AH,5
OR BH,AH {zero flag}
JMP @NEXTOPC
{---[8Ah: txa implied]------------------------------------------------------}
@OPCODE8A: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV BL,CL
OR BL,BL
JMP @UPDATENZ
{---[8Ch: sty absolute]-----------------------------------------------------}
@OPCODE8C: MOV WORD PTR [INSTRCYCLES],$1F04
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
MOV AL,AH
AND AL,$F0
CMP AL,$A0
JB @OPC8C_2
CMP AL,$B0
JNZ @OPC8C_3
CMP AH,$B0
JNZ @OPC8C_4
CMP DI,$B000
JZ @STY_B000
CMP DI,$B002
JZ @STY_B002
CMP DI,$B003
JNZ @OPC8C_3
JMP @STY_B003
@OPC8C_4: CMP AH,$B8
JZ @STY_VIA
JB @OPC8C_5
CMP AH,$BA
JNZ @OPC8C_6
MOV AL,DL
CALL WRITE_FDC
JMP @NEXTOPC
@OPC8C_6: CMP DI,$BFE0
JZ @STY_MOUSEX
CMP DI,$BFE1
JZ @STY_MOUSEY
CMP DI,$BFE2
JNZ @OPC8C_1
MOV AL,DL
JMP @STORE_MOUSENR
@OPC8C_1: CMP DI,SCHAKELBYTE
JNZ @OPC8C_3
CALL SAVEZP90
MOV BYTE PTR [DI],DL
CALL SETA000MEM
JMP @NEXTOPC
@OPC8C_2: MOV BYTE PTR [DI],DL
CALL UPDATEGRAPH
@OPC8C_3: JMP @NEXTOPC
@OPC8C_5: CMP AH,$B4
JB @OPC8C_3
MOV AL,DL
PUSH DX
MOV DX,DI
AND DX,$03FF
OUT DX,AL
POP DX
JMP @NEXTOPC
{---[8Dh: sta absolute]-----------------------------------------------------}
@OPCODE8D: MOV WORD PTR [INSTRCYCLES],$1F04
MOV AX,WORD PTR [SI]
ADD SI,+$02
@STORE_A: MOV DI,AX
MOV AL,AH
AND AL,$F0
CMP AL,$A0
JB @OPC8D_2
CMP AL,$B0
JNZ @OPC8D_3
CMP AH,$B0
JNZ @OPC8D_4
CMP DI,$B000
JZ @STA_B000
CMP DI,$B002
JZ @STA_B002
CMP DI,$B003
JNZ @OPC8D_3
JMP @STA_B003
@OPC8D_4: CMP AH,$B8
JZ @STA_VIA
JB @OPC8D_5
CMP AH,$BA
JNZ @OPC8D_6
MOV AL,BL
CALL WRITE_FDC
JMP @NEXTOPC
@OPC8D_6: CMP DI,$BFE0
JZ @STA_MOUSEX
CMP DI,$BFE1
JZ @STA_MOUSEY
CMP DI,$BFE2
JNZ @OPC8D_1
MOV AL,BL
JMP @STORE_MOUSENR
@OPC8D_1: CMP DI,SCHAKELBYTE
JNZ @OPC8D_3
CALL SAVEZP90
MOV BYTE PTR [DI],BL
CALL SETA000MEM
JMP @NEXTOPC
@OPC8D_2: MOV BYTE PTR [DI],BL
CALL UPDATEGRAPH
@OPC8D_3: JMP @NEXTOPC
@OPC8D_5: CMP AH,$B4
JB @OPC8D_3
MOV AL,BL
PUSH DX
MOV DX,DI
AND DX,$03FF
OUT DX,AL
POP DX
JMP @NEXTOPC
{---[8Eh: stx absolute]-----------------------------------------------------}
@OPCODE8E: MOV WORD PTR [INSTRCYCLES],$1F04
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
MOV AL,AH
AND AL,$F0
CMP AL,$A0
JB @OPC8E_2
CMP AL,$B0
JNZ @OPC8E_3
CMP AH,$B0
JNZ @OPC8E_4
CMP DI,$B000
JZ @STX_B000
CMP DI,$B002
JZ @STX_B002
CMP DI,$B003
JNZ @OPC8E_3
JMP @STX_B003
@OPC8E_4: CMP AH,$B8
JZ @STX_VIA
JB @OPC8E_5
CMP AH,$BA
JNZ @OPC8E_6
MOV AL,CL
CALL WRITE_FDC
JMP @NEXTOPC
@OPC8E_6: CMP DI,$BFE0
JZ @STX_MOUSEX
CMP DI,$BFE1
JZ @STX_MOUSEY
CMP DI,$BFE2
JNZ @OPC8E_1
MOV AL,CL
JMP @STORE_MOUSENR
@OPC8E_1: CMP DI,SCHAKELBYTE
JNZ @OPC8E_3
CALL SAVEZP90
MOV BYTE PTR [DI],CL
CALL SETA000MEM
JMP @NEXTOPC
@OPC8E_2: MOV BYTE PTR [DI],CL
CALL UPDATEGRAPH
@OPC8E_3: JMP @NEXTOPC
@OPC8E_5: CMP AH,$B4
JB @OPC8E_3
MOV AL,CL
PUSH DX
MOV DX,DI
AND DX,$03FF
OUT DX,AL
POP DX
JMP @NEXTOPC
{---[sta/stx/sty/stz_b002]--------------------------------------------------}
@STZ_B002: MOV AL,$00
JMP @S_B002_1
@STA_B002: MOV AL,BL
JMP @S_B002_1
@STX_B002: MOV AL,CL
JMP @S_B002_1
@STY_B002: MOV AL,DL
@S_B002_1: MOV AH,BYTE PTR [$B002]
AND AL,$0F
AND BYTE PTR [$B002],$F0
OR BYTE PTR [$B002],AL
PUSH AX
AND AX,$0808
CMP AL,AH
JZ @S_B002_4
OR AL,AL
JNZ @S_B002_5
CMP BYTE PTR [CS:GRAPHMODE],$05
JB @S_B002_6
PUSH DX
MOV DX,$03C8
MOV AL,$03
OUT DX,AL
INC DX
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3+1)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(3*3+2)]
OUT DX,AL
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+1)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+2)]
OUT DX,AL
POP DX
JMP @S_B002_4
@S_B002_6: PUSH DX
MOV DX,$03C8
MOV AL,$01
OUT DX,AL
INC DX
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3+1)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(1*3+2)]
OUT DX,AL
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+1)]
OUT DX,AL
MOV AL,BYTE PTR EMULCOLORS[CS:(7*3+2)]
OUT DX,AL
POP DX
JMP @S_B002_4
@S_B002_5: CMP BYTE PTR [CS:GRAPHMODE],$05
JB @S_B002_7
PUSH DX
MOV DX,$03C8
MOV AL,$03
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSCOLOR[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$02]
OUT DX,AL
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSCOLOR[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSCOLOR[CS:$02]
OUT DX,AL
POP DX
JMP @S_B002_4
@S_B002_7: PUSH DX
MOV DX,$03C8
MOV AL,$01
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSMONO[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$02]
OUT DX,AL
CMP BYTE PTR [CS:GRAPHMODE],$00
JZ @S_B002_9
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,BYTE PTR INTENSMONO[CS:$00]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$01]
OUT DX,AL
MOV AL,BYTE PTR INTENSMONO[CS:$02]
OUT DX,AL
@S_B002_9: POP DX
@S_B002_4: POP AX
AND AX,$0404
CMP AL,AH
JZ @S_B002_2
CMP BYTE PTR [CS:SOUNDOUTPUT],$00
JZ @S_B002_2
CMP BYTE PTR @SBAVAIL,$00
JNZ @S_B002_3
IN AL,$61
XOR AL,$02
OUT $61,AL
ADD WORD PTR [PCCYCLES],+95
JMP @NEXTOPC
@S_B002_3: CALL SBSOUND
ADD WORD PTR [PCCYCLES],+300
JMP @NEXTOPC
@S_B002_2: ADD WORD PTR [PCCYCLES],+25
JMP @NEXTOPC
{---[sta/stx/sty/stz_b003]--------------------------------------------------}
@STZ_B003: MOV AL,$00
JMP @S_B003_1
@STA_B003: MOV AL,BL
JMP @S_B003_1
@STX_B003: MOV AL,CL
JMP @S_B003_1
@STY_B003: MOV AL,DL
@S_B003_1: TEST AL,00001000b
JNZ @S_B003_2
PUSH CX
MOV CL,AL
AND CL,00000110b
SHR CL,1
AND AL,00000001b
SHL AL,CL
POP CX
MOV AH,AL
NEG AH
AND AH,BYTE PTR [$B002]
OR AL,AH
JMP @S_B002_1
@S_B003_2: ADD WORD PTR [PCCYCLES],+10
JMP @NEXTOPC
{---[sta/stx/sty/stz_b000]--------------------------------------------------}
@STZ_B000: MOV AL,$00
JMP @S_B000_1
@STA_B000: MOV AL,BL
JMP @S_B000_1
@STX_B000: MOV AL,CL
JMP @S_B000_1
@STY_B000: MOV AL,DL
@S_B000_1: ADD WORD PTR [PCCYCLES],+25
MOV BYTE PTR [$B000],AL
SHR AL,5
JNC @S_B000_2 {lores}
SHR AL,1
JNC @S_B000_3 {hires color mode}
INC AL {hires mode}
JMP @S_B000_4
@S_B000_3: ADD AL,$05
JMP @S_B000_4
@S_B000_2: MOV AL,$00
@S_B000_4: CMP AL,BYTE PTR [CS:GRAPHMODE]
JZ @S_B000_5
MOV BYTE PTR [CS:GRAPHMODE],AL
CALL SETBORDERCOL
CALL REBUILDSCREEN
@S_B000_5: JMP @NEXTOPC
{---[90h: bcc relative]-----------------------------------------------------}
@OPCODE90: MOV AL,BH
SHR AL,1 {get carry}
JC @OPC90_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPC90_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[91h: sta (indirect),y]-------------------------------------------------}
@OPCODE91: MOV WORD PTR [INSTRCYCLES],$2306
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
JMP @STORE_A
{---[92h: sta (indirect)]---------------------------------------------------}
@OPCODE92: MOV WORD PTR [INSTRCYCLES],$2405
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
JMP @STORE_A
{---[94h: sty zero page,x]--------------------------------------------------}
@OPCODE94: MOV WORD PTR [INSTRCYCLES],$1004
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],DL
JMP @NEXTOPC
{---[95h: sta zero page,x]--------------------------------------------------}
@OPCODE95: MOV WORD PTR [INSTRCYCLES],$1004
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],BL
JMP @NEXTOPC
{---[96h: stx zero page,y]--------------------------------------------------}
@OPCODE96: MOV WORD PTR [INSTRCYCLES],$1004
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,DL
MOV AH,$00
MOV DI,AX
MOV BYTE PTR [DI],CL
JMP @NEXTOPC
{---[98h: tya implied]------------------------------------------------------}
@OPCODE98: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV BL,DL
OR BL,BL
JMP @UPDATENZ
{---[99h: sta absolute,y]---------------------------------------------------}
@OPCODE99: MOV WORD PTR [INSTRCYCLES],$2105
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
JMP @STORE_A
{---[9Ah: txs implied]------------------------------------------------------}
@OPCODE9A: MOV WORD PTR [INSTRCYCLES],$0902
MOV AL,CL
MOV AH,$00
MOV BP,AX
JMP @NEXTOPC
{---[9Bh: txy implied]------------------------------------------------------}
@OPCODE9B: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV DL,CL
OR DL,DL
JMP @UPDATENZ
{---[9Ch: stz absolute]-----------------------------------------------------}
@OPCODE9C: MOV WORD PTR [INSTRCYCLES],$1F04
MOV AX,WORD PTR [SI]
ADD SI,+$02
@STORE_Z: MOV DI,AX
MOV AL,AH
AND AL,$F0
CMP AL,$A0
JB @OPC9C_2
CMP AL,$B0
JNZ @OPC9C_3
CMP AH,$B0
JNZ @OPC9C_4
CMP DI,$B000
JZ @STZ_B000
CMP DI,$B002
JZ @STZ_B002
CMP DI,$B003
JNZ @OPC9C_3
JMP @STZ_B003
@OPC9C_4: CMP AH,$B8
JZ @STZ_VIA
JB @OPC9C_5
CMP AH,$BA
JNZ @OPC9C_6
MOV AL,$00
CALL WRITE_FDC
JMP @NEXTOPC
@OPC9C_6: CMP DI,$BFE0
JZ @STZ_MOUSEX
CMP DI,$BFE1
JZ @STZ_MOUSEY
CMP DI,$BFE2
JNZ @OPC9C_1
MOV AL,$00
JMP @STORE_MOUSENR
@OPC9C_1: CMP DI,SCHAKELBYTE
JNZ @OPC9C_3
CALL SAVEZP90
MOV BYTE PTR [DI],$00
CALL SETA000MEM
JMP @NEXTOPC
@OPC9C_2: MOV BYTE PTR [DI],$00
CALL UPDATEGRAPH
@OPC9C_3: JMP @NEXTOPC
@OPC9C_5: CMP AH,$B4
JB @OPC9C_3
MOV AL,$00
PUSH DX
MOV DX,DI
AND DX,$03FF
OUT DX,AL
POP DX
JMP @NEXTOPC
{---[9Dh: sta absolute,x]---------------------------------------------------}
@OPCODE9D: MOV WORD PTR [INSTRCYCLES],$2105
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @STORE_A
{---[9Eh: stz absolute,x]---------------------------------------------------}
@OPCODE9E: MOV WORD PTR [INSTRCYCLES],$2105
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @STORE_Z
{---[A0h: ldy immediate]----------------------------------------------------}
@OPCODEA0: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV DL,AL
OR AL,AL
JMP @UPDATENZ
{---[A1h: lda (indirect,x)]-------------------------------------------------}
@OPCODEA1: MOV WORD PTR [INSTRCYCLES],$1D06+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
JMP @LOAD_A
{---[A2h: ldx immediate]----------------------------------------------------}
@OPCODEA2: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV CL,AL
OR AL,AL
JMP @UPDATENZ
{---[A4h: ldy zero page]----------------------------------------------------}
@OPCODEA4: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DL,BYTE PTR [DI]
OR DL,DL
JMP @UPDATENZ
{---[A5h: lda zero page]----------------------------------------------------}
@OPCODEA5: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV BL,BYTE PTR [DI]
OR BL,BL
JMP @UPDATENZ
{---[A6h: ldx zero page]----------------------------------------------------}
@OPCODEA6: MOV WORD PTR [INSTRCYCLES],$1003+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV CL,BYTE PTR [DI]
OR CL,CL
JMP @UPDATENZ
{---[A8h: tay implied]------------------------------------------------------}
@OPCODEA8: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV DL,BL
OR DL,DL
JMP @UPDATENZ
{---[A9h: lda immediate]----------------------------------------------------}
@OPCODEA9: MOV WORD PTR [INSTRCYCLES],$0B02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV BL,AL
OR AL,AL
JMP @UPDATENZ
{---[AAh: tax implied]------------------------------------------------------}
@OPCODEAA: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV CL,BL
OR CL,CL
JMP @UPDATENZ
{---[lda/ldx/ldy_b002]------------------------------------------------------}
@LDY_B002: CALL @L_B002_1
MOV DL,AL
JMP @UPDATENZ
@LDA_B002: CALL @L_B002_1
MOV BL,AL
JMP @UPDATENZ
@LDX_B002: CALL @L_B002_1
MOV CL,AL
JMP @UPDATENZ
@L_B002_1: TEST BYTE PTR [CS:CPUSPEEDMODE],$01
JZ @L_B002_4
MOV AL,$00
CMP WORD PTR [AANTCYCLES],CYCLESFLYBACK
JB @L_B002_6
MOV AL,$80
CMP WORD PTR [AANTCYCLES],(1026620/60)
JB @L_B002_6
JMP @L_B002_7
@L_B002_4: MOV AL,$00
CMP WORD PTR [AANTCYCLES],CYCLESFLYBACK
JB @L_B002_6
CMP WORD PTR [AANTCYCLES],(1026620/60)
JAE @L_B002_5
PUSH DX
MOV DX,$03DA
IN AL,DX
POP DX
TEST AL,$08
JNZ @L_B002_7
MOV AL,$80
JMP @L_B002_6
@L_B002_5: PUSH BX
MOV BX,$0A00
PUSH DX
MOV DX,$03DA
@L_B002_9: IN AL,DX
TEST AL,$08
JNZ @L_B002_10
DEC BX
JNZ @L_B002_9
@L_B002_10: POP DX
POP BX
@L_B002_7: MOV WORD PTR [AANTCYCLES],$0000
MOV AL,$00
@L_B002_6: AND BYTE PTR [$B002],$7F
OR AL,BYTE PTR [$B002]
@L_B002_3: PUSH DI
MOV DI,$0038 {---alt---}
CMP BYTE PTR [CS:ALTKEYB],$00
JZ @L_B002_8
MOV DI,$0036 {---right shift---}
@L_B002_8: TEST BYTE PTR TOETS[CS:DI],$03
POP DI
JZ @L_B002_2
ADD WORD PTR [PCCYCLES],+158
AND AL,$BF
RETN
@L_B002_2: ADD WORD PTR [PCCYCLES],+158
OR AL,$40
RETN
{---[lda/ldx/ldy_b003]------------------------------------------------------}
@LDY_B003: CALL @L_B003_1
MOV DL,AL
JMP @UPDATENZ
@LDA_B003: CALL @L_B003_1
MOV BL,AL
JMP @UPDATENZ
@LDX_B003: CALL @L_B003_1
MOV CL,AL
JMP @UPDATENZ
@L_B003_1: AND BYTE PTR [$B003],$3F
MOV AL,$C0
OR AL,BYTE PTR [$B003]
CMP BYTE PTR [CS:ALTKEYB],$00
JNZ @L_B003_9
{---standard keyboard---}
MOV AH,BYTE PTR TOETS[CS:$2A] {---left shift---}
OR AH,BYTE PTR TOETS[CS:$36] {---right shift---}
OR AH,BYTE PTR TOETS[CS:$4B] {---crsr left---}
OR AH,BYTE PTR TOETS[CS:$50] {---crsr down---}
AND AH,$03
JZ @L_B003_5
AND AL,$7F
@L_B003_5: MOV AH,BYTE PTR TOETS[CS:$1D] {---ctrl---}
OR AH,BYTE PTR TOETS[CS:$38] {---alt---}
AND AH,$03
JZ @L_B003_3
AND AL,$BF
JMP @L_B003_3
@L_B003_9: {---alternate keyboard---}
MOV AH,BYTE PTR TOETS[CS:$1D] {---ctrl---}
OR AH,BYTE PTR TOETS[CS:$38] {---alt---}
AND AH,$03
JZ @L_B003_10
AND AL,$7F
@L_B003_10: MOV AH,BYTE PTR TOETS[CS:$2A] {---left shift---}
OR AH,BYTE PTR TOETS[CS:$36] {---right shift---}
AND AH,$03
JZ @L_B003_3
AND AL,$BF
@L_B003_3: ADD WORD PTR [PCCYCLES],+158
OR AL,AL
RETN
{---[ACh: ldy absolute]-----------------------------------------------------}
@OPCODEAC: MOV WORD PTR [INSTRCYCLES],$1604+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
@LOAD_Y: CMP DI,$B001
JB @OPCAC_1
JZ @LDY_B001
CMP DI,$B003
JB @LDY_B002
JZ @LDY_B003
MOV AX,DI
CMP AH,$B8
JZ @LDY_VIA
JB @OPCAC_3
CMP AH,$BA
JNZ @OPCAC_2
CALL READ_FDC
MOV DL,AL
OR AL,AL
JMP @UPDATENZ
@OPCAC_2: CMP AX,FLIPFLOP
JNZ @OPCAC_1
NOT BYTE PTR [DI]
@OPCAC_1: MOV DL,BYTE PTR [DI]
OR DL,DL
JMP @UPDATENZ
@OPCAC_3: CMP AH,$B4
JB @OPCAC_2
PUSH DX
AND AX,$03FF
MOV DX,AX
IN AL,DX
MOV BYTE PTR [DI],AL
POP DX
MOV DL,AL
OR DL,DL
JMP @UPDATENZ
{---[ADh: lda absolute]-----------------------------------------------------}
@OPCODEAD: MOV WORD PTR [INSTRCYCLES],$1604+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
@LOAD_A: CMP DI,$B001
JB @OPCAD_1
JZ @LDA_B001
CMP DI,$B003
JB @LDA_B002
JZ @LDA_B003
MOV AX,DI
CMP AH,$B8
JZ @LDA_VIA
JB @OPCAD_3
CMP AH,$BA
JNZ @OPCAD_2
CALL READ_FDC
MOV BL,AL
OR AL,AL
JMP @UPDATENZ
@OPCAD_2: CMP AX,FLIPFLOP
JNZ @OPCAD_1
NOT BYTE PTR [DI]
@OPCAD_1: MOV BL,BYTE PTR [DI]
OR BL,BL
JMP @UPDATENZ
@OPCAD_3: CMP AH,$B4
JB @OPCAD_2
PUSH DX
AND AX,$03FF
MOV DX,AX
IN AL,DX
MOV BYTE PTR [DI],AL
POP DX
MOV BL,AL
OR BL,BL
JMP @UPDATENZ
{---[AEh: ldx absolute]-----------------------------------------------------}
@OPCODEAE: MOV WORD PTR [INSTRCYCLES],$1604+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
@LOAD_X: CMP DI,$B001
JB @OPCAE_1
JZ @LDX_B001
CMP DI,$B003
JB @LDX_B002
JZ @LDX_B003
MOV AX,DI
CMP AH,$B8
JZ @LDX_VIA
JB @OPCAE_3
CMP AH,$BA
JNZ @OPCAE_2
CALL READ_FDC
MOV CL,AL
OR AL,AL
JMP @UPDATENZ
@OPCAE_2: CMP AX,FLIPFLOP
JNZ @OPCAE_1
NOT BYTE PTR [DI]
@OPCAE_1: MOV CL,BYTE PTR [DI]
OR CL,CL
JMP @UPDATENZ
@OPCAE_3: CMP AH,$B4
JB @OPCAE_2
PUSH DX
AND AX,$03FF
MOV DX,AX
IN AL,DX
MOV BYTE PTR [DI],AL
POP DX
MOV CL,AL
OR CL,CL
JMP @UPDATENZ
{---[lda/ldx/ldy_b001]------------------------------------------------------}
@LDY_B001: CALL @L_B001_1
MOV DL,AL
OR AL,AL
JMP @UPDATENZ
@LDA_B001: CALL @L_B001_1
MOV BL,AL
OR AL,AL
JMP @UPDATENZ
@LDX_B001: CALL @L_B001_1
MOV CL,AL
OR AL,AL
JMP @UPDATENZ
@L_B001_1: MOV AL,$FF
CMP BYTE PTR [CS:ALTKEYB],$00
JNZ @L_B001_9
{---standard keyboard---}
MOV AH,BYTE PTR TOETS[CS:$2A] {---left shift---}
OR AH,BYTE PTR TOETS[CS:$36] {---right shift---}
OR AH,BYTE PTR TOETS[CS:$4B] {---crsr left---}
OR AH,BYTE PTR TOETS[CS:$50] {---crsr down---}
AND AH,$03
JZ @L_B001_5
AND AL,$7F
@L_B001_5: TEST BYTE PTR TOETS[CS:$1D],$03 {---ctrl---}
JZ @L_B001_3
AND AL,$BF
JMP @L_B001_3
@L_B001_9: {---alternate keyboard---}
MOV AH,BYTE PTR TOETS[CS:$1D] {---ctrl---}
OR AH,BYTE PTR TOETS[CS:$38] {---alt---}
AND AH,$03
JZ @L_B001_10
AND AL,$7F
@L_B001_10: TEST BYTE PTR TOETS[CS:$2A],$03 {---left shift---}
JZ @L_B001_3
AND AL,$BF
@L_B001_3: PUSH BX
MOV BL,BYTE PTR [$B000]
AND BX,$000F
CMP BL,$09
JA @L_B001_6
SHL BX,3
MOV DI,BX
CMP BYTE PTR [CS:ALTKEYB],$00
JNZ @L_B001_8
ADD DI,OFFSET KEYSCAN
JMP @L_B001_7
@L_B001_8: ADD DI,OFFSET ALTKEYSCAN
@L_B001_7: MOV AH,11111110b
@L_B001_4: MOV BL,BYTE PTR [CS:DI]
TEST BYTE PTR TOETS[CS:BX],$03 {BH=0}
JZ @L_B001_2
AND AL,AH
@L_B001_2: INC DI
STC
RCL AH,1
CMP AH,10111111b
JNZ @L_B001_4
@L_B001_6: POP BX
MOV BYTE PTR [$B001],AL
ADD WORD PTR [PCCYCLES],+156
RETN
{---[B0h: bcs relative]-----------------------------------------------------}
@OPCODEB0: MOV AL,BH
SHR AL,1 {get carry}
JNC @OPCB0_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPCB0_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[B1h: lda (indirect),y]-------------------------------------------------}
@OPCODEB1: MOV WORD PTR [INSTRCYCLES],$1E05+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
JMP @LOAD_A
{---[B2h: lda (indirect)]---------------------------------------------------}
@OPCODEB2: MOV WORD PTR [INSTRCYCLES],$1C05+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
JMP @LOAD_A
{---[B4h: ldy zero page,x]--------------------------------------------------}
@OPCODEB4: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DL,BYTE PTR [DI]
OR DL,DL
JMP @UPDATENZ
{---[B5h: lda zero page,x]--------------------------------------------------}
@OPCODEB5: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV BL,BYTE PTR [DI]
OR BL,BL
JMP @UPDATENZ
{---[B6h: ldx zero page,y]--------------------------------------------------}
@OPCODEB6: MOV WORD PTR [INSTRCYCLES],$1104+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,DL {add y-reg}
MOV AH,$00
MOV DI,AX
MOV CL,BYTE PTR [DI]
OR CL,CL
JMP @UPDATENZ
{---[B8h: clv]--------------------------------------------------------------}
@OPCODEB8: MOV WORD PTR [INSTRCYCLES],$0802
AND BH,10111111b
JMP @NEXTOPC
{---[B9h: lda absolute,y]---------------------------------------------------}
@OPCODEB9: MOV WORD PTR [INSTRCYCLES],$1B04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
JMP @LOAD_A
{---[BAh: tsx implied]------------------------------------------------------}
@OPCODEBA: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV AX,BP
MOV CL,AL
OR AL,AL
JMP @UPDATENZ
{---[BBh: tyx implied]------------------------------------------------------}
@OPCODEBB: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
MOV CL,DL
OR CL,CL
JMP @UPDATENZ
{---[BCh: ldy absolute,x]---------------------------------------------------}
@OPCODEBC: MOV WORD PTR [INSTRCYCLES],$1B04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
JMP @LOAD_Y
{---[BDh: lda absolute,x]---------------------------------------------------}
@OPCODEBD: MOV WORD PTR [INSTRCYCLES],$1B04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
JMP @LOAD_A
{---[BEh: ldx absolute,y]---------------------------------------------------}
@OPCODEBE: MOV WORD PTR [INSTRCYCLES],$1B04+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
JMP @LOAD_X
{---[C0h: cpy immediate]----------------------------------------------------}
@OPCODEC0: MOV WORD PTR [INSTRCYCLES],$0D02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
CMP DL,AL
CMC
JMP @UPDATECNZ
{---[C1h: cmp (indirect,x)]-------------------------------------------------}
@OPCODEC1: MOV WORD PTR [INSTRCYCLES],$1606+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[C4h: cpy zero page]----------------------------------------------------}
@OPCODEC4: MOV WORD PTR [INSTRCYCLES],$1203+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
CMP DL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[C5h: cmp zero page]----------------------------------------------------}
@OPCODEC5: MOV WORD PTR [INSTRCYCLES],$1203+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[C6h: dec zero page]----------------------------------------------------}
@OPCODEC6: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
DEC BYTE PTR [DI]
JMP @UPDATENZ
{---[C8h: iny implied]------------------------------------------------------}
@OPCODEC8: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
INC DL
JMP @UPDATENZ
{---[C9h: cmp immediate]----------------------------------------------------}
@OPCODEC9: MOV WORD PTR [INSTRCYCLES],$0D02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
CMP BL,AL
CMC
JMP @UPDATECNZ
{---[CAh: dex implied]------------------------------------------------------}
@OPCODECA: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
DEC CL
JMP @UPDATENZ
{---[CCh: cpy absolute]-----------------------------------------------------}
@OPCODECC: MOV WORD PTR [INSTRCYCLES],$1004+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
CMP DL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[CDh: cmp absolute]-----------------------------------------------------}
@OPCODECD: MOV WORD PTR [INSTRCYCLES],$1204+$0F00
MOV DI,WORD PTR [SI]
ADD SI,+$02
CMP DI,FLIPFLOP
JNZ @OPCCD_1
NOT BYTE PTR [DI]
@OPCCD_1: CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[CEh: dec absolute]-----------------------------------------------------}
@OPCODECE: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
@DEC_ABS: MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPCCE_1
DEC BYTE PTR [DI]
CALL UPDATEGRAPH
JMP @UPDATENZ
@OPCCE_1: CMP AH,$B0
JZ @OPCCE_2
MOV AL,BYTE PTR [DI]
DEC AL
JMP @UPDATENZ
@OPCCE_2: CMP DI,$B002
JNZ @OPCCE_3
MOV AH,AL
AND AH,$F0
DEC AL
AND AL,$0F
OR AL,AH
MOV BYTE PTR [$B002],AL
JMP @UPDATENZ
@OPCCE_3: CMP DI,SCHAKELBYTE
JZ @OPCCE_4
DEC BYTE PTR [DI]
JMP @UPDATENZ
@OPCCE_4: CALL SAVEZP90
DEC BYTE PTR [DI]
PUSHF
CALL SETA000MEM
POPF
JMP @UPDATENZ
{---[D0h: bne relative]-----------------------------------------------------}
@OPCODED0: MOV AL,BH
SHR AL,2 {get zero}
JC @OPCD0_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPCD0_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[D1h: cmp (indirect),y]-------------------------------------------------}
@OPCODED1: MOV WORD PTR [INSTRCYCLES],$1905+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[D2h: cmp (indirect)]---------------------------------------------------}
@OPCODED2: MOV WORD PTR [INSTRCYCLES],$1505+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[D5h: cmp zero page,x]--------------------------------------------------}
@OPCODED5: MOV WORD PTR [INSTRCYCLES],$1304+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[D6h: dec zero page,x]--------------------------------------------------}
@OPCODED6: MOV WORD PTR [INSTRCYCLES],$1206+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
DEC BYTE PTR [DI]
JMP @UPDATENZ
{---[D8h: cld]--------------------------------------------------------------}
@OPCODED8: MOV WORD PTR [INSTRCYCLES],$0802
AND BH,11110111b
JMP @NEXTOPC
{---[D9h: cmp absolute,y]---------------------------------------------------}
@OPCODED9: MOV WORD PTR [INSTRCYCLES],$1304+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[DAh: phx implied]------------------------------------------------------}
@OPCODEDA: MOV WORD PTR [INSTRCYCLES],$0903
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],CL
DEC BP
JMP @NEXTOPC
{---[DDh: cmp absolute,x]---------------------------------------------------}
@OPCODEDD: MOV WORD PTR [INSTRCYCLES],$1304+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
CMP BL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[DEh: dec absolute,x]---------------------------------------------------}
@OPCODEDE: MOV WORD PTR [INSTRCYCLES],$1607+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @DEC_ABS
{---[E0h: cpx immediate]----------------------------------------------------}
@OPCODEE0: MOV WORD PTR [INSTRCYCLES],$0D02+$0F00
MOV AL,BYTE PTR [SI]
INC SI
CMP CL,AL
CMC
JMP @UPDATECNZ
{---[E1h: sbc (indirect,x)]-------------------------------------------------}
@OPCODEE1: MOV WORD PTR [INSTRCYCLES],$2006+$1400
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[E4h: cpx zero page]----------------------------------------------------}
@OPCODEE4: MOV WORD PTR [INSTRCYCLES],$1203+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
CMP CL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[E5h: sbc zero page]----------------------------------------------------}
@OPCODEE5: MOV WORD PTR [INSTRCYCLES],$1C03+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[E6h: inc zero page]----------------------------------------------------}
@OPCODEE6: MOV WORD PTR [INSTRCYCLES],$1105+$0F00
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
INC BYTE PTR [DI]
JMP @UPDATENZ
{---[E8h: inx implied]------------------------------------------------------}
@OPCODEE8: MOV WORD PTR [INSTRCYCLES],$0802+$0F00
INC CL
JMP @UPDATENZ
{---[E9h: sbc immediate]----------------------------------------------------}
@OPCODEE9:
MOV WORD PTR [INSTRCYCLES],$1702+$1400
MOV AL,BYTE PTR [SI]
INC SI
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[EAh: nop implied]------------------------------------------------------}
@OPCODEEA:
@OPCODE03:
@OPCODE07:
@OPCODE0B:
@OPCODE0F:
@OPCODE13:
@OPCODE17:
@OPCODE1F:
@OPCODE23:
@OPCODE27:
@OPCODE2B:
@OPCODE2F:
@OPCODE33:
@OPCODE37:
@OPCODE3F:
@OPCODE43:
@OPCODE47:
@OPCODE4B:
@OPCODE4F:
@OPCODE53:
@OPCODE57:
@OPCODE5B:
@OPCODE5F:
@OPCODE63:
@OPCODE67:
@OPCODE6B:
@OPCODE6F:
@OPCODE73:
@OPCODE77:
@OPCODE7B:
@OPCODE7F:
@OPCODE83:
@OPCODE87:
@OPCODE8B:
@OPCODE8F:
@OPCODE93:
@OPCODE97:
@OPCODE9F:
@OPCODEA3:
@OPCODEA7:
@OPCODEAB:
@OPCODEAF:
@OPCODEB3:
@OPCODEB7:
@OPCODEBF:
@OPCODEC3:
@OPCODEC7:
@OPCODECB:
@OPCODECF:
@OPCODED3:
@OPCODED7:
@OPCODEDB:
@OPCODEDF:
@OPCODEE3:
@OPCODEE7:
@OPCODEEF:
@OPCODEF3:
@OPCODEF7:
@OPCODEFB:
@OPCODEFF: MOV WORD PTR [INSTRCYCLES],$0702
JMP @NEXTOPC
{---[EBh: swa implied]------------------------------------------------------}
@OPCODEEB: MOV WORD PTR [INSTRCYCLES],$0902+$0F00
XCHG BL,BYTE PTR [CS:ACCU_B]
OR BL,BL
JMP @UPDATENZ
{---[ECh: cpx absolute]-----------------------------------------------------}
@OPCODEEC: MOV WORD PTR [INSTRCYCLES],$1004+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
CMP CL,BYTE PTR [DI]
CMC
JMP @UPDATECNZ
{---[EDh: sbc absolute]-----------------------------------------------------}
@OPCODEED: MOV WORD PTR [INSTRCYCLES],$1A04+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[EEh: inc absolute]-----------------------------------------------------}
@OPCODEEE: MOV WORD PTR [INSTRCYCLES],$1406+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
@INC_ABS: MOV DI,AX
AND AH,$F0
CMP AH,$A0
JAE @OPCEE_1
INC BYTE PTR [DI]
CALL UPDATEGRAPH
JMP @UPDATENZ
@OPCEE_1: CMP AH,$B0
JZ @OPCEE_2
MOV AL,BYTE PTR [DI]
INC AL
JMP @UPDATENZ
@OPCEE_2: CMP DI,$B002
JNZ @OPCEE_3
MOV AH,AL
AND AH,$F0
INC AL
AND AL,$0F
OR AL,AH
MOV BYTE PTR [$B002],AL
JMP @UPDATENZ
@OPCEE_3: CMP DI,SCHAKELBYTE
JZ @OPCEE_4
INC BYTE PTR [DI]
JMP @UPDATENZ
@OPCEE_4: CALL SAVEZP90
INC BYTE PTR [DI]
PUSHF
CALL SETA000MEM
POPF
JMP @UPDATENZ
{---[sbc_dec]---------------------------------------------------------------}
@SBC_DEC: XCHG AL,BL
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB AL,BL
JO @SBCDEC1
DAS
CMC
LAHF
MOV BL,AL
AND BH,10111111b {clear overflow}
SAHF
JMP @UPDATECNZ
@SBCDEC1: DAS
CMC
LAHF
MOV BL,AL
OR BH,01000000b {set overflow}
SAHF
JMP @UPDATECNZ
{---[F0h: beq relative]-----------------------------------------------------}
@OPCODEF0: MOV AL,BH
SHR AL,2 {get zero}
JNC @OPCF0_1
MOV WORD PTR [INSTRCYCLES],$1303
MOV AL,BYTE PTR [SI]
INC SI
CBW
ADD SI,AX
JMP @NEXTOPC
@OPCF0_1: MOV WORD PTR [INSTRCYCLES],$0E02
INC SI
JMP @NEXTOPC
{---[F1h: sbc (indirect),y]-------------------------------------------------}
@OPCODEF1: MOV WORD PTR [INSTRCYCLES],$2305+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV AX,WORD PTR [DI] {get address from atom memory}
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[F2h: sbc (indirect)]---------------------------------------------------}
@OPCODEF2: MOV WORD PTR [INSTRCYCLES],$1F05+$1400
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
MOV DI,AX
MOV DI,WORD PTR [DI] {get address from atom memory}
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[F5h: sbc zero page,x]--------------------------------------------------}
@OPCODEF5: MOV WORD PTR [INSTRCYCLES],$1D04+$1400
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[F6h: inc zero page,x]--------------------------------------------------}
@OPCODEF6: MOV WORD PTR [INSTRCYCLES],$1206+$0F00
MOV AL,BYTE PTR [SI]
INC SI
ADD AL,CL {add x-reg}
MOV AH,$00
MOV DI,AX
INC BYTE PTR [DI]
JMP @UPDATENZ
{---[F8h: sed]--------------------------------------------------------------}
@OPCODEF8: MOV WORD PTR [INSTRCYCLES],$0802
OR BH,00001000b
JMP @NEXTOPC
{---[F9h: sbc absolute,y]---------------------------------------------------}
@OPCODEF9: MOV WORD PTR [INSTRCYCLES],$1D04+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,DL {add y-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[FAh: plx implied]------------------------------------------------------}
@OPCODEFA: MOV WORD PTR [INSTRCYCLES],$0904+$0F00
INC BP
AND BP,$00FF
MOV CL,BYTE PTR [DS:BP+STACKBASE]
OR CL,CL
JMP @UPDATENZ
{---[FCh: jsr (absolute,x)]-------------------------------------------------}
@OPCODEFC: MOV WORD PTR [INSTRCYCLES],$1906
MOV AX,SI
INC AX
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AH
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
MOV AX,WORD PTR [SI]
ADD AL,CL {add x-reg}
ADC AH,$00
MOV SI,AX
MOV SI,WORD PTR [SI]
JMP @NEXTOPC
{---[FDh: sbc absolute,x]---------------------------------------------------}
@OPCODEFD: MOV WORD PTR [INSTRCYCLES],$1D04+$1400
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
MOV DI,AX
MOV AL,BYTE PTR [DI] {get byte from atom memory}
TEST BH,00001000b
JNZ @SBC_DEC
MOV AH,BH
SHR AH,1 {get carry}
CMC
SBB BL,AL
CMC
JMP @UPDATECVNZ
{---[FEh: inc absolute,x]---------------------------------------------------}
@OPCODEFE: MOV WORD PTR [INSTRCYCLES],$1607+$0F00
MOV AX,WORD PTR [SI]
ADD SI,+$02
ADD AL,CL {add x-reg}
ADC AH,$00
JMP @INC_ABS
{---[updatenz]--------------------------------------------------------------}
@UPDATENZ: LAHF
AND BH,01111101b
MOV AL,AH
AND AH,10000000b
OR BH,AH {negative}
AND AL,01000000b
SHR AL,5
OR BH,AL {zero}
JMP @NEXTOPC
{---[updatecnz]-------------------------------------------------------------}
@UPDATECNZ: LAHF
AND BH,01111100b
MOV AL,AH
AND AH,10000001b
OR BH,AH {negative & carry}
AND AL,01000000b
SHR AL,5
OR BH,AL {zero}
JMP @NEXTOPC
{---[updatecvnz]------------------------------------------------------------}
@UPDATECVNZ: LAHF
JNO @CVNZ_2
OR BH,01000000b {overflow}
JMP @CVNZ_1
@CVNZ_2: AND BH,10111111b {no overflow}
@CVNZ_1: AND BH,01111100b
MOV AL,AH
AND AH,10000001b
OR BH,AH {negative & carry}
AND AL,01000000b
SHR AL,5
OR BH,AL {zero}
{JMP @NEXTOPC}
{---[nextopc]---------------------------------------------------------------}
@NEXTOPC: MOV AL,BYTE PTR [INSTRCYCLES]
MOV AH,$00
TEST BYTE PTR [$B80B],00100000b
JNZ @DECRTIM5
{---t2 one shot mode---}
SUB WORD PTR [$B808],AX
JA @DECRTIM5
TEST BYTE PTR [$B80D],00100000b
JNZ @DECRTIM5
OR BYTE PTR [$B80D],00100000b
TEST BYTE PTR [$B80E],00100000b
JZ @DECRTIM5
OR BYTE PTR [IRQ_NMI],$02
JMP @DECRTIM2
@DECRTIM5: TEST BYTE PTR [$B80B],01000000b
JNZ @DECRTIM1
{---t1 one shot mode---}
SUB WORD PTR [$B804],AX
JA @DECRTIM2
TEST BYTE PTR [$B80D],01000000b
JNZ @DECRTIM2
OR BYTE PTR [$B80D],01000000b
PUSH AX
MOV AL,BYTE PTR [$B80B]
AND AL,BYTE PTR [$B802]
POP AX
JNS @DECRTIM3
OR BYTE PTR [$B800],10000000b
@DECRTIM3: TEST BYTE PTR [$B80E],01000000b
JZ @DECRTIM2
OR BYTE PTR [IRQ_NMI],$01
JMP @DECRTIM2
@DECRTIM1: {---t1 free run mode---}
SUB WORD PTR [$B804],AX
JA @DECRTIM2
PUSH AX
MOV AX,WORD PTR [$B806]
ADD WORD PTR [$B804],AX
OR BYTE PTR [$B80D],01000000b
MOV AL,BYTE PTR [$B80B]
AND AL,BYTE PTR [$B802]
POP AX
JNS @DECRTIM4
XOR BYTE PTR [$B800],10000000b
@DECRTIM4: TEST BYTE PTR [$B80E],01000000b
JZ @DECRTIM2
OR BYTE PTR [IRQ_NMI],$01
@DECRTIM2: CMP BYTE PTR [IRQ_NMI],$00
JZ @DECRTIM6
JNS @IRQOCC
{---nmi---}
PUSH AX
INC BYTE PTR [CS:NMIDELAY]
MOV AL,BYTE PTR [CS:NMIRESPONSE]
CMP BYTE PTR [CS:NMIDELAY],AL
POP AX
JB @DECRTIM6
AND BYTE PTR [IRQ_NMI],$7F
MOV BYTE PTR [CS:NMIDELAY],$00
PUSH AX
MOV AX,SI
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AH
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],BH
DEC BP
OR BH,00000100b {set interrupt disable flag}
AND BH,11110111b {clear decimal mode flag}
CALL FDC_NMI_HANDLER {call fdc}
MOV SI,WORD PTR [NMI_VECTOR]
POP AX
JMP @DECRTIM6
@IRQOCC: {---irq---}
TEST BH,00000100b {test interrupt disable flag}
JNZ @DECRTIM6
INC BYTE PTR [CS:IRQDELAY]
CMP BYTE PTR [CS:IRQDELAY],$02
JB @DECRTIM6
AND BYTE PTR [IRQ_NMI],$FC
MOV BYTE PTR [CS:IRQDELAY],$00
PUSH AX
MOV AX,SI
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AH
DEC BP
AND BP,$00FF
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
AND BP,$00FF
MOV AL,BH
AND AL,11101111b {clear break flag}
MOV BYTE PTR [DS:BP+STACKBASE],AL
DEC BP
OR BH,00000100b {set interrupt disable flag}
AND BH,11110111b {clear decimal mode flag}
MOV SI,WORD PTR [IRQ_VECTOR]
POP AX
@DECRTIM6: ADD WORD PTR [AANTCYCLES],AX
CMP BYTE PTR [CS:CPUSPEEDMODE],$00
JNZ @NEXTOPC3
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR PCWAITTABLE[CS:DI]
SUB AX,+90-15
SUB AX,WORD PTR [PCCYCLES]
JS @NEXTOPC6
JZ @NEXTOPC3
MOV DI,WORD PTR [WACHTSCHULD]
OR DI,DI
JNZ @NEXTOPC5
@NEXTOPC8: SHR AX,1
JZ @NEXTOPC3
NEG AX
ADD AX,+4000+OFFSET SPEEDLOOP {4000=size of speedloop}
CALL AX
JMP @NEXTOPC3
@NEXTOPC5: CMP AX,DI
JAE @NEXTOPC7
SUB WORD PTR [WACHTSCHULD],AX
JMP @NEXTOPC3
@NEXTOPC7: MOV WORD PTR [WACHTSCHULD],$0000
SUB AX,DI
JZ @NEXTOPC3
JMP @NEXTOPC8
@NEXTOPC6: NEG AX
ADD WORD PTR [WACHTSCHULD],AX
@NEXTOPC3: MOV WORD PTR [PCCYCLES],$0000
DEC WORD PTR [COUNTER]
JNZ @DBGSWAPBYTE2
MOV WORD PTR [COUNTER],$3FFF
MOV AL,BYTE PTR TOETS[CS:$1D] {---ctrl+f12---}
AND AL,BYTE PTR TOETS[CS:$58]
AND AL,$03
JZ @NEXTOPC9
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEFOUTBUF
JMP @ENDOFEMUL
@NEXTOPC9: MOV AL,BYTE PTR TOETS[CS:$38] {---alt+f12---}
AND AL,BYTE PTR TOETS[CS:$58]
AND AL,$03
JNZ @BOOT
@NEXTOPC21: MOV AL,BYTE PTR TOETS[CS:$2A] {---shift+f12---}
OR AL,BYTE PTR TOETS[CS:$36]
AND AL,BYTE PTR TOETS[CS:$58]
AND AL,$03
JZ @NEXTOPC1
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEFOUTBUF
CALL @VOLUMEOFF
CALL @CLRINT
CALL TEMPDOSPROMPT
CALL INITATOMGRAPH
MOV AX,$A000
MOV ES,AX
CALL @SETINT
POPA
POP ES
POP DS
CALL @VOLUMEON
CALL SETBORDERCOL
CALL SETINTENSCOL
CALL REBUILDSCREEN
JMP @DBGSWAPBYTE1
@NEXTOPC1: TEST BYTE PTR TOETS[CS:$3E],$03 {---f4---}
JZ @NEXTOPC12
CALL DISABLEMOUSE
CALL SWAPKEYBOARD
@NEXTOPC13: TEST BYTE PTR TOETS[CS:$3E],$03 {---f4---}
JNZ @NEXTOPC13
CALL ENABLEMOUSE
CALL REBUILDSCREEN
JMP @DBGSWAPBYTE1
@NEXTOPC12: TEST BYTE PTR TOETS[CS:$3F],$03 {---f5---}
JZ @NEXTOPC14
CALL DISABLEMOUSE
CALL SWAPCPUSPEED
@NEXTOPC15: TEST BYTE PTR TOETS[CS:$3F],$03 {---f5---}
JNZ @NEXTOPC15
CALL ENABLEMOUSE
CALL REBUILDSCREEN
JMP @DBGSWAPBYTE1
@NEXTOPC14: TEST BYTE PTR TOETS[CS:$40],$03 {---f6---}
JZ @NEXTOPC2
CALL DISABLEMOUSE
CALL BOXINFO
@NEXTOPC17: TEST BYTE PTR TOETS[CS:$40],$03 {---f6---}
JNZ @NEXTOPC17
CALL ENABLEMOUSE
CALL REBUILDSCREEN
JMP @DBGSWAPBYTE1
@NEXTOPC2: TEST BYTE PTR TOETS[CS:$37],$03 {---print scrn---}
JZ @NEXTOPC18
CALL DISABLEMOUSE
PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEBMP
POPA
POP ES
POP DS
@NEXTOPC19: TEST BYTE PTR TOETS[CS:$37],$03 {---print scrn---}
JNZ @NEXTOPC19
CALL ENABLEMOUSE
JMP @DBGSWAPBYTE1
@NEXTOPC18: TEST BYTE PTR TOETS[CS:$58],$03 {---f12---}
JZ @DBGSWAPBYTE1
@NEXTOPC4: TEST BYTE PTR TOETS[CS:$58],$03 {---f12---}
JNZ @NEXTOPC4
{---breakkey---}
@BREAKKEY: PUSH DS
PUSH ES
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEFOUTBUF
POPA
POP ES
MOV BYTE PTR FOUTOPEN,$00
POP DS
CALL CLRDRIVETXT
TEST BYTE PTR [CS:BOX0ONBREAK],$FF
JZ @BRKKEY1
CMP BYTE PTR [SCHAKELBYTE],$00
JZ @BRKKEY1
CALL SAVEZP90
MOV BYTE PTR [SCHAKELBYTE],$00
CALL SETA000MEM
@BRKKEY1: MOV BYTE PTR [CS:AANTBOXRET],$00
MOV BYTE PTR [CS:ALTKEYB],$00
MOV BYTE PTR [CS:CPUSPEEDMODE],$00
MOV DS,WORD PTR [CS:ATOMSEG]
MOV BX,$2000
MOV BYTE PTR [CS:ACCU_B],$00
SUB CX,CX
SUB DX,DX
MOV WORD PTR [$B800],CX
MOV WORD PTR [$B802],CX
MOV BYTE PTR [$B80B],CL
MOV WORD PTR [$B80C],CX
MOV WORD PTR [$B80E],CX
MOV BYTE PTR [CS:T2L_L],CL
MOV BYTE PTR [$BFE2],$07
MOV BYTE PTR [CS:MOUSENR],$80 {mouse off}
MOV BYTE PTR [IRQ_NMI],CL
MOV BYTE PTR [CS:IRQDELAY],CL
MOV BYTE PTR [CS:NMIDELAY],CL
MOV WORD PTR [$0202],CX
MOV BYTE PTR [FLIPFLOP],$55
TEST BYTE PTR [CS:LEENDERTSROM],$FF
JZ @BRKKEY2
{---initialize fp-rom: determine co-processor type---}
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
MOV SI,$DBA9
@INITFPROM1: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,$DBB1
JNZ @INITFPROM1
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
@BRKKEY2: MOV SI,WORD PTR [RES_VECTOR]
JMP @DBGSWAPBYTE2
@DBGSWAPBYTE1: {@DBGSWAPBYTE1 can be RETN byte-swapped}
TEST BYTE PTR TOETS[CS:$42],$03 {---f8---}
JZ @NEXTOPC20
MOV BYTE PTR @LASTMENU,$04
CALL @SHOWMENU
JMP @DBGSWAPBYTE2
@NEXTOPC20: TEST BYTE PTR TOETS[CS:$43],$03 {---f9---}
JZ @NEXTOPC10
MOV BYTE PTR @LASTMENU,$01
CALL @SHOWMENU
JMP @DBGSWAPBYTE2
@NEXTOPC10: TEST BYTE PTR TOETS[CS:$44],$03 {---f10---}
JZ @NEXTOPC16
MOV BYTE PTR @LASTMENU,$02
CALL @SHOWMENU
JMP @DBGSWAPBYTE2
@NEXTOPC16: TEST BYTE PTR TOETS[CS:$57],$03 {---f11---}
JZ @DBGSWAPBYTE2
MOV BYTE PTR @LASTMENU,$03
CALL @SHOWMENU
@DBGSWAPBYTE2: {@DBGSWAPBYTE2 can be RETN byte-swapped}
MOV AL,BYTE PTR [SI]
INC SI
MOV AH,$00
SHL AX,1
MOV DI,AX
JMP WORD PTR @OPCODETABLE[DI]
{---[lda/ldx/ldy_via]-------------------------------------------------------}
@LDX_VIA: CALL @GETVIAREG
MOV CL,AL
OR AL,AL
JMP @UPDATENZ
@LDY_VIA: CALL @GETVIAREG
MOV DL,AL
OR AL,AL
JMP @UPDATENZ
@LDA_VIA: CALL @GETVIAREG
MOV BL,AL
OR AL,AL
JMP @UPDATENZ
@BIT_VIA: CALL @GETVIAREG
JMP @OPC2C_1
@GETVIAREG: MOV AL,BYTE PTR [DI]
AND DI,$000F
SHL DI,1
MOV DI,WORD PTR @VIAGETTABLE[DI]
OR DI,DI
JZ @GETVIA1
JMP DI
@GETVIA1: RETN
@GETB801: PUSH DS
PUSH ES
PUSHA
MOV AH,$02
SUB DX,DX
INT $17
TEST AH,00100000b {test: out of paper}
JZ @GETB801_1
@GETB801_2: POPA
POP ES
POP DS
{---printer out of paper---}
MOV AL,$FF
XOR AL,BYTE PTR [$B803]
RETN
@GETB801_1: TEST AH,10010000b {test: not busy, selected}
JZ @GETB801_2
POPA
POP ES
POP DS
{---printer ready---}
MOV AL,$00
RETN
@GETB804: MOV AL,BYTE PTR [$B804]
AND BYTE PTR [$B80D],10111111b
RETN
@GETB808: MOV AL,BYTE PTR [$B808]
AND BYTE PTR [$B80D],11011111b
RETN
@GETB80C: PUSH DS
PUSH ES
PUSHA
MOV AH,$02
SUB DX,DX
INT $17
TEST AH,00001001b {test: I/O error, timeout}
JZ @GETB80C_1
{---printer not ready---}
POPA
POP ES
POP DS
MOV AL,$00
MOV BYTE PTR [$B80C],AL
RETN
@GETB80C_1: {---printer ready---}
POPA
POP ES
POP DS
MOV AL,BYTE PTR [$B80C]
RETN
@GETB80D: MOV AL,BYTE PTR [$B80D]
AND AL,01111111b
TEST AL,BYTE PTR [$B80E]
JZ @GETB80D_1
OR AL,10000000b
@GETB80D_1: RETN
@GETB80E: MOV AL,BYTE PTR [$B80E]
OR AL,$80
RETN
@GETB80F: MOV AL,BYTE PTR [$B800]
RETN
{---[sta/stx/sty/stz_via]---------------------------------------------------}
@STZ_VIA: MOV AL,$00
JMP @STOREVIA1
@STX_VIA: MOV AL,CL
JMP @STOREVIA1
@STY_VIA: MOV AL,DL
JMP @STOREVIA1
@STA_VIA: MOV AL,BL
@STOREVIA1: AND DI,$000F
SHL DI,1
JMP WORD PTR @VIASTORETABLE[DI]
@STOREB801: MOV BYTE PTR [$B801],AL
JMP @NEXTOPC
@STOREB804: MOV BYTE PTR [$B806],AL
JMP @NEXTOPC
@STOREB805: MOV BYTE PTR [$B807],AL
MOV AH,AL
MOV AL,BYTE PTR [$B806]
MOV WORD PTR [$B804],AX
AND BYTE PTR [$B80D],10111111b
MOV AL,BYTE PTR [$B80B]
AND AL,BYTE PTR [$B802]
JNS @STB805_1
AND BYTE PTR [$B800],01111111b
@STB805_1: MOV AL,BYTE PTR [INSTRCYCLES]
MOV AH,$00
JMP @DECRTIM2
@STOREB808: MOV BYTE PTR [CS:T2L_L],AL
JMP @NEXTOPC
@STOREB809: MOV AH,AL
MOV AL,BYTE PTR [CS:T2L_L]
MOV WORD PTR [$B808],AX
AND BYTE PTR [$B80D],11011111b
MOV AL,BYTE PTR [INSTRCYCLES]
MOV AH,$00
JMP @DECRTIM2
@STOREB80C: MOV BYTE PTR [$B80C],AL
AND AL,$0F
CMP AL,$0C
JNZ @STB80C_1
PUSH DS
PUSH ES
PUSHA
MOV AH,$00
MOV AL,BYTE PTR [$B801]
SUB DX,DX
INT $17
POPA
POP ES
POP DS
@STB80C_1: JMP @NEXTOPC
@STOREB80D: OR BYTE PTR [$B80D],AL
JMP @NEXTOPC
@STOREB80E: OR AL,AL
JS @STB80E_1
NOT AL
AND BYTE PTR [$B80E],AL
JMP @NEXTOPC
@STB80E_1: OR BYTE PTR [$B80E],AL
JMP @NEXTOPC
@STOREB80F: MOV BYTE PTR [$B800],AL
JMP @NEXTOPC
@STOREB8xx: SHR DI,1
MOV BYTE PTR [$B800+DI],AL
JMP @NEXTOPC
{---[store_mousex]----------------------------------------------------------}
@STZ_MOUSEX: MOV AL,$00
JMP @STOREMX
@STA_MOUSEX: MOV AL,BL
JMP @STOREMX
@STX_MOUSEX: MOV AL,CL
JMP @STOREMX
@STY_MOUSEX: MOV AL,DL
@STOREMX: CMP AL,$F8
JBE @STMX1
MOV AL,$F8
@STMX1: CLI
PUSH ES
MOV DI,$A000
MOV ES,DI
PUSH WORD PTR [CS:MOUSENR]
CALL CLRMOUSECURSOR
MOV BYTE PTR [$BFE0],AL
JMP @NEWPOSMOUSE
{---[store_mousey]----------------------------------------------------------}
@STZ_MOUSEY: MOV AL,$00
JMP @STOREMY
@STA_MOUSEY: MOV AL,BL
JMP @STOREMY
@STX_MOUSEY: MOV AL,CL
JMP @STOREMY
@STY_MOUSEY: MOV AL,DL
@STOREMY: CMP AL,$47
JAE @STMY1
MOV AL,$47
@STMY1: CLI
PUSH ES
MOV DI,$A000
MOV ES,DI
PUSH WORD PTR [CS:MOUSENR]
CALL CLRMOUSECURSOR
MOV BYTE PTR [$BFE1],AL
@NEWPOSMOUSE: MOV ES,WORD PTR [CS:DATASEG]
MOV AL,BYTE PTR [$BFE0]
MOV BYTE PTR TEMPMOUSEDAT[ES:$00],AL
MOV AH,$00
SHL AX,1
MOV WORD PTR TEMPMOUSEDAT[ES:$03],AX
MOV AL,BYTE PTR [$BFE1]
MOV BYTE PTR TEMPMOUSEDAT[ES:$01],AL
SUB AL,+64
MOV AH,$00
SHL AX,1
SUB AX,+511
NEG AX
MOV WORD PTR TEMPMOUSEDAT[ES:$05],AX
POP AX {---[cs:mousenr]---}
MOV DI,$A000
MOV ES,DI
CALL SETMOUSECURSOR
MOV ES,WORD PTR [CS:DATASEG]
PUSH DS
PUSHA
MOV AX,$0004
MOV CX,WORD PTR TEMPMOUSEDAT[ES:$03]
MOV DX,WORD PTR TEMPMOUSEDAT[ES:$05]
INT $33
POPA
POP DS
POP ES
STI
JMP @NEXTOPC
{---[store_mousenr]---------------------------------------------------------}
@STORE_MOUSENR:CLI
CALL CLRMOUSECURSOR
CALL SETMOUSECURSOR
STI
JMP @NEXTOPC
{---[trace]-----------------------------------------------------------------}
@TRACE: MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
MOV SI,WORD PTR [CS:PROGRAMCNT]
@TRACE1: MOV BP,WORD PTR [CS:STACKPOINTER]
MOV BL,BYTE PTR [CS:ACCUMULATOR]
MOV BH,BYTE PTR [CS:FLAGREGISTER]
MOV CL,BYTE PTR [CS:XREGISTER]
MOV DL,BYTE PTR [CS:YREGISTER]
MOV DS,WORD PTR [CS:ATOMSEG]
LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
MOV WORD PTR [CS:PROGRAMCNT],SI
MOV WORD PTR [CS:STACKPOINTER],BP
MOV BYTE PTR [CS:ACCUMULATOR],BL
MOV BYTE PTR [CS:FLAGREGISTER],BH
MOV BYTE PTR [CS:XREGISTER],CL
MOV BYTE PTR [CS:YREGISTER],DL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
RETN
{---[step]------------------------------------------------------------------}
@STEP: MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
MOV SI,WORD PTR [CS:PROGRAMCNT]
MOV BYTE PTR [CS:TRACEORSTEP],$00
CMP BYTE PTR[SI],$20 {---jsr---}
JNZ @TRACE1
MOV BYTE PTR [CS:TRACEORSTEP],$01
MOV AX,SI
ADD AX,$03
@STEP4: MOV WORD PTR @STEPENDOFS,AX
PUSH SI
CALL SETCOLORS
POP SI
SUB DI,DI
MOV CX,$4000
MOV AL,$FF
@STEP5: STOSB
STOSB
STOSB
INC AL
STOSB
DEC AL
LOOP @STEP5
CALL ENABLEMOUSE
MOV BP,WORD PTR [CS:STACKPOINTER]
MOV BL,BYTE PTR [CS:ACCUMULATOR]
MOV BH,BYTE PTR [CS:FLAGREGISTER]
MOV CL,BYTE PTR [CS:XREGISTER]
MOV DL,BYTE PTR [CS:YREGISTER]
MOV DS,WORD PTR [CS:ATOMSEG]
CALL SETBORDERCOL
CALL REBUILDSCREEN
@STEP1: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
MOV AL,BYTE PTR TOETS[CS:$3B] {---f1---}
OR AL,BYTE PTR TOETS[CS:$42] {---f8---}
OR AL,BYTE PTR TOETS[CS:$43] {---f9---}
OR AL,BYTE PTR TOETS[CS:$44] {---f10---}
OR AL,BYTE PTR TOETS[CS:$57] {---f11---}
AND AL,$03
JNZ @STEP3
CMP SI,WORD PTR @STEPENDOFS
JNZ @STEP1
JMP @STEP2
@STEP3: MOV AL,BYTE PTR TOETS[CS:$3B] {---f1---}
OR AL,BYTE PTR TOETS[CS:$42] {---f8---}
OR AL,BYTE PTR TOETS[CS:$43] {---f9---}
OR AL,BYTE PTR TOETS[CS:$44] {---f10---}
OR AL,BYTE PTR TOETS[CS:$57] {---f11---}
AND AL,$03
JNZ @STEP3
@STEP2: MOV WORD PTR [CS:PROGRAMCNT],SI
MOV WORD PTR [CS:STACKPOINTER],BP
MOV BYTE PTR [CS:ACCUMULATOR],BL
MOV BYTE PTR [CS:FLAGREGISTER],BH
MOV BYTE PTR [CS:XREGISTER],CL
MOV BYTE PTR [CS:YREGISTER],DL
CALL DISABLEMOUSE
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
RETN
{---[untilcursor]-----------------------------------------------------------}
@UNTILCURSOR: MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
@UNTILCURS1: TEST BYTE PTR TOETS[CS:$23],$03 {---h---}
JNZ @UNTILCURS1
MOV SI,WORD PTR [CS:PROGRAMCNT]
MOV AX,WORD PTR [CS:DISASPTR]
JMP @STEP4
{---[breakpoint]------------------------------------------------------------}
@BREAKPOINT: PUSH DS
MOV AX,CS
MOV DS,AX
MOV BYTE PTR CURSORX,+10
MOV BYTE PTR CURSORY,+6
MOV BL,$0C
MOV AL,01000101b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@BRKPNT2: CALL PRINTCHAR
LOOP @BRKPNT2
MOV AL,01001010b
CALL PRINTCHAR
MOV CL,+7
@BRKPNT3: MOV BYTE PTR CURSORX,+10
MOV BYTE PTR CURSORY,CL
MOV AL,01010101b
CALL PRINTCHAR
MOV BYTE PTR CURSORX,+29
MOV AL,01101010b
CALL PRINTCHAR
INC CL
CMP CL,+12
JBE @BRKPNT3
MOV BYTE PTR CURSORX,+10
MOV BYTE PTR CURSORY,+13
MOV AL,01010100b
CALL PRINTCHAR
MOV CX,+18
MOV AL,01001100b
@BRKPNT4: CALL PRINTCHAR
LOOP @BRKPNT4
MOV AL,01101000b
CALL PRINTCHAR
CALL PRINTSTRING
DB +11, +7,$0E,' ADD BRKP : ',$00
CALL PRINTSTRING
DB +11, +8,$0E,' ',$00
CALL PRINTSTRING
DB +11, +9,$0E,' REMOVE : ',$00
CALL PRINTSTRING
DB +11,+10,$0E,' REMOVE : ',$00
CALL PRINTSTRING
DB +11,+11,$0E,' REMOVE : ',$00
CALL PRINTSTRING
DB +11,+12,$0E,' REMOVE : ',$00
MOV BYTE PTR CURSORX,+12
MOV BYTE PTR CURSORY,+7
MOV AL,'A' AND $3F
MOV BL,$0F
CALL PRINTCHAR
MOV CL,'1'
@BRKPNT5: MOV BYTE PTR CURSORX,+19
MOV AL,CL
ADD AL,+9-'1'
MOV BYTE PTR CURSORY,AL
MOV AL,CL
CALL PRINTCHAR
INC CL
CMP CL,'4'
JBE @BRKPNT5
MOV BYTE PTR CURSORX,+23
MOV BYTE PTR CURSORY,+7
MOV AL,BYTE PTR [CS:HEXTEKEN]
MOV BL,$09
CALL PRINTCHAR
MOV AX,WORD PTR [CS:DISASPTR]
CALL PRINTWORD
MOV BL,$0E
SUB CX,CX
@BRKPNT7: MOV AL,$01
SHL AL,CL
TEST BYTE PTR [CS:BRKPNTON],AL
JZ @BRKPNT8
MOV BYTE PTR CURSORX,+23
MOV AL,CL
ADD AL,+9
MOV BYTE PTR CURSORY,AL
MOV AL,BYTE PTR [CS:HEXTEKEN]
MOV BL,$0E
CALL PRINTCHAR
MOV SI,CX
SHL SI,1
MOV AX,WORD PTR BRKPNTS[CS:SI]
CALL PRINTWORD
@BRKPNT8: INC CL
CMP CL,$04
JNZ @BRKPNT7
@BRKPNT6: TEST BYTE PTR TOETS[CS:$30],$03 {---b---}
JNZ @BRKPNT6
@BRKPNT9: TEST BYTE PTR TOETS[CS:$1E],$03 {---a---}
JZ @BRKPNT10
CMP BYTE PTR [CS:BRKPNTON],$0F
JAE @BRKPNT10
MOV AX,WORD PTR [CS:DISASPTR]
SUB CX,CX
@BRKPNT11: MOV BL,$01
SHL BL,CL
TEST BYTE PTR [CS:BRKPNTON],BL
JZ @BRKPNT12
MOV SI,CX
SHL SI,1
CMP AX,WORD PTR BRKPNTS[CS:SI]
JZ @BRKPNT10
@BRKPNT12: INC CL
CMP CL,$04
JNZ @BRKPNT11
SUB CX,CX
@BRKPNT14: MOV BL,$01
SHL BL,CL
TEST BYTE PTR [CS:BRKPNTON],BL
JZ @BRKPNT13
INC CL
JMP @BRKPNT14
@BRKPNT13: MOV SI,CX
SHL SI,1
MOV WORD PTR BRKPNTS[CS:SI],AX
OR BYTE PTR [CS:BRKPNTON],BL
JMP @BRKPNT15
@BRKPNT10: MOV BX,$0002
@BRKPNT17: TEST BYTE PTR TOETS[CS:BX],$03 {---1/2/3/4---}
JZ @BRKPNT16
MOV CL,BL
SUB CL,$02
MOV AL,$01
SHL AL,CL
TEST BYTE PTR [CS:BRKPNTON],AL
JZ @BRKPNT16
XOR AL,$0F
AND BYTE PTR [CS:BRKPNTON],AL
JMP @BRKPNT15
@BRKPNT16: INC BL
CMP BL,$05
JBE @BRKPNT17
TEST BYTE PTR TOETS[CS:$01],$03 {---esc---}
JZ @BRKPNT9
@BRKPNT15: MOV AL,BYTE PTR TOETS[CS:$01] {---esc---}
OR AL,BYTE PTR TOETS[CS:$1E] {---a---}
OR AL,BYTE PTR TOETS[CS:$02] {---1---}
OR AL,BYTE PTR TOETS[CS:$03] {---2---}
OR AL,BYTE PTR TOETS[CS:$04] {---3---}
OR AL,BYTE PTR TOETS[CS:$05] {---4---}
AND AL,$03
JNZ @BRKPNT15
POP DS
RETN
{---[showmenu]--------------------------------------------------------------}
@SHOWMENU: MOV WORD PTR [CS:PROGRAMCNT],SI
MOV WORD PTR [CS:STACKPOINTER],BP
MOV BYTE PTR [CS:ACCUMULATOR],BL
MOV BYTE PTR [CS:FLAGREGISTER],BH
MOV BYTE PTR [CS:XREGISTER],CL
MOV BYTE PTR [CS:YREGISTER],DL
CALL DISABLEMOUSE
MOV DX,$03C8
MOV AL,$07
OUT DX,AL
INC DX
MOV AL,$00
OUT DX,AL
OUT DX,AL
OUT DX,AL
CALL UPPERLINES
MOV AL,BYTE PTR @LASTMENU
OR AL,AL
JNZ @SHOWMENU4
MOV AL,$01
@SHOWMENU4: CMP AL,$01
JNZ @SHOWMENU5
CALL TAPE
JMP @SHOWMENU3
@SHOWMENU5: CMP AL,$02
JNZ @SHOWMENU6
CALL OPTIONS
JMP @SHOWMENU3
@SHOWMENU6: CMP AL,$03
JNZ @SHOWMENU8
CALL MONITOR
JMP @SHOWMENU3
@SHOWMENU8: CALL DISK
@SHOWMENU3: OR AL,AL
JZ @SHOWMENU1
MOV BYTE PTR @LASTMENU,AL
JMP @SHOWMENU4
@SHOWMENU1: TEST BYTE PTR TOETS[CS:$01],$03 {---escape---}
JNZ @SHOWMENU1
CALL SETCOLORS
SUB DI,DI
MOV CX,$4000
MOV AL,$FF
@SHOWMENU2: STOSB
STOSB
STOSB
INC AL
STOSB
DEC AL
LOOP @SHOWMENU2
CALL ENABLEMOUSE
MOV SI,WORD PTR [CS:PROGRAMCNT]
MOV BP,WORD PTR [CS:STACKPOINTER]
MOV BL,BYTE PTR [CS:ACCUMULATOR]
MOV BH,BYTE PTR [CS:FLAGREGISTER]
MOV CL,BYTE PTR [CS:XREGISTER]
MOV DL,BYTE PTR [CS:YREGISTER]
MOV DS,WORD PTR [CS:ATOMSEG]
CALL SETBORDERCOL
CALL SETINTENSCOL
CALL REBUILDSCREEN
TEST BYTE PTR [CS:BRKPNTON],$0F
JNZ @SHOWMENU7
RETN
@SHOWMENU7: {---execute until breakpoint or f1 (exit debug mode)---}
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
@BREAKP1: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
MOV AL,BYTE PTR TOETS[CS:$3B] {---f1---}
OR AL,BYTE PTR TOETS[CS:$42] {---f8---}
OR AL,BYTE PTR TOETS[CS:$43] {---f9---}
OR AL,BYTE PTR TOETS[CS:$44] {---f10---}
OR AL,BYTE PTR TOETS[CS:$57] {---f11---}
AND AL,$03
JNZ @BREAKP3
MOV AL,BYTE PTR [CS:BRKPNTON]
TEST AL,00000001b
JZ @BREAKP4
CMP SI,WORD PTR BRKPNTS[CS:$0000]
JZ @BREAKP2
@BREAKP4: TEST AL,00000010b
JZ @BREAKP5
CMP SI,WORD PTR BRKPNTS[CS:$0002]
JZ @BREAKP2
@BREAKP5: TEST AL,00000100b
JZ @BREAKP6
CMP SI,WORD PTR BRKPNTS[CS:$0004]
JZ @BREAKP2
@BREAKP6: TEST AL,00001000b
JZ @BREAKP1
CMP SI,WORD PTR BRKPNTS[CS:$0006]
JZ @BREAKP2
JMP @BREAKP1
@BREAKP3: MOV BYTE PTR @LASTMENU,$03
TEST BYTE PTR TOETS[CS:$43],$03
JZ @BREAKP9
MOV BYTE PTR @LASTMENU,$01
@BREAKP9: TEST BYTE PTR TOETS[CS:$44],$03
JZ @BREAKP7
MOV BYTE PTR @LASTMENU,$02
@BREAKP7: MOV AL,BYTE PTR TOETS[CS:$3B] {---f1---}
OR AL,BYTE PTR TOETS[CS:$42] {---f8---}
OR AL,BYTE PTR TOETS[CS:$43] {---f9---}
OR AL,BYTE PTR TOETS[CS:$44] {---f10---}
OR AL,BYTE PTR TOETS[CS:$57] {---f11---}
AND AL,$03
JNZ @BREAKP7
JMP @BREAKP8
@BREAKP2: MOV BYTE PTR @LASTMENU,$03
@BREAKP8: MOV WORD PTR [CS:DISASPTR],SI
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
JMP @SHOWMENU
{---[resetandload; commandline in 0100h preset (including 0Dh,0Ah)]---------}
@RESETANDLOAD: MOV BYTE PTR [CS:AANTBOXRET],$00
MOV DS,WORD PTR [CS:ATOMSEG]
CALL SETBORDERCOL
CALL REBUILDSCREEN
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH AX
MOV BYTE PTR [CS:AANTBOXRET],$00
MOV BX,$2000
MOV BYTE PTR [CS:ACCU_B],$00
SUB CX,CX
SUB DX,DX
MOV WORD PTR [$B800],CX
MOV WORD PTR [$B802],CX
MOV BYTE PTR [$B80B],CL
MOV WORD PTR [$B80C],CX
MOV WORD PTR [$B80E],CX
MOV BYTE PTR [CS:T2L_L],CL
MOV BYTE PTR [$BFE2],$07
MOV BYTE PTR [CS:MOUSENR],$80 {mouse off}
MOV BYTE PTR [IRQ_NMI],CL
MOV BYTE PTR [CS:IRQDELAY],CL
MOV BYTE PTR [CS:NMIDELAY],CL
MOV WORD PTR [$0202],CX
MOV SI,WORD PTR [RES_VECTOR]
@RESANDLOAD1: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,$C2D2
JNZ @RESANDLOAD1
MOV DI,$00FF
MOV AL,'>'
XCHG AL,BYTE PTR [DI]
PUSH AX
@RESANDLOAD4: MOV BL,BYTE PTR [DI]
PUSH DI
MOV SI,$FFEF
@RESANDLOAD2: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,$FFF2
JNZ @RESANDLOAD2
POP DI
CMP BL,$0A
JZ @RESANDLOAD3
INC DI
JMP @RESANDLOAD4
@RESANDLOAD3: POP AX
MOV BYTE PTR [$00FF],AL
MOV BYTE PTR [$0007],$00
MOV SI,$C2D5
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
JMP @DBGSWAPBYTE2
{---[boot]------------------------------------------------------------------}
@BOOT: MOV AL,BYTE PTR TOETS[CS:$38] {---alt+f12---}
AND AL,BYTE PTR TOETS[CS:$58]
AND AL,$03
JNZ @BOOT
MOV WORD PTR [$0100],'TS'
MOV WORD PTR [$0102],'RA'
MOV WORD PTR [$0104],'0T'
MOV WORD PTR [$0106],$0A0D
JMP @RESETANDLOAD
{---[setint]----------------------------------------------------------------}
@SETINT: CLI
PUSH DS
SUB AX,AX
MOV DS,AX
MOV AX,WORD PTR [$0020]
MOV WORD PTR @ORGIRQVEC[CS:$0000],AX
MOV AX,WORD PTR [$0022]
MOV WORD PTR @ORGIRQVEC[CS:$0002],AX
MOV AX,OFFSET @IRQHANDLER
MOV WORD PTR [$0020],AX
MOV WORD PTR [$0022],CS
MOV AX,WORD PTR [$0024]
MOV WORD PTR @ORGKEYVEC[CS:$0000],AX
MOV AX,WORD PTR [$0026]
MOV WORD PTR @ORGKEYVEC[CS:$0002],AX
MOV AX,OFFSET @KEYHANDLER
MOV WORD PTR [$0024],AX
MOV WORD PTR [$0026],CS
MOV AX,WORD PTR [$006C]
MOV WORD PTR @ORGBRKVEC[CS:$0000],AX
MOV AX,WORD PTR [$006E]
MOV WORD PTR @ORGBRKVEC[CS:$0002],AX
MOV AX,OFFSET @BRKHANDLER
MOV WORD PTR [$006C],AX
MOV WORD PTR [$006E],CS
MOV AL,$36
OUT $43,AL
MOV AL,$00
OUT $40,AL
OUT $40,AL
PUSH ES
MOV AX,CS
MOV ES,AX
MOV DI,OFFSET TOETS
MOV CX,$0082
MOV AL,$00
CLD
REPZ
STOSB
SUB AX,AX
INT $33
CMP AX,$FFFF
JNZ @SETINT1
MOV AX,$000C
MOV CX,$007F
MOV DX,OFFSET @MOUSEHANDLER
PUSH CS
POP ES
INT $33
MOV AX,$0007
SUB CX,CX
MOV DX,$01F0
INT $33
MOV AX,$0008
MOV CX,+128
MOV DX,+496
INT $33
MOV AX,$0004
SUB CX,CX
MOV DX,+128
INT $33
MOV DS,WORD PTR [CS:ATOMSEG]
MOV BYTE PTR [$BFE0],0
MOV BYTE PTR [$BFE1],+255
@SETINT1: POP ES
STI
POP DS
RETN
{---[clrint]----------------------------------------------------------------}
@CLRINT: PUSH DS
CLI
SUB AX,AX
MOV DS,AX
MOV AX,WORD PTR @ORGIRQVEC[CS:$0000]
MOV WORD PTR [$0020],AX
MOV AX,WORD PTR @ORGIRQVEC[CS:$0002]
MOV WORD PTR [$0022],AX
MOV AX,WORD PTR @ORGKEYVEC[CS:$0000]
MOV WORD PTR [$0024],AX
MOV AX,WORD PTR @ORGKEYVEC[CS:$0002]
MOV WORD PTR [$0026],AX
MOV AX,WORD PTR @ORGBRKVEC[CS:$0000]
MOV WORD PTR [$006C],AX
MOV AX,WORD PTR @ORGBRKVEC[CS:$0002]
MOV WORD PTR [$006E],AX
SUB AX,AX
INT $33
STI
POP DS
RETN
{---[mousehandler]----------------------------------------------------------}
@MOUSEHANDLER: PUSH DS
PUSH ES
PUSHA
MOV SI,$A000
MOV ES,SI
MOV AH,BYTE PTR [CS:MOUSENR]
TEST AL,$01
JZ @MOUSEH1
CALL CLRMOUSECURSOR
@MOUSEH1: MOV DS,WORD PTR [CS:ATOMSEG]
SHR CX,1
MOV BYTE PTR [$BFE0],CL
NEG DX
ADD DX,+511
SHR DX,1
ADD DL,+64
MOV BYTE PTR [$BFE1],DL
XOR BL,$07
MOV BYTE PTR [$BFE2],BL
TEST AL,$01
JZ @MOUSEH2
TEST AH,$80
JNZ @MOUSEH2
MOV AL,BYTE PTR [CS:MOUSENR]
AND AL,$1F
CALL SETMOUSECURSOR
@MOUSEH2: POPA
POP ES
POP DS
RETF
{---[keyhandler]------------------------------------------------------------}
@KEYHANDLER: PUSH AX
PUSH DI
IN AL,$60
MOV AH,AL
IN AL,$61
OR AL,$80
OUT $61,AL
AND AL,$7F
OUT $61,AL
MOV AL,AH
MOV AH,$00
OR AL,AL
JNS @KEYHND6
AND AL,$7F
MOV DI,AX
MOV BYTE PTR TOETS[CS:DI],$00
CMP AL,$48
JB @KEYHND4
JNZ @KEYHND7
AND BYTE PTR TOETS[CS:$80],$FE
JMP @KEYHND4
@KEYHND7: CMP AL,$50
JNZ @KEYHND8
AND BYTE PTR TOETS[CS:$80],$FD
JMP @KEYHND4
@KEYHND8: CMP AL,$4B
JNZ @KEYHND9
AND BYTE PTR TOETS[CS:$81],$FE
JMP @KEYHND4
@KEYHND9: CMP AL,$4D
JNZ @KEYHND4
AND BYTE PTR TOETS[CS:$81],$FD
@KEYHND4: MOV AL,$20
OUT $20,AL
POP DI
POP AX
@BRKHANDLER: IRET
@KEYHND6: MOV DI,AX
MOV BYTE PTR TOETS[CS:DI],$01
CMP AL,$48
JB @KEYHND4
JNZ @KEYHND10
OR BYTE PTR TOETS[CS:$80],$01
JMP @KEYHND4
@KEYHND10: CMP AL,$50
JNZ @KEYHND11
OR BYTE PTR TOETS[CS:$80],$02
JMP @KEYHND4
@KEYHND11: CMP AL,$4B
JNZ @KEYHND12
OR BYTE PTR TOETS[CS:$81],$01
JMP @KEYHND4
@KEYHND12: CMP AL,$4D
JNZ @KEYHND4
OR BYTE PTR TOETS[CS:$81],$02
JMP @KEYHND4
{---[irqhandler]------------------------------------------------------------}
@IRQHANDLER: INC BYTE PTR [CS:KEYRELEASETEL]
DB $2E,$FF,$2E
DW OFFSET @ORGIRQVEC
{---[loadfile]--------------------------------------------------------------}
@LOADFILE: PUSH DS
PUSH ES
PUSH BX
PUSH CX
PUSH DX
PUSH BP
PUSH CX {---offset loadtable---}
PUSH WORD PTR [CS:LASTATM] {---file pointer---}
PUSH CS {---segment exitcode---}
PUSH OFFSET @LOADCODE {---offset exitcode---}
MOV DS,WORD PTR [CS:DATASEG]
CALL LOAD
MOV AX,$A000
MOV ES,AX
SUB DI,DI
MOV CX,$4000
MOV AL,$FF
@LOADFILE4: STOSB
STOSB
STOSB
INC AL
STOSB
DEC AL
LOOP @LOADFILE4
POP BP
POP DX
POP CX
POP BX
POP ES
POP DS
CALL SETBORDERCOL
CALL REBUILDSCREEN
MOV AX,WORD PTR @LOADCODE
TEST AH,$80
JZ @LOADFILE1
MOV SI,$F9FD
JMP @NEXTOPC {---generate checksum error 6---}
@LOADFILE1: TEST AH,$40
JNZ @LOADFILE3
{---load ok---}
MOV WORD PTR [CS:LASTATM],AX
@LOADFILE2: TEST BYTE PTR TOETS[CS:$1C],$FF {---enter---}
JNZ @LOADFILE2
JMP @OPCODE60 {---rts---}
@LOADFILE3: {---frozen file---}
AND AH,$3F
MOV WORD PTR [CS:LASTATM],AX
MOV SI,WORD PTR [CS:PROGRAMCNT]
MOV BP,WORD PTR [CS:STACKPOINTER]
MOV BL,BYTE PTR [CS:ACCUMULATOR]
MOV BH,BYTE PTR [CS:FLAGREGISTER]
MOV CL,BYTE PTR [CS:XREGISTER]
MOV DL,BYTE PTR [CS:YREGISTER]
JMP @NEXTOPC
{---[savefile]--------------------------------------------------------------}
@SAVEFILE: PUSH DS
PUSH ES
PUSH BX
PUSH CX
PUSH DX
PUSH BP
PUSH CX {---offset savetable---}
PUSH WORD PTR [CS:LASTATM] {---file pointer---}
PUSH CS {---segment exitcode---}
PUSH OFFSET @SAVECODE {---offset exitcode---}
MOV DS,WORD PTR [CS:DATASEG]
CALL SAVE
POP BP
POP DX
POP CX
POP BX
POP ES
POP DS
MOV AX,WORD PTR @SAVECODE
TEST AH,$80
JNZ @SAVEFILE1
{---save ok---}
INC WORD PTR [CS:LASTATM]
JMP @OPCODE60 {---rts---}
@SAVEFILE1: MOV SI,$F9FD
JMP @NEXTOPC {---generate checksum error 6---}
{---[getbyte]---------------------------------------------------------------}
@GETBYTE: PUSH DS
PUSH SI
MOV DS,WORD PTR [CS:DATASEG]
MOV SI,WORD PTR FINBUFPTR
CMP SI,WORD PTR FINSIZE
JAE @GETB1
ADD SI,WORD PTR FINBUFOFS
INC WORD PTR FINBUFPTR
MOV DS,WORD PTR FINBUFSEG
MOV BL,BYTE PTR [SI]
JMP @GETB2
@GETB1: MOV BL,$0D
@GETB2: POP SI
POP DS
JMP @OPCODE60
{---[putbyte]---------------------------------------------------------------}
@PUTBYTE: PUSH DS
MOV DS,WORD PTR [CS:DATASEG]
TEST BYTE PTR FOUTOPEN,$FF
JNZ @PUTB2
POP DS
MOV SI,$F9FD
JMP @NEXTOPC {---generate checksum error 6---}
@PUTB2: PUSH DI
MOV DI,WORD PTR FOUTBUFPTR
ADD DI,WORD PTR FOUTBUFOFS
MOV DS,WORD PTR FOUTBUFSEG
MOV BYTE PTR [DI],BL
POP DI
MOV DS,WORD PTR [CS:DATASEG]
INC WORD PTR FOUTBUFPTR
CMP WORD PTR FOUTBUFPTR,FOUTBUFSIZE
JB @PUTB1
PUSH ES
PUSHA
CALL WRITEFOUTBUF
POPA
POP ES
@PUTB1: POP DS
JMP @OPCODE60
{---[finfoutcmd (see also finfoutcmd preparation at @OPCODE28)]-------------}
@FINFOUTCMD: PUSH DS
PUSH ES
PUSHA
TEST BH,$01 {test carry}
JZ @FINFOUT1
{---fin---}
PUSH WORD PTR @FILENAMEOFS
PUSH WORD PTR [CS:LASTATM] {---file pointer---}
PUSH CS {---segment exitcode---}
PUSH OFFSET @LOADCODE {---offset exitcode---}
MOV DS,WORD PTR [CS:DATASEG]
CALL READFINBUF
POPA
POP ES
POP DS
MOV AX,WORD PTR @LOADCODE
TEST AH,$80
JZ @FINFOUT5
MOV SI,$F9FD
JMP @NEXTOPC {---generate checksum error 6---}
@FINFOUT5: MOV WORD PTR [CS:LASTATM],AX
MOV BL,$0D {---return filehandle---}
JMP @OPCODE60
@FINFOUT1: {---fout---}
PUSH DS
PUSHA
MOV DS,WORD PTR [CS:DATASEG]
CALL WRITEFOUTBUF
POPA
POP DS
MOV ES,WORD PTR [CS:DATASEG]
MOV SI,WORD PTR @FILENAMEOFS
SUB BX,BX
@FINFOUT4: MOV AL,BYTE PTR [SI+BX]
CMP AL,$0D
JZ @FINFOUT3
MOV BYTE PTR [ES:FOUTNAME+$01+BX],AL
INC BL
CMP BL,$10
JB @FINFOUT4
@FINFOUT3: MOV BYTE PTR [ES:FOUTNAME],BL
OR BL,BL
JNZ @FINFOUT2
MOV BYTE PTR [ES:FOUTNAME],$04
MOV WORD PTR [ES:FOUTNAME+$01],'IF'
MOV WORD PTR [ES:FOUTNAME+$03],'EL'
@FINFOUT2: MOV DS,WORD PTR [CS:DATASEG]
SUB BX,BX
@FINFOUT6: MOV AL,BYTE PTR TAPEIMAGENAME[BX]
MOV BYTE PTR IMAGEFOUTNAME[BX],AL
INC BL
CMP BL,$09
JB @FINFOUT6
MOV BYTE PTR FOUTOPEN,$01
MOV WORD PTR FOUTBUFPTR,$0000
CALL CREATEFOUT
POPA
POP ES
POP DS
MOV BL,$0D {---return filehandle---}
JMP @OPCODE60
{---[tapecat]---------------------------------------------------------------}
@TAPECAT: PUSH ES
PUSHA
MOV ES,WORD PTR [CS:DATASEG]
CMP BYTE PTR [ES:AANTALTAPEIMAGES],$00
JZ @CAT2
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH ES
PUSHA
PUSH WORD PTR [@STEPENDOFS]
{---check rest of *cat command for searchstring---}
MOV BYTE PTR CATSEARCH[ES:$00],$00
MOV BX,DX
DEC BX
@CAT19: INC BX
CMP BYTE PTR [$0100+BX],' '
JZ @CAT19
SUB SI,SI
@CAT15: MOV AL,BYTE PTR [$0100+BX]
CMP AL,'"'
JZ @CAT17
CMP AL,$0D
JZ @CAT18
MOV BYTE PTR CATSEARCH[ES:SI],AL
INC SI
CMP SI,$0010
JZ @CAT23
@CAT17: INC BX
CMP AL,'*'
JNZ @CAT15
@CAT18: MOV BYTE PTR CATSEARCH[ES:SI],$00
@CAT23: {---name of tape image---}
MOV AX,WORD PTR [CS:LASTTAPE]
MOV CX,STR8GROOTTE
MUL CX
MOV SI,AX
MOV BX,$0001
@CAT11: MOV AL,BYTE PTR TAPEIMAGES[ES:SI+BX]
CMP AL,$40
JB @CAT14
ADD AL,$20
JMP @CAT13
@CAT14: ADD AL,$60
@CAT13: MOV BYTE PTR [BX+$00EC],AL
INC BL
CMP BL,BYTE PTR TAPEIMAGES[ES:SI]
JBE @CAT11
MOV BYTE PTR [BX+$00EC],$0D
MOV AX,$A000
MOV ES,AX
{---print name of tape image---}
MOV DL,$00 {y-reg=00h}
MOV SI,$FA4A
MOV WORD PTR @STEPENDOFS,$FA4D
@CAT10: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT10
{---go to next line---}
MOV SI,$FA5D
MOV WORD PTR @STEPENDOFS,$FA60
@CAT12: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT12
POP WORD PTR [@STEPENDOFS]
POPA
POP ES
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
{---contents of tape image---}
SUB DX,DX
SUB SI,SI
@CAT1: CMP DX,WORD PTR [ES:AANTALATOMFILES]
JZ @CAT2
SUB BX,BX
@CAT22: MOV AL,BYTE PTR CATSEARCH[ES:BX]
CMP AL,$00
JZ @CAT16
CMP AL,'*'
JZ @CAT16
CMP AL,BYTE PTR ATOMFILES[ES:SI+BX]
JNZ @CAT20
INC BL
CMP BL,$10
JB @CAT22
@CAT16: {---name ok for searchstring---}
SUB BX,BX
@CAT4: MOV AL,BYTE PTR ATOMFILES[ES:SI+BX] {filename}
OR AL,AL
JNZ @CAT3
MOV AL,' '
@CAT3: MOV BYTE PTR [$00ED+BX],AL
INC BL
CMP BL,$10
JB @CAT4
MOV BYTE PTR [$00ED+BX],$0D
MOV AX,WORD PTR ATOMFILES[ES:SI+$0010] {strtaddr}
MOV WORD PTR [$00D4],AX
MOV AX,WORD PTR ATOMFILES[ES:SI+$0012] {execaddr}
MOV WORD PTR [$00D6],AX
MOV AX,WORD PTR ATOMFILES[ES:SI+$0014] {datasize}
MOV WORD PTR [$00D9],AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE1],AL
PUSH AX
MOV AL,$C3 {retn}
XCHG BYTE PTR [CS:@DBGSWAPBYTE2],AL
PUSH ES
PUSHA
PUSH WORD PTR [@STEPENDOFS]
MOV AX,$A000
MOV ES,AX
{---print filename, strtaddr and execaddr---}
MOV DL,$00 {y-reg=00h}
MOV SI,$FA4A
MOV WORD PTR @STEPENDOFS,$FA50
@CAT5: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT5
{---print hi-byte of datasize---}
MOV SI,$F7FA
MOV WORD PTR @STEPENDOFS,$F7FD
MOV BL,[$00DA] {acc=hi-byte}
@CAT7: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT7
{---print lo-byte of datasize---}
MOV SI,$F7FA
MOV WORD PTR @STEPENDOFS,$F7FD
MOV BL,[$00D9] {acc=lo-byte}
@CAT8: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT8
{---go to next line---}
MOV SI,$FA5D
MOV WORD PTR @STEPENDOFS,$FA60
@CAT6: LODSB
MOV AH,$00
SHL AX,1
MOV DI,AX
MOV AX,WORD PTR @OPCODETABLE[DI]
CALL AX
CMP SI,WORD PTR @STEPENDOFS
JNZ @CAT6
POP WORD PTR [@STEPENDOFS]
POPA
POP ES
MOV BYTE PTR [CS:@DBGSWAPBYTE2],AL
POP AX
MOV BYTE PTR [CS:@DBGSWAPBYTE1],AL
@CAT20: INC DX
ADD SI,ATMRECGROOTTE
MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$1D] {---ctrl---}
AND AL,$03
JZ @CAT1
@CAT9: MOV AL,BYTE PTR TOETS[CS:$01] {---escape---}
OR AL,BYTE PTR TOETS[CS:$1D] {---ctrl---}
AND AL,$03
JNZ @CAT9
@CAT2: POPA
POP ES
JMP @OPCODE60
{---[volumeon]--------------------------------------------------------------}
@VOLUMEON: CMP BYTE PTR @SBAVAIL,$00
JNZ @VOLON1
IN AL,$61
AND AL,$FC
OUT $61,AL
RETN
@VOLON1: PUSH DS
PUSH DX
MOV DS,WORD PTR [CS:DATASEG]
MOV DX,WORD PTR IOPORT
ADD DL,$0C
MOV AL,$D1
CALL OUTBYTE
POP DX
POP DS
RETN
{---[volumeoff]-------------------------------------------------------------}
@VOLUMEOFF: CMP BYTE PTR @SBAVAIL,$00
JNZ @VOLOFF1
IN AL,$61
AND AL,$FC
OUT $61,AL
RETN
@VOLOFF1: PUSH DS
PUSH DX
MOV DS,WORD PTR [CS:DATASEG]
MOV DX,WORD PTR IOPORT
ADD DL,$0C
MOV AL,$D3
CALL OUTBYTE
POP DX
POP DS
RETN
{---[data]------------------------------------------------------------------}
@OPCODETABLE: DW OFFSET @OPCODE00
DW OFFSET @OPCODE01
DW OFFSET @OPCODE02
DW OFFSET @OPCODE03
DW OFFSET @OPCODE04
DW OFFSET @OPCODE05
DW OFFSET @OPCODE06
DW OFFSET @OPCODE07
DW OFFSET @OPCODE08
DW OFFSET @OPCODE09
DW OFFSET @OPCODE0A
DW OFFSET @OPCODE0B
DW OFFSET @OPCODE0C
DW OFFSET @OPCODE0D
DW OFFSET @OPCODE0E
DW OFFSET @OPCODE0F
DW OFFSET @OPCODE10
DW OFFSET @OPCODE11
DW OFFSET @OPCODE12
DW OFFSET @OPCODE13
DW OFFSET @OPCODE14
DW OFFSET @OPCODE15
DW OFFSET @OPCODE16
DW OFFSET @OPCODE17
DW OFFSET @OPCODE18
DW OFFSET @OPCODE19
DW OFFSET @OPCODE1A
DW OFFSET @OPCODE1B
DW OFFSET @OPCODE1C
DW OFFSET @OPCODE1D
DW OFFSET @OPCODE1E
DW OFFSET @OPCODE1F
DW OFFSET @OPCODE20
DW OFFSET @OPCODE21
DW OFFSET @OPCODE22
DW OFFSET @OPCODE23
DW OFFSET @OPCODE24
DW OFFSET @OPCODE25
DW OFFSET @OPCODE26
DW OFFSET @OPCODE27
DW OFFSET @OPCODE28
DW OFFSET @OPCODE29
DW OFFSET @OPCODE2A
DW OFFSET @OPCODE2B
DW OFFSET @OPCODE2C
DW OFFSET @OPCODE2D
DW OFFSET @OPCODE2E
DW OFFSET @OPCODE2F
DW OFFSET @OPCODE30
DW OFFSET @OPCODE31
DW OFFSET @OPCODE32
DW OFFSET @OPCODE33
DW OFFSET @OPCODE34
DW OFFSET @OPCODE35
DW OFFSET @OPCODE36
DW OFFSET @OPCODE37
DW OFFSET @OPCODE38
DW OFFSET @OPCODE39
DW OFFSET @OPCODE3A
DW OFFSET @OPCODE3B
DW OFFSET @OPCODE3C
DW OFFSET @OPCODE3D
DW OFFSET @OPCODE3E
DW OFFSET @OPCODE3F
DW OFFSET @OPCODE40
DW OFFSET @OPCODE41
DW OFFSET @OPCODE42
DW OFFSET @OPCODE43
DW OFFSET @OPCODE44
DW OFFSET @OPCODE45
DW OFFSET @OPCODE46
DW OFFSET @OPCODE47
DW OFFSET @OPCODE48
DW OFFSET @OPCODE49
DW OFFSET @OPCODE4A
DW OFFSET @OPCODE4B
DW OFFSET @OPCODE4C
DW OFFSET @OPCODE4D
DW OFFSET @OPCODE4E
DW OFFSET @OPCODE4F
DW OFFSET @OPCODE50
DW OFFSET @OPCODE51
DW OFFSET @OPCODE52
DW OFFSET @OPCODE53
DW OFFSET @OPCODE54
DW OFFSET @OPCODE55
DW OFFSET @OPCODE56
DW OFFSET @OPCODE57
DW OFFSET @OPCODE58
DW OFFSET @OPCODE59
DW OFFSET @OPCODE5A
DW OFFSET @OPCODE5B
DW OFFSET @OPCODE5C
DW OFFSET @OPCODE5D
DW OFFSET @OPCODE5E
DW OFFSET @OPCODE5F
DW OFFSET @OPCODE60
DW OFFSET @OPCODE61
DW OFFSET @OPCODE62
DW OFFSET @OPCODE63
DW OFFSET @OPCODE64
DW OFFSET @OPCODE65
DW OFFSET @OPCODE66
DW OFFSET @OPCODE67
DW OFFSET @OPCODE68
DW OFFSET @OPCODE69
DW OFFSET @OPCODE6A
DW OFFSET @OPCODE6B
DW OFFSET @OPCODE6C
DW OFFSET @OPCODE6D
DW OFFSET @OPCODE6E
DW OFFSET @OPCODE6F
DW OFFSET @OPCODE70
DW OFFSET @OPCODE71
DW OFFSET @OPCODE72
DW OFFSET @OPCODE73
DW OFFSET @OPCODE74
DW OFFSET @OPCODE75
DW OFFSET @OPCODE76
DW OFFSET @OPCODE77
DW OFFSET @OPCODE78
DW OFFSET @OPCODE79
DW OFFSET @OPCODE7A
DW OFFSET @OPCODE7B
DW OFFSET @OPCODE7C
DW OFFSET @OPCODE7D
DW OFFSET @OPCODE7E
DW OFFSET @OPCODE7F
DW OFFSET @OPCODE80
DW OFFSET @OPCODE81
DW OFFSET @OPCODE82
DW OFFSET @OPCODE83
DW OFFSET @OPCODE84
DW OFFSET @OPCODE85
DW OFFSET @OPCODE86
DW OFFSET @OPCODE87
DW OFFSET @OPCODE88
DW OFFSET @OPCODE89
DW OFFSET @OPCODE8A
DW OFFSET @OPCODE8B
DW OFFSET @OPCODE8C
DW OFFSET @OPCODE8D
DW OFFSET @OPCODE8E
DW OFFSET @OPCODE8F
DW OFFSET @OPCODE90
DW OFFSET @OPCODE91
DW OFFSET @OPCODE92
DW OFFSET @OPCODE93
DW OFFSET @OPCODE94
DW OFFSET @OPCODE95
DW OFFSET @OPCODE96
DW OFFSET @OPCODE97
DW OFFSET @OPCODE98
DW OFFSET @OPCODE99
DW OFFSET @OPCODE9A
DW OFFSET @OPCODE9B
DW OFFSET @OPCODE9C
DW OFFSET @OPCODE9D
DW OFFSET @OPCODE9E
DW OFFSET @OPCODE9F
DW OFFSET @OPCODEA0
DW OFFSET @OPCODEA1
DW OFFSET @OPCODEA2
DW OFFSET @OPCODEA3
DW OFFSET @OPCODEA4
DW OFFSET @OPCODEA5
DW OFFSET @OPCODEA6
DW OFFSET @OPCODEA7
DW OFFSET @OPCODEA8
DW OFFSET @OPCODEA9
DW OFFSET @OPCODEAA
DW OFFSET @OPCODEAB
DW OFFSET @OPCODEAC
DW OFFSET @OPCODEAD
DW OFFSET @OPCODEAE
DW OFFSET @OPCODEAF
DW OFFSET @OPCODEB0
DW OFFSET @OPCODEB1
DW OFFSET @OPCODEB2
DW OFFSET @OPCODEB3
DW OFFSET @OPCODEB4
DW OFFSET @OPCODEB5
DW OFFSET @OPCODEB6
DW OFFSET @OPCODEB7
DW OFFSET @OPCODEB8
DW OFFSET @OPCODEB9
DW OFFSET @OPCODEBA
DW OFFSET @OPCODEBB
DW OFFSET @OPCODEBC
DW OFFSET @OPCODEBD
DW OFFSET @OPCODEBE
DW OFFSET @OPCODEBF
DW OFFSET @OPCODEC0
DW OFFSET @OPCODEC1
DW OFFSET @OPCODEC2
DW OFFSET @OPCODEC3
DW OFFSET @OPCODEC4
DW OFFSET @OPCODEC5
DW OFFSET @OPCODEC6
DW OFFSET @OPCODEC7
DW OFFSET @OPCODEC8
DW OFFSET @OPCODEC9
DW OFFSET @OPCODECA
DW OFFSET @OPCODECB
DW OFFSET @OPCODECC
DW OFFSET @OPCODECD
DW OFFSET @OPCODECE
DW OFFSET @OPCODECF
DW OFFSET @OPCODED0
DW OFFSET @OPCODED1
DW OFFSET @OPCODED2
DW OFFSET @OPCODED3
DW OFFSET @OPCODED4
DW OFFSET @OPCODED5
DW OFFSET @OPCODED6
DW OFFSET @OPCODED7
DW OFFSET @OPCODED8
DW OFFSET @OPCODED9
DW OFFSET @OPCODEDA
DW OFFSET @OPCODEDB
DW OFFSET @OPCODEDC
DW OFFSET @OPCODEDD
DW OFFSET @OPCODEDE
DW OFFSET @OPCODEDF
DW OFFSET @OPCODEE0
DW OFFSET @OPCODEE1
DW OFFSET @OPCODEE2
DW OFFSET @OPCODEE3
DW OFFSET @OPCODEE4
DW OFFSET @OPCODEE5
DW OFFSET @OPCODEE6
DW OFFSET @OPCODEE7
DW OFFSET @OPCODEE8
DW OFFSET @OPCODEE9
DW OFFSET @OPCODEEA
DW OFFSET @OPCODEEB
DW OFFSET @OPCODEEC
DW OFFSET @OPCODEED
DW OFFSET @OPCODEEE
DW OFFSET @OPCODEEF
DW OFFSET @OPCODEF0
DW OFFSET @OPCODEF1
DW OFFSET @OPCODEF2
DW OFFSET @OPCODEF3
DW OFFSET @OPCODEF4
DW OFFSET @OPCODEF5
DW OFFSET @OPCODEF6
DW OFFSET @OPCODEF7
DW OFFSET @OPCODEF8
DW OFFSET @OPCODEF9
DW OFFSET @OPCODEFA
DW OFFSET @OPCODEFB
DW OFFSET @OPCODEFC
DW OFFSET @OPCODEFD
DW OFFSET @OPCODEFE
DW OFFSET @OPCODEFF
@VIASTORETABLE:DW OFFSET @STOREB8xx
DW OFFSET @STOREB801
DW OFFSET @STOREB8xx
DW OFFSET @STOREB8xx
DW OFFSET @STOREB804
DW OFFSET @STOREB805
DW OFFSET @STOREB8xx
DW OFFSET @STOREB8xx
DW OFFSET @STOREB808
DW OFFSET @STOREB809
DW OFFSET @NEXTOPC
DW OFFSET @STOREB8xx
DW OFFSET @STOREB80C
DW OFFSET @STOREB80D
DW OFFSET @STOREB80E
DW OFFSET @STOREB80F
@VIAGETTABLE: DW $0000
DW OFFSET @GETB801
DW $0000
DW $0000
DW OFFSET @GETB804
DW $0000
DW $0000
DW $0000
DW OFFSET @GETB808
DW $0000
DW $0000
DW $0000
DW OFFSET @GETB80C
DW OFFSET @GETB80D
DW OFFSET @GETB80E
DW OFFSET @GETB80F
@ORGIRQVEC: DD $00000000
@ORGKEYVEC: DD $00000000
@ORGBRKVEC: DD $00000000
@PCSP: DW $0000
@SBAVAIL: DB $00
@STEPENDOFS: DW $0000
@LASTMENU: DB $00
@LOADCODE: DW $0000
@SAVECODE: DW $0000
@SCHAKELSTART: DB $00
@FILENAMEOFS: DW $0000
@ENDOFPRG:
END;
FOR I := 0 TO 3 DO
IF DISKETTENAMES[I] <> '' THEN CLOSE_DISK_IMAGE (I);
END.
{===========================================================================
BL = A
CL = X
DL = Y
BH flags bit value description pc-bit
7 (80h) N negative 1=NEG 7
6 (40h) V overflow 1=OVFL
5 (20h) -
4 (10h) B break
3 (08h) D decimal 1=DEC
2 (04h) I interrupt 1=DISABLE
1 (02h) Z zero 1=RESULT ZERO 6
0 (01h) C carry 1=TRUE 0
DS = segment of atom memory
SI = PC
BP = stackpointer (only lower 8 bits valid)
----------------------------------------------------------------------------
Memory heap requirements (for $m directive at top of code):
Atom memory FFF8h
Extension boxes & data 101F0h
FIN buffer FFF8h
FOUT buffer 1000h
Flt.Point PC buffer 0900h
Temporary buffers 10FF8h (maximum wanted)
------+
42AD8h = 273,112 bytes minimum required. |
unit YoutubeURLParserU;
interface
uses
System.RegularExpressions;
type
TYoutubeURLParser = class
strict private
class var RegEx: TRegEx;
function GetIsValid: boolean;
var
FYoutubeUrl: String;
FYouTubeID: string;
public
class constructor Create;
constructor Create(AYoutubeUrl: String); reintroduce;
public
property YoutubeUrl: String read FYoutubeUrl;
property IsValid: boolean read GetIsValid;
property YouTubeID: string read FYouTubeID;
end;
implementation
uses
System.SysUtils;
{ TYoutubeURLParser }
class constructor TYoutubeURLParser.Create;
begin
RegEx := TRegEx.Create('(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*)', [TRegExOption.roCompiled]);
end;
constructor TYoutubeURLParser.Create(AYoutubeUrl: String);
var
Tokens: TArray<string>;
Match: TMatch;
begin
inherited Create;
FYouTubeID := '';
FYoutubeUrl := AYoutubeUrl;
Match := RegEx.Match(AYoutubeUrl);
if Match.Success then
begin
Tokens := Match.Value.Split(['/', '='], TStringSplitOptions.ExcludeEmpty);
if Length(Tokens) = 2 then
FYouTubeID := Tokens[1];
end;
end;
function TYoutubeURLParser.GetIsValid: boolean;
begin
Result := FYouTubeID <> '';
end;
end.
|
unit TSTOPluginIntf;
interface
Uses
Forms, Graphics, Classes, TB2Item, HsInterfaceEx,
TSTORgbProgress, TSTOProjectWorkSpace.IO, TSTOScriptTemplate.IO, TSTOHackMasterList.IO;
Type
TUIItemKind = (iikToolBar, iikMainMenu);
ITSTOApplication = Interface(IInterfaceEx)
['{168D6848-663D-4EE2-9599-84B00AAC1ABC}']
Function GetWorkSpace() : ITSTOWorkSpaceProjectGroupIO;
Function GetCurrentProject() : ITSTOWorkSpaceProjectIO;
Function GetCurrentSkinName() : String;
Function GetIcon() : TIcon;
Function GetHost() : TApplication;
Procedure AddItem(AItemKind : TUIItemKind; Sender : TComponent; AItem : TTBCustomItem); OverLoad;
Procedure AddItem(Sender : TComponent; ASrcItem, ATrgItem : TTBCustomItem); OverLoad;
Procedure RemoveItem(AItemKind : TUIItemKind; Sender : TComponent; AItem : TTBCustomItem);
Function CreateWorkSpace() : ITSTOWorkSpaceProjectGroupIO;
Function CreateScriptTemplates() : ITSTOScriptTemplateHacksIO;
Function CreateHackMasterList() : ITSTOHackMasterListIO;
Function CreateRgbProgress() : IRgbProgress;
Property WorkSpace : ITSTOWorkSpaceProjectGroupIO Read GetWorkSpace;
Property CurrentProject : ITSTOWorkSpaceProjectIO Read GetCurrentProject;
Property CurrentSkinName : String Read GetCurrentSkinName;
Property Icon : TIcon Read GetIcon;
Property Host : TApplication Read GetHost;
End;
TTSTOPluginKind = (pkScript, pkPatches, pkGUI);
ITSTOPlugin = Interface(IInterfaceEx)
['{E20CF1A9-1302-4643-8715-7CE1FC87090B}']
Function GetInitialized() : Boolean;
Function GetEnabled() : Boolean;
Procedure SetEnabled(Const AEnabled : Boolean);
Function GetPluginKind() : TTSTOPluginKind;
Function GetName() : String;
Function GetAuthor() : String;
Function GetCopyright() : String;
Function GetDescription() : String;
Function GetPluginId() : String;
Function GetPluginVersion() : String;
Function GetHaveSettings() : Boolean;
Function GetMainApp() : ITSTOApplication;
Function GetPluginPath() : String;
Function GetPluginFileName() : String;
Procedure Configure();
Procedure Initialize(AMainApplication : ITSTOApplication);
Procedure Finalize();
Function ShowSettings() : Boolean;
Function Execute() : Integer;
Property Initialized : Boolean Read GetInitialized;
Property Enabled : Boolean Read GetEnabled Write SetEnabled;
Property PluginKind : TTSTOPluginKind Read GetPluginKind;
Property Name : String Read GetName;
Property Author : String Read GetAuthor;
Property Copyright : String Read GetCopyright;
Property Description : String Read GetDescription;
Property PluginId : String Read GetPluginId;
Property PluginVersion : String Read GetPluginVersion;
Property HaveSettings : Boolean Read GetHaveSettings;
Property MainApp : ITSTOApplication Read GetMainApp;
Property PluginPath : String Read GetPluginPath;
Property PluginFileName : String Read GetPluginFileName;
End;
ITSTOPlugins = Interface(IInterfaceListEx)
['{4B61686E-29A0-2112-858B-BB0F2B390FB5}']
Function Get(Index : Integer) : ITSTOPlugin;
Procedure Put(Index : Integer; Const Item : ITSTOPlugin);
Function Add(Const AItem : ITSTOPlugin) : Integer; OverLoad;
Property Items[Index : Integer] : ITSTOPlugin Read Get Write Put; Default;
End;
TTSTOPlugins = Class(TObject)
Public
Class Function CreatePluginList() : ITSTOPlugins;
End;
implementation
Type
TTSTOPluginsImpl = Class(TInterfaceListEx, ITSTOPlugins)
Protected
Function Get(Index : Integer) : ITSTOPlugin; OverLoad;
Procedure Put(Index : Integer; Const Item : ITSTOPlugin); OverLoad;
Function Add(Const AItem : ITSTOPlugin) : Integer; OverLoad;
End;
Class Function TTSTOPlugins.CreatePluginList() : ITSTOPlugins;
Begin
Result := TTSTOPluginsImpl.Create();
End;
Function TTSTOPluginsImpl.Get(Index : Integer) : ITSTOPlugin;
Begin
Result := InHerited Items[Index] As ITSTOPlugin;
End;
Procedure TTSTOPluginsImpl.Put(Index : Integer; Const Item : ITSTOPlugin);
Begin
InHerited Items[Index] := Item;
End;
Function TTSTOPluginsImpl.Add(Const AItem : ITSTOPlugin) : Integer;
Begin
Result := InHerited Add(AItem);
End;
end.
|
unit TestKM_AIFields;
interface
uses
TestFramework, KM_CommonTypes, SysUtils, KM_CommonClasses, KM_Points,
KM_Defaults, KromUtils, Classes, KM_Utils, Math, KM_Hand, KM_PolySimplify,
KM_AIFields, KM_Log, KM_Terrain, KM_Resource, KM_ResTileset;
type
TestTKMAIFields = class(TTestCase)
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestUpdateNavMesh;
end;
implementation
procedure TestTKMAIFields.SetUp;
begin
SKIP_RENDER := True;
ExeDir := ExtractFilePath(ParamStr(0)) + '..\';
gLog := TKMLog.Create(ExtractFilePath(ParamStr(0)) + 'Temp\temp.log');
gRes := TKMResource.Create(nil, nil);
gRes.LoadMainResources;
gTerrain := TKMTerrain.Create;
fAIFields := TKMAIFields.Create;
end;
procedure TestTKMAIFields.TearDown;
begin
fAIFields.Free;
gTerrain.Free;
FreeAndNil(gRes);
gLog.Free;
end;
procedure TestTKMAIFields.TestUpdateNavMesh;
var
I: Integer;
Count, Total: Integer;
SearchRec: TSearchRec;
PathToMaps: TStringList;
begin
Count := 0;
Total := 0;
PathToMaps := TStringList.Create;
try
PathToMaps.Add(ExeDir + 'Maps\');
PathToMaps.Add(ExeDir + 'MapsMP\');
PathToMaps.Add(ExeDir + 'Tutorials\');
//Include all campaigns maps
FindFirst(ExeDir + 'Campaigns\*', faDirectory, SearchRec);
repeat
if (SearchRec.Name <> '.') and (SearchRec.Name <> '..') then
PathToMaps.Add(ExeDir + 'Campaigns\' + SearchRec.Name + '\');
until (FindNext(SearchRec) <> 0);
FindClose(SearchRec);
for I := 0 to PathToMaps.Count - 1 do
if DirectoryExists(PathToMaps[I]) then
begin
FindFirst(PathToMaps[I] + '*', faDirectory, SearchRec);
repeat
if (SearchRec.Name <> '.') and (SearchRec.Name <> '..')
and FileExists(PathToMaps[I] + SearchRec.Name + '\' + SearchRec.Name + '.map') then
begin
try
gTerrain.LoadFromFile(PathToMaps[I] + SearchRec.Name + '\' + SearchRec.Name + '.map', False);
fAIFields.UpdateState(0);
Inc(Count);
except
//Report and swallow asserts
on E: EAssertionFailed do
Status('Map did not load: ' + SearchRec.Name + '. '+ E.Message);
end;
Inc(Total);
end;
until (FindNext(SearchRec) <> 0);
FindClose(SearchRec);
end;
finally
PathToMaps.Free;
end;
Check(Total = Count, IntToStr(Total - Count) + ' of ' + IntToStr(Total) + ' maps failed');
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTKMAIFields.Suite);
end.
|
// ******************************************************************
//
// Program Name : AT Software_DNA Library
// Program Version: 1.00
// Platform(s) : OS X, Win32, Win64
// Framework : FireMonkey
//
// Filenames : AT.DNA.FMX.Dlg.Activation.pas/.fmx
// File Version : 1.20
// Date Created : 04-MAY-2016
// Author : Matthew S. Vesperman
//
// Description:
//
// Activation dialog for Software_DNA - FireMonkey version for
// cross-platform.
//
// Revision History:
//
// v1.00 : Initial version
// v1.10 : 30-MAY-2016
// + text field trimming
// + password field validity check
// v1.20 : 28-JUN-2016
// * Implemented resource strings
//
// ******************************************************************
//
// COPYRIGHT © 2015 - PRESENT Angelic Technology
// ALL RIGHTS RESERVED WORLDWIDE
//
// ******************************************************************
unit AT.DNA.FMX.Dlg.Activation;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes,
System.Variants, FMX.Types, FMX.Graphics, FMX.Controls, FMX.Forms,
FMX.Dialogs, FMX.StdCtrls, AT.DNA.FMX.Dlg.Base, FMX.Objects,
FMX.Edit, System.ImageList, FMX.ImgList, FMX.Layouts,
FMX.Controls.Presentation;
type
TDNAActivationDlg = class(TDNABaseDlg)
btnConfirmEmailClear: TClearEditButton;
btnConfirmPwdClear: TClearEditButton;
btnConfirmPwdShow: TPasswordEditButton;
btnEmailClear: TClearEditButton;
btnPwdClear: TClearEditButton;
btnPwdShow: TPasswordEditButton;
lblConfirmEmail: TLabel;
lblConfirmPwd: TLabel;
lblEmail: TLabel;
lblPassword: TLabel;
Line1: TLine;
txtConfirmEmail: TEdit;
txtConfirmPassword: TEdit;
txtEmail: TEdit;
txtPassword: TEdit;
strict private
/// <summary>
/// Stores the value of the ActivationCode property.
/// </summary>
FActivationCode: string;
/// <summary>
/// EmailAddress property getter.
/// </summary>
function GetEmailAddress: String;
/// <summary>
/// Password property getter.
/// </summary>
function GetPassword: string;
/// <summary>
/// ActivationCode property setter.
/// </summary>
procedure SetActivationCode(const Value: string);
/// <summary>
/// EmailAddress property setter.
/// </summary>
procedure SetEmailAddress(const Value: String);
/// <summary>
/// Password property setter.
/// </summary>
procedure SetPassword(const Value: string);
strict protected
procedure InitControls; override;
procedure InitFields; override;
function ValidateFields: Boolean; override;
published
/// <summary>
/// Gets/Sets the activation code for the dialog box.
/// </summary>
property ActivationCode: string read FActivationCode
write SetActivationCode;
/// <summary>
/// Gets/Sets the email address field of the dialog box.
/// </summary>
property EmailAddress: String read GetEmailAddress
write SetEmailAddress;
/// <summary>
/// Gets/Sets the password field of the dialog box.
/// </summary>
property Password: string read GetPassword write SetPassword;
end;
var
DNAActivationDlg: TDNAActivationDlg;
implementation
{$R *.fmx}
uses
AT.XPlatform.Internet, AT.DNA.ResourceStrings;
function TDNAActivationDlg.GetEmailAddress: String;
begin
Result := TrimTextField(txtEmail); //Return the email address...
end;
function TDNAActivationDlg.GetPassword: string;
begin
Result := TrimTextField(txtPassword); //Return the password...
end;
procedure TDNAActivationDlg.InitControls;
begin
inherited InitControls; //call inherited...
//Set OK button caption to 'Activate'...
btnOK.Text := rstrActivate;
txtEmail.SetFocus; //set focus to email address field...
end;
procedure TDNAActivationDlg.InitFields;
begin
inherited InitFields; //call inherited...
//Set all fields to empty string...
ActivationCode := EmptyStr;
EmailAddress := EmptyStr;
Password := EmptyStr;
end;
procedure TDNAActivationDlg.SetActivationCode(const Value: string);
begin
//Store activation code...
FActivationCode := Value;
//Set dialog caption to include activation code...
Self.Caption := Format(rstrActivateCapFmt, [Value]);
end;
procedure TDNAActivationDlg.SetEmailAddress(const Value: String);
begin
//Set email and confirm email to value...
txtEmail.Text := Value.Trim;
txtConfirmEmail.Text := Value.Trim;
end;
procedure TDNAActivationDlg.SetPassword(const Value: string);
begin
//Set pwd and confirm pwd fields to value...
txtPassword.Text := Value.Trim;
txtConfirmPassword.Text := Value.Trim;
end;
function TDNAActivationDlg.ValidateFields: Boolean;
var
AEmail, AConfirmEmail, APwd, AConfirmPwd: String;
begin
//Check if email address is empty...
AEmail := TrimTextField(txtEmail);
if (AEmail.IsEmpty) then
begin
//Email address is blank, inform user...
MessageDlg(rstrValEmailEmpty, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtEmail.SetFocus; //Set focus to email address...
Exit(False); //Validation failure...
end;
//Check format of email address...
if (NOT CheckEmailFormat(AEmail)) then
begin
//Email address format invalid, inform user...
MessageDlg(rstrValEmailInvalid, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtEmail.SetFocus; //Set focus to email address...
Exit(False); //Validation failure...
end;
//Check if confirm email address is empty...
AConfirmEmail := TrimTextField(txtConfirmEmail);
if (AConfirmEmail.IsEmpty) then
begin
//Confirm email is blank, inform user...
MessageDlg(rstrValEmailConfirmEmpty, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtConfirmEmail.SetFocus; //Set focus to confirm email...
Exit(False); //Validation failure...
end;
//Check format of confirm email...
if (NOT CheckEmailFormat(AConfirmEmail)) then
begin
//Confirm email format invalid...
MessageDlg(rstrValEmailConfirmInvalid, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtConfirmEmail.SetFocus; //Set focus to confirm email...
Exit(False); //Validation failure...
end;
//Check if email and confirm email are the same, case-insensitive...
if (CompareText(AEmail, AConfirmEmail) <> 0) then
begin
//Emails do not match, inform user...
MessageDlg(rstrValEmailMismatch, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtConfirmEmail.SetFocus; //Set focus to confirm email...
Exit(False); //Validation failure...
end;
//Check if password is empty...
APwd := TrimTextField(txtPassword);
if (APwd.IsEmpty) then
begin
//Password is blank, inform user...
MessageDlg(rstrValPwdEmpty, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtPassword.SetFocus; //Set focus to password...
Exit(False); //Validation failure...
end;
//Check for valid password...
if (NOT IsPasswordValid(APwd)) then
begin
//Password is invalid...
MessageDlg(rstrValPwdInvalid, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtPassword.SetFocus; //Set focus to password...
Exit(False); //Validation failure...
end;
//Check if confirm password is blank...
AConfirmPwd := TrimTextField(txtConfirmPassword);
if (AConfirmPwd.IsEmpty) then
begin
//Confirm pwd is blank, inform user...
MessageDlg(rstrValPwdConfirmEmpty, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtConfirmPassword.SetFocus; //Set focus to confirm pwd...
Exit(False); //Validation failure...
end;
//Check if pwd and confirm pwd match, case-sensitive...
if (APwd.CompareTo(AConfirmPwd) <> 0) then
begin
//Passwords do NOT match, inform user...
MessageDlg(rstrValPwdMismatch, TMsgDlgType.mtError,
[TMsgDlgBtn.mbOK], 0, TMsgDlgBtn.mbOK);
txtPassword.SetFocus; //Set focus to password field...
Exit(False); //Validation failure...
end;
Result := inherited ValidateFields; //call inherited...
end;
end.
|
//---------------------------------------------------------------------------
// This software is Copyright (c) 2015 Embarcadero Technologies, Inc.
// You may only use this software if you are an authorized licensee
// of an Embarcadero developer tools product.
// This software is considered a Redistributable as defined under
// the software license agreement that comes with the Embarcadero Products
// and is subject to that software license agreement.
//---------------------------------------------------------------------------
unit CloudPopulator;
interface
uses
SysUtils, Classes, Generics.Collections, Data.Cloud.CloudAPI, Data.Cloud.AmazonAPI, Data.Cloud.AzureAPI;
type
TCloudLoggerType = (cltError, cltInfo);
TCloudLoggerHook = procedure(Msg: String; MsgType: TCloudLoggerType) of object;
TCloudLogger = class
private
FHook: TCloudLoggerHook;
public
constructor Create(Hook: TCloudLoggerHook); virtual;
property Hook: TCloudLoggerHook read FHook;
end;
TLocalFileType = (lftDrive, lftDirectory, lftFile);
TCloudFileType = (cftBucket, cftContainer, cftFolder, cftFile);
TCloudConnectionType = (cctAmazon, cctAzure);
TCloudConnection = class
private
FCloudType: TCloudConnectionType;
FDisplayName: String;
FConnection: TCloudConnectionInfo;
public
constructor Create(const DisplayName, AccountName, AccountPass: String;
CloudType: TCloudConnectionType); virtual;
destructor Destroy; override;
property CloudType: TCloudConnectionType read FCloudType;
property DisplayName: String read FDisplayName;
property Connection: TCloudConnectionInfo read FConnection;
end;
TLocalFile = record
Path: String;
Name: String;
FileType: TLocalFileType;
class function Create(const Name, Path: String; FileType: TLocalFileType): TLocalFile; static;
end;
TCloudFile = record
Container: String;
Path: String;
Name: String;
FileType: TCloudFileType;
class function Create(const Name, Container, Path: String; FileType: TCloudFileType): TCloudFile; static;
end;
TCloudPopulator = class abstract
protected
FLogger: TCloudLogger;
FConnectionId: String;
function GetCloudType: TCloudConnectionType; virtual; abstract;
procedure Log(Msg: String; MsgType: TCloudLoggerType);
public
procedure LoadRootFiles(var Files: TObjectDictionary<String,TCloudFile>); virtual; abstract;
function GetPath: String; virtual; abstract;
function GetContainer: String; virtual; abstract;
procedure SetPath(Container, Path: String; var Files: TObjectDictionary<String,TCloudFile>); virtual; abstract;
procedure GetCurrentFiles(var Files: TObjectDictionary<String,TCloudFile>); virtual; abstract;
function UploadFile(LocalFile: TLocalFile; BasePath: String = ''): Boolean; virtual; abstract;
function DeleteFile(CloudFile: TCloudFile): Boolean; virtual; abstract;
function DownloadFile(CloudFile: TCloudFile; Directory: String): Boolean; virtual; abstract;
function CreateContainer(ContainerName: String): Boolean; virtual; abstract;
property CloudType: TCloudConnectionType read GetCloudType;
property Logger: TCloudLogger read FLogger write FLogger;
property ConnectionId: String read FConnectionId write FConnectionId;
end;
TAmazonPopulator = class(TCloudPopulator)
private
FPath: String;
FContainer: String;
FConnection: TAmazonConnectionInfo;
FService: TAmazonStorageService;
procedure GetFiles(Container, Path: String; var Files: TObjectDictionary<String,TCloudFile>; Flatten: Boolean = false);
protected
function GetCloudType: TCloudConnectionType; override;
public
constructor Create(Conn: TAmazonConnectionInfo);
destructor Destroy; override;
procedure LoadRootFiles(var Files: TObjectDictionary<String,TCloudFile>); override;
function GetPath: String; override;
function GetContainer: String; override;
procedure SetPath(Container, Path: String; var Files: TObjectDictionary<String,TCloudFile>); override;
procedure GetCurrentFiles(var Files: TObjectDictionary<String,TCloudFile>); override;
function UploadFile(LocalFile: TLocalFile; BasePath: String = ''): Boolean; override;
function DeleteFile(CloudFile: TCloudFile): Boolean; override;
function DownloadFile(CloudFile: TCloudFile; Directory: String): Boolean; override;
function CreateContainer(ContainerName: String): Boolean; override;
end;
TAzurePopulator = class(TCloudPopulator)
private
FPath: String;
FContainer: String;
FConnection: TAzureConnectionInfo;
FService: TAzureBlobService;
function GetContainerName(SpecifiedContainer: String): String;
function IsInRootContainer: Boolean;
procedure GetFiles(Container, Path: String; var Files: TObjectDictionary<String,TCloudFile>; Flatten: Boolean = false);
protected
function GetCloudType: TCloudConnectionType; override;
public
constructor Create(Conn: TAzureConnectionInfo);
destructor Destroy; override;
procedure LoadRootFiles(var Files: TObjectDictionary<String,TCloudFile>); override;
function GetPath: String; override;
function GetContainer: String; override;
procedure SetPath(Container, Path: String; var Files: TObjectDictionary<String,TCloudFile>); override;
procedure GetCurrentFiles(var Files: TObjectDictionary<String,TCloudFile>); override;
function UploadFile(LocalFile: TLocalFile; BasePath: String = ''): Boolean; override;
function DeleteFile(CloudFile: TCloudFile): Boolean; override;
function DownloadFile(CloudFile: TCloudFile; Directory: String): Boolean; override;
function CreateContainer(ContainerName: String): Boolean; override;
end;
TTransferJobStatus = (tjsWAITING, tjsRUNNING, tjsFINISHED);
TTransferJobType = (tjtUPLOAD, tjtDOWNLOAD);
TCloudTransferJob = class abstract(TThread)
protected
FLocalFilePath: String;
FContainerName: String;
FFileName: String;
FJobType: TTransferJobType;
FJobStatus: TTransferJobStatus;
public
property JobType: TTransferJobType read FJobType write FJobType;
property FileName: String read FFileName write FFileName;
property ContainerName: String read FContainerName write FContainerName;
property LocalFilePath: String read FLocalFilePath write FLocalFilePath;
property JobStatus: TTransferJobStatus read FJobStatus write FJobStatus;
end;
TAmazonTransferJob = class(TCloudTransferJob)
private
FService: TAmazonStorageService;
FPopulator: TCloudPopulator;
public
constructor Create(Service: TAmazonStorageService; JobType: TTransferJobType;
FileName, ContainerName, LocalFilePath: String;
Populator: TCloudPopulator); virtual;
destructor Destroy; override;
procedure Execute; override;
end;
TAzureTransferJob = class(TCloudTransferJob)
private
FService: TAzureBlobService;
FPopulator: TCloudPopulator;
public
constructor Create(Service: TAzureBlobService; JobType: TTransferJobType;
FileName, ContainerName, LocalFilePath: String;
Populator: TCloudPopulator); virtual;
destructor Destroy; override;
procedure Execute; override;
end;
TTransferJobUpdateListener = reference to procedure(Job: TCloudTransferJob);
TTransferJobVisitor = reference to procedure(const Job: TCloudTransferJob);
TCloudTransferManager = class
private
class var FInstance: TCloudTransferManager;
FJobs: TList<TCloudTransferJob>;
FListeners: TList<TTransferJobUpdateListener>;
procedure NotifyListeners(Job: TCloudTransferJob);
function GetSize: Integer;
public
constructor Create;
destructor Destroy; override;
/// <summary> Iterates over all jobs and invokes the TTransferJobVisitor for each.
/// </summary>
procedure ForEachJob(AVisitor: TTransferJobVisitor);
function AddJob(Job: TCloudTransferJob): boolean;
procedure RemoveJob(Job: TCloudTransferJob);
procedure AddListener(Listener: TTransferJobUpdateListener);
procedure RemoveListener(Listener: TTransferJobUpdateListener);
property Size: Integer read GetSize;
/// <summary> Returns the singleton instance of this class.</summary>
class property Instance: TCloudTransferManager read FInstance;
end;
//returns a new instance of a populator, depending on connection type
function GetPopulator(Conn: TCloudConnection): TCloudPopulator;
function GetCloudTypeName(AType: TCloudConnectionType): String;
function GetCloudTypeFromName(AType: String): TCloudConnectionType;
implementation
uses StrUtils;
function GetPopulator(Conn: TCloudConnection): TCloudPopulator;
begin
Result := nil;
if Conn = nil then
Exit;
if Conn.FCloudType = cctAmazon then
Result := TAmazonPopulator.Create(TAmazonConnectionInfo(Conn.Connection))
else if Conn.FCloudType = cctAzure then
Result := TAzurePopulator.Create(TAzureConnectionInfo(Conn.Connection));
if Result <> nil then
Result.ConnectionId := Conn.DisplayName;
end;
function GetCloudTypeName(AType: TCloudConnectionType): String;
begin
case AType of
cctAmazon : Exit('Amazon');
cctAzure : Exit('Azure');
else
Exit('Unknown');
end;
end;
function GetCloudTypeFromName(AType: String): TCloudConnectionType;
begin
Result := cctAzure; //Default to azure
if AnsiSameText('Amazon', AType) then
Exit(cctAmazon);
if AnsiSameText('Azure', AType) then
Exit(cctAzure);
end;
procedure GetNestedLocalFiles(LocalFile: TLocalFile; var FileList: TList<TLocalFile>; Flatten: Boolean);
var
SR: TSearchRec;
IsFound: Boolean;
Path: String;
LF: TLocalFile;
begin
if (LocalFile.FileType = lftDirectory) or (LocalFile.FileType = lftDrive) then
begin
Path := LocalFile.Path + LocalFile.Name;
if (Path <> EmptyStr) and (not AnsiEndsStr('\', Path)) then
Path := Path + '\';
//Find all the files of the directory
IsFound := FindFirst(Path + '*', faAnyFile - faDirectory, SR) = 0;
while IsFound do begin
FileList.Add(TLocalFile.Create(SR.Name, Path, lftFile));
IsFound := FindNext(SR) = 0;
end;
FindClose(SR);
//find all the directories
IsFound := FindFirst(Path + '*.*', faAnyFile, SR) = 0;
while IsFound do begin
if ((SR.Attr and faDirectory) <> 0) and (SR.Name[1] <> '.') and (not AnsiSameText(SR.Name, '$Recycle.Bin')) then
begin
LF := TLocalFile.Create(SR.Name, Path, lftDirectory);
//if flatten is true, recursivly get the files under each directory
if Flatten then
GetNestedLocalFiles(LF, FileList, Flatten)
//otherwise, just return the list of directories
else
FileList.Add(LF);
end;
IsFound := FindNext(SR) = 0;
end;
FindClose(SR);
end;
end;
function ByteContent(DataStream: TStream): TBytes;
var
Buffer: TBytes;
begin
if not Assigned(DataStream) then
exit(nil);
SetLength(Buffer, DataStream.Size);
// the content may have been read
DataStream.Position := 0;
if DataStream.Size > 0 then
DataStream.Read(Buffer[0], DataStream.Size);
Result := Buffer;
end;
{ TCloudLogger }
constructor TCloudLogger.Create(Hook: TCloudLoggerHook);
begin
FHook := Hook;
end;
{ TCloudConnection }
constructor TCloudConnection.Create(const DisplayName, AccountName, AccountPass: String;
CloudType: TCloudConnectionType);
begin
FDisplayName := DisplayName;
FCloudType := CloudType;
if CloudType = cctAmazon then
FConnection := TAmazonConnectionInfo.Create(nil)
else
FConnection := TAzureConnectionInfo.Create(nil);
FConnection.AccountName := AccountName;
FConnection.AccountKey := AccountPass;
end;
destructor TCloudConnection.Destroy;
begin
FreeAndNil(FConnection);
inherited;
end;
{ TLocalFile }
class function TLocalFile.Create(const Name, Path: String; FileType: TLocalFileType): TLocalFile;
begin
Result.Path := Path;
Result.Name := Name;
Result.FileType := FileType;
end;
{ TCloudFile }
class function TCloudFile.Create(const Name, Container, Path: String; FileType: TCloudFileType): TCloudFile;
begin
Result.Container := Container;
Result.Path := Path;
Result.Name := Name;
Result.FileType := FileType;
end;
{ TCloudPopulator }
procedure TCloudPopulator.Log(Msg: String; MsgType: TCloudLoggerType);
begin
if Assigned(FLogger) then
FLogger.Hook(Msg, MsgType);
end;
{ TAmazonPopulator }
constructor TAmazonPopulator.Create(Conn: TAmazonConnectionInfo);
begin
FPath := EmptyStr;
FContainer := EmptyStr;
FConnection := Conn;
FService := TAmazonStorageService.Create(Conn);
end;
function TAmazonPopulator.CreateContainer(ContainerName: String): Boolean;
var
RespInfo: TCloudResponseInfo;
begin
Result := False;
if FService <> nil then
begin
Log('Creating Amazon Bucket: ' + ContainerName, cltInfo);
RespInfo := TCloudResponseInfo.Create;
try
Result := FService.CreateBucket(AnsiLowerCase(ContainerName), amzbaNotSpecified, amzrNotSpecified, RespInfo);
if not Result then
Log(RespInfo.StatusMessage, cltError);
finally
FreeAndNil(RespInfo);
end;
end;
end;
function TAmazonPopulator.DeleteFile(CloudFile: TCloudFile): Boolean;
var
RespInfo: TCloudResponseInfo;
FilePath: String;
Params: TStrings;
BR: TAmazonBucketResult;
ObjR: TAmazonObjectResult;
begin
Result := False;
if FService <> nil then
begin
RespInfo := TCloudResponseInfo.Create;
try
if CloudFile.FileType = cftBucket then
begin
Log('Deleting Amazon Bucket: ' + CloudFile.Name, cltInfo);
Result := FService.DeleteBucket(CloudFile.Name);
end
else if CloudFile.FileType = cftFolder then
begin
Params := TStringList.Create;
Params.Values['prefix'] := CloudFile.Path + CloudFile.Name;
BR := nil;
try
Log('Deleting Amazon Virtual Folder: ' + CloudFile.Path + CloudFile.Name, cltInfo);
BR := FService.GetBucket(CloudFile.Container, Params, RespInfo);
for ObjR In BR.Objects do
begin
if not FService.DeleteObject(CloudFile.Container, ObjR.Name, RespInfo) then
begin
Log(RespInfo.StatusMessage, cltError);
Result := False;
end;
end;
finally
FreeAndNil(BR);
FreeAndNil(Params);
end;
end
else if CloudFile.FileType = cftFile then
begin
Log('Deleting Amazon Object: ' + FilePath, cltInfo);
FilePath := CloudFile.Path + CloudFile.Name;
Result := FService.DeleteObject(CloudFile.Container, FilePath, RespInfo);
if not Result then
Log(RespInfo.StatusMessage, cltError);
end;
finally
FreeAndNil(RespInfo);
end;
end;
end;
destructor TAmazonPopulator.Destroy;
begin
FreeAndNil(FService);
inherited;
end;
function TAmazonPopulator.DownloadFile(CloudFile: TCloudFile; Directory: String): Boolean;
var
FileName: String;
LocalFilePath: String;
LFiles: TObjectDictionary<String,TCloudFile>;
AFile: TCloudFile;
VirtualPath, TruncPath: String;
begin
Result := false;
LFiles := nil;
if FService <> nil then
begin
Directory := AnsiReplaceStr(Directory, '/', '\');
if not ForceDirectories(Directory) then
begin
Log('Failed to make directories: ' + IntToStr(GetLastError) + ' (' + Directory + ')', cltError);
Exit(False);
end;
Directory := AnsiReplaceStr(Directory, '\', '/');
if not AnsiEndsStr('/', Directory) then
Directory := Directory + '/';
if CloudFile.FileType = cftBucket then
begin
GetFiles(CloudFile.Name, EmptyStr, LFiles, True);
try
for AFile In LFiles.Values do
DownloadFile(AFile, Directory + CloudFile.Name + '/' + AFile.Path);
finally
FreeAndNil(LFiles);
end;
end
else if CloudFile.FileType = cftFolder then
begin
VirtualPath := CloudFile.Path + CloudFile.Name;
GetFiles(CloudFile.Container, VirtualPath, LFiles, True);
try
for AFile In LFiles.Values do
begin
//Make the full path based on the parent folder's name, and the relative path
//from the parent folder to this folder. The files retuned are flattened,
//so a file may be nested several virtual folders deep.
TruncPath := Copy(AFile.Path, Length(VirtualPath) + 1);
TruncPath := Directory + VirtualPath + TruncPath;
DownloadFile(AFile, TruncPath);
end;
finally
FreeAndNil(LFiles);
end;
end
else if CloudFile.FileType = cftFile then
begin
FileName := Cloudfile.Path + CloudFile.Name;
Directory := AnsiReplaceStr(Directory, '\', '/');
if not AnsiEndsStr('/', Directory) then
Directory := Directory + '/';
LocalFilePath := Directory + CloudFile.Name;
Log('Downloading Amazon From: ' + FileName + ', to: ' + LocalFilePath, cltInfo);
TAmazonTransferJob.Create(FService, tjtDOWNLOAD, FileName, CloudFile.Container, LocalFilePath, Self);
end;
end;
end;
function TAmazonPopulator.GetCloudType: TCloudConnectionType;
begin
Result := cctAmazon;
end;
function TAmazonPopulator.GetContainer: String;
begin
Result := FContainer;
end;
function TAmazonPopulator.GetPath: String;
begin
Result := FPath;
end;
procedure TAmazonPopulator.LoadRootFiles(var Files: TObjectDictionary<String, TCloudFile>);
begin
FPath := EmptyStr;
FContainer := EmptyStr;
GetCurrentFiles(Files);
end;
procedure TAmazonPopulator.SetPath(Container, Path: String; var Files: TObjectDictionary<String, TCloudFile>);
begin
FContainer := Container;
FPath := Path;
if (FPath <> EmptyStr) and (not AnsiEndsStr('/', FPath)) then
FPath := FPath + '/';
if AnsiStartsStr('/', FPath) then
FPath := Copy(FPath, 2);
GetCurrentFiles(Files);
end;
function TAmazonPopulator.UploadFile(LocalFile: TLocalFile; BasePath: String): Boolean;
var
ObjName: String;
FileName: String;
LocalFiles: TList<TLocalFile>;
InnerLF: TLocalFile;
begin
Result := False;
if (LocalFile.Name <> EmptyStr) and (FContainer <> EmptyStr) then
begin
if LocalFile.FileType = lftDirectory then
begin
LocalFiles := TList<TLocalFile>.Create;
GetNestedLocalFiles(LocalFile, LocalFiles, True);
try
Result := True;
for InnerLF In LocalFiles do
begin
BasePath := AnsiReplaceStr(Copy(InnerLF.Path, Length(LocalFile.Path) + 1), '\', '/');
if not UploadFile(InnerLF, BasePath) then
begin
Result := False;
end;
end;
finally
FreeAndNil(LocalFiles);
end;
end
else if LocalFile.FileType = lftFile then
begin
FileName := LocalFile.Path + LocalFile.Name;
if FileExists(FileName) then
begin
ObjName := FPath + BasePath + LocalFile.Name;
Log('Uploading File to Amazon. From: ' + FileName + ', To: ' + ObjName, cltInfo);
TAmazonTransferJob.Create(FService, tjtUPLOAD, ObjName, FContainer, FileName, Self);
end;
end;
end;
end;
procedure TAmazonPopulator.GetCurrentFiles(var Files: TObjectDictionary<String, TCloudFile>);
begin
GetFiles(FContainer, FPath, Files);
end;
procedure TAmazonPopulator.GetFiles(Container, Path: String;
var Files: TObjectDictionary<String,TCloudFile>; Flatten: Boolean);
var
Aux: String;
Results: TStrings;
RespInfo: TCloudResponseInfo;
Params: TStrings;
BResult: TAmazonBucketResult;
OResult: TAmazonObjectResult;
I, Count, Index: Integer;
TrimmedName, TrimmedPath, UniqueId: String;
begin
if not Assigned(Files) then
Files := TObjectDictionary<String,TCloudFile>.Create
else
Files.Clear;
RespInfo := TCloudResponseInfo.Create;
try
//load either buckets, or files of a bucket. Container = Bucket
if (Container = EmptyStr) then
begin
Results := FService.ListBuckets(RespInfo);
if Assigned(Results) then
begin
try
Count := Results.Count - 1;
for I := 0 to Count do
begin
Aux := Results.Names[I];
Files.Add(Aux, TCloudFile.Create(Aux, EmptyStr, EmptyStr, cftBucket));
end;
finally
FreeAndNil(Results);
end;
end
else
Log(RespInfo.StatusMessage, cltError);
end
//load files from a bucket
else
begin
Params := TStringList.Create;
if not Flatten then
Params.Values['delimiter'] := '/';
Params.Values['prefix'] := Path;
try
BResult := FService.GetBucket(Container, Params, RespInfo);
if BResult <> nil then
begin
try
//Populate folders
if (not Flatten) and Assigned(BResult.Prefixes) then
begin
for Aux In BResult.Prefixes do
begin
Count := Length(Path);
if AnsiEndsStr('/', Aux) then
TrimmedName := Copy(Aux, Count + 1, (Length(Aux) - Count) - 1)
else
TrimmedName := Copy(Aux, Count + 1);
Files.Add(TrimmedName, TCloudFile.Create(TrimmedName, Container, Path, cftFolder));
end;
end
else
Log(RespInfo.StatusMessage, cltError);
//Populate files
if Assigned(BResult.Objects) then
begin
for OResult In BResult.Objects do
//TODO:: If it ends in '_$folder$' then make a folder
if (not OResult.IsDeleted) and (not AnsiEndsStr('_$folder$', OResult.Name)) then
begin
if Flatten then
TrimmedPath := EmptyStr;
TrimmedName := OResult.Name;
if AnsiEndsText('/', TrimmedName) then
TrimmedName := Copy(TrimmedName, 1, Length(TrimmedName));
Index := LastDelimiter('/', TrimmedName);
if (Index > 0) and (Index < Length(TrimmedName)) then
begin
TrimmedPath := Copy(TrimmedName, 1, Index);
TrimmedName := Copy(TrimmedName, Index + 1);
end
else
begin
TrimmedPath := Path;
TrimmedName := Copy(OResult.Name, Length(Path) + 1);
end;
//If flattening, then you need to make sure the dictionary Keys are all unique
//add container to path because you can have a blob in the root container
//and a blob directly under some container, where the blob has the same name as the one
//in the root container. (This would cause a name conflict.)
if Flatten then
UniqueId := Container + '/' + TrimmedPath + TrimmedName
else
UniqueId := TrimmedName;
Files.Add(UniqueId, TCloudFile.Create(TrimmedName, Container, TrimmedPath, cftFile));
end;
end;
finally
FreeAndNil(BResult);
end;
end;
finally
FreeAndNil(Params);
end;
end;
finally
FreeAndNil(RespInfo);
end;
end;
{ TAzurePopulator }
constructor TAzurePopulator.Create(Conn: TAzureConnectionInfo);
begin
FPath := EmptyStr;
FContainer := EmptyStr;
FConnection := Conn;
FService := TAzureBlobService.Create(Conn);
end;
function TAzurePopulator.CreateContainer(ContainerName: String): Boolean;
var
RespInfo: TCloudResponseInfo;
begin
Result := False;
if FService <> nil then
begin
Log('Creating Azure Container: ' + ContainerName, cltInfo);
RespInfo := TCloudResponseInfo.Create;
try
//TODO:: Control visibility
Result := FService.CreateContainer(AnsiLowerCase(ContainerName), nil, bpaPrivate, RespInfo);
if not Result then
Log(RespInfo.StatusMessage, cltError);
finally
FreeAndNil(RespInfo);
end;
end;
end;
function TAzurePopulator.DeleteFile(CloudFile: TCloudFile): Boolean;
var
RespInfo: TCloudResponseInfo;
FilePath: String;
ContainerName: String;
Params: TStrings;
Blobs: TList<TAzureBlob>;
Blob: TAzureBlob;
begin
Result := False;
if FService <> nil then
begin
RespInfo := TCloudResponseInfo.Create;
try
//delete a container
if CloudFile.FileType = cftContainer then
begin
if (CloudFile.Name <> EmptyStr) and (CloudFile.Name <> '$root') then
begin
Log('Deleting Azure Container: ' + CloudFile.Name, cltInfo);
Result := FService.DeleteContainer(CloudFile.Name, RespInfo);
if not Result then
Log(RespInfo.StatusMessage, cltError);
end;
end
//delete a folder
else if CloudFile.FileType = cftFolder then
begin
Params := TStringList.Create;
Params.Values['prefix'] := CloudFile.Path + CloudFile.Name;
try
Blobs := FService.ListBlobs(CloudFile.Container, Params, RespInfo);
if Blobs <> nil then
begin
Log('Deleting Azure Virtual Folder: ' + CloudFile.Path + CloudFile.Name, cltInfo);
Result := True;
for Blob In Blobs do
begin
try
if not FService.DeleteBlob(CloudFile.Container, Blob.Name, False, EmptyStr, RespInfo) then
begin
Log(RespInfo.StatusMessage, cltError);
Result := False;
end;
finally
Blob.Free;
end;
end;
end;
finally
FreeAndNil(Params);
FreeAndNil(Blobs);
end;
end
//delete a file
else
begin
FilePath := CloudFile.Path + CloudFile.Name;
ContainerName := GetContainerName(CloudFile.Container);
Log('Deleting Azure Object: ' + FilePath, cltInfo);
Result := FService.DeleteBlob(ContainerName, FilePath, false, '', RespInfo);
if not Result then
Log(RespInfo.StatusMessage, cltError);
end;
finally
FreeAndNil(RespInfo);
end;
end;
end;
destructor TAzurePopulator.Destroy;
begin
FreeAndNil(FService);
inherited;
end;
function TAzurePopulator.DownloadFile(CloudFile: TCloudFile; Directory: String): Boolean;
var
FileName: String;
LocalFilePath: String;
ContainerName: String;
LFiles: TObjectDictionary<String,TCloudFile>;
AFile: TCloudFile;
VirtualPath, TruncPath: String;
begin
Result := false;
LFiles := nil;
if FService <> nil then
begin
Directory := AnsiReplaceStr(Directory, '/', '\');
if not ForceDirectories(Directory) then
begin
Log('Failed to make directories: ' + IntToStr(GetLastError) + ' (' + Directory + ')', cltError);
Exit(False);
end;
Directory := AnsiReplaceStr(Directory, '\', '/');
if not AnsiEndsStr('/', Directory) then
Directory := Directory + '/';
//Handle downloading a container
if CloudFile.FileType = cftContainer then
begin
GetFiles(CloudFile.Name, EmptyStr, LFiles, True);
try
for AFile In LFiles.Values do
DownloadFile(AFile, Directory + CloudFile.Name + '/' + AFile.Path);
finally
FreeAndNil(LFiles);
end;
end
//Handle downloading a virtual folder structure
else if CloudFile.FileType = cftFolder then
begin
VirtualPath := CloudFile.Path + CloudFile.Name;
GetFiles(CloudFile.Container, VirtualPath, LFiles, True);
try
for AFile In LFiles.Values do
begin
//Make the full path based on the parent folder's name, and the relative path
//from the parent folder to this folder. The files retuned are flattened,
//so a file may be nested several virtual folders deep.
TruncPath := Copy(AFile.Path, Length(VirtualPath) + 1);
TruncPath := Directory + VirtualPath + TruncPath;
DownloadFile(AFile, TruncPath);
end;
finally
FreeAndNil(LFiles);
end;
end
//Handle downloading a file
else if CloudFile.FileType = cftFile then
begin
FileName := Cloudfile.Path + CloudFile.Name;
LocalFilePath := Directory + CloudFile.Name;
ContainerName := GetContainerName(CloudFile.Container);
Log('Downloading Azure From: ' + FileName + ', to: ' + LocalFilePath, cltInfo);
TAzureTransferJob.Create(FService, tjtDOWNLOAD, FileName, ContainerName, LocalFilePath, Self);
end;
end;
end;
function TAzurePopulator.GetCloudType: TCloudConnectionType;
begin
Result := cctAzure;
end;
function TAzurePopulator.GetContainer: String;
begin
Result := FContainer;
end;
function TAzurePopulator.GetContainerName(SpecifiedContainer: String): String;
begin
if SpecifiedContainer = EmptyStr then
Result := '$root'
else
Result := SpecifiedContainer;
end;
function TAzurePopulator.GetPath: String;
begin
Result := FPath;
end;
function TAzurePopulator.IsInRootContainer: Boolean;
begin
Result := (FContainer = EmptyStr) or (FContainer = '$root');
end;
procedure TAzurePopulator.LoadRootFiles(var Files: TObjectDictionary<String, TCloudFile>);
begin
FPath := EmptyStr;
FContainer := EmptyStr;
GetCurrentFiles(Files);
end;
procedure TAzurePopulator.SetPath(Container, Path: String;
var Files: TObjectDictionary<String, TCloudFile>);
begin
FContainer := Container;
FPath := Path;
if (FPath <> EmptyStr) and (not AnsiEndsStr('/', FPath)) then
FPath := FPath + '/';
if AnsiStartsStr('/', FPath) then
FPath := Copy(FPath, 2);
GetCurrentFiles(Files);
end;
function TAzurePopulator.UploadFile(LocalFile: TLocalFile; BasePath: String): Boolean;
var
ObjName: String;
FileName: String;
ContainerName: String;
LocalFiles: TList<TLocalFile>;
InnerLF: TLocalFile;
begin
Result := False;
if (LocalFile.Name <> EmptyStr) then
begin
if LocalFile.FileType = lftDirectory then
begin
if not IsInRootContainer then
begin
LocalFiles := TList<TLocalFile>.Create;
GetNestedLocalFiles(LocalFile, LocalFiles, True);
try
for InnerLF In LocalFiles do
begin
BasePath := AnsiReplaceStr(Copy(InnerLF.Path, Length(LocalFile.Path) + 1), '\', '/');
Result := UploadFile(InnerLF, BasePath) and Result;
end;
finally
FreeAndNil(LocalFiles);
end;
end
else
Result := False;
end
else if LocalFile.FileType = lftFile then
begin
FileName := LocalFile.Path + LocalFile.Name;
//upload a file
if FileExists(FileName) then
begin
ObjName := FPath + BasePath + LocalFile.Name;
ContainerName := GetContainerName(FContainer);
Log('Uploading File to Azure. From: ' + FileName + ', To: ' + ObjName, cltInfo);
TAzureTransferJob.Create(FService, tjtUPLOAD, ObjName, ContainerName, FileName, Self);
end;
end;
end;
end;
procedure TAzurePopulator.GetCurrentFiles(var Files: TObjectDictionary<String, TCloudFile>);
begin
GetFiles(FContainer, FPath, Files);
end;
procedure TAzurePopulator.GetFiles(Container, Path: String;
var Files: TObjectDictionary<String,TCloudFile>; Flatten: Boolean);
var
Aux: String;
Containers: TList<TAzureContainer>;
LContainer: TAzureContainer;
HasRootContainer: Boolean;
Blobs: TList<TAzureBlob>;
Blob: TAzureBlob;
RespInfo: TCloudResponseInfo;
Params: TStrings;
Count, Index: Integer;
TrimmedName, TrimmedPath, UniqueId: String;
begin
HasRootContainer := False;
Blobs := nil;
if not Assigned(Files) then
Files := TObjectDictionary<String,TCloudFile>.Create
else
Files.Clear;
RespInfo := TCloudResponseInfo.Create;
try
//load either buckets, or files of a bucket. Container = Bucket
if (Container = EmptyStr) then
begin
Containers := FService.ListContainers(nil, RespInfo);
if Assigned(Containers) then
begin
try
for LContainer In Containers do
begin
if not LContainer.IsRoot then
begin
Files.Add(LContainer.Name, TCloudFile.Create(LContainer.Name, EmptyStr, EmptyStr, cftContainer));
end
else
HasRootContainer := True;
//free the container. not needed anymore.
LContainer.Free;
end;
finally
FreeAndNil(Containers);
end;
end
else
Log(RespInfo.StatusMessage, cltError);
if HasRootContainer then
begin
Blobs := FService.ListBlobs('$root', nil, RespInfo);
if Assigned(Blobs) then
begin
try
for Blob In Blobs do
begin
try
if Flatten then
UniqueId := '$root/' + Blob.Name
else
UniqueId := Blob.Name;
//NOTE: Blobs in the $root container can't have a virtual folder structure
Files.Add(UniqueId, TCloudFile.Create(Blob.Name, EmptyStr, EmptyStr, cftFile));
finally
Blob.Free;
end;
end;
finally
FreeAndNil(Blobs);
end;
end
else
Log(RespInfo.StatusMessage, cltError);
end;
end
//load files from a container
else
begin
Params := TStringList.Create;
if not Flatten then
Params.Values['delimiter'] := '/';
Params.Values['prefix'] := Path;
try
Blobs := FService.ListBlobs(Container, Params, RespInfo);
if Blobs <> nil then
begin
for Blob In Blobs do
begin
try
Aux := Blob.Name;
if not Flatten then
begin
TrimmedPath := Path;
Count := Length(Path);
if AnsiEndsStr('/', Aux) then
TrimmedName := Copy(Aux, Count + 1, (Length(Aux) - Count) - 1)
else
TrimmedName := Copy(Aux, Count + 1);
end
else
begin
TrimmedPath := EmptyStr;
TrimmedName := Blob.Name;
if AnsiEndsText('/', TrimmedName) then
TrimmedName := Copy(TrimmedName, 1, Length(TrimmedName));
Index := LastDelimiter('/', TrimmedName);
if (Index > 0) and (Index < Length(TrimmedName)) then
begin
TrimmedPath := Copy(TrimmedName, 1, Index);
TrimmedName := Copy(TrimmedName, Index + 1);
end
end;
//If flattening, then you need to make sure the dictionary Keys are all unique
//add container to path because you can have a blob in the root container
//and a blob directly under some container, where the blob has the same name as the one
//in the root container. (This would cause a name conflict.)
if Flatten then
UniqueId := Container + '/' + TrimmedPath + TrimmedName
else
UniqueId := TrimmedName;
if Blob.BlobType = abtPrefix then
Files.Add(UniqueId, TCloudFile.Create(TrimmedName, Container, TrimmedPath, cftFolder))
else
Files.Add(UniqueId, TCloudFile.Create(TrimmedName, Container, TrimmedPath, cftFile));
finally
Blob.Free;
end;
end;
end
else
Log(RespInfo.StatusMessage, cltError);
finally
FreeAndNil(Params);
FreeAndNil(Blobs);
end;
end;
finally
FreeAndNil(RespInfo);
end;
end;
{ TCloudTransferManager }
constructor TCloudTransferManager.Create;
begin
FJobs := TList<TCloudTransferJob>.Create;
FListeners := TList<TTransferJobUpdateListener>.Create;
end;
destructor TCloudTransferManager.Destroy;
begin
FreeAndNil(FListeners);
ForEachJob(procedure(const Job: TCloudTransferJob)
begin
Job.Terminate;
end);
FreeAndNil(FJobs);
inherited;
end;
procedure TCloudTransferManager.ForEachJob(AVisitor: TTransferJobVisitor);
var
Job: TCloudTransferJob;
begin
if (FJobs = nil) then
Exit;
TMonitor.Enter(FJobs);
try
for Job In FJobs do
AVisitor(Job);
finally
TMonitor.Exit(FJobs);
end;
end;
function TCloudTransferManager.GetSize: Integer;
begin
Result := FJobs.Count;
end;
procedure TCloudTransferManager.NotifyListeners(Job: TCloudTransferJob);
var
Event: TTransferJobUpdateListener;
begin
if (FListeners = nil) or (Job = nil) then
Exit;
TMonitor.Enter(FListeners);
try
if Assigned(FListeners) then
begin
for Event in FListeners do
begin
try
Event(Job);
except
end;
end;
end;
finally
TMonitor.Exit(FListeners);
end;
end;
procedure TCloudTransferManager.RemoveJob(Job: TCloudTransferJob);
begin
if (Job <> nil) and FJobs.Contains(Job) then
begin
TMonitor.Enter(FJobs);
try
FJobs.Remove(Job);
finally
TMonitor.Exit(FJobs);
end;
NotifyListeners(Job);
end;
end;
function TCloudTransferManager.AddJob(Job: TCloudTransferJob): boolean;
begin
Result := true;
//TODO:: validate that the job won't cause conflicts, like uploading a file
//which is currently being downloaded
if (Job <> nil) and (not FJobs.Contains(Job)) then
begin
TMonitor.Enter(FJobs);
try
FJobs.Add(Job);
finally
TMonitor.Exit(FJobs);
end;
NotifyListeners(Job);
end;
end;
procedure TCloudTransferManager.AddListener(Listener: TTransferJobUpdateListener);
begin
TMonitor.Enter(FListeners);
try
if not FListeners.Contains(Listener) then
FListeners.Add(Listener);
finally
TMonitor.Exit(FListeners);
end;
end;
procedure TCloudTransferManager.RemoveListener(Listener: TTransferJobUpdateListener);
begin
TMonitor.Enter(FListeners);
try
if Assigned(FListeners) then
FListeners.Remove(Listener);
finally
TMonitor.Exit(FListeners);
end;
end;
{ TAzureTransferJob }
constructor TAzureTransferJob.Create(Service: TAzureBlobService; JobType: TTransferJobType;
FileName, ContainerName, LocalFilePath: String; Populator: TCloudPopulator);
begin
inherited Create;
FService := Service;
FJobType := JobType;
FFileName := FileName;
FContainerName := ContainerName;
FLocalFilePath := LocalFilePath;
FPopulator := Populator;
FJobStatus := tjsWAITING;
//TODO:: Handle case when job fails to get added
TCloudTransferManager.Instance.AddJob(Self);
end;
destructor TAzureTransferJob.Destroy;
begin
TCloudTransferManager.Instance.RemoveJob(Self);
inherited;
end;
procedure TAzureTransferJob.Execute;
var
FS: TFileStream;
Content: TBytes;
Success: Boolean;
RespInfo: TCloudResponseInfo;
begin
inherited;
FreeOnTerminate := True;
FJobStatus := tjsRUNNING;
RespInfo := TCloudResponseInfo.Create;
Success := True;
FS := nil;
try
if JobType = tjtUPLOAD then
begin
if FileExists(LocalFilePath) then
begin
FS := TFileStream.Create(LocalFilePath, fmOpenRead);
Content := ByteContent(fs);
Success := FService.PutBlockBlob(ContainerName, FileName, Content, EmptyStr, nil, nil, RespInfo);
end;
end
else
begin
if FileExists(LocalFilePath) then
FS := TFileStream.Create(LocalFilePath, fmOpenWrite)
else
FS := TFileStream.Create(LocalFilePath, fmCreate);
Success := FService.GetBlob(ContainerName, FileName, FS, '', RespInfo);
end;
finally
if not Success then
FPopulator.Log(RespInfo.StatusMessage, cltError);
FreeAndNil(FS);
FreeAndNil(RespInfo);
FJobStatus := tjsFINISHED;
end;
end;
{ TAmazonTransferJob }
constructor TAmazonTransferJob.Create(Service: TAmazonStorageService; JobType: TTransferJobType;
FileName, ContainerName, LocalFilePath: String; Populator: TCloudPopulator);
begin
inherited Create;
FService := Service;
FJobType := JobType;
FFileName := FileName;
FContainerName := ContainerName;
FLocalFilePath := LocalFilePath;
FPopulator := Populator;
FJobStatus := tjsWAITING;
//TODO:: Handle case when job fails to get added
TCloudTransferManager.Instance.AddJob(Self);
end;
destructor TAmazonTransferJob.Destroy;
begin
TCloudTransferManager.Instance.RemoveJob(Self);
inherited;
end;
procedure TAmazonTransferJob.Execute;
var
FS: TFileStream;
Content: TBytes;
Success: Boolean;
RespInfo: TCloudResponseInfo;
begin
inherited;
FreeOnTerminate := True;
FJobStatus := tjsRUNNING;
RespInfo := TCloudResponseInfo.Create;
Success := True;
FS := nil;
try
if JobType = tjtUPLOAD then
begin
if FileExists(LocalFilePath) then
begin
FS := TFileStream.Create(LocalFilePath, fmOpenRead);
Content := ByteContent(fs);
Success := FService.UploadObject(ContainerName, FileName, Content, false, nil, nil, amzbaNotSpecified, RespInfo);
end;
end
else
begin
if FileExists(LocalFilePath) then
FS := TFileStream.Create(LocalFilePath, fmOpenWrite)
else
FS := TFileStream.Create(LocalFilePath, fmCreate);
Success := FService.GetObject(ContainerName, FileName, FS, RespInfo);
end;
finally
if not Success then
FPopulator.Log(RespInfo.StatusMessage, cltError);
FreeAndNil(FS);
FreeAndNil(RespInfo);
FJobStatus := tjsFINISHED;
end;
end;
initialization
TCloudTransferManager.FInstance := TCloudTransferManager.Create;
finalization
TCloudTransferManager.FInstance.Free;
TCloudTransferManager.FInstance := nil;
end.
|
unit ItemAvulso;
interface
uses
Cor,
Produto,
Contnrs;
type
TItemAvulso = class
private
FCodigo :Integer;
FCodigoNotaFiscal :Integer;
FCodigoProduto :Integer;
FPreco :Real;
FPercentualDesconto :Real;
FProduto :TProduto;
FQuantidade :Real;
procedure SetCodigo (const Value: Integer);
procedure SetProduto(const Value: TProduto);
private
function GetCodigo :Integer;
function GetProduto :TProduto;
function GetValorBruto :Real;
function GetValorDesconto :Real;
function GetValorTotal :Real;
private
procedure SetPercentualDesconto(const Value: Real);
procedure SetPreco (const Value: Real);
public
constructor Create;
constructor CriaParaRepositorio(Codigo :Integer;
CodigoNotaFiscal :Integer;
CodigoProduto :Integer;
Preco :Real;
PercentualDesconto :Real;
Quantidade :Real);
public
destructor Destroy; override;
public
property Codigo :Integer read GetCodigo write SetCodigo;
property CodigoNotaFiscal :Integer read FCodigoNotaFiscal write FCodigoNotaFiscal;
property Produto :TProduto read GetProduto write SetProduto;
property Preco :Real read FPreco write SetPreco;
property PercentualDesconto :Real read FPercentualDesconto write SetPercentualDesconto;
property Quantidade :Real read FQuantidade write FQuantidade;
property ValorBruto :Real read GetValorBruto;
property ValorDesconto :Real read GetValorDesconto;
property ValorTotal :Real read GetValorTotal;
end;
implementation
uses
SysUtils,
FabricaRepositorio,
Repositorio;
{ TItemAvulso }
constructor TItemAvulso.Create;
begin
self.FProduto := nil;
end;
constructor TItemAvulso.CriaParaRepositorio(Codigo, CodigoNotaFiscal,
CodigoProduto: Integer; Preco, PercentualDesconto, Quantidade :Real);
begin
self.FCodigo := Codigo;
self.FCodigoNotaFiscal := CodigoNotaFiscal;
self.FCodigoProduto := CodigoProduto;
self.FPreco := Preco;
self.FPercentualDesconto := PercentualDesconto;
self.FQuantidade := Quantidade;
end;
destructor TItemAvulso.Destroy;
begin
FreeAndNil(self.FProduto);
inherited;
end;
function TItemAvulso.GetCodigo: Integer;
begin
result := self.FCodigo;
end;
function TItemAvulso.GetProduto: TProduto;
var
Repositorio :TRepositorio;
begin
if not Assigned(self.FProduto) then begin
Repositorio := nil;
try
Repositorio := TFabricaRepositorio.GetRepositorio(TProduto.ClassName);
self.FProduto := (Repositorio.Get(self.FCodigoProduto) as TProduto);
finally
FreeAndNil(Repositorio);
end;
end;
result := self.FProduto;
end;
function TItemAvulso.GetValorBruto: Real;
begin
result := (self.FPreco * self.Quantidade);
end;
function TItemAvulso.GetValorDesconto: Real;
begin
result := ((self.ValorBruto * self.PercentualDesconto) / 100);
end;
function TItemAvulso.GetValorTotal: Real;
begin
result := (self.ValorBruto - self.ValorDesconto);
end;
procedure TItemAvulso.SetCodigo(const Value: Integer);
begin
self.FCodigo := Value;
end;
procedure TItemAvulso.SetPercentualDesconto(const Value: Real);
begin
FPercentualDesconto := Value;
end;
procedure TItemAvulso.SetPreco(const Value: Real);
begin
FPreco := Value;
end;
procedure TItemAvulso.SetProduto(const Value: TProduto);
begin
FreeAndNil(self.FProduto);
if Assigned(Value) then
self.FCodigoProduto := Value.Codigo;
end;
end.
|
unit stanicniHlaseniHelper;
{
Tato unit implementuje pomocne funkce pro prehravani stanicho hlaseni.
}
interface
uses Souprava, TOblRizeni, Generics.Collections, TBlokUsek, TBlokTrat;
type
// jaka stanicni hlaseni prehrat
TSHToPlay = record
trat:TBlkTrat;
stanicniKolej:TBlkUsek;
end;
{ Mozne stavy:
- trat = nil, stanicniKolej = nil: neprehravat hlaseni
- trat = nil, stanicniKolej != nil: prehrat prijezd na kolej
- trat != nil, stanicniKolej = nil: prehrat prujezd
- trat != nil, stanicniKolej != nil: prehrat prujezd po koleji
}
function CanPlayPrijezdSH(spr:TSouprava; OblR:TOR):TSHToPlay;
// vraci jaka prijezdova stanicni hlaseni lze prehrat
// tato funkce predpoklada, ze jsou spravne vypocitany predpovidani souprav
// funkce overuje jen pritomnost na usecich, overeni dostupnosti fyzickeho
// modulu SH ve stanici je potreba provest zvlast
implementation
uses TBloky, TBlok, TBlokTratUsek;
////////////////////////////////////////////////////////////////////////////////
function CanPlayPrijezdSH(spr:TSouprava; OblR:TOR):TSHToPlay;
var blksWithSpr:TList<TBlkUsek>;
i, j:Integer;
blk:TBlk;
blkUsek:TBlkUsek;
inTrat:TBlkTrat;
inOR:boolean;
begin
blksWithSpr := TList<TBlkUsek>.Create();
Result.trat := nil;
Result.stanicniKolej := nil;
try
inTrat := nil;
// ziskame seznam bloku na kterych je souprava predpovidana v dane stanici
// ziskame trat, ve ktere se aktualne souprava nachazi
for i := 0 to Blky.Cnt-1 do
begin
Blky.GetBlkByIndex(i, blk);
inOR := false;
for j := 0 to Blk.OblsRizeni.Cnt-1 do
begin
if (Blk.OblsRizeni.ORs[j] = OblR) then
begin
inOR := true;
break;
end;
end;
// trate z aktualni stanice kontrolujeme cele
if ((not inOR) and (blk.typ = _BLK_TU) and (TBlkUsek(blk).SprPredict = spr.index) and
(TBlkTU(blk).Trat <> nil) and
(((TBlkTrat(TBlkTU(blk).Trat)).uvazkaA.OblsRizeni.ORs[0] = OblR) or
((TBlkTrat(TBlkTU(blk).Trat)).uvazkaB.OblsRizeni.ORs[0] = OblR))) then
blksWithSpr.Add(TBlkUsek(blk));
if (not inOR) then continue;
if (((blk.typ = _BLK_USEK) or (blk.typ = _BLK_TU)) and
(TBlkUsek(blk).SprPredict = spr.index)) then
blksWithSpr.Add(TBlkUsek(blk));
if ((blk.typ = _BLK_TU) and (TBlkUsek(blk).Souprava = spr.index)) then
if (TBlkTU(blk).Trat <> nil) then
inTrat := TBlkTrat(TBlkTU(blk).Trat);
end;
// zjistime, na ktere stanicni a na ktere tratove koleje je souprava predpovidana
Result.trat := nil;
for blkUsek in blksWithSpr do
begin
// souprava je predpovidana do jine trati nez ve ktere je -> prujezd
if ((blkUsek.typ = _BLK_TU) and (TBlkTU(blkUsek).Trat <> inTrat)
and (TBlkTU(blkUsek).Trat <> nil)) then
Result.trat := TBlkTrat(TBlkTU(blkUsek).Trat);
// souprava je predpovidana na stanicni kolej -> vybrat tu s nejkratsim nazvem
if ((blkUsek.Stav.cislo_koleje <> '') and ((Result.stanicniKolej = nil) or
(Length(blkUsek.Stav.cislo_koleje) < Length(Result.stanicniKolej.Stav.cislo_koleje)))) then
Result.stanicniKolej := blkUsek;
end;
// odjezd z koleje neni povazovan za prujezd
if ((inTrat = nil) and (Result.trat <> nil) and (Result.stanicniKolej = nil)) then
Result.trat := nil;
finally
blksWithSpr.Free();
end;
end;
////////////////////////////////////////////////////////////////////////////////
end.
|
unit zAutoruns;
// Класс для работы с автозапуском
interface
uses Windows, Classes, SysUtils, registry, ShlObj, ComObj, ActiveX, INIFiles, zLogSystem;
const
atRegKey = 1; // Ключ реестра
atRegKeyMulty = 11; // Ключ реестра, содержащий несколько значений
atLnkFile = 2; // LNK/PIF файл
atFile = 3; // Файл (например, физическое размещение программы в папаке автозапуска)
atINIFile = 4; // Ключ INI файла
type
TAutorunItemCfgParams = record
EnableMode : Shortint; // Режим перехода в статус "разрешен" (0-не поддерживается)
DisableMode : Shortint; // Режим перехода в статус "запрещен" (0-не поддерживается)
DeleteMode : Shortint; // Режим удаления (0-не поддерживается)
RestoreMode : Shortint; // Режим восстановления (0-не поддерживается)
DefVal : string; // Параметры для восстановления
end;
// Описание элемента автозапуска
TAutorunItem = record
BinFile : string; // Полный путь к файлу
CheckResult : integer; // Результат проверки
Enabled : boolean; // Статус (true - это разрешенный элемент, false - заблокированный AVZ)
AutorunType : integer; // Код типа автозапуска
X1, X2, X3, X4 : string; // Параметры, которые описывают источик (их назначение зависит от кода)
GroupCode : integer; // Код круппы
CfgParams : TAutorunItemCfgParams; // Параметры конфигурации
end;
TAutorunEvent = function (AutorunItem : TAutorunItem) : boolean of object;
// Массив элементов автозапуска
TAutorunItems = array of TAutorunItem;
// Менеджер автозапуска
TAutorunManager = class
private
// Сканирование ключа реестра (формат параметра=исп_файл)
function ScanRegKey_(ARootKey: HKEY; AKeyName: String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
// Сканирование параметра реестра
function ScanRegValue_(ARootKey: HKEY; AKeyName, AParamName : String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
function ScanRegMultyValue_(ARootKey: HKEY; AKeyName, AParamName : String; ID : integer; AConfigScript : string): boolean;
// Сканирование ключа реестра (формат параметра=исп_файл)
function ScanRegKey(ARootKey: HKEY; AKeyName: String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
// Сканирование параметра реестра
function ScanRegValue(ARootKey: HKEY; AKeyName, AParamName : String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
function ScanRegMultyValue(ARootKey: HKEY; AKeyName, AParamName : String; ID : integer; AConfigScript : string): boolean;
// Сканирование параметра INI Файла
function ScanINIParam(AINIFileName, AKeyName, AParamName : String; ID : integer; AConfigScript : string): boolean;
function ScanDir(ADirName : string; ID : integer; AConfigScript : string) : boolean;
function ScanFile(AFileName : string; ID : integer; AConfigScript : string) : boolean;
Function ScanAutorunRegKeys(ARootKey : HKEY; APrefix : string; ID : integer) : boolean;
Function ScanAutorunINIKeys(ID : integer) : boolean;
// Сканирование системных ключей автозапуска
Function ScanAutorunSysRegKeys(ARootKey : HKEY; APrefix : string; ID : integer) : boolean;
// Сканирование ключей Winlogon
Function ScanWinlogonSysRegKeys(ARootKey : HKEY; BaseKey : string; ID : integer) : boolean;
// Добавление элемента
procedure AddItem(Item : TAutorunItem; ID : integer; AConfigScript : string);
function GetRecCount: integer;
function ScanMPRRegKeys(ID: integer): boolean;
function ScanWinlogonGPERegKeys(ARootKey: HKEY; BaseKey: string;
ID: integer): boolean;
function ScanUtilityManagerRegKeys(ARootKey: HKEY; BaseKey: string;
ID: integer): boolean;
public
AutorunItems : TAutorunItems;
constructor Create;
destructor Destroy; override;
// Обновление списка
function Refresh : boolean;
// Удаление из автозапуска
function DeleteFromAutorun(AFileName : string) : boolean;
// Проверка, существует ли элемент
function AutorunItemExists(AFileName : string) : boolean;
// Получение статуса элемента
function GetItemEnabledStatus(AutorunItem : TAutorunItem) : integer;
// **** Обработчики ****
// Удаление
function OnItemDelete(var AutorunItem : TAutorunItem) : boolean;
// Запрет
function OnItemDisable(var AutorunItem : TAutorunItem) : boolean;
// Разрешение
function OnItemEnable(var AutorunItem : TAutorunItem) : boolean;
// Восстановление
function OnItemRepair(var AutorunItem : TAutorunItem) : boolean;
// Запрос кол-ва записей
property RecCount : integer read GetRecCount;
end;
implementation
uses zutil, zSharedFunctions, zAVZKernel;
{ TAutorunManager }
procedure TAutorunManager.AddItem(Item: TAutorunItem; ID : integer; AConfigScript : string);
var
Lines : TStrings;
begin
try
Lines := TStringList.Create;
AConfigScript := AConfigScript + '|';
while pos('|', AConfigScript) > 0 do begin
Lines.Add(copy(AConfigScript, 1, pos('|', AConfigScript)-1));
Delete(AConfigScript, 1, pos('|', AConfigScript));
end;
Item.GroupCode := ID;
Item.CfgParams.EnableMode := StrToIntDef(Lines.Values['Enable'], 0);
Item.CfgParams.DisableMode := StrToIntDef(Lines.Values['Disable'], 0);
Item.CfgParams.DeleteMode := StrToIntDef(Lines.Values['Delete'], 0);
Item.CfgParams.RestoreMode := StrToIntDef(Lines.Values['Restore'], 0);
Item.CfgParams.DefVal := Lines.Values['DefVal'];
Lines.Free;
SetLength(AutorunItems, Length(AutorunItems)+1);
AutorunItems[Length(AutorunItems)-1] := Item;
except
on E : Exception do
AddToDebugLog('$AVZ0648 ['+Item.BinFile+']: '+e.Message);
end;
end;
constructor TAutorunManager.Create;
begin
AutorunItems := nil;
end;
function TAutorunManager.GetRecCount: integer;
begin
Result := length(AutorunItems);
end;
function TAutorunManager.OnItemDelete(
var AutorunItem: TAutorunItem): boolean;
var
Reg : TRegistry;
INI : TINIFile;
S : string;
begin
Result := false;
// Режим 1 - параметр в реестре
if AutorunItem.CfgParams.DeleteMode = 1 then begin
Reg := TRegistry.Create;
Reg.RootKey := StrToRootKey(AutorunItem.X1);
if Reg.OpenKey(AutorunItem.X2, true) then begin
try Reg.DeleteValue(AutorunItem.X3); except exit; end;
Reg.CloseKey;
Result := true;
end;
Reg.Free;
exit;
end;
// Режим 2 - файл
if AutorunItem.CfgParams.DeleteMode = 2 then begin
Result := AVZDeleteFile(AutorunItem.X2);
end;
// Режим 3 - секция INI файла
if AutorunItem.CfgParams.DeleteMode = 3 then begin
INI := TIniFile.Create(AutorunItem.X1);
INI.DeleteKey(AutorunItem.X2, AutorunItem.X3);
Result := true;
INI.Free;
exit;
end;
// Режим 11 - параметр в реестре, но значение X4 удаляется из содержимого параметра X3
if AutorunItem.CfgParams.DeleteMode = atRegKeyMulty then begin
Reg := TRegistry.Create;
Reg.RootKey := StrToRootKey(AutorunItem.X1);
if Reg.OpenKey(AutorunItem.X2, true) then begin
try
S := Reg.ReadString(AutorunItem.X3);
if Pos(AutorunItem.X4, S) > 0 then
Delete(S, Pos(AutorunItem.X4, S), Length(AutorunItem.X4)+1);
Reg.WriteString(AutorunItem.X3, Trim(S));
except exit; end;
Reg.CloseKey;
Result := true;
end;
Reg.Free;
exit;
end;
end;
function TAutorunManager.OnItemDisable(
var AutorunItem: TAutorunItem): boolean;
var
TekStatus : integer;
Reg : TRegistry;
INI : TIniFile;
S : string;
begin
Result := false;
TekStatus := GetItemEnabledStatus(AutorunItem);
if TekStatus <> 1 then exit;
// Режим 1 - параметр в реестре
if AutorunItem.CfgParams.EnableMode = 1 then begin
Reg := TRegistry.Create;
Reg.RootKey := StrToRootKey(AutorunItem.X1);
if Reg.OpenKey(AutorunItem.X2+'-', true) then begin
try Reg.WriteString(AutorunItem.X3, AutorunItem.X4); except exit; end;
Reg.CloseKey;
if Reg.OpenKey(AutorunItem.X2, false) then begin
try Reg.DeleteValue(AutorunItem.X3); except end;
Reg.CloseKey;
end;
AutorunItem.X2 := AutorunItem.X2+'-';
Result := true;
end;
Reg.Free;
exit;
end;
// Режим 2 - файл
if AutorunItem.CfgParams.EnableMode = 2 then begin
S := NormalNameDir(ExtractFilePath(AutorunItem.X2))+'-';
S := S + '\' + ExtractFileName(AutorunItem.X2);
zForceDirectories(ExtractFilePath(S));
MoveFile(PChar(AutorunItem.X2), PChar(S));
Result := FileExists(S);
if Result then
AutorunItem.X2 := S;
end;
// Режим 4 - секция INI файла
if AutorunItem.CfgParams.EnableMode = 3 then begin
INI := TIniFile.Create(AutorunItem.X1);
INI.WriteString(AutorunItem.X2+'-',
AutorunItem.X3, AutorunItem.X4);
INI.DeleteKey(AutorunItem.X2, AutorunItem.X3);
AutorunItem.X2 := AutorunItem.X2+'-';
Result := true;
INI.Free;
exit;
end;
end;
function TAutorunManager.Refresh: boolean;
var
Path : string;
Tmp : TAutoRunItem;
begin
AutorunItems := nil;
// Ключи автозапуска в реестре
ScanAutorunRegKeys(HKEY_LOCAL_MACHINE, '', 010201);
ScanAutorunRegKeys(HKEY_CURRENT_USER, '', 010201);
ScanAutorunRegKeys(HKEY_USERS, '.DEFAULT\', 010201);
ScanAutorunSysRegKeys(HKEY_LOCAL_MACHINE, '', 010202);
ScanRegMultyValue(HKEY_LOCAL_MACHINE, 'SYSTEM\CurrentControlSet\Control\SecurityProviders', 'SecurityProviders', 050000, 'Delete=11');
// Сканирование Winlogon
ScanWinlogonSysRegKeys(HKEY_LOCAL_MACHINE, 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Notify', 020101);
ScanWinlogonGPERegKeys(HKEY_LOCAL_MACHINE, 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\GPExtensions', 020201);
ScanUtilityManagerRegKeys(HKEY_LOCAL_MACHINE, 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Accessibility\Utility Manager', 040001);
ScanMPRRegKeys(030101);
ScanAutorunSysRegKeys(HKEY_CURRENT_USER, '', 010202);
ScanAutorunSysRegKeys(HKEY_USERS, '.DEFAULT\', 010202);
Path := NormalDir(RegKeyReadString(HKEY_LOCAL_MACHINE, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders', 'Common Startup'));
if Length(Path) > 3 then begin
ScanDir(Path, 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
ScanDir(NormalDir(NormalNameDir(Path)+'-'), 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
end;
// SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
Path := NormalDir(RegKeyReadString(HKEY_LOCAL_MACHINE, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders', 'Startup'));
if Length(Path) > 3 then begin
ScanDir(Path, 010102,'GetStatus=2|Enable=2|Disable=2|Delete=2');
ScanDir(NormalDir(NormalNameDir(Path)+'-'), 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
end;
// Сканирование папки Startup
Path := NormalDir(RegKeyReadString(HKEY_CURRENT_USER, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders', 'Startup'));
if Length(Path) > 3 then begin
ScanDir(Path, 010103,'GetStatus=2|Enable=2|Disable=2|Delete=2');
ScanDir(NormalDir(NormalNameDir(Path)+'-'), 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
end;
// Сканирование папки Startup Win98
Path := NormalDir(GetWindowsDirectoryPath + 'start menu\programs\startup');
if Length(Path) > 3 then begin
ScanDir(Path, 010103,'GetStatus=2|Enable=2|Disable=2|Delete=2');
ScanDir(NormalDir(NormalNameDir(Path)+'-'), 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
end;
// Сканирование папки Startup Win98
Path := NormalDir(GetWindowsDirectoryPath + 'All Users\Start Menu\Programs\StartUp');
if Length(Path) > 3 then begin
ScanDir(Path, 010103,'GetStatus=2|Enable=2|Disable=2|Delete=2');
ScanDir(NormalDir(NormalNameDir(Path)+'-'), 010101,'GetStatus=2|Enable=2|Disable=2|Delete=2');
end;
if FileExists(GetWindowsDirectoryPath + 'winstart.bat') then begin
Tmp.BinFile := GetWindowsDirectoryPath + 'winstart.bat';
Tmp.Enabled := true;
Tmp.AutorunType := atFile;
Tmp.X1 := GetWindowsDirectoryPath;
Tmp.X2 := GetWindowsDirectoryPath + 'winstart.bat';
AddItem(Tmp, 010103, 'GetStatus=2|Delete=2');
end;
// Сканирование INI файлов
ScanAutorunINIKeys(010209);
end;
function TAutorunManager.ScanAutorunRegKeys(ARootKey: HKEY; APrefix : string; ID : integer): boolean;
var
BaseScript1 : string;
begin
BaseScript1 := 'GetStatus=1|Enable=1|Disable=1|Delete=1';
// Стандартные ключи автозапуска
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Run', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\RunOnce', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\RunOnce\Setup', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\RunOnceEx', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\RunServices', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\RunServicesOnce', ID, BaseScript1);
// Ключи автозапуска NT
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Run', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\RunOnce', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\RunOnce\Setup', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\RunOnceEx', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\RunServices', ID, BaseScript1);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\RunServicesOnce', ID, BaseScript1);
Result := true;
end;
function TAutorunManager.ScanAutorunSysRegKeys(ARootKey: HKEY;
APrefix: string; ID: integer): boolean;
var
S : string;
begin
S := 'GetStatus=1|Enable=1|Disable=1|Delete=1';
// Ключи Winlogon
ScanRegMultyValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'Userinit', ID, 'Restore=1|DefVal='+GetSystemDirectoryPath+'userinit.exe,');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'Taskman', ID, 'Restore=1|DefVal=TASKMAN.EXE');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'UIHost', ID, 'Restore=1|DefVal=logonui.exe');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'GinaDLL', ID, 'Restore=1|DefVal=MSGina.dll');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'Shell', ID, 'Restore=1|DefVal=Explorer.exe');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Winlogon', 'VmApplet', ID, 'Restore=1|DefVal=rundll32 shell32,Control_RunDLL "sysdm.cpl"');
ScanRegValue(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon', 'AppSetup', 010202, S);
ScanRegValue(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon', 'TaskMan', 010202, S);
ScanRegValue(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon', 'System', 010202, S);
ScanRegValue(ARootKey, APrefix+'Control Panel\Desktop', 'scrnsave.exe', ID, S);
ScanRegValue(ARootKey, APrefix+'System\CurrentControlSet\Control\BootVerificationProgram','ImageName', ID, S);
ScanRegValue(ARootKey, APrefix+'System\CurrentControlSet\Control\Lsa\AccessProviders\Windows NT Access Provider','ProviderPath', ID, 'Restore=1|DefVal=%SystemRoot%\system32\ntmarta.dll');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Command Processor','AutoRun', ID, S);
// Ключи SharedTaskScheduler
ScanRegKey(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\SharedTaskScheduler', 010205, S, 2);
// Ключи ShellExecuteHooks
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Explorer\ShellExecuteHooks', 010206, S, 2);
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Policies\System','Shell', ID, '');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Command Processor\','Autorun', ID, S);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\ShellServiceObjectDelayLoad', 010203, S);
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Windows','Run', ID, '');
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows NT\CurrentVersion\Windows','Load', ID, '');
ScanRegValue(ARootKey, APrefix+'Software\Policies\Microsoft\Windows\System','Scripts', ID, S);
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Policies\Explorer','Run', ID, S);
ScanRegValue(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run','system', ID, S);
ScanRegKey(ARootKey, APrefix+'Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run',ID, S);
ScanRegValue(ARootKey, APrefix+'System\CurrentControlSet\Control\Session Manager','BootExecute', ID, 'Restore=1|DefVal=autocheck autochk *');
// Terminal Server
ScanRegKey(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Windows\CurrentVersion\Runonce', 010204, S);
ScanRegKey(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Windows\CurrentVersion\RunonceEx', 010204, S);
ScanRegKey(ARootKey, APrefix+'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Windows\CurrentVersion\Run', 010204, S);
ScanRegValue(ARootKey, APrefix+'System\CurrentControlSet\Control\Terminal Server\Wds\rdpwd','StartupPrograms', 010204, S);
// AppInit_DLLs
ScanRegMultyValue(ARootKey, 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows', 'AppInit_DLLs', 010207, 'Delete=11');
ScanRegValue(ARootKey, 'Control Panel\IOProcs', 'MVB', ID, 'Restore=1|DefVal=mvfs32.dll');
// Ключи для кнопок "Мой компьютер/Сервис"
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\MyComputer\BackupPath', '', ID, 'Restore=1|DefVal=%SystemRoot%\system32\ntbackup.exe');
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\MyComputer\cleanuppath', '', ID, 'Restore=1|DefVal=%SystemRoot%\system32\cleanmgr.exe /D %c');
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\MyComputer\DefragPath', '', ID, 'Restore=1|DefVal=%systemroot%\system32\dfrg.msc %c:');
// Отладчик
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug', 'Debugger', ID, 'Restore=1|DefVal=drwtsn32 -p %ld -e %ld -g');
// Windows Scripting Host
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows Scripting Host\Locations', 'CScript', 010208, 'Restore=1|DefVal=%SystemRoot%\System32\cscript.exe');
ScanRegValue(ARootKey, 'SOFTWARE\Microsoft\Windows Scripting Host\Locations', 'WScript', 010208, 'Restore=1|DefVal=%SystemRoot%\System32\wscript.exe');
end;
function TAutorunManager.ScanDir(ADirName: string; ID : integer; AConfigScript : string): boolean;
var
SR : TSearchRec;
Res : integer;
Tmp : TAutoRunItem;
begin
ADirName := NormalDir(ADirName);
try
Res := FindFirst(ADirName+'*.*', faAnyFile, SR);
while Res = 0 do begin
if (SR.Attr and faDirectory) = 0 then begin
if not(ScanFile(ADirName + SR.Name, ID, AConfigScript)) then begin
Tmp.BinFile := ADirName + SR.Name;
Tmp.Enabled := true;
Tmp.AutorunType := atFile;
Tmp.X1 := ADirName;
Tmp.X2 := ADirName + SR.Name;
if LowerCase(SR.Name) <> 'desktop.ini' then
AddItem(Tmp, ID, AConfigScript);
end;
end;
Res := FindNext(SR);
end;
except
on E : Exception do
AddToDebugLog('$AVZ0651+'+ADirName+': '+e.Message);
end;
end;
function TAutorunManager.ScanFile(AFileName: string; ID : integer; AConfigScript : string): boolean;
var
IObject : IUnknown;
SLink : IShellLink;
PFile : IPersistFile;
pfd : TWin32FindData;
S : string;
Tmp : TAutoRunItem;
begin
Result := false;
try
if Not(FileExists(AFileName)) then exit;
try
IObject := CreateComObject(CLSID_ShellLink);
if (IObject = nil) then exit;
SLink := IObject as IShellLink;
PFile := IObject as IPersistFile;
if (IObject = nil) or (SLink = nil) or (PFile = nil) then exit;
if PFile.Load(PWChar(WideString(AFileName)), STGM_READ) <> S_OK then exit;
SetLength(S, 255);
ZeroMemory(@S[1], length(S));
SLink.GetPath(@S[1], 255, pfd, SLGP_UNCPRIORITY);
S := Trim(S);
if S = '' then exit;
Tmp.BinFile := S;
Tmp.Enabled := true;
Tmp.AutorunType := atLnkFile;
Tmp.X1 := ExtractFilePath(AFileName);
Tmp.X2 := AFileName;
AddItem(Tmp, ID, AConfigScript);
Result := true;
except
on E : Exception do begin
Result := false;
AddToDebugLog('$AVZ0647 ['+AFileName+']: '+e.Message);
end;
end;
finally
SLink := nil;
PFile := nil;
IObject := nil;
end;
end;
function TAutorunManager.ScanRegKey_(ARootKey: HKEY; AKeyName: String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
ValNames : TStrings;
i : integer;
begin
Result := false;
try
// Создание экземпляров классов и очиска списка результатов
Reg := TRegistry.Create;
ValNames := TStringList.Create;
// Анализ заданного раздела
Reg.RootKey := ARootKey;
// Открытие указанного ключа
if Reg.OpenKey(AKeyName, false) then begin
try Reg.GetValueNames(ValNames); except end;
for i := 0 to ValNames.Count - 1 do
if Reg.GetDataType(ValNames[i]) in [rdString, rdExpandString] then begin
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := ValNames[i];
Tmp.X4 := '';
try Tmp.X4 := Reg.ReadString(ValNames[i]); except end;
Tmp.BinFile := '';
// Добавление сообразно режиму (0-значение=exe, 1-значение=CLSID, 2- имя_параметра=CLSID, 3-имя_параметра=EXE)
case AValMode of
0 : begin
Tmp.BinFile := Trim(Tmp.X4);
end;
1 : begin
Tmp.BinFile := GetBinFileByGUID(Tmp.X4);
end;
2 : begin
Tmp.BinFile := GetBinFileByGUID(Tmp.X3);
end;
4 : begin
Tmp.BinFile := Trim(Tmp.X3);
end;
end;
if (Tmp.BinFile <> '') and (pos('{', Tmp.BinFile) > 0) and (pos('}', Tmp.BinFile) > 0) then
Tmp.BinFile := GetBinFileByGUID(Tmp.BinFile);
Tmp.BinFile := NormalProgramFileName(Tmp.BinFile, '.exe');
if (Tmp.BinFile <> '') then
AddItem(Tmp, ID, AConfigScript);
end;
Reg.CloseKey;
end;
Reg.Free;
ValNames.Free;
Result := true;
except
on E : Exception do
AddToDebugLog('$AVZ0650+'+AKeyName+': '+e.Message);
end;
end;
function TAutorunManager.ScanRegValue_(ARootKey: HKEY; AKeyName,
AParamName: String; ID : integer; AConfigScript : string; AValMode : integer = 0): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
i : integer;
begin
Result := false;
try
// Создание экземпляров классов и очиска списка результатов
Reg := TRegistry.Create;
// Анализ заданного раздела
Reg.RootKey := ARootKey;
// Открытие указанного ключа в режиме "только чтение"
Reg.Access := KEY_READ;
if Reg.OpenKey(AKeyName, false) then begin
if Reg.ValueExists(AParamName) then begin
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := AParamName;
Tmp.X4 := '';
Tmp.BinFile := '';
try
case Reg.GetDataType(AParamName) of
rdString, rdExpandString : Tmp.X4 := Reg.ReadString(AParamName);
rdBinary, rdUnknown : begin
SetLength(Tmp.X4, 2048);
i := Reg.ReadBinaryData(AParamName, Tmp.X4[1], length(Tmp.X4));
SetLength(Tmp.X4, i);
end;
end;
except end;
// Добавление сообразно режиму (0-значение=exe, 1-значение=CLSID, 2- имя_параметра=CLSID, 3-имя_параметра=EXE)
case AValMode of
0 : begin
Tmp.BinFile := Trim(Tmp.X4);
end;
1 : begin
Tmp.BinFile := GetBinFileByGUID(Tmp.X4);
end;
2 : begin
Tmp.BinFile := GetBinFileByGUID(Tmp.X3);
end;
4 : begin
Tmp.BinFile := Trim(Tmp.X3);
end;
end;
Tmp.BinFile := NTFileNameToNormalName(Tmp.BinFile);
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, AConfigScript);
end;
Reg.CloseKey;
end;
Reg.Free;
except
on E : Exception do
AddToDebugLog('$AVZ0652+'+AKeyName+' '+AParamName+': '+e.Message);
end;
Result := true;
end;
function TAutorunManager.OnItemEnable(var AutorunItem: TAutorunItem): boolean;
var
TekStatus : integer;
Reg : TRegistry;
INI : TIniFile;
S : string;
begin
Result := false;
TekStatus := GetItemEnabledStatus(AutorunItem);
if TekStatus <> 0 then exit;
// Режим 1 - параметр ключа реестра
if AutorunItem.CfgParams.EnableMode = 1 then begin
Reg := TRegistry.Create;
Reg.RootKey := StrToRootKey(AutorunItem.X1);
if Reg.OpenKey(copy(AutorunItem.X2, 1, length(AutorunItem.X2)-1), true) then begin
try Reg.WriteString(AutorunItem.X3, AutorunItem.X4); except exit; end;
Reg.CloseKey;
if Reg.OpenKey(AutorunItem.X2, false) then begin
try Reg.DeleteValue(AutorunItem.X3); except end;
Reg.CloseKey;
end;
AutorunItem.X2 := copy(AutorunItem.X2, 1, length(AutorunItem.X2)-1);
Result := true;
end;
Reg.Free;
exit;
end;
// Режим 2 - файл
if AutorunItem.CfgParams.EnableMode = 2 then begin
S := NormalNameDir(ExtractFilePath(AutorunItem.X2));
S := copy(S, 1, length(S)-1);
S := S + '\' + ExtractFileName(AutorunItem.X2);
zForceDirectories(ExtractFilePath(S));
MoveFile(PChar(AutorunItem.X2), PChar(S));
Result := FileExists(S);
if Result then
AutorunItem.X2 := S;
end;
// Режим 3 - секция INI файла
if AutorunItem.CfgParams.EnableMode = 3 then begin
INI := TIniFile.Create(AutorunItem.X1);
INI.WriteString(copy(AutorunItem.X2, 1, length(AutorunItem.X2)-1),
AutorunItem.X3, AutorunItem.X4);
INI.DeleteKey(AutorunItem.X2, AutorunItem.X3);
AutorunItem.X2 := copy(AutorunItem.X2, 1, length(AutorunItem.X2)-1);
Result := true;
INI.Free;
exit;
end;
end;
function TAutorunManager.GetItemEnabledStatus(
AutorunItem: TAutorunItem): integer;
var
S : string;
begin
Result := -1;
case AutorunItem.CfgParams.EnableMode of
// Ключ реестра
1 : if copy(AutorunItem.X2, length(AutorunItem.X2), 1) = '-' then
Result := 0 else Result := 1;
// Ссылка на файл или файл
2 : begin
S := NormalNameDir(ExtractFilePath(AutorunItem.X2));
if copy(S, length(S), 1) = '-' then
Result := 0 else Result := 1;
end;
// INI файл
3 : if copy(AutorunItem.X2, length(AutorunItem.X2), 1) = '-' then
Result := 0 else Result := 1;
end;
end;
function TAutorunManager.OnItemRepair(
var AutorunItem: TAutorunItem): boolean;
var
Reg : TRegistry;
INI : TINIFile;
begin
Result := false;
Reg := TRegistry.Create;
case AutorunItem.CfgParams.RestoreMode of
1 : begin
Reg.RootKey := StrToRootKey(AutorunItem.X1);
if Reg.OpenKey(AutorunItem.X2, true) then begin
try Reg.WriteString(AutorunItem.X3, AutorunItem.CfgParams.DefVal); except exit; end;
Reg.CloseKey;
Result := true;
end;
end;
3 : begin
INI := TIniFile.Create(AutorunItem.X1);
INI.WriteString(AutorunItem.X2,
AutorunItem.X3, AutorunItem.CfgParams.DefVal);
AutorunItem.X4 := AutorunItem.CfgParams.DefVal;
Result := true;
INI.Free;
end;
end;
Reg.Free;
end;
function TAutorunManager.ScanWinlogonSysRegKeys(ARootKey: HKEY;
BaseKey: string; ID: integer): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
List : TStrings;
i : integer;
begin
Reg := TRegistry.Create;
List := TStringList.Create;
Reg.RootKey := HKEY_LOCAL_MACHINE;
if Reg.OpenKey(BaseKey, false) then begin
Reg.GetKeyNames(List);
Reg.CloseKey;
for i := 0 to List.Count - 1 do begin
if Reg.OpenKey(BaseKey + '\' + List[i], false) then begin
if Reg.ValueExists('DLLName') then begin
Tmp.BinFile := Reg.ReadString('DLLName');
Tmp.CheckResult := -1;
Tmp.Enabled := false;
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := 'DLLName';
Tmp.X4 := Tmp.BinFile;
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, 'GetStatus=1|Enable=1|Disable=1|Delete=1');
end;
Reg.CloseKey;
end;
end;
end;
Reg.Free;
List.Free;
end;
function TAutorunManager.ScanWinlogonGPERegKeys(ARootKey: HKEY;
BaseKey: string; ID: integer): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
List : TStrings;
i : integer;
begin
Reg := TRegistry.Create;
List := TStringList.Create;
Reg.RootKey := HKEY_LOCAL_MACHINE;
if Reg.OpenKey(BaseKey, false) then begin
Reg.GetKeyNames(List);
Reg.CloseKey;
for i := 0 to List.Count - 1 do begin
if Reg.OpenKey(BaseKey + '\' + List[i], false) then begin
if Reg.ValueExists('DLLName') then begin
Tmp.BinFile := NormalProgramFileName(Reg.ReadString('DLLName'), '.dll');
Tmp.CheckResult := -1;
Tmp.Enabled := false;
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := 'DLLName';
Tmp.X4 := Tmp.BinFile;
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, 'GetStatus=1|Enable=1|Disable=1|Delete=1');
end;
Reg.CloseKey;
end;
end;
end;
Reg.Free;
List.Free;
end;
function TAutorunManager.ScanUtilityManagerRegKeys(ARootKey: HKEY;
BaseKey: string; ID: integer): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
List : TStrings;
i : integer;
begin
Reg := TRegistry.Create;
List := TStringList.Create;
Reg.RootKey := HKEY_LOCAL_MACHINE;
if Reg.OpenKey(BaseKey, false) then begin
Reg.GetKeyNames(List);
Reg.CloseKey;
for i := 0 to List.Count - 1 do begin
if Reg.OpenKey(BaseKey + '\' + List[i], false) then begin
if Reg.ValueExists('Application path') then begin
Tmp.BinFile := Reg.ReadString('Application path');
Tmp.CheckResult := -1;
Tmp.Enabled := false;
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := 'Application path';
Tmp.X4 := Tmp.BinFile;
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, 'GetStatus=1|Enable=1|Disable=1|Delete=1');
end;
Reg.CloseKey;
end;
end;
end;
Reg.Free;
List.Free;
end;
function TAutorunManager.ScanMPRRegKeys(ID: integer): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
List : TStrings;
i : integer;
BaseKey : string;
begin
Reg := TRegistry.Create;
List := TStringList.Create;
BaseKey := 'System\CurrentControlSet\Control\MPRServices';
Reg.RootKey := HKEY_LOCAL_MACHINE;
if Reg.OpenKey(BaseKey, false) then begin
Reg.GetKeyNames(List);
Reg.CloseKey;
for i := 0 to List.Count - 1 do begin
if Reg.OpenKey(BaseKey + '\' + List[i], false) then begin
if Reg.ValueExists('DLLName') then begin
Tmp.BinFile := Reg.ReadString('DLLName');
Tmp.CheckResult := -1;
Tmp.Enabled := false;
Tmp.AutorunType := atRegKey;
Tmp.X1 := RootKeyToStr(HKEY_LOCAL_MACHINE);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := 'DLLName';
Tmp.X4 := Tmp.BinFile;
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, 'GetStatus=1|Enable=1|Disable=1|Delete=1');
end;
Reg.CloseKey;
end;
end;
end;
Reg.Free;
List.Free;
end;
function TAutorunManager.ScanINIParam(AINIFileName, AKeyName,
AParamName: String; ID: integer; AConfigScript: string): boolean;
var
INI : TINIFile;
Tmp : TAutoRunItem;
begin
Result := false;
try
INI := TIniFile.Create(AINIFileName);
try
if not(INI.SectionExists(AKeyName)) then exit;
if not(INI.ValueExists(AKeyName, AParamName)) then exit;
Tmp.AutorunType := atINIFile;
Tmp.X1 := AINIFileName;
Tmp.X2 := AKeyName;
Tmp.X3 := AParamName;
Tmp.X4 := INI.ReadString(AKeyName, AParamName, '');
Tmp.BinFile := Trim(Tmp.X4);
if (Tmp.BinFile <> '') then
AddItem(Tmp, ID, AConfigScript);
finally
INI.Free;
end;
except
on e:Exception do begin
AddToDebugLog('$AVZ0649+'+AINIFileName+': '+e.Message);
end;
end;
end;
function TAutorunManager.ScanAutorunINIKeys(ID: integer): boolean;
var
BaseScript1 : string;
begin
BaseScript1 := 'GetStatus=3|Enable=3|Disable=3|Delete=3';
// Сканирование INI файлов
ScanINIParam(GetWindowsDirectoryPath+'win.ini', 'windows', 'load', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'win.ini', 'windows', 'run', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'windows', 'load', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'windows', 'run', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'boot', 'shell', ID, 'Restore=1|DefVal=Explorer.exe');
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'boot', 'SCRNSAVE.EXE', ID, BaseScript1);
// Сканирование INI файлов
ScanINIParam(GetWindowsDirectoryPath+'win.ini', 'windows-', 'load', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'win.ini', 'windows-', 'run', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'windows-', 'load', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'windows-', 'run', ID, BaseScript1);
ScanINIParam(GetWindowsDirectoryPath+'system.ini', 'boot-', 'shell', ID, 'Restore=1|DefVal=Explorer.exe');
end;
function TAutorunManager.DeleteFromAutorun(AFileName: string): boolean;
var
i : integer;
S : string;
begin
Result := false;
AFileName := AnsiLowerCase(AFileName);
for i := 0 to Length(AutorunItems) - 1 do begin
S := Trim(AnsiLowerCase(AutorunItems[i].BinFile));
if pos(AFileName, S) > 0 then begin
OnItemDelete(AutorunItems[i]);
OnItemRepair(AutorunItems[i]);
AddToLog('$AVZ0422 '+AutorunItems[i].X1+','+AutorunItems[i].X2+','+AutorunItems[i].X3+','+AutorunItems[i].X4, logInfo)
end;
end;
end;
function TAutorunManager.AutorunItemExists(AFileName: string): boolean;
var
i : integer;
S : string;
begin
Result := false;
AFileName := AnsiLowerCase(AFileName);
for i := 0 to Length(AutorunItems) - 1 do begin
S := Trim(AnsiLowerCase(AutorunItems[i].BinFile));
if pos(AFileName, S) > 0 then begin
Result := true;
exit;
end;
end;
end;
destructor TAutorunManager.Destroy;
begin
AutorunItems := nil;
inherited;
end;
function TAutorunManager.ScanRegKey(ARootKey: HKEY; AKeyName: String;
ID: integer; AConfigScript: string; AValMode: integer): boolean;
begin
Result := ScanRegKey_(ARootKey, AKeyName, ID, AConfigScript, AValMode);
Result := ScanRegKey_(ARootKey, AKeyName+'-', ID, AConfigScript, AValMode);
end;
function TAutorunManager.ScanRegValue(ARootKey: HKEY; AKeyName,
AParamName: String; ID: integer; AConfigScript: string;
AValMode: integer): boolean;
begin
Result := ScanRegValue_(ARootKey, AKeyName, AParamName, ID, AConfigScript, AValMode);
Result := ScanRegValue_(ARootKey, AKeyName+'-', AParamName, ID, AConfigScript, AValMode);
end;
function TAutorunManager.ScanRegMultyValue_(ARootKey: HKEY; AKeyName,
AParamName: String; ID: integer; AConfigScript: string): boolean;
var
Tmp : TAutoRunItem;
Reg : TRegistry;
S : string;
i : integer;
begin
Result := false;
try
// Создание экземпляров классов и очиска списка результатов
Reg := TRegistry.Create;
// Анализ заданного раздела
Reg.RootKey := ARootKey;
// Открытие указанного ключа в режиме "только чтение"
Reg.Access := KEY_READ;
if Reg.OpenKey(AKeyName, false) then begin
if Reg.ValueExists(AParamName) then begin
Tmp.AutorunType := atRegKeyMulty;
Tmp.X1 := RootKeyToStr(ARootKey);
Tmp.X2 := Reg.CurrentPath;
Tmp.X3 := AParamName;
Tmp.X4 := '';
Tmp.BinFile := '';
try
case Reg.GetDataType(AParamName) of
rdString, rdExpandString : Tmp.X4 := Reg.ReadString(AParamName);
rdBinary, rdUnknown : begin
SetLength(Tmp.X4, 2048);
i := Reg.ReadBinaryData(AParamName, Tmp.X4[1], length(Tmp.X4));
SetLength(Tmp.X4, i);
end;
end;
except end;
// Добавление сообразно режиму (0-значение=exe, 1-значение=CLSID, 2- имя_параметра=CLSID, 3-имя_параметра=EXE)
S := Trim(Tmp.X4)+' ';
i := 1;
while i <= length(S) do begin
if S[i] in [' ', ','] then begin
Tmp.X4 := Trim(copy(S, 1, i-1));
Tmp.BinFile := NormalProgramFileName(Tmp.X4, '.exe');
if Tmp.BinFile <> '' then
AddItem(Tmp, ID, AConfigScript);
delete(S, 1, i);
i := 1;
end else inc(i);
end;
end;
Reg.CloseKey;
end;
Reg.Free;
except
on E : Exception do
AddToDebugLog('$AVZ0652+'+AKeyName+' '+AParamName+': '+e.Message);
end;
Result := true;
end;
function TAutorunManager.ScanRegMultyValue(ARootKey: HKEY; AKeyName,
AParamName: String; ID: integer; AConfigScript: string): boolean;
begin
Result := ScanRegMultyValue_(ARootKey, AKeyName, AParamName, ID, AConfigScript);
Result := ScanRegMultyValue_(ARootKey, AKeyName+'-', AParamName, ID, AConfigScript);
end;
end.
|
unit HlpBlake2SP;
{$I ..\Include\HashLib.inc}
interface
uses
SysUtils,
{$IFDEF HAS_DELPHI_PPL}
System.Classes,
System.Threading,
{$ENDIF HAS_DELPHI_PPL}
HlpHash,
HlpIHashResult,
HlpBlake2S,
HlpIBlake2SConfig,
HlpBlake2SConfig,
HlpIBlake2STreeConfig,
HlpBlake2STreeConfig,
HlpIHash,
HlpIHashInfo,
HlpArrayUtils,
HlpHashLibTypes;
type
TBlake2SP = class(THash, ICryptoNotBuildIn, ITransformBlock)
strict private
const
BlockSizeInBytes = Int32(64);
OutSizeInBytes = Int32(32);
ParallelismDegree = Int32(8);
var
FRootHash: IHash;
FLeafHashes: THashLibGenericArray<IHash>;
FBuffer, FKey: THashLibByteArray;
FBufferLength: UInt64;
/// <summary>
/// <br />Blake2S defaults to setting the expected output length <br />
/// from the <c>HashSize</c> in the <c>TBlake2SConfig</c> class. <br />In
/// some cases, however, we do not want this, as the output length <br />
/// of these instances is given by <c>TBlake2STreeConfig.InnerSize</c>
/// instead. <br />
/// </summary>
function Blake2SPInitLeafParam(const ABlake2SConfig: IBlake2SConfig;
const ABlake2STreeConfig: IBlake2STreeConfig): IHash;
function Blake2SPInitLeaf(AOffset: UInt64): IHash;
function Blake2SPInitRoot(): IHash;
procedure ParallelComputation(AIdx: Int32; APtrDataTwo: PByte;
ACounter: UInt64);
procedure DoParallelComputation(APtrDataTwo: PByte; ACounter: UInt64);
procedure Clear();
strict protected
function GetName: String; override;
public
constructor Create(AHashSize: Int32; const AKey: THashLibByteArray);
destructor Destroy; override;
procedure Initialize; override;
procedure TransformBytes(const AData: THashLibByteArray;
AIndex, ADataLength: Int32); override;
function TransformFinal: IHashResult; override;
function Clone(): IHash; override;
end;
implementation
{ TBlake2SP }
function TBlake2SP.Blake2SPInitLeafParam(const ABlake2SConfig: IBlake2SConfig;
const ABlake2STreeConfig: IBlake2STreeConfig): IHash;
begin
Result := TBlake2S.Create(ABlake2SConfig, ABlake2STreeConfig);
Result.Initialize;
(Result as THash).HashSize := ABlake2STreeConfig.InnerHashSize;
end;
function TBlake2SP.Blake2SPInitLeaf(AOffset: UInt64): IHash;
var
LBlake2SConfig: IBlake2SConfig;
LBlake2STreeConfig: IBlake2STreeConfig;
begin
LBlake2SConfig := TBlake2SConfig.Create(HashSize);
LBlake2SConfig.Key := FKey;
LBlake2STreeConfig := TBlake2STreeConfig.Create();
LBlake2STreeConfig.FanOut := ParallelismDegree;
LBlake2STreeConfig.MaxDepth := 2;
LBlake2STreeConfig.NodeDepth := 0;
LBlake2STreeConfig.LeafSize := 0;
LBlake2STreeConfig.NodeOffset := AOffset;
LBlake2STreeConfig.InnerHashSize := OutSizeInBytes;
if AOffset = (ParallelismDegree - 1) then
begin
LBlake2STreeConfig.IsLastNode := True;
end;
Result := Blake2SPInitLeafParam(LBlake2SConfig, LBlake2STreeConfig);
end;
function TBlake2SP.Blake2SPInitRoot(): IHash;
var
LBlake2SConfig: IBlake2SConfig;
LBlake2STreeConfig: IBlake2STreeConfig;
begin
LBlake2SConfig := TBlake2SConfig.Create(HashSize);
LBlake2SConfig.Key := FKey;
LBlake2STreeConfig := TBlake2STreeConfig.Create();
LBlake2STreeConfig.FanOut := ParallelismDegree;
LBlake2STreeConfig.MaxDepth := 2;
LBlake2STreeConfig.NodeDepth := 1;
LBlake2STreeConfig.LeafSize := 0;
LBlake2STreeConfig.NodeOffset := 0;
LBlake2STreeConfig.InnerHashSize := OutSizeInBytes;
LBlake2STreeConfig.IsLastNode := True;
Result := TBlake2S.Create(LBlake2SConfig, LBlake2STreeConfig, False);
Result.Initialize;
end;
procedure TBlake2SP.Clear;
begin
TArrayUtils.ZeroFill(FKey);
end;
function TBlake2SP.Clone(): IHash;
var
LHashInstance: TBlake2SP;
begin
LHashInstance := TBlake2SP.Create(HashSize, FKey);
if FRootHash <> Nil then
begin
LHashInstance.FRootHash := FRootHash.Clone();
end;
// TODO
// confirm that this line below does a deep copy
LHashInstance.FLeafHashes := System.Copy(FLeafHashes);
LHashInstance.FBuffer := System.Copy(FBuffer);
LHashInstance.FBufferLength := FBufferLength;
Result := LHashInstance as IHash;
Result.BufferSize := BufferSize;
end;
constructor TBlake2SP.Create(AHashSize: Int32; const AKey: THashLibByteArray);
begin
Inherited Create(AHashSize, BlockSizeInBytes);
System.SetLength(FBuffer, ParallelismDegree * BlockSizeInBytes);
System.SetLength(FLeafHashes, ParallelismDegree);
FKey := System.Copy(AKey);
end;
destructor TBlake2SP.Destroy;
begin
Clear();
inherited Destroy;
end;
function TBlake2SP.GetName: String;
begin
Result := Format('%s_%u', [Self.ClassName, Self.HashSize * 8]);
end;
procedure TBlake2SP.Initialize;
var
LIdx: Int32;
begin
FRootHash := Blake2SPInitRoot;
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
FLeafHashes[LIdx] := Blake2SPInitLeaf(LIdx);
end;
TArrayUtils.ZeroFill(FBuffer);
FBufferLength := 0;
end;
procedure TBlake2SP.ParallelComputation(AIdx: Int32; APtrDataTwo: PByte;
ACounter: UInt64);
begin
System.Inc(APtrDataTwo, AIdx * BlockSizeInBytes);
while (ACounter >= (ParallelismDegree * BlockSizeInBytes)) do
begin
FLeafHashes[AIdx].TransformUntyped(APtrDataTwo,
BlockSizeInBytes * System.SizeOf(Byte));
System.Inc(APtrDataTwo, ParallelismDegree * BlockSizeInBytes);
ACounter := ACounter - UInt64(ParallelismDegree * BlockSizeInBytes);
end;
end;
{$IFDEF HAS_DELPHI_PPL}
procedure TBlake2SP.DoParallelComputation(APtrDataTwo: PByte; ACounter: UInt64);
function CreateTask(AIdx: Int32; APtrDataTwo: PByte; ACounter: UInt64): ITask;
begin
Result := TTask.Create(
procedure()
begin
ParallelComputation(AIdx, APtrDataTwo, ACounter);
end);
end;
var
LArrayTasks: array of ITask;
LIdx: Int32;
begin
System.SetLength(LArrayTasks, ParallelismDegree);
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
LArrayTasks[LIdx] := CreateTask(LIdx, APtrDataTwo, ACounter);
LArrayTasks[LIdx].Start;
end;
TTask.WaitForAll(LArrayTasks);
end;
{$ELSE}
procedure TBlake2SP.DoParallelComputation(APtrDataTwo: PByte; ACounter: UInt64);
var
LIdx: Int32;
begin
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
ParallelComputation(LIdx, APtrDataTwo, ACounter);
end;
end;
{$ENDIF HAS_DELPHI_PPL}
procedure TBlake2SP.TransformBytes(const AData: THashLibByteArray;
AIndex, ADataLength: Int32);
var
LLeft, LFill, LDataLength, LCounter: UInt64;
LPtrData, LPtrDataTwo: PByte;
LIdx: Int32;
begin
LDataLength := UInt64(ADataLength);
LPtrData := PByte(AData) + AIndex;
LLeft := FBufferLength;
LFill := UInt64(System.Length(FBuffer)) - LLeft;
if (LLeft > 0) and (LDataLength >= LFill) then
begin
System.Move(LPtrData^, FBuffer[LLeft], LFill);
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
FLeafHashes[LIdx].TransformBytes(FBuffer, LIdx * BlockSizeInBytes,
BlockSizeInBytes);
end;
System.Inc(LPtrData, LFill);
LDataLength := LDataLength - LFill;
LLeft := 0;
end;
LPtrDataTwo := LPtrData;
LCounter := LDataLength;
DoParallelComputation(LPtrDataTwo, LCounter);
System.Inc(LPtrData, LDataLength - (LDataLength mod UInt64(ParallelismDegree *
BlockSizeInBytes)));
LDataLength := LDataLength mod UInt64(ParallelismDegree * BlockSizeInBytes);
if (LDataLength > 0) then
begin
System.Move(LPtrData^, FBuffer[LLeft], LDataLength);
end;
FBufferLength := UInt32(LLeft) + UInt32(LDataLength);
end;
function TBlake2SP.TransformFinal: IHashResult;
var
LHash: THashLibMatrixByteArray;
LIdx: Int32;
LLeft: UInt64;
begin
System.SetLength(LHash, ParallelismDegree);
for LIdx := System.Low(LHash) to System.High(LHash) do
begin
System.SetLength(LHash[LIdx], OutSizeInBytes);
end;
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
if (FBufferLength > (LIdx * BlockSizeInBytes)) then
begin
LLeft := FBufferLength - UInt64(LIdx * BlockSizeInBytes);
if (LLeft > BlockSizeInBytes) then
begin
LLeft := BlockSizeInBytes;
end;
FLeafHashes[LIdx].TransformBytes(FBuffer, LIdx * BlockSizeInBytes,
Int32(LLeft));
end;
LHash[LIdx] := FLeafHashes[LIdx].TransformFinal().GetBytes();
end;
for LIdx := 0 to System.Pred(ParallelismDegree) do
begin
FRootHash.TransformBytes(LHash[LIdx]);
end;
Result := FRootHash.TransformFinal();
Initialize();
end;
end.
|
unit Endereco;
interface
uses SysUtils, Contnrs, Cidade;
type
TEndereco = class
private
Fcodigo :Integer;
Fcodigo_cliente :Integer;
Fcep :String;
Flogradouro :String;
Fnumero :String;
Freferencia :String;
Fbairro :String;
Fcodigo_cidade :Integer;
Fuf :String;
FCidade :TCidade;
Ffone :String;
FCodigo_pessoa :integer;
private
function GetCidade: TCidade;
public
property codigo :Integer read Fcodigo write Fcodigo;
property codigo_pessoa :integer read FCodigo_pessoa write FCodigo_pessoa;
property cep :String read Fcep write Fcep;
property logradouro :String read Flogradouro write Flogradouro;
property numero :String read Fnumero write Fnumero;
property referencia :String read Freferencia write Freferencia;
property bairro :String read Fbairro write Fbairro;
property codigo_cidade :Integer read Fcodigo_cidade write Fcodigo_cidade;
property uf :String read Fuf write Fuf;
property fone :String read Ffone write Ffone;
public
property Cidade :TCidade read GetCidade;
end;
implementation
uses Funcoes, repositorio, FabricaRepositorio, EspecificacaoCidadePorCodigoIBGE;
{ TEndereco }
function TEndereco.GetCidade: TCidade;
var repositorio :TRepositorio;
especificacao :TEspecificacaoCidadePorCodigoIBGE;
begin
if not assigned(FCidade) then
begin
repositorio := TFabricaRepositorio.GetRepositorio(TCidade.ClassName);
especificacao := TEspecificacaoCidadePorCodigoIBGE.Create(self.codigo_cidade);
FCidade := TCidade(repositorio.GetPorEspecificacao(especificacao));
end;
result := FCidade;
end;
end.
|
unit mpiSaveLoadDataFile;
interface
uses mpiDeclaration, mpiLibrary;
procedure SaveDataFile(aLasFileName : String; fStartDepth, fEndDepth : TFloat);
procedure LoadDataFile();
procedure SetDefaultParamForPlanshet();
procedure SetDefaultParamForReportClass();
procedure SetFormParamReportClass();
implementation
uses mpiLasFile, SysUtils, unit_Main, Classes, Unit_SeriesValue, Unit_Marks, Dialogs,
Forms, mpiGuardantStealth, mpiReportClass, Unit_ReportOfWell1_Param, Graphics;
{===============================================================================
}
procedure SaveDataFile(aLasFileName : String; fStartDepth, fEndDepth : TFloat);
var
aFileName : String;
iFileHandle : Integer;
i,k : Integer;
Series : Tseries;
CountMarks : Integer;
NewMarkArray : array of TMarks;
begin
if LasFile = nil then exit;
if prov1 and prov2 and prov3 and prov4 and prov5 and prov6 then begin
aFileName := ExtractFileName(aLasFileName);
aFileName := ExtractFilePath(Application.ExeName) + 'LasData\' + copy(aFileName, 1, Length(aFileName) - 4) + '.ld';
if (LasFile <> nil) {and (Length(MarkArray) <> 0)} then begin
Try
// ----- Опредиляю список записываемых отметок ----------
CountMarks := 0;
for i := 0 to Length(MarkArray) - 1 do begin
if ((MarkArray[i].fCurrentDepth >= fStartDepth) and (MarkArray[i].fCurrentDepth <= fEndDepth)) or
((MarkArray[i].fCurrentDepth <= fStartDepth) and (MarkArray[i].fCurrentDepth >= fEndDepth)) then begin
CountMarks := CountMarks + 1;
SetLength(NewMarkArray, CountMarks);
NewMarkArray[CountMarks-1] := MarkArray[i];
end
end;
// ---------------
CountMarks := Length(NewMarkArray);
//=======================================
iFileHandle := FileCreate(aFileName);
//=======================================
// ------ Запись отметок ----------------
FileWrite(iFileHandle, CountMarks, SizeOf(CountMarks));
for i := 0 to CountMarks - 1 do FileWrite(iFileHandle, NewMarkArray[i], SizeOf(NewMarkArray[i]));
// ------ Запись Установок планшета -------------
FillChar(PlanshetParam, sizeOf(PlanshetParam), 0);
// ---------
for k := 0 to 2 do PlanshetParam.Pole_Visible[k] := Planshet.PoleArray[k].Visible;
FileWrite(iFileHandle, PlanshetParam.Pole_Visible, SizeOf(PlanshetParam.Pole_Visible));
// ---------
for k := 0 to 2 do PlanshetParam.CountSeriesPole[k] := Planshet.PoleArray[k].SeriesList.Count;
FileWrite(iFileHandle, PlanshetParam.CountSeriesPole, SizeOf(PlanshetParam.CountSeriesPole));
// ---------
for k := 0 to 2 do begin
SetLength(PlanshetParam.SeriesListPole[k], PlanshetParam.CountSeriesPole[k]);
for i := 0 to PlanshetParam.CountSeriesPole[k] - 1 do begin
Series := TSeries(Planshet.PoleArray[k].SeriesList.Items[i]);
PlanshetParam.SeriesListPole[k][i].index := LasFile.GetSeriesIndex(Series);
PlanshetParam.SeriesListPole[k][i].PenColor := Integer(Series.PenColor);
PlanshetParam.SeriesListPole[k][i].PenStyle := Integer(Series.PenStyle);
PlanshetParam.SeriesListPole[k][i].PenWidth := Series.PenWidth;
PlanshetParam.SeriesListPole[k][i].fMin := Series.CorrectMinValue;
PlanshetParam.SeriesListPole[k][i].fMax := Series.CorrectMaxValue;
FileWrite(iFileHandle, PlanshetParam.SeriesListPole[k][i], SizeOf(PlanshetParam.SeriesListPole[k][i]));
end;
end;
// ---------
PlanshetParam.MashtabCoef := frmMain.tbMashtab.Position; FileWrite(iFileHandle, PlanshetParam.MashtabCoef, SizeOf(PlanshetParam.MashtabCoef));
PlanshetParam.ScrollBarPos := frmMain.ScrollBar1.Position; FileWrite(iFileHandle, PlanshetParam.ScrollBarPos, SizeOf(PlanshetParam.ScrollBarPos));
PlanshetParam.OtmetkiVisible := frmMain.tbOtmetki.Down; FileWrite(iFileHandle, PlanshetParam.OtmetkiVisible, SizeOf(PlanshetParam.OtmetkiVisible));
PlanshetParam.ListOtmetkiVisible := frmMain.tbOtmetkiPanel.Down; FileWrite(iFileHandle, PlanshetParam.ListOtmetkiVisible, SizeOf(PlanshetParam.ListOtmetkiVisible));
PlanshetParam.WindowsValuePosition := point(frmSeriesValue.Left, frmSeriesValue.Top); FileWrite(iFileHandle, PlanshetParam.WindowsValuePosition, SizeOf(PlanshetParam.WindowsValuePosition));
PlanshetParam.WindowsOtmetkiValue := point(frmMarks.Left , frmMarks.Top); FileWrite(iFileHandle, PlanshetParam.WindowsOtmetkiValue, SizeOf(PlanshetParam.WindowsOtmetkiValue));
// ---------------------------------------------
// ---------------------------------------------
// ---------------------------------------------
// --------- Запись отчетной формы -------------
// ---------------------------------------------
// ---------------------------------------------
// ---------------------------------------------
FillChar(ReportClassParam, SizeOf(ReportClassParam), 0);
ReportClassParam.DepthCoef := ReportClass.MashtabCoef;
FileWrite(iFileHandle, ReportClassParam.DepthCoef, SizeOf(ReportClassParam.DepthCoef));
ReportClassParam.DepthStep := StrToFloat(frmReportOfWell1_Param.eDepthStep.Text);
FileWrite(iFileHandle, ReportClassParam.DepthStep, SizeOf(ReportClassParam.DepthStep));
ReportClassParam.CountLitLayer := frmReportOfWell1_Param.lbLayer.Items.Count; SetLength(ReportClassParam.LitLayerArray, ReportClassParam.CountLitLayer);
FileWrite(iFileHandle, ReportClassParam.CountLitLayer, SizeOf(ReportClassParam.CountLitLayer));
for i := 0 to ReportClassParam.CountLitLayer - 1 do Begin
ReportClassParam.LitLayerArray[i] := TLithography(ReportClass.PoleList.Items[1]).LayerArray[i];
FileWrite(iFileHandle, ReportClassParam.LitLayerArray[i], SizeOf(TLithographyLayer));
end;
ReportClassParam.CountDopCurves := TDropCurves (ReportClass.PoleList.Items[2]).SeriesList.Count; SetLength(ReportClassParam.DopCurverArray, ReportClassParam.CountDopCurves);
FileWrite(iFileHandle, ReportClassParam.CountDopCurves, SizeOf(ReportClassParam.CountDopCurves));
for i := 0 to ReportClassParam.CountDopCurves - 1 do begin
ReportClassParam.DopCurverArray[i] := LasFile.GetSeriesIndex(TSeries(TDropCurves (ReportClass.PoleList.Items[2]).SeriesList.Items[i]));
FileWrite(iFileHandle, ReportClassParam.DopCurverArray[i], SizeOf(Integer));
end;
ReportClassParam.NominalDiametrEnabled := frmReportOfWell1_Param.cbNominalDiametr.Checked;
FileWrite(iFileHandle, ReportClassParam.NominalDiametrEnabled, SizeOf(ReportClassParam.NominalDiametrEnabled));
ReportClassParam.NominalDiametr := StrToFLoat(frmReportOfWell1_Param.eNominalDiametr.Text);
FileWrite(iFileHandle, ReportClassParam.NominalDiametr, SizeOf(ReportClassParam.NominalDiametr));
if TGIS(ReportClass.PoleList.Items[4]).GISLasFile <> nil then begin
ReportClassParam.NameLasFile := TGIS(ReportClass.PoleList.Items[4]).GISLasFile.FileName;
ReportClassParam.NumberSeries := TGIS(ReportClass.PoleList.Items[4]).GISLasFile.GetSeriesIndex(TSeries(frmReportOfWell1_Param.lbGISPole.Items.Objects[0]));
ReportClassParam.SeriesColor := Integer(TSeries(frmReportOfWell1_Param.lbGISPole.Items.Objects[0]).PenColor);
ReportClassParam.SeriesStyle := Integer(TSeries(frmReportOfWell1_Param.lbGISPole.Items.Objects[0]).PenStyle);
ReportClassParam.SeriesWidth := Integer(TSeries(frmReportOfWell1_Param.lbGISPole.Items.Objects[0]).PenWidth);
end else begin
ReportClassParam.NameLasFile := '';
ReportClassParam.NumberSeries := -1;
ReportClassParam.SeriesColor := 0;
ReportClassParam.SeriesStyle := 0;
ReportClassParam.SeriesWidth := 0;
end;
FileWrite(iFileHandle, ReportClassParam.NameLasFile, SizeOf(ReportClassParam.NameLasFile));
FileWrite(iFileHandle, ReportClassParam.NumberSeries, SizeOf(ReportClassParam.NumberSeries));
FileWrite(iFileHandle, ReportClassParam.SeriesColor, SizeOf(ReportClassParam.SeriesColor));
FileWrite(iFileHandle, ReportClassParam.SeriesStyle, SizeOf(ReportClassParam.SeriesStyle));
FileWrite(iFileHandle, ReportClassParam.SeriesWidth, SizeOf(ReportClassParam.SeriesWidth));
ReportClassParam.DiametrGolovastic := frmReportOfWell1_Param.seGolovasticRadius.Value;
ReportClassParam.a1 := frmReportOfWell1_Param.se1.Value;
ReportClassParam.a2 := frmReportOfWell1_Param.seMain1.Value;
ReportClassParam.b1 := frmReportOfWell1_Param.se2.Value;
ReportClassParam.b2 := frmReportOfWell1_Param.seMain2.Value;
ReportClassParam.c1 := frmReportOfWell1_Param.se3.Value;
ReportClassParam.c2 := frmReportOfWell1_Param.seMain3.Value;
ReportClassParam.d1 := frmReportOfWell1_Param.se4.Value;
ReportClassParam.d2 := frmReportOfWell1_Param.seMain4.Value;
ReportClassParam.e1 := frmReportOfWell1_Param.se5.Value;
ReportClassParam.e2 := frmReportOfWell1_Param.seMain5.Value;
FileWrite(iFileHandle, ReportClassParam.DiametrGolovastic, SizeOf(ReportClassParam.DiametrGolovastic));
FileWrite(iFileHandle, ReportClassParam.a1, SizeOf(ReportClassParam.a1));
FileWrite(iFileHandle, ReportClassParam.a2, SizeOf(ReportClassParam.a2));
FileWrite(iFileHandle, ReportClassParam.b1, SizeOf(ReportClassParam.b1));
FileWrite(iFileHandle, ReportClassParam.b2, SizeOf(ReportClassParam.b2));
FileWrite(iFileHandle, ReportClassParam.c1, SizeOf(ReportClassParam.c1));
FileWrite(iFileHandle, ReportClassParam.c2, SizeOf(ReportClassParam.c2));
FileWrite(iFileHandle, ReportClassParam.d1, SizeOf(ReportClassParam.d1));
FileWrite(iFileHandle, ReportClassParam.d2, SizeOf(ReportClassParam.d2));
FileWrite(iFileHandle, ReportClassParam.e1, SizeOf(ReportClassParam.e1));
FileWrite(iFileHandle, ReportClassParam.e2, SizeOf(ReportClassParam.e2));
ReportClassParam.CountFreqLayer := frmReportOfWell1_Param.lbFreqLayer.Items.Count; SetLength(ReportClassParam.FreqLayerArray, ReportClassParam.CountFreqLayer);
FileWrite(iFileHandle, ReportClassParam.CountFreqLayer, SizeOf(ReportClassParam.CountFreqLayer));
for i := 0 to ReportClassParam.CountFreqLayer - 1 do begin
ReportClassParam.FreqLayerArray[i] := TFreqPole(ReportClass.PoleList.Items[6]).FreqLayerArray[i];
FileWrite(iFileHandle, ReportClassParam.FreqLayerArray[i], SizeOf(TFreqLayer));
end;
//FileWrite(iFileHandle, ReportClassParam, SizeOf(ReportClassParam));
FileWrite(iFileHandle, L_big , SizeOf(L_big) );
FileWrite(iFileHandle, L_Small, SizeOf(L_Small));
FileWrite(iFileHandle, r0 , SizeOf(r0) );
//=======================================
FileClose(iFileHandle);
//=======================================
except
Beep();
MessageDlg('Ошибка записи файла данных "'+ExtractFileName(aFileName)+'" соответствующего файлу "'+ExtractFileName(LasFile.FileName)+'"' + #13#10#13#10'Файл данных не будет записан ... ', mtError, [mbOk], 0);
end;
end;
end; // ---- if prov1 and prov2 and prov3 and prov4 and prov5 and prov6 then begin
end;
{===============================================================================
}
procedure LoadDataFile();
var
aFileName : String;
iFileHandle : Integer;
CountMarks : Integer;
i, k : Integer;
TempMarkArray : array of TMarks;
err : Boolean;
begin
err := False;
aFileName := ExtractFileName(LasFile.FileName);
aFileName := ExtractFilePath(Application.ExeName) + 'LasData\' + copy(aFileName, 1, Length(aFileName) - 4) + '.ld';
if FileExists(aFileName) then begin
Try
//=======================================
iFileHandle := FileOpen(aFileName, fmOpenRead);
//=======================================
FileRead(iFileHandle, CountMarks, SizeOf(CountMarks));
// ------- Загружаю отметки ------------
SetLength(TempMarkArray, CountMarks);
if CountMarks <> 0 then for i := 0 to CountMarks - 1 do FileRead(iFileHandle, TempMarkArray[i], SizeOf(TempMarkArray[i]));
// ------- Заружаю параметры планшета ------------
FillChar(PlanshetParam, sizeOf(PlanshetParam), 0);
FileRead(iFileHandle, PlanshetParam.Pole_Visible , SizeOf(PlanshetParam.Pole_Visible ));
FileRead(iFileHandle, PlanshetParam.CountSeriesPole, SizeOf(PlanshetParam.CountSeriesPole));
// ---------
for k := 0 to 2 do begin
SetLength(PlanshetParam.SeriesListPole[k], PlanshetParam.CountSeriesPole[k]);
for i := 0 to PlanshetParam.CountSeriesPole[k] - 1 do
FileRead(iFileHandle, PlanshetParam.SeriesListPole[k][i], SizeOf(PlanshetParam.SeriesListPole[k][i]));
end;
// ---------
FileRead(iFileHandle, PlanshetParam.MashtabCoef, SizeOf(PlanshetParam.MashtabCoef));
FileRead(iFileHandle, PlanshetParam.ScrollBarPos, SizeOf(PlanshetParam.ScrollBarPos));
FileRead(iFileHandle, PlanshetParam.OtmetkiVisible, SizeOf(PlanshetParam.OtmetkiVisible));
FileRead(iFileHandle, PlanshetParam.ListOtmetkiVisible, SizeOf(PlanshetParam.ListOtmetkiVisible));
FileRead(iFileHandle, PlanshetParam.WindowsValuePosition, SizeOf(PlanshetParam.WindowsValuePosition));
FileRead(iFileHandle, PlanshetParam.WindowsOtmetkiValue, SizeOf(PlanshetParam.WindowsOtmetkiValue));
// ---------------------------------------------
// ---------------------------------------------
// ---------------------------------------------
// --------- Считывание отчетной формы ---------
// ---------------------------------------------
// ---------------------------------------------
// ---------------------------------------------
FillChar(ReportClassParam, SizeOf(ReportClassParam), 0);
FileRead(iFileHandle, ReportClassParam.DepthCoef , SizeOf(ReportClassParam.DepthCoef));
FileRead(iFileHandle, ReportClassParam.DepthStep , SizeOf(ReportClassParam.DepthStep));
FileRead(iFileHandle, ReportClassParam.CountLitLayer, SizeOf(ReportClassParam.CountLitLayer)); SetLength(ReportClassParam.LitLayerArray, ReportClassParam.CountLitLayer);
for i := 0 to ReportClassParam.CountLitLayer - 1 do FileRead(iFileHandle, ReportClassParam.LitLayerArray[i], SizeOf(TLithographyLayer));
FileRead(iFileHandle, ReportClassParam.CountDopCurves, SizeOf(ReportClassParam.CountDopCurves)); SetLength(ReportClassParam.DopCurverArray, ReportClassParam.CountDopCurves);
for i := 0 to ReportClassParam.CountDopCurves - 1 do FileRead(iFileHandle, ReportClassParam.DopCurverArray[i], SizeOf(Integer));
FileRead(iFileHandle, ReportClassParam.NominalDiametrEnabled, SizeOf(ReportClassParam.NominalDiametrEnabled));
FileRead(iFileHandle, ReportClassParam.NominalDiametr, SizeOf(ReportClassParam.NominalDiametr));
FileRead(iFileHandle, ReportClassParam.NameLasFile, SizeOf(ReportClassParam.NameLasFile));
FileRead(iFileHandle, ReportClassParam.NumberSeries, SizeOf(ReportClassParam.NumberSeries));
FileRead(iFileHandle, ReportClassParam.SeriesColor, SizeOf(ReportClassParam.SeriesColor));
FileRead(iFileHandle, ReportClassParam.SeriesStyle, SizeOf(ReportClassParam.SeriesStyle));
FileRead(iFileHandle, ReportClassParam.SeriesWidth, SizeOf(ReportClassParam.SeriesWidth));
FileRead(iFileHandle, ReportClassParam.DiametrGolovastic, SizeOf(ReportClassParam.DiametrGolovastic));
FileRead(iFileHandle, ReportClassParam.a1 , SizeOf(ReportClassParam.a1));
FileRead(iFileHandle, ReportClassParam.a2 , SizeOf(ReportClassParam.a2));
FileRead(iFileHandle, ReportClassParam.b1 , SizeOf(ReportClassParam.b1));
FileRead(iFileHandle, ReportClassParam.b2 , SizeOf(ReportClassParam.b2));
FileRead(iFileHandle, ReportClassParam.c1 , SizeOf(ReportClassParam.c1));
FileRead(iFileHandle, ReportClassParam.c2 , SizeOf(ReportClassParam.c2));
FileRead(iFileHandle, ReportClassParam.d1 , SizeOf(ReportClassParam.d1));
FileRead(iFileHandle, ReportClassParam.d2 , SizeOf(ReportClassParam.d2));
FileRead(iFileHandle, ReportClassParam.e1 , SizeOf(ReportClassParam.e1));
FileRead(iFileHandle, ReportClassParam.e2 , SizeOf(ReportClassParam.e2));
FileRead(iFileHandle, ReportClassParam.CountFreqLayer, SizeOf(ReportClassParam.CountFreqLayer));
// ReportClassParam.CountFreqLayer := 0;
SetLength(ReportClassParam.FreqLayerArray, ReportClassParam.CountFreqLayer);
for i := 0 to ReportClassParam.CountFreqLayer - 1 do FileRead(iFileHandle, ReportClassParam.FreqLayerArray[i], SizeOf(TFreqLayer));
FileRead(iFileHandle, L_big , SizeOf(L_big) );
FileRead(iFileHandle, L_Small, SizeOf(L_Small));
FileRead(iFileHandle, r0 , SizeOf(r0) );
//=======================================
FileClose(iFileHandle);
//=======================================
// -------------------
frmMarks.OtputMarks();
except
Beep();
err := true;
if MessageDlg('Файл данных "'+ExtractFileName(aFileName)+'" соответствующий файлу "'+ExtractFileName(LasFile.FileName)+'" поврежден ...'#13#10#13#10'Удалить поврежденный файл данных ?', mtError, [mbOk, mbCancel], 0) = 1 {mrOk} then begin
DeleteFile(aFileName);
end;
end;
//------------------
if not err then begin
SetLength(MarkArray, CountMarks);
for i := 0 to CountMarks - 1 do
MarkArray[i] := TempMarkArray[i];
end;
//------------------
SetLength(TempMarkArray, 0);
end else begin
SetDefaultParamForPlanshet();
PlanshetParam.SeriesListPole[0][0].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK1'));
PlanshetParam.SeriesListPole[0][1].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK3'));
PlanshetParam.SeriesListPole[0][2].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK5'));
PlanshetParam.SeriesListPole[0][3].index := LasFile.GetSeriesIndex(LasFile.GetSeries('RADS'));
PlanshetParam.SeriesListPole[1][0].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK2'));
PlanshetParam.SeriesListPole[1][1].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK4'));
PlanshetParam.SeriesListPole[1][2].index := LasFile.GetSeriesIndex(LasFile.GetSeries('BMK6'));
PlanshetParam.SeriesListPole[1][3].index := LasFile.GetSeriesIndex(LasFile.GetSeries('RADS'));
SetDefaultParamForReportClass();
end;
end;
{===============================================================================
}
procedure SetDefaultParamForPlanshet();
begin
FillChar(PlanshetParam, SizeOf(PlanshetParam), 0);
with PlanshetParam do begin
Pole_Visible[0] := True;
Pole_Visible[1] := False;
Pole_Visible[2] := False;
// ----------------------------
CountSeriesPole[0] := 4; SetLength(SeriesListPole[0], CountSeriesPole[0]);
CountSeriesPole[1] := 4; SetLength(SeriesListPole[1], CountSeriesPole[1]);
CountSeriesPole[2] := 0; SetLength(SeriesListPole[2], CountSeriesPole[2]);
// ----------------------------
SeriesListPole[0][0].index := 2;
SeriesListPole[0][0].PenColor := clBlue;
SeriesListPole[0][0].PenStyle := Integer(psSolid);
SeriesListPole[0][0].PenWidth := 1;
SeriesListPole[0][0].fMax := -1;
SeriesListPole[0][0].fMin := -1;
SeriesListPole[0][1].index := 4;
SeriesListPole[0][1].PenColor := clRed;
SeriesListPole[0][1].PenStyle := Integer(psSolid);
SeriesListPole[0][1].PenWidth := 1;
SeriesListPole[0][1].fMax := -1;
SeriesListPole[0][1].fMin := -1;
SeriesListPole[0][2].index := 6;
SeriesListPole[0][2].PenColor := clGreen;
SeriesListPole[0][2].PenStyle := Integer(psSolid);
SeriesListPole[0][2].PenWidth := 1;
SeriesListPole[0][2].fMax := -1;
SeriesListPole[0][2].fMin := -1;
SeriesListPole[0][3].index := 25;
SeriesListPole[0][3].PenColor := clBlack;
SeriesListPole[0][3].PenStyle := Integer(psSolid);
SeriesListPole[0][3].PenWidth := 1;
SeriesListPole[0][3].fMax := -1;
SeriesListPole[0][3].fMin := -1;
SeriesListPole[1][0].index := 3;
SeriesListPole[1][0].PenColor := clBlue;
SeriesListPole[1][0].PenStyle := Integer(psSolid);
SeriesListPole[1][0].PenWidth := 1;
SeriesListPole[1][0].fMax := -1;
SeriesListPole[1][0].fMin := -1;
SeriesListPole[1][1].index := 5;
SeriesListPole[1][1].PenColor := clRed;
SeriesListPole[1][1].PenStyle := Integer(psSolid);
SeriesListPole[1][1].PenWidth := 1;
SeriesListPole[1][1].fMax := -1;
SeriesListPole[1][1].fMin := -1;
SeriesListPole[1][2].index := 7;
SeriesListPole[1][2].PenColor := clGreen;
SeriesListPole[1][2].PenStyle := Integer(psSolid);
SeriesListPole[1][2].PenWidth := 1;
SeriesListPole[1][2].fMax := -1;
SeriesListPole[1][2].fMin := -1;
SeriesListPole[1][3].index := 25;
SeriesListPole[1][3].PenColor := clBlack;
SeriesListPole[1][3].PenStyle := Integer(psSolid);
SeriesListPole[1][3].PenWidth := 1;
SeriesListPole[1][3].fMax := -1;
SeriesListPole[1][3].fMin := -1;
// ----------------------------
MashtabCoef := 1;
ScrollBarPos := 0;
// ----------------------------
OtmetkiVisible := true;
ListOtmetkiVisible := true;
// ----------------------------
WindowsValuePosition := Point(-1, -1);
WindowsOtmetkiValue := Point(-1, -1);
end;
end;
{===============================================================================
}
procedure SetDefaultParamForReportClass();
var
i : integer;
begin
FillChar(ReportClassParam, SizeOf(ReportClassParam), 0);
with ReportClassParam do begin
ReportClassParam.DepthCoef := 1;
ReportClassParam.DepthStep := 1;
ReportClassParam.CountLitLayer := 0;
SetLength(ReportClassParam.LitLayerArray, ReportClassParam.CountLitLayer);
ReportClassParam.CountDopCurves := 6;
SetLength(ReportClassParam.DopCurverArray, ReportClassParam.CountDopCurves);
for i := 2 to 2 + ReportClassParam.CountDopCurves - 1 do ReportClassParam.DopCurverArray[i-2] := i;
ReportClassParam.NominalDiametrEnabled := true;
ReportClassParam.NominalDiametr := 210;
ReportClassParam.NameLasFile := '';
ReportClassParam.NumberSeries := -1;
ReportClassParam.SeriesColor := clBlack;
ReportClassParam.SeriesStyle := integer(psSolid);
ReportClassParam.SeriesWidth := 1;
ReportClassParam.DiametrGolovastic := 4;
ReportClassParam.a1 := 90;
ReportClassParam.a2 := 100;
ReportClassParam.b1 := 80;
ReportClassParam.b2 := 90;
ReportClassParam.c1 := 70;
ReportClassParam.c2 := 80;
ReportClassParam.d1 := 60;
ReportClassParam.d2 := 70;
ReportClassParam.e1 := 0;
ReportClassParam.e2 := 60;
ReportClassParam.CountFreqLayer := 0;
SetLength(ReportClassParam.FreqLayerArray, ReportClassParam.CountFreqLayer);
end;
end;
procedure SetFormParamReportClass();
var
DepthPole : TDepthPole;
Lithography : TLithography;
DropCurves : TDropCurves;
MidleRadius : TMidleRadius;
GIS : TGIS;
Golovastic : TGolovastic;
FreqPole : TFreqPole;
i : Integer;
Series : TSeries;
begin
// ------------------
DepthPole := TDepthPole (ReportClass.PoleList.Items[0]);
Lithography := TLithography(ReportClass.PoleList.Items[1]);
DropCurves := TDropCurves (ReportClass.PoleList.Items[2]);
MidleRadius := TMidleRadius(ReportClass.PoleList.Items[3]);
GIS := TGIS (ReportClass.PoleList.Items[4]);
Golovastic := TGolovastic (ReportClass.PoleList.Items[5]);
FreqPole := TFreqPole (ReportClass.PoleList.Items[6]);
// -------------------
DropCurves.SeriesList.Clear;
Gis.SeriesList.clear;
frmReportOfWell1_Param.lbLayer.Items.Clear;
frmReportOfWell1_Param.lbPole1.Items.Clear;
frmReportOfWell1_Param.lbGISPole.Items.Clear;
frmReportOfWell1_Param.lbGISSeries.Items.Clear;
frmReportOfWell1_Param.lbFreqLayer.Items.Clear;
// --------------------
// ----------- 11 ------------
ReportClass.MashtabCoef := ReportClassParam.DepthCoef;
if ReportClass.MashtabCoef > 1 then frmReportOfWell1_Param.TrackBar1.Position := Round(ReportClass.MashtabCoef + 9);
if ReportClass.MashtabCoef = 1 then frmReportOfWell1_Param.TrackBar1.Position := 10;
if ReportClass.MashtabCoef < 1 then frmReportOfWell1_Param.TrackBar1.Position := Round(ReportClass.MashtabCoef * 10);
DepthPole.StepDepthLabel := ReportClassParam.DepthStep; frmReportOfWell1_Param.eDepthStep.text := FloatToStr(DepthPole.StepDepthLabel);
// ---------- 22 -----------
SetLength(Lithography.LayerArray, ReportClassParam.CountLitLayer);
for i := 0 to ReportClassParam.CountLitLayer - 1 do begin
Lithography.LayerArray[i] := ReportClassParam.LitLayerArray[i];
frmReportOfWell1_Param.lbLayer.Items.AddObject(Lithography.LayerArray[i].NameLayer, addr(Lithography.LayerArray[i].NameLayer));
end;
// ---------- 33 -----------
// ---!!!!!!!!!!!!!!!??????????????????????????????????????????????
try
for i := 0 to ReportClassParam.CountDopCurves - 1 do begin
frmReportOfWell1_Param.addSeriesToPoleDopCurves(TSeries(LasFile.SeriesList.Items[ReportClassParam.DopCurverArray[i]]))
//DropCurves.SeriesList.Add();
//frmReportOfWell1_Param.lbPole1.Items.AddObject(TSeries(DropCurves.SeriesList.Items[i]).Name, TSeries(DropCurves.SeriesList.Items[i]));
end;
except end;
// ---------- 44 -----------
MidleRadius.NominalDiametrEnabled := ReportClassParam.NominalDiametrEnabled; frmReportOfWell1_Param.cbNominalDiametr.Checked := MidleRadius.NominalDiametrEnabled;
MidleRadius.NominalDiametr := ReportClassParam.NominalDiametr; frmReportOfWell1_Param.eNominalDiametr.Text := FloatToStr(MidleRadius.NominalDiametr);
// ---------- 55 -----------
if ReportClassParam.NameLasFile <> '' then begin
frmReportOfWell1_Param.LoadGisLasFile(ReportClassParam.NameLasFile);
if (Gis.GISLasFile <> nil) and (ReportClassParam.NumberSeries <> -1) then begin
Series := TSeries(Gis.GISLasFile.SeriesList.Items[ReportClassParam.NumberSeries]);
frmReportOfWell1_Param.addSeriesToGISPole(Series);
Series.PenColor := ReportClassParam.SeriesColor;
Series.PenStyle := TPenStyle(ReportClassParam.SeriesStyle);
Series.PenWidth := ReportClassParam.SeriesWidth;
end;
end;
// --------- 66 -----------
Golovastic.HolovasticRadius := ReportClassParam.DiametrGolovastic;
Golovastic.MinMaxArray[0].min := ReportClassParam.a1;
Golovastic.MinMaxArray[0].max := ReportClassParam.a2;
Golovastic.MinMaxArray[1].min := ReportClassParam.b1;
Golovastic.MinMaxArray[1].max := ReportClassParam.b2;
Golovastic.MinMaxArray[2].min := ReportClassParam.c1;
Golovastic.MinMaxArray[2].max := ReportClassParam.c2;
Golovastic.MinMaxArray[3].min := ReportClassParam.d1;
Golovastic.MinMaxArray[3].max := ReportClassParam.d2;
Golovastic.MinMaxArray[4].min := ReportClassParam.e1;
Golovastic.MinMaxArray[4].max := ReportClassParam.e2;
frmReportOfWell1_Param.se1.value := ReportClassParam.a1;
frmReportOfWell1_Param.seMain1.value := ReportClassParam.a2;
frmReportOfWell1_Param.se2.value := ReportClassParam.b1;
frmReportOfWell1_Param.seMain2.value := ReportClassParam.b2;
frmReportOfWell1_Param.se3.value := ReportClassParam.c1;
frmReportOfWell1_Param.seMain3.value := ReportClassParam.c2;
frmReportOfWell1_Param.se4.value := ReportClassParam.d1;
frmReportOfWell1_Param.seMain4.value := ReportClassParam.d2;
frmReportOfWell1_Param.se5.value := ReportClassParam.e1;
frmReportOfWell1_Param.seMain5.value := ReportClassParam.e2;
frmReportOfWell1_Param.seGolovasticRadius.Value := ReportClassParam.DiametrGolovastic;
// -------- 77 -----------
SetLength(FreqPole.FreqLayerArray, ReportClassParam.CountFreqLayer);
for i := 0 to ReportClassParam.CountFreqLayer - 1 do begin
FreqPole.FreqLayerArray[i] := ReportClassParam.FreqLayerArray[i];
frmReportOfWell1_Param.lbFreqLayer.Items.AddObject(FloatToStrF(FreqPole.FreqLayerArray[i].BeginDepth, ffFixed, 20,4) + ' - ' + FloatTOStrF(FreqPole.FreqLayerArray[i].EndDepth, ffFixed, 20,4), addr(FreqPole.FreqLayerArray[i]));
end;
end;
end.
|
unit UKMundo;
interface
uses
Classes, SysUtils,
NativeXML, FastStrings;
const
ALTOMAXIMO = 256;
ANCHOMAXIMO = 256;
DIR_HORIZONTAL = 0;
DIR_VERTICAL = 1;
DIR_NORTE = 0;
DIR_ESTE = 1;
DIR_SUR = 2;
DIR_OESTE = 3;
PARED_NORTE = 1;
PARED_ESTE = 2;
PARED_SUR = 4;
PARED_OESTE = 8;
type
TfcbCambioMundo = procedure (x, y, cambio : integer);
TKCasillaMundo = record
case Integer of
0 : (valor : Cardinal);
1 : (zumbadores : WORD);
2 : (pRes : WORD;
paredes : BYTE);
3 : (x : WORD; y : WORD);
end;
TKMundo = class
private
_errMsg : string;
_fcbCambioZumbador, _fcbCambioPared : TfcbCambioMundo;
_alto, _ancho : integer;
_mundo : array [0..ANCHOMAXIMO + 1,0..ALTOMAXIMO + 1] of TKCasillaMundo;
_dumpSelectivo : boolean;
_arrayDumpSelectivo : array [0..ANCHOMAXIMO + 1,0..ALTOMAXIMO + 1] of boolean;
_slErrores : TStringList;
function getParedesEnCoordenada(cX, cY: integer): integer; // OK
function getZumbadoresEnCoordenada(cX, cY: integer): integer; // OK
procedure setZumbadoresEnCoordenada(cX, cY: integer; const Value: integer); // OK
function getListaErrores: string; // OK
function getNumErrores: integer; // OK
public
constructor Create;
destructor Destroy; override;
function leeDeArchivo(const archivo : string) : boolean;
function leeDeNodo(raiz : TXMLNode) : boolean;
function escribeAXML(nodo : TXMLNode; compresionDeCeros : boolean = true; const nombre : string = ''; usaDumpSelectivo : boolean = false) : boolean;
procedure limpiaMundo; // OK
procedure limpiaErrores;
function agregaPared(xI, yI : integer; xF : integer = -1; yF : integer = -1) : boolean; // OK
function agregaLinea(xI, yI, xF, yF : integer) : boolean;
function agregaDumpSelectivo(x, y : integer) : boolean;
function cogeZumbador(x, y : integer; cuantos : integer = 1; contabiliza : boolean = true) : boolean; // OK
function dejaZumbador(x, y : integer; cuantos : integer = 1) : boolean; // OK
function avanceValido(xI, yI, direccion : integer) : boolean; // OK
procedure agregaAErrores(const msg : string);
property alto : integer read _alto;
property ancho : integer read _ancho;
property errMsg : string read _errMsg write _errMsg;
property cambioPared : TfcbCambioMundo read _fcbCambioPared write _fcbCambioPared;
property cambioZumbador : TfcbCambioMundo read _fcbCambioZumbador write _fcbCambioZumbador;
property zumbadoresEnCoordenada[cX, cY : integer] : integer read getZumbadoresEnCoordenada write setZumbadoresEnCoordenada;
property paredesEnCoordenada[cX, cY : integer] : integer read getParedesEnCoordenada;
property listaErrores : string read getListaErrores;
property numeroDeErrores : integer read getNumErrores;
property dumpSelectivo : boolean read _dumpSelectivo write _dumpSelectivo;
end;
{TODO : Seria bueno llevar un control de cambios}
implementation
{ TKMundo }
procedure TKMundo.agregaAErrores(const msg: string);
begin
_slErrores.Add(msg);
end;
function TKMundo.agregaDumpSelectivo(x, y: integer): boolean;
begin
_arrayDumpSelectivo[x,y]:=true;
end;
function TKMundo.agregaLinea(xI, yI, xF, yF: integer): boolean;
var
i, j, dir, inicio, fin : integer;
begin
result:=false;
// OBTEN LA DIRECCION
if xI = xF then begin
dir:=DIR_VERTICAL;
if yI > yF then begin
inicio:=yF;
fin:=yI;
end
else begin
inicio:=yI;
fin:=yF;
end;
end
else if yI = yF then begin
dir:=DIR_HORIZONTAL;
if xI > xF then begin
inicio:=xF;
fin:=xI;
end
else begin
inicio:=xI;
fin:=xF;
end;
end
else begin
exit;
end;
// CONSTRUYE LA PARED
result:=true;
case dir of
DIR_VERTICAL : begin
j:=xI + 1;
for i:=inicio + 1 to fin do begin
_mundo[xI,i].paredes:=_mundo[xI,i].paredes or PARED_ESTE;
_mundo[j,i].paredes:=_mundo[j,i].paredes or PARED_OESTE;
end;
end;
DIR_HORIZONTAL : begin
j:=yI + 1;
for i:=inicio + 1 to fin do begin
_mundo[i,yI].paredes:=_mundo[i,yI].paredes or PARED_NORTE;
_mundo[i,j].paredes:=_mundo[i,j].paredes or PARED_SUR;
end;
end;
end;
end;
function TKMundo.agregaPared(xI, yI : integer; xF : integer = -1; yF : integer = -1) : boolean;
var
i, j, dir, inicio, fin : integer;
begin
result:=false;
if xF = -1 then xF:=xI;
if yF = -1 then yF:=yI;
if (xI = xF) or (yI = yF) then begin
result:=agregaLinea(xI,yI,xF,yF);
end
else begin
result:=agregaLinea(xI,yI,xI,yF) and agregaLinea(xI,yF,xF,yF);
end;
end;
function TKMundo.avanceValido(xI, yI, direccion: integer): boolean;
var
p : integer;
begin
p:=paredesEnCoordenada[xI,yI];
if p <> -1 then begin
case direccion of
DIR_NORTE : result:=(p and PARED_NORTE) = 0;
DIR_ESTE : result:=(p and PARED_ESTE) = 0;
DIR_SUR : result:=(p and PARED_SUR) = 0;
DIR_OESTE : result:=(p and PARED_OESTE) = 0;
else
result:=false;
end;
end
else
result:=false;
end;
function TKMundo.cogeZumbador(x, y: integer; cuantos : integer = 1; contabiliza : boolean = true): boolean;
var
z : integer;
begin
z:=zumbadoresEnCoordenada[x,y];
if z >= cuantos then begin
result:=true;
if contabiliza then
zumbadoresEnCoordenada[x,y]:=z - cuantos;
end
else
result:=false;
end;
constructor TKMundo.Create;
begin
_slErrores:=TStringList.Create;
_dumpSelectivo:=false;
end;
function TKMundo.dejaZumbador(x, y: integer; cuantos : integer = 1): boolean;
begin
if (x > 0) and (y > 0) and (x <= ancho) and (y <= alto) then begin
_mundo[x,y].zumbadores:=_mundo[x,y].zumbadores + cuantos;
result:=true;
end
else
result:=false;
end;
destructor TKMundo.Destroy;
begin
_slErrores.Free;
inherited;
end;
function TKMundo.escribeAXML(nodo : TXMLNode; compresionDeCeros : boolean = true; const nombre : string = ''; usaDumpSelectivo : boolean = false): boolean;
var
nodoMundo, nodoLinea : TXMLNode;
i, j, z : integer;
sLinea : AnsiString;
ponCoordenada : boolean;
begin
// ESCRIBE A UN XML EL RESULTADO DE LOS ZUMBADORES EN UN MUNDO
nodoMundo:=nodo.NodeNew('mundo');
nodoMundo.WriteAttributeString('nombre',nombre);
for j:=alto downto 1 do begin
ponCoordenada:=true;
sLinea:='';
for i:=1 to ancho do begin
if not(usaDumpSelectivo) or (dumpSelectivo and _arrayDumpSelectivo[i,j]) then begin
z:=zumbadoresEnCoordenada[i,j];
if compresionDeCeros then begin
if z <> 0 then begin
if ponCoordenada then begin
sLinea:=sLinea + '(' + IntToStr(i) + ') ';
end;
sLinea:=sLinea + IntToStr(z) + ' ';
end;
ponCoordenada:=z = 0;
end
else begin
sLinea:=sLinea + IntToStr(z) + ' ';
end;
end;
end;
if sLinea <> '' then begin
nodoLinea:=nodoMundo.NodeNew('linea');
nodoLinea.Value:=sLinea;
nodoLinea.WriteAttributeInteger('fila',j);
nodoLinea.WriteAttributeBool('compresionDeCeros',compresionDeCeros);
end;
end;
end;
function TKMundo.getListaErrores: string;
begin
result:=_slErrores.Text;
end;
function TKMundo.getNumErrores: integer;
begin
result:=_slErrores.Count;
end;
function TKMundo.getParedesEnCoordenada(cX, cY: integer): integer;
begin
if (cX > 0) and (cY > 0) and (cX <= ancho) and (cY <= alto) then begin
result:=_mundo[cX,cY].paredes;
end
else
result:=-1;
end;
function TKMundo.getZumbadoresEnCoordenada(cX, cY: integer): integer;
begin
if (cX > 0) and (cY > 0) and (cX <= ancho) and (cY <= alto) then begin
result:=_mundo[cX,cY].zumbadores;
end
else
result:=-1;
end;
function TKMundo.leeDeArchivo(const archivo: string): boolean;
var
xml : TNativeXML;
nodoa : TXMLNode;
i, j, x1, y1, x2, y2, xo, yo, z : integer;
sNombreNodo : string;
sLista, sTupla : string;
APos, BPos : integer;
abierta : boolean;
begin
result:=false;
if Not(FileExists(archivo)) then begin
errMsg:='No fue posible encontrar el archivo de mundo (' + archivo + ')';
exit;
end;
try
xml:=TNativeXML.Create(nil);
try
xml.LoadFromFile(archivo);
result := leeDeNodo(xml.Root);
finally
xml.Free;
end;
except
On E : Exception do begin
errMsg:='Error al cargar archivo de mundo (' + E.Message + ')';
end;
end;
end;
function TKMundo.leeDeNodo(raiz: TXMLNode): boolean;
var
xml : TNativeXML;
nodoa : TXMLNode;
i, j, x1, y1, x2, y2, xo, yo, z : integer;
sNombreNodo : string;
sLista, sTupla : string;
APos, BPos : integer;
abierta : boolean;
begin
result:=false;
try
// LEE LAS DIMENSIONES
_ancho:=raiz.ReadAttributeInteger('ancho',100);
_alto:=raiz.ReadAttributeInteger('alto',100);
if (ancho < 1) or (ancho > ANCHOMAXIMO) then begin
errMsg:='El ancho del mundo debe ser un valor entre 1 y ' + IntToStr(ANCHOMAXIMO);
exit;
end;
if (alto < 1) or (alto > ALTOMAXIMO) then begin
errMsg:='El alto del mundo debe ser un valor entre 1 y ' + IntToStr(ALTOMAXIMO);
exit;
end;
// INICIALIZA EL MARCO
limpiaMundo;
agregaPared(0,0,0,alto);
agregaPared(0,alto,ancho,alto);
agregaPared(ancho,alto,ancho,0);
agregaPared(ancho,0,0,0);
// LEE EL MUNDO.
for i:=0 to raiz.NodeCount - 1 do begin
nodoa:=raiz.Nodes[i];
sNombreNodo:=UpperCase(nodoa.Name);
if sNombreNodo = 'MONTON' then begin
// PONE UN MONTON DE ZUMBADORES EN UNA POSICION DEL MUNDO, LA SINTAXIS DEL NODO ES:
// <monton x="<coordenada_x>" y="<coordenada_y>" zumbadores="<numero_de_zumbadores>"/>
// UN VALOR DE -1 EN EL NUMERO DE ZUMBADORES IMPLICA UN NUMERO INFINITO DE ZUMBADORES
x1:=nodoa.ReadAttributeInteger('x',-1);
y1:=nodoa.ReadAttributeInteger('y',-1);
z:=nodoa.ReadAttributeInteger('zumbadores',0);
if not(dejaZumbador(x1,y1,z)) then begin
agregaAErrores('Imposible colocar el monton de zumbadores especificado en el nodo ' + IntToStr(i));
end;
end
else if sNombreNodo = 'LISTAMONTONES' then begin
// PERMITE DAR UNA LISTA DE MONTONES COMO TRIPLETAS {x,y,z} QUE INDICAN LAS COORDENADAS (x,y) DEL MONTON Y EL NUMERO DE ZUMBADORES
// LA SINTAXIS DEL NODO ES:
// <listamontones>lista_de_tripletas_separadas_por_;_entre_tripletas_y_por_,_entre_elementos</listamontones>
// EJEMPLO <listamontones>1,2,1;1,3,2;3,5,-1</listamontones>
// UN VALOR DE -1 EN EL NUMERO DE ZUMBADORES IMPLICA UN NUMERO INFINITO DE ZUMBADORES
sLista:=nodoa.Value;
j:=0;
repeat
sLista:=Trim(sLista);
APos:=FastCharPos(sLista,';',1);
if APos <> 0 then begin
sTupla:=Copy(sLista,1,APos - 1);
sLista:=Copy(sLista,APos + 1,Length(sLista) - APos);
end
else begin
sTupla:=sLista;
sLista:='';
end;
if sTupla <> '' then begin
Inc(j);
APos:=FastCharPos(sTupla,',',1);
BPos:=FastCharPos(sTupla,',',APos + 1);
x1:=StrToIntDef(Copy(sTupla,1,APos - 1),-1);
y1:=StrToIntDef(Copy(sTupla,APos + 1,BPos - APos - 1),-1);
z:=StrToIntDef(Copy(sTupla,BPos + 1,Length(sTupla) - BPos),0);
if not(dejaZumbador(x1,y1,z)) then begin
agregaAErrores('Imposible colocar el monton de zumbadores especificado en el nodo ' + IntToStr(i) +
', tupla ' + IntToStr(j));
end;
end;
until sLista = '';
end
else if sNombreNodo = 'PARED' then begin
// PERMITE PONER UNA PARED EN EL MUNDO, LA SINTAXIS DEL NODO ES:
// <pared x1="<coordenada_x_vertice_1>" y1="<coordenada_y_vertice_1>" x2="<coordenada_x2>" y2="<coordenada_y2>"/>
// ES IMPORTANTE NOTAR QUE LAS COORDENADAS PARA LAS PAREDES Y PARA LOS ZUMBADORES ESTAN DEFASADAS, MIENTRAS QUE LAS COORDENADAS
// POSIBLES PARA UN MONTON DE ZUMBADORES VAN DE 1-ancho O 1-alto, LAS DE LAS PAREDES VAN DESDE 0-ancho O desde 0-alto,
// SI LA PARED POR SUS COORDENADAS ES INCLINADA, SE AJUSTARA MENDIANTO DOS LINEAS INICIANDO SIEMPRE POR EL SEGMENTO VERTICAL
// POR ULTIMO SI ALGUNA DE LAS COORDENADAS _2 NO APARECE, YA SEA x O y, SE ASUME QUE ES IGUAL A LA COORDENADA _1
x1:=nodoa.ReadAttributeInteger('x1',-1);
x2:=nodoa.ReadAttributeInteger('x2',-1);
y1:=nodoa.ReadAttributeInteger('y1',-1);
y2:=nodoa.ReadAttributeInteger('y2',-1);
if (x1 <> -1) and (y1 <> -1) then begin
if Not(agregaPared(x1,y1,x2,y2)) then
agregaAErrores('Fue imposible agregar la pared especificada por el nodo ' + IntToStr(i));
end
else begin
agregaAErrores('Nodo ' + IntToStr(i) + ' tipo PARED no tiene atributos minimos x1 y y1');
end;
end
else if sNombreNodo = 'POLIGONAL' then begin
// PERMITE PONER UNA POLIGONAL ESTABLECIENDO UNICAMENTE LA SUCESION DE VERTICES. LA SINTAXIS DEL NODO ES:
// <poligonal abierta="[true|false]">lista_de_vertices_como_duplas_separadas_por_;_ y_por_,_entre_sus_elementos</poligonal>
// EJEMPLO <poligonal abierta="false">0,0;0,10;10,10;10,0</poligonal> <!-- TRAZA UN CUADRADO -->
// SI LA POLIGONAL SE DEFINE COMO CERRADA, SE TRAZARA UNA ULTIMA PARED ENTRE EL NODO INICIO Y EL FIN DE LA SUCESION.
abierta:=nodoa.ReadAttributeBool('abierta',false);
sLista:=nodoa.Value;
j:=0;
repeat
sLista:=Trim(sLista);
APos:=FastCharPos(sLista,';',1);
if APos <> 0 then begin
sTupla:=Copy(sLista,1,APos - 1);
sLista:=Copy(sLista,APos + 1,Length(sLista) - APos);
end
else begin
sTupla:=sLista;
sLista:='';
end;
if sTupla <> '' then begin
Inc(j);
APos:=FastCharPos(sTupla,',',1);
x1:=x2;
y1:=y2;
x2:=StrToIntDef(Copy(sTupla,1,APos - 1),-1);
y2:=StrToIntDef(Copy(sTupla,APos + 1,Length(sTupla) - APos),-1);
if j > 1 then begin
if not(agregaPared(x1,y1,x2,y2)) then begin
agregaAErrores('Fue imposible agregar el segmento ' + IntToStr(j) +
' de la poligonal especificada en el nodo ' + IntToStr(i));
end;
end
else begin
xo:=x2;
yo:=y2;
end;
end;
until sLista = '';
if Not(abierta) then begin
if Not(agregaPared(x2,y2,xo,yo)) then begin
agregaAErrores('Fue imposible agregar la pared que cierra la poligonal especificada en el nodo ' + IntToStr(i));
end;
end;
end;
end;
result:=true;
except
On E : Exception do begin
errMsg:='Error al cargar archivo de mundo (' + E.Message + ')';
end;
end;
end;
procedure TKMundo.limpiaErrores;
begin
_slErrores.Clear;
end;
procedure TKMundo.limpiaMundo;
var
i, j : integer;
begin
for i:=0 to ancho + 1 do
for j:=0 to alto + 1 do
_mundo[i,j].valor:=0;
end;
procedure TKMundo.setZumbadoresEnCoordenada(cX, cY: integer;
const Value: integer);
begin
if (cX > 0) and (cY > 0) and (cX <= ancho) and (cY <= alto) then begin
_mundo[cX,cY].zumbadores:=Value;
end;
end;
end.
|
{$IFDEF FPC}
{$MODE DELPHI}{$H+}
{$ENDIF}
unit cef_type;
{$ALIGN ON}
{$MINENUMSIZE 4}
{$I cef.inc}
interface
uses
Windows;
type
{$IFDEF UNICODE}
ustring = type string;
rbstring = type RawByteString;
{$ELSE}
{$IFDEF FPC}
{$if declared(unicodestring)}
ustring = type unicodestring;
{$else}
ustring = type WideString;
{$ifend}
{$ELSE}
ustring = type WideString;
{$ENDIF}
rbstring = type AnsiString;
{$ENDIF}
{$if not defined(uint64)}
uint64 = int64;
{$ifend}
TCefWindowHandle = {$IFDEF MACOS}Pointer{$ELSE}HWND{$ENDIF};
TCefCursorHandle = {$IFDEF MACOS}Pointer{$ELSE}HCURSOR{$ENDIF};
Char16 = WideChar;
PChar16 = PWideChar;
PCefStringWide = ^TCefStringWide;
TCefStringWide = record
str: PWideChar;
length: Cardinal;
dtor: procedure(str: PWideChar); stdcall;
end;
PCefStringUtf8 = ^TCefStringUtf8;
TCefStringUtf8 = record
str: PAnsiChar;
length: Cardinal;
dtor: procedure(str: PAnsiChar); stdcall;
end;
PCefStringUtf16 = ^TCefStringUtf16;
TCefStringUtf16 = record
str: PChar16;
length: Cardinal;
dtor: procedure(str: PChar16); stdcall;
end;
PCefStringUserFreeWide = ^TCefStringUserFreeWide;
TCefStringUserFreeWide = type TCefStringWide;
PCefStringUserFreeUtf8 = ^TCefStringUserFreeUtf8;
TCefStringUserFreeUtf8 = type TCefStringUtf8;
PCefStringUserFreeUtf16 = ^TCefStringUserFreeUtf16;
TCefStringUserFreeUtf16 = type TCefStringUtf16;
{$IFDEF CEF_STRING_TYPE_UTF8}
TCefChar = AnsiChar;
PCefChar = PAnsiChar;
TCefStringUserFree = TCefStringUserFreeUtf8;
PCefStringUserFree = PCefStringUserFreeUtf8;
TCefString = TCefStringUtf8;
PCefString = PCefStringUtf8;
{$ENDIF}
{$IFDEF CEF_STRING_TYPE_UTF16}
TCefChar = Char16;
PCefChar = PChar16;
TCefStringUserFree = TCefStringUserFreeUtf16;
PCefStringUserFree = PCefStringUserFreeUtf16;
TCefString = TCefStringUtf16;
PCefString = PCefStringUtf16;
{$ENDIF}
{$IFDEF CEF_STRING_TYPE_WIDE}
TCefChar = WideChar;
PCefChar = PWideChar;
TCefStringUserFree = TCefStringUserFreeWide;
PCefStringUserFree = PCefStringUserFreeWide;
TCefString = TCefStringWide;
PCefString = PCefStringWide;
{$ENDIF}
TCefStringMap = Pointer;
TCefStringMultimap = Pointer;
TCefStringList = Pointer;
TCefGraphicsImplementation = (
{$IFDEF MSWINDOWS}
ANGLE_IN_PROCESS,
ANGLE_IN_PROCESS_COMMAND_BUFFER,
{$ENDIF}
DESKTOP_IN_PROCESS,
DESKTOP_IN_PROCESS_COMMAND_BUFFER
);
PCefWindowInfo = ^TCefWindowInfo;
{$IFDEF MACOS}
TCefWindowInfo = record
m_windowName: TCefString;
m_x: Integer;
m_y: Integer;
m_nWidth: Integer;
m_nHeight: Integer;
m_bHidden: Integer;
m_ParentView: TCefWindowHandle;
m_View: TCefWindowHandle;
end;
{$ENDIF}
{$IFDEF MSWINDOWS}
TCefWindowInfo = record
ExStyle: DWORD;
windowName: TCefString;
Style: DWORD;
x: Integer;
y: Integer;
Width: Integer;
Height: Integer;
WndParent: HWND;
Menu: HMENU;
m_bWindowRenderingDisabled: BOOL;
m_bTransparentPainting: BOOL;
Wnd: HWND ;
end;
{$ENDIF}
TCefPrintInfo = record
{$IFDEF MSWINDOWS}
DC: HDC;
Rect: TRect;
{$ENDIF}
Scale: double;
end;
PCefKeyInfo = ^TCefKeyInfo;
TCefKeyInfo = record
key: Integer;
sysChar: BOOL;
imeChar: BOOL;
end;
// Log severity levels.
TCefLogSeverity = (
LOGSEVERITY_VERBOSE = -1,
LOGSEVERITY_INFO,
LOGSEVERITY_WARNING,
LOGSEVERITY_ERROR,
LOGSEVERITY_ERROR_REPORT,
// Disables logging completely.
LOGSEVERITY_DISABLE = 99
);
// Initialization settings. Specify NULL or 0 to get the recommended default
// values.
PCefSettings = ^TCefSettings;
TCefSettings = record
size: Cardinal;
multi_threaded_message_loop: Boolean;
cache_path: TCefString;
user_agent: TCefString;
product_version: TCefString;
locale: TCefString;
extra_plugin_paths: TCefStringList;
log_file: TCefString;
log_severity: TCefLogSeverity;
release_dcheck_enabled: Boolean;
graphics_implementation: TCefGraphicsImplementation;
local_storage_quota: Cardinal;
session_storage_quota: Cardinal;
javascript_flags: TCefString;
{$IFDEF MSWINDOWS}
auto_detect_proxy_settings_enabled: Boolean;
{$ENDIF}
resources_dir_path: TCefString;
locales_dir_path: TCefString;
pack_loading_disabled: Boolean;
uncaught_exception_stack_size: Integer;
context_safety_implementation: Integer;
end;
PCefBrowserSettings = ^TCefBrowserSettings;
TCefBrowserSettings = record
size: Cardinal;
drag_drop_disabled: Boolean;
load_drops_disabled: Boolean;
history_disabled: Boolean;
animation_frame_rate: Integer;
standard_font_family: TCefString;
fixed_font_family: TCefString;
serif_font_family: TCefString;
sans_serif_font_family: TCefString;
cursive_font_family: TCefString;
fantasy_font_family: TCefString;
default_font_size: Integer;
default_fixed_font_size: Integer;
minimum_font_size: Integer;
minimum_logical_font_size: Integer;
remote_fonts_disabled: Boolean;
default_encoding: TCefString;
encoding_detector_enabled: Boolean;
javascript_disabled: Boolean;
javascript_open_windows_disallowed: Boolean;
javascript_close_windows_disallowed: Boolean;
javascript_access_clipboard_disallowed: Boolean;
dom_paste_disabled: Boolean;
caret_browsing_enabled: Boolean;
java_disabled: Boolean;
plugins_disabled: Boolean;
universal_access_from_file_urls_allowed: Boolean;
file_access_from_file_urls_allowed: Boolean;
web_security_disabled: Boolean;
xss_auditor_enabled: Boolean;
image_load_disabled: Boolean;
shrink_standalone_images_to_fit: Boolean;
site_specific_quirks_disabled: Boolean;
text_area_resize_disabled: Boolean;
page_cache_disabled: Boolean;
tab_to_links_disabled: Boolean;
hyperlink_auditing_disabled: Boolean;
user_style_sheet_enabled: Boolean;
user_style_sheet_location: TCefString;
author_and_user_styles_disabled: Boolean;
local_storage_disabled: Boolean;
databases_disabled: Boolean;
application_cache_disabled: Boolean;
webgl_disabled: Boolean;
accelerated_compositing_enabled: Boolean;
accelerated_layers_disabled: Boolean;
accelerated_2d_canvas_disabled: Boolean;
accelerated_painting_disabled: Boolean;
accelerated_filters_disabled: Boolean;
accelerated_plugins_disabled: Boolean;
developer_tools_disabled: Boolean;
fullscreen_enabled: Boolean;
end;
PCefUrlParts = ^TCefUrlParts;
TCefUrlParts = record
spec: TCefString;
scheme: TCefString;
username: TCefString;
password: TCefString;
host: TCefString;
port: TCefString;
path: TCefString;
query: TCefString;
end;
PCefTime = ^TCefTime;
TCefTime = record
year: Integer; // Four digit year "2007"
month: Integer; // 1-based month (values 1 = January, etc.)
day_of_week: Integer; // 0-based day of week (0 = Sunday, etc.)
day_of_month: Integer; // 1-based day of month (1-31)
hour: Integer; // Hour within the current day (0-23)
minute: Integer; // Minute within the current hour (0-59)
second: Integer; // Second within the current minute (0-59 plus leap
// seconds which may take it up to 60).
millisecond: Integer; // Milliseconds within the current second (0-999)
end;
TCefCookie = record
name: TCefString;
value: TCefString;
domain: TCefString;
path: TCefString;
secure: Boolean;
httponly: Boolean;
creation: TCefTime;
last_access: TCefTime;
has_expires: Boolean;
expires: TCefTime;
end;
TCefStorageType = (
ST_LOCALSTORAGE = 0,
ST_SESSIONSTORAGE
);
TCefMouseButtonType = (
MBT_LEFT = 0,
MBT_MIDDLE,
MBT_RIGHT
);
TCefKeyType = (
KT_KEYUP = 0,
KT_KEYDOWN,
KT_CHAR
);
TCefHandlerNavtype = (
NAVTYPE_LINKCLICKED = 0,
NAVTYPE_FORMSUBMITTED,
NAVTYPE_BACKFORWARD,
NAVTYPE_RELOAD,
NAVTYPE_FORMRESUBMITTED,
NAVTYPE_OTHER,
NAVTYPE_LINKDROPPED
);
TCefHandlerErrorcode = Integer;
const
ERR_FAILED = -2;
ERR_ABORTED = -3;
ERR_INVALID_ARGUMENT = -4;
ERR_INVALID_HANDLE = -5;
ERR_FILE_NOT_FOUND = -6;
ERR_TIMED_OUT = -7;
ERR_FILE_TOO_BIG = -8;
ERR_UNEXPECTED = -9;
ERR_ACCESS_DENIED = -10;
ERR_NOT_IMPLEMENTED = -11;
ERR_CONNECTION_CLOSED = -100;
ERR_CONNECTION_RESET = -101;
ERR_CONNECTION_REFUSED = -102;
ERR_CONNECTION_ABORTED = -103;
ERR_CONNECTION_FAILED = -104;
ERR_NAME_NOT_RESOLVED = -105;
ERR_INTERNET_DISCONNECTED = -106;
ERR_SSL_PROTOCOL_ERROR = -107;
ERR_ADDRESS_INVALID = -108;
ERR_ADDRESS_UNREACHABLE = -109;
ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110;
ERR_TUNNEL_CONNECTION_FAILED = -111;
ERR_NO_SSL_VERSIONS_ENABLED = -112;
ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113;
ERR_SSL_RENEGOTIATION_REQUESTED = -114;
ERR_CERT_COMMON_NAME_INVALID = -200;
ERR_CERT_DATE_INVALID = -201;
ERR_CERT_AUTHORITY_INVALID = -202;
ERR_CERT_CONTAINS_ERRORS = -203;
ERR_CERT_NO_REVOCATION_MECHANISM = -204;
ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205;
ERR_CERT_REVOKED = -206;
ERR_CERT_INVALID = -207;
ERR_CERT_END = -208;
ERR_INVALID_URL = -300;
ERR_DISALLOWED_URL_SCHEME = -301;
ERR_UNKNOWN_URL_SCHEME = -302;
ERR_TOO_MANY_REDIRECTS = -310;
ERR_UNSAFE_REDIRECT = -311;
ERR_UNSAFE_PORT = -312;
ERR_INVALID_RESPONSE = -320;
ERR_INVALID_CHUNKED_ENCODING = -321;
ERR_METHOD_NOT_SUPPORTED = -322;
ERR_UNEXPECTED_PROXY_AUTH = -323;
ERR_EMPTY_RESPONSE = -324;
ERR_RESPONSE_HEADERS_TOO_BIG = -325;
ERR_CACHE_MISS = -400;
ERR_INSECURE_RESPONSE = -501;
type
TCefDragOperations = Integer;
const
DRAG_OPERATION_NONE = 0;
DRAG_OPERATION_COPY = 1;
DRAG_OPERATION_LINK = 2;
DRAG_OPERATION_GENERIC = 4;
DRAG_OPERATION_PRIVATE = 8;
DRAG_OPERATION_MOVE = 16;
DRAG_OPERATION_DELETE = 32;
DRAG_OPERATION_EVERY = $FFFFFFFF;
type
TCefV8AccessControls = Integer;
const
V8_ACCESS_CONTROL_DEFAULT = 0;
V8_ACCESS_CONTROL_ALL_CAN_READ = 1;
V8_ACCESS_CONTROL_ALL_CAN_WRITE = 1 shl 1;
V8_ACCESS_CONTROL_PROHIBITS_OVERWRITING = 1 shl 2;
type
TCefV8PropertyAttributes = Integer;
const
V8_PROPERTY_ATTRIBUTE_NONE = 0; // Writeable, Enumerable, Configurable
V8_PROPERTY_ATTRIBUTE_READONLY = 1 shl 0; // Not writeable
V8_PROPERTY_ATTRIBUTE_DONTENUM = 1 shl 1; // Not enumerable
V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 shl 2; // Not configurable
type
// Structure representing menu information.
TCefMenuInfo = record
// Values from the cef_handler_menutypebits_t enumeration.
typeFlags: Integer;
x: Integer;
y: Integer;
linkUrl: TCefString;
imageUrl: TCefString;
pageUrl: TCefString;
frameUrl: TCefString;
selectionText: TCefString;
misspelledWord: TCefString;
// Values from the cef_handler_menucapabilitybits_t enumeration
editFlags: Integer;
securityInfo: TCefString;
end;
// The TCefMenuInfo typeFlags value will be a combination of the
// following values.
TCefMenuTypeBits = Integer;
const
MENUTYPE_NONE = $0;
MENUTYPE_PAGE = $1;
MENUTYPE_FRAME = $2;
MENUTYPE_LINK = $4;
MENUTYPE_IMAGE = $8;
MENUTYPE_SELECTION = $10;
MENUTYPE_EDITABLE = $20;
MENUTYPE_MISSPELLED_WORD = $40;
MENUTYPE_VIDEO = $80;
MENUTYPE_AUDIO = $100;
type
// The TCefMenuInfo editFlags value will be a combination of the
// following values.
TCefMenuCapabilityBits = Integer;
const
// Values from WebContextMenuData::EditFlags in WebContextMenuData.h
MENU_CAN_DO_NONE = $0;
MENU_CAN_UNDO = $1;
MENU_CAN_REDO = $2;
MENU_CAN_CUT = $4;
MENU_CAN_COPY = $8;
MENU_CAN_PASTE = $10;
MENU_CAN_DELETE = $20;
MENU_CAN_SELECT_ALL = $40;
MENU_CAN_TRANSLATE = $80;
// Values unique to CEF
MENU_CAN_GO_FORWARD = $10000000;
MENU_CAN_GO_BACK = $20000000;
type
// Supported menu ID values.
TCefMenuId = (
MENU_ID_NAV_BACK = 10,
MENU_ID_NAV_FORWARD = 11,
MENU_ID_NAV_RELOAD = 12,
MENU_ID_NAV_RELOAD_NOCACHE = 13,
MENU_ID_NAV_STOP = 14,
MENU_ID_UNDO = 20,
MENU_ID_REDO = 21,
MENU_ID_CUT = 22,
MENU_ID_COPY = 23,
MENU_ID_PASTE = 24,
MENU_ID_DELETE = 25,
MENU_ID_SELECTALL = 26,
MENU_ID_PRINT = 30,
MENU_ID_VIEWSOURCE = 31
);
TCefPaintElementType = (
PET_VIEW = 0,
PET_POPUP
);
// Post data elements may represent either bytes or files.
TCefPostDataElementType = (
PDE_TYPE_EMPTY = 0,
PDE_TYPE_BYTES,
PDE_TYPE_FILE
);
type
TCefWebUrlRequestFlags = Integer;
const
WUR_FLAG_NONE = 0;
WUR_FLAG_SKIP_CACHE = $1;
WUR_FLAG_ALLOW_CACHED_CREDENTIALS = $2;
WUR_FLAG_ALLOW_COOKIES = $4;
WUR_FLAG_REPORT_UPLOAD_PROGRESS = $8;
WUR_FLAG_REPORT_LOAD_TIMING = $10;
WUR_FLAG_REPORT_RAW_HEADERS = $20;
type
TCefWebUrlRequestState = (
WUR_STATE_UNSENT = 0,
WUR_STATE_STARTED = 1,
WUR_STATE_HEADERS_RECEIVED = 2,
WUR_STATE_LOADING = 3,
WUR_STATE_DONE = 4,
WUR_STATE_ERROR = 5,
WUR_STATE_ABORT = 6
);
// Focus sources.
TCefHandlerFocusSource = (
// The source is explicit navigation via the API (LoadURL(), etc).
FOCUS_SOURCE_NAVIGATION = 0,
// The source is a system-generated focus event.
FOCUS_SOURCE_SYSTEM,
// The source is a child widget of the browser window requesting focus.
FOCUS_SOURCE_WIDGET
);
// Key event types.
TCefHandlerKeyEventType = (
KEYEVENT_RAWKEYDOWN = 0,
KEYEVENT_KEYDOWN,
KEYEVENT_KEYUP,
KEYEVENT_CHAR
);
// Key event modifiers.
TCefHandlerKeyEventModifiers = Integer;
const
KEY_SHIFT = 1 shl 0;
KEY_CTRL = 1 shl 1;
KEY_ALT = 1 shl 2;
KEY_META = 1 shl 3;
KEY_KEYPAD = 1 shl 4; // Only used on Mac OS-X
type
// Structure representing a rectangle.
PCefRect = ^TCefRect;
TCefRect = record
x: Integer;
y: Integer;
width: Integer;
height: Integer;
end;
TCefRectArray = array[0..(High(Integer) div SizeOf(TCefRect))-1] of TCefRect;
PCefRectArray = ^TCefRectArray;
// Existing thread IDs.
TCefThreadId = (
TID_UI = 0,
TID_IO = 1,
TID_FILE = 2
);
// Paper type for printing.
TCefPaperType = (
PT_LETTER = 0,
PT_LEGAL,
PT_EXECUTIVE,
PT_A3,
PT_A4,
PT_CUSTOM
);
// Paper metric information for printing.
TCefPaperMetrics = record
paper_type: TCefPaperType;
//Length and width needed if paper_type is custom_size
//Units are in inches.
length: Double;
width: Double;
end;
// Paper print margins.
TCefPrintMargins = record
//Margin size in inches for left/right/top/bottom (this is content margins).
left: Double;
right: Double;
top: Double;
bottom: Double;
//Margin size (top/bottom) in inches for header/footer.
header: Double;
footer: Double;
end;
// Page orientation for printing
TCefPageOrientation = (
PORTRAIT = 0,
LANDSCAPE
);
// Printing options.
PCefPrintOptions = ^TCefPrintOptions;
TCefPrintOptions = record
page_orientation: TCefPageOrientation;
paper_metrics: TCefPaperMetrics;
paper_margins: TCefPrintMargins;
end;
TCefXmlEncodingType = (
XML_ENCODING_NONE = 0,
XML_ENCODING_UTF8,
XML_ENCODING_UTF16LE,
XML_ENCODING_UTF16BE,
XML_ENCODING_ASCII
);
// XML node types.
TCefXmlNodeType = (
XML_NODE_UNSUPPORTED = 0,
XML_NODE_PROCESSING_INSTRUCTION,
XML_NODE_DOCUMENT_TYPE,
XML_NODE_ELEMENT_START,
XML_NODE_ELEMENT_END,
XML_NODE_ATTRIBUTE,
XML_NODE_TEXT,
XML_NODE_CDATA,
XML_NODE_ENTITY_REFERENCE,
XML_NODE_WHITESPACE,
XML_NODE_COMMENT
);
// Status message types.
TCefHandlerStatusType = (
STATUSTYPE_TEXT = 0,
STATUSTYPE_MOUSEOVER_URL,
STATUSTYPE_KEYBOARD_FOCUS_URL
);
// Popup window features.
PCefPopupFeatures = ^TCefPopupFeatures;
TCefPopupFeatures = record
x: Integer;
xSet: Boolean;
y: Integer;
ySet: Boolean;
width: Integer;
widthSet: Boolean;
height: Integer;
heightSet: Boolean;
menuBarVisible: Boolean;
statusBarVisible: Boolean;
toolBarVisible: Boolean;
locationBarVisible: Boolean;
scrollbarsVisible: Boolean;
resizable: Boolean;
fullscreen: Boolean;
dialog: Boolean;
additionalFeatures: TCefStringList;
end;
// DOM document types.
TCefDomDocumentType = (
DOM_DOCUMENT_TYPE_UNKNOWN = 0,
DOM_DOCUMENT_TYPE_HTML,
DOM_DOCUMENT_TYPE_XHTML,
DOM_DOCUMENT_TYPE_PLUGIN
);
// DOM event category flags.
TCefDomEventCategory = Integer;
const
DOM_EVENT_CATEGORY_UNKNOWN = $0;
DOM_EVENT_CATEGORY_UI = $1;
DOM_EVENT_CATEGORY_MOUSE = $2;
DOM_EVENT_CATEGORY_MUTATION = $4;
DOM_EVENT_CATEGORY_KEYBOARD = $8;
DOM_EVENT_CATEGORY_TEXT = $10;
DOM_EVENT_CATEGORY_COMPOSITION = $20;
DOM_EVENT_CATEGORY_DRAG = $40;
DOM_EVENT_CATEGORY_CLIPBOARD = $80;
DOM_EVENT_CATEGORY_MESSAGE = $100;
DOM_EVENT_CATEGORY_WHEEL = $200;
DOM_EVENT_CATEGORY_BEFORE_TEXT_INSERTED = $400;
DOM_EVENT_CATEGORY_OVERFLOW = $800;
DOM_EVENT_CATEGORY_PAGE_TRANSITION = $1000;
DOM_EVENT_CATEGORY_POPSTATE = $2000;
DOM_EVENT_CATEGORY_PROGRESS = $4000;
DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS = $8000;
DOM_EVENT_CATEGORY_WEBKIT_ANIMATION = $10000;
DOM_EVENT_CATEGORY_WEBKIT_TRANSITION = $20000;
DOM_EVENT_CATEGORY_BEFORE_LOAD = $40000;
type
// DOM event processing phases.
TCefDomEventPhase = (
DOM_EVENT_PHASE_UNKNOWN = 0,
DOM_EVENT_PHASE_CAPTURING,
DOM_EVENT_PHASE_AT_TARGET,
DOM_EVENT_PHASE_BUBBLING
);
// DOM node types.
TCefDomNodeType = (
DOM_NODE_TYPE_UNSUPPORTED = 0,
DOM_NODE_TYPE_ELEMENT,
DOM_NODE_TYPE_ATTRIBUTE,
DOM_NODE_TYPE_TEXT,
DOM_NODE_TYPE_CDATA_SECTION,
DOM_NODE_TYPE_ENTITY_REFERENCE,
DOM_NODE_TYPE_ENTITY,
DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS,
DOM_NODE_TYPE_COMMENT,
DOM_NODE_TYPE_DOCUMENT,
DOM_NODE_TYPE_DOCUMENT_TYPE,
DOM_NODE_TYPE_DOCUMENT_FRAGMENT,
DOM_NODE_TYPE_NOTATION,
DOM_NODE_TYPE_XPATH_NAMESPACE
);
// Proxy types.
TCefProxyType = (
CEF_PROXY_TYPE_DIRECT = 0,
CEF_PROXY_TYPE_NAMED,
CEF_PROXY_TYPE_PAC_STRING
);
// Proxy information.
TCefProxyInfo = record
proxyType: TCefProxyType;
proxyList: TCefString;
end;
// Geoposition error codes.
TCefGeopositionErrorCode = (
GEOPOSITON_ERROR_NONE = 0,
GEOPOSITON_ERROR_PERMISSION_DENIED,
GEOPOSITON_ERROR_POSITION_UNAVAILABLE,
GEOPOSITON_ERROR_TIMEOUT
);
TCefGeoposition = record
latitude: Double;
longitude: Double;
altitude: Double;
accuracy: Double;
altitude_accuracy: Double;
heading: Double;
speed: Double;
timestamp: TCefTime;
error_code: TCefGeopositionErrorCode;
error_message: TCefString;
end;
implementation
end.
|
(*============================================================================
-----BEGIN PGP SIGNED MESSAGE-----
This code (c) 1994, 1997 Graham THE Ollis
GENERAL NOTES
=============
This is 16bit DOS TURBO PASCAL source code. It has been tested using
TURBO PASCAL 7.0. You will need AT LEAST version 5.0 to compile this
source code. You may need 7.0.
This is a generic pascal header for all my old pascal programs. Most of
these programs were written before I really got excited enough about 32bit
operating systems. In general this code dates back to 1994. Some of it
is important enough that I still work on it. For the most part though,
it's not the best code and it's probably the worst example of
documentation in all of computer science. oh well, you've been warned.
PGP NOTES
=========
This PGP signed message is provided in the hopes that it will prove useful
and informative. My name is Graham THE Ollis <ollisg@ns.arizona.edu> and my
public PGP key can be found by fingering my university account:
finger ollisg@u.arizona.edu
LEGAL NOTES
===========
You are free to use, modify and distribute this source code provided these
headers remain in tact. If you do make modifications to these programs,
i'd appreciate it if you documented your changes and leave some contact
information so that others can blame you and me, rather than just me.
If you maintain a anonymous ftp site or bbs feel free to archive this
stuff away. If your pressing CDs for commercial purposes again have fun.
It would be nice if you let me know about it though.
HOWEVER- there is no written or implied warranty. If you don't trust this
code then delete it NOW. I will in no way be held responsible for any
losses incurred by your using this software.
CONTACT INFORMATION
===================
You may contact me for just about anything relating to this code through
e-mail. Please put something in the subject line about the program you
are working with. The source file would be best in this case (e.g.
frag.pas, hexed.pas ... etc)
ollisg@ns.arizona.edu
ollisg@idea-bank.com
ollisg@lanl.gov
The first address is the most likely to work.
all right. that all said... HAVE FUN!
-----BEGIN PGP SIGNATURE-----
Version: 2.6.2
iQCVAwUBMv1UFoazF2irQff1AQFYNgQAhjiY/Dh3gSpk921FQznz4FOwqJtAIG6N
QTBdR/yQWrkwHGfPTw9v8LQHbjzl0jjYUDKR9t5KB7vzFjy9q3Y5lVHJaaUAU4Jh
e1abPhL70D/vfQU3Z0R+02zqhjfsfKkeowJvKNdlqEe1/kSCxme9mhJyaJ0CDdIA
40nefR18NrA=
=IQEZ
-----END PGP SIGNATURE-----
==============================================================================
| header.pas
| this is the eqivalent to a .h file in C. it contains all the global
| definitions that are important to everything. what a mess.
|
| History:
| Date Author Comment
| ---- ------ -------
| -- --- 94 G. Ollis created and developed program
============================================================================*)
{$I-}
Unit Header;
INTERFACE
Uses
CRT,ChFile;
Type
ConfigerationType=Record
Case Boolean Of
TRUE :
(Highlight,Lolight,Numbers,InputColor:Byte;
HelpWindow,HelpColor:Byte;
StatusVer,StatusFN,StatusSave,StatusMid:Byte;
Error:Byte;
MsgColor,MsgLolight,MsgChoice:Byte;
BOF_Color,EOF_Color,Block_Color:Byte;
MenuLolight,MenuHilight,MenuDisab:Byte);
FALSE : (ByteArr:Array [1..20] of Byte)
End;
MacroIndex=Record
Num:Byte;
Data:Array [1..$FF] of Byte;
Name:String[20];
End;
MacroType=Array [0..9] of MacroIndex;
Const
versionnumber='1.60'; {stores the version number so I only have to
change it in one place}
Var
ICFG:ConfigerationType;
Type
FormatType=String[10];
Const
BlockColor=Cyan;
Bookend=300; (* number of bytes we will be sure to stay away
from either side of the image*)
imagesize=$FFFF; {maximum size of file that HEXED can edit/view}
(* size of the buffer used in file viewing/editing*)
maxlong=$7FFFFFFF; (* maximum value for a longint, maximum file size
for hexed (in theory)*)
helpfile='HEXED.HLP'; {name of the help file (text format)}
MaxHelp=84; {maximum number of lines in the help file}
HelpY1=12; {location of help window}
HelpY2=24;
DataOffSet=11; {format for displaying location numbers}
NumberOfFileTypes=14;
BinFileType:Array[1..NumberOfFileTypes] Of FormatType=
('NONE','PCX','PAL/COL','CMF','SBI','GIF','VOC','IMG','MOD31',
'MOD15','IBK','FLI','FRAGMENT','EXE');
NumberOfExeTypes=13;
ExeFileType:Array [0..NumberofExeTypes] Of FormatType
=('old','new','bor','arj','lz90',
'lz91','pkl','lharc','lha',
'ts','pka','bsa','larc','lh');
{
HEXED supports the folowing files for byte determination and/or formated
viewing
NONE raw
PCX graphics byte id formated view
PAL/COL palette byte id formated view
*CMF FM music byte id formated view
SBI FM instrument byte id formated view
GIF graphics byte id formated view
**VOC digitized sample byte id formated view
IMG graphics byte id formated view
MOD digitized music byte id
IBK FM instruments byte id formated view
FLI movie/flick byte id
Fxx fragment byte id
EXE executable
* requires SMFMDRV.COM to be loaded
** requires a voice driver in some place where HEXED can find it
}
Type
ExeData=Record
Tp:Integer;
NumRlc:Word;
OffRlc:Word;
HeadSize:LongInt;
End;
binaryimage=Array [1..imagesize] of Byte;
{type for storage of the binary file}
binaryImagePointer=^binaryImage;
{TP doesn't let me use a plain old static array
for this (It'd be to large), so I used a pointer}
strtype=String[78]; {for file name and convinence}
DataType=Record
D:binaryImagePointer; (*this record stores all important information *)
FN:StrType; (*about the file in memory*)
EOF:LongInt;
X:LongInt;
changes:Boolean;
stream:File;
offset:LongInt; (* where the in memory segment is relative to
the file beginning *)
BlockStart,
BlockFinish:LongInt; (* for the block commands (^K) *)
BFT:Byte; {formated file type (.PAL,.GIF,.CMF etc.)}
ED:ExeData;
FragOffset:Word;
End;
HelpString=String[78];
HelpType=Record
Y:Integer;
S:Array [1..MaxHelp] Of HelpString;
End;
HelpPointer=^HelpType; {These two types store the help file for on-line
access}
Var
viewMode:Byte; {how many rows should HEXED display?}
Paused:Boolean; {is the secondary file paused (not moving)}
Secondary:^DataType; {storage for secondary file}
AutomaticTUse:Boolean; {for the 'p' button}
{pointer to the Commands() proceure so that it
can be called from above it in the file}
FilePath:MaskString; {string containing "*.*" or what ever the last
load wildcard was.}
SearchFor:String[36]; {For Text Searches}
{For Binary Array Searches}
Const
ArrayLength=19;
Var
FArray:Array [1..ArrayLength] Of Byte;
NumElement:Byte;
CurrentElement:Byte;
{For the Byte Editor (On the binary level)}
Const
Bit1=$01;
Bit2=$02;
Bit3=$04;
Bit4=$08;
Bit5=$10;
Bit6=$20;
Bit7=$40;
Bit8=$80;
Bit:Array[1..8] Of Byte=(Bit1,Bit2,Bit3,Bit4,Bit5,Bit6,Bit7,Bit8);
OctDigit1=$07;
OctDigit2=$38;
OctDigit3=$B0;
{For Multi Type Output}
Type
MultType=Record
Case Byte Of
0 : (S:ShortInt);
1 : (I:Integer);
2 : (L:LongInt);
3 : (R:Real);
4 : (Si:Single);
5 : (D:Double);
6 : (E:Extended);
7 : (C:Comp);
End;
{Mouse Input}
Var
I,N:Word;
C1,C2:Char;
{See Byte2Bin Function}
Type
BinString=String[9];
{Help and File Vars}
Var
Data:DataType;
Hp:HelpPointer;
{Default Edit Hex}
DefVarEd:Integer;
Const
DefHex=0;
DefDec=1;
{StringEdit() Types/Constants}
Type
CharacterSet=Set of Char;
Const
FileSet:CharacterSet= ['A'..'Z',
'a'..'z',
'0'..'9',
'!'..'$',
'^'..'*',
'-','.',
'\',':'];
NormSet:CharacterSet= [' '..'~'];
NumSet:CharacterSet= ['0'..'9','$','A'..'F','a'..'f','-'];
{Alternate View Mode}
Var
AltMode:Integer;
Const
StdMode=0;
Byte4Mode=1;
ThirdView=2;
IMPLEMENTATION
Begin
DefVarEd:=DefHex;
AltMode:=StdMode;
End.
|
unit TSTOSbtp.Bin;
interface
Uses Windows, HsStreamEx, TSTOSbtpIntf;
Type
IBinSbtpSubVariable = Interface(ISbtpSubVariable)
['{4B61686E-29A0-2112-91BD-618FC563E57D}']
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
End;
IBinSbtpSubVariables = Interface(ISbtpSubVariables)
['{4B61686E-29A0-2112-AD5D-BDA0707E79C0}']
Function Get(Index : Integer) : IBinSbtpSubVariable;
Procedure Put(Index : Integer; Const Item : IBinSbtpSubVariable);
Function Add() : IBinSbtpSubVariable; OverLoad;
Function Add(Const AItem : IBinSbtpSubVariable) : Integer; OverLoad;
Property Items[Index : Integer] : IBinSbtpSubVariable Read Get Write Put; Default;
End;
IBinSbtpVariable = Interface(ISbtpVariable)
['{4B61686E-29A0-2112-B4F0-E9282D0EBD3D}']
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Function GetSubItem() : IBinSbtpSubVariables;
Property SubItem : IBinSbtpSubVariables Read GetSubItem;
End;
IBinSbtpVariables = Interface(ISbtpVariables)
['{4B61686E-29A0-2112-9B6F-61BCC5656B3F}']
Function Get(Index : Integer) : IBinSbtpVariable;
Procedure Put(Index : Integer; Const Item : IBinSbtpVariable);
Function Add() : IBinSbtpVariable; OverLoad;
Function Add(Const AItem : IBinSbtpVariable) : Integer; OverLoad;
Property Items[Index : Integer] : IBinSbtpVariable Read Get Write Put; Default;
End;
IBinSbtpHeader = Interface(ISbtpHeader)
['{4B61686E-29A0-2112-9F36-1A81FBE06C31}']
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
End;
IBinSbtpFile = Interface(ISbtpFile)
['{4B61686E-29A0-2112-A562-E106D9FBFE45}']
Function GetHeader() : IBinSbtpHeader;
Function GetItem() : IBinSbtpVariables;
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property Header : IBinSbtpHeader Read GetHeader;
Property Item : IBinSbtpVariables Read GetItem;
End;
IBinSbtpFiles = Interface(ISbtpFiles)
['{4B61686E-29A0-2112-6969-6CC05ECFA921}']
Function Get(Index : Integer) : IBinSbtpFile;
Procedure Put(Index : Integer; Const Item : IBinSbtpFile);
Function Add() : IBinSbtpFile; OverLoad;
Function Add(Const AItem : IBinSbtpFile) : Integer; OverLoad;
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property Items[Index : Integer] : IBinSbtpFile Read Get Write Put; Default;
End;
TBinSbtpFile = Class(TObject)
Public
Class Function CreateSbtpFile() : IBinSbtpFile; OverLoad;
Class Function CreateSbtpFile(AStream : IStreamEx) : IBinSbtpFile; OverLoad;
Class Function CreateSbtpFiles() : IBinSbtpFiles;
End;
implementation
Uses Forms, HsInterfaceEx, TSTOSbtpImpl;
Type
TBinSbtpSubVariable = Class(TSbtpSubVariable, IBinSbtpSubVariable)
Protected
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property VariableName : String Read GetVariableName Write SetVariableName;
Property VariableData : String Read GetVariableData Write SetVariableData;
End;
TBinSbtpSubVariables = Class(TSbtpSubVariables, IBinSbtpSubVariables)
Protected
Function GetItemClass() : TInterfacedObjectExClass; OverRide;
Function Get(Index : Integer) : IBinSbtpSubVariable; OverLoad;
Procedure Put(Index : Integer; Const Item : IBinSbtpSubVariable); OverLoad;
Function Add() : IBinSbtpSubVariable; OverLoad;
Function Add(Const AItem : IBinSbtpSubVariable) : Integer; OverLoad;
End;
TBinSbtpVariable = Class(TSbtpVariable, IBinSbtpVariable)
Protected
Function GetSubItem() : IBinSbtpSubVariables; OverLoad;
Function GetSubItemClass() : TSbtpSubVariablesClass; OverRide;
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property VariableType : String Read GetVariableType Write SetVariableType;
Property NbSubItems : DWord Read GetNbSubItems;
Property SubItem : IBinSbtpSubVariables Read GetSubItem;
End;
TBinSbtpVariables = Class(TSbtpVariables, IBinSbtpVariables)
Protected
Function GetItemClass() : TInterfacedObjectExClass; OverRide;
Function Get(Index : Integer) : IBinSbtpVariable; OverLoad;
Procedure Put(Index : Integer; Const Item : IBinSbtpVariable); OverLoad;
Function Add() : IBinSbtpVariable; OverLoad;
Function Add(Const AItem : IBinSbtpVariable) : Integer; OverLoad;
End;
TBinSbtpHeader = Class(TSbtpHeader, IBinSbtpHeader)
Private
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property Header : String Read GetHeader Write SetHeader;
Property HeaderPadding : Word Read GetHeaderPadding Write SetHeaderPadding;
End;
TBinSbtpFileImpl = Class(TSbtpFile, IBinSbtpFile)
Protected
Function GetHeader() : IBinSbtpHeader; OverLoad;
Function GetHeaderClass() : TSbtpHeaderClass; OverRide;
Function GetItem() : IBinSbtpVariables; OverLoad;
Function GetItemClass() : TSbtpVariablesClass; OverRide;
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
Property Header : IBinSbtpHeader Read GetHeader;
Property Item : IBinSbtpVariables Read GetItem;
End;
TBinSbtpFilesImpl = Class(TSbtpFiles, IBinSbtpFiles)
Protected
Function GetItemClass() : TInterfacedObjectExClass; OverRide;
Function Get(Index : Integer) : IBinSbtpFile; OverLoad;
Procedure Put(Index : Integer; Const Item : IBinSbtpFile); OverLoad;
Function Add() : IBinSbtpFile; OverLoad;
Function Add(Const AItem : IBinSbtpFile) : Integer; OverLoad;
Procedure LoadFromStream(ASource : IStreamEx);
Procedure SaveToStream(ATarget : IStreamEx);
End;
Class Function TBinSbtpFile.CreateSbtpFile() : IBinSbtpFile;
Begin
Result := TBinSbtpFileImpl.Create();
End;
Class Function TBinSbtpFile.CreateSbtpFile(AStream : IStreamEx) : IBinSbtpFile;
Begin
Result := TBinSbtpFileImpl.Create();
With KeepStreamPosition(AStream, 0) Do
Result.LoadFromStream(AStream);
End;
Class Function TBinSbtpFile.CreateSbtpFiles() : IBinSbtpFiles;
Begin
Result := TBinSbtpFilesImpl.Create();
End;
(******************************************************************************)
Procedure TBinSbtpSubVariable.LoadFromStream(ASource : IStreamEx);
Begin
VariableName := ASource.ReadAnsiString();
VariableData := ASource.ReadAnsiString(SizeOf(DWord), True);
End;
Procedure TBinSbtpSubVariable.SaveToStream(ATarget : IStreamEx);
Begin
ATarget.WriteAnsiString(VariableName);
ATarget.WriteAnsiString(VariableData, True, SizeOf(DWord), True);
End;
Function TBinSbtpSubVariables.GetItemClass() : TInterfacedObjectExClass;
Begin
Result := TBinSbtpSubVariable;
End;
Function TBinSbtpSubVariables.Get(Index : Integer) : IBinSbtpSubVariable;
Begin
Result := InHerited Items[Index] As IBinSbtpSubVariable;
End;
Procedure TBinSbtpSubVariables.Put(Index : Integer; Const Item : IBinSbtpSubVariable);
Begin
InHerited Items[Index] := Item;
End;
Function TBinSbtpSubVariables.Add() : IBinSbtpSubVariable;
Begin
Result := InHerited Add() As IBinSbtpSubVariable;
End;
Function TBinSbtpSubVariables.Add(Const AItem : IBinSbtpSubVariable) : Integer;
Begin
Result := InHerited Add(AItem);
End;
Function TBinSbtpVariable.GetSubItem() : IBinSbtpSubVariables;
Begin
Result := InHerited GetSubItem() As IBinSbtpSubVariables;
End;
Function TBinSbtpVariable.GetSubItemClass() : TSbtpSubVariablesClass;
Begin
Result := TBinSbtpSubVariables;
End;
Procedure TBinSbtpVariable.LoadFromStream(ASource : IStreamEx);
Var lNbSubItems : DWord;
Begin
VariableType := ASource.ReadAnsiString();
lNbSubItems := ASource.ReadDWord(True);
While lNbSubItems > 0 Do
Begin
SubItem.Add().LoadFromStream(ASource);
Application.ProcessMessages();
Dec(lNbSubItems)
End;
End;
Procedure TBinSbtpVariable.SaveToStream(ATarget : IStreamEx);
Var X : Integer;
Begin
ATarget.WriteAnsiString(VariableType);
ATarget.WriteDWord(SubItem.Count, True);
For X := 0 To SubItem.Count - 1 Do
SubItem[X].SaveToStream(ATarget);
End;
Function TBinSbtpVariables.GetItemClass() : TInterfacedObjectExClass;
Begin
Result := TBinSbtpVariable;
End;
Function TBinSbtpVariables.Get(Index : Integer) : IBinSbtpVariable;
Begin
Result := InHerited Items[Index] As IBinSbtpVariable;
End;
Procedure TBinSbtpVariables.Put(Index : Integer; Const Item : IBinSbtpVariable);
Begin
InHerited Items[Index] := Item;
End;
Function TBinSbtpVariables.Add() : IBinSbtpVariable;
Begin
Result := InHerited Add() As IBinSbtpVariable;
End;
Function TBinSbtpVariables.Add(Const AItem : IBinSbtpVariable) : Integer;
Begin
Result := InHerited Add(AItem);
End;
Procedure TBinSbtpHeader.LoadFromStream(ASource : IStreamEx);
Begin
Header := ASource.ReadAnsiString(4);
HeaderPadding := ASource.ReadWord(True);
End;
Procedure TBinSbtpHeader.SaveToStream(ATarget : IStreamEx);
Begin
ATarget.WriteAnsiString(Header, False);
ATarget.WriteWord(HeaderPadding, True);
End;
Function TBinSbtpFileImpl.GetHeaderClass() : TSbtpHeaderClass;
Begin
Result := TBinSbtpHeader;
End;
Function TBinSbtpFileImpl.GetItemClass() : TSbtpVariablesClass;
Begin
Result := TBinSbtpVariables;
End;
Function TBinSbtpFileImpl.GetHeader() : IBinSbtpHeader;
Begin
Result := InHerited GetHeader() As IBinSbtpHeader;
End;
Function TBinSbtpFileImpl.GetItem() : IBinSbtpVariables;
Begin
Result := InHerited GetItem() As IBinSbtpVariables;
End;
Procedure TBinSbtpFileImpl.LoadFromStream(ASource : IStreamEx);
Begin
Clear();
Header.LoadFromStream(ASource);
Repeat
Item.Add().LoadFromStream(ASource);
Until ASource.Position >= ASource.Size;
End;
Procedure TBinSbtpFileImpl.SaveToStream(ATarget : IStreamEx);
Var X : Integer;
Begin
Header.SaveToStream(ATarget);
For X := 0 To Item.Count - 1 Do
Item[X].SaveToStream(ATarget);
End;
Function TBinSbtpFilesImpl.GetItemClass() : TInterfacedObjectExClass;
Begin
Result := TBinSbtpFileImpl;
End;
Function TBinSbtpFilesImpl.Get(Index : Integer) : IBinSbtpFile;
Begin
Result := InHerited Items[Index] As IBinSbtpFile;
End;
Procedure TBinSbtpFilesImpl.Put(Index : Integer; Const Item : IBinSbtpFile);
Begin
InHerited Items[Index] := Item;
End;
Function TBinSbtpFilesImpl.Add() : IBinSbtpFile;
Begin
Result := InHerited Add() As IBinSbtpFile;
End;
Function TBinSbtpFilesImpl.Add(Const AItem : IBinSbtpFile) : Integer;
Begin
Result := InHerited Add(AItem);
End;
Procedure TBinSbtpFilesImpl.LoadFromStream(ASource : IStreamEx);
Var lNbFiles : Byte;
lNbVars : Byte;
Begin
lNbFiles := ASource.ReadByte();
While lNbFiles > 0 Do
Begin
With Add() Do
Begin
lNbVars := ASource.ReadByte();
Header.HeaderPadding := ASource.ReadByte();
While lNbVars > 0 Do
Begin
Item.Add().LoadFromStream(ASource);
Dec(lNbVars);
End;
End;
Dec(lNbFiles);
End;
End;
Procedure TBinSbtpFilesImpl.SaveToStream(ATarget : IStreamEx);
Var X, Y : Integer;
Begin
ATarget.WriteByte(Count);
For X := 0 To Count - 1 Do
Begin
With Get(X) Do
Begin
ATarget.WriteByte(Item.Count);
ATarget.WriteByte(Header.HeaderPadding);
For Y := 0 To Item.Count - 1 Do
Item[Y].SaveToStream(ATarget);
End;
End;
End;
end.
|
unit RoadsterEndpoint;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Roadster;
type
IRoadsterEndpoint = interface(IInterface) ['{7FF4DAB2-86C0-4E25-A5D8-A23EA5CFE57A}']
function All: IRoadster;
end;
function NewRoadsterEndpoint: IRoadsterEndpoint;
implementation
uses
Endpoint_Helper;
const
Endpoint = 'roadster/';
type
{ TRoadsterEndpoint }
TRoadsterEndpoint = class(TInterfacedObject, IRoadsterEndpoint)
function All: IRoadster;
end;
function NewRoadsterEndpoint: IRoadsterEndpoint;
begin
Result := TRoadsterEndpoint.Create;
end;
{ TRoadsterEndpoint }
function TRoadsterEndpoint.All: IRoadster;
begin
Result := NewRoadster;
EndpointToModel(Endpoint, Result);
end;
end.
|
program zgld25;
{$DEFINE STATIC}
{$R *.res}
uses math, SysUtils, zglHeader;
type
texture = zglptexture;
real = single;
vector2d = zglTPoint2D;
type
sprite = object
x, y : real;
w, h : integer;
dx, dy : real;
accel : vector2d;
end;
const
assetdir : UTF8String = 'assets';
maxfps = 50;
naplen = 1000 div maxfps;
maxdx = 12.5;
maxdy = 7.5;
gravity = 0.075;
friction = 0.0125;
chunkw = 50;
chunks = 128;
camera2D : zglTCamera2D =
( X: 0; Y: 0; Angle: 0; Zoom: ( X: 1; Y: 1 ); Center: ( X: 0; Y: 0 ) );
{ palette }
black = $ff000000;
rgb_land_a = black + $663300;
rgb_land_b = black + $cc6600;
rgb_squid_color = black + $d4145a;
rgb_squid_shade = black + $9e005d;
var
spritesheet : texture;
alien : sprite;
landscape : array[ -chunks div 2 .. chunks div 2 - 1 ] of byte;
camera : zglPCamera2D;
scrH, scrW : cardinal;
function clamped( var n : single; const min, max : single ) : boolean;
begin
result := true;
if n < min then n := min
else if n > max then n := max
else result := false
end;
procedure init;
var i : Integer;
begin
spritesheet := tex_LoadFromFile( assetdir + '/invaders.png' );
tex_SetFrameSize( spritesheet, 50, 50 );
alien.w := 50; alien.h := 50;
alien.accel.x := 0.50;
alien.accel.y := 0.25;
for i := low( landscape ) to high( landscape ) do
begin
landscape[ i ] := 45 + 5 * random( 8 );
end;
New( camera );
cam2d_init( camera^ );
end;
procedure update( dt : double );
begin
{ handle keyboard }
if key_down( K_RIGHT ) then alien.dx += alien.accel.x;
if key_down( K_LEFT ) then alien.dx -= alien.accel.x;
if key_down( K_UP ) then alien.dy -= alien.accel.y;
if key_down( k_down ) then alien.dy += alien.accel.y * 1.50;
key_clearstate;
{ speed checking }
if abs(alien.dx) > maxdx then alien.dx := sign( alien.dx ) * maxdx;
if abs(alien.dy) > maxdy then alien.dy := sign( alien.dy ) * maxdy;
alien.x += alien.dx * dt / maxfps;
alien.y += alien.dy * dt / maxfps;
{ external forces }
alien.dy += gravity;
alien.dx *= 1 - friction;
{ bounds checking }
if clamped( alien.x,
low(landscape) * chunkw,
high(landscape) * chunkw - alien.w )
then alien.dx := 0;
if clamped( alien.y, 100, scrH - 150 ) { leave room for hud , ground }
then alien.dy := 0;
{ limit frames per second }
sleep( naplen );
end;
procedure render_hud;
const width = chunks * 2; height = 50; ypos = 15;
var xpos : integer;
begin
cam2d_set( @camera2D );
{ draw the map }
xpos := ( scrW - width ) div 2;
pr2d_rect( xpos -2, ypos-2, width + 4, height + 4, rgb_squid_shade, 255, PR2D_FILL );
pr2d_Rect( xpos, ypos, width, height, black, 255, PR2D_FILL );
{ draw the alien on the map }
{ the *2 is because we have 2pixels per landscape chunk }
pr2d_rect( xpos + 2 * ( high( landscape ) + floor( alien.x / chunkw )),
ypos + floor( alien.y / scrH * height ),
4, 4, rgb_squid_color, 255, PR2D_FILL );
end;
procedure render_cam;
var i : integer; color : longword;
begin
camera^.x := alien.x - scrW div 2 ;
cam2d_Set( camera );
{ draw the alien }
asprite2d_Draw( spritesheet, alien.x, alien.y, 50, 50,
floor((alien.dx / maxdx) * 20), 10 );
{ draw the terrain }
for i := low( landscape ) to high( landscape ) do
begin
if odd( i ) then color := rgb_land_a else color := rgb_land_b;
pr2d_rect( i * chunkw, scrH - landscape[ i ],
chunkw, landscape[ i ], color, 255, PR2D_FILL );
end
end;
procedure render;
begin
render_hud;
render_cam;
end;
begin
if not zglLoad( libZenGL ) then halt;
wnd_SetCaption( 'hello world!' );
scrW := zgl_get( DESKTOP_WIDTH );
scrH := zgl_get( DESKTOP_HEIGHT );
scr_SetOptions( scrW, scrH, REFRESH_DEFAULT,
{fullscreen} True, {vsync} False );
zgl_reg( sys_load, @init );
zgl_reg( sys_update, @update );
zgl_reg( sys_draw, @render );
zgl_init;
end.
|
unit BuilderPizzaExample.Processors.ICalculatePrice;
interface
uses
BuilderPizzaExample.Domain.Pizza;
type
ICalculatePrice = interface
['{444E9852-5142-4FC6-8797-6487092FC3EC}']
procedure DefinePrice(APizza : TPizza);
end;
implementation
end.
|
unit WorldGenLiquids_u;
interface
uses WorldGenerator_u, generation, RandomMCT;
type WorldGenLiquids=class(WorldGenerator)
private
liquidBlockId:integer;
public
constructor Create(i:integer);
function generate(xreg,yreg:integer; map:region; rand:rnd; i,j,k:integer):boolean; override;
end;
implementation
constructor WorldGenLiquids.Create(i:integer);
begin
liquidBlockId:=i;
end;
function WorldGenLiquids.generate(xreg,yreg:integer; map:region; rand:rnd; i,j,k:integer):boolean;
var t,l,t1,t2,t3,t4,i1:integer;
begin
if (get_block_id(map,xreg,yreg,i, j + 1, k) <> 1) then
begin
result:=false;
exit;
end;
if (get_block_id(map,xreg,yreg,i, j - 1, k) <> 1) then
begin
result:=false;
exit;
end;
t:=get_block_id(map,xreg,yreg,i,j,k);
if (t <> 0)and(t <> 1) then
begin
result:=false;
exit;
end;
l:=0;
t1:=get_block_id(map,xreg,yreg,i-1,j,k);
t2:=get_block_id(map,xreg,yreg,i+1,j,k);
t3:=get_block_id(map,xreg,yreg,i,j,k-1);
t4:=get_block_id(map,xreg,yreg,i,j,k+1);
if t1=1 then inc(l);
if t2=1 then inc(l);
if t3=1 then inc(l);
if t4=1 then inc(l);
i1:=0;
if t1=0 then inc(i1);
if t2=0 then inc(i1);
if t3=0 then inc(i1);
if t4=0 then inc(i1);
if (l = 3)and(i1 = 1) then
begin
set_block_id(map,xreg,yreg,i, j, k, liquidBlockId);
{world.scheduledUpdatesAreImmediate = true;
Block.blocksList[liquidBlockId].updateTick(world, i, j, k, random);
world.scheduledUpdatesAreImmediate = false;}
end;
result:=true;
end;
end.
|
unit Model.Books;
interface
uses
System.SysUtils,
System.Classes,
System.StrUtils,
System.Generics.Collections,
Procesor.Currency.Intf;
type
TBook = class
strict private
FISBN: string;
FTitle: String;
FAuthors: TList<string>;
FReleaseDate: TDateTime;
FIsPreciseReleaseDate: boolean;
FPrice: Currency;
FPriceCurrency: string;
FPages: integer;
private
public
constructor Create; virtual;
destructor Destroy; override;
// ---
function GetAuthorsList: string;
function GetReleaseDate: string;
function GetPrice(const aCurrencyCode: string;
aCurrencyProcessor: ICurrencyProcessor): double;
// ---
property ISBN: string read FISBN write FISBN;
property Title: String read FTitle write FTitle;
property Authors: TList<string> read FAuthors write FAuthors;
property ReleaseDate: TDateTime read FReleaseDate write FReleaseDate;
property IsPreciseReleaseDate: boolean read FIsPreciseReleaseDate
write FIsPreciseReleaseDate;
property Price: Currency read FPrice write FPrice;
property PriceCurrency: string read FPriceCurrency write FPriceCurrency;
property Pages: integer read FPages write FPages;
end;
implementation
constructor TBook.Create;
begin
FAuthors := TList<string>.Create;
end;
destructor TBook.Destroy;
begin
FAuthors.Free;
inherited;
end;
function TBook.GetAuthorsList: string;
var
idx: integer;
begin
if FAuthors.Count = 0 then
Exit('');
Result := FAuthors[0];
for idx := 1 to FAuthors.Count - 1 do
Result := Result + ', ' + FAuthors[idx];
end;
function LocateRate(const aCurrencyCode: string;
const aCurrencyTable: TArray<TCurrencyRate>): integer;
var
idx: integer;
begin
for idx := 0 to High(aCurrencyTable) do
if aCurrencyTable[idx].Code = aCurrencyCode then
Exit(idx);
Result := -1;
end;
function TBook.GetPrice(const aCurrencyCode: string;
aCurrencyProcessor: ICurrencyProcessor): double;
begin
// OLD:
{
idxFrom := LocateRate(FPriceCurrency, aCurrencyTable);
idxTo := LocateRate(aCurrencyCode, aCurrencyTable);
Result := Round(FPrice / aCurrencyTable[idxFrom].Rate * aCurrencyTable
[idxTo].Rate);
}
Result := Round(aCurrencyProcessor.Convert(FPrice, FPriceCurrency,
aCurrencyCode));
end;
function TBook.GetReleaseDate: string;
begin
if FReleaseDate = 0 then
Result := '---'
else if FIsPreciseReleaseDate then
Result := DateToStr(FReleaseDate)
else
Result := FormatDateTime('mm yyyy', FReleaseDate);
end;
end.
|
unit calendar2;
interface
uses Calendar, Graphics, Types, Grids, Classes, Controls, Messages;
type
TOnEstadoDiaNotify = procedure (const dia: integer; var enabled: boolean) of object;
TCalendar2 = class(TCalendar)
private
FOnEstadoDia: TOnEstadoDiaNotify;
FColorDisabled: TColor;
FFontDisabled: TFont;
MaxDateYear, MaxDateMonth, MaxDateDay: Word;
MinDateYear, MinDateMonth, MinDateDay: Word;
FDisableWeekEnds: boolean;
FOnSelectDay: TNotifyEvent;
FCurrentDate: TDate;
FColorCurrent: TColor;
CoordFocused: TGridCoord;
FColorFocused: TColor;
procedure SetColorDisabled(const Value: TColor);
procedure SetFontDisabled(const Value: TFont);
procedure SetMaxDate(const Value: TDate);
procedure SetMinDate(const Value: TDate);
procedure SetColorCurrent(const Value: TColor);
function GetCalendarDate: TDate;
procedure SetCalendarDate(const Value: TDate);
procedure SetColorFocused(const Value: TColor);
procedure InvalidateFocused;
procedure SetCurrentDate(const Value: TDate);
function GetMaxDate: TDate;
protected
function isCeldaEnabled(ACol, ARow: Longint): boolean;
procedure DrawCell(ACol, ARow: Longint; ARect: TRect; AState: TGridDrawState); override;
function SelectCell(ACol, ARow: Longint): Boolean; override;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState;
X, Y: Integer); override;
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
property MaxDate: TDate read GetMaxDate write SetMaxDate;
property MinDate: TDate write SetMinDate;
property CurrentDate: TDate read FCurrentDate write SetCurrentDate;
property CalendarDate: TDate read GetCalendarDate write SetCalendarDate;
published
property OnEstadoDia: TOnEstadoDiaNotify read FOnEstadoDia write FOnEstadoDia;
property ColorDisabled: TColor read FColorDisabled write SetColorDisabled default clLtGray;
property ColorCurrent: TColor read FColorCurrent write SetColorCurrent default clYellow;
property ColorFocused: TColor read FColorFocused write SetColorFocused default $00F2E6DE;
property DisableWeekEnds: boolean read FDisableWeekEnds write FDisableWeekEnds default true;
property FontDisabled: TFont read FFontDisabled write SetFontDisabled;
property StartOfWeek default 1;
property GridLineWidth default 0;
property OnSelectDay: TNotifyEvent read FOnSelectDay write FOnSelectDay;
end;
implementation
uses SysUtils, DateUtils;
{ TCalendar2 }
procedure TCalendar2.CMMouseLeave(var Message: TMessage);
begin
InvalidateFocused;
CoordFocused.X := 0;
CoordFocused.Y := 0;
end;
constructor TCalendar2.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FColorDisabled := clLtGray;
FFontDisabled := TFont.Create;
FFontDisabled.Color := clGray;
GridLineWidth := 0;
StartOfWeek := 1;
FDisableWeekEnds := true;
FCurrentDate := now;
FColorCurrent := clYellow;
FColorFocused := $00F2E6DE;
DefaultDrawing := false;
end;
destructor TCalendar2.Destroy;
begin
FFontDisabled.Free;
inherited;
end;
procedure TCalendar2.DrawCell(ACol, ARow: Integer; ARect: TRect;
AState: TGridDrawState);
var text: string;
begin
if ARow = 0 then
inherited DrawCell(ACol, ARow, ARect, AState)
else begin
text := CellText[ACol, ARow];
if (ACol = CoordFocused.X) and (ARow = CoordFocused.Y) then begin
Canvas.Brush.Color := FColorFocused;
Canvas.Font.Assign(Font);
end
else begin
if (YearOf(FCurrentDate) = Year) and (MonthOf(FCurrentDate) = Month) and
(text <> '') and (StrToInt(text) = DayOf(FCurrentDate)) then begin
Canvas.Brush.Color := FColorCurrent;
Canvas.Font.Assign(Font);
end
else begin
if (text='') or (isCeldaEnabled(ACol, ARow)) then begin
Canvas.Brush.Color := Color;
Canvas.Font.Assign(Font);
end
else begin
Canvas.Brush.Color := FColorDisabled;
Canvas.Font.Assign(FFontDisabled);
end;
end;
end;
with ARect, Canvas do
TextRect(ARect, Left + (Right - Left - TextWidth(text)) div 2,
Top + (Bottom - Top - TextHeight(text)) div 2, text);
end;
end;
function TCalendar2.GetCalendarDate: TDate;
begin
result := inherited CalendarDate;
end;
function TCalendar2.GetMaxDate: TDate;
begin
result := EncodeDate(MaxDateYear, MaxDateMonth, MaxDateDay);
end;
procedure TCalendar2.InvalidateFocused;
begin
if (CoordFocused.X <> 0) or (CoordFocused.Y <> 0) then
InvalidateCell(CoordFocused.X, CoordFocused.Y);
end;
function TCalendar2.isCeldaEnabled(ACol, ARow: Integer): boolean;
var text: string;
dia: word;
begin
if (ARow = 0) then
result := false
else begin
if (FDisableWeekEnds) and (ACol > 4) then
result := false
else begin
text := CellText[ACol, ARow];
if text = '' then
result := False
else begin
dia := StrToInt(text);
if ((Year = MaxDateYear) and (Month = MaxDateMonth) and (dia > MaxDateDay)) then
result := false
else begin
if ((Year = MinDateYear) and (Month = MinDateMonth) and (dia < MinDateDay)) then
result := false
else begin
result := true;
if Assigned(FOnEstadoDia) then
FOnEstadoDia(dia, result);
end;
end;
end;
end;
end;
end;
procedure TCalendar2.MouseMove(Shift: TShiftState; X, Y: Integer);
var Coord: TGridCoord;
begin
inherited MouseMove(Shift, X, Y);
Coord := MouseCoord(X, Y);
if isCeldaEnabled(Coord.X, Coord.Y) then begin
Cursor := crHandPoint;
if (CoordFocused.X <> Coord.X) or (CoordFocused.Y <> Coord.Y) then begin
InvalidateCell(CoordFocused.X, CoordFocused.Y);
InvalidateCell(Coord.X, Coord.Y);
end;
CoordFocused := Coord;
end
else begin
InvalidateFocused;
CoordFocused.X := 0;
CoordFocused.Y := 0;
Cursor := crDefault;
end;
end;
procedure TCalendar2.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
Y: Integer);
var Coord: TGridCoord;
begin
inherited MouseUp(Button, Shift, X, Y);
Coord := MouseCoord(X, Y);
if isCeldaEnabled(Coord.X, Coord.Y) then
CurrentDate := CalendarDate;
end;
function TCalendar2.SelectCell(ACol, ARow: Integer): Boolean;
begin
if isCeldaEnabled(ACol, ARow) then
result := inherited SelectCell(ACol, ARow)
else begin
result := false;
end;
end;
procedure TCalendar2.SetCalendarDate(const Value: TDate);
begin
inherited CalendarDate := Value;
CoordFocused.X := 0;
CoordFocused.Y := 0;
Invalidate;
end;
procedure TCalendar2.SetColorCurrent(const Value: TColor);
begin
FColorCurrent := Value;
Invalidate;
end;
procedure TCalendar2.SetColorDisabled(const Value: TColor);
begin
FColorDisabled := Value;
Invalidate;
end;
procedure TCalendar2.SetColorFocused(const Value: TColor);
begin
FColorFocused := Value;
InvalidateFocused;
end;
procedure TCalendar2.SetCurrentDate(const Value: TDate);
begin
FCurrentDate := Value;
if Assigned(FOnSelectDay) then
FOnSelectDay(Self);
Invalidate;
end;
procedure TCalendar2.SetFontDisabled(const Value: TFont);
begin
FFontDisabled.Assign(Value);
end;
procedure TCalendar2.SetMaxDate(const Value: TDate);
begin
DecodeDate(Value, MaxDateYear, MaxDateMonth, MaxDateDay);
if CurrentDate > Value then begin
CalendarDate := Value;
CurrentDate := Value;
end;
Invalidate;
end;
procedure TCalendar2.SetMinDate(const Value: TDate);
begin
DecodeDate(Value, MinDateYear, MinDateMonth, MinDateDay);
if CurrentDate < Value then begin
CalendarDate := Value;
CurrentDate := Value;
end;
Invalidate;
end;
end.
|
unit UWatchFolders; {UInBoxFolders}
{ ClickForms Application }
{ Bradford Technologies, Inc. }
{ All Rights Reserved }
{ Source Code Copyrighted © 1998-2005 by Bradford Technologies, Inc. }
{This unit contains the code for performing the work-flow operations}
{for ClickForms. It handles the Photo Inbox, Orders Inbox, WorkIn and}
{WorkOut folders.}
{$WARN SYMBOL_PLATFORM OFF}
{$WARN UNIT_PLATFORM OFF}
interface
Uses
Classes,
UContainer, UDirMonitor;
const
//Watch Folder Types
mtGeneral = 0;
mtInboxPhotos = 1;
mtInboxOrders = 2;
mtInboxWIP = 3;
mtOutboxWIP = 4;
mtInboxPropInfo = 5;
type
TFolderWatchers = class(TDirMonitorList)
private
FParent: TComponent;
procedure EventManager(Sender: TObject; Action: TDirAction; FileName: String);
procedure NewPhotoEvent(doc: TContainer; Action: TDirAction; FileName: String);
procedure NewOrderEvent(Sender: TObject; Action: TDirAction; FileName: String);
procedure WorkInEvent(Sender: TObject; Action: TDirAction; FileName: String);
procedure WorkOutEvent(Sender: TObject; Action: TDirAction; FileName: String);
function GetItem(WatcherID: Integer): TDirMonitor;
public
constructor Create(AOwner: TComponent);
destructor Destroy; override;
function CreateWatcher(MonitorID: Integer; AFolder: String): TDirMonitor;
//this will go into another unit dedicated to Photo Inspection form
function AddPhotoToCatalog(doc: TContainer; fileName: String): Boolean;
procedure MoveToProcessedSubFolder(const fileName: String);
procedure SetupWatchers(AOwner: TComponent);
property Watcher[WatcherID: Integer]: TDirMonitor read GetItem;
end;
procedure PhotoInboxChangeNotification(doc: TContainer);
var
FolderWatchers: TFolderWatchers; //store in global var so everyone can get to it
implementation
uses
Forms, SysUtils,
UGlobals, UUtil1, UEditor, UFileFinder, UStatus, UStrings;
const
processedDirName = 'Processed';
var
PhotoDoc: TContainer;
procedure ProcessNewInBoxPhotos(Sender: TObject; FileName: String);
begin
if FileExists(FileName) then
if PhotoDoc.docEditor is TGraphicEditor then
begin
TGraphicEditor(PhotoDoc.docEditor).LoadImageFile(FileName);
// DeleteFile(FileName);
end;
end;
procedure PhotoInboxChangeNotification(doc: TContainer);
begin
if not assigned(doc) then
begin
{create a report with inspection photo form}
Exit; //while developing
end;
PhotoDoc := doc; //hack
FileFinder.OnFileFoundP := ProcessNewInBoxPhotos;
FileFinder.Find(appPref_DirNewPhotosInbox, False, SupportedImageFormats);
end;
{ TFolderWatchers }
constructor TFolderWatchers.Create(AOwner: TComponent);
begin
inherited Create(True); //list will own the objects
FParent := AOwner; //remember the Main window
end;
destructor TFolderWatchers.Destroy;
begin
inherited Destroy;
end;
function TFolderWatchers.CreateWatcher(MonitorID: Integer; AFolder: String): TDirMonitor;
begin
result := AddMonitor(FParent, MonitorID, AFolder);
if assigned(result) then
result.OnChange := EventManager;
end;
function TFolderWatchers.GetItem(WatcherID: Integer): TDirMonitor;
begin
result := ItemByID[WatcherID];
end;
procedure TFolderWatchers.EventManager(Sender: TObject; Action: TDirAction; FileName: String);
var
doc: TContainer;
begin
//get the doc that is active
//handle any other common processing here
doc := TContainer(GetTopMostContainer);
if assigned(Sender) then
case TDirMonitor(Sender).MonitorID of
mtInboxPhotos:
begin
NewPhotoEvent(doc, action, filename);
end;
mtInboxOrders:
begin
NewOrderEvent(doc, action, filename);
end;
mtInboxWIP:
begin
WorkInEvent(doc, action, filename);
end;
mtOutboxWIP:
begin
WorkOutEvent(doc, action, filename);
end;
end;
end;
function WaitUntilFileIsThere(fName: String): Boolean;
var
i: integer;
begin
i := 1;
repeat
// if i = 10000 then showNotice('file not ready '+ fName);
result := FileExists(FName);
Application.ProcessMessages;
inc(i);
until (result = true) or (i > 10000);
end;
procedure TFolderWatchers.NewPhotoEvent(doc: TContainer; Action: TDirAction; FileName: String);
var
processed: Boolean;
begin
if (Action = faADDED) or (action = faMODIFIED) then
begin
processed := False;
// ShowNotice('Action = '+ inttostr(integer(action)));
Sleep(3000); //3 second delay so file can finish writing
WaitUntilFileIsThere(fileName);
if fileExists(filename) then //if its really there...
begin
//want to put in empty cell and we have an empty cell
if appPref_AutoPhotoInsert2Cell then
begin
if assigned(doc) and (doc.docEditor is TGraphicEditor) then
processed := TGraphicEditor(doc.docEditor).LoadImageFile(FileName);
end;
//if not put into cell, try into inspection photo form
if (not processed) and appPref_AutoPhoto2Catalog then
begin
processed := AddPhotoToCatalog(doc, FileName);
end;
if processed then
MoveToProcessedSubFolder(FileName);
end
// else
// ShowNotice('file does not exist.'); //github #646
end;
// else
//### only during debug
// ShowNotice('Action = '+ inttostr(integer(action)));
end;
procedure TFolderWatchers.NewOrderEvent(Sender: TObject; Action: TDirAction; FileName: String);
begin
// handle orders
end;
procedure TFolderWatchers.WorkInEvent(Sender: TObject; Action: TDirAction; FileName: String);
begin
//handle generic work in
end;
procedure TFolderWatchers.WorkOutEvent(Sender: TObject; Action: TDirAction; FileName: String);
begin
//handle generic work out
end;
function TFolderWatchers.AddPhotoToCatalog(doc: TContainer; fileName: String): Boolean;
begin
result := True;
end;
procedure TFolderWatchers.MoveToProcessedSubFolder(const fileName: String);
var
dir, processDir: String;
begin
dir := ExtractFileDir(fileName);
if FindLocalSubFolder(dir, processedDirName, processDir, True) then
begin
FileOperator.Move(fileName, processDir);
end;
end;
procedure TFolderWatchers.SetupWatchers(AOwner: TComponent);
Var
WFolder: TDirMonitor;
begin
//setup to watch the photo inbox folder
if appPref_WatchPhotosInbox and VerifyFolder(appPref_DirNewPhotosInbox) then
begin
WFolder := AddMonitor(AOwner, mtInboxPhotos, appPref_DirNewPhotosInbox);
WFolder.CanStart := appPref_WatchPhotosInbox;
WFolder.OnChange := EventManager;
end;
//setup to watch the orders inbox folder
if appPref_WatchOrdersInbox and VerifyFolder(appPref_DirNewOrdersInbox) then
begin
//WFolder := AddMonitor(mtInboxOrders, appPref_DirNewOrdersInbox);
//WFolder.OnDirectoryChange := EventManager;
end;
//setup to watch the WorkIn folder
//setup to watch the WorkOut folder
end;
end.
|
unit uBuiltinFunctions;
// Developed using Delphi for Windows and Mac platforms.
// *** Ths source is distributed under Apache 2.0 ***
// Copyright (C) 2019-2020 Herbert M Sauro
// Author Contact Information:
// email: hsauro@gmail.com
interface
Uses System.SysUtils, uUtils, uMachineStack, System.generics.Collections, uVM;
type
TBuiltInFunction = procedure (vm : TVM);
TBuiltinFunctionRecord = record
name : string;
nArguments : integer;
helpStr : string;
funcPtr : TBuiltInFunction;
end;
TBuiltinList = class (TList<TBuiltInFunctionRecord>)
public
function find(const name: string; var index : integer): boolean;
end;
var builtinList : TBuiltinList;
implementation
Uses Math, uVMExceptions, uStringObject;
procedure argMustBeNumber;
begin
raise ERuntimeException.Create('argument must be a number');
end;
function TBuiltinList.find(const Name: string; var index : integer) : boolean;
var i : integer;
begin
for i := 0 to Count-1 do
if Self[i].name = name then
begin
index := i;
exit (true);
end;
result := false;
end;
procedure myInt (vm : TVM);
var x : PMachineStackRecord; tmp : int32;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (x.iValue);
stDouble : begin
// Do it this way inorder to get a range check error
// if dValue can't be case to a 32-bit integer
tmp := trunc (x.dValue);
vm.push (int32 (tmp));
end;
else
argMustBeNumber;
end;
end;
procedure readNumber (vm : TVM);
var s : string;
iValue : integer;
dValue : double;
begin
readln(s);
while (not TryStrToInt(s, iValue)) and (not TryStrToFloat(s, dValue)) do
begin
writeln ('Number error: ' + s + ' is not a number, try again');
readln (s);
end;
if TryStrToInt(s, iValue) then
vm.push (iValue)
else
vm.push (dValue);
end;
procedure readString (vm : TVM);
var s : string;
sObj : TStringObject;
begin
readln(s);
sobj := TStringObject.create (s);
vm.push (sObj);
end;
procedure mySin (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (sin (x.iValue));
stDouble : vm.push (sin (x.dValue));
else
argMustBeNumber;
end;
end;
procedure myCos (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (cos (x.iValue));
stDouble : vm.push (cos (x.dValue));
else
argMustBeNumber;
end;
end;
procedure myTan (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (tan (x.iValue));
stDouble : vm.push (tan (x.dValue));
else
argMustBeNumber;
end;
end;
procedure mySqrt (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (sqrt (x.iValue));
stDouble : vm.push (sqrt (x.dValue));
else
argMustBeNumber;
end;
end;
procedure myExp (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (exp (x.iValue));
stDouble : vm.push (exp (x.dValue));
else
argMustBeNumber;
end;
end;
procedure myLn (vm : TVM);
var x : PMachineStackRecord;
begin
x := vm.pop;
case x.stackType of
stInteger : vm.push (ln (x.iValue));
stDouble : vm.push (ln (x.dValue));
else
argMustBeNumber;
end;
end;
procedure addBuiltIns (name : string; nArguments : integer; helpStr : string; fcn : TBuiltInFunction);
var builtin : TBuiltInFunctionRecord;
begin
builtin.name := name;
builtin.nArguments := nArguments;
builtin.helpStr := helpStr;
builtin.funcPtr := fcn;
builtinList.Add (builtin);
end;
initialization
builtinList := TBuiltinList.Create;
addBuiltIns ('readNumber', 0, 'read an integer from the console', readNumber);
addBuiltIns ('readString', 0, 'read a string from the console', readString);
addBuiltIns ('int', 1, 'convert float to integer: int (3.4)', myInt);
addBuiltIns ('sin', 1, 'compute sine of a radian angle: sin (x)', mySin);
addBuiltIns ('cos', 1, 'compute cosine of a radian angle: cos (x)', myCos);
addBuiltIns ('tan', 1, 'compute tangent of a radian angle: tan (x)', myTan);
addBuiltIns ('sqrt',1, 'compute the square rootof a number. Negative values are not supported: sqrt (9)', mySqrt);
addBuiltIns ('exp', 1, 'compute e raised to the power of a value: exp (10)', myExp);
addBuiltIns ('ln', 1, 'compute the natural logarithm of a value: ln (123)', myLn);
finalization
builtinList.Free;
end.
|
unit SynEditDataObject;
{
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/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.
Contributors to the SynEdit and mwEdit projects are listed in the
Contributors.txt file.
Alternatively, the contents of this file may be used under the terms of the
GNU General Public License Version 2 or later (the "GPL"), in which case
the provisions of the GPL are applicable instead of those above.
If you wish to allow use of your version of this file only under the terms
of the GPL and not to allow others to use your version of this file
under the MPL, indicate your decision by deleting the provisions above and
replace them with the notice and other provisions required by the GPL.
If you do not delete the provisions above, a recipient may use your version
of this file under either the MPL or the GPL.
This unit implements the IDataObject interface for Clipboard and Drag & Drop
operations.
Code based on Grahame Marsh's articles on OLE Drag & Drop
published in UNDO (www.undo.com)
}
interface
uses
Windows,
SysUtils,
Classes,
ActiveX,
Generics.Collections;
Type
TSynEnumFormatEtc = class (TInterfacedObject, IEnumFORMATETC)
private
FList : TArray<TClipFormat>;
FIndex : integer;
protected
function GetFormatEtc(ClipFormat : TClipFormat): TFormatEtc;
{IEnumFORMATETC}
function Next (celt: Longint; out elt; pceltFetched: PLongint): HResult; stdcall;
function Skip (celt: Longint): HResult; stdcall;
function Reset : HResult; stdcall;
function Clone (out Enum: IEnumFormatEtc): HResult; stdcall;
public
constructor Create (FormatList : TArray<TClipFormat>; Index : integer = 0);
end;
TSynEditDataObject = class (TInterfacedObject, IDataObject)
private
fText : string;
FFormatEtc : TList<TClipFormat>;
MemoryStream : TMemoryStream;
HtmlStream : TMemoryStream;
procedure StreamHTML(Editor: TObject; Stream: TStream);
protected
function GetData (const formatetcIn: TFormatEtc; out medium: TStgMedium): HResult; overload; stdcall;
function GetDataHere (const formatetc: TFormatEtc; out medium: TStgMedium): HResult; overload; stdcall;
function QueryGetData (const formatetc: TFormatEtc): HResult; overload; stdcall;
function GetCanonicalFormatEtc (const formatetc: TFormatEtc; out formatetcOut: TFormatEtc): HResult; overload; stdcall;
function SetData (const formatetc: TFormatEtc; var medium: TStgMedium; fRelease: BOOL): HResult; overload; stdcall;
function EnumFormatEtc (dwDirection: Longint; out enumFormatEtc: IEnumFormatEtc): HResult; overload; stdcall;
function DAdvise (const formatetc: TFormatEtc; advf: Longint; const advSink: IAdviseSink; out dwConnection: Longint): HResult; overload; stdcall;
function DUnadvise (dwConnection: Longint): HResult; overload; stdcall;
function EnumDAdvise (out enumAdvise: IEnumStatData): HResult; overload; stdcall;
public
constructor Create(ASynEdit : TObject);
destructor Destroy; override;
end;
function MakeGlobal (Value : integer) : hGlobal; overload;
function MakeGlobal (const S: string): hGlobal; overload;
function MakeGlobal (var P; Size : integer) : hGlobal; overload;
function HasFormat(DataObject : IDataObject; Format : TClipFormat): Boolean;
var
SynEditClipboardFormat: UINT;
HTMLClipboardFormat: UINT;
implementation
uses
SynEdit,
SynExportHTML;
function MakeGlobal (const S: string): hGlobal;
var
P : PChar;
Size : Integer;
begin
Size := ByteLength(S) + SizeOf(Char);
Result := GlobalAlloc (GHND, Size);
if Result = 0 then
OutOfMemoryError;
P := GlobalLock (Result);
try
Move(PChar(S)^, P^, Size)
finally
GlobalUnlock (Result)
end
end;
function MakeGlobal (Value : integer) : hGlobal;
begin
Result := MakeGlobal (Value, sizeof (integer))
end;
function MakeGlobal (var P; Size : integer) : hGlobal;
var
D : pointer;
begin
Result := GlobalAlloc (GHND, Size);
if Result = 0 then
OutOfMemoryError;
D := GlobalLock (Result);
try
Move (P, D^, Size)
finally
GlobalUnlock (Result)
end
end;
function HasFormat(DataObject : IDataObject; Format : TClipFormat):Boolean;
Var
FormatEnumerator : IEnumFormatEtc;
FormatEtc : TFormatEtc;
Returned : integer;
begin
Result := False;
if (DataObject.EnumFormatEtc (DATADIR_GET, FormatEnumerator) = S_OK) then begin
FormatEnumerator.Reset;
while FormatEnumerator.Next (1, FormatEtc, @Returned) = S_OK do
if FormatEtc.cfFormat = Format then
Exit(True);
end;
end;
constructor TSynEditDataObject.Create(ASynEdit : TObject);
begin
inherited Create;
MemoryStream := TMemoryStream.Create;
HtmlStream := TMemoryStream.Create;
FFormatEtc := TList<TClipFormat>.Create;
FFormatEtc.Add(CF_UNICODETEXT);
FFormatEtc.Add(SynEditClipboardFormat); // InternalFormat
fText := (ASynEdit as TCustomSynEdit).SelText;
MemoryStream.Write((ASynEdit as TCustomSynEdit).ActiveSelectionMode,
SizeOf(TCustomSynEdit(ASynEdit).ActiveSelectionMode));
if not (eoCopyPlainText in TCustomSynEdit(ASynEdit).Options) and
Assigned(TCustomSynEdit(ASynEdit).Highlighter)
then
begin
FFormatEtc.Add(HTMLClipboardFormat); // HTMLFormat
StreamHtml(ASynEdit, HtmlStream);
end;
end;
destructor TSynEditDataObject.Destroy;
begin
FFormatEtc.Free;
MemoryStream.Free;
HtmlStream.Free;
inherited Destroy
end;
function TSynEditDataObject.GetData (const formatetcIn: TFormatEtc; out medium: TStgMedium): HResult;
begin
ZeroMemory (@Medium, sizeof (TStgMedium));
Result := QueryGetData(formatetcIn);
if Result = S_OK then
try
Medium.tymed := TYMED_HGLOBAL;
if FormatEtcIn.cfFormat = CF_UNICODETEXT then
Medium.hGlobal := MakeGlobal(FText)
else if FormatEtcIn.cfFormat = SynEditClipboardFormat then
Medium.hGlobal := MakeGlobal(MemoryStream.Memory^, MemoryStream.Position)
else if (FormatEtcIn.cfFormat = HTMLClipboardFormat) then
Medium.hGlobal := MakeGlobal(HtmlStream.Memory^, HtmlStream.Position);
except
Result := E_UNEXPECTED;
end
end;
function TSynEditDataObject.GetDataHere (const formatetc: TFormatEtc; out medium: TStgMedium): HResult;
begin
Result := E_NOTIMPL;
end;
procedure TSynEditDataObject.StreamHTML(Editor: TObject; Stream: TStream);
var
HTMLExport: TSynExporterHTML;
Ed: TCustomSynEdit;
begin
Ed := Editor as TCustomSynEdit;
HTMLExport := TSynExporterHTML.Create(nil);
try
HTMLExport.Font := Ed.Font;
HTMLExport.CreateHTMLFragment := True;
HTMLExport.UseBackground := True;
HTMLExport.Highlighter := Ed.Highlighter;
HTMLExport.ExportRange(Ed.Lines, Ed.BlockBegin, Ed.BlockEnd);
HTMLExport.SaveToStream(Stream);
// Adding a terminating null byte to the Stream.
Stream.WriteData(0, 1);
finally
HTMLExport.Free;
end;
end;
function TSynEditDataObject.QueryGetData (const formatetc: TFormatEtc): HResult;
begin
if (formatetc.tymed and TYMED_HGLOBAL = TYMED_HGLOBAL) and
FFormatEtc.Contains(formatetc.cfFormat)
then
Result := S_OK
else
Result := DV_E_FORMATETC;
end;
function TSynEditDataObject.GetCanonicalFormatEtc (const formatetc: TFormatEtc; out formatetcOut: TFormatEtc): HResult;
begin
FormatEtcOut.ptd := nil;
Result := DATA_S_SAMEFORMATETC;
end;
function TSynEditDataObject.SetData (const formatetc: TFormatEtc; var medium: TStgMedium; fRelease: BOOL): HResult;
begin
Result := E_NOTIMPL;
end;
function TSynEditDataObject.EnumFormatEtc (dwDirection: Longint; out enumFormatEtc: IEnumFormatEtc): HResult;
begin
try
if dwDirection = DATADIR_GET then
begin
EnumFormatEtc := TSynEnumFormatEtc.Create(FFormatEtc.ToArray);
Result := S_OK
end else
Result := E_NOTIMPL;
except
Result := E_UNEXPECTED;
end
end;
function TSynEditDataObject.DAdvise (const formatetc: TFormatEtc; advf: Longint; const advSink: IAdviseSink; out dwConnection: Longint): HResult;
begin
Result := OLE_E_ADVISENOTSUPPORTED;
end;
function TSynEditDataObject.DUnadvise (dwConnection: Longint): HResult;
begin
Result := OLE_E_ADVISENOTSUPPORTED;
end;
function TSynEditDataObject.EnumDAdvise (out enumAdvise: IEnumStatData): HResult;
begin
Result := OLE_E_ADVISENOTSUPPORTED;
end;
//=== BASE ENUM FORMATETC CLASS ================================================
constructor TSynEnumFormatEtc.Create(FormatList: TArray<TClipFormat>;
Index: integer);
begin
inherited Create;
FList := FormatList;
FIndex := Index;
end;
function TSynEnumFormatEtc.GetFormatEtc(ClipFormat: TClipFormat): TFormatEtc;
begin
with Result do
begin
cfFormat := ClipFormat;
dwAspect := DVASPECT_CONTENT;
ptd := nil;
tymed := TYMED_HGLOBAL;
lindex := -1;
end;
end;
function TSynEnumFormatEtc.Next (celt: Longint; out elt; pceltFetched: PLongint): HResult;
var
I : integer;
FormatEtc: PFormatEtc;
begin
I := 0;
FormatEtc:= PFormatEtc(@Elt);
while (I < Celt) and (FIndex < Length(FList)) do
begin
FormatEtc^ := GetFormatEtc(FList[FIndex]);
Inc(FormatEtc);
Inc (FIndex);
Inc (I)
end;
if (pCeltFetched <> nil) then pCeltFetched^:= i;
if (I = Celt) then
Result:= S_OK
else
Result:= S_FALSE;
end;
function TSynEnumFormatEtc.Skip (celt: Longint): HResult;
begin
Result := S_OK;
if Celt <= Length(FList) - FIndex then
FIndex := FIndex + Celt
else begin
FIndex := Length(FList);
Result := S_FALSE
end
end;
function TSynEnumFormatEtc.Reset : HResult;
begin
FIndex := 0;
Result := S_OK;
end;
function TSynEnumFormatEtc.Clone (out Enum: IEnumFormatEtc): HResult;
begin
Result := S_OK;
Enum := TSynEnumFormatEtc.Create (FList, FIndex);
end;
const
CF_HTML = 'HTML Format';
initialization
OleInitialize(nil);
SynEditClipboardFormat := RegisterClipboardFormat ('Internal SynEdit clipboard format');
HTMLClipboardFormat := RegisterClipboardFormat(CF_HTML);
finalization
OleFlushClipboard;
OleUninitialize;
end.
|
unit RPDBCBImp;
{**********************************************
Kingstar Delphi Library
Copyright (C) Kingstar Corporation
<Unit>RPDBCBImp
<What>Report Dataset Callback implementations
针对RPDBCB描述的数据集回调函数，实现了TRPCBDataset(TRPCBDataset的子类)和TRPCBField(TRPDataField的子类)
<Written By> Huang YanLai (黄燕来)
<History>
**********************************************}
interface
uses Classes,Contnrs, RPDBCB,RPDB, RPDefines;
type
TRPCBDataset = class;
TRPCBField = class (TRPDataField)
private
FFieldIndex: Integer;
procedure SetFieldIndex(const Value: Integer);
public
function GetPrintableText(TextFormatType : TRPTextFormatType=tfNone;
const TextFormat : string='') : string; override;
function AsInteger : Integer; override;
function AsFloat : Double; override;
function AsDateTime : TDateTime; override;
function AsString : string; override;
procedure SaveBlobToStream(Stream : TStream); override;
procedure AssignTo(Dest: TPersistent); override;
property FieldIndex : Integer read FFieldIndex write SetFieldIndex;
end;
TRPCBDataset = class(TRPDataset)
private
protected
FFields : TObjectList;
function GetFields(Index : Integer) : TRPDataField; override;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
procedure RecreateFields;
procedure NeedRecreateFields;
function Available:Boolean;
public
DatasetRecord : PDatasetRecord;
constructor Create(AOwner : TComponent); override;
destructor Destroy;override;
procedure First; override;
procedure Next; override;
function Eof : Boolean; override;
procedure Last; override;
procedure Prior; override;
function Bof : Boolean; override;
function FieldCount : Integer; override;
published
end;
TRPCBDataEntries = class(TRPDataEntries)
private
FOwnedDatasets : TObjectList;
public
procedure ClearControllers; override;
procedure AddRecord(const DatasetName : string; DatasetRecord : PDatasetRecord);
end;
implementation
uses SysUtils, SafeCode;
{ TRPCBField }
function TRPCBField.AsDateTime: TDateTime;
begin
with TRPCBDataset(Dataset).DatasetRecord^ do
Result := GetDateTime(Dataset,FieldIndex);
end;
function TRPCBField.AsFloat: Double;
begin
with TRPCBDataset(Dataset).DatasetRecord^ do
Result := GetFloat(Dataset,FieldIndex);
end;
function TRPCBField.AsInteger: Integer;
begin
with TRPCBDataset(Dataset).DatasetRecord^ do
Result := GetInteger(Dataset,FieldIndex);
end;
procedure TRPCBField.AssignTo(Dest: TPersistent);
begin
// empty
end;
function TRPCBField.AsString: string;
var
Len : Integer;
begin
with TRPCBDataset(Dataset).DatasetRecord^ do
begin
Len := GetString(Dataset,FieldIndex,nil,0);
SetLength(Result,Len);
if Len>0 then
GetString(Dataset,FieldIndex,PChar(Result),Len);
end;
end;
function TRPCBField.GetPrintableText(TextFormatType : TRPTextFormatType=tfNone;
const TextFormat : string=''): string;
begin
if TextFormatType=tfNone then
begin
case FieldType of
gfdtInteger : Result := IntToStr(AsInteger);
gfdtFloat : Result := FloatToStr(AsFloat);
gfdtString : Result := AsString;
gfdtDate : Result := FloatToStr(AsDateTime);
else Result := '';
end;
end else
Result := inherited GetPrintableText(TextFormatType, TextFormat);
end;
procedure TRPCBField.SaveBlobToStream(Stream: TStream);
begin
// empty
end;
procedure TRPCBField.SetFieldIndex(const Value: Integer);
var
DT : integer;
Len : Integer;
S : string;
begin
FFieldIndex := Value;
with TRPCBDataset(Dataset).DatasetRecord^ do
begin
Len := GetFieldName(Dataset,FFieldIndex,nil,0);
SetLength(S,Len);
if Len>0 then
GetFieldName(Dataset,FFieldIndex,PChar(S),Len);
FieldName := S;
DT := GetFieldDataType(Dataset,FFieldIndex);
end;
if (DT<0) or (DT>cdtBinary) then
FFieldType := gfdtOther else
FFieldType := TRPFieldDataType(DT);
end;
{ TRPCBDataset }
constructor TRPCBDataset.Create(AOwner: TComponent);
begin
inherited;
FFields := nil;
end;
destructor TRPCBDataset.Destroy;
begin
inherited;
FreeAndNil(FFields);
end;
function TRPCBDataset.Eof: Boolean;
begin
if Available then
Result := DatasetRecord.Eof(DatasetRecord.Dataset) else
Result := true;
end;
function TRPCBDataset.Bof: Boolean;
begin
if Available then
Result := DatasetRecord.Bof(DatasetRecord.Dataset) else
Result := true;
end;
function TRPCBDataset.FieldCount: Integer;
begin
if Available then
Result := DatasetRecord.FieldCount(DatasetRecord.Dataset) else
Result := 0;
end;
function TRPCBDataset.GetFields(Index: Integer): TRPDataField;
begin
if FFields=nil then
RecreateFields;
if FFields=nil then
Result := nil else
Result := TRPDataField(FFields[Index]);
end;
procedure TRPCBDataset.First;
begin
if Available then
DatasetRecord.First(DatasetRecord.Dataset);
end;
procedure TRPCBDataset.Last;
begin
if Available then
DatasetRecord.Last(DatasetRecord.Dataset);
end;
procedure TRPCBDataset.Next;
begin
if Available then
DatasetRecord.Next(DatasetRecord.Dataset);
end;
procedure TRPCBDataset.Prior;
begin
if Available then
DatasetRecord.Prior(DatasetRecord.Dataset);
end;
procedure TRPCBDataset.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited;
end;
procedure TRPCBDataset.RecreateFields;
var
i : integer;
Field : TRPCBField;
FieldCount : Integer;
begin
if FFields<>nil then
FFields.Clear;
if Available then
begin
if FFields=nil then
FFields := TObjectList.Create;
FieldCount := Self.FieldCount;
for i:=0 to FieldCount-1 do
begin
Field := TRPCBField.Create(Self);
Field.FieldIndex := I;
FFields.Add(Field);
end;
end
else
FreeAndNil(FFields);
end;
procedure TRPCBDataset.NeedRecreateFields;
begin
FreeAndNil(FFields);
end;
function TRPCBDataset.Available: Boolean;
begin
Result := DatasetRecord<>nil;
end;
{ TRPCBDataEntries }
procedure TRPCBDataEntries.AddRecord(const DatasetName: string;
DatasetRecord: PDatasetRecord);
var
i : integer;
Dataset: TRPCBDataset;
begin
CheckPtr(DatasetRecord,'Invalid DatasetRecord.');
if FOwnedDatasets=nil then
FOwnedDatasets := TObjectList.Create;
i := IndexOfDataset(DatasetName);
CheckTrue(i>=0,'No Entry For '+DatasetName);
Dataset:= TRPCBDataset.Create(nil);
Dataset.Environment := TRPDatasetController(Controllers[i]).Environment;
Dataset.DatasetName := DatasetName;
Dataset.DatasetRecord := DatasetRecord;
FOwnedDatasets.Add(Dataset);
TRPDatasetController(Controllers[i]).Dataset := Dataset;
end;
procedure TRPCBDataEntries.ClearControllers;
begin
inherited;
FreeAndNil(FOwnedDatasets);
end;
end.
|
unit IPGeoLocation.Providers.IPDig;
interface
uses
IPGeoLocation.Interfaces, IPGeoLocation.Core, System.Net.HttpClient;
type
{$REGION 'TIPGeoLocationProviderIPDig'}
TIPGeoLocationProviderIPDig = class sealed(TIPGeoLocationProviderCustom)
private
{ private declarations }
protected
{ protected declarations }
function GetRequest: IIPGeoLocationRequest; override;
public
{ public declarations }
constructor Create(pParent: IIPGeoLocation; const pIP: string); override;
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationResponseIPDig'}
TIPGeoLocationResponseIPDig = class sealed(TIPGeoLocationResponseCustom)
private
{ private declarations }
protected
{ protected declarations }
procedure Parse; override;
public
{ public declarations }
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationRequestIPDig'}
TIPGeoLocationRequestIPDig = class sealed(TIPGeoLocationRequestCustom)
private
{ private declarations }
protected
{ protected declarations }
function InternalExecute: IHTTPResponse; override;
function GetResponse(pIHTTPResponse: IHTTPResponse): IGeoLocation; override;
function GetMessageExceptionAPI(const pJSON: string): string; override;
public
{ public declarations }
constructor Create(pParent: IIPGeoLocationProvider; const pIP: string); override;
end;
{$ENDREGION}
implementation
uses
System.JSON, System.SysUtils, System.Net.URLClient;
{$I APIKey.inc}
{$REGION 'TIPGeoLocationProviderIPDig'}
constructor TIPGeoLocationProviderIPDig.Create(pParent: IIPGeoLocation;
const pIP: string);
begin
inherited Create(pParent, pIP);
FID := '#IPDIG';
FURL := 'https://ipdig.io';
FAPIKey := APIKey_IPDig; //TOKEN FROM APIKey.inc
end;
function TIPGeoLocationProviderIPDig.GetRequest: IIPGeoLocationRequest;
begin
Result := TIPGeoLocationRequestIPDig.Create(Self, FIP);
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationResponseIPDig'}
procedure TIPGeoLocationResponseIPDig.Parse;
var
lJSONObject: TJSONObject;
lCoordinates: string;
lCoordinatesArray: TArray<string>;
lFormatSettings: TFormatSettings;
begin
lJSONObject := nil;
try
lJSONObject := TJSONObject.ParseJSONValue(FJSON) as TJSONObject;
if not Assigned(lJSONObject) then
Exit;
lJSONObject.TryGetValue('country', FCountryCode);
lJSONObject.TryGetValue('country_full', FCountryName);
lJSONObject.TryGetValue('region', FState);
lJSONObject.TryGetValue('city', FCity);
lJSONObject.TryGetValue('postal', FZipCode);
lJSONObject.TryGetValue('loc', lCoordinates);
lJSONObject.TryGetValue('organization', FISP);
lCoordinatesArray := lCoordinates.Split([',']);
if (Length(lCoordinatesArray) >= 2) then
begin
lFormatSettings := TFormatSettings.Create('en-US');
TryStrToFloat(lCoordinatesArray[0], FLatitude, lFormatSettings);
TryStrToFloat(lCoordinatesArray[1], FLongitude, lFormatSettings);
end;
finally
lJSONObject.Free;
end;
end;
{$ENDREGION}
{$REGION 'TIPGeoLocationRequestIPDig'}
constructor TIPGeoLocationRequestIPDig.Create(pParent: IIPGeoLocationProvider;
const pIP: string);
begin
inherited Create(pParent, pIP);
FCheckJSONValue := False;
end;
function TIPGeoLocationRequestIPDig.GetMessageExceptionAPI(
const pJSON: string): string;
begin
Result := pJSON;
end;
function TIPGeoLocationRequestIPDig.GetResponse(
pIHTTPResponse: IHTTPResponse): IGeoLocation;
begin
Result := TIPGeoLocationResponseIPDig.Create(pIHTTPResponse.ContentAsString, FIP, FProvider);
end;
function TIPGeoLocationRequestIPDig.InternalExecute: IHTTPResponse;
var
lURL: TURI;
begin
//CONFORME A DOCUMENTAÇÃO DA API
lURL := TURI.Create(Format('%s/%s', [FIPGeoLocationProvider.URL, FIP]));
FHttpRequest.URL := lURL.ToString;
//REQUISIÇÃO
Result := inherited InternalExecute;
end;
{$ENDREGION}
end.
|
UNIT WordsUnit;
{ unit for work with words }
INTERFACE
USES ConstsUnit;
PROCEDURE ToLowerCase(VAR Ch: CHAR); { transpose all char case to lower }
PROCEDURE GetWord(VAR FIn: TEXT; VAR Data: Str50);
{ get correct word from FIn to Data}
IMPLEMENTATION
PROCEDURE ToLowerCase(VAR Ch: CHAR);
BEGIN {ToLowerCase}
IF (Ch IN UpperCase)
THEN
Ch := Chr(Ord(Ch) + CodeToUpper);
IF ((Ord(Ch) = CodeForRuELow) OR (Ord(Ch) = CodeForRuEUpp))
THEN
Ch := Chr(CodeForRuENorm)
END; {ToLowerCase}
PROCEDURE GetWord(VAR FIn: TEXT; VAR Data: Str50);
VAR
Ch: CHAR;
BEGIN {GetStatistic}
Data := '';
WHILE NOT EOLN(FIn)
DO
BEGIN
READ(FIn, Ch);
IF (Ch IN CorrectChars)
THEN
BEGIN
ToLowerCase(Ch);
Data := Data + Ch
END
ELSE
BREAK
END
END; {GetStatistic}
END.
|
unit CalculatorViewModel;
interface
uses
CalculatorInterfaces,
DSharp.PresentationModel.ViewModelBase,
SysUtils;
type
TCalcOperator = (Add, Subtract, Multiply, Divide);
TCalculatorViewModel = class(TViewModelBase, ICalculatorViewModel)
private
FLeftOperand: Double;
FRightOperand: Double;
FCalcOperator: TCalcOperator;
FCalcResult: Double;
FError: string;
public
procedure Calculate;
property LeftOperand: Double read FLeftOperand write FLeftOperand;
property RightOperand: Double read FRightOperand write FRightOperand;
property CalcOperator: TCalcOperator read FCalcOperator write FCalcOperator;
property CalcResult: Double read FCalcResult write FCalcResult;
property Error: string read FError write FError;
end;
implementation
{ TCalculatorViewModel }
procedure TCalculatorViewModel.Calculate;
begin
try
case FCalcOperator of
Add: FCalcResult := FLeftOperand + FRightOperand;
Subtract: FCalcResult := FLeftOperand - FRightOperand;
Multiply: FCalcResult := FLeftOperand * FRightOperand;
Divide: FCalcResult := FLeftOperand / FRightOperand;
end;
FError := '';
except
on E: Exception do
begin
FError := E.Message;
FCalcResult := 0;
end;
end;
DoPropertyChanged('CalcResult');
DoPropertyChanged('Error');
end;
initialization
TCalculatorViewModel.ClassName;
end.
|
//Only compile for the iOS platform.
{$IF NOT Defined(IOS)}
{$MESSAGE Fatal 'AT.iOS.Folders.pas only compiles for the iOS platform.'}
{$ENDIF}
// ******************************************************************
//
// Program Name : Angelic Tech iOS Library
// Program Version: 2017
// Platform(s) : iOS
// Framework : None
//
// Filename : AT.iOS.Folders.pas
// File Version : 2017.04
// Date Created : 10-Apr-2017
// Author : Matthew Vesperman
//
// Description:
//
// iOS folder routines.
//
// Revision History:
//
// v1.00 : Initial version
//
// ******************************************************************
//
// COPYRIGHT © 2017 - PRESENT Angelic Technology
// ALL RIGHTS RESERVED WORLDWIDE
//
// ******************************************************************
/// <summary>
/// Contains routines that return folder paths for the iOS
/// platform.
/// </summary>
unit AT.iOS.Folders;
interface
/// <summary>
/// Returns the documents folder on the iOS platform.
/// </summary>
/// <param name="AAppPath">
/// The path to append to the documents folder path. The folder
/// tree passed here will be created if it does not exist. Pass an
/// empty string to get just the documents path.
/// </param>
/// <returns>
/// The full path to the documents folder for an iOS device.
/// </returns>
/// <remarks>
/// If the AAppPath parameter is an empty string then this function
/// returns just the documents folder. If AAppPath contains a value
/// then it is appended to the documents path and the full path is
/// created if it does not exist.
/// </remarks>
/// <seealso cref="AT.iOS.Folders|GetDocumentDirectory(string)">
/// GetDocumentDirectory
/// </seealso>
function GetAppDataDirectory(AAppPath: String = ''): String;
/// <summary>
/// Returns the full path to the application's executable within
/// its bundle.
/// </summary>
/// <returns>
/// The full path to the application's executable within its
/// bundle.
/// </returns>
/// <seealso cref="AT.iOS.Folders|GetBundleDirectory">
/// GetBundleDirectory
/// </seealso>
/// <seealso cref="AT.iOS.App|GetAppBundle">
/// GetAppBundle
/// </seealso>
function GetAppDirectory: String;
/// <summary>
/// Returns the full path to the application's bundle.
/// </summary>
/// <returns>
/// The full path to the application's bundle.
/// </returns>
/// <seealso cref="AT.iOS.Folders|GetAppDirectory">
/// GetAppDirectory
/// </seealso>
/// <seealso cref="AT.iOS.App|GetAppBundle">
/// GetAppBundle
/// </seealso>
function GetBundleDirectory: String;
/// <summary>
/// Returns the documents folder on the iOS platform.
/// </summary>
/// <param name="ADocPath">
/// The path to append to the documents folder path. The folder
/// tree passed here will be created if it does not exist. Pass an
/// empty string to get just the documents path.
/// </param>
/// <returns>
/// <para>
/// The full path to the documents folder for an iOS device.
/// </para>
/// <para>
/// On the iOS platform GetDocumentDirectory is an alias to
/// GetAppDataDirectory.
/// </para>
/// </returns>
/// <remarks>
/// If the AAppPath parameter is an empty string then this function
/// returns just the documents folder. If AAppPath contains a value
/// then it is appended to the documents path and the full path is
/// created if it does not exist.
/// </remarks>
/// <seealso cref="AT.iOS.Folders|GetAppDataDirectory(string)">
/// GetAppDataDirectory
/// </seealso>
function GetDocumentDirectory(const ADocPath: String = ''): String;
implementation
uses
iOSapi.Foundation, AT.iOS.App, Macapi.Helpers, System.IOUtils,
System.SysUtils;
function GetAppDataDirectory(AAppPath: String = ''): String;
begin
//Get the documents folder path and Ensure trailing path delimeter
//is added to the path...
Result := IncludeTrailingPathDelimiter(TPath.GetDocumentsPath);
if (NOT AAppPath.IsEmpty) then
begin
//Append the AAppPath value to the path...
Result := Format('%s%s', [Result, AAppPath]);
//Ensure trailing path delimeter is added to the path...
Result := IncludeTrailingPathDelimiter(Result);
//Make sure the path actually exists...
TDirectory.CreateDirectory(Result);
end;
end;
function GetAppDirectory: String;
var
ABundle: NSBundle; //App bundle reference...
AValue: String; //Temp string value...
begin
//Get a reference to the app's bundle...
ABundle := GetAppBundle;
//Retrieve the bundle's executable path...
AValue := NSStrToStr(ABundle.executablePath);
//Ensure the trailing path delimeter is added...
AValue := IncludeTrailingPathDelimiter(AValue);
//Return the path...
Result := AValue;
end;
function GetBundleDirectory: String;
var
ABundle: NSBundle;
AValue: String;
begin
//Get a reference to the app's bundle...
ABundle := GetAppBundle;
//Retrieve the bundle's path...
AValue:= NSStrToStr(ABundle.bundlePath);
//Ensure the trailing path delimeter is added...
AValue := IncludeTrailingPathDelimiter(AValue);
//Return the path...
Result := AValue;
end;
function GetDocumentDirectory(const ADocPath: String = ''): String;
begin
//Return the value from GetAppDataDirectory...
Result := GetAppDataDirectory(ADocPath);
end;
end.
|
unit Crud.Controller;
interface
uses
FireDAC.Stan.Intf,
FireDAC.Stan.Option,
FireDAC.Stan.Error,
FireDAC.UI.Intf,
FireDAC.Phys.Intf,
FireDAC.Stan.Def,
FireDAC.Stan.Pool,
FireDAC.Stan.Async,
FireDAC.Phys,
FireDAC.Stan.ExprFuncs,
FireDAC.VCLUI.Wait,
FireDAC.Comp.UI,
Data.DB,
FireDAC.Comp.Client,
Crud.Controller.Interfaces,
Crud.Controller.Generic,
Crud.Model.Entity.Categoria,
Crud.Model.Entity.Produto;
type
TController = class(TInterfacedObject, iController)
private
FProduto : iControllerServices<TProduto>;
FCategoria : iControllerServices<TCategoria>;
public
constructor Create;
destructor Destroy; override;
class function New : iController;
function Categoria : iControllerServices<TCategoria>;
function Produto : iControllerServices<TProduto>;
end;
implementation
constructor TController.Create;
begin
end;
destructor TController.Destroy;
begin
inherited;
end;
class function TController.New : iController;
begin
Result := Self.Create;
end;
function TController.Categoria: iControllerServices<TCategoria>;
begin
if not Assigned(FCategoria) then
FCategoria := TControllerGeneric<TCategoria>.New(Self);
Result := FCategoria;
end;
function TController.Produto: iControllerServices<TProduto>;
begin
if not Assigned(FProduto) then
FProduto := TControllerGeneric<TProduto>.New(Self);
Result := FProduto;
end;
end.
|
unit uMapCls;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils,
Windows,
uMap, uStatus, uStatusSaxParser;
type
{ TBaseMap }
TBaseMap = class(TInterfacedObject, IBaseMap)
private
Tables: TTables;
fLock: TRtlCriticalSection;
public
function Lock(const aTypeTable: TTypeTable = TTypeTable.ttInput): PTable;
procedure UnLock;
constructor Create;
destructor Destroy; override;
end;
{ TMap }
TMap = class(TBaseMap, IMap)
private
fStatus: TStatus;
fValue: string;
public
constructor Create;
procedure AfterConstruction; override;
destructor Destroy; override;
public
procedure WriteData(const aOffSet: word; const aPdu: PPdu);
procedure WriteToTable(const aOffSet: word; const aRequestPdu: PPdu);
function ReadIoData(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword = 1): string;
function ReadIpAddress(const aTypeTable: TTypeTable; const aOffSet: word): string;
function ReadUint8l(const aTypeTable: TTypeTable; const aOffSet: word): byte; overload;
function ReadUint8l(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadUint8h(const aTypeTable: TTypeTable; const aOffSet: word): byte; overload;
function ReadUint8h(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadUint16(const aTypeTable: TTypeTable; const aOffSet: word): word; overload;
function ReadUint16(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadUint32(const aTypeTable: TTypeTable; const aOffSet: word): dword; overload;
function ReadUint32(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadSint16(const aTypeTable: TTypeTable; const aOffSet: word): smallInt; overload;
function ReadSint16(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadSint32(const aTypeTable: TTypeTable; const aOffSet: word): longint; overload;
function ReadSint32(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single; overload;
function ReadBitmap16(const aTypeTable: TTypeTable; const aOffSet: word): word; overload;
function ReadBitmap32(const aTypeTable: TTypeTable; const aOffSet: word): dword; overload;
function ReadFloat(const aTypeTable: TTypeTable; const aOffSet: word): single; overload;
function ReadBool(const aTypeTable: TTypeTable; const aOffSet: word): boolean; overload;
procedure Clear;
end;
implementation
{ TBaseMap }
function TBaseMap.Lock(const aTypeTable: TTypeTable): PTable;
begin
System.EnterCriticalSection(fLock);
Result := @Tables[aTypeTable];
end;
procedure TBaseMap.UnLock;
begin
System.LeaveCriticalSection(fLock);
end;
constructor TBaseMap.Create;
var
I: TTypeTable;
begin
inherited Create;
InitCriticalSection(fLock);
for I := Low(TTypeTable) to High(TTypeTable) do
ZeroMemory(@Tables[I], Length(Tables[I]));
end;
destructor TBaseMap.Destroy;
begin
Lock;
try
inherited Destroy;
finally
Unlock;
DoneCriticalSection(fLock);
end;
end;
{ TMap }
constructor TMap.Create;
begin
inherited Create;
fStatus := TStatus.Create;
end;
procedure TMap.AfterConstruction;
begin
inherited AfterConstruction;
with TStatusFactory.Create(fStatus) do
try
Parse;
finally
Free;
end;
end;
destructor TMap.Destroy;
begin
FreeAndNil(fStatus);
inherited Destroy;
end;
procedure TMap.WriteData(const aOffSet: word; const aPdu: PPdu);
var
Table: PTable;
TypeTable: TTypeTable;
NRegs: byte;
Wrd: word;
TableOffset: word;
PduOffset: word;
begin
// Тип таблицы
case aPdu^[0] of
3: TypeTable := TTypeTable.ttHolding;
4: TypeTable := TTypeTable.ttInput;
else
Exit;
end;
// количество регистров для записи
NRegs := aPdu^[1] shr 1;
// Начальное смещение в PDU
PduOffset := 2;
// Начальное смещение в Table
TableOffset := aOffSet;
// Таблица с данными
Table := Lock(TypeTable);
try
while NRegs > 0 do
begin
// Слово из PDU
Wrd := PWord(@aPdu^[PduOffset])^;
// Записать своппированное слово в Table
Table^[TableOffset] := Swap(Wrd);
// Счетчики
Inc(PduOffset, 2);
Inc(TableOffset, 1);
Dec(NRegs, 1);
end;
finally
Unlock;
end;
end;
procedure TMap.WriteToTable(const aOffSet: word; const aRequestPdu: PPdu);
var
Table: PTable;
TypeTable: TTypeTable;
NRegs: byte;
Wrd: word;
TableOffset: word;
PduOffset: word;
begin
// Тип таблицы
case aRequestPdu^[0] of
3: TypeTable := TTypeTable.ttHolding;
4: TypeTable := TTypeTable.ttInput;
else
Exit;
end;
// количество регистров для записи
NRegs := aRequestPdu^[5] shr 1;
// Начальное смещение в PDU
PduOffset := 6;
// Начальное смещение в Table
TableOffset := aOffSet;
// Таблица с данными
Table := Lock(TypeTable);
try
while NRegs > 0 do
begin
// Слово из PDU
Wrd := PWord(@aRequestPdu^[PduOffset])^;
// Записать своппированное слово в Table
Table^[TableOffset] := Swap(Wrd);
// Счетчики
Inc(PduOffset, 2);
Inc(TableOffset, 1);
Dec(NRegs, 1);
end;
finally
Unlock;
end;
end;
function TMap.ReadIoData(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): string;
type
TIoData = record
ioValue: integer;
ioStatus: byte;
ioType: byte;
end;
var
IoData: TIoData;
Value: dword;
Table: PTable;
FoundIndex: Integer;
begin
Table := Lock(aTypeTable);
try
Value := PDWord(@Table^[aOffSet])^;
with IoData do
begin
ioValue := Value and $FFFF; // младшие 2 байта
ioStatus := Value shr $10 and $00FF; // 3 байт
ioType := Value shr $F and $00FF; // старший байт
if ioType = 0 then
ioValue := word(Value)
else
ioValue := smallint(Value);
if aMultipler = 1 then
fValue := IntToStr(ioValue)
else
fValue := FloatToStrF(ioValue / aMultipler, ffFixed, 15,
NumberDecimals(aMultipler));
FoundIndex := fStatus.IndexOf(IoStatus);
if FoundIndex = -1 then
fValue := Format('%s (не определено)', [fValue])
else
fValue := Format('%s (%s)', [fValue, fStatus.Data[FoundIndex].ShortDescription]);
end;
finally
Unlock;
end;
Result := fValue;
end;
function TMap.ReadIpAddress(const aTypeTable: TTypeTable; const aOffSet: word): string;
var
Table: PTable;
Value: dword;
a, b, c, d: byte;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Value := PDWord(@Table^[aOffSet])^;
d := Value and $FF;
c := (Value shr 8) and $FF;
b := (Value shr 16) and $FF;
a := (Value shr 24) and $FF;
fValue := Format('%d.%d.%d.%d', [a, b, c, d]);
finally
Unlock;
end;
Result := fValue;
end;
function TMap.ReadUint8l(const aTypeTable: TTypeTable; const aOffSet: word): byte;
var
Table: PTable;
begin
Result := 0;
Table := Lock(aTypeTable);
try
Result := Lo(Table^[aOffSet]);
finally
Unlock;
end;
end;
function TMap.ReadUint8l(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadUint8l(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadUint8h(const aTypeTable: TTypeTable; const aOffSet: word): byte;
var
Table: PTable;
begin
Result := 0;
Table := Lock(aTypeTable);
try
Result := Hi(Table^[aOffSet]);
finally
Unlock;
end;
end;
function TMap.ReadUint8h(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadUint8h(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadUint16(const aTypeTable: TTypeTable; const aOffSet: word): word;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := Table^[aOffSet]
finally
Unlock;
end;
end;
function TMap.ReadUint16(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadUint16(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadUint32(const aTypeTable: TTypeTable; const aOffSet: word
): dword;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := PDWord(@Table^[aOffSet])^;
finally
Unlock;
end;
end;
function TMap.ReadUint32(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadUint32(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadSint16(const aTypeTable: TTypeTable; const aOffSet: word
): smallInt;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := PSmallint(@Table^[aOffSet])^
finally
Unlock;
end;
end;
function TMap.ReadSint16(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadSint16(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadSint32(const aTypeTable: TTypeTable; const aOffSet: word
): longint;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := PLongint(@Table^[aOffSet])^;
finally
Unlock;
end;
end;
function TMap.ReadSint32(const aTypeTable: TTypeTable; const aOffSet: word;
const aMultipler: dword): single;
begin
Result := ReadSint32(aTypeTable, aOffSet) / aMultipler;
end;
function TMap.ReadBitmap16(const aTypeTable: TTypeTable; const aOffSet: word
): word;
begin
Result := ReadUint16(aTypeTable, aOffSet);
end;
function TMap.ReadBitmap32(const aTypeTable: TTypeTable; const aOffSet: word
): dword;
begin
Result := ReadUint32(aTypeTable, aOffSet);
end;
function TMap.ReadFloat(const aTypeTable: TTypeTable; const aOffSet: word
): single;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := PSingle(@Table^[aOffSet])^;
finally
Unlock;
end;
end;
function TMap.ReadBool(const aTypeTable: TTypeTable; const aOffSet: word
): boolean;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(aTypeTable);
try
Result := boolean(Table^[aOffSet]);
finally
Unlock;
end;
end;
procedure TMap.Clear;
var
Table: PTable;
begin
// Таблица с данными
Table := Lock(ttInput);
try
ZeroMemory(Table, Length(Table^));
finally
Unlock;
end;
Table := Lock(ttHolding);
try
ZeroMemory(Table, Length(Table^));
finally
Unlock;
end;
end;
end.
|
unit uSupplierType;
interface
uses
uTypePersonInterface,uPerson,Windows,DB;
type
TSupplierType = class(TInterfacedObject,ITypePerson)
procedure Save(obj:TObject);
procedure Delete(obj:TObject);
function ListPerson(obj:TObject):string;
function PesquisarPessoa(obj:TObject):OleVariant;
function ListCombo:string;
procedure saveService(psService:string);
end;
implementation
uses
uSupplier,forms, SysUtils,Dialogs,uSupplierDao;
{ TSupplierType }
procedure TSupplierType.Delete(obj: TObject);
var
oCliente:TSupplierDao;
begin
oCliente := TSupplierDao.Create;
try
oCliente.DeleteSupplier((obj as TSupplier));
finally
FreeAndNil(oCliente);
end;
end;
function TSupplierType.ListPerson(obj: TObject): string;
var
oCliente:TSupplierDao;
begin
oCliente := TSupplierDao.Create;
try
result := oCliente.ListPerson((obj as TSupplier));
finally
FreeAndNil(oCliente);
end;
end;
function TSupplierType.ListCombo: string;
var
oCliente:TSupplierDao;
begin
try
oCliente := TSupplierDao.Create;
Result := oCliente.ListCombo;
finally
FreeAndNil(oCliente);
end;
end;
function TSupplierType.PesquisarPessoa(obj: TObject): OleVariant;
var
oCliente:TSupplierDao;
begin
try
oCliente := TSupplierDao.Create;
Result := oCliente.PesquisarPessoa((obj as TSupplier));
finally
FreeAndNil(oCliente);
end;
end;
procedure TSupplierType.Save(obj: TObject);
var
oCliente:TSupplierDao;
begin
try
try
oCliente := TSupplierDao.Create;
oCliente.save((obj as TSupplier));
finally
FreeAndNil(oCliente);
end;
ShowMessage('Saved successfully.');
except
ShowMessage('Error saving.');
raise;
end;
end;
procedure TSupplierType.saveService(psService:string);
var
oCliente:TSupplierDao;
begin
try
oCliente := TSupplierDao.Create;
oCliente.saveService(psService);
finally
FreeAndNil(oCliente);
end;
end;
end.
|
unit win.cpu;
interface
uses
Windows;
type
TArithmeticException = (
exInvalidOp,
exDenormalized,
exZeroDivide,
exOverflow,
exUnderflow,
exPrecision);
TFPUException = type TArithmeticException;
TSSEException = type TArithmeticException;
TFPUExceptionMask = set of TFPUException;
TSSEExceptionMask = set of TSSEException;
const
exAllArithmeticExceptions = [
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exInvalidOp,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exDenormalized,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exZeroDivide,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exOverflow,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exUnderflow,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exPrecision];
DefaultExceptionFlags = [
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exInvalidOp,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exZeroDivide,
{$IF CompilerVersion > 19}TArithmeticException.{$IFEND}exOverflow];
function SetFPUExceptionMask(const Mask: TFPUExceptionMask): TFPUExceptionMask;
function SetSSEExceptionMask(const Mask: TSSEExceptionMask): TSSEExceptionMask;
implementation
(*//
//防止Webbrowser中Flash抛出被0除的异常.
SetSSEExceptionMask(exAllArithmeticExceptions);
SetFPUExceptionMask(exAllArithmeticExceptions);
//*)
function SetFPUExceptionMask(const Mask: TFPUExceptionMask): TFPUExceptionMask;
var
CtlWord: Word;
begin
CtlWord := Get8087CW;
Set8087CW((CtlWord and $FFC0) or Byte(Mask));
Byte(Result) := CtlWord and $3F;
end;
function SetSSEExceptionMask(const Mask: TSSEExceptionMask): TSSEExceptionMask;
var
MXCSR: Word;
begin
{$IF CompilerVersion > 19}
MXCSR := GetMXCSR;
SetMXCSR((MXCSR and $FFFFE07F) or (Byte(Mask) shl 7));
Byte(Result) := (MXCSR shr 7) and $3F;
{$IFEND}
end;
end.
|
(* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1
*
* 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/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is TurboPower Abbrevia
*
* The Initial Developer of the Original Code is
* Robert Love
*
* Portions created by the Initial Developer are Copyright (C) 1997-2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* ***** END LICENSE BLOCK ***** *)
unit AbCabViewTests;
{$I AbDefine.inc}
interface
uses
AbCView, AbVisualTestBase;
type
TAbCabViewTests = class(TAbVisualTestCase)
private
Component : TAbCabView;
protected
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestDefaultStreaming;
procedure TestComponentLinks;
end;
implementation
uses
Menus, TestFrameWork, AbCBrows, AbTestFrameWork;
{ TAbCabViewTests }
procedure TAbCabViewTests.SetUp;
begin
inherited;
Component := TAbCabView.Create(TestForm);
end;
procedure TAbCabViewTests.TearDown;
begin
Component.Free;
inherited;
end;
procedure TAbCabViewTests.TestComponentLinks;
begin
TestComponentLink(Component, 'PopupMenu', TPopupMenu);
TestComponentLink(Component, 'CabComponent', TAbCabBrowser);
end;
procedure TAbCabViewTests.TestDefaultStreaming;
begin
inherited TestDefaultStreaming(Component);
end;
initialization
TestFramework.RegisterTest('Abbrevia.Component Level Test Suite',
TAbCabViewTests.Suite);
end.
|
unit uController;
{$mode objfpc}{$H+}
{$DEFINE DEBUG}// Альтернатива -dDEBUG
{$C+}// Альтернатива Включить Assert
interface
uses
Classes, SysUtils,
Windows,
uBase,
uModbus;
type
{ TController }
TController = class(TThreadSafePriorityQueue, IController)
private
fName: string;
// Флаг открыта ли очередь
fIsOpen: Integer;
// Указатель на объект транзакции: Tcp или Rtu
fTransaction: ITransaction;
// Дескриптор потока
fThreadId: TThreadId;
// Событие: прервать поток по требованию
fBreakEvent: THandle;
// Массив ожидаемых событий
fEvents: array[0..1] of THandle;
//
fTypeController: TTypeController;
private
function GetTransaction: ITransaction;
procedure SetTransaction(const aTransaction: ITransaction);
function GetTypeController: TTypeController;
procedure SetTypeController(const aTypeController: TTypeController);
public
constructor Create(const aCapacity: Word); override;
procedure AfterConstruction; override;
destructor Destroy; override;
procedure BeforeDestruction; override;
function ToString: string; override;
public
function IsOpen: Boolean;
procedure Open;
procedure Close;
function InQueue(const aFrame: IFrame): Boolean;
property Transaction: ITransaction read GetTransaction write SetTransaction;
property TypeController: TTypeController read GetTypeController write SetTypeController;
end;
implementation
const
ERROR_NOT_OPEN = 1;
ERROR_READY_OPEN = 2;
ERROR_PUSH = 3;
ERROR_THREAD = 4;
resourcestring
sERROR_NOT_OPEN = 'Контроллер отключен';
sERROR_READY_OPEN = 'Контроллер уже запущен';
sERROR_PUSH = 'Ошибка постановки запроса в очередь';
sERROR_THREAD = 'Ошибка выполнения потока';
{ TController }
function DeQueue(aParameter: Pointer): Integer;
var
Controller: TController;
Item: IPriorityItem;
begin
Result := 0;
{$IFDEF DEBUG}
Assert(aParameter <> nil);
Assert(TObject(aParameter) is TController);
{$ENDIF}
Controller := TController(aParameter);
while True do
case WaitForMultipleObjects(2, @Controller.fEvents, False, INFINITE) of
// Событие: Закрыть поток
WAIT_OBJECT_0:
Break;
// Событие: Чтение из очереди
WAIT_OBJECT_0 + 1:
// Пока очередь не пуста
while Controller.Pop(Item) do
// Выполнение транзакции
Controller.fTransaction.Transact(Item as IFrame);
else
// Ошибка функции ожидания
begin
Result := ERROR_THREAD;
Break;
end;
end;
end;
function TController.GetTransaction: ITransaction;
begin
Result := fTransaction;
end;
procedure TController.SetTransaction(const aTransaction: ITransaction);
begin
fTransaction := aTransaction;
end;
function TController.GetTypeController: TTypeController;
begin
Result := fTypeController;
end;
procedure TController.SetTypeController(const aTypeController: TTypeController);
begin
if fTypeController <> aTypeController then
fTypeController := aTypeController;
end;
constructor TController.Create(const aCapacity: Word);
begin
inherited Create(aCapacity);
fIsOpen := 0;
fBreakEvent := CreateEvent(nil, False, False, '');
end;
procedure TController.AfterConstruction;
begin
inherited AfterConstruction;
{$IFDEF DEBUG}
Assert(fPushEvent <> 0);
Assert(fBreakEvent <> 0);
{$ENDIF}
{$IFDEF DEBUG}
Assert(fErrors <> nil);
{$ENDIF}
// Массив событий
fEvents[0] := fBreakEvent;
fEvents[1] := fPushEvent;
// Карта ошибок
fErrors.Add(ERROR_NOT_OPEN, sERROR_NOT_OPEN);
fErrors.Add(ERROR_READY_OPEN, sERROR_READY_OPEN);
fErrors.Add(ERROR_PUSH, sERROR_PUSH);
fErrors.Add(ERROR_THREAD, sERROR_THREAD);
// Запуск потока изъятия элемента из списка
fThreadId := BeginThread(@DeQueue, Self);
end;
destructor TController.Destroy;
begin
CloseHandle(fBreakEvent);
inherited Destroy;
end;
procedure TController.BeforeDestruction;
const
TIMEOUT_CLOSE = 5000;
begin
// Закрыть очередь
Close;
// Закрытие потока
if fThreadId <> 0 then
begin
SetEvent(fBreakEvent);
WaitForThreadTerminate(fThreadId, TIMEOUT_CLOSE);
GetExitCodeThread(fThreadId, fLastError);
CloseThread(fThreadId);
fThreadId := 0;
end;
inherited BeforeDestruction;
end;
function TController.ToString: string;
var
S: string;
begin
case TypeController of
mbRtu:
begin
S := string((Transaction.Communication as IRtuCommunication).RtuConnection.PortName);
fName := Copy(S, 5, Length(S));
end;
mbAcTcp:
fName := Format ('%s (сервер)',
[(Transaction.Communication as ITcpCommunication).TcpConnection.GetIp]);
mbCnTcp:
fName := Format ('%s: %d',
[ITcpCommunication(Transaction.Communication as ITcpCommunication).TcpConnection.GetIp,
ITcpCommunication(Transaction.Communication as ITcpCommunication).TcpConnection.Port]);
end;
Result := fName;
end;
procedure TController.Open;
begin
{$IFDEF DEBUG}
Assert(fTransaction <> nil);
{$ENDIF}
Windows.InterLockedExchange(fIsOpen, 1);
end;
procedure TController.Close;
begin
Windows.InterLockedExchange(fIsOpen, 0);
Sleep(100);
Transaction.Communication.Disconnect;
end;
function TController.IsOpen: Boolean;
begin
Result := Windows.InterlockedCompareExchange(fIsOpen, 0, 0) = 1;
end;
function TController.InQueue(const aFrame: IFrame): Boolean;
begin
Result := False;
{$IFDEF DEBUG}
Assert(aFrame <> nil);
{$ENDIF}
// Контроллер закрыт
if not IsOpen then
begin
fLastError := ERROR_NOT_OPEN;
Exit;
end;
// Сброс события ожидания, если оно оказалось сигнальным в результате
// неудачной предыдущей транзакции
// aFrame.PrepareAsync;
aFrame.Responded:= False;
Result := Push(aFrame);
if not Result then
fLastError := ERROR_PUSH;
end;
end.
|
unit AqDrop.Core.Helpers.TArray;
interface
uses
System.SysUtils,
System.Classes;
type
TAqArray<T> = class
strict private
class procedure InternalForIn(const pArray: array of T; const pProcessingMethod: TFunc<T, Boolean>;
out pIndex: Int32; const pAscendingProcessing: Boolean = True); overload;
public
class procedure ForIn(const pArray: array of T; const pProcessingMethod: TProc<T>;
const pAscendingProcessing: Boolean = True); overload;
class procedure ForIn(const pArray: array of T; const pProcessingMethod: TFunc<T, Boolean>;
const pAscendingProcessing: Boolean = True); overload;
class function Find(const pArray: array of T; const pMatchFunction: TFunc<T, Boolean>; out pIndex: Int32;
const pAscendingSearch: Boolean = True): Boolean; overload;
class function Find(const pArray: array of T; const pMatchFunction: TFunc<T, Boolean>;
const pAscendingSearch: Boolean = True): Boolean; overload;
class procedure FillStrings(const pSource: array of T; const pTarget: TStrings);
class function FindItemEnum<TEnum {enum}>(const pValue: T; const pArray: array of T; out pEnum: TEnum): Boolean;
end;
implementation
uses
System.TypInfo,
System.Math,
System.Rtti,
System.Generics.Defaults,
AqDrop.Core.Exceptions,
AqDrop.Core.Helpers,
AqDrop.Core.Generics.Converters;
{ TAqArray<T> }
class procedure TAqArray<T>.InternalForIn(const pArray: array of T; const pProcessingMethod: TFunc<T, Boolean>;
out pIndex: Int32; const pAscendingProcessing: Boolean);
var
lEndIndex: Int32;
begin
if pAscendingProcessing then
begin
pIndex := 0;
lEndIndex := Length(pArray);
end else begin
pIndex := Length(pArray) - 1;
lEndIndex := 0;
end;
while (pAscendingProcessing xor (pIndex >= lEndIndex)) and pProcessingMethod(pArray[pIndex]) do
begin
Inc(pIndex, IfThen(pAscendingProcessing, 1, -1));
end;
end;
class procedure TAqArray<T>.FillStrings(const pSource: array of T; const pTarget: TStrings);
var
lValue: T;
begin
pTarget.Clear;
for lValue in pSource do
begin
pTarget.Add(TAqTypeConverters.Default.Convert<T, string>(lValue));
end;
end;
class function TAqArray<T>.Find(const pArray: array of T; const pMatchFunction: TFunc<T, Boolean>;
const pAscendingSearch: Boolean): Boolean;
var
lIndice: Int32;
begin
Result := Find(pArray, pMatchFunction, lIndice, pAscendingSearch);
end;
class function TAqArray<T>.FindItemEnum<TEnum>(const pValue: T; const pArray: array of T; out pEnum: TEnum): Boolean;
var
lTypeInfo: PTypeInfo;
lIndex: Int32;
begin
lTypeInfo := TypeInfo(TEnum);
if lTypeInfo^.Kind <> tkEnumeration then
begin
raise EAqInternal.Create('Uso inválido da função BuscarValorArray');
end;
Result := Find(pArray,
function(pItem: T): Boolean
var
lComparer: IComparer<T>;
begin
if TypeInfo(T) = TypeInfo(string) then
begin
lComparer := TDelegatedComparer<T>.Create(
function(const pLeft, pRight: T): Int32
begin
Result := IfThen(string.SameText(TValue.From<T>(pLeft).AsString, TValue.From<T>(pRight).AsString), 0, 1);
end);
end else
begin
lComparer := TComparer<T>.Default;
end;
Result := lComparer.Compare(pValue, pItem) = 0;
end, lIndex) and (lIndex >= lTypeInfo^.TypeData^.MinValue) and (lIndex <= lTypeInfo^.TypeData^.MaxValue);
if Result then
begin
case SizeOf(TEnum) of
1: pByte(@pEnum)^ := lIndex;
2: pWord(@pEnum)^ := lIndex;
4: pCardinal(@pEnum)^ := lIndex;
end;
end;
end;
class procedure TAqArray<T>.ForIn(const pArray: array of T; const pProcessingMethod: TProc<T>;
const pAscendingProcessing: Boolean);
begin
ForIn(pArray,
function(pItem: T): Boolean
begin
pProcessingMethod(pItem);
Result := True;
end, pAscendingProcessing);
end;
class procedure TAqArray<T>.ForIn(const pArray: array of T; const pProcessingMethod: TFunc<T, Boolean>;
const pAscendingProcessing: Boolean);
var
lIndex: Int32;
begin
InternalForIn(pArray, pProcessingMethod, lIndex, pAscendingProcessing);
end;
class function TAqArray<T>.Find(const pArray: array of T; const pMatchFunction: TFunc<T, Boolean>;
out pIndex: Int32; const pAscendingSearch: Boolean): Boolean;
var
lResult: Boolean;
begin
lResult := False;
InternalForIn(pArray,
function(pItem: T): Boolean
begin
lResult := pMatchFunction(pItem);
Result := not lResult;
end, pIndex, pAscendingSearch);
Result := lResult;
end;
end.
|
unit EnviarEmail;
interface
uses
Windows,Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, IdSMTP, Idpop3,
IdMessage, IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient, IdMessageClient,
WinInet, uDMPrincipal, IdIOHandler, IdIOHandlerSocket, IdSSLOpenSSL, IdText, IdAttachmentFile;
type
TEnviaMail = class
private
{ Private declarations }
public
function EnviarBoleto(Destinatario, TextoCorpo, Anexo: TStringList): Boolean;
function EnviarEmail(sUserEmail, sPassWord, sHost, sPorta, sAssunto, sFileCorpo : string;
bTLS, bAuth : Integer; sDestinatarios, sCC, sCCo : TStringList;
sTextoCorpo, sAnexo : TStrings): Boolean;
{ Public declarations }
end;
implementation
uses
IdAttachment, IdExplicitTLSClientServerBase;
{ TEnviaMail }
function TEnviaMail.EnviarBoleto(Destinatario, TextoCorpo, Anexo: TStringList): Boolean;
begin
Result := False;
try
EnviarEmail(DMPrincipal.qry_ParametrosEmail_Emitente.Value,
DMPrincipal.qry_ParametrosEmail_Senha.Value,
DMPrincipal.qry_ParametrosEmail_SMTP.Value,
DMPrincipal.qry_ParametrosEmail_Porta.AsString,
DMPrincipal.qry_ParametrosEmail_Assunto.Value,
'',
DMPrincipal.qry_ParametrosEmail_TLS.Value,
DMPrincipal.qry_ParametrosEmail_Autenticar.Value,
Destinatario,
nil,
nil,
TextoCorpo,
Anexo );
Result := True;
except
ShowMEssage('Erro ao enviar o email, verifique a configuração.');
exit;
end;
end;
function TEnviaMail.EnviarEmail(sUserEmail, sPassWord, sHost, sPorta, sAssunto, sFileCorpo: string; bTLS, bAuth: Integer; sDestinatarios, sCC,
sCCo: TStringList; sTextoCorpo, sAnexo: TStrings): Boolean;
var
i : Smallint;
A_IdSMTP : TIdSMTP;
A_IdSSLIOHandler : TIdSSLIOHandlerSocketOpenSSL;
A_IdMessage : TIdMessage;
A_Texto : TStringList;
begin
Result := False;
A_IdSMTP := TIdSMTP.Create(nil);
A_IdSSLIOHandler := TIdSSLIOHandlerSocketOpenSSL.Create();
A_IdMessage := TIdMessage.Create();
A_IdSMTP.Disconnect;
A_IdSMTP.Host := sHost;
A_IdSMTP.Port := StrToInt(sPorta);
A_IdSMTP.Username := sUserEmail;
A_IdSMTP.Password := sPassWord;
if bAuth = 1 then
A_IdSMTP.AuthType := atDefault
else
A_IdSMTP.AuthType := atNone;
if bTLS = 1 then
begin
A_IdSSLIOHandler.SSLOptions.Method := sslvTLSv1;
A_IdSSLIOHandler.SSLOptions.Mode := sslmClient;
A_IdSMTP.IOHandler := A_IdSSLIOHandler;
A_IdSMTP.UseTLS := utUseImplicitTLS;
end
else
begin
A_IdSMTP.IOHandler := nil;
A_IdSMTP.UseTLS := utNoTLSSupport;
end;
if pos('hotmail', LowerCase(sUserEmail)) > 0 then
begin
A_IdSSLIOHandler.SSLOptions.Method := sslvTLSv1;
A_IdSSLIOHandler.SSLOptions.Mode := sslmClient;
A_IdSMTP.IOHandler := A_IdSSLIOHandler;
A_IdSMTP.UseTLS := utUseExplicitTLS;
end;
A_IdMessage.Clear;
A_IdMessage.Body.Clear;
A_IdMessage.Recipients.Clear;
A_IdMessage.From.Address := sUserEmail;
A_IdMessage.From.Name := sUserEmail;
A_IdMessage.ReceiptRecipient.Address := sUserEmail;
A_IdMessage.Subject := sAssunto;
A_IdMessage.ContentType := 'multipart/mixed';
//dm.IdMessage1.ContentTransferEncoding := 'text/html';
for i := 0 to sDestinatarios.Count - 1 do
A_IdMessage.Recipients.EMailAddresses := sDestinatarios[i];
if sCC <> nil then
for i := 0 to sCC.Count - 1 do
A_IdMessage.CCList.EMailAddresses := sCC[i];
if sCCo <> nil then
for i := 0 to sCCo.Count - 1 do
A_IdMessage.BccList.EMailAddresses := sCCo[i];
if ((Trim(sFileCorpo) <> '') and FileExists(sFileCorpo)) then
if (Trim(sTextoCorpo.Text) <> '') And (sTextoCorpo <> nil) then
with TIdText.Create(A_IdMessage.MessageParts) do
begin
ContentType := 'text/html';
ContentTransfer := '7bit';
for i := 0 to sTextoCorpo.Count - 1 do
Body.Append(sTextoCorpo[i] + '<br>');
if (Trim(sFileCorpo) <> '') and FileExists(sFileCorpo) then
begin
A_Texto := TStringList.Create;
A_Texto.LoadFromFile(sFileCorpo);
Body.Append(A_Texto.Text);
FreeAndNil(A_Texto);
end;
end;
if sAnexo <> nil then
for i := 0 to sAnexo.Count - 1 do
if FileExists(TFileName(sAnexo[i])) then
with TIdAttachmentFile.Create(A_IdMessage.MessageParts, TFileName(sAnexo[i])) do
begin
//ContentType := 'application/octet-stream';
ContentDisposition := 'attachment';
ContentTransfer := 'base64';
end;
A_IdSMTP.Disconnect;
try
A_IdSMTP.Connect;
A_IdSMTP.Authenticate;
A_IdSMTP.Send(A_IdMessage);
A_IdSMTP.Disconnect;
Application.MessageBox('Mensagem enviada com sucesso', 'Aviso', MB_ICONINFORMATION);
Result := True;
except
Application.MessageBox('Houve um erro no envio da mensagem. Tente novamente!', 'Atenção', MB_ICONINFORMATION);
A_IdSMTP.Disconnect;
end;
FreeAndNil(A_IdMessage);
FreeAndNil(A_IdSSLIOHandler);
FreeAndNil(A_IdSMTP);
end;
end.
|
{
ClickForms
(C) Copyright 1998 - 2010, Bradford Technologies, Inc.
All Rights Reserved.
}
unit UTaskThread;
interface
uses
Classes;
type
{ forward declarations }
TTaskThread = class;
{ a callback procedure for performing a threaded task }
TTaskProcedure = procedure(const Thread: TTaskThread; const Data: Pointer) of object;
{ a thread for performing a generic tasks through callback procedures }
{ thread is always created suspended; call Resume to initiate }
TTaskThread = class(TThread)
private
FExceptionMessage: String;
FTaskData: Pointer;
FTaskProcedure: TTaskProcedure;
protected
procedure Execute; override;
public
constructor Create(const TaskProcedure: TTaskProcedure; const TaskData: Pointer);
property ExceptionMessage: String read FExceptionMessage;
property ReturnValue;
property Terminated;
end;
implementation
uses
ActiveX,
SysUtils;
{ --- TTaskThread ------------------------------------------------------------}
procedure TTaskThread.Execute;
begin
FExceptionMessage := '';
ReturnValue := S_OK;
CoInitialize(nil);
try
if Assigned(FTaskProcedure) then
FTaskProcedure(Self, FTaskData);
except
on E: Exception do
begin
// cannot return E_UNEXPECTED because EurekaLog has a heart attack and
// kills the whole program. Since there is no exception object,
// EurekaLog finds itself in a recursive never-ending chain of
// self-inflicted exceptions. All I can say is that EurekaLog gets what
// it deserves. All my sympathy is directed towards our suffering users.
ReturnValue := S_FALSE;
FExceptionMessage := E.Message;
end;
end;
CoUninitialize;
Terminate;
end;
constructor TTaskThread.Create(const TaskProcedure: TTaskProcedure; const TaskData: Pointer);
begin
FTaskProcedure := TaskProcedure;
FTaskData := TaskData;
inherited Create(True);
end;
end.
|
unit WhereClauseTests;
interface
uses
TestFrameWork,
SqlWhereClauseBuilder;
type
TWhereClauseTests = class(TTestCase)
private
builder: TSqlWhereClauseBuilder;
protected
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestThatStringEqualsConditionIsAdded;
procedure TestThatIntegerEqualsConditionIsAdded;
end;
implementation
procedure TWhereClauseTests.SetUp;
begin
builder:= TSqlWhereClauseBuilder.Create('');
end;
procedure TWhereClauseTests.TearDown;
begin
builder.Free;
builder:= nil;
inherited;
end;
procedure TWhereClauseTests.TestThatStringEqualsConditionIsAdded;
begin
CheckEqualsString('WHERE col="name"', builder.Where('col').Equals('name').build);
end;
procedure TWhereClauseTests.TestThatIntegerEqualsConditionIsAdded;
begin
CheckEqualsString('WHERE col=15', builder.Where('col').Equals(15).build);
end;
end. |
{******************************************************************************}
{ }
{ Indy (Internet Direct) - Internet Protocols Simplified }
{ }
{ https://www.indyproject.org/ }
{ https://gitter.im/IndySockets/Indy }
{ }
{******************************************************************************}
{ }
{ This file is part of the Indy (Internet Direct) project, and is offered }
{ under the dual-licensing agreement described on the Indy website. }
{ (https://www.indyproject.org/license/) }
{ }
{ Copyright: }
{ (c) 1993-2020, Chad Z. Hower and the Indy Pit Crew. All rights reserved. }
{ }
{******************************************************************************}
{ }
{ Originally written by: Fabian S. Biehn }
{ fbiehn@aagon.com (German & English) }
{ }
{ Contributers: }
{ Here could be your name }
{ }
{******************************************************************************}
unit IdOpenSSLHeaders_conferr;
interface
// Headers for OpenSSL 1.1.1
// conferr.h
{$i IdCompilerDefines.inc}
uses
IdCTypes,
IdGlobal,
IdOpenSSLConsts;
const
///*
// * CONF function codes.
// */
CONF_F_CONF_DUMP_FP = 104;
CONF_F_CONF_LOAD = 100;
CONF_F_CONF_LOAD_FP = 103;
CONF_F_CONF_PARSE_LIST = 119;
CONF_F_DEF_LOAD = 120;
CONF_F_DEF_LOAD_BIO = 121;
CONF_F_GET_NEXT_FILE = 107;
CONF_F_MODULE_ADD = 122;
CONF_F_MODULE_INIT = 115;
CONF_F_MODULE_LOAD_DSO = 117;
CONF_F_MODULE_RUN = 118;
CONF_F_NCONF_DUMP_BIO = 105;
CONF_F_NCONF_DUMP_FP = 106;
CONF_F_NCONF_GET_NUMBER_E = 112;
CONF_F_NCONF_GET_SECTION = 108;
CONF_F_NCONF_GET_STRING = 109;
CONF_F_NCONF_LOAD = 113;
CONF_F_NCONF_LOAD_BIO = 110;
CONF_F_NCONF_LOAD_FP = 114;
CONF_F_NCONF_NEW = 111;
CONF_F_PROCESS_INCLUDE = 116;
CONF_F_SSL_MODULE_INIT = 123;
CONF_F_STR_COPY = 101;
///*
// * CONF reason codes.
// */
CONF_R_ERROR_LOADING_DSO = 110;
CONF_R_LIST_CANNOT_BE_NULL = 115;
CONF_R_MISSING_CLOSE_SQUARE_BRACKET = 100;
CONF_R_MISSING_EQUAL_SIGN = 101;
CONF_R_MISSING_INIT_FUNCTION = 112;
CONF_R_MODULE_INITIALIZATION_ERROR = 109;
CONF_R_NO_CLOSE_BRACE = 102;
CONF_R_NO_CONF = 105;
CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE = 106;
CONF_R_NO_SECTION = 107;
CONF_R_NO_SUCH_FILE = 114;
CONF_R_NO_VALUE = 108;
CONF_R_NUMBER_TOO_LARGE = 121;
CONF_R_RECURSIVE_DIRECTORY_INCLUDE = 111;
CONF_R_SSL_COMMAND_SECTION_EMPTY = 117;
CONF_R_SSL_COMMAND_SECTION_NOT_FOUND = 118;
CONF_R_SSL_SECTION_EMPTY = 119;
CONF_R_SSL_SECTION_NOT_FOUND = 120;
CONF_R_UNABLE_TO_CREATE_NEW_SECTION = 103;
CONF_R_UNKNOWN_MODULE_NAME = 113;
CONF_R_VARIABLE_EXPANSION_TOO_LONG = 116;
CONF_R_VARIABLE_HAS_NO_VALUE = 104;
var
function ERR_load_CONF_strings: TIdC_INT;
implementation
end.
|
unit dmTareas;
interface
uses
SysUtils, Classes, DB, kbmMemTable, Windows, Messages, dmHandledDataModule,
UtilThread;
type
TTareaMessageType = (tmtInfo, tmtWarning, tmtError);
TTarea = class;
TOnPerCentNotify = procedure (const Sender: TTarea; const percent: integer) of object;
TEstadoTarea = (etIndeterminado, etCorriendo, etPausada, etParando);
TTareaMessage = record
fecha: TDateTime;
tipo: TTareaMessageType;
msg: string;
end;
PTareaMessage = ^TTareaMessage;
TOnMessageNotify = procedure (const Sender: TTarea; const pMsg: PTareaMessage) of object;
TTarea = class(TProtectedThread)
private
fHWnd: HWND;
FID: integer;
FOnPerCent: TOnPerCentNotify;
FOnMessage: TOnMessageNotify;
FMessages: array of TTareaMessage;
FMaxPosition: integer;
function GetPMessage(const index: integer): PTareaMessage;
function GetMessageCount: integer;
protected
lastPercent: integer;
procedure NotificarTareaEnd;
procedure DoPerCent(const percent: integer); virtual;
procedure DoMessage(const tipoMsg: TTareaMessageType; const mensaje: string); virtual;
procedure DoPerCentPos(const position: integer); virtual;
procedure InternalCancel; override;
property MaxPosition: integer read FMaxPosition write FMaxPosition;
public
constructor Create; reintroduce;
procedure Execute; override;
property PMessage[const index: integer]: PTareaMessage read GetPMessage;
property OnMessage: TOnMessageNotify read FOnMessage write FOnMessage;
property OnPerCent: TOnPerCentNotify read FOnPerCent write FOnPerCent;
property ID: integer read FID;
property Percent: integer read lastPercent;
property MessageCount: integer read GetMessageCount;
end;
TTareas = class(THandledDataModule)
kbmTareas: TkbmMemTable;
kbmTareasID: TIntegerField;
kbmTareasTIPO: TStringField;
kbmTareasDESCRIPCION: TStringField;
kbmTareasPRIORIDAD: TIntegerField;
kbmTareasPERCENT: TIntegerField;
kbmTareasESTADO: TIntegerField;
procedure kbmTareasPRIORIDADGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
procedure DataModuleCreate(Sender: TObject);
procedure DataModuleDestroy(Sender: TObject);
procedure kbmTareasESTADOGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
procedure kbmTareasPERCENTGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
private
lastID: integer;
listaTareas: TStringList;
criticalSection: TRTLCriticalSection;
procedure OnTareaMsg(const id: integer; const msgIndex: integer);
procedure OnTareaTerminated(const id: integer);
procedure OnTareaPerCent(const id: integer; const percent: integer);
function GetPriority: TThreadPriority;
procedure SetPriority(const Value: TThreadPriority);
function GetCount: integer;
function GetEstado: TEstadoTarea;
function GetTareas(const i: integer): TTarea;
protected
procedure WndMethod(var Msg: TMessage); override;
procedure Kill(const id: integer);
public
procedure Parar;
procedure Reanudar;
procedure Pausar;
procedure CancelarTodas;
function GetTarea(const id: integer): TTarea;
function GetTareaActual: TTarea;
function EjecutarTarea(const tarea: TTarea; const tipo, descripcion: string): integer;
property Priority: TThreadPriority read GetPriority write SetPriority;
property Count: integer read GetCount;
property Estado: TEstadoTarea read GetEstado;
property Tareas[const i: integer]: TTarea read GetTareas;
end;
function FormatTareaMessage(const pMsg: PTareaMessage): string;
function MessageTypeToString(const msgType: TTareaMessageType): string;
var Tareas: TTareas;
implementation
{$R *.dfm}
uses forms;
const
WM_TAREA_PER_CENT = WM_USER + 0;
WM_TAREA_MESSAGE = WM_USER + 1;
WM_TAREA_END = WM_USER + 2;
resourcestring
PRIORITY_IDLE = 'Bajísima';
PRIORITY_LOWEST = 'Muy baja';
PRIORITY_LOWER = 'Baja';
PRIORITY_NORMAL = 'Normal';
PRIORITY_HIGHER = 'Alta';
PRIORITY_HIGHEST = 'Muy alta';
PRIORITY_TIMECRITICAL = 'Altísima';
ESTADO_CORRIENDO = 'Corriendo';
ESTADO_PAUSADA = 'Pausada';
ESTADO_PARANDO = 'Parando';
MESSAGE_TYPE_INFO = 'I';
MESSAGE_TYPE_WARNING = 'W';
MESSAGE_TYPE_ERROR = 'E';
function MessageTypeToString(const msgType: TTareaMessageType): string;
begin
case msgType of
tmtInfo : result := MESSAGE_TYPE_INFO;
tmtWarning : result := MESSAGE_TYPE_WARNING;
tmtError : result := MESSAGE_TYPE_ERROR;
end;
end;
function FormatTareaMessage(const pMsg: PTareaMessage): string;
begin
result := '[' + DateTimeToStr(pMsg^.fecha) + '] [' +
MessageTypeToString(pMsg^.tipo) + '] ' + pMsg^.msg;
end;
{ TTareas }
function TTareas.EjecutarTarea(const tarea: TTarea; const tipo,
descripcion: string): integer;
begin
kbmTareas.Append;
kbmTareasID.Value := lastID;
kbmTareasTIPO.Value := tipo;
kbmTareasDESCRIPCION.Value := descripcion;
kbmTareasPERCENT.Clear;
kbmTareasPRIORIDAD.Value := Integer(tarea.Priority);
kbmTareasESTADO.Value := Integer(etCorriendo);
kbmTareas.Post;
listaTareas.AddObject(IntToStr(lastID), tarea);
tarea.FID := lastID;
tarea.fHWnd := Handle;
tarea.Resume;
result := lastID;
inc(lastID);
end;
procedure TTareas.CancelarTodas;
//var i: Integer;
begin
{ EnterCriticalSection(criticalSection);
for i := listaTareas.Count - 1 downto 0 do
TTarea(listaTareas.Objects[i]).Cancel;
LeaveCriticalSection(criticalSection);}
while listaTareas.Count > 0 do
Application.ProcessMessages;
end;
procedure TTareas.DataModuleCreate(Sender: TObject);
begin
InitializeCriticalSection(criticalSection);
listaTareas := TStringList.Create;
lastID := 0;
kbmTareas.Open;
end;
procedure TTareas.DataModuleDestroy(Sender: TObject);
begin
listaTareas.Free;
DeleteCriticalSection(criticalSection);
end;
function TTareas.GetCount: integer;
begin
result := listaTareas.Count;
end;
function TTareas.GetEstado: TEstadoTarea;
begin
result := TEstadoTarea(kbmTareasESTADO.Value);
end;
function TTareas.GetPriority: TThreadPriority;
begin
result := GetTareaActual.Priority;
end;
function TTareas.GetTarea(const id: integer): TTarea;
var i: integer;
begin
i := listaTareas.IndexOf(IntToStr(id));
if i = -1 then
result := nil
else
result := TTarea(listaTareas.Objects[i]);
end;
function TTareas.GetTareaActual: TTarea;
begin
result := GetTarea(kbmTareasID.Value);
end;
function TTareas.GetTareas(const i: integer): TTarea;
begin
result := TTarea(listaTareas.Objects[i]);
end;
procedure TTareas.Kill(const id: integer);
var i: integer;
begin
if kbmTareas.Locate('ID', id, []) then begin
kbmTareas.Delete;
i := listaTareas.IndexOf(IntToStr(id));
listaTareas.Delete(i);
end;
end;
procedure TTareas.Parar;
var tarea: TTarea;
begin
kbmTareas.Edit;
kbmTareasESTADO.Value := integer(etParando);
kbmTareas.Post;
tarea := GetTareaActual;
tarea.Cancel;
end;
procedure TTareas.Pausar;
begin
kbmTareas.Edit;
kbmTareasESTADO.Value := integer(etPausada);
kbmTareas.Post;
GetTareaActual.Suspend;
end;
procedure TTareas.Reanudar;
begin
kbmTareas.Edit;
kbmTareasESTADO.Value := integer(etCorriendo);
kbmTareas.Post;
GetTareaActual.Resume;
end;
procedure TTareas.SetPriority(const Value: TThreadPriority);
begin
kbmTareas.Edit;
kbmTareasPRIORIDAD.Value := Integer(Value);
kbmTareas.Post;
GetTareaActual.Priority := Value;
end;
procedure TTareas.kbmTareasESTADOGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
begin
if Sender.IsNull then
Text := ''
else begin
case TEstadoTarea(Sender.AsInteger) of
etCorriendo : Text := ESTADO_CORRIENDO;
etPausada : Text := ESTADO_PAUSADA;
etParando : Text := ESTADO_PARANDO;
end;
end;
end;
procedure TTareas.kbmTareasPERCENTGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
begin
if Sender.IsNull then
Text := ''
else
Text := Sender.AsString + '%';
end;
procedure TTareas.kbmTareasPRIORIDADGetText(Sender: TField; var Text: string;
DisplayText: Boolean);
begin
if Sender.IsNull then
Text := ''
else begin
case TThreadPriority(Sender.AsInteger) of
tpIdle : Text := PRIORITY_IDLE;
tpLowest : Text := PRIORITY_LOWEST;
tpLower : Text := PRIORITY_LOWER;
tpNormal : Text := PRIORITY_NORMAL;
tpHigher : Text := PRIORITY_HIGHER;
tpHighest : Text := PRIORITY_HIGHEST;
tpTimeCritical : Text := PRIORITY_TIMECRITICAL;
end;
end;
end;
procedure TTareas.WndMethod(var Msg: TMessage);
begin
case Msg.Msg of
WM_TAREA_PER_CENT: OnTareaPerCent(Msg.WParam, Msg.LParam);
WM_TAREA_MESSAGE: OnTareaMsg(Msg.WParam, Msg.LParam);
WM_TAREA_END: OnTareaTerminated(Msg.WParam);
end;
end;
procedure TTareas.OnTareaMsg(const id, msgIndex: integer);
var tarea: TTarea;
begin
tarea := GetTarea(id);
if Assigned(tarea.OnMessage) then
tarea.OnMessage(tarea, tarea.PMessage[msgIndex]);
end;
procedure TTareas.OnTareaPerCent(const id, percent: integer);
var bookmark: TBookmarkStr;
tarea: TTarea;
begin
bookmark := kbmTareas.Bookmark;
try
if kbmTareas.Locate('ID', id, []) then begin
kbmTareas.Edit;
kbmTareasPERCENT.Value := percent;
kbmTareas.Post;
end;
finally
kbmTareas.Bookmark := bookmark;
end;
tarea := GetTarea(id);
if (tarea <> nil) and (not tarea.Terminated) then begin
if Assigned(tarea.OnPerCent) then
tarea.OnPerCent(tarea, percent);
end;
end;
procedure TTareas.OnTareaTerminated(const id: integer);
begin
EnterCriticalSection(criticalSection);
Kill(id);
LeaveCriticalSection(criticalSection);
end;
{ TTarea }
constructor TTarea.Create;
begin
inherited Create(true);
lastPercent := 0;
SetLength(FMessages, 0);
end;
procedure TTarea.DoMessage(const tipoMsg: TTareaMessageType; const mensaje: string);
var count: integer;
begin
count := length(FMessages) + 1;
SetLength(FMessages, count);
// zero based
dec(count);
with FMessages[count] do begin
fecha := now;
tipo := tipoMsg;
msg := mensaje;
end;
PostMessage(fHWnd, WM_TAREA_MESSAGE, ID, count);
end;
procedure TTarea.DoPerCent(const percent: integer);
begin
if lastPercent <> percent then begin
lastPercent := percent;
PostMessage(fHWnd, WM_TAREA_PER_CENT, ID, percent);
end;
end;
procedure TTarea.DoPerCentPos(const position: integer);
begin
DoPerCent(Round(position / FMaxPosition * 100));
end;
procedure TTarea.Execute;
begin
inherited;
NotificarTareaEnd;
end;
function TTarea.GetMessageCount: integer;
begin
result := length(FMessages);
end;
function TTarea.GetPMessage(const index: integer): PTareaMessage;
begin
result := @FMessages[index];
end;
procedure TTarea.InternalCancel;
begin
inherited;
// NotificarTareaEnd;
end;
procedure TTarea.NotificarTareaEnd;
var m: TMsg;
begin
while PeekMessage(m, fHWnd, WM_TAREA_PER_CENT, WM_TAREA_END, PM_REMOVE) do;
SendMessage(fHWnd, WM_TAREA_END, ID, 0);
end;
end.
|
unit UParameters;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Buttons;
type
TFrmParameters = class(TForm)
Label1: TLabel;
EdStockWarning: TEdit;
EStockWarning: TLabel;
BtSave: TBitBtn;
Label2: TLabel;
EEndWarning: TLabel;
EdEndWarning: TEdit;
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure FormCreate(Sender: TObject);
procedure BtSaveClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
FrmParameters: TFrmParameters;
implementation
{$R *.dfm}
uses UParametersHelper, UValidator;
procedure TFrmParameters.BtSaveClick(Sender: TObject);
var
Error: boolean;
begin
Error := false;
EStockWarning.Visible := false;
EEndWarning.Visible := false;
if Trim(EdStockWarning.Text) = '' then
begin
EStockWarning.Caption := 'Campo Obrigatório';
EStockWarning.Visible := true;
Error := true;
end
else
begin
if not UValidator.IsNumber(EdStockWarning.Text) then
begin
EStockWarning.Caption := 'Número inválido';
EStockWarning.Visible := true;
Error := true;
end;
end;
if Trim(EdEndWarning.Text) = '' then
begin
EEndWarning.Caption := 'Campo Obrigatório';
EEndWarning.Visible := true;
Error := true;
end
else
begin
if not UValidator.IsNumber(EdEndWarning.Text) then
begin
EEndWarning.Caption := 'Número inválido';
EEndWarning.Visible := true;
Error := true;
end;
end;
if not Error then
begin
UParametersHelper.SetParameter(UParametersHelper.StockWarning,
EdStockWarning.Text);
UParametersHelper.SetParameter(UParametersHelper.EndWarning,
EdEndWarning.Text);
Close;
end;
end;
procedure TFrmParameters.FormClose(Sender: TObject; var Action: TCloseAction);
begin
FrmParameters := nil;
end;
procedure TFrmParameters.FormCreate(Sender: TObject);
var
StockWarning, EndWarning: String;
begin
StockWarning := UParametersHelper.GetParameter
(UParametersHelper.StockWarning);
if StockWarning = '' then
begin
EdStockWarning.Text := IntToStr(UParametersHelper.DefaultStockWarning);
end
else
begin
EdStockWarning.Text := StockWarning;
end;
EndWarning := UParametersHelper.GetParameter(UParametersHelper.EndWarning);
if EndWarning = '' then
begin
EdEndWarning.Text := IntToStr(UParametersHelper.DefaultEndWarning);
end
else
begin
EdEndWarning.Text := EndWarning;
end;
end;
end.
|
{* *****************************************************************************
PROYECTO FACTURACION ELECTRONICA
Copyright (C) 2010-2014 - Bambú Code SA de CV - Ing. Luis Carrasco
Esta clase representa la implementación para timbrado de CFDI del proveedor
Ecodex (http://www.finkok.com)
Este archivo pertenece al proyecto de codigo abierto de Bambú Code:
http://bambucode.com/codigoabierto
La licencia de este código fuente se encuentra en:
http://github.com/bambucode/tfacturaelectronica/blob/master/LICENCIA
***************************************************************************** *}
unit PACFinkOk;
interface
uses Types,
xmldom,
XMLIntf,
msxmldom,
XMLDoc,
SysUtils,
ProveedorAutorizadoCertificacion,
FacturaTipos,
FETimbreFiscalDigital,
Math,
feCFDv32,
FinkOkWsTimbrado,
FacturaReglamentacion,
FeCFD;
type
PStringArray = ^StringArray;
{$REGION 'Documentation'}
/// <summary>
/// Implementa el servicio de timbrado para CFDI del proveedor "FinkOk"
/// (<see href="http://www.finkok.com" />)
/// </summary>
{$ENDREGION}
TPACFinkOk = class(TProveedorAutorizadoCertificacion)
private
fCredenciales : TFEPACCredenciales;
fDocumentoXMLTimbrado : TXMLDocument;
wsTimbradoFinkOk: IFinkOkServicioTimbrado;
wsCancelaFinkOk: IFinkOkCancelaTimbrado;
wsAltaClienteFinkOk: IFinkOkAltaCliente;
function AsignarTimbreDeRespuestaDeFinkOk(const aRespuestaTimbrado: TFinkOkRespuestaTimbrado): TFETimbre;
function ObtenerURLTimbrado: String;
function ValidarXML(const xmlFile : TFileName) : String; //unicamente valida la estructura del xml solo se usaria para desarrollo
function UTF8Bytes(const s: UTF8String): TBytedynArray;
public
destructor Destroy(); override;
procedure AfterConstruction; override;
procedure AsignarCredenciales(const aCredenciales: TFEPACCredenciales); override;
function CancelarDocumento(const aDocumento: String): Boolean; override;
function TimbrarDocumento(const aDocumento: TTipoComprobanteXML): TFETimbre; override;
Function AgregaCliente(const aRFC: String):String; override;
Function EditaCliente(const Activar: Boolean;const aRFC:String):String; override;
Function BorraCliente(const aRFC: String):String; override;
end;
implementation
uses {$IF Compilerversion >= 20} Soap.InvokeRegistry, {$IFEND}
CodeSiteLogging;
function TPACFinkOk.UTF8Bytes(const s: UTF8String): TBytedynArray; // sacada de http://stackoverflow.com/questions/5233480/string-to-byte-array-in-utf-8
begin
{$IF Compilerversion >= 20}Assert(StringElementSize(s)=1){$IFEND};
SetLength(Result, Length(s));
if Length(Result)>0 then
Move(s[1], Result[0], Length(s));
end;
destructor TPACFinkOk.Destroy();
begin
// Al ser una interface el objeto TXMLDocument se libera automaticamente por Delphi al dejar de ser usado
// aunque para asegurarnos hacemos lo siguiente:
inherited;
end;
procedure TPACFinkOk.AfterConstruction;
begin
fDocumentoXMLTimbrado := TXMLDocument.Create(nil);
fDocumentoXMLTimbrado.Active := True;
// Obtenemos una instancia del WebService de Timbrado de FinkOk
wsTimbradoFinkOk := GetFinkOkTimbrado(False,'',nil);
wsCancelaFinkOk := GetFinkOkCancelar(False,'',nil);
wsAltaClienteFinkOk:= GetFinkOkCliente(False,'',nil);
end;
procedure TPACFinkOk.AsignarCredenciales(const aCredenciales: TFEPACCredenciales);
begin
fCredenciales := aCredenciales;
end;
Function TPACFinkOk.AgregaCliente(const aRFC: String):String;
var
respuestaTimbrado: IFinkOkRespuestaRegistro;
begin
respuestaTimbrado := wsAltaClienteFinkOk.Add(fCredenciales.RFC,fCredenciales.Clave,Trim(aRFC),'','');
if respuestaTimbrado.success then
Result:=respuestaTimbrado.message
Else
CodeSite.Send('El Cliente no se pudo agregar '+respuestaTimbrado.message);
End;
Function TPACFinkOk.EditaCliente(const Activar: Boolean;const aRFC:String):String;
var
respuestaTimbrado: IFinkOkRespuestaRegistro;
begin
if Activar then
respuestaTimbrado := wsAltaClienteFinkOk.edit(fCredenciales.RFC,fCredenciales.Clave,Trim(aRFC),'A')
Else
respuestaTimbrado := wsAltaClienteFinkOk.edit(fCredenciales.RFC,fCredenciales.Clave,Trim(aRFC),'S');
if respuestaTimbrado.success then
Result:=respuestaTimbrado.message
Else
CodeSite.Send('El Cliente no se pudo modificar '+respuestaTimbrado.message);
End;
Function TPACFinkOk.BorraCliente(const aRFC: String):String;
var
respuestaTimbrado: IFinkOkRespuestaRegistro;
begin
respuestaTimbrado := wsAltaClienteFinkOk.delete(fCredenciales.RFC,fCredenciales.Clave,Trim(aRFC));
if respuestaTimbrado.success then
Result:=respuestaTimbrado.message
Else
CodeSite.Send('El Cliente no se pudo eliminar '+respuestaTimbrado.message);
End;
function TPACFinkOk.ObtenerURLTimbrado: String;
begin
end;
//unicamente valida la estructura del xml solo se usaria para desarrollo
function TPACFinkOk.ValidarXML(const xmlFile : TFileName) : String;
begin
try
fDocumentoXMLTimbrado.LoadFromFile(xmlFile) ;
fDocumentoXMLTimbrado.Active := true; //esto valida
result := '';
except
on EX : EDOMParseError do
begin
Result:='XML Invalido: ' + Ex.Message ;
end;
end;
end;
function TPACFinkOk.AsignarTimbreDeRespuestaDeFinkOk(const aRespuestaTimbrado:
TFinkOkRespuestaTimbrado): TFETimbre;
var
comprobanteTimbrado: IFEXMLComprobanteV32;
nodoXMLTimbre: IFEXMLtimbreFiscalDigital;
documentoXMLTimbrado, documentoXMLTimbre: TXmlDocument;
begin
Assert(aRespuestaTimbrado <> nil, 'La respuesta del servicio de timbrado fue nula');
// Creamos el documento XML para almacenar el XML del comprobante completo que nos regresa Ecodex
documentoXMLTimbrado := TXMLDocument.Create(nil);
documentoXMLTimbrado.Active := True;
documentoXMLTimbrado.Version := '1.0';
documentoXMLTimbrado.Encoding := 'utf-8';
{$IF Compilerversion >= 20}
// Delphi 2010 y superiores
documentoXMLTimbrado.XML.Text:=aRespuestaTimbrado.xml;
{$ELSE}
documentoXMLTimbrado.XML.Text:=UTF8Encode(aRespuestaTimbrado.XML);
{$IFEND}
documentoXMLTimbrado.Active:=True;
// Convertimos el XML a la interfase del CFD v3.2
comprobanteTimbrado := GetComprobanteV32(documentoXMLTimbrado);
// Extraemos solamente el nodo del timbre
Assert(IFEXMLComprobanteV32(comprobanteTimbrado).Complemento.HasChildNodes,
'No se recibio correctamente el timbre');
Assert(IFEXMLComprobanteV32(comprobanteTimbrado).Complemento.ChildNodes.Count = 1,
'Se debio haber tenido solo el timbre como complemento');
// Creamos el documento XML solamente del timbre
documentoXMLTimbre := TXMLDocument.Create(nil);
documentoXMLTimbre.XML.Text := IFEXMLComprobanteV32(comprobanteTimbrado).Complemento.ChildNodes.First.XML;
documentoXMLTimbre.Active := True;
// Convertimos el XML del nodo a la interfase del Timbre v3.2
nodoXMLTimbre := GetTimbreFiscalDigital(documentoXMLTimbre);
// Extraemos las propiedades del timbre para regresarlas en el tipo TFETimbre
Result.Version:=nodoXMLTimbre.Version;
Result.UUID:=nodoXMLTimbre.UUID;
Result.FechaTimbrado:=TFEReglamentacion.DeFechaHoraISO8601(nodoXMLTimbre.FechaTimbrado);
Result.SelloCFD:=nodoXMLTimbre.SelloCFD;
Result.NoCertificadoSAT:=nodoXMLTimbre.NoCertificadoSAT;
Result.SelloSAT:=nodoXMLTimbre.SelloSAT;
Result.XML := nodoXMLTimbre.XML;
end;
function TPACFinkOk.TimbrarDocumento(const aDocumento: TTipoComprobanteXML): TFETimbre;
var
nodoXMLTimbre : IFEXMLtimbreFiscalDigital;
respuestaTimbrado: TFinkOkRespuestaTimbrado;
sXML:TByteDynArray;
begin
sXML := UTF8Bytes(aDocumento);
try
respuestaTimbrado := wsTimbradoFinkOk.stamp(sXML,fCredenciales.RFC,fCredenciales.Clave);
if Trim(respuestaTimbrado.CodEstatus) <> '' then
Result := AsignarTimbreDeRespuestaDeFinkOk(respuestaTimbrado)
except
On E:Exception do
begin
if Trim(respuestaTimbrado.CodEstatus) = '' then
begin
CodeSite.Send('Falla Validacion Error No.', respuestaTimbrado.Incidencias[0].CodigoError);
CodeSite.Send('Falla Validacion Desc:', respuestaTimbrado.Incidencias[0].MensajeIncidencia);
end;
end else
raise;
end;
end;
function TPACFinkOk.CancelarDocumento(const aDocumento: string): Boolean;
begin
// TODO: TPACComercioDigital.CancelarDocumento
// TODO: TPACFinkOk.CancelarDocumento
// TODO: TPACFinkOk.CancelarDocumento
end;
end.
|
unit BuilderPizzaExample.View.Main;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
BuilderPizzaExample.Domain.IPizza, Vcl.ExtCtrls;
type
TfrmMain = class(TForm)
mmResult: TMemo;
pnlTop: TPanel;
btnCreateProducts: TButton;
procedure btnCreateProductsClick(Sender: TObject);
private
procedure CreateProducts;
public
end;
var
frmMain: TfrmMain;
implementation
uses
BuilderPizzaExample.Director.MenuServices,
BuilderPizzaExample.Builder.Product.PizzaPepperoni,
BuilderPizzaExample.Builder.Product.PizzaHouseStyle,
BuilderPizzaExample.Processors.CalculatePrice,
BuilderPizzaExample.Domain.ValueObject.PizzaSize,
BuilderPizzaExample.Domain.ValueObject.EdgeType,
BuilderPizzaExample.Domain.ValueObject.EdgeSize,
BuilderPizzaExample.Domain.Edge,
BuilderPizzaExample.Util.View;
{$R *.dfm}
procedure TfrmMain.btnCreateProductsClick(Sender: TObject);
begin
mmResult.Clear;
CreateProducts;
end;
procedure TfrmMain.CreateProducts;
begin
mmResult.Lines.Add(TUtilsView.View('Pizza 1: ',
TMenuServices.New.PreparePizzaWihEdge(TPizzaPepperoni.New
(TCalculatePrice.New), TPizzaSize.Small, TEdge.New(TEdgeType.Catupiry,
TEdgeSize.Normal)).GetProduct));
mmResult.Lines.Add(TUtilsView.View('Pizza 2: ',
TMenuServices.New.PreparePizzaWihoutEdge(TPizzaPepperoni.New
(TCalculatePrice.New), TPizzaSize.Big).GetProduct));
mmResult.Lines.Add(TUtilsView.View('Pizza 3: ',
TMenuServices.New.PreparePizzaWihEdge(TPizzaHouseStyle.New
(TCalculatePrice.New), TPizzaSize.Normal, TEdge.New(TEdgeType.Cheddar,
TEdgeSize.Normal)).GetProduct));
mmResult.Lines.Add(TUtilsView.View('Pizza 4: ',
TMenuServices.New.PreparePizzaWihoutEdge(TPizzaHouseStyle.New
(TCalculatePrice.New), TPizzaSize.Family).GetProduct));
mmResult.Lines.Add(TUtilsView.View('Pizza 5: ',
TMenuServices.New.PreparePizzaWihEdge(TPizzaPepperoni.New
(TCalculatePrice.New), TPizzaSize.Big, TEdge.New(TEdgeType.Chocolate,
TEdgeSize.Thick)).GetProduct));
end;
initialization
ReportMemoryLeaksOnShutdown := True;
end.
|
unit uGlobal;
interface
uses
System.Classes, System.SysUtils, System.Types, System.Variants, System.IOUtils,
System.Math,
FireDAC.Comp.Client, Data.DB;
type
TIntDyadicArray = array of TIntegerDynArray;
TWorkState = (wsNone, wsInputData, wsInputResultData, wsClearColumn, wsExportToFile, wsExecuting);
TFDConnectionHelp = class helper for TFDConnection
procedure SQLiteBuildTable(ATableName, ASQL: string);
end;
TDataSetHelp = class helper for TDataSet
procedure LoadFromFile(AFileName: string; AMethod: TDataSetNotifyEvent = nil);
end;
const
i64: Int64 = 1;
var
AppFilePath: string;
function SeparateDigit(var s: string): string;
procedure StrToIntArray(s: string; var Arr: TIntegerDynArray; Offset: Integer = 0); overload;
procedure StrToIntArray(s: string; var Arr, Arr2: TIntegerDynArray); overload;
function BuildGUID: string;
procedure ShellSort(var x: TIntegerDynArray);
implementation
procedure TFDConnectionHelp.SQLiteBuildTable(ATableName: string; ASQL: string);
var
s: string;
begin
s := Format('SELECT COUNT(*) FROM sqlite_master WHERE type = ''table'' AND name = ''%s''', [ATableName]);
if VarToStr(ExecSQLScalar(s)).ToInteger = 0 then ExecSQL(ASQL);
end;
procedure TDataSetHelp.LoadFromFile(AFileName: string; AMethod: TDataSetNotifyEvent = nil);
var
l: TStringList;
s, FileExt, sColNo: string;
i, RowNo, ColNo, ValueCount: Integer;
f: TField;
begin
if not TFile.Exists(AFileName) then Exit;
l := TStringList.Create;
try
FileExt := ExtractFileExt(AFileName);
if LowerCase(FileExt).Equals('.txt') then l.LoadFromFile(AFileName)
else if LowerCase(FileExt).Equals('.xls') or LowerCase(FileExt).Equals('.xlsx') then
begin
end
else Exit;
for i := 0 to l.Count - 1 do
begin
if not TryStrToInt(l.Names[i].Trim, RowNo) then Continue;
s := l.ValueFromIndex[i].Trim;
ValueCount := 0;
Append;
repeat
sColNo := SeparateDigit(s);
if TryStrToInt(sColNo, ColNo) then
begin
f := FieldByName('Field' + Ceil(ColNo / 64).ToString);
f.AsLargeInt := f.AsLargeInt or (i64 shl (64 - ColNo));
Inc(ValueCount);
end;
until s.IsEmpty;
f := FindField('ValueCount');
if Assigned(f) then f.AsInteger := ValueCount;
f := FindField('RowNo');
if Assigned(f) then f.AsInteger := RowNo;
if Assigned(AMethod) then AMethod(Self);
Post;
end;
finally
l.Free;
end;
end;
function SeparateDigit(var s: string): string;
var
i: Integer;
c: Char;
begin
Result := '';
i := 0;
if s.Trim.IsEmpty then
begin
s := '';
Exit;
end;
for c in s do
begin
if c in ['0'..'9'] then Result := Result + c
else
begin
if not Result.IsEmpty then Break;
end;
Inc(i);
end;
s := s.Substring(i)
end;
procedure StrToIntArray(s: string; var Arr: TIntegerDynArray; Offset: Integer = 0);
var
sColNo: string;
ColNo: Integer;
HasMinus: Boolean;
begin
HasMinus := s.IndexOf('-') > -1;
SetLength(Arr, 0);
repeat
sColNo := SeparateDigit(s);
if TryStrToInt(sColNo, ColNo) then
begin
if HasMinus and (s.IndexOf('-') = -1) then ColNo := ColNo + Offset;
SetLength(Arr, Length(Arr) + 1);
Arr[Length(Arr) - 1] := ColNo;
end;
until s = '';
end;
procedure StrToIntArray(s: string; var Arr, Arr2: TIntegerDynArray);
var
sColNo: string;
ColNo: Integer;
HasMinus: Boolean;
begin
HasMinus := s.IndexOf('-') > -1;
SetLength(Arr, 0);
SetLength(Arr2, 0);
repeat
sColNo := SeparateDigit(s);
if TryStrToInt(sColNo, ColNo) then
begin
if HasMinus and (s.IndexOf('-') = -1) then
begin
SetLength(Arr2, Length(Arr2) + 1);
Arr2[Length(Arr2) - 1] := ColNo;
end
else
begin
SetLength(Arr, Length(Arr) + 1);
Arr[Length(Arr) - 1] := ColNo;
end;
end;
until s = '';
end;
function BuildGUID: string;
begin
Result := TGUID.NewGuid.ToString.Replace('-', '').Replace('{', '').Replace('}', '');
Result := LowerCase(Result);
end;
procedure ShellSort(var x: TIntegerDynArray);
var
h, i,j ,intTmp: Integer;
begin
h:=high(x) div 2;
while h>0 do
begin
for i:=h to high(x) do
begin
j:=i;
while (j>=h) and (x[j-h]>x[j]) do
begin
intTmp:=x[j-h];
x[j-h]:=x[j];
x[j]:=intTmp;
j:=j-h;
end;
end;
h:=h div 2;
end;
end;
initialization
finalization
end.
|
(*----------------------------------------------------------*)
(* Übung 3 ; Beispiel 4 Ranking *)
(* Entwickler: Neuhold Michael *)
(* Datum: 24.10.2018 *)
(* Lösungsidee: Eingabe von pos. & neg. Umfragewerten von *)
(* 6 unterschiedlichen Parteien; *)
(* "grafische" Darstellung der Umfragewerte *)
(*----------------------------------------------------------*)
PROGRAM Ranking;
(*
Runden der Eingabe Werte auf die naheliegenste 10er Stelle
und Divison durch 10 für die Darstellung mit dem Zeichen X
für 10%.
*)
FUNCTION RundeEingabe(zahl:INTEGER) : INTEGER;
VAR
rest : INTEGER;
BEGIN
IF zahl < 0 THEN
zahl := zahl * (-1);
rest := zahl MOD 10;
IF rest <= 4 THEN
RundeEingabe := (zahl-rest) DIV 10
ELSE
RundeEingabe := (zahl+(10-rest)) DIV 10;
END; (* RundeEingabe *)
(*
FOR Schleife wurde wegen mehrfacher
Verwendung ausgelagert.
*)
PROCEDURE AusgabeZaehlen(n: INTEGER; ch: CHAR);
VAR
i : INTEGER;
BEGIN
FOR i := 1 TO n DO BEGIN
Write(ch);
END;
END; (* AusgabeZaehlen *)
(*
Auslagerung für die "grafische" Ausgabe, damit das
Hauptprogramm übersichtlich bleibt.
*)
PROCEDURE Ausgabe(nr: INTEGER; neg:INTEGER; pos:INTEGER);
VAR
blanks : INTEGER; (* blanks bezieht sich auf die '-' in der Ausgabe *)
BEGIN
blanks := 10 - neg;
write('| ',nr,'. ');
IF (neg + pos) <= 10 THEN
BEGIN
AusgabeZaehlen(blanks,'-');
AusgabeZaehlen(neg,'X');
Write('|');
AusgabeZaehlen(pos,'X');
blanks := 10 - pos;
AusgabeZaehlen(blanks,'-');
WriteLn('|');
END
ELSE
WriteLn('--------Error--------|');
END; (* Ausgabe *)
(*
Main
*)
VAR
parteien_pos : ARRAY[1..6] OF INTEGER;
parteien_neg : ARRAY[1..6] OF INTEGER;
i : INTEGER;
BEGIN
WriteLn('Bitte die Umfragewerte in dieser Reihenfolge eingeben:');
WriteLn('ÖVP, FPÖ, NEOS, GRÜNE, LP, SPÖ');
FOR i := 1 TO 6 DO BEGIN
Write('Partei ',i,' Positiver Wert: ');
ReadLn(parteien_pos[i]);
parteien_pos[i] := RundeEingabe(parteien_pos[i]);
Write('Partei ',i,' Negativer Wert: ');
ReadLn(parteien_neg[i]);
parteien_neg[i] := RundeEingabe(parteien_neg[i]);
END;
WriteLn('___________________________');
WriteLn('| NR Negativ | Positiv |');
WriteLn('|______________|__________|');
FOR i := 1 TO 6 DO BEGIN
Ausgabe(i, parteien_neg[i], parteien_pos[i]);
END;
WriteLn('|_________________________|');
END. (* Ranking *) |
unit jclass_items;
{$mode objfpc}{$H+}
interface
uses
Classes,
SysUtils,
jclass_common,
jclass_attributes,
jclass_enum,
jclass_constants,
jclass_common_abstract;
type
{ TJClassItem }
TJClassItem = class(TJClassLoadable)
protected
FAccessFlags: UInt16;
FNameIndex: UInt16;
FDescriptorIndex: UInt16;
FAttributes: TJClassAttributes;
FClassFile: TJClassFileAbstract;
public
procedure BuildDebugInfo(AIndent: string; AOutput: TStrings); override;
property AccessFlags: UInt16 read FAccessFlags;
property NameIndex: UInt16 read FNameIndex;
property DescriptorIndex: UInt16 read FDescriptorIndex;
property Attributes: TJClassAttributes read FAttributes;
constructor Create(AClassFile: TJClassFileAbstract);
destructor Destroy; override;
end;
implementation
{ TJClassItem }
procedure TJClassItem.BuildDebugInfo(AIndent: string; AOutput: TStrings);
begin
AOutput.Add('%sName: %s', [AIndent, FClassFile.FindUtf8Constant(FNameIndex)]);
AOutput.Add('%sFlags: %.8x', [AIndent, FAccessFlags]);
AOutput.Add('%sDescriptor %s', [AIndent, FClassFile.FindUtf8Constant(FDescriptorIndex)]);
AOutput.Add('%sAttributes', [AIndent]);
FAttributes.BuildDebugInfo(AIndent + ' ', AOutput);
end;
constructor TJClassItem.Create(AClassFile: TJClassFileAbstract);
begin
FClassFile := AClassFile;
FAttributes := TJClassAttributes.Create(AClassFile);
end;
destructor TJClassItem.Destroy;
begin
FAttributes.Free;
inherited Destroy;
end;
end.
|
unit HGM.IpInfo;
interface
uses
System.SysUtils, System.Types, System.Classes, System.Net.HttpClient, REST.Json;
type
TDomains = class
private
FDomains: TArray<string>;
FIp: string;
FTotal: Integer;
public
property Domains: TArray<string> read FDomains write FDomains;
property Ip: string read FIp write FIp;
property Total: Integer read FTotal write FTotal;
end;
TAbuse = class
private
FAddress: string;
FCountry: string;
FEmail: string;
FName: string;
FNetwork: string;
FPhone: string;
public
property Address: string read FAddress write FAddress;
property Country: string read FCountry write FCountry;
property Email: string read FEmail write FEmail;
property Name: string read FName write FName;
property Network: string read FNetwork write FNetwork;
property Phone: string read FPhone write FPhone;
end;
TPrivacy = class
private
FHosting: Boolean;
FProxy: Boolean;
FTor: Boolean;
FVpn: Boolean;
public
property Hosting: Boolean read FHosting write FHosting;
property Proxy: Boolean read FProxy write FProxy;
property Tor: Boolean read FTor write FTor;
property Vpn: Boolean read FVpn write FVpn;
end;
TCompany = class
private
FDomain: string;
FName: string;
FType: string;
public
property Domain: string read FDomain write FDomain;
property Name: string read FName write FName;
property&Type: string read FType write FType;
end;
TAsn = class
private
FAsn: string;
FDomain: string;
FName: string;
FRoute: string;
FType: string;
public
property Asn: string read FAsn write FAsn;
property Domain: string read FDomain write FDomain;
property Name: string read FName write FName;
property Route: string read FRoute write FRoute;
property&Type: string read FType write FType;
end;
TDetails = class
private
FAbuse: TAbuse;
FAnycast: Boolean;
FAsn: TAsn;
FCity: string;
FCompany: TCompany;
FCountry: string;
FDomains: TDomains;
FHostname: string;
FIp: string;
FLoc: string;
FPostal: Boolean;
FPrivacy: TPrivacy;
FRegion: string;
FTimezone: string;
public
property Abuse: TAbuse read FAbuse write FAbuse;
property Anycast: Boolean read FAnycast write FAnycast;
property Asn: TAsn read FAsn write FAsn;
property City: string read FCity write FCity;
property Company: TCompany read FCompany write FCompany;
property Country: string read FCountry write FCountry;
property Domains: TDomains read FDomains write FDomains;
property Hostname: string read FHostname write FHostname;
property Ip: string read FIp write FIp;
property Loc: string read FLoc write FLoc;
property Postal: Boolean read FPostal write FPostal;
property Privacy: TPrivacy read FPrivacy write FPrivacy;
property Region: string read FRegion write FRegion;
property Timezone: string read FTimezone write FTimezone;
constructor Create;
destructor Destroy; override;
end;
TIpInfo = class
private
FToken: string;
FHTTP: THTTPClient;
FEndPointUrl: string;
procedure SetEndPointUrl(const Value: string);
public
constructor Create(const AToken: string = ''); reintroduce;
destructor Destroy; override;
function GetDetails(out Value: TDetails; const Target: string = ''): Boolean;
property EndPointUrl: string read FEndPointUrl write SetEndPointUrl;
end;
implementation
{ TIpInfo }
constructor TIpInfo.Create(const AToken: string);
begin
FEndPointUrl := 'https://ipinfo.io';
FHTTP := THTTPClient.Create;
FToken := AToken;
end;
destructor TIpInfo.Destroy;
begin
FHTTP.Free;
inherited;
end;
function TIpInfo.GetDetails(out Value: TDetails; const Target: string): Boolean;
var
Mem: TStringStream;
FTarget: string;
begin
Value := nil;
Mem := TStringStream.Create;
try
if Target.IsEmpty then
FTarget := ''
else
FTarget := '/' + Target;
if FHTTP.Get(FEndPointUrl + FTarget + '/json?token=' + FToken, Mem).StatusCode = 200 then
begin
if Mem.Size > 0 then
Value := TJson.JsonToObject<TDetails>(Mem.DataString);
end;
finally
Mem.Free;
end;
Result := Assigned(Value);
end;
procedure TIpInfo.SetEndPointUrl(const Value: string);
begin
FEndPointUrl := Value;
end;
{ TDetails }
constructor TDetails.Create;
begin
inherited;
end;
destructor TDetails.Destroy;
begin
if Assigned(FAsn) then
FAsn.Free;
if Assigned(FCompany) then
FCompany.Free;
if Assigned(FPrivacy) then
FPrivacy.Free;
if Assigned(FAbuse) then
FAbuse.Free;
if Assigned(FDomains) then
FDomains.Free;
inherited;
end;
end.
|
unit dmInternalPerCentServer;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, dmInternalUserServer, UserMessages, UtilWeb;
type
TPerCentStream = class(TStream)
private
dataReceived: string;
FPerCentWindowReceiver: HWND;
constructor Create(const PerCentWindowReceiver: HWND); reintroduce;
public
function Write(const Buffer; Count: Longint): Longint; override;
function Read(var Buffer; Count: Longint): Longint; override;
end;
TInternalPerCentServer = class(TInternalUserServer)
private
httpPerCent: THTTPPOST;
perCentStream: TPerCentStream;
FPerCentWindowReceiver: HWND;
SesionID: string;
procedure SetPerCentWindowReceiver(const Value: HWND);
procedure PerCent;
protected
procedure OnAcceptedRequest(const headers: string); override;
procedure OnHttpEnd(Sender: TObject); override;
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
procedure CancelPerCentOperation;
procedure CancelCurrentOperation; override;
property PerCentWindowReceiver: HWND read FPerCentWindowReceiver write SetPerCentWindowReceiver;
end;
implementation
uses StrUtils, ServerURLs;
{$R *.dfm}
const
SESSION_ID : string = 'JSESSIONID';
procedure TInternalPerCentServer.SetPerCentWindowReceiver(const Value: HWND);
begin
FPerCentWindowReceiver := Value;
end;
procedure TInternalPerCentServer.PerCent;
begin
httpPerCent := THTTPPOST.Create(URLServidor, URL_PERCENT, SESSION_ID + '=' + SesionID);
perCentStream := TPerCentStream.Create(PerCentWindowReceiver);
httpPerCent.ExecuteAsincrono(perCentStream);
end;
procedure TInternalPerCentServer.CancelCurrentOperation;
begin
CancelPerCentOperation;
inherited CancelCurrentOperation;
end;
procedure TInternalPerCentServer.CancelPerCentOperation;
begin
if httpPerCent <> nil then
httpPerCent.Cancel;
end;
constructor TInternalPerCentServer.Create(Owner: TComponent);
begin
inherited;
httpPerCent := nil;
perCentStream := nil;
end;
destructor TInternalPerCentServer.Destroy;
begin
CancelCurrentOperation;
if httpPerCent <> nil then begin
// httpPerCent.WaitForThread;
// httpPerCent.Free//
FreeAndNil(httpPerCent);
end;
if perCentStream <> nil then begin
FreeAndNil(perCentStream);
// perCentStream.Free;
// perCentStream := nil;
end;
inherited;
end;
procedure TInternalPerCentServer.OnAcceptedRequest(const headers: string);
var i: Integer;
begin
inherited;
i := Pos(SESSION_ID, headers);
if i <> 0 then begin
i := PosEx('=', headers, i);
SesionID := Copy(headers, i + 1, PosEx(';', headers, i + 1) - i - 1);
SesionID:= Trim(SesionID);
PerCent;
end;
end;
procedure TInternalPerCentServer.OnHttpEnd(Sender: TObject);
begin
CancelPerCentOperation;
end;
{ TPerCentStream }
constructor TPerCentStream.Create(const PerCentWindowReceiver: HWND);
begin
inherited Create;
FPerCentWindowReceiver := PerCentWindowReceiver;
end;
function TPerCentStream.Read(var Buffer; Count: Integer): Longint;
begin
Result := Count;
end;
function TPerCentStream.Write(const Buffer; Count: Integer): Longint;
var
S: PChar;
i, num, perCent: integer;
begin
S := PChar(@Buffer);
num := Count - 1;
for i := 0 to num do begin
if S[i] = '|' then begin
try
perCent := StrToInt(dataReceived);
PostMessage(FPerCentWindowReceiver, WM_PERCENT, perCent, 0);
except
on EConvertError do;
end;
dataReceived := '';
end
else
dataReceived := dataReceived + S[i];
end;
Result := Count;
end;
end.
|
unit ui.texcolorpalette;
interface
uses
ui.texcolor;
type
PPaletteEntry = ^TPaletteEntry;
TPaletteEntry = packed record
peRed: Byte;
peGreen: Byte;
peBlue: Byte;
peFlags: Byte;
end;
PMaxLogPalette = ^TMaxLogPalette; // not in Windows Headers
TMaxLogPalette = packed record
palVersion: Word;
palNumEntries: Word;
palPalEntry: array [Byte] of TPaletteEntry;
end;
PPalette32 = ^TPalette32;
TPalette32 = array [Byte] of TColor32;
function Color32(AIndex: Byte; APalette: TPalette32): TColor32;
implementation
function Color32(AIndex: Byte; APalette: TPalette32): TColor32;
begin
Result := APalette[AIndex];
end;
end.
|
unit uMain;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, RzCmboBx, RzEdit,
Vcl.WinXCtrls, Vcl.Mask, Vcl.ExtCtrls, RzPanel,
Vcl.Grids, RzGrids, Grijjy.MongoDB, RzButton, Grijjy.Bson,
Grijjy.MongoDB.Queries, System.DateUtils, System.Threading;
type
TfxMongoDBView = class(TForm)
RzPanel1 : TRzPanel;
edtAddr : TRzEdit;
ToggleSwitch1 : TToggleSwitch;
nedtPort : TRzNumericEdit;
cbDatabase : TRzComboBox;
mLog : TRzMemo;
edtCollections : TRzEdit;
btnSearch : TRzButton;
cbLoop : TCheckBox;
tmrLoop : TTimer;
neCount : TRzNumericEdit;
Label1 : TLabel;
procedure ToggleSwitch1Click(Sender : TObject);
procedure btnSearchClick(Sender : TObject);
procedure cbDatabaseChange(Sender : TObject);
procedure cbLoopClick(Sender : TObject);
procedure tmrLoopTimer(Sender : TObject);
private
{ Private declarations }
FLock : Integer;
Client : IgoMongoClient;
Database : IgoMongoDatabase;
Collection : IgoMongoCollection;
procedure Log(ALog : string);
public
{ Public declarations }
procedure SearchDocument;
end;
var
fxMongoDBView : TfxMongoDBView;
implementation
{$R *.dfm}
procedure TfxMongoDBView.btnSearchClick(Sender : TObject);
begin
SearchDocument;
end;
procedure TfxMongoDBView.cbDatabaseChange(Sender : TObject);
begin
Database := Client.GetDatabase(cbDatabase.Text);
end;
procedure TfxMongoDBView.SearchDocument;
var
Doc : TgoBsonDocument;
LDoc : TgoBsonType;
Collection : IgoMongoCollection;
LTask : ITask;
begin
if FLock = 0 then begin
if not Assigned(Database) then begin
ShowMessage('Please Database Connection');
exit;
end;
LTask := TTask.Create(
Procedure()
var
Doc : TgoBsonDocument;
Count : Integer;
begin
Inc(FLock);
Collection := Database.GetCollection(edtCollections.Text);
Count := 0;
for Doc in Collection.Find() do begin
Inc(Count);
Log(Doc.ToJson);
neCount.Value := Count;
Sleep(10);
end;
Dec(FLock);
end);
LTask.Start;
end;
end;
procedure TfxMongoDBView.tmrLoopTimer(Sender : TObject);
begin
SearchDocument;
end;
procedure TfxMongoDBView.cbLoopClick(Sender : TObject);
begin
tmrLoop.Enabled := cbLoop.Checked;
end;
procedure TfxMongoDBView.Log(ALog : string);
begin
if Length(ALog) > 0 then begin
if mLog.Lines.Count > 5000 then begin
mLog.Clear;
end;
mLog.Lines.BeginUpdate;
mLog.Lines.Insert(0, ALog);
mLog.Lines.EndUpdate;
end;
end;
procedure TfxMongoDBView.ToggleSwitch1Click(Sender : TObject);
var
LDatabases : TArray< TgoBsonDocument >;
LBsonType : TgoBsonValue;
i : Integer;
begin
if ToggleSwitch1.State = tssOn then begin
Client := TgoMongoClient.Create(edtAddr.Text);
LDatabases := Client.ListDatabases;
if Length(LDatabases) > 0 then begin
for i := 0 to Length(LDatabases) - 1 do begin
cbDatabase.Add(LDatabases[i].Get('name', LBsonType).ToString());
end;
cbDatabase.ItemIndex := 0;
Database := Client.GetDatabase(cbDatabase.Text);
end;
end;
end;
end.
|
unit rfOrder_unit;
interface
uses
SysUtils;
type
//Класс заказа по столу
TrfOrder = class(TObject)
private
FID: Integer;
FNumber: String;
FTimeClodeOrder: TDateTime;
FResponsibleKey: Integer;
FComputerName: String;
FIsLocked: Boolean;
public
constructor Create(const AID: Integer; const ANumber: String); overload;
constructor Create(AFromOrder: TrfOrder); overload;
property ID: Integer read FID write FID;
property Number: String read FNumber write FNumber;
property TimeCloseOrder: TDateTime read FTimeClodeOrder write FTimeClodeOrder;
property ResponsibleKey: Integer read FResponsibleKey write FResponsibleKey;
property ComputerName: String read FComputerName write FComputerName;
property IsLocked: Boolean read FIsLocked write FIsLocked;
end;
//бронирование по столу
TrfReservation = class(TObject)
private
FID: Integer;
FNumber: String;
FReservTime: TTime;
FReservDate: TDate;
FOrderKey: Integer;
FAvansSum: Currency;
FGuestCount: Integer;
public
constructor Create(const AID: Integer; const ANumber: String); overload;
property ID: Integer read FID write FID;
property Number: String read FNumber write FNumber;
property ReservDate: TDate read FReservDate write FReservDate;
property ReservTime: TTime read FReservTime write FReservTime;
property OrderKey: Integer read FOrderKey write FOrderKey;
property AvansSum: Currency read FAvansSum write FAvansSum;
property GuestCount: Integer read FGuestCount write FGuestCount;
end;
implementation
{ TrfOrder }
constructor TrfOrder.Create(const AID: Integer; const ANumber: String);
begin
FID := AID;
FNumber := ANumber;
FTimeClodeOrder := 0;
FResponsibleKey := -1;
ComputerName := '';
IsLocked := False;
end;
constructor TrfOrder.Create(AFromOrder: TrfOrder);
begin
FID := AFromOrder.ID;
FNumber := AFromOrder.Number;
FTimeClodeOrder := AFromOrder.TimeCloseOrder;
FResponsibleKey := AFromOrder.ResponsibleKey;
ComputerName := AFromOrder.ComputerName;
IsLocked := AFromOrder.IsLocked;
end;
{ TrfReservation }
constructor TrfReservation.Create(const AID: Integer; const ANumber: String);
begin
FID := AID;
FNumber := ANumber;
FOrderKey := -1;
FAvansSum := 0;
FGuestCount := 1;
end;
end.
|
unit EDIOrdersLoader.Main;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ExtCtrls, Vcl.StdCtrls, dsdDB, EDI, Vcl.ActnList,
dsdAction, cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters, cxContainer, cxEdit,
Vcl.ComCtrls, dxCore, cxDateUtils, dxSkinsCore, dxSkinsDefaultPainters, Vcl.Menus, cxButtons,
cxLabel, cxTextEdit, cxMaskEdit, cxDropDownEdit, cxCalendar, System.IniFiles,
Data.DB, Datasnap.DBClient, cxStyles, dxSkinscxPCPainter, cxCustomData,
cxFilter, cxData, cxDataStorage, cxDBData, dsdInternetAction, cxGridLevel,
cxGridCustomTableView, cxGridTableView, cxGridDBTableView, cxClasses,
cxGridCustomView, cxGrid, dsdExportToXLSAction, dxSkinBlack, dxSkinBlue,
dxSkinBlueprint, dxSkinCaramel, dxSkinCoffee, dxSkinDarkRoom, dxSkinDarkSide,
dxSkinDevExpressDarkStyle, dxSkinDevExpressStyle, dxSkinFoggy,
dxSkinGlassOceans, dxSkinHighContrast, dxSkiniMaginary, dxSkinLilian,
dxSkinLiquidSky, dxSkinLondonLiquidSky, dxSkinMcSkin, dxSkinMoneyTwins,
dxSkinOffice2007Black, dxSkinOffice2007Blue, dxSkinOffice2007Green,
dxSkinOffice2007Pink, dxSkinOffice2007Silver, dxSkinOffice2010Black,
dxSkinOffice2010Blue, dxSkinOffice2010Silver, dxSkinPumpkin, dxSkinSeven,
dxSkinSevenClassic, dxSkinSharp, dxSkinSharpPlus, dxSkinSilver,
dxSkinSpringTime, dxSkinStardust, dxSkinSummer2008, dxSkinTheAsphaltWorld,
dxSkinValentine, dxSkinVS2010, dxSkinWhiteprint, dxSkinXmas2008Blue
,frxBarcode, FastReportAddOn;
type
TMainForm = class(TForm)
TrayIcon: TTrayIcon;
Timer: TTimer;
OptionsMemo: TMemo;
LogMemo: TMemo;
FormParams: TdsdFormParams;
spGetDefaultEDI: TdsdStoredProc;
EDI: TEDI;
ActionList: TActionList;
actSetDefaults: TdsdExecStoredProc;
spHeaderOrder: TdsdStoredProc;
spListOrder: TdsdStoredProc;
Panel: TPanel;
deStart: TcxDateEdit;
deEnd: TcxDateEdit;
cxLabel1: TcxLabel;
cxLabel2: TcxLabel;
StartButton: TcxButton;
StopButton: TcxButton;
actStartEDI: TAction;
actStopEDI: TAction;
EDIActionOrdersLoad: TEDIAction;
cbPrevDay: TCheckBox;
spGetStatMovementEDI: TdsdStoredProc;
actGet_Movement_Edi_stat: TdsdExecStoredProc;
PrintHeaderCDS: TClientDataSet;
PrintItemsCDS: TClientDataSet;
spSelectSale_EDI: TdsdStoredProc;
spUpdateEdiOrdspr: TdsdStoredProc;
spUpdateEdiInvoice: TdsdStoredProc;
spUpdateEdiDesadv: TdsdStoredProc;
actExecPrintStoredProc: TdsdExecStoredProc;
actUpdateEdiDesadvTrue: TdsdExecStoredProc;
actUpdateEdiInvoiceTrue: TdsdExecStoredProc;
actUpdateEdiOrdsprTrue: TdsdExecStoredProc;
actInvoice: TEDIAction;
actOrdSpr: TEDIAction;
actDesadv: TEDIAction;
mactInvoice: TMultiAction;
mactOrdSpr: TMultiAction;
mactDesadv: TMultiAction;
Send_toEDICDS: TClientDataSet;
spSelectSend_toEDI: TdsdStoredProc;
spUpdate_EDI_Send: TdsdStoredProc;
actUpdate_EDI_Send: TdsdExecStoredProc;
cbLoad: TCheckBox;
cbSend: TCheckBox;
actAfterInvoice: TAction;
ExportEmailCDS: TClientDataSet;
ExportEmailDS: TDataSource;
ExportCDS: TClientDataSet;
ExportDS: TDataSource;
ExportXmlGrid: TcxGrid;
ExportXmlGridDBTableView: TcxGridDBTableView;
RowData: TcxGridDBColumn;
ExportXmlGridLevel: TcxGridLevel;
spGet_Export_Email: TdsdStoredProc;
spGet_Export_FileName: TdsdStoredProc;
spSelect_Export: TdsdStoredProc;
spUpdate_isMail: TdsdStoredProc;
actGet_Export_Email: TdsdExecStoredProc;
actGet_Export_FileName: TdsdExecStoredProc;
actSelect_Export: TdsdExecStoredProc;
actExport_Grid: TExportGrid;
actSMTPFile: TdsdSMTPFileAction;
actUpdate_isMail: TdsdExecStoredProc;
mactExport: TMultiAction;
cbEmail: TCheckBox;
Send_EmailCDS: TClientDataSet;
spSelectSend_Email: TdsdStoredProc;
mactExport_xls: TMultiAction;
spSelectPrintItem: TdsdStoredProc;
cbEmailExcel: TCheckBox;
PrintSignCDS: TClientDataSet;
spSelectPrintHeader: TdsdStoredProc;
spSelectPrintSign: TdsdStoredProc;
actSelect_Export_xls: TdsdExecStoredProc;
actExportToXLS_project: TdsdExportToXLS;
actGet_Export_FileName_xls: TdsdExecStoredProc;
spGet_Export_FileName_xls: TdsdStoredProc;
spGetReportName: TdsdStoredProc;
actSPPrintSaleProcName: TdsdExecStoredProc;
PrintItemsSverkaCDS: TClientDataSet;
spSelectPrint: TdsdStoredProc;
actExport_fr3: TdsdPrintAction;
mactExport_xls_2244900110: TMultiAction;
procedure TrayIconClick(Sender: TObject);
procedure AppMinimize(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure actStartEDIExecute(Sender: TObject);
procedure actStartEDIUpdate(Sender: TObject);
procedure actStopEDIExecute(Sender: TObject);
procedure actStopEDIUpdate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure TimerTimer(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure actAfterInvoiceExecute(Sender: TObject);
private
{ Private declarations }
FIntervalVal: Integer;
FProccessing: Boolean;
FProccessingEmail: Boolean;
isPrevDay_begin: Boolean;
gErr: Boolean;
Hour_onDel: Integer;
Hour_onSendEmail: Integer;
fStartTime: TDateTime;
procedure AddToLog(S: string);
procedure StartEDI;
procedure StopEDI;
procedure ProccessEDI;
procedure ProccessEmail;
function fGet_Movement_Edi_stat : Integer;
function fEdi_LoadData_from : Boolean;
function fEdi_SendData_to : Boolean;
function fSale_SendEmail : Boolean;
public
{ Public declarations }
property IntervalVal: Integer read FIntervalVal;
property Proccessing: Boolean read FProccessing write FProccessing;
property ProccessingEmail: Boolean read FProccessingEmail write FProccessingEmail;
end;
var
MainForm: TMainForm;
implementation
{$R *.dfm}
procedure TMainForm.actAfterInvoiceExecute(Sender: TObject);
begin
if (PrintHeaderCDS.FieldByName('InvNumber').asString = '') or (PrintHeaderCDS.RecordCount <> 1)
then
LogMemo.Lines.Add('!!! FIND ERROR !!!'
+ ' InvNumber = <'+PrintHeaderCDS.FieldByName('InvNumber').asString + '>'
+ ' MovementId = <'+IntToStr (FormParams.ParamByName('MovementId_toEDI').Value) + '>'
+ ' RecordCount = <'+IntToStr (PrintHeaderCDS.RecordCount) + '>'
)
else
LogMemo.Lines.Add('ok Send = <'+PrintHeaderCDS.FieldByName('InvNumber').asString);
end;
procedure TMainForm.actStartEDIExecute(Sender: TObject);
begin
try StartEDI;
//
Hour_onSendEmail:=-1;
ProccessEmail;
finally
Timer.Enabled:=True;
end;
end;
procedure TMainForm.actStartEDIUpdate(Sender: TObject);
begin
// actStartEDI.Enabled := not Timer.Enabled;
end;
procedure TMainForm.actStopEDIExecute(Sender: TObject);
begin
StopEDI;
end;
procedure TMainForm.actStopEDIUpdate(Sender: TObject);
begin
// actStopEDI.Enabled := Timer.Enabled;
end;
procedure TMainForm.AddToLog(S: string);
var
LogStr: string;
LogFileName: string;
LogFile: TextFile;
begin
Application.ProcessMessages;
LogStr := FormatDateTime('yyyy-mm-dd hh:mm:ss', Now) + ' ' + S;
LogMemo.Lines.Add(LogStr);
LogFileName := ChangeFileExt(Application.ExeName, '') + '_' + FormatDateTime('yyyymmdd', Date) + '.log';
AssignFile(LogFile, LogFileName);
if FileExists(LogFileName) then
Append(LogFile)
else
Rewrite(LogFile);
Writeln(LogFile, LogStr);
CloseFile(LogFile);
Application.ProcessMessages;
end;
procedure TMainForm.AppMinimize(Sender: TObject);
begin
ShowWindow(Handle, SW_HIDE);
end;
procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
StopEDI;
end;
procedure TMainForm.FormCreate(Sender: TObject);
var
IntervalStr: string;
ExcelStr: string;
begin
Application.OnMinimize := AppMinimize;
Timer.Enabled := False;
Proccessing := False;
ProccessingEmail := False;
Hour_onDel := -1;
Hour_onSendEmail:= -1;
cbEmailExcel.Checked:= TRUE; // ParamStr(3) = 'Excel';
cbLoad.Checked:= TRUE; // ParamStr(3) = '';
cbSend.Checked:= TRUE; // ParamStr(3) = '';
cbEmail.Checked:= TRUE; // ParamStr(3) = '';
// При запуске считаем что пред день НЕ надо, т.е. он уже обработан
isPrevDay_begin:= True;
if FindCmdLineSwitch('interval', IntervalStr) then
FIntervalVal := StrToIntDef(IntervalStr, 1)
else
FIntervalVal := 1;
if IntervalVal > 0 then
Timer.Interval := IntervalVal * 60 * 1000
else
Timer.Interval := 1 * 1 * 1000;
if cbPrevDay.Checked = TRUE
then deStart.EditValue := Date - 1
else deStart.EditValue := Date;
deEnd.EditValue := Date ;
deStart.Enabled := False;
deEnd.Enabled := False;
fStartTime:= Now;
OptionsMemo.Lines.Text := 'Текущий интервал: ' + IntToStr(IntervalVal) + ' мин.';
LogMemo.Clear;
end;
procedure TMainForm.FormShow(Sender: TObject);
begin
ActiveControl:= cbPrevDay;
if not Timer.Enabled then
try MainForm.StartEDI;
finally
Timer.Enabled:=True;
end;
end;
function TMainForm.fGet_Movement_Edi_stat : Integer;
begin
actGet_Movement_Edi_stat.Execute;
Result:= spGetStatMovementEDI.ParamByName('gpGet_Movement_Edi_stat').Value;
end;
function TMainForm.fEdi_LoadData_from : Boolean;
var Old_stat : Integer;
Present: TDateTime;
Year, Month, Day, Hour, Min, Sec, MSec: Word;
lHoursInterval_del : Integer;
begin
Present:=Now;
DecodeTime(Present, Hour, Min, Sec, MSec);
if isPrevDay_begin = false then cbPrevDay.Checked:= true;
try
Result:= false;
//
AddToLog('.....');
actSetDefaults.Execute;
AddToLog('Обновили Default для EDI : ' + DateTimeToStr(now));
// напрямую - работает криво
lHoursInterval_del:= FormParams.ParamByName('HoursInterval_del').Value;
// если пришло время и за "текущий" Hour еще не было удаления
if ((Hour mod lHoursInterval_del) = 0)
and (Hour_onDel <> Hour)
and (spGetDefaultEDI.ParamByName('gIsDelete').Value = TRUE)
then begin
//переопределили Признак - "удаление на ФТП" - будем делать каждые Х часов :)
FormParams.ParamByName('gIsDelete').Value := TRUE;
//запомнили текущий Hour кода сделали удаление
Hour_onDel:= Hour;
end
// поставили что НЕ надо удалить
// else FormParams.ParamByName('gIsDelete').Value := FALSE;
else FormParams.ParamByName('gIsDelete').Value := TRUE;
//
OptionsMemo.Lines.Clear;
OptionsMemo.Lines.Add('Старт: '+FormatDateTime('dd.mm.yy hh:mm', fStartTime));
if FormParams.ParamByName('gIsDelete').Value = TRUE
then OptionsMemo.Lines.Add('Текущий интервал: ' + IntToStr(IntervalVal) + ' : del = TRUE')
else OptionsMemo.Lines.Add('Текущий интервал: ' + IntToStr(IntervalVal) + ' : del = FALSE');
OptionsMemo.Lines.Add('Host: ' + FormParams.ParamByName('Host').AsString);
OptionsMemo.Lines.Add('UserName: ' + FormParams.ParamByName('UserName').AsString);
OptionsMemo.Lines.Add('Password: ' + FormParams.ParamByName('Password').AsString);
if cbLoad.Checked = FALSE then
begin
AddToLog('.....');
AddToLog('ОТКЛЮЧИЛИ Загрузку из EDI');
Result:= true;
exit
end;
if cbPrevDay.Checked = TRUE
then deStart.EditValue := Date - 1
else deStart.EditValue := Date;
deEnd.EditValue := Date;
Old_stat:=fGet_Movement_Edi_stat;
AddToLog('Загрузка EDI началась ... <'+IntToStr(Old_stat)+'>');
if FormParams.ParamByName('gIsDelete').Value = TRUE
then AddToLog(' - Период с ' + deStart.EditText + ' по ' + deEnd.EditText + ' : del = TRUE')
else AddToLog(' - Период с ' + deStart.EditText + ' по ' + deEnd.EditText + ' : del = FALSE');
EDIActionOrdersLoad.Execute;
AddToLog('Загружено <'+IntToStr(fGet_Movement_Edi_stat - Old_stat)+'> Документов');
AddToLog('Finish');
if cbPrevDay.Checked = true then begin cbPrevDay.Checked:= false; isPrevDay_begin:= true; end;
//
Result:= TRUE;
except
on E: Exception do begin
gErr:= Pos('--- ignore file',E.Message) = 0;
AddToLog(E.Message);
end;
end;
end;
function TMainForm.fEdi_SendData_to : Boolean;
var Err_str: String;
i : Integer;
begin
if cbSend.Checked = FALSE then
begin
AddToLog('.....');
AddToLog('ОТКЛЮЧИЛИ отправку в EDI');
Result:= true;
exit
end;
Result:= false;
spSelectSend_toEDI.Execute;
Send_toEDICDS.First;
if Send_toEDICDS.RecordCount = 0 then
begin
AddToLog('.....');
AddToLog('Нет отправки в EDI <' + IntToStr(Send_toEDICDS.RecordCount) + '>');
Result:= true;
exit
end;
AddToLog('.....');
AddToLog('Началась отправка в EDI итого : <' + IntToStr(Send_toEDICDS.RecordCount) + '>');
i:= 1;
with Send_toEDICDS do
while (not EOF) and ((gErr=FALSE) or (i<5)) do
begin
Application.ProcessMessages;
FormParams.ParamByName('MovementId_toEDI').Value := FieldByName('Id').AsInteger;
FormParams.ParamByName('MovementId_sendEDI').Value := FieldByName('MovementId').AsInteger;
Application.ProcessMessages;
// Попробовали отправить
try
if FieldByName('isEdiOrdspr').AsBoolean = true then mactOrdspr.Execute;
if FieldByName('isEdiInvoice').AsBoolean = true then mactInvoice.Execute;
if FieldByName('isEdiDesadv').AsBoolean = true then mactDesadv.Execute;
FormParams.ParamByName('Err_str_toEDI').Value := '';
//
Application.ProcessMessages;
// Сохранили что отправка прошла
AddToLog('отправилось без ошибки № : <' + IntToStr(i) + '>');
actUpdate_EDI_Send.Execute;
except
FormParams.ParamByName('Err_str_toEDI').Value := 'Ошибка при отправке';
if FieldByName('isEdiOrdspr').AsBoolean = true then AddToLog('isEdiOrdspr = <true>');
if FieldByName('isEdiInvoice').AsBoolean = true then AddToLog('isEdiInvoice = <true>');
if FieldByName('isEdiDesadv').AsBoolean = true then AddToLog('isEdiDesadv = <true>');
AddToLog('Ошибка при отправке № : <' + IntToStr(i) + '> <' + FieldByName('Id').AsString + '>');
//
Application.ProcessMessages;
// Сохранили что ошибка
actUpdate_EDI_Send.Execute;
end;
//
AddToLog('завершен № : <' + IntToStr(i) + '> из <' + IntToStr(Send_toEDICDS.RecordCount) + '>');
//
Next;
i:= i+1;
end;
AddToLog('Завершилась отправка в EDI : <' + IntToStr(i-1) + '> из <' + IntToStr(Send_toEDICDS.RecordCount) + '>');
AddToLog('.....');
end;
function TMainForm.fSale_SendEmail : Boolean;
var Err_str: String;
i : Integer;
begin
if (cbEmail.Checked = FALSE)and (cbEmailExcel.Checked = FALSE) then
begin
AddToLog('.....');
AddToLog('ОТКЛЮЧИЛИ отправку Email');
Result:= true;
exit
end;
Result:= false;
spSelectSend_Email.ParamByName('inIsExcel').Value:= cbEmailExcel.Checked = TRUE;
spSelectSend_Email.Execute;
Send_EmailCDS.First;
if Send_EmailCDS.RecordCount = 0 then
begin
AddToLog('.....');
AddToLog('Нет отправки Email <' + IntToStr(Send_EmailCDS.RecordCount) + '>');
Result:= true;
exit
end;
AddToLog('.....');
AddToLog('Началась отправка Email итого : <' + IntToStr(Send_EmailCDS.RecordCount) + '>');
i:= 1;
with Send_EmailCDS do
while (not EOF) and ((gErr=FALSE) or (i<5)) do
begin
Application.ProcessMessages;
FormParams.ParamByName('MovementId_sendEmail').Value := FieldByName('MovementId').AsInteger;
Application.ProcessMessages;
// Попробовали отправить
try
if FieldByName('ExportKindId').AsInteger = FieldByName('zc_Logistik41750857').AsInteger
then mactExport_xls.Execute
else
if FieldByName('ExportKindId').AsInteger = FieldByName('zc_Nedavn2244900110').AsInteger
then mactExport_xls_2244900110.Execute
else mactExport.Execute;
//
Application.ProcessMessages;
// Сохранили что отправка прошла
AddToLog('отправилось без ошибки № : <' + IntToStr(i) + '> <' + FieldByName('MovementId').AsString + '> <' + FieldByName('InvNumber').AsString + '> <' + FieldByName('ToName').AsString + '> <' + FieldByName('OperDatePartner').AsString + '>' + '> <' + FieldByName('OperDate_protocol').AsString + '>');
except
// FormParams.ParamByName('Err_str_Email').Value := 'Ошибка при отправке';
AddToLog('Ошибка при отправке № : <' + IntToStr(i) + '> <' + FieldByName('MovementId').AsString + '> <' + FieldByName('InvNumber').AsString + '> <' + FieldByName('ToName').AsString + '> <' + FieldByName('OperDatePartner').AsString + '>' + '> <' + FieldByName('OperDate_protocol').AsString + '>');
//
Application.ProcessMessages;
// Сохранили что ошибка
//actUpdate_Email_Send_err.Execute;
end;
//
//AddToLog('завершен № : <' + IntToStr(i) + '> из <' + IntToStr(RecordCount) + '>');
//
Next;
i:= i+1;
end;
AddToLog('Завершилась отправка Email : <' + IntToStr(i-1) + '> из <' + IntToStr(Send_EmailCDS.RecordCount) + '>');
AddToLog('.....');
end;
procedure TMainForm.ProccessEDI;
var Present: TDateTime;
Hour, Min, Sec, MSec: Word;
IntervalStr: string;
begin
ActiveControl:= cbPrevDay;
Present:=Now;
DecodeTime(Present, Hour, Min, Sec, MSec);
//если уже работает, повторно НЕ запускаем
if Proccessing then
Exit;
try
// Timer.Enabled:=False;
Proccessing := True;
if ((Hour>=0) and (Hour<7)) or (Hour>=23)
then
begin
// !!! Только Отправка !!!
fEdi_SendData_to;
//
//
AddToLog('..... Нет Загрузки .....');
Proccessing := False;
//Timer.Enabled:=True;
isPrevDay_begin := false;
exit;
end;
//
// !!! Только Загрузка !!!
gErr:= FALSE;
try fEdi_LoadData_from;
except
on E: Exception do begin
gErr:= Pos('--- ignore file',E.Message) = 0;
AddToLog('**** Ошибка *** LoadData - from *** : ' + E.Message);
end;
end;
//
// !!! Только Отправка !!!
try fEdi_SendData_to;
except
on E: Exception do begin
AddToLog('**** Ошибка *** SendData - to *** : ' + E.Message);
end;
end;
//
if gErr = TRUE then
begin
FIntervalVal := 0;
AddToLog('Текущий интервал изменен до : ' + IntToStr(3) + ' сек.');
end
else
if FindCmdLineSwitch('interval', IntervalStr) then
FIntervalVal := StrToIntDef(IntervalStr, 1)
else
FIntervalVal := 1;
if (Hour > 18) and (IntervalVal >= 1) then
begin
//Timer.Interval := (IntervalVal * 15) * 60 * 1000;
//AddToLog('Текущий интервал изменен до : ' + IntToStr(IntervalVal * 15) + ' мин.');
Timer.Interval := 30 * 60 * 1000;
AddToLog('Текущий интервал изменен до : ' + IntToStr(30) + ' мин.');
end
else
if IntervalVal >= 1
then
Timer.Interval := (IntervalVal * 1) * 60 * 1000
else
Timer.Interval := (3 * 1) * 1 * 1000;
finally
Proccessing := False;
// Timer.Enabled:=True;
end;
end;
procedure TMainForm.ProccessEmail;
var Present: TDateTime;
Hour, Min, Sec, MSec: Word;
IntervalStr: string;
begin
ActiveControl:= cbPrevDay;
Present:=Now;
DecodeTime(Present, Hour, Min, Sec, MSec);
//если уже работает, повторно НЕ запускаем
if ProccessingEmail then
Exit;
//если надо перезапустить
if (Hour_onSendEmail >= 21) and (Hour >=4) then Hour_onSendEmail:= 0;
//если уже сделали отправку Email, тогда не надо (отправляем каждые 2 часа)
if (Hour_onSendEmail + 2 >= Hour) and (Hour_onSendEmail >= 0) then
Exit;
try
ProccessingEmail := True;
//
// !!! Только Отправка !!!
try fSale_SendEmail;
//запомнили текущий Hour кода сделали отправку Email
Hour_onSendEmail:= Hour;
except
on E: Exception do begin
AddToLog('**** Ошибка *** SendEmail *** : ' + E.Message);
end;
end;
finally
ProccessingEmail := False;
end;
end;
procedure TMainForm.StartEDI;
begin
AddToLog('Запуск ...');
if IntervalVal > 0 then
begin
StartButton.Enabled:= FALSE;
StopButton.Enabled := TRUE;
//
ProccessEDI;
// Timer.Enabled := True;
end
else
AddToLog('Запуск не выполнен, т.к. не определен интервал');
end;
procedure TMainForm.StopEDI;
begin
if Timer.Enabled then
begin
while Proccessing do
Application.ProcessMessages;
Timer.Enabled := False;
AddToLog('Остановка');
//
StartButton.Enabled:= TRUE;
StopButton.Enabled := FALSE;
end;
end;
procedure TMainForm.TimerTimer(Sender: TObject);
begin
try
Timer.Enabled:= false;
//
ProccessEDI;
//
ProccessEmail;
finally
Timer.Enabled:= true;
end;
end;
procedure TMainForm.TrayIconClick(Sender: TObject);
begin
ShowWindow(Handle, SW_RESTORE);
SetForegroundWindow(Handle);
end;
end.
|
unit ServerUnit;
interface
uses
Aurelius.Drivers.Interfaces,
XData.Http.Server,
System.SysUtils, System.Classes;
type
TServerModule = class(TDataModule)
procedure DataModuleCreate(Sender: TObject);
procedure DataModuleDestroy(Sender: TObject);
private
function CreateConnectionFactory: IDBConnectionFactory;
public
HttpServer: THttpServer;
end;
implementation
uses
Modules.FirebirdConnection,
Aurelius.Drivers.Base,
Aurelius.Drivers.DBExpress,
Aurelius.Sql.Firebird,
Aurelius.Sql.SQLite,
XData.Aurelius.ConnectionPool,
XData.Aurelius.EntityServer,
XData.RemoteDB.Server,
XData.Http.Url;
{%CLASSGROUP 'System.Classes.TPersistent'}
{$R *.dfm}
function TServerModule.CreateConnectionFactory: IDBConnectionFactory;
begin
Result := TDBConnectionFactory.Create(
function: IDBConnection
var
Module: TFirebirdConnectionModule;
begin
Module := TFirebirdConnectionModule.Create(nil);
Result := TDBExpressConnectionAdapter.Create(Module.SQLConnection1, Module);
end
);
end;
procedure TServerModule.DataModuleCreate(Sender: TObject);
var
RemoteDBServer: TRemoteDBServer;
EntityServer: TAureliusHttpHandler;
ConnectionFactory: IDBConnectionFactory;
begin
HttpServer := THttpServer.Create;
ConnectionFactory := CreateConnectionFactory;
RemoteDBServer := TRemoteDBServer.Create(
TUrl.Create('http://localhost:2001/tms/db'),
ConnectionFactory
);
HttpServer.RegisterHandler(RemoteDBServer);
EntityServer := TAureliusHttpHandler.Create(
TUrl.Create('http://localhost:2001/tms/entities'),
TDBConnectionPool.Create(10, ConnectionFactory)
);
EntityServer.AccessControlAllowOrigin := '*'; // to allow access from JavaScript
HttpServer.RegisterHandler(EntityServer);
end;
procedure TServerModule.DataModuleDestroy(Sender: TObject);
begin
HttpServer.Free;
end;
end.
|
unit KeyHook;
interface
uses
Windows, Messages, Classes, Forms;
type
TKeyHookEvent = procedure(Sender: TObject; var Key: Word; Shift: TShiftState;
KeyName: string; RepeatedKeypress: Boolean) of object;
TKeyHook = class(TComponent)
private
FOnKeyDown, FOnKeyUp: TKeyHookEvent;
protected
public
constructor Create(aOwner: TComponent); override;
destructor Destroy; override;
published
property OnKeyDown: TKeyHookEvent read FOnKeyDown write FOnKeyDown;
property OnKeyUp: TKeyHookEvent read FOnKeyUp write FOnKeyUp;
end;
implementation
var
KeyHookInstance: TKeyHook = nil;
KeyboardHook: hHook = 0;
function GetKeyName(lParam: LongInt): string;
var
szKeyName: array[0..$FF] of Char;
begin
GetKeyNameText(lParam, szKeyName, SizeOf(szKeyName));
Result := szKeyName;
end;
function KeyboardCallbackProc(nCode: Integer; wParam, lParam: LongInt): LongInt;
stdcall;
var
Msg: TMessage;
begin
Result := 0;
if nCode = HC_ACTION then
try
with KeyHookInstance do
begin
Msg.wParam := wParam;
Msg.lParam := lParam;
if not Boolean(lParam shr 31) then // key down
if Assigned(FOnKeyDown) then
begin
Msg.Msg := WM_KEYDOWN;
FOnKeyDown(KeyHookInstance, TWMKey(Msg).CharCode,
KeyDataToShiftState(TWMKey(Msg).KeyData), GetKeyName(lParam),
Boolean(lParam shr 30));
end
else
else {// key up} if Assigned(FOnKeyUp) then
begin
Msg.Msg := WM_KEYUP;
FOnKeyUp(KeyHookInstance, TWMKey(Msg).CharCode,
KeyDataToShiftState(TWMKey(Msg).KeyData), GetKeyName(lParam),
Boolean(lParam shr 30));
end;
end;
except
end;
if (nCode < 0) or (Result = 0) then
Result := CallNextHookEx(KeyboardHook, nCode, wParam, lParam);
end;
constructor TKeyHook.Create(aOwner: TComponent);
begin
inherited Create(aOwner);
if not (csDesigning in ComponentState) and (KeyHookInstance = nil) then
begin
KeyHookInstance := Self;
KeyboardHook := SetWindowsHookEx(WH_KEYBOARD, @KeyboardCallbackProc, 0,
GetCurrentThreadID);
end;
end;
destructor TKeyHook.Destroy;
begin
if not (csDesigning in ComponentState) then
begin
if KeyboardHook <> 0 then
UnhookWindowsHookEx(KeyboardHook);
KeyboardHook := 0;
end;
inherited Destroy;
end;
end.
|
unit Retail_PrintKindItem;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, cxGraphics, cxControls, cxLookAndFeels,
cxLookAndFeelPainters, cxStyles, cxCustomData, cxFilter, cxData,
cxDataStorage, cxEdit, Data.DB, cxDBData, cxGridLevel, cxClasses,
cxGridCustomView, cxGridCustomTableView, cxGridTableView, cxGridDBTableView,
cxGrid, Datasnap.DBClient, cxPropertiesStore, dxBar,
Vcl.ActnList, DataModul, ParentForm, dsdDB, dsdAction, dsdAddOn, dxBarExtItems,
cxGridBandedTableView, cxGridDBBandedTableView, cxCheckBox, dxSkinsCore,
dxSkinsDefaultPainters, dxSkinscxPCPainter, dxSkinsdxBarPainter, cxButtonEdit,
cxCurrencyEdit, cxContainer, dsdGuides, cxTextEdit, cxMaskEdit, cxLabel;
type
TRetail_PrintKindItemForm = class(TParentForm)
cxGridLevel: TcxGridLevel;
cxGrid: TcxGrid;
DataSource: TDataSource;
ClientDataSet: TClientDataSet;
cxPropertiesStore: TcxPropertiesStore;
dxBarManager: TdxBarManager;
dxBarManagerBar1: TdxBar;
ActionList: TActionList;
bbRefresh: TdxBarButton;
actRefresh: TdsdDataSetRefresh;
bbInsert: TdxBarButton;
dsdStoredProc: TdsdStoredProc;
actUpdate: TdsdInsertUpdateAction;
bbEdit: TdxBarButton;
bbSetErased: TdxBarButton;
bbSetUnErased: TdxBarButton;
dsdGridToExcel: TdsdGridToExcel;
bbToExcel: TdxBarButton;
dxBarStatic: TdxBarStatic;
spErasedUnErased: TdsdStoredProc;
bbChoice: TdxBarButton;
cxGridDBTableView: TcxGridDBTableView;
Code: TcxGridDBColumn;
Name: TcxGridDBColumn;
isErased: TcxGridDBColumn;
dsdUserSettingsStorageAddOn: TdsdUserSettingsStorageAddOn;
dsdChoiceGuides: TdsdChoiceGuides;
dsdDBViewAddOn: TdsdDBViewAddOn;
actInsert: TdsdInsertUpdateAction;
BranchName: TcxGridDBColumn;
ProtocolOpenForm: TdsdOpenForm;
bbProtocolOpenForm: TdxBarButton;
spUpdate: TdsdStoredProc;
actUpdateDataSet: TdsdUpdateDataSet;
actChoiceGoodsProperty: TOpenChoiceForm;
isMovement: TcxGridDBColumn;
isAccount: TcxGridDBColumn;
isTransport: TcxGridDBColumn;
isQuality: TcxGridDBColumn;
isPack: TcxGridDBColumn;
isSpec: TcxGridDBColumn;
isTax: TcxGridDBColumn;
cxLabel6: TcxLabel;
edBranch: TcxButtonEdit;
GuidesBranch: TdsdGuides;
bbBranchLabel: TdxBarControlContainerItem;
bbBranch: TdxBarControlContainerItem;
RefreshDispatcher: TRefreshDispatcher;
private
{ Private declarations }
public
{ Public declarations }
end;
implementation
{$R *.dfm}
initialization
RegisterClass(TRetail_PrintKindItemForm);
end.
|
unit PowerDisplay;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, IPPeerClient,
IPPeerServer, System.Tether.Manager, System.Tether.AppProfile, FMX.Layouts,
FMX.ListBox, FMX.StdCtrls, FMX.Platform
{$IFDEF ANDROID}
, Androidapi.JNI.PowerManager
{$ENDIF}
;
type
TForm17 = class(TForm)
TetheringManager1: TTetheringManager;
TetheringAppProfile1: TTetheringAppProfile;
pbPower: TProgressBar;
lbCommand: TLabel;
StyleBook1: TStyleBook;
Layout1: TLayout;
Label2: TLabel;
{$IFDEF ANDROID}
fWakeLock: JWakeLock;
{$ENDIF}
procedure TetheringAppProfile1ResourceReceived(const Sender: TObject;
const AResource: TRemoteResource);
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure TetheringManager1PairedFromLocal(const Sender: TObject;
const AManagerInfo: TTetheringManagerInfo);
procedure TetheringManager1PairedToRemote(const Sender: TObject;
const AManagerInfo: TTetheringManagerInfo);
private
function HandleAppEvent(AAppEvent: TApplicationEvent;
AContext: TObject): Boolean;
{ Private declarations }
public
{ Public declarations }
end;
var
Form17: TForm17;
implementation
{$R *.fmx}
{$R *.GGlass.fmx ANDROID}
{$ifdef Android}
uses
Androidapi.JNIBridge,
Androidapi.JNI.JavaTypes,
Androidapi.Helpers,
Androidapi.JNI.GraphicsContentViewText,
Androidapi.JNI.Net.Wifi;
function GetIpAddress: String;
var
WifiManagerObj: JObject;
WifiManager: JWifiManager;
WifiInfo: JWifiInfo;
ip: Integer;
begin
WifiManagerObj := SharedActivityContext.getSystemService(TJContext.JavaClass.WIFI_SERVICE);
WifiManager := TJWifiManager.Wrap((WifiManagerObj as ILocalObject).GetObjectID);
WifiInfo := WifiManager.getConnectionInfo();
ip := WifiInfo.getIpAddress and $FFFFFFFF;
result := Format('%d.%d.%d.%d',
[(IP) and $FF,
(IP shr 8) and $FF,
(IP shr 16) and $FF,
(IP shr 24) and $FF]);
end;
{$ELSE}
function GetIpAddress: String;
begin
result := 'unknown';
end;
{$ENDIF}
procedure TForm17.FormCreate(Sender: TObject);
var
aFMXApplicationEventService: IFMXApplicationEventService;
begin
if TPlatformServices.Current.SupportsPlatformService(IFMXApplicationEventService, IInterface(aFMXApplicationEventService)) then
aFMXApplicationEventService.SetApplicationEventHandler(HandleAppEvent);
end;
procedure TForm17.TetheringAppProfile1ResourceReceived(const Sender: TObject;
const AResource: TRemoteResource);
var
power: Integer;
begin
power := StrToInt(AResource.Value.AsString);
pbPower.Value := power;
if Power > 0 then
lbCommand.Text := AResource.Hint
else
lbCommand.Text := '';
end;
procedure TForm17.TetheringManager1PairedFromLocal(const Sender: TObject;
const AManagerInfo: TTetheringManagerInfo);
begin
lbCommand.Text := 'Paired';
end;
procedure TForm17.TetheringManager1PairedToRemote(const Sender: TObject;
const AManagerInfo: TTetheringManagerInfo);
begin
lbCommand.Text := 'Paired';
end;
procedure TForm17.FormDestroy(Sender: TObject);
begin
{$IFDEF ANDROID}
ReleaseWakeLock(fWakeLock);
{$ENDIF}
end;
procedure TForm17.FormShow(Sender: TObject);
begin
lbCommand.Text := GetIpAddress;
end;
function TForm17.HandleAppEvent(AAppEvent: TApplicationEvent;
AContext: TObject): Boolean;
begin
{$IFDEF ANDROID}
case AAppEvent of
TApplicationEvent.FinishedLaunching: AcquireWakeLock(fWakeLock);
TApplicationEvent.BecameActive: AcquireWakeLock(fWakeLock);
TApplicationEvent.WillBecomeInactive: ReleaseWakeLock(fWakeLock);
TApplicationEvent.EnteredBackground: ReleaseWakeLock(fWakeLock);
TApplicationEvent.WillBecomeForeground: AcquireWakeLock(fWakeLock);
TApplicationEvent.WillTerminate: ;
TApplicationEvent.LowMemory: ;
TApplicationEvent.TimeChange: ;
TApplicationEvent.OpenURL: ;
end;
{$ENDIF}
Result := False;
end;
end.
|
/// HTML5 Boilerplate integration with Synopse mORMot Framework
// Licensed under The MIT License (MIT)
unit BoilerplateAssets;
(*
This unit is a path of integration project between HTML5 Boilerplate and
Synopse mORMot Framework.
https://synopse.info
https://html5boilerplate.com
Boilerplate HTTP Server
(c) 2016-Present Yevgeny Iliyn
License: MIT
https://github.com/eugeneilyin/mORMotBP
Version 1.0
- First public release
Version 1.7
- get rid of system PosEx for better compatibility with Delphi 2007 and below
Version 2.0
- Zopfli compression support
(save up to 5-15% compared to max GZip Level)
- Brotli compression support as per RFC 7932
(save another 15%-25% compared to Zopfli)
- Embed all compressed encoding into Asset
- New COMPRESSED_TYPES_CSV list to has compressed versions only for
specific MIME types
- Assets now saved in 'identity/*', 'gzip/*.gz', and 'brotli/*.br' directories
- Updated assetslz tool
- Free Pascal support
- All Delphi compilers support started from Delphi 6
- Kylix 3 support (over CrossKilyx)
Version 2.1.1
- Fix TAsset.SaveIdentityToFile bug when Root is empty
Version 2.2
- Content types normalization
*)
interface
{$I Synopse.inc} // define HASINLINE USETYPEINFO CPU32 CPU64 OWNNORMTOUPPER
uses
SysUtils,
SynCommons;
type
{TAsset }
TFileCheck = (fcModified, fcSize);
TFileChecks = set of TFileCheck;
TAssetEncoding = (aeIdentity, aeGZip, aeBrotli);
{$IFDEF FPC} {$PACKRECORDS 1} {$ELSE} {$A-} {$ENDIF}
TAsset = {$IFDEF FPC_OR_UNICODE}record{$ELSE}object{$ENDIF}
public
Path: RawUTF8;
Modified: TDateTime;
ContentType: RawUTF8;
Content: RawByteString;
Hash: Cardinal;
// We cann't use array[TAssetEncoding] here due to TDynArrayHashed.SaveTo
// limitations in old Delphi compilers: Delphi 2009 and below. That's why
// the TAsset structure without nested arrays.
GZipExists: Boolean;
GZipEncoding: RawByteString;
GZipHash: Cardinal;
BrotliExists: Boolean;
BrotliEncoding: RawByteString;
BrotliHash: Cardinal;
function LoadFromFile(const Root, FileName: TFileName): Boolean;
procedure SetEncoding(const Encoded: RawByteString;
const Encoding: TAssetEncoding = aeIdentity);
function SaveToFile(const Root: TFileName = '';
const Encoding: TAssetEncoding = aeIdentity;
const ChecksNotModified: TFileChecks = [fcModified, fcSize]): TFileName;
function SaveIdentityToFile(const Root: TFileName = '';
const ChecksNotModified: TFileChecks = [fcModified, fcSize]): TFileName;
end;
PAsset = ^TAsset;
TAssetDynArray = array of TAsset;
{ TAssets }
type
TAssets = {$IFDEF FPC_OR_UNICODE}record private{$ELSE}object protected{$ENDIF}
FAssetsDAH: TDynArrayHashed;
public
Assets: TAssetDynArray;
Count: Integer;
procedure Init;
function Add(const Root, FileName: TFileName): PAsset;
procedure SaveToFile(const FileName: TFileName);
procedure LoadFromFile(const FileName: TFileName);
procedure LoadFromResource(const ResName: string);
procedure SaveAll(const Root: TFileName = '';
const ChecksNotModified: TFileChecks = [fcModified, fcSize]);
procedure SaveAllIdentities(const Root: TFileName = '';
const ChecksNotModified: TFileChecks = [fcModified, fcSize]);
function Find(const Path: RawUTF8): PAsset;
{$IFDEF HASINLINE}inline;{$ENDIF}
end;
const
/// Default asset extenstions used for GZip/Zopfli and Brotli compression
COMPRESSED_TYPES_CSV = 'html,css,js,json,svg,' +
'atom,mjs,map,topojson,jsonld,webmanifest,rdf,rss,geojson,eot,ttf,ttc,' +
'wasm,webapp,xml,otf,bmp,cur,ico,appcache,ics,markdown,md,vcard,vcf,' +
'xloc,vtt,htc';
MIME_CONTENT_TYPES =
// HyperText Markup Language
'.html=text/html' + #10 +
// Cascading Style Sheets
'.css=text/css' + #10 +
// JavaScript
// Servers should use text/javascript for JavaScript resources.
// https://html.spec.whatwg.org/multipage/scripting.html#scriptingLanguages
'.js=text/javascript'#10 +
'.mjs=text/javascript'#10 +
// Text
'.txt=text/plain' + #10 +
// Data interchange
'.json=application/json'#10 +
'.map=application/json'#10 +
'.geojson=application/geo+json'#10 +
'.topojson=application/json'#10 +
'.jsonld=application/ld+json'#10 +
'.atom=application/atom+xml'#10 +
'.rss=application/rss+xml'#10 +
'.rdf=application/rdf+xml'#10 +
'.xml=application/xml'#10 +
// Manifest files
'.webmanifest=application/manifest+json'#10 +
'.webapp=application/x-web-app-manifest+json'#10 +
'.appcache=text/cache-manifest'#10 +
// Media files
'.svg=image/svg+xml'#10 +
'.svgz=image/svg+xml'#10 +
'.f4a=audio/mp4'#10 +
'.f4b=audio/mp4'#10 +
'.m4a=audio/mp4'#10 +
'.oga=audio/ogg'#10 +
'.ogg=audio/ogg'#10 +
'.opus=audio/ogg'#10 +
'.bmp=image/bmp'#10 +
'.webp=image/webp'#10 +
'.f4v=video/mp4'#10 +
'.f4p=video/mp4'#10 +
'.m4v=video/mp4'#10 +
'.mp4=video/mp4'#10 +
'.ogv=video/ogg'#10 +
'.webm=video/webm'#10 +
'.flv=video/x-flv'#10 +
// Serving `.ico` image files with a different media type
// prevents Internet Explorer from displaying them as images:
// https://github.com/h5bp/html5-boilerplate/commit/37b5fec090d00f38de64b591bcddcb205aadf8ee
'.cur=image/x-icon'#10 +
'.ico=image/x-icon'#10 +
// WebAssembly
'.wasm=application/wasm'#10 +
// Web fonts
'.woff=font/woff'#10 +
'.woff2=font/woff2'#10 +
'.eot=application/vnd.ms-fontobject'#10 +
'.ttf=font/ttf'#10 +
'.ttc=font/collection'#10 +
'.otf=font/otf'#10 +
// Other
'.safariextz=application/octet-stream'#10 +
'.bbaw=application/x-bb-appworld'#10 +
'.crx=application/x-chrome-extension'#10 +
'.oex=application/x-opera-extension'#10 +
'.xpi=application/x-xpinstall'#10 +
'.ics=text/calendar'#10 +
'.markdown=text/markdown'#10 +
'.md=text/markdown'#10 +
'.vcard=text/vcard'#10 +
'.vcf=text/vcard'#10 +
'.xloc=text/vnd.rim.location.xloc'#10 +
'.vtt=text/vtt'#10 +
'.htc=text/x-component'#10 +
// Mustache partial template
'.partial=text/html' + #10 +
'';
/// Fill the RawUTF8 array with unique, lower-cased and
// sorted values ready for binary search
procedure ArrayFromCSV(out anArray: TRawUTF8DynArray; const CSV: RawUTF8;
const Prefix: RawUTF8 = '.'; const Sep: AnsiChar = ',');
procedure CreateDirectories(const FileName: TFileName);
{$IFDEF HASINLINE}inline;{$ENDIF}
function GetFileInfo(const FileName: TFileName; Modified: PDateTime;
Size: PInt64): Boolean;
function SetFileTime(const FileName: TFileName;
const Modified: TDateTime): Boolean;
implementation
uses
{$IFDEF MSWINDOWS}
Windows,
{$ENDIF}
{$IFDEF KYLIX3}
Libc,
{$ELSE KYLIX3}
{$IFDEF LINUX}
BaseUnix,
{$ENDIF LINUX}
{$ENDIF KYLIX3}
Classes;
var
KnownMIMEContentTypes: TSynNameValue;
procedure ArrayFromCSV(out anArray: TRawUTF8DynArray; const CSV: RawUTF8;
const Prefix: RawUTF8; const Sep: AnsiChar);
var
Values: PUTF8Char;
Value: RawUTF8;
ArrayDA: TDynArray;
ArrayCount: Integer;
Index: Integer;
begin
ArrayDA.Init(TypeInfo(TRawUTF8DynArray), anArray, @ArrayCount);
Values := PUTF8Char(CSV);
while Values <> nil do
begin
Value := GetNextItem(Values, Sep);
if Value <> '' then
begin
Value := Prefix + LowerCase(Value);
ArrayDA.Add(Value);
end;
end;
ArrayDA.Sort(SortDynArrayPUTF8Char);
for Index := ArrayDA.Count - 1 downto 1 do
if anArray[Index] = anArray[Index - 1] then
ArrayDA.Delete(Index);
SetLength(anArray, ArrayDA.Count);
end;
function GetFileInfo(const FileName: TFileName; Modified: PDateTime;
Size: PInt64): Boolean;
{$IFDEF MSWINDOWS}
var
FA: TWin32FileAttributeData;
SystemTime: TSystemTime;
begin
Result := GetFileAttributesEx(Pointer(FileName), GetFileExInfoStandard, @FA);
if not Result then Exit;
if Modified <> nil then
begin
Result := FileTimeToSystemTime(FA.ftLastWriteTime, SystemTime);
if not Result then Exit;
Modified^ := SystemTimeToDateTime(SystemTime);
end;
if Size <> nil then
begin
PInt64Rec(Size)^.Lo := FA.nFileSizeLow;
PInt64Rec(Size)^.Hi := FA.nFileSizeHigh;
end;
end;
{$ENDIF}
{$IFDEF FPCLINUX}
var
fd: cint;
sb: Stat;
begin
fd := FpOpen(PChar(FileName), O_RdOnly);
Result := fd > 0;
if not Result then Exit;
try
Result := FpFStat(fd, sb) = 0;
if not Result then Exit;
if Modified <> nil then
Modified^ := UnixMSTimeToDateTime(sb.st_mtime * MSecsPerSec);
if Size <> nil then
Size^ := sb.st_size;
finally
if FpClose(fd) <> 0 then
Result := False;
end;
end;
{$ENDIF}
{$IFDEF KYLIX3}
var
Handle: Integer;
StatBuf: TStatBuf;
Current, LSize: Int64;
begin
Handle := Libc.open(PChar(FileName), O_RDONLY);
Result := PtrInt(Handle) > 0;
if not Result then Exit;
try
if Modified <> nil then
begin
Result := Libc.fstat(Handle, StatBuf) = 0;
if not Result then Exit;
Modified^ := UnixMSTimeToDateTime(
TUnixMSTime(StatBuf.st_mtime) * MSecsPerSec);
end;
if Size <> nil then
begin
Current := Libc.lseek64(Handle, 0, SEEK_CUR);
Result := Current <> -1;
if not Result then Exit;
LSize := Libc.lseek64(Handle, 0, SEEK_END);
Result := LSize <> -1;
if not Result then Exit;
Result := lseek64(Handle, Current, SEEK_SET) <> -1;
if not Result then Exit;
Size^ := LSize;
end;
finally
if Libc.__close(Handle) <> 0 then
Result := False;
end;
end;
{$ENDIF}
function SetFileTime(const FileName: TFileName;
const Modified: TDateTime): Boolean;
{$IFDEF MSWINDOWS}
var
Handle: THandle;
SystemTime: TSystemTime;
LModified: TFileTime;
begin
DateTimeToSystemTime(Modified, SystemTime);
Result := SystemTimeToFileTime(SystemTime, LModified);
if not Result then Exit;
Handle := FileOpen(FileName, fmOpenWrite or fmShareDenyNone);
if Handle = THandle(-1) then
begin
Result := False;
Exit;
end;
Result := Windows.SetFileTime(Handle, @LModified, @LModified, @LModified);
FileClose(Handle);
end;
{$ENDIF}
{$IFDEF FPCLINUX}
var
times: UTimBuf;
begin
times.actime := DateTimeToUnixTime(Modified);
times.modtime := times.actime;
Result := FpUtime(PChar(FileName), @times) = 0;
end;
{$ENDIF}
{$IFDEF KYLIX3}
var
AccessModTimes: TAccessModificationTimes;
TimeStamp: Int64;
begin
TimeStamp := DateTimeToUnixTime(Modified);
AccessModTimes.AccessTime.tv_sec := TimeStamp;
AccessModTimes.AccessTime.tv_usec := 0;
AccessModTimes.ModificationTime.tv_sec := TimeStamp;
AccessModTimes.ModificationTime.tv_usec := 0;
Result := utimes(PChar(FileName), AccessModTimes) = 0;
end;
{$ENDIF}
procedure CreateDirectories(const FileName: TFileName);
var
Index: Integer;
LFileName: RawUTF8;
Directory: TFileName;
begin
LFileName := StringToUTF8(FileName);
Index := 1;
repeat
Index := PosEx(PathDelim, LFileName, Index);
if Index = 0 then Exit;
SetString(Directory, PChar(FileName), Index);
EnsureDirectoryExists(Directory, True);
Inc(Index);
until False;
end;
{ TAsset }
function TAsset.LoadFromFile(const Root, FileName: TFileName): Boolean;
begin
Result := FileExists(FileName);
if not Result then Exit;
Result := GetFileInfo(FileName, @Modified, nil);
if not Result then Exit;
if (Root <> '') and (Length(FileName) > Length(Root)) and
IdemPropName(Pointer(Root), Pointer(FileName),
Length(Root), Length(Root)) then
SetString(Path, PChar(@FileName[Length(Root)]),
Length(FileName) - Length(Root) + 1)
else
SetString(Path, PChar(FileName), Length(FileName));
{$IFDEF MSWINDOWS}
Path := StringReplaceChars(Path, PathDelim, '/');
{$ENDIF}
Path := LowerCase(Path);
SetEncoding(StringFromFile(FileName));
ContentType := KnownMIMEContentTypes.Value(
LowerCase(StringToAnsi7(ExtractFileExt(FileName))), #0);
if ContentType = #0 then
ContentType := GetMimeContentType(Pointer(Content), Length(Content),
FileName);
GZipExists := False;
GZipEncoding := '';
GZipHash := 0;
BrotliExists := False;
BrotliEncoding := '';
BrotliHash := 0;
end;
function TAsset.SaveIdentityToFile(const Root: TFileName;
const ChecksNotModified: TFileChecks): TFileName;
var
LModified: TDateTime;
LSize: Int64;
FileModified: Boolean;
begin
Result := UTF8ToString(Path);
{$IFDEF MSWINDOWS}
Result := StringReplace(Result, '/', PathDelim, [rfReplaceAll]);
{$ENDIF}
if Root = '' then
Delete(Result, 1, 1)
else if Root[Length(Root)] = PathDelim then
Result := Root + Result
else
Result := Root + PathDelim + Result;
if (ChecksNotModified <> []) and FileExists(Result) and
GetFileInfo(Result, @LModified, @LSize) then
begin
FileModified := False;
if fcModified in ChecksNotModified then
FileModified := FileModified or
(Round((LModified - Modified) * SecsPerDay) <> 0);
if fcSize in ChecksNotModified then
FileModified := FileModified or
(FileSize(Result) <> Length(Content));
if not FileModified then Exit;
end;
CreateDirectories(Result);
if FileFromString(Content, Result) then
SetFileTime(Result, Modified);
end;
function TAsset.SaveToFile(const Root: TFileName;
const Encoding: TAssetEncoding;
const ChecksNotModified: TFileChecks): TFileName;
const
DIRS: array[TAssetEncoding] of TFileName = ('identity', 'gzip', 'brotli');
EXTS: array[TAssetEncoding] of TFileName = ('', '.gz', '.br');
var
LModified: TDateTime;
LSize: Int64;
FileModified: Boolean;
FileContent: RawByteString;
begin
case Encoding of
aeIdentity:
FileContent := Content;
aeGZip:
if GZipExists then
FileContent := GZipEncoding
else begin
Result := '';
Exit;
end;
aeBrotli:
if BrotliExists then
FileContent := BrotliEncoding
else begin
Result := '';
Exit;
end;
end;
Result := UTF8ToString(Path);
{$IFDEF MSWINDOWS}
Result := StringReplace(Result, '/', PathDelim, [rfReplaceAll]);
{$ENDIF}
if Root = '' then
Result := DIRS[Encoding] + Result
else if Root[Length(Root)] = PathDelim then
Result := Root + DIRS[Encoding] + Result
else
Result := Root + PathDelim + DIRS[Encoding] + Result;
if Encoding in [aeGZip, aeBrotli] then
Result := Result + EXTS[Encoding];
if (ChecksNotModified <> []) and FileExists(Result) and
GetFileInfo(Result, @LModified, @LSize) then
begin
FileModified := False;
if fcModified in ChecksNotModified then
FileModified := FileModified or
(Round((LModified - Modified) * SecsPerDay) <> 0);
if fcSize in ChecksNotModified then
FileModified := FileModified or
(FileSize(Result) <> Length(FileContent));
if not FileModified then Exit;
end;
CreateDirectories(Result);
if FileFromString(FileContent, Result) then
SetFileTime(Result, Modified);
end;
procedure TAsset.SetEncoding(const Encoded: RawByteString;
const Encoding: TAssetEncoding);
begin
case Encoding of
aeIdentity:
begin
Content := Encoded;
Hash := crc32c(0, Pointer(Encoded), Length(Encoded));
end;
aeGZip:
begin
GZipExists := True;
GZipEncoding := Encoded;
GZipHash := crc32c(0, Pointer(Encoded), Length(Encoded));
end;
aeBrotli:
begin
BrotliExists := True;
BrotliEncoding := Encoded;
BrotliHash := crc32c(0, Pointer(Encoded), Length(Encoded));
end;
end;
end;
{ TAssets }
function TAssets.Add(const Root, FileName: TFileName): PAsset;
var
Asset: TAsset;
Index: Integer;
WasAdded: Boolean;
begin
if not Asset.LoadFromFile(Root, FileName) then
begin
Result := nil;
Exit;
end;
Index := FAssetsDAH.FindHashedForAdding(Asset.Path, WasAdded);
Assets[Index] := Asset;
Result := @Assets[Index];
end;
function TAssets.Find(const Path: RawUTF8): PAsset;
var
Index: Integer;
begin
Index := FAssetsDAH.FindHashed(Path);
if Index >= 0 then
Result := @Assets[Index]
else
Result := nil;
end;
procedure TAssets.Init;
begin
Assets := nil;
FillCharFast(Self, SizeOf(Self), 0);
FAssetsDAH.InitSpecific(TypeInfo(TAssetDynArray), Assets, djRawUTF8, @Count);
end;
procedure TAssets.LoadFromFile(const FileName: TFileName);
begin
FAssetsDAH.LoadFrom(Pointer(AlgoSynLZ.Decompress(StringFromFile(FileName))));
FAssetsDAH.ReHash;
end;
procedure TAssets.LoadFromResource(const ResName: string);
var
RawAssets: RawByteString;
begin
ResourceSynLZToRawByteString(ResName, RawAssets);
FAssetsDAH.LoadFrom(Pointer(RawAssets));
FAssetsDAH.ReHash;
end;
procedure TAssets.SaveAll(const Root: TFileName;
const ChecksNotModified: TFileChecks);
var
Index: Integer;
Encoding: TAssetEncoding;
begin
for Index := 0 to Count - 1 do
with Assets[Index] do
for Encoding := Low(TAssetEncoding) to High(TAssetEncoding) do
SaveToFile(Root, Encoding, ChecksNotModified);
end;
procedure TAssets.SaveAllIdentities(const Root: TFileName;
const ChecksNotModified: TFileChecks);
var
Index: Integer;
begin
for Index := 0 to Count - 1 do
with Assets[Index] do
SaveIdentityToFile(Root, ChecksNotModified);
end;
procedure TAssets.SaveToFile(const FileName: TFileName);
begin
FileFromString(AlgoSynLZ.Compress(FAssetsDAH.SaveTo), FileName);
end;
initialization
KnownMIMEContentTypes.InitFromCSV(MIME_CONTENT_TYPES);
end.
|
PROCEDURE MyProgram;
{This program will count paragraphs}
{Created by: Eric Gates 6/6/89}
{HW #1, Part 1}
VAR CurrLine,PrevLine: String;
ParCount: integer;
(*************************************************************************)
FUNCTION IsItBlank(S: String): boolean;
{Checks to see if a line is blank}
VAR Counter: integer;
Stop: character;
BEGIN {IsItBlank}
Counter := 1;
REPEAT
IF S[Counter] NOT IN [BLANK,TAB,BELL,BACKSPACE]
THEN BEGIN {IF-THEN}
Stop := 'Y';
IsItBlank := False;
END {IF-THEN]
ELSE IsItBlank := True;
Counter := Counter + 1;
UNTIL (Stop = 'Y') OR (Counter >= Length(S))
END; {IsItBlank}
(*************************************************************************)
PROCEDURE Init(var S: String);
{Initializes strings to blanks}
VAR Counter: integer;
BEGIN {Init}
FOR Counter := 1 TO MAXSTR DO
S[Counter] := BLANK;
END; {Init}
(*************************************************************************)
PROCEDURE CountParagraphs(var PrevLine,Currline: string;
var ParCount: integer);
{Counts the paragraphs}
VAR Counter: integer;
BEGIN {CountParagraphs}
ParCount := 0;
WHILE GetLine(CurrentLine,STDIN,MAXSTR) DO
BEGIN {WHILE}
IF IsItBlank(CurrLine) AND (NOT IsItBlank(PrevLine))
THEN ParCount := ParCount + 1;
Init(PrevLine);
FOR Counter := 1 TO Length(CurrLine) DO
PrevLine[Counter] := CurrLine[Counter]
Init(CurrLine);
END; {WHILE}
IF NOT IsItBlank(PrevLine)
THEN ParCount := ParCount + 1;
END; {CountParagraphs}
(*************************************************************************)
BEGIN {MyProgram}
Message('Paragraph Counter by Eric Gates -- ALDER. 6/6/89');
ParCount := 0;
Init(CurrLine);
Init(PrevLine);
CountParagraphs(PrevLine,CurrLine,ParCount);
Putcf(ParCount,STDOUT);
END; {MyProgram}
|
namespace Sunko;
type
///Типы слов
WordType = abstract class
public function ToString: string; override;
begin
Result := self.GetType.Name;
end;
end;
{WordType = (
///Разделитель
///Примером разделителя является =
Splitter
);}
end. |
unit UFormInfo;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls,
UForm, UForms;
type
TFormInfo = class(TAdvancedForm)
btnOK: TButton;
Label1: TLabel;
Label2: TLabel;
lblFormID: TLabel;
Label4: TLabel;
lblFormName: TLabel;
lblVersion: TLabel;
Label7: TLabel;
lblCreated: TLabel;
Label9: TLabel;
lblModified: TLabel;
Label14: TLabel;
lblPages: TLabel;
procedure FormShow(Sender: TObject);
private
{ Private declarations }
procedure AdjustDPISettings;
public
{ Public declarations }
procedure SetFormProperties(form: TDocForm);
end;
var
FormInfo: TFormInfo;
implementation
(*
uses
SysUtils;
*)
{$R *.dfm}
{ TFormInfo }
procedure TFormInfo.SetFormProperties(form: TDocForm);
begin
with Form.frmInfo do
begin
lblFormName.Caption := ExtractFileName(fFormFilePath);
lblFormID.Caption := IntToStr(fFormUID);
lblVersion.Caption := IntToStr(fFormVers);
lblCreated.Caption := fCreateDate;
lblModified.Caption := fLastUpdate;
lblPages.Caption := IntToStr(fFormPgCount);
end;
end;
procedure TFormInfo.AdjustDPISettings;
begin
btnOK.Left := Label9.Left;
btnOK.top := lblModified.Top + lblModified.Height + 20;
self.Width := lblModified.Left + lblModified.Width + 100;
self.Height := btnOK.Top + btnOK.Height + 50;
self.Constraints.MaxWidth := 0;
self.Constraints.MinWidth := 0;
self.Constraints.MaxHeight := 0;
self.Constraints.MinHeight := 0;
end;
procedure TFormInfo.FormShow(Sender: TObject);
begin
AdjustDPISettings;
end;
end.
|
unit dsdGuides;
interface
uses Classes, Controls, dsdDB, VCL.Menus, VCL.ActnList, Forms;
type
TAccessControl = class(Controls.TWinControl)
public
property OnDblClick;
end;
TActionItem = class(TCollectionItem)
private
FAction: TCustomAction;
procedure SetAction(const Value: TCustomAction);
protected
function GetDisplayName: string; override;
public
procedure Assign(Source: TPersistent); override;
published
property Action: TCustomAction read FAction write SetAction;
end;
TShortCutActionItem = class(TActionItem)
private
FSecondaryShortCuts: TShortCutList;
FShortCut: TShortCut;
procedure SetShortCut(const Value: TShortCut);
function GetSecondaryShortCuts: TShortCutList;
procedure SetSecondaryShortCuts(const Value: TShortCutList);
function IsSecondaryShortCutsStored: Boolean;
public
procedure Assign(Source: TPersistent); override;
published
property ShortCut: TShortCut read FShortCut write SetShortCut default 0;
property SecondaryShortCuts: TShortCutList read GetSecondaryShortCuts
write SetSecondaryShortCuts stored IsSecondaryShortCutsStored;
end;
TActionItemList = class(TOwnedCollection)
private
function GetItem(Index: Integer): TActionItem;
procedure SetItem(Index: Integer; const Value: TActionItem);
public
function Add: TActionItem;
property Items[Index: Integer]: TActionItem read GetItem write SetItem; default;
end;
// имплементирующий данный класс вызывает форму для выбора из справочника
IChoiceCaller = interface
['{879D5206-590F-43CB-B992-26B096342EC2}']
procedure SetOwner(Owner: TObject);
procedure AfterChoice(Params: TdsdParams; Form: TForm);
property Owner: TObject write SetOwner;
end;
TCustomGuides = class(TComponent, IChoiceCaller)
private
FParams: TdsdParams;
FKey: String;
FParentId: String;
FTextValue: String;
FPositionDataSet: string;
FParentDataSet: string;
FFormName: string;
FLookupControl: TWinControl;
FKeyField: string;
FChoiceAction: TComponent;
FFormNameParam: TdsdParam;
FisShowModal: boolean;
FDisableGuidesOpen: boolean;
function GetKey: String;
function GetTextValue: String;
procedure SetKey(const Value: String);
procedure SetTextValue(const Value: String);
procedure SetLookupControl(const Value: TWinControl); virtual;
procedure OnDblClick(Sender: TObject);
procedure OpenGuides;
procedure OnButtonClick(Sender: TObject; AButtonIndex: Integer);
procedure SetOwner(Owner: TObject);
procedure SetFormName(const Value: string);
function GetFormName: string;
function GetFormNameParam: TdsdParam;
protected
FOnChange: TNotifyEvent;
// имя формы
property FormName: string read GetFormName write SetFormName;
property FormNameParam: TdsdParam read GetFormNameParam write FFormNameParam;
// Где позиционируемся по ParentId
property ParentDataSet: string read FParentDataSet write FParentDataSet;
// Где позиционируемся по ИД
property PositionDataSet: string read FPositionDataSet write FPositionDataSet;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
// ID записи
property Key: String read GetKey write SetKey;
// Текстовое значение
property TextValue: String read GetTextValue write SetTextValue;
// Родитель для древовидных справочников
property ParentId: String read FParentId write FParentId;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
protected
property isShowModal: boolean read FisShowModal write FisShowModal default false;
// Вызыввем процедуру после выбора элемента из справочника
procedure AfterChoice(Params: TdsdParams; Form: TForm); virtual; abstract;
// данные, получаемые после выбора из справочника. Например для передачи в другие контролы
property Params: TdsdParams read FParams write FParams;
published
// ключевое поле
property KeyField: string read FKeyField write FKeyField;
// визуальный компонент
property LookupControl: TWinControl read FLookupControl write SetLookupControl;
// закрыть выбор из справочников
property DisableGuidesOpen: boolean read FDisableGuidesOpen write FDisableGuidesOpen default false;
end;
// Компонент работает со справочниками. Выбирает значение из элементов управления или форм
TdsdGuides = class(TCustomGuides)
private
FOnAfterChoice: TNotifyEvent;
FPopupMenu: TPopupMenu;
procedure OnPopupClick(Sender: TObject);
procedure SetLookupControl(const Value: TWinControl); override;
protected
// Вызыввем процедуру после выбора элемента из справочника
procedure AfterChoice(Params: TdsdParams; Form: TForm); override;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
property OnChange: TNotifyEvent read FOnChange write FOnChange;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property isShowModal;
property Key;
// Текстовое значение
property TextValue;
property FormNameParam;
property FormName;
// Родитель для древовидных справочников
property ParentId;
// Где позиционируемся по ИД
property PositionDataSet;
// Где позиционируемся по ParentId
property ParentDataSet;
property Params;
property OnAfterChoice: TNotifyEvent read FOnAfterChoice write FOnAfterChoice;
end;
TChangeStatus = class(TCustomGuides)
private
FProcedure: TdsdStoredProc;
FParam: TdsdParam;
function GetStoredProcName: string;
procedure SetStoredProcName(const Value: string);
protected
// Вызываем процедуру после выбора элемента из справочника
procedure AfterChoice(Params: TdsdParams; Form: TForm); override;
public
constructor Create(AOwner: TComponent); override;
published
property IdParam: TdsdParam read FParam write FParam;
property StoredProcName: string read GetStoredProcName write SetStoredProcName;
end;
TGuidesListItem = class(TCollectionItem)
private
FGuides: TdsdGuides;
procedure SetGuides(const Value: TdsdGuides);
public
procedure Assign(Source: TPersistent); override;
protected
function GetDisplayName: string; override;
published
property Guides: TdsdGuides read FGuides write SetGuides;
end;
TGuidesFiller = class;
TGuidesList = class(TOwnedCollection)
private
function GetItem(Index: Integer): TGuidesListItem;
procedure SetItem(Index: Integer; const Value: TGuidesListItem);
public
function Add: TGuidesListItem;
property Items[Index: Integer]: TGuidesListItem read GetItem write SetItem; default;
end;
// Вызывает заполнение справочников при создании документа
TGuidesFiller = class(TComponent)
private
FGuidesList: TGuidesList;
FParam: TdsdParam;
FOnAfterShow: TNotifyEvent;
FActionItemList: TActionItemList;
procedure OnAfterShow(Sender: TObject);
procedure OnAfterChoice(Sender: TObject);
protected
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property IdParam: TdsdParam read FParam write FParam;
property GuidesList: TGuidesList read FGuidesList write FGuidesList;
property ActionItemList: TActionItemList read FActionItemList write FActionItemList;
end;
procedure Register;
implementation
uses cxDBLookupComboBox, cxButtonEdit, Variants, ParentForm, FormStorage, DB,
SysUtils, Dialogs, dsdAction, cxDBEdit, dsdAddOn;
procedure Register;
begin
RegisterComponents('DSDComponent', [TdsdGuides]);
RegisterComponents('DSDComponent', [TGuidesFiller]);
RegisterComponents('DSDComponent', [TChangeStatus]);
end;
{ TdsdGuides }
type
TAccessWinControl = class(TWinControl)
public
property onExit;
end;
procedure TdsdGuides.AfterChoice(Params: TdsdParams; Form: TForm);
var i: integer;
begin
// Расставляем параметры по местам
Self.Params.AssignParams(Params);
if Assigned(FOnAfterChoice) then
// Здесь форму закроют
FOnAfterChoice(Form)
else
// Если форма не закрыта, то закрываем
if Form.Visible then
Form.Close;
// Вызываем заполнение параметров
for I := 0 to Params.Count - 1 do
if assigned(Self.Params.ParamByName(Params[i].Name).Component) then
if Self.Params.ParamByName(Params[i].Name).Component is TCustomGuides then
if not (Self.Params.ParamByName(Params[i].Name).Component as TCustomGuides).LookupControl.Focused then
if ansilowercase(Self.Params.ParamByName(Params[i].Name).ComponentItem) = 'textvalue' then
if Assigned(TAccessWinControl((Self.Params.ParamByName(Params[i].Name).Component as TCustomGuides).LookupControl).onExit) then
TAccessWinControl((Self.Params.ParamByName(Params[i].Name).Component as TCustomGuides).LookupControl).onExit((Self.Params.ParamByName(Params[i].Name).Component as TCustomGuides).LookupControl);
end;
constructor TdsdGuides.Create(AOwner: TComponent);
var MenuItem: TMenuItem;
begin
inherited;
FFormNameParam := TdsdParam.Create(nil);
FFormNameParam.DataType := ftString;
FFormNameParam.Value := '';
FParams := TdsdParams.Create(Self, TdsdParam);
FPopupMenu := TPopupMenu.Create(nil);
MenuItem := TMenuItem.Create(FPopupMenu);
with MenuItem do begin
Caption := 'Обнулить значение';
ShortCut := 32776; // Alt + BkSp
OnClick := OnPopupClick;
end;
FPopupMenu.Items.Add(MenuItem);
end;
destructor TdsdGuides.Destroy;
begin
FreeAndNil(FParams);
FreeAndNil(FPopupMenu);
FreeAndNil(FFormNameParam);
inherited;
end;
procedure TdsdGuides.Notification(AComponent: TComponent;
Operation: TOperation);
var i: integer;
begin
inherited;
if csDestroying in ComponentState then
exit;
if (Operation = opRemove) then begin
if Assigned(Params) then
for i := 0 to Params.Count - 1 do
if Params[i].Component = AComponent then
Params[i].Component := nil;
end;
end;
procedure TdsdGuides.OnPopupClick(Sender: TObject);
begin
Key := '0';
TextValue := '';
end;
procedure TdsdGuides.SetLookupControl(const Value: TWinControl);
begin
inherited;
if FLookupControl is TcxButtonEdit then
(LookupControl as TcxButtonEdit).PopupMenu := FPopupMenu;
if FLookupControl is TcxLookupComboBox then
(LookupControl as TcxLookupComboBox).PopupMenu := FPopupMenu;
end;
{ TGuidesListItem }
function TGuidesListItem.GetDisplayName: string;
begin
if Assigned(Guides) then
result := Guides.Name
else
result := inherited;
end;
procedure TGuidesListItem.SetGuides(const Value: TdsdGuides);
begin
if Assigned(Value) then begin
if Assigned(Collection) then
Value.FreeNotification(TComponent(Collection.Owner));
if Collection.Owner is TGuidesFiller then
Value.OnAfterChoice := TGuidesFiller(Self.Collection.Owner).OnAfterChoice;
end;
FGuides := Value;
end;
procedure TGuidesListItem.Assign(Source: TPersistent);
begin
if Source is TGuidesListItem then
with TGuidesListItem(Source) do
begin
Self.FGuides := FGuides;
end
else
inherited Assign(Source);
end;
{ TGuidesList }
function TGuidesList.Add: TGuidesListItem;
begin
result := TGuidesListItem(inherited Add);
end;
function TGuidesList.GetItem(Index: Integer): TGuidesListItem;
begin
Result := TGuidesListItem(inherited GetItem(Index));
end;
procedure TGuidesList.SetItem(Index: Integer; const Value: TGuidesListItem);
begin
inherited SetItem(Index, Value);
end;
{ TGuidesFiller }
constructor TGuidesFiller.Create(AOwner: TComponent);
begin
inherited;
GuidesList := TGuidesList.Create(Self, TGuidesListItem);
FParam := TdsdParam.Create(nil);
FActionItemList := TActionItemList.Create(Self, TActionItem);
if AOwner is TCustomForm then begin
FOnAfterShow := TParentForm(AOwner).OnAfterShow;
TParentForm(AOwner).OnAfterShow := Self.OnAfterShow;
end;
end;
destructor TGuidesFiller.Destroy;
begin
FreeAndNil(FGuidesList);
FreeAndNil(FParam);
FreeAndNil(FActionItemList);
if Owner is TCustomForm then
TParentForm(Owner).OnAfterShow := FOnAfterShow;
inherited;
end;
procedure TGuidesFiller.Notification(AComponent: TComponent;
Operation: TOperation);
var i: integer;
begin
inherited;
if csDestroying in ComponentState then
exit;
if (Operation = opRemove) then begin
if (AComponent is TdsdGuides) and Assigned(GuidesList) then
for i := 0 to GuidesList.Count - 1 do
if GuidesList[i].Guides = AComponent then
GuidesList[i].Guides := nil;
if (AComponent is TCustomAction) and Assigned(ActionItemList) then
for i := 0 to ActionItemList.Count - 1 do
if ActionItemList[i].Action = AComponent then
ActionItemList[i].Action := nil;
end;
end;
procedure TGuidesFiller.OnAfterChoice(Sender: TObject);
var i: integer;
begin
if Assigned(FParam) then
if (FParam.Value = 0) or VarIsNull(FParam.Value) then begin
for I := 0 to GuidesList.Count - 1 do
if assigned(GuidesList[i].Guides) then
if (GuidesList[i].Guides.Key = '0') or ((GuidesList[i].Guides.Key = '')) then begin
// Закроем форму справочника
if Sender is TForm then
TForm(Sender).Close;
GuidesList[i].Guides.OpenGuides;
exit;
end;
// Прошли по всем справочникам и они заполнены
// Выполняем все Action
for I := 0 to FActionItemList.Count - 1 do
if Assigned(FActionItemList[i].Action) then
if FActionItemList[i].Action.Enabled then begin
// ну раз уж сохранили ИД, то уж
// нет смысла вызывать THeaderSaver
FActionItemList[i].Action.Execute;
end;
// Эмулирует заход во все контролы, чтобы установить текущие значения
if Assigned(Owner) then
for i :=0 to Owner.ComponentCount - 1 do
if Owner.Components[i] is THeaderSaver then
THeaderSaver(Owner.Components[i]).EnterAll;
end;
// Если не возникло ошибок!!! закроем форму справочника
if (Sender is TForm) then
TForm(Sender).Close;
end;
procedure TGuidesFiller.OnAfterShow(Sender: TObject);
begin
if Assigned(FOnAfterShow) then
FOnAfterShow(Sender);
OnAfterChoice(Self);
end;
{ TActionItem }
procedure TActionItem.SetAction(const Value: TCustomAction);
begin
if FAction <> Value then begin
if Assigned(Collection) and Assigned(Value) then
Value.FreeNotification(TComponent(Collection.Owner));
FAction := Value;
end;
end;
procedure TActionItem.Assign(Source: TPersistent);
begin
if Source is TActionItem then
Self.Action := TActionItem(Source).Action
else
inherited Assign(Source);
end;
function TActionItem.GetDisplayName: string;
begin
if Assigned(Action) then
result := Action.Name
else
result := inherited;
end;
procedure TShortCutActionItem.Assign(Source: TPersistent);
begin
inherited Assign(Source);
with TShortCutActionItem(Source) do begin
Self.ShortCut := ShortCut;
Self.SecondaryShortCuts.Assign(SecondaryShortCuts);
end;
end;
function TShortCutActionItem.GetSecondaryShortCuts: TShortCutList;
begin
if FSecondaryShortCuts = nil then
FSecondaryShortCuts := TShortCutList.Create;
Result := FSecondaryShortCuts;
end;
procedure TShortCutActionItem.SetSecondaryShortCuts(const Value: TShortCutList);
begin
if FSecondaryShortCuts = nil then
FSecondaryShortCuts := TShortCutList.Create;
FSecondaryShortCuts.Assign(Value);
end;
function TShortCutActionItem.IsSecondaryShortCutsStored: Boolean;
begin
Result := Assigned(FSecondaryShortCuts) and (FSecondaryShortCuts.Count > 0);
end;
procedure TShortCutActionItem.SetShortCut(const Value: TShortCut);
begin
FShortCut := Value;
end;
{ TActionItemList }
function TActionItemList.Add: TActionItem;
begin
result := TActionItem(inherited Add);
end;
function TActionItemList.GetItem(Index: Integer): TActionItem;
begin
Result := TActionItem(inherited GetItem(Index));
end;
procedure TActionItemList.SetItem(Index: Integer; const Value: TActionItem);
begin
inherited SetItem(Index, Value);
end;
{ TCustomGuides }
procedure TCustomGuides.OnDblClick(Sender: TObject);
begin
OpenGuides;
end;
procedure TCustomGuides.SetLookupControl(const Value: TWinControl);
begin
FLookupControl := Value;
if not Assigned(FLookupControl) then
exit;
TAccessControl(FLookupControl).OnDblClick := OnDblClick;
if FLookupControl is TcxButtonEdit then
(LookupControl as TcxButtonEdit).Properties.OnButtonClick := OnButtonClick;
if FLookupControl is TcxDBButtonEdit then
(LookupControl as TcxDBButtonEdit).Properties.OnButtonClick := OnButtonClick;
end;
procedure TCustomGuides.SetOwner(Owner: TObject);
begin
FChoiceAction := Owner as TComponent;
FChoiceAction.FreeNotification(Self);
end;
procedure TCustomGuides.OnButtonClick(Sender: TObject; AButtonIndex: Integer);
begin
if Sender is TcxButtonEdit then
if not Assigned(TcxButtonEdit(Sender).Properties.Buttons[AButtonIndex].Action) then
OnDblClick(Sender);
if Sender is TcxDBButtonEdit then
if not Assigned(TcxDBButtonEdit(Sender).Properties.Buttons[AButtonIndex].Action) then
OnDblClick(Sender);
end;
procedure TCustomGuides.OpenGuides;
var
Form: TParentForm;
DataSet: TDataSet;
begin
if DisableGuidesOpen then exit;
if FormName = '' then exit;
Form := TdsdFormStorageFactory.GetStorage.Load(FormName);
// Открыли форму
Form.Execute(Self, Params);
// Спозиционировались на ParentData если он есть
if ParentDataSet <> '' then begin
DataSet := Form.FindComponent(ParentDataSet) as TDataSet;
if not Assigned(DataSet) then
raise Exception.Create('Не правильно установлено свойство ParentDataSet для формы ' + FormName);
if ParentId <> '' then
DataSet.Locate('Id', ParentId, []);
end;
if not (Form.FindComponent(PositionDataSet) is TDataSet) then
raise Exception.Create(FormName + '. Компонент ' + Name + '. Класс ' + PositionDataSet + ' не является TDataSet');
// Спозиционировались на дата сете
DataSet := Form.FindComponent(PositionDataSet) as TDataSet;
if not Assigned(DataSet) then
raise Exception.Create('Не правильно установлено свойство PositionDataSet для формы ' + FormName);
if Key <> '' then
DataSet.Locate(KeyField, Key, []);
// Показали форму
if isShowModal then
Form.ShowModal
else
Form.Show;
end;
constructor TCustomGuides.Create(AOwner: TComponent);
begin
inherited;
PositionDataSet := 'ClientDataSet';
KeyField := 'Id';
isShowModal := false;
FDisableGuidesOpen := false;
end;
destructor TCustomGuides.Destroy;
begin
// Унижтожаем ссылку на себя в другом компоненте!
try
if Assigned(FChoiceAction) then
if FChoiceAction is TdsdChoiceGuides then
TdsdChoiceGuides(FChoiceAction).ChoiceCaller := nil;
except
end;
inherited;
end;
function TCustomGuides.GetFormName: string;
begin
result := FFormNameParam.AsString;
if result = '' then
result := FFormName
end;
function TCustomGuides.GetFormNameParam: TdsdParam;
begin
if FFormNameParam.AsString = '' then
FFormNameParam.Value := FormName;
Result := FFormNameParam;
end;
function TCustomGuides.GetKey: String;
begin
if Assigned(LookupControl) then begin
if LookupControl is TcxLookupComboBox then begin
// Проверим выбран ли элемент
if VarisNull((LookupControl as TcxLookupComboBox).EditValue) then
Result := '0'
else
Result := (LookupControl as TcxLookupComboBox).EditValue;
end
else
Result := FKey;
end;
end;
function TCustomGuides.GetTextValue: String;
begin
result := FTextValue
end;
procedure TCustomGuides.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited;
if csDestroying in ComponentState then
exit;
if (Operation = opRemove) then begin
if (AComponent = FLookupControl) then
FLookupControl := nil;
if (AComponent = FChoiceAction) then
FChoiceAction := nil;
end;
end;
procedure TCustomGuides.SetFormName(const Value: string);
begin
if (Value <> '') and (csDesigning in ComponentState) and not (csLoading in ComponentState) then
ShowMessage('Используйте FormNameParam')
else
FFormName := Value;
end;
procedure TCustomGuides.SetKey(const Value: String);
var isChange_my:Boolean; // add 25.02.2018
begin
isChange_my:= TRUE; // add 25.02.2018
//
if Value = '' then
FKey := '0'
else begin
try isChange_my:= FKey <> Value; except isChange_my:= TRUE; end; // add 25.02.2018
FKey := Value;
end;
if Assigned(FOnChange) and (isChange_my = TRUE) then
FOnChange(Self);
if Assigned(LookupControl) then begin
if LookupControl is TcxLookupComboBox then
(LookupControl as TcxLookupComboBox).EditValue := FKey
end;
end;
procedure TCustomGuides.SetTextValue(const Value: String);
var
TextShow: string;
begin
FTextValue := Value;
if (FTextValue = '') and (Key <> '0') and (Key <> '') then
TextShow := Key
else
TextShow := FTextValue;
if Assigned(LookupControl) then begin
if LookupControl is TcxLookupComboBox then
(LookupControl as TcxLookupComboBox).Text := TextShow;
if LookupControl is TcxButtonEdit then
(LookupControl as TcxButtonEdit).Text := TextShow;
if LookupControl is TcxDBButtonEdit then
(LookupControl as TcxDBButtonEdit).Text := TextShow;
end;
end;
{ TChangeStatus }
procedure TChangeStatus.AfterChoice(Params: TdsdParams; Form: TForm);
begin
// Вот прямо тут вызываем процедуру и если отработала,
FProcedure.ParamByName('inMovementId').Value := IdParam.Value;
FProcedure.ParamByName('inStatusCode').Value := Params.ParamByName('Key').Value;
FProcedure.Execute;
// то меняем данные
Key := Params.ParamByName('Key').Value;
TextValue := Params.ParamByName('TextValue').Value;
end;
constructor TChangeStatus.Create(AOwner: TComponent);
begin
inherited;
FFormName := 'TStatusForm';
FParam := TdsdParam.Create(nil);
FProcedure := TdsdStoredProc.Create(Self);
FProcedure.OutputType := otResult;
FProcedure.Params.AddParam('inMovementId', ftInteger, ptInput, 0);
FProcedure.Params.AddParam('inStatusCode', ftInteger, ptInput, 0);
end;
function TChangeStatus.GetStoredProcName: string;
begin
result := FProcedure.StoredProcName;
end;
procedure TChangeStatus.SetStoredProcName(const Value: string);
begin
FProcedure.StoredProcName := Value;
end;
initialization
RegisterClass(TdsdGuides);
end.
|
unit
RouteLinks;
interface
uses Project, Connective, Netlist, Classes, Contnrs, SysUtils,
Types, ManagedItem;
type
ERouterError = class(Exception);
// Copper Strip Belonging to a Net.
// A TroStrip does not own the TcnStrip in its FCheckerStrip member - it is just a
// reference.
type TroStrip = class( TManagedItem )
protected
FCheckerStrip : TcnStrip;
public
property CheckerStrip : TcnStrip read FCheckerStrip write FCheckerStrip;
end;
type TroLink = record
X : integer;
StartY : integer;
EndY : integer;
Valid : boolean;
end;
type TroMoveBreakLink = record
// this record describes a valid link
Valid : boolean;
// link X, and Y
X : integer;
StartY : integer;
EndY : integer;
// first break Y
BreakLeftY : integer;
// first break original X
BreakLeftFromX : integer;
// first break new X
BreakLeftToX : integer;
// second break Y
BreakRightY : integer;
// second break original X
BreakRightFromX : integer;
// second break new X
BreakRightToX : integer;
RightStrip : TroStrip;
LeftStrip : TroStrip;
end;
// Island of Strips - all belonging to same net and joined by wires or links
// Island does not own the strip objects in its list - they are just references
type TroIsland = class
protected
FStrips : TList;
FIslandNo : integer;
function GetStrip( index : integer ) : TroStrip;
function GetStripCount : integer;
public
property Strips[index : integer] : TroStrip read GetStrip;
property StripCount : integer read GetStripCount;
property IslandNo : integer read FIslandNo write FIslandNo;
procedure AddStrip( Strip : TroStrip );
procedure ClearStrips;
constructor Create;
destructor Destroy; override;
end;
// Record describes free strips - those we can use for linking
type TroFreeStrip = class
XLeft : integer;
XRight : integer;
Y : integer;
end;
// Record describes how an island joins to a FreeStrip
type TroIslandToStrip = record
Valid : boolean;
LinkLength : integer;
IslandStripY : integer;
LinkX : integer;
end;
// Record describes how Islands[] array joins to a FreeStrip
type TXSlots = array[0..TveBoardMAXWIDTH-1] of boolean;
type StripToIslandStatus = record
TotalLinkLength : integer;
LinksMade : integer;
FreeStrip : TroFreeStrip;
// store link starting points (all links end on the FreeStrip)
LinkStarts : array[0..10] of TPoint;
// record which positions are already taken along joining strip
XSlots : TXSlots;
end;
// Router creates and owns TroIsland and TroStrip objects.
type TveRouter = class
protected
FProject : TveProject;
FConnectivity : TConnectivity;
FIslands : TObjectList;
FStrips : TObjectList;
FIslandCount : integer;
FStripCount : integer;
OffBoardLeadedItems : TList;
FFreeStrips : TObjectList;
function GetIsland( index : integer ) : TroIsland;
procedure RemoveIsland( Island : TroIsland );
function GetStrip( index : integer ) : TroStrip;
function LinkPathExists( x, y1, y2 : integer ) : boolean;
procedure JoinIslands;
function LinkStrips( FromStrip, ToStrip : TroStrip ) : TroLink;
procedure JoinIslandsWithBreakShift;
function LinkStripsWithShift( FromStrip, ToStrip : TroStrip ) : TroMoveBreakLink;
procedure JoinIslandsWithFreeStrips;
procedure JoinIslandToStrip(
Island : TroIsland;
FreeStrip : TroFreeStrip;
var XSlots : TXSlots;
var Status : TroIslandToStrip );
procedure IslandStripToFreeStrip(
Strip : TroStrip;
FreeStrip : TroFreeStrip;
var XSlots : TXSlots;
var Status : TroIslandToStrip );
function CreateStrip : TroStrip;
function CreateIsland : TroIsland;
procedure LocateFreeStrips;
function GetFreeStrip( index : integer ) : TroFreeStrip;
function GetFreeStripCount : integer;
function CreateFreeStrip : TroFreeStrip;
procedure Clear;
procedure InternalRouteNet( Net : TneNode );
//procedure RouteAllNets;
property Islands[ index : integer ] : TroIsland read GetIsland;
property Strips[ index : integer ] : TroStrip read GetStrip;
property IslandCount : integer read FIslandCount;
property StripCount : integer read FStripCount;
property FreeStrips[ index : integer ] : TroFreeStrip read GetFreeStrip;
property FreeStripCount : integer read GetFreeStripCount;
procedure DeleteFreeStrip( FreeStrip : TroFreeStrip );
public
property Project : TveProject read FProject write FProject;
procedure RouteNet( Net : TneNode );
procedure RouteAllNetsWithoutLeaded;
constructor Create;
destructor Destroy; override;
end;
implementation
uses Outlines, OtherOutlines, SizeableOutlines, Math;
// *******************************************
// TroIsland
// *******************************************
function TroIsland.GetStrip( index : integer ) : TroStrip;
begin
result := TroStrip(FStrips[index]);
end;
function TroIsland.GetStripCount : integer;
begin
result := FStrips.Count;
end;
procedure TroIsland.AddStrip( Strip : TroStrip );
begin
FStrips.Add( Strip );
end;
procedure TroIsland.ClearStrips;
begin
FStrips.Count := 0;
end;
constructor TroIsland.Create;
begin
FStrips := TList.Create;
end;
destructor TroIsland.Destroy;
begin
FStrips.Free;
end;
// *******************************************
// TveRouter Create, Destroy
// *******************************************
constructor TveRouter.Create;
begin
FStrips := TObjectList.Create;
FIslands := TObjectList.Create;
OffBoardLeadedItems := TList.Create;
FFreeStrips := TObjectList.Create;
end;
destructor TveRouter.Destroy;
begin
FIslands.Free; // destroyes islands
FStrips.Free; // destroys container plus contained strip objects
OffBoardLeadedItems.Free;
FFreeStrips.Free; // destroys container plus contained FreeStrip objects
inherited;
end;
procedure TveRouter.Clear;
begin
FIslandCount := 0;
FStripCount := 0;
end;
function TveRouter.GetIsland( index : integer ) : TroIsland;
begin
if index >= FIslandCount then begin
raise EListError.Create( 'Island index out of bounds' );
end;
result := TroIsland(FIslands[index]);
end;
function TveRouter.GetStrip( index : integer ) : TroStrip;
begin
if index >= FStripCount then begin
raise EListError.Create( 'Strip index out of bounds' );
end;
result := TroStrip(FStrips[index] )
end;
function TveRouter.CreateStrip : TroStrip;
begin
// reuse strip from list
if FStrips.Count > FStripCount then begin
result := TroStrip(FStrips[FStripCount]);
end
// add a new strip to list
else begin
result := TroStrip.Create;
FStrips.Add( result );
end;
Inc( FStripCount );
end;
function TveRouter.CreateIsland : TroIsland;
begin
// reuse island from list
if FIslands.Count > FIslandCount then begin
result := TroIsland(FIslands[FIslandCount]);
// make it look like new
result.ClearStrips;
end
// add a new island to list
else begin
result := TroIsland.Create;
FIslands.Add( result );
end;
Inc( FIslandCount );
end;
procedure TveRouter.RemoveIsland( Island : TroIsland );
var
i : integer;
begin
// find index of our Island.
i := FIslands.IndexOf( Island );
// if removing an island which is already removed
if (i > FIslandCount) then begin
raise ERouterError.Create( 'Island removed twice' );
end;
// move that object to end of list
//.. exception here if line i is -1 for Island invalid
FIslands.Move( i, FIslands.Count -1 );
// and hide it by decreasing count
dec( FIslandCount );
end;
// *******************************************
// SORT STRIPS COMPARISON FUNCTION
// *******************************************
function CompareStripsByStartY_X( P1, P2 : pointer ) : integer;
var
XLeft1, XLeft2 : integer;
Y1, Y2 : integer;
begin
// first compare strips by XLeft (leftmost cell X coord)
// XLeft1 := TdrStrip(P1).XLeft;
// XLeft2 := TdrStrip(P2).XLeft;
XLeft1 := TcnStrip(P1).Start.X;
XLeft2 := TcnStrip(P2).Start.X;
if XLeft1 > XLeft2 then begin
result := 1;
end
else if XLeft1 < XLeft2 then begin
result := -1;
end
// if XLefts are same, next compare strips by Y
else begin
// Y1 := TdrStrip(P1).Y;
// Y2 := TdrStrip(P2).Y;
Y1 := TcnStrip(P1).Start.Y;
Y2 := TcnStrip(P2).Start.Y;
if Y1 > Y2 then begin
result := 1;
end
else if Y1 > Y2 then begin
result := -1;
end
else begin
// we should never get here - overlapping strips
result := 0;
end;
end;
end;
// *******************************************************
// COMPARE TWO LINKS
// *******************************************************
{
Two links are compared and an integer returned:
1 = Link1 better
-1 = Link2 better
0 = Link1, Link2 equal "goodness"
}
function CompareLinks( const Link1, Link2 : TroLink ) : integer;
var
Length1, Length2 : integer;
begin
if Link1.Valid and (not Link2.Valid) then begin
result := 1;
end
else if (not Link1.Valid) and (Link2.Valid) then begin
result := -1;
end
else if (not Link1.Valid) and (not Link2.Valid) then begin
result := 0;
end
else begin
Length1 := abs(Link1.EndY - Link1.StartY);
Length2 := abs(Link2.EndY - Link2.StartY);
if Length1 < Length2 then begin
result := 1;
end
else if Length1 > Length2 then begin
result := -1;
end
else begin
result := 0;
end;
end;
end;
// *******************************************************
// COMPARE TWO BREAK-SHIFTED LINKS
// *******************************************************
{
Two links are compared and an integer returned:
1 = Link1 better
-1 = Link2 better
0 = Link1, Link2 equal "goodness"
}
function CompareLinksWithShift( const Link1, Link2 : TroMoveBreakLink ) : integer;
var
Length1, Length2 : integer;
begin
if Link1.Valid and (not Link2.Valid) then begin
result := 1;
end
else if (not Link1.Valid) and (Link2.Valid) then begin
result := -1;
end
else if (not Link1.Valid) and (not Link2.Valid) then begin
result := 0;
end
else begin
Length1 := abs(Link1.EndY - Link1.StartY);
Length2 := abs(Link2.EndY - Link2.StartY);
if Length1 < Length2 then begin
result := 1;
end
else if Length1 > Length2 then begin
result := -1;
end
else begin
result := 0;
// calculate total amount of break shifting of both links
end;
end;
end;
// *******************************************
// TEST PATH FOR LINK
// *******************************************
// see if there is a clear line for a link to run vertically
// between two points. Returns True if path exists.
function TveRouter.LinkPathExists( x, y1, y2 : integer ) : boolean;
var
y : integer;
Index : integer;
Item : TveBoardItem;
begin
result := True;
for y := y1 to y2 do begin
// a component body or pin means an obstruction
Index := 0;
while true do begin
// See if this cell contains part of a board item
// ..GetNextItemAt() is slow - we may need to make a map of cells
// ..occupied by component pins & bodies.
FProject.GetNextItemAt( Item, Index, x, y );
// no more items - finished checking
if Item = nil then begin
break;
end;
// anything other than a break is an obstruction - no path for link
if not (Item.Outline is TveBreakOutline) then begin
result := False;
break;
end;
end;
end;
end;
// *******************************************
// High Level Public Functions
// *******************************************
// Use these functions to run the class.
// ROUTE A SINGLE NET BY ADDING LINKS
// Start an Undo operation before calling this. RouteNet
// will add its changes to the latest undo operation.
procedure TveRouter.RouteNet( Net : TneNode );
begin
FConnectivity := TConnectivity( FProject.ConnectivityObject );
// find unused strip we can use as joining strip
LocateFreeStrips;
InternalRouteNet( Net );
end;
// ROUTE ALL NETS BY TAKING LEADED ITEMS OFF BOARD THEN ADDING LINKS
// Start an Undo operation before calling this. RouteAllNetsWithoutLeaded
// will add its changes to the latest undo operation.
procedure TveRouter.RouteAllNetsWithoutLeaded;
var
i : integer;
item : TveBoardItem;
j : integer;
begin
FConnectivity := TConnectivity( FProject.ConnectivityObject );
// take all leaded items off the board
OffBoardLeadedItems.Count := 0;
for i := FProject.BoardItemCount -1 downto 0 do begin
Item := FProject.BoardItems[i];
if (Item.Outline is TveLeadedOutline) and (Item.Group = 0) then begin
OffBoardLeadedItems.Add( Item );
FProject.ReleaseBoardItem( Item );
end;
end;
try
// with leaded parts missing, we need to reevaluate DRC strips
FConnectivity.Check;
// find unused strip we can use as joining strips
LocateFreeStrips;
// with leaded items absent, call standard breaks function.
// revaluate connection errors ready for next iteration
for j := 0 to FProject.Netlist.NodeCount -1 do begin
InternalRouteNet( FProject.Netlist.Nodes[j] );
end;
finally
// replace leaded items on board
for i := OffBoardLeadedItems.Count -1 downto 0 do begin
Item := TveBoardItem( OffBoardLeadedItems[i] );
FProject.AddBoardItem( Item );
end;
end;
end;
//************************************************
// End of Public Functions
//************************************************
// *******************************************
// TveRouter RouteNet
// *******************************************
{
This function is called to Autoroute links between strips which
require connection. This function does the core work of this class and as
it runs the lower level class members are called.
Given TveNode, connect all strips belonging to this node.
This reduces to joining the strip islands which the TConnectivity
has identified and which belong to our net.
}
procedure TveRouter.InternalRouteNet( Net : TneNode );
var
i : integer;
StripSet : TcnStripSet;
j : integer;
NewStrip : TroStrip;
NewIsland : TroIsland;
begin
if Net = nil then begin
exit;
end;
// clear old Islands and Strips
Clear;
FStrips.Count :=0;
// Connectivity stores a separate StripSet for each island, so
// create an island for each stripset that belongs to our net
for i := 0 to FConnectivity.StripSetCount - 1 do begin
StripSet := FConnectivity.StripSets[ i ];
if StripSet.Net = Net then begin
// create a new TroIsland object.
NewIsland := CreateIsland;
// give island a unique "island number"
NewIsland.IslandNo := i;
// add all the StripSets strips to the island
for j := 0 to StripSet.Count -1 do begin
NewStrip := CreateStrip;
// connect strip to TConnectivity TcnStrip object
NewStrip.CheckerStrip := StripSet.Strips[j];
// add reference to our strip to current Island
NewIsland.AddStrip( NewStrip );
end;
end;
end;
// no islands to join - ie. No StripSets have this net. Caused by no
// component pin in the net
if IslandCount <= 0 then begin
exit;
end;
// now pass the job to a link maker which links Islands together
JoinIslands;
// pass the job to second link maker which can move breaks to make
// additional links
JoinIslandsWithBreakShift;
// pass the job to the third link maker which can add joining strips
JoinIslandsWithFreeStrips;
end;
// *******************************************
// TveRouter JoinIslands
// *******************************************
{
Given a list of Islands, in the class member Islands[], merge the Islands by
connecting links between strips belonging to different Islands.
1. We start at the first island and try to link to every other island -
then keep the shortest link. We merge the two islands to make a bigger
first island.
2. Using the merged island, we go back to step 1. Eventually we cannot
make a link, and goto step 3.
3. Move to next island down the list and goto step 1, attempting to link to
islands later in the list - never earlier.
Note: do not call if there are no islands to join, because Islands[0] in
code will cause exception
}
procedure TveRouter.JoinIslands;
var
FromIslandIndex : integer;
FromIsland : TroIsland;
ToIsland : TroIsland;
i,j,k : integer;
FromStrip, ToStrip : TroStrip;
TestedLink, BestLink : TroLink;
BestToIsland : TroIsland;
m : integer;
NewLink : TveBoardItem;
begin
// prevent "uninitialised variable" compiler warnings
BestToIsland := nil;
// start a process of many linking attempts
//.. start with first Island
FromIslandIndex := 0;
FromIsland := Islands[0];
while True do begin
// if reached bottom of Islands list, then can't join to any more
// Islands later in the list, so finished
if FromIslandIndex >= IslandCount - 1 then begin
break;
end;
// evaluate all possible links from our Island to all other strips
// outside our Island and belonging to Islands later than our Island in
// the Islands[] list.
BestLink.Valid := False;
for i := FromIslandIndex + 1 to IslandCount -1 do begin
ToIsland := Islands[i];
// from each strip in our Island
for j := 0 to FromIsland.StripCount -1 do begin
FromStrip := FromIsland.Strips[j];
// to each strip in that Island
for k := 0 to ToIsland.StripCount -1 do begin
ToStrip := ToIsland.Strips[k];
//.. LinkStrips called for the same 2 strips every
//.. time we evaluate links from the same island to other
//.. islands. We may want to optimise by caching the result
//.. of the initial call to LinkStrips and just look
//.. up the TroLink records which describes how the link
//.. rated.
TestedLink := LinkStrips( FromStrip, ToStrip );
if (CompareLinks( TestedLink, BestLink ) > 0) then begin
BestLink := TestedLink;
BestToIsland := ToIsland;
end;
end;
end;
end;
// if no link can be made from our Island to a strip from another
// Island further down the list, then we are finished with our Island.
// Move to the next Island down the list
if not BestLink.Valid then begin
Inc( FromIslandIndex);
FromIsland := Islands[FromIslandIndex];
continue;
end;
// 2 Islands are joined by the new link, so combine the later Island
// into in Our Island (FromIsland)
for m := 0 to BestToIsland.StripCount -1 do begin
FromIsland.AddStrip( BestToIsland.Strips[m] );
// BestToIsland.ClearStrips; .. not needed since strips are cleared
// when strips reused.
end;
RemoveIsland( BestToIsland );
// place the "best link"
NewLink := TveBoardItem.Create;
NewLink.Outline := FProject.LinkOutline;
NewLink.Selected := True;
//.. careful - this assumes StartY < StartX.
NewLink.X := BestLink.X;
NewLink.Y := BestLink.StartY;
NewLink.Length := BestLink.EndY - BestLink.StartY;
// record added item for Undo
Project.AddItemToUndo( NewLink );
// loop will continue and attempt to find the "next best link" from
// our Island to another Island
end;
end;
// *******************************************
// LinkStrips
// *******************************************
{
Given two strips, find the best possible link between the strips, and
return a TroLink record which describes that link.
This code fakes it - we do not find the best possible link - we find the
first valid link scanning from the left. To find best possible link we
would have to keep a "BestLinkX" record which stores the ratings of the
best link tried to date. This may not be worth the trouble - a "relax"
process might be better - relaxing looks over the board and moves links
sideways to get vertical alignment of links, thus freeing up long vertical
runs which could take links.
}
function TveRouter.LinkStrips( FromStrip, ToStrip : TroStrip ) : TroLink;
var
StartX, EndX : integer; // X range in common with both strips
LowY, HighY : integer;
Temp : integer;
i : integer;
begin
// find X coord range shared by both strips
StartX := Max( FromStrip.CheckerStrip.Start.X, ToStrip.CheckerStrip.Start.X );
EndX := Min( FromStrip.CheckerStrip.Finish.X, ToStrip.CheckerStrip.Finish.X );
// if no overlap
// .. NB, a one cell length strip has StartX = EndX
if StartX > EndX then begin
result.Valid := False;
exit;
end;
// grab Y coords of two strips
LowY := FromStrip.CheckerStrip.Start.Y;
HighY := ToStrip.CheckerStrip.Start.Y;
if LowY > HighY then begin
Temp := LowY;
LowY := HighY;
HighY := Temp;
end;
// look for a pair of free cells vertically aligned with no obstruction
// between these end points
for i := StartX to EndX do begin
if LinkPathExists( i, LowY, HighY ) then begin
result.Valid := True;
result.X := i;
result.StartY := LowY;
result.EndY := HighY;
exit;
end;
end;
// never went round the loop OR never found a match
result.Valid := False;
end;
// *******************************************
// JoinIslandsWithBreakShift
// *******************************************
{
Given a list of Islands, merge the Islands by connecting links between
strips belonging to different Islands. Each link is chosen to be that which
gives the shortest connection between an Island and a strip from another
Island.
Call this AFTER calling JoinIslands - this will add a few more links
in cases where strips do not have an overlap
Do not call if IslandCount <= 0 because Islands[0] will cause exception
}
procedure TveRouter.JoinIslandsWithBreakShift;
function GetBreakAt( x, y : integer ) : TveBoardItem;
var
Index : integer;
Item : TveBoardItem;
begin
// no break found yet
result := nil;
// a component body or pin means an obstruction
Index := 0;
while true do begin
// See if this cell contains part of a board item
// ..GetNextItemAt() is slow - we may need to make a map of cells
// ..occupied by component pins & bodies.
FProject.GetNextItemAt( Item, Index, x, y );
// no more items - finished checking
if Item = nil then begin
break;
end;
// anything other than a break is an obstruction - no path for link
if (Item.Outline is TveBreakOutline) then begin
result := Item;
break;
end;
end;
end;
var
FromIslandIndex : integer;
FromIsland : TroIsland;
ToIsland : TroIsland;
i,j,k : integer;
FromStrip, ToStrip : TroStrip;
TestedLink, BestLink : TroMoveBreakLink;
BestToIsland : TroIsland;
m : integer;
NewLink : TveBoardItem;
BreakItem : TveBoardItem;
// Strip : TdrStrip;
Strip : TcnStrip;
begin
// prevent "uninitialised variable" compiler warnings
BestToIsland := nil;
// start a process of many linking attempts
//.. start with first Island
FromIslandIndex := 0;
FromIsland := Islands[0];
while True do begin
// if reached bottom of Islands list, then can't join to any more
// Islands later in the list, so finished
if FromIslandIndex >= IslandCount - 1 then begin
break;
end;
// evaluate all possible links from our Island to all other strips
// outside our Island and belonging to Islands later than our Island in
// the Islands[] list.
BestLink.Valid := False;
for i := FromIslandIndex + 1 to IslandCount -1 do begin
ToIsland := Islands[i];
// from each strip in our Island
for j := 0 to FromIsland.StripCount -1 do begin
FromStrip := FromIsland.Strips[j];
// to each strip in that Island
for k := 0 to ToIsland.StripCount -1 do begin
ToStrip := ToIsland.Strips[k];
//.. LinkStrips called for the same 2 strips every
//.. time we evaluate links from the same island to other
//.. islands. We may want to optimise by caching the result
//.. of the initial call to LinkStrips and just look
//.. up the TroLink records which describes how the link
//.. rated.
TestedLink := LinkStripsWithShift( FromStrip, ToStrip );
if (CompareLinksWithShift( TestedLink, BestLink ) > 0) then begin
BestLink := TestedLink;
BestToIsland := ToIsland;
end;
end;
end;
end;
// if no link can be made from our Island to a strip from another
// Island further down the list, then we are finished with our Island.
// Move to the next Island down the list
if not BestLink.Valid then begin
Inc( FromIslandIndex);
FromIsland := Islands[FromIslandIndex];
continue;
end;
// 2 Islands are joined by the new link, so combine the later Island
// into in Our Island (FromIsland)
for m := 0 to BestToIsland.StripCount -1 do begin
FromIsland.AddStrip( BestToIsland.Strips[m] );
// BestToIsland.ClearStrips; .. not needed since strips are cleared
// when strips reused.
end;
RemoveIsland( BestToIsland );
// place the "best link"
NewLink := TveBoardItem.Create;
NewLink.Outline := FProject.LinkOutline;
NewLink.Selected := True;
FProject.AddItemToUndo( NewLink );
//.. careful - this assumes StartY < StartX.
NewLink.X := BestLink.X;
NewLink.Y := BestLink.StartY;
NewLink.Length := BestLink.EndY - BestLink.StartY;
// move first break
if BestLink.BreakLeftFromX <> BestLink.BreakLeftToX then begin
BreakItem := GetBreakAt( BestLink.BreakLeftFromX, BestLink.BreakLeftY );
if BreakItem <> nil then begin
BreakItem.TakeSnapshot;
BreakItem.X := BestLink.BreakLeftToX;
Project.ItemSnapshotToUndo( BreakItem );
end;
end;
// move second break
if BestLink.BreakRightFromX <> BestLink.BreakRightToX then begin
BreakItem := GetBreakAt( BestLink.BreakRightFromX, BestLink.BreakRightY );
if BreakItem <> nil then begin
BreakItem.TakeSnapshot;
BreakItem.X := BestLink.BreakRightToX;
Project.ItemSnapshotToUndo( BreakItem );
end;
end;
// shorten strip "nudged" by right hand strip moving leftward
Strip := FConnectivity.StripAt(
BestLink.BreakRightFromX - 1, BestLink.BreakRightY );
if Strip <> nil then begin
// end cell is to left of link
Strip.Finish.X := BestLink.X - 2;
end;
// shorten strip "nudged" by left hand strip moving rightward
Strip := FConnectivity.StripAt(
BestLink.BreakLeftFromX + 1, BestLink.BreakLeftY );
if Strip <> nil then begin
// end cell is to left of link
Strip.Start.X := BestLink.X + 2;
end;
// adjust the strips to terminate on the link cell
BestLink.RightStrip.CheckerStrip.Start.X := BestLink.X;
BestLink.LeftStrip.CheckerStrip.Finish.X := BestLink.X;
// record added item for Undo
FProject.AddItemToUndo( NewLink );
// loop will continue and attempt to find the "next best link" from
// our Island to another Island
end;
end;
// *******************************************
// LINK STRIPS USING BREAK-SHIFT
// *******************************************
// Call this after LinkStrips() - it can create links by shoving breaks aside.
// However, it might cause disarray if used on easy links - so we should run it
// after LinkStrips() has made the easy links.
function TveRouter.LinkStripsWithShift( FromStrip, ToStrip : TroStrip ) : TroMoveBreakLink;
// see if anything is obstructing this strip
function CellFree( x, y : integer ) : boolean;
var
index : integer;
Item : TveBoardItem;
begin
index := 0;
while True do begin
FProject.GetNextItemAt( Item, Index, x, y );
if Item = nil then begin
result := true;
exit;
end;
if not (Item.Outline is TveBreakOutline) then begin
result := false;
exit;
end;
end;
end;
const
MAX_OVERLAP = 3;
MAX_EXTEND = 2;
var
OverlapStartX: integer;
OverlapEndX : integer;
Overlap : integer;
LeftStrip : TroStrip;
RightStrip : TroStrip;
LeftStripNewEnd: integer;
RightStripNewEnd: integer;
x: integer;
ZoneLeft: integer;
ZoneRight: integer;
LowY: integer;
HighY: integer;
Temp: integer;
begin
{ ********************GG small gap GG
GG*****************
}
{ ******************** small overlap GG
GG
*****************
Note that CheckerStrip.XRight is coord of last cell in the strip, not
bounding coord.
}
// if strips are co-linear, we cannot link them!
if FromStrip.CheckerStrip.Start.Y = ToStrip.CheckerStrip.Start.Y then begin
result.Valid := False;
exit;
end;
// see if the extend left and extend right will cause additional overlap
// find X coord range shared by both strips
OverlapStartX := Max( FromStrip.CheckerStrip.Start.X, ToStrip.CheckerStrip.Start.X );
OverlapEndX := Min( FromStrip.CheckerStrip.Finish.X, ToStrip.CheckerStrip.Finish.X );
Overlap := OverlapEndX - OverlapStartX;
// We are interested in a small small overlap or small gap (negative overlap)
// We are just catching the cases a vertical row of breaks prevents a strips
// being joined by vertical links.
if Abs(Overlap) > MAX_OVERLAP then begin
result.Valid := False;
exit;
end;
// find which strip is left, which is right
if FromStrip.CheckerStrip.Start.X < ToStrip.CheckerStrip.Start.X then begin
LeftStrip := FromStrip;
RightStrip := ToStrip;
end
else begin
LeftStrip := ToStrip;
RightStrip := FromStrip;
end;
// extend left strip toward right
LeftStripNewEnd := Min(
LeftStrip.CheckerStrip.Finish.X + MAX_EXTEND, FProject.BoardWidth -1 );
//. See if cells are free for the extension
//. Next cell has a break, but may be overlaid with a component,
//. include it in check for free cells
//. At the end of extended strip we need to place a break
for x := LeftStrip.CheckerStrip.Finish.X + 1 to LeftStripNewEnd do begin
if not CellFree( x, LeftStrip.CheckerStrip.Start.Y ) then begin
LeftStripNewEnd := x -1;
break;
end;
end;
//. if we are not at board edge, we need an extra clear cell for a break
if LeftStripNewEnd < FProject.BoardWidth -1 then begin
if not CellFree( LeftStripNewEnd +1, LeftStrip.CheckerStrip.Start.Y ) then begin
dec(LeftStripNewEnd);
end;
end;
//.. (now LeftStripNewEnd equals possible end of extended left strip)
// extend right strip toward left
RightStripNewEnd := Max( RightStrip.CheckerStrip.Start.X - MAX_EXTEND, 0 );
//. see if cells are free for the extension
//. next cell has a break and so is available.
//. at the end of extended strip we need to place a break
for x := RightStrip.CheckerStrip.Start.X -1 downto RightStripNewEnd do begin
if not CellFree( x, RightStrip.CheckerStrip.Start.Y ) then begin
RightStripNewEnd := x +1;
break;
end;
end;
//. if we are not at board edge, we need an extra clear cell for a break
if RightStripNewEnd > 0 then begin
if not CellFree( RightStripNewEnd -1, RightStrip.CheckerStrip.Start.Y ) then begin
inc(RightStripNewEnd);
end;
end;
//.. (now RightStripNewEnd equals possible end of extended right strip)
// calculate overlap zone of two extended areas
ZoneLeft := Max( RightStripNewEnd, LeftStrip.CheckerStrip.Start.X );
ZoneRight := Min( LeftStripNewEnd, RightStrip.CheckerStrip.Finish.X );
// grab Y coords of two strips
LowY := FromStrip.CheckerStrip.Start.Y;
HighY := ToStrip.CheckerStrip.Start.Y;
if LowY > HighY then begin
Temp := LowY;
LowY := HighY;
HighY := Temp;
end;
// See if we can place any links between the strips, for x within zone
// Look for a pair of free cells vertically aligned with no obstruction
// between these end points
for x := ZoneLeft to ZoneRight do begin
if LinkPathExists( x, LowY, HighY ) then begin
result.X := x;
result.StartY := LowY;
result.EndY := HighY;
result.Valid := True;
// left strip
// first break Y
result.BreakLeftY := LeftStrip.CheckerStrip.Start.Y;
// first break original X
result.BreakLeftFromX := LeftStrip.CheckerStrip.Finish.X +1;
// first break new X
result.BreakLeftToX := x + 1;
// right strip
// second break Y
result.BreakRightY := RightStrip.CheckerStrip.Start.Y;
// second break original X
result.BreakRightFromX := RightStrip.CheckerStrip.Start.X -1;
// second break new X
result.BreakRightToX := x - 1;
// strips
result.RightStrip := RightStrip;
result.LeftStrip := LeftStrip;
exit;
end;
end;
// never went round the loop OR never found a match
result.Valid := False;
end;
// *******************************************
// List of Available Strips
// *******************************************
function TveRouter.GetFreeStrip( index : integer ) : TroFreeStrip;
begin
result := TroFreeStrip( FFreeStrips[index] );
end;
function TveRouter.GetFreeStripCount : integer;
begin
result := FFreeStrips.Count;
end;
function TveRouter.CreateFreeStrip : TroFreeStrip;
begin
result := TroFreeStrip.Create;
FFreeStrips.Add( result );
end;
procedure TveRouter.DeleteFreeStrip( FreeStrip : TroFreeStrip );
begin
FFreeStrips.Delete( FFreeStrips.IndexOf( FreeStrip ) );
end;
// *******************************************
// Make List of Available Strips
// *******************************************
{ Make a list of TFreeStrip records. Each record describes a strip which
is either unused, or can be cut free with a single break.
}
procedure TveRouter.LocateFreeStrips;
// Add a new free strip to the list.
// StartX = x of leftmost cell of the strip available for links.
// EndX = x of rightmost cell (not bounding cell) of the strip available
// for links.
// BreakX = x value where we need to place a break to free our strip for use
// BreakX = -1 means no break required
// Y is Y coord of strip.
procedure NewFreeStrip( StartX, EndX, Y : integer );
var
NewFreeStrip : TroFreeStrip;
begin
NewFreeStrip := CreateFreeStrip;
NewFreeStrip.XLeft := StartX;
NewFreeStrip.XRight := EndX;
NewFreeStrip.Y := Y;
end;
const
MINIMUM_STRIP_LENGTH = 8;
var
x, y : integer;
pCell : PcnCellData;
StripClear : boolean;
begin
// clear Free Strip list
FFreeStrips.Clear;
// scan every board row (strip) from left
for y := 0 to FProject.BoardHeight - 1 do begin
// scan copper strip from board left
StripClear := True;
for x := 0 to FProject.BoardWidth - 1 do begin
pCell := @FConnectivity.Cells[ x, y ];
// if found a pin: strip not free
if (pCell^.PinCount <> 0) then begin
StripClear := False;
break;
end;
// if found a break: end of strip
// down break is ignored on horizontal strip, but unshifted and
// right shifted breaks cut the strip
if (pCell^.Break * [brUnshifted, brShiftRight]) <> [] then begin
StripClear := False;
if x >= MINIMUM_STRIP_LENGTH then begin
NewFreeStrip( 0, x-1, y );
end
// strip too short to bother
else begin
break;
end;
end;
end;
// if we scanned across board width without meeting anything
// therefore strip is empty
if StripClear then begin
NewFreeStrip( 0, FProject.BoardWidth - 1, y );
end;
end;
// scan every board row (strip) from right
for y := 0 to Fproject.BoardHeight - 1 do begin
// scan copper strip from board right
for x := FProject.BoardWidth - 1 downto 0 do begin
pCell := @FConnectivity.Cells[ x, y ];
// if found a pin: strip not free
if (pCell^.PinCount <> 0) then begin
break;
end;
// if found a break: end of strip
if (pCell^.Break * [brUnshifted, brShiftRight]) <> [] then begin
if (FProject.BoardWidth - x -1 ) >= MINIMUM_STRIP_LENGTH then begin
NewFreeStrip( x+1, FProject.BoardWidth, y );
end
// strip too short to bother
else begin
break;
end;
end;
end;
end;
end;
// *********************************************
// TEST JOIN AN ISLAND STRIP TO A FREE STRIP
// *********************************************
{
Given a strips, find the best possible link between the strips, and
return a TroLink record which describes that link.
}
procedure TveRouter.IslandStripToFreeStrip(
Strip : TroStrip;
FreeStrip : TroFreeStrip;
var XSlots : TXSlots;
var Status : TroIslandToStrip );
var
StartX, EndX : integer; // X range in common with both strips
LowY, HighY : integer;
Temp : integer;
x : integer;
begin
//***<<< WARNING: is StartX, EndX same for links requiring a break?
// find X coord range shared by both strips
StartX := Max( Strip.CheckerStrip.Start.X, FreeStrip.XLeft );
EndX := Min( Strip.CheckerStrip.Finish.X, FreeStrip.XRight );
// if no overlap
// .. NB, a one cell length strip has StartX = EndX
if StartX > EndX then begin
Status.Valid := False;
exit;
end;
// grab Y coords of two strips
LowY := Strip.CheckerStrip.Start.Y;
HighY := FreeStrip.Y;
if LowY > HighY then begin
Temp := LowY;
LowY := HighY;
HighY := Temp;
end;
// look for a pair of free cells vertically aligned with no obstruction
// between these end points
for x := StartX to EndX do begin
// if another link to be placed at at x pos on joining strip
if XSlots[x] then begin
continue;
end;
if LinkPathExists( x, LowY, HighY ) then begin
// informtion to evaluate the link
Status.Valid := True;
Status.LinkLength := HighY - LowY;
// enough information to create the link
Status.IslandStripY := Strip.CheckerStrip.Start.Y;
Status.LinkX := x;
// reserve the link location
XSlots[x] := True;
exit;
end;
end;
// never went round the loop OR never found a match
Status.Valid := False;
end;
// *******************************************
// TEST JOIN AN ISLAND TO A FREE STRIP
// *******************************************
// Need to call this offering linksX[0..TveBoardMAXWIDTH-1] array showing
// showing x positions currently used by links (can't use same hole twice!).
procedure TveRouter.JoinIslandToStrip(
Island : TroIsland;
FreeStrip : TroFreeStrip;
var XSlots : TXSlots;
var Status : TroIslandToStrip );
var
i : integer;
Strip : TroStrip;
CurrentJoin : TroIslandToStrip;
begin
// start out with the worst possible join
Status.Valid := False;
Status.LinkLength := High(Status.LinkLength);
// for every strip in the island ("IslandStrip")
for i := 0 to Island.StripCount - 1 do begin
Strip := Island.Strips[ i ];
// test link the Strip to the IslandStrip
IslandStripToFreeStrip( Strip, FreeStrip, XSlots, CurrentJoin );
// if this join is better than the last
if CurrentJoin.Valid and
(CurrentJoin.LinkLength < Status.LinkLength) then begin
Status := CurrentJoin;
end;
end;
end;
// *******************************************
// JOIN ISLANDS USING A FREE STRIP
// *******************************************
{
To use, call LocateFreeStrips(), load class member Islands[] with Islands to
be joined, then call this function.
This function will allocate a free strip from FreeStrips[] and add links
to make the join. This function may not be able to join every island, but
will join at least two.
}
procedure TveRouter.JoinIslandsWithFreeStrips;
{***********
1. Pick a Joining Strip
2. Join every island to the strip
3. Track the best join: total link length, number of links,
(join strip length could also be used to evaluate?)
***********}
var
FreeStripIndex : integer;
IslandIndex: Integer;
Island : TroIsland;
LatestJoin : TroIslandToStrip;
CurrentStatus : StripToIslandStatus;
BestStatus : StripToIslandStatus;
Link : TveBoardItem;
i : integer;
Y1, Y2 : integer;
begin
// create a "dud" BestStatus to get started
BestStatus.LinksMade := 0;
// for every free strip (count down lets us delete FreeStrips[] members
// as we go.)
for FreeStripIndex := FreeStripCount - 1 downto 0 do begin
// start a status record
CurrentStatus.TotalLinkLength := 0;
CurrentStatus.LinksMade := 0;
CurrentStatus.FreeStrip := FreeStrips[FreeStripIndex];
FillChar( CurrentStatus.XSlots, sizeof(CurrentStatus.XSlots), 0 );
// attempt to link the free strip to every island
for IslandIndex := 0 to IslandCount - 1 do begin
// if our array can't hold any more links
if CurrentStatus.LinksMade > High(CurrentStatus.LinkStarts) then begin
break;
end;
Island := Islands[IslandIndex];
JoinIslandToStrip(
Island,
CurrentStatus.FreeStrip,
CurrentStatus.XSlots,
LatestJoin );
// include latest join attempt into status
if LatestJoin.Valid then begin
// remember where to place the link
CurrentStatus.LinkStarts[CurrentStatus.LinksMade] :=
Point( LatestJoin.LinkX, LatestJoin.IslandStripY);
// remember some statistics used to rate this join
inc( CurrentStatus.LinksMade );
inc( CurrentStatus.TotalLinkLength, LatestJoin.LinkLength );
end;
end;
// assess the results of the attempted joinings of current free
// strip to our islands
if( CurrentStatus.LinksMade > BestStatus.LinksMade ) or
(
(CurrentStatus.LinksMade = BestStatus.LinksMade) and
(CurrentStatus.TotalLinkLength < BestStatus.TotalLinkLength)
)
then begin
BestStatus := CurrentStatus;
end;
end;
// now implement the best join we found - but at least two links must be
// made or we have not joined any islands!
if BestStatus.LinksMade >= 2 then begin
// remove our FreeStrip from the list
DeleteFreeStrip( BestStatus.FreeStrip );
// place the links
for i := 0 to BestStatus.LinksMade - 1 do begin
Link := TveBoardItem.Create;
Link.Outline := FProject.LinkOutline;
Link.Selected := True;
Link.X := BestStatus.LinkStarts[i].X;
// link ref point at top
Y1 := BestStatus.FreeStrip.Y;
Y2 := BestStatus.LinkStarts[i].Y;
Link.Y := Min( Y1, Y2 );
Link.Length := Abs( Y1 - Y2 );
// record added item for Undo
Project.AddItemToUndo( Link );
end;
end;
end;
end.
|
unit ChooseDiscountCardForm_Unit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, kbmMemTable, Front_DataBase_Unit, DB, FrontData_Unit,
ExtCtrls, AdvPanel, AdvSmoothButton, BaseFrontForm_Unit;
type
TChooseDiscountCard = class(TBaseFrontForm)
pnlMain: TAdvPanel;
Label1: TLabel;
usrg_lblCardCode: TEdit;
Label2: TLabel;
usrg_lblCustomer: TLabel;
Label3: TLabel;
usrg_lblPersDiscount: TLabel;
Label4: TLabel;
usrg_lbBonusSum: TLabel;
Label5: TLabel;
usrg_lbBonusPay: TLabel;
btnChooseBonus: TAdvSmoothButton;
btnCancel: TAdvSmoothButton;
btnOK: TAdvSmoothButton;
btnDelete: TAdvSmoothButton;
Bevel1: TBevel;
btnFindCard: TAdvSmoothButton;
procedure btnChooseBonusClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure btnCancelClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure btnOKClick(Sender: TObject);
procedure usrg_lblCardCodeKeyPress(Sender: TObject; var Key: Char);
procedure btnFindCardClick(Sender: TObject);
private
FFrontBase: TFrontBase;
FHeaderTable: TkbmMemTable;
FDataTable: TkbmMemTable;
FCardid: Integer;
FDiskid: Integer;
FUserID: Integer;
{ Private declarations }
public
property FrontBase: TFrontBase read FFrontBase write FFrontBase;
property HeaderTable: TkbmMemTable read FHeaderTable write FHeaderTable;
property Cardid: Integer read FCardid write FCardid;
property UserID: Integer read FUserID write FUserID;
property Diskid: Integer read FDiskid write FDiskid;
end;
const
cn_dontManagerPermission = 'Данный пользователь не обладает правами менеджера!';
var
ChooseDiscountCard: TChooseDiscountCard;
implementation
uses
DevideForm_Unit, TouchMessageBoxForm_Unit, rfUtils_unit, rfDiscountListForm_Unit;
{$R *.dfm}
procedure TChooseDiscountCard.btnChooseBonusClick(Sender: TObject);
var
Form: TDevideForm;
Sum1, Sum2: Currency;
begin
Form := TDevideForm.Create(nil);
try
Form.LabelCaption := 'Сумма';
if usrg_lbBonusSum.Caption <> '' then
Form.Number := usrg_lbBonusSum.Caption
else
Form.Number := '0';
Form.ShowModal;
if Form.ModalResult = 1 then
begin
Sum1 := StrToCurr(Form.Number);
if usrg_lbBonusSum.Caption <> '' then
Sum2 := StrToCurr(usrg_lbBonusSum.Caption)
else
Sum2 := 0;
if Sum1 > Sum2 then
Sum1 := Sum2;
usrg_lbBonusPay.Caption := CurrToStr(Sum1);
end;
finally
Form.Free;
end;
end;
procedure TChooseDiscountCard.btnDeleteClick(Sender: TObject);
begin
if Touch_MessageBox('Внимание', 'Удалить скидку?', MB_YESNO, mtConfirmation) = IDYES then
begin
if FHeaderTable.State = dsBrowse then
FHeaderTable.Edit;
FHeaderTable.FieldByName('USR$DISCCARDKEY').Clear;
FHeaderTable.Post;
FCardid := 0;
usrg_lblCustomer.Caption := '';
usrg_lblPersDiscount.Caption := '';
usrg_lblCardCode.Text := '';
usrg_lbBonusSum.Caption := '';
usrg_lbBonusPay.Caption := '';
end;
end;
procedure TChooseDiscountCard.btnFindCardClick(Sender: TObject);
var
FUserInfo: TUserInfo;
FForm: TDiscountList;
FCardCode: String;
begin
FUserInfo := FFrontBase.CheckUserPasswordWithForm;
if FUserInfo.CheckedUserPassword then
begin
if (FUserInfo.UserInGroup and FFrontBase.Options.ManagerGroupMask) = 0 then
begin
Touch_MessageBox('Внимание', cn_dontManagerPermission, MB_OK, mtWarning);
exit;
end;
FForm := TDiscountList.Create(nil);
try
FForm.FrontBase := FFrontBase;
FForm.ShowModal;
if FForm.ModalResult = mrOk then
begin
FCardCode := FForm.CardCode;
if FCardCode <> '' then
begin
usrg_lblCardCode.Text := FCardCode;
PostMessage(usrg_lblCardCode.Handle, WM_KEYUP, Ord(#13), 0);
end;
end;
finally
FForm.Free;
end;
end;
end;
procedure TChooseDiscountCard.FormShow(Sender: TObject);
begin
Assert(Assigned(FFrontBase), 'FrontBase not assigned');
Assert(Assigned(FHeaderTable), 'HeaderTable not assigned');
if Cardid > 0 then
if FFrontBase.GetDiscountCardInfo(FDataTable, Cardid, FFrontBase.GetLogicDate, '') then
begin
FDataTable.First;
if not FDataTable.Eof then
begin
usrg_lblCustomer.Caption := FDataTable.FieldByName('contactname').AsString;
usrg_lblPersDiscount.Caption := FDataTable.FieldByName('Discountname').AsString + ', ' +
FDataTable.FieldByName('DiscPers').AsString + '%';
if FDataTable.FieldByName('usr$bonus').AsInteger = 1 then
begin
usrg_lbBonusSum.Caption := FDataTable.FieldByName('USR$BALANCE').AsString;
btnChooseBonus.Enabled := True;
end else
usrg_lbBonusSum.Caption := '';
end;
end;
end;
procedure TChooseDiscountCard.btnCancelClick(Sender: TObject);
begin
ModalResult := mrCancel;
FCardid := 0;
end;
procedure TChooseDiscountCard.FormCreate(Sender: TObject);
begin
btnChooseBonus.Enabled := False;
FDataTable := TkbmMemTable.Create(Self);
FDataTable.FieldDefs.Add('ID', ftInteger, 0);
FDataTable.FieldDefs.Add('contactname', ftString, 120);
FDataTable.FieldDefs.Add('Discountname', ftString, 40);
FDataTable.FieldDefs.Add('DiscPers', ftCurrency, 0);
FDataTable.FieldDefs.Add('usr$bonus', ftCurrency, 0);
FDataTable.FieldDefs.Add('USR$BALANCE', ftCurrency, 0);
FDataTable.FieldDefs.Add('DiscKey', ftInteger, 0);
FDataTable.CreateTable;
FDataTable.Open;
btnOK.Picture := FrontData.RestPictureContainer.FindPicture('tick');
btnCancel.Picture := FrontData.RestPictureContainer.FindPicture('cross');
btnDelete.Picture := FrontData.RestPictureContainer.FindPicture('cancel');
btnFindCard.Picture := FrontData.RestPictureContainer.FindPicture('group_edit');
end;
procedure TChooseDiscountCard.usrg_lblCardCodeKeyPress(Sender: TObject;
var Key: Char);
begin
RemoveWrongPassChar(Key);
if (Key = #13) then
begin
if FFrontBase.GetDiscountCardInfo(FDataTable, 0, FFrontBase.GetLogicDate, usrg_lblCardCode.Text) then
begin
FDataTable.First;
if not FDataTable.Eof then
begin
FCardid := FDataTable.FieldByName('ID').AsInteger;
FDiskid := FDataTable.FieldByName('DiscKey').AsInteger;
usrg_lblCustomer.Caption := FDataTable.FieldByName('contactname').AsString;
usrg_lblPersDiscount.Caption := FDataTable.FieldByName('Discountname').AsString + ', ' +
FDataTable.FieldByName('DiscPers').AsString + '%';
if FDataTable.FieldByName('usr$bonus').AsInteger = 1 then
begin
usrg_lbBonusSum.Caption := FDataTable.FieldByName('USR$BALANCE').AsString;
btnChooseBonus.Enabled := True;
end else
usrg_lbBonusSum.Caption := '';
end;
end else
begin
usrg_lblCardCode.Text := '';
FCardid := 0;
end;
end;
end;
procedure TChooseDiscountCard.btnOKClick(Sender: TObject);
begin
ModalResult := mrOK;
end;
end.
|
unit MainForm;
{$mode objfpc}{$H+}
interface
uses
{$IFDEF WINDOWS}
{$IFDEF DIRECTX_ENABLED}
ACS_DXAudio, //DirectSound Driver
{$ENDIF}
{$ELSE}
acs_alsaaudio, //Alsa Driver
ACS_AOLive, //AO Live Driver
{$ENDIF}
acs_stdaudio, //Wavemapper Driver
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
ComCtrls, EditBtn, acs_file, acs_audio, acs_allformats, acs_classes,
TypInfo;
type
{ TFormMain }
TFormMain = class(TForm)
AcsAudioIn1: TAcsAudioIn;
AcsAudioOut1: TAcsAudioOut;
AcsFileIn1: TAcsFileIn;
AcsFileOut1: TAcsFileOut;
btnStart: TButton;
btnStop: TButton;
FileNameEditOut: TFileNameEdit;
FileNameEditInput: TFileNameEdit;
gbInput: TGroupBox;
gbOutput: TGroupBox;
gbProgress: TGroupBox;
lbOutPosition: TLabel;
ListBoxAudioInDrivers: TListBox;
ListBoxAudioInDevices: TListBox;
ListBoxAudioOutDevices: TListBox;
ListBoxFileOutDrivers: TListBox;
ListBoxAudioOutDrivers: TListBox;
ListBoxFileInDrivers: TListBox;
MemoAudioOutInfo: TMemo;
MemoInputFileInfo: TMemo;
MemoAudioInInfo: TMemo;
pgcOutputTypes: TPageControl;
pgcInputTypes: TPageControl;
ProgressBar1: TProgressBar;
tsInputFile: TTabSheet;
tsOutFile: TTabSheet;
tsOutAudioDevice: TTabSheet;
tsInputAudioDevice: TTabSheet;
procedure btnStartClick(Sender: TObject);
procedure btnStopClick(Sender: TObject);
procedure FileNameEditInputAcceptFileName(Sender: TObject; var Value: String
);
procedure FileNameEditOutAcceptFileName(Sender: TObject; var Value: String);
procedure FileNameEditOutEditingDone(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure ListBoxAudioInDriversSelectionChange(Sender: TObject;
User: boolean);
procedure ListBoxAudioOutDriversSelectionChange(Sender: TObject;
User: boolean);
procedure ListBoxFileOutDriversSelectionChange(Sender: TObject;
User: boolean);
private
{ private declarations }
procedure OnProgressHandler(Sender: TComponent);
public
{ public declarations }
AcsOut: TAcsCustomOutput;
AcsIn: TAcsCustomInput;
procedure PrepareAudioChain();
procedure Start();
procedure Stop();
end;
var
FormMain: TFormMain;
implementation
{$R *.lfm}
function SecondsToStr(AValue: Real): string;
begin
Result:=Format('%.2d:%.2d:%.2d', [Round((AValue-30) / 60) mod 120, Round(AValue) mod 60, Round(AValue*100) mod 100]);
end;
procedure AcsInToStrings(AAcsIn: TAcsCustomInput; AStrings: TStrings);
begin
if not Assigned(AAcsIn) then Exit;
if not Assigned(AStrings) then Exit;
AStrings.Append('Sample rate: '+IntToStr(AAcsIn.SampleRate));
AStrings.Append('Bits per sample: '+IntToStr(AAcsIn.BitsPerSample));
AStrings.Append('Channels: '+IntToStr(AAcsIn.Channels));
AStrings.Append('Buffer size: '+IntToStr(AAcsIn.BufferSize));
//AStrings.Append('Size, bytes: '+IntToStr(AAcsIn.Size));
//AStrings.Append('Total samples: '+IntToStr(AAcsIn.TotalSamples));
//AStrings.Append('Total time: '+SecondsToStr(AAcsIn.TotalTime));
end;
function TypeKindToStr(AValue: TTypeKind): string;
begin
Result:='';
case AValue of
tkUnknown: Result:='tkUnknown';
tkInteger: Result:='tkInteger';
tkChar: Result:='tkChar';
tkEnumeration: Result:='tkEnumeration';
tkFloat: Result:='tkFloat';
tkSet: Result:='tkSet';
tkMethod: Result:='tkMethod';
tkSString: Result:='tkSString';
tkLString: Result:='tkLString';
tkAString: Result:='tkAString';
tkWString: Result:='tkWString';
tkVariant: Result:='tkVariant';
tkArray: Result:='tkArray';
tkRecord: Result:='tkRecord';
tkInterface: Result:='tkInterface';
tkClass: Result:='tkClass';
tkObject: Result:='tkObject';
tkWChar: Result:='tkWChar';
tkBool: Result:='tkBool';
tkInt64: Result:='tkInt64';
tkQWord: Result:='tkQWord';
tkDynArray: Result:='tkDynArray';
tkInterfaceRaw: Result:='tkInterfaceRaw';
tkProcVar: Result:='tkProcVar';
tkUString: Result:='tkUString';
tkUChar: Result:='tkUChar';
tkHelper: Result:='tkHelper';
end;
end;
procedure AcsOutToStrings(AAcsOut: TAcsCustomOutput; AStrings: TStrings);
var
i: Integer;
PropList: PPropList;
TypeData: PTypeData;
PropName, PropTypeName, PropValue: string;
begin
if not Assigned(AAcsOut) then Exit;
if not Assigned(AStrings) then Exit;
TypeData:=GetTypeData(AAcsOut.ClassInfo);
GetMem(PropList, TypeData^.PropCount * SizeOf(Pointer));
//GetPropList(AAcsOut, PropList);
try
GetPropInfos(AAcsOut.ClassInfo, PropList);
for i:=0 to TypeData^.PropCount-1 do
begin
PropName:=PropList^[i]^.Name;
PropTypeName:=TypeKindToStr(PropType(AAcsOut, PropName));
//PropTypeName:=PropList^[i]^.PropType^.Name;
PropValue:='';
case PropList^[i]^.PropType^.Kind of
tkInteger: PropValue:=IntToStr(GetInt64Prop(AAcsOut, PropName));
tkFloat: PropValue:=FloatToStr(GetFloatProp(AAcsOut, PropName));
tkSString..tkWString: PropValue:=GetStrProp(AAcsOut, PropName);
tkVariant: PropValue:=GetPropValue(AAcsOut, PropName, True);
tkEnumeration: PropValue:=GetEnumProp(AAcsOut, PropName);
end;
AStrings.Append(IntToStr(i)+': '+PropName+' ('+PropTypeName+') = '+PropValue);
end;
finally
FreeMem(PropList);
end;
//for i:=0 to AAcsOut.
//AStrings.Append('Sample rate: '+IntToStr(AAcsOut.SampleRate));
//AStrings.Append('Bits per sample: '+IntToStr(AAcsOut.BitsPerSample));
//AStrings.Append('Channels: '+IntToStr(AAcsOut.Channels));
//AStrings.Append('Buffer size: '+IntToStr(AAcsOut.BufferSize));
//AStrings.Append('Size, bytes: '+IntToStr(AAcsOut.Size));
//AStrings.Append('Total samples: '+IntToStr(AAcsOut.TotalSamples));
//AStrings.Append('Total time: '+SecondsToStr(AAcsOut.TotalTime));
end;
{ TFormMain }
procedure TFormMain.FileNameEditInputAcceptFileName(Sender: TObject;
var Value: String);
begin
AcsFileIn1.FileName:=Value;
MemoInputFileInfo.Clear();
if AcsFileIn1.Valid then
begin
AcsInToStrings(AcsFileIn1, MemoInputFileInfo.Lines);
MemoInputFileInfo.Append('Size, bytes: '+IntToStr(AcsFileIn1.Size));
MemoInputFileInfo.Append('Total samples: '+IntToStr(AcsFileIn1.TotalSamples));
MemoInputFileInfo.Append('Total time: '+SecondsToStr(AcsFileIn1.TotalTime));
end
else
begin
MemoInputFileInfo.Append('Invalid file format');
end;
end;
procedure TFormMain.FileNameEditOutAcceptFileName(Sender: TObject;
var Value: String);
begin
AcsFileOut1.FileName:=Value;
end;
procedure TFormMain.FileNameEditOutEditingDone(Sender: TObject);
begin
AcsFileOut1.FileName:=FileNameEditOut.FileName;
end;
procedure TFormMain.btnStartClick(Sender: TObject);
begin
Start();
end;
procedure TFormMain.btnStopClick(Sender: TObject);
begin
Stop();
end;
procedure TFormMain.FormCreate(Sender: TObject);
begin
// fill audio in drivers
AcsAudioIn1.GetDriversList(ListBoxAudioInDrivers.Items);
// fill file in drivers
AcsFileIn1.GetDriversList(ListBoxFileInDrivers.Items);
// fill file out drivers
AcsFileOut1.GetDriversList(ListBoxFileOutDrivers.Items);
// fill audio out drivers
AcsAudioOut1.GetDriversList(ListBoxAudioOutDrivers.Items);
btnStop.Enabled:=False;
end;
procedure TFormMain.ListBoxAudioInDriversSelectionChange(Sender: TObject;
User: boolean);
var
i, n: Integer;
begin
if not User then Exit;
for i:=0 to ListBoxAudioInDrivers.Count-1 do
begin
if ListBoxAudioInDrivers.Selected[i] then
begin
AcsAudioIn1.DriverName:=AcsAudioIn1.Drivers[i];
// fill devices list
ListBoxAudioInDevices.Clear();
for n:=0 to AcsAudioIn1.DeviceCount-1 do
begin
ListBoxAudioInDevices.AddItem(AcsAudioIn1.DeviceInfo[n].DeviceName, nil);
if AcsAudioIn1.Device = n then ListBoxAudioInDevices.Selected[n]:=True;
end;
// show info
MemoAudioInInfo.Clear();
AcsInToStrings(AcsAudioIn1, MemoAudioInInfo.Lines);
Exit;
end;
end;
end;
procedure TFormMain.ListBoxAudioOutDriversSelectionChange(Sender: TObject;
User: boolean);
var
i, n: Integer;
begin
if not User then Exit;
for i:=0 to ListBoxAudioOutDrivers.Count-1 do
begin
if ListBoxAudioOutDrivers.Selected[i] then
begin
AcsAudioOut1.DriverName:=AcsAudioOut1.Drivers[i];
// fill devices list
ListBoxAudioOutDevices.Clear();
for n:=0 to AcsAudioOut1.DeviceCount-1 do
begin
ListBoxAudioOutDevices.AddItem(AcsAudioOut1.DeviceInfo[n].DeviceName, nil);
if AcsAudioOut1.Device = n then ListBoxAudioOutDevices.Selected[n]:=True;
end;
// show driver properties
MemoAudioOutInfo.Lines.Clear();
AcsOutToStrings(AcsAudioOut1.Driver, MemoAudioOutInfo.Lines);
Exit;
end;
end;
end;
procedure TFormMain.ListBoxFileOutDriversSelectionChange(Sender: TObject;
User: boolean);
var
i: integer;
SelectedExt: string;
begin
if not User then Exit;
for i:=0 to ListBoxFileOutDrivers.Count-1 do
begin
if ListBoxFileOutDrivers.Selected[i] then
begin
//ListBoxFileOutDrivers.Items.Objects[i];
end;
end;
//SelectedExt:=
end;
procedure TFormMain.OnProgressHandler(Sender: TComponent);
begin
ProgressBar1.Position:=Round(AcsFileIn1.Progress);
lbOutPosition.Caption:=SecondsToStr(AcsOut.TimeElapsed);
end;
procedure TFormMain.PrepareAudioChain();
begin
AcsIn:=AcsAudioIn1;
if pgcInputTypes.ActivePage = tsInputFile then AcsIn:=AcsFileIn1;
if pgcOutputTypes.ActivePage = tsOutAudioDevice then
begin
AcsOut:=AcsAudioOut1;
end
else if pgcOutputTypes.ActivePage = tsOutFile then
begin
AcsOut:=AcsFileOut1;
end;
AcsOut.Input:=AcsIn;
AcsOut.OnProgress:=@OnProgressHandler;
end;
procedure TFormMain.Start();
begin
PrepareAudioChain();
AcsOut.Run();
btnStart.Enabled:=not AcsOut.Active;
btnStop.Enabled:=AcsOut.Active;
end;
procedure TFormMain.Stop();
begin
if not Assigned(AcsOut) then Exit;
AcsOut.Stop();
btnStart.Enabled:=not AcsOut.Active;
btnStop.Enabled:=AcsOut.Active;
end;
end.
|
unit TestuControllerAbastecimento;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, uAbastecimentoDao, uControllerAbastecimento, uLib, uGlobal,
ClasseAbastecimento, uEmpresaDao, math;
type
// Test methods for class TControllerAbastecimento
TestTControllerAbastecimento = class(TTestCase)
strict private
FControllerAbastecimento: TControllerAbastecimento;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure Testgravar;
end;
implementation
uses
System.SysUtils, udm , ClasseEmpresa;
procedure TestTControllerAbastecimento.SetUp;
var
objDao : TEmpresaDao;
begin
FControllerAbastecimento := TControllerAbastecimento.Create;
dm := Tdm.Create(nil);
objEmpresa := TEmpresa.create;
objEmpresa.idEmpresa := 1;
objDao := TEmpresaDao.Create;
objDao.getById(objEmpresa);
end;
procedure TestTControllerAbastecimento.TearDown;
begin
FControllerAbastecimento.Free;
FControllerAbastecimento := nil;
end;
procedure TestTControllerAbastecimento.Testgravar;
var
ReturnValue: Boolean;
valorImposto : double;
objAbastecimento: TAbastecimento;
begin
// TODO: Setup method call parameters
objAbastecimento := TAbastecimento.create;
objAbastecimento.idAbastecimento := 0;
objAbastecimento.data := date;
objAbastecimento.idBomba.id_bomba := 1;
objAbastecimento.idBomba.idTanque.tipoCombustivel.id_tipo := 1;
objAbastecimento.preco := 3.99;
objAbastecimento.qtd := 10.71;
objAbastecimento.valor := objAbastecimento.preco * objAbastecimento.qtd;
ReturnValue := FControllerAbastecimento.gravar(objAbastecimento);
valorImposto := objAbastecimento.impostoValor;
// TODO: Validate method results
checkEquals(true, returnValue);
checkEquals(roundto(valorImposto,-4),5.5553 );
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTControllerAbastecimento.Suite);
end.
|
unit TipoProduto;
interface
uses StrUtils, SysUtils;
type
TTipoProduto = (tpProduto = 1, tpMateria = 2, tpComposto=3, tpServico=4);
type
TTipoProdutoUtilitario = class
public
class function DeStringParaEnumerado(TipoProduto :String) :TTipoProduto;
class function DeEnumeradoParaString(TipoProduto :TTipoProduto) :String;
end;
implementation
{ TTipoProdutoUtilitario }
class function TTipoProdutoUtilitario.DeEnumeradoParaString(TipoProduto: TTipoProduto): String;
begin
case TipoProduto of
tpProduto: result := 'P';
tpMateria: result := 'M';
tpComposto: result := 'C';
tpServico: result := 'S';
end;
end;
class function TTipoProdutoUtilitario.DeStringParaEnumerado(TipoProduto: String): TTipoProduto;
begin
case AnsiIndexStr(UpperCase(TipoProduto), ['P', 'M', 'C', 'S']) of
0 : result := TTipoProduto(1);
1 : result := TTipoProduto(2);
2 : result := TTipoProduto(3);
3 : result := TTipoProduto(4);
else
raise Exception.Create('Tipo de produto inválido: "'+TipoProduto+'"');
end;
end;
end.
|
const
tabf:array[0..7] of string[4]=('TEST','0','NOT','NEG','MUL','IMUL','DIV','IDIV');
tabn:array[0..7] of string[6]=('"test"','0','"not"','"neg"','"mul"','"imul"','"div"','"idiv"');
function tohex(a:byte):string;
const
xltab:array[0..15] of char = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
var
s:string[2];
begin
s[0]:=#2;
if a<16 then begin s[1]:='0'; s[2]:=xltab[a and 15]; end
else
begin
s[1]:=xltab[a shr 4];
s[2]:=xltab[a and 15];
end;
tohex:=s;
end;
function rm2p(rm:byte):longint;
var
t1,p1:longint;
begin
p1:=rm and 7;
if rm<$40 then t1:=16
else
if rm<$80 then t1:=17
else
if rm<$C0 then t1:=18
else
t1:=0;
rm2p:=t1+p1 shl 8;
end;
var
i:byte;
begin
for i:=0 to 255 do
begin
if ((i shr 3) and 7)=0 then
writeln(' /*',i,'(0x',tohex(i),')*/ {',tabn[(i shr 3) and 7],',F_IMM,',rm2p(i),',',tabf[(i shr 3) and 7],',0},')
else
writeln(' /*',i,'(0x',tohex(i),')*/ {',tabn[(i shr 3) and 7],',0,',rm2p(i),',',tabf[(i shr 3) and 7],',0},');
end;
end. |
{*******************************************************}
{ }
{ Delphi FireMonkey Platform }
{ Copyright(c) 2013 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
unit FMX.BehaviorManager;
interface
uses
System.Generics.Collections, FMX.Types;
type
IStyleBehavior = interface
['{665EC261-3E3C-41F1-9964-ADCB39B47662}']
procedure GetSystemStyle(const Context: TFmxObject; var Style: TFmxObject);
end;
IDeviceNameBehavior = interface
['{820055FF-2005-4160-8751-6BCD492C117E}']
procedure GetDeviceName(const Context: TFmxObject; var DeviceName: string);
end;
IOSVersionForStyleBehavior = interface
['{F55F7580-3E67-4916-8D16-A33AFC171888}']
procedure GetMajorOSVersion(const Context: TFMXObject; var OSVersion: Integer);
end;
IFontBehavior = interface
['{25D83842-FF28-4748-90C0-7E8610141190}']
procedure GetDefaultFontFamily(const Context: TFmxObject; var FontFamily: string);
end;
IListener = interface
['{9D325387-E1F1-4B3F-A9FB-BAFF9CE03B8C}']
procedure GetBehaviorService(const AServiceGUID: TGUID;
var AService: IInterface; const Context: TFmxObject);
procedure SupportsBehaviorService(const AServiceGUID: TGUID;
const Context: TFmxObject; var Found: Boolean); overload;
procedure SupportsBehaviorService(const AServiceGUID: TGUID;
var AService: IInterface; const Context: TFmxObject; var Found: Boolean); overload;
end;
TBehaviorServices = class
private
FServicesList: TDictionary<TGUID, IInterface>;
FListenerList: TList<IListener>;
public
constructor Create;
destructor Destroy; override;
procedure AddBehaviorListener(const Listener: IListener);
procedure AddBehaviorService(const AServiceGUID: TGUID; const AService: IInterface);
function GetBehaviorService(const AServiceGUID: TGUID;
const Context: TFmxObject): IInterface;
procedure RemoveBehaviorListener(const Listener: IListener);
procedure RemoveBehaviorService(const AServiceGUID: TGUID);
function SupportsBehaviorService(const AServiceGUID: TGUID;
const Context: TFmxObject): Boolean; overload;
function SupportsBehaviorService(const AServiceGUID: TGUID;
out AService: IInterface; const Context: TFmxObject): Boolean; overload;
end;
var
BehaviorServices: TBehaviorServices = nil;
implementation
uses
System.SysUtils;
{ TBehaviorServices }
procedure TBehaviorServices.AddBehaviorListener(const Listener: IListener);
begin
FListenerList.Add(Listener);
end;
procedure TBehaviorServices.AddBehaviorService(const AServiceGUID: TGUID;
const AService: IInterface);
begin
if not FServicesList.ContainsKey(AServiceGUID) then
FServicesList.Add(AServiceGUID, AService);
end;
constructor TBehaviorServices.Create;
begin
inherited;
FServicesList := TDictionary<TGUID, IInterface>.Create;
FListenerList := TList<IListener>.Create;
end;
destructor TBehaviorServices.Destroy;
begin
FServicesList.Free;
FListenerList.Free;
inherited;
end;
function TBehaviorServices.GetBehaviorService(
const AServiceGUID: TGUID; const Context: TFmxObject): IInterface;
var
Listener: IListener;
begin
Supports(FServicesList.Items[AServiceGUID], AServiceGUID, Result);
for Listener in FListenerList do
Listener.GetBehaviorService(AServiceGUID, Result, Context);
end;
procedure TBehaviorServices.RemoveBehaviorListener(const Listener: IListener);
begin
FListenerList.Remove(Listener);
end;
procedure TBehaviorServices.RemoveBehaviorService(const AServiceGUID: TGUID);
begin
FServicesList.Remove(AServiceGUID);
end;
function TBehaviorServices.SupportsBehaviorService(const AServiceGUID: TGUID;
out AService: IInterface; const Context: TFmxObject): Boolean;
var
Listener: IListener;
begin
if FServicesList.ContainsKey(AServiceGUID) then
Result := Supports(FServicesList.Items[AServiceGUID], AServiceGUID, AService)
else
begin
AService := nil;
Result := False;
end;
for Listener in FListenerList do
Listener.SupportsBehaviorService(AServiceGUID, AService, Context, Result);
end;
function TBehaviorServices.SupportsBehaviorService(
const AServiceGUID: TGUID; const Context: TFmxObject): Boolean;
var
Listener: IListener;
begin
Result := FServicesList.ContainsKey(AServiceGUID);
for Listener in FListenerList do
Listener.SupportsBehaviorService(AServiceGUID, Context, Result);
end;
initialization
BehaviorServices := TBehaviorServices.Create;
finalization
BehaviorServices.Free;
end.
|
unit PedidoM;
interface
uses PedidoIntf, Pedido, Generics.Collections;
type
TPedidoM = class(TInterfacedObject, IPedido)
private
FPedido: TPedido;
FPedidos: TList<TPedido>;
function GetIndex(Id: Integer): Integer;
protected
function GetPedido: TPedido;
procedure SetPedido(Value: TPedido);
public
constructor Create;
function Add: Integer;
function Get: TPedido;
function ListAll: TList<TPedido>;
property Pedido: TPedido read GetPedido write SetPedido;
end;
implementation
{ TPedidoM }
function TPedidoM.Add: Integer;
begin
Pedido.Id := FPedidos.Count + 1;
FPedidos.Add(Pedido);
Result := Pedido.Id;
end;
constructor TPedidoM.Create;
begin
FPedido := TPedido.Create;
FPedidos := TList<TPedido>.Create;
end;
function TPedidoM.Get: TPedido;
var
Index: Integer;
begin
Index := GetIndex(Pedido.Id);
if (Index > -1) then
Result := FPedidos.Items[Index]
else Result := Nil;
end;
function TPedidoM.GetIndex(Id: Integer): Integer;
var
I, Index: Integer;
begin
Index := -1;
for I := 0 to FPedidos.Count - 1 do
if (TPedido(FPedidos.Items[I]).id = Id) then
begin
Index := I;
Break;
end;
Result := Index;
end;
function TPedidoM.GetPedido: TPedido;
begin
Result := FPedido;
end;
function TPedidoM.ListAll: TList<TPedido>;
begin
Result := FPedidos;
end;
procedure TPedidoM.SetPedido(Value: TPedido);
begin
FPedido := Value;
end;
end.
|
unit GraphicsVolume;
interface
uses
System.SysUtils, System.Classes, Vcl.Controls, Winapi.Windows,
Winapi.GDIPAPI, Winapi.GDIPOBJ;
const
GV_WIDTH = 16;
GV_HEIGHT = 32;
type
TGraphicsVolume = class(TCustomControl)
private
{ Private declarations }
FBitmap: TGPBitmap;
FBuffer: Array [0 .. GV_WIDTH * GV_HEIGHT] of Integer;
procedure DrawVolumeBar(Value: Integer);
protected
{ Protected declarations }
procedure Paint; override;
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure SetVolume(Value: Integer);
published
{ Published declarations }
property Visible;
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Samples', [TGraphicsVolume]);
end;
const
GRAY_COLOR: DWORD = $FFC0DCE2;
LO_COLOR: DWORD = $FF16C900;
HI_COLOR: DWORD = $FFFF0000;
var
BarColors : array [0 .. 9] of DWORD;
BarColorInit: Boolean;
procedure InitBarColors();
var
r, g, b : DWORD;
r1, g1, b1: DWORD;
r2, g2, b2: DWORD;
i : DWORD;
begin
if BarColorInit then Exit;
BarColorInit := TRUE;
r1 := (LO_COLOR shr 16) and $FF;
g1 := (LO_COLOR shr 8) and $FF;
b1 := (LO_COLOR shr 0) and $FF;
r2 := (HI_COLOR shr 16) and $FF;
g2 := (HI_COLOR shr 8) and $FF;
b2 := (HI_COLOR shr 0) and $FF;
for i := 0 to 9 do
begin
r := (r1 * (9 - i) + r2 * i) div 9;
g := (g1 * (9 - i) + g2 * i) div 9;
b := (b1 * (9 - i) + b2 * i) div 9;
BarColors[i] := $FF000000 + (r shl 16) + (g shl 8) + (b);
end;
end;
constructor TGraphicsVolume.Create(AOwner: TComponent);
var
i: Integer;
begin
inherited Create(AOwner);
InitBarColors();
Width := GV_WIDTH;
Height := GV_HEIGHT;
FBitmap := TGPBitmap.Create(GV_WIDTH, GV_HEIGHT, GV_WIDTH * 4, PixelFormat32bppRGB, @FBuffer[0]);
for i := 0 to GV_WIDTH * GV_HEIGHT - 1 do
begin
FBuffer[i] := -1;
end;
DrawVolumeBar(0);
end;
destructor TGraphicsVolume.Destroy;
begin
FBitmap.Free();
inherited Destroy;
end;
procedure TGraphicsVolume.Paint();
var
Graphics: TGPGraphics;
begin
Graphics := TGPGraphics.Create(Self.Canvas.Handle);
Graphics.DrawImage(FBitmap, 0, 0);
Graphics.Free();
end;
procedure TGraphicsVolume.DrawVolumeBar(Value: Integer);
var
i, j: Integer;
c : Integer;
p : Integer;
begin
Value := (Value + 9) div 10;
for i := 0 to 9 do
begin
if Value > i then
begin
c := BarColors[i];
end else begin
c := GRAY_COLOR;
end;
p := ((9 - i) * 3 + 1) * GV_WIDTH;
for j := 0 to GV_WIDTH * 2 - 1 do
begin
FBuffer[p + j] := c;
end;
end;
end;
procedure TGraphicsVolume.SetVolume(Value: Integer);
begin
DrawVolumeBar(Value);
Self.Paint();
end;
end.
|
unit uDrone;
interface
type
TDrone = class
private
FName: string;
FWeight: Double;
procedure SetName(const Value: string);
procedure SetWeight(const Value: Double);
public
property Name: string read FName write SetName;
property MaximumWeight: Double read FWeight write SetWeight;
end;
implementation
{ TDrone }
procedure TDrone.SetName(const Value: string);
begin
FName := Value;
end;
procedure TDrone.SetWeight(const Value: Double);
begin
FWeight := Value;
end;
end.
|
unit DUTemplater;
interface
uses SysUtils, Classes;
type
TTemplater = class
FTemplate, FResults:string;
public
procedure LoadTemplate(FileName:string);
procedure Restart;
procedure PutSymbol(Sym,Value:string);
procedure SaveResults(FileName:string);
property Template : string read FTemplate write FTemplate;
property Results : string read FResults;
end;
implementation
{ TTemplater }
procedure TTemplater.LoadTemplate(FileName: string);
var sl:TStringList;
begin
sl:= TStringList.Create;
try
sl.LoadFromFile(FileName);
FTemplate:= sl.Text;
Restart;
finally
sl.Free;
end;
end;
procedure TTemplater.PutSymbol(Sym, Value: string);
begin
FResults:= StringReplace(FResults,Sym,Value,[rfReplaceAll]);
end;
procedure TTemplater.Restart;
begin
FResults:= FTemplate;
end;
procedure TTemplater.SaveResults(FileName: string);
var sl:TStringList;
begin
sl:= TStringList.Create;
try
sl.Text:= FResults;
sl.SaveToFile(FileName);
finally
sl.Free;
end;
end;
end.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.