text stringlengths 14 6.51M |
|---|
unit HireOfferTask;
interface
uses
Tasks, Kernel, Accounts, CacheAgent, BackupInterfaces, Inventions, FacIds;
type
TMetaHireOfferTask =
class(TMetaTask)
private
fHire : boolean;
fGoods : integer;
fFacId : TFacId;
public
property Hire : boolean read fHire write fHire;
property Goods : integer read fGoods write fGoods;
property FacId : integer read fFacId write fFacId;
end;
THireOfferTask =
class(TAtomicTask)
public
Completed : boolean;
public
function Execute : TTaskResult; override;
procedure StoreToCache(Prefix : string; Cache : TObjectCache); override;
private
procedure MsgHireOffer(var Msg : TMsgFacHireOffer); message msgKernel_FacsHireOffer;
end;
procedure RegisterBackup;
implementation
uses
TaskUtils, ResidentialTasks, ClassStorage;
// THireOfferTask
procedure THireOfferTask.MsgHireOffer(var Msg : TMsgFacHireOffer);
begin
if (Msg.Fac <> nil) and (Msg.Fac.MetaFacility.FacId = TMetaHireOfferTask(MetaTask).FacId)
then
if Msg.Hire = TMetaHireOfferTask(MetaTask).Hire
then
Completed := True;
end;
function THireOfferTask.Execute : TTaskResult;
begin
if Completed
then result := trFinished
else result := trContinue;
end;
procedure THireOfferTask.StoreToCache(Prefix : string; Cache : TObjectCache);
begin
inherited;
Cache.WriteInteger(Prefix + 'CommerceId', TMetaHireOfferTask(MetaTask).Goods);
end;
procedure RegisterBackup;
begin
RegisterClass(THireOfferTask);
end;
end.
|
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// Yawara static site generator
// Static Site Generator unit
// POST generation
// @author : Zendrael <zendrael@gmail.com>
// @date : 2014/10/19
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
unit untPost;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, RegExpr;
//teste
//MarkdownDaringFireball, MarkdownProcessor;
type
{ TPost }
TPost = class
protected
//
strTitle: string;
strDate : String;
strTags: TStringList;
strContentFull: TStringList;
strContent: TStringList;
strFileName: string;
strTemplate : string;
public
//
procedure setTitle( Title: string );
function getTitle: string;
function getTitleLink: string;
procedure setDate( date: string);
function getDate: string;
procedure setTags( Tags: string );
function getTags: string;
procedure setContent( Content: string );
function getContent: string;
procedure setFileName( name: string);
function getFileName: string;
procedure setTemplate( name: string);
function getTemplate: string;
procedure LoadFile( path, fileName: string );
function getFullPost: string;
function getSimplePost: string;
procedure applyTemplate( strFullTemplate : WideString );
procedure save( strFullFileName: String );
function Explode(delimiter:string; source:string) : TStringList;
constructor Create;
destructor Destroy; override;
end;
implementation
{ TPost }
function TPost.Explode(delimiter:string; source:string) : TStringList;
(*
// Name : Explode
// Purpose : each of which is a substring of string formed by splitting
it on
// boundaries formed by the string delim. It does not support PHP's
// 'limit' feature.
// Date : 12 Feb 2001 by Bob Brown (bob....@opus.co.nz)
// Comments : Based on PHP's Explode function (http://www.php.net/explode).
// Returns an array of strings, each of which is a substring of
// string formed by splitting it on boundaries formed by the string //
delimiter.
*)
var
c : word;
begin
Result:=TStringList.Create;
c:=0;
while source<>'' do
begin
if Pos(delimiter,source)>0 then
begin
Result.Add(Copy(Source,1,Pos(delimiter,source)-1));
Delete(Source,1,Length(Result[c])+Length(delimiter));
end
else
begin
Result.Add( Trim( Source ) );
Source:='';
end;
inc(c);
end;
end;
procedure TPost.setTitle(Title: string);
begin
Self.strTitle:= Title;
end;
function TPost.getTitle: string;
begin
Result:= self.strTitle;
end;
function TPost.getTitleLink: string;
begin
Result:= '<a href="'+ getFileName +'">'+ self.strTitle + '</a>';
end;
procedure TPost.setDate(date: string);
begin
self.strDate := date;
end;
function TPost.getDate: string;
begin
Result := self.strDate;
end;
procedure TPost.setTags(Tags: string);
var
i: integer;
begin
self.strTags.Add( Tags );
//processa cada tag em uma linha e cria os links
self.strTags:= Explode(',', self.strTags.Text);
for i:=0 to self.strTags.Count-1 do
begin
self.strTags[i] := '<a href="tag-'+ Trim(self.strTags[i]) +'.html">' + Trim(self.strTags[i]) + '</a> ';
end;
end;
function TPost.getTags: string;
begin
//deve retornar conjunto ul li a
Result:= self.strTags.Text;
end;
procedure TPost.setContent(Content: string);
begin
self.strContentFull.Text:= Content;
self.strContent.Text := Content;
end;
function TPost.getContent: string;
begin
Result:= self.strContentFull.Text;
end;
procedure TPost.LoadFile(path, fileName: string);
var
strTheme : TStringList;
//md : TMarkdownProcessor;
begin
//initialize vars
strTheme := TStringList.Create;
//load template
strTheme.LoadFromFile( getTemplate + '/' + 'detail.html' );
//load file content
strContentFull.LoadFromFile( path + '/' + fileName );
//separa o nome do arquivo
setFileName( fileName );
//prepara cada item se acordo com o arquivo
setTitle( strContentFull[0] );
setDate( strContentFull[1] );
setTags( strContentFull[2] );
//deleta as primeiras linhas e retorna o resto.
//a cada delete, o index e o count é alterado,
//por isso deleto as primeiras 4 linhas através de 0
strContentFull.Delete(0);
strContentFull.Delete(0);
strContentFull.Delete(0);
strContentFull.Delete(0);
//post.Delete(3);
//replace line breaks
strContentFull.Text:= StringReplace( Trim( strContentFull.text ), sLineBreak, '<br />', [rfreplaceAll]);
//process markdown
//strContentFull.Text:= md.process( strContentFull.Text );
//negrito
strContentFull.Text:= ReplaceRegExpr('/(\*\*|__)(.*?)\1/',strContentFull.Text,'<strong>$1</strong>',TRUE);
//replace all starting with template
strTheme.Text := StringReplace(strTheme.Text, '%%POSTTITLE%%', getTitleLink, [rfreplaceAll]);
strTheme.Text := StringReplace(strTheme.Text, '%%POSTCONTENT%%', strContentFull.Text, [rfreplaceAll]);
strTheme.Text := StringReplace(strTheme.Text, '%%POSTDATE%%', getDate, [rfreplaceAll]);
strTheme.Text := StringReplace(strTheme.Text, '%%POSTTAGS%%', getTags, [rfreplaceAll]);
//set complete content
setContent( Trim( strTheme.Text ) );
end;
procedure TPost.setFileName(name: string);
begin
Delete( name, Pos('.', name), Length( name ) );
self.strFileName:= name + '.html';
end;
function TPost.getFileName: string;
begin
Result:= self.strFileName;
end;
procedure TPost.setTemplate(name: string);
begin
self.strTemplate:= name;
end;
function TPost.getTemplate: string;
begin
Result := self.strTemplate;
end;
function TPost.getFullPost: string;
begin
Result := self.strContentFull.Text;
end;
function TPost.getSimplePost: string;
begin
Result := self.strContent.Text;
end;
procedure TPost.applyTemplate(strFullTemplate: WideString);
begin
//apply template to the post (post to template exactly)
strContentFull.Text := StringReplace(strFullTemplate, '%%POSTS%%', getFullPost, [rfreplaceAll]);
//remove pagination for single post
strContentFull.Text := StringReplace(strContentFull.Text, '%%PAGINATION%%', '', [rfreplaceAll]);
strContentFull.Text := StringReplace(strContentFull.Text, '%%POSTTITLE%%', getTitle, [rfreplaceAll]);
end;
procedure TPost.save( strFullFileName: String );
begin
//save file
strContentFull.SaveToFile( strFullFileName );
end;
constructor TPost.Create;
begin
self.strContentFull:= TStringList.Create;
self.strContent:= TStringList.Create;
self.strTags:= TStringList.Create;
end;
destructor TPost.Destroy;
begin
inherited Destroy;
end;
end.
|
unit FrameRow;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.StdCtrls,
FMX.Controls.Presentation, FMX.Edit, FMX.ListBox, FrameRowData,
FrameNetwaveCam, FMX.Layouts;
type
TfraRow = class(TFrame)
panRow: TPanel;
panCommands: TPanel;
cmdDelete: TButton;
panStatus: TPanel;
lblStatus: TLabel;
panSelected: TPanel;
chkSelRow: TCheckBox;
panHost: TPanel;
lblHost: TLabel;
panPort: TPanel;
lblPort: TLabel;
panCountry: TPanel;
lblCountry: TLabel;
panProvider: TPanel;
lblProvider: TLabel;
panCity: TPanel;
lblCity: TLabel;
panNotes: TPanel;
txtNotes: TEdit;
panPlacement: TPanel;
cboPlacement: TComboBox;
panRating: TPanel;
cboRating: TComboBox;
panAuth: TPanel;
lblAuth: TLabel;
layRowData: TLayout;
private
AHost: string;
APort: integer;
AAuth: string;
public
property Host: string read AHost write AHost;
property Port: integer read APort write APort default 0;
property Auth: string read AAuth write AAuth;
end;
implementation
{$R *.fmx}
end.
|
{
Clever Internet Suite
Copyright (C) 2013 Clever Components
All Rights Reserved
www.CleverComponents.com
}
unit clZLibStreams;
interface
{$I clVer.inc}
uses
{$IFNDEF DELPHIXE2}
Classes, Windows,
{$ELSE}
System.Classes, Winapi.Windows,
{$ENDIF}
clInflate, clDeflate, clChecksum, clZLibBase, clUtils, clWUtils;
type
TclGZipInflateStream = class(TStream)
private
FInflater: TclInflater;
FDestination: TStream;
FFileCrc: TclCrc32;
FFileSize: LongWord;
FRawData: TStream;
FIsContent: Boolean;
FIsTrailer: Boolean;
FTotalWritten: LongWord;
FRawBytes: TclByteArray;
FRawBytesSize: Integer;
procedure InitStream;
function WriteBuffer(const Buffer; Count: Integer; var Offset: Integer): Boolean;
function WriteHeader(const Buffer; Count: Integer; var Offset: Integer): Boolean;
function WriteData(const Buffer; Count: Integer; var Offset: Integer): Boolean;
function WriteTrailer(const Buffer; Count, Offset: Integer): Boolean;
public
constructor Create(ADestination: TStream);
destructor Destroy; override;
function Read(var Buffer; Count: Longint): Longint; override;
function Seek(Offset: Longint; Origin: Word): Longint; overload; override;
function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; overload; override;
function Write(const Buffer; Count: Longint): Longint; override;
end;
TclGZipDeflateStream = class(TStream)
private
FDeflater: TclDeflater;
FFileCrc: TclCrc32;
FFileSize: LongWord;
FDestination: TStream;
FTotalWritten: LongWord;
procedure InitStream(ADestination: TStream; ALevel: TclCompressionLevel; AStrategy: TclCompressionStrategy; AFlags: Integer);
procedure WriteHeader(AFlags: Integer);
procedure WriteTrailer;
public
constructor Create(ADestination: TStream; ALevel: TclCompressionLevel;
AStrategy: TclCompressionStrategy; AFlags: Integer); overload;
constructor Create(ADestination: TStream); overload;
destructor Destroy; override;
function Read(var Buffer; Count: Longint): Longint; override;
function Seek(Offset: Longint; Origin: Word): Longint; overload; override;
function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; overload; override;
function Write(const Buffer; Count: Longint): Longint; override;
end;
implementation
{ TclGZipInflateStream }
constructor TclGZipInflateStream.Create(ADestination: TStream);
begin
inherited Create();
Assert(ADestination <> nil);
FDestination := ADestination;
FRawData := TMemoryStream.Create();
FInflater := TclInflater.Create(True);
FFileCrc := TclCrc32.Create();
InitStream();
FTotalWritten := 0;
SetLength(FRawBytes, 10);
FRawBytesSize := 0;
end;
destructor TclGZipInflateStream.Destroy;
begin
FFileCrc.Free();
FInflater.Free();
FRawData.Free();
inherited Destroy();
end;
procedure TclGZipInflateStream.InitStream;
begin
FFileCrc.Reset();
FFileSize := 0;
FRawData.Size := 0;
FRawData.Position := 0;
FRawBytesSize := 0;
FIsContent := False;
FIsTrailer := False;
end;
function TclGZipInflateStream.Read(var Buffer; Count: Integer): Longint;
begin
Result := 0;
end;
function TclGZipInflateStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
begin
case Origin of
soBeginning: Result := Offset;
soCurrent: Result := Integer(FTotalWritten) + Offset;
soEnd: Result := Integer(FTotalWritten) + Offset
else
Result := 0;
end;
if (Result <> Integer(FTotalWritten)) then
begin
raise EclZLibError.Create(ZLibInvalidStreamOperation, ZLibInvalidStreamOperationCode);
end;
end;
function TclGZipInflateStream.Seek(Offset: Integer; Origin: Word): Longint;
begin
case Origin of
soFromBeginning: Result := Offset;
soFromCurrent: Result := Integer(FTotalWritten) + Offset;
soFromEnd: Result := Integer(FTotalWritten) + Offset
else
Result := 0;
end;
if (Result <> Integer(FTotalWritten)) then
begin
raise EclZLibError.Create(ZLibInvalidStreamOperation, ZLibInvalidStreamOperationCode);
end;
end;
function TclGZipInflateStream.Write(const Buffer; Count: Integer): Longint;
var
offset: Integer;
begin
Result := Count;
FTotalWritten := FTotalWritten + LongWord(Result);
offset := 0;
if not FIsContent then
begin
if not WriteHeader(Buffer, Count, offset) then Exit;
FIsContent := True;
end;
if (not FIsTrailer) then
begin
FIsTrailer := WriteData(Buffer, Count, offset);
end;
if FIsTrailer then
begin
if WriteTrailer(Buffer, Count, offset) then
begin
InitStream();
end;
end;
end;
function TclGZipInflateStream.WriteBuffer(const Buffer; Count: Integer; var Offset: Integer): Boolean;
var
len: Integer;
buf: TclByteArray;
begin
{$IFNDEF DELPHI2005}buf := nil;{$ENDIF}
Result := False;
if (Offset >= Count) then Exit;
FInflater.SetInput(Buffer, Offset, Count - Offset);
SetLength(buf, $4000);
while(FInflater.RemainingInput > 0) and (not FInflater.IsNeedingInput) and (not FInflater.IsFinished) do
begin
len := FInflater.Inflate(buf, 0, Length(buf));
if(len > 0) then
begin
FDestination.Write(buf[0], len);
FFileCrc.Update(buf[0], len);
Inc(FFileSize, len);
end;
if(FInflater.IsNeedingDictionary) then
begin
raise EclZLibError.Create(ZLibNeedDictionary, ZLibNeedDictionaryCode);
end;
end;
Offset := Count - FInflater.RemainingInput;
Result := FInflater.IsFinished;
end;
function TclGZipInflateStream.WriteData(const Buffer; Count: Integer; var Offset: Integer): Boolean;
var
dataLen, ofs: Integer;
begin
Result := False;
if (Offset >= Count) then Exit;
dataLen := (Count - Offset);
if (dataLen = 1) then
begin
if (FRawBytesSize = 0) then
begin
FRawBytes[0] := Byte(PclChar(@Buffer)[Offset]);
Inc(FRawBytesSize);
Inc(Offset);
end else
begin
FRawBytes[FRawBytesSize] := Byte(PclChar(@Buffer)[Offset]);
Inc(FRawBytesSize);
Offset := 0;
Result := WriteBuffer(FRawBytes[0], FRawBytesSize, Offset);
FRawBytesSize := 0;
end;
end else
if (dataLen = 2) then
begin
if (FRawBytesSize = 0) then
begin
Result := WriteBuffer(Buffer, Count, Offset);
end else
begin
FRawBytes[FRawBytesSize] := Byte(PclChar(@Buffer)[Offset]);
Inc(FRawBytesSize);
FRawBytes[FRawBytesSize] := Byte(PclChar(@Buffer)[Offset + 1]);
Inc(FRawBytesSize);
Offset := 0;
Result := WriteBuffer(FRawBytes[0], FRawBytesSize, Offset);
FRawBytesSize := 0;
end;
end else
begin
if (FRawBytesSize = 0) then
begin
Result := WriteBuffer(Buffer, Count, Offset);
end else
begin
FRawBytes[FRawBytesSize] := Byte(PclChar(@Buffer)[Offset]);
Inc(FRawBytesSize);
ofs := Offset;
Offset := 0;
WriteBuffer(FRawBytes[0], FRawBytesSize, Offset);
FRawBytesSize := 0;
Offset := ofs;
Inc(Offset);
Result := WriteBuffer(Buffer, Count, Offset);
end;
end;
end;
function TclGZipInflateStream.WriteHeader(const Buffer; Count: Integer; var Offset: Integer): Boolean;
var
flags: Byte;
extra: Word;
b: Byte;
begin
Offset := 0;
Result := False;
FRawData.Seek(0, soEnd);
FRawData.Write(Buffer, Count);
FRawData.Position := 0;
if FRawData.Size < 10 then
begin
Result := False;
Exit;
end;
FRawData.Seek(3, soCurrent);
FRawData.Read(flags, 1);
FRawData.Seek(6, soCurrent);
if flags and $4 = $4 then
begin // FEXTRA
if FRawData.Size - FRawData.Position < 2 then Exit;
FRawData.Read(extra, 2);
if FRawData.Size - FRawData.Position < extra then Exit;
FRawData.Seek(extra, soCurrent);
end;
if flags and $8 = $8 then
begin // FNAME
repeat
if FRawData.Read(b, 1) = 0 then Exit;
until (b = 0);
end;
if flags and $10 = $10 then
begin // FCOMMENT
repeat
if FRawData.Read(b, 1) = 0 then Exit;
until (b = 0);
end;
if flags and $2 = $2 then
begin // FHCRC
if FRawData.Size - FRawData.Position < 2 then Exit;
FRawData.Seek(2, soCurrent);
end;
Offset := FRawData.Position - FRawData.Size + Count;
FRawData.Size := 0;
FRawData.Position := 0;
FRawBytesSize := 0;
Result := True;
end;
function TclGZipInflateStream.WriteTrailer(const Buffer; Count, Offset: Integer): Boolean;
var
crc, size: LongWord;
begin
Result := False;
if (Offset >= Count) then Exit;
FRawData.Seek(0, soEnd);
FRawData.Write(Pointer(TclIntPtr(@Buffer) + Offset)^, Count - Offset);
FRawData.Position := 0;
Assert(SizeOf(crc) = 4);
if (FRawData.Size >= SizeOf(crc) + SizeOf(size)) then
begin
FRawData.Read(crc, SizeOf(crc));
FRawData.Read(size, SizeOf(size));
if (crc <> FFileCrc.Value) then
begin
raise EclZLibError.Create(ZLibInvalidCrc, ZLibInvalidCrcCode);
end;
if (size <> FFileSize) then
begin
raise EclZLibError.Create(ZLibInvalidDataSize, ZLibInvalidDataSizeCode);
end;
Result := True;
end;
end;
{ TclGZipDeflateStream }
constructor TclGZipDeflateStream.Create(ADestination: TStream;
ALevel: TclCompressionLevel; AStrategy: TclCompressionStrategy; AFlags: Integer);
begin
inherited Create();
InitStream(ADestination, ALevel, AStrategy, AFlags);
end;
constructor TclGZipDeflateStream.Create(ADestination: TStream);
begin
inherited Create();
InitStream(ADestination, clDefault, csDefault, 0);
end;
destructor TclGZipDeflateStream.Destroy;
begin
try
WriteTrailer();
finally
FDeflater.Free();
FFileCrc.Free();
inherited Destroy();
end;
end;
procedure TclGZipDeflateStream.InitStream(ADestination: TStream;
ALevel: TclCompressionLevel; AStrategy: TclCompressionStrategy; AFlags: Integer);
begin
Assert(ADestination <> nil);
FDestination := ADestination;
FFileCrc := TclCrc32.Create();
FFileCrc.Reset();
FFileSize := 0;
FTotalWritten := 0;
FDeflater := TclDeflater.Create(CompressionLevelInt[ALevel], True);
FDeflater.SetStrategy(AStrategy);
WriteHeader(AFlags);
end;
function TclGZipDeflateStream.Read(var Buffer; Count: Integer): Longint;
begin
Result := 0;
end;
function TclGZipDeflateStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
begin
case Origin of
soBeginning: Result := Offset;
soCurrent: Result := Integer(FTotalWritten) + Offset;
soEnd: Result := Integer(FTotalWritten) + Offset
else
Result := 0;
end;
if (Result <> Integer(FTotalWritten)) then
begin
raise EclZLibError.Create(ZLibInvalidStreamOperation, ZLibInvalidStreamOperationCode);
end;
end;
function TclGZipDeflateStream.Seek(Offset: Integer; Origin: Word): Longint;
begin
case Origin of
soFromBeginning: Result := Offset;
soFromCurrent: Result := Integer(FTotalWritten) + Offset;
soFromEnd: Result := Integer(FTotalWritten) + Offset
else
Result := 0;
end;
if (Result <> Integer(FTotalWritten)) then
begin
raise EclZLibError.Create(ZLibInvalidStreamOperation, ZLibInvalidStreamOperationCode);
end;
end;
function TclGZipDeflateStream.Write(const Buffer; Count: Integer): Longint;
var
buf: TclByteArray;
len: Integer;
begin
Result := Count;
FTotalWritten := Integer(FTotalWritten) + Count;
FDeflater.SetInput(Buffer, 0, Count);
SetLength(buf, $4000);
while(not FDeflater.IsNeedingInput) do
begin
len := FDeflater.Deflate(buf, 0, Length(buf));
if (len > 0) then
begin
FDestination.Write(buf[0], len);
end else
begin
Break;
end;
end;
if (not FDeflater.IsNeedingInput) then
begin
raise EclZLibError.Create(ZLibDeflateInputError, ZLibDeflateInputErrorCode);
end;
FFileCrc.Update(Buffer, Count);
Inc(FFileSize, LongWord(Count));
end;
procedure TclGZipDeflateStream.WriteHeader(AFlags: Integer);
var
gzheader: array[0..9] of Byte;
begin
ZeroMemory(@gzheader, SizeOf(gzheader));
gzheader[0] := $1F;
gzheader[1] := $8B;
gzheader[2] := DEFLATED;
gzheader[3] := Byte(AFlags);
FDestination.Write(gzheader, SizeOf(gzheader));
end;
procedure TclGZipDeflateStream.WriteTrailer;
var
buf: TclByteArray;
len: Integer;
w: LongWord;
begin
FDeflater.Finish();
SetLength(buf, $4000);
while (not FDeflater.IsFinished) do
begin
len := FDeflater.Deflate(buf, 0, Length(buf));
if (len > 0) then
begin
FDestination.Write(buf[0], len);
end else
begin
Break;
end;
end;
if (not FDeflater.IsFinished) then
begin
raise EclZLibError.Create(ZLibDeflateInputError, ZLibDeflateInputErrorCode);
end;
w := FFileCrc.Value;
FDestination.Write(w, SizeOf(w));
w := FFileSize;
FDestination.Write(FFileSize, SizeOf(w));
end;
end.
|
unit Model.ContatosEmpresa;
interface
uses Common.ENum, FireDAC.Comp.Client;
type
TContatosEmpresa = class
private
FID: Integer;
FSequencia: Integer;
FDescricao: String;
FTelefone: String;
FEMail: String;
FAcao: TAcao;
public
property ID: Integer read FID write FID;
property Sequencia: Integer read FSequencia write FSequencia;
property Descricao: String read FDescricao write FDescricao;
property Telefone: String read FTelefone write FTelefone;
property EMail: String read FEMail write FEMail;
property Acao: TAcao read FAcao write FAcao;
function GetID(iID: Integer): Integer;
function Localizar(aParam: array of variant): TFDQuery;
function Gravar(): Boolean;
end;
implementation
{ TContatosEmpresa }
uses DAO.ContatosEmpresa;
function TContatosEmpresa.GetID(iID: Integer): Integer;
var
contatosDAO : TContatosEmpresaDAO;
begin
try
contatosDAO := TContatosEmpresaDAO.Create;
Result := contatosDAO.GetID(iID);
finally
contatosDAO.Free;
end;
end;
function TContatosEmpresa.Gravar: Boolean;
var
contatosDAO: TContatosEmpresaDAO;
begin
try
contatosDAO := TContatosEmpresaDAO.Create;
case FAcao of
tacIncluir: Result := contatosDAO.Insert(Self);
tacAlterar: Result := contatosDAO.Update(Self);
tacExcluir: Result := contatosDAO.Delete(Self);
end;
finally
contatosDAO.Create.Free;
end;
end;
function TContatosEmpresa.Localizar(aParam: array of variant): TFDQuery;
var
contatosDAO: TContatosEmpresaDAO;
begin
try
contatosDAO := TContatosEmpresaDAO.Create;
Result := contatosDAO.Localizar(aParam);
finally
contatosDAO.Free;
end;
end;
end.
|
unit TSP;
interface
uses
Windows, Classes, SysUtils, asn1util, synacode, clHTTPSendEx, Contnrs;
type
EASN1Exception = class(Exception);
ETSPException = class(Exception)
private
FCode: Integer;
FCodeString: string;
FFailureCode: Integer;
FFailureCodeString: string;
public
constructor Create(const Code, FailureCode: Integer; FailureCodeString: string = ''); overload;
property Code: Integer read FCode;
property CodeString: string read FCodeString;
property FailureCode: Integer read FFailureCode;
property FailureCodeString: string read FFailureCodeString;
end;
procedure ASN1AsXML(Memory: PAnsiChar; MemorySize: Cardinal; OutStream: TStream; Pos: Integer = 0; Level: Integer = 0);
function ASN1ExtractSequence(OID: String; Memory: PAnsiChar; MemorySize: Cardinal): AnsiString;
procedure TSPGetResponse(TimeStampServer, Hash: string; Response: TStream);
implementation
uses VipNet;
type
TASN1Tree = class
private
FItems: TObjectList;
FDataSize: Integer;
FDataType: Integer;
FOffset: Integer;
FNodeSize: Integer;
FNode: PAnsiChar;
FData: PAnsiChar;
function GetData: AnsiString;
function GetItems(Index: Integer): TASN1Tree;
function GetNode: AnsiString;
procedure ParseItems;
public
constructor Create(ABuf: PAnsiChar; ASize: Integer);
destructor Destroy; override;
property Items[Index: Integer]: TASN1Tree read GetItems;
property Offset: Integer read FOffset;
property Node: AnsiString read GetNode;
property PNode: PAnsiChar read FNode;
property NodeSize: Integer read FNodeSize;
property DataType: Integer read FDataType;
property Data: AnsiString read GetData;
property PData: PAnsiChar read FData;
property DataSize: Integer read FDataSize;
function Count: Integer;
end;
constructor ETSPException.Create(const Code, FailureCode: Integer; FailureCodeString: string = '');
var
S: string;
begin
FCode:=Code;
FFailureCode:=FailureCode;
case FCode of
0: FCodeString:='';
1: FCodeString:='Modifications';
2: FCodeString:='Rejection';
3: FCodeString:='Waiting';
4: FCodeString:='Revocation warning';
5: FCodeString:='Revocation notification';
else FCodeString:='Code='+IntToStr(FCode);
end;
if FailureCodeString<>'' then
FFailureCodeString:=FailureCodeString
else
case FFailureCode of
0: FFailureCodeString:='Bad failure';
1: FFailureCodeString:='The request data is incorrect (for notary services)';
2: FFailureCodeString:='The authority indicated in the request is different from the one creating the response token';
4: FFailureCodeString:='The data submitted has the wrong format';
8: FFailureCodeString:='No certificate could be found matching the provided criteria';
16: FFailureCodeString:='MessageTime was not sufficiently close to the system time, as defined by local policy';
32: FFailureCodeString:='Transaction not permitted or supported';
64: FFailureCodeString:='Integrity check failed';
128: FFailureCodeString:='Unrecognized or unsupported algorithm identifier';
else FFailureCodeString:='FailureCode='+IntToStr(FFailureCode);
end;
S:=FCodeString;
if S<>'' then S:=S+': ';
inherited Create(S+FFailureCodeString);
end;
const
ASN1_ROOT = -1;
ASN1_BOOL = $01;
ASN1_BIT_STRING = $03;
ASN1_UTF8_STRING = $0c;
ASN1_NUMERIC_STRING = $12;
ASN1_PRINTABLE_STRING = $13;
ASN1_IA5_STRING = $16;
ASN1_UTC_TIME = $17;
ASN1_BMP_STRING = $1e;
ASN1_SEQUENCE = $30;
ASN1_CONTEXT_SPECIFIC = $a0;
function ASNEncOIDItem(Value: Integer): string;
begin
Result:='';
repeat
Result:=AnsiChar((Value mod 128) or $80*Ord(Length(Result)>0))+Result;
Value:=Value div 128;
until Value=0;
end;
function MibToId(Mib: string): string;
var
I: Integer;
SL: TStringList;
begin
Result:='';
SL := TStringList.Create;
try
SL.Delimiter := '.';
SL.DelimitedText := Mib;
for I := 0 to SL.Count - 1 do
begin
case I of
0: Result := SL[I];
1: Result:=ASNEncOIDItem(StrToInt(Result) * 40 + StrToInt(SL[I]));
else Result := Result + ASNEncOIDItem(StrToInt(SL[I]));
end;
end;
finally
SL.Free;
end;
end;
function ASN1DecOIDItem(var Buffer: PAnsiChar): Integer;
begin
Result:=0;
repeat
Result:=Result*128 + Ord(Buffer^) and $7F;
Inc(Buffer);
until Ord((Buffer-1)^)<$80;
end;
function IdToMib(Id: PAnsiChar; Size: Integer): string;
var
X: Integer;
B: PAnsiChar;
begin
B := Id + Size;
X := ASN1DecOIDItem(Id);
Result := IntToStr(X div 40) + '.' + IntToStr(X mod 40);
while Id < B do Result := Result + '.' + IntToStr(ASN1DecOIDItem(Id));
end;
function ASN1DecInt(Data: PAnsiChar; Size: Integer): Integer;
var
n: Integer;
neg: Boolean;
x: Byte;
begin
Result := 0;
neg := False;
for n := 1 to Size do
begin
x := Ord(Data^);
if (n = 1) and (x > $7F) then
neg := True;
if neg then
x := not x;
Result := Result * 256 + x;
Inc(Data);
end;
if neg then
Result := -(Result + 1);
end;
function ASN1DecodeItem(Memory: PAnsiChar; out DataType: Integer; out Data: PAnsiChar; out Size: Integer; CheckDataType: Integer = 0): Integer;
var
I: Integer;
begin
Result := 0;
Size := 0;
DataType := Ord(Memory^);
Inc(Memory);
Inc(Result);
if Ord(Memory^) < $80 then
Size:=Ord(Memory^)
else
for I:=1 to Ord(Memory^) and $7F do
begin
Inc(Memory);
Inc(Result);
Size := Size * 256 + Ord(Memory^);
end;
Data := Memory + 1;
Inc(Result);
if not (CheckDataType in [0, DataType]) then
raise EASN1Exception.Create('Datatype failed (Expected: ' + IntToStr(CheckDataType) + ', Found: ' + IntToStr(DataType) + ')');
end;
function IsASN1Include(MemoryDataType: Integer; MemoryData: PAnsiChar; MemorySize: Integer): Boolean;
var
DataType,Size: Integer;
Data: PAnsiChar;
begin
Result := False;
if (MemorySize < 5) or (MemoryDataType <> ASN1_OCTSTR) then Exit;
ASN1DecodeItem(MemoryData,DataType,Data,Size);
Result := (DataType in [ASN1_SEQUENCE, ASN1_UTF8_STRING]) and (Data + Size = MemoryData + MemorySize);
end;
function UTF8ToWideStr(const Buf; Size: Integer): WideString;
var
Sz: integer;
begin
if Size <= 0 then
begin
Result := '';
Exit;
end;
SetLength(Result, Size);
Sz := MultiByteToWideChar(CP_UTF8, 0, @Buf, Size, @Result[1], Size);
SetLength(Result, Sz);
end;
function ASN1GetValueAsString(DataType: Integer; Data: PAnsiChar; DataSize: Integer): String;
var
P: Char;
PC, PB: PAnsiChar;
UTF: PAnsiChar;
I: Integer;
SS: TMemoryStream;
begin
case DataType of
ASN1_INT,ASN1_BOOL:
Result := IntToStr(ASN1DecInt(Data, DataSize));
ASN1_NUMERIC_STRING,ASN1_IA5_STRING,ASN1_PRINTABLE_STRING,ASN1_UTC_TIME:
SetString(Result, Data, DataSize);
ASN1_OBJID:
Result := IdToMib(Data, DataSize);
ASN1_BMP_STRING:
begin
try
GetMem(PB, DataSize);
try
Move(Data^, PB^, DataSize);
PC := PB;
I := 0;
while I < DataSize do
begin
P := PC^;
PC^ := (PC+1)^;
(PC+1)^ := P;
Inc(I, 2);
Inc(PC, 2);
end;
Result := WideCharToString(PWideChar(PB));
finally
FreeMem(PB, DataSize);
end;
finally
end;
end;
ASN1_UTF8_STRING:
begin
Result := UTF8ToWideStr(Data^, DataSize);
end;
else
SetString(Result, Data, DataSize);
Result := StringReplace(EncodeBase64(Result),#13#10,'',[rfReplaceAll]);
end;
end;
procedure WriteToStream(S: TStream; DataType: Integer; Level: Integer; Pos: Integer; Data: PAnsiChar; Size: Integer);
var
I: Integer;
C: Char;
Str: String;
begin
C := #32;
for I := 1 to Level do
begin
S.WriteBuffer(C, 1);
end;
Str := Format('L%d P%4.4X T%4.4X: ', [Level, Pos, DataType]);
S.WriteBuffer(Str[1], Length(Str));
S.WriteBuffer(Data^, Size);
S.WriteBuffer(sLineBreak, Length(sLineBreak));
end;
procedure ASN1AsXML(Memory: PAnsiChar; MemorySize: Cardinal; OutStream: TStream; Pos: Integer = 0; Level: Integer = 0);
procedure SaveNodeToStream(Node: TASN1Tree; Level: Integer);
var
I: Integer;
S: AnsiString;
begin
if Node.Count > 0 then
begin
WriteToStream(OutStream, Node.DataType, Level, Node.Offset, Node.PData, 0);
for I := 0 to Node.Count - 1 do
begin
SaveNodeToStream(Node.Items[I], Level + 1);
end;
end
else
begin
S := ASN1GetValueAsString(Node.DataType, Node.PData, Node.DataSize);
WriteToStream(OutStream, Node.DataType, Level, Node.Offset, @S[1], Length(S));
end;
end;
var
Root: TASN1Tree;
I: Integer;
begin
Root := TASN1Tree.Create(Memory, MemorySize);
Root.ParseItems;
for I := 0 to Root.Count - 1 do
begin
SaveNodeToStream(Root.Items[I], Level);
end;
end;
function ASN1ExtractSequence(OID: String; Memory: PAnsiChar; MemorySize: Cardinal): AnsiString;
function FindSequence(Node: TASN1Tree): TASN1Tree;
var
Item: TASN1Tree;
I: Integer;
begin
Result := nil;
for I := 0 to Node.Count - 1 do
begin
Item := FindSequence(Node.Items[I]);
if Assigned(Item) then
begin
Result := Item;
Break;
end
else if (Node.DataType = ASN1_SEQUENCE)
and (Node.Items[I].DataType = ASN1_OBJID)
and (IdToMib(Node.Items[I].PNode, Node.Items[I].DataSize) = OID)
then
begin
Result := Node;
Break;
end;
end;
end;
var
Root: TASN1Tree;
I: Integer;
Node: TASN1Tree;
begin
Root := TASN1Tree.Create(Memory, MemorySize);
Root.ParseItems;
for I := 0 to Root.Count - 1 do
begin
Node := FindSequence(Root.Items[I]);
if Assigned(Node) then
begin
Result := Node.Node;
Break;
end;
end;
end;
procedure TSPGetResponse(TimeStampServer, Hash: string; Response: TStream);
var
S: AnsiString;
HTTPResponse: String;
DataType,Size: Integer;
Memory: PAnsiChar;
E,B: Integer;
F: string;
RR: Boolean;
Request: TMemoryStream;
HTTPClient: THTTPSendEx;
begin
S := ASNObject(
ASNObject(ASNEncInt(1), ASN1_INT)+
ASNObject(
ASNObject(
ASNObject(MibToId('1.2.643.2.2.9'), ASN1_OBJID)+ASNObject('', ASN1_NULL),
// ASNObject(MibToId(szOID_DOMEN_ELIP_SIGN_ALG), ASN1_OBJID)+ASNObject('', ASN1_NULL),
ASN1_SEQ) +
ASNObject(Hash, ASN1_OCTSTR), ASN1_SEQ) +
ASNObject(IntToStr(GetTickCount), ASN1_INT) +
ASNObject(Char(True),ASN1_BOOL),
ASN1_SEQ);
Request := TMemoryStream.Create;
HTTPClient := THTTPSendEx.Create;
try
try
HTTPClient.MimeType := 'application/timestamp-query';
RR := HTTPClient.Post(TimeStampServer, S, Response);
if not RR or (HTTPClient.ResponseCode < 200) or (HTTPClient.ResponseCode > 299) then
begin
raise ETSPException.Create(IntToStr(HTTPClient.ResponseCode)+': '+UTF8Decode(HTTPClient.ResponseString)+'. URL:'+TimeStampServer);
end;
except
on E:Exception do
raise ETSPException.Create(E.ClassName+': '+E.Message+'. URL:'+TimeStampServer);
end;
if not SameText(HTTPClient.MimeType,'application/timestamp-reply') then
raise ETSPException.Create('Bad reply. Content-Type: '+HTTPClient.MimeType+'. URL:'+TimeStampServer);
Response.Position:=0;
Request.Clear;
Request.CopyFrom(Response,Response.Size);
Memory:=Request.Memory;
ASN1DecodeItem(Memory,DataType,Memory,Size,ASN1_SEQUENCE);
ASN1DecodeItem(Memory,DataType,Memory,Size,ASN1_SEQUENCE);
ASN1DecodeItem(Memory,DataType,Memory,Size,ASN1_INT);
E:=ASN1DecInt(Memory,Size);
if E<>0 then //обработка ошибки
begin
B:=0;
F:='';
//далее может быть сразу: или код ошибки, или текст ошибки, а только потом - код ошибки
//сервер может возвращать только код
while True do
begin
Inc(Memory,Size); //переход на следующий узел
ASN1DecodeItem(Memory,DataType,Memory,Size);
case DataType of
ASN1_BIT_STRING: //это код ошибки
if Size=2 then
B:=PByte(Memory+1)^; //второй байт
ASN1_SEQUENCE: //это блок с текстом ошибки
begin
ASN1DecodeItem(Memory,DataType,Memory,Size); //получим текстовую строку об ошибке
if DataType in [ASN1_UTF8_STRING,ASN1_PRINTABLE_STRING,ASN1_IA5_STRING,ASN1_BMP_STRING] then
begin
F:=ASN1GetValueAsString(DataType,Memory,Size);
Continue;
end;
end;
end;
Break;
end;
raise ETSPException.Create(E,B,F);
end;
finally
Request.Free;
HTTPClient.Free;
end;
end;
{ TASN1Tree }
function TASN1Tree.Count: Integer;
begin
Result := FItems.Count;
end;
constructor TASN1Tree.Create(ABuf: PAnsiChar; ASize: Integer);
begin
inherited Create;
FItems := TObjectList.Create(True);
FDataSize := 0;
FDataType := ASN1_ROOT;
FOffset := 0;
FNodeSize := ASize;
FNode := ABuf;
FData := nil;
end;
destructor TASN1Tree.Destroy;
begin
FItems.Free;
inherited;
end;
function TASN1Tree.GetData: AnsiString;
begin
SetLength(Result, FDataSize);
Move(FData^, Result[1], FDataSize);
end;
function TASN1Tree.GetItems(Index: Integer): TASN1Tree;
begin
Result := FItems[Index] as TASN1Tree;
end;
function TASN1Tree.GetNode: AnsiString;
begin
SetLength(Result, FNodeSize);
Move(FNode^, Result[1], FNodeSize);
end;
procedure TASN1Tree.ParseItems;
var
LDataType, LSize: Integer;
LData, LMemory, LMemoryEnd: PAnsiChar;
Pos: Integer;
Item: TASN1Tree;
begin
FItems.Clear;
LMemory := FNode;
LMemoryEnd := LMemory + FNodeSize;
Pos := FOffset;
while LMemory < LMemoryEnd do
begin
Pos := Pos + ASN1DecodeItem(LMemory, LDataType, LData, LSize);
Item := TASN1Tree.Create(LData, LSize);
Item.FDataSize := LSize;
Item.FDataType := LDataType;
Item.FOffset := Pos;
Item.FData := LData;
FItems.Add(Item);
if ((LDataType and $20)<>0) or IsASN1Include(LDataType, LData, LSize) then
begin
Item.ParseItems;
end;
LMemory := LData + LSize;
Pos := Pos + LSize;
end;
end;
initialization
finalization
end.
|
unit frmInIOCPShortConnection;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, fmIOCPSvrInfo, iocp_base, iocp_clients, iocp_server,
iocp_sockets, iocp_managers, iocp_clientBase;
type
TFormInIOCPShortConnection = class(TForm)
Memo1: TMemo;
InIOCPServer1: TInIOCPServer;
InConnection1: TInConnection;
btnStart: TButton;
btnStop: TButton;
btnConnect: TButton;
btnDisconnect: TButton;
btnSend: TButton;
InMessageManager1: TInMessageManager;
InMessageClient1: TInMessageClient;
EditTarget: TEdit;
btnBroad: TButton;
InClientManager1: TInClientManager;
InCertifyClient1: TInCertifyClient;
btnLogin: TButton;
btnLogout: TButton;
EditUserName: TEdit;
edtPort: TEdit;
lbl1: TLabel;
btnQuery: TButton;
FrameIOCPSvrInfo1: TFrameIOCPSvrInfo;
Button1: TButton;
InEchoClient1: TInEchoClient;
procedure btnStartClick(Sender: TObject);
procedure btnStopClick(Sender: TObject);
procedure btnConnectClick(Sender: TObject);
procedure btnDisconnectClick(Sender: TObject);
procedure InConnection1Error(Sender: TObject; const Msg: string);
procedure btnSendClick(Sender: TObject);
procedure btnBroadClick(Sender: TObject);
procedure btnLoginClick(Sender: TObject);
procedure InClientManager1Login(Sender: TObject; Params: TReceiveParams;
Result: TReturnResult);
procedure FormCreate(Sender: TObject);
procedure InMessageClient1ReturnResult(Sender: TObject;
Result: TResultParams);
procedure btnLogoutClick(Sender: TObject);
procedure InCertifyClient1Certify(Sender: TObject; Action: TActionType;
ActResult: Boolean);
procedure InMessageManager1Receive(Sender: TObject; Params: TReceiveParams;
Result: TReturnResult);
procedure EditUserNameDblClick(Sender: TObject);
procedure btnQueryClick(Sender: TObject);
procedure InCertifyClient1ListClients(Sender: TObject; Count, No: Cardinal;
Client: PClientInfo);
procedure InMessageManager1Push(Sender: TObject; Params: TReceiveParams;
Result: TReturnResult);
procedure InMessageManager1Broadcast(Sender: TObject;
Params: TReceiveParams; Result: TReturnResult);
procedure Button1Click(Sender: TObject);
procedure InEchoClient1ReturnResult(Sender: TObject; Result: TResultParams);
procedure InConnection1ReceiveMsg(Sender: TObject; Msg: TResultParams);
procedure InIOCPServer1AfterOpen(Sender: TObject);
procedure InIOCPServer1AfterClose(Sender: TObject);
private
{ Private declarations }
FAppDir: String;
public
{ Public declarations }
end;
var
FormInIOCPShortConnection: TFormInIOCPShortConnection;
InstanceCount: Integer = 0;
implementation
uses
iocp_log, iocp_varis, iocp_utils;
{$R *.dfm}
procedure TFormInIOCPShortConnection.btnBroadClick(Sender: TObject);
begin
// 管理员权限才能广播
InMessageClient1.Broadcast('广播消息, aaa, bbb');
end;
procedure TFormInIOCPShortConnection.btnConnectClick(Sender: TObject);
begin
// 注意：
// InConnection1.AutoConnect := True;
// InConnection1.ReuseSession := True;
InConnection1.Active := True;
end;
procedure TFormInIOCPShortConnection.btnDisconnectClick(Sender: TObject);
begin
InConnection1.Active := False;
end;
procedure TFormInIOCPShortConnection.btnLoginClick(Sender: TObject);
begin
// 重用 Session：
// InConnection1.ReuseSession := True;
InCertifyClient1.Group := 'aaa';
InCertifyClient1.UserName := EditUserName.Text;
InCertifyClient1.Password := 'AAABBB';
InCertifyClient1.Login;
end;
procedure TFormInIOCPShortConnection.btnLogoutClick(Sender: TObject);
begin
// InConnection1.ReuseSession := True;
// -> 登出后保留 InConnection1.Session
// 30分钟内再次连接后不用重新登录！可以直接发送消息等...
InCertifyClient1.Logout;
end;
procedure TFormInIOCPShortConnection.btnSendClick(Sender: TObject);
begin
// 发送前要先登录
// 请再运行本程序测试相互之间的消息发送
if EditTarget.Text <> '' then
InMessageClient1.SendMsg('发消息给 ' + EditTarget.Text, EditTarget.Text)
else
InMessageClient1.SendMsg('发消息到服务端（无意义）');
end;
procedure TFormInIOCPShortConnection.btnStartClick(Sender: TObject);
begin
Memo1.Lines.Clear;
iocp_log.TLogThread.InitLog; // 开启日志
InIOCPServer1.ServerPort := StrToInt(edtPort.Text);
InIOCPServer1.Active := True; // 开启服务
FrameIOCPSvrInfo1.Start(InIOCPServer1); // 开始统计
end;
procedure TFormInIOCPShortConnection.btnStopClick(Sender: TObject);
begin
InIOCPServer1.Active := False; // 停止服务
FrameIOCPSvrInfo1.Stop; // 停止统计
iocp_log.TLogThread.StopLog; // 停止日志
end;
procedure TFormInIOCPShortConnection.Button1Click(Sender: TObject);
begin
InEchoClient1.Post; // 测试一下服务器的反应
end;
procedure TFormInIOCPShortConnection.btnQueryClick(Sender: TObject);
begin
// 查询全部连接的客户端（可能未登录）
// 在 InCertifyClient1ListClients 处返回结果
InCertifyClient1.QueryClients;
end;
procedure TFormInIOCPShortConnection.EditUserNameDblClick(Sender: TObject);
begin
EditUserName.Text := 'USER_B';
end;
procedure TFormInIOCPShortConnection.FormCreate(Sender: TObject);
begin
if (InstanceCount = 1) then
begin
btnStart.Enabled := False;
btnStop.Enabled := False;
EditUserName.Text := 'USER_B';
EditTarget.Text := 'USER_A';
end;
// 准备工作路径
FAppDir := ExtractFilePath(Application.ExeName);
// 客户端数据存放路径（2.0改名称）
iocp_Varis.gUserDataPath := FAppDir + 'client_data\';
MyCreateDir(FAppDir + 'log'); // 建目录
MyCreateDir(FAppDir + 'temp'); // 建目录
// 建测试的用户路径
MyCreateDir(iocp_Varis.gUserDataPath); // 建目录
MyCreateDir(iocp_Varis.gUserDataPath + 'user_a');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_a\data');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_a\msg');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_a\temp');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_b');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_b\data');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_b\msg');
MyCreateDir(iocp_Varis.gUserDataPath + 'user_b\temp');
end;
procedure TFormInIOCPShortConnection.InCertifyClient1Certify(Sender: TObject;
Action: TActionType; ActResult: Boolean);
begin
case Action of
atUserLogin: // 登录
if ActResult then
begin
Memo1.Lines.Add('登录成功，30 分钟内 Session 有效，请断开, 连接->发送,');
Memo1.Lines.Add('不用每次连接后都登录了')
end else
Memo1.Lines.Add('登录失败');
atUserLogout: // 登出
if ActResult then
Memo1.Lines.Add('登出成功')
else
Memo1.Lines.Add('登出失败');
end;
end;
procedure TFormInIOCPShortConnection.InCertifyClient1ListClients(Sender: TObject;
Count, No: Cardinal; Client: PClientInfo);
begin
// 在此列出查询到的客户端信息
// Client^.Socket = 0 的为短连接客户端
if Client^.Socket = 0 then
memo1.Lines.Add(IntToStr(No) + '/' + IntToStr(Count) + ', ' +
Client^.Group + ':' + Client^.Name + ' -> ' +
IntToStr(Cardinal(Client^.Socket)) + '(短连接)')
else
memo1.Lines.Add(IntToStr(No) + '/' + IntToStr(Count) + ', ' +
Client^.Group + ':' + Client^.Name + ' -> ' +
IntToStr(Cardinal(Client^.Socket)));
end;
procedure TFormInIOCPShortConnection.InClientManager1Login(Sender: TObject;
Params: TReceiveParams; Result: TReturnResult);
begin
if (Params.Password <> '') then
begin
Result.Role := crAdmin; // 2.0 改，返回 crAdmin 权限，能广播
Result.ActResult := arOK;
// 登记属性, 自动设置用户数据路径（注册时建）
InClientManager1.Add(Params.Socket, crAdmin);
end else
Result.ActResult := arFail;
end;
procedure TFormInIOCPShortConnection.InConnection1Error(Sender: TObject; const Msg: string);
begin
Memo1.Lines.Add(Msg); // 显示异常提示
end;
procedure TFormInIOCPShortConnection.InConnection1ReceiveMsg(Sender: TObject;
Msg: TResultParams);
begin
// 收到其他客户发来的消息（被动接收）
Memo1.Lines.Add(InConnection1.UserName + ' 收到 ' + IntToStr(Integer(Msg.Owner)) + ' 的消息：' + Msg.Msg);
end;
procedure TFormInIOCPShortConnection.InEchoClient1ReturnResult(Sender: TObject;
Result: TResultParams);
begin
// 收到响应的反馈, Result.VarCount 是连接数
Memo1.Lines.Add('服务器反馈, 客户端连接数=' + IntToStr(Result.VarCount));
end;
procedure TFormInIOCPShortConnection.InIOCPServer1AfterClose(Sender: TObject);
begin
btnStart.Enabled := not InIOCPServer1.Active;
btnStop.Enabled := InIOCPServer1.Active;
end;
procedure TFormInIOCPShortConnection.InIOCPServer1AfterOpen(Sender: TObject);
begin
btnStart.Enabled := not InIOCPServer1.Active;
btnStop.Enabled := InIOCPServer1.Active;
Memo1.Lines.Add('ip: ' + InIOCPServer1.ServerAddr);
Memo1.Lines.Add('port: ' + IntToStr(InIOCPServer1.ServerPort));
end;
procedure TFormInIOCPShortConnection.InMessageClient1ReturnResult(Sender: TObject;
Result: TResultParams);
begin
// 服务器反馈事件
case Result.ActResult of
arOK:
Memo1.Lines.Add('消息发送成功.');
arOffline:
Memo1.Lines.Add('反馈：对方离线.');
arOutDate:
Memo1.Lines.Add('凭证过期，请重新登录.');
end;
end;
procedure TFormInIOCPShortConnection.InMessageManager1Broadcast(Sender: TObject;
Params: TReceiveParams; Result: TReturnResult);
begin
// 广播：发送消息给全部在线客户端
InMessageManager1.Broadcast(Params);
Result.ActResult := arOK;
end;
procedure TFormInIOCPShortConnection.InMessageManager1Push(Sender: TObject;
Params: TReceiveParams; Result: TReturnResult);
begin
// 发送消息给其他客户端: ToUser、TargetUser
if (Params.ToUser <> '') then
begin
InMessageManager1.PushMsg(Params, Params.ToUser);
Result.Msg := '推送消息成功已投放';
end else
Result.Msg := '消息未投放';
end;
procedure TFormInIOCPShortConnection.InMessageManager1Receive(Sender: TObject;
Params: TReceiveParams; Result: TReturnResult);
begin
Memo1.Lines.Add('服务器：收到消息 ' + Params.Msg);
Result.ActResult := arOK;
end;
end.
|
{====================================================}
{ }
{ EldoS Visual Components }
{ }
{ Copyright (c) 1998-2003, EldoS Corporation }
{ }
{====================================================}
{$include elpack2.inc}
{$ifdef ELPACK_SINGLECOMP}
{$I ElPack.inc}
{$else}
{$ifdef LINUX}
{$I ../ElPack.inc}
{$else}
{$I ..\ElPack.inc}
{$endif}
{$endif}
(*
Version History
10/06/2201
Added MoveToIns method
*)
unit ElMTree;
interface
uses Classes, SysUtils, ElList;
type
TElMTree = class;
TElMTreeItem = ^RElMTreeItem;
RElMTreeItem = record
Parent : TElMTreeItem;
Data : pointer;
List : TElList;
end;
TIterProc = procedure(Item : TElMTreeItem; Index : integer; var ContinueIterate : boolean;
IterateData : pointer);
TItemSaveEvent = procedure(Sender : TObject; Item : TElMTreeItem; Stream : TStream) of object;
TElMTreeItemDelete = procedure(Sender : TObject; Item : TElMTreeItem; Data : pointer) of object;
TElMTree = class
private
FRoot : TElMTreeItem;
FCount : integer;
FOnItemSave : TItemSaveEvent;
FOnItemLoad : TItemSaveEvent;
FOnItemDelete : TElMTreeItemDelete;
function GetItem(index : integer) : TElMTreeItem;
protected
procedure TriggerItemSaveEvent(Item : TElMTreeItem; Stream : TStream); virtual;
procedure TriggerItemLoadEvent(Item : TElMTreeItem; Stream : TStream); virtual;
procedure TriggerItemDeleteEvent(Item : TElMTreeItem; Data : pointer); virtual;
public
constructor Create;
destructor Destroy; override;
function AddItem(Parent : TElMTreeItem; Value : pointer) : TElMTreeItem;
function InsertItem(Parent : TElMTreeItem; Index : integer; Value : pointer) : TElMTreeItem;
procedure DeleteItem(Item : TElMTreeItem);
procedure MoveTo(Item, NewParent : TElMTreeItem);
procedure Clear;
function GetIndex(Item : TElMTreeItem) : Integer;
function GetAbsIndex(Item : TElMTreeItem) : Integer;
procedure Iterate(IterateProc : TIterProc; IterateData : pointer);
procedure SaveToStream(Stream : TStream); virtual;
procedure LoadFromStream(Stream : TStream); virtual;
procedure SaveSubTreeToStream(Item : TElMTreeItem; Stream : TStream); virtual;
// Item will be saved too
procedure LoadSubTreeFromStream(Item : TElMTreeItem; Stream : TStream); virtual;
procedure MoveToIns(Item, NewParent : TElMTreeItem; Index : integer);
function FindData(Data : Pointer): TElMTreeItem;
// Item here is the "parent" item for all items loaded
property Count : Integer read FCount; { Public }
property Item[index : integer] : TElMTreeItem read GetItem; { Public }
property OnItemSave : TItemSaveEvent read FOnItemSave write FOnItemSave;
property OnItemLoad : TItemSaveEvent read FOnItemLoad write FOnItemLoad;
property OnItemDelete : TElMTreeItemDelete read FOnItemDelete write FOnItemDelete;
property Root : TElMTreeItem read FRoot;
end;
implementation
procedure TElMTree.Iterate(IterateProc : TIterProc; IterateData : pointer);
var
j : integer;
DoContinue : boolean;
procedure IntIterate(Item : TElMTreeItem);
var
i : integer;
begin
inc(j);
if j >= 0 then IterateProc(Item, j, DoContinue, IterateData);
if not (DoContinue) then exit;
for i := 0 to Item^.List.Count - 1 do
begin
IntIterate(TElMTreeItem(Item.List[i]));
if not (DoContinue) then exit;
end;
end;
begin
j := -2;
DoContinue := true;
IntIterate(FRoot);
end;
function TElMTree.GetItem(index : integer) : TElMTreeItem;
type
PGIRec = ^TGIRec;
TGIRec = record
j : integer;
TSI : TElMTreeItem;
end;
var
GIRec : TGIRec;
procedure IntGetItem(Item : TElMTreeItem; Index : integer; var ContinueIterate : boolean;
IterateData : pointer);
begin
if Index = PGIRec(IterateData)^.j then
begin
PGIRec(IterateData)^.TSI := Item;
ContinueIterate := false;
end;
end;
begin
if (index < 0) or (index >= FCount) then
begin
result := nil;
exit;
end;
GIRec.TSI := nil;
GIRec.j := index;
Iterate(@IntGetItem, @GIRec);
result := GIRec.TSI;
end;
function TElMTree.AddItem(Parent : TElMTreeItem; Value : pointer) : TElMTreeItem; { public }
var
TI : TElMTreeItem;
begin
New(TI);
TI^.List := TElList.Create;
TI^.Data := Value;
if Parent = nil then
FRoot^.List.Add(TI)
else
Parent^.List.Add(TI);
if Parent = nil then
TI^.Parent := FRoot
else
TI^.Parent := Parent;
result := ti;
inc(FCount);
end; { AddItem }
function TElMTree.InsertItem(Parent : TElMTreeItem; Index : integer; Value : pointer) : TElMTreeItem; { public }
var
TI : TElMTreeItem;
begin
New(TI);
TI^.List := TElList.Create;
TI^.Data := Value;
if Parent = nil then
begin
FRoot^.List.Insert(index, TI);
TI^.Parent := FRoot;
end
else
begin
Parent^.List.Insert(Index, TI);
TI^.Parent := Parent;
end;
result := ti;
inc(FCount);
end; { InsertItem }
procedure TElMTree.DeleteItem(Item : TElMTreeItem); { public }
begin
if (Item = nil) then exit;
while Item^.List.Count > 0 do
DeleteItem(Item^.List[0]);
Item^.List.Free;
Item^.Parent^.List.Remove(Item);
TriggerItemDeleteEvent(Item, Item^.Data);
Dispose(Item);
dec(FCount);
end; { DeleteItem }
procedure TElMTree.Clear; { public }
begin
while FRoot^.List.Count > 0 do
DeleteItem(FRoot^.List[0]);
end; { Clear }
procedure TElMTree.MoveTo(Item, NewParent : TElMTreeItem); { public }
begin
if Item = nil then exit;
Item^.Parent.List.Remove(Item);
if NewParent = nil then NewParent := FRoot;
NewParent^.List.Add(Item);
Item^.Parent := NewParent;
end; { MoveTo }
function TElMTree.GetIndex(Item : TElMTreeItem) : Integer; { public }
begin
result := Item^.Parent^.List.IndexOf(Item);
end; { GetIndex }
function TElMTree.GetAbsIndex(Item : TElMTreeItem) : Integer; { public }
type
PGIRec = ^TGIRec;
TGIRec = record
j : integer;
TSI : TElMTreeItem;
end;
var
GIRec : TGIRec;
procedure IntGetIndex(Item : TElMTreeItem; Index : integer; var ContinueIterate : boolean;
IterateData : pointer);
begin
if PGIRec(IterateData)^.TSI = Item then
begin
PGIRec(IterateData)^.j := index;
ContinueIterate := false;
end;
end;
begin
if Item = nil then
begin result := -1;
exit;
end;
GIRec.j := -1;
GIRec.TSI := Item;
Iterate(@IntGetIndex, @GIRec);
result := GIRec.j;
end;
procedure TElMTree.SaveToStream(Stream : TStream); { public }
begin
SaveSubTreeToStream(FRoot, Stream);
end; { SaveToStream }
procedure TElMTree.LoadFromStream(Stream : TStream); { public }
begin
LoadSubTreeFromStream(FRoot, Stream);
end; { LoadFromStream }
procedure TElMTree.SaveSubTreeToStream(Item : TElMTreeItem; Stream : TStream);
procedure IntSave(Item : TElMTreeItem; Stream : TStream; Tree : TElMTree);
var
i, j : integer;
begin
i := Item^.List.Count;
Stream.WriteBuffer(i, sizeof(integer));
if (Item <> Tree.FRoot) then
Tree.TriggerItemSaveEvent(Item, Stream);
for j := 0 to i - 1 do
IntSave(TElMTreeItem(Item^.List[j]), Stream, Tree);
end;
begin
if Item = nil then Item := FRoot;
IntSave(Item, Stream, self);
end;
procedure TElMTree.LoadSubTreeFromStream(Item : TElMTreeItem; Stream : TStream);
procedure IntLoad(Item : TElMTreeItem; Stream : TStream; Tree : TElMTree);
var
i, j : integer;
NewItem : TElMTreeItem;
begin
Stream.ReadBuffer(i, sizeof(integer));
if Item <> Tree.FRoot then
Tree.TriggerItemLoadEvent(Item, Stream);
if i < 0 then
raise EOutOfMemory.Create('');
for j := 0 to i - 1 do
begin
NewItem := Tree.AddItem(Item, nil);
IntLoad(NewItem, Stream, Tree);
end;
end;
begin
if Item = nil then Item := FRoot;
IntLoad(Item, Stream, self);
end;
procedure TElMTree.TriggerItemSaveEvent(Item : TElMTreeItem; Stream : TStream);
{ Triggers the OnItemSave event. This is a virtual method (descendants of this component can override it). }
begin
if (assigned(FOnItemSave)) then
FOnItemSave(Self, Item, Stream);
end; { TriggerItemSaveEvent }
procedure TElMTree.TriggerItemLoadEvent(Item : TElMTreeItem; Stream : TStream);
{ Triggers the OnItemLoad event. This is a virtual method (descendants of this component can override it). }
begin
if (assigned(FOnItemLoad)) then
FOnItemLoad(Self, Item, Stream);
end; { TriggerItemLoadEvent }
procedure TElMTree.TriggerItemDeleteEvent(Item : TElMTreeItem; Data : pointer);
{ Triggers the OnItemDelete event. This is a virtual method (descendants of this component can override it). }
begin
if (assigned(FOnItemDelete)) then
FOnItemDelete(Self, Item, Data);
end; { TriggerItemDeleteEvent }
constructor TElMTree.Create; { public }
begin
inherited;
New(FRoot);
FRoot.Parent := nil;
FRoot.Data := nil;
FRoot^.List := TElList.Create;
end; { Create }
destructor TElMTree.Destroy; { public }
begin
Clear;
FRoot^.List.Free;
Dispose(FRoot);
inherited;
end; { Destroy }
procedure TElMTree.MoveToIns(Item, NewParent : TElMTreeItem; Index : integer);
begin
if Item = nil then exit;
Item^.Parent.List.Remove(Item);
if NewParent = nil then
NewParent := FRoot;
NewParent^.List.Insert(Index, Item);
Item^.Parent := NewParent;
end; { MoveTo }
function TElMTree.FindData(Data : Pointer): TElMTreeItem;
type TSRec = record
Data : pointer;
Item : TElMTreeItem;
end;
PSrec = ^TSrec;
var SRec : TSRec;
procedure SearchProc(Item : TElMTreeItem; Index : integer; var ContinueIterate : boolean;
IterateData : pointer);
begin
if Item.Data = PSrec(IterateData).Data then
begin
ContinueIterate := false;
PSrec(IterateData).Item := Item;
end;
end;
begin
SRec.Data := Data;
SRec.Item := nil;
Iterate(@SearchProc, @SRec);
Result := SRec.Item;
end;
end.
|
unit udmFilhos;
interface
uses
Windows, System.UITypes,Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, udmPadrao, DBAccess, IBC, DB, MemDS;
type
TdmFilhos = class(TdmPadrao)
qryLocalizacaoREGISTRO: TFloatField;
qryLocalizacaoNOME_FILHO: TStringField;
qryLocalizacaoDATA_NASCIMENTO: TDateTimeField;
qryLocalizacaoOPERADOR: TStringField;
qryLocalizacaoDT_ALTERACAO: TDateTimeField;
qryManutencaoREGISTRO: TFloatField;
qryManutencaoNOME_FILHO: TStringField;
qryManutencaoDATA_NASCIMENTO: TDateTimeField;
qryManutencaoOPERADOR: TStringField;
qryManutencaoDT_ALTERACAO: TDateTimeField;
protected
procedure MontaSQLBusca(DataSet :TDataSet = Nil); override;
procedure MontaSQLRefresh; override;
private
FCod_Filhos: String;
FNome_Filho: String;
public
function LocalizarFilho(DataSet: TDataSet): Boolean;
property Cod_Filhos: String read FCod_Filhos write FCod_Filhos;
property Nome_Filho: String read FNome_Filho write FNome_Filho;
end;
const
SQL_DEFAULT =
' SELECT ' +
' REGISTRO, ' +
' NOME_FILHO, ' +
' DATA_NASCIMENTO, ' +
' OPERADOR, ' +
' DT_ALTERACAO ' +
' FROM STWCPGTFUN2 ';
var
dmFilhos: TdmFilhos;
implementation
{$R *.dfm}
{ TdmFilhos }
function TdmFilhos.LocalizarFilho(DataSet: TDataSet): Boolean;
begin
if DataSet = nil then
DataSet := qryLocalizacao;
with (DataSet as TIBCQuery) do
begin
Close;
SQL.Clear;
SQL.Add(SQL_DEFAULT);
SQL.Add('WHERE REGISTRO = :REGISTRO ');
SQL.Add(' AND NOME_FILHO = :NOME_FILHO ');
Params[0].AsString := FCod_Filhos;
Params[1].AsString := FNome_Filho;
Open;
Result := not IsEmpty;
end;
end;
procedure TdmFilhos.MontaSQLBusca(DataSet: TDataSet);
begin
inherited;
end;
procedure TdmFilhos.MontaSQLRefresh;
begin
inherited;
end;
end.
|
unit uSceneDelChar;
interface
uses uScene, Graphics, uGraph, uResFont, uButton;
type
TSceneDelChar = class(TSceneCustom)
private
FBtnPos: ShortInt;
FLogo: TBitmap;
FIsLoad: Boolean;
FGraph: TGraph;
FFont: TResFont;
FBack: TBitmap;
FButton: TButton;
FDelBtn: TButton;
procedure Load;
procedure Del();
procedure Back();
procedure Add(N: string; V: string);
public
//** Конструктор.
constructor Create;
destructor Destroy; override;
procedure Draw(); override;
function MouseDown(Button: TMouseBtn; X, Y: Integer): Boolean; override;
function MouseMove(X, Y: Integer): Boolean; override;
function Click(Button: TMouseBtn): Boolean; override;
function Keys(var Key: Word): Boolean; override;
end;
implementation
uses SysUtils, uSceneMenu, uSceneSellect, uSounds, uUtils, uGUIBorder, uIni, uColors, uSCR, uBox,
uSaveLoad, uVars;
{ TSceneDelChar }
procedure TSceneDelChar.Del;
var
C: Integer;
begin
Sound.PlayClick;
if FileExists(SavePath) then SysUtils.DeleteFile(SavePath);
SceneMenu.Start;
end;
procedure TSceneDelChar.Back;
begin
Sound.PlayClick;
SceneManager.SetScene(SceneSellect);
end;
function TSceneDelChar.Click(Button: TMouseBtn): Boolean;
begin
Result := True;
if FButton.MouseOver then Back();
if FDelBtn.MouseOver then Del();
end;
constructor TSceneDelChar.Create;
begin
FIsLoad := False;
FBtnPos := 0;
end;
destructor TSceneDelChar.Destroy;
begin
FButton.Free;
FDelBtn.Free;
FGraph.Free;
FBack.Free;
FLogo.Free;
FFont.Free;
inherited;
end;
var
Y: Integer;
procedure TSceneDelChar.Add(N: string; V: string);
begin
with FBack.Canvas do
begin
TextOut(500, Y, N);
TextOut((500 + 250) - TextWidth(V), Y, V);
Inc(Y, 20);
end;
end;
procedure TSceneDelChar.Draw;
var
S: string;
begin
if not FIsLoad then Load;
S := 'Вы уверены, что хотите удалить этого персонажа?';
FButton.Sellected := FBtnPos = 0;
FButton.Draw;
FDelBtn.Sellected := FBtnPos = 1;
FDelBtn.Draw;
FBack.Assign(FLogo);
FBack.Canvas.Font.Size := 20;
FBack.Canvas.Font.Style := [fsBold];
FBack.Canvas.Font.Color := cBlackText;
FBack.Canvas.TextOut(400 - (FBack.Canvas.TextWidth(S) div 2), 150, S);
FBack.Canvas.Font.Color := cNormRare;
S := GetSavePCName(SceneSellect.SavePos);
FBack.Canvas.TextOut(500, 270, S);
LoadPCForMenu(S);
FBack.Canvas.Font.Size := 14;
FBack.Canvas.Font.Style := [];
S := VM.GetStr('Hero.RaceName') + ', ' + VM.GetStrInt('Hero.Level') + ' уровень';
FBack.Canvas.TextOut(500, 305, S);
Y := 330;
Add('Побед', VM.GetStrInt('Hero.Kills'));
Add('Поражений', VM.GetStrInt('Hero.Deads'));
Add('Глубина', VM.GetStrInt('Hero.Deep'));
Add('Шаги', VM.GetStrInt('Hero.Step'));
SCR.BG.Canvas.Draw(0, 0, FBack);
end;
function TSceneDelChar.Keys(var Key: Word): Boolean;
begin
TransKeys(Key);
Result := True;
case Key of
13: if (FBtnPos = 0) then Back() else Del();
27: Back();
37, 39:
begin
if (FBtnPos = 0) then FBtnPos := 1
else FBtnPos := 0;
SceneManager.Draw;
end;
end;
end;
procedure TSceneDelChar.Load;
var
FBG: Graphics.TBitmap;
begin
FIsLoad := True;
FGraph := TGraph.Create(Path + 'Data\Images\Screens\');
FFont := TResFont.Create;
FFont.LoadFromFile(Path + 'Data\Fonts\' + Ini.FontName);
FBack := TBitmap.Create;
FBack.Canvas.Brush.Style := bsClear;
FBack.Canvas.Font.Name := FFont.FontName;
FBG := Graphics.TBitmap.Create;
FBG.LoadFromFile('Data\Images\GUI\BG.bmp');
FBG.Height := 190;
FBG.Width := 290;
GUIBorder.Make(FBG);
FLogo := Graphics.TBitmap.Create;
FGraph.LoadImage('Hero.jpg', FLogo);
GUIBorder.Make(FLogo);
FLogo.Canvas.Brush.Style := bsClear;
FLogo.Canvas.Draw(480, 250, FBG);
FButton := TButton.Create(10, 540, FLogo.Canvas, 'Отмена');
FDelBtn := TButton.Create(590, 540, FLogo.Canvas, 'Удалить');
FBG.Free;
end;
function TSceneDelChar.MouseDown(Button: TMouseBtn; X,
Y: Integer): Boolean;
begin
Result := False;
FButton.MouseDown(X, Y);
FDelBtn.MouseDown(X, Y);
SceneManager.Draw;
end;
function TSceneDelChar.MouseMove(X, Y: Integer): Boolean;
begin
Result := False;
FButton.Draw;
FDelBtn.Draw;
SceneManager.Draw;
end;
end.
|
{ Routines that create assignment statement opcodes.
}
module sst_r_syn_assign;
define sst_r_syn_assign_exp;
define sst_r_syn_assign_match;
%include 'sst_r_syn.ins.pas';
{
********************************************************************************
*
* Subroutine SST_R_SYN_ASSIGN_EXP (V, EXP)
*
* Write SST opcode to assign the expression EXP to the variable SYM.
}
procedure sst_r_syn_assign_exp ( {make opcode to assign expression to variable}
in var v: sst_var_t; {variable to assign value to}
in var exp: sst_exp_t); {expression to assign to the variable}
val_param;
begin
sst_opcode_new; {create new blank opcode, make it current}
sst_opc_p^.opcode := sst_opc_assign_k; {set opcode type}
sst_opc_p^.assign_var_p := addr(v); {save pointer to the variable}
sst_opc_p^.assign_exp_p := addr(exp); {save pointer to the expression}
end;
{
********************************************************************************
*
* Subroutine SST_R_SYN_ASSIGN_MATCH (TF)
*
* Write SST opcode to assign the value TF to the local variable MATCH of the
* subroutine being currently defined.
}
procedure sst_r_syn_assign_match ( {make opcode to assign true/false to MATCH}
in tf: boolean); {the value to assign to MATCH}
val_param;
begin
if tf
then begin
sst_r_syn_assign_exp (match_var_p^, exp_true_p^);
end
else begin
sst_r_syn_assign_exp (match_var_p^, exp_false_p^);
end
;
end;
|
unit tfwWordsIterator;
// Модуль: "w:\common\components\rtl\Garant\ScriptEngine\tfwWordsIterator.pas"
// Стереотип: "SimpleClass"
// Элемент модели: "TtfwWordsIterator" MUID: (55ED4D040017)
{$Include w:\common\components\rtl\Garant\ScriptEngine\seDefine.inc}
interface
{$If NOT Defined(NoScripts)}
uses
l3IntfUses
, tfwIteratableParent
, tfwScriptingInterfaces
, tfwWordRefList
;
type
TtfwWordsIterator = class(TtfwIteratableParent, ItfwValueList)
private
f_Words: TtfwWordRefList;
protected
procedure SetItem(anIndex: Integer;
const aValue: TtfwStackValue);
function ItemsCountInSlice: Integer;
procedure Cleanup; override;
{* Функция очистки полей объекта. }
function GetCount: Integer; override;
function GetItem(anIndex: Integer): TtfwStackValue; override;
public
constructor Create(aWords: TtfwWordRefList); reintroduce;
class function Make(aWords: TtfwWordRefList): ItfwValueList; reintroduce;
procedure ForEach(aLambda: TtfwWordPrim;
const aCtx: TtfwContext);
procedure ForEachBack(aLambda: TtfwWordPrim;
const aCtx: TtfwContext);
end;//TtfwWordsIterator
{$IfEnd} // NOT Defined(NoScripts)
implementation
{$If NOT Defined(NoScripts)}
uses
l3ImplUses
, SysUtils
//#UC START# *55ED4D040017impl_uses*
//#UC END# *55ED4D040017impl_uses*
;
constructor TtfwWordsIterator.Create(aWords: TtfwWordRefList);
//#UC START# *55ED4DC20358_55ED4D040017_var*
//#UC END# *55ED4DC20358_55ED4D040017_var*
begin
//#UC START# *55ED4DC20358_55ED4D040017_impl*
inherited Create;
//f_Words := aWords;
aWords.SetRefTo(f_Words);
//#UC END# *55ED4DC20358_55ED4D040017_impl*
end;//TtfwWordsIterator.Create
class function TtfwWordsIterator.Make(aWords: TtfwWordRefList): ItfwValueList;
var
l_Inst : TtfwWordsIterator;
begin
l_Inst := Create(aWords);
try
Result := l_Inst;
finally
l_Inst.Free;
end;//try..finally
end;//TtfwWordsIterator.Make
procedure TtfwWordsIterator.ForEach(aLambda: TtfwWordPrim;
const aCtx: TtfwContext);
//#UC START# *52E23B7A00EC_55ED4D040017_var*
var
l_I : Integer;
//#UC END# *52E23B7A00EC_55ED4D040017_var*
begin
//#UC START# *52E23B7A00EC_55ED4D040017_impl*
if (f_Words <> nil) then
begin
for l_I := 0 to Pred(f_Words.Count) do
begin
aCtx.rEngine.PushObj(f_Words.ItemSlot(l_I)^);
try
aLambda.DoIt(aCtx);
except
on EtfwBreakIterator do
break;
on EtfwBreak do
break;
on EtfwContinue do
continue;
end;//try..except
end;//for l_I
end;//f_Words <> nil
//#UC END# *52E23B7A00EC_55ED4D040017_impl*
end;//TtfwWordsIterator.ForEach
procedure TtfwWordsIterator.ForEachBack(aLambda: TtfwWordPrim;
const aCtx: TtfwContext);
//#UC START# *52E23BB102FA_55ED4D040017_var*
var
l_I : Integer;
//#UC END# *52E23BB102FA_55ED4D040017_var*
begin
//#UC START# *52E23BB102FA_55ED4D040017_impl*
if (f_Words <> nil) then
begin
for l_I := Pred(f_Words.Count) downto 0 do
begin
aCtx.rEngine.PushObj(f_Words.ItemSlot(l_I)^);
try
aLambda.DoIt(aCtx);
except
on EtfwBreakIterator do
break;
on EtfwBreak do
break;
on EtfwContinue do
continue;
end;//try..except
end;//for l_I
end;//f_Words <> nil
//#UC END# *52E23BB102FA_55ED4D040017_impl*
end;//TtfwWordsIterator.ForEachBack
procedure TtfwWordsIterator.SetItem(anIndex: Integer;
const aValue: TtfwStackValue);
//#UC START# *55CDF40C03D4_55ED4D040017_var*
//#UC END# *55CDF40C03D4_55ED4D040017_var*
begin
//#UC START# *55CDF40C03D4_55ED4D040017_impl*
EtfwCheck.Fail('Массив неизменяемый');
//#UC END# *55CDF40C03D4_55ED4D040017_impl*
end;//TtfwWordsIterator.SetItem
function TtfwWordsIterator.ItemsCountInSlice: Integer;
//#UC START# *55E849210175_55ED4D040017_var*
//#UC END# *55E849210175_55ED4D040017_var*
begin
//#UC START# *55E849210175_55ED4D040017_impl*
Result := 1;
//#UC END# *55E849210175_55ED4D040017_impl*
end;//TtfwWordsIterator.ItemsCountInSlice
procedure TtfwWordsIterator.Cleanup;
{* Функция очистки полей объекта. }
//#UC START# *479731C50290_55ED4D040017_var*
//#UC END# *479731C50290_55ED4D040017_var*
begin
//#UC START# *479731C50290_55ED4D040017_impl*
FreeAndNil(f_Words);
//f_Words := nil;
inherited;
//#UC END# *479731C50290_55ED4D040017_impl*
end;//TtfwWordsIterator.Cleanup
function TtfwWordsIterator.GetCount: Integer;
//#UC START# *57C811A30375_55ED4D040017_var*
//#UC END# *57C811A30375_55ED4D040017_var*
begin
//#UC START# *57C811A30375_55ED4D040017_impl*
if (f_Words = nil) then
Result := 0
else
Result := f_Words.Count;
//#UC END# *57C811A30375_55ED4D040017_impl*
end;//TtfwWordsIterator.GetCount
function TtfwWordsIterator.GetItem(anIndex: Integer): TtfwStackValue;
//#UC START# *57C8146602DB_55ED4D040017_var*
//#UC END# *57C8146602DB_55ED4D040017_var*
begin
//#UC START# *57C8146602DB_55ED4D040017_impl*
Result := TtfwStackValue_C(f_Words[anIndex]);
//#UC END# *57C8146602DB_55ED4D040017_impl*
end;//TtfwWordsIterator.GetItem
{$IfEnd} // NOT Defined(NoScripts)
end.
|
unit evSearchWaiter;
// Модуль: "w:\common\components\gui\Garant\Everest\new\evSearchWaiter.pas"
// Стереотип: "SimpleClass"
// Элемент модели: "TevSearchWaiter" MUID: (4EA6A47C0260)
{$Include w:\common\components\gui\Garant\Everest\evDefine.inc}
interface
uses
l3IntfUses
, l3Tool
, nevTools
, l3Variant
;
type
TevSearchWaiter = class(Tl3Tool, InevWaiter)
private
f_Searcher: IevSearcher;
f_FoundBlock: InevDataObjectPrim2;
f_WasFound: Boolean;
f_ChildPara: Tl3Variant;
protected
function TrySelect(const aContainer: InevDocumentContainer): Boolean;
function TrySelectObj(const aContainer: InevDocumentContainer;
aParent: Tl3Variant;
aChild: Tl3Variant): Boolean;
procedure Cleanup; override;
{* Функция очистки полей объекта. }
public
constructor Create(const aControl: InevControl;
const aSearcher: IevSearcher); reintroduce;
class function Make(const aControl: InevControl;
const aSearcher: IevSearcher): InevWaiter;
end;//TevSearchWaiter
implementation
uses
l3ImplUses
, l3Interfaces
, l3Base
, SysUtils
, LeafPara_Const
, evdInterfaces
{$If Defined(k2ForEditor)}
, evParaTools
{$IfEnd} // Defined(k2ForEditor)
, k2Tags
//#UC START# *4EA6A47C0260impl_uses*
//#UC END# *4EA6A47C0260impl_uses*
;
constructor TevSearchWaiter.Create(const aControl: InevControl;
const aSearcher: IevSearcher);
//#UC START# *4EA6A573010B_4EA6A47C0260_var*
//#UC END# *4EA6A573010B_4EA6A47C0260_var*
begin
//#UC START# *4EA6A573010B_4EA6A47C0260_impl*
inherited Create(aControl As Il3ToolOwner);
f_Searcher := aSearcher;
f_FoundBlock := nil;
f_WasFound := False;
f_ChildPara := nil;
//#UC END# *4EA6A573010B_4EA6A47C0260_impl*
end;//TevSearchWaiter.Create
class function TevSearchWaiter.Make(const aControl: InevControl;
const aSearcher: IevSearcher): InevWaiter;
//#UC START# *4EA6A5C500A2_4EA6A47C0260_var*
var
l_Waiter : TevSearchWaiter;
//#UC END# *4EA6A5C500A2_4EA6A47C0260_var*
begin
//#UC START# *4EA6A5C500A2_4EA6A47C0260_impl*
l_Waiter := Create(aControl, aSearcher);
try
Result := l_Waiter;
finally
l3Free(l_Waiter);
end;//try..finally
//#UC END# *4EA6A5C500A2_4EA6A47C0260_impl*
end;//TevSearchWaiter.Make
function TevSearchWaiter.TrySelect(const aContainer: InevDocumentContainer): Boolean;
//#UC START# *47C6B3040133_4EA6A47C0260_var*
var
l_Sel : InevSelection;
l_Para : InevPara;
l_NewPt : InevPoint;
l_Start : InevBasePoint;
l_Finish : InevBasePoint;
l_NewSel : InevRange;
l_Control : InevControl;
//#UC END# *47C6B3040133_4EA6A47C0260_var*
begin
//#UC START# *47C6B3040133_4EA6A47C0260_impl*
if (f_Owner = nil) then
// - все уже нигде не надо позиционироваться
Result := True
else
if f_FoundBlock <> nil then
begin
l_Control := (IUnknown(f_Owner) As InevControl);
l_Sel := l_Control.Selection;
if (l_Sel = nil) then
Result := False
else
begin
if (f_ChildPara <> nil) and f_ChildPara.QT(InevObject, l_Para) then
begin
l_NewPt := l_Para.OwnerPara.MakePoint;
l_NewPt.SetEntryPoint(l_Para.PID + 1);
l_Start := l_NewPt.ClonePoint(l_Control.View).Inner;
l_Start.SetEntryPoint(f_FoundBlock.Borders.rStart);
l_Start := l_Start.PointToParent;
l_Finish := l_NewPt.ClonePoint(l_Control.View).Inner;
l_Finish.SetEntryPoint(f_FoundBlock.Borders.rFinish);
l_Finish := l_Finish.PointToParent;
l_NewSel := l_Sel.GetBlock;
(l_NewSel as InevRangeFactory).Init(l_Start, l_Finish);
l_Sel.Select(l_NewSel, false);
end; // if l_Handle > 0 then
Result := True;
end;
end;
//#UC END# *47C6B3040133_4EA6A47C0260_impl*
end;//TevSearchWaiter.TrySelect
function TevSearchWaiter.TrySelectObj(const aContainer: InevDocumentContainer;
aParent: Tl3Variant;
aChild: Tl3Variant): Boolean;
//#UC START# *47C6B30F0277_4EA6A47C0260_var*
var
l_Sel : InevSelection;
l_Para : InevObject;
l_OutPara : InevObject;
l_FoundBlock : IevdDataObject;
//#UC END# *47C6B30F0277_4EA6A47C0260_var*
begin
//#UC START# *47C6B30F0277_4EA6A47C0260_impl*
Result := False;
if (f_Owner = nil) then
// - все уже нигде не надо позиционироваться
Result := True
else
begin
Result := False;
if not f_WasFound and (f_Searcher <> nil) AND aChild.IsKindOf(k2_typLeafPara) then
if aChild.QT(InevObject, l_Para) then
try
if evSearchPara(l_Para, f_Searcher, l_OutPara, False, @l_FoundBlock) then
begin
f_ChildPara := aChild;
f_FoundBlock := l_FoundBlock As InevDataObjectPrim2;
f_WasFound := True;
end; // if evSearchPara(l_Para, f_Searcher, l_OutPara, False, @l_FoundBlock) then
finally
l_Para := nil;
end//try..finally
else
Assert(false);
end;
//#UC END# *47C6B30F0277_4EA6A47C0260_impl*
end;//TevSearchWaiter.TrySelectObj
procedure TevSearchWaiter.Cleanup;
{* Функция очистки полей объекта. }
//#UC START# *479731C50290_4EA6A47C0260_var*
//#UC END# *479731C50290_4EA6A47C0260_var*
begin
//#UC START# *479731C50290_4EA6A47C0260_impl*
f_Searcher := nil;
f_FoundBlock := nil;
f_WasFound := False;
f_ChildPara := nil;
inherited;
//#UC END# *479731C50290_4EA6A47C0260_impl*
end;//TevSearchWaiter.Cleanup
end.
|
(*
Datatype Test
Michael Neuhold
31.10.2018
some tests with scalar datatypes
*)
PROGRAM DTTest;
TYPE
MyChars = 'a'..'e';
Color = (green, blue, organge, red);
VAR
ch: CHAR;
ch2: MyChars;
ch3: 'a'..'e'; // Implizite Typdefinition
col: Color;
rVal: REAL;
iVal: INTEGER;
s : STRING;
s2 : STRING;
BEGIN
ch := 'a';
WriteLn(ch);
ch2 := 'a'; (* mit zb. g funktioniert die Ausgabe es nicht, da g auserhalb der range liegt.*)
WriteLn(ch2);
ch3 := 'a';
WriteLn(ch3);
ch := ch2; (* Dürfte eigentlich nicht gehen, da die zwei Datentypen zwei unterschiedliche Namen haben. *)
ch := ch3; (* Dürfte auch nicht funktionieren. *)
col := red;
WriteLn(col);
IF col < organge THEN
WriteLn('is smaller')
ELSE
WriteLn('is not smaller');
WriteLn('Ordinalzahl von red: ', Ord(red));
WriteLn('Ordinalzahl von ch: ', Ord(ch));
WriteLn('Ordinalzahl von ch: ', Succ(ch));
WriteLn('Ordinalzahl von ch: ', Pred(ch));
WriteLn('Kleinster ch: ', Low(ch));
WriteLn('Größtes ch: ', High(ch));
WriteLn('Größtes integer: ', High(Integer));
(* DIV ist die Ganzzahlinge Division *)
iVal := 11 DIV 2; (* DIV ist nur für INTEGER definiert (ERROR für REAL Werte) *)
WriteLn('iVal: ',iVal);
(* Division mit Nachkommastellen *)
rVal := 11/2;
WriteLn('rVal: ',rVal:4:2);
(* Divisionsrestwert *)
iVal := 11 MOD 2;
WriteLn('iVal: ',iVal);
(* String Ausgaben: *)
s := 'Hagenberg ist ';
s2 := 'nice';
WriteLn('Ausgabe eines String: ', s + s2);
END. (*DTTest*) |
{ *************************************************************************** }
{ SynWebEnv.pas is the 1st file of SynBroker Project }
{ by c5soft@189.cn Version 0.9.0.0 2018-5-27 }
{ *************************************************************************** }
unit SynWebEnv;
interface
uses Classes, SynCommons, SynCrtSock;
type
TSynWebEnv = class
protected
FHost, FMethod, FURL, FPathInfo, FQueryString, FAnchor: RawUTF8;
FRemoteIP: string;
FContext: THttpServerRequest;
function PrepareURL: RawUTF8; virtual;
public
property Context: THttpServerRequest read FContext;
property Host: RawUTF8 read FHost;
property Method: RawUTF8 read FMethod;
property URL: RawUTF8 read FURL;
property PathInfo: RawUTF8 read FPathInfo;
property QueryString: RawUTF8 read FQueryString;
property Anchor: RawUTF8 read FAnchor;
property RemoteIP: string read FRemoteIP;
function GetHeader(const AUpKey: RawUTF8; const ASource: RawUTF8 = ''; const Sep: AnsiChar = #13): RawUTF8;
constructor Create(const AContext: THttpServerRequest);
procedure OutStream(const AStream: TStream);
procedure OutFile(const AFileName: string);
procedure OutHeader(const ANewHeaderAppended: RawUTF8);
procedure OutJSon(const AOutput: PDocVariantData); overload;
procedure OutJSon(const AOutput: RawUTF8); overload;
{$IFDEF UNICODE}
procedure OutHtml(const AOutput: RawUTF8); overload;
procedure OutHtml(const AOutput: string); overload;
procedure OutXML(const AOutput: RawUTF8); overload;
procedure OutXML(const AOutput: string); overload;
{$ELSE}
procedure OutHtml(const AOutput: string); overload;
procedure OutXML(const AOutput: string); overload;
{$ENDIF}
end;
implementation
{ TSynWebEnv }
function InferContentType(const AFileName: string): RawUTF8;
var
pFileName: PUTF8Char;
begin
Result := '';
pFileName := PUTF8Char(StringToUTF8(AFileName));
if IdemFileExt(pFileName, '.HTML') or IdemFileExt(pFileName, '.HTM') then Result := HTML_CONTENT_TYPE
else if IdemFileExt(pFileName, '.JPG') then Result := JPEG_CONTENT_TYPE
else if IdemFileExt(pFileName, '.PNG') then Result := 'image/png'
else if IdemFileExt(pFileName, '.GIF') then Result := 'image/gif'
else if IdemFileExt(pFileName, '.ICO') then Result := 'image/x-icon'
else if IdemFileExt(pFileName, '.JS') then Result := 'application/x-javascript'
else if IdemFileExt(pFileName, '.CSS') then Result := 'text/css'
else Result := 'application/octet-stream';
end;
{$IFDEF UNICODE}
procedure TSynWebEnv.OutHtml(const AOutput: string);
begin
OutHtml(StringToUTF8(AOutput));
end;
procedure TSynWebEnv.OutHtml(const AOutput: RawUTF8);
begin
Context.OutContent := AOutput;
Context.OutContentType := 'text/html; charset=utf-8';
end;
procedure TSynWebEnv.OutXML(const AOutput: string);
begin
OutXML(StringToUTF8(AOutput));
end;
procedure TSynWebEnv.OutXML(const AOutput: RawUTF8);
begin
Context.OutContent := AOutput;
Context.OutContentType := 'text/xml; charset=utf-8';
end;
{$ELSE}
procedure TSynWebEnv.OutHtml(const AOutput: string);
begin
Context.OutContent := StringToUTF8(AOutput);
Context.OutContentType := 'text/html; charset=utf-8';
end;
procedure TSynWebEnv.OutXML(const AOutput: string);
begin
Context.OutContent := StringToUTF8(AOutput);
Context.OutContentType := 'text/xml; charset=utf-8';
end;
{$ENDIF}
procedure TSynWebEnv.OutJSon(const AOutput: PDocVariantData);
begin
OutJSon(AOutput.ToJson);
end;
procedure TSynWebEnv.OutJSon(const AOutput: RawUTF8);
begin
Context.OutContent := AOutput;
Context.OutContentType := 'application/json; charset=utf-8';
end;
procedure TSynWebEnv.OutHeader(const ANewHeaderAppended: RawUTF8);
begin
if Length(ANewHeaderAppended) > 0 then begin
with FContext do begin
if Length(OutCustomHeaders) > 0 then OutCustomHeaders := OutCustomHeaders + #13#10;
OutCustomHeaders := OutCustomHeaders + ANewHeaderAppended;
end;
end;
end;
procedure TSynWebEnv.OutFile(const AFileName: string);
var
ContentType: RawUTF8;
begin
Context.OutContent := StringToUTF8(AFileName);
Context.OutContentType := HTTP_RESP_STATICFILE;
ContentType := InferContentType(AFileName);
if Length(ContentType) > 0 then OutHeader(HEADER_CONTENT_TYPE + ContentType);
end;
function TSynWebEnv.GetHeader(const AUpKey: RawUTF8; const ASource: RawUTF8 = ''; const Sep: AnsiChar = #13): RawUTF8;
var
P, pUpKey, pSource: PUTF8Char;
cVal: RawUTF8;
begin
pUpKey := PUTF8Char(AUpKey);
if ASource = '' then pSource := PUTF8Char(FContext.InHeaders)
else pSource := PUTF8Char(ASource);
P := StrPosI(pUpKey, pSource);
if IdemPCharAndGetNextItem(P, pUpKey, cVal, Sep) then Result := Trim(cVal)
else Result := '';
end;
constructor TSynWebEnv.Create(const AContext: THttpServerRequest);
var
nQPos, nAPos: Integer;
begin
FContext := AContext;
FHost := GetHeader('HOST:');
FRemoteIP := UTF8ToString(GetHeader('REMOTEIP:'));
FMethod := FContext.Method;
FURL := PrepareURL;
nAPos := {$IFDEF UNICODE}SynCommons.Pos{$ELSE}Pos{$ENDIF}('#', FURL);
nQPos := {$IFDEF UNICODE}SynCommons.Pos{$ELSE}Pos{$ENDIF}('?', FURL);
if nQPos > 0 then begin
FPathInfo := copy(FURL, 1, nQPos - 1);
if nAPos > nQPos then begin
FQueryString := copy(FURL, nQPos + 1, nAPos - nQPos - 1);
FAnchor := copy(FURL, nAPos + 1, Length(FURL) - nAPos);
end else begin
FQueryString := copy(FURL, nQPos + 1, Length(FURL) - nQPos);
FAnchor := '';
end;
end else begin
FQueryString := '';
if nAPos > 0 then begin
FPathInfo := copy(FURL, 1, nAPos - 1);
FAnchor := copy(FURL, nAPos + 1, Length(FURL) - nAPos);
end else begin
FPathInfo := FURL;
FAnchor := '';
end;
end;
end;
function TSynWebEnv.PrepareURL: RawUTF8;
begin
Result := Context.URL;
end;
procedure TSynWebEnv.OutStream(const AStream: TStream);
var
Buffer: SockString;
begin
SetLength(Buffer, AStream.Size);
AStream.Read(Buffer[1], AStream.Size);
Context.OutContent := Buffer;
end;
end.
|
{
Copyright (C) 2013-2021 Tim Sinaeve tim.sinaeve@gmail.com
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.
}
unit ts.RichEditor.Events;
{$MODE DELPHI}
interface
uses
Classes, SysUtils,
ts.RichEditor.Types, ts.RichEditor.Interfaces;
type
{ TRichEditorEvents }
TRichEditorEvents = class(TInterfacedObject, IRichEditorEvents)
private
FManager : IRichEditorManager;
FOnNew : TNewEvent;
FOnLoad : TStorageEvent;
FOnOpen : TStorageEvent;
FOnBeforeSave : TStorageEvent;
FOnAfterSave : TStorageEvent;
FOnSave : TStorageEvent;
FOnChange : TNotifyEvent;
{$REGION 'property access mehods'}
function GetOnAfterSave: TStorageEvent;
function GetOnBeforeSave: TStorageEvent;
function GetOnChange: TNotifyEvent;
function GetOnLoad: TStorageEvent;
function GetOnNew: TNewEvent;
function GetOnOpen: TStorageEvent;
function GetOnSave: TStorageEvent;
function GetView: IRichEditorView;
procedure SetOnAfterSave(AValue: TStorageEvent);
procedure SetOnBeforeSave(AValue: TStorageEvent);
procedure SetOnChange(AValue: TNotifyEvent);
procedure SetOnLoad(AValue: TStorageEvent);
procedure SetOnNew(AValue: TNewEvent);
procedure SetOnOpen(AValue: TStorageEvent);
procedure SetOnSave(AValue: TStorageEvent);
{$ENDREGION}
protected
// event dispatch methods
procedure DoChange;
procedure DoOpen(const AName: string);
procedure DoBeforeSave(const AName: string);
procedure DoAfterSave(const AName: string);
procedure DoLoad(const AName: string);
procedure DoNew(
const AName : string = '';
const AText : string = ''
);
property View: IRichEditorView
read GetView;
public
constructor Create(AManager: IRichEditorManager);
destructor Destroy; override;
{ triggered when caret position changes }
property OnChange: TNotifyEvent
read GetOnChange write SetOnChange;
property OnLoad: TStorageEvent
read GetOnLoad write SetOnLoad;
property OnSave: TStorageEvent
read GetOnSave write SetOnSave;
property OnNew: TNewEvent
read GetOnNew write SetOnNew;
property OnOpen: TStorageEvent
read GetOnOpen write SetOnOpen;
property OnBeforeSave: TStorageEvent
read GetOnBeforeSave write SetOnBeforeSave;
property OnAfterSave: TStorageEvent
read GetOnAfterSave write SetOnAfterSave;
end;
implementation
{$REGION 'construction and destruction'}
constructor TRichEditorEvents.Create(AManager: IRichEditorManager);
begin
inherited Create;
FManager := AManager;
end;
destructor TRichEditorEvents.Destroy;
begin
FManager := nil;
inherited Destroy;
end;
{$ENDREGION}
{$REGION 'property access mehods'}
function TRichEditorEvents.GetOnAfterSave: TStorageEvent;
begin
Result := FOnAfterSave;
end;
function TRichEditorEvents.GetOnBeforeSave: TStorageEvent;
begin
Result := FOnBeforeSave;
end;
function TRichEditorEvents.GetOnChange: TNotifyEvent;
begin
Result := FOnChange;
end;
function TRichEditorEvents.GetOnLoad: TStorageEvent;
begin
Result := FOnLoad;
end;
function TRichEditorEvents.GetOnNew: TNewEvent;
begin
Result := FOnNew;
end;
function TRichEditorEvents.GetOnOpen: TStorageEvent;
begin
Result := FOnOpen;
end;
function TRichEditorEvents.GetOnSave: TStorageEvent;
begin
Result := FOnSave;
end;
procedure TRichEditorEvents.SetOnSave(AValue: TStorageEvent);
begin
FOnSave := AValue;
end;
function TRichEditorEvents.GetView: IRichEditorView;
begin
Result := FManager as IRichEditorView;
end;
procedure TRichEditorEvents.SetOnAfterSave(AValue: TStorageEvent);
begin
FOnAfterSave := AValue;
end;
procedure TRichEditorEvents.SetOnBeforeSave(AValue: TStorageEvent);
begin
FOnBeforeSave := AValue;
end;
procedure TRichEditorEvents.SetOnChange(AValue: TNotifyEvent);
begin
FOnChange := AValue;
end;
procedure TRichEditorEvents.SetOnLoad(AValue: TStorageEvent);
begin
FOnLoad := AValue;
end;
procedure TRichEditorEvents.SetOnNew(AValue: TNewEvent);
begin
FOnNew := AValue;
end;
procedure TRichEditorEvents.SetOnOpen(AValue: TStorageEvent);
begin
FOnOpen := AValue;
end;
{$ENDREGION}
{$REGION 'event dispatch methods'}
procedure TRichEditorEvents.DoChange;
begin
if Assigned(FOnChange) then
FOnChange(Self);
end;
procedure TRichEditorEvents.DoOpen(const AName: string);
var
S : string;
begin
S := AName;
if Assigned(FOnOpen) then
FOnOpen(Self, S);
end;
procedure TRichEditorEvents.DoBeforeSave(const AName: string);
var
S : string;
begin
if Assigned(FOnBeforeSave) then
begin
S := View.FileName;
FOnBeforeSave(Self, S);
end;
end;
procedure TRichEditorEvents.DoAfterSave(const AName: string);
var
S : string;
begin
S := AName;
if Assigned(FOnAfterSave) then
begin
FOnAfterSave(Self, S);
end;
end;
procedure TRichEditorEvents.DoLoad(const AName: string);
var
S : string;
begin
S := AName;
if Assigned(FOnLoad) then
FOnLoad(Self, S);
end;
procedure TRichEditorEvents.DoNew(const AName: string; const AText: string);
var
S : string;
begin
S := AName;
if Assigned(FOnNew) then
FOnNew(Self, S, AText);
end;
{$ENDREGION}
end.
|
unit uSimpleGame;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls,
FMX.Ani, FMX.Layouts;
type
TForm5 = class(TForm)
ship: TLabel;
target: TLabel;
Label1: TLabel;
ShipX: TFloatAnimation;
ShipY: TFloatAnimation;
Label2: TLabel;
TargetX: TFloatAnimation;
TargetY: TFloatAnimation;
StyleBook1: TStyleBook;
lblScore: TLabel;
playArea: TLayout;
procedure FormKeyDown(Sender: TObject; var Key: Word; var KeyChar: Char;
Shift: TShiftState);
procedure ShipXFinish(Sender: TObject);
private
{ Private declarations }
procedure MoveLeft;
procedure MoveRight;
procedure MoveUp;
procedure MoveDown;
procedure HitCheck;
const fMove = 20;
var fScore: Integer;
public
{ Public declarations }
end;
var
Form5: TForm5;
implementation
{$R *.fmx}
procedure TForm5.FormKeyDown(Sender: TObject; var Key: Word; var KeyChar: Char;
Shift: TShiftState);
begin
case Key of
37: MoveLeft;
38: MoveUp;
39: MoveRight;
40: MoveDown;
end;
label1.Text := 'Key: ' + Key.ToString;
end;
procedure TForm5.HitCheck;
var
shipPt, targetPt: TPointF;
distance: Integer;
begin
shipPt := ship.Position.Point;
targetPt := target.Position.Point;
distance := round(shipPt.Distance(targetPt));
label2.Text := 'Dist: ' + round(distance).ToString;
if distance < fMove then
begin
targetX.StartValue := target.Position.X;
targetY.StartValue := target.Position.Y;
targetX.StopValue := Random(round(playArea.width));
targetY.StopValue := Random(round(playArea.height));
targetX.Start;
targetY.Start;
label2.Text := 'Hit!';
fScore := fScore + 1;
lblScore.Text := 'Score: ' + fScore.ToString;
end;
end;
procedure TForm5.MoveDown;
begin
ship.Text := '\/';
if not ShipY.Running then
begin
ShipY.StopValue := ShipY.StopValue + fMove;
ShipY.Start;
end;
end;
procedure TForm5.MoveLeft;
begin
ship.Text := '<';
if not Shipx.Running then
begin
shipX.StopValue := Shipx.StopValue - fMove;
shipX.Start;
end;
end;
procedure TForm5.MoveRight;
begin
ship.Text := '>';
if not Shipx.Running then
begin
shipX.StopValue := Shipx.StopValue + fMove;
shipX.Start;
end;
end;
procedure TForm5.MoveUp;
begin
ship.Text := '/\';
if not ShipY.Running then
begin
ShipY.StopValue := ShipY.StopValue - fMove;
ShipY.Start;
end;
end;
procedure TForm5.ShipXFinish(Sender: TObject);
begin
HitCheck;
end;
end.
|
unit evCellsOffsetsPair;
// Модуль: "w:\common\components\gui\Garant\Everest\evCellsOffsetsPair.pas"
// Стереотип: "SimpleClass"
// Элемент модели: "TevCellsOffsetsPair" MUID: (4F2F6F750263)
{$Include w:\common\components\gui\Garant\Everest\evDefine.inc}
interface
uses
l3IntfUses
, l3ProtoObject
, evCellsCharOffsets
, edCellTypesList
, evEditorInterfacesTypes
, evEditorInterfaces
;
type
TedCellPosType = (
ed_cpNone
, ed_cpLast
, ed_cpIgnoreLast
);//TedCellPosType
TevCellsOffsetsPair = class(Tl3ProtoObject)
private
f_FoundUpper: Boolean;
f_OldOffset: TevCellsCharOffsets;
f_NewOffset: TevCellsCharOffsets;
f_CellsType: TedCellTypesList;
{* Массив с типами содержимого ячеек. }
f_RowType: TedRowType;
private
function CompareWidth(const aOffsetList: TevCellsOffsetsPair;
var l_Delta: Integer): Integer;
function FindUpper(const aOffsetList: TevCellsOffsetsPair;
var l_Delta: Integer): Boolean;
function FindLower(const aOffsetList: TevCellsOffsetsPair;
var anIndex: Integer;
var aDelta: Integer): Boolean;
procedure UpdateNewWidth(anIndex: Integer;
aDelta: Integer);
function FindOffset(const aOffsetList: TevCellsOffsetsPair): Boolean;
protected
procedure Cleanup; override;
{* Функция очистки полей объекта. }
public
constructor Create; reintroduce;
procedure Clear;
procedure AddCellWidthAndRecalc;
function GetOffset(aNew: Boolean): Integer;
function GetWidth(aNew: Boolean): Integer;
function LastNewWidth: Integer;
function PrevNewWidth: Integer;
procedure SetWidthPair(aNewWidth: Integer;
aOldWidth: Integer);
function GetNextOffset(aNew: Boolean): Integer;
function EqualCells(const anIterator: IedCellsIterator): Boolean;
function GetRowWidth(aNew: Boolean): Integer;
procedure CheckCurrentRow(aList: TevCellsOffsetsPair;
aNewWidth: Integer;
anOldCellWidth: Integer;
aPrevRowWidth: Integer;
aCelPosl: TedCellPosType;
out aNeedBreak: Boolean);
procedure AlignByPrevious(const aData: TevCellsOffsetsPair);
procedure CopyData(aData: TevCellsCharOffsets;
const anIterator: IedCellsIterator); overload;
procedure CopyData(const aData: TevCellsOffsetsPair;
const anIterator: IedCellsIterator); overload;
procedure CheckPrevAlignment(const aPrev: TevCellsOffsetsPair);
public
property CellsType: TedCellTypesList
read f_CellsType
write f_CellsType;
{* Массив с типами содержимого ячеек. }
property RowType: TedRowType
read f_RowType
write f_RowType;
end;//TevCellsOffsetsPair
implementation
uses
l3ImplUses
, l3UnitsTools
, SysUtils
//#UC START# *4F2F6F750263impl_uses*
//#UC END# *4F2F6F750263impl_uses*
;
constructor TevCellsOffsetsPair.Create;
//#UC START# *4F2F7030001E_4F2F6F750263_var*
//#UC END# *4F2F7030001E_4F2F6F750263_var*
begin
//#UC START# *4F2F7030001E_4F2F6F750263_impl*
inherited Create;
f_RowType := ed_rtNull;
f_OldOffset := TevCellsCharOffsets.Create;
f_NewOffset := TevCellsCharOffsets.Create;
//#UC END# *4F2F7030001E_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.Create
procedure TevCellsOffsetsPair.Clear;
//#UC START# *4F2F704A01F8_4F2F6F750263_var*
//#UC END# *4F2F704A01F8_4F2F6F750263_var*
begin
//#UC START# *4F2F704A01F8_4F2F6F750263_impl*
if f_NewOffset <> nil then
f_NewOffset.Clear;
if (f_OldOffset <> nil) then
f_OldOffset.Clear;
f_FoundUpper := False;
//#UC END# *4F2F704A01F8_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.Clear
procedure TevCellsOffsetsPair.AddCellWidthAndRecalc;
//#UC START# *4F2F70660228_4F2F6F750263_var*
//#UC END# *4F2F70660228_4F2F6F750263_var*
begin
//#UC START# *4F2F70660228_4F2F6F750263_impl*
f_OldOffset.AddCellWidthAndRecalc;
f_NewOffset.AddCellWidthAndRecalc;
//#UC END# *4F2F70660228_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.AddCellWidthAndRecalc
function TevCellsOffsetsPair.GetOffset(aNew: Boolean): Integer;
//#UC START# *4F2F708E0299_4F2F6F750263_var*
//#UC END# *4F2F708E0299_4F2F6F750263_var*
begin
//#UC START# *4F2F708E0299_4F2F6F750263_impl*
if aNew then
Result := f_NewOffset.GetOffset
else
Result := f_OldOffset.GetOffset
//#UC END# *4F2F708E0299_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.GetOffset
function TevCellsOffsetsPair.GetWidth(aNew: Boolean): Integer;
//#UC START# *4F2F70B6006A_4F2F6F750263_var*
//#UC END# *4F2F70B6006A_4F2F6F750263_var*
begin
//#UC START# *4F2F70B6006A_4F2F6F750263_impl*
if aNew then
Result := f_NewOffset.GetWidth
else
Result := f_OldOffset.GetWidth
//#UC END# *4F2F70B6006A_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.GetWidth
function TevCellsOffsetsPair.LastNewWidth: Integer;
//#UC START# *4F2F70EB0222_4F2F6F750263_var*
//#UC END# *4F2F70EB0222_4F2F6F750263_var*
begin
//#UC START# *4F2F70EB0222_4F2F6F750263_impl*
Result := f_NewOffset.LastWidth;
//#UC END# *4F2F70EB0222_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.LastNewWidth
function TevCellsOffsetsPair.PrevNewWidth: Integer;
//#UC START# *4F2F710D00D6_4F2F6F750263_var*
//#UC END# *4F2F710D00D6_4F2F6F750263_var*
begin
//#UC START# *4F2F710D00D6_4F2F6F750263_impl*
Result := f_NewOffset.PrevWidth;
//#UC END# *4F2F710D00D6_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.PrevNewWidth
procedure TevCellsOffsetsPair.SetWidthPair(aNewWidth: Integer;
aOldWidth: Integer);
//#UC START# *4F2F712F0179_4F2F6F750263_var*
//#UC END# *4F2F712F0179_4F2F6F750263_var*
begin
//#UC START# *4F2F712F0179_4F2F6F750263_impl*
f_OldOffset.SetWidth(aOldWidth);
f_NewOffset.SetWidth(aNewWidth);
//#UC END# *4F2F712F0179_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.SetWidthPair
function TevCellsOffsetsPair.CompareWidth(const aOffsetList: TevCellsOffsetsPair;
var l_Delta: Integer): Integer;
//#UC START# *4F2F719C01AF_4F2F6F750263_var*
//#UC END# *4F2F719C01AF_4F2F6F750263_var*
begin
//#UC START# *4F2F719C01AF_4F2F6F750263_impl*
Result := f_OldOffset.GetWidth - aOffsetList.f_OldOffset.GetWidth;
l_Delta := f_NewOffset.GetWidth - aOffsetList.f_NewOffset.GetWidth;
if Abs(Result) < evCellWidthEpsilon then
Result := 0;
f_FoundUpper := Result > 0;
//#UC END# *4F2F719C01AF_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.CompareWidth
function TevCellsOffsetsPair.FindUpper(const aOffsetList: TevCellsOffsetsPair;
var l_Delta: Integer): Boolean;
//#UC START# *4F2F71C0015D_4F2F6F750263_var*
//#UC END# *4F2F71C0015D_4F2F6F750263_var*
begin
//#UC START# *4F2F71C0015D_4F2F6F750263_impl*
l_Delta := GetNextOffset(True) - aOffsetList.GetOffset(True);
Result := f_FoundUpper and
(Abs((aOffsetList.GetNextOffset(False) - GetOffset(False)) - GetWidth(False)) < evCellWidthEpsilon);
//#UC END# *4F2F71C0015D_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.FindUpper
function TevCellsOffsetsPair.FindLower(const aOffsetList: TevCellsOffsetsPair;
var anIndex: Integer;
var aDelta: Integer): Boolean;
//#UC START# *4F2F71EF028D_4F2F6F750263_var*
var
l_Offset : Integer;
//#UC END# *4F2F71EF028D_4F2F6F750263_var*
begin
//#UC START# *4F2F71EF028D_4F2F6F750263_impl*
l_Offset := aOffsetList.f_OldOffset.GetNextOffset;
Result := f_OldOffset.FindOffset(l_Offset, anIndex);
if Result then
begin
Dec(anIndex);
f_NewOffset.SetCurrent(anIndex);
l_Offset := aOffsetList.GetNextOffset(True);
aDelta := l_Offset - GetNextOffset(True);
//Result := Abs(aDelta) >= evCellWidthEpsilon;
end; // if Result then
//#UC END# *4F2F71EF028D_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.FindLower
procedure TevCellsOffsetsPair.UpdateNewWidth(anIndex: Integer;
aDelta: Integer);
//#UC START# *4F2F7226039B_4F2F6F750263_var*
//#UC END# *4F2F7226039B_4F2F6F750263_var*
begin
//#UC START# *4F2F7226039B_4F2F6F750263_impl*
f_NewOffset.UpdateWidth(anIndex, aDelta);
//#UC END# *4F2F7226039B_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.UpdateNewWidth
function TevCellsOffsetsPair.GetNextOffset(aNew: Boolean): Integer;
//#UC START# *4F2F7268015A_4F2F6F750263_var*
//#UC END# *4F2F7268015A_4F2F6F750263_var*
begin
//#UC START# *4F2F7268015A_4F2F6F750263_impl*
if aNew then
Result := f_NewOffset.GetNextOffset
else
Result := f_OldOffset.GetNextOffset
//#UC END# *4F2F7268015A_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.GetNextOffset
function TevCellsOffsetsPair.EqualCells(const anIterator: IedCellsIterator): Boolean;
//#UC START# *4F2FABC40294_4F2F6F750263_var*
//#UC END# *4F2FABC40294_4F2F6F750263_var*
begin
//#UC START# *4F2FABC40294_4F2F6F750263_impl*
Result := f_OldOffset.Equals(anIterator);
//#UC END# *4F2FABC40294_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.EqualCells
function TevCellsOffsetsPair.GetRowWidth(aNew: Boolean): Integer;
//#UC START# *4FAB83530326_4F2F6F750263_var*
//#UC END# *4FAB83530326_4F2F6F750263_var*
begin
//#UC START# *4FAB83530326_4F2F6F750263_impl*
if aNew then
Result := f_NewOffset.GetRowWidth
else
Result := f_OldOffset.GetRowWidth;
//#UC END# *4FAB83530326_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.GetRowWidth
procedure TevCellsOffsetsPair.CheckCurrentRow(aList: TevCellsOffsetsPair;
aNewWidth: Integer;
anOldCellWidth: Integer;
aPrevRowWidth: Integer;
aCelPosl: TedCellPosType;
out aNeedBreak: Boolean);
//#UC START# *4FC5F3CF0017_4F2F6F750263_var*
var
l_Delta: Integer;
procedure lp_CorrectUpper(anOnlyPositive: Boolean);
begin
aList.AddCellWidthAndRecalc;
l_Delta := aList.GetOffset(True) - aPrevRowWidth;
if not anOnlyPositive or (l_Delta > 0) then
UpdateNewWidth(-1, l_Delta);
aNeedBreak := True;
end;
var
l_Index : Integer;
l_Compare : Integer;
//#UC END# *4FC5F3CF0017_4F2F6F750263_var*
begin
//#UC START# *4FC5F3CF0017_4F2F6F750263_impl*
aNeedBreak := False;
if FindUpper(aList, l_Delta) then
begin
if (l_Delta > 0) then
if (aList.RowType = ed_rtChessTableRow) and (aCelPosl = ed_cpLast) then
lp_CorrectUpper(False)
else
aList.SetWidthPair(l_Delta, anOldCellWidth)
end // if l_PrevWidthList.FindUpper(aList, l_Delta) then
else
if FindOffset(aList) then
begin
l_Compare := CompareWidth(aList, l_Delta);
if l_Compare = 0 then
begin
if l_Delta <> 0 then
aList.SetWidthPair(aNewWidth + l_Delta, anOldCellWidth);
end // if l_Compare = 0 then
else
if l_Compare < 0 then // возможно охватывающая ячейка...
if aCelPosl > ed_cpNone then
begin
if aCelPosl = ed_cpLast then
lp_CorrectUpper(True)
end // if l_Cell = nil then
else
if FindLower(aList, l_Index, l_Delta) then
aList.SetWidthPair(aNewWidth - l_Delta, anOldCellWidth)
end; // if FindOffset(aList) then
//#UC END# *4FC5F3CF0017_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.CheckCurrentRow
function TevCellsOffsetsPair.FindOffset(const aOffsetList: TevCellsOffsetsPair): Boolean;
//#UC START# *4F2F716F0249_4F2F6F750263_var*
var
l_Index: Integer;
//#UC END# *4F2F716F0249_4F2F6F750263_var*
begin
//#UC START# *4F2F716F0249_4F2F6F750263_impl*
Result := f_OldOffset <> nil;
if Result then
begin
Result := f_OldOffset.FindOffset(aOffsetList.f_OldOffset, l_Index);
if Result then
f_NewOffset.SetCurrent(l_Index);
end; // if Result then
//#UC END# *4F2F716F0249_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.FindOffset
procedure TevCellsOffsetsPair.AlignByPrevious(const aData: TevCellsOffsetsPair);
//#UC START# *4FC76FA7005D_4F2F6F750263_var*
//#UC END# *4FC76FA7005D_4F2F6F750263_var*
begin
//#UC START# *4FC76FA7005D_4F2F6F750263_impl*
f_NewOffset.AlignByPrevious(aData.f_NewOffset);
//#UC END# *4FC76FA7005D_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.AlignByPrevious
procedure TevCellsOffsetsPair.CopyData(aData: TevCellsCharOffsets;
const anIterator: IedCellsIterator);
//#UC START# *50925F0800F6_4F2F6F750263_var*
//#UC END# *50925F0800F6_4F2F6F750263_var*
begin
//#UC START# *50925F0800F6_4F2F6F750263_impl*
f_OldOffset.CopyData(aData, anIterator);
f_NewOffset.CopyData(aData, nil);
//#UC END# *50925F0800F6_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.CopyData
procedure TevCellsOffsetsPair.CopyData(const aData: TevCellsOffsetsPair;
const anIterator: IedCellsIterator);
//#UC START# *528DED3F007E_4F2F6F750263_var*
//#UC END# *528DED3F007E_4F2F6F750263_var*
begin
//#UC START# *528DED3F007E_4F2F6F750263_impl*
f_OldOffset.CopyData(aData.f_OldOffset, anIterator);
f_NewOffset.CopyData(aData.f_NewOffset, nil);
//#UC END# *528DED3F007E_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.CopyData
procedure TevCellsOffsetsPair.CheckPrevAlignment(const aPrev: TevCellsOffsetsPair);
//#UC START# *52F1EFF800A6_4F2F6F750263_var*
var
l_Index : Integer;
l_NeedAlign : Boolean;
l_PrevIndex : Integer;
l_PrevOffset: Integer;
//#UC END# *52F1EFF800A6_4F2F6F750263_var*
begin
//#UC START# *52F1EFF800A6_4F2F6F750263_impl*
if (aPrev <> nil) and (aPrev.RowType = ed_rtSimpleCells) and (RowType = ed_rtSimpleCells) then
begin
l_Index := 0;
while l_Index < f_OldOffset.GetCount do
begin
if f_CellsType[l_Index] <> ed_ctEmptyAndNotFramed then
begin
aPrev.f_OldOffset.FindOffset(f_OldOffset.GetOffsetByIndex(l_Index), l_PrevIndex);
if (l_PrevIndex > -1) then
begin
l_PrevOffset := aPrev.f_NewOffset.GetOffsetByIndex(l_PrevIndex);
if (aPrev.f_OldOffset.GetOffsetByIndex(l_PrevIndex) = f_OldOffset.GetOffsetByIndex(l_Index)) and
(aPrev.CellsType[l_PrevIndex] <> ed_ctEmptyAndNotFramed) and
(l_PrevOffset <> f_NewOffset.GetOffsetByIndex(l_Index)) then
begin
f_NewOffset.AlignByOffset(l_PrevOffset, l_Index, f_CellsType);
end;
end; // if (l_PrevIndex > -1) then
end; // if f_CellsType[l_Index] <> ed_EmptyAndNotFramed then
Inc(l_Index);
end; // while l_Index < f_NewOffset.GetCount do
end; // if (aPrev.RowType = ed_SimpleCells) and (RowType = ed_SimpleCells) then
//#UC END# *52F1EFF800A6_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.CheckPrevAlignment
procedure TevCellsOffsetsPair.Cleanup;
{* Функция очистки полей объекта. }
//#UC START# *479731C50290_4F2F6F750263_var*
//#UC END# *479731C50290_4F2F6F750263_var*
begin
//#UC START# *479731C50290_4F2F6F750263_impl*
if f_OldOffset <> nil then
f_OldOffset.Clear;
FreeAndNil(f_OldOffset);
if f_NewOffset <> nil then
f_NewOffset.Clear;
FreeAndNil(f_NewOffset);
if f_CellsType <> nil then
f_CellsType.Clear;
FreeAndNil(f_CellsType);
f_RowType := ed_rtNull;
inherited;
//#UC END# *479731C50290_4F2F6F750263_impl*
end;//TevCellsOffsetsPair.Cleanup
end.
|
{$I OVC.INC}
unit ExMove1;
interface
uses
Controls, Classes, Forms, Dialogs, SysUtils, StdCtrls,
OvcBase, OvcNbk, OvcEf, OvcSf, OvcNf, OvcPb, OvcPf,
OvcAe, OvcMeter, OvcSc;
{$IFNDEF MoveableComponents}
*** This example requires "MoveableComponents" to be defined in the ***
*** OVC.INC file. ***
{$ENDIF}
type
TForm1 = class(TForm)
OvcSimpleField1: TOvcSimpleField;
OvcPictureField1: TOvcPictureField;
OvcNumericField1: TOvcNumericField;
OvcSimpleArrayEditor1: TOvcSimpleArrayEditor;
Button1: TButton;
OvcSimpleField2: TOvcSimpleField;
OvcController1: TOvcController;
OvcMeter1: TOvcMeter;
OvcSpinner1: TOvcSpinner;
OvcNotebook1: TOvcNotebook;
OvcSimpleField3: TOvcSimpleField;
procedure Button1Click(Sender: TObject);
procedure ControlMove(Sender: TObject);
private
{ Private declarations }
HoldCaption : string;
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
begin
with OvcController1 do begin
AllowMove := not AllowMove;
OnControlMove := ControlMove;
if AllowMove then begin
HoldCaption := Caption;
Button1.Caption := 'Disable Move';
end else begin
Caption := HoldCaption;
Button1.Caption := 'Enable Move';
{*** would probably save the position of the components here ***}
end;
end;
end;
procedure TForm1.ControlMove(Sender : TObject);
var
C : TCustomControl;
begin
C := Sender as TCustomControl;
Caption := Format(HoldCaption + ' - %s (%d:%d)', [C.Name, C.Left, C.Top]);
end;
end.
|
{ *********************************************************** }
{ }
{ CodeGear Delphi Runtime Library }
{ }
{ Copyright(c) 2012-2014 Embarcadero Technologies, Inc. }
{ }
{ *********************************************************** }
//
// Delphi-Objective-C Bridge
// Interfaces for Cocoa framework BaiduMapAPI_Location
//
unit iOSapi.BaiduMapAPI_Location;
interface
uses
Macapi.CoreFoundation,
Macapi.CoreServices,
Macapi.Dispatch,
Macapi.Mach,
Macapi.ObjCRuntime,
Macapi.ObjectiveC,
iOSapi.BaiduMapAPI_Base,
iOSapi.CocoaTypes,
iOSapi.CoreLocation,
iOSapi.Foundation;
type
// ===== Forward declarations =====
{$M+}
BMKLocationServiceDelegate = interface;
BMKLocationService = interface;
// ===== Framework typedefs =====
{$M+}
// ===== Interface declarations =====
BMKLocationServiceClass = interface(NSObjectClass)
['{68E0D760-79BF-49DC-9E2A-30BB275617C2}']
{ class } procedure setLocationDistanceFilter(distanceFilter
: CLLocationDistance); cdecl;
{ class } function getCurrentLocationDistanceFilter
: CLLocationDistance; cdecl;
{ class } procedure setLocationDesiredAccuracy(desiredAccuracy
: CLLocationAccuracy); cdecl;
{ class } function getCurrentLocationDesiredAccuracy
: CLLocationAccuracy; cdecl;
end;
BMKLocationService = interface(NSObject)
['{07B048E3-7F0F-445D-8D88-7C66A9E64C35}']
function userLocation: BMKUserLocation; cdecl;
procedure setDelegate(delegate: Pointer); cdecl;
function delegate: Pointer; cdecl;
procedure startUserLocationService; cdecl;
procedure stopUserLocationService; cdecl;
procedure setDistanceFilter(distanceFilter: CLLocationDistance); cdecl;
function distanceFilter: CLLocationDistance; cdecl;
procedure setDesiredAccuracy(desiredAccuracy: CLLocationAccuracy); cdecl;
function desiredAccuracy: CLLocationAccuracy; cdecl;
procedure setHeadingFilter(headingFilter: CLLocationDegrees); cdecl;
function headingFilter: CLLocationDegrees; cdecl;
procedure setPausesLocationUpdatesAutomatically
(pausesLocationUpdatesAutomatically: Boolean); cdecl;
function pausesLocationUpdatesAutomatically: Boolean; cdecl;
procedure setAllowsBackgroundLocationUpdates(allowsBackgroundLocationUpdates
: Boolean); cdecl;
function allowsBackgroundLocationUpdates: Boolean; cdecl;
end;
TBMKLocationService = class(TOCGenericImport<BMKLocationServiceClass,
BMKLocationService>)
end;
PBMKLocationService = Pointer;
// ===== Protocol declarations =====
BMKLocationServiceDelegate = interface(IObjectiveC)
['{0318E275-A978-4FF8-BCD5-825B88D73605}']
procedure willStartLocatingUser; cdecl;
procedure didStopLocatingUser; cdecl;
procedure didUpdateUserHeading(userLocation: BMKUserLocation); cdecl;
procedure didUpdateBMKUserLocation(userLocation: BMKUserLocation); cdecl;
procedure didFailToLocateUserWithError(error: NSError); cdecl;
end;
// ===== External functions =====
const
libBaiduMapAPI_Location =
'/System/Library/Frameworks/BaiduMapAPI_Location.framework/BaiduMapAPI_Location';
function BMKGetMapApiLocationComponentVersion: Pointer { NSString }; cdecl;
external libBaiduMapAPI_Location name _PU +
'BMKGetMapApiLocationComponentVersion';
function BMKCheckLocationComponentIsLegal: Boolean; cdecl;
external libBaiduMapAPI_Location name _PU +
'BMKCheckLocationComponentIsLegal';
implementation
{$IF defined(IOS) and NOT defined(CPUARM)}
uses
Posix.Dlfcn;
var
BaiduMapAPI_LocationModule: THandle;
{$ENDIF IOS}
{$IF defined(IOS) and NOT defined(CPUARM)}
initialization
BaiduMapAPI_LocationModule := dlopen(MarshaledAString(libBaiduMapAPI_Location),
RTLD_LAZY);
finalization
dlclose(BaiduMapAPI_LocationModule);
{$ENDIF IOS}
end.
|
unit Display;
// TDisplay handles, list and change between disp modes, (c) merchise, hcg
interface
uses
Windows;
type // we just keep a part of the DEVMODE structure (the usefull one)
TDispInfo =
packed record
BitsPerPel : DWORD;
PelsWidth : DWORD;
PelsHeight : DWORD;
DisplayFlags : DWORD;
DisplayFrequency : DWORD;
end;
type
TDispInfoArray = array of TDispInfo;
type
TDisplay =
class
private
fSupportedModes : TDispInfoArray;
fSupportedModeCount : cardinal;
private
fModesEnumerated : boolean;
fRestartAllowed : boolean;
fTestBeforeChange : boolean;
private
fCurrentModeKnown : boolean;
fCurrentModeIndex : cardinal; // Valid only if running on NT
protected
constructor Create(const EnumModes : boolean); // Can not be created by you. Call CreateDisplay instead
public
destructor Destroy; override;
public
procedure EnumSupportedModes;
function SetDispMode(const aMode : TDispInfo; var ExtendedResult : longint) : boolean; overload;
function SetDispMode(const aIndex : cardinal; var ExtendedResult : longint) : boolean; overload;
function Reset : boolean;
public // be carefull, use wisely, you can freeze the system (in win9x)
function SetDispModeEx(const aMode : TDispInfo; const aFlags : DWORD; var ExtendedResult : longint) : boolean; overload;
function SetDispModeEx(const aIndex : cardinal; const aFlags : DWORD; var ExtendedResult : longint) : boolean; overload;
public
function GetCurrentModeIndex(var aIndex : cardinal) : boolean;
public
function IndexOf(const aMode : TDispInfo) : cardinal;
private
function DispInfoFromDevMode(const aMode : DEVMODE) : TDispInfo;
procedure NewDispMode(const aMode : DEVMODE);
function ChangeDispMode(const aIndex : cardinal; const aFlags : DWORD) : longint;
function ObtainCurrentModeIndex(var aIndex : cardinal) : boolean;
private
function GetDispMode(Index : cardinal) : TDispInfo;
public
property DispMode[index : cardinal] : TDispInfo read GetDispMode;
property SupportedModeCount : cardinal read FSupportedModeCount;
property RestartAllowed : boolean read fRestartAllowed write fRestartAllowed;
property TestBeforeChange : boolean read fTestBeforeChange write fTestBeforeChange;
end;
var
DisplayManager : TDisplay;
procedure CreateDisplay(EnumModes : boolean);
procedure FreeDisplay;
implementation
uses
WinVersion;
const
ENUM_CURRENT_SETTINGS = cardinal(-1);
procedure CreateDisplay(EnumModes : boolean);
begin
if DisplayManager = nil
then DisplayManager := TDisplay.Create(EnumModes);
end;
procedure FreeDisplay;
begin
DisplayManager.Free;
DisplayManager := nil;
end;
// TDisplay
constructor TDisplay.Create(const EnumModes: boolean);
begin
inherited Create;
fTestBeforeChange := true;
if EnumModes
then EnumSupportedModes;
end;
destructor TDisplay.Destroy;
begin
fSupportedModes := nil; // to deallocate the dinamic array memory;
inherited;
end;
procedure TDisplay.EnumSupportedModes;
var
CurrentModeIdx : cardinal;
CurrentMode : DEVMODE;
begin
if not fModesEnumerated
then
begin
CurrentModeIdx := 0;
while EnumDisplaySettings(nil, CurrentModeIdx, CurrentMode) do
begin
NewDispMode(CurrentMode);
Inc(CurrentModeIdx);
end;
fModesEnumerated := true;
end;
fCurrentModeKnown := ObtainCurrentModeIndex(fCurrentModeIndex);
end;
function TDisplay.SetDispMode(const aMode : TDispInfo; var ExtendedResult : longint) : boolean;
begin
Result := SetDispMode(IndexOf(aMode), ExtendedResult)
end;
function TDisplay.SetDispMode(const aIndex : cardinal; var ExtendedResult : longint) : boolean;
var
aFlags : cardinal;
begin
Assert(fModesEnumerated and (aIndex < SupportedModeCount));
aFlags := DM_BITSPERPEL or DM_PELSWIDTH or DM_PELSHEIGHT;
ExtendedResult := ChangeDispMode(aIndex, aFlags);
case ExtendedResult of
DISP_CHANGE_SUCCESSFUL :
Result := true;
DISP_CHANGE_RESTART :
Result := RestartAllowed;
DISP_CHANGE_BADFLAGS, DISP_CHANGE_FAILED, DISP_CHANGE_BADMODE :
Result := false;
else
Result := false;
end;
end;
function TDisplay.Reset : boolean;
var
ErrCode : Longint;
PDevMode : ^DEVMODE;
begin
PDevMode := nil;
ErrCode := ChangeDisplaySettings(PDevMode^, CDS_FULLSCREEN);
case ErrCode of
DISP_CHANGE_SUCCESSFUL :
Result := true;
DISP_CHANGE_RESTART :
Result := RestartAllowed;
DISP_CHANGE_BADFLAGS, DISP_CHANGE_FAILED, DISP_CHANGE_BADMODE :
Result := false;
else
Result := false;
end;
end;
function TDisplay.SetDispModeEx(const aMode : TDispInfo; const aFlags : DWORD; var ExtendedResult : longint) : boolean;
begin
Result := SetDispModeEx(IndexOf(aMode), aflags, ExtendedResult)
end;
function TDisplay.SetDispModeEx(const aIndex : cardinal; const aFlags : DWORD; var ExtendedResult : longint) : boolean;
begin
Assert(fModesEnumerated and (aIndex < SupportedModeCount));
ExtendedResult := ChangeDispMode(aIndex, aFlags);
case ExtendedResult of
DISP_CHANGE_SUCCESSFUL :
Result := true;
DISP_CHANGE_RESTART :
Result := RestartAllowed;
DISP_CHANGE_BADFLAGS, DISP_CHANGE_FAILED, DISP_CHANGE_BADMODE :
Result := false;
else
Result := false;
end;
end;
function TDisplay.GetCurrentModeIndex(var aIndex : cardinal) : boolean;
begin
Result := fCurrentModeKnown;
if fCurrentModeKnown
then aIndex := fCurrentModeIndex
else aIndex := MaxInt;
end;
function TDisplay.IndexOf(const aMode : TDispInfo) : cardinal;
var
i : cardinal;
begin
Assert(fModesEnumerated);
Result := MaxInt;
i := 0;
while (i < SupportedModeCount) and (Result = cardinal(MaxInt)) do
begin
if ( (fSupportedModes[i].BitsPerPel = aMode.BitsPerPel) and
(fSupportedModes[i].PelsWidth = aMode.PelsWidth) and
(fSupportedModes[i].PelsHeight = aMode.PelsHeight) )
then Result := i;
Inc(i);
end;
end;
function TDisplay.DispInfoFromDevMode(const aMode : DEVMODE) : TDispInfo;
begin
with Result, aMode do
begin
BitsPerPel := dmBitsPerPel;
PelsWidth := dmPelsWidth;
PelsHeight := dmPelsHeight;
DisplayFlags := dmDisplayFlags;
DisplayFrequency := dmDisplayFrequency;
end;
end;
procedure TDisplay.NewDispMode(const aMode : DEVMODE);
begin
if Pred(SupportedModeCount) = cardinal(High(fSupportedModes))
then SetLength(fSupportedModes, Length(fSupportedModes) + 4);
fSupportedModes[SupportedModeCount] := DispInfoFromDevMode(aMode);
Inc(fSupportedModeCount);
end;
function TDisplay.ChangeDispMode(const aIndex : cardinal; const aFlags : DWORD) : longint;
var
aDevMode : DEVMODE;
Change : boolean;
begin
Result := DISP_CHANGE_FAILED; // to avoid the warn
EnumDisplaySettings(nil, aIndex, aDEVMODE);
aDEVMODE.dmFields := aFlags;
if TestBeforeChange
then
begin
Result := ChangeDisplaySettings(aDevMode,CDS_TEST);
case Result of
DISP_CHANGE_SUCCESSFUL :
Change := true;
DISP_CHANGE_RESTART :
Change := RestartAllowed;
DISP_CHANGE_BADFLAGS, DISP_CHANGE_FAILED, DISP_CHANGE_BADMODE :
Change := false;
else Change := false;
end;
end
else Change := true;
if Change
then Result := ChangeDisplaySettings(aDevMode, CDS_FULLSCREEN);
end;
function TDisplay.ObtainCurrentModeIndex(var aIndex : cardinal) : boolean;
var
aDevMode : DEVMODE;
begin
Assert(fModesEnumerated);
if IsNT and EnumDisplaySettings(nil, ENUM_CURRENT_SETTINGS, aDevMode)
then
begin
aIndex := IndexOf(DispInfoFromDevMode(aDevMode));
Result := true;
end
else
begin
aIndex := MaxInt;
Result := false;
end;
end;
function TDisplay.GetDispMode(Index: cardinal): TDispInfo;
begin
Assert(fModesEnumerated and (Index < SupportedModeCount));
Result := fSupportedModes[Index];
end;
end.
|
program hw4q2;
var
X,Y,W,Z : integer ;
(*Each function will print out that it has been called
and will give the new value of X inside that function.*)
function add1(var param : integer):integer ;
begin
writeln('Inside add1.') ;
param := param + 1 ;
writeln('Value of X now is: ', param) ;
add1 := param ;
end;(*fxn add1*)
function subtract2(var param : integer):integer ;
begin
writeln('Inside subtract2.') ;
param := param - 2 ;
writeln('Value of X now is: ', param) ;
subtract2 := param ;
end;(*fxn subtract2*)
function double_(var param : integer):integer ;
begin
writeln('Inside double_.') ;
param := param * 2 ;
writeln('Value of X now is: ', param) ;
double_ := param ;
end;(*fxn double_*)
function triple(var param : integer):integer ;
begin
writeln('Inside triple.') ;
param := param * 3 ;
writeln('Value of X now is: ', param) ;
triple := param ;
end;(*fxn triple*)
(*Main program*)
begin
(*identification*)
writeln('Mark Sattolo 428500, CSI3125, DGD-2, Homework#4') ;
writeln ;
(*calculate the expression for a sequence of values in a loop*)
writeln('We will calculate from X = 1 to a maximum value.') ;
write('Enter the maximum integer value for the loop: ') ;
(*can assume that the input is perfect*)
readln(Y) ;
(*start the loop*)
for W := 1 to Y do
begin
writeln;
(* set the initial value of X*)
X := W ;
(* print out the initial value *)
writeln(' >> Starting input value was: ', X) ;
(*process the expression*)
Z := triple(X) + subtract2(X) + add1(X) * double_(X) * X ;
(*write out the new values*)
writeln(' >> Ouput value is: ', Z);
writeln(' >> Input value now is: ', X);
end ;
writeln;
writeln(' PROGRAM ENDED.') ;
end.
|
unit uGraph;
interface
uses Graphics;
type
TGraph = class
private
FSurface: TBitmap;
FCanvas: TCanvas;
procedure SetSurface(const Value: TBitmap);
procedure SetCanvas(const Value: TCanvas);
public
constructor Create(ACanvas: TCanvas; AWidth, AHeight: Integer);
destructor Destroy; override;
property Surface: TBitmap read FSurface write SetSurface;
property Canvas: TCanvas read FCanvas write SetCanvas;
function Width: Integer;
function Height: Integer;
procedure Render;
procedure Clear;
end;
var
Graph: TGraph;
implementation
uses Windows, Types, uUtils;
{ TGraph }
procedure TGraph.Clear;
begin
Surface.Canvas.Brush.Color := 0;
Surface.Canvas.FillRect(Rect(0, 0, Surface.Width, Surface.Height));
end;
constructor TGraph.Create(ACanvas: TCanvas; AWidth, AHeight: Integer);
begin
Canvas := ACanvas;
Surface := Graphics.TBitmap.Create();
Surface.Width := AWidth;
Surface.Height := AHeight;
Surface.Canvas.Brush.Style := bsClear;
Surface.Canvas.Font.Name := 'Tahoma';
Surface.Canvas.Font.Size := 11;
Surface.PixelFormat := pf16bit;
ScreenWidth := (AWidth div TileSize) - PanelWidth;
ScreenHeight := AHeight div TileSize;
end;
destructor TGraph.Destroy;
begin
Surface.Free;
inherited;
end;
function TGraph.Height: Integer;
begin
Result := Surface.Height;
end;
procedure TGraph.Render;
begin
Canvas.Draw(0, 0, Surface);
end;
procedure TGraph.SetCanvas(const Value: TCanvas);
begin
FCanvas := Value;
end;
procedure TGraph.SetSurface(const Value: Graphics.TBitmap);
begin
FSurface := Value;
end;
function TGraph.Width: Integer;
begin
Result := Surface.Width;
end;
end.
|
{ Subroutine SST_W_C_EXP_CONST (EXP,ADDR_CNT,DT_OUT_P,ENCLOSE)
*
* Write the value of the expression EXP. An error will result if the
* expression does not have a constant value known at compile time.
* ADDR_CNT is the number of times to take the address of the expression.
* It may be negative to indicate the number of times the expression
* should be assumed to be a pointer and dereferenced.
*
* DT_OUT_P is the desired data type of the final output expression.
* Currently this is only implemented for strings. Strings are always written
* to the full length of the desired output data type since C appends a
* NULL character at the end if there is room.
*
* ENCLOSE indicates whether the final expression should be enclosed in
* parentheses. Values of ENCLOSE can be:
*
* ENCLOSE_YES_K - Enclose in parentheses, if neccessary, to make the
* entire expression be one term.
*
* ENCLOSE_NO_K - Don't enclose expression in parentheses, even if it is
* written as more than one term with operators in between.
}
module sst_w_c_EXP_CONST;
define sst_w_c_exp_const;
%include 'sst_w_c.ins.pas';
procedure sst_w_c_exp_const ( {write exp value, const value must be known}
in exp: sst_exp_t; {expression descriptor}
in addr_cnt: sys_int_machine_t; {number of times to take address of}
in dt_out_p: sst_dtype_p_t; {desired output data type, NIL = as is}
in enclose: enclose_k_t); {enclose in () yes/no}
const
max_msg_parms = 1; {max parameters we can pass to a message}
var
i: sys_int_machine_t; {scratch integer an loop counter}
dt_p: sst_dtype_p_t; {points to base desired expression data type}
enc: enclose_k_t; {internal enclose flag}
c: char; {either address-of or dereference operator}
str: string_var256_t; {string value with desired output length}
val: sst_var_value_t; {value descriptor used when out dtype forced}
msg_parm: {parameter references for messages}
array[1..max_msg_parms] of sys_parm_msg_t;
label
raw_value, exp_value;
begin
str.max := sizeof(str.str); {init local var string}
enc := enclose; {init our enclose flag to caller's}
if not exp.val_fnd then begin {expression has no constant value ?}
syo_error (exp.str_h, 'sst', 'exp_not_const_val', nil, 0);
end;
if exp.term1.ttype = sst_term_field_k then begin {exp is record constant ?}
sst_w_c_exp_rec (exp); {handle in separate routine}
return;
end;
if exp.term1.ttype = sst_term_arele_k then begin {exp is array constant ?}
sst_w_c_exp_array (exp); {handle in separate routine}
return;
end;
if exp.term1.next_p = nil then begin {expression has only one term ?}
case exp.term1.ttype of
sst_term_var_k: begin {term is a "variable", could be named const}
case exp.term1.var_var_p^.vtype of {what kind of "variable" is this ?}
sst_vtype_const_k: goto exp_value; {term is a named constant}
otherwise
goto raw_value;
end;
end;
end; {end of special handling term type cases}
end; {done handling non-compound expression}
raw_value: {jump here to write raw numeric value}
if addr_cnt <> 0 then begin {need to write starting "*" or "&" ?}
enc := enclose_yes_k; {must now be enclosed in ()}
if addr_cnt > 0 {select which operator to write}
then c := '&'
else c := '*';
for i := 1 to abs(addr_cnt) do begin {once for each time to write operator}
sst_w.appendn^ (c, 1);
end;
end; {done handling ADDR_CNT not zero}
if dt_out_p <> nil then begin {an output data type was specified ?}
dt_p := dt_out_p;
while dt_p^.dtype = sst_dtype_copy_k {resolve base requested output dtype}
do dt_p := dt_p^.copy_dtype_p;
if {requested output dtype is a string ?}
(dt_p^.dtype = sst_dtype_array_k) and
dt_p^.ar_string
then begin {output data type is a string}
str.max := min(sizeof(str.str), dt_p^.ar_ind_n); {length of desired string}
case exp.val.dtype of {what is data type of constant descriptor ?}
sst_dtype_array_k: begin {constant is a string}
string_copy (exp.val.ar_str_p^, str); {make local copy of string}
end;
sst_dtype_char_k: begin {constant is a character}
str.str[1] := exp.val.char_val; {set first character of string}
str.len := 1;
end;
otherwise {incompatible data type}
sys_msg_parm_int (msg_parm[1], ord(exp.val.dtype));
syo_error (exp.str_h, 'sst_c_write', 'dtype_exp_unexpected', msg_parm, 1);
end;
string_pad (str); {pad to max length by adding blanks}
val.dtype := sst_dtype_array_k; {create const descriptor for final string}
val.ar_str_p := univ_ptr(addr(str));
sst_w_c_value (val, enc); {write value of temp constant descriptor}
return;
end; {done handling output data type is a string}
end; {done handling output data type specified}
sst_w_c_value (exp.val, enc); {write constant value}
return;
exp_value: {jump here to write full expression}
sst_w_c_exp (exp, addr_cnt, nil, enclose);
end;
|
{ Mark Sattolo 428500
CSI-1100A DGD-1 TA: Chris Lankester
1997 Final Exam, Question 5 }
program MostFlights (input,output);
const MaxSize = 20;
type ArrayType = array[1..MaxSize, 1..MaxSize] of integer;
{ *************************************************************************** }
procedure FindCommon(Flights:ArrayType; N,i,j: integer; var Common: integer);
var k : integer;
begin
Common := 0;
for k := 1 to N do
if (Flights[i,k] = 1) and (Flights[i,k] = Flights[j,k]) then
inc(Common);
end; { procedure FindCommon }
{ *************************************************************************** }
procedure MostDest(Flights:ArrayType; N:integer; var CityA, CityB, Most: integer);
var i, j, Common : integer;
begin
Most := 0;
for i := 1 to N-1 do
for j := i+1 to N do
begin
FindCommon(Flights, N, i, j, Common);
if Common > Most then
begin
Most := Common;
CityA := i;
CityB := j;
end; { if }
end; { for }
end; { procedure MostDest }
{ *************************************************************************** }
{ Program MostFlights }
var
Flights : ArrayType;
N, i, j, Dest1, Dest2, Most : integer;
begin
repeat { start outer input loop }
{ Read in the program's givens. }
repeat
write('Please enter a value from 1 to ', MaxSize, ' [ <1 to exit ] for N: ');
readln(N);
until (N <= MaxSize);
for i := 1 to N do
begin
writeln('Please enter values (with a space between) for row #', i);
for j := 1 to N do
read(Flights[i,j]);
end;
{ body }
MostDest(Flights, N, Dest1, Dest2, Most);
{ write out the results }
writeln;
writeln('**********************************************');
writeln(' Mark Sattolo 428500');
writeln(' CSI-1100A DGD-1 TA: Chris Lankester');
writeln(' 1997 Final Exam, Question 5');
writeln('**********************************************');
writeln;
if N > 1 then
writeln('The Flights array is: ');
writeln;
for i := 1 to N do
begin
for j := 1 to N do
write(Flights[i,j]:3, ' ');
writeln;
end; { for loop to write Flights }
{ inform user of the most number of flights }
if N > 1 then
begin
writeln;
writeln('The two cities with the most destinations in common are:');
writeln('City ', Dest1, ' and City ', Dest2, ' with ', Most, ' common destinations.');
writeln;
end;
until
N < 1; { end outer input loop }
end.
|
(**
This module contains a frame which represents the controls for configuring the IDE Help
Helper settings.
@Version 1.0
@Author David Hoyle
@Date 07 Apr 2016
**)
Unit DGHIDEHelpHelperOptionsFrame;
Interface
Uses
Windows,
Messages,
SysUtils,
Variants,
Classes,
Graphics,
Controls,
Forms,
Dialogs,
StdCtrls,
CheckLst,
Buttons,
ExtCtrls;
Type
(** A class to represent a frame of controls for configuring settings. **)
TfmIDEHelpHelperOptions = Class(TFrame)
gpGridPanel: TGridPanel;
pnlSearchURLs: TPanel;
lblSearchURLs: TLabel;
pnlSearchButtons: TPanel;
btnAddSearch: TBitBtn;
btnEditSearch: TBitBtn;
btnDeleteSearch: TBitBtn;
lbxSearchURLs: TCheckListBox;
pnlPermanentURLs: TPanel;
lblPermanentURLs: TLabel;
lbxPermanentURLs: TListBox;
pnlPermanentButtons: TPanel;
btnAddPermanent: TBitBtn;
btnEditPeranent: TBitBtn;
btnDeletePermanent: TBitBtn;
btnDefault: TBitBtn;
Procedure lbxSearchURLsClickCheck(Sender: TObject);
Procedure lbxSearchURLsMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
Procedure FormKeyDown(Sender: TObject; Var Key: Word; Shift: TShiftState);
Procedure lbxSearchURLsClick(Sender: TObject);
Procedure lbxPermanentURLsClick(Sender: TObject);
Procedure btnAddSearchClick(Sender: TObject);
Procedure btnAddPermanentClick(Sender: TObject);
Procedure btnDeleteSearchClick(Sender: TObject);
Procedure btnDeletePermanentClick(Sender: TObject);
Procedure btnEditSearchClick(Sender: TObject);
Procedure btnEditPeranentClick(Sender: TObject);
Procedure btnDefaultClick(Sender: TObject);
Private
{Private declarations}
(** This variable is updated to the index of the clicked item in the Search URLs
listbox so that is check value can be left along when the other check marks
are reset. **)
FClickIndex: Integer;
Public
{Public declarations}
Procedure InitialiseFrame(slSearchURLs, slPermanentURLs : TStringList;
iSearchURL : Integer);
Procedure FinaliseFrame(slSearchURLs, slPermanentURLs : TStringList;
var iSearchURL : Integer);
End;
Implementation
{$R *.dfm}
Const
(** This is a message template for the removal of items from the URL lists. **)
strMsg = 'Are you sure you want to remove "%s" from this list?';
(**
This is an on click event handler for the Add button for Permanent URLs.
@precon None.
@postcon Adds a Permanent URL to the list IF the InputQuery is confirmed.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnAddPermanentClick(Sender: TObject);
Var
strURL : String;
Begin
If InputQuery('NEW Permanent URL', 'Please enter a new Permanent URL.', strURL) Then
lbxPermanentURLs.Items.Add(strURL);
End;
(**
This is an on click event handler for the Add button for Search URLs.
@precon None.
@postcon Adds a Search URL to the list IF the InputQuery is confirmed.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnAddSearchClick(Sender: TObject);
Var
strURL : String;
Begin
If InputQuery('NEW Search URL',
'Please enter a new search URL (place %s where the identifier should be inserted).',
strURL) Then
lbxSearchURLs.Items.Add(strURL);
End;
(**
This is an on click event handler for the Default button.
@precon None.
@postcon Move the selected item to the top of the list to act as the home page on first
display.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnDefaultClick(Sender: TObject);
Begin
lbxPermanentURLs.Items.Move(lbxPermanentURLs.ItemIndex, 0);
lbxPermanentURLs.ItemIndex := 0;
lbxPermanentURLsClick(Sender);
End;
(**
This is an on click event handler for the Delete button for the Permanent URLs.
@precon None.
@postcon Prompts the user to delete the selected entry and if confirmed deletes the
item.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnDeletePermanentClick(Sender: TObject);
Begin
If lbxPermanentURLs.ItemIndex > -1 Then
If MessageDlg(Format(strMsg, [lbxPermanentURLs.Items[lbxPermanentURLs.ItemIndex]]),
mtConfirmation, [mbYes, mbNo], 0) = mrYes Then
lbxPermanentURLs.Items.Delete(lbxPermanentURLs.ItemIndex);
End;
(**
This is an on click event handler for the Delete button for the Search URLs.
@precon None.
@postcon Prompts the user to delete the selected entry and if confirmed deletes the
item.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnDeleteSearchClick(Sender: TObject);
Begin
If lbxSearchURLs.ItemIndex > -1 Then
If MessageDlg(Format(strMsg, [lbxSearchURLs.Items[lbxSearchURLs.ItemIndex]]),
mtConfirmation, [mbYes, mbNo], 0) = mrYes Then
lbxSearchURLs.Items.Delete(lbxSearchURLs.ItemIndex);
End;
(**
This is an on click event handler for the Edit button for the Permanent URLs.
@precon None.
@postcon Prompts the users to edit the selected permanent URL and if confirmed updates
the URL.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnEditPeranentClick(Sender: TObject);
Var
strURL : String;
Begin
If lbxPermanentURLs.ItemIndex > -1 Then
Begin
strURL := lbxPermanentURLs.Items[lbxPermanentURLs.ItemIndex];
If InputQuery('Edit Search URL', 'Please enter a permanent URL.', strURL) Then
lbxPermanentURLs.Items[lbxPermanentURLs.ItemIndex] := strURL;
End;
End;
(**
This is an on click event handler for the Edit button for the Search URLs.
@precon None.
@postcon Prompts the users to edit the selected search URL and if confirmed updates the
URL.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.btnEditSearchClick(Sender: TObject);
Var
strURL : String;
Begin
If lbxSearchURLs.ItemIndex > -1 Then
Begin
strURL := lbxSearchURLs.Items[lbxSearchURLs.ItemIndex];
If InputQuery('Edit Search URL',
'Please enter a search URL (place %s where the identifier should be inserted).',
strURL) Then
lbxSearchURLs.Items[lbxSearchURLs.ItemIndex] := strURL;
End;
End;
(**
This method retreives the settings from the frame and returns them to the calling code.
@precon The strings lists MUST be valid instances.
@postcon The updated information in the frame is returned to the calling code through
the parameters of the method.
@param slSearchURLs as a TStringList
@param slPermanentURLs as a TStringList
@param iSearchURL as an Integer as a reference
**)
Procedure TfmIDEHelpHelperOptions.FinaliseFrame(slSearchURLs,
slPermanentURLs: TStringList; Var iSearchURL: Integer);
Var
i: Integer;
Begin
slSearchURLs.Assign(lbxSearchURLs.Items);
slPermanentURLs.Assign(lbxPermanentURLs.Items);
iSearchURL := -1;
For i := 0 To lbxSearchURLs.Items.Count - 1 Do
If lbxSearchURLs.Checked[i] Then
Begin
iSearchURL := i;
Break;
End;
End;
(**
This is an on Key Down event handler for the Search URL List box.
@precon None.
@postcon If the space bar is pressed to check an item is sets the FClickIndex is updated
to the selected item.
@param Sender as a TObject
@param Key as a Word as a reference
@param Shift as a TShiftState
**)
Procedure TfmIDEHelpHelperOptions.FormKeyDown(Sender: TObject; Var Key: Word;
Shift: TShiftState);
Begin
If (Shift = []) And (Key = 32) Then
Begin
FClickIndex := lbxSearchURLs.ItemIndex;
lbxSearchURLsClickCheck(Sender);
Key := 0;
End;
End;
(**
This method initialises the controls in the frame with the information in the
parameters.
@precon The strign lists must be valid instances.
@postcon The frame is initialised.
@param slSearchURLs as a TStringList
@param slPermanentURLs as a TStringList
@param iSearchURL as an Integer
**)
Procedure TfmIDEHelpHelperOptions.InitialiseFrame(slSearchURLs,
slPermanentURLs: TStringList; iSearchURL: Integer);
Begin
FClickIndex := -1;
lbxSearchURLsClick(Nil);
lbxPermanentURLsClick(Nil);
lbxSearchURLs.Items.Assign(slSearchURLs);
lbxPermanentURLs.Items.Assign(slPermanentURLs);
If (iSearchURL > -1) And (iSearchURL <= lbxSearchURLs.Items.Count - 1) Then
lbxSearchURLs.Checked[iSearchURL] := True;
End;
(**
This is an on click event handler for the Permanent URLs list box.
@precon None.
@postcon Updates the availability of the edit and delete buttons.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.lbxPermanentURLsClick(Sender: TObject);
Begin
btnDefault.Enabled := lbxPermanentURLs.ItemIndex > -1;
btnEditPeranent.Enabled := lbxPermanentURLs.ItemIndex > -1;
btnDeletePermanent.Enabled := lbxPermanentURLs.ItemIndex > -1;
End;
(**
This is an on click event handler for the Search URLs list box.
@precon None.
@postcon Updates the availability of the edit and delete buttons.
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.lbxSearchURLsClick(Sender: TObject);
Begin
btnEditSearch.Enabled := lbxSearchURLs.ItemIndex > -1;
btnDeleteSearch.Enabled := lbxSearchURLs.ItemIndex > -1;
End;
(**
This is an on click check event handler for the Search Listbox.
@precon None.
@postcon This method unselects all the check marks of the listbox except the one with
index FClickIndex (i.e. ensure that ONLY the selected items check mark is
checked).
@param Sender as a TObject
**)
Procedure TfmIDEHelpHelperOptions.lbxSearchURLsClickCheck(Sender: TObject);
Var
i: Integer;
Begin
For i := 0 To lbxSearchURLs.Items.Count - 1 Do
lbxSearchURLs.Checked[i] := (FClickIndex = i);
End;
(**
This method is an on mouse down event handler for the Search URLs list box.
@precon None.
@postcon Updates the FClickIndex when the left mouse button is clicked over a listbox
item.
@param Sender as a TObject
@param Button as a TMouseButton
@param Shift as a TShiftState
@param X as an Integer
@param Y as an Integer
**)
Procedure TfmIDEHelpHelperOptions.lbxSearchURLsMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
Begin
If Button = mbLeft Then
FClickIndex := lbxSearchURLs.ItemAtPos(Point(X, Y), True);
End;
End.
|
unit uFrmMQTTClient;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
Vcl.StdCtrls, Vcl.ExtCtrls, MQTT, Vcl.Buttons, Vcl.ComCtrls;
const
WM_WRITE_LOG = WM_USER + 1;
type
TFrmMQTTClient = class(TForm)
MMLog: TMemo;
pnl1: TPanel;
btnPublish: TButton;
EdtPubTopic: TEdit;
lbl2: TLabel;
lbl1: TLabel;
btnPing: TButton;
mmo1: TMemo;
Connect: TBitBtn;
DisConnect: TBitBtn;
stat1: TStatusBar;
lbl3: TLabel;
EdtSubTopic: TEdit;
btnSub: TButton;
btnDisSub: TButton;
procedure btnPublishClick(Sender: TObject);
procedure ConnectClick(Sender: TObject);
procedure DisConnectClick(Sender: TObject);
procedure SetMQTTStatus;
procedure FormCreate(Sender: TObject);
procedure btnSubClick(Sender: TObject);
procedure btnDisSubClick(Sender: TObject);
private
procedure WriteLog(const Msg: string);
procedure MSG_Log(var message:TMessage); message WM_WRITE_LOG;
{ Private declarations }
public
{ Public declarations }
procedure OnSocketConnect(Sender: TObject;Connected:Boolean);
procedure OnConnAck(Sender: TObject; ReturnCode: integer);
procedure OnPubAck(Sender: TObject; MsgId:Word);
procedure OnPubRec(Sender: TObject; MsgId:Word);
procedure OnPubRel(Sender: TObject; MsgId:Word);
procedure OnPubComp(Sender: TObject; MsgId:Word);
procedure OnSubAck(Sender: TObject; MessageID: integer; GrantedQoS: Integer);
procedure OnPublish(Sender: TObject;const msg:TRecvPublishMessage);
//Qos:TQosLevel;MsgID:Word;Retain:Boolean;const topic, payload: AnsiString);
procedure OnPingResp(Sender: TObject);
procedure OnUnSubAck(Sender: TObject; MsgId:Word);
procedure OnDisConnect(Sender: TObject);
end;
var
FrmMQTTClient: TFrmMQTTClient;
gConnectError:Boolean;
implementation
{$R *.dfm}
procedure TFrmMQTTClient.btnDisSubClick(Sender: TObject);
var
Topic:AnsiString;
begin
Topic := AnsiString(edtSubTopic.Text);
MQ.UnSubScribe(Topic);
end;
procedure TFrmMQTTClient.btnPublishClick(Sender: TObject);
var
Topic, Data: AnsiString;
begin
Topic := Self.edtPubTopic.Text;
Data := Self.MMO1.Lines.Text;
Data := AnsiToUtf8(Data);
MQ.Publish(Topic, Data, MQ.Qos, MQ.Retain);
//WriteLog(format('[published],[%s],iRet[%d]',[Topic,iRet]));
end;
procedure TFrmMQTTClient.btnSubClick(Sender: TObject);
var
Topic:AnsiString;
begin
Topic := edtSubTopic.Text;
MQ.SubScribe(Topic,MQ.Qos);
end;
procedure TFrmMQTTClient.ConnectClick(Sender: TObject);
begin
GetMQTT;
if MQ.Connected then
Stat1.Panels[0].Text := '连接时间: ' + FormatDateTime('YYYY-MM-DD hh:mm:ss',Now());
end;
procedure TFrmMQTTClient.DisConnectClick(Sender: TObject);
begin
if MQ.Connected then
MQ.DisConnect;
end;
procedure TFrmMQTTClient.FormCreate(Sender: TObject);
begin
SetMQTTStatus;
//
{$IF Defined(CPUX64)}
Stat1.Panels[1].Text := 'Win64A';
{$ELSE}
Stat1.Panels[1].Text := 'Win32';
{$IFEND}
//
Stat1.Panels[2].Text := MQ.ComponmentVersion;
end;
procedure TFrmMQTTClient.MSG_Log(var message: TMessage);
var
Msg:string;
begin
Msg := FormatDateTime('YYYY-MM-DD hh:mm:ss.zzz',Now());
Msg := Msg + ': ' + PString(message.WParam)^;
mmLog.Lines.Add(Msg);
end;
procedure TFrmMQTTClient.WriteLog(const Msg: string);
begin
if mmLog.Lines.Count > 2048 then
mmLog.Lines.Clear();
SendMessage(Handle,WM_WRITE_LOG,WPARAM(@Msg),0);
end;
procedure TFrmMQTTClient.OnConnAck(Sender: TObject; ReturnCode: integer);
function ReturnCodeToStr():string;
begin
case ReturnCode of
0: Result := 'OK';
1: Result := 'ConnectAckState';
2: Result := 'InvalidClientID';
3: Result := 'Serverunavailable';
4: Result := 'InvalidUserOrPassWord';
5: Result := 'NoAuthorizd';
else
Result := 'Unknown';
end;
end;
begin
WriteLog('OnConnAck ReturnCode=' + IntToStr(ReturnCode) + ',Status=' + ReturnCodeToStr());
if ReturnCode = 0 then
begin
Connect.Enabled := FALSE;
end;
end;
procedure TFrmMQTTClient.OnDisConnect(Sender: TObject);
var
Msg:string;
Obj:TMQTTClient;
begin
Obj := Sender as TMQTTClient;
Msg := Format('OnDisConnect...,UserCancel[%s],ErrDesc[%s]',[
BoolToStr(Obj.UserCancelSocket,true),
Obj.ErrDesc]);
gConnectError := Obj.ErrDesc <> '';
WriteLog(Msg);
//
if Obj.AutoReConnect then
begin
WriteLog('OnDisConnect...ReConnect-----AutoReConnect,延迟 :' + IntToStr(Obj.AutoReConnectDelaySec) + '秒后重连');
end;
Connect.Enabled := not MQ.AutoReConnect;
end;
procedure TFrmMQTTClient.OnPingResp(Sender: TObject);
begin
WriteLog('OnPingResp');
end;
procedure TFrmMQTTClient.OnPubAck(Sender: TObject; MsgId: Word);
begin
WriteLog('OnPubAck MsgId=' + IntToStr(MsgId));
end;
procedure TFrmMQTTClient.OnPubComp(Sender: TObject; MsgId: Word);
begin
WriteLog('OnPubComp MsgId=' + IntToStr(MsgId));
end;
procedure TFrmMQTTClient.OnPublish(Sender: TObject;
const msg: TRecvPublishMessage);
var
Text:string;
MsgContent:AnsiString;
begin
{if cb_utf8.Checked then
MsgContent := Utf8ToAnsi(msg.MsgContent)
else }
MsgContent := UTF8Decode(msg.MsgContent);
Text := format('OnPublish,Dup=%s,Qos=%d,MsgID[%d],Retain[%s],Topic=%s,payload=%s',
[BoolToStr(msg.Dup,TRUE),
Integer(msg.Qos),
msg.MsgID,
BoolToStr(msg.Retain,TRUE),
msg.topic,
msg.MsgContent]);
WriteLog(Text);
end;
procedure TFrmMQTTClient.OnPubRec(Sender: TObject; MsgId: Word);
begin
WriteLog('OnPubRec MsgId=' + IntToStr(MsgId));
end;
procedure TFrmMQTTClient.OnPubRel(Sender: TObject; MsgId: Word);
begin
WriteLog('OnPubRel MsgId=' + IntToStr(MsgId));
end;
procedure TFrmMQTTClient.OnSocketConnect(Sender: TObject;
Connected: Boolean);
var
Msg:string;
Obj :TMQTTClient;
begin
Obj := Sender as TMQTTClient;
Msg := Format('OnSocketConnect,Connected[%s],ErrDesc[%s]',[
BoolToStr(Connected,TRUE),
Obj.ErrDesc]);
WriteLog(Msg);
//
Self.Connect.Enabled := FALSE;
Self.DisConnect.Enabled := TRUE;
Self.btnPublish.Enabled := TRUE;
Self.btnPing.Enabled := TRUE;
end;
procedure TFrmMQTTClient.OnSubAck(Sender: TObject; MessageID,
GrantedQoS: Integer);
var
Msg:string;
begin
Msg := Format('OnSubAck MsgId=%d,GrantedQoS=%d',[MessageID,GrantedQoS]);
WriteLog(Msg);
end;
procedure TFrmMQTTClient.OnUnSubAck(Sender: TObject; MsgId: Word);
var
Msg:string;
begin
Msg := Format('OnUnSubAck,MsgId=%d',[MsgId]);
WriteLog(Msg);
end;
procedure TFrmMQTTClient.SetMQTTStatus;
begin
MQ.OnFConnAck := OnConnAck;
MQ.OnPubAck := OnPubAck;
MQ.OnPubRec := OnPubRec;
MQ.OnPubRel := OnPubRel;
MQ.OnPubComp := OnPubComp;
MQ.onSubAck := OnSubAck;
MQ.OnUnSubAck := OnUnSubAck;
MQ.OnPublish := OnPublish;
MQ.OnPingResp := OnPingResp;
MQ.OnSocketConnect := OnSocketConnect;
MQ.OnDisConnect := OnDisConnect;
end;
end.
|
unit SplashServerInterfaces;
{* Интерфейсы для сервера }
// Модуль: "w:\garant6x\implementation\Garant\GbaNemesis\Splash\SplashServerInterfaces.pas"
// Стереотип: "Interfaces"
// Элемент модели: "SplashServerInterfaces" MUID: (499D06A201BE)
{$Include w:\garant6x\implementation\Garant\nsDefine.inc}
interface
{$If NOT Defined(Admin) AND NOT Defined(Monitorings)}
uses
l3IntfUses
, l3Interfaces
;
type
InsSplashWaiter = interface
{* Объект ожидающий нотификацию о том, что клиент хочет погасить сплеш }
['{3551107A-2BC6-4CC3-94EA-7F5455557CB0}']
procedure CanCloseSplash;
{* Клиент разрешил закрыть сплеш }
end;//InsSplashWaiter
InsSplashInfo = interface
{* Информация с описанием сплеша, который надо показать }
['{CBECD569-DD17-4BFB-8FAA-F16E652356A4}']
function Get_Waiter: InsSplashWaiter;
procedure Set_Waiter(const aValue: InsSplashWaiter);
function Get_IsValid: Boolean;
function Get_MinimalShowTime: Cardinal;
function Get_Warning: Il3CString;
function Get_UserInfo: Il3CString;
function Get_ApplicationTitle: PAnsiChar;
procedure SwitchToParent;
{* Переключиться на окно клиента (в конце показа) }
function MakeSplashDataStream: IStream;
function MakeLogoStream: IStream;
{* Создает поток для вычитывания TvtPngImageList в котормо лежит лого }
property Waiter: InsSplashWaiter
read Get_Waiter
write Set_Waiter;
{* Нотификатор, которому надо сказать, что клиент кочет закрыть сплеш.
По идее достаточно этого, а не полноценного Publisher/Subscriber }
property IsValid: Boolean
read Get_IsValid;
{* Данные успешно вычитаны и можно показывать сплеш }
property MinimalShowTime: Cardinal
read Get_MinimalShowTime;
{* Минимальное время показа сплеша }
property Warning: Il3CString
read Get_Warning;
{* Предупреждение о нарушении авторских прав. }
property UserInfo: Il3CString
read Get_UserInfo;
{* Строка с информацией о пользователе }
property ApplicationTitle: PAnsiChar
read Get_ApplicationTitle;
{* Заголовок клиентского приложения }
end;//InsSplashInfo
{$IfEnd} // NOT Defined(Admin) AND NOT Defined(Monitorings)
implementation
{$If NOT Defined(Admin) AND NOT Defined(Monitorings)}
uses
l3ImplUses
;
{$IfEnd} // NOT Defined(Admin) AND NOT Defined(Monitorings)
end.
|
unit evdHyperlinkInfo;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Библиотека "EVD"
// Автор: Люлин А.В.
// Модуль: "w:/common/components/rtl/Garant/EVD/evdHyperlinkInfo.pas"
// Начат: 12.11.2010 16:14
// Родные Delphi интерфейсы (.pas)
// Generated from UML model, root element: <<SimpleClass::Class>> Shared Delphi::EVD::Core Objects::TevdHyperlinkInfo
//
//
// Все права принадлежат ООО НПП "Гарант-Сервис".
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ! Полностью генерируется с модели. Править руками - нельзя. !
{$Include ..\EVD\evdDefine.inc}
interface
uses
l3Interfaces,
evdInterfaces,
l3ProtoObject
;
type
TevdHyperlinkInfo = class(Tl3ProtoObject, IevdHyperlinkInfo)
private
// private fields
f_Address : TevdAddress;
f_Text : Il3CString;
f_AppInfo : Il3CString;
protected
// realized methods
function Get_Text: Il3CString;
function Get_Address: TevdAddress;
function Get_AppInfo: Il3CString;
protected
// overridden protected methods
procedure ClearFields; override;
public
// public methods
constructor Create(const aText: Il3CString;
const anAddress: TevdAddress;
const anAppInfo: Il3CString); reintroduce;
class function Make(const aText: Il3CString;
const anAddress: TevdAddress;
const anAppInfo: Il3CString): IevdHyperlinkInfo; reintroduce;
{* Сигнатура фабрики TevdHyperlinkInfo.Make }
end;//TevdHyperlinkInfo
implementation
// start class TevdHyperlinkInfo
constructor TevdHyperlinkInfo.Create(const aText: Il3CString;
const anAddress: TevdAddress;
const anAppInfo: Il3CString);
//#UC START# *4CDD3E250364_4CDD3D930147_var*
//#UC END# *4CDD3E250364_4CDD3D930147_var*
begin
//#UC START# *4CDD3E250364_4CDD3D930147_impl*
inherited Create;
f_Text := aText;
f_Address := anAddress;
f_AppInfo := anAppInfo;
//#UC END# *4CDD3E250364_4CDD3D930147_impl*
end;//TevdHyperlinkInfo.Create
class function TevdHyperlinkInfo.Make(const aText: Il3CString;
const anAddress: TevdAddress;
const anAppInfo: Il3CString): IevdHyperlinkInfo;
var
l_Inst : TevdHyperlinkInfo;
begin
l_Inst := Create(aText, anAddress, anAppInfo);
try
Result := l_Inst;
finally
l_Inst.Free;
end;//try..finally
end;
function TevdHyperlinkInfo.Get_Text: Il3CString;
//#UC START# *4CDD38870303_4CDD3D930147get_var*
//#UC END# *4CDD38870303_4CDD3D930147get_var*
begin
//#UC START# *4CDD38870303_4CDD3D930147get_impl*
Result := f_Text;
//#UC END# *4CDD38870303_4CDD3D930147get_impl*
end;//TevdHyperlinkInfo.Get_Text
function TevdHyperlinkInfo.Get_Address: TevdAddress;
//#UC START# *4CDD3950013B_4CDD3D930147get_var*
//#UC END# *4CDD3950013B_4CDD3D930147get_var*
begin
//#UC START# *4CDD3950013B_4CDD3D930147get_impl*
Result := f_Address;
//#UC END# *4CDD3950013B_4CDD3D930147get_impl*
end;//TevdHyperlinkInfo.Get_Address
function TevdHyperlinkInfo.Get_AppInfo: Il3CString;
//#UC START# *4CDD6BCA034C_4CDD3D930147get_var*
//#UC END# *4CDD6BCA034C_4CDD3D930147get_var*
begin
//#UC START# *4CDD6BCA034C_4CDD3D930147get_impl*
Result := f_AppInfo;
//#UC END# *4CDD6BCA034C_4CDD3D930147get_impl*
end;//TevdHyperlinkInfo.Get_AppInfo
procedure TevdHyperlinkInfo.ClearFields;
{-}
begin
f_Text := nil;
f_AppInfo := nil;
inherited;
end;//TevdHyperlinkInfo.ClearFields
end. |
unit MMO.ServerCreateOptions;
interface
type
TServerCreateOptions = record
ThreadSafe: Boolean;
Port: UInt16;
MaxPlayers: UInt16;
end;
implementation
end.
|
unit DW.Androidapi.JNI.Debug;
{*******************************************************}
{ }
{ Kastri Free }
{ }
{ DelphiWorlds Cross-Platform Library }
{ }
{*******************************************************}
{$I DW.GlobalDefines.inc}
interface
uses
Androidapi.JNIBridge, Androidapi.JNI.JavaTypes, Androidapi.JNI.Os;
type
JDebug = interface;
JDebugClass = interface(JObjectClass)
['{5759F2AF-54E3-44F4-839A-008BD6964FC5}']
{class} function _GetSHOW_CLASSLOADER: Integer; cdecl;
{class} function _GetSHOW_FULL_DETAIL: Integer; cdecl;
{class} function _GetSHOW_INITIALIZED: Integer; cdecl;
{class} function _GetTRACE_COUNT_ALLOCS: Integer; cdecl;
{class} procedure changeDebugPort(port: Integer); cdecl;
{class} procedure dumpHprofData(fileName: JString); cdecl;
{class} function dumpService(name: JString; fd: JFileDescriptor; args: TJavaObjectArray<JString>): Boolean; cdecl;
{class} procedure enableEmulatorTraceOutput; cdecl;
{class} function getBinderDeathObjectCount: Integer; cdecl;
{class} function getBinderLocalObjectCount: Integer; cdecl;
{class} function getBinderProxyObjectCount: Integer; cdecl;
{class} function getBinderReceivedTransactions: Integer; cdecl;
{class} function getBinderSentTransactions: Integer; cdecl;
{class} function getGlobalAllocCount: Integer; cdecl;
{class} function getGlobalAllocSize: Integer; cdecl;
{class} function getGlobalClassInitCount: Integer; cdecl;
{class} function getGlobalClassInitTime: Integer; cdecl;
{class} function getGlobalExternalAllocCount: Integer; cdecl;
{class} function getGlobalExternalAllocSize: Integer; cdecl;
{class} function getGlobalExternalFreedCount: Integer; cdecl;
{class} function getGlobalExternalFreedSize: Integer; cdecl;
{class} function getGlobalFreedCount: Integer; cdecl;
{class} function getGlobalFreedSize: Integer; cdecl;
{class} function getGlobalGcInvocationCount: Integer; cdecl;
{class} function getLoadedClassCount: Integer; cdecl;
{class} procedure getMemoryInfo(memoryInfo: JDebug_MemoryInfo); cdecl;
{class} function getNativeHeapAllocatedSize: Int64; cdecl;
{class} function getNativeHeapFreeSize: Int64; cdecl;
{class} function getNativeHeapSize: Int64; cdecl;
{class} function getPss: Int64; cdecl;
{class} function getRuntimeStat(statName: JString): JString; cdecl;
{class} function getRuntimeStats: JMap; cdecl;
{class} function getThreadAllocCount: Integer; cdecl;
{class} function getThreadAllocSize: Integer; cdecl;
{class} function getThreadExternalAllocCount: Integer; cdecl;
{class} function getThreadExternalAllocSize: Integer; cdecl;
{class} function getThreadGcInvocationCount: Integer; cdecl;
{class} function isDebuggerConnected: Boolean; cdecl;
{class} procedure printLoadedClasses(flags: Integer); cdecl;
{class} procedure resetAllCounts; cdecl;
{class} procedure resetGlobalAllocCount; cdecl;
{class} procedure resetGlobalAllocSize; cdecl;
{class} procedure resetGlobalClassInitCount; cdecl;
{class} procedure resetGlobalClassInitTime; cdecl;
{class} procedure resetGlobalExternalAllocCount; cdecl;
{class} procedure resetGlobalExternalAllocSize; cdecl;
{class} procedure resetGlobalExternalFreedCount; cdecl;
{class} procedure resetGlobalExternalFreedSize; cdecl;
{class} procedure resetGlobalFreedCount; cdecl;
{class} procedure resetGlobalFreedSize; cdecl;
{class} procedure resetGlobalGcInvocationCount; cdecl;
{class} procedure resetThreadAllocCount; cdecl;
{class} procedure resetThreadAllocSize; cdecl;
{class} procedure resetThreadExternalAllocCount; cdecl;
{class} procedure resetThreadExternalAllocSize; cdecl;
{class} procedure resetThreadGcInvocationCount; cdecl;
{class} function setAllocationLimit(limit: Integer): Integer; cdecl;
{class} function setGlobalAllocationLimit(limit: Integer): Integer; cdecl;
{class} procedure startAllocCounting; cdecl;
{class} procedure startMethodTracing; cdecl; overload;
{class} procedure startMethodTracing(traceName: JString); cdecl; overload;
{class} procedure startMethodTracing(traceName: JString; bufferSize: Integer); cdecl; overload;
{class} procedure startMethodTracing(traceName: JString; bufferSize: Integer; flags: Integer); cdecl; overload;
{class} procedure startMethodTracingSampling(traceName: JString; bufferSize: Integer; intervalUs: Integer); cdecl;
{class} procedure startNativeTracing; cdecl;
{class} procedure stopAllocCounting; cdecl;
{class} procedure stopMethodTracing; cdecl;
{class} procedure stopNativeTracing; cdecl;
{class} function threadCpuTimeNanos: Int64; cdecl;
{class} procedure waitForDebugger; cdecl;
{class} function waitingForDebugger: Boolean; cdecl;
{class} property SHOW_CLASSLOADER: Integer read _GetSHOW_CLASSLOADER;
{class} property SHOW_FULL_DETAIL: Integer read _GetSHOW_FULL_DETAIL;
{class} property SHOW_INITIALIZED: Integer read _GetSHOW_INITIALIZED;
{class} property TRACE_COUNT_ALLOCS: Integer read _GetTRACE_COUNT_ALLOCS;
end;
[JavaSignature('android/os/Debug')]
JDebug = interface(JObject)
['{EE4BF6EE-020D-49EF-94F2-03A4787C3D3C}']
end;
TJDebug = class(TJavaGenericImport<JDebugClass, JDebug>) end;
implementation
end.
|
unit V_ADT;
interface
type
intArray = array [1..1] of integer;
stackPtr = POINTER;
procedure add(s : stackPtr; val : integer);
procedure getElementAt(s : stackPtr; pos : integer; var val : integer);
procedure setElementAt(s : stackPtr; pos : integer; val : integer);
procedure removeElementAt(s : stackPtr; pos : integer);
function size(s : stackPtr) : integer;
function capacity(s : stackPtr) : integer;
function isEmpty(s : stackPtr) : boolean;
procedure init(var s : stackPtr);
procedure disposeStack(var s : stackPtr);
implementation
type
internalStackPtr = ^stack;
stack = record
arrPtr : ^intArray;
capacityCount : integer;
top : integer; (* index of top element *)
end;
procedure reallocStack(var s : stackPtr); FORWARD;
procedure errorIfOutOfRange(s : stackPtr; pos : integer); FORWARD;
procedure init(var s : stackPtr);
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
if(s <> NIL) then begin
writeln('Can''t initialize non-empty stack!');
halt;
end;
new(isPtr);
isPtr^.top := 0;
isPtr^.capacityCount := 16;
GetMem(isPtr^.arrPtr, SIZEOF(integer) * isPtr^.capacityCount);
s := isPtr;
end;
procedure errorIfOutOfRange(s : stackPtr; pos : integer);
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
if pos > isPtr^.top then begin
writeln('Pos out of range!');
halt;
end;
end;
procedure add(s : stackPtr; val : integer);
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
if isPtr^.top >= isPtr^.capacityCount then begin
reallocStack(s);
end;
inc(isPtr^.top);
(*$R-*)
isPtr^.arrPtr^[isPtr^.top] := val;
(*$R+*)
end;
procedure getElementAt(s : stackPtr; pos : integer; var val : integer);
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
errorIfOutOfRange(isPtr, pos);
(*$R-*)
val := isPtr^.arrPtr^[pos];
(*$R+*)
end;
procedure setElementAt(s : stackPtr; pos : integer; val : integer);
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
errorIfOutOfRange(isPtr, pos);
(*$R-*)
isPtr^.arrPtr^[pos] := val;
(*$R+*)
end;
procedure removeElementAt(s : stackPtr; pos : integer);
var
isPtr : internalStackPtr;
element : integer;
begin
isPtr := internalStackPtr(s);
errorIfOutOfRange(isPtr, pos);
element := pos + 1;
while element <= isPtr^.top do begin
(*$R-*)
isPtr^.arrPtr^[element - 1] := isPtr^.arrPtr^[element];
(*$R+*)
inc(element);
end;
(*$R-*)
isPtr^.arrPtr^[isPtr^.top] := 0;
(*$R+*)
dec(isPtr^.top);
end;
function size(s : stackPtr) : integer;
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
size := isPtr^.top;
end;
function capacity(s : stackPtr) : integer;
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
capacity := isPtr^.capacityCount;
end;
function isEmpty(s : stackPtr) : boolean;
var isPtr : internalStackPtr;
begin
isPtr := internalStackPtr(s);
isEmpty := isPtr^.top = 0;
end;
procedure disposeStack(var s : stackPtr);
var isPtr : internalStackPtr;
begin
if s = NIL then begin
writeln('Can''t dispose a uninitialized stack!');
halt;
end;
isPtr := internalStackPtr(s);
freeMem(isPtr^.arrPtr, SIZEOF(integer) * isPtr^.capacityCount);
isPtr^.arrPtr := NIL;
dispose(isPtr);
s := NIL;
end;
procedure reallocStack(var s : stackPtr);
var isPtr : internalStackPtr;
newArray : ^intArray;
i : integer;
begin
isPtr := internalStackPtr(s);
getMem(newArray, SIZEOF(INTEGER) * 2 * isPtr^.capacityCount);
for i := 1 to isPtr^.top do begin
(*$R-*)
newArray^[i] := isPtr^.arrPtr^[i];
(*$R+*)
end;
freeMem(isPtr^.arrPtr, SIZEOF(integer) * isPtr^.capacityCount);
isPtr^.capacityCount := 2 * isPtr^.capacityCount;
isPtr^.arrPtr := newArray;
end;
begin
end.
|
unit MultiBMPButton;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;
type
TButtonState = (bsNormal, bsLighted, bsPushed, bsDisabled);
type
TMultiBMPButton =
class(TGraphicControl)
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
private
fCurState : TButtonState;
fNormalImage : TBitMap;
fLightedImage : TBitMap;
fPushedImage : TBitMap;
fDisabledImage : TBitMap;
private
procedure SetState(aState : TButtonState);
public
property State : TButtonState read fCurState write SetState;
protected
procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER;
procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
procedure CMEnabledChanged(var Message: TMessage); message CM_ENABLEDCHANGED;
procedure WMEraseBkgnd(var Message: TMessage); message WM_ERASEBKGND;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
private
function GetCurrentImage : TBitMap;
protected
procedure Paint; override;
private
function GetNormalImage : TBitMap;
function GetLightedImage : TBitMap;
function GetPushedImage : TBitMap;
function GetDisabledImage : TBitMap;
procedure SetNormalImage(Image : TBitMap);
procedure SetLightedImage(Image : TBitMap);
procedure SetPushedImage(Image : TBitMap);
procedure SetDisabledImage(Image : TBitMap);
published
property NormalImage : TBitMap read GetNormalImage write SetNormalImage;
property LightedImage : TBitMap read GetLightedImage write SetLightedImage;
property PushedImage : TBitMap read GetPushedImage write SetPushedImage;
property DisabledImage : TBitMap read GetDisabledImage write SetDisabledImage;
published
property Caption;
property DragCursor;
property DragMode;
property Enabled;
property Font;
property ParentFont;
property ParentShowHint;
property PopupMenu;
property ShowHint;
//property TabOrder;
//property TabStop;
property Visible;
property OnClick;
property OnDragDrop;
property OnDragOver;
property OnEndDrag;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnStartDrag;
end;
procedure Register;
implementation
// TMultiBMPButton
constructor TMultiBMPButton.Create(AOwner: TComponent);
begin
inherited;
fNormalImage := TBitMap.Create;
fLightedImage := TBitMap.Create;
fPushedImage := TBitMap.Create;
fDisabledImage := TBitMap.Create;
fCurState := bsNormal;
Width := 64;
Height := 64;
end;
destructor TMultiBMPButton.Destroy;
begin
fNormalImage.free;
fLightedImage.free;
fPushedImage.free;
fDisabledImage.free;
inherited;
end;
procedure TMultiBMPButton.SetState(aState : TButtonState);
begin
if aState <> fCurState
then
begin
fCurState := aState;
Repaint;
end;
end;
procedure TMultiBMPButton.CMMouseEnter(var Message: TMessage);
begin
if Enabled
then State := bsLighted;
end;
procedure TMultiBMPButton.CMMouseLeave(var Message: TMessage);
begin
if Enabled
then State := bsNormal;
end;
procedure TMultiBMPButton.CMEnabledChanged(var Message: TMessage);
begin
inherited;
if Enabled
then State := bsNormal
else State := bsDisabled;
end;
procedure TMultiBMPButton.WMEraseBkgnd(var Message: TMessage);
begin
Message.Result := 1;
end;
procedure TMultiBMPButton.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
inherited;
if Enabled
then State := bsPushed;
end;
procedure TMultiBMPButton.MouseMove(Shift: TShiftState; X, Y: Integer);
begin
inherited;
end;
procedure TMultiBMPButton.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
inherited;
if Enabled and (fCurState = bsPushed)
then State := bsLighted;
end;
function TMultiBMPButton.GetCurrentImage : TBitMap;
begin
case fCurState of
bsNormal :
result := fNormalImage;
bsLighted :
result := fLightedImage;
bsPushed :
result := fPushedImage;
bsDisabled :
result := fDisabledImage;
else result := nil;
end;
end;
procedure TMultiBMPButton.Paint;
var
Image : TBitMap;
xSize : word;
ySize : word;
begin
Image := GetCurrentImage;
xSize := Image.Width;
ySize := Image.Height;
if (xSize > 0) and (ySize > 0)
then
begin
Width := xSize;
Height := ySize;
Canvas.CopyRect(Canvas.ClipRect, Image.Canvas, Image.Canvas.ClipRect)
end;
end;
function TMultiBMPButton.GetNormalImage : TBitMap;
begin
result := fNormalImage;
end;
function TMultiBMPButton.GetLightedImage : TBitMap;
begin
result := fLightedImage;
end;
function TMultiBMPButton.GetPushedImage : TBitMap;
begin
result := fPushedImage;
end;
function TMultiBMPButton.GetDisabledImage : TBitMap;
begin
result := fDisabledImage;
end;
procedure TMultiBMPButton.SetNormalImage(Image : TBitMap);
begin
fNormalImage.Assign(Image);
Invalidate;
end;
procedure TMultiBMPButton.SetLightedImage(Image : TBitMap);
begin
fLightedImage.Assign(Image);
Invalidate;
end;
procedure TMultiBMPButton.SetPushedImage(Image : TBitMap);
begin
fPushedImage.Assign(Image);
Invalidate;
end;
procedure TMultiBMPButton.SetDisabledImage(Image : TBitMap);
begin
fDisabledImage.Assign(Image);
Invalidate;
end;
// Register component
procedure Register;
begin
RegisterComponents('Five', [TMultiBMPButton]);
end;
end.
|
unit UMultiEPGFrame;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes,
System.Variants,
FMX.Types, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.StdCtrls,
FMXTee.Chart, FMXTee.Series.Gantt, FMXTee.Procs, FMXTee.Series, FMX.Gestures,
UMainDataModule, StrUtils, Data.DB, DateUtils;
type
TMultiEPGFrame = class(TFrame)
MultiEPGTopToolBar: TToolBar;
MultiEPGTopLabel: TLabel;
procedure ChartScroll(Sender: TObject);
private
{ Private declarations }
fChart: TChart;
fGanttSeriesChannels: TGanttSeries;
fGanttSeriesGuides: TGanttSeries;
fLineSeriesNow: TLineSeries;
fLastPosition: TPointF;
fGanttSeriesChannelsMax: Double;
fGanttSeriesChannelsMin: Double;
fChannelNumber: Integer;
fGanttSeriesGuidesMax: TDateTime;
fGanttSeriesGuidesMin: TDateTime;
fChMin: Integer;
fChMax: Integer;
procedure loadNextChannels(vChMin: Integer; vChMax: Integer);
public
{ Public declarations }
procedure init;
Constructor Create(AOwner: TComponent); override;
end;
implementation
{$R *.fmx}
constructor TMultiEPGFrame.Create(AOwner: TComponent);
begin
// Execute the parent (TObject) constructor first
inherited; // Call the parent Create method
end;
procedure TMultiEPGFrame.loadNextChannels(vChMin: Integer; vChMax: Integer);
var
lChNumber: Integer;
lMarkLength: Integer;
lDefaultServiceReference: string;
lShowCount: Integer;
lShowColor: Integer;
lShowTitle: string;
begin
lChNumber := vChMin;
lMarkLength := 10;
MainDataModule.DreamFDMemTableChannelList.RecNo := vChMin;
while not MainDataModule.DreamFDMemTableChannelList.EOF do
begin
fGanttSeriesChannels.AddGanttColor(now, now, lChNumber,
AnsiLeftStr(MainDataModule.DreamFDMemTableChannelList.FieldByName
('servicename').AsString, 8), TAlphaColorRec.Honeydew);
lDefaultServiceReference := MainDataModule.DreamFDMemTableChannelList.
FieldByName('servicereference').AsString;
if MainDataModule.DreamFDMemTableTextEPG.Active then
begin
MainDataModule.DreamRESTResponseDataSetAdapterTextEPG.ClearDataSet;
MainDataModule.DreamRESTResponseDataSetAdapterTextEPG.Active := False;
MainDataModule.DreamFDMemTableTextEPG.Close;
end;
MainDataModule.DreamRESTResponseDataSetAdapterTextEPG.FieldDefs.Clear;
// sRef parameter
MainDataModule.DreamRESTRequestTextEPG.Params[0].Value :=
lDefaultServiceReference;
try
MainDataModule.DreamRESTRequestTextEPG.Execute;
except
if MainDataModule.DreamFDMemTableTextEPG.State = dsBrowse then
begin
MainDataModule.DreamFDMemTableTextEPG.Close;
end;
MainDataModule.DreamRESTRequestTextEPG.Execute;
end;
lShowCount := 0;
while not MainDataModule.DreamFDMemTableTextEPG.EOF do
begin
if lShowCount = 0 then
begin
lShowColor := TAlphaColorRec.Beige;
end
else
begin
lShowColor := TAlphaColorRec.Honeydew;
end;
try
// readjust minimum on the fly
if (lChNumber = 0) and (lShowCount = 0) then
begin
fGanttSeriesGuidesMin :=
UnixToDateTime(MainDataModule.DreamFDMemTableTextEPG.FieldByName
('begin_timestamp').AsInteger, False);
fChart.BottomAxis.Minimum := fGanttSeriesGuidesMin;
fGanttSeriesGuidesMax := IncMinute(fGanttSeriesGuidesMin, 120);
fChart.BottomAxis.Maximum := fGanttSeriesGuidesMax;
end;
lMarkLength := Trunc(MainDataModule.DreamFDMemTableTextEPG.FieldByName
('duration_sec').AsFloat / 400) - 1;
if lMarkLength < 0 then
begin
lMarkLength := 0;
end;
if lMarkLength = 0 then
begin
lShowTitle := ' ';
end
else
begin
lShowTitle :=
AnsiLeftStr(MainDataModule.DreamFDMemTableTextEPG.FieldByName
('title').AsString, lMarkLength);
if (Length(lShowTitle) <
Length(MainDataModule.DreamFDMemTableTextEPG.FieldByName('title')
.AsString)) then
begin
lShowTitle := lShowTitle + ' ...';
if lShowTitle = ' ...' then
lShowTitle := ' ';
end;
end;
fGanttSeriesGuides.AddGanttColor
(UnixToDateTime(MainDataModule.DreamFDMemTableTextEPG.FieldByName
('begin_timestamp').AsInteger, False),
UnixToDateTime(MainDataModule.DreamFDMemTableTextEPG.FieldByName
('begin_timestamp').AsInteger + MainDataModule.DreamFDMemTableTextEPG.
FieldByName('duration_sec').AsInteger, False), lChNumber, lShowTitle,
lShowColor);
except
inc(lShowCount);
if lShowCount = 10 then
Break;
MainDataModule.DreamFDMemTableTextEPG.Next;
end;
inc(lShowCount);
if lShowCount = vChMax then
Break;
MainDataModule.DreamFDMemTableTextEPG.Next;
end;
inc(lChNumber);
if lChNumber = vChMax then
Break;
MainDataModule.DreamFDMemTableChannelList.Next;
end;
end;
procedure TMultiEPGFrame.ChartScroll(Sender: TObject);
begin
{ if (fChart.BottomAxis.Minimum < fGanttSeriesGuidesMin) then
begin
fChart.BottomAxis.Minimum := fGanttSeriesGuidesMin;
fChart.BottomAxis.Maximum := fChart.BottomAxis.Minimum +
fGanttSeriesGuidesMax;
end;
if (fChart.BottomAxis.Maximum > 70) then
begin
fChart.BottomAxis.Minimum := 20;
fChart.BottomAxis.Maximum := 70;
end; }
if (fChart.LeftAxis.Minimum < fGanttSeriesChannelsMin) then
begin
fChart.LeftAxis.Minimum := fGanttSeriesChannelsMin;
fChart.LeftAxis.Maximum := fGanttSeriesChannelsMax;
end;
if (fChart.LeftAxis.Maximum > fChannelNumber - 0.5) then
begin
fChart.LeftAxis.Maximum := fChannelNumber - 0.5;
fChart.LeftAxis.Minimum := fChart.LeftAxis.Maximum - fChannelNumber + 0.5;
// fGanttSeriesChannels.Clear;
// fGanttSeriesGuides.Clear;
// loadNextChannels(7, 14);
end;
end;
procedure TMultiEPGFrame.init;
var
lChMin: Integer;
begin
fChart := TChart.Create(self);
fChart.Parent := self;
fChart.Align := TAlignLayout.Client;
fChart.View3D := False;
fChart.BottomAxis.Visible := True;
fChart.BottomAxis.OtherSide := True;
fChart.Frame.Visible := False;
fChart.Width := self.Width;
fChart.Height := self.Height;
fChart.MarginRight := 0;
fChart.MarginBottom := 0;
fChart.MarginLeft := 0;
fChart.MarginTop := 1;
fChart.LeftAxis.LabelsSize := 80;
fChart.Legend.Visible := False;
fChart.Border.Visible := False;
fChart.Color := TAlphaColorRec.White;
fChart.LeftAxis.Inverted := True;
fChart.LeftAxis.TickOnLabelsOnly := True;
fChart.LeftAxis.MinorTicks.Visible := False;
fChart.BottomAxis.MinorTicks.Visible := False;
fChart.AllowZoom := False;
fChart.AllowPanning := TPanningMode.pmBoth;
fChart.ScrollMouseButton := TMouseButton.mbLeft;
fChart.OnScroll := self.ChartScroll;
// fChannelNumber := MainDataModule.DreamFDMemTableChannelList.RecordCount;
fChannelNumber := 7;
fChMin := 0;
fChMax := fChannelNumber;
fGanttSeriesChannelsMin := -0.5;
fGanttSeriesChannelsMax := fChannelNumber - 1;
fChart.LeftAxis.Automatic := False;
fChart.LeftAxis.Minimum := fGanttSeriesChannelsMin;
fChart.LeftAxis.Maximum := fGanttSeriesChannelsMax;
fGanttSeriesGuidesMin := now;
fGanttSeriesGuidesMax := IncMinute(fGanttSeriesGuidesMin, 120);
fChart.BottomAxis.Automatic := False;
fChart.BottomAxis.Maximum := fGanttSeriesGuidesMax;
fChart.BottomAxis.Minimum := fGanttSeriesGuidesMin;
fGanttSeriesChannels := TGanttSeries.Create(self);
fGanttSeriesGuides := TGanttSeries.Create(self);
fLineSeriesNow := TLineSeries.Create(self);
if not MainDataModule.DreamFDMemTableChannelList.Active then
begin
MainDataModule.DreamFDMemTableChannelList.Open;
MainDataModule.DreamFDMemTableChannelList.First;
end;
// loading the next channels
loadNextChannels(0, fChannelNumber);
fLineSeriesNow.AddXY(now, fGanttSeriesChannelsMin, '',
TAlphaColorRec.Darksalmon);
fLineSeriesNow.AddXY(now, fChannelNumber + 1.5, '',
TAlphaColorRec.Darksalmon);
fLineSeriesNow.LinePen.Width := 2;
fGanttSeriesChannels.Pointer.VertSize := 20;
fGanttSeriesGuides.Pointer.VertSize := 20;
fChart.AddSeries(fGanttSeriesChannels);
fChart.AddSeries(fGanttSeriesGuides);
fChart.AddSeries(fLineSeriesNow);
fGanttSeriesGuides.Marks.Visible := True;
fGanttSeriesGuides.Marks.Transparent := True;
fGanttSeriesGuides.Marks.Clip := True;
end;
end.
|
{ Subroutine SST_R_PAS_DTYPE_RECORD (D)
*
* Process the RECORD_DATA_TYPE syntax. D is the data type definition block that
* will be filled in.
}
module sst_r_pas_DTYPE_RECORD;
define sst_r_pas_dtype_record;
%include 'sst_r_pas.ins.pas';
procedure sst_r_pas_dtype_record ( {process RECORD_DATA_TYPE}
in out d: sst_dtype_t); {returned pointer to newly created data type}
var
tag: sys_int_machine_t; {syntax tags from .syn file}
str_h: syo_string_t; {handle to string for a tag}
align_old: sys_int_adr_t; {saved copy of old alignment rule}
start_pp: sst_symbol_pp_t; {adr of start of fields chain pointer}
variant: sys_int_machine_t; {sequential overlay variant number, 0 = base}
val: sst_var_value_t; {user variant ID value}
val_dtype_p: sst_dtype_p_t; {points to data type of user variant IDs}
pack: boolean; {TRUE when fields are being packed into rec}
variant_used: boolean; {TRUE if fields created with curr VARIANT}
{
*************************************************************************
*
* Local subroutine RECORD_FIELD (NEXT_PP, D, OFSA, OFSB)
*
* Process RECORD_FIELD syntax. NEXT_PP is the address of the pointer that
* will point to the next field name symbol. NEXT_PP will be updated to point
* to the new end of chain NIL pointer. D is the data type descriptor for the
* whole record. The size and alignment fields will be updated for the
* fields read in. OFSA and OFSB are the current offsets of where the next
* field will start within the whole record. OFSA is the offset in whole
* machine addresses. OFSB is any additional offset in bits. OFSA and OFSB
* will be updated to after the new field.
}
procedure record_field (
in out next_pp: sst_symbol_pp_t; {pointer to end of chain pointer}
in out d: sst_dtype_t; {data type block for whole record}
in out ofsa: sys_int_max_t; {machine address offset from record start}
in out ofsb: sys_int_machine_t); {bit offset within machine address}
var
tag: sys_int_machine_t; {syntax tags from .syn file}
str_h: syo_string_t; {handle to string for a tag}
sym_first_p: sst_symbol_p_t; {pointer to first symbol in chain}
sym_p: sst_symbol_p_t; {pointer to current symbol}
dt_p: sst_dtype_p_t; {pointer to data type for fields}
dt2_p: sst_dtype_p_t; {points to base data type for fields}
sz: sys_int_max_t; {scratch size value}
scope_save_p: sst_scope_p_t; {saved pointer to scope for field names}
stat: sys_err_t; {completion status code}
label
loop;
begin
syo_level_down; {down into RECORD_FIELD syntax}
sym_first_p := nil; {indicate no symbol created yet}
loop: {back here each new RECORD_FIELD tag}
syo_get_tag_msg (tag, str_h, 'sst_pas_read', 'dtype_bad', nil, 0); {get next tag}
case tag of
{
* RECORD_FIELD is empty. This should only occurr as the first tag.
}
syo_tag_end_k: begin
syo_level_up; {up from RECORD_FIELD syntax}
return;
end;
{
* Tag was the name of a field that will represent the data type to
* be read in later.
}
1: begin
sst_symbol_new {create new field name symbol}
(str_h, syo_charcase_down_k, sym_p, stat);
syo_error_abort (stat, str_h, '', '', nil, 0);
sym_p^.symtype := sst_symtype_field_k; {new symbol is field of a record data type}
sym_p^.flags := sym_p^.flags + [sst_symflag_def_k]; {symbol will be defined}
sym_p^.field_parent_p := addr(d); {point to data type for whole record}
sym_p^.field_next_p := nil; {init to this field is end of fields chain}
sym_p^.field_variant := variant; {set sequential variant ID}
variant_used := true; {flag that fields created in this variant}
sym_p^.field_var_val := val; {set user variant ID}
if sym_first_p = nil then begin {this is first new symbol ?}
sym_first_p := sym_p; {save pointer to first symbol for this field}
end;
next_pp^ := sym_p; {link new symbol to end of field names chain}
next_pp := addr(sym_p^.field_next_p); {update pointer to new end of chain}
end;
{
* Tag was the data type that all the previous fields represent.
}
2: begin
dt_p := nil; {indicate to create new data type descriptor}
scope_save_p := sst_scope_p; {save pointer to field names' scope}
sst_scope_p := sst_scope_p^.parent_p; {pop scope one level back}
sst_names_p := sst_scope_p;
sst_r_pas_data_type (dt_p); {create data type descriptor}
sst_scope_p := scope_save_p; {restore scope to that for field names}
sst_names_p := sst_scope_p;
{
* Make sure this is a legal field data type if the record is packed.
}
if pack then begin {record fields are being packed together ?}
dt2_p := dt_p; {resolve pointer to base field data type}
while dt2_p^.dtype = sst_dtype_copy_k do dt2_p := dt2_p^.copy_dtype_p;
case dt2_p^.dtype of {what is base data type ?}
sst_dtype_int_k,
sst_dtype_enum_k,
sst_dtype_bool_k,
sst_dtype_set_k,
sst_dtype_range_k: ; {all the data types that may be packed}
otherwise
syo_error (str_h, 'sst_pas_read', 'dtype_packed_bad', nil, 0);
end;
end;
sym_p := sym_first_p; {init to first symbol for this field}
while sym_p <> nil do begin {once for each name for this field}
if dt_p^.align > 0 then begin {this field more than just bit-aligned ?}
if pack then begin {packing fields, but field not bit-aligned ?}
syo_error (str_h, 'sst_pas_read', 'dtype_packed_aligned', nil, 0);
end;
ofsa := ofsa + {go to end of any partially used address}
((ofsb + sst_config.bits_adr - 1) div sst_config.bits_adr);
ofsb := 0;
ofsa := {add padding for alignment, if needed}
((ofsa + dt_p^.align - 1) div dt_p^.align) * dt_p^.align;
d.align_nat := {update alignment for whole record}
max(d.align_nat, dt_p^.align);
end; {OFSA, OFSB all set for this new field start}
sym_p^.field_dtype_p := dt_p; {point symbol to data type for this field}
sym_p^.field_ofs_adr := ofsa; {offset in machine addresses}
sym_p^.field_ofs_bits := ofsb; {additional offset in bits}
sym_p := sym_p^.field_next_p; {advance to next name symbol for this field}
if pack
then begin {record is PACKED, use BITS_MIN field size}
ofsb := ofsb + dt_p^.bits_min; {skip over just bits needed for this field}
sz := ofsb div sst_config.bits_adr; {number of whole addresses in OFSB}
ofsa := ofsa + sz; {move whole addresses into OFSA}
ofsb := ofsb - (sst_config.bits_adr * sz);
end
else begin {record is NOT packed, use SIZE_USED size}
ofsa := ofsa + dt_p^.size_used; {skip over whole addresses used by field}
end
; {all done updating OFSA,OFSB to after field}
sz := (ofsa * sst_config.bits_adr) + ofsb; {min new curr offset in bits}
d.bits_min := max(d.bits_min, sz); {update record size to include new field}
end;
syo_level_up; {up from RECORD_FIELD syntax}
return;
end;
otherwise
syo_error_tag_unexp (tag, str_h);
end; {end of RECORD_FIELD tag cases}
goto loop; {back for next RECORD_FIELD tag}
end;
{
*************************************************************************
*
* Local subroutine RECORD_FIELDS (NEXT_PP, D, OFS_A, OFS_B)
*
* Read the RECORD_FIELDS syntax. NEXT_PP is the address of the pointer that
* will point to the next field name symbol. NEXT_PP will be updated to point
* to the new end of chain NIL pointer. D is the data type descriptor for the
* whole record. The size and alignment fields will be updated for the
* fields read in. OFS_A and OFS_B are the current offsets of where the next
* field will start within the whole record. OFS_A is the offset in whole
* machine addresses. OFS_B is any additional offset in bits.
}
procedure record_fields (
in out next_pp: sst_symbol_pp_t; {pointer to end of chain pointer}
in out d: sst_dtype_t; {data type block for whole record}
in ofs_a: sys_int_max_t; {machine address offset from record start}
in ofs_b: sys_int_machine_t); {bit offset within machine address}
var
tag: sys_int_machine_t; {syntax tags from .syn file}
str_h: syo_string_t; {handle to string for a tag}
ofsa: sys_int_max_t; {current offsets to end of last invariant rec}
ofsb: sys_int_machine_t;
dt: sst_dtype_k_t; {scratch data type ID}
err: boolean; {scratch error flag}
label
loop;
begin
syo_level_down; {down into RECORD_FIELDS syntax}
ofsa := ofs_a; {init current offset to start given}
ofsb := ofs_b;
loop: {back here each new non-variant field}
syo_get_tag_msg (tag, str_h, 'sst_pas_read', 'dtype_bad', nil, 0); {get next tag}
case tag of
syo_tag_end_k: begin {no more tags in this RECORD_FIELDS syntax}
syo_level_up; {up from RECORD_FIELDS syntax}
return;
end;
1: begin {tag is for a new non-variant field}
record_field (next_pp, d, ofsa, ofsb); {process RECORD_FIELD syntax}
end;
2: begin {tag is data type for later overlay IDs}
if variant <> 0 then begin {already within a variant part ?}
syo_error (str_h, 'sst_pas_read', 'dtype_case_nested', nil, 0);
end;
val_dtype_p := nil; {indicate find old descriptor, if possible}
sst_r_pas_data_type (val_dtype_p); {get pointer to variant IDs data type}
sst_dtype_resolve ( {resolve base data type}
val_dtype_p^, val_dtype_p, dt);
case dt of {what kind of data type is it ?}
sst_dtype_int_k, {all the legal data types}
sst_dtype_enum_k,
sst_dtype_bool_k,
sst_dtype_char_k: ;
otherwise
syo_error (str_h, 'sst', 'dtype_not_ordinal2', nil, 0);
end;
end;
3: begin {tag is for new overlay ID expression}
if {OK to increment to next sequential variant ?}
(variant = 0) or {currently in non-variant part ?}
variant_used {fields created with current variant ID ?}
then begin
variant := variant + 1; {make sequential overlay ID for this variant}
variant_used := false; {init to no fields with this new variant yet}
end;
sst_r_pas_exp_eval (val); {get user overlay ID expression value}
case val.dtype of {what is data type of overlay ID value ?}
sst_dtype_int_k: begin
err := not sst_dtype_convertable (
sst_dtype_int_max_p^, {value data type}
val_dtype_p^); {data type must be convertable to}
end;
sst_dtype_enum_k: begin
err := not sst_dtype_convertable (
val.enum_p^.enum_dtype_p^, {value data type}
val_dtype_p^); {data type must be convertable to}
end;
sst_dtype_bool_k: begin
err := not sst_dtype_convertable (
sst_dtype_bool_p^, {value data type}
val_dtype_p^); {data type must be convertable to}
end;
sst_dtype_char_k: begin
err := not sst_dtype_convertable (
sst_dtype_char_p^, {value data type}
val_dtype_p^); {data type must be convertable to}
end;
otherwise
err := true; {definately a data type mismatch error}
end;
if err then begin {overlay ID doesn't match data type ?}
syo_error (str_h, 'sst', 'dtype_exp_mismatch', nil, 0);
end;
end;
4: begin {tag is for fields within current variant}
record_fields (next_pp, d, ofsa, ofsb); {process this variant case}
end;
otherwise
syo_error_tag_unexp (tag, str_h);
end; {end of RECORD_FIELDS TAG cases}
goto loop; {back for next tag in RECORD_FIELDS}
end;
{
*************************************************************************
*
* Start of main routine.
}
begin
syo_level_down; {down into RECORD_DATA_TYPE syntax}
variant := 0; {init to next fields are base fields}
variant_used := false; {init to no fields of this variant found}
val.dtype := sst_dtype_int_k; {init user variant ID to harmless value}
val.int_val := 0;
syo_get_tag_msg ( {get alignment tag}
tag, str_h, 'sst_pas_read', 'dtype_bad', nil, 0);
{
* The keywords preceeding RECORD effect the alignment of the whole record,
* and the alignment of the fields within the record. SST_ALIGN will be
* set to the new alignment rules for fields in this record. The old
* alignment rule will be saved in ALIGN_OLD.
}
align_old := sst_align; {save old alignment rule}
pack := false; {init to fields not PACKED}
case tag of
1: begin {ALIGNED}
sst_align := sst_align_natural_k; {fields will be naturally aligned}
end;
2: begin {UNALIGNED}
sst_align := sst_align_natural_k; {align fields naturally within record}
end;
3: begin {PACKED}
sst_align := 0; {fields will be bit-aligned}
pack := true; {indicate fields are being packed}
end;
4: begin {no explicit keyword, use current alignment}
end;
otherwise
syo_error_tag_unexp (tag, str_h);
end; {end of alignment directive cases}
sst_scope_new; {make new scope for all the field names}
syo_get_tag_msg ( {get RECORD_FIELDS tag}
tag, str_h, 'sst_pas_read', 'dtype_bad', nil, 0);
if tag <> 1 then begin
syo_error_tag_unexp (tag, str_h);
end;
d.dtype := sst_dtype_rec_k; {this data type is a record}
d.bits_min := 0; {no size since no fields yet}
d.align_nat := 0;
d.size_used := 0;
d.rec_scope_p := sst_scope_p; {point to scope for field names}
d.rec_first_p := nil; {init field names chain to empty}
start_pp := addr(d.rec_first_p); {init adr of start of fields chain pointer}
record_fields (start_pp, d, 0, 0); {create the fields for the record}
d.size_used := {make min machine addresses actually used}
(d.bits_min + sst_config.bits_adr - 1) div sst_config.bits_adr;
sst_scope_old; {restore old current scope}
sst_align := align_old; {restore old alignment rule}
syo_level_up; {up from RECORD_DATA_TYPE syntax}
end;
|
unit FindUnit.SearchString;
interface
uses
Classes, FindUnit.PasParser, Generics.Collections, FindUnit.Header;
type
TSearchString = class(TObject)
protected
FCandidates: TObjectList<TPasFile>;
function FoundAllEntries(Entries: TStringList; const Text: string): Boolean;
function GetMatcherOnItemListType(Item: TPasFile; SearchString: TStringList; List: TStringList; const Sufix: string; var ItensFound: integer): string;
function GetMatchesOnItem(Item: TPasFile; SearchString: TStringList; var ItensFound: integer): string;
public
constructor Create(Candidates: TObjectList<TPasFile>);
destructor Destroy; override;
function GetMatch(const SearchString: string): TStringList;
end;
implementation
uses
SysUtils;
{ TSearchString }
constructor TSearchString.Create(Candidates: TObjectList<TPasFile>);
begin
FCandidates := Candidates;
end;
destructor TSearchString.Destroy;
begin
inherited;
end;
function TSearchString.FoundAllEntries(Entries: TStringList; const Text: string): Boolean;
var
I: Integer;
Entry: string;
begin
Result := True;
for I := 0 to Entries.Count -1 do
begin
Entry := Entries[i];
Result := Pos(Entry, Text) <> 0;
if not Result then
Exit;
end;
end;
function TSearchString.GetMatch(const SearchString: string): TStringList;
var
I: Integer;
Item: TPasFile;
ItensFound: Integer;
SearchList: TStringList;
begin
ItensFound := 0;
Result := TStringList.Create;
SearchList := TStringList.Create;
try
SearchList.Delimiter := ' ';
SearchList.DelimitedText := UpperCase(SearchString);
for I := 0 to FCandidates.Count - 1 do
begin
Item := FCandidates[I];
if FoundAllEntries(SearchList, UpperCase(Item.OriginUnitName) + '.') then
begin
Result.Text := Result.Text + Item.OriginUnitName + '.* - Unit';
Inc(ItensFound);
end;
Result.Text := Result.Text + GetMatchesOnItem(Item, SearchList, ItensFound);
if ItensFound >= MAX_RETURN_ITEMS then
Exit;
end;
finally
SearchList.Free;
end;
end;
function TSearchString.GetMatcherOnItemListType(Item: TPasFile; SearchString: TStringList; List: TStringList; const Sufix: string; var ItensFound: integer): string;
var
LocalSearchUpperCase: TStringList;
iString: Integer;
ItemToFind: string;
MatchList: TStringList;
FoundAll: Boolean;
begin
MatchList := TStringList.Create;
LocalSearchUpperCase := TStringList.Create;
try
LocalSearchUpperCase.Text := UpperCase(List.Text);
for iString := 0 to LocalSearchUpperCase.Count - 1 do
begin
ItemToFind := UpperCase(Item.OriginUnitName) + '.' + LocalSearchUpperCase[iString];
if FoundAllEntries(SearchString, ItemToFind) then
begin
MatchList.Add(Item.OriginUnitName + '.' + List[iString] + Sufix);
Inc(ItensFound);
if ItensFound > MAX_RETURN_ITEMS then
Exit;
end;
end;
finally
Result := MatchList.Text;
MatchList.Free;
LocalSearchUpperCase.Free;
end;
end;
function TSearchString.GetMatchesOnItem(Item: TPasFile; SearchString: TStringList; var ItensFound: integer): string;
var
ListType: TListType;
List: TStringList;
I: TListType;
begin
Result := '';
for ListType := Low(TListType) to High(TListType) do
begin
List := Item.GetListFromType(ListType);
Result := Result + GetMatcherOnItemListType(Item, SearchString, List, strListTypeDescription[ListType], ItensFound);
if ItensFound >= MAX_RETURN_ITEMS then
Exit;
end;
end;
end.
|
unit MdiChilds.ImportResourcesKSR;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, MDIChilds.CustomDialog, Vcl.StdCtrls, Vcl.ExtCtrls, MdiChilds.ProgressForm, ActionHandler;
type
TFmImportResourcesKSR = class(TFmProcess)
edtFile: TLabeledEdit;
btnOpen: TButton;
OpenDialog: TOpenDialog;
rgMode: TRadioGroup;
procedure btnOpenClick(Sender: TObject);
private
{ Private declarations }
protected
procedure DoOk(Sender: TObject; ProgressForm: TFmProgress;
var ShowMessage: Boolean); override;
public
{ Public declarations }
end;
TImportResourcesKSRActionHandler = class (TAbstractActionHandler)
public
procedure ExecuteAction(UserData: Pointer = nil); override;
end;
var
FmImportResourcesKSR: TFmImportResourcesKSR;
implementation
{$R *.dfm}
uses Parsers.Excel.Resources.KSR, Parsers.Excel;
{ TFmImportResourcesKSR }
procedure TFmImportResourcesKSR.btnOpenClick(Sender: TObject);
begin
if OpenDialog.Execute then
edtFile.Text := OpenDialog.FileName;
end;
procedure TFmImportResourcesKSR.DoOk(Sender: TObject; ProgressForm: TFmProgress; var ShowMessage: Boolean);
var
Parser: IExcelParser;
begin
Parser := TResourceKRSParser.Create(rgMode.ItemIndex);
try
Parser.ParseDoc(edtFile.Text);
finally
Parser := nil;
end;
ShowMessage := True;
end;
{ TImportResourcesKSRActionHandler }
procedure TImportResourcesKSRActionHandler.ExecuteAction;
begin
TFmImportResourcesKSR.Create(Application).Show;
end;
begin
ActionHandlerManager.RegisterActionHandler('Импорт ресурсов КРС', hkDefault, TImportResourcesKSRActionHandler);
end.
|
inherited dmCtasReceber: TdmCtasReceber
OldCreateOrder = True
inherited qryManutencao: TIBCQuery
SQLInsert.Strings = (
'INSERT INTO STWFATTCOB'
' (TIPO_DOC, FIL_ORIG, FATURA, ANO, FIL_COBR, CGC, NOME, TOT_FAT' +
'URA, DT_EMISSAO, DT_VENCTO, DT_PAGTO, DT_BAIXA, DT_COMPENSACAO, ' +
'BANCO, AGENCIA, CONTA, CARTEIRA, NR_BOLETO, VLR_DESC, VLR_JUROS,' +
' VLR_PAGO, STATUS, DT_STATUS, VENDEDOR, TRANSMITE, SERVICO, CGC_' +
'FATURADO, OBSERVACAO, DT_AVISO1, DT_AVISO2, DT_SPC, DT_RECIBO, D' +
'T_DESCONTO, TX_MORA, TX_MULTA, DIA_PROTESTO, TIT_DESC, DT_ALTERA' +
'CAO, OPERADOR, NRO_REMESSA)'
'VALUES'
' (:TIPO_DOC, :FIL_ORIG, :FATURA, :ANO, :FIL_COBR, :CGC, :NOME, ' +
':TOT_FATURA, :DT_EMISSAO, :DT_VENCTO, :DT_PAGTO, :DT_BAIXA, :DT_' +
'COMPENSACAO, :BANCO, :AGENCIA, :CONTA, :CARTEIRA, :NR_BOLETO, :V' +
'LR_DESC, :VLR_JUROS, :VLR_PAGO, :STATUS, :DT_STATUS, :VENDEDOR, ' +
':TRANSMITE, :SERVICO, :CGC_FATURADO, :OBSERVACAO, :DT_AVISO1, :D' +
'T_AVISO2, :DT_SPC, :DT_RECIBO, :DT_DESCONTO, :TX_MORA, :TX_MULTA' +
', :DIA_PROTESTO, :TIT_DESC, :DT_ALTERACAO, :OPERADOR, :NRO_REMES' +
'SA)')
SQLDelete.Strings = (
'DELETE FROM STWFATTCOB'
'WHERE'
' TIPO_DOC = :Old_TIPO_DOC AND FIL_ORIG = :Old_FIL_ORIG AND FATU' +
'RA = :Old_FATURA AND ANO = :Old_ANO')
SQLUpdate.Strings = (
'UPDATE STWFATTCOB'
'SET'
' TIPO_DOC = :TIPO_DOC, FIL_ORIG = :FIL_ORIG, FATURA = :FATURA, ' +
'ANO = :ANO, FIL_COBR = :FIL_COBR, CGC = :CGC, NOME = :NOME, TOT_' +
'FATURA = :TOT_FATURA, DT_EMISSAO = :DT_EMISSAO, DT_VENCTO = :DT_' +
'VENCTO, DT_PAGTO = :DT_PAGTO, DT_BAIXA = :DT_BAIXA, DT_COMPENSAC' +
'AO = :DT_COMPENSACAO, BANCO = :BANCO, AGENCIA = :AGENCIA, CONTA ' +
'= :CONTA, CARTEIRA = :CARTEIRA, NR_BOLETO = :NR_BOLETO, VLR_DESC' +
' = :VLR_DESC, VLR_JUROS = :VLR_JUROS, VLR_PAGO = :VLR_PAGO, STAT' +
'US = :STATUS, DT_STATUS = :DT_STATUS, VENDEDOR = :VENDEDOR, TRAN' +
'SMITE = :TRANSMITE, SERVICO = :SERVICO, CGC_FATURADO = :CGC_FATU' +
'RADO, OBSERVACAO = :OBSERVACAO, DT_AVISO1 = :DT_AVISO1, DT_AVISO' +
'2 = :DT_AVISO2, DT_SPC = :DT_SPC, DT_RECIBO = :DT_RECIBO, DT_DES' +
'CONTO = :DT_DESCONTO, TX_MORA = :TX_MORA, TX_MULTA = :TX_MULTA, ' +
'DIA_PROTESTO = :DIA_PROTESTO, TIT_DESC = :TIT_DESC, DT_ALTERACAO' +
' = :DT_ALTERACAO, OPERADOR = :OPERADOR, NRO_REMESSA = :NRO_REMES' +
'SA'
'WHERE'
' TIPO_DOC = :Old_TIPO_DOC AND FIL_ORIG = :Old_FIL_ORIG AND FATU' +
'RA = :Old_FATURA AND ANO = :Old_ANO')
SQLRefresh.Strings = (
'SELECT TIPO_DOC, FIL_ORIG, FATURA, ANO, FIL_COBR, CGC, NOME, TOT' +
'_FATURA, DT_EMISSAO, DT_VENCTO, DT_PAGTO, DT_BAIXA, DT_COMPENSAC' +
'AO, BANCO, AGENCIA, CONTA, CARTEIRA, NR_BOLETO, VLR_DESC, VLR_JU' +
'ROS, VLR_PAGO, STATUS, DT_STATUS, VENDEDOR, TRANSMITE, SERVICO, ' +
'CGC_FATURADO, OBSERVACAO, DT_AVISO1, DT_AVISO2, DT_SPC, DT_RECIB' +
'O, DT_DESCONTO, TX_MORA, TX_MULTA, DIA_PROTESTO, TIT_DESC, DT_AL' +
'TERACAO, OPERADOR, NRO_REMESSA FROM STWFATTCOB'
'WHERE'
' TIPO_DOC = :Old_TIPO_DOC AND FIL_ORIG = :Old_FIL_ORIG AND FATU' +
'RA = :Old_FATURA AND ANO = :Old_ANO')
SQLLock.Strings = (
'SELECT NULL FROM STWFATTCOB'
'WHERE'
'TIPO_DOC = :Old_TIPO_DOC AND FIL_ORIG = :Old_FIL_ORIG AND FATURA' +
' = :Old_FATURA AND ANO = :Old_ANO'
'FOR UPDATE WITH LOCK')
SQL.Strings = (
'SELECT'
' COB.TIPO_DOC,'
' COB.FIL_ORIG,'
' COB.FATURA,'
' COB.ANO,'
' COB.FIL_COBR,'
' COB.CGC,'
' COB.NOME,'
' COB.TOT_FATURA, '
' COB.DT_EMISSAO, '
' COB.DT_VENCTO, '
' COB.DT_PAGTO, '
' COB.DT_BAIXA, '
' COB.DT_COMPENSACAO, '
' COB.BANCO, '
' COB.AGENCIA, '
' COB.CONTA, '
' COB.CARTEIRA, '
' COB.NR_BOLETO, '
' COB.VLR_DESC, '
' COB.VLR_JUROS, '
' COB.VLR_PAGO, '
' COB.STATUS, '
' COB.DT_STATUS, '
' COB.VENDEDOR, '
' COB.TRANSMITE, '
' COB.SERVICO, '
' COB.CGC_FATURADO, '
' COB.OBSERVACAO, '
' COB.DT_AVISO1, '
' COB.DT_AVISO2, '
' COB.DT_SPC, '
' COB.DT_RECIBO, '
' COB.DT_DESCONTO,'
' COB.TX_MORA, '
' COB.TX_MULTA, '
' COB.DIA_PROTESTO, '
' COB.TIT_DESC, '
' COB.DT_ALTERACAO, '
' COB.OPERADOR, '
' COB.NRO_REMESSA,'
' FIL.NOME NM_COBRADORA,'
' CASE SRV.SERVICO'
' WHEN NULL THEN '#39'COMISSIONAMENTO PADRAO'#39
' ELSE SRV.SERVICO'
' END NM_SERVICO,'
' VEN.NOME NM_VENDEDOR,'
' CASE SIT.DESCRICAO'
' WHEN NULL THEN '#39'EM ABERTO'#39
' ELSE SIT.DESCRICAO'
' END NM_STATUS,'
' BCO.NOME_BCO NM_PORTADOR,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.ENDERECO'
' ELSE PAR.ENDERECO'
' END COB_ENDERECO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.BAIRRO'
' ELSE PAR.BAIRRO'
' END COB_BAIRRO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.CIDADE'
' ELSE PAR.CIDADE'
' END COB_CIDADE,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.ESTADO'
' ELSE PAR.ESTADO'
' END COB_ESTADO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.CEP'
' ELSE PAR.CEP'
' END COB_CEP,'
' CLI.INSC_EST COB_IESTADUAL'
'FROM STWFATTCOB COB'
'LEFT JOIN STWOPETFIL FIL ON FIL.FILIAL = COB.FIL_COBR'
'LEFT JOIN STWOPETSERV SRV ON SRV.CODIGO = COB.SERVICO'
'LEFT JOIN STWOPETVEN VEN ON VEN.CODIGO = COB.VENDEDOR'
'LEFT JOIN STWFATTSTA SIT ON SIT.STATUS = COB.STATUS'
'LEFT JOIN STWFATTBCO BCO ON BCO.COD_BCO = COB.BANCO'
'LEFT JOIN STWOPETCLI CLI ON CLI.CGC = COB.CGC'
'LEFT JOIN STWOPETPARC PAR ON PAR.CGC = COB.CGC')
object qryManutencaoTIPO_DOC: TStringField
FieldName = 'TIPO_DOC'
Required = True
Size = 2
end
object qryManutencaoFIL_ORIG: TStringField
FieldName = 'FIL_ORIG'
Required = True
Size = 3
end
object qryManutencaoFATURA: TIntegerField
FieldName = 'FATURA'
Required = True
end
object qryManutencaoANO: TStringField
FieldName = 'ANO'
Required = True
Size = 2
end
object qryManutencaoFIL_COBR: TStringField
FieldName = 'FIL_COBR'
Size = 3
end
object qryManutencaoCGC: TStringField
FieldName = 'CGC'
Size = 18
end
object qryManutencaoNOME: TStringField
FieldName = 'NOME'
Size = 40
end
object qryManutencaoTOT_FATURA: TFloatField
FieldName = 'TOT_FATURA'
DisplayFormat = '##0.00'
end
object qryManutencaoDT_EMISSAO: TDateTimeField
FieldName = 'DT_EMISSAO'
end
object qryManutencaoDT_VENCTO: TDateTimeField
FieldName = 'DT_VENCTO'
end
object qryManutencaoDT_PAGTO: TDateTimeField
FieldName = 'DT_PAGTO'
end
object qryManutencaoDT_BAIXA: TDateTimeField
FieldName = 'DT_BAIXA'
end
object qryManutencaoDT_COMPENSACAO: TDateTimeField
FieldName = 'DT_COMPENSACAO'
end
object qryManutencaoBANCO: TStringField
FieldName = 'BANCO'
Size = 3
end
object qryManutencaoAGENCIA: TStringField
FieldName = 'AGENCIA'
Size = 10
end
object qryManutencaoCONTA: TStringField
FieldName = 'CONTA'
Size = 10
end
object qryManutencaoCARTEIRA: TStringField
FieldName = 'CARTEIRA'
Size = 3
end
object qryManutencaoNR_BOLETO: TStringField
FieldName = 'NR_BOLETO'
Size = 15
end
object qryManutencaoVLR_DESC: TFloatField
FieldName = 'VLR_DESC'
DisplayFormat = '##0.00'
end
object qryManutencaoVLR_JUROS: TFloatField
FieldName = 'VLR_JUROS'
DisplayFormat = '##0.00'
end
object qryManutencaoVLR_PAGO: TFloatField
FieldName = 'VLR_PAGO'
DisplayFormat = '##0.00'
end
object qryManutencaoSTATUS: TStringField
FieldName = 'STATUS'
Size = 2
end
object qryManutencaoDT_STATUS: TDateTimeField
FieldName = 'DT_STATUS'
end
object qryManutencaoVENDEDOR: TIntegerField
FieldName = 'VENDEDOR'
end
object qryManutencaoTRANSMITE: TStringField
FieldName = 'TRANSMITE'
Size = 1
end
object qryManutencaoSERVICO: TIntegerField
FieldName = 'SERVICO'
end
object qryManutencaoCGC_FATURADO: TStringField
FieldName = 'CGC_FATURADO'
Size = 18
end
object qryManutencaoOBSERVACAO: TBlobField
FieldName = 'OBSERVACAO'
end
object qryManutencaoDT_AVISO1: TDateTimeField
FieldName = 'DT_AVISO1'
end
object qryManutencaoDT_AVISO2: TDateTimeField
FieldName = 'DT_AVISO2'
end
object qryManutencaoDT_SPC: TDateTimeField
FieldName = 'DT_SPC'
end
object qryManutencaoDT_RECIBO: TDateTimeField
FieldName = 'DT_RECIBO'
end
object qryManutencaoDT_DESCONTO: TDateTimeField
FieldName = 'DT_DESCONTO'
end
object qryManutencaoTX_MORA: TFloatField
FieldName = 'TX_MORA'
DisplayFormat = '##0.00'
end
object qryManutencaoTX_MULTA: TFloatField
FieldName = 'TX_MULTA'
DisplayFormat = '##0.00'
end
object qryManutencaoDIA_PROTESTO: TIntegerField
FieldName = 'DIA_PROTESTO'
end
object qryManutencaoTIT_DESC: TStringField
FieldName = 'TIT_DESC'
Size = 1
end
object qryManutencaoDT_ALTERACAO: TDateTimeField
FieldName = 'DT_ALTERACAO'
end
object qryManutencaoOPERADOR: TStringField
FieldName = 'OPERADOR'
end
object qryManutencaoNRO_REMESSA: TFloatField
FieldName = 'NRO_REMESSA'
end
object qryManutencaoNM_COBRADORA: TStringField
FieldName = 'NM_COBRADORA'
ProviderFlags = []
ReadOnly = True
Size = 40
end
object qryManutencaoNM_SERVICO: TStringField
FieldName = 'NM_SERVICO'
ProviderFlags = []
ReadOnly = True
Size = 30
end
object qryManutencaoNM_VENDEDOR: TStringField
FieldName = 'NM_VENDEDOR'
ProviderFlags = []
ReadOnly = True
Size = 40
end
object qryManutencaoNM_STATUS: TStringField
FieldName = 'NM_STATUS'
ProviderFlags = []
ReadOnly = True
Size = 40
end
object qryManutencaoNM_PORTADOR: TStringField
FieldName = 'NM_PORTADOR'
ProviderFlags = []
ReadOnly = True
Size = 40
end
object qryManutencaoCOB_ENDERECO: TStringField
FieldName = 'COB_ENDERECO'
ProviderFlags = []
ReadOnly = True
Size = 60
end
object qryManutencaoCOB_BAIRRO: TStringField
FieldName = 'COB_BAIRRO'
ProviderFlags = []
ReadOnly = True
Size = 15
end
object qryManutencaoCOB_CIDADE: TStringField
FieldName = 'COB_CIDADE'
ProviderFlags = []
ReadOnly = True
Size = 30
end
object qryManutencaoCOB_ESTADO: TStringField
FieldName = 'COB_ESTADO'
ProviderFlags = []
ReadOnly = True
Size = 2
end
object qryManutencaoCOB_CEP: TStringField
FieldName = 'COB_CEP'
ProviderFlags = []
ReadOnly = True
Size = 9
end
object qryManutencaoCOB_IESTADUAL: TStringField
FieldName = 'COB_IESTADUAL'
ProviderFlags = []
ReadOnly = True
Size = 18
end
end
inherited qryLocalizacao: TIBCQuery
SQL.Strings = (
'SELECT'
' COB.TIPO_DOC,'
' COB.FIL_ORIG,'
' COB.FATURA,'
' COB.ANO,'
' COB.FIL_COBR,'
' COB.CGC,'
' COB.NOME,'
' COB.TOT_FATURA, '
' COB.DT_EMISSAO, '
' COB.DT_VENCTO, '
' COB.DT_PAGTO, '
' COB.DT_BAIXA, '
' COB.DT_COMPENSACAO, '
' COB.BANCO, '
' COB.AGENCIA, '
' COB.CONTA, '
' COB.CARTEIRA, '
' COB.NR_BOLETO, '
' COB.VLR_DESC, '
' COB.VLR_JUROS, '
' COB.VLR_PAGO, '
' COB.STATUS, '
' COB.DT_STATUS, '
' COB.VENDEDOR, '
' COB.TRANSMITE, '
' COB.SERVICO, '
' COB.CGC_FATURADO, '
' COB.OBSERVACAO, '
' COB.DT_AVISO1, '
' COB.DT_AVISO2, '
' COB.DT_SPC, '
' COB.DT_RECIBO, '
' COB.DT_DESCONTO,'
' COB.TX_MORA, '
' COB.TX_MULTA, '
' COB.DIA_PROTESTO, '
' COB.TIT_DESC, '
' COB.DT_ALTERACAO, '
' COB.OPERADOR, '
' COB.NRO_REMESSA,'
' FIL.NOME NM_COBRADORA,'
' CASE SRV.SERVICO'
' WHEN NULL THEN '#39'COMISSIONAMENTO PADRAO'#39
' ELSE SRV.SERVICO'
' END NM_SERVICO,'
' VEN.NOME NM_VENDEDOR,'
' CASE SIT.DESCRICAO'
' WHEN NULL THEN '#39'EM ABERTO'#39
' ELSE SIT.DESCRICAO'
' END NM_STATUS,'
' BCO.NOME_BCO NM_PORTADOR,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.ENDERECO'
' ELSE PAR.ENDERECO'
' END COB_ENDERECO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.BAIRRO'
' ELSE PAR.BAIRRO'
' END COB_BAIRRO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.CIDADE'
' ELSE PAR.CIDADE'
' END COB_CIDADE,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.ESTADO'
' ELSE PAR.ESTADO'
' END COB_ESTADO,'
' CASE PAR.ENDERECO'
' WHEN NULL THEN CLI.CEP'
' ELSE PAR.CEP'
' END COB_CEP,'
' CLI.INSC_EST COB_IESTADUAL'
'FROM STWFATTCOB COB'
'LEFT JOIN STWOPETFIL FIL ON FIL.FILIAL = COB.FIL_COBR'
'LEFT JOIN STWOPETSERV SRV ON SRV.CODIGO = COB.SERVICO'
'LEFT JOIN STWOPETVEN VEN ON VEN.CODIGO = COB.VENDEDOR'
'LEFT JOIN STWFATTSTA SIT ON SIT.STATUS = COB.STATUS'
'LEFT JOIN STWFATTBCO BCO ON BCO.COD_BCO = COB.BANCO'
'LEFT JOIN STWOPETCLI CLI ON CLI.CGC = COB.CGC'
'LEFT JOIN STWOPETPARC PAR ON PAR.CGC = COB.CGC')
object qryLocalizacaoTIPO_DOC: TStringField
FieldName = 'TIPO_DOC'
Required = True
Size = 2
end
object qryLocalizacaoFIL_ORIG: TStringField
FieldName = 'FIL_ORIG'
Required = True
Size = 3
end
object qryLocalizacaoFATURA: TIntegerField
FieldName = 'FATURA'
Required = True
end
object qryLocalizacaoANO: TStringField
FieldName = 'ANO'
Required = True
Size = 2
end
object qryLocalizacaoFIL_COBR: TStringField
FieldName = 'FIL_COBR'
Size = 3
end
object qryLocalizacaoCGC: TStringField
FieldName = 'CGC'
Size = 18
end
object qryLocalizacaoNOME: TStringField
FieldName = 'NOME'
Size = 40
end
object qryLocalizacaoTOT_FATURA: TFloatField
FieldName = 'TOT_FATURA'
DisplayFormat = '#0,.#0'
end
object qryLocalizacaoDT_EMISSAO: TDateTimeField
FieldName = 'DT_EMISSAO'
end
object qryLocalizacaoDT_VENCTO: TDateTimeField
FieldName = 'DT_VENCTO'
end
object qryLocalizacaoDT_PAGTO: TDateTimeField
FieldName = 'DT_PAGTO'
end
object qryLocalizacaoDT_BAIXA: TDateTimeField
FieldName = 'DT_BAIXA'
end
object qryLocalizacaoDT_COMPENSACAO: TDateTimeField
FieldName = 'DT_COMPENSACAO'
end
object qryLocalizacaoBANCO: TStringField
FieldName = 'BANCO'
Size = 3
end
object qryLocalizacaoAGENCIA: TStringField
FieldName = 'AGENCIA'
Size = 10
end
object qryLocalizacaoCONTA: TStringField
FieldName = 'CONTA'
Size = 10
end
object qryLocalizacaoCARTEIRA: TStringField
FieldName = 'CARTEIRA'
Size = 3
end
object qryLocalizacaoNR_BOLETO: TStringField
FieldName = 'NR_BOLETO'
Size = 15
end
object qryLocalizacaoVLR_DESC: TFloatField
FieldName = 'VLR_DESC'
DisplayFormat = '#0,.#0'
end
object qryLocalizacaoVLR_JUROS: TFloatField
FieldName = 'VLR_JUROS'
DisplayFormat = '#0,.#0'
end
object qryLocalizacaoVLR_PAGO: TFloatField
FieldName = 'VLR_PAGO'
DisplayFormat = '#0,.#0'
end
object qryLocalizacaoSTATUS: TStringField
FieldName = 'STATUS'
Size = 2
end
object qryLocalizacaoDT_STATUS: TDateTimeField
FieldName = 'DT_STATUS'
end
object qryLocalizacaoVENDEDOR: TIntegerField
FieldName = 'VENDEDOR'
end
object qryLocalizacaoTRANSMITE: TStringField
FieldName = 'TRANSMITE'
Size = 1
end
object qryLocalizacaoSERVICO: TIntegerField
FieldName = 'SERVICO'
end
object qryLocalizacaoCGC_FATURADO: TStringField
FieldName = 'CGC_FATURADO'
Size = 18
end
object qryLocalizacaoOBSERVACAO: TBlobField
FieldName = 'OBSERVACAO'
end
object qryLocalizacaoDT_AVISO1: TDateTimeField
FieldName = 'DT_AVISO1'
end
object qryLocalizacaoDT_AVISO2: TDateTimeField
FieldName = 'DT_AVISO2'
end
object qryLocalizacaoDT_SPC: TDateTimeField
FieldName = 'DT_SPC'
end
object qryLocalizacaoDT_RECIBO: TDateTimeField
FieldName = 'DT_RECIBO'
end
object qryLocalizacaoDT_DESCONTO: TDateTimeField
FieldName = 'DT_DESCONTO'
end
object qryLocalizacaoTX_MORA: TFloatField
FieldName = 'TX_MORA'
end
object qryLocalizacaoTX_MULTA: TFloatField
FieldName = 'TX_MULTA'
end
object qryLocalizacaoDIA_PROTESTO: TIntegerField
FieldName = 'DIA_PROTESTO'
end
object qryLocalizacaoTIT_DESC: TStringField
FieldName = 'TIT_DESC'
Size = 1
end
object qryLocalizacaoDT_ALTERACAO: TDateTimeField
FieldName = 'DT_ALTERACAO'
end
object qryLocalizacaoOPERADOR: TStringField
FieldName = 'OPERADOR'
end
object qryLocalizacaoNRO_REMESSA: TFloatField
FieldName = 'NRO_REMESSA'
end
object qryLocalizacaoNM_COBRADORA: TStringField
FieldName = 'NM_COBRADORA'
ReadOnly = True
Size = 40
end
object qryLocalizacaoNM_SERVICO: TStringField
FieldName = 'NM_SERVICO'
ReadOnly = True
Size = 30
end
object qryLocalizacaoNM_VENDEDOR: TStringField
FieldName = 'NM_VENDEDOR'
ReadOnly = True
Size = 40
end
object qryLocalizacaoNM_STATUS: TStringField
FieldName = 'NM_STATUS'
ReadOnly = True
Size = 40
end
object qryLocalizacaoNM_PORTADOR: TStringField
FieldName = 'NM_PORTADOR'
ReadOnly = True
Size = 40
end
object qryLocalizacaoCOB_ENDERECO: TStringField
FieldName = 'COB_ENDERECO'
ReadOnly = True
Size = 60
end
object qryLocalizacaoCOB_BAIRRO: TStringField
FieldName = 'COB_BAIRRO'
ReadOnly = True
Size = 15
end
object qryLocalizacaoCOB_CIDADE: TStringField
FieldName = 'COB_CIDADE'
ReadOnly = True
Size = 30
end
object qryLocalizacaoCOB_ESTADO: TStringField
FieldName = 'COB_ESTADO'
ReadOnly = True
Size = 2
end
object qryLocalizacaoCOB_CEP: TStringField
FieldName = 'COB_CEP'
ReadOnly = True
Size = 9
end
object qryLocalizacaoCOB_IESTADUAL: TStringField
FieldName = 'COB_IESTADUAL'
ReadOnly = True
Size = 18
end
end
object RDprint1: TRDprint
ImpressoraPersonalizada.NomeImpressora = 'Modelo Personalizado - (Epson)'
ImpressoraPersonalizada.AvancaOitavos = '27 48'
ImpressoraPersonalizada.AvancaSextos = '27 50'
ImpressoraPersonalizada.SaltoPagina = '12'
ImpressoraPersonalizada.TamanhoPagina = '27 67 66'
ImpressoraPersonalizada.Negrito = '27 69'
ImpressoraPersonalizada.Italico = '27 52'
ImpressoraPersonalizada.Sublinhado = '27 45 49'
ImpressoraPersonalizada.Expandido = '27 14'
ImpressoraPersonalizada.Normal10 = '18 27 80'
ImpressoraPersonalizada.Comprimir12 = '18 27 77'
ImpressoraPersonalizada.Comprimir17 = '27 80 27 15'
ImpressoraPersonalizada.Comprimir20 = '27 77 27 15'
ImpressoraPersonalizada.Reset = '27 80 18 20 27 53 27 70 27 45 48'
ImpressoraPersonalizada.Inicializar = '27 64'
OpcoesPreview.PaginaZebrada = False
OpcoesPreview.Remalina = False
OpcoesPreview.CaptionPreview = 'Rdprint Preview'
OpcoesPreview.PreviewZoom = 100
OpcoesPreview.CorPapelPreview = clWhite
OpcoesPreview.CorLetraPreview = clBlack
OpcoesPreview.Preview = False
OpcoesPreview.BotaoSetup = Ativo
OpcoesPreview.BotaoImprimir = Ativo
OpcoesPreview.BotaoGravar = Ativo
OpcoesPreview.BotaoLer = Ativo
OpcoesPreview.BotaoProcurar = Ativo
OpcoesPreview.BotaoPDF = Ativo
OpcoesPreview.BotaoEMAIL = Ativo
Margens.Left = 10
Margens.Right = 10
Margens.Top = 10
Margens.Bottom = 10
Autor = Deltress
RegistroUsuario.NomeRegistro = 'AMERICA SOFT INFORMATICA LTDA'
RegistroUsuario.SerieProduto = 'SITE-0314/00806'
RegistroUsuario.AutorizacaoKey = 'K0RR-XZX1-6E6I-QCD2-V8I0'
About = 'RDprint 5.0 - Registrado'
Acentuacao = Transliterate
CaptionSetup = 'Rdprint Setup'
TitulodoRelatorio = 'Gerado por RDprint'
UsaGerenciadorImpr = False
CorForm = clBtnFace
CorFonte = clBlack
Impressora = Grafico
Mapeamento.Strings = (
'//--- Grafico Compativel com Windows/USB ---//'
'//'
'GRAFICO=GRAFICO'
'HP=GRAFICO'
'DESKJET=GRAFICO'
'LASERJET=GRAFICO'
'INKJET=GRAFICO'
'STYLUS=GRAFICO'
'EPL=GRAFICO'
'USB=GRAFICO'
'//'
'//--- Linha Epson Matricial 9 e 24 agulhas ---//'
'//'
'EPSON=EPSON'
'GENERICO=EPSON'
'LX-300=EPSON'
'LX-810=EPSON'
'FX-2170=EPSON'
'FX-1170=EPSON'
'LQ-1170=EPSON'
'LQ-2170=EPSON'
'OKIDATA=EPSON'
'//'
'//--- Rima e Emilia ---//'
'//'
'RIMA=RIMA'
'EMILIA=RIMA'
'//'
'//--- Linha HP/Xerox padr'#227'o PCL ---//'
'//'
'PCL=HP'
'//'
'//--- Impressoras 40 Colunas ---//'
'//'
'DARUMA=BOBINA'
'SIGTRON=BOBINA'
'SWEDA=BOBINA'
'BEMATECH=BOBINA')
PortaComunicacao = 'LPT1'
MostrarProgresso = True
TamanhoQteLinhas = 66
TamanhoQteColunas = 136
TamanhoQteLPP = Seis
NumerodeCopias = 1
FonteTamanhoPadrao = S12cpp
FonteEstiloPadrao = []
Orientacao = poPortrait
Left = 244
Top = 167
end
end
|
unit evDocumentContainerWithProcessor;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Библиотека "Everest"
// Автор: Люлин А.В.
// Модуль: "w:/common/components/gui/Garant/Everest/new/evDocumentContainerWithProcessor.pas"
// Начат: 28.09.2004 17:36
// Родные Delphi интерфейсы (.pas)
// Generated from UML model, root element: <<SimpleClass::Class>> Shared Delphi::Everest::DocumentContainers::TevDocumentContainerWithProcessor
//
// Контейнер документа с процессором операций.
//
//
// Все права принадлежат ООО НПП "Гарант-Сервис".
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ! Полностью генерируется с модели. Править руками - нельзя. !
{$Include w:\common\components\gui\Garant\Everest\evDefine.inc}
interface
uses
nevDocumentContainer,
evOpProc,
nevBase,
nevTools,
l3IID
;
type
TevDocumentContainerWithProcessor = class(TnevDocumentContainer)
{* Контейнер документа с процессором операций. }
private
// private fields
f_Processor : TevCustomUndoProcessor;
{* Поле для свойства Processor}
protected
// property methods
function pm_GetProcessor: TevCustomUndoProcessor;
procedure pm_SetProcessor(aValue: TevCustomUndoProcessor);
protected
// overridden protected methods
procedure Cleanup; override;
{* Функция очистки полей объекта. }
function StartOp(Op: Integer = 0;
DoLock: Boolean = true): InevOp; override;
{* открывает пачку операций с кодом Op. }
function DoGetProcessor: InevProcessor; override;
function DoGetDocumentLimits: InevDocumentLimits; override;
function DoGetDocumentInfo: InevDocumentInfo; override;
function GetHasProcessor: Boolean; override;
function COMQueryInterface(const IID: Tl3GUID;
out Obj): Tl3HResult; override;
{* Реализация запроса интерфейса }
protected
// protected methods
procedure MakeProcessor(out theProcessor: TevCustomUndoProcessor); virtual;
public
// public properties
property Processor: TevCustomUndoProcessor
read pm_GetProcessor
write pm_SetProcessor;
{* Процессор операций. }
end;//TevDocumentContainerWithProcessor
implementation
uses
l3Base,
evDefaultContext
;
// start class TevDocumentContainerWithProcessor
function TevDocumentContainerWithProcessor.pm_GetProcessor: TevCustomUndoProcessor;
//#UC START# *483D903003C8_47F3513A017Fget_var*
//#UC END# *483D903003C8_47F3513A017Fget_var*
begin
//#UC START# *483D903003C8_47F3513A017Fget_impl*
if (f_Processor = nil) then
begin
MakeProcessor(f_Processor);
if (f_Processor <> nil) then
f_Processor.LinkDocument(Self);
end;//f_Processor = nil
Result := f_Processor;
//#UC END# *483D903003C8_47F3513A017Fget_impl*
end;//TevDocumentContainerWithProcessor.pm_GetProcessor
procedure TevDocumentContainerWithProcessor.pm_SetProcessor(aValue: TevCustomUndoProcessor);
//#UC START# *483D903003C8_47F3513A017Fset_var*
//#UC END# *483D903003C8_47F3513A017Fset_var*
begin
//#UC START# *483D903003C8_47F3513A017Fset_impl*
if (f_Processor <> aValue) then
begin
if (f_Processor <> nil) then
f_Processor.UnlinkDocument(Self);
l3Set(f_Processor, aValue);
if (f_Processor <> nil) then
f_Processor.LinkDocument(Self);
end;//f_Processor <> aValue
//#UC END# *483D903003C8_47F3513A017Fset_impl*
end;//TevDocumentContainerWithProcessor.pm_SetProcessor
procedure TevDocumentContainerWithProcessor.MakeProcessor(out theProcessor: TevCustomUndoProcessor);
//#UC START# *47F35245009A_47F3513A017F_var*
//#UC END# *47F35245009A_47F3513A017F_var*
begin
//#UC START# *47F35245009A_47F3513A017F_impl*
theProcessor := TevCustomUndoProcessor.Create(TevDefaultContext);
//#UC END# *47F35245009A_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.MakeProcessor
procedure TevDocumentContainerWithProcessor.Cleanup;
//#UC START# *479731C50290_47F3513A017F_var*
//#UC END# *479731C50290_47F3513A017F_var*
begin
//#UC START# *479731C50290_47F3513A017F_impl*
if (f_Processor <> nil) AND (f_Processor.Owner = Self) then
f_Processor.Owner := nil;
Processor := nil;
inherited;
//#UC END# *479731C50290_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.Cleanup
function TevDocumentContainerWithProcessor.StartOp(Op: Integer = 0;
DoLock: Boolean = true): InevOp;
//#UC START# *47F10A0502B8_47F3513A017F_var*
//#UC END# *47F10A0502B8_47F3513A017F_var*
begin
//#UC START# *47F10A0502B8_47F3513A017F_impl*
Result := Processor.StartOp(Op, DoLock);
//#UC END# *47F10A0502B8_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.StartOp
function TevDocumentContainerWithProcessor.DoGetProcessor: InevProcessor;
//#UC START# *47F2714A0216_47F3513A017F_var*
//#UC END# *47F2714A0216_47F3513A017F_var*
begin
//#UC START# *47F2714A0216_47F3513A017F_impl*
Result := Processor;
//#UC END# *47F2714A0216_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.DoGetProcessor
function TevDocumentContainerWithProcessor.DoGetDocumentLimits: InevDocumentLimits;
//#UC START# *47F27268004F_47F3513A017F_var*
//#UC END# *47F27268004F_47F3513A017F_var*
begin
//#UC START# *47F27268004F_47F3513A017F_impl*
Result := Processor;
//#UC END# *47F27268004F_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.DoGetDocumentLimits
function TevDocumentContainerWithProcessor.DoGetDocumentInfo: InevDocumentInfo;
//#UC START# *47F27286016C_47F3513A017F_var*
//#UC END# *47F27286016C_47F3513A017F_var*
begin
//#UC START# *47F27286016C_47F3513A017F_impl*
Result := Processor;
//#UC END# *47F27286016C_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.DoGetDocumentInfo
function TevDocumentContainerWithProcessor.GetHasProcessor: Boolean;
//#UC START# *47F2729800DD_47F3513A017F_var*
//#UC END# *47F2729800DD_47F3513A017F_var*
begin
//#UC START# *47F2729800DD_47F3513A017F_impl*
Result := (f_Processor <> nil);
//#UC END# *47F2729800DD_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.GetHasProcessor
function TevDocumentContainerWithProcessor.COMQueryInterface(const IID: Tl3GUID;
out Obj): Tl3HResult;
//#UC START# *4A60B23E00C3_47F3513A017F_var*
//#UC END# *4A60B23E00C3_47F3513A017F_var*
begin
//#UC START# *4A60B23E00C3_47F3513A017F_impl*
Result.SetOk;
if IID.EQ(InevProcessor) then
InevProcessor(Obj) := Processor
else
Result := inherited COMQueryInterface(IID, Obj);
//#UC END# *4A60B23E00C3_47F3513A017F_impl*
end;//TevDocumentContainerWithProcessor.COMQueryInterface
end. |
unit DAO.CadastroEnderecos;
interface
uses FireDAC.Comp.Client, System.SysUtils, DAO.Conexao, Control.Sistema, Model.CadastroEnderecos;
type
TCadastroEnderecosDAO = class
private
FConexao : TConexao;
public
constructor Create();
function GetID(iID: Integer): Integer;
function Insert(aEnderecos: TCadastroEnderecos): Boolean;
function Update(aEnderecos: TCadastroEnderecos): Boolean;
function Delete(aEnderecos: TCadastroEnderecos): Boolean;
function Localizar(aParam: Array of variant): TFDQuery;
end;
const
TABLENAME = 'cadastro_enderecos';
implementation
function TCadastroEnderecosDAO.Insert(aEnderecos: TCadastroEnderecos): Boolean;
var
sSQL: String;
FDQuery : TFDQuery;
begin
try
Result := False;
FDQuery := FConexao.ReturnQuery;
sSQL := 'INSERT INTO ' + TABLENAME + '(' +
'ID_CADASTRO, DES_TIPO_ENDERECO, NUM_CEP, DES_LOGRADOURO, NUM_LOGRADOURO, DES_COMPLEMENTO, NOM_BAIRRO, ' +
'NOM_CIDADE, UF_ESTADO, NUM_CNPJ, NUM_IE, NUM_IEST, NUM_IM) ' +
'VALUES (' +
':pID_CADASTRO, :pDES_TIPO_ENDERECO, :pNUM_CEP, :pDES_LOGRADOURO, :pNUM_LOGRADOURO, :pDES_COMPLEMENTO, ' +
':pNOM_BAIRRO, :pNOM_CIDADE, :pUF_ESTADO, :pNUM_CNPJ, :pNUM_IE, :pNUM_IEST, :pNUM_IM);';
FDQuery.ExecSQL(sSQL,[aEnderecos.ID, aEnderecos.Tipo, aEnderecos.CEP, aEnderecos.Logradouro,
aEnderecos.Numero, aEnderecos.Complemento, aEnderecos.Bairro, aEnderecos.Cidade, aEnderecos.UF,
aEnderecos.CNPJ, aEnderecos.IE, aEnderecos.IEST, aEnderecos.IM]);
Result := True;
finally
FDQuery.Connection.Close;
FDQuery.Free;
end;
end;
function TCadastroEnderecosDAO.Localizar(aParam: array of variant): TFDQuery;
var
FDQuery: TFDQuery;
begin
FDQuery := FConexao.ReturnQuery();
if Length(aParam) < 2 then Exit;
FDQuery.SQL.Clear;
FDQuery.SQL.Add('select * from ' + TABLENAME);
if aParam[0] = 'ID' then
begin
FDQuery.SQL.Add('WHERE ID_CADASTRO = :ID_CADASTRO');
FDQuery.ParamByName('ID_CADASTRO').AsInteger := aParam[1];
end;
if aParam[0] = 'CNPJ' then
begin
FDQuery.SQL.Add('WHERE NUM_CNPJ = :NUM_CNPJ');
FDQuery.ParamByName('NUM_CNPJ').AsString := aParam[1];
end;
if aParam[0] = 'IE' then
begin
FDQuery.SQL.Add('WHERE NUM_IE = :NUM_IE');
FDQuery.ParamByName('NUM_IE').AsString := aParam[1];
end;
if aParam[0] = 'IM' then
begin
FDQuery.SQL.Add('WHERE NUM_IM = :NUM_IM');
FDQuery.ParamByName('NUM_IM').AsString := aParam[1];
end;
if aParam[0] = 'TIPO' then
begin
FDQuery.SQL.Add('WHERE ID_CADASTRO = :ID_CADASTRO AND DES_TIPO_ENDERECO = :DES_TIPO_ENDERECO');
FDQuery.ParamByName('ID_CADASTRO').AsInteger := aParam[1];
FDQuery.ParamByName('DES_TIPO_ENDERECO').AsString := aParam[2];
end;
if aParam[0] = 'CEP' then
begin
FDQuery.SQL.Add('WHERE NUM_CEP LIKE :NUM_CEP');
FDQuery.ParamByName('NUM_CEP').AsString := aParam[1];
end;
if aParam[0] = 'ENDERECO' then
begin
FDQuery.SQL.Add('WHERE DES_LOGRADOURO LIKE :DES_LOGRADOURO');
FDQuery.ParamByName('DES_LOGRADOURO').AsString := aParam[1];
end;
if aParam[0] = 'FILTRO' then
begin
FDQuery.SQL.Add('WHERE ' + aParam[1]);
end;
if aParam[0] = 'APOIO' then
begin
FDQuery.SQL.Clear;
FDQuery.SQL.Add('SELECT ' + aParam[1] + ' FROM ' + TABLENAME + ' ' + aParam[2]);
end;
FDQuery.Open();
Result := FDQuery;
end;
function TCadastroEnderecosDAO.Update(aEnderecos: TCadastroEnderecos): Boolean;
var
sSQL: String;
FDQuery: TFDQuery;
begin
try
Result := False;
FDQuery := FConexao.ReturnQuery;
sSQL := 'UPDATE ' + TABLENAME + ' SET ' +
'NUM_CEP = :pNUM_CEP, DES_LOGRADOURO := :pDES_LOGRADOURO, ' +
'NUM_LOGRADOURO = :pNUM_LOGRADOURO, DES_COMPLEMENTO = :pDES_COMPLEMENTO, ' +
'NOM_BAIRRO = :pNOM_BAIRRO, NOM_CIDADE = :pNOM_CIDADE, ' +
'UF_ESTADO = :pUF_ESTADO, NUM_CNPJ = :pNUM_CNPJ, NUM_IE = :pNUM_IE, NUM_IEST = :pNUM_IEST, NUM_IM = :pNUM_IM ' +
'WHERE ID_CADASTRO = :pID_CADASTRO AND DES_TIPO_ENDERECO = :pDES_TIPO_ENDERECO;';
FDQuery.ExecSQL(sSQL,[aEnderecos.CEP, aEnderecos.Logradouro,
aEnderecos.Numero, aEnderecos.Complemento, aEnderecos.Bairro, aEnderecos.Cidade, aEnderecos.UF,
aEnderecos.CNPJ, aEnderecos.IE, aEnderecos.IEST, aEnderecos.IM, aEnderecos.ID, aEnderecos.Tipo]);
Result := True;
finally
FDQuery.Connection.Close;
FDQuery.Free;
end;
end;
constructor TCadastroEnderecosDAO.Create;
begin
Fconexao := TConexao.Create;
end;
function TCadastroEnderecosDAO.Delete(aEnderecos: TCadastroEnderecos): Boolean;
var
FDQuery: TFDQuery;
sSQL: String;
begin
try
Result := False;
sSQL := '';
FDQuery := FConexao.ReturnQuery();
if aEnderecos.Sequencia = -1 then
begin
sSQL := 'DELETE FROM ' + TABLENAME + ' ' +
'WHERE ID_CADASTRO = :pID_CADASTRO;';
FDQuery.ExecSQL(sSQL,[aEnderecos.ID]);
end
else
begin
sSQL := 'DELETE FROM ' + TABLENAME + ' ' +
'WHERE ID_CADASTRO = :pID_CADASTRO AND DES_TIPO_ENDERECO = :pDES_TIPO_ENDERECO;';
FDQuery.ExecSQL(sSQL,[aEnderecos.ID, aEnderecos.Sequencia]);
end;
Result := True;
finally
FDQuery.Connection.Close;
FDquery.Free;
end;
end;
function TCadastroEnderecosDAO.GetID(iID: Integer): Integer;
var
FDQuery: TFDQuery;
begin
try
FDQuery := FConexao.ReturnQuery();
FDQuery.Open('select coalesce(max(SEQ_ENDERECO),0) + 1 from ' + TABLENAME + ' WHERE ID_CADASTRO = ' + iID.toString);
try
Result := FDQuery.Fields[0].AsInteger;
finally
FDQuery.Close;
end;
finally
FDQuery.Connection.Close;
FDQuery.Free;
end;
end;
end.
|
unit ddDefDocLinkFinder;
{ $Id: ddDefDocLinkFinder.pas,v 1.3 2016/10/14 15:25:08 fireton Exp $ }
interface
uses
l3Interfaces,
l3Date,
dt_Types,
ddAutolinkTypes,
ddCustomLinkFinder,
ddEntryCollector,
ddDocStruct;
type
TddDocCacheType = (dctBasic, dctFile);
TddDefDocLinkFinder = class(TddCustomLinkFinder)
private
f_TargetExtDocID: TDocID;
f_EntryCollector: TddEntryCollector;
f_StructCache: TddProtoStructCache;
f_TargetIntDocID: TDocID;
procedure pm_SetTargetExtDocID(const Value: TDocID);
protected
procedure Cleanup; override;
public
constructor Create(aCacheType: TddDocCacheType);
procedure Done; override;
procedure FindLinks(const aText : Tl3WString; // text from master doc
aDocID : TDocID; // master doc id
aDocDate : TStDate; // master doc date
const aCaseCode : Il3CString; // casecode
aLinkProc : TddLinkSetRoutine); override;
procedure Init; override;
property StructCache: TddProtoStructCache read f_StructCache;
property TargetExtDocID: TDocID read f_TargetExtDocID write pm_SetTargetExtDocID;
end;
implementation
uses
SysUtils,
l3RecList,
ddAutolinkCache,
daSchemeConsts,
daDataProvider,
dt_LinkServ
, Dt_ReNum;
constructor TddDefDocLinkFinder.Create(aCacheType: TddDocCacheType);
begin
inherited Create;
case aCacheType of
dctBasic: f_StructCache := TddProtoStructCache.Create;
dctFile : f_StructCache := TddDocStructCache.Create(GetAutolinkStructCacheFilePath(dsLocal), GlobalDataProvider.TextBase[CurrentFamily], True);
else
Assert(False);
end;
end;
procedure TddDefDocLinkFinder.Cleanup;
begin
FreeAndNil(f_StructCache);
inherited;
end;
procedure TddDefDocLinkFinder.Done;
begin
FreeAndNil(f_EntryCollector);
end;
procedure TddDefDocLinkFinder.FindLinks(const aText : Tl3WString; // text from master doc
aDocID : TDocID; // master doc id
aDocDate : TStDate; // master doc date
const aCaseCode : Il3CString; // casecode
aLinkProc : TddLinkSetRoutine);
var
I: Integer;
l_List: Tl3RecList;
l_Pos: Integer;
l_SubNo: Longint;
l_PLinkItem: PLinkPrimRec;
begin
l_Pos := 0;
l_List := TddEntryCollector.MakeEntryList;
try
while True do
begin
if not f_EntryCollector.CollectEntries(aText.S, l_Pos, aText.SLen - 1, l_List) then
Break;
for I := 0 to l_List.Hi do
begin
l_PLinkItem := PLinkPrimRec(l_List.ItemSlot(I));
l_SubNo := f_StructCache.FindBlockSmart(f_TargetExtDocID, l_PLinkItem.rAddress);
if l_SubNo >= 0 then
aLinkProc(l_PLinkItem.rStart, l_PLinkItem.rEnd, f_TargetIntDocID, l_SubNo, '');
if l_Pos < l_PLinkItem.rEnd then
l_Pos := l_PLinkItem.rEnd + 1;
end;
end;
finally
FreeAndNil(l_List);
end;
end;
procedure TddDefDocLinkFinder.Init;
begin
if (f_TargetExtDocID = 0) then
raise EddAutolinkError.Create('Не определён целевой документ!');
f_EntryCollector := TddEntryCollector.Create(False{not right-aligned});
end;
procedure TddDefDocLinkFinder.pm_SetTargetExtDocID(const Value: TDocID);
begin
f_TargetExtDocID := Value;
f_TargetIntDocID := LinkServer(CurrentFamily).Renum.ConvertExternalDocNumberToInternal(f_TargetExtDocID);
end;
end. |
// **********************************************************************
//
// Copyright (c) 2001 MT Tools.
//
// All Rights Reserved
//
// MT_DORB is based in part on the product DORB,
// written by Shadrin Victor
//
// See Readme.txt for contact information
//
// **********************************************************************
unit addr_int;
interface
{$I dorb.inc}
uses
orbtypes,SysUtils,Classes,{$IFDEF WIN32}winsock{$ENDIF} {$IFDEF LINUX}Libc{$ENDIF},
disp_int,code_int,env_int;
type
IAddress = interface;
ITransportCallBack = interface;
ITransportServerCallBack = interface;
TTransportState = (tsClosed, tsOpen);
ITransport = interface(IUnknown)
['{61252F64-4D23-11d4-9D27-204C4F4F5020}']
function bad(): Boolean; stdcall;
procedure block(val: Boolean);
function isblocking(): boolean;
function bufread(buf: IBuffer;size: _ulong): integer; stdcall;
function bufwrite(buf: IBuffer; size: _ulong; eat: boolean = true): integer; stdcall;
function connect(const addr : IAddress): Boolean; stdcall;
procedure open(fd: Longint); stdcall;
procedure close(); stdcall;
function eof(): Boolean; stdcall;
function peer(): IAddress;
function read(var buffer; size: _ulong): integer; stdcall;
procedure rselect(const disp: IORBDispatcher;const cb: ITransportCallback); stdcall;
procedure wselect(const disp: IORBDispatcher;const cb: ITransportCallback); stdcall;
function write(const buffer;size: _ulong): integer; stdcall;
function get_principal(): IPrincipal;
function get_address: IAddress;
end;
ITransportServer = interface
['{61252F65-4D23-11d4-9D27-204C4F4F5020}']
function accept(): ITransport;
procedure aselect(const disp: IORBDispatcher;const cb: ITransportServerCallback);
function bind(const addr: IAddress): Boolean;
function get_address: IAddress;
procedure listen();
procedure block(doblock: boolean);
procedure close();
// function isblocking(): boolean;
{$IFDEF HAVE_THREADS}
procedure create_thread();
procedure start();
{$ENDIF}
end;
ITransportCallBack = interface
['{61252F66-4D23-11d4-9D27-204C4F4F5020}']
procedure callback(tr: ITransport;event :TTransportCallBackEvent);
end;
ITransportServerCallBack = interface
['{61252F67-4D23-11d4-9D27-204C4F4F5020}']
procedure ts_callback(ts: ITransportServer;event :TTransportServerCallBackEvent);
end;
IAddress = interface
['{61252F68-4D23-11d4-9D27-204C4F4F5020}']
function proto(): AnsiString;
function compare(const addr: IAddress): Boolean;
function toString(): AnsiString;
function make_transport(): ITransport;
function make_transport_server(): ITransportServer;
function make_ior_profile(const key: AnsiString; const len: _ulong;const mc: IInterface; const version: _ushort): IInterface;
function socketaddress(): TSockAddrIn;
procedure set_socketaddress(val:TSockAddrIn);
function resolve_ip(): Boolean;
function is_local(): Boolean;
function valid: Boolean;
end;
IInetAddress = interface(IAddress)
['{02F45D85-203A-11d4-9CCB-204C4F4F5020}']
function Host: AnsiString;
function _Port: _ushort;
procedure SetPort(const port: _ushort);
function Family: TFamily;
function socketaddress(): TSockAddrIn;
function ipaddr: _ulong;
function ipaddrstr: AnsiString;
end;
IAddressParser = interface
['{02F45D86-203A-11d4-9CCB-204C4F4F5020}']
function has_protocol(const str: AnsiString): Boolean;
function parse(const rest: AnsiString; const proto: AnsiString): IAddress;
end;
implementation
end.
|
{ Subroutine SST_W_C_EXEC (FIRST_P)
*
* Process a chain of executable opcodes. The opcodes will be translated
* to C. FIRST_P is pointing to the first opcode in the chain. It may
* be NIL to indicate an empty chain. This subroutine returns when the
* end of chain is reached. It is an error if the chain contains any
* non-executable opcodes.
}
module sst_w_c_EXEC;
define sst_w_c_exec;
%include 'sst_w_c.ins.pas';
var
int_def_name: string_var4_t := {name of default integer}
[str := 'int', len := 3, max := 4];
procedure sst_w_c_exec ( {process executable opcode chain}
in first_p: sst_opc_p_t); {pointer to first opcode, may be NIL}
const
n_args_same_line = 1; {max args on same line before expand vertical}
max_msg_parms = 1; {max parameters we can pass to a message}
var
opc_p: sst_opc_p_t; {pointer to current opcode descriptor}
sym_p, sym2_p, sym3_p: sst_symbol_p_t; {pointers to implicit symbols}
arg_p: sst_proc_arg_p_t; {pointer to subroutine argument descriptor}
argt_p: sst_proc_arg_p_t; {pointer to subroutine arg template}
dt_p: sst_dtype_p_t; {scratch pointer to data type descriptor}
case_opc_p: sst_case_opc_p_t; {points to descriptor for current case}
case_val_p: sst_case_val_p_t; {points to descriptor for current case choice}
token: string_var32_t; {for number conversion}
fw: sys_int_machine_t; {explicit field width value}
n: sys_int_machine_t; {scratch counter}
i: sys_int_machine_t; {scratch integer and loop counter}
ordval: sys_int_max_t; {scratch ordinal value}
fw1_param, fw2_param: boolean; {TRUE if field widths passed as parameters}
did_eol: boolean; {TRUE when already did next WRITE EOL opcode}
unsig: boolean; {TRUE if argument is unsigned}
cast_arg: boolean; {TRUE if need to type-cast argument}
c: char; {scratch character}
msg_parm: {parameter references for messages}
array[1..max_msg_parms] of sys_parm_msg_t;
stat: sys_err_t; {completion status code}
label
write_new_dtype, write_int, write_int_default, write_done_float, done_opcode;
{
*********************************************
*
* Local subroutine PRECEEDING_BLANKS (DSIZE, EXP_P, FW)
*
* Emit code that writes blanks before a character string or character.
* This is neccessary when the desired field width is either unknown or
* exceeds the size of the available data. DSIZE is the number of characters
* available in the data. EXP_P points to the expression for the desired
* field width. EXP_P may be NIL to indicate that no explicit field width
* was requested. FW is returned to indicate the remaining field width.
* When the remaining field width is known, FW is >= zero. In this case
* the remaining field width is MAX(MIN(EXP,DSIZE),0). When the remaining
* field width is not a known constant FW < 0.
*
* If N is the known constant number of padding characters:
*
* printf ("%Ns","");
*
* When the number of padding characters is not a known constant, EXP is the
* desired field width expression, and DSIZE is the data size number:
*
* if (EXP > DSIZE) printf ("%*s", EXP - DSIZE, "");
*
* An implicit variable will be created for EXP if it is not "simple". In
* that case, SYM_P will be left pointing to the implicit variable, otherwise
* SYM_P will be NIL.
}
procedure preceeding_blanks (
in dsize: sys_int_machine_t; {number of characters available in the data}
in exp_p: sst_exp_p_t; {NIL or points to field width expression}
out fw: sys_int_machine_t); {returned to indicate remaining field width}
val_param;
var
token: string_var32_t; {scratch string for number conversion}
begin
token.max := sizeof(token.str); {init local var string}
sym_p := nil; {init to no implicit variable created}
if exp_p = nil then begin {default field width requires no padding}
fw := dsize;
return;
end;
if exp_p^.val_fnd
then begin {desired field width is a known constant val}
if exp_p^.val.int_val <= dsize then begin {no padding needed ?}
fw := exp_p^.val.int_val;
return;
end;
sst_w.appendn^ ('printf ("%', 10);
string_f_int (token, exp_p^.val.int_val - dsize); {make num pad chars string}
sst_w.append^ (token);
sst_w.appendn^ ('s","")', 6);
fw := dsize;
end
else begin {desired field width value is not known}
sst_w_c_exp_implicit (exp_p^, sym_p); {create implicit var if needed}
sst_w.appendn^ ('if (', 4);
if sym_p = nil {write field width expression value}
then sst_w_c_exp (exp_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ ('>', 1);
sst_w.delimit^;
string_f_int (token, dsize); {make DSIZE constant string}
sst_w.append^ (token);
sst_w.appendn^ (')', 1);
sst_w.delimit^;
sst_w.appendn^ ('printf (', 8);
sst_w.allow_break^;
sst_w.appendn^ ('"%*s",', 6);
sst_w.delimit^;
if sym_p = nil {write field width expression value}
then sst_w_c_exp (exp_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ ('-', 1);
sst_w.delimit^;
sst_w.append^ (token);
sst_w.appendn^ (',', 1);
sst_w.delimit^;
sst_w.appendn^ ('"")', 3);
if dsize <= 0
then fw := 0 {definately nothing left to write}
else fw := -1; {remaining field width not known}
end
;
sst_w_c_sment_end;
sst_w_c_sment_start;
end;
{
*********************************************
*
* Local subroutine CHECK_EOL
*
* Check whether the next opcode is WRITE EOL. If so, write the neccessary
* characters to the PRINTF format string at the current position to cause
* the end of line to be written, and set DID_EOL to TRUE. The characters
* written are "\n".
}
procedure check_eol;
begin
if {next opcode is WRITE EOL ?}
(opc_p^.next_p <> nil) and then
(opc_p^.next_p^.opcode = sst_opc_write_eol_k)
then begin
sst_w.appendn^ ('\n', 2);
did_eol := true; {remember that next opcode already done}
end;
end;
{
*********************************************
*
* Local subroutine FIELD_WIDTH (FW_P, PARAM)
*
* Write the field width specifier in a PRINTF format string. FW_P points to the
* field width expression descriptor. The field width will be written
* directly into the format string when it is a known constant. Otherwise
* "*" will be written into the format string, and PARAM will be set to
* TRUE to indicate that the field width must be explicitly passed as
* a parameter after the format string.
}
procedure field_width (
in fw_p: sst_exp_p_t; {expression descriptor for field width}
out param: boolean); {TRUE when field width must be passed later}
val_param;
begin
param := false; {init to don't write FW as parameter later}
if fw_p = nil then return; {no field width to write ?}
if not fw_p^.val_fnd then begin {field width has no known constant value ?}
sst_w.appendn^ ('*', 1); {tells C that field width coming as param}
param := true;
return;
end;
sst_w_c_value (fw_p^.val, enclose_yes_k); {write field width value into fmt string}
end;
{
*********************************************
*
* Start of main routine.
}
begin
token.max := sizeof(token.str); {init local var string}
path_to_here := true; {init to path exists to after opcodes}
opc_p := first_p; {init current opcode to first opcode}
while opc_p <> nil do begin {keep looping until end of opcode chain}
with opc_p^: opc do begin {OPC is the current opcode descriptor}
case opc.opcode of {what kind of opcode is this ?}
{
***************************************
*
* Label at current position.
}
sst_opc_label_k: begin
path_to_here := true; {executable path exists to after this opcode}
if not (sst_symflag_used_k in opc.label_sym_p^.flags) {label not used }
then goto done_opcode; {skip over unused label}
sst_w.append_sym_name^ (opc.label_sym_p^); {write label name}
sst_w.appendn^ (': ;', 3);
sst_w.line_close^; {label reference is always on its own line}
end;
{
***************************************
*
* Subroutine call.
}
sst_opc_call_k: begin
sst_w_c_sment_start; {start a new statement}
sst_w_c_var (opc.call_var_p^, 0); {write subroutine name reference}
sst_w.delimit^;
sst_w.appendn^ ('(', 1); {open paren of argument list}
arg_p := opc.call_proc_p^.first_arg_p; {init pointer to first call argument}
argt_p := opc.call_proct_p^.first_arg_p; {init pointer to first call arg template}
while (arg_p <> nil) or (argt_p <> nil) do begin {once for each call argument}
if opc.call_proc_p^.n_args > n_args_same_line then begin {expand vertically ?}
sst_w.line_close^; {start this arg on a new line}
sst_w.tab_indent^;
end;
sst_w_c_arg (arg_p, argt_p); {write this call argument}
if (arg_p <> nil) or (argt_p <> nil) then begin {another arg after this one ?}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
end;
end; {back and process new argument}
sst_w.appendn^ (')', 1); {close paren of argument list}
sst_w_c_sment_end;
path_to_here := not {path continues if routine might return}
(sst_procflag_noreturn_k in opc.call_proc_p^.flags);
end;
{
***************************************
*
* Assignment statement.
}
sst_opc_assign_k: begin
sst_w_c_assign (opc.assign_var_p^, opc.assign_exp_p^);
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* GOTO statment.
}
sst_opc_goto_k: begin
sst_w_c_sment_start; {start a new statement}
sst_w.appendn^ ('goto', 4);
sst_w.delimit^;
sst_w.append_sym_name^ (opc.goto_sym_p^); {write label name}
sst_w_c_sment_end; {finish this statement}
path_to_here := false; {no path exists to after this opcode}
end;
{
***************************************
*
* CASE statement. This will have the form:
*
* switch (<expression>) [
* case <expression>:
* case <expression>:
* <statements for these cases>
* break;
* case <expression>:
* .
* .
* break;
* default:
* <statements>
* break;
* ]
*
* If the switch expression has a known value, then only the code for the
* appropriate case is written out.
}
sst_opc_case_k: begin
if opc.case_exp_p^.val_fnd then begin {value of switch expression is known ?}
sst_ordval (opc.case_exp_p^.val, ordval, stat); {get ordinal value of switch exp}
syo_error_abort (stat, opc.case_exp_p^.str_h, '', '', nil, 0);
case_val_p := opc.case_val_p; {init pointer to first choice value in list}
while case_val_p <> nil do begin {loop thru the list of choice values}
if case_val_p^.val = ordval then begin {this is the selected choice ?}
sst_w_c_exec (case_val_p^.opc_p^.code_p); {write code for selected case}
goto done_opcode;
end;
case_val_p := case_val_p^.next_val_p; {advance to next value in CASE}
end; {back and check this new choice value}
sst_w_c_exec (opc.case_none_p); {switch value didn't match any choice}
goto done_opcode;
end; {done handling switch value is known}
{
* switch <expression> [
}
sst_w_c_sment_start; {start a new statement}
sst_w.indent^; {extra indent for continued lines}
sst_w.appendn^ ('switch (', 8);
sst_w_c_exp (opc.case_exp_p^, 0, nil, enclose_no_k); {write case selection expression}
sst_w.appendn^ (')', 1);
sst_w.delimit^;
sst_w.appendn^ ('{', 1);
sst_w.line_close^;
sst_w.undent^; {back for extra indentation level}
{
* Done writing statement header. Now loop over the cases in this
* statement.
}
case_opc_p := opc.case_opc_p; {init current case to first case in chain}
while case_opc_p <> nil do begin {once for each case in CASE statement}
{
* Write the choice values for the current case. These have the form:
*
* case <expression>:
}
case_val_p := case_opc_p^.val_first_p; {init curr choice to first for this case}
while case_val_p <> nil do begin {once for each choice value for this case}
sst_w.tab_indent^;
sst_w.indent^;
sst_w.appendn^ ('case', 4);
sst_w.delimit^;
sst_w_c_exp (case_val_p^.exp_p^, 0, nil, enclose_no_k); {write choice expression}
sst_w.appendn^ (':', 1);
sst_w.line_close^;
sst_w.undent^;
case_val_p := case_val_p^.next_opc_p; {advance to next choice for this case}
end;
{
* Done writing the last choice value for the current case.
* Now write the code for this case.
}
sst_w.indent^; {code is indented one more level from choice}
sst_w_c_exec (case_opc_p^.code_p); {write the statements for this case}
if path_to_here then begin {path exists to after opcodes for this case ?}
sst_w.tab_indent^;
sst_w.appendn^ ('break;', 6);
sst_w.line_close^;
end;
sst_w.undent^; {back to level for next choice}
case_opc_p := case_opc_p^.next_p; {advance to next case in CASE statement}
end; {back and process this new case}
{
* Done handling all the explicit cases in the CASE statement. Now write
* the DEFAULT clause, if exists.
}
if opc.case_none_p <> nil then begin {DEFAULT case exists ?}
sst_w.tab_indent^;
sst_w.appendn^ ('default:', 8);
sst_w.line_close^;
sst_w.indent^; {code is indented one more level from choice}
sst_w_c_exec (opc.case_none_p); {write the statements for the default case}
sst_w.tab_indent^;
sst_w.appendn^ ('break;', 6);
sst_w.line_close^;
sst_w.undent^; {back to level of case choices}
end;
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1); {end of SWITCH statement block}
sst_w_c_sment_end; {end the SWITCH statement}
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* If statement. This will have the simple form:
*
* if (conditional expression) [
* .
* .
* ]
*
* or the more complicated form:
*
* if (conditional expression)
* [
* .
* .
* ]
* else [
* .
* .
* ]
* ;
*
* The decision logic will be removed completely if the conditional expression
* has a known value.
}
sst_opc_if_k: begin
if opc.if_exp_p^.val_fnd then begin {conditional expression value is known ?}
if opc.if_exp_p^.val.bool_val
then begin {conditional expression is TRUE}
sst_w_c_exec (opc.if_true_p);
end
else begin {conditional expression is FALSE}
sst_w_c_exec (opc.if_false_p);
end
;
goto done_opcode; {all done with this conditional opcode}
end;
sst_w_c_sment_start; {start a new statement}
sst_w.indent^; {indent header wrapping one extra level}
sst_w.appendn^ ('if', 2);
sst_w.delimit^;
sst_w.appendn^ ('(', 1);
sst_w_c_exp (opc.if_exp_p^, 0, nil, enclose_no_k); {write the conditional expression}
sst_w.appendn^ (')', 1);
if opc.if_false_p = nil
{
* Statement has the simple form.
}
then begin
sst_w.delimit^;
sst_w.appendn^ ('{', 1);
sst_w.undent^; {done with extra header wrap indent}
sst_w.line_close^;
sst_w_c_exec (opc.if_true_p);
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1);
end
{
* Statement has the more complicated form.
}
else begin
sst_w.undent^; {done with extra header wrap indent}
sst_w.line_close^;
sst_w.tab_indent^;
sst_w.appendn^ ('{', 1);
sst_w.indent^; {indent for TRUE case statements}
sst_w.line_close^;
sst_w_c_exec (opc.if_true_p); {write TRUE case statements}
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1); {end of TRUE case clause}
sst_w.undent^; {back from TRUE case clause indentation}
sst_w.line_close^;
sst_w.tab_indent^;
sst_w.appendn^ ('else {', 6);
sst_w.indent^; {indent for FALSE case statements}
sst_w.line_close^;
sst_w_c_exec (opc.if_false_p); {write the FALSE case statements}
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1);
sst_w.undent^; {back from FALSE case clause indentation}
sst_w.line_close^;
sst_w.tab_indent^;
end
;
sst_w_c_sment_end; {finish this statement}
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Counted loop statement. This will take one of three forms.
* In all cases, the loop limit will be assigned to an implicit
* variable if it is not known to be a constant. This is because
* C re-evaluates the loop limit every iteration.
*
* The loop running variable that the compiler is told about will always
* be of at least machine integer size. This makes it far less likely that
* we will be going up to the last, or down to the first possible value
* of the running variable (in which case the loop will never terminate).
*
* SYM3_P will be set to point at the substitue running variable, if one
* is created. SYM3_P will be NIL if none is created.
}
sst_opc_loop_cnt_k: begin
sst_w_c_sment_start; {start a new statement}
if opc.lpcn_exp_end_p^.val_fnd
then begin {limit expression has constant value}
sym2_p := nil; {indicate to use expression directly}
end
else begin {limit expression may change}
sst_w_c_exp_explicit ( {assign limit expression to a variable}
opc.lpcn_exp_end_p^, {descriptor for expression value}
opc.lpcn_exp_end_p^.dtype_p^, {data type for variable}
sym2_p); {returned pointing to the variable}
end
;
sym3_p := nil; {init to running variable not substituted}
dt_p := opc.lpcn_var_p^.dtype_p; {resolve running variable base data type}
while dt_p^.dtype = sst_dtype_copy_k do dt_p := dt_p^.copy_dtype_p;
if dt_p^.bits_min < sst_config.int_machine_p^.bits_min then begin {substitute ?}
sst_sym_var_new_out ( {create substitue running variable}
sst_config.int_machine_p^, {data type for new running variable}
sym3_p); {returned pointer to new variable symbol}
sst_w_c_symbol (sym3_p^); {declare the new variable}
end;
case opc.lpcn_inc_dir of
{
* Case 1 - The loop variable is counting up.
*
* for (var = initial value; var <= limit; var += increment) [
* <statements>
* ];
*
* Case 2 - The loop variable is counting down.
*
* for (var = initial value; var >= limit; var += increment) [
* <statements>
* ];
*
*
* If a substitute runing variable is created an up-counting loop will be:
*
* for (var = subvar = initial value; subvar <= limit; subvar += increment,
* var = subvar) [
* <statements>
* ];
}
sst_incdir_up_k, {loop variable is counting up}
sst_incdir_down_k: begin {loop variable is counting down}
sst_w.indent^; {indent header wrapping one extra level}
sst_w.appendn^ ('for', 3);
sst_w.delimit^;
sst_w.appendn^ ('(', 1);
sst_w_c_var (opc.lpcn_var_p^, 0);
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
if sym3_p <> nil then begin {substitute running variable in use ?}
sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
end;
sst_w_c_exp (opc.lpcn_exp_start_p^, 0, nil, enclose_no_k); {initial value expression}
sst_w.appendn^ (';', 1);
sst_w.delimit^;
if sym3_p = nil
then sst_w_c_var (opc.lpcn_var_p^, 0)
else sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
case opc.lpcn_inc_dir of {write end condition comparison operator}
sst_incdir_up_k: sst_w.appendn^ ('<=', 2);
sst_incdir_down_k: sst_w.appendn^ ('>=', 2);
end;
sst_w.delimit^;
if sym2_p = nil {write loop limit value}
then sst_w_c_exp (opc.lpcn_exp_end_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym2_p^);
sst_w.appendn^ (';', 1);
sst_w.delimit^;
if sym3_p = nil
then sst_w_c_var (opc.lpcn_var_p^, 0)
else sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('+=', 2);
sst_w.delimit^;
sst_w_c_exp (opc.lpcn_exp_inc_p^, 0, nil, enclose_yes_k); {increment value expression}
if sym3_p <> nil then begin {using a substitute running variable ?}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
sst_w_c_var (opc.lpcn_var_p^, 0); {write real variable reference}
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
sst_w.append_sym_name^ (sym3_p^);
end;
sst_w.appendn^ (')', 1);
sst_w.delimit^;
sst_w.appendn^ ('{', 1);
sst_w.undent^;
sst_w.line_close^;
end; {end of UP or DOWN increment direction case}
{
*
* Case 3 - The loop variable counting direction is not known.
*
* for (
* var = initial value;
* increment > 0 ? var >= limit : var <= limit;
* var += increment) [
* <statements>
* ];
*
* This form requires an implicit variable be created for the increment
* value if it is not a simple expression.
}
sst_incdir_unk_k: begin
sst_w_c_exp_implicit (opc.lpcn_exp_inc_p^, sym_p); {make implicit var if needed}
sst_w.indent^; {indent header wrapping one extra level}
sst_w.appendn^ ('for (', 5);
sst_w.line_close^;
sst_w.tab_indent^;
sst_w_c_var (opc.lpcn_var_p^, 0);
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
if sym3_p <> nil then begin {substitute running variable in use ?}
sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
end;
sst_w_c_exp (opc.lpcn_exp_start_p^, 0, nil, enclose_no_k); {initial value expression}
sst_w.appendn^ (';', 1);
sst_w.line_close^;
sst_w.tab_indent^;
if sym_p = nil {write increment value expression}
then sst_w_c_exp (opc.lpcn_exp_inc_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ ('>', 1);
sst_w.delimit^;
sst_w.appendn^ ('0', 1);
sst_w.delimit^;
sst_w.appendn^ ('?', 1);
sst_w.delimit^;
if sym3_p = nil
then sst_w_c_var (opc.lpcn_var_p^, 0)
else sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('>=', 2);
sst_w.delimit^;
if sym2_p = nil {write loop limit value}
then sst_w_c_exp (opc.lpcn_exp_end_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym2_p^);
sst_w.delimit^;
sst_w.appendn^ (':', 1);
sst_w.delimit^;
if sym3_p = nil
then sst_w_c_var (opc.lpcn_var_p^, 0)
else sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('<=', 2);
sst_w.delimit^;
if sym2_p = nil {write loop limit value}
then sst_w_c_exp (opc.lpcn_exp_end_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym2_p^);
sst_w.appendn^ (';', 1);
sst_w.line_close^;
sst_w.tab_indent^;
if sym3_p = nil
then sst_w_c_var (opc.lpcn_var_p^, 0)
else sst_w.append_sym_name^ (sym3_p^);
sst_w.delimit^;
sst_w.appendn^ ('+=', 2);
sst_w.delimit^;
if sym_p = nil {write increment value expression}
then sst_w_c_exp (opc.lpcn_exp_inc_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
if sym3_p <> nil then begin {using a substitute running variable ?}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
sst_w_c_var (opc.lpcn_var_p^, 0); {write real variable reference}
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
sst_w.append_sym_name^ (sym3_p^);
end;
sst_w.appendn^ (')', 1);
sst_w.delimit^;
sst_w.appendn^ ('{', 1);
sst_w.undent^;
sst_w.line_close^;
end; {end of unknown increment direction case}
end; {end of increment direction cases}
{
* The FOR statement header has been written. Now write the loop body
* and close the FOR statement. The syntax of this part is not dependent
* on the loop increment direction.
}
sst_w_c_exec (opc.lpcn_code_p); {write body of loop}
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1);
sst_w_c_sment_end; {finish FOR statement}
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Loop with the test at the top. The loop continues if the descision
* expression is TRUE. This takes the form:
*
* FOR (; expression;) [
* <statements>
* ];
}
sst_opc_loop_ttop_k: begin
sst_w_c_sment_start;
sst_w.indent^; {indent wrapped characters one more level}
sst_w.appendn^ ('for (;', 6);
sst_w.delimit^;
sst_w_c_exp (opc.lptp_exp_p^, 0, nil, enclose_no_k); {write loop decision expression}
sst_w.appendn^ (';) {', 4);
sst_w.undent^; {back to normal indentation level}
sst_w.line_close^; {end of FOR statement line}
sst_w_c_exec (opc.lptp_code_p); {write the statements inside the loop}
sst_w.tab_indent^;
sst_w.appendn^ ('}', 1); {write end of whole FOR statement}
sst_w_c_sment_end; {close the FOR statement}
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Loop with test at the bottom. The loop continues if the decision
* expression is FALSE. This takes the form:
*
* DO [
* <statements>
* ] WHILE (! expression);
}
sst_opc_loop_tbot_k: begin
sst_w_c_sment_start;
sst_w.appendn^ ('do {', 4);
sst_w.line_close^;
sst_w_c_exec (opc.lpbt_code_p); {write the statements inside the loop}
sst_w.tab_indent^;
sst_w.indent^; {indent wrapped characters an extra level}
sst_w.appendn^ ('} while (!', 10);
sst_w_c_exp (opc.lpbt_exp_p^, 0, nil, enclose_yes_k); {write loop decision expression}
sst_w.appendn^ (')', 1);
sst_w.undent^; {restore indentation level}
sst_w_c_sment_end;
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Go to start of next time around loop.
}
sst_opc_loop_next_k: begin
sst_w_c_sment_start;
sst_w.appendn^ ('continue', 8);
sst_w_c_sment_end;
path_to_here := false;
end;
{
***************************************
*
* Unconditionally exit loop.
}
sst_opc_loop_exit_k: begin
sst_w_c_sment_start;
sst_w.appendn^ ('break', 5);
sst_w_c_sment_end;
path_to_here := false;
end;
{
***************************************
*
* Return from subroutine or function. If this is a function then the function
* return value must follow the RETURN statement.
}
sst_opc_return_k: begin
sst_w_c_sment_start;
sst_w.appendn^ ('return', 6);
if frame_scope_p^.funcval_sym_p <> nil then begin {function return var exists ?}
sst_w.delimit^;
sst_w.append_sym_name^ (frame_scope_p^.funcval_sym_p^);
end;
if frame_scope_p^.scope_type = scope_type_prog_k then begin {in top program ?}
sst_w.delimit^;
sst_w.appendn^ ('0', 1);
end;
sst_w_c_sment_end;
path_to_here := false;
end;
{
***************************************
*
* Opcode declares abbreviation in effect over a specific block of code.
* The abbreviation symbol has already been declared as a variable with
* a data type of pointer to the abbreviation expansion.
}
sst_opc_abbrev_k: begin
if opc.abbrev_code_p = nil then goto done_opcode; {no code here ?}
n := 0; {init number of abbreviations actually used}
sym_p := opc.abbrev_sym_first_p; {init curr abbrev to first in list}
while sym_p <> nil do begin {once for each abbrev in list}
if sst_symflag_used_k in sym_p^.flags then begin {this abbrev actually used ?}
n := n + 1; {count one more used abbreviation}
end;
sym_p := sym_p^.next_p; {advance to next abbreviation in list}
end; {back to check this new abbreviation}
if n <= 0 then begin {no abbreviations were actually used ?}
sst_w_c_exec (opc.abbrev_code_p); {write code as if no abbrevs were declared}
goto done_opcode; {all done with the abbrev opcode}
end;
{
* This ABBREV opcode has a code section and at least one abbreviation that
* is actually used.
}
sst_w.tab_indent^; {write start bracket for new scope}
sst_w.appendn^ ('{', 1);
sst_w.line_close^;
sst_w_c_scope_push ( {enter abbrev scope and declare all symbols}
opc.abbrev_scope_p^, scope_type_rout_k);
sym_p := opc.abbrev_sym_first_p; {init curr abbrev to first in list}
sst_w_c_armode_push ( {array vars are pointers to their first ele}
array_pnt_first_k);
while sym_p <> nil do begin {once for each abbreviation in list}
if sst_symflag_used_k in sym_p^.flags then begin {this abbrev actually used ?}
sst_w_c_sment_start; {start pointer assignment statement}
sst_w.append_sym_name^ (sym_p^); {write abbreviation pointer name}
sst_w.delimit^;
sst_w.appendn^ ('=', 1);
sst_w.delimit^;
sst_w_c_var ( {write value to assign to abbrev pointer}
sym_p^.abbrev_var_p^, {abbreviation expansion variable reference}
1); {number of times to take addr of var ref}
sst_w_c_sment_end; {close abbrev pointer definition statement}
end;
sym_p := sym_p^.next_p; {advance to next abbreviation in list}
end;
sst_w_c_armode_pop;
sst_w_c_exec (opc.abbrev_code_p); {write code that uses the abbreviations}
sst_w_c_scope_pop; {pop back from abbreviations scope}
sst_w.tab_indent^; {write close bracket to end C scope}
sst_w.appendn^ ('}', 1);
sst_w.line_close^;
end;
{
***************************************
*
* Call function and discard result.
}
sst_opc_discard_k: begin
sst_w_c_sment_start;
sst_w_c_exp (opc.discard_exp_p^, 0, nil, enclose_no_k);
sst_w_c_sment_end;
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Write value of expression to standard output.
}
sst_opc_write_k: begin
sst_w_c_declare (decl_stdio_k); {make sure PRINTF and FWRITE declared}
sst_w_c_sment_start; {start this statement}
fw1_param := false; {init to field widths not passed as params}
fw2_param := false;
did_eol := false; {init to not already did following opcode}
dt_p := opc.write_exp_p^.dtype_p; {init data type of value to print}
cast_arg := false; {init to not type-cast argument}
write_new_dtype: {back here to re-try with new data type}
case dt_p^.dtype of {what data type is this ?}
sst_dtype_int_k: begin
unsig := false; {integer is signed}
write_int: {common code with SUBRANGE data type}
sst_w.appendn^ ('printf ("%', 10);
field_width (opc.write_width_exp_p, fw1_param); {write field width, if any}
{
* Determine if any prefix character needs to be written to specify a
* non-default integer argument size. Unfortunately, these characters
* are system-specific. By default, PRINTF assumes its arguments are INTs.
}
for i := 1 to sst_config.n_size_int do begin {once for each integer type}
if string_equal (sst_config.size_int[i].name, int_def_name) then begin
if dt_p^.size_used = sst_config.size_int[i].size {write default size int ?}
then goto write_int_default;
end;
end; {back and check next available integer name}
{
* The integer value we are trying to write is not of the size assumed by
* PRINTF. An special size specification character is therefore required.
}
c := ' '; {init to no suitable size char exists}
case sst_config.os of {what target environment writing code for ?}
sys_os_domain_k: begin
case dt_p^.size_used of
2: c := 'h';
end;
end;
sys_os_hpux_k: ; {no size characters available in this OS}
sys_os_aix_k: ; {no size characters available in this OS}
sys_os_irix_k: ; {no size characters available in this OS}
sys_os_solaris_k: begin
if sst_config.int_machine_p^.size_used = 1 then begin {8051 special case ?}
case dt_p^.size_used of
1: c := 'b';
4: c := 'l';
end;
end; {end of Franklin C51 compiler special case}
end; {end of SOLARIS OS case}
end; {end of OS type cases}
{
* The character C is set to non-blank if an appropriate integer argument size
* is available in this compiler.
}
cast_arg := true; {init to must type-case argument later}
if c <> ' ' then begin {applicable int arg size char was found ?}
sst_w.appendn^ (c, 1); {write the char}
cast_arg := false; {no need to type-cast argument later}
end;
write_int_default: {skip to here if writing default int size}
if unsig
then begin {integer is unsigned}
sst_w.appendn^ ('u', 1);
end
else begin {integer is signed}
sst_w.appendn^ ('i', 1);
end
;
check_eol;
end;
sst_dtype_float_k: begin
sst_w.appendn^ ('printf ("%', 10);
if opc.write_width_exp_p <> nil then begin {first field width exists ?}
field_width (opc.write_width_exp_p, fw1_param);
if opc.write_width2_exp_p <> nil then begin {second field width exists ?}
sst_w.appendn^ ('.', 1);
field_width (opc.write_width2_exp_p, fw2_param);
sst_w.appendn^ ('f', 1);
goto write_done_float;
end;
end;
sst_w.appendn^ ('g', 1);
write_done_float:
check_eol;
end;
sst_dtype_char_k: begin
preceeding_blanks (1, opc.write_width_exp_p, fw); {handle any blank padding}
sst_w.appendn^ ('printf ("%c', 11);
check_eol;
end;
sst_dtype_array_k: begin
if not dt_p^.ar_string then begin {this array is not a string of characters ?}
writeln ('Writing non-character array values not implemented.');
sys_bomb;
end;
preceeding_blanks ( {handle any blank padding}
dt_p^.ar_ind_n, opc.write_width_exp_p, fw);
if fw = 0 then begin {definately nothing more to write ?}
sst_w_c_sment_end_nclose; {close statement started for this opcode}
path_to_here := true; {executable path exists to after this opcode}
goto done_opcode;
end;
sst_w_c_armode_push (array_whole_k); {array identifiers represent whole array}
sst_w.appendn^ ('fwrite (', 8);
sst_w_c_exp (opc.write_exp_p^, 0, nil, enclose_no_k); {write string value}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
string_f_int (token, sst_config.size_char); {size of one character}
sst_w.append^ (token); {write size of each element (one character)}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
if fw >= 0
then begin {remaining field width is a known constant}
string_f_int (token, fw);
sst_w.append^ (token);
end
{
* The remaining field width is not a known constant. This makes the
* remaining field width the value of the field width expression clipped to
* 0 and the number of characters in the string. If EXP is the field width
* expression, and SLEN is the string size, the expression will have the form:
*
* EXP > 0 ? EXP < DSIZE ? EXP : DSIZE : 0
*
* An implicit variable will be created for EXP if it is not "simple". This
* may have already been done in routine PRECEEDING_BLANKS. If so, SYM_P
* is pointing to the implicit variable, otherwise SYM_P is NIL.
}
else begin
if sym_p = nil then begin {not already made implicit variable ?}
sst_w_c_exp_implicit (opc.write_width_exp_p^, sym_p);
end;
if sym_p = nil
then sst_w_c_exp (opc.write_width_exp_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ ('>', 1);
sst_w.delimit^;
sst_w.appendn^ ('0', 1);
sst_w.delimit^;
sst_w.appendn^ ('?', 1);
sst_w.delimit^;
if sym_p = nil
then sst_w_c_exp (opc.write_width_exp_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ ('<', 1);
sst_w.delimit^;
string_f_int (token, dt_p^.ar_ind_n); {make data size expression}
sst_w.append^ (token);
sst_w.delimit^;
sst_w.appendn^ ('?', 1);
sst_w.delimit^;
if sym_p = nil
then sst_w_c_exp (opc.write_width_exp_p^, 0, nil, enclose_yes_k)
else sst_w.append_sym_name^ (sym_p^);
sst_w.delimit^;
sst_w.appendn^ (':', 1);
sst_w.delimit^;
sst_w.append^ (token);
sst_w.delimit^;
sst_w.appendn^ (':', 1);
sst_w.delimit^;
sst_w.appendn^ ('0', 1);
end
; {done writing number of elements to write}
sst_w.appendn^ (',', 1);
sst_w.delimit^;
sst_w.appendn^ ('stdout)', 7);
sst_w_c_armode_pop; {restore previous array name interpret mode}
sst_w_c_sment_end;
path_to_here := true; {executable path exists to after this opcode}
goto done_opcode;
end;
sst_dtype_range_k: begin
unsig := dt_p^.range_ord_first >= 0; {true if subrange is unsigned}
goto write_int; {to common code with INTEGER data type}
end;
sst_dtype_copy_k: begin
dt_p := dt_p^.copy_dtype_p; {resolve to copied data type}
goto write_new_dtype;
end;
otherwise
sys_msg_parm_int (msg_parm[1], ord(dt_p^.dtype));
syo_error (
opc.write_exp_p^.str_h, 'sst_c_write', 'dtype_exp_unexpected', msg_parm, 1);
end;
{
* The format string has been written up to and including the closing
* character identifying the data type. FW1_PARAM and FW2_PARAM are TRUE
* if the first and second field width specifiers need to be passed as
* arguments. DID_EOL is TRUE if the next opcode has already been processed.
}
sst_w.appendn^ ('",', 2); {close the format string}
sst_w.delimit^;
if fw1_param then begin {pass field width 1 as parameter ?}
sst_w_c_exp (opc.write_width_exp_p^, 0, nil, enclose_no_k);
sst_w.appendn^ (',', 1);
sst_w.delimit^;
end;
if fw2_param then begin {pass field width 2 as parameter ?}
sst_w_c_exp (opc.write_width2_exp_p^, 0, nil, enclose_no_k);
sst_w.appendn^ (',', 1);
sst_w.delimit^;
end;
if cast_arg then begin {need to type-cast argument ?}
sst_w.appendn^ ('(', 1);
if unsig then begin {unsigned integer ?}
sst_w.appendn^ ('unsigned', 8);
sst_w.delimit^;
end;
sst_w.appendn^ ('int)', 4);
sst_w.allow_break^;
end;
sst_w_c_exp (opc.write_exp_p^, 0, nil, enclose_no_k);
sst_w.appendn^ (')', 1);
sst_w_c_sment_end;
if did_eol then begin {already handled next opcode ?}
opc_p := opc_p^.next_p; {skip over since we already did this one}
end;
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Write end-of-line to standard output.
}
sst_opc_write_eol_k: begin
sst_w_c_declare (decl_stdio_k); {make sure PRINTF is declared}
sst_w_c_sment_start; {start this statement}
sst_w.appendn^ ('printf ("\n")', 13);
sst_w_c_sment_end;
path_to_here := true; {executable path exists to after this opcode}
end;
{
***************************************
*
* Unrecognized or unexpected opcode.
}
otherwise
sys_msg_parm_int (msg_parm[1], ord(opc.opcode));
sys_message_bomb ('sst', 'opcode_unexpected', msg_parm, 1);
end; {end of opcode type cases}
end; {done with OPC abbreviation}
done_opcode: {jump here if done with current opcode}
if opc_p <> nil then begin {advance to next opcode descriptor in chain}
opc_p := opc_p^.next_p;
end;
end; {back and process new opcode}
end;
|
{$I ok_sklad.inc}
unit MetaDiscount;
interface
uses
MetaClass, XMLDoc, XMLIntf,
Classes;
type
TDiscountSourceType = (
DiscSrcCard,
DiscSrcManual,
DiscSrcWholeSaler,
DiscSrcVIP
);
TDiscountMethod = (
DiscMethodPercent,
DiscMethodValue
);
//-----------------------------------------------------------------------
TMetaDiscount = class(TMetaClass)
protected
FSourceType: TDiscountSourceType;
FSourceID: Integer;
FMethod: TDiscountMethod;
FValue: Extended;
FnonAdditive: Boolean; // when this discount can be only one
// properties handling
procedure setSourceType(const Value: TDiscountSourceType);
procedure setSourceID(const Value: Integer);
procedure setMethod(const Value: TDiscountMethod);
procedure setValue(const Value: Extended);
function LoadXMLNode(var topNode, Node: IXMLNode; paramIndex: Integer = -1): Boolean;
public
constructor Create(const AParent: TMetaClass); overload;
constructor Create(const AParent: TMetaClass; const AMethod: TDiscountMethod; const AValue: Extended); overload;
procedure Clear;
property SourceType: TDiscountSourceType read FSourceType write setSourceType;
property SourceID: Integer read FSourceID write setSourceID;
property Method: TDiscountMethod read FMethod write setMethod;
property Value: Extended read FValue write setValue;
end;
//-----------------------------------------------------------------------
TMetaDiscountList = class(TMetaClassList)
protected
function LoadXMLNode(var topNode, Node: IXMLNode; paramIndex: Integer = -1): Boolean;
public
constructor Create(const AParent: TMetaClass);
destructor Destroy; override;
procedure Clear;
function Add(const Value: TMetaDiscount): Integer; overload;
function Add(const AMethod: TDiscountMethod; const AValue: Extended): Integer; overload;
// property processing
function getItem(const idx: Integer): TMetaDiscount;
procedure setItem(const idx: Integer; const Value: TMetaDiscount);
function getCount: Integer;
property Items[const idx: Integer]: TMetaDiscount read getItem write setItem; default;
end;
//==============================================================================================
//==============================================================================================
//==============================================================================================
//==============================================================================================
implementation
uses
udebug, SysUtils, StrUtils;
var
DEBUG_unit_ID: Integer; Debugging: Boolean; DEBUG_group_ID: String = '';
//==============================================================================================
constructor TMetaDiscount.Create(const AParent: TMetaClass);
begin
inherited;
Clear;
end;
//==============================================================================================
constructor TMetaDiscount.Create(const AParent: TMetaClass; const AMethod: TDiscountMethod; const AValue: Extended);
begin
Create(AParent);
FMethod := AMethod;
FValue := AValue;
Clear;
end;
//==============================================================================================
procedure TMetaDiscount.Clear;
begin
inherited;
FSourceType := DiscSrcManual;
FSourceID := -1;
FMethod := DiscMethodValue;
FValue := 0;
setModified(False);
end;
//==============================================================================================
procedure TMetaDiscount.setSourceType(const Value: TDiscountSourceType);
begin
if FSourceType = Value then Exit;
FsourceType := Value;
setModified(True);
end;
//==============================================================================================
procedure TMetaDiscount.setSourceID(const Value: Integer);
begin
if FSourceID = Value then Exit;
FSourceID := Value;
setModified(True);
end;
//==============================================================================================
procedure TMetaDiscount.setMethod(const Value: TDiscountMethod);
begin
if FMethod = Value then Exit;
FMethod := Value;
setModified(True);
end;
//==============================================================================================
procedure TMetaDiscount.setValue(const Value: Extended);
begin
if FValue = Value then Exit;
FValue := Value;
setModified(True);
end;
//==============================================================================================
function TMetaDiscount.LoadXMLNode(var topNode, Node: IXMLNode; paramIndex: Integer = -1): Boolean;
var
name, data: string;
begin
Result := True;
name := AnsiLowerCase(Node.NodeName);
data := trim(Node.Text);
try
if name = 'value' then begin
FValue := StrToFloat(data);
Exit;
end
else if name = 'sourceid' then begin
FSourceID := StrToInt(data);
Exit;
end;
except
Ferror := ap_err_XML_badData;
Exit;
end;
if name = 'nonadditive' then begin
FnonAdditive := StrToBool(data);
Exit;
end
else if name = 'method' then begin
data := AnsiLowerCase(data);
if data = 'percent'
then FMethod := DiscMethodPercent
else FMethod := DiscMethodValue;
Exit;
end
else if name = 'sourcetype' then begin
data := AnsiLowerCase(data);
if data = 'card'
then FSourceType := DiscSrcCard
else if data = 'manual'
then FSourceType := DiscSrcManual
else if data = 'wholesaler'
then FSourceType := DiscSrcWholeSaler
else if data = 'vip'
then FSourceType := DiscSrcVIP;
Exit;
end
else Result := inherited loadXMLNode(Node, Node);
end;
//==============================================================================================
//==============================================================================================
//==============================================================================================
constructor TMetaDiscountList.Create(const AParent: TMetaClass);
begin
inherited;
end;
//==============================================================================================
destructor TMetaDiscountList.Destroy;
begin
Clear;
FItems.Free;
end;
//==============================================================================================
procedure TMetaDiscountList.Clear;
var i: Integer;
begin
for i := 0 to FItems.Count - 1 do TMetaDiscount(FItems[i]).Destroy;
end;
//==============================================================================================
function TMetaDiscountList.Add(const Value: TMetaDiscount): Integer;
begin
Result := FItems.Add(Value);
end;
//==============================================================================================
function TMetaDiscountList.Add(const AMethod: TDiscountMethod; const AValue: Extended): Integer;
begin
Result := FItems.Add(TMetaDiscount.Create(Self, AMethod, AValue));
end;
//==============================================================================================
function TMetaDiscountList.getItem(const idx: Integer): TMetaDiscount;
begin
Result := TMetaDiscount(FItems[idx]);
end;
//==============================================================================================
procedure TMetaDiscountList.setItem(const idx: Integer; const Value: TMetaDiscount);
begin
FItems[idx] := Value;
end;
//==============================================================================================
function TMetaDiscountList.getCount: Integer;
begin
Result := FItems.Count;
end;
//==============================================================================================
function TMetaDiscountList.LoadXMLNode(var topNode, Node: IXMLNode; paramIndex: Integer = -1): Boolean;
var
name, data: string;
d: TMetaDiscount;
begin
Result := True;
name := AnsiLowerCase(Node.NodeName);
data := trim(Node.Text);
try
if name = 'discount' then begin
d := TMetaDiscount.Create(Self);
FItems.Add(d);
Result := d.loadXML(node);
Exit;
end;
except
Ferror := ap_err_XML_badData;
Exit;
end;
Result := inherited loadXMLNode(Node, Node);
end;
//==============================================================================================
initialization
{$IFDEF UDEBUG}
Debugging := False;
DEBUG_unit_ID := debugRegisterUnit('MetaDiscount', @Debugging, DEBUG_group_ID);
{$ENDIF}
//==============================================================================================
finalization
//{$IFDEF UDEBUG}debugUnregisterUnit(DEBUG_unit_ID);{$ENDIF}
end.
|
unit Classe.Calculadora;
interface
type
iCalculadora = interface
['{9D5EAAD8-9C87-4A4A-96DD-98B4DDA09977}']
// CTRL+SHIHT+C ´para criar a assinatura
function Operacao(Num1, Num2 : double) : double;
//herdar de mais de uma classe, usando interface
end;
TSoma = class(TInterfacedObject,iCalculadora)
function Operacao(Num1, Num2 : double) : double;
end;
TSubtrair = class(TInterfacedObject,iCalculadora)
function Operacao(Num1, Num2 : double) : double;
end;
TMultiplicar = class(TInterfacedObject,iCalculadora)
function Operacao(Num1, Num2 : double) : double;
end;
TDividir = class(TInterfacedObject,iCalculadora)
function Operacao(Num1, Num2 : double) : double;
end;
implementation
uses
System.SysUtils;
{ TSoma }
function TSoma.Operacao(Num1, Num2: double): double;
begin
Result := Num1 + Num2;
end;
{ TDividir }
function TDividir.Operacao(Num1, Num2: double): double;
begin
if Num2<=0 then
raise Exception.Create('Valor não pode ser dividido por zero');
Result := Num1 / Num2;
end;
{ TMultiplicar }
function TMultiplicar.Operacao(Num1, Num2: double): double;
begin
Result := Num1 * Num2;
end;
{ TSubtrair }
function TSubtrair.Operacao(Num1, Num2: double): double;
begin
Result := Num1 - Num2;
end;
end.
|
unit SDTdxForm;
interface
uses
Windows, Forms, BaseForm, Classes, Controls, Sysutils, StdCtrls,
VirtualTrees, BaseStockFormApp,
define_dealItem, define_stock_quotes,
StockMinuteDataAccess, ExtCtrls;
type
PMinuteNodeData = ^TMinuteNodeData;
TMinuteNodeData = record
MinuteData: PRT_Quote_Minute;
end;
TfrmSDTdx = class(TfrmBase)
pnl1: TPanel;
btnImport: TButton;
btnLoad: TButton;
btnSave: TButton;
Label1: TLabel;
Panel1: TPanel;
vt1: TVirtualStringTree;
Panel2: TPanel;
btnImportAll: TButton;
edRootPath: TEdit;
edStock: TEdit;
btnGetInfo: TButton;
mmo1: TMemo;
procedure btnImportClick(Sender: TObject);
procedure vt1GetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
Column: TColumnIndex; TextType: TVSTTextType; var CellText: WideString);
procedure btnLoadClick(Sender: TObject);
procedure btnSaveClick(Sender: TObject);
procedure btnImportAllClick(Sender: TObject);
procedure btnGetInfoClick(Sender: TObject);
protected
fMinuteDataAccess: TStockMinuteDataAccess;
fColDateTime: TVirtualTreeColumn;
fColPriceOpen: TVirtualTreeColumn;
fColPriceHigh: TVirtualTreeColumn;
fColPriceLow: TVirtualTreeColumn;
fColPriceClose: TVirtualTreeColumn;
fColVolume: TVirtualTreeColumn;
procedure ImportDayData;
procedure ImportTxtData; overload;
procedure ImportTxtData(AFileUrl: string); overload;
procedure ImportLcData;
procedure LoadStockData_Minute2View;
procedure InitVirtualTreeView;
public
constructor Create(Owner: TComponent); override;
end;
implementation
{$R *.dfm}
uses
iniFiles,
RichEdit,
define_datasrc,
define_price,
define_datetime,
define_dealstore_file,
//utilsLog,
StockData_Import_tdx,
StockMinuteData_Load,
StockMinuteData_Save;
type
TTdxMinuteDataHead = packed record // 26 字节
// 570 的话表示9:30分(570/60=9.5)
DealTime: Word; // 2
PriceNow: Integer; // 4
PriceAverage: Integer; // 4 均价
Volume: Word; // 2 个或 4 个字节
end;
TTdxMinuteDataSection = packed record
DataHead: TTdxMinuteDataHead;
DataReserve: array[0..26 - 1 - SizeOf(TTdxMinuteDataHead)] of Byte;
end;
PTdxData = ^TTdxData;
TTdxData = packed record
MinuteData: array[0..65565] of TTdxMinuteDataSection;
end;
(*//
通达信日线和分时图数据格式
http://blog.csdn.net/coollzt/article/details/7245298
http://blog.csdn.net/coollzt/article/details/7245312
http://blog.csdn.net/coollzt/article/details/7245304
http://www.tdx.com.cn/list_66_68.html
原来 招商证券 通达信 可以直接导出 那就直接导出好了
//*)
constructor TfrmSDTdx.Create(Owner: TComponent);
var
tmpIni: TIniFile;
begin
inherited;
InitVirtualTreeView;
tmpIni := TIniFile.Create(ChangeFileExt(paramStr(0), '.ini'));
try
edRootPath.Text := tmpIni.ReadString('TDX', 'RootPath', '');
finally
tmpIni.Free;
end;
end;
procedure TfrmSDTdx.InitVirtualTreeView;
begin
vt1.NodeDataSize := SizeOf(TMinuteNodeData);
vt1.Header.Options := [hoColumnResize, hoVisible];
vt1.Indent := 1;
fColDateTime := vt1.Header.Columns.Add;
fColDateTime.Text := 'DateTime';
fColDateTime.Width := vt1.Canvas.TextWidth('XXXyyyy-mm-dd hh:nn:ss');
fColPriceOpen := vt1.Header.Columns.Add;
fColPriceOpen.Text := 'Open';
fColPriceOpen.Width := vt1.Canvas.TextWidth('XXXXXXYYY');
fColPriceHigh := vt1.Header.Columns.Add;
fColPriceHigh.Text := 'High';
fColPriceHigh.Width := fColPriceOpen.Width;
fColPriceLow := vt1.Header.Columns.Add;
fColPriceLow.Text := 'Low';
fColPriceLow.Width := fColPriceOpen.Width;
fColPriceClose := vt1.Header.Columns.Add;
fColPriceClose.Text := 'Close';
fColPriceClose.Width := fColPriceOpen.Width;
fColVolume := vt1.Header.Columns.Add;
fColVolume.Text := 'Volume';
fColVolume.Width := vt1.Canvas.TextWidth('xxxxxxxxxxx');
end;
procedure TfrmSDTdx.ImportLcData;
var
tmpFileUrl: string;
begin
tmpFileUrl := 'E:\StockApp\sdata\sh999999.lc5';
end;
procedure TfrmSDTdx.ImportDayData;
begin
// Vipdoc\sh\lday\*.day
(*
tmpFileUrl := 'E:\StockApp\sdata\sh600000.day';
tmpWinFile := CheckOutWinFile;
try
if WinFileOpen(tmpWinFile, tmpFileUrl, false) then
begin
if WinFileOpenMap(tmpWinFile) then
begin
tmpFileData := tmpWinFile.FileMapRootView;
if nil <> tmpFileData then
begin
end;
end;
end;
finally
CheckInWinFile(tmpWinFile);
end;
//*)
end;
procedure TfrmSDTdx.ImportTxtData();
var
tmpFileUrl: string;
begin
tmpFileUrl := 'E:\StockApp\sdata\999999.txt';
tmpFileUrl := 'E:\StockApp\sdata\002414.txt';
tmpFileUrl := 'E:\StockApp\sdata\000050.txt';
//tmpFileUrl := 'E:\StockApp\sdata\600050.txt';
fMinuteDataAccess := TStockMinuteDataAccess.Create(nil, src_tongdaxin, weightUnknown);
ImportStockData_Minute_TDX_FromFile(fMinuteDataAccess, tmpFileUrl);
LoadStockData_Minute2View;
end;
procedure TfrmSDTdx.LoadStockData_Minute2View;
var
i: integer;
tmpVNode: PVirtualNode;
tmpVNodeData: PMinuteNodeData;
begin
if nil <> fMinuteDataAccess then
begin
vt1.Clear;
vt1.BeginUpdate;
try
for i := 0 to fMinuteDataAccess.RecordCount - 1 do
begin
tmpVNode := vt1.AddChild(nil);
tmpVNodeData := vt1.GetNodeData(tmpVNode);
if nil <> tmpVNodeData then
begin
tmpVNodeData.MinuteData := fMinuteDataAccess.RecordItem[i];
end;
end;
finally
vt1.EndUpdate;
end;
end;
end;
procedure TfrmSDTdx.vt1GetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
Column: TColumnIndex; TextType: TVSTTextType; var CellText: WideString);
var
tmpVNodeData: PMinuteNodeData;
begin
inherited;
CellText := '';
tmpVNodeData := vt1.GetNodeData(Node);
if nil <> tmpVNodeData then
begin
if nil <> fColDateTime then
begin
if Column = fColDateTime.Index then
begin
CellText := FormatDateTime('yyyy-mm-dd hh:nn:ss', DateTimeStock2DateTime(@tmpVNodeData.MinuteData.DealDateTime));
end;
end;
if nil <> fColPriceOpen then
begin
if Column = fColPriceOpen.Index then
begin
CellText := IntToStr(tmpVNodeData.MinuteData.PriceRange.PriceOpen.Value);
end;
end;
if nil <> fColPriceHigh then
begin
if Column = fColPriceHigh.Index then
begin
CellText := IntToStr(tmpVNodeData.MinuteData.PriceRange.PriceHigh.Value);
end;
end;
if nil <> fColPriceLow then
begin
if Column = fColPriceLow.Index then
begin
CellText := IntToStr(tmpVNodeData.MinuteData.PriceRange.PriceLow.Value);
end;
end;
if nil <> fColPriceClose then
begin
if Column = fColPriceClose.Index then
begin
CellText := IntToStr(tmpVNodeData.MinuteData.PriceRange.PriceClose.Value);
end;
end;
if nil <> fColVolume then
begin
if Column = fColVolume.Index then
begin
CellText := IntToStr(tmpVNodeData.MinuteData.DealVolume);
end;
end;
end;
end;
procedure TfrmSDTdx.ImportTxtData(AFileUrl: string);
//var
// tmpFileName: string;
begin
// if not FileExists(AFileUrl) then
// exit;
// tmpFileName := ExtractFileName(AFileUrl);
end;
function Process_ReadRichEditText(AHandle: THandle): WideString;
var
vGetTextEx: GETTEXTEX;
vGetTextLengthEx: GETTEXTLENGTHEX;
L: Integer;
vProcessId: DWORD;
vProcess: THandle;
vPointer: Pointer;
vNumberOfBytesRead: Cardinal;
begin
Result := '';
if not IsWindow(AHandle) then
Exit;
GetWindowThreadProcessId(AHandle, @vProcessId);
vProcess := OpenProcess(PROCESS_VM_OPERATION or PROCESS_VM_READ or
PROCESS_VM_WRITE, False, vProcessId);
try
vPointer := VirtualAllocEx(vProcess, nil, 4096, MEM_RESERVE or MEM_COMMIT,
PAGE_READWRITE);
try
vGetTextLengthEx.flags := GTL_DEFAULT;
vGetTextLengthEx.codepage := 1200; // Unicode
WriteProcessMemory(vProcess, vPointer, @vGetTextLengthEx,
SizeOf(vGetTextLengthEx), vNumberOfBytesRead);
L := SendMessage(AHandle, EM_GETTEXTLENGTHEX, Integer(vPointer), 0);
finally
VirtualFreeEx(vProcess, vPointer, 0, MEM_RELEASE);
end;
if L <= 0 then Exit;
vPointer := VirtualAllocEx(vProcess, nil, SizeOf(vGetTextEx) + L * 2 + 2,
MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE);
try
SetLength(Result, L);
vGetTextEx.cb := L * 2 + 2; // 加上结束符号
vGetTextEx.flags := GT_DEFAULT;
vGetTextEx.codepage := 1200; // Unicode
vGetTextEx.lpDefaultChar := nil;
vGetTextEx.lpUsedDefChar := nil;
WriteProcessMemory(vProcess, vPointer, @vGetTextEx,
SizeOf(vGetTextEx), vNumberOfBytesRead);
SendMessage(AHandle, EM_GETTEXTEX, Integer(vPointer),
Integer(vPointer) + SizeOf(vGetTextEx));
ReadProcessMemory(vProcess, Pointer(Integer(vPointer) + SizeOf(vGetTextEx)),
@Result[1], L * 2, vNumberOfBytesRead);
finally
VirtualFreeEx(vProcess, vPointer, 0, MEM_RELEASE);
end;
finally
CloseHandle(vProcess);
end;
end; { Process_ReadRichEditText }
procedure TfrmSDTdx.btnGetInfoClick(Sender: TObject);
var
tmpWnd: HWND;
begin
inherited;
// F10 信息获取 ???
tmpWnd := $000D0C5A;
if IsWindow(tmpWnd) then
begin
mmo1.Lines.BeginUpdate;
mmo1.Lines.Clear;
mmo1.Lines.Add(Process_ReadRichEditText(tmpWnd));
//
mmo1.Lines.ENdUpdate;
end;
end;
procedure TfrmSDTdx.btnImportAllClick(Sender: TObject);
var
i: integer;
tmpDealItem: PRT_DealItem;
// tmpFileUrl: WideString;
tmpTxtFile: string;
tmpSaveFile: string;
tmpRootPath: string;
tmpCode: string;
tmpMinuteData: TStockMinuteDataAccess;
tmpIni: TIniFile;
begin
inherited;
tmpRootPath := IncludeTrailingPathDelimiter(Trim(edRootPath.Text));
if not DirectoryExists(tmpRootPath) then
exit;
tmpIni := TIniFile.Create(ChangeFileExt(paramStr(0), '.ini'));
try
tmpIni.WriteString('TDX', 'RootPath', tmpRootPath);
finally
tmpIni.Free;
end;
for i := 0 to TBaseStockApp(App).StockItemDB.RecordCount - 1 do
begin
if Application.Terminated then
Break;
tmpDealItem := TBaseStockApp(App).StockItemDB.Items[i];
if 0 = tmpDealItem.EndDealDate then
begin
//tmpFile := 'F:\Program Files\zd_zszq\';
tmpTxtFile := tmpRootPath + 'T0002\export\';
tmpCode := tmpDealItem.sCode;
tmpTxtFile := tmpTxtFile + tmpCode + '.txt';
label1.Caption := tmpCode;
//Log('SDTdxForm.pas', 'Import:' + tmpFile);
if FileExists(tmpTxtFile) then
begin
//Log('SDTdxForm.pas', 'Import File Begin' + tmpTxtFile);
tmpSaveFile := App.Path.GetFileUrl(
tmpDealItem.DBType,
FilePath_DataType_MinuteData,
DataSrc_tongdaxin, 60, tmpDealItem);
if FileExists(tmpSaveFile) then
begin
Continue;
end;
tmpMinuteData := TStockMinuteDataAccess.Create(tmpDealItem, src_tongdaxin, weightNone);
try
ImportStockData_Minute_TDX_FromFile(tmpMinuteData, tmpTxtFile);
//Log('SDTdxForm.pas', 'Save File ' + tmpCode + ' minute:' + IntToStr(tmpMinuteData.Minute));
SaveStockMinuteData(App, tmpMinuteData);
finally
tmpMinuteData.Free;
end;
end;
end;
Sleep(10);
Application.ProcessMessages;
//if 2 = i then
// Break;
end;
//
end;
procedure TfrmSDTdx.btnImportClick(Sender: TObject);
begin
inherited;
//tmpFileUrl := 'E:\StockApp\sdata\20160617\sh160617.mhq';
//tmpFileUrl := 'E:\StockApp\sdata\20160617\sh160617.ref';
//tmpFileUrl := 'E:\StockApp\sdata\20160617\20160617.tic';
ImportTxtData;
end;
procedure TfrmSDTdx.btnLoadClick(Sender: TObject);
var
tmpDealItem: PRT_DealItem;
begin
inherited;
tmpDealItem := TBaseStockApp(App).StockItemDB.FindDealItemByCode(edStock.Text);
if nil = tmpDealItem then
exit;
if nil <> fMinuteDataAccess then
fMinuteDataAccess.Free;
fMinuteDataAccess := TStockMinuteDataAccess.Create(tmpDealItem, src_tongdaxin, weightUnknown);
//LoadStockMinuteData(App, fMinuteDataAccess, 'e:\minute.m60');
//fMinuteDataAccess.StockCode := '000050';
if nil = fMinuteDataAccess.StockItem then
begin
if '' <> fMinuteDataAccess.StockCode then
begin
fMinuteDataAccess.StockItem := TBaseStockApp(App).StockItemDB.FindDealItemByCode(fMinuteDataAccess.StockCode);
end;
end;
fMinuteDataAccess.Minute := 60;
LoadStockMinuteData(App, fMinuteDataAccess);
LoadStockData_Minute2View;
//
end;
procedure TfrmSDTdx.btnSaveClick(Sender: TObject);
begin
inherited;
if nil <> fMinuteDataAccess then
begin
if 0 < fMinuteDataAccess.RecordCount then
begin
//SaveStockMinuteData(App, fMinuteDataAccess, 'e:\minute.m60');
if nil = fMinuteDataAccess.StockItem then
begin
if '' <> fMinuteDataAccess.StockCode then
begin
fMinuteDataAccess.StockItem := TBaseStockApp(App).StockItemDB.FindDealItemByCode(fMinuteDataAccess.StockCode);
end;
end;
if nil <> fMinuteDataAccess.StockItem then
begin
SaveStockMinuteData(App, fMinuteDataAccess);
end;
end;
end;
//
end;
end.
|
unit vg_dsgn_lang;
interface
uses
SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, vg_scene, vg_layouts, vg_listbox, vg_controls,
vg_objects, vg_textbox, vgCustomResources, vgComponent, vgCustomObject,
vgCustomControl, vgScenePrim;
type
TvgLangDesigner = class(TForm)
vgScene1: TvgScene;
Root1: TvgHudWindow;
vgResources1: TvgResources;
OriginalList: TvgHudListBox;
btnAddItem: TvgHudCornerButton;
langList: TvgHudPopupBox;
ToolBar1: TvgToolBar;
inputLang: TvgHudTextBox;
HudLabel1: TvgHudLabel;
layoutSelect: TvgLayout;
HudLabel2: TvgHudLabel;
btnAddNewLang: TvgHudButton;
btnCancalAdd: TvgHudButton;
layoutAdd: TvgLayout;
layoutAddText: TvgLayout;
btnAddText: TvgHudButton;
btnCancelAddText: TvgHudButton;
inputAddText: TvgHudTextBox;
btnRemoveItem: TvgHudCornerButton;
btnCollect: TvgHudCornerButton;
SaveDialog1: TSaveDialog;
OpenDialog1: TOpenDialog;
btnAddLang: TvgHudButton;
btnLoadTxt: TvgHudButton;
btnCreateTemplate: TvgHudCornerButton;
btnLoadLng: TvgHudCornerButton;
btnSaveLng: TvgHudCornerButton;
OpenDialog2: TOpenDialog;
SaveDialog2: TSaveDialog;
procedure btnAddClick(Sender: TObject);
procedure btnAddLangClick(Sender: TObject);
procedure langListChange(Sender: TObject);
procedure btnAddItemClick(Sender: TObject);
procedure btnRemoveItemClick(Sender: TObject);
procedure btnAddNewLangClick(Sender: TObject);
procedure btnCancalAddClick(Sender: TObject);
procedure btnCancelAddTextClick(Sender: TObject);
procedure btnAddTextClick(Sender: TObject);
procedure btnCollectClick(Sender: TObject);
procedure btnCreateTemplateClick(Sender: TObject);
procedure btnLoadTxtClick(Sender: TObject);
procedure btnLoadLngClick(Sender: TObject);
procedure btnSaveLngClick(Sender: TObject);
private
{ Private declarations }
FLang: TvgLang;
FCurLang: WideString;
procedure RebuildOriginalList;
procedure DoTranslateChanged(Sender: TObject);
public
{ Public declarations }
end;
var
vgLangDesigner: TvgLangDesigner;
procedure ShowDsgnLang(Lang: TvgLang);
implementation
{$R *.dfm}
procedure ShowDsgnLang(Lang: TvgLang);
begin
vgLangDesigner := TvgLangDesigner.Create(Application);
with vgLangDesigner do
begin
FLang := Lang;
langList.Items.Assign(Lang.Resources);
if langList.Items.Count > 0 then
langList.ItemIndex := Lang.Resources.IndexOf(Lang.Lang);
layoutAdd.Visible := langList.Items.Count = 0;
layoutSelect.Visible := langList.Items.Count > 0;
RebuildOriginalList;
if ShowModal = mrOk then
begin
FLang.Lang := langList.Text;
end;
end;
vgLangDesigner.Free;
end;
procedure TvgLangDesigner.RebuildOriginalList;
var
i: integer;
Str: TvgWideStrings;
Item: TvgListboxItem;
begin
OriginalList.Clear;
if FLang.Original.Count = 0 then
begin
// create original from Collection
CollectLangStart;
UpdateLang;
FLang.Original.Assign(CollectLangStrings);
CollectLangFinish;
end;
Str := FLang.Original;
for i := 0 to Str.Count - 1 do
begin
Item := TvgListboxItem.Create(Self);
Item.AutoTranslate := false;
Item.Resource := 'langitem';
Item.Text := Str[i];
Item.TextAlign := vgTextAlignCenter;
Item.Height := 22;
Item.Parent := OriginalList;
if (FLang.Resources.Count > 0) and (langList.ItemIndex >= 0) then
begin
if FLang.LangStr[langList.Text] <> nil then
begin
Item.Binding['translate'] := FLang.LangStr[langList.Text].Values[Str[i]];
Item.Binding['translate'] := EventToVariant(DoTranslateChanged);
end;
end
else
TvgVisualObject(Item.FindBinding('translate').Visual).Visible := false;
end;
end;
procedure TvgLangDesigner.btnAddClick(Sender: TObject);
var
List: TvgListBox;
begin
{ add new lang }
List := TvgListBox.Create(Self);
end;
procedure TvgLangDesigner.DoTranslateChanged(Sender: TObject);
begin
if (FLang.LangStr[langList.Text] <> nil) and (OriginalList.Selected <> nil) then
with FLang.LangStr[langList.Text] do
begin
Values[OriginalList.Selected.Text] := TvgTextBox(Sender).Text;
end;
end;
procedure TvgLangDesigner.btnAddLangClick(Sender: TObject);
var
S: string;
begin
if inputLang.Text = '' then Exit;
S := inputLang.Text;
if Length(S) > 2 then
Delete(S, 3, MaxInt);
FLang.AddLang(S);
langList.Items := FLang.Resources;
langList.ItemIndex := langList.Items.IndexOf(S);
RebuildOriginalList;
layoutAdd.Visible := false;
layoutSelect.Visible := true;
end;
procedure TvgLangDesigner.langListChange(Sender: TObject);
begin
RebuildOriginalList;
end;
procedure TvgLangDesigner.btnAddNewLangClick(Sender: TObject);
begin
layoutAdd.Visible := true;
layoutSelect.Visible := false;
btnCancalAdd.Visible := langList.Items.Count > 0;
inputLang.Text := '';
inputLang.SetFocus;
end;
procedure TvgLangDesigner.btnCancalAddClick(Sender: TObject);
begin
if langList.Items.Count > 0 then
begin
layoutAdd.Visible := false;
layoutSelect.Visible := true;
end;
end;
procedure TvgLangDesigner.btnAddItemClick(Sender: TObject);
begin
{ Add Word }
layoutAdd.Visible := false;
layoutSelect.Visible := false;
layoutAddText.Visible := true;
inputAddText.Text := '';
inputAddText.SetFocus;
RebuildOriginalList;
end;
procedure TvgLangDesigner.btnRemoveItemClick(Sender: TObject);
begin
{ Remove Word }
if OriginalList.ItemIndex >= 0 then
begin
FLang.Original.Delete(OriginalList.ItemIndex);
RebuildOriginalList;
end;
end;
procedure TvgLangDesigner.btnCancelAddTextClick(Sender: TObject);
begin
layoutAdd.Visible := langList.Items.Count = 0;
layoutSelect.Visible := langList.Items.Count > 0;
layoutAddText.Visible := false;
end;
procedure TvgLangDesigner.btnAddTextClick(Sender: TObject);
begin
btnCancelAddTextClick(Sender);
FLang.Original.Add(inputAddText.Text);
RebuildOriginalList;
OriginalList.ItemIndex := OriginalList.Count - 1;
end;
procedure TvgLangDesigner.btnCollectClick(Sender: TObject);
var
Str: TvgWideStrings;
i: integer;
begin
CollectLangStart;
UpdateLang;
Str := TvgWideStringList.Create;
Str.Assign(CollectLangStrings);
for i := 0 to Str.Count - 1 do
if FLang.Original.IndexOf(Str[i]) < 0 then
FLang.Original.Add(Str[i]);
FreeAndNil(Str);
CollectLangFinish;
RebuildOriginalList;
end;
procedure TvgLangDesigner.btnCreateTemplateClick(Sender: TObject);
var
Str: TvgWideStrings;
i: integer;
begin
if SaveDialog1.Execute then
begin
Str := TvgWideStringList.Create;
Str.Assign(FLang.Original);
for i := 0 to Str.Count - 1 do
Str[i] := Str[i] + '=';
Str.SaveToFile(SaveDialog1.FileName);
FreeAndNil(Str);
end;
end;
procedure TvgLangDesigner.btnLoadTxtClick(Sender: TObject);
var
Str: TvgWideStrings;
i: integer;
begin
if OpenDialog1.Execute then
begin
FLang.AddLang(inputLang.Text);
langList.Items := FLang.Resources;
langList.ItemIndex := langList.Items.IndexOf(inputLang.Text);
RebuildOriginalList;
layoutAdd.Visible := false;
layoutSelect.Visible := true;
Str := TvgWideStringList.Create;
Str.LoadFromFile(OpenDialog1.FileName);
for i := 0 to Str.Count - 1 do
if FLang.LangStr[langList.Text].IndexOfName(Str.Names[i]) < 0 then
FLang.LangStr[langList.Text].Add(Str[i])
else
FLang.LangStr[langList.Text].Values[Str.Names[i]] := Str.Values[Str.Names[i]];
FreeAndNil(Str);
RebuildOriginalList;
end;
end;
procedure TvgLangDesigner.btnLoadLngClick(Sender: TObject);
begin
if OpenDialog2.Execute then
begin
FLang.LoadFromFile(OpenDialog2.FileName);
RebuildOriginalList;
end;
end;
procedure TvgLangDesigner.btnSaveLngClick(Sender: TObject);
begin
if SaveDialog2.Execute then
begin
FLang.SaveToFile(SaveDialog2.FileName);
end;
end;
end.
|
{ ***************************************************************************** }
{ * string support,writen by QQ 600585@qq.com * }
{ * https://github.com/PassByYou888/CoreCipher * }
(* https://github.com/PassByYou888/ZServer4D *)
{ ****************************************************************************** }
(*
update history
2017-11-26
fixed UnicodeString in FPC
*)
unit PascalStrings;
{$I ZDefine.inc}
interface
uses SysUtils;
type
SystemChar = Char;
SystemString = string;
THash = Cardinal;
THash64 = UInt64;
PSystemString = ^SystemString;
PPascalString = ^TPascalString;
TPascalChars = array of Char;
TPascalString = record
private
function GetText: SystemString;
procedure SetText(const Value: SystemString);
function GetLen: Integer;
procedure SetLen(const Value: Integer);
function GetItems(index: Integer): SystemChar;
procedure SetItems(index: Integer; const Value: SystemChar);
function GetBytes: TBytes;
procedure SetBytes(const Value: TBytes);
function GetLast: SystemChar;
procedure SetLast(const Value: SystemChar);
function GetFirst: SystemChar;
procedure SetFirst(const Value: SystemChar);
public
Buff: TPascalChars;
{$IFDEF DELPHI}
class operator Equal(const Lhs, Rhs: TPascalString): Boolean;
class operator NotEqual(const Lhs, Rhs: TPascalString): Boolean;
class operator GreaterThan(const Lhs, Rhs: TPascalString): Boolean;
class operator GreaterThanOrEqual(const Lhs, Rhs: TPascalString): Boolean;
class operator LessThan(const Lhs, Rhs: TPascalString): Boolean;
class operator LessThanOrEqual(const Lhs, Rhs: TPascalString): Boolean;
class operator Add(const Lhs, Rhs: TPascalString): TPascalString;
class operator Add(const Lhs: SystemString; const Rhs: TPascalString): TPascalString;
class operator Add(const Lhs: TPascalString; const Rhs: SystemString): TPascalString;
class operator Add(const Lhs: SystemChar; const Rhs: TPascalString): TPascalString;
class operator Add(const Lhs: TPascalString; const Rhs: SystemChar): TPascalString;
class operator Implicit(Value: Variant): TPascalString;
class operator Implicit(Value: SystemString): TPascalString;
class operator Implicit(Value: SystemChar): TPascalString;
class operator Implicit(Value: TPascalString): SystemString;
class operator Implicit(Value: TPascalString): Variant;
class operator Explicit(Value: TPascalString): SystemString;
class operator Explicit(Value: TPascalString): Variant;
class operator Explicit(Value: SystemString): TPascalString;
class operator Explicit(Value: Variant): TPascalString;
class operator Explicit(Value: SystemChar): TPascalString;
{$ENDIF}
function copy(index, count: Integer): TPascalString; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function Same(const t: TPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function Same(const IgnoreCase: Boolean; const t: TPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function ComparePos(Offset: Integer; const t: PPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function ComparePos(Offset: Integer; const t: TPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function GetPos(const SubStr: TPascalString; const Offset: Integer = 1): Integer; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function Exists(c: SystemChar): Boolean; overload;
function Exists(c: array of SystemChar): Boolean; overload;
property Last: SystemChar read GetLast write SetLast;
property First: SystemChar read GetFirst write SetFirst;
procedure DeleteLast; {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure DeleteFirst; {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure Delete(idx, cnt: Integer); {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure Clear; {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure Append(t: TPascalString); overload;
procedure Append(c: SystemChar); overload;
function GetString(bPos, ePos: Integer): TPascalString; {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure Insert(AText: SystemString; idx: Integer); {$IFDEF INLINE_ASM} inline; {$ENDIF}
procedure AsText(var Output: SystemString);
procedure FastGetBytes(var Output: TBytes); {$IFDEF INLINE_ASM} inline; {$ENDIF}
property Text: SystemString read GetText write SetText;
function LowerText: SystemString;
function UpperText: SystemString;
property Len: Integer read GetLen write SetLen;
property Items[index: Integer]: SystemChar read GetItems write SetItems; default;
property Bytes: TBytes read GetBytes write SetBytes;
function BOMBytes: TBytes;
end;
TOrdChar = (c0to9, c1to9, c0to32, c0to32no10, cLoAtoF, cHiAtoF, cLoAtoZ, cHiAtoZ, cHex, cAtoF, cAtoZ);
TOrdChars = set of TOrdChar;
function CharIn(c: SystemChar; const SomeChars: array of SystemChar): Boolean; overload;
function CharIn(c: SystemChar; const SomeChar: SystemChar): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const s: TPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const p: PPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const SomeCharset: TOrdChar): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars; const SomeChars: TPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars; const p: PPascalString): Boolean; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function BytesOfPascalString(var s: TPascalString): TBytes; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function PascalStringOfBytes(var s: TBytes): TPascalString; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHashSystemString(s: PSystemString): THash; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHash64SystemString(s: PSystemString): THash64; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHashSystemString(s: SystemString): THash; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHash64SystemString(s: SystemString): THash64; overload; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHashPascalString(s: PPascalString): THash; {$IFDEF INLINE_ASM} inline; {$ENDIF}
function FastHash64PascalString(s: PPascalString): THash64; {$IFDEF INLINE_ASM} inline; {$ENDIF}
{$IFDEF FPC}
operator := (const s: Variant)r: TPascalString;
operator := (const s: AnsiString)r: TPascalString;
operator := (const s: Unicodestring)r: TPascalString;
operator := (const s: WideString)r: TPascalString;
operator := (const s: ShortString)r: TPascalString;
operator := (const c: SystemChar)r: TPascalString;
operator := (const s: TPascalString)r: AnsiString;
operator := (const s: TPascalString)r: Unicodestring;
operator := (const s: TPascalString)r: WideString;
operator := (const s: TPascalString)r: ShortString;
operator := (const s: TPascalString)r: Variant;
operator = (const A: TPascalString; const B: TPascalString): Boolean;
operator <> (const A: TPascalString; const B: TPascalString): Boolean;
operator > (const A: TPascalString; const B: TPascalString): Boolean;
operator >= (const A: TPascalString; const B: TPascalString): Boolean;
operator < (const A: TPascalString; const B: TPascalString): Boolean;
operator <= (const A: TPascalString; const B: TPascalString): Boolean;
operator + (const A: TPascalString; const B: TPascalString): TPascalString;
operator + (const A: TPascalString; const B: SystemString): TPascalString;
operator + (const A: SystemString; const B: TPascalString): TPascalString;
operator + (const A: TPascalString; const B: SystemChar): TPascalString;
operator + (const A: SystemChar; const B: TPascalString): TPascalString;
{$ENDIF}
implementation
uses CoreClasses, Variants;
const
{$IFDEF FirstCharInZero}
FirstCharPos = 0;
{$ELSE}
FirstCharPos = 1;
{$ENDIF}
SystemCharSize = SizeOf(SystemChar);
procedure CombineCharsPP(const c1, c2: TPascalChars; var Output: TPascalChars); {$IFDEF INLINE_ASM} inline; {$ENDIF}
var
ll, rl: Integer;
begin
ll := Length(c1);
rl := Length(c2);
SetLength(Output, ll + rl);
if ll > 0 then
CopyPtr(@c1[0], @Output[0], ll * SystemCharSize);
if rl > 0 then
CopyPtr(@c2[0], @Output[ll], rl * SystemCharSize);
end;
procedure CombineCharsSP(c1: SystemString; c2: TPascalChars; var Output: TPascalChars); {$IFDEF INLINE_ASM} inline; {$ENDIF}
var
ll, rl: Integer;
begin
ll := Length(c1);
rl := Length(c2);
SetLength(Output, ll + rl);
if ll > 0 then
CopyPtr(@c1[FirstCharPos], @Output[0], ll * SystemCharSize);
if rl > 0 then
CopyPtr(@c2[0], @Output[ll], rl * SystemCharSize);
end;
procedure CombineCharsPS(c1: TPascalChars; c2: SystemString; var Output: TPascalChars); {$IFDEF INLINE_ASM} inline; {$ENDIF}
var
ll, rl: Integer;
begin
ll := Length(c1);
rl := Length(c2);
SetLength(Output, ll + rl);
if ll > 0 then
CopyPtr(@c1[0], @Output[0], ll * SystemCharSize);
if rl > 0 then
CopyPtr(@c2[FirstCharPos], @Output[ll], rl * SystemCharSize);
end;
procedure CombineCharsCP(const c1: SystemChar; c2: TPascalChars; var Output: TPascalChars); {$IFDEF INLINE_ASM} inline; {$ENDIF}
var
rl: Integer;
begin
rl := Length(c2);
SetLength(Output, rl + 1);
Output[0] := c1;
if rl > 0 then
CopyPtr(@c2[0], @Output[1], rl * SystemCharSize);
end;
procedure CombineCharsPC(const c1: TPascalChars; c2: SystemChar; var Output: TPascalChars); {$IFDEF INLINE_ASM} inline; {$ENDIF}
var
ll: Integer;
begin
ll := Length(c1);
SetLength(Output, ll + 1);
if ll > 0 then
CopyPtr(@c1[0], @Output[0], ll * SystemCharSize);
Output[ll] := c2;
end;
function CharIn(c: SystemChar; const SomeChars: array of SystemChar): Boolean;
var
AChar: SystemChar;
begin
Result := True;
for AChar in SomeChars do
if AChar = c then
Exit;
Result := False;
end;
function CharIn(c: SystemChar; const SomeChar: SystemChar): Boolean;
begin
Result := c = SomeChar;
end;
function CharIn(c: SystemChar; const s: TPascalString): Boolean;
begin
Result := s.Exists(c);
end;
function CharIn(c: SystemChar; const p: PPascalString): Boolean;
begin
Result := p^.Exists(c);
end;
function CharIn(c: SystemChar; const SomeCharset: TOrdChar): Boolean;
const
ord0 = ord('0');
ord1 = ord('1');
ord9 = ord('9');
ordLA = ord('a');
ordHA = ord('A');
ordLF = ord('f');
ordHF = ord('F');
ordLZ = ord('z');
ordHZ = ord('Z');
var
v: NativeInt;
begin
v := ord(c);
case SomeCharset of
c0to9: Result := (v >= ord0) and (v <= ord9);
c1to9: Result := (v >= ord1) and (v <= ord9);
c0to32: Result := ((v >= 0) and (v <= 32));
c0to32no10: Result := ((v >= 0) and (v <= 32) and (v <> 10));
cLoAtoF: Result := (v >= ordLA) and (v <= ordLF);
cHiAtoF: Result := (v >= ordHA) and (v <= ordHF);
cLoAtoZ: Result := (v >= ordLA) and (v <= ordLZ);
cHiAtoZ: Result := (v >= ordHA) and (v <= ordHZ);
cHex: Result := ((v >= ordLA) and (v <= ordLF)) or ((v >= ordHA) and (v <= ordHF)) or ((v >= ord0) and (v <= ord9));
cAtoF: Result := ((v >= ordLA) and (v <= ordLF)) or ((v >= ordHA) and (v <= ordHF));
cAtoZ: Result := ((v >= ordLA) and (v <= ordLZ)) or ((v >= ordHA) and (v <= ordHZ));
else Result := False;
end;
end;
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars): Boolean;
var
i: TOrdChar;
begin
Result := True;
for i in SomeCharsets do
if CharIn(c, i) then
Exit;
Result := False;
end;
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars; const SomeChars: TPascalString): Boolean;
begin
if CharIn(c, SomeCharsets) then
Result := True
else
Result := CharIn(c, SomeChars);
end;
function CharIn(c: SystemChar; const SomeCharsets: TOrdChars; const p: PPascalString): Boolean;
begin
if CharIn(c, SomeCharsets) then
Result := True
else
Result := CharIn(c, p);
end;
function BytesOfPascalString(var s: TPascalString): TBytes;
begin
Result := s.Bytes;
end;
function PascalStringOfBytes(var s: TBytes): TPascalString;
begin
Result.Bytes := s;
end;
function FastHashSystemString(s: PSystemString): THash;
const
A = ord('A');
Z = ord('Z');
var
i: Integer;
c: Cardinal;
begin
Result := 0;
{$IFDEF FirstCharInZero}
for i := 0 to Length(s^) - 1 do
{$ELSE}
for i := 1 to Length(s^) do
{$ENDIF}
begin
c := ord(s^[i]);
if (c >= A) and (c <= Z) then
c := c + $20;
Result := ((Result shl 7) or (Result shr 25)) + c;
end;
end;
function FastHash64SystemString(s: PSystemString): THash64;
const
A = ord('A');
Z = ord('Z');
var
i: Integer;
c: Cardinal;
begin
Result := 0;
{$IFDEF FirstCharInZero}
for i := 0 to Length(s^) - 1 do
{$ELSE}
for i := 1 to Length(s^) do
{$ENDIF}
begin
c := ord(s^[i]);
if (c >= A) and (c <= Z) then
c := c + $20;
Result := ((Result shl 7) or (Result shr 57)) + c;
end;
end;
function FastHashSystemString(s: SystemString): THash;
begin
Result := FastHashSystemString(@s);
end;
function FastHash64SystemString(s: SystemString): THash64;
begin
Result := FastHash64SystemString(@s);
end;
function FastHashPascalString(s: PPascalString): THash;
const
A = ord('A');
Z = ord('Z');
var
i: Integer;
c: Cardinal;
begin
Result := 0;
for i := 1 to s^.Len do
begin
c := ord(s^[i]);
if (c >= A) and (c <= Z) then
c := c + $20;
Result := ((Result shl 7) or (Result shr 25)) + c;
end;
end;
function FastHash64PascalString(s: PPascalString): THash64;
const
A = ord('A');
Z = ord('Z');
var
i: Integer;
c: Cardinal;
begin
Result := 0;
for i := 1 to s^.Len do
begin
c := ord(s^[i]);
if (c >= A) and (c <= Z) then
c := c + $20;
Result := ((Result shl 7) or (Result shr 57)) + c;
end;
end;
{$IFDEF FPC}
operator := (const s: Variant)r: TPascalString;
begin
r.Text := s;
end;
operator := (const s: AnsiString)r: TPascalString;
begin
r.Text := s;
end;
operator := (const s: Unicodestring)r: TPascalString;
begin
r.Text := s;
end;
operator := (const s: WideString)r: TPascalString;
begin
r.Text := s;
end;
operator := (const s: ShortString)r: TPascalString;
begin
r.Text := s;
end;
operator := (const c: SystemChar)r: TPascalString;
begin
r.Text := c;
end;
operator := (const s: TPascalString)r: AnsiString;
begin
r := s.Text;
end;
operator := (const s: TPascalString)r: Unicodestring;
begin
r := s.Text;
end;
operator := (const s: TPascalString)r: WideString;
begin
r := s.Text;
end;
operator := (const s: TPascalString)r: ShortString;
begin
r := s.Text;
end;
operator := (const s: TPascalString)r: Variant;
begin
r := s.Text;
end;
operator = (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text = B.Text;
end;
operator <> (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text <> B.Text;
end;
operator > (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text > B.Text;
end;
operator >= (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text >= B.Text;
end;
operator < (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text < B.Text;
end;
operator <= (const A: TPascalString; const B: TPascalString): Boolean;
begin
Result := A.Text <= B.Text;
end;
operator + (const A: TPascalString; const B: TPascalString): TPascalString;
begin
CombineCharsPP(A.Buff, B.Buff, Result.Buff);
end;
operator + (const A: TPascalString; const B: SystemString): TPascalString;
begin
CombineCharsPS(A.Buff, B, Result.Buff);
end;
operator + (const A: SystemString; const B: TPascalString): TPascalString;
begin
CombineCharsSP(A, B.Buff, Result.Buff);
end;
operator + (const A: TPascalString; const B: SystemChar): TPascalString;
begin
CombineCharsPC(A.Buff, B, Result.Buff);
end;
operator + (const A: SystemChar; const B: TPascalString): TPascalString;
begin
CombineCharsCP(A, B.Buff, Result.Buff);
end;
{$ENDIF}
function TPascalString.GetText: SystemString;
begin
SetLength(Result, Length(Buff));
CopyPtr(@Buff[0], @Result[FirstCharPos], Length(Buff) * SystemCharSize);
end;
procedure TPascalString.SetText(const Value: SystemString);
var
i: Integer;
begin
SetLength(Buff, Length(Value));
CopyPtr(@Value[FirstCharPos], @Buff[0], Length(Buff) * SystemCharSize);
end;
function TPascalString.GetLen: Integer;
begin
Result := Length(Buff);
end;
procedure TPascalString.SetLen(const Value: Integer);
begin
SetLength(Buff, Value);
end;
function TPascalString.GetItems(index: Integer): SystemChar;
begin
Result := Buff[index - 1];
end;
procedure TPascalString.SetItems(index: Integer; const Value: SystemChar);
begin
Buff[index - 1] := Value;
end;
procedure TPascalString.SetBytes(const Value: TBytes);
var
i: Integer;
begin
SetLength(Buff, 0);
try
Text := StringOf(SysUtils.TEncoding.Convert(SysUtils.TEncoding.UTF8, SysUtils.TEncoding.Default, Value));
except
SetLength(Buff, 0);
end;
end;
function TPascalString.GetBytes: TBytes;
begin
{$IFDEF FPC}
Result := SysUtils.TEncoding.UTF8.GetBytes(Text);
{$ELSE}
Result := SysUtils.TEncoding.UTF8.GetBytes(Buff);
{$ENDIF}
end;
function TPascalString.GetLast: SystemChar;
begin
Result := Buff[high(Buff)];
end;
procedure TPascalString.SetLast(const Value: SystemChar);
begin
Buff[high(Buff)] := Value;
end;
function TPascalString.GetFirst: SystemChar;
begin
Result := Buff[0];
end;
procedure TPascalString.SetFirst(const Value: SystemChar);
begin
Buff[0] := Value;
end;
{$IFDEF DELPHI}
class operator TPascalString.Equal(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := (Lhs.Len = Rhs.Len) and (Lhs.Text = Rhs.Text);
end;
class operator TPascalString.NotEqual(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := not(Lhs = Rhs);
end;
class operator TPascalString.GreaterThan(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := Lhs.Text > Rhs.Text;
end;
class operator TPascalString.GreaterThanOrEqual(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := Lhs.Text >= Rhs.Text;
end;
class operator TPascalString.LessThan(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := Lhs.Text < Rhs.Text;
end;
class operator TPascalString.LessThanOrEqual(const Lhs, Rhs: TPascalString): Boolean;
begin
Result := Lhs.Text <= Rhs.Text;
end;
class operator TPascalString.Add(const Lhs, Rhs: TPascalString): TPascalString;
begin
CombineCharsPP(Lhs.Buff, Rhs.Buff, Result.Buff);
end;
class operator TPascalString.Add(const Lhs: SystemString; const Rhs: TPascalString): TPascalString;
begin
CombineCharsSP(Lhs, Rhs.Buff, Result.Buff);
end;
class operator TPascalString.Add(const Lhs: TPascalString; const Rhs: SystemString): TPascalString;
begin
CombineCharsPS(Lhs.Buff, Rhs, Result.Buff);
end;
class operator TPascalString.Add(const Lhs: SystemChar; const Rhs: TPascalString): TPascalString;
begin
CombineCharsCP(Lhs, Rhs.Buff, Result.Buff);
end;
class operator TPascalString.Add(const Lhs: TPascalString; const Rhs: SystemChar): TPascalString;
begin
CombineCharsPC(Lhs.Buff, Rhs, Result.Buff);
end;
class operator TPascalString.Implicit(Value: Variant): TPascalString;
begin
Result.Text := VarToStr(Value);
end;
class operator TPascalString.Implicit(Value: SystemString): TPascalString;
begin
Result.Text := Value;
end;
class operator TPascalString.Implicit(Value: SystemChar): TPascalString;
begin
Result.Len := 1;
Result.Buff[0] := Value;
end;
class operator TPascalString.Implicit(Value: TPascalString): SystemString;
begin
Result := Value.Text;
end;
class operator TPascalString.Implicit(Value: TPascalString): Variant;
begin
Result := Value.Text;
end;
class operator TPascalString.Explicit(Value: TPascalString): SystemString;
begin
Result := Value.Text;
end;
class operator TPascalString.Explicit(Value: TPascalString): Variant;
begin
Result := Value.Text;
end;
class operator TPascalString.Explicit(Value: SystemString): TPascalString;
begin
Result.Text := Value;
end;
class operator TPascalString.Explicit(Value: Variant): TPascalString;
begin
Result.Text := VarToStr(Value);
end;
class operator TPascalString.Explicit(Value: SystemChar): TPascalString;
begin
Result.Len := 1;
Result.Buff[0] := Value;
end;
{$ENDIF}
function TPascalString.copy(index, count: Integer): TPascalString;
begin
Result.Buff := System.copy(Buff, index - 1, count);
end;
function TPascalString.Same(const t: TPascalString): Boolean;
var
i : Integer;
s, d: SystemChar;
begin
Result := (t.Len = Len);
if not Result then
Exit;
for i := 0 to Len - 1 do
begin
s := Buff[i];
if (s >= 'A') and (s <= 'Z') then
s := SystemChar(ord(s) + $20);
d := t.Buff[i];
if (d >= 'A') and (d <= 'Z') then
d := SystemChar(ord(d) + $20);
if s <> d then
Exit(False);
end;
end;
function TPascalString.Same(const IgnoreCase: Boolean; const t: TPascalString): Boolean;
var
i : Integer;
s, d: SystemChar;
begin
Result := (t.Len = Len);
if not Result then
Exit;
for i := 0 to Len - 1 do
begin
s := Buff[i];
if IgnoreCase then
if (s >= 'A') and (s <= 'Z') then
s := SystemChar(ord(s) + $20);
d := t.Buff[i];
if IgnoreCase then
if (d >= 'A') and (d <= 'Z') then
d := SystemChar(ord(d) + $20);
if s <> d then
Exit(False);
end;
end;
function TPascalString.ComparePos(Offset: Integer; const t: PPascalString): Boolean;
var
i, l : Integer;
sourChar, destChar: SystemChar;
begin
Result := False;
i := 1;
l := t^.Len;
if (Offset + l - 1) > Len then
Exit;
while i <= l do
begin
sourChar := Items[Offset + i - 1];
destChar := t^[i];
if CharIn(sourChar, cLoAtoZ) then
dec(sourChar, 32);
if CharIn(destChar, cLoAtoZ) then
dec(destChar, 32);
if sourChar <> destChar then
Exit;
inc(i);
end;
Result := True;
end;
function TPascalString.ComparePos(Offset: Integer; const t: TPascalString): Boolean;
var
i, l : Integer;
sourChar, destChar: SystemChar;
begin
Result := False;
i := 1;
l := t.Len;
if (Offset + l) > Len then
Exit;
while i <= l do
begin
sourChar := Items[Offset + i - 1];
destChar := t[i];
if CharIn(sourChar, cLoAtoZ) then
dec(sourChar, 32);
if CharIn(destChar, cLoAtoZ) then
dec(destChar, 32);
if sourChar <> destChar then
Exit;
inc(i);
end;
Result := True;
end;
function TPascalString.GetPos(const SubStr: TPascalString; const Offset: Integer = 1): Integer;
var
i: Integer;
begin
Result := 0;
if SubStr.Len > 0 then
for i := Offset to Len - SubStr.Len + 1 do
if ComparePos(i, @SubStr) then
Exit(i);
end;
function TPascalString.Exists(c: SystemChar): Boolean;
var
i: Integer;
begin
for i := low(Buff) to high(Buff) do
if Buff[i] = c then
Exit(True);
Result := False;
end;
function TPascalString.Exists(c: array of SystemChar): Boolean;
var
i: Integer;
begin
for i := low(Buff) to high(Buff) do
if CharIn(Buff[i], c) then
Exit(True);
Result := False;
end;
procedure TPascalString.DeleteLast;
begin
if Len > 0 then
Buff := System.copy(Buff, 0, Len - 1);
end;
procedure TPascalString.DeleteFirst;
begin
if Len > 0 then
Buff := System.copy(Buff, 1, Len);
end;
procedure TPascalString.Delete(idx, cnt: Integer);
begin
if (idx + cnt <= Len) then
Text := GetString(1, idx) + GetString(idx + cnt, Len)
else
Text := GetString(1, idx);
end;
procedure TPascalString.Clear;
begin
SetLength(Buff, 0);
end;
procedure TPascalString.Append(t: TPascalString);
var
r, l: Integer;
begin
l := Length(t.Buff);
if l > 0 then
begin
r := Length(Buff);
SetLength(Buff, r + l);
CopyPtr(@t.Buff[0], @Buff[r], l * SystemCharSize);
end;
end;
procedure TPascalString.Append(c: SystemChar);
begin
SetLength(Buff, Length(Buff) + 1);
Buff[Length(Buff) - 1] := c;
end;
function TPascalString.GetString(bPos, ePos: Integer): TPascalString;
begin
Result.Text := Self.copy(bPos, ePos - bPos);
end;
procedure TPascalString.Insert(AText: SystemString; idx: Integer);
begin
Text := GetString(1, idx) + AText + GetString(idx + 1, Len);
end;
procedure TPascalString.AsText(var Output: SystemString);
begin
SetLength(Output, Length(Buff));
CopyPtr(@Buff[0], @Output[FirstCharPos], Length(Buff) * SystemCharSize);
end;
procedure TPascalString.FastGetBytes(var Output: TBytes);
begin
{$IFDEF FPC}
Output := SysUtils.TEncoding.UTF8.GetBytes(Text);
{$ELSE}
Output := SysUtils.TEncoding.UTF8.GetBytes(Buff);
{$ENDIF}
end;
function TPascalString.LowerText: SystemString;
begin
Result := LowerCase(Text);
end;
function TPascalString.UpperText: SystemString;
begin
Result := UpperCase(Text);
end;
function TPascalString.BOMBytes: TBytes;
begin
{$IFDEF FPC}
Result := GetBytes;
{$ELSE}
Result := SysUtils.TEncoding.UTF8.GetPreamble + GetBytes;
{$ENDIF}
end;
initialization
finalization
end.
|
{
Clever Internet Suite
Copyright (C) 2014 Clever Components
All Rights Reserved
www.CleverComponents.com
}
unit clProgressBarDC;
interface
{$I clVer.inc}
uses
{$IFNDEF DELPHIXE2}
Classes, SysUtils,
{$ELSE}
System.Classes, System.SysUtils,
{$ENDIF}
clProgressBar, clMultiDC, clResourceState;
type
TclProgressBarDC = class;
TclProgressBarDCNotifier = class(TclControlNotifier)
private
FProgressBar: TclProgressBarDC;
FLastItem: TclInternetItem;
function GetLastState(): TclResourceStateList;
protected
procedure DoResourceStateChanged(Item: TclInternetItem); override;
procedure DoItemDeleted(Item: TclInternetItem); override;
public
constructor Create(AControl: TclCustomInternetControl; AProgressBar: TclProgressBarDC);
end;
TclProgressBarDC = class(TclProgressBar)
private
FInternetControl: TclCustomInternetControl;
FNotifier: TclProgressBarDCNotifier;
procedure SetInternetControl(const Value: TclCustomInternetControl);
procedure ClearNotifier();
protected
function GetResourceState: TclResourceStateList; override;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
destructor Destroy; override;
published
property InternetControl: TclCustomInternetControl read FInternetControl write SetInternetControl;
end;
implementation
{ TclProgressBarDC }
destructor TclProgressBarDC.Destroy();
begin
ClearNotifier();
inherited Destroy();
end;
function TclProgressBarDC.GetResourceState: TclResourceStateList;
begin
if (FNotifier <> nil) then
begin
Result := FNotifier.GetLastState();
end else
begin
Result := inherited GetResourceState();
end;
end;
procedure TclProgressBarDC.Notification(AComponent: TComponent; Operation: TOperation);
begin
if (AComponent = FInternetControl) and (Operation = opRemove) then
begin
SetInternetControl(nil);
end;
inherited Notification(AComponent, Operation);
end;
procedure TclProgressBarDC.ClearNotifier();
begin
FreeAndNil(FNotifier);
end;
procedure TclProgressBarDC.SetInternetControl(const Value: TclCustomInternetControl);
begin
if (FInternetControl <> Value) then
begin
FInternetControl := Value;
ClearNotifier();
if (FInternetControl <> nil) then
begin
FInternetControl.FreeNotification(Self);
FNotifier := TclProgressBarDCNotifier.Create(FInternetControl, Self);
end;
end;
end;
{ TclProgressBarDCNotifier }
constructor TclProgressBarDCNotifier.Create(AControl: TclCustomInternetControl; AProgressBar: TclProgressBarDC);
begin
inherited Create(AControl);
FProgressBar := AProgressBar;
Assert(FProgressBar <> nil);
end;
procedure TclProgressBarDCNotifier.DoItemDeleted(Item: TclInternetItem);
begin
if (FLastItem = Item) then
begin
FLastItem := nil;
end;
inherited DoItemDeleted(Item);
end;
procedure TclProgressBarDCNotifier.DoResourceStateChanged(Item: TclInternetItem);
begin
FLastItem := Item;
FProgressBar.NotifyChanged();
end;
function TclProgressBarDCNotifier.GetLastState(): TclResourceStateList;
begin
Result := nil;
if (FLastItem <> nil) then
begin
Result := FLastItem.ResourceState;
end;
end;
end.
|
unit ValidationRuleIntf;
interface
type
TValidateFunction = reference to function: Boolean;
IValidationRule = interface(IInterface)
['{5E44704E-3C00-4E22-A7BA-3579C1094EB2}']
function GetValidateFunction: TValidateFunction;
procedure SetValidateFunction(const Value: TValidateFunction);
function Valid: boolean;
property ValidateFunction: TValidateFunction read GetValidateFunction write SetValidateFunction;
end;
implementation
end.
|
unit MainWindow;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
DDraw, Menus, ExtDlgs, StdCtrls;
type
TMainForm =
class(TForm)
Log: TMemo;
procedure FormShow(Sender: TObject);
private
{ Private declarations }
fDirectDraw : IDirectDraw4;
fPrimarySurface : IDirectDrawSurface4;
fOverlay : IDirectDrawSurface4;
//fBackBuffer : IDirectDrawSurface4;
//fClipper : IDirectDrawClipper;
//fOverlayVisible : boolean;
//fBitmap : TBitmap;
//fBitmapSurface : IDirectDrawSurface4;
public
{ Public declarations }
end;
var
MainForm: TMainForm;
implementation
{$R *.DFM}
uses
ComObj, LogFile;
function CopyBitmapToSurface(Bitmap : TBitmap; const Surface : IDirectDrawSurface4; x, y : integer) : boolean;
var
dc : HDC;
memdc : HDC;
begin
Result := false;
if Surface.GetDC(dc) = DD_OK
then
try
memdc := CreateCompatibleDC(dc);
if memdc <> 0
then
try
SelectObject(memdc, Bitmap.Handle);
if not BitBlt(dc, x, y, Bitmap.Width, Bitmap.Height, memdc, 0, 0, SRCCOPY)
then LogThis('BitBlt FAILED')
else Result := true;
finally
DeleteDC(memdc);
end
else LogThis('CreateCompatibleDC FAILED');
finally
Surface.ReleaseDC(dc);
end
else LogThis('GetDC FAILED');
end;
const
cMaxPixelFormats = 6;
const
cPixelFormats : array [0..pred(cMaxPixelFormats)] of TDDPixelFormat =
(
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 16; dwRBitMask : $7C00; dwGBitMask : $03e0; dwBBitMask : $001F; dwRGBAlphaBitMask : 0), // 16-bit RGB 5:5:5
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 16; dwRBitMask : $F800; dwGBitMask : $07e0; dwBBitMask : $001F; dwRGBAlphaBitMask : 0), // 16-bit RGB 5:6:5
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 24; dwRBitMask : $FF0000; dwGBitMask : $00FF00; dwBBitMask : $0000FF; dwRGBAlphaBitMask : 0), // 24-bit RGB 8:8:8
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 24; dwRBitMask : $0000FF; dwGBitMask : $00FF00; dwBBitMask : $FF0000; dwRGBAlphaBitMask : 0), // 24-bit BGR 8:8:8
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 32; dwRBitMask : $FF0000; dwGBitMask : $00FF00; dwBBitMask : $0000FF; dwRGBAlphaBitMask : 0), // 32-bit RGB 8:8:8
(dwSize : sizeof(TDDPixelFormat); dwFlags : DDPF_RGB; dwFourCC : 0; dwRGBBitCount : 32; dwRBitMask : $0000FF; dwGBitMask : $00FF00; dwBBitMask : $FF0000; dwRGBAlphaBitMask : 0) // 32-bit BGR 8:8:8
);
const
cPixelFormatNames : array [0..pred(cMaxPixelFormats)] of string =
(
'16-bit RGB 5:5:5',
'16-bit RGB 5:6:5',
'24-bit RGB 8:8:8',
'24-bit BGR 8:8:8',
'32-bit RGB 8:8:8',
'32-bit BGR 8:8:8'
);
function CreateFlippingOverlay(const DirectDraw : IDirectDraw4; Control : TWinControl; out BackBuffer : IDirectDrawSurface4; pixformat : integer) : IDirectDrawSurface4;
var
hRet : HRESULT;
ddsd : TDDSurfaceDesc2;
ddscaps : TDDSCaps2;
devcaps : TDDCaps;
HELcaps : TDDCaps;
begin
if DirectDraw <> nil
then
if (DirectDraw.GetCaps(@devcaps, @HELCaps) = DD_OK) and ((devcaps.dwCaps and DDCAPS_OVERLAY) <> 0)
then
begin
fillchar(ddsd, sizeof(ddsd), 0);
ddsd.dwSize := sizeof(ddsd);
ddsd.dwFlags := DDSD_CAPS or DDSD_HEIGHT or DDSD_WIDTH or DDSD_BACKBUFFERCOUNT or DDSD_PIXELFORMAT;
ddsd.ddsCaps.dwCaps := DDSCAPS_OVERLAY or DDSCAPS_FLIP or DDSCAPS_COMPLEX or DDSCAPS_VIDEOMEMORY;
ddsd.dwWidth := Control.ClientWidth;
ddsd.dwHeight := Control.ClientHeight;
ddsd.dwBackBufferCount := 2;
ddsd.ddpfPixelFormat := cPixelFormats[pixformat];
hRet := DirectDraw.CreateSurface(ddsd, Result, nil);
if hRet <> DD_OK
then Result := nil;
if Result <> nil
then
begin
ddscaps.dwCaps := DDSCAPS_BACKBUFFER;
hRet := Result.GetAttachedSurface(ddscaps, BackBuffer);
if hRet <> DD_OK
then
begin
LogThis('GetAttachedSurface FAILED');
Result := nil;
BackBuffer := nil;
end;
end;
end
else Result := nil
else Result := nil;
end;
function CreateOverlay(const DirectDraw : IDirectDraw4; Control : TWinControl; pixformat : integer) : IDirectDrawSurface4;
var
hRet : HRESULT;
ddsd : TDDSurfaceDesc2;
devcaps : TDDCaps;
HELcaps : TDDCaps;
begin
if DirectDraw <> nil
then
begin
fillchar(devcaps, sizeof(devcaps), 0);
devcaps.dwSize := sizeof(devcaps);
fillchar(HELCaps, sizeof(HELCaps), 0);
HELCaps.dwSize := sizeof(HELCaps);
if DirectDraw.GetCaps(@devcaps, @HELCaps) = DD_OK
then
if devcaps.dwCaps and DDCAPS_OVERLAY <> 0
then
begin
fillchar(ddsd, sizeof(ddsd), 0);
ddsd.dwSize := sizeof(ddsd);
ddsd.dwFlags := DDSD_CAPS or DDSD_HEIGHT or DDSD_WIDTH or DDSD_PIXELFORMAT;
ddsd.ddsCaps.dwCaps := DDSCAPS_OVERLAY or DDSCAPS_VIDEOMEMORY;
ddsd.dwWidth := Control.ClientWidth;
ddsd.dwHeight := Control.ClientHeight;
ddsd.ddpfPixelFormat := cPixelFormats[pixformat];
hRet := DirectDraw.CreateSurface(ddsd, Result, nil);
if hRet <> DD_OK
then Result := nil;
end
else Result := nil
else Result := nil;
end
else Result := nil;
end;
function HideOverlay(const PrimarySurface, Overlay : IDirectDrawSurface4) : boolean;
begin
Result := Overlay.UpdateOverlay(nil, PrimarySurface, nil, DDOVER_HIDE, nil) = DD_OK;
end;
function ShowOverlay(Control : TWinControl; const Overlay, Primary : IDirectDrawSurface4) : boolean;
var
SrcRect : TRect;
DestRect : TRect;
ScPt : TPoint;
begin
SrcRect := Rect(0, 0, pred(Control.ClientWidth), pred(Control.ClientHeight));
DestRect := SrcRect;
ScPt := Control.ClientToScreen(Point(0, 0));
OffsetRect(DestRect, ScPt.x, ScPt.y);
// fix rects to account for strecth factors as well as size and alignment restrictions
if Overlay.UpdateOverlay(@SrcRect, Primary, @DestRect, DDOVER_SHOW, nil) <> DD_OK
then
begin
LogThis('UpdateOverlay FAILED');
Result := false;
end
else Result := true;
end;
function ResizeOverlay(const DirectDraw : IDirectDraw4; Control : TWinControl; const PrimarySurface : IDirectDrawSurface4; var Overlay : IDirectDrawSurface4) : boolean;
begin
//HideOverlay(PrimarySurface, Overlay);
ShowOverlay(Control, Overlay, PrimarySurface);
Result := Overlay <> nil;
end;
function MoveOverlay(Control : TWinControl; const Overlay : IDirectDrawSurface4) : boolean;
var
ScPt : TPoint;
begin
ScPt := Control.ClientToScreen(Point(0, 0));
// adjust position accounting for destination alignment restrictions
Result := Overlay.SetOverlayPosition(ScPt.x, ScPt.y) = DD_OK;
end;
function CreateClipper(const DirectDraw : IDirectDraw4; Control : TWinControl) : IDirectDrawClipper;
var
hRet : HRESULT;
begin
if DirectDraw <> nil
then
begin
hRet := DirectDraw.CreateClipper(0, Result, nil);
if hRet <> DD_OK
then Result := nil;
end
else Result := nil;
end;
function FillSurface(const Surface : IDirectDrawSurface4; rgbColor : integer) : boolean;
var
DDBltFx : TDDBltFx;
begin
fillchar(DDBltFx, sizeof(DDBltFx), 0);
DDBltFx.dwSize := sizeof(DDBltFx);
DDBltFx.dwFillColor := rgbColor;
Result := Surface.Blt(nil, nil, nil, DDBLT_COLORFILL, @DDBltFx) = DD_OK;
end;
procedure TMainForm.FormShow(Sender: TObject);
var
ddsd : TDDSurfaceDesc2;
//ddscaps : TDDSCAPS2;
hRet : HRESULT;
pDD : IDirectDraw;
i : integer;
begin
hRet := DirectDrawCreate(nil, pDD, nil);
if hRet <> DD_OK
then LogThis('DirectDrawCreate FAILED')
else
begin
hRet := pDD.QueryInterface(IID_IDirectDraw4, fDirectDraw);
if hRet <> DD_OK
then LogThis('QueryInterface FAILED')
else
begin
hRet := fDirectDraw.SetCooperativeLevel(Handle, DDSCL_NORMAL);
if hRet <> DD_OK
then LogThis('SetCooperativeLevel FAILED')
else
begin
fillchar(ddsd, sizeof(ddsd), 0);
ddsd.dwSize := sizeof(ddsd);
ddsd.dwFlags := DDSD_CAPS;
ddsd.ddsCaps.dwCaps := DDSCAPS_PRIMARYSURFACE;
hRet := fDirectDraw.CreateSurface(ddsd, fPrimarySurface, nil);
if hRet <> DD_OK
then LogThis('CreateSurface FAILED');
end;
end;
end;
for i := 0 to pred(cMaxPixelFormats) do
begin
fOverlay := CreateOverlay(fDirectDraw, Self, i);
if fOverlay <> nil
then
begin
Log.Lines.Add(cPixelFormatNames[i] + ' overlay successfully created');
fOverlay := nil;
end
else Log.Lines.Add(cPixelFormatNames[i] + ' overlay could not be created');
end;
end;
initialization
SetLogFile(ExtractFileName(Application.ExeName) + '.log');
end.
|
{ Subroutine SST_SYM_DTYPE_NEW_OUT (NAME,RENAME,DTYPE,SIZE,DT_P,STAT)
*
* Create a new symbol that is a data type. The symbol will go into the output
* symbol table at the current scope.
*
* NAME is the raw symbol name. It may be altered to create a unique name if
* MAKE_UNIQUE is set to true. In either case, the current character case
* rule will be applied to it.
*
* RENAME - Rename stategy flag.
*
* DTYPE is the base data type for the new data type descriptor.
*
* SIZE is the storage size of the new data type. It will be initialized
* assuming natural alignment.
*
* DT_P will be returned pointing to the new data type descriptor. The
* descriptor will be initialized as far as possible.
*
* STAT is the returned completion status code. It will be set to the
* SST_STAT_SYM_PREV_DEF_K status if the symbol name was already in the symbol
* table at or above the current scope, and MAKE_UNIQUE was set to FALSE.
}
module sst_SYM_DTYPE_NEW_OUT;
define sst_sym_dtype_new_out;
%include 'sst2.ins.pas';
procedure sst_sym_dtype_new_out ( {create output symbol that is a data type}
in name: univ string_var_arg_t; {name of symbol to create}
in rename: sst_rename_k_t; {re-name strategy flag}
in dtype: sst_dtype_k_t; {which base data type it is}
in size: sys_int_adr_t; {data type size in machine addresses}
out dt_p: sst_dtype_p_t); {points to new data type descriptor}
var
namef: string_var80_t; {final name used after conversions}
name_p: string_var_p_t; {points to name stored in hash table}
pos: string_hash_pos_t; {hash table position handle}
sym_pp: sst_symbol_pp_t; {points to hash table user data area}
sym_p: sst_symbol_p_t; {points to symbol descriptor for this name}
begin
namef.len := sizeof(namef.str); {init local VAR string}
sst_w.name^ ( {get hash handle for new symbol name}
name.str, name.len, {raw input name}
sst_config.suffix_dtype.str, sst_config.suffix_dtype.len, {suffix name}
rename, {re-name strategy flag}
namef, {final resulting name}
pos); {hash table position handle where name goes}
string_hash_ent_add (pos, name_p, sym_pp); {add name to hash table}
sst_mem_alloc_scope (sizeof(sym_p^), sym_p); {alloc symbol descriptor}
sym_pp^ := sym_p; {point hash table entry to symbol descriptor}
sym_p^.name_in_p := nil; {partially initialize new symbol descriptor}
sym_p^.name_out_p := name_p;
sym_p^.next_p := nil;
sym_p^.char_h.crange_p := nil;
sym_p^.scope_p := sst_scope_p;
sym_p^.flags := [];
{
* The symbol has been added to the symbol table. SYM_P is pointing to the
* new symbol descriptor. The symbol descriptor has been partially initialized.
}
sym_p^.symtype := sst_symtype_dtype_k; {symbol is a data type}
sst_mem_alloc_scope (sizeof(dt_p^), dt_p); {allocate mem for new data type}
sym_p^.dtype_dtype_p := dt_p; {point symbol descriptor to data type desc}
dt_p^.symbol_p := sym_p; {init data type descriptor as far as possible}
dt_p^.dtype := dtype;
dt_p^.bits_min := sst_config.bits_adr * size;
dt_p^.align_nat := size;
dt_p^.align := size;
dt_p^.size_used := size;
dt_p^.size_align := size;
end;
|
unit k2ChildOperation;
{ Библиотека "K-2" }
{ Автор: Люлин А.В. © }
{ Модуль: k2ChildOperation - }
{ Начат: 18.10.2005 14:33 }
{ $Id: k2ChildOperation.pas,v 1.9 2014/03/25 11:53:36 lulin Exp $ }
// $Log: k2ChildOperation.pas,v $
// Revision 1.9 2014/03/25 11:53:36 lulin
// - переходим от интерфейсов к объектам.
//
// Revision 1.8 2014/03/21 12:39:25 lulin
// - перетряхиваем работу с тегами.
//
// Revision 1.7 2009/07/23 13:42:34 lulin
// - переносим процессор операций туда куда надо.
//
// Revision 1.6 2009/07/22 17:16:40 lulin
// - оптимизируем использование счётчика ссылок и преобразование к интерфейсам при установке атрибутов тегов.
//
// Revision 1.5 2009/07/17 13:47:23 lulin
// - bug fix: неправильно обрабатывали удаление дочерних тегов.
//
// Revision 1.4 2009/07/07 08:58:27 lulin
// - вычищаем ненужное.
//
// Revision 1.3 2009/07/06 13:32:12 lulin
// - возвращаемся от интерфейсов к объектам.
//
// Revision 1.2 2007/09/04 14:24:59 lulin
// - убран ненужный параметр.
//
// Revision 1.1 2005/10/18 10:48:29 lulin
// - реализация базовой Undo-записи удаления/добавления тегов, перенесена в правильное место.
//
{$Include k2Define.inc }
interface
uses
l3Types,
l3Variant,
k2Interfaces,
k2AtomOperation,
k2Op,
k2Base
;
type
Ok2AddChild = class(Tk2AtomOperation)
private
// internal fields
f_Child : Tl3Variant;
f_Index : Long;
protected
// internal methods
procedure DoUndo(const Container: Ik2Op);
override;
{-отменить операцию}
procedure DoRedo(const Container: Ik2Op);
override;
{-повторить операцию}
public
// public methods
class procedure ToUndo(const anOpPack : Ik2Op;
aList : Tl3Variant;
const aProp : Tk2Prop;
aChild : Tl3Variant;
anIndex : Long);
reintroduce;
{-}
function SetParam(List : Tl3Variant;
const Prop : Tk2Prop;
aChild : Tl3Variant;
Index : Long): Ok2AddChild;
reintroduce;
{-}
procedure Clear;
override;
{-}
function CanJoinWith(anOperation: Tk2Op): Bool;
override;
{-}
function DoJoin(anOperation: Tk2Op): Tk2Op;
override;
{-соединяет две операции и возвращает:
nil - соединение неудачно
Self - соединение удачно и все поместилось в старую запись
New - распределена новая операция }
function CanLinkTo(anOp: Ok2AddChild): Tk2Op;
virtual;
{-}
public
// public properties
property Index: Long
read f_Index;
{-}
property Child: Tl3Variant
read f_Child;
{-}
end;//Ok2AddChild
Ok2DeleteChild = class(Ok2AddChild)
protected
// internal methods
procedure DoUndo(const Container: Ik2Op);
override;
{-отменить операцию}
procedure DoRedo(const Container: Ik2Op);
override;
{-повторить операцию}
end;//Ok2DeleteChild
implementation
uses
SysUtils,
l3Base
;
// start class Ok2AddChild
class procedure Ok2AddChild.ToUndo(const anOpPack : Ik2Op;
aList : Tl3Variant;
const aProp : Tk2Prop;
aChild : Tl3Variant;
anIndex : Long);
{-}
var
l_Op : Tk2Op;
begin
if (anOpPack <> nil) then
begin
l_Op := Create.SetParam(aList, aProp, aChild, anIndex);
try
l_Op.Put(anOpPack);
finally
l3Free(l_Op);
end;//try..finally
end;//anOpPack <> nil
end;
function Ok2AddChild.SetParam(List : Tl3Variant;
const Prop : Tk2Prop;
aChild : Tl3Variant;
Index : Long): Ok2AddChild;
{-}
begin
inherited SetParam(List.AsObject, Prop);
aChild.SetRef(f_Child);
f_Index := Index;
Result := Self;
end;
function Ok2AddChild.CanJoinWith(anOperation: Tk2Op): Bool;
//override;
{-}
begin
Result := true;
end;
function Ok2AddChild.DoJoin(anOperation: Tk2Op): Tk2Op;
//override;
{-соединяет две операции и возвращает:
nil - соединение неудачно
Self - соединение удачно и все поместилось в старую запись
New - распределена новая операция }
begin
if (anOperation Is Ok2AddChild) then
Result := Ok2AddChild(anOperation).CanLinkTo(Self)
else
Result := nil;
end;
function Ok2AddChild.CanLinkTo(anOp: Ok2AddChild): Tk2Op;
//virtual;
{-}
begin
Result := nil;
end;
procedure Ok2AddChild.Clear;
{override;}
{-}
begin
FreeAndNil(f_Child);
inherited;
end;
procedure Ok2AddChild.DoUndo(const Container: Ik2Op);
{override;}
{-отменить операцию}
begin
if Child.IsValid then
Atom.DeleteChild(Child, Container)
else
Atom.DeleteChild(f_Index, Container);
//Tk2ArrayProperty(f_Prop).DeleteChild(Atom, f_Index, Child, Container);
end;
procedure Ok2AddChild.DoRedo(const Container: Ik2Op);
{override;}
{-повторить операцию}
var
l_Child : Tl3Variant;
begin
l_Child := Child;
f_Index := Atom.AddChild(l_Child, Container);
end;
// start class Ok2DeleteChild
procedure Ok2DeleteChild.DoUndo(const Container: Ik2Op);
{override;}
{-отменить операцию}
var
l_Child : Tl3Variant;
begin
l_Child := Child;
f_Index := Atom.AddChild(l_Child, Container);
end;
procedure Ok2DeleteChild.DoRedo(const Container: Ik2Op);
{override;}
{-повторить операцию}
begin
if Child.IsValid then
Atom.DeleteChild(Child, Container)
else
Atom.DeleteChild(f_Index, Container);
//Tk2ArrayProperty(f_Prop).DeleteChild(Atom, f_Index, Child, Container);
end;
end.
|
unit uModuloController;
interface
uses
System.SysUtils, uDMModulo, uRegras, uEnumerador, uDM, Data.DB, Vcl.Forms;
type
TModuloController = class
private
FModel: TDMModulo;
FOperacao: TOperacao;
public
procedure Filtrar(ACampo, ATexto, AAtivo: string; AContem: Boolean = False);
procedure FiltrarCliente(AIdCliente: Integer; ACampo, ATexto, AAtivo: string; AContem: Boolean = False);
procedure FiltrarCodigo(ACodigo: Integer);
procedure LocalizarId(AId: Integer);
procedure LocalizarCodigo(ACodigo: integer; AIdCliente: integer = 0);
procedure Novo(AIdUsuario: Integer);
procedure Editar(AId: Integer; AFormulario: TForm);
procedure Salvar(AIdUsuario: Integer);
procedure Excluir(AIdUsuario, AId: Integer);
procedure Cancelar();
procedure Imprimir(AIdUsuario: Integer);
function ProximoId(): Integer;
function ProximoCodigo(): Integer;
procedure Pesquisar(AId, ACodigo: Integer; AIdCliente: Integer = 0);
function CodigoAtual: Integer;
property Model: TDMModulo read FModel write FModel;
constructor Create();
destructor Destroy; override;
end;
implementation
{ TModuloController }
uses uFuncoesSIDomper;
procedure TModuloController.Cancelar;
begin
if FModel.CDSCadastro.State in [dsEdit, dsInsert] then
FModel.CDSCadastro.Cancel;
end;
function TModuloController.CodigoAtual: Integer;
begin
Result := FModel.CDSCadastroMod_Codigo.AsInteger;
end;
constructor TModuloController.Create;
begin
FModel := TDMModulo.Create(nil);
end;
destructor TModuloController.Destroy;
begin
FreeAndNil(FModel);
inherited;
end;
procedure TModuloController.Editar(AId: Integer; AFormulario: TForm);
var
Negocio: TServerMethods1Client;
Resultado: Boolean;
begin
if AId = 0 then
raise Exception.Create('Não há Registro para Editar!');
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSCadastro.Close;
Resultado := Negocio.Editar(CModuloPrograma, dm.IdUsuario, AId);
FModel.CDSCadastro.Open;
TFuncoes.HabilitarCampo(AFormulario, Resultado);
FOperacao := opEditar;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Excluir(AIdUsuario, AId: Integer);
var
Negocio: TServerMethods1Client;
begin
if AId = 0 then
raise Exception.Create('Não há Registro para Excluir!');
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
Negocio.Excluir(CModuloPrograma, AIdUsuario, AId);
FModel.CDSConsulta.Delete;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Filtrar(ACampo, ATexto, AAtivo: string;
AContem: Boolean);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSConsulta.Close;
Negocio.Filtrar(CModuloPrograma, ACampo, ATexto, AAtivo, AContem);
FModel.CDSConsulta.Open;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.FiltrarCliente(AIdCliente: Integer; ACampo, ATexto,
AAtivo: string; AContem: Boolean);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSConsulta.Close;
Negocio.FiltrarModuloCliente(AIdCliente, ACampo, ATexto, AAtivo, AContem);
FModel.CDSConsulta.Open;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.FiltrarCodigo(ACodigo: Integer);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSConsulta.Close;
Negocio.FiltrarCodigo(CModuloPrograma, ACodigo);
FModel.CDSConsulta.Open;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Imprimir(AIdUsuario: Integer);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(dm.Conexao.DBXConnection);
try
Negocio.Relatorio(CModuloPrograma, AIdUsuario);
FModel.Rel.Print;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.LocalizarCodigo(ACodigo: Integer; AIdCliente: integer = 0);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSCadastro.Close;
if AIdCliente = 0 then
Negocio.LocalizarCodigo(CModuloPrograma, ACodigo)
else
Negocio.LocalizarModuloClienteCodigo(AIdCliente, ACodigo);
FModel.CDSCadastro.Open;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.LocalizarId(AId: Integer);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSCadastro.Close;
Negocio.LocalizarId(CModuloPrograma, AId);
FModel.CDSCadastro.Open;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Novo(AIdUsuario: Integer);
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
FModel.CDSCadastro.Close;
Negocio.Novo(CModuloPrograma, AIdUsuario);
LocalizarId(0);
FModel.CDSCadastro.Open;
FModel.CDSCadastro.Append;
FModel.CDSCadastroMod_Codigo.AsInteger := ProximoCodigo();
FOperacao := opIncluir;
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Pesquisar(AId, ACodigo: Integer; AIdCliente: Integer = 0);
begin
if AId > 0 then
LocalizarId(AId)
else
LocalizarCodigo(ACodigo, AIdCliente);
end;
function TModuloController.ProximoCodigo: Integer;
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
Result := StrToInt(Negocio.ProximoCodigo(CModuloPrograma).ToString);
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
function TModuloController.ProximoId: Integer;
var
Negocio: TServerMethods1Client;
begin
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
Result := StrToInt(Negocio.ProximoId(CModuloPrograma).ToString);
dm.Desconectar;
finally
FreeAndNil(Negocio);
end;
end;
procedure TModuloController.Salvar(AIdUsuario: Integer);
var
Negocio: TServerMethods1Client;
begin
if FModel.CDSCadastroMod_Codigo.AsInteger <= 0 then
raise Exception.Create('Informe o Código!');
if Trim(FModel.CDSCadastroMod_Nome.AsString) = '' then
raise Exception.Create('Informe o Nome!');
DM.Conectar;
Negocio := TServerMethods1Client.Create(DM.Conexao.DBXConnection);
try
try
if FModel.CDSCadastro.State in [dsEdit, dsInsert] then
FModel.CDSCadastro.Post;
Negocio.Salvar(CModuloPrograma, AIdUsuario);
FModel.CDSCadastro.ApplyUpdates(0);
FOperacao := opNavegar;
dm.Desconectar;
except
on E: Exception do
begin
dm.ErroConexao(E.Message);
end;
end;
finally
FreeAndNil(Negocio);
end;
end;
end.
|
unit DW.OSLog;
{*******************************************************}
{ }
{ Kastri }
{ }
{ Delphi Worlds Cross-Platform Library }
{ }
{ Copyright 2020-2021 Dave Nottage under MIT license }
{ which is located in the root folder of this library }
{ }
{*******************************************************}
{$I DW.GlobalDefines.inc}
interface
type
TLogType = (Debug, Warning, Error);
IOSLogListener = interface(IInterface)
['{4510EE70-3B7F-4F5C-91F4-F9AEB1A1C311}']
procedure LogNotify(const ALogType: TLogType; const AMsg: string);
end;
TOSLogListeners = TArray<IOSLogListener>;
/// <summary>
/// Operating System specific logging
/// </summary>
/// <remarks>
/// DO NOT ADD ANY FMX UNITS TO THESE FUNCTIONS
/// </remarks>
TOSLog = record
private
class var FEnabled: Boolean;
class var FIncludeDeviceSummary: Boolean;
class var FListeners: TOSLogListeners;
class var FTag: string;
/// <summary>
/// Timestamps ASrc if prefixed with an '@'
/// </summary>
class function ts(const ASrc: string): string; static;
class function FormatMsg(const AFmt: string; const AParams: array of const): string; static;
class procedure LogCloud(AFmt: string; const AParams: array of const; const ALogType: TLogType); static;
class procedure NotifyLog(const ALogType: TLogType; const AMsg: string); static;
public
/// <summary>
/// Replacement functions for IFMXLoggingService
/// </summary>
class procedure d(const AFmt: string; const ACloud: Boolean = False); overload; static;
class procedure d(const AInstance: TObject; const AFmt: string; const ACloud: Boolean = False); overload; static;
class procedure d(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False); overload; static;
class procedure e(const AFmt: string; const ACloud: Boolean = False); overload; static;
class procedure e(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False); overload; static;
class procedure w(const AFmt: string; const ACloud: Boolean = False); overload; static;
class procedure w(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False); overload; static;
/// <summary>
/// Retrieves the OS stack trace. ANDROID ONLY at present
/// </summary>
/// <remarks>
/// Can be useful for working out "how the OS arrived here" when implementing methods of Android interfaces
/// </remarks>
class function GetTrace: string; static;
class procedure RegisterListener(const AListener: IOSLogListener); static;
/// <summary>
/// Dumps a stack trace to the OS log. ANDROID ONLY at present
/// </summary>
/// <remarks>
/// Can be useful for working out "how the OS arrived here" when implementing methods of Android interfaces
/// </remarks>
class procedure Trace; static;
class property Enabled: Boolean read FEnabled write FEnabled;
class property IncludeDeviceSummary: Boolean read FIncludeDeviceSummary write FIncludeDeviceSummary;
class property Tag: string read FTag write FTag;
end;
const
cLogTypeCaptions: array[TLogType] of string = ('DEBUG', 'WARN', 'ERROR');
implementation
uses
// RTL
System.SysUtils,
System.TypInfo,
// Grijjy
{$IF Defined(CLOUDLOGGING)}
Grijjy.CloudLogging,
{$ENDIF}
// DW
DW.OSDevice,
{$IF Defined(ANDROID)}
DW.OSLog.Android;
{$ELSEIF Defined(MACOS)}
DW.OSLog.Mac;
{$ELSEIF Defined(MSWINDOWS)}
DW.OSLog.Win;
{$ELSEIF Defined(LINUX)}
DW.OSLog.Linux;
{$ENDIF}
{ TOSLog }
class function TOSLog.FormatMsg(const AFmt: string; const AParams: array of const): string;
begin
if Length(AParams) > 0 then
Result := Format(AFmt, AParams)
else
Result := AFmt;
end;
class function TOSLog.ts(const ASrc: string): string;
var
LUseTimestamp: Boolean;
begin
Result := ASrc;
LUseTimestamp := False;
if Result.StartsWith('@') then
begin
LUseTimestamp := True;
Result := Result.Substring(1);
end;
{$IF not Defined(ANDROID)}
if not FTag.IsEmpty then
Result := Format('@%s %s', [FTag, Result]);
{$ENDIF}
if LUseTimestamp then
Result := Format('%s - %s', [FormatDateTime('yyyy/mm/dd hh:nn:ss.zzz', Now), Result]);
end;
class procedure TOSLog.LogCloud(AFmt: string; const AParams: array of const; const ALogType: TLogType);
{$IF Defined(CLOUDLOGGING)}
var
LMsg: string;
LLogLevel: TgoLogLevel;
begin
if AFmt.StartsWith('@') then
AFmt := AFmt.Substring(1);
LMsg := Format(AFmt, AParams);
if FIncludeDeviceSummary then
LMsg := TOSDevice.GetDeviceSummary + ': ' + LMsg;
LLogLevel := TgoLogLevel.Info;
case ALogType of
TLogType.Warning:
LLogLevel := TgoLogLevel.Warning;
TLogType.Error:
LLogLevel := TgoLogLevel.Error;
end;
GrijjyLog.Send(LMsg, LLogLevel);
end;
{$ELSE}
begin
end;
{$ENDIF}
class procedure TOSLog.RegisterListener(const AListener: IOSLogListener);
begin
FListeners := FListeners + [AListener];
end;
class procedure TOSLog.NotifyLog(const ALogType: TLogType; const AMsg: string);
var
LListener: IOSLogListener;
begin
for LListener in FListeners do
LListener.LogNotify(ALogType, AMsg);
end;
class procedure TOSLog.d(const AFmt: string; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Debug, FormatMsg(ts(AFmt), []));
NotifyLog(TLogType.Debug, FormatMsg(ts(AFmt), []));
if ACloud then
LogCloud(AFmt, [], TLogType.Debug);
end;
end;
class procedure TOSLog.d(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Debug, FormatMsg(ts(AFmt), AParams));
NotifyLog(TLogType.Debug, FormatMsg(ts(AFmt), AParams));
if ACloud then
LogCloud(AFmt, AParams, TLogType.Debug);
end;
end;
class procedure TOSLog.e(const AFmt: string; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Error, FormatMsg(ts(AFmt), []));
NotifyLog(TLogType.Error, FormatMsg(ts(AFmt), []));
if ACloud then
LogCloud(AFmt, [], TLogType.Error);
end;
end;
class procedure TOSLog.d(const AInstance: TObject; const AFmt: string; const ACloud: Boolean = False);
var
LTypeData: PTypeData;
begin
LTypeData := nil;
if AInstance <> nil then
LTypeData := GetTypeData(AInstance.ClassInfo);
if LTypeData <> nil then
d(AFmt.Substring(0, 1) + LTypeData^.UnitNameFld.ToString + '.' + AInstance.ClassName + '.' + AFmt.Substring(1), ACloud)
else
d(AFmt, ACloud);
end;
class procedure TOSLog.e(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Error, FormatMsg(ts(AFmt), AParams));
NotifyLog(TLogType.Error, FormatMsg(ts(AFmt), AParams));
if ACloud then
LogCloud(AFmt, AParams, TLogType.Error);
end;
end;
class procedure TOSLog.w(const AFmt: string; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Warning, FormatMsg(ts(AFmt), []));
NotifyLog(TLogType.Warning, FormatMsg(ts(AFmt), []));
if ACloud then
LogCloud(AFmt, [], TLogType.Warning);
end;
end;
class procedure TOSLog.w(const AFmt: string; const AParams: array of const; const ACloud: Boolean = False);
begin
if FEnabled then
begin
TPlatformOSLog.Log(TLogType.Warning, FormatMsg(ts(AFmt), AParams));
NotifyLog(TLogType.Warning, FormatMsg(ts(AFmt), AParams));
if ACloud then
LogCloud(AFmt, AParams, TLogType.Warning);
end;
end;
class function TOSLog.GetTrace: string;
begin
{$IF Defined(ANDROID)}
Result := TPlatformOSLog.GetTrace;
{$ELSE}
Result := '';
{$ENDIF}
end;
class procedure TOSLog.Trace;
begin
{$IF Defined(ANDROID)}
TPlatformOSLog.Trace;
{$ENDIF}
end;
initialization
TOSLog.Enabled := True;
end.
|
unit DAO.EstoqueInsumos;
interface
uses DAO.base, Model.EstoqueInsumos, Generics.Collections, System.Classes;
type TEstoqueInsumosDAO = class(TDAO)
public
function Insert(aEstoque: Model.EstoqueInsumos.TEstoqueInsumos): Boolean;
function Update(aEstoque: Model.EstoqueInsumos.TEstoqueInsumos): Boolean;
function Delete(sFiltro: String): Boolean;
function FindEstoque(sFiltro: String): TObjectList<Model.EstoqueInsumos.TEstoqueInsumos>;
function AtualizaEstoque(iInsumo: Integer; dQuantidade: Double): Double;
end;
const
TABLENAME = 'tbestoqueinsumos';
implementation
uses System.SysUtils, FireDAC.Comp.Client, Data.DB, uGlobais;
function TEstoqueInsumosDAO.Insert(aEstoque: TEstoqueInsumos): Boolean;
var
sSQL: String;
begin
Result := False;
aEstoque.ID := GetKeyValue(TABLENAME, 'ID_ESTOQUE');
sSQL := 'INSERT INTO ' + TABLENAME + ' ' +
'(ID_ESTOQUE, ID_INSUMO, DAT_ESTOQUE, QTD_ESTOQUE, VAL_UNITARIO, VAL_TOTAL, DES_LOG) ' +
'VALUES ' +
'(:ID, :INSUMO, :DATA, :ESTOQUE, :UNITARIO, :TOTAL, :LOG);';
Connection.ExecSQL(sSQL,[aEstoque.ID, aEstoque.Insumo, aEstoque.Data, aEstoque.Qtde, aEstoque.Unitario, aEstoque.Total,
aEstoque.Log],[ftInteger, ftInteger, ftDate, ftFloat, ftFloat, ftFloat, ftString]);
Result := True;
end;
function TEstoqueInsumosDAO.Update(aEstoque: TEstoqueInsumos): Boolean;
var
sSQL: String;
begin
Result := False;
sSQL := 'UPDATE ' + TABLENAME + ' ' +
'SET ' +
'ID_INSUMO = :INSUMO, DAT_ESTOQUE = :DATA, QTD_ESTOQUE = :ESTOQUE, VAL_UNITARIO = :UNITARIO, ' +
'VAL_TOTAL = :TOTAL, DES_LOG = :LOG ' +
'WHERE ID_ESTOQUE = :ID;';
Connection.ExecSQL(sSQL,[aEstoque.Insumo, aEstoque.Data, aEstoque.Qtde, aEstoque.Unitario, aEstoque.Total,
aEstoque.Log, aEstoque.ID],[FtInteger, ftDate, ftFloat, ftFloat, ftFloat, ftString, ftInteger]);
Result := True;
end;
function TEstoqueInsumosDAO.Delete(sFiltro: string): Boolean;
var
sSQL : String;
begin
Result := False;
sSQL := 'DELETE FROM ' + TABLENAME + ' ';
if not sFiltro.IsEmpty then
begin
sSQl := sSQL + sFiltro;
end
else
begin
Exit;
end;
Result := True;
end;
function TEstoqueInsumosDAO.FindEstoque(sFiltro: string): TObjectList<TEstoqueInsumos>;
var
FDQuery: TFDQuery;
Estoques: TObjectList<TEstoqueInsumos>;
begin
FDQuery := TFDQuery.Create(nil);
try
FDQuery.Connection := Connection;
FDQuery.SQL.Clear;
FDQuery.SQL.Add('SELECT * FROM ' + TABLENAME);
if not sFiltro.IsEmpty then
begin
FDQuery.SQL.Add(sFiltro);
end;
FDQuery.Open();
Estoques := TObjectList<TEstoqueInsumos>.Create();
while not FDQuery.Eof do
begin
Estoques.Add(TEstoqueInsumos.Create(FDQuery.FieldByName('ID_ESTOQUE').AsInteger, FDQuery.FieldByName('ID_INSUMO').AsInteger,
FDQuery.FieldByName('DAT_ESTOQUE').AsDateTime, FDQuery.FieldByName('QTD_ESTOQUE').AsFloat,
FDQuery.FieldByName('VAL_UNITARIO').AsFloat, FDQuery.FieldByName('VAL_TOTAL').AsFloat,
FDQuery.FieldByName('DES_LOG').AsString));
FDQuery.Next;
end;
finally
FDQuery.Free;
end;
Result := Estoques;
end;
function TEstoqueInsumosDAO.AtualizaEstoque(iInsumo: Integer; dQuantidade: Double): Double;
var
Estoques: TObjectList<TEstoqueInsumos>;
estoque : TEstoqueInsumos;
sFiltro: String;
i: Integer;
dValor, dSobra: Double;
bFlag : Boolean;
sLog : TStringList;
begin
try
Result := 0;
estoque := TEstoqueInsumos.Create();
sFiltro := 'WHERE ID_INSUMO = ' + IntToStr(iInsumo) + ' AND QTD_ESTOQUE > 0 ORDER BY DAT_ESTOQUE;' ;
estoques := Self.FindEstoque(sFiltro);
dValor := 0;
dSobra := 0;
if Estoques.Count > 0 then
begin
bFlag := True;
for i := 0 to Estoques.Count - 1 do
begin
if bFlag then
begin
if Estoques[i].Qtde >= dQuantidade then
begin
dValor := Estoques[i].Unitario * dQuantidade;
Estoques[i].Qtde := Estoques[i].Qtde - dQuantidade;
Estoques[i].Total := Estoques[i].Qtde * Estoques[i].Unitario;
bFlag := False;
end
else
begin
dValor := Estoques[i].Unitario * dQuantidade;
dSobra := dQuantidade - Estoques[i].Qtde;
if dSobra > 0 then
begin
Estoques[i].Qtde := 0;
Estoques[i].Total := Estoques[i].Qtde * Estoques[i].Unitario;
dQuantidade := dSobra;
end;
end;
end;
end;
end;
sLog := TStringList.Create();
for i := 0 to Estoques.Count - 1 do
begin
estoque.ID := Estoques[i].ID;
estoque.Insumo := Estoques[i].Insumo;
estoque.Data := Estoques[i].Data;
estoque.Qtde := Estoques[i].Qtde;
estoque.Unitario := Estoques[i].Unitario;
estoque.Total := Estoques[i].Total;
sLog.Text := Estoques[i].Log;
sLog.Add(FormatDateTime('dd/mm/yyyy hh:mm:ss', Now()) + ' registro no controle de transportes por ' + uGlobais.sUsuario);
estoque.Log := sLog.Text;
Self.Update(estoque);
end;
Result := dValor;
finally
estoque.Free;
end;
end;
end.
|
{ Subroutine SST_W_C_DECL_SYM_EXP (EXP)
*
* Make sure that all the symbols referenced by the expression EXP are declared.
}
module sst_w_c_DECL_SYM_EXP;
define sst_w_c_decl_sym_exp;
%include 'sst_w_c.ins.pas';
procedure sst_w_c_decl_sym_exp ( {declare symbols reference by an expression}
in exp: sst_exp_t); {expression that may reference symbols}
const
max_msg_parms = 1; {max parameters we can pass to a message}
var
term_p: sst_exp_term_p_t; {points to curren term in expression}
ifarg_p: sst_exp_chain_p_t; {points to current itrinsic function argument}
msg_parm: {references to paramters for messages}
array[1..max_msg_parms] of sys_parm_msg_t;
begin
sst_w_c_decl_sym_dtype (exp.dtype_p^); {declare symbols used by data type}
term_p := addr(exp.term1); {init current term to first in expression}
while term_p <> nil do begin {once for each term in expression}
if exp.term1.next_p <> nil then begin {expression has more than one term ?}
sst_w_c_decl_sym_dtype (term_p^.dtype_p^); {declare dtype syms for this term}
end;
case term_p^.ttype of {what kind of term is this ?}
{
* Term is a constant.
}
sst_term_const_k: ;
{
* Term is a variable reference.
}
sst_term_var_k: begin
sst_w_c_symbol (term_p^.var_var_p^.mod1.top_sym_p^); {do top variable symbol}
end;
{
* Term is a function reference.
}
sst_term_func_k: begin
sst_w_c_symbol (term_p^.func_var_p^.mod1.top_sym_p^); {do top variable symbol}
sst_w_c_decl_sym_rout (term_p^.func_proc_p^); {do the routine descriptor}
end;
{
* Term is an intrinsic function reference.
}
sst_term_ifunc_k: begin
ifarg_p := term_p^.ifunc_args_p; {init current ifunc argument to first arg}
while ifarg_p <> nil do begin {once for each argument}
sst_w_c_decl_sym_exp (ifarg_p^.exp_p^);
ifarg_p := ifarg_p^.next_p; {advance to next argument}
end; {back and process this new argument}
end;
{
* Term is an explicit type-casting function.
}
sst_term_type_k: begin
sst_w_c_decl_sym_dtype (term_p^.type_dtype_p^);
sst_w_c_decl_sym_exp (term_p^.type_exp_p^);
end;
{
* Term is a SET value.
}
sst_term_set_k: ;
{
* Term is nested expression.
}
sst_term_exp_k: begin
sst_w_c_decl_sym_exp (term_p^.exp_exp_p^); {process nested expression}
end;
{
* Term is the value of a field in a record.
}
sst_term_field_k: begin
sst_w_c_decl_sym_exp (term_p^.field_exp_p^);
end;
{
* Term is the value of a range of array subscripts.
}
sst_term_arele_k: begin
sst_w_c_decl_sym_exp (term_p^.arele_exp_p^);
end;
{
* Unrecognized or illegal term type.
}
otherwise
sys_msg_parm_int (msg_parm[1], ord(term_p^.ttype));
syo_error (term_p^.str_h, 'sst', 'term_type_unknown', msg_parm, 1);
end; {end of term type cases}
term_p := term_p^.next_p; {advance to next term in expression}
end; {back and process this new term in expression}
end;
|
unit GX_Actions;
{$I GX_CondDefine.inc}
interface
uses
Classes, ActnList,
Menus, ImgList,
{$IFDEF GX_VER240_up}
System.UITypes,
{$ENDIF GX_VER240_up}
GX_KbdShortCutBroker;
type
{ This interface is a rather typical action - except
that it takes care of
a) freeing + unregistering due to reference-counting
b) keyboard shortcut assignment which is special
due to the IDE's interference automatically. }
IGxAction = interface(IUnknown)
['{4B163781-D710-11D3-A95A-5AE3EA000000}']
function GetCaption: string;
function GetCategory: string;
function GetChecked: Boolean;
function GetEnabled: Boolean;
function GetHint: string;
function GetImageIndex: TImageIndex;
function GetOnExecute: TNotifyEvent;
function GetOnUpdate: TNotifyEvent;
function GetShortCut: TShortCut;
function GetVisible: Boolean;
procedure SetCaption(const Value: string);
procedure SetCategory(const Value: string);
procedure SetChecked(Value: Boolean);
procedure SetEnabled(Value: Boolean);
procedure SetHint(const Value: string);
procedure SetImageIndex(Value: TImageIndex);
procedure SetOnExecute(Value: TNotifyEvent);
procedure SetOnUpdate(Value: TNotifyEvent);
procedure SetShortCut(Value: TShortCut);
procedure SetVisible(Value: Boolean);
function GetAction: TCustomAction;
property Caption: string read GetCaption write SetCaption;
property Category: string read GetCategory write SetCategory;
property Checked: Boolean read GetChecked write SetChecked;
property Enabled: Boolean read GetEnabled write SetEnabled;
property Hint: string read GetHint write SetHint;
property ImageIndex: TImageIndex read GetImageIndex write SetImageIndex;
property OnExecute: TNotifyEvent read GetOnExecute write SetOnExecute;
property OnUpdate: TNotifyEvent read GetOnUpdate write SetOnUpdate;
property ShortCut: TShortCut read GetShortCut write SetShortCut;
property Visible: Boolean read GetVisible write SetVisible;
end;
IGxMenuAction = interface(IGxAction)
['{FD68EC31-D723-11D3-A95A-5AE3EA000000}']
function GetAssociatedMenuItem: TMenuItem;
property AssociatedMenuItem: TMenuItem read GetAssociatedMenuItem;
end;
type
{ Base implementor for all actions implemented and registered
by GExperts.
Features life-time management through reference-counting. }
TGxCustomAction = class(TCustomAction, IGxAction)
private
FIdeShortCut: IGxKeyboardShortCut;
protected
property IdeShortCut: IGxKeyboardShortCut read FIdeShortCut write FIdeShortCut;
protected
// IUnknown overrides
FRefCount: Integer;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
protected
// IGxAction
function GetCaption: string;
function GetCategory: string;
function GetChecked: Boolean;
function GetEnabled: Boolean;
function GetHint: string;
function GetImageIndex: TImageIndex;
function GetOnExecute: TNotifyEvent;
function GetOnUpdate: TNotifyEvent;
function GetShortCut: TShortCut;
function GetVisible: Boolean;
procedure SetCaption(const Value: string); {$ifdef GX_VER240_up} override; {$endif}
procedure SetCategory(const Value: string);
procedure SetChecked(Value: Boolean); {$ifdef GX_VER240_up} override; {$endif}
procedure SetEnabled(Value: Boolean);{$ifdef GX_VER240_up} override; {$endif}
procedure SetHint(const Value: string); {$ifdef GX_VER240_up} override; {$endif}
procedure SetImageIndex(Value: TImageIndex); {$ifdef GX_VER240_up} override; {$endif}
procedure SetOnExecute(Value: TNotifyEvent); override;
procedure SetOnUpdate(Value: TNotifyEvent);
procedure SetShortCut(Value: TShortCut); {$ifdef GX_VER240_up} override; {$endif}
procedure SetVisible(Value: Boolean); {$ifdef GX_VER240_up} override; {$endif}
public
property ShortCut: TShortCut read GetShortCut write SetShortCut;
function GetAction: TCustomAction;
end;
implementation
uses
Windows;
{ TGxCustomAction }
function TGxCustomAction.GetAction: TCustomAction;
begin
Result := Self;
end;
function TGxCustomAction.GetCaption: string;
begin
Result := inherited Caption;
end;
function TGxCustomAction.GetCategory: string;
begin
Result := inherited Category;
end;
function TGxCustomAction.GetChecked: Boolean;
begin
Result := inherited Checked;
end;
function TGxCustomAction.GetEnabled: Boolean;
begin
Result := inherited Enabled;
end;
function TGxCustomAction.GetHint: string;
begin
Result := inherited Hint;
end;
function TGxCustomAction.GetImageIndex: TImageIndex;
begin
Result := inherited ImageIndex;
end;
function TGxCustomAction.GetOnExecute: TNotifyEvent;
begin
Result := inherited OnExecute;
end;
function TGxCustomAction.GetOnUpdate: TNotifyEvent;
begin
Result := inherited OnUpdate;
end;
function TGxCustomAction.GetShortCut: TShortCut;
begin
Result := inherited ShortCut;
end;
function TGxCustomAction.GetVisible: Boolean;
begin
Result := inherited Visible;
end;
procedure TGxCustomAction.SetCaption(const Value: string);
begin
{$ifdef GX_VER240_up}
inherited SetCaption(Value);
{$else}
inherited Caption := Value;
{$endif}
if Hint = '' then
Hint := StripHotkey(Value);
end;
procedure TGxCustomAction.SetCategory(const Value: string);
begin
TCustomAction(Self).Category := Value;
end;
procedure TGxCustomAction.SetChecked(Value: Boolean);
begin
{$ifdef GX_VER240_up}
inherited SetChecked(Value);
{$else}
inherited Checked := Value;
{$endif}
end;
procedure TGxCustomAction.SetEnabled(Value: Boolean);
begin
{$ifdef GX_VER240_up}
inherited SetEnabled(Value);
{$else}
inherited Enabled := Value;
{$endif}
end;
procedure TGxCustomAction.SetHint(const Value: string);
begin
{$ifdef GX_VER240_up}
inherited SetHint(Value);
{$else}
inherited Hint := Value;
{$endif}
end;
procedure TGxCustomAction.SetImageIndex(Value: TImageIndex);
begin
{$ifdef GX_VER240_up}
inherited SetImageIndex(Value);
{$else}
inherited ImageIndex := Value;
{$endif}
end;
procedure TGxCustomAction.SetOnExecute(Value: TNotifyEvent);
begin
inherited SetOnExecute(Value);
end;
procedure TGxCustomAction.SetOnUpdate(Value: TNotifyEvent);
begin
inherited OnUpdate := Value;
end;
procedure TGxCustomAction.SetShortCut(Value: TShortCut);
begin
{$ifdef GX_VER240_up}
inherited SetShortCut(Value);
{$else}
inherited ShortCut := Value;
{$endif}
end;
procedure TGxCustomAction.SetVisible(Value: Boolean);
begin
{$ifdef GX_VER240_up}
inherited SetVisible(Value);
{$else}
inherited Visible := Value;
{$endif}
end;
function TGxCustomAction._AddRef: Integer;
begin
Result := InterlockedIncrement(FRefCount);
end;
function TGxCustomAction._Release: Integer;
begin
Result := InterlockedDecrement(FRefCount);
if (Result = 0) { and (Owner = nil) } then
Destroy;
end;
end.
|
unit vcmToolbarsInterfaces;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Библиотека "VCM"
// Автор: Люлин А.В.
// Модуль: "w:/common/components/gui/Garant/VCM/vcmToolbarsInterfaces.pas"
// Начат: 12.02.2008 21:10
// Родные Delphi интерфейсы (.pas)
// Generated from UML model, root element: <<Interfaces::Category>> Shared Delphi::VCM::vcmToolbarsInterfaces
//
// Интерфейсы для работы с панелями инструментов
//
//
// Все права принадлежат ООО НПП "Гарант-Сервис".
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ! Полностью генерируется с модели. Править руками - нельзя. !
{$Include ..\VCM\vcmDefine.inc}
interface
{$If not defined(NoVCM)}
uses
vcmExternalInterfaces
;
type
IvcmToolbarsCustomizeListener = interface(IvcmBase)
{* Слушатель событий настройки панелей инструментов }
['{68687746-F997-4BEC-BD6B-BDCFBD82726B}']
procedure BeforeCustomize;
{* вызывается перед вызовом окна редактирования панелей инструментов }
end;//IvcmToolbarsCustomizeListener
IvcmToolbarsCustomizeNotify = interface(IvcmBase)
{* Уведомляет о событиях редактирования панели инструментов }
['{30A12550-6409-4E0E-B7FD-817414AE3CC2}']
procedure AddListener(const aListener: IvcmToolbarsCustomizeListener);
procedure RemoveListener(const aListener: IvcmToolbarsCustomizeListener);
end;//IvcmToolbarsCustomizeNotify
IvcmToolbarsCustomize = interface(IvcmBase)
{* Настройка панелей инструментов }
['{4A5A5457-01CE-4FFF-B872-7633827158D4}']
function pm_GetNotify: IvcmToolbarsCustomizeNotify;
property Notify: IvcmToolbarsCustomizeNotify
read pm_GetNotify;
end;//IvcmToolbarsCustomize
{$IfEnd} //not NoVCM
implementation
end. |
{ Date Created: 5/22/00 11:17:32 AM }
unit InfoGROUPNAMESTable;
interface
uses
Classes, DB, DBISAMTb, SysUtils, DBISAMTableAU, DataBuf;
type
TInfoGROUPNAMESRecord = record
PIndex: Integer;
PName: String[10];
End;
TInfoGROUPNAMESBuffer = class(TDataBuf)
protected
function PtrIndex(Index:integer):Pointer;override;
public
Data: TInfoGROUPNAMESRecord
end;
TEIInfoGROUPNAMES = (InfoGROUPNAMESPrimaryKey, InfoGROUPNAMESByName);
TInfoGROUPNAMESTable = class( TDBISAMTableAU )
private
FDFIndex: TAutoIncField;
FDFName: TStringField;
procedure SetPName(const Value: String);
function GetPName:String;
function GenerateNewFieldName( AOwner: TComponent; const DatasetName: string; const FieldName: string ): string;
procedure SetEnumIndex(Value: TEIInfoGROUPNAMES);
function GetEnumIndex: TEIInfoGROUPNAMES;
protected
function CreateField( const FieldName : string ): TField;
procedure CreateFields; virtual;
procedure SetActive(Value: Boolean); override;
procedure LoadFieldDefs(AStringList:TStringList);override;
procedure LoadIndexDefs(AStringList:TStringList);override;
public
function GetDataBuffer:TInfoGROUPNAMESRecord;
procedure StoreDataBuffer(ABuffer:TInfoGROUPNAMESRecord);
property DFIndex: TAutoIncField read FDFIndex;
property DFName: TStringField read FDFName;
property PName: String read GetPName write SetPName;
procedure Validate; virtual;
published
property Active write SetActive;
property EnumIndex: TEIInfoGROUPNAMES read GetEnumIndex write SetEnumIndex;
end; { TInfoGROUPNAMESTable }
procedure Register;
implementation
function TInfoGROUPNAMESTable.GenerateNewFieldName( AOwner: TComponent; const DatasetName: string; const FieldName: string ): string;
var
I: Integer;
NewName: string;
Done: Boolean;
function ComponentExists( AOwner: TComponent; const CompName: string ): Boolean;
var
I: Integer;
begin
Result := False;
for I := 0 To AOwner.ComponentCount - 1 do
begin
if AnsiCompareText( CompName, AOwner.Components[ I ].Name ) = 0 then
begin
Result := True;
Break;
end;
end;
end; { ComponentExists }
begin { TInfoGROUPNAMESTable.GenerateNewFieldName }
NewName := DatasetName;
for I := 1 to Length( FieldName ) do
begin
if FieldName[ I ] in [ '0'..'9', '_', 'A'..'Z', 'a'..'z' ] then
NewName := NewName + FieldName[ I ];
end;
if ComponentExists( Owner, NewName ) then
begin
I := 1;
Done := False;
repeat
Inc( I );
if not ComponentExists( AOwner, NewName + IntToStr( I ) ) then
begin
Result := NewName + IntToStr( I );
Done := True;
end;
until Done;
end
else
Result := NewName;
end; { TInfoGROUPNAMESTable.GenerateNewFieldName }
function TInfoGROUPNAMESTable.CreateField( const FieldName : string ): TField;
begin
{ First, try to find an existing field object. FindField is the same }
{ as FieldByName, but does not raise an exception if the field object }
{ cannot be found. }
Result := FindField( FieldName );
if Result = nil then
begin
{ If an existing field object cannot be found... }
{ Instruct the FieldDefs object to create a new field object }
Result := FieldDefs.Find( FieldName ).CreateField( Owner );
{ The new field object must be given a name so that it may appear in }
{ the Object Inspector. The Delphi default naming convention is used.}
Result.Name := GenerateNewFieldName( Owner, Name, FieldName);
end;
end; { TInfoGROUPNAMESTable.CreateField }
procedure TInfoGROUPNAMESTable.CreateFields;
begin
FDFIndex := CreateField( 'Index' ) as TAutoIncField;
FDFName := CreateField( 'Name' ) as TStringField;
end; { TInfoGROUPNAMESTable.CreateFields }
procedure TInfoGROUPNAMESTable.SetActive(Value: Boolean);
begin
inherited SetActive(Value);
if Active then
CreateFields;
end; { TInfoGROUPNAMESTable.SetActive }
procedure TInfoGROUPNAMESTable.Validate;
begin
{ Enter Validation Code Here }
end; { TInfoGROUPNAMESTable.Validate }
procedure TInfoGROUPNAMESTable.SetPName(const Value: String);
begin
DFName.Value := Value;
end;
function TInfoGROUPNAMESTable.GetPName:String;
begin
result := DFName.Value;
end;
procedure TInfoGROUPNAMESTable.LoadFieldDefs(AStringList: TStringList);
begin
inherited;
with AstringList do
begin
Add('Index, AutoInc, 0, Y');
Add('Name, String, 10, Y');
end;
end;
procedure TInfoGROUPNAMESTable.LoadIndexDefs(AStringList: TStringList);
begin
inherited;
with AstringList do
begin
Add('PrimaryKey, Index, Y, Y, N, N');
Add('ByName, Name, N, N, N, N');
end;
end;
procedure TInfoGROUPNAMESTable.SetEnumIndex(Value: TEIInfoGROUPNAMES);
begin
case Value of
InfoGROUPNAMESPrimaryKey : IndexName := '';
InfoGROUPNAMESByName : IndexName := 'ByName';
end;
end;
function TInfoGROUPNAMESTable.GetDataBuffer:TInfoGROUPNAMESRecord;
var buf: TInfoGROUPNAMESRecord;
begin
fillchar(buf, sizeof(buf), 0);
buf.PIndex := DFIndex.Value;
buf.PName := DFName.Value;
result := buf;
end;
procedure TInfoGROUPNAMESTable.StoreDataBuffer(ABuffer:TInfoGROUPNAMESRecord);
begin
DFName.Value := ABuffer.PName;
end;
function TInfoGROUPNAMESTable.GetEnumIndex: TEIInfoGROUPNAMES;
var iname : string;
begin
iname := uppercase(indexname);
if iname = '' then result := InfoGROUPNAMESPrimaryKey;
if iname = 'BYNAME' then result := InfoGROUPNAMESByName;
end;
(********************************************)
(************ Register Component ************)
(********************************************)
procedure Register;
begin
RegisterComponents( 'Info Tables', [ TInfoGROUPNAMESTable, TInfoGROUPNAMESBuffer ] );
end; { Register }
function TInfoGROUPNAMESBuffer.PtrIndex(index:integer):Pointer;
begin
result := nil;
case index of
1 : result := @Data.PIndex;
2 : result := @Data.PName;
end;
end;
end. { InfoGROUPNAMESTable }
|
PROGRAM ReverseSort_a(INPUT, OUTPUT);
{Программа
1) Копирует INPUT в F1
2) Копирует F1 в OUTPUT}
PROCEDURE Copy(VAR F1, F2: TEXT); {F1 -> F2}
VAR
Ch: CHAR;
BEGIN {Copy}
RESET(F1);
REWRITE(F2);
WHILE NOT EOLN(F1)
DO
BEGIN
READ(F1, Ch);
WRITE(F2, Ch)
END
END; {Copy}
VAR
F1, F2, F3: TEXT;
BEGIN {ReverseSort}
Copy(INPUT, F1);
Copy(F1, OUTPUT)
END. {ReverseSort}
|
unit atCreateFoldersOperation;
{* Создает папки. }
// Модуль: "w:\quality\test\garant6x\AdapterTest\Operations\atCreateFoldersOperation.pas"
// Стереотип: "SimpleClass"
// Элемент модели: "TatCreateFoldersOperation" MUID: (4846994F0144)
interface
uses
l3IntfUses
, atOperationBase
, FoldersUnit
;
type
TatCreateFoldersOperation = class(TatOperationBase)
{* Создает папки. }
private
f_TotalFoldersAdded: Integer;
{* Столько папок всего уже создано. }
f_MaxFoldersCount: Integer;
{* Столько всего надо создать папок }
f_NamePrefix: AnsiString;
private
function CreateAsNTree(const aRootNode: IFoldersNode;
aMaxFoldersCount: Integer;
aN: Integer): Integer; virtual;
{* Создает дерево папок - в корне создает aN папок, в каждой папке еще aN и т.д., пока в общей сложности не создастся aMaxFoldersCount папок.
Если хотим все папки на одном уровне, то, очевидно, надо чтобы aN >= aMaxFoldersCount. }
procedure FolderHasBeenAdded(const aFolder: IFoldersNode); virtual;
{* Метод вызывается при добавлении папки. }
protected
procedure ExecuteSelf; override;
procedure InitParamList; override;
procedure ExecuteChilds; override;
end;//TatCreateFoldersOperation
implementation
uses
l3ImplUses
, atFoldersHelper
, atLogger
, BaseTreeSupportUnit
, SysUtils
, Math
, atCommon
//#UC START# *4846994F0144impl_uses*
//#UC END# *4846994F0144impl_uses*
;
function TatCreateFoldersOperation.CreateAsNTree(const aRootNode: IFoldersNode;
aMaxFoldersCount: Integer;
aN: Integer): Integer;
{* Создает дерево папок - в корне создает aN папок, в каждой папке еще aN и т.д., пока в общей сложности не создастся aMaxFoldersCount папок.
Если хотим все папки на одном уровне, то, очевидно, надо чтобы aN >= aMaxFoldersCount. }
//#UC START# *48469BEB00C7_4846994F0144_var*
var
l_SubNodes : array of INode;
l_Name, l_Comment : String;
i, l_ChildNodesCount, l_MaxChildNodesCount, l_NodesAdded : Integer;
//#UC END# *48469BEB00C7_4846994F0144_var*
begin
//#UC START# *48469BEB00C7_4846994F0144_impl*
Assert(aRootNode <> nil, 'aRootNode <> nil');
Assert(aN > 0, 'aN > 0');
Result := 0;
l_NodesAdded := 0;
l_MaxChildNodesCount := 1 + ((aMaxFoldersCount - aN) div aN);
SetLength(l_SubNodes, aN);
// сначала добавляем папки к рутовой
for i := Low(l_SubNodes) to High(l_SubNodes) do
if (l_NodesAdded < aMaxFoldersCount) then
begin
if (f_NamePrefix <> '') then
l_Name := f_NamePrefix + IntToStr(i)
else
l_Name := 'Папка созданная ' + GetTimeStamp;
l_Comment := 'Комментарий к папке';
TatFoldersHelper.CreateFolder(aRootNode, l_Name, l_Comment, l_SubNodes[i]);
Inc(l_NodesAdded);
FolderHasBeenAdded(l_SubNodes[i] as IFoldersNode);
end
else
break;
// а теперь, если еще есть чего добавлять, то добавляем папки к каждой из добавленных
for i := Low(l_SubNodes) to High(l_SubNodes) do
if (l_NodesAdded < aMaxFoldersCount) then
begin
// число дочерних нод орпеделяем как меньшее между максимально возможным и тем сколько еще можно добавить
l_ChildNodesCount := Min(l_MaxChildNodesCount, aMaxFoldersCount - l_NodesAdded);
// добавляем дочерние папки
Inc(l_NodesAdded, CreateAsNTree(l_SubNodes[i] as IFoldersNode, l_ChildNodesCount, aN) );
//
l_SubNodes[i] := nil;
end
else
break;
Result := l_NodesAdded;
//#UC END# *48469BEB00C7_4846994F0144_impl*
end;//TatCreateFoldersOperation.CreateAsNTree
procedure TatCreateFoldersOperation.FolderHasBeenAdded(const aFolder: IFoldersNode);
{* Метод вызывается при добавлении папки. }
//#UC START# *484A715B032F_4846994F0144_var*
const
PARTN = 5;
//#UC END# *484A715B032F_4846994F0144_var*
begin
//#UC START# *484A715B032F_4846994F0144_impl*
Assert(aFolder <> nil, 'aFolder <> nil');
//
Inc(f_TotalFoldersAdded);
// делаем добавленную папку текущей
ExecutionContext.UserWorkContext.CurrFolder := aFolder;
// пишем сообщение в лог если надо
if ( ((f_TotalFoldersAdded mod (Max(PARTN, f_MaxFoldersCount) div PARTN)) = 0) // если добавлена очередная PARTN-я часть от общего количества папок
OR (f_TotalFoldersAdded = f_MaxFoldersCount) ) // или добавлена последняя папка
then
Logger.Info('Добавлено папок: %d. Осталось: %d.', [f_TotalFoldersAdded, f_MaxFoldersCount - f_TotalFoldersAdded]);
// вызываем дочерние операции...
inherited ExecuteChilds;
//#UC END# *484A715B032F_4846994F0144_impl*
end;//TatCreateFoldersOperation.FolderHasBeenAdded
procedure TatCreateFoldersOperation.ExecuteSelf;
//#UC START# *48089F460352_4846994F0144_var*
var
l_FoldersCount, l_NOrder : Integer;
l_MyDocs : IFoldersNode;
//#UC END# *48089F460352_4846994F0144_var*
begin
//#UC START# *48089F460352_4846994F0144_impl*
f_TotalFoldersAdded := 0;
l_FoldersCount := Parameters['folders_count'].AsInt;
l_NOrder := Parameters['n_order'].AsInt;
f_NamePrefix := Parameters['name_prefix'].AsStr;
//
if (l_NOrder = -1) then
l_NOrder := l_FoldersCount; // это чтобы положить все папки на один уровень в "Мои документы"
// получаем папку Мои документы
l_MyDocs := TatFoldersHelper.GetMyDocuments;
Assert(l_MyDocs <> nil, 'l_MyDocs <> nil');
// добавляем в нее папки
f_MaxFoldersCount := l_FoldersCount;
CreateAsNTree(l_MyDocs, l_FoldersCount, l_NOrder);
//#UC END# *48089F460352_4846994F0144_impl*
end;//TatCreateFoldersOperation.ExecuteSelf
procedure TatCreateFoldersOperation.InitParamList;
//#UC START# *48089F3701B4_4846994F0144_var*
//#UC END# *48089F3701B4_4846994F0144_var*
begin
//#UC START# *48089F3701B4_4846994F0144_impl*
inherited;
with f_ParamList do
begin
Add( ParamType.Create('folders_count', 'Максимальное количество папок', '1') );
Add( ParamType.Create('name_prefix', 'Префикс имени папки', '') ); // имя папки генерируется как префикс + номер, если префикс пуст, то генерируется случайнм образом
Add( ParamType.Create('n_order', 'Папок на каждом уровне', '-1') );
end;
//#UC END# *48089F3701B4_4846994F0144_impl*
end;//TatCreateFoldersOperation.InitParamList
procedure TatCreateFoldersOperation.ExecuteChilds;
//#UC START# *48089F660238_4846994F0144_var*
//#UC END# *48089F660238_4846994F0144_var*
begin
//#UC START# *48089F660238_4846994F0144_impl*
// ничего не делаем. Дочерние операции будут явно выполняться в FolderHasBeenAdded после добавления каждой папки
//#UC END# *48089F660238_4846994F0144_impl*
end;//TatCreateFoldersOperation.ExecuteChilds
end.
|
unit Twainscan;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, JvFormPlacement,
JvComponentBase, JvAppStorage, JvAppIniStorage, Vcl.ExtCtrls;
type
TFTwainScan = class(TForm)
btnok: TButton;
JvAppIniFileStorage1: TJvAppIniFileStorage;
JvFormPlacement1: TJvFormStorage;
btnGrabar: TButton;
SaveDialog: TSaveDialog;
img: TImage;
procedure btnokClick(Sender: TObject);
procedure btnGrabarClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
Filename: Ansistring;
Twain: TDelphiTwain;
procedure grabar;
procedure grabarImagen;
procedure TwainTwainAcquire(Sender: TObject; const Index: Integer;
Image: TBitmap; var Cancel: Boolean);
public
{ Public declarations }
end;
var
FTwainScan: TFTwainScan;
implementation
{$R *.dfm}
procedure TFTwainScan.btnGrabarClick(Sender: TObject);
begin
grabarimagen;
end;
procedure TFTwainScan.btnokClick(Sender: TObject);
var
SelectedSource: Integer;
begin
Self.Enabled := False;
try
if Twain = nil then
begin
Twain := TDelphiTwain.Create(Self);
Twain.OnTwainAcquire := TwainTwainAcquire;
end;
{It is always recommended to load library dynamically, never forcing}
{final user to have twain installed}
if Twain.LoadLibrary then
begin
{Load source manager}
Twain.SourceManagerLoaded := TRUE;
{Allow user to select source}
SelectedSource := Twain.SelectSource;
if SelectedSource <> -1 then
begin
{Load source, select transference method and enable (display interface)}
Twain.Source[SelectedSource].Loaded := TRUE;
Twain.Source[SelectedSource].Enabled := True;
end {if SelectedSource <> -1}
end
else
showmessage('Twain is not installed.');
finally
Self.Enabled := True;
end;
end;
procedure TFTwainScan.TwainTwainAcquire(Sender: TObject; const Index: Integer;
Image: TBitmap; var Cancel: Boolean);
begin
img.Picture.Assign(Image);
Cancel := TRUE; {Only want one image}
end;
procedure TFTwainScan.FormCreate(Sender: TObject);
begin
ReportMemoryLeaksOnShutdown := True;
end;
procedure TFTwainScan.grabar;
begin
if Img.Picture = nil then
Exit;
// Img.SaveToFile(FileName);
end;
procedure TFTwainScan.grabarImagen;
begin
// SaveDialog.Filter := GraphicFilter(TDibGraphic);
// SaveDialog.DefaultExt := 'jpg';
if SaveDialog.Execute then
begin
FileName := AnsiString(SaveDialog.FileName);
if FileExists(FileName) and
(MessageDlg( 'Archivo ' + FileName + ' ya existe.'#13 + ' Lo sobre-escribe ?',
mtConfirmation, [mbYes, mbNo], 0) <> mrYes) then
Abort;
grabar;
Caption := FileName;
end;
end;
end.
|
unit FindUnit.Header;
interface
const
VERSION: array[0..2] of Word = (1,0,6);//(MAJOR, RELEASE, BUILD)
type
TListType = (ltClasses = 0,
ltProcedures = 1,
ltFunctions = 2,
ltContants = 3,
ltVariables = 4);
TStringPosition = record
Value: string;
Line: Integer;
end;
var
strListTypeDescription: array[TListType] of string;
VERSION_STR: string;
const
MAX_RETURN_ITEMS = 200;
implementation
uses
SysUtils;
procedure LoadConts;
begin
strListTypeDescription[ltClasses] := '';
strListTypeDescription[ltProcedures] := ' - Procedure';
strListTypeDescription[ltFunctions] := ' - Function';
strListTypeDescription[ltContants] := ' - Constant';
strListTypeDescription[ltVariables] := ' - Variable';
VERSION_STR := Format('%d.%d.%d', [VERSION[0], VERSION[1], VERSION[2]]);
end;
initialization
LoadConts;
end.
|
unit Classe.Pessoa;
interface
uses
System.Classes, Interfaces;
type
TEventMemo = procedure(Value : String) of object;
TNotifyEvent = procedure(Sender : TObject) of Object;
TPessoa = class
private
Conexao : IConexao;
FUF: String;
FNome: String;
FCidade: String;
FEndereco: String;
FTelefone: String;
FEventMemo: TEventMemo;
FOnClick: TNotifyEvent;
procedure SetCidade(const Value: String);
procedure SetEndereco(const Value: String);
procedure SetNome(const Value: String);
procedure SetTelefone(const Value: String);
procedure SetUF(const Value: String);
procedure SetEventMemo(const Value: TEventMemo);
procedure SetOnClick(const Value: TNotifyEvent);
public
constructor Create(aConexao : IConexao); virtual;
procedure Cadastrar;
procedure CriarFinanceiro;
function Tipo : String; virtual; abstract;
property Nome : String read FNome write SetNome;
procedure EvOnCadastro;
property Telefone : String read FTelefone write SetTelefone;
property Endereco : String read FEndereco write SetEndereco;
property Cidade : String read FCidade write SetCidade;
property UF : String read FUF write SetUF;
property EventMsg : TEventMemo read FEventMemo write SetEventMemo;
property OnCadastro : TNotifyEvent read FOnClick write SetOnClick;
end;
implementation
uses
System.SysUtils;
{ TCliente }
procedure TPessoa.Cadastrar;
var
Lista : TStringList;
begin
Lista := TStringList.Create;
try
Lista.Add('Nome:' + Nome);
Lista.Add('Telefone:' + Telefone);
Lista.Add('Enderešo:' + Endereco);
Lista.Add('Cidade:' + Cidade);
Lista.Add('UF:' + UF);
Lista.SaveToFile(Nome + '_Cliente.txt');
Conexao.Gravar;
EvOnCadastro;
finally
Lista.Free;
end;
end;
constructor TPessoa.Create(aConexao : IConexao);
begin
Conexao := aConexao;
UF := 'RJ';
end;
procedure TPessoa.CriarFinanceiro;
var
Lista : TStringList;
begin
Lista := TStringList.Create;
try
Lista.Add('Nome:' + Nome);
Lista.SaveToFile(Nome + '_Financeiro.txt');
finally
Lista.Free;
end;
end;
procedure TPessoa.EvOnCadastro;
begin
if Assigned(OnCadastro) then
OnCadastro(Self);
end;
procedure TPessoa.SetCidade(const Value: String);
begin
FCidade := Value;
end;
procedure TPessoa.SetEndereco(const Value: String);
begin
FEndereco := Value;
end;
procedure TPessoa.SetEventMemo(const Value: TEventMemo);
begin
FEventMemo := Value;
end;
procedure TPessoa.SetNome(const Value: String);
begin
FNome := Value;
end;
procedure TPessoa.SetOnClick(const Value: TNotifyEvent);
begin
FOnClick := Value;
end;
procedure TPessoa.SetTelefone(const Value: String);
begin
FTelefone := Value;
end;
procedure TPessoa.SetUF(const Value: String);
begin
FUF := Value;
end;
end.
|
{***********************************************************************************************************************
*
* TERRA Game Engine
* ==========================================
*
* Copyright (C) 2003, 2014 by SÚrgio Flores (relfos@gmail.com)
*
***********************************************************************************************************************
*
* 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.
*
**********************************************************************************************************************
* TERRA_ResourceManager
* Implements a generic Resource Manager
***********************************************************************************************************************
}
Unit TERRA_ResourceManager;
{$I terra.inc}
Interface
Uses {$IFDEF USEDEBUGUNIT}TERRA_Debug,{$ENDIF}
TERRA_String, TERRA_Resource, TERRA_Collections, TERRA_Stream, TERRA_Application,
TERRA_Threads, TERRA_Mutex, TERRA_Hashmap, TERRA_Queue;
Const
ResourceUpdateTime = 5000;
ResourceDiscardTime = 60000;
Type
ResourceEntry = Class(CollectionObject)
Public
Value:Resource;
Function ToString():TERRAString; Override;
Constructor Create(MyResource:Resource);
Procedure CopyValue(Other:CollectionObject); Override;
End;
ResourceManager = Class(ApplicationComponent)
Protected
_LastUpdate:Cardinal;
_Queue:Queue;
{$IFNDEF DISABLETHREADS}
_LockSection:CriticalSection;
{$ENDIF}
_Resources:HashMap;
_Purging:Boolean;
// Procedure OnAppDestroy; Override;
Public
UseThreads:Boolean;
AutoUnload:Boolean;
Procedure Init; Override;
Procedure Release; Override;
Procedure Update; Override;
Function GetResource(Const Name:TERRAString):Resource;
Procedure AddResource(MyResource:Resource);
Procedure ReloadResource(Resource:Resource; InBackground:Boolean=True);
Function GetLoadedResourceCount:Integer;
Function ResolveResourceLink(Const ResourceName:TERRAString):TERRAString;
Function Busy:Boolean;
Procedure Lock;
Procedure Unlock;
Procedure Clear;
Procedure PurgeResources;
Procedure PreFetch(MyResource:Resource);
Property Resources:HashMap Read _Resources;
End;
Implementation
Uses TERRA_Error, TERRA_Log, TERRA_OS, TERRA_Image, TERRA_GraphicsManager, TERRA_Utils, TERRA_Color,
TERRA_FileUtils, TERRA_FileStream, TERRA_FileManager;
Type
ResourceLoader = Class(Task)
Protected
_Target:Resource;
Public
Constructor Create(Target:Resource);
Procedure Execute; Override;
End;
Constructor ResourceLoader.Create(Target:Resource);
Begin
_Target := Target;
End;
Procedure ResourceLoader.Execute();
Var
MyResource:Resource;
Source:Stream;
Result:Boolean;
Manager:ResourceManager;
Begin
MyResource := _Target;
If (Not Assigned(MyResource)) Or (MyResource.Status = rsReady) Then
Exit;
Log(logDebug, 'ResourceManager', 'Obtaining manager for '+MyResource.Name);
Manager := MyResource.GetManager();
If (Manager = Nil) Then
Begin
Log(logDebug, 'ResourceManager', 'Could not find a manager for '+MyResource.Name);
MyResource.Status := rsInvalid;
Exit;
End;
Source := FileManager.Instance.OpenStream(MyResource.Location, smRead);
If (Source=Nil) Then
Begin
Log(logDebug, 'ResourceManager', 'Could not open location...');
MyResource.Status := rsInvalid;
Exit;
End;
MyResource.Status := rsBusy;
Log(logDebug, 'Resources', 'Loading '+MyResource.Name);
If Source.Size = 0 Then
Begin
Source := FileManager.Instance.OpenStream(MyResource.Location, smRead);
Log(logWarning, 'Resources', 'Empty resource stream at '+MyResource.Location);
end;
Result := MyResource.Load(Source);
If (MyResource.Kind <> rtStreamed) Then
ReleaseObject(Source);
If (Not Result) Then
Begin
MyResource.Status := rsInvalid;
Exit;
End;
MyResource.Time := Application.GetTime;
Log(logDebug, 'Resource', 'Loaded '+MyResource.Name);
If (Manager.UseThreads) Then
Begin
Manager.Lock;
Manager._Queue.Push(ResourceEntry.Create(MyResource));
Manager.Unlock;
End Else
Begin
Log(logDebug, 'Resource', 'Updating '+MyResource.Name);
MyResource.Update();
MyResource.Status := rsReady;
End;
Log(logDebug, 'Resource', 'Finished '+MyResource.Name);
End;
Procedure ResourceManager.Init;
Begin
Log(logDebug, 'Resource', 'Creating resource manager for class: '+Self.ClassName);
_Resources := HashMap.Create(1024);
_LastUpdate := 0;
_Queue := Queue.Create();
{$IFNDEF DISABLETHREADS}
_LockSection := CriticalSection.Create({Self.ClassName});
{$ENDIF}
UseThreads := False;
AutoUnload := False;
Log(logDebug, 'Resource', 'This resource manager is ready to go!');
End;
Procedure ResourceManager.Release;
Var
I:Integer;
Begin
ReleaseObject(_Resources);
ReleaseObject(_Queue);
{$IFNDEF DISABLETHREADS}
ReleaseObject(_LockSection);
{$ENDIF}
End;
Procedure ResourceManager.AddResource(MyResource:Resource);
Begin
If (_Resources <> Nil) Then
_Resources.Add(MyResource)
Else
RaiseError('Resource table is null!');
End;
Function ResourceManager.GetResource(Const Name:TERRAString): Resource;
Var
Temp:TERRAString;
Begin
If _Resources = Nil Then
Begin
RaiseError('Resource table is null!');
Result := Nil;
Exit;
End;
If (StringContainsChar(Ord('.'), Name)) Then
Temp := GetFileName(Name, True)
Else
Temp := Name;
Result := Resource(_Resources.Items[Temp]);
{If Assigned(Result) Then
Log(logDebug, 'Resource', 'Searched for '+Name+': got '+Result.Name)
Else
Log(logDebug, 'Resource', 'Searched for '+Name+': got (NIL)');}
End;
Procedure ResourceManager.ReloadResource(Resource: Resource; InBackground:Boolean=True);
Begin
If Not Assigned(Resource) Then
Begin
RaiseError('Cannot load null resource!');
Exit;
End;
If InBackground Then
Log(logDebug, 'ResourceManager', 'Reloading '+Resource.Name+' in background')
Else
Log(logDebug, 'ResourceManager', 'Reloading '+Resource.Name+' in foreground');
ThreadPool.Instance.RunTask(ResourceLoader.Create(Resource), (InBackground And UseThreads), Nil, Resource.Priority);
End;
{Procedure ResourceManager.OnAppDestroy;
Begin
If (Assigned(_ResourceManager_Instance)) Then
_ResourceManager_Instance.Release;
End;
}
Procedure ResourceManager.PurgeResources;
Var
It:Iterator;
MyResource:Resource;
Begin
If (Not AutoUnload) Then
Exit;
If (_Purging) Then
Exit;
_Purging := True;
It := _Resources.GetIterator();
While (It.HasNext) Do
Begin
MyResource := Resource(It.Value);
If (MyResource = Nil) Then
Break;
If (MyResource.Status<>rsReady) Or (MyResource.Kind <> rtLoaded) Then
Continue;
If (MyResource.ShouldUnload()) Then
Begin
MyResource.Status := rsBusy;
Log(logDebug,'Resource','Unloaded '+MyResource.Name);
If MyResource.Unload Then
MyResource.Status := rsUnloaded
Else
MyResource.Status := rsReady;
End;
End;
ReleaseObject(It);
_Purging := False;
_LastUpdate := Application.GetTime;
End;
Procedure ResourceManager.Update;
Var
Entry:ResourceEntry;
Begin
If (_Queue = Nil) Then
Exit;
While (_Queue.Count>0) Do
Begin
Self.Lock;
Entry := ResourceEntry(_Queue.Pop());
Self.Unlock;
Entry.Value.Update;
Entry.Value.Status := rsReady;
ReleaseObject(Entry);
Break; // only one item per frame
End;
{$IFDEF PC}
If (Application.GetTime-_LastUpdate<ResourceUpdateTime) Then
Exit;
PurgeResources();
{$ENDIF}
End;
Procedure ResourceManager.Lock;
Begin
{$IFNDEF DISABLETHREADS}
_LockSection.Lock();
{$ENDIF}
End;
Procedure ResourceManager.Unlock;
Begin
{$IFNDEF DISABLETHREADS}
_LockSection.Unlock();
{$ENDIF}
End;
Procedure ResourceManager.PreFetch(MyResource:Resource);
Begin
If Assigned(MyResource) Then
Begin
If MyResource.Status <> rsUnloaded Then
Exit;
MyResource.Prefetch();
End;
End;
Function ResourceManager.GetLoadedResourceCount:Integer;
Var
It:Iterator;
MyResource:Resource;
Begin
Result := 0;
It := _Resources.GetIterator();
While (It.HasNext) Do
Begin
MyResource := Resource(It.Value);
If (MyResource.Status <> rsBusy) Then
Inc(Result);
End;
End;
Function ResourceManager.Busy: Boolean;
Begin
Result := _Queue.Count>0;
End;
Procedure ResourceManager.Clear;
Var
It:Iterator;
N:Integer;
MyResource:Resource;
Begin
Log(logDebug, Self.ClassName, 'Unloading all resources.');
N := 0;
It := _Resources.GetIterator();
While (It.HasNext) Do
Begin
MyResource := Resource(It.Value);
MyResource.Status := rsBusy;
// Log(logDebug,'Resource','Unloaded '+MyResource.Name);
If MyResource.Unload Then
MyResource.Status := rsUnloaded
Else
MyResource.Status := rsReady;
Inc(N);
End;
Log(logDebug, 'Resources', 'Unloaded '+IntToString(N) + ' resources.');
_LastUpdate := Application.GetTime;
End;
{ ResourceEntry }
Constructor ResourceEntry.Create(MyResource: Resource);
Begin
Self.Value := MyResource;
End;
Procedure ResourceEntry.CopyValue(Other: CollectionObject);
Begin
Self.Value := ResourceEntry(Other).Value;
End;
Function ResourceEntry.ToString:TERRAString;
Begin
Result := Value.Name;
End;
(*Procedure ResourceManager.OnContextLost;
Var
It:Iterator;
MyResource:Resource;
Begin
If (_Resources = Nil) Then
Exit;
It := _Resources.GetIterator();
While (It.HasNext) Do
Begin
MyResource := Resource(It.Value);
If (MyResource.Status = rsReady) Then
Begin
Log(logDebug, 'ResourceManager', 'Context lost: '+MyResource.Name);
MyResource.OnContextLost();
End;
End;
End;*)
Function ResourceManager.ResolveResourceLink(Const ResourceName: TERRAString):TERRAString;
Const
LinkExtension = '.link';
Var
Name:TERRAString;
Src:Stream;
Begin
Result := '';
If Pos(LinkExtension, ResourceName)>0 Then
Exit;
Src := FileManager.Instance.OpenStream(ResourceName + LinkExtension);
If Assigned(Src) Then
Begin
Src.ReadLine(Name);
ReleaseObject(Src);
If (StringLower(Name) = StringLower(ResourceName)) Then
Exit;
Result := Name;
End;
End;
End.
|
Program Aufgabe7;
{$codepage utf8}
Var Zahl1: Integer;
Zahl2: Integer;
Begin
Write('Bitte gib die erste Zahl ein: ');
Read(Zahl1);
Write('Bitte gib die zweite Zahl ein: ');
Read(Zahl2);
If (Zahl1 < 1) or (Zahl2 < 1) Then
WriteLn('Beide Zahlen müssen positiv sein!')
Else Begin
Write('Der ggT von ', Zahl1, ' und ', Zahl2, ' ist ');
While Zahl1 <> Zahl2 Do
If Zahl1 > Zahl2 Then
Zahl1 := Zahl1 - Zahl2
Else
Zahl2 := Zahl2 - Zahl1;
WriteLn(Zahl1, '.');
End;
End. |
// Unfinished work, tho it should be usable.
type
TMouseObj = record
Speed:Int8;
end;
var
__MouseConvert:Array of Int8 = [1,0,2];
Mouse: TMouseObj;
function TMouseObj.GetPosition(): TPoint;
begin
GetMousePos(Result.x, Result.y);
end;
procedure TMouseObj.SetPosition(PT: TPoint);
begin
MoveMouse(PT.x, PT.y);
end;
procedure TMouseObj.ButtonDown(btn:TMouseButton);
var PT: TPoint;
begin
PT := Self.GetPosition();
HoldMouse(PT.x,PT.y,__MouseConvert[UInt32(btn)]);
end;
procedure TMouseObj.ButtonUp(btn:TMouseButton);
var PT: TPoint;
begin
PT := Self.GetPosition();
ReleaseMouse(PT.x,PT.y,__MouseConvert[UInt32(btn)]);
end;
function TMouseObj.ButtonState(btn:TMouseButton): Int32;
begin
Result := ord(IsMouseButtonDown(__MouseConvert[UInt32(btn)]));
end;
procedure TMouseObj.DragTo(PT:TPoint; btn:TMouseButton);
begin
Self.ButtonDown(btn);
Self.Move(PT);
Self.ButtonUp(btn);
end;
procedure TMouseObj.DragTo(Box:TBox; btn:TMouseButton); overload;
begin
Self.ButtonDown(btn);
Self.Move(Box);
Self.ButtonUp(btn);
end;
procedure TMouseObj.Scroll(x,y:Int32; Lines:UInt32);
begin
ScrollMouse(x,y,lines);
end;
{$IFNDEF CODEINSIGHT}
(*
Moves the mouse from current position to the given postion (xe,ye)
This function is based of BenLand100`s "windMouse", and released under the GNU-GPL v3.
https://github.com/BenLand100/SMART
All right of this function therefore goes to Benjamin Land.
Modifications made:
- Slows down gradually once it's close to the target.
*)
procedure TMouseObj.__mouseMove(xe,ye, Gravity, wind, meanWait, stdWait, maxStep, targetArea:Double);
var
sqrt3,sqrt5,dist,step,randomDist,xs,ys:Double;
veloX, veloY, veloMag, windX, windY, Base, w: Double;
mx,my,cx,cy,i:Int32;
begin
sqrt3 := Sqrt(3);
sqrt5 := Sqrt(5);
GetMousePos(cx,cy);
xs := cx; ys := cy;
veloX := 0; veloY := 0; windX := 0; windY := 0;
Base := Hypot(xs - xe,ys - ye);
repeat
dist := Hypot(xs - xe,ys - ye);
if dist <= 1 then Break;
wind := Double(minE(wind, dist));
if (dist >= targetArea) then begin
windX := windX / sqrt3 + (Random() * (wind * 2.0 + 1.0) - wind) / sqrt5;
windY := windY / sqrt3 + (Random() * (wind * 2.0 + 1.0) - wind) / sqrt5;
end else begin
windX := windX / sqrt3;
windY := windY / sqrt3;
if (maxStep < 3) then
maxStep = Random() * 3 + 3.0
else
maxStep := maxStep / sqrt5;
end;
veloX := veloX + windX + gravity * (xe - xs) / dist;
veloY := veloY + windY + gravity * (ye - ys) / dist;
veloMag := Hypot(veloX, veloY);
if (veloMag > maxStep) then
begin
randomDist := maxStep / 2.0 + Random() * maxStep / 2.0;
veloX := (veloX / veloMag) * randomDist;
veloY := (veloY / veloMag) * randomDist;
end;
xs := xs + veloX;
ys := ys + veloY;
mx := Round(xs);
my := Round(ys);
if (cx <> mx) or (cy <> my) then
MoveMouse(mx, my);
step := Hypot(xs - cx, ys - cy);
if (i mod Speed = 0) then begin
w := Rand.Gauss(2.0,stdWait);
if (dist < Base*0.1) then MaxStep := MaxE(MaxStep-0.05, 1.0);
Wait(Abs(Round(Min(Ceil(Pow((dist+20),-1.005)*667),20)+w)));
end;
inc(i);
until Hypot(xs - xe,ys - ye) <= 1;
MoveMouse(Round(xe), Round(ye));
end;
{$endif}
procedure TMouseObj.Move(TargetX, TargetY:Int32);
var f:Double;
begin
if Speed <= 0 then Speed := 7;
f := Rand.Gauss(0.9,0.25);
Self.__mouseMove(Targetx,Targety,8.9,3.0,3.0,1.0,2.0*f,8.0*f);
end;
procedure TMouseObj.Move(Target:TPoint); overload;
var f:Double;
begin
if Speed <= 0 then Speed := 7;
f := Rand.Gauss(0.9,0.25);
Self.__mouseMove(Target.x,Target.y,8.9,3.0,3.0,1.0,2.0*f,8.0*f);
end;
procedure TMouseObj.Move(Target:TPoint; Rx,Ry:Int32); overload;
var
f:Double;
rr: TPoint
begin
if Speed <= 0 then Speed := 7;
f := Rand.Gauss(0.9,0.25);
rr := rand.GaussPtOval(Target, Rx / 3.0, Ry / 3.0, Rx, Ry);
Self.__mouseMove(rr.x,rr.y,8.9,3.0,3.0,1.0,2.0*f,8.0*f);
end;
procedure TMouseObj.Move(Target:TBox); overload;
var
f:Double;
rr: TPoint;
begin
if Speed <= 0 then Speed := 7;
f := Rand.Gauss(0.9,0.20);
rr := rand.GaussPtOval(Target.Center(), Target.Width / 5.0, Target.Height / 5.0, Target.Width/2,Target.Height/2);
Self.__mouseMove(rr.x,rr.y,8.9,3.0,3.0,1.0,2.0*f,8.0*f);
end;
procedure TMouseObj.Click(btn:TMouseButton);
begin
Self.ButtonDown(btn);
Wait(Round(rand.Gauss(61,16)));
Self.ButtonUp(btn);
end;
procedure TMouseObj.Click(PT:TPoint; btn:TMouseButton); overload;
begin
Self.Move(PT);
Self.ButtonDown(btn);
Wait(Round(rand.Gauss(61,16)));
Self.ButtonUp(btn);
end;
procedure TMouseObj.Click(Box:TBox; btn:TMouseButton); overload;
var PT:TPoint;
begin
PT := rand.GaussPtOval(Box.Center(), Box.Width/5.0, Box.Height/5.0,
Box.Width/2.0, Box.Height/2.0);
Self.Move(PT);
Self.ButtonDown(btn);
Wait(Round(rand.Gauss(61,16)));
Self.ButtonUp(btn);
end;
procedure TMouseObj.ClickReturn(Box:TBox; btn:TMouseButton);
var S,PT:TPoint;
begin
S := Self.GetPosition();
PT := rand.GaussPtOval(Box.Center(), Box.Width/5.0, Box.Height/5.0,
Box.Width/2.0, Box.Height/2.0);
Self.Move(PT);
Self.ButtonDown(btn);
Wait(Round(rand.Gauss(61,16)));
Self.ButtonUp(btn);
Wait(Round(rand.Gauss(115,26)));
Self.Move(S);
end;
|
unit AvoidanceZoneActionsUnit;
interface
uses
SysUtils, BaseActionUnit,
AvoidanceZoneUnit, AvoidanceZoneQueryUnit;
type
TAvoidanceZoneActions = class(TBaseAction)
public
/// <summary
/// Create an Avoidance Zone
/// </summary
function Add(AvoidanceZone: TAvoidanceZone; out ErrorString: String): TAvoidanceZone;
/// <summary
/// Get a specified Avoidance Zone by Id.
/// </summary
function Get(TerritoryId: String; out ErrorString: String): TAvoidanceZone;
/// <summary
/// Get all of the Avoidance Zones defined by a user.
/// </summary
function GetList(out ErrorString: String): TAvoidanceZoneList;
/// <summary
/// Update a specified Avoidance Zone
/// </summary
function Update(AvoidanceZone: TAvoidanceZone; out ErrorString: String): TAvoidanceZone;
/// <summary
/// Delete a specified Avoidance Zone.
/// </summary
function Remove(TerritoryId: String; out ErrorString: String): boolean; overload;
/// <summary
/// Delete a specified Avoidance Zone.
/// </summary
function Remove(TerritoryIds: TArray<String>; out ErrorString: String): boolean; overload;
end;
implementation
{ TAvoidanceZoneActions }
uses
SettingsUnit, GenericParametersUnit;
function TAvoidanceZoneActions.Add(
AvoidanceZone: TAvoidanceZone; out ErrorString: String): TAvoidanceZone;
begin
Result := FConnection.Post(TSettings.EndPoints.Avoidance, AvoidanceZone,
TAvoidanceZone, ErrorString) as TAvoidanceZone;
end;
function TAvoidanceZoneActions.Remove(TerritoryId: String;
out ErrorString: String): boolean;
begin
Result := Remove([TerritoryId], ErrorString);
end;
function TAvoidanceZoneActions.Get(TerritoryId: String;
out ErrorString: String): TAvoidanceZone;
var
Query: TGenericParameters;
begin
Query := TGenericParameters.Create;
try
Query.AddParameter('territory_id', TerritoryId);
Result := FConnection.Get(TSettings.EndPoints.Avoidance, Query,
TAvoidanceZone, ErrorString) as TAvoidanceZone;
finally
FreeAndNil(Query);
end;
end;
function TAvoidanceZoneActions.GetList(out ErrorString: String): TAvoidanceZoneList;
var
Query: TGenericParameters;
begin
Query := TGenericParameters.Create;
try
Result := FConnection.Get(TSettings.EndPoints.Avoidance, Query,
TAvoidanceZoneList, ErrorString) as TAvoidanceZoneList;
if (Result = nil) then
Result := TAvoidanceZoneList.Create;
Result.OwnsObjects := True;
finally
FreeAndNil(Query);
end;
end;
function TAvoidanceZoneActions.Remove(TerritoryIds: TArray<String>;
out ErrorString: String): boolean;
var
Query: TGenericParameters;
i: integer;
AErrorString: String;
begin
ErrorString := EmptyStr;
Query := TGenericParameters.Create;
try
for i := 0 to High(TerritoryIds) do
begin
Query.ReplaceParameter('territory_id', TerritoryIds[i]);
FConnection.Delete(TSettings.EndPoints.Avoidance, Query, TAvoidanceZone, AErrorString);
if (AErrorString <> EmptyStr) then
ErrorString := ErrorString + '; ' + AErrorString;
end;
Result := (ErrorString = EmptyStr);
finally
FreeAndNil(Query);
end;
end;
function TAvoidanceZoneActions.Update(AvoidanceZone: TAvoidanceZone;
out ErrorString: String): TAvoidanceZone;
begin
Result := FConnection.Put(TSettings.EndPoints.Avoidance, AvoidanceZone,
TAvoidanceZone, ErrorString) as TAvoidanceZone;
end;
end.
|
unit umpgSendMail;
interface
uses
Classes, IdIOHandlerStack, IdSSLOpenSSL, IdBaseComponent, IdComponent,
IdTCPConnection, IdExplicitTLSClientServerBase, IdSMTP, IdMessage,
IdMessageParts;
type
// TmpgSendMailAttachment = record
// Attachment : TMemoryStream;
// ContentDisposition : string;
// ContentTransfer : string;
// FileName : string;
// Name : string;
// end;
TmpgSendMailRecipients = class(TObject)
Address : string;
Name : string;
end;
TmpgSendMailServerConfig = class(TObject)
Host : string;
Port : integer;
UserName : string;
UserPws : string;
end;
TmpgSendMailMessage = class(TObject)
Subject : string;
ContentType : string;
Body : string;
Date : TDateTime;
end;
TmpgSendMail = Class(TObject)
private
// FAttachment01: TmpgSendMailAttachment;
// FAttachment02: TmpgSendMailAttachment;
// FAttachment03: TmpgSendMailAttachment;
FbTestMode: boolean;
FFrom: TmpgSendMailRecipients;
FMessage: TmpgSendMailMessage;
FServer: TmpgSendMailServerConfig;
FTo: TmpgSendMailRecipients;
FUseTLS: TIdUseTLS;
IdHandlerSSL: TIdSSLIOHandlerSocketOpenSSL;
IdMessage: TIdMessage;
IdSMTP: TIdSMTP;
FOnAfterSend: TNotifyEvent;
function GetMessagePart: TIdMessageParts;
public
constructor Create(msgCharset: string); reintroduce;
destructor Destroy; override;
procedure SendMail;
// property Attachment01 : TmpgSendMailAttachment read FAttachment01 write FAttachment01;
// property Attachment02 : TmpgSendMailAttachment read FAttachment02 write FAttachment02;
// property Attachment03 : TmpgSendMailAttachment read FAttachment03 write FAttachment03;
property FromList : TmpgSendMailRecipients read FFrom write FFrom;
property Message : TmpgSendMailMessage read FMessage write FMessage;
property Server : TmpgSendMailServerConfig read FServer write FServer;
property TestMode : boolean read FbTestMode write FbTestMode;
property ToList : TmpgSendMailRecipients read FTo write FTo;
property UseTLS : TIdUseTLS read FUseTLS write FUseTLS;
property MessagePart : TIdMessageParts read GetMessagePart;
property OnAfterSend : TNotifyEvent read FOnAfterSend write FOnAfterSend;
end;
implementation
uses
IdAttachmentMemory, IdText, IdGlobal, SysUtils;
{ TmpgSendMail }
constructor TmpgSendMail.Create(msgCharset: string);
begin
inherited Create;
IdHandlerSSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
with IdHandlerSSL do
begin
Name := 'IdHandlerSSL';
Destination := ':25';
MaxLineAction := maException;
Port := 25;
DefaultPort := 0;
end;
IdSMTP := TIdSMTP.Create(nil);
IdSMTP.Name := 'IdSMTP';
IdSMTP.IOHandler := IdHandlerSSL;
IdMessage := TIdMessage.Create(nil);
with IdMessage do
begin
Name := 'IdMessage';
AttachmentEncoding := 'UUE';
CharSet := msgCharset;
ContentType := 'multipart/mixed';
Encoding := meMIME;
ConvertPreamble := True;
end;
// FAttachment01.ContentDisposition := 'attachment';
// FAttachment01.ContentTransfer := 'base64';
// FAttachment02.ContentDisposition := 'attachment';
// FAttachment02.ContentTransfer := 'base64';
// FAttachment03.ContentDisposition := 'attachment';
// FAttachment03.ContentTransfer := 'base64';
FFrom := TmpgSendMailRecipients.Create;
FMessage := TmpgSendMailMessage.Create;
FServer := TmpgSendMailServerConfig.Create;
FTo := TmpgSendMailRecipients.Create;
FMessage.ContentType := 'text/html';
end;
destructor TmpgSendMail.Destroy;
begin
IdMessage.Free;
IdSMTP.Free;
FFrom.Free;
FMessage.Free;
FServer.Free;
FTo.Free;
inherited;
end;
function TmpgSendMail.GetMessagePart: TIdMessageParts;
begin
result := IdMessage.MessageParts;
end;
procedure TmpgSendMail.SendMail;
var
// oAnexo : TIdAttachmentMemory;
aTexto : TIdText;
// procedure AddAttachment(pAttachment : TmpgSendMailAttachment);
// begin
// if Assigned(pAttachment.Attachment) then
// begin
// oAnexo.LoadFromStream(pAttachment.Attachment);
// oAnexo.Name := FAttachment01.Name;
// oAnexo.ContentDisposition := pAttachment.ContentDisposition;
// oAnexo.FileName := pAttachment.FileName;
// oAnexo.ContentTransfer := pAttachment.ContentTransfer;
// end;
// end;
begin
// oAnexo := TIdAttachmentMemory.Create(IdMessage.MessageParts);
aTexto := TIdText.Create(IdMessage.MessageParts);
try
//Anexos
// AddAttachment(FAttachment01);
// AddAttachment(FAttachment02);
// AddAttachment(FAttachment03);
//Configuraзхes do servidor
IdSMTP.Host := FServer.Host;
IdSMTP.Password := FServer.UserPws;
IdSMTP.UseTLS := FUseTLS;
IdSMTP.Port := FServer.Port;
IdSMTP.Username := FServer.UserName;
IdSMTP.ConnectTimeout:=10000;
IdSMTP.ReadTimeout:=10000;
//Corpo da mensagem
aTexto.Body.Text := FMessage.Body;
aTexto.ContentType := FMessage.ContentType;
IdMessage.Date := Now;
IdMessage.Subject := FMessage.Subject;
//From
IdMessage.From.Address := FFrom.Address;
IdMessage.From.Name := FFrom.Name;
//To
with IdMessage.Recipients.Add do
begin
if not(FbTestMode) then
Address := FTo.Address
else
Address := 'artem-xp@yandex.ru';//'ruscigno@gmail.com';
Name := FTo.Name;
end;
IdSMTP.Connect;
IdSMTP.Send(IdMessage); //
{ если ошибка Invalid codepage 20932 - установить кодовую страницу преобразования в языке панели управления }
IdSMTP.Disconnect;
if Assigned(FOnAfterSend) then
FOnAfterSend(Self);
finally
FreeAndNil(aTexto);
// FreeAndNil(oAnexo);
//Limpando resнduos
IdMessage.Recipients.Clear;
IdMessage.FromList.Clear;
IdMessage.MessageParts.Clear;
IdMessage.Body.Clear;
end;
end;
end.
|
unit UpdStat;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs,
DB, DBClient, MConnect, SConnect, ssSocketConnection, xClasses, xLog,
ExtCtrls, ssClientDataSet;
type
TsvcUpdateStat = class(TService)
SConn: TssSocketConnection;
tmrMain: TTimer;
Log: TxLog;
qMain: TxQueue;
cdsDB: TssClientDataSet;
procedure ServiceCreate(Sender: TObject);
procedure ServiceStart(Sender: TService; var Started: Boolean);
procedure ServiceStop(Sender: TService; var Stopped: Boolean);
procedure ServicePause(Sender: TService; var Paused: Boolean);
procedure ServiceShutdown(Sender: TService);
procedure ServiceContinue(Sender: TService; var Continued: Boolean);
procedure tmrMainTimer(Sender: TObject);
procedure qMainAction(AAction: TxQueueAction);
private
InProcess: Boolean;
public
function GetServiceController: TServiceController; override;
end;
var
svcUpdateStat: TsvcUpdateStat;
//=============================================================================
//=============================================================================
//=============================================================================
implementation
uses Registry, ok_svc_const, ssRegUtils;
{$R *.DFM}
//=============================================================================
function IntToStrEx(const AValue, ADigits: Integer): string;
var
S: string;
i, l: Integer;
begin
S := IntToStr(AValue);
L := Length(S);
for i := 1 to ADigits - l do S := '0' + S;
Result := S;
end;
//=============================================================================
procedure ServiceController(CtrlCode: DWord); stdcall;
begin
svcUpdateStat.Controller(CtrlCode);
end;
//=============================================================================
function TsvcUpdateStat.GetServiceController: TServiceController;
begin
Result := ServiceController;
end;
//=============================================================================
procedure TsvcUpdateStat.ServiceCreate(Sender: TObject);
begin
Log.FileName := ExtractFilePath(ParamStr(0)) + 'svcupdstat.log';
end;
//=============================================================================
procedure TsvcUpdateStat.ServiceStart(Sender: TService; var Started: Boolean);
begin
Log.Add('Update Statistics Service started');
tmrMain.Enabled := True;
Started := True;
end;
//=============================================================================
procedure TsvcUpdateStat.ServiceStop(Sender: TService; var Stopped: Boolean);
begin
Log.Add('Update Statistics Service stopped');
tmrMain.Enabled := False;
Stopped := True;
end;
//=============================================================================
procedure TsvcUpdateStat.ServicePause(Sender: TService; var Paused: Boolean);
begin
Log.Add('Update Statistics Service paused');
tmrMain.Enabled := False;
Paused := True;
end;
//=============================================================================
procedure TsvcUpdateStat.ServiceShutdown(Sender: TService);
begin
Log.Add('Update Statistics Service shutdowned');
end;
//=============================================================================
procedure TsvcUpdateStat.ServiceContinue(Sender: TService; var Continued: Boolean);
begin
Log.Add('Update Statistics Service continued');
tmrMain.Enabled := True;
Continued := True;
end;
//=============================================================================
procedure TsvcUpdateStat.tmrMainTimer(Sender: TObject);
var
h, min, sec, msec, d, m, y, h2, min2, sec2: Word;
FDBKey: string;
intTmp, i, DBID, intInterval: Integer;
strType: string;
dtTime, dtLastBackup: TDateTime;
lstKeys: TStringList;
begin
if (Status = csRunning) and not InProcess then begin
InProcess := True;
DecodeTime(Time, h, min, sec, msec);
DecodeDate(Date, y, m, d);
with TRegistry.Create do
try
lstKeys := TStringList.Create;
RootKey := HKEY_LOCAL_MACHINE;
if not OpenKey(BackupSvcRegKey, False) then Exit;
GetKeyNames(lstKeys);
CloseKey;
for i := 0 to lstKeys.Count - 1 do begin
FDBKey := lstKeys.Strings[i];
if OpenKey(BackupSvcRegKey + '\' + FDBKey, False) then begin
try
try
intTmp := ReadInteger('UpdIntervalValue');
if intTmp <= 0 then Continue;
strType := ReadString('UpdIntervalType');
dtTime := ReadDateTime('UpdTime');
try
dtLastBackup := ReadDateTime('UpdLastTime');
except
dtLastBackup := 0;
end;
DecodeTime(dtTime, h2, min2, sec2, msec);
intInterval := 1;
case strType[1] of
'D': intInterval := intTmp;
'W': intInterval := intTmp * 7;
'M': intInterval := intTmp * 30;
end;
{$IFDEF DEBUG}
Log.Add(DateTimeToStr(Now));
Log.Add(DateTimeToStr(dtLastBackup));
Log.Add(FloatToStr(Now - dtLastBackup));
{$ENDIF}
if (Now - dtLastBackup) > intInterval then begin
DBID := StrToInt(Copy(FDBKey, 3, Length(FDBKey) - 2));
if (h = h2) and (min = min2)// and (sec = sec2)
then begin
qMain.Add(0, DBID, 0);
end;
end;
finally
CloseKey;
end;
except
on e: exception do begin
Log.Add(e.message);
end;
end;
end;
end;
finally
Free;
lstKeys.Free;
end;
InProcess := False;
end;
// Log.Add('begin');
end;
//=============================================================================
procedure TsvcUpdateStat.qMainAction(AAction: TxQueueAction);
var
h, min, sec, msec, d, m, y: Word;
DBID, Res: Integer;
begin
try
SConn.Connected := True;
except
InProcess := False;
Log.Add('Error: could not connect to OK_Server');
Exit;
end;
cdsDB.Open;
if cdsDB.Locate('dbid', AAction.Param, []) then begin
Log.Add('Start updating statistics for database <' + cdsDB.FieldByName('desc').AsString + '>');
DBID := AAction.Param;
DecodeTime(Time, h, min, sec, msec);
DecodeDate(Date, y, m, d);
try
//Log.Add(BackupFile);
Res := SConn.AppServer.db_UpdateStat(DBID);
if Res = 0
then begin
Log.Add('Update statistics for database <' + cdsDB.FieldByName('desc').AsString + '> complete');
WriteToRegDate(BackupSvcRegKey + '\DB' + IntToStr(DBID), 'UpdLastTime', Now, HKEY_LOCAL_MACHINE);
end
else Log.Add('Error: Update statistics for database <' + cdsDB.FieldByName('desc').AsString + '> failed')
except
on E:Exception do begin
Log.Add('Error: ' + E.Message);
SConn.Connected := False;
end;
end;
end;
cdsDB.Close;
SConn.Connected := False;
end;
end.
|
unit UserList_Form;
{------------------------------------------------------------------------------}
{ Автор : Тучнин Д.А.; }
{ Начат : 15.08.2005 19.00; }
{ Модуль : enUserList; }
{ Описание : Форма для отображения списка пользователей; }
{------------------------------------------------------------------------------}
// $Id: UserList_Form.pas,v 1.37 2013/01/22 15:59:35 kostitsin Exp $
// $Log: UserList_Form.pas,v $
// Revision 1.37 2013/01/22 15:59:35 kostitsin
// [$424399029]
//
// Revision 1.36 2011/11/16 17:35:34 lulin
// {RequestLink:232098711}
//
// Revision 1.35 2010/09/10 11:29:34 lulin
// {RequestLink:197496539}.
//
// Revision 1.115 2010/09/10 10:29:25 lulin
// {RequestLink:197496539}.
//
// Revision 1.114 2010/08/31 12:46:15 lulin
// {RequestLink:224134305}.
//
// Revision 1.113 2010/02/26 06:41:29 oman
// - fix: {RequestLink:193134891}
//
// Revision 1.112 2009/12/07 19:10:33 lulin
// - удалил ненужный модуль.
//
// Revision 1.111 2009/12/03 14:33:05 lulin
// {RequestLink:172986031}.
//
// Revision 1.110 2009/12/02 17:21:47 lulin
// {RequestLink:172984885}.
//
// Revision 1.109 2009/11/18 13:06:13 lulin
// - используем базовые параметры операции.
//
// Revision 1.108 2009/11/17 18:11:04 lulin
// {RequestLink:159360578}. №58.
//
// Revision 1.107 2009/11/12 14:32:40 lulin
// - убираем возможность менять список параметров.
//
// Revision 1.106 2009/11/06 13:21:35 oman
// - fix: {RequestLink:168957117}
//
// Revision 1.105 2009/11/06 09:31:54 oman
// - fix: {RequestLink:168957117}
//
// Revision 1.104 2009/10/16 17:00:55 lulin
// {RequestLink:159360578}. №52.
//
// Revision 1.103 2009/10/01 19:12:08 lulin
// - параметризуем фабрики конечных форм приложения.
//
// Revision 1.102 2009/09/10 12:19:15 lulin
// - генерируем файл проекта.
//
// Revision 1.101 2009/07/31 17:30:11 lulin
// - убираем мусор.
//
// Revision 1.100 2009/04/28 11:59:12 oman
// - new: Делаем drop - [$127762671]
//
// Revision 1.99 2009/04/22 08:21:51 oman
// - new: Убираем назначение доступа к базам с пользователя - [$127762671]
//
// Revision 1.98 2009/04/16 06:57:08 oman
// - new: Вернули Удалить и Отключить - [$127762671]
//
// Revision 1.97 2009/04/15 10:09:59 oman
// - new: Подставляем в админ новое дерево - [$127762671]
//
// Revision 1.96 2009/02/20 18:50:47 lulin
// - <K>: 136941122. Убираем передачу параметров при запросе состояния операции.
//
// Revision 1.95 2009/02/12 10:07:31 oman
// - fix: Пишем имя файла (К-104431648)
//
// Revision 1.94 2009/02/12 09:59:39 oman
// - fix: Может приехать пустой ds (К-136268640)
//
// Revision 1.93 2009/02/12 09:36:42 oman
// - fix: Может приехать пустой ds (К-136268640)
//
// Revision 1.92 2009/02/10 19:03:38 lulin
// - <K>: 133891247. Вычищаем морально устаревший модуль.
//
// Revision 1.91 2009/02/10 15:43:34 lulin
// - <K>: 133891247. Выделяем интерфейсы локализации.
//
// Revision 1.90 2009/01/30 13:51:33 lulin
// - чистка кода.
//
// Revision 1.89 2008/12/29 16:40:55 lulin
// - <K>: 134316705.
//
// Revision 1.88 2008/12/24 19:49:23 lulin
// - <K>: 121153186.
//
// Revision 1.87 2008/12/22 18:15:28 lulin
// - <K>: 128288718.
//
// Revision 1.86 2008/12/22 17:51:14 lulin
// - <K>: 128288718. Первый взлёт.
//
// Revision 1.85 2008/12/19 12:41:50 lulin
// - <K>: 128288713. Подкладываем под форму контроллер области ввода.
//
// Revision 1.84 2008/12/19 09:59:47 lulin
// - <K>: 128288713. Хак для того, чтобы наследоваться от сгенерированных форм.
//
// Revision 1.83 2008/12/17 14:20:14 lulin
// - отказ от наследования, т.к. Delphi это не понимает.
//
// Revision 1.82 2008/12/17 14:18:43 lulin
// - <K>: 128288713.
//
// Revision 1.81 2008/12/08 09:33:07 lulin
// - <K>: 128292941.
//
// Revision 1.80 2008/11/19 19:18:48 lulin
// - <K>: 124944838.
//
// Revision 1.79 2008/10/21 09:38:31 oman
// - fix: Неверно отдавали операцию контролу (К-121156669)
//
// Revision 1.78 2008/10/21 08:52:22 oman
// - fix: Неверно перефильтровывали (К-121156848)
//
// Revision 1.77 2008/09/16 09:17:18 oman
// - fix: Открываем операцию (К-116851579)
//
// Revision 1.76 2008/07/22 10:42:47 oman
// - new: Отключение пищалки - везде кроме КЗ (К-103940886)
//
// Revision 1.75 2008/06/23 10:36:15 oman
// - new: Меняем доступ из списка пользователей (cq29373)
//
// Revision 1.74 2008/03/18 09:21:14 lulin
// - <K>: 87197434.
//
// Revision 1.73 2008/01/26 11:48:43 mmorozov
// - new: реализация отложенного обновления связанного с деревом представления при смене текущего (K<79858456>).
//
// Revision 1.72 2008/01/10 07:23:06 oman
// Переход на новый адаптер
//
// Revision 1.71 2007/12/25 11:32:02 mmorozov
// - new: подписка на обновление данных приложения (CQ: OIT5-27823);
//
// Revision 1.70 2007/12/21 07:12:28 mmorozov
// - new: подписка на уведомление об обновлении данных (CQ: OIT5-27823);
//
// Revision 1.69 2007/12/03 12:12:56 oman
// - fix: Контекстно запрещаем привилегированность для
// одиночного пользователя (cq27766)
//
// Revision 1.68 2007/11/16 13:09:37 oman
// - new: операции для привилегированных пользователей стали
// негрупповыми (cq27255)
//
// Revision 1.67 2007/11/15 12:33:40 oman
// - new: Групповые операции для привилегированных пользователей (cq27255)
//
// Revision 1.66 2007/11/15 07:39:11 oman
// - new: Заготовка для новых иконок (cq27255)
//
// Revision 1.65 2007/11/14 15:06:50 oman
// - new: Корректируем список фильтров на переключении баз (cq27255)
//
// Revision 1.64 2007/10/17 11:12:56 oman
// - fix: Более правильно публикуем операции (cq27106)
//
// Revision 1.63 2007/09/25 03:58:29 mmorozov
// - new behaviour: для чтения\изменения текущего выбранного значения для операций типа vcm_otDate, vcm_otCombo, vcm_otEditCombo используем свойство параметров _SelectedString, раньше Caption. Тем самым Caption для этих типов операций стал изменяемым (в рамках работы CQ: OIT5-26741);
//
// Revision 1.62 2007/07/30 07:01:07 oman
// - new: Контекстное меню для администратора (cq25987)
//
// Revision 1.61 2007/06/21 12:00:55 mmorozov
// - new: запрет авторегистрации (CQ: OIT5-25328);
//
// Revision 1.60 2007/06/13 09:21:29 oman
// - fix: Перепутаны состояния операции местами
//
// Revision 1.59 2007/06/05 12:20:01 oman
// - fix: Не было обработки исключения (cq25571)
//
// Revision 1.58 2007/05/24 14:13:28 oman
// - new: Мультиоперации в администраторе (удалить, права на консалтинг
// и отключить) (cq25336)
//
// Revision 1.57 2007/05/22 13:57:05 oman
// - fix: При выводе информации в статусбар не учитывали возможность
// отфильтровать все (cq25381)
//
// Revision 1.56 2007/05/04 11:39:18 mmorozov
// - new: запрет авторегистрации (CQ: OIT5-25217);
//
// Revision 1.55 2007/04/10 07:42:18 oman
// - fix: Более гуманно подсчитываем число пользователей и групп (cq24954)
//
// Revision 1.54 2007/04/10 07:22:47 oman
// - new: Выводим информацию в статусной строке для списка
// пользователей в админе (cq24954)
//
// Revision 1.53 2007/04/05 10:22:36 lulin
// - избавляемся от лишних преобразований строк.
//
// Revision 1.52 2007/04/02 07:40:42 oman
// - fix: Вернул обратно ResetData
//
// Revision 1.51 2007/03/22 10:12:06 oman
// - new: Реакция на переключение баз - первое приближение (cq24456)
//
// Revision 1.50 2007/03/21 15:52:43 oman
// - new: Новое свойство ContextFilterTarget
// Более адекватное обновление IsContextWrong
// Реакция на внешнее изменение параметров контекстной
// фильтрации (cq24456)
//
// Revision 1.49 2007/03/20 09:13:32 oman
// - new: Поддержка "внешнего ввода" в контекстный фильтр от
// дерева (cq24456)
//
// Revision 1.48 2007/03/19 11:35:26 lulin
// - разделяем приведение к строке для форматирования и для исключения.
//
// Revision 1.47 2007/03/19 10:49:23 oman
// - new: Дерево пользователей переведно на новый фильтр (cq24456)
//
// Revision 1.46 2007/03/16 13:34:32 oman
// cleanup
//
// Revision 1.45 2007/03/16 07:48:30 oman
// - new: Положили новый контекстный фильтр (cq24456)
//
// Revision 1.44 2007/03/05 11:30:46 oman
// - fix: Опечатка в названии константы
//
// Revision 1.43 2007/02/13 14:33:23 lulin
// - cleanup.
//
// Revision 1.42 2007/02/13 12:08:53 lulin
// - переводим на строки с кодировкой.
//
// Revision 1.41 2007/02/12 16:39:07 lulin
// - переводим на строки с кодировкой.
//
// Revision 1.40 2007/02/07 19:13:33 lulin
// - переводим мапы на строки с кодировкой.
//
// Revision 1.39 2007/01/30 15:24:21 lulin
// - текст ноды - теперь более простого типа.
//
// Revision 1.38 2007/01/26 14:34:22 lulin
// - поправил обращение к неправильному параметру.
//
// Revision 1.37 2007/01/17 14:03:00 lulin
// - вычищены последние нефиксированные параметры в тестах операций.
//
// Revision 1.36 2007/01/16 14:13:16 lulin
// - избавляемся от нефиксированного параметра - заголовка операции.
//
// Revision 1.35 2007/01/10 13:58:52 lulin
// - от параметра по индексу переходим к свойству в параметрах операции.
//
// Revision 1.34 2006/12/22 15:06:31 lulin
// - текст ноды - теперь структура с длиной и кодовой страницей.
//
// Revision 1.33 2006/12/20 13:34:14 lulin
// - удален ненужный модуль.
//
// Revision 1.32 2006/12/05 14:15:51 lulin
// - контрол переехал в визуальную библиотеку.
//
// Revision 1.31 2006/12/05 13:49:54 lulin
// - контрол переехал в визуальную библиотеку.
//
// Revision 1.30 2006/11/27 10:35:25 mmorozov
// - MERGE WITH B_NEMESIS_6_4;
//
// Revision 1.29 2006/11/10 16:00:03 oman
// Merge from B_NEMESIS_6_4
//
// Revision 1.28 2006/11/03 09:45:58 oman
// Merge with B_NEMESIS_6_4_0
//
// Revision 1.27.4.1.2.2 2006/11/10 11:36:39 oman
// - fix: Не обновлялись свойства пользователя (cq23515)
//
// Revision 1.27.4.1.2.1 2006/11/08 15:29:10 oman
// - new: Новые операции по запрету платных консультаций (cq23515)
//
// Revision 1.27.4.1 2006/10/25 07:29:52 oman
// Продолжаем избавлятся от StdStr
//
// Revision 1.27 2006/04/17 07:18:55 oman
// - change: Избавляем бизнес-объекты (слой модели) от обязательств
// контроллера (хинты, imageindex)
// - new beh: перекладываем StdStr в _StdRes
//
// Revision 1.26 2006/04/12 13:15:09 oman
// - change: перевод механизма локализации строк на использование фабрик
// - new beh: Локализация nsc
//
// Revision 1.25 2006/04/03 12:01:55 oman
// - new beh: Перевод на механизм мап "строка для отображения в UI"-<нечто>.
//
// Revision 1.24 2006/03/31 07:42:17 lulin
// - изменен тип параметров, подаваемый в Execte операции.
//
// Revision 1.23 2006/03/30 15:31:31 lulin
// - изменен тип параметров в _OnTest.
//
// Revision 1.22 2006/03/24 15:11:15 oman
// - new beh: переход с _OnTest на OnGetState для операций
//
// Revision 1.21 2006/03/20 09:27:58 oman
// - new beh: Перекладываем все текстовые константы в три места (StdStr, DebugStr и SystemStr)
//
// Revision 1.20 2006/03/13 15:00:43 mmorozov
// - new behaviour: не держим бизнес объект на форме всегда получаем его из _DataSource формы;
//
// Revision 1.19 2005/11/24 15:49:02 oman
// - new behavior: избавление отIProfileNodeNew, поддержка состояния
// "пользователь отключается"
//
// Revision 1.18 2005/11/22 11:05:37 oman
// - fix: При хождении по истрии не сохранялся фильтр
//
// Revision 1.17 2005/10/21 12:03:08 lulin
// - вычищено использование реализации ImageList'ов в интерфейсах бизнес-объектов.
//
// Revision 1.16 2005/09/28 18:15:07 mmorozov
// new: в событии ChangedDataSource появился параметр aFromHistory;
//
// Revision 1.15 2005/09/02 12:59:31 demon
// - new behavior: добавлен запрет на удаление системмных пользователей
//
// Revision 1.14 2005/09/02 12:34:48 demon
// - new behavior: Запрещено удаление активного пользователя
//
// Revision 1.13 2005/08/31 15:32:39 demon
// - fix: неверный хинт к операции "Удалить пользователя"
//
// Revision 1.12 2005/08/30 13:00:40 demon
// - new icons: для Администратора пользователей
//
// Revision 1.11 2005/08/22 16:36:10 demon
// - new behavior: реализована операция фильтрации дерева пользователей
//
// Revision 1.10 2005/08/19 16:42:26 demon
// - new behavior: добавлена операция отключения пользователя
//
// Revision 1.9 2005/08/19 15:24:28 demon
// - new behavior: реализована операция создания нового пользователя
//
// Revision 1.8 2005/08/19 14:08:53 demon
// - new behavior: добавлена операция создания нового пользователя
//
// Revision 1.7 2005/08/19 11:17:56 demon
// - new behavior: подтверждение при удалении пользователя
//
// Revision 1.6 2005/08/19 10:51:03 demon
// - new behavior: Удаление пользователя
//
// Revision 1.5 2005/08/18 13:48:11 demon
// - new behavior: реализовано перечитывание дерева пользователей с сохранением текущего
//
// Revision 1.4 2005/08/16 16:28:55 demon
// - new behavior: обработка смены текущего элемента
//
// Revision 1.3 2005/08/16 13:20:48 demon
// - new behavior: Сохранение/загрузка в историю FormDataSource
//
// Revision 1.2 2005/08/16 11:41:10 demon
// - new behavior: подключена базовая реализация работы с деревом (показ иконок)
//
// Revision 1.1 2005/08/15 18:18:41 demon
// - new behavior: формы для интерфейса администратора
//
interface
uses
Windows,
Messages,
SysUtils,
Classes,
Graphics,
Controls,
Forms,
Dialogs,
ImgList,
l3Interfaces,
l3TreeInterfaces,
l3Types,
OvcBase,
afwInputControl,
afwControl,
vtLister,
vtOutliner,
vtOutlinerWithQuickSearch,
vtOutlinerWithDragDrop,
vtPanel,
eeTreeViewExport,
eeTreeView,
vcmInterfaces,
vcmBase,
vcmEntityForm,
vcmEntities,
vcmComponent,
vcmBaseEntities,
vcmExternalInterfaces,
nscContextFilter,
afwControlPrim, afwBaseControl, afwTextControlPrim,
afwTextControl,
L10nInterfaces,
AdminInterfaces,
l3InterfacedComponent,
PrimUserListOptions_Form
;
type
TefUserList = class(TvcmEntityFormRef)
Entities : TvcmEntities;
BackgroundPanel: TvtPanel;
ContextFilter: TnscContextFilter;
trUserList: TeeTreeView;
procedure vcmEntityFormChangedDataSource(aSender: TObject;
const aOld, aNew: IvcmFormDataSource;
const aFromHistory : Boolean);
function trUserListGetItemImage(Sender: TObject; Index: Integer;
var aImages: TCustomImageList): Integer;
procedure trUserListCurrentChanged(Sender: TObject; aNewCurrent,
aOldCurrent: Integer);
procedure vcmEntityFormInit;
procedure ContextFilterChange(Sender: TObject);
procedure trUserListNewCharPressed(aChar: Char);
procedure trUserListCountChanged(Sender: TObject; NewCount: Integer);
procedure trUserListSelectCountChanged(aSender: TObject; anOldCount,
aNewCount: Integer);
procedure trUserListFormatStatusInfo(aSender: TObject;
var Info: Il3CString; const aCurrent, aCount, aSelected: Integer);
procedure trUserListTreeChanged(aSender: TObject; const anOldTree,
aNewTree: Il3SimpleTree);
procedure ContextFilterWrongContext(Sender: TObject);
end;
implementation
{$R *.DFM}
uses
l3String,
l3Base,
l3Utils,
eeInterfaces,
bsTypes,
dsForbidAutoregistration,
nsTypes,
nsValueMapsIDs,
nsValueMaps,
nsTreeUtils,
nsUtils,
DataAdapter,
GBLAdapter,
SecurityUnit,
StdRes,
AdminRes
;
procedure TefUserList.vcmEntityFormChangedDataSource(aSender: TObject;
const aOld, aNew: IvcmFormDataSource;
const aFromHistory : Boolean);
var
l_CurrentNode: IdeNode;
l_Current: LongInt;
begin
if Assigned(ViewArea) then
begin
l_CurrentNode := ViewArea.GetFrosenNode(trUserList.GetCurrentNode);
with trUserList do
begin
Images := ViewArea.ImageList.Hack;
if not aFromHistory then
begin
TreeStruct := ViewArea.SimpleTree;
ContextFilter.AssignState(ViewArea.CurrentContextFilter);
end;
UpdateStatusInfo;
if Assigned(l_CurrentNode) then
begin
// Дерево перегружают надо восстановить текущий и уведомить других об этом
l_Current := ViewArea.FindFrosenNode(l_CurrentNode, ShowRoot);
if l_Current >= 0 then
Current := l_Current;
ViewArea.CurrentChanged(trUserList.GetCurrentNode);
end;
end;
ContextFilter.UpdateIsContextWrong;
end;
end;
function TefUserList.trUserListGetItemImage(Sender: TObject;
Index: Integer;
var aImages: TCustomImageList): Integer;
const
cImageIndexMap: array [TbsUserNodeType] of Integer = (
ciiUser, // untUnknownUser,
ciiAdmin, // untActiveSystem,
ciiUser, // untActiveNonSystem,
ciiAdmin_NA, // untInactiveSystem,
ciiUser_NA, // untInactiveNonSystem,
ciiExiting, // untExiting
ciiPriveleged, // untActivePrivileged
ciiPriveleged_NA // untInActivePrivileged
);
begin
if Assigned(ViewArea) then
Result := cImageIndexMap[ViewArea.UserListNodeType(trUserList.GetNode(Index))]
else
Result := ciiUser_NA;
end;
procedure TefUserList.trUserListCurrentChanged(Sender: TObject;
aNewCurrent, aOldCurrent: Integer);
begin
UpdateCurrent;
end;
procedure TefUserList.vcmEntityFormInit;
begin
ContextFilter.Images := dmStdRes.SmallImageList;
UpdateStatusInfo;
end;
procedure TefUserList.ContextFilterChange(Sender: TObject);
var
l_TreeSource: Il3SimpleTree;
l_Current: Integer;
begin
with trUserList do
begin
l_TreeSource := ViewArea.FiltrateByContext(TreeStruct, GetCurrentNode,
ContextFilter.MakeState, l_Current);
if Assigned(l_TreeSource) and (l_TreeSource.CountView > 0) then
begin
Changing;
try
LockChangeSelected;
try
TreeStruct := l_TreeSource;
finally
UnLockChangeSelected;
end;
finally
Changed;
end;
Current := l_Current;
end;
end;
end;
procedure TefUserList.trUserListNewCharPressed(aChar: Char);
begin
ContextFilter.PressChar(aChar);
end;
procedure TefUserList.trUserListCountChanged(Sender: TObject;
NewCount: Integer);
begin
UpdateStatusInfo;
end;
procedure TefUserList.trUserListSelectCountChanged(aSender: TObject;
anOldCount, aNewCount: Integer);
begin
UpdateStatusInfo;
end;
procedure TefUserList.trUserListFormatStatusInfo(aSender: TObject;
var Info: Il3CString; const aCurrent, aCount, aSelected: Integer);
begin
if trUserList.TreeStruct.RootNode.HasChild then
Info := vcmFmt(vcmCStr(str_UserListStatus),[trUserList.TreeStruct.RootNode.ThisChildrenCount, aSelected])
else
Info := nil;
end;
procedure TefUserList.trUserListTreeChanged(aSender: TObject;
const anOldTree, aNewTree: Il3SimpleTree);
begin
UpdateStatusInfo;
end;
procedure TefUserList.ContextFilterWrongContext(Sender: TObject);
begin
nsBeepWrongContext;
end;
end. |
unit ce_observer;
{$I ce_defines.inc}
interface
uses
Classes, SysUtils, Contnrs;
type
(**
* interface for a single Coedit service (many to one relation).
* A service is valid during the whole application life-time and
* is mostly designed to avoid messy uses clauses or to limit
* the visibility of the implementer methods.
*)
ICESingleService = interface
function singleServiceName: string;
end;
(**
* Manages the connections between the observers and their subjects in the
* whole program.
*)
TCEEntitiesConnector = class
private
fObservers: TObjectList;
fSubjects: TObjectList;
fServices: TObjectList;
fUpdatesCount: Integer;
procedure tryUpdate;
procedure updateEntities;
function getIsUpdating: boolean;
public
constructor Create;
destructor Destroy; override;
// forces the update, fixes begin/add pair error or if immediate update is needed.
procedure forceUpdate;
// entities will be added in bulk, must be followed by an enUpdate().
procedure beginUpdate;
// entities has ben added in bulk
procedure endUpdate;
// add/remove entities, update is automatic
procedure addObserver(anObserver: TObject);
procedure addSubject(aSubject: TObject);
procedure removeObserver(anObserver: TObject);
procedure removeSubject(aSubject: TObject);
// allow to register a single service provider.
procedure addSingleService(aServiceProvider: TObject);
// allow to retrieve a single service provider based on its interface name
function getSingleService(const aName: string): TObject;
// should be tested before forceUpdate()
property isUpdating: boolean read getIsUpdating;
end;
(**
* Interface for a Coedit subject. Basically designed to hold a list of observer
*)
ICESubject = interface
// an observer is proposed. anObserver is not necessarly compatible.
procedure addObserver(anObserver: TObject);
// anObserver must be removed.
procedure removeObserver(anObserver: TObject);
// optionally implemented to trigger all the methods of the observer interface.
procedure updateObservers;
end;
(**
* Standard implementation of an ICESubject.
* Any descendant adds itself to the global EntitiesConnector.
*)
TCECustomSubject = class(ICESubject)
protected
fObservers: TObjectList;
// test for a specific interface when adding an observer.
function acceptObserver(aObject: TObject): boolean; virtual;
function getObserversCount: Integer;
function getObserver(index: Integer): TObject;
public
constructor Create; virtual;
destructor Destroy; override;
//
procedure addObserver(anObserver: TObject);
procedure removeObserver(anObserver: TObject);
procedure updateObservers; virtual;
//
property observersCount: Integer read getObserversCount;
property observers[index: Integer]: TObject read getObserver; default;
end;
var
EntitiesConnector: TCEEntitiesConnector = nil;
implementation
uses
LCLProc;
{$REGION TCEEntitiesConnector --------------------------------------------------}
constructor TCEEntitiesConnector.Create;
begin
fObservers := TObjectList.Create(False);
fSubjects := TObjectList.Create(False);
fServices := TObjectList.Create(False);
end;
destructor TCEEntitiesConnector.Destroy;
begin
fObservers.Free;
fSubjects.Free;
fServices.Free;
inherited;
end;
function TCEEntitiesConnector.getIsUpdating: boolean;
begin
exit(fUpdatesCount > 0);
end;
procedure TCEEntitiesConnector.tryUpdate;
begin
{$IFDEF DEBUG}
if fUpdatesCount > 0 then
DebugLn('saved uselless update in TCEEntitiesConnector')
else
DebugLn('efficient update in TCEEntitiesConnector');
{$ENDIF}
if fUpdatesCount <= 0 then
updateEntities;
end;
procedure TCEEntitiesConnector.forceUpdate;
begin
updateEntities;
end;
procedure TCEEntitiesConnector.updateEntities;
var
i, j: Integer;
begin
fUpdatesCount := 0;
for i := 0 to fSubjects.Count - 1 do
begin
if not (fSubjects[i] is ICESubject) then
continue;
for j := 0 to fObservers.Count - 1 do
begin
if fSubjects[i] <> fObservers[j] then
(fSubjects[i] as ICESubject).addObserver(fObservers[j]);
end;
end;
end;
procedure TCEEntitiesConnector.beginUpdate;
begin
fUpdatesCount += 1;
end;
procedure TCEEntitiesConnector.endUpdate;
begin
fUpdatesCount -= 1;
tryUpdate;
end;
procedure TCEEntitiesConnector.addObserver(anObserver: TObject);
begin
if fObservers.IndexOf(anObserver) <> -1 then
exit;
fObservers.Add(anObserver);
tryUpdate;
end;
procedure TCEEntitiesConnector.addSubject(aSubject: TObject);
begin
if (aSubject as ICESubject) = nil then
exit;
if fSubjects.IndexOf(aSubject) <> -1 then
exit;
fSubjects.Add(aSubject);
tryUpdate;
end;
procedure TCEEntitiesConnector.removeObserver(anObserver: TObject);
var
i: Integer;
begin
fObservers.Remove(anObserver);
for i := 0 to fSubjects.Count - 1 do
if fSubjects[i] <> nil then
(fSubjects[i] as ICESubject).removeObserver(anObserver);
tryUpdate;
end;
procedure TCEEntitiesConnector.removeSubject(aSubject: TObject);
begin
fSubjects.Remove(aSubject);
tryUpdate;
end;
procedure TCEEntitiesConnector.addSingleService(aServiceProvider: TObject);
begin
if fServices.IndexOf(aServiceProvider) <> -1 then
exit;
if not (aServiceProvider is ICESingleService) then
exit;
fServices.Add(aServiceProvider);
end;
function TCEEntitiesConnector.getSingleService(const aName: string): TObject;
var
i: Integer;
serv: ICESingleService;
begin
Result := nil;
for i := 0 to fServices.Count - 1 do
begin
serv := fServices[i] as ICESingleService;
if serv.singleServiceName = aName then
exit(fServices[i]);
end;
end;
{$ENDREGION}
{$REGION TCECustomSubject ------------------------------------------------------}
constructor TCECustomSubject.Create;
begin
fObservers := TObjectList.Create(False);
EntitiesConnector.addSubject(Self);
end;
destructor TCECustomSubject.Destroy;
begin
EntitiesConnector.removeSubject(Self);
fObservers.Free;
Inherited;
end;
function TCECustomSubject.acceptObserver(aObject: TObject): boolean;
begin
exit(False);
end;
function TCECustomSubject.getObserversCount: Integer;
begin
exit(fObservers.Count);
end;
function TCECustomSubject.getObserver(index: Integer): TObject;
begin
exit(fObservers.Items[index]);
end;
procedure TCECustomSubject.addObserver(anObserver: TObject);
begin
if not acceptObserver(anObserver) then
exit;
if fObservers.IndexOf(anObserver) <> -1 then
exit;
fObservers.Add(anObserver);
end;
procedure TCECustomSubject.removeObserver(anObserver: TObject);
begin
fObservers.Remove(anObserver);
end;
procedure TCECustomSubject.updateObservers;
begin
end;
{$ENDREGION}
initialization
EntitiesConnector := TCEEntitiesConnector.Create;
EntitiesConnector.beginUpdate;
finalization
EntitiesConnector.Free;
EntitiesConnector := nil;
end.
|
unit ItemsFRM;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Data.DB, Vcl.Grids, Vcl.DBGrids,
ItemController, System.Actions, Vcl.ActnList, VirtualTrees, Vcl.StdCtrls,
Vcl.ExtCtrls, System.UITypes;
type
TfrmItems = class(TForm)
pnlActions: TPanel;
btnAdd: TButton;
btnEdit: TButton;
btnDelete: TButton;
btnClose: TButton;
ItemsTree: TVirtualStringTree;
ActionList: TActionList;
FilterAction: TAction;
ResetFilterAction: TAction;
AddAction: TAction;
EditAction: TAction;
DeleteAction: TAction;
CancelAction: TAction;
PrintAction: TAction;
DesignAction: TAction;
FindPatientAction: TAction;
ClearPatientAction: TAction;
PreviewAction: TAction;
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure btnAddClick(Sender: TObject);
procedure btnEditClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure btnCloseClick(Sender: TObject);
procedure ItemsTreeDblClick(Sender: TObject);
procedure ItemsTreeGetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
Column: TColumnIndex; TextType: TVSTTextType; var CellText: string);
procedure ItemsTreeInitNode(Sender: TBaseVirtualTree; ParentNode,
Node: PVirtualNode; var InitialStates: TVirtualNodeInitStates);
private
{ Private declarations }
FItemController: TItemController;
FIsLookUp: boolean;
procedure ItemControllerListChanged(ASender: TObject);
function ShowAddNewItem: boolean;
function GetSelectedItem: TItem;
public
{ Public declarations }
property SelectedItem: TItem read GetSelectedItem;
property IsLookUp: boolean read FIsLookUp write FIsLookUp;
end;
implementation
uses
ItemDetailsFRM;
{$R *.dfm}
procedure TfrmItems.FormCreate(Sender: TObject);
begin
FItemController := TItemController.Create;
FItemController.OnListChanged := ItemControllerListChanged;
ItemsTree.NodeDataSize := SizeOf(TItem);
FItemController.LoadItems;
end;
procedure TfrmItems.FormDestroy(Sender: TObject);
begin
FItemController.Free;
end;
procedure TfrmItems.FormShow(Sender: TObject);
begin
if ItemsTree.CanFocus then
ItemsTree.SetFocus;
pnlActions.Visible := not IsLookUp;
end;
procedure TfrmItems.btnAddClick(Sender: TObject);
begin
if ShowAddNewItem then
FItemController.LoadItems;
end;
procedure TfrmItems.btnEditClick(Sender: TObject);
var
LItemDetailsFRM: TfrmItemDetails;
LItem: TItem;
begin
if not Assigned(ItemsTree.FocusedNode) then
Exit;
LItem := ItemsTree.FocusedNode.GetData<TItem>;
LItemDetailsFRM := TfrmItemDetails.Create(nil);
try
LItemDetailsFRM.Item := LItem;
if LItemDetailsFRM.ShowModal = mrOK then
begin
FItemController.EditItem(LItem);
FItemController.LoadItems;
end;
finally
LItemDetailsFRM.Free;
end;
end;
procedure TfrmItems.btnCloseClick(Sender: TObject);
begin
Close;
end;
procedure TfrmItems.btnDeleteClick(Sender: TObject);
var
LNode: PVirtualNode;
LItem: TItem;
begin
LNode := ItemsTree.FocusedNode;
if Assigned(LNode) then
begin
LItem := LNode.GetData<TItem>;
if MessageDlg('Are you sure to delete the Item for ItemId ' +
IntToStr(LItem.ItemId) + '?', mtConfirmation, [mbYes, mbNo], 0) = mrYes
then
begin
FItemController.DeleteItem(LItem);
end;
end;
end;
procedure TfrmItems.ItemsTreeDblClick(Sender: TObject);
begin
if IsLookUp then
ModalResult := mrOk
else
btnEditClick(Sender);
end;
procedure TfrmItems.ItemsTreeGetText(Sender: TBaseVirtualTree;
Node: PVirtualNode; Column: TColumnIndex; TextType: TVSTTextType;
var CellText: string);
var
LItem: TItem;
begin
LItem := Node.GetData<TItem>;
case Column of
0:
CellText := IntToStr(LItem.ItemId);
1:
CellText := LItem.ItemName;
2:
CellText := LItem.ItemDescription;
end;
end;
procedure TfrmItems.ItemsTreeInitNode(Sender: TBaseVirtualTree; ParentNode,
Node: PVirtualNode; var InitialStates: TVirtualNodeInitStates);
begin
Node.SetData<TItem>(FItemController.ItemList[Node.Index]);
end;
function TfrmItems.ShowAddNewItem: boolean;
var
LItemDetailsFRM: TfrmItemDetails;
LItem: TItem;
begin
result := false;
LItemDetailsFRM := TfrmItemDetails.Create(nil);
LItemDetailsFRM.ItemMode := smNew;
try
LItem := TItem.Create;
LItemDetailsFRM.Item := LItem;
if LItemDetailsFRM.ShowModal = mrOK then
begin
// LItem := TItem.Create;
// LItem.ItemId := StrToInt(LItemDetailsFRM.edtItemId.Text);
// LItem.ItemName := LItemDetailsFRM.edtItemName.Text;
// LItem.ItemDescription := LItemDetailsFRM.edtItemId.Text;
FItemController.AddItem(LItem);
result := True;
end;
finally
LItemDetailsFRM.Free;
end;
end;
procedure TfrmItems.ItemControllerListChanged(ASender: TObject);
begin
ItemsTree.RootNodeCount := FItemController.ItemList.Count;
ItemsTree.ReinitNode(nil, True);
end;
function TfrmItems.GetSelectedItem: TItem;
var
LNode: PVirtualNode;
begin
result := nil;
LNode := ItemsTree.FocusedNode;
if Assigned(LNode) then
begin
result := LNode.GetData<TItem>;
end;
end;
end.
|
unit GX_MultiLinePalette;
{$I GX_CondDefine.inc}
interface
uses
Classes;
type
TMultiLineTabManager = class(TComponent)
private
FOldCPResizeHandler: TNotifyEvent;
procedure CPResizeHandler(Sender: TObject);
private
FTabRaggedRight: Boolean;
FTabScrollOpposite: Boolean;
procedure SetTabRaggedRight(const Value: Boolean);
procedure SetTabScrollOpposite(const Value: Boolean);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
property TabRaggedRight: Boolean read FTabRaggedRight write SetTabRaggedRight;
property TabScrollOpposite: Boolean read FTabScrollOpposite write SetTabScrollOpposite;
end;
implementation
uses
{$IFOPT D+} GX_DbugIntf, {$ENDIF}
SysUtils, Controls, ComCtrls,
GX_GenericUtils, GX_IdeUtils;
procedure TMultiLineTabManager.CPResizeHandler(Sender: TObject);
var
AHeight: Integer;
SenderControl: TTabControl;
begin
{$IFOPT D+} SendDebug('Component palette resized: adjusting multiline settings'); {$ENDIF}
SenderControl := Sender as TTabControl;
AHeight := SenderControl.Height -
(SenderControl.DisplayRect.Bottom - SenderControl.DisplayRect.Top) + 29;
SenderControl.Constraints.MinHeight := AHeight;
SenderControl.Parent.Constraints.MaxHeight := AHeight;
end;
procedure TMultiLineTabManager.SetTabRaggedRight(const Value: Boolean);
var
TabControl: TTabControl;
begin
if Value = FTabRaggedRight then
Exit;
FTabRaggedRight := Value;
TabControl := GetComponentPaletteTabControl;
if TabControl = nil then
Exit;
TabControl.RaggedRight := FTabRaggedRight;
end;
procedure TMultiLineTabManager.SetTabScrollOpposite(const Value: Boolean);
var
TabControl: TTabControl;
begin
if Value = FTabScrollOpposite then
Exit;
FTabScrollOpposite := Value;
TabControl := GetComponentPaletteTabControl;
if TabControl = nil then
Exit;
if FTabScrollOpposite then
TabControl.ScrollOpposite := FTabScrollOpposite;
end;
constructor TMultiLineTabManager.Create(AOwner: TComponent);
var
Tab: TTabControl;
begin
inherited Create(AOwner);
Tab := GetComponentPaletteTabControl;
if (AOwner = nil) or (Tab = nil) then
Exit;
FOldCPResizeHandler := Tab.OnResize;
Tab.OnResize := CPResizeHandler;
Tab.MultiLine := True;
end;
destructor TMultiLineTabManager.Destroy;
procedure RemoveIDETabHook;
var
TabControl: TTabControl;
begin
TabControl := GetComponentPaletteTabControl;
if TabControl = nil then
Exit;
with TabControl do
begin
MultiLine := False;
OnResize := FOldCPResizeHandler;
{$IFOPT D+} SendDebug('Restored old component palette resize handler'); {$ENDIF}
end;
end;
begin
try
{$IFOPT D+} SendDebug('Removing IDE component palette hooks'); {$ENDIF}
RemoveIDETabHook;
except
on E: Exception do
begin
GxLogException(E, 'MultiLine component palette removal');
{$IFOPT D+} SendDebug('MultiLine component palette removal exception: ' + E.Message) {$ENDIF};
// Swallow exception
end;
end;
inherited Destroy;
{$IFOPT D+} SendDebug('Removed IDE component palette hooks'); {$ENDIF}
end;
end.
|
{
$Project$
$Workfile$
$Revision$
$DateUTC$
$Id$
This file is part of the Indy (Internet Direct) project, and is offered
under the dual-licensing agreement described on the Indy website.
(http://www.indyproject.org/)
Copyright:
(c) 1993-2005, Chad Z. Hower and the Indy Pit Crew. All rights reserved.
}
{
$Log$
}
{
{ Rev 1.13 9/8/2004 8:55:46 PM JPMugaas
{ Fix for compile problem where a char is being compared with an incompatible
{ type in some compilers.
}
{
{ Rev 1.12 02/07/2004 21:59:28 CCostelloe
{ Bug fix
}
{
{ Rev 1.11 17/06/2004 14:19:00 CCostelloe
{ Bug fix for long subject lines that have characters needing CharSet encoding
}
{
{ Rev 1.10 23/04/2004 20:33:04 CCostelloe
{ Minor change to support From headers holding multiple addresses
}
{
{ Rev 1.9 2004.02.03 5:44:58 PM czhower
{ Name changes
}
{
{ Rev 1.8 24/01/2004 19:08:14 CCostelloe
{ Cleaned up warnings
}
{
{ Rev 1.7 1/22/2004 3:56:38 PM SPerry
{ fixed set problems
}
{
{ Rev 1.6 2004.01.22 2:34:58 PM czhower
{ TextIsSame + D8 bug workaround
}
{
Rev 1.5 10/16/2003 11:11:02 PM DSiders
Added localization comments.
}
{
{ Rev 1.4 10/8/2003 9:49:36 PM GGrieve
{ Use IdDelete
}
{
{ Rev 1.3 6/10/2003 5:48:46 PM SGrobety
{ DotNet updates
}
{
{ Rev 1.2 04/09/2003 20:35:28 CCostelloe
{ Parameter AUseAddressForNameIfNameMissing (defaulting to False to preserve
{ existing code) added to EncodeAddressItem
}
{
{ Rev 1.1 2003.06.23 9:46:52 AM czhower
{ Russian, Ukranian support for headers.
}
{
{ Rev 1.0 11/14/2002 02:14:46 PM JPMugaas
}
unit IdCoderHeader;
//TODO: Optimize and restructure code
//TODO: Redo this unit to fit with the new coders and use the exisiting MIME stuff
{
2002-08-21 JM Berg
- brought in line with the RFC regarding
whitespace between encoded words
- added logic so that lines that already seem encoded are really encoded again
(so that if a user types =?iso8859-1?Q?======?= its really encoded again
and displayed like that on the other side)
2001-Nov-18 Peter Mee
- Fixed multiple QP decoding in single header.
11-10-2001 - J. Peter Mugaas
- tiny fix for 8bit header encoding suggested by Andrew P.Rybin}
interface
uses
IdSys,
IdEMailAddress;
type
TTransfer = (bit7, bit8, iso2022jp);
// Procs
function EncodeAddressItem(EmailAddr:TIdEmailAddressItem; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string; AUseAddressForNameIfNameMissing: Boolean = False): string;
function EncodeHeader(const Header: string; const specials : String; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string): string;
function Encode2022JP(const S: ansistring): string;
function EncodeAddress(EmailAddr:TIdEMailAddressList; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string; AUseAddressForNameIfNameMissing: Boolean = False): string;
function DecodeHeader(Header: string):string;
function Decode2022JP(const S: string): string;
Procedure DecodeAddress(EMailAddr : TIdEmailAddressItem);
Procedure DecodeAddresses(AEMails : String; EMailAddr : TIdEmailAddressList);
implementation
uses
IdCoderMIME,
IdGlobal,
IdGlobalProtocols;
const
csSPECIALS = '()[]<>:;.,@\"'; {Do not Localize}
kana_tbl : array[#$A1..#$DF] of Word = (
$2123,$2156,$2157,$2122,$2126,$2572,$2521,$2523,$2525,$2527,
$2529,$2563,$2565,$2567,$2543,$213C,$2522,$2524,$2526,$2528,
$252A,$252B,$252D,$252F,$2531,$2533,$2535,$2537,$2539,$253B,
$253D,$253F,$2541,$2544,$2546,$2548,$254A,$254B,$254C,$254D,
$254E,$254F,$2552,$2555,$2558,$255B,$255E,$255F,$2560,$2561,
$2562,$2564,$2566,$2568,$2569,$256A,$256B,$256C,$256D,$256F,
$2573,$212B,$212C);
vkana_tbl : array[#$A1..#$DF] of Word = (
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$2574,$0000,
$0000,$252C,$252E,$2530,$2532,$2534,$2536,$2538,$253A,$253C,
$253E,$2540,$2542,$2545,$2547,$2549,$0000,$0000,$0000,$0000,
$0000,$2550,$2553,$2556,$2559,$255C,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000);
sj1_tbl : array[#128..#255] of Byte = (
$00,$21,$23,$25,$27,$29,$2B,$2D,$2F,$31,$33,$35,$37,$39,$3B,$3D,
$3F,$41,$43,$45,$47,$49,$4B,$4D,$4F,$51,$53,$55,$57,$59,$5B,$5D,
$00,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,
$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,
$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,
$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$01,
$5F,$61,$63,$65,$67,$69,$6B,$6D,$6F,$71,$73,$75,$77,$79,$7B,$7D,
$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$00,$00,$00);
sj2_tbl : array[AnsiChar] of Word = (
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,
$0000,$0000,$0000,$0000,$0021,$0022,$0023,$0024,$0025,$0026,
$0027,$0028,$0029,$002A,$002B,$002C,$002D,$002E,$002F,$0030,
$0031,$0032,$0033,$0034,$0035,$0036,$0037,$0038,$0039,$003A,
$003B,$003C,$003D,$003E,$003F,$0040,$0041,$0042,$0043,$0044,
$0045,$0046,$0047,$0048,$0049,$004A,$004B,$004C,$004D,$004E,
$004F,$0050,$0051,$0052,$0053,$0054,$0055,$0056,$0057,$0058,
$0059,$005A,$005B,$005C,$005D,$005E,$005F,$0000,$0060,$0061,
$0062,$0063,$0064,$0065,$0066,$0067,$0068,$0069,$006A,$006B,
$006C,$006D,$006E,$006F,$0070,$0071,$0072,$0073,$0074,$0075,
$0076,$0077,$0078,$0079,$007A,$007B,$007C,$007D,$007E,$0121,
$0122,$0123,$0124,$0125,$0126,$0127,$0128,$0129,$012A,$012B,
$012C,$012D,$012E,$012F,$0130,$0131,$0132,$0133,$0134,$0135,
$0136,$0137,$0138,$0139,$013A,$013B,$013C,$013D,$013E,$013F,
$0140,$0141,$0142,$0143,$0144,$0145,$0146,$0147,$0148,$0149,
$014A,$014B,$014C,$014D,$014E,$014F,$0150,$0151,$0152,$0153,
$0154,$0155,$0156,$0157,$0158,$0159,$015A,$015B,$015C,$015D,
$015E,$015F,$0160,$0161,$0162,$0163,$0164,$0165,$0166,$0167,
$0168,$0169,$016A,$016B,$016C,$016D,$016E,$016F,$0170,$0171,
$0172,$0173,$0174,$0175,$0176,$0177,$0178,$0179,$017A,$017B,
$017C,$017D,$017E,$0000,$0000,$0000);
base64_tbl: array [0..63] of Char = (
'A','B','C','D','E','F','G','H', {Do not Localize}
'I','J','K','L','M','N','O','P', {Do not Localize}
'Q','R','S','T','U','V','W','X', {Do not Localize}
'Y','Z','a','b','c','d','e','f', {Do not Localize}
'g','h','i','j','k','l','m','n', {Do not Localize}
'o','p','q','r','s','t','u','v', {Do not Localize}
'w','x','y','z','0','1','2','3', {Do not Localize}
'4','5','6','7','8','9','+','/'); {Do not Localize}
function EncodeAddressItem(EmailAddr:TIdEmailAddressItem; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string; AUseAddressForNameIfNameMissing: Boolean = False): string;
var
S : string;
I : Integer;
NeedEncode : Boolean;
begin
if ((AUseAddressForNameIfNameMissing = True) and (EmailAddr.Name = '')) then begin
{CC: Use Address as Name...}
EmailAddr.Name := EmailAddr.Address;
end;
if EmailAddr.Name <> '' then {Do not Localize}
begin
NeedEncode := False;
for I := 1 to Length(EmailAddr.Name) do
begin
if (EmailAddr.Name[I] < #32) or (EmailAddr.Name[I] >= #127) then
begin
NeedEncode := True;
Break;
end;
end;
if NeedEncode then
S := EncodeHeader(EmailAddr.Name, csSPECIALS, HeaderEncoding, TransferHeader, MimeCharSet)
else
begin { quoted string }
S := '"'; {Do not Localize}
for I := 1 to Length(EmailAddr.Name) do
begin { quote special characters }
if (EmailAddr.Name[I] = '\') or (EmailAddr.Name[I] = '"') then S := S + '\'; {Do not Localize}
S := S + EmailAddr.Name[I];
end;
S := S + '"'; {Do not Localize}
end;
Result := Sys.Format('%s <%s>', [S, EmailAddr.Address]) {Do not Localize}
end
else Result := Sys.Format('%s', [EmailAddr.Address]); {Do not Localize}
end;
function DecodeHeader(Header: string):string;
const
WhiteSpace = LF+CR+CHAR32+TAB;
var
i, l: Integer;
HeaderEncoding,
HeaderCharSet,
s: string;
aDecoder:TIdDecoderMIMELineByLine;
LEncodingStartPos,encodingendpos:Integer;
LPreviousEncodingStartPos: integer;
substring: string;
EncodingFound: Boolean;
OnlyWhitespace: boolean;
EncodingBeforeEnd: integer;
begin
// Get the Charset part.
EncodingBeforeEnd := -1;
LEncodingStartPos := PosIdx('=?ISO', Sys.UpperCase(Header), 1); {do not localize}
if LEncodingStartPos = 0 then begin
LEncodingStartPos := PosIdx('=?WINDOWS', Sys.UpperCase(Header), 1); {do not localize}
end;
if LEncodingStartPos = 0 then begin
LEncodingStartPos := PosIdx('=?KOI8', Sys.UpperCase(Header), 1); {do not localize}
end;
while LEncodingStartPos > 0 do begin
// Assume we will find the encoding
EncodingFound := True;
//we need 3 more question marks first and after that a '?=' {Do not Localize}
//to find the end of the substring, we can't just search for '?=', {Do not Localize}
//example: '=?ISO-8859-1?Q?=E4?=' {Do not Localize}
encodingendpos := PosIdx('?', Sys.UpperCase(Header),LEncodingStartPos+5); {Do not Localize}
if encodingendpos = 0 then begin
EncodingFound := False;
end else begin
// valid encoded words can not contain spaces
// if the user types something *almost* like an encoded word,
// and its sent as-is, we need to find this!!
for i := LEncodingStartPos to encodingendpos-1 do begin
if CharIsInSet(Header, i, Whitespace) then begin
EncodingFound := false;
break;
end;
end;
end;
if EncodingFound then
begin
encodingendpos:=PosIdx('?', Sys.UpperCase(Header),encodingendpos+1); {Do not Localize}
if encodingendpos=0 then
begin
EncodingFound := false;
end else begin
for i := LEncodingStartPos to encodingendpos-1 do begin
if CharIsInSet(Header, i, Whitespace) then begin
EncodingFound := false;
break;
end;
end;
end;
end;
if EncodingFound then
begin
encodingendpos:=PosIdx('?=', Sys.UpperCase(Header),encodingendpos+1); {Do not Localize}
if encodingendpos > 0 then
begin
for i := LEncodingStartPos to encodingendpos-1 do begin
if CharIsInSet(Header, i, Whitespace) then begin
EncodingFound := false;
break;
end;
end;
if EncodingFound then begin
substring:=Copy(Header,LEncodingStartPos,encodingendpos-LEncodingStartPos+2);
//now decode the substring
for i := 1 to 3 do
begin
l := Pos('?', substring); {Do not Localize}
substring := Copy(substring, l+1, Length(substring) - l + 1 );
if i = 1 then
begin
HeaderCharSet := Copy(substring, 1, Pos('?', substring)-1) {Do not Localize}
end else if i = 2 then
begin
HeaderEncoding := copy(substring,1,1);
end;
end;
//now Substring needs to end with '?=' otherwise give up! {Do not Localize}
if Copy(substring,Length(substring)-1,2)<>'?=' then {Do not Localize}
begin
EncodingFound := false;
end;
end;
if (EncodingBeforeEnd>=0) and EncodingFound and (LEncodingStartPos > 0) then begin
OnlyWhitespace := true;
for i:=EncodingBeforeEnd to LEncodingStartPos-1 do begin
if not (CharIsInSet(Header, i, WhiteSpace)) then begin
OnlyWhitespace := false;
break;
end;
end;
if OnlyWhitespace then begin
Delete(Header, EncodingBeforeEnd, LEncodingStartPos-EncodingBeforeEnd);
encodingendpos := encodingendpos - (LEncodingStartPos-encodingbeforeend);
LEncodingStartPos := EncodingBeforeEnd;
end;
end;
// Get the HeaderEncoding
if TextIsSame(HeaderEncoding, 'Q') {Do not Localize}
and EncodingFound then begin
i := 1;
s := ''; {Do not Localize}
repeat // substring can be accessed by index here, because we know that it ends with '?=' {Do not Localize}
if substring[i] = '_' then {Do not Localize}
begin
s := s + ' '; {Do not Localize}
end else if (substring[i] = '=') and (Length(substring)>=i+2+2) then //make sure we can access i+2 and '?=' is still beyond {Do not Localize}
begin
s := s + chr(Sys.StrToInt('$' + substring[i+1] + substring[i+2])); {Do not Localize}
inc(i,2);
end else
begin
s := s + substring[i];
end;
inc(i);
until (substring[i]='?') and (substring[i+1]='=') {Do not Localize}
end else if EncodingFound then
begin
S := Copy(Substring,1,Length(Substring)-2);
aDecoder := TIdDecoderMIMELineByLine.Create(nil);
try
aDecoder.Clear;
S := aDecoder.DecodeString(S);
finally
Sys.FreeAndNil(aDecoder);
end;
end;
if EncodingFound then
begin
if TextIsSame(HeaderCharSet, 'ISO-2022-JP') then {Do not Localize}
begin
substring := Decode2022JP(s);
end else
begin
substring := s;
end;
//replace old substring in header with decoded one:
header := Copy(header, 1, LEncodingStartPos - 1)
+ substring + Copy(header, encodingendpos + 2, Length(Header));
encodingendpos := length(substring);
substring := ''; {Do not Localize}
end;
end;
end;
encodingendpos := LEncodingStartPos + encodingendpos;
{CC: Bug fix - changed LEncodingStartPos to LPreviousEncodingStartPos because
LEncodingStartPos gets overwritten by return value from PosIdx.}
LPreviousEncodingStartPos := LEncodingStartPos;
LEncodingStartPos := PosIdx('=?ISO', Sys.UpperCase(Header), LPreviousEncodingStartPos + 1); {do not localize}
if LEncodingStartPos = 0 then begin
LEncodingStartPos := PosIdx('=?WINDOWS', Sys.UpperCase(Header), LPreviousEncodingStartPos + 1); {do not localize}
end;
if LEncodingStartPos = 0 then begin
LEncodingStartPos := PosIdx('=?KOI8', Sys.UpperCase(Header), LPreviousEncodingStartPos + 1); {do not localize}
end;
// delete whitespace between adjacent encoded words, but only
// if we had an encoding before
if EncodingFound then begin
EncodingBeforeEnd := encodingendpos;
end else begin
EncodingBeforeEnd := -1;
end;
end;
//There might be #0's in header when this it b64 encoded, e.g with:
//decodeheader('"Fernando Corti=?ISO-8859-1?B?8Q==?=a" <fernando@nowhere.com>');
while Pos(#0, header) > 0 do begin
Delete(header, Pos(#0, header), 1);
end;
Result := Header;
end;
{ convert Shift_JIS to ISO-2022-JP (RFC 1468) }
function Decode2022JP(const S: string): string;
var
T : string;
I, L : integer;
isK : Boolean;
K1, K2 : byte;
K3 : byte;
begin
T := ''; {Do not Localize}
isK := False;
L := length(S);
I := 1;
while I <= L do
begin
if S[I] = #27 then
begin
Inc(I);
if I+1 <= L then
begin
if Copy(S, I, 2) = '$B' then {Do not Localize}
begin
isK := True;
end
else
begin
if Copy(S, I, 2) = '(B' then {Do not Localize}
begin
isK := False;
end;
end;
Inc(I, 2); { TODO -oTArisawa : Check RFC 1468}
end;
end
else
begin
if isK then
begin
if I+1 <= L then
begin
K1 := byte(S[I]);
K2 := byte(S[I + 1]);
K3:= (K1 - 1) shr 1;
if K1 < 95 then
K3:= K3 + 113
else
K3 := K3 + 177;
if (K1 mod 2) = 1 then
begin
if K2 < 96 Then
K2 := K2 + 31
else
K2 := K2 + 32
end
else
K2 := K2 + 126;
T := T + char(K3) + char(k2);
Inc(I,2);
end
else
Inc(I); { invalid DBCS }
end
else
begin
T := T + S[I];
Inc(I);
end;
end;
end;
Result := T;
end;
Procedure DecodeAddress(EMailAddr : TIdEmailAddressItem);
begin
EMailAddr.Name := DecodeHeader(EMailAddr.Name);
end;
Procedure DecodeAddresses(AEMails : String; EMailAddr : TIdEmailAddressList);
var idx : Integer;
begin
idx := 0;
EMailAddr.EMailAddresses := AEMails;
while idx < EMailAddr.Count do
begin
DecodeAddress(EMailAddr[idx]);
inc(idx);
end;
end;
function EncodeAddress(EmailAddr:TIdEMailAddressList; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string; AUseAddressForNameIfNameMissing: Boolean = False): string;
var idx : Integer;
begin
Result := ''; {Do not Localize}
idx := 0;
while ( idx < EmailAddr.Count ) do
begin
Result := Result + ', ' + EncodeAddressItem(EMailAddr[idx], HeaderEncoding, TransferHeader, MimeCharSet, AUseAddressForNameIfNameMissing); {Do not Localize}
Inc ( idx );
end; // while ( idx < EncodeAddress.Count ) do
{Remove the first comma and the following space ', ' } {Do not Localize}
IdDelete ( Result, 1, 2 );
end;
{ convert Shift_JIS to ISO-2022-JP (RFC 1468) }
function Encode2022JP(const S: ansistring): string;
const
desig_asc = #27'(B'; {Do not Localize}
desig_jis = #27'$B'; {Do not Localize}
var
T: string;
I, L: Integer;
isK: Boolean;
K1: Byte;
K2, K3: Word;
begin
T := ''; {Do not Localize}
isK := False;
L := Length(S);
I := 1;
while I <= L do
begin
if Ord(S[I]) < 128 then {Do not Localize}
begin
if isK then
begin
T := T + desig_asc;
isK := False;
end;
T := T + S[I];
INC(I);
end else begin
K1 := sj1_tbl[S[I]];
case K1 of
0: INC(I); { invalid SBCS }
2: INC(I, 2); { invalid DBCS }
1:
begin { halfwidth katakana }
if not isK then begin
T := T + desig_jis;
isK := True;
end;
{ simple SBCS -> DBCS conversion }
K2 := kana_tbl[S[I]];
if (I < L) and (Ord(S[I+1]) AND $FE = $DE) then
begin { convert kana + voiced mark to voiced kana }
K3 := vkana_tbl[S[I]];
// This is an if and not a case because of a D8 bug, return to
// case when d8 patch is released
if S[I+1] = #$DE then begin { voiced }
if K3 <> 0 then
begin
K2 := K3;
INC(I);
end;
end else if S[I+1] = #$DF then begin { semivoiced }
if (K3 >= $2550) and (K3 <= $255C) then
begin
K2 := K3 + 1;
INC(I);
end;
end;
end;
T := T + Chr(K2 SHR 8) + Chr(K2 AND $FF);
INC(I);
end;
else { DBCS }
if (I < L) then begin
K2 := sj2_tbl[S[I + 1]];
if K2 <> 0 then
begin
if not isK then begin
T := T + desig_jis;
isK := True;
end;
T := T + Chr(K1 + K2 SHR 8) + Chr(K2 AND $FF);
end;
end;
INC(I, 2);
end;
end;
end;
if isK then
T := T + desig_asc;
Result := T;
end;
{ encode a header field if non-ASCII characters are used }
function EncodeHeader(const Header: string; const specials : String; const HeaderEncoding: Char;
TransferHeader: TTransfer; MimeCharSet: string): string;
const
SPACES = ' '+#9+#10+#13; {Do not Localize}
var
S, T: string;
L, P, Q, R: Integer;
B0, B1, B2: Integer;
InEncode: Integer;
NeedEncode: Boolean;
csNeedEncode, csReqQuote: String;
BeginEncode, EndEncode: string;
procedure EncodeWord(P: Integer);
const
MaxEncLen = 75;
var
Q: Integer;
EncLen: Integer;
Enc1: string;
begin
T := T + BeginEncode;
if L < P then P := L + 1;
Q := InEncode;
InEncode := 0;
EncLen := Length(BeginEncode) + 2;
if TextIsSame(HeaderEncoding, 'Q') then { quoted-printable } {Do not Localize}
begin
while Q < P do
begin
if not (CharIsInSet(S, Q, csReqQuote)) then
begin
Enc1 := S[Q]
end
else
begin
if S[Q] = ' ' then {Do not Localize}
Enc1 := '_' {Do not Localize}
else
Enc1 := '=' + Sys.IntToHex(Ord(S[Q]), 2); {Do not Localize}
end;
if EncLen + Length(Enc1) > MaxEncLen then
begin
//T := T + EndEncode + #13#10#9 + BeginEncode;
//CC: The #13#10#9 above caused the subsequent call to FoldWrapText to
//insert an extra #13#10 which, being a blank line in the headers,
//was interpreted by email clients, etc., as the end of the headers
//and the start of the message body. FoldWrapText seems to look for
//and treat correctly the sequence #13#10 + ' ' however...
T := T + EndEncode + #13#10 + ' ' + BeginEncode;
EncLen := Length(BeginEncode) + 2;
end;
T := T + Enc1;
INC(EncLen, Length(Enc1));
INC(Q);
end;
end
else
begin { base64 }
while Q < P do
begin
if EncLen + 4 > MaxEncLen then
begin
//T := T + EndEncode + #13#10#9 + BeginEncode;
//CC: The #13#10#9 above caused the subsequent call to FoldWrapText to
//insert an extra #13#10 which, being a blank line in the headers,
//was interpreted by email clients, etc., as the end of the headers
//and the start of the message body. FoldWrapText seems to look for
//and treat correctly the sequence #13#10 + ' ' however...
T := T + EndEncode + #13#10 + ' ' + BeginEncode;
EncLen := Length(BeginEncode) + 2;
end;
B0 := Ord(S[Q]);
case P - Q of
1: T := T + base64_tbl[B0 SHR 2] + base64_tbl[B0 AND $03 SHL 4] + '=='; {Do not Localize}
2:
begin
B1 := Ord(S[Q + 1]);
T := T + base64_tbl[B0 SHR 2] +
base64_tbl[B0 AND $03 SHL 4 + B1 SHR 4] +
base64_tbl[B1 AND $0F SHL 2] + '='; {Do not Localize}
end;
else
B1 := Ord(S[Q + 1]);
B2 := Ord(S[Q + 2]);
T := T + base64_tbl[B0 SHR 2] +
base64_tbl[B0 AND $03 SHL 4 + B1 SHR 4] +
base64_tbl[B1 AND $0F SHL 2 + B2 SHR 6] +
base64_tbl[B2 AND $3F];
end;
INC(EncLen, 4);
INC(Q, 3);
end;
end;
T := T + EndEncode;
end;
begin
case TransferHeader of
iso2022jp:
S := Encode2022JP(Header);
else
S := Header;
end;
{Suggested by Andrew P.Rybin for easy 8bit support}
if HeaderEncoding='8' then begin {Do not Localize}
Result:=S;
EXIT;
end;//if
csNeedEncode := CharRange( #0,#31)+CharRange( #127,#255) + specials;
csReqQuote := csNeedEncode + '?=_'; {Do not Localize}
BeginEncode := '=?' + MimeCharSet + '?' + HeaderEncoding + '?'; {Do not Localize}
EndEncode := '?='; {Do not Localize}
// JMBERG: We want to encode stuff that the user typed
// as if it already is encoded!!
if DecodeHeader(Header) <> Header then begin
csNeedEncode := csNeedEncode + '=';
end;
L := Length(S);
P := 1;
T := ''; {Do not Localize}
InEncode := 0;
while P <= L do
begin
Q := P;
while (P <= L) and (CharIsInSet(S, P, SPACES)) do
INC(P);
R := P;
NeedEncode := False;
while (P <= L) and not (CharIsInSet(S, P, SPACES)) do
begin
if CharIsInSet(S, P, csNeedEncode) then
begin
NeedEncode := True;
end;
INC(P);
end;
if NeedEncode then
begin
if InEncode = 0 then
begin
T := T + Copy(S, Q, R - Q);
InEncode := R;
end;
end
else
begin
if InEncode <> 0 then
begin
EncodeWord(Q);
end;
T := T + Copy(S, Q, P - Q);
end;
end;
if InEncode <> 0 then
begin
EncodeWord(P);
end;
Result := T;
end;
end.
|
// **********************************************************************
//
// Copyright (c) 2001 MT Tools.
//
// All Rights Reserved
//
// MT_DORB is based in part on the product DORB,
// written by Shadrin Victor
//
// See Readme.txt for contact information
//
// **********************************************************************
unit except_int;
interface
uses
code_int,Classes,orbtypes;
const
OMGVMCID = $4f4d0000;
MTDORBVMCID = $4f4f0000;
// Minor error codes for INITIALIZE
// MTDORB specific minor codes
MinorORBDestroyed = 1 or MTDORBVMCID;
// Minor error codes for NO_IMPLEMENT
// Standard minor codes
MinorMissingLocalValueImplementation = 1 or OMGVMCID;
MinorIncompatibleValueImplementationVersion = 2 or OMGVMCID;
MinorNotSupportedByLocalObject = 3 or OMGVMCID;
MinorDIINotSupportedByLocalObject = 4 or OMGVMCID;
// Minor error codes for OBJECT_NOT_EXIST
// Standard minor codes
MinorUnregisteredValue = 1 or OMGVMCID;
MinorCannotDispatch = 2 or OMGVMCID;
// Minor error codes for BAD_PARAM
// Standard minor codes
MinorValueFactoryError = 1 or OMGVMCID;
MinorRepositoryIdExists = 2 or OMGVMCID;
MinorNameExists = 3 or OMGVMCID;
MinorInvalidContainer = 4 or OMGVMCID;
MinorNameClashInInheritedContext = 5 or OMGVMCID;
MinorBadAbstractInterfaceType = 6 or OMGVMCID;
MinorBadSchemeName = 7 or OMGVMCID;
MinorBadAddress = 8 or OMGVMCID;
MinorBadSchemeSpecificPart = 9 or OMGVMCID;
MinorOther = 10 or OMGVMCID;
MinorInvalidAbstractInterfaceInheritance = 11 or OMGVMCID;
MinorInvalidValueInheritance = 12 or OMGVMCID;
MinorIncompleteTypeCodeParameter = 13 or OMGVMCID;
MinorInvalidObjectId = 14 or OMGVMCID;
MinorInvalidName = 15 or OMGVMCID;
MinorInvalidId = 16 or OMGVMCID;
MinorInvalidMemberName = 17 or OMGVMCID;
MinorDuplicateLabel = 18 or OMGVMCID;
MinorIncompatibleLabelType = 19 or OMGVMCID;
MinorInvalidDiscriminatorType = 20 or OMGVMCID;
MinorNoExceptionInAny = 21 or OMGVMCID;
MinorUnlistedUserException = 22 or OMGVMCID;
MinorNoWcharCodeSet = 23 or OMGVMCID;
MinorServiceContextIdOutOfRange = 24 or OMGVMCID;
MinorEnumValueOutOfRange = 25 or OMGVMCID;
MinorInvalidServiceContextId = 26 or OMGVMCID;
MinorObjectIsNull = 27 or OMGVMCID;
MinorInvalidComponentId = 28 or OMGVMCID;
MinorInvalidProfileId = 29 or OMGVMCID;
MinorDuplicatePolicyType = 30 or OMGVMCID;
// MTDORB specific minor codes
MinorDuplicateDeclarator = 1 or MTDORBVMCID;
MinorInvalidValueModifier = 2 or MTDORBVMCID;
MinorDuplicateValueInit = 3 or MTDORBVMCID;
MinorAbstractValueInit = 4 or MTDORBVMCID;
MinorDuplicateBaseType = 5 or MTDORBVMCID;
MinorSingleThreadedOnly = 6 or MTDORBVMCID;
MinorNameRedefinitionInImmediateScope = 7 or MTDORBVMCID;
MinorInvalidValueBoxType = 8 or MTDORBVMCID;
MinorInvalidLocalInterfaceInheritance = 9 or MTDORBVMCID;
MinorConstantTypeMismatch = 10 or MTDORBVMCID;
// Minor error codes for BAD_INV_ORDER
// Standard minor codes
MinorDependencyPreventsDestruction = 1 or OMGVMCID;
MinorIndestructibleObject = 2 or OMGVMCID;
MinorDestroyWouldBlock = 3 or OMGVMCID;
MinorShutdownCalled = 4 or OMGVMCID;
MinorDuplicateSend = 5 or OMGVMCID;
MinorServantManagerAlreadySet = 6 or OMGVMCID;
MinorInvalidUseOfDSIArguments = 7 or OMGVMCID;
MinorInvalidUseOfDSIContext = 8 or OMGVMCID;
MinorInvalidUseOfDSIResult = 9 or OMGVMCID;
MinorRequestAlreadySent = 10 or OMGVMCID;
MinorRequestNotSent = 11 or OMGVMCID;
MinorResponseAlreadyReceived = 12 or OMGVMCID;
MinorSynchronousRequest = 13 or OMGVMCID;
MinorInvalidPICall = 14 or OMGVMCID;
MinorServiceContextExists = 15 or OMGVMCID;
MinorPolicyFactoryExists = 16 or OMGVMCID;
MinorNoCreatePOA = 17 or OMGVMCID;
// Minor error codes for COMM_FAILURE
// Standard minor code
(* None yet *)
// MTDORB specific minor codes
MinorRecv = 1 or MTDORBVMCID;
MinorSend = 2 or MTDORBVMCID;
MinorRecvZero = 3 or MTDORBVMCID;
MinorSendZero = 4 or MTDORBVMCID;
MinorSocket = 5 or MTDORBVMCID;
MinorSetsockopt = 6 or MTDORBVMCID;
MinorGetsockopt = 7 or MTDORBVMCID;
MinorBind = 8 or MTDORBVMCID;
MinorListen = 9 or MTDORBVMCID;
MinorConnect = 10 or MTDORBVMCID;
MinorAccept = 11 or MTDORBVMCID;
MinorSelect = 12 or MTDORBVMCID;
MinorSetSoTimeout = 26 or MTDORBVMCID;
MinorGethostname = 13 or MTDORBVMCID;
MinorGethostbyname = 14 or MTDORBVMCID;
MinorWSAStartup = 15 or MTDORBVMCID;
MinorWSACleanup = 16 or MTDORBVMCID;
MinorNoGIOP = 17 or MTDORBVMCID;
MinorUnknownMessage = 18 or MTDORBVMCID;
MinorWrongMessage = 19 or MTDORBVMCID;
MinorMessageError = 21 or MTDORBVMCID;
MinorFragment = 22 or MTDORBVMCID;
MinorUnknownReqId = 24 or MTDORBVMCID;
MinorVersion = 25 or MTDORBVMCID;
MinorPipe = 23 or MTDORBVMCID;
// Minor error codes for TRANSIENT
// Standard minor codes
MinorRequestDiscarded = 1 or OMGVMCID;
MinorNoUsableProfileInIOR = 2 or OMGVMCID;
MinorRequestCancelled = 3 or OMGVMCID;
MinorPOADestroyed = 4 or OMGVMCID;
// MTDORB specific minor codes
MinorConnectFailed = 1 or MTDORBVMCID;
MinorCloseConnection = 2 or MTDORBVMCID;
MinorActiveConnectionManagement = 3 or MTDORBVMCID;
MinorForcedShutdown = 4 or MTDORBVMCID;
MinorLocationForwardHopCountExceeded = 5 or MTDORBVMCID;
// Minor error codes for UNKNOWN
// Standard minor codes
//
MinorUnknownUserException = 1 or OMGVMCID;
MinorSystemExceptionNotSupported = 2 or OMGVMCID;
// Minor error codes for INV_POLICY
// Standard minor codes
//
MinorCannotReconcilePolicy = 1 or OMGVMCID;
MinorInvalidPolicyType = 2 or OMGVMCID;
MinorNoPolicyFactory = 3 or OMGVMCID;
// Minor error codes for OBJ_ADAPTER
// Standard minor codes
//
MinorSystemExceptionInUnknownAdapter = 1 or OMGVMCID;
MinorServantNotFound = 2 or OMGVMCID;
MinorNoDefaultServant = 3 or OMGVMCID;
MinorNoServantManager = 4 or OMGVMCID;
MinorIncarnateViolatedPOAPolicy = 5 or OMGVMCID;
// Minor error codes for NO_RESOURCES
// PortableInterceptor minor codes
//
MinorInvalidBinding = 1 or OMGVMCID;
type
IORBException = interface(IUnknown)
['{61252F7A-4D23-11d4-9D27-204C4F4F5020}']
procedure encode(const enc: IEncoder);
procedure encode_any(const a: IAny);
function clone(): IORBException;
procedure print(s: TStream);
function repoid(): RepositoryId;
procedure throw();
function ref_count(): integer;
end;
ISystemException = interface(IORBexception)
['{61252F7B-4D23-11d4-9D27-204C4F4F5020}']
procedure assign(const ex: ISystemException);
function completed(): TCompletionStatus;
function minor(): _ulong;
procedure set_minor(val: _ulong);
procedure set_completed(val: TCompletionStatus);
function extype(): SYSEXC_TYPES;
function _reason(): string;
procedure set_reason(const reason: string);
function _remote(): boolean;
procedure set_remote(remote: boolean);
end;
IUserException = interface(IORBException)
['{FBB86C41-9AF8-11d4-9DB2-204C4F4F5020}']
end;
IUnknownUserException = interface(IUserException)
['{61252F7C-4D23-11d4-9D27-204C4F4F5020}']
function exception(tc: ITypeCode): IAny; overload;
function exception(sa: IStaticTypeInfo): IStaticAny; overload;
function except_repoid: RepositoryId;
end;
IBadKind = interface(IUserException)
['{FBB86C42-9AF8-11d4-9DB2-204C4F4F5020}']
end;
IBounds = interface(IUserException)
['{FBB86C43-9AF8-11d4-9DB2-204C4F4F5020}']
end;
implementation
end.
|
{***********************************************************************************************************************
*
* TERRA Game Engine
* ==========================================
*
* Copyright (C) 2003, 2014 by SÚrgio Flores (relfos@gmail.com)
*
***********************************************************************************************************************
*
* 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.
*
**********************************************************************************************************************
* TERRA_Callback
* Implements callstack debug info (tested with Delphi 7 only, will provide empty info in other compilers)
***********************************************************************************************************************
}
Unit TERRA_Callstack;
{$I terra.inc}
Interface
Uses SysUtils;
Type
CallInfo = Record
Name:^String;
Line:Cardinal;
End;
Procedure GetCurrentCall(Var Info:CallInfo);
//Function TextualDebugInfoForAddress(Const TheAddress: Cardinal):TERRAString;
Function DumpCallstack:String;
Function DumpExceptionCallStack(E: Exception):String;
//Function GetLibraryAddress():Cardinal;
Var
SettingCallStack:Boolean = False;
Implementation
//Uses TERRA_Utils, TERRA_String, TERRA_Stream, TERRA_FileStream
{$IFNDEF FPC}
//Uses Windows;
{$ENDIF}
Const
{$IFNDEF FPC}
SkillCalls = 0;
LineEnding = #13#10;
StoredCallStackDepth = 26; // Size of the call stack we store when GetMem is called, must be an EVEN number
{$ELSE}
StoredCallStackDepth = 20;
{$ENDIF}
Type
CallStackArray = Array[0..StoredCallStackDepth] of Pointer;
Var
_CurrentCallstack:CallStackArray;
_CurrentCallstackSize:Integer;
(*Function GetLibraryAddress():Cardinal;
Const
libname = 'libterra.so';
Var
S, Range,Perms, Ofs, Dev, Inode, Path:TERRAString;
StartPos, EndPos, OfsValue:Cardinal;
Src:FileStream;
Begin
Result := 0;
Src := FileStream.Open('/proc/self/maps');
While Not Src.EOF Do
Begin
Src.ReadLine(S);
Range := StringGetNextSplit(S, Ord(' '));
Perms := StringGetNextSplit(S, Ord(' '));
Ofs := StringGetNextSplit(S, Ord(' '));
Dev := StringGetNextSplit(S, Ord(' '));
INode := StringGetNextSplit(S, Ord(' '));
Path := StringGetNextSplit(S, Ord(' '));
If StringContains(LibName, Path) Then
Begin
StartPos := StringToCardinal(StringGetNextSplit(Range, Ord('-')));
OfsValue := StringToCardinal(Ofs);
If (StringContainsChar(Ord('r'), Perms)) And (StringContainsChar(Ord('x'), Perms)) Then
Begin
Result := StartPos - OfsValue;
End;
End;
End;
ReleaseObject(Src);
End;
Procedure AdjustCallstack();
Var
BaseAddr:Cardinal;
I:Integer;
Begin
BaseAddr := GetLibraryAddress();
For I:=0 To Pred(_CurrentCallstackSize) Do
Dec(Cardinal(_CurrentCallstack[I]), BaseAddr);
End;*)
{$IFDEF DELPHI}
Type
AddressToLine = Class
Public
Address: Cardinal;
Line: Cardinal;
Constructor Create(const AAddress, ALine: Cardinal);
End;
UnitDebugInfos = Class
Public
Name:String;
Addresses: array of AddressToLine;
ShowOnCallstack:Boolean;
Constructor Create(const AName:String; const NbLines: Cardinal);
Function LineWhichContainsAddress(const Address: Cardinal):Integer;
End;
RoutineDebugInfos = Class
Public
Name:String;
StartAddress: Cardinal;
EndAddress: Cardinal;
Constructor Create(const AName:String; const AStartAddress: Cardinal; const ALength: Cardinal);
End;
Constructor UnitDebugInfos.Create(const AName:String; const NbLines: Cardinal);
Begin
Name := AName;
ShowOnCallstack := {(Pos('TERRA_', AName)>0) And} (Pos('Callstack', AName)<=0) And (Pos('MemoryManager', AName)<=0);
SetLength(Addresses, NbLines);
End;
constructor RoutineDebugInfos.Create(const AName:String; const AStartAddress: Cardinal; const ALength: Cardinal);
Var
I:Integer;
begin
Name := Copy(AName, 2, MaxInt);
Name := Copy(Name, Succ(Pos('@', Name)), MaxInt);
For I:=1 To Length(Name) Do
If (Name[I]='@') Then
Name[I] := '.';
StartAddress := AStartAddress;
EndAddress := StartAddress + ALength - 1;
end;
constructor AddressToLine.Create(const AAddress, ALine: Cardinal);
begin
Address := AAddress;
Line := ALine
end;
function UnitDebugInfos.LineWhichContainsAddress(const Address: Cardinal):Integer;
var
Start, Finish, Pivot: Cardinal;
begin
if Addresses[0].Address > Address then
Result := 0
else
begin
Start := 0;
Finish := Length(Addresses) - 1;
while Start < Finish - 1 do
begin
Pivot := Start + (Finish - Start) div 2;
if Addresses[Pivot].Address = Address then
begin
Start := Pivot;
Finish := Start
end
else
if Addresses[Pivot].Address > Address then
Finish := Pivot
else
Start := Pivot
end;
Result := Addresses[Start].Line;
end;
end;
Const
MaxListSize = MaxInt div 16 - 1;
Type
SRCMODHDR = packed record
_cFile: Word;
_cSeg: Word;
_baseSrcFile: array[0..MaxListSize] of Integer;
end;
SRCFILE = packed record
_cSeg: Word;
_nName: Integer;
_baseSrcLn: array[0..MaxListSize] of Integer;
end;
SRCLN = packed record
_Seg: Word;
_cPair: Word;
_Offset: array[0..MaxListSize] of Integer;
end;
PSRCMODHDR = ^SRCMODHDR;
PSRCFILE = ^SRCFILE;
PSRCLN = ^SRCLN;
TArrayOfByte = array[0..MaxListSize] of Byte;
TArrayOfWord = array[0..MaxListSize] of Word;
PArrayOfByte = ^TArrayOfByte;
PArrayOfWord = ^TArrayOfWord;
PArrayOfPointer = ^TArrayOfPointer;
TArrayOfPointer = array[0..MaxListSize] of PArrayOfByte;
Var
Routines: array of RoutineDebugInfos;
RoutinesCount: integer;
Units: array of UnitDebugInfos;
UnitsCount: integer;
Function Max(A,B:Integer):Integer;
Begin
If (A>B) Then
Result := A
Else
Result := B;
End;
procedure AddRoutine(const Name:String; const Start, Len: Cardinal);
begin
if Length(Routines) <= RoutinesCount then
SetLength(Routines, Max(RoutinesCount * 2, 1000));
Routines[RoutinesCount] := RoutineDebugInfos.Create(Name, Start, Len);
RoutinesCount := RoutinesCount + 1;
end;
procedure AddUnit(const U: UnitDebugInfos);
begin
if Length(Units) <= UnitsCount then
SetLength(Units, Max(UnitsCount * 2, 1000));
Units[UnitsCount] := U;
UnitsCount := UnitsCount + 1;
end;
procedure dumpsymbols(NameTbl: PArrayOfPointer; sstptr: PArrayOfByte; size: integer);
//Copyright (C) Tenth Planet Software Intl., Clive Turvey 1998. All rights reserved. - Reused & modified by SG with permission
var
len, sym: integer;
begin
while size > 0 do
begin
len := PWord(@sstptr^[0])^;
sym := PWord(@sstptr^[2])^;
INC(len, 2);
if ((sym = $205) or (sym = $204)) and (PInteger(@sstptr^[40])^ > 0) then
AddRoutine(PAnsiChar(NameTbl^[PInteger(@sstptr^[40])^ - 1]), PInteger(@sstptr^[28])^, PInteger(@sstptr^[16])^);
if (len = 2) then
size := 0
else
begin
sstptr := PArrayOfByte(@sstptr^[len]);
DEC(size, len);
end;
end;
end;
Const
MAX_PATH = 260;
IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
IMAGE_SIZEOF_FILE_HEADER = 20;
Type
PImageFileHeader = ^TImageFileHeader;
TImageFileHeader = Packed Record
Machine: Word;
NumberOfSections: Word;
TimeDateStamp:Cardinal;
PointerToSymbolTable:Cardinal;
NumberOfSymbols:Cardinal;
SizeOfOptionalHeader: Word;
Characteristics: Word;
End;
PImageDataDirectory = ^TImageDataDirectory;
TImageDataDirectory = record
VirtualAddress:Cardinal;
Size:Cardinal;
End;
PImageOptionalHeader = ^TImageOptionalHeader;
TImageOptionalHeader = packed record
{ Standard fields. }
Magic: Word;
MajorLinkerVersion: Byte;
MinorLinkerVersion: Byte;
SizeOfCode: Cardinal;
SizeOfInitializedData: Cardinal;
SizeOfUninitializedData: Cardinal;
AddressOfEntryPoint: Cardinal;
BaseOfCode: Cardinal;
BaseOfData: Cardinal;
{ NT additional fields. }
ImageBase: Cardinal;
SectionAlignment: Cardinal;
FileAlignment: Cardinal;
MajorOperatingSystemVersion: Word;
MinorOperatingSystemVersion: Word;
MajorImageVersion: Word;
MinorImageVersion: Word;
MajorSubsystemVersion: Word;
MinorSubsystemVersion: Word;
Win32VersionValue: Cardinal;
SizeOfImage: Cardinal;
SizeOfHeaders: Cardinal;
CheckSum: Cardinal;
Subsystem: Word;
DllCharacteristics: Word;
SizeOfStackReserve: Cardinal;
SizeOfStackCommit: Cardinal;
SizeOfHeapReserve: Cardinal;
SizeOfHeapCommit: Cardinal;
LoaderFlags: Cardinal;
NumberOfRvaAndSizes: Cardinal;
DataDirectory: packed array[0..IMAGE_NUMBEROF_DIRECTORY_ENTRIES-1] of TImageDataDirectory;
End;
PImageDosHeader = ^TImageDosHeader;
TImageDosHeader = packed record { DOS .EXE header }
e_magic: Word; { Magic number }
e_cblp: Word; { Bytes on last page of file }
e_cp: Word; { Pages in file }
e_crlc: Word; { Relocations }
e_cparhdr: Word; { Size of header in paragraphs }
e_minalloc: Word; { Minimum extra paragraphs needed }
e_maxalloc: Word; { Maximum extra paragraphs needed }
e_ss: Word; { Initial (relative) SS value }
e_sp: Word; { Initial SP value }
e_csum: Word; { Checksum }
e_ip: Word; { Initial IP value }
e_cs: Word; { Initial (relative) CS value }
e_lfarlc: Word; { File address of relocation table }
e_ovno: Word; { Overlay number }
e_res: array [0..3] of Word; { Reserved words }
e_oemid: Word; { OEM identifier (for e_oeminfo) }
e_oeminfo: Word; { OEM information; e_oemid specific}
e_res2: array [0..9] of Word; { Reserved words }
_lfanew: LongInt; { File address of new exe header }
End;
Var
Displ: Cardinal;
{Displ is the displacement of the code in the executable file. The code in SetDispl was written by Juan Vidal Pich}
procedure SetDispl;
var
NTHeader: PImageFileHeader;
NTOptHeader: PImageOptionalHeader;
begin
//-> If you have a compilation error in this routine and you are compiling with delphi 4, I'd say that you did not install the Delphi update pack 3
NTHeader := PImageFileHeader(Cardinal(PImageDosHeader(HInstance)._lfanew) + HInstance + 4); {SizeOf(IMAGE_NT_SIGNATURE) = 4}
NTOptHeader := PImageOptionalHeader(Cardinal(NTHeader) + IMAGE_SIZEOF_FILE_HEADER);
Displ := HInstance + NTOptHeader.BaseOfCode;
//Result := HInstance + PImageNtHeaders(LongInt(HInstance)+PImageDosHeader(HInstance)^._lfanew)^.OptionalHeader.BaseOfCode;
end;
Const
PathSeparator = '\';
Function ExtractFileName(FileName:String):String;
Var
I, Len:Integer;
Begin
Len := Length(FileName);
For I:=Len DownTo 1 Do
If (FileName[I] = PathSeparator) Then
Begin
Result := Copy(FileName, Succ(I), MaxInt);
Exit;
End;
Result := FileName;
End;
procedure dumplines(NameTbl: PArrayOfPointer; sstptr: PArrayOfByte; size: integer);
//Copyright (C) Tenth Planet Software Intl., Clive Turvey 1998. All rights reserved. - Reused & modified by SG with permission
var
srcmodhdr: PSRCMODHDR;
i: Word;
srcfile: PSRCFILE;
srcln: PSRCLN;
k: Word;
CurrentUnit: UnitDebugInfos;
begin
if size > 0 then
begin
srcmodhdr := PSRCMODHDR(sstptr);
for i := 0 to pred(srcmodhdr^._cFile) do
begin
srcfile := PSRCFILE(@sstptr^[srcmodhdr^._baseSrcFile[i]]);
if srcfile^._nName > 0 then
//note: I assume that the code is always in segment #1. If this is not the case, Houston ! - VM
begin
srcln := PSRCLN(@sstptr^[srcfile^._baseSrcLn[0]]);
CurrentUnit := UnitDebugInfos.Create(ExtractFileName(PAnsiChar(NameTbl^[srcfile^._nName - 1])), srcln^._cPair);
AddUnit(CurrentUnit);
for k := 0 to pred(srcln^._cPair) do
CurrentUnit.Addresses[k] := AddressToLine.Create(Integer(PArrayOfPointer(@srcln^._Offset[0])^[k]), Integer(PArrayOfWord(@srcln^._Offset[srcln^._cPair])^[k]));
end;
end;
end;
end;
Function GetModuleFileName(hModule: HINST; lpFilename: PAnsiChar; nSize: Cardinal):Cardinal; stdcall; External 'Kernel32.dll' Name 'GetModuleFileNameA';
Var
InfoInitialized:Boolean = False;
Procedure GetProjectInfos();
//Copyright (C) Tenth Planet Software Intl., Clive Turvey 1998. All rights reserved. - Reused & modified by SG with permission
var
AHeader: packed record
Signature: array[0..3] Of AnsiChar;
AnInteger: Integer;
end;
k: integer;
j: Word;
lfodir: Integer;
SstFrameSize: integer;
SstFrameElem: PArrayOfByte;
ssttype, sstsize, sstbase: Integer;
x, y, z: Integer;
sstbuf: PArrayOfByte;
OldFileMode: integer;
AFileOfByte: file of Byte;
Names: PArrayOfByte;
NameTbl: PArrayOfPointer;
SstFrame: PArrayOfByte;
ifabase: Integer;
cdir, cbdirentry: word;
FileName:String;
DebugOffset:Integer;
I, Size:Integer;
Id:Integer;
Buf:Array Of AnsiChar;
begin
If InfoInitialized Then
Exit;
InfoInitialized := True;
SetDispl;
RoutinesCount := 0;
UnitsCount := 0;
OldFileMode := FileMode;
FileMode := 0;
SetLength(FileName, MAX_PATH + 1);
SetLength(FileName, GetModuleFileName(HInstance, PAnsiChar(FileName), MAX_PATH));
AssignFile(AFileOfByte, FileName);
Reset(AFileOfByte);
Names := nil;
NameTbl := nil;
Size := FileSize(AFileOfByte);
SetLength(Buf, Size);
BlockRead(AFileOfByte, Buf[0], Size);
ID := 4;
DebugOffset := -1;
I := Pred(Size);
Repeat
Case ID Of
4: If (Buf[I]='9') Or (Buf[I]='A') Then
Dec(ID);
3: If (Buf[I]='0') Then
Dec(ID)
Else
ID := 4;
2: If (Buf[I]='B') Then
Dec(ID)
Else
ID := 4;
1: If (Buf[I]='F') Then
Begin
DebugOffset := I;
Break;
End Else
ID := 4;
End;
Dec(I);
Until (I<0);
SetLength(Buf, 0);
If DebugOffset >= 0 Then
Begin
Seek(AFileOfByte, DebugOffset);
BlockRead(AFileOfByte, AHeader, SizeOf(AHeader));
if (AHeader.Signature = 'FB09') or (AHeader.Signature = 'FB0A') then
begin
ifabase := FilePos(AFileOfByte) - AHeader.AnInteger;
Seek(AFileOfByte, ifabase);
BlockRead(AFileOfByte, AHeader, SizeOf(AHeader));
if (AHeader.Signature = 'FB09') or (AHeader.Signature = 'FB0A') then
begin
lfodir := ifabase + AHeader.AnInteger;
if lfodir >= ifabase then
begin
Seek(AFileOfByte, lfodir);
BlockRead(AFileOfByte, j, SizeOf(Word));
BlockRead(AFileOfByte, cbdirentry, SizeOf(Word));
BlockRead(AFileOfByte, cdir, SizeOf(Word));
Seek(AFileOfByte, lfodir + j);
SstFrameSize := cdir * cbdirentry;
getmem(SstFrame, SstFrameSize);
BlockRead(AFileOfByte, SstFrame^, SstFrameSize);
for k := 0 to pred(cdir) do
begin
SstFrameElem := PArrayOfByte(@SstFrame^[k * cbdirentry]);
ssttype := PWord(@SstFrameElem^[0])^;
if (ssttype = $0130) then
begin
sstbase := ifabase + PInteger(@SstFrameElem^[4])^;
sstsize := PInteger(@SstFrameElem^[8])^;
getmem(Names, sstsize);
Seek(AFileOfByte, sstbase);
BlockRead(AFileOfByte, Names^, sstsize);
y := PInteger(@Names^[0])^;
getmem(NameTbl, sizeof(Pointer) * y);
z := 4;
for x := 0 to pred(y) do
begin
NameTbl^[x] := PArrayOfByte(@Names^[z + 1]);
z := z + Names^[z] + 2;
end;
end;
end;
for k := 0 to pred(cdir) do
begin
SstFrameElem := PArrayOfByte(@SstFrame^[k * cbdirentry]);
ssttype := PWord(@SstFrameElem^[0])^;
sstbase := ifabase + PInteger(@SstFrameElem^[4])^;
sstsize := PInteger(@SstFrameElem^[8])^;
getmem(sstbuf, sstsize);
Seek(AFileOfByte, sstbase);
BlockRead(AFileOfByte, sstbuf^, sstsize);
if (ssttype = $0125) then
dumpsymbols(NameTbl, PArrayOfByte(@sstbuf^[4]), sstsize - 4);
if (ssttype = $0127) then
dumplines(NameTbl, sstbuf, sstsize);
FreeMem(sstbuf);
end;
FreeMem(Names);
FreeMem(NameTbl);
FreeMem(SstFrame);
end;
end;
end;
End;
CloseFile(AFileOfByte);
FileMode := OldFileMode;
End;
Function UnitWhichContainsAddress(const Address: Cardinal):UnitDebugInfos;
var
Start, Finish, Pivot: integer;
begin
Start := 0;
Finish := UnitsCount - 1;
Result := nil;
If (UnitsCount<=0) Then
Exit;
while Start <= Finish do
begin
Pivot := Start + (Finish - Start) div 2;
if (Pivot>=Length(Units)) Or (Length(UnitDebugInfos(Units[Pivot]).Addresses)<=0) Then
Break
Else
If (UnitDebugInfos(Units[Pivot]).Addresses[0].Address > Address) then
Finish := Pivot - 1
else
if UnitDebugInfos(Units[Pivot]).Addresses[Length(UnitDebugInfos(Units[Pivot]).Addresses) - 1].Address < Address then
Start := Pivot + 1
else
begin
Result := Units[Pivot];
Start := Finish + 1;
end;
end;
end;
Function RoutineWhichContainsAddress(const Address: Cardinal):RoutineDebugInfos;
Var
Start, Finish, Pivot: integer;
Begin
Start := 0;
Result := Nil;
Finish := RoutinesCount - 1;
while Start <= Finish do
begin
Pivot := Start + (Finish - Start) div 2;
if RoutineDebugInfos(Routines[Pivot]).StartAddress > Address then
Finish := Pivot - 1
else
if RoutineDebugInfos(Routines[Pivot]).EndAddress < Address then
Start := Pivot + 1
else
begin
Result := RoutineDebugInfos(Routines[Pivot]);
Start := Finish + 1;
end;
end;
End;
Function BackTraceStrFunc(Const TargetAddress:Pointer):String;
var
U:UnitDebugInfos;
R:RoutineDebugInfos;
AddressInDebugInfos: Cardinal;
Num:String;
TheAddress:Cardinal;
begin
If UnitsCount<=0 Then
GetProjectInfos();
TheAddress := Cardinal(TargetAddress);
If (TheAddress > Displ) then
Begin
AddressInDebugInfos := TheAddress - Displ;
U := UnitWhichContainsAddress(AddressInDebugInfos);
R := RoutineWhichContainsAddress(AddressInDebugInfos);
If Assigned(R) Then
Begin
Result := R.Name;
If Assigned(U) Then
Begin
Str(U.LineWhichContainsAddress(AddressInDebugInfos), Num);
Result := Result + ' (line '+Num+' of '+U.Name+')';
End;
Exit;
End;
End;
Str(TheAddress, Num);
Result := Num + ' (No debug info)';
End;
Procedure FillCallStackFromAddress(StackStart, StackMax:Pointer);
{Works only with stack frames - Without, St contains correct info, but is not as deep as it should
I just don't know a general rule for walking the stack when they are not there}
Var
//the stack can never go beyond - stackmax http://msdn.microsoft.com/library/periodic/period96/S2CE.htm
CurrentFrame:Pointer;
Count:Integer;
begin
FillChar(_CurrentCallstack, SizeOf(_CurrentCallstack), 0);
CurrentFrame := StackStart;
Count := 0;
While (longint(CurrentFrame) >= longint(StackStart)) and (longint(CurrentFrame) < longint(StackMax)) and (Count <= StoredCallStackDepth) Do
Begin
_CurrentCallstack[Count] := Pointer(PInteger(longint(CurrentFrame) + 4)^ - 4);
Inc(Count);
CurrentFrame := Pointer(PInteger(CurrentFrame)^);
End;
_CurrentCallstackSize := Count;
End;
Procedure FillCurrentCallStack();
Var
StackStart, StackMax:Pointer;
Begin
Asm
mov EAX, FS:[4]
mov StackMax, EAX
mov StackStart, EBP
End;
FillCallStackFromAddress(StackStart, StackMax);
End;
Procedure FillExceptionCallStack(E:Exception);
Begin
FillCurrentCallStack();
//FillCallStackFromAddress(ExceptAddr, Pointer(Cardinal(ExceptAddr) + 16));
End;
Procedure GetCurrentCall(Var Info:CallInfo);
Var
I, Count:Integer;
TheAddress:Cardinal;
AddressInDebugInfos: Cardinal;
U:UnitDebugInfos;
Routine:RoutineDebugInfos;
Begin
SettingCallStack := True;
If (UnitsCount<=0) Then
GetProjectInfos();
FillCurrentCallstack();
SettingCallStack := False;
I := 0;
Info.Name := Nil;
Info.Line := 0;
Count := SkillCalls;
While (i <= StoredCallStackDepth) and (_CurrentCallstack[i] <> nil) Do
Begin
TheAddress := Cardinal(_CurrentCallstack[i]);
If (TheAddress > Displ) Then
Begin
AddressInDebugInfos := TheAddress - Displ;
U := UnitWhichContainsAddress(AddressInDebugInfos);
If (Assigned(U)) And (U.ShowOnCallstack) Then
Begin
Routine := RoutineWhichContainsAddress(AddressInDebugInfos);
If Assigned(Routine) Then
Begin
Dec(Count);
Info.Name := @Routine.Name;
Info.Line := U.LineWhichContainsAddress(AddressInDebugInfos);
If (Count<0) Then
Exit;
End;
End;
End;
Inc(I);
End;
End;
{$ELSE}
Procedure GetCurrentCall(Var Info:CallInfo);
Begin
Info.Name := Nil;
Info.Line := 0;
End;
Procedure FillCurrentCallStack();
Var
I:Integer;
prevbp: Pointer;
CallerFrame, CallerAddress, bp:Pointer;
Begin
_CurrentCallstackSize := 0;
bp := get_frame;
// This trick skip SendCallstack item
// bp:= get_caller_frame(get_frame);
Try
prevbp := bp - 1;
I := 0;
While bp > prevbp Do
Begin
CallerAddress := get_caller_addr(bp);
CallerFrame := get_caller_frame(bp);
if (CallerAddress = nil) then
Break;
_CurrentCallstack[_CurrentCallstackSize] := CallerAddress;
Inc(_CurrentCallstackSize);
Inc(I);
if (I >= StoredCallStackDepth) or (CallerFrame = nil) then
Break;
prevbp := bp;
bp := CallerFrame;
End;
{$IFDEF ANDROID}
//AdjustCallstack();
{$ENDIF}
Except
// prevent endless dump if an exception occured
End;
End;
Procedure FillExceptionCallStack(E:Exception);
Var
I:Integer;
Frames: PPointer;
Begin
_CurrentCallstack[0] := ExceptAddr;
Frames := ExceptFrames;
I := 0;
While (I<ExceptFrameCount) And (Succ(I)<StoredCallStackDepth) Do
Begin
_CurrentCallstack[Succ(I)] := Frames[I];
Inc(I);
End;
{$IFDEF ANDROID}
//AdjustCallstack();
{$ENDIF}
_CurrentCallstackSize := Succ(I);
End;
{$ENDIF}
Function GetCallstackString():String;
Var
I:Integer;
Begin
If _CurrentCallstackSize<=0 Then
Begin
Result := 'No call stack info present.';
Exit;
End;
Result := '';
For I:=0 To Pred(_CurrentCallstackSize) Do
Result := Result + BackTraceStrFunc(_CurrentCallstack[I]) + LineEnding;
End;
Function DumpCallstack:String;
Begin
FillCurrentCallStack();
Result := GetCallstackString();
End;
Function DumpExceptionCallStack(E: Exception):String;
Begin
FillExceptionCallStack(E);
Result := GetCallstackString();
End;
End.
|
unit uCadFornecedor;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, FireDAC.Stan.Intf,
FireDAC.Stan.Option, FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS,
FireDAC.Phys.Intf, FireDAC.DApt.Intf, FireDAC.Stan.Async, FireDAC.DApt,
Data.DB, FireDAC.Comp.DataSet, FireDAC.Comp.Client, Vcl.DBCtrls, Vcl.Grids,Entidade.Fornecedor,
Vcl.DBGrids, Vcl.StdCtrls, Vcl.Buttons, Vcl.Mask, Vcl.ExtCtrls, Vcl.ComCtrls,uEnum,uDTMConexao,
uTelaHerancaEntidade,SimpleDAO,SimpleInterface
,SimpleQueryFiredac,System.Generics.Collections, uDWResponseTranslator, uDWAbout, uDWConstsData,
uRESTDWPoolerDB;
type
TfrmCadFornecedor = class(TfrmTelaHerancaEntidade)
lbledtCodigo: TLabeledEdit;
lbledtNome: TLabeledEdit;
grpResidencia: TGroupBox;
lblCEP: TLabel;
lblTelefone: TLabel;
lbl13: TLabel;
lbl14: TLabel;
btnConsultaCEP: TSpeedButton;
lbledtEmail: TLabeledEdit;
lbledtBairro: TLabeledEdit;
lbledtRua: TLabeledEdit;
lbledtCidade: TLabeledEdit;
medtCEP: TMaskEdit;
medtTelefoneCel: TMaskEdit;
lbledtNumero: TLabeledEdit;
cbbUf: TComboBox;
medtTelFixo: TMaskEdit;
cbbTipo: TComboBox;
DWClientRESTCEP: TDWClientREST;
dwGetCEP: TRESTDWClientSQL;
DWResponseTranslatorCEP: TDWResponseTranslator;
lbl12: TLabel;
medtCpfcnpj: TMaskEdit;
lbltipo: TLabel;
procedure FormCreate(Sender: TObject);
procedure dsListagemDataChange(Sender: TObject; Field: TField);
procedure btnConsultaCEPClick(Sender: TObject);
procedure cbbTipoChange(Sender: TObject);
procedure DWClientRESTCEPBeforeGet(var AUrl: string;
var AHeaders: TStringList);
procedure btnCancelarClick(Sender: TObject);
procedure btnApagarClick(Sender: TObject);
procedure btnAlterarClick(Sender: TObject);
private
{ Private declarations }
function Apagar:Boolean; override;
function Gravar(EstadodoCadastro:TEstadoDoCadastro):Boolean; override;
function Listar:string;
public
{ Public declarations }
DAOFornecedor : iSimpleDAO<TFORNECEDOR>;
end;
var
frmCadFornecedor: TfrmCadFornecedor;
implementation
uses
uPrincipal;
{$R *.dfm}
{$REGION 'Override'}
function TfrmCadFornecedor.Apagar: Boolean;
var
tipo : TFORNECEDOR;
begin
if MessageDlg('Apagar o Registro: ' + #13 + #13 + 'Código: ' +
lbledtCodigo.Text + #13 + 'Descrição: ' + lbledtNome.Text,
mtConfirmation, [mbYes, mbNo], 0) = mrNO then
begin
Result:=False;
Abort;
end;
tipo := TFORNECEDOR.Create;
TRY
tipo.ID := StrToInt(lbledtCodigo.Text);
DAOFornecedor.Delete(tipo);
finally
Result:=true;
tipo.Free;
//btnBuscarClick(nil);
end;
end;
procedure TfrmCadFornecedor.btnAlterarClick(Sender: TObject);
begin
inherited;
lbledtCodigo.Text := dsListagem.DataSet.FieldByName('ID').AsString;
lbledtNome.Text := dsListagem.DataSet.FieldByName('NOMERAZAO').AsString;
lbledtEmail.Text:= dsListagem.DataSet.FieldByName('EMAIL').AsString;
lbledtRua.Text:= dsListagem.DataSet.FieldByName('RUA').AsString;
lbledtCidade.Text:=dsListagem.DataSet.FieldByName('CIDADE').AsString;
lbledtBairro.Text:=dsListagem.DataSet.FieldByName('BAIRRO').AsString;
lbledtNumero.Text:= dsListagem.DataSet.FieldByName('NUMERO').AsString;
cbbUf.Text:=dsListagem.DataSet.FieldByName('UF').AsString;
medtTelFixo.Text := dsListagem.DataSet.FieldByName('TELEFONE').AsString;
medtTelefoneCel.Text:= dsListagem.DataSet.FieldByName('CELULAR').AsString;
medtCEP.Text:=dsListagem.DataSet.FieldByName('CEP').AsString;
cbbTipo.Text:= dsListagem.DataSet.FieldByName('TIPO').AsString;
end;
procedure TfrmCadFornecedor.btnApagarClick(Sender: TObject);
begin
inherited;
Listar;
end;
procedure TfrmCadFornecedor.btnCancelarClick(Sender: TObject);
begin
inherited;
Listar;
end;
procedure TfrmCadFornecedor.btnConsultaCEPClick(Sender: TObject);
begin
inherited;
if Length(medtCEP.Text) = 8 then
begin
Screen.Cursor := crSQLWait;
dwGetCEP.Close;
dwGetCEP.Open;
if (dwGetCEP.FieldCount > 1) then
begin
{
https://viacep.com.br/ws/%s/json/
"cep": "88801-530",
"logradouro": "Rua João Pessoa",
"complemento": "até 743/744",
"bairro": "Centro",
"localidade": "Criciúma",
"uf": "SC",
"unidade": "",
"ibge": "4204608",
"gia": ""
}
lbledtRua.Text := dwGetCEP.FieldByName('logradouro').AsString;
lbledtBairro.Text := dwGetCEP.FieldByName('bairro').AsString;
lbledtCidade.Text := dwGetCEP.FieldByName('localidade').AsString;
cbbUf.ItemIndex := cbbUf.Items.IndexOf(dwGetCEP.FieldByName('uf').AsString);
end
else
ShowMessage('CEP não encontrado!');
Screen.Cursor := crDefault;
end
else
ShowMessage('CEP inválido, verifique!'+medtCEP.Text);
end;
procedure TfrmCadFornecedor.cbbTipoChange(Sender: TObject);
begin
inherited;
if cbbTipo.Text = 'F' then begin
lbltipo.Caption:= 'CPF';
medtCpfcnpj.EditMask:='###.###.###-##;0;_';
end else begin
lbltipo.Caption:= 'CNPJ';
medtCpfcnpj.EditMask:='##.###.###/####-##;0';
end;
end;
procedure TfrmCadFornecedor.dsListagemDataChange(Sender: TObject;
Field: TField);
begin
inherited;
lbledtCodigo.Text := dsListagem.DataSet.FieldByName('ID').AsString;
lbledtNome.Text := dsListagem.DataSet.FieldByName('NOMERAZAO').AsString;
lbledtEmail.Text:= dsListagem.DataSet.FieldByName('EMAIL').AsString;
lbledtRua.Text:= dsListagem.DataSet.FieldByName('RUA').AsString;
lbledtCidade.Text:=dsListagem.DataSet.FieldByName('CIDADE').AsString;
lbledtBairro.Text:=dsListagem.DataSet.FieldByName('BAIRRO').AsString;
lbledtNumero.Text:= dsListagem.DataSet.FieldByName('NUMERO').AsString;
cbbUf.Text:=dsListagem.DataSet.FieldByName('UF').AsString;
medtTelFixo.Text := dsListagem.DataSet.FieldByName('TELEFONE').AsString;
medtTelefoneCel.Text:= dsListagem.DataSet.FieldByName('CELULAR').AsString;
medtCEP.Text:=dsListagem.DataSet.FieldByName('CEP').AsString;
medtCpfcnpj.Text:=dsListagem.DataSet.FieldByName('CPFCNPJ').AsString;
end;
procedure TfrmCadFornecedor.DWClientRESTCEPBeforeGet(var AUrl: string;
var AHeaders: TStringList);
begin
inherited;
AUrl := format('https://viacep.com.br/ws/%s/json/', [medtCEP.Text]);
end;
procedure TfrmCadFornecedor.FormCreate(Sender: TObject);
begin
inherited;
DAOFornecedor:= TSimpleDAO<TFORNECEDOR>
.New(TSimpleQueryFiredac.Create(dtmPrincipal.ConexaoDB)).DataSource(dsListagem);
Listar;
end;
function TfrmCadFornecedor.Gravar(EstadodoCadastro: TEstadoDoCadastro): Boolean;
var
tipo : TFORNECEDOR;
begin
tipo := TFORNECEDOR.Create;
if lbledtCodigo.Text <>EmptyStr then begin
try
tipo.ID := StrToInt(lbledtCodigo.Text);
tipo.NOMERAZAO := lbledtNome.Text;
tipo.EMAIL := lbledtEmail.Text;
tipo.TELEFONE:= medtTelFixo.Text;
tipo.CELULAR:= medtTelefoneCel.Text;
tipo.RUA:= lbledtRua.Text;
tipo.BAIRRO:= lbledtBairro.Text;
tipo.NUMERO:= lbledtNumero.Text;
tipo.CIDADE:= lbledtCidade.Text;
tipo.CEP:= medtCEP.Text;
tipo.UF:= cbbUf.Text;
tipo.TIPO:=cbbTipo.Text;
tipo.USUARIO_CADASTRO:= oUsuarioLogado.nome;
tipo.CPFCNPJ := medtCpfcnpj.Text;
DAOFornecedor.Update(tipo);
finally
Result :=true;
tipo.Free;
Listar;
end;
end else begin
try
tipo.NOMERAZAO := lbledtNome.Text;
tipo.EMAIL := lbledtEmail.Text;
tipo.TELEFONE:= medtTelFixo.Text;
tipo.CELULAR:= medtTelefoneCel.Text;
tipo.RUA:= lbledtRua.Text;
tipo.BAIRRO:= lbledtBairro.Text;
tipo.NUMERO:= lbledtNumero.Text;
tipo.CIDADE:= lbledtCidade.Text;
tipo.CEP:= medtCEP.Text;
tipo.UF:= cbbUf.Text;
tipo.TIPO:=cbbTipo.Text;
tipo.CPFCNPJ := medtCpfcnpj.Text;
DAOFornecedor.Insert(tipo);
finally
Result :=true;
tipo.Free;
Listar;
end;
end;
end;
function TfrmCadFornecedor.Listar: string;
var
tipos : TList<TFORNECEDOR>;
tipo : TFORNECEDOR;
begin
tipos := DAOFornecedor.SQL.OrderBy('ID').&End.Find;
dbgrdListagem.Columns[0].Title.Caption:='Código';
dbgrdListagem.Columns[1].Title.Caption:='Nome';
dbgrdListagem.Columns[1].Width:=100;
end;
{$endregion}
end.
|
unit untDescricaoJson;
interface
type
DescricaoJson = class(TCustomAttribute)
private
FDescricao: string;
procedure SetDescricao(const Value: string);
public
constructor Create(Descricao: string);
property Descricao: string read FDescricao write SetDescricao;
end;
implementation
{ DescricaoJson }
constructor DescricaoJson.Create(Descricao: string);
begin
FDescricao := Descricao;
end;
procedure DescricaoJson.SetDescricao(const Value: string);
begin
FDescricao := Value;
end;
end.
|
unit abstract_document_lib;
interface
uses classes,sysUtils,actnList,introspected_streaming_class,abstract_command_lib,
comCtrls, UITypes, Types, Messages, streaming_class_lib;
type
TAbstractToolAction=class;
TAbstractDocument=class(TIntrospectedStreamingClass) //документ вместе со списком undo/redo
private
fOnDocumentChange: TNotifyEvent;
fOnLoad: TNotifyEvent;
fCriticalSection: TMultiReadExclusiveWriteSynchronizer;
fActionList: TActionList;
procedure SetOnDocumentChange(value: TNotifyEvent);
procedure SetOnLoad(value: TNotifyEvent);
protected
initial_pos: TAbstractCommand; //узнать, сместилось ли состояние после сохр.
new_commands_added: Boolean; //и добавлены ли новые команды
procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
procedure Notification(aComponent: TComponent; operation: TOperation); override;
public
SaveWithUndo: boolean;
StatusPanel: TStatusPanel;
DoneStatusPanel: TStatusPanel;
FileName: string;
constructor Create(Aowner: TComponent); override;
constructor LoadFromFile(const aFileName: string); override;
constructor LoadFromTemporaryFile(aFileName: string);
procedure AfterConstruction; override;
destructor Destroy; override;
procedure Release;
function NameExistsSomewhere(proposedName: string; me: TComponent=nil): boolean; override;
//для взаимодействия с ActionList
procedure RegisterActionList(value: TActionList);
procedure Undo;
procedure Redo;
procedure JumpToBranch(Branch: TAbstractCommand);
function isEmpty: Boolean;
function Changed: Boolean;
function DispatchCommand(command: TAbstractCommand): boolean;
procedure Save;
procedure Autosave;
procedure Change; virtual;
procedure DoLoad; virtual;
property onDocumentChange: TNotifyEvent read fOnDocumentChange write SetOnDocumentChange;
property onLoad: TNotifyEvent read fOnLoad write SetOnLoad;
property CriticalSection: TMultiReadExclusiveWriteSynchronizer read fCriticalSection;
published
UndoContainer: TAbstractCommandContainer;
Tool: TAbstractToolAction;
end;
TSavingThread=class(TThread)
private
fdoc: TAbstractDocument;
protected
procedure Execute; override;
public
constructor Create(docToSave: TAbstractDocument);
end;
TAbstractDocumentAction=class(TCustomAction)
protected
function GetDoc: TAbstractDocument;
public
function HandlesTarget(Target: TObject): Boolean; override;
function Update: Boolean; override;
published
property Caption;
property Hint;
property ImageIndex;
end;
TAbstractToolAction=class(TAbstractDocumentAction)
public
procedure SetStatusPanel(text: string);
destructor Destroy; override;
procedure ExecuteTarget(Target: TObject); override;
function Select: boolean; virtual; abstract;
procedure Unselect; virtual; abstract;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,Y: Integer); virtual; abstract;
procedure MouseMove(Shift: TShiftState; X,Y: Integer); virtual;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); virtual;
procedure MouseWheelUp(Shift: TShiftState; MousePos: TPoint; var Handled: Boolean); virtual;
procedure MouseWheelDown(Shift: TShiftState; MousePos: TPoint; var Handled: Boolean); virtual;
procedure KeyDown(var Msg: TWMKey; var Handled: Boolean); virtual;
end;
TAbstractToolActionClass=class of TAbstractToolAction;
IHistoryEvents = interface
['{9514240A-83A8-41A6-A6EC-6644F1EA98CC}']
procedure RefreshHistoryHighlights;
procedure ChangeHistory;
end;
//интерфейс-"флаг", что по логике работы программы, в документе имена компонентов
//зафиксированы, и значит, команды могут смело писать в caption текущие имена и пути,
//а не возвращаться "во времени" на момент выполнения, и не хранить лишние тексты в файле
IConstantComponentName = interface
['{6BD88A2A-129F-4FEE-8B55-F82906B4D1D7}']
end;
var CurProjectFileName: string='current_project.txt'; //not to translate
DocumentDefaultDir: string;
DocumentDefaultSaveFormat: TStreamingClassSaveFormat = sfAscii;
implementation
(*
TAbstractDocument
*)
constructor TAbstractDocument.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
SaveWithUndo:=true;
fCriticalSection:=TMultiReadExclusiveWriteSynchronizer.Create;
end;
constructor TAbstractDocument.LoadFromFile(const aFileName: string);
begin
inherited LoadFromFile(aFileName);
FileName:=aFileName;
new_commands_added:=false;
if UndoContainer<>nil then initial_pos:=UndoContainer.currentExecutedCommand;
end;
constructor TAbstractDocument.LoadFromTemporaryFile(aFileName: string);
begin
inherited LoadFromFile(aFileName);
new_commands_added:=false;
end;
procedure TAbstractDocument.afterConstruction;
var i: Integer;
buCurrent: TAbstractCommand;
iterator: TAbstractCommandIterator;
cur: TAbstractCommand;
begin
if UndoContainer=nil then begin
UndoContainer:=GetCommandContainerClass.Create(self);
UndoContainer.Name:='UndoContainer';
initial_pos:=UndoContainer.currentExecutedCommand;
end
else begin
buCurrent:=UndoContainer.currentExecutedCommand;
iterator:=UndoContainer.GetAllCommandsIterator;
try
while iterator.GetCommand(cur) do
cur.ResolveMemory;
finally
iterator.Free;
end;
UndoContainer.JumpToBranch(buCurrent);
end;
end;
procedure TAbstractDocument.Release;
begin
if Assigned(self) then begin
fCriticalSection.BeginWrite;
Destroy;
end;
end;
destructor TAbstractDocument.Destroy;
begin
UndoContainer.Free;
fCriticalSection.Free;
inherited Destroy;
end;
procedure TAbstractDocument.GetChildren(Proc: TGetChildProc; Root: TComponent);
var
i : Integer;
begin
for i := 0 to ComponentCount-1 do
if not (csSubComponent in Components[i].ComponentStyle) and
(((Components[i]<>UndoContainer) and (Components[i]<>Tool)) or SaveWithUndo) then
Proc(Components[i]);
end;
function TAbstractDocument.NameExistsSomewhere(proposedName: string; me: TComponent=nil): boolean;
var i: integer;
c: TComponent;
begin
c:=FindComponent(proposedName);
Result:=Assigned(c) and (c<>me);
if not Result then
for i:=0 to ComponentCount-1 do begin
if (Components[i] is TIntrospectedStreamingClass) and
not (Components[i]=UndoContainer) and
not (Components[i]=Tool) then begin
Result:=Result or
TIntrospectedStreamingClass(Components[i]).NameExistsSomewhere(proposedName,me);
if Result=true then break;
end;
end;
end;
procedure TAbstractDocument.Notification(aComponent: TComponent; operation: TOperation);
begin
if (operation=opRemove) and (aComponent=fActionList) then
fActionList:=nil;
inherited;
end;
function TAbstractDocument.Changed: Boolean;
begin
Result:=(UndoContainer.currentExecutedCommand<>initial_pos) or new_commands_added;
end;
procedure TAbstractDocument.RegisterActionList(value: TActionList);
begin
fActionList:=value;
if Assigned(value) then
value.FreeNotification(self); //если будет удаляться, то пусть мы об этом
//узнаем и выставим знач. в nil
end;
function TAbstractDocument.DispatchCommand(command: TAbstractCommand): Boolean;
var term: ITerminalCommand;
historyEvents: IHistoryEvents;
begin
//нужно проверить, имеем ли мы право выполнять команду в данном месте
if undoContainer.currentExecutedCommand.GetInterface(ITerminalCommand,term)
and undoContainer.UndoEnabled then
UndoContainer.Undo;
undoContainer.InsertComponent(command);
//может быть, не нужно исполнять конкретно эту команду, она уже есть
//именно когда обе команды еще не исполнены, их можно сравнивать
if undoContainer.CheckForExistingCommand(command) then begin
//состояние уже поменялось, мы выполнили существующую команду
change;
//но history не надо перестраивать, лишь указать тек. команду
if Assigned(fActionList) and
fActionList.GetInterface(IHistoryEvents,historyEvents) then
historyEvents.RefreshHistoryHighlights;
command.Free;
Result:=false;
end
else if command.Execute then begin
undoContainer.RemoveComponent(command);
undoContainer.Add(command);
Change;
if Assigned(fActionList) and
fActionList.GetInterface(IHistoryEvents, historyEvents) then
historyEvents.ChangeHistory;
new_commands_added:=true;
Result:=true;
end
else begin
command.Free;
Result:=false;
end;
end;
procedure TAbstractDocument.Save;
begin
TSavingThread.Create(self);
initial_pos:=UndoContainer.currentExecutedCommand;
new_commands_added:=false;
end;
procedure TAbstractDocument.Autosave;
var buCurDir: string;
buSaveFormat: TStreamingClassSaveFormat;
buSaveWithUndo: boolean;
begin
buCurDir:=GetCurrentDir;
buSaveFormat:=saveFormat;
buSaveWithUndo:=SaveWithUndo;
SetCurrentDir(DocumentDefaultDir);
SaveFormat:=DocumentDefaultSaveFormat;
SaveWithUndo:=true;
SaveToFile(CurProjectFileName);
saveFormat:=buSaveFormat;
SaveWithUndo:=buSaveWithUndo;
SetCurrentDir(buCurDir);
end;
procedure TAbstractDocument.Undo;
begin
if UndoTree.UndoEnabled then begin
// fCriticalSection.Acquire;
UndoTree.Undo;
// fCriticalSection.Leave;
Change;
if Assigned(fActionList) and (fActionList is TAbstractDocumentActionList) then
TAbstractDocumentActionList(fActionList).RefreshHistoryHighlights;
end;
end;
procedure TAbstractDocument.Redo;
begin
if UndoTree.RedoEnabled then begin
// fCriticalSection.Acquire;
UndoTree.Redo;
// fCriticalSection.Leave;
Change;
if Assigned(fActionList) and (fActionList is TAbstractDocumentActionList) then
TAbstractDocumentActionList(fActionList).RefreshHistoryHighlights;
end;
end;
procedure TAbstractDocument.JumpToBranch(Branch: TAbstractCommand);
begin
// fCriticalSection.Acquire;
UndoTree.JumpToBranch(Branch);
// fCriticalSection.Leave;
Change;
if Assigned(fActionList) and (fActionList is TAbstractDocumentActionList) then
TAbstractDocumentActionList(fActionList).RefreshHistoryHighlights;
end;
procedure TAbstractDocument.Change;
begin
if Assigned(onDocumentChange) then onDocumentChange(self);
end;
procedure TAbstractDocument.DoLoad;
begin
if Assigned(onLoad) then onLoad(self);
end;
function TAbstractDocument.UndoTree: TCommandTree;
begin
Result:=UndoContainer as TCommandTree;
end;
procedure TAbstractDocument.SetOnDocumentChange(value: TNotifyEvent);
begin
fOnDocumentChange:=value;
Change;
end;
procedure TAbstractDocument.SetOnLoad(value: TNotifyEvent);
begin
fOnLoad:=value;
DoLoad;
end;
(*
TSavingThread
*)
constructor TSavingThread.Create(docToSave: TAbstractDocument);
begin
inherited Create(true);
fdoc:=docToSave;
FreeOnTerminate:=true;
Resume;
end;
procedure TSavingThread.Execute;
begin
fdoc.fCriticalSection.Acquire;
fdoc.SaveToFile(fdoc.FileName);
fdoc.fCriticalSection.Leave;
end;
(*
TAbstractDocumentAction
*)
function TAbstractDocumentAction.GetDoc: TAbstractDocument;
begin
if (ActionList is TAbstractDocumentActionList) and Assigned(TAbstractDocumentActionList(ActionList).doc) then
Result:=TAbstractDocumentActionList(ActionList).doc^
else
Result:=nil;
//получается, что результат nil в след. случаях:
//- действие принадлежит неправильному ActionList'у (не имеющему свойства doc)
//- doc=nil, т.е. actionList ни на что не ссылается
//- doc^=nil, т.е actionList ссылается на переменную, которая ссылается на nil
end;
function TAbstractDocumentAction.HandlesTarget(Target: TObject): Boolean;
begin
//выполнима ли команда или пора ее сразу отключить, от греха подальше
Result:=Assigned(Target) and (Target is TAbstractDocument);
//классы-потомки могут начинать свою проверку с inherited HandlesTarget(Target) and ...
//по принципу short cut, если даже это ложно, дальше он не полезет.
end;
function TAbstractDocumentAction.Update: boolean;
var doc: TabstractDocument;
begin
inherited Update;
//это место будет вызываться когда не лень, чтобы выяснить, не надо ль
//отключить элем. управления или еще что-нибудь в этом духе
doc:=getDoc;
Enabled:=Assigned(doc);
Result:=true; //то есть мы выяснили все что хотели и дальше бегать не надо
//если отсутствует документ вообще, тогда разумеется и действие отключаем
end;
(*
TAbstractToolAction
*)
procedure TAbstractToolAction.ExecuteTarget(Target: TObject);
var doc: TAbstractDocument;
ToolClass: TAbstractToolActionClass;
begin
doc:=Target as TAbstractDocument;
//слишком много переливаний из порожнего в пустое
//надо все-таки разграничить классы - один отвечает за красивые кнопочки
//и их вкл/выкл вовремя
//а другой - за работу инструмента и сохранение данных в документе
//а пока оставим один класс, но упростим процедуры
ToolClass:=TAbstractToolActionClass(self.classType);
if Assigned(doc.Tool) then begin
if not (doc.Tool is ToolClass) then begin
doc.Tool.Unselect;
doc.Tool.Free;
doc.Tool:=ToolClass.Create(doc);
doc.Tool.Name:='Tool';
doc.Tool.Assign(self);
end;
end
else begin
doc.Tool:=ToolClass.Create(doc);
doc.Tool.Name:='Tool';
end;
doc.Tool.Select;
end;
destructor TAbstractToolAction.Destroy;
begin
inherited Destroy;
end;
procedure TAbstractToolAction.SetStatusPanel(text: string);
var data: TAbstractDocument;
begin
if (owner<>nil) then begin
data:=owner as TAbstractDocument;
if data.StatusPanel<>nil then
data.StatusPanel.Text:=text;
end;
end;
procedure TAbstractToolAction.KeyDown(var Msg: TWMKey; var Handled: Boolean);
begin
//далеко не всегда нужно реагировать на клавиши, поэтому сделаем "пустую" реализацию, чтобы
//не ругалась чуть что
end;
procedure TAbstractToolAction.MouseMove(Shift: TShiftState; X,Y: Integer);
begin
end;
procedure TAbstractToolAction.MouseUp(Button: TMouseButton; Shift: TShiftState; X,Y: Integer);
begin
end;
procedure TAbstractToolAction.MouseWheelUp(Shift: TShiftState; MousePos: TPoint;
var Handled: Boolean);
begin
Handled:=false;
end;
procedure TAbstractToolAction.MouseWheelDown(Shift: TShiftState; MousePos: TPoint;
var Handled: Boolean);
begin
Handled:=false;
end;
end.
|
{
Clever Internet Suite
Copyright (C) 2013 Clever Components
All Rights Reserved
www.CleverComponents.com
}
unit clTlsSocket;
interface
{$I clVer.inc}
{$IFDEF DELPHI7}
{$WARN UNSAFE_CODE OFF}
{$WARN UNSAFE_TYPE OFF}
{$WARN UNSAFE_CAST OFF}
{$ENDIF}
uses
{$IFNDEF DELPHIXE2}
Windows, Classes, SysUtils, SyncObjs,
{$ELSE}
Winapi.Windows, System.Classes, System.SysUtils, System.SyncObjs,
{$ENDIF}
clSocket, clSspi, clSspiTls, clCertificate, clCertificateStore;
type
TclVerifyPeerEvent = procedure (Sender: TObject; ACertificate: TclCertificate;
const AStatusText: string; AStatusCode: Integer; var AVerified: Boolean) of object;
TclTlsNetworkStream = class(TclNetworkStream)
private
FReadData: TStream;
FWriteData: TStream;
FSSPIBuffer: TStream;
FSSPI: TclTlsSspi;
FSSPIResult: TclSspiReturnCode;
FPacketSize: Integer;
FNeedAuthenticate: Boolean;
FWriteSize: Int64;
FOnGetCertificate: TclGetCertificateEvent;
FOnVerifyPeer: TclVerifyPeerEvent;
FCertificateFlags: TclCertificateVerifyFlags;
FTargetName: string;
FTLSFlags: TclTlsFlags;
FPeerVerified: Boolean;
FRequireClientCertificate: Boolean;
FSSPIAccess: TCriticalSection;
FEncryptedBytesProceed: Int64;
FCSP: string;
procedure Authenticate(ADestination: TStream);
procedure AfterRead(ABuffer, ADestination: TStream);
function WriteBuffer(ABuffer: TStream; ABufferSize: Integer): Boolean;
procedure DoUpdateProgress(ABytesProceed: Int64);
procedure DoStreamReady;
function GetSSPI: TclTlsSspi;
procedure FreeSSPI;
procedure VerifyPeer;
procedure SetCertificateFlags(const Value: TclCertificateVerifyFlags);
procedure SetTLSFlags(const Value: TclTlsFlags);
procedure SetRequireClientCertificate(const Value: Boolean);
procedure SetTargetName(const Value: string);
function GetPacketSize: Integer;
procedure SetCSP(const Value: string);
public
constructor Create;
destructor Destroy; override;
procedure Assign(ASource: TclNetworkStream); override;
procedure Close(ANotifyPeer: Boolean); override;
procedure StreamReady; override;
function Read(AData: TStream): Boolean; override;
function Write(AData: TStream): Boolean; override;
function GetReadBatchSize: Integer; override;
function GetWriteBatchSize: Integer; override;
function IsProceedLimit: Boolean; override;
procedure InitProgress; override;
procedure UpdateProgress(ABytesProceed: Int64); override;
procedure InitClientSession; override;
procedure InitServerSession; override;
property SSPI: TclTlsSspi read GetSSPI;
property TargetName: string read FTargetName write SetTargetName;
property CertificateFlags: TclCertificateVerifyFlags read FCertificateFlags write SetCertificateFlags;
property TLSFlags: TclTlsFlags read FTLSFlags write SetTLSFlags;
property RequireClientCertificate: Boolean read FRequireClientCertificate write SetRequireClientCertificate;
property CSP: string read FCSP write SetCSP;
property OnGetCertificate: TclGetCertificateEvent read FOnGetCertificate write FOnGetCertificate;
property OnVerifyPeer: TclVerifyPeerEvent read FOnVerifyPeer write FOnVerifyPeer;
end;
resourcestring
cReAuthNeeded = 'The connection must be re-negotiated';
implementation
uses
clSocketUtils{$IFDEF LOGGER}, clLogger{$ENDIF};
{ TclTlsNetworkStream }
procedure TclTlsNetworkStream.Close(ANotifyPeer: Boolean);
begin
ClearNextAction();
FSSPIResult := rcOK;
FSSPIBuffer.Size := 0;
try
FSSPIResult := SSPI.EndSession(FSSPIBuffer);
except
on EclSSPIError do;
end;
try
if ANotifyPeer and (FSSPIResult = rcCompleteNeeded) then
begin
if not WriteBuffer(nil, 0) then
begin
SetNextAction(saWrite);
end;
end;
except
on EclSocketError do;
end;
FNeedAuthenticate := False;
FSSPIResult := rcOK;
end;
constructor TclTlsNetworkStream.Create;
begin
inherited Create();
FSSPIAccess := TCriticalSection.Create();
FReadData := TMemoryStream.Create();
FWriteData := TMemoryStream.Create();
FSSPIBuffer := TMemoryStream.Create();
TLSFlags := [tfUseTLS];
FTargetName := FloatToStr(Now);
end;
destructor TclTlsNetworkStream.Destroy;
begin
FWriteData.Free();
FReadData.Free();
FSSPIBuffer.Free();
FreeSSPI();
FSSPIAccess.Free();
inherited Destroy();
end;
procedure TclTlsNetworkStream.FreeSSPI;
begin
FSSPIAccess.Enter();
try
FSSPI.Free();
FSSPI := nil;
FPeerVerified := False;
finally
FSSPIAccess.Leave();
end;
end;
function TclTlsNetworkStream.GetReadBatchSize: Integer;
begin
Result := inherited GetReadBatchSize() + GetPacketSize();
end;
function TclTlsNetworkStream.GetWriteBatchSize: Integer;
begin
Result := inherited GetWriteBatchSize() + GetPacketSize();
end;
function TclTlsNetworkStream.GetPacketSize: Integer;
begin
if (FPacketSize = 0) and (FSSPIResult = rcOK) then
begin
try
FPacketSize := Integer(SSPI.StreamSizes.cbHeader + SSPI.StreamSizes.cbTrailer);
except
on EclSSPIError do ;
end;
end;
Result := FPacketSize;
end;
function TclTlsNetworkStream.Read(AData: TStream): Boolean;
var
oldPos: Int64;
stream: TMemoryStream;
begin
{$IFDEF LOGGER}try clPutLogMessage(Self, edEnter, 'Read');{$ENDIF}
oldPos := -1;
if (AData <> nil) then
begin
oldPos := AData.Position;
end;
try
ClearNextAction();
Result := True;
if (FReadData.Size > 0) and (AData <> nil) then
begin
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'Read: if (FSSPIResult = rcOK)');{$ENDIF}
AData.CopyFrom(FReadData, 0);
FReadData.Size := 0;
end else
begin
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'Read: else of if (FSSPIResult = rcOK)');{$ENDIF}
if (AData = nil) then
begin
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'Read: else of if (FSSPIResult = rcOK), (AData = nil)');{$ENDIF}
AData := FReadData;
end;
stream := TMemoryStream.Create();
try
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'Read: before inherited Read, %d', nil, [stream.Size]);{$ENDIF}
inherited Read(stream);
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'Read: after inherited Read', stream, 0);{$ENDIF}
if (stream.Size > 0) then
begin
stream.Position := 0;
AfterRead(stream, AData);
end;
finally
stream.Free();
end;
end;
HasReadData := (FReadData.Size > 0);
if (FSSPIResult = rcReAuthNeeded) then
begin
SetNextAction(saWrite);
end else
if not (FSSPIResult in [rcOK, rcError, rcClosingNeeded]) then
begin
SetNextAction(saRead);
end;
finally
if (oldPos > -1) then
begin
DoUpdateProgress(AData.Size - oldPos);
end;
end;
{$IFDEF LOGGER}clPutLogMessage(Self, edLeave, 'Read'); except on E: Exception do begin clPutLogMessage(Self, edLeave, 'Read', E); raise; end; end;{$ENDIF}
end;
function TclTlsNetworkStream.Write(AData: TStream): Boolean;
begin
{$IFDEF LOGGER}try clPutLogMessage(Self, edEnter, 'Write');{$ENDIF}
ClearNextAction();
Result := True;
if FNeedAuthenticate then
begin
FNeedAuthenticate := False;
Authenticate(nil);
if (FSSPIResult <> rcOK) then
begin
SetNextAction(saRead);
end;
end else
if (AData <> nil) then
begin
while Result and (AData.Position < AData.Size) do
begin
if (FWriteData.Size = 0) then
begin
FWriteSize := AData.Size - AData.Position;
if (FWriteSize > Connection.BatchSize) then //TODO check Connection.BatchSize vs GetWriteBatchSize
begin
FWriteSize := Connection.BatchSize;
end;
Result := WriteBuffer(AData, FWriteSize);
if Result then
begin
DoUpdateProgress(FWriteSize);
AData.Position := AData.Position + FWriteSize;
end;
end else
begin
Result := WriteBuffer(nil, 0);
if Result then
begin
DoUpdateProgress(FWriteSize);
AData.Position := AData.Position + FWriteSize;
end;
end;
end;
end else
begin
Result := WriteBuffer(nil, 0);
if not Result then
begin
SetNextAction(saWrite);
end;
end;
{$IFDEF LOGGER}clPutLogMessage(Self, edLeave, 'Write'); except on E: Exception do begin clPutLogMessage(Self, edLeave, 'Write', E); raise; end; end;{$ENDIF}
end;
procedure TclTlsNetworkStream.Authenticate(ADestination: TStream);
var
cert: TclCertificate;
certList: TclCertificateList;
handled: Boolean;
begin
{$IFDEF LOGGER}try clPutLogMessage(Self, edEnter, 'Authenticate');{$ENDIF}
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, FSSPIBuffer.Position = %d, FSSPIBuffer.Size = %d', nil, [FSSPIBuffer.Position, FSSPIBuffer.Size]);
{$ENDIF}
certList := TclCertificateList.Create(False);
try
FPacketSize := 0;
FSSPIResult := SSPI.GenContext(FSSPIBuffer, certList, False);
if (FSSPIResult = rcCredentialNeeded) then
begin
cert := nil;
handled := False;
if Assigned(OnGetCertificate) then
begin
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, before OnGetCertificate');
{$ENDIF}
OnGetCertificate(Self, cert, certList, handled);
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, after OnGetCertificate');
{$ENDIF}
end;
if (cert <> nil) then
begin
certList.Add(cert);
end;
FSSPIResult := SSPI.GenContext(FSSPIBuffer, certList, True);
end;
if (FSSPIResult = rcCredentialNeeded) then
begin
RaiseSocketError(SSPIErrorQueryLocalCertificate, SSPI_E_QueryLocalCertificate);
end;
if (FSSPIResult in [rcOK, rcEncodeNeeded]) then
begin
VerifyPeer();
end;
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, before case FSSPIResult of, FSSPIBuffer.Position = %d, FSSPIBuffer.Size = %d', nil, [FSSPIBuffer.Position, FSSPIBuffer.Size]);
clPutLogMessage(Self, edInside, 'Authenticate, before case FSSPIResult of, FSSPIResult = %s', nil, [clSspiReturnCodes[FSSPIResult]]);
{$ENDIF}
case FSSPIResult of
rcAuthContinueNeeded:
begin
if not WriteBuffer(nil, 0) then
begin
SetNextAction(saWrite);
end;
FSSPIResult := rcAuthDataNeeded;
end;
rcEncodeNeeded:
begin
AfterRead(FSSPIBuffer, ADestination);
if (FSSPIResult <> rcMoreDataNeeded) and (FSSPIResult <> rcClosingNeeded) then
begin
FSSPIResult := rcOk;
end;
end;
rcOK:
begin
if (SSPI is TclTlsServerSspi) then
begin
FSSPIResult := rcAuthContinueNeeded;
if not WriteBuffer(nil, 0) then
begin
SetNextAction(saWrite);
end;
FSSPIResult := rcOk;
end;
end;
end;
finally
certList.Free();
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, inside finally, FSSPIBuffer.Position = %d, FSSPIBuffer.Size = %d', nil, [FSSPIBuffer.Position, FSSPIBuffer.Size]);
{$ENDIF}
if not (FSSPIResult in [rcOK, rcAuthContinueNeeded, rcAuthMoreDataNeeded]) then
begin
FSSPIBuffer.Size := 0;
end;
end;
if (FSSPIResult = rcOK) or (FSSPIResult = rcClosingNeeded) then
begin
DoStreamReady();
end;
{$IFDEF LOGGER}
clPutLogMessage(Self, edInside, 'Authenticate, before end, FSSPIBuffer.Position = %d, FSSPIBuffer.Size = %d', nil, [FSSPIBuffer.Position, FSSPIBuffer.Size]);
{$ENDIF}
{$IFDEF LOGGER}clPutLogMessage(Self, edLeave, 'Authenticate'); except on E: Exception do begin clPutLogMessage(Self, edLeave, 'Authenticate', E); raise; end; end;{$ENDIF}
end;
procedure TclTlsNetworkStream.AfterRead(ABuffer, ADestination: TStream);
var
oldPos: Int64;
begin
{$IFDEF LOGGER}try clPutLogMessage(Self, edEnter, 'AfterRead, ABuffer.Position = %d, ABuffer.Size = %d, FSSPIResult = %s', nil, [ABuffer.Position, ABuffer.Size, clSspiReturnCodes[FSSPIResult]]);{$ENDIF}
case FSSPIResult of
rcOk,
rcAuthDataNeeded:
begin
FSSPIBuffer.Size := 0;
FSSPIBuffer.CopyFrom(ABuffer, ABuffer.Size);
FSSPIBuffer.Position := 0;
if (FSSPIResult = rcAuthDataNeeded) then
begin
Authenticate(ADestination);
{$IFDEF LOGGER}clPutLogMessage(Self, edLeave, 'AfterRead, %d, Authenticate exit', nil, [FSSPIBuffer.Size]);{$ENDIF}
Exit;
end;
end;
rcAuthMoreDataNeeded,
rcMoreDataNeeded:
begin
oldPos := FSSPIBuffer.Position;
FSSPIBuffer.Position := FSSPIBuffer.Size;
FSSPIBuffer.CopyFrom(ABuffer, ABuffer.Size);
FSSPIBuffer.Position := oldPos;
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'AfterRead, oldPos = %d', nil, [oldPos]);{$ENDIF}
if (FSSPIResult = rcAuthMoreDataNeeded) then
begin
Authenticate(ADestination);
{$IFDEF LOGGER}clPutLogMessage(Self, edLeave, 'AfterRead, %d, Authenticate exit', nil, [FSSPIBuffer.Size]);{$ENDIF}
Exit;
end;
end;
end;
Assert(ADestination <> nil);
FSSPIResult := SSPI.Decrypt(FSSPIBuffer, ADestination, FSSPIBuffer);
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'AfterRead, FSSPI.Decrypt %s', nil, [clSspiReturnCodes[FSSPIResult]]);{$ENDIF}
case FSSPIResult of
rcOk: FSSPIBuffer.Size := 0;
rcReAuthNeeded:
begin
FSSPIBuffer.Size := 0;
FNeedAuthenticate := True;
end;
rcContinueAndMoreDataNeeded: FSSPIResult := rcMoreDataNeeded;
end;
if (FSSPIResult = rcClosingNeeded) then
begin
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'AfterRead: Self.NeedClose := True');{$ENDIF}
NeedClose := True;
end;
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'AfterRead, %d', nil, [ADestination.Size]);{$ENDIF}
{$IFDEF LOGGER}
clPutLogMessage(Self, edLeave, 'AfterRead, %d', nil, [FSSPIBuffer.Size]);
except on E: Exception do begin clPutLogMessage(Self, edLeave, 'AfterRead, %d', E, [FSSPIBuffer.Size]); raise; end; end;
{$ENDIF}
end;
function TclTlsNetworkStream.WriteBuffer(ABuffer: TStream; ABufferSize: Integer): Boolean;
begin
if (FWriteData.Size = 0) then
begin
if not (FSSPIResult in [rcCompleteNeeded, rcAuthContinueNeeded]) then
begin
Assert(ABuffer <> nil);
FSSPIBuffer.Size := 0;
SSPI.Encrypt(ABuffer, FSSPIBuffer, ABufferSize);
FWriteData.CopyFrom(FSSPIBuffer, FSSPIBuffer.Size);
FSSPIBuffer.Position := 0;
end else
begin
Assert(ABuffer = nil);
FWriteData.CopyFrom(FSSPIBuffer, FSSPIBuffer.Size);
FSSPIBuffer.Size := 0;
end;
FWriteData.Position := 0;
end;
Result := inherited Write(FWriteData);
if Result then
begin
FWriteData.Size := 0;
end;
end;
procedure TclTlsNetworkStream.UpdateProgress(ABytesProceed: Int64);
begin
{$IFDEF LOGGER}clPutLogMessage(Self, edInside, 'UpdateProgress, FEncryptedBytesProceed=%d, ABytesProceed=%d', nil, [FEncryptedBytesProceed, ABytesProceed]);{$ENDIF}
FEncryptedBytesProceed := FEncryptedBytesProceed + ABytesProceed;
end;
procedure TclTlsNetworkStream.DoUpdateProgress(ABytesProceed: Int64);
begin
inherited UpdateProgress(ABytesProceed);
end;
function TclTlsNetworkStream.GetSSPI: TclTlsSspi;
begin
FSSPIAccess.Enter();
try
Result := FSSPI;
Assert(Result <> nil);
finally
FSSPIAccess.Leave();
end;
end;
function TclTlsNetworkStream.IsProceedLimit: Boolean;
begin
Result := inherited IsProceedLimit()
or ((Connection.BytesToProceed > -1) and (Connection.BytesToProceed <= FEncryptedBytesProceed));
end;
procedure TclTlsNetworkStream.StreamReady;
begin
end;
procedure TclTlsNetworkStream.DoStreamReady;
begin
inherited StreamReady();
end;
procedure TclTlsNetworkStream.VerifyPeer;
var
statusText: string;
begin
if FPeerVerified then Exit;
FPeerVerified := SSPI.Certified;
statusText := GetSSPIErrorMessage(SSPI.StatusCode);
if Assigned(OnVerifyPeer) then
begin
OnVerifyPeer(Self, SSPI.PeerCertificate, statusText, SSPI.StatusCode, FPeerVerified);
end;
if not FPeerVerified then
begin
RaiseSocketError(statusText, SSPI.StatusCode);
end;
end;
procedure TclTlsNetworkStream.InitClientSession;
begin
FSSPIAccess.Enter();
try
FreeSSPI();
FSSPI := TclTlsClientSspi.Create();
TclTlsClientSspi(FSSPI).TargetName := TargetName;
FSSPI.CertificateFlags := CertificateFlags;
FSSPI.TLSFlags := TLSFlags;
FSSPI.CSP := CSP;
FSSPIBuffer.Size := 0;
FNeedAuthenticate := True;
SetNextAction(saWrite);
finally
FSSPIAccess.Leave();
end;
end;
procedure TclTlsNetworkStream.InitServerSession;
begin
FSSPIAccess.Enter();
try
FreeSSPI();
FSSPI := TclTlsServerSspi.Create();
TclTlsServerSspi(FSSPI).RequireClientCertificate := RequireClientCertificate;
FSSPI.CertificateFlags := CertificateFlags;
FSSPI.TLSFlags := TLSFlags;
FSSPI.CSP := CSP;
FSSPIBuffer.Size := 0;
FSSPIResult := rcAuthDataNeeded;
FNeedAuthenticate := False;
SetNextAction(saRead);
finally
FSSPIAccess.Leave();
end;
end;
procedure TclTlsNetworkStream.InitProgress;
begin
inherited InitProgress();
FEncryptedBytesProceed := 0;
end;
procedure TclTlsNetworkStream.SetCertificateFlags(const Value: TclCertificateVerifyFlags);
begin
FCertificateFlags := Value;
if (FSSPI <> nil) then
begin
FSSPI.CertificateFlags := FCertificateFlags;
end;
end;
procedure TclTlsNetworkStream.SetCSP(const Value: string);
begin
FCSP := Value;
if (FSSPI <> nil) then
begin
FSSPI.CSP := FCSP;
end;
end;
procedure TclTlsNetworkStream.SetRequireClientCertificate(const Value: Boolean);
begin
FRequireClientCertificate := Value;
if (FSSPI <> nil) and (FSSPI is TclTlsServerSspi) then
begin
TclTlsServerSspi(FSSPI).RequireClientCertificate := FRequireClientCertificate;
end;
end;
procedure TclTlsNetworkStream.SetTargetName(const Value: string);
begin
FTargetName := Value;
if (FSSPI <> nil) and (FSSPI is TclTlsClientSspi) then
begin
TclTlsClientSspi(FSSPI).TargetName := FTargetName;
end;
end;
procedure TclTlsNetworkStream.SetTLSFlags(const Value: TclTlsFlags);
begin
FTLSFlags := Value;
if (FSSPI <> nil) then
begin
FSSPI.TLSFlags := FTLSFlags;
end;
end;
procedure TclTlsNetworkStream.Assign(ASource: TclNetworkStream);
var
src: TclTlsNetworkStream;
begin
inherited Assign(ASource);
if (ASource is TclTlsNetworkStream) then
begin
src := ASource as TclTlsNetworkStream;
FTargetName := src.TargetName;
FCertificateFlags := src.CertificateFlags;
FTLSFlags := src.TLSFlags;
FRequireClientCertificate := src.RequireClientCertificate;
FCSP := src.CSP;
end;
end;
end.
|
program RPN;
{$CODEPAGE UTF-8}
{----------------------------------}
{ О структуре комментариев }
{Все подпрограммы разбиты на блоки }
{исходя из того, для чего они }
{были созданы. Но это не исключает }
{их дальнейшего использования в }
{подпрограммах других блоков. }
{Здесь и далее начало блока будет }
{обрамляться "***", конец "@@@@", }
{а примечания с }
{помощью знаков "---" }
{----------------------------------}
const NUM_OF_OP = 8; //Максимальное число операторов в таблице операторов
MAX_LENGTH_OF_OPERATOR = 2; //Максимальная длина оператора
MAX_VARIABLE_NAME_LENGTH = 5; //Максимальная длина имени переменной
AMOUNT_OF_NUMERALS = 10; //Количество цифр в таблице цифр
type t_max_str_op = string[MAX_LENGTH_OF_OPERATOR]; //Строка оператора. Устанавливается длина для уменьшения занимаемой памяти
t_array_of_op = array [1 .. NUM_OF_OP] of t_max_str_op; //Массив строк операторов
t_array_of_op_pri = array [1 .. NUM_OF_OP] of byte; //Массив приоритетов операторов
t_array_of_numerals_chars = array [1 .. AMOUNT_OF_NUMERALS] of char; //Символы цифр, используемых в вычислениях
t_p_complex = ^t_complex; //Указатель на комплексное число
t_p_node = ^t_node; //Указатель на узел стека или списка
t_p_cell = ^t_cell; //Указатель на ячейку вычисл. выражения
t_p_variable = ^t_variable; //Указатель на переменную
t_p_max_str_op = ^t_max_str_op; //Указатель на строку оператора
t_p_string = ^string; //Указатель на строку
t_complex = record {Комплексное число}
re : real;
im : real;
end;
t_node = record {Узел стека или списка}
data : pointer; //Указатель на данные, хранящиеся в узле
link : t_p_node; // Указатель на следующий узел
end;
t_stack = record {Стек. Содержит только указатель на вершину}
head : t_p_node;
end;
t_list = record {Список. Содержит только указатель на начало}
start : t_p_node;
end;
t_operators_table = record {Таблица операторов}
op_s : t_array_of_op; // Строковые представления операторов
op_p : t_array_of_op_pri; // Приоритеты операторов
end;
t_RPN_expression = record {Выражение в ОПЗ}
expres : string; // Строковое представление выражения
st : t_stack; // Стек для преобразования выражения, содержащий операторы
end;
t_cell = record {Ячейка вычисляемого выражения}
type_c : string[3]; // Тип ячейки
data : pointer; // Указатель на данные в ячейке
end;
t_variable = record {Переменная выражения}
name : string[MAX_VARIABLE_NAME_LENGTH]; //Имя переменной
value : pointer; //Указатель на значение переменной
end;
t_calculated_RPN_expression = record {Вычисляемое выражение в ОПЗ}
expres : t_list; // Список ячеек выражения. Каждая ячейка - оператор или операнд
variables : t_list; // Список переменных выражения
st : t_stack; // Стек для вычислений
inter_res : t_list; // Список промежуточных итогов вычислений
end;
const OPERATORS : t_operators_table = (op_s : ('(', ')', '-', '~', '+', '*', '/', 'ln'); op_p : (1, 1, 2, 4, 2, 3, 3, 5));
NUMERALS : t_array_of_numerals_chars = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
{----------------------------------}
{ Про таблицу операторов }
{ OPERATORS }
{Оператарами условно названо все, }
{что не является операндом. Sin, ln}
{и т.п называются операторами. }
{При изменении таблицы операторов }
{учтите, что если оператор имеет }
{и унарную, и бинарную функцию, }
{как, например, минус, то вы должны}
{расположить отдельный символ для }
{обозначения унарной операции сразу}
{после бинарной в табл. операторов }
{----------------------------------}
{----------------------------------}
{ Про таблицу цифр }
{ NUMERALS }
{Она составлена на случай того, }
{если понадобится использовать }
{систему счисления, отличную от 10й}
{Изменение таблицы на данный момент}
{повлияет лишь на то, какой тип }
{будет присвоен ячейке вычисляемого}
{выражения на этапе преобразования }
{строки ОПЗ в вычисл. выражение. }
{Определять операции над числами }
{и т.п. в другой СС }
{необходимо самостоятельно }
{----------------------------------}
{**********************************}
{Базовые операции над структурами }
{**********************************}
{* Присваивает строковому представлению выражения в ОПЗ expres пустую строку, а указателю вершины стека - nil}
procedure create_expression(var expres : t_RPN_expression);
begin
expres.expres := '';
expres.st.head := nil;
end;
{* Присваивает указателю начала списка ячеек, списка переменных, списка промежуточных итогов
* и указателю вершины стека вычисляемого выражения в ОПЗ expres значение nil}
procedure create_calculated_express(var expres : t_calculated_RPN_expression);
begin
expres.expres.start := nil;
expres.variables.start := nil;
expres.st.head := nil;
expres.inter_res.start := nil;
end;
{* Добавляет указатель pt на вершину стека stack}
procedure push(var stack : t_stack; var pt : pointer);
var p_node : t_p_node;
begin
new(p_node);
p_node^.link := stack.head;
p_node^.data := pt;
stack.head := p_node;
end;
{* Присваивает указателю pt указатель, хранящийся на вершине стека, удаляя его из стека}
procedure pop(var stack : t_stack; var pt : pointer);
var t : t_p_node;
begin
t := stack.head;
pt := stack.head^.data;
stack.head := t^.link;
dispose(t);
end;
{* Присваивает указателю p_node указатель на начало списка list}
procedure link_node_list_start(const list : t_list; var p_node : t_p_node);
begin
p_node := list.start;
end;
{* Добавляет указатель pt в конец списка list, как элемент списка }
procedure push_last(var list : t_list; var pt : pointer);
var p_node, p_nd_list : t_p_node;
begin
new(p_node);
p_node^.data := pt;
p_node^.link := nil;
if list.start = nil then
list.start := p_node
else
begin
link_node_list_start(list, p_nd_list);
while p_nd_list^.link <> nil do
p_nd_list := p_nd_list^.link;
p_nd_list^.link := p_node;
end;
end;
{* Присваивает указателю pt указатель элемента, хранящейся в начале списка list, удаляя его списка}
procedure pop_first(var list : t_list; var pt : pointer);
var p_nd_list : t_p_node;
begin
p_nd_list := list.start;
list.start := list.start^.link;
pt := p_nd_list^.data;
dispose(p_nd_list);
end;
{* Очищает память, занимаемую узлами списка list, а так же блоки памяти размера n байт, на которые указывают указатели, хранящиеся в каждом узле.
* Будьте осторожны: данная процедура не сможет полностью очистить память, если указатели узлов указывают на блоки памяти разной длины,
* или они указывают на блоки памяти, которые занимают структуры, имеющие свои указатели на динамические переменные}
procedure clear_list(var list : t_list; const n : byte);
var p : pointer;
begin
while list.start <> nil do
begin
pop_first(list, p);
freeMem(p, n);
end;
end;
{* Присваивает указателю p_element указатель, хранящийся в узле p_node.
* p_node, обязанный быть узлом списка или стека, начинает указывать на следующий узел.
* Будьте осторожны: подпрограмма не отслеживает ситуации, когда p_node указывает на nil.
* Если вы попробуете получить элемент за границей стека или списка - произойдет ошибка времени выполнения}
procedure take_implicitly_element(var p_node : t_p_node; var p_element : pointer);
begin
p_element := p_node^.data;
p_node := p_node^.link;
end;
{* Присваивает указателю p_elemnt указатель, хранящийся в узле списка list с номером n. Указатель из списка НЕ удаляется
* Будьте осторожны: если вы укажите n больше, чем количество узлов списка - произойдет ошибка времени выполнения}
procedure take_list_element_by_num(const list : t_list; const n : byte; var p_element : pointer);
var i : byte;
p_node : t_p_node;
begin
i := 1;
p_node := list.start;
while i < n do
begin
p_node := p_node^.link;
i += 1;
end;
p_element := p_node^.data;
end;
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{**********************************}
{ПОДПРОГРАММЫ ПРЕОБРАЗОВАНИЯ В ОПЗ }
{**********************************}
{* Возвращает номер строкового представления оператора opr из таблицы операторов OPERATORS.
* Если opr не является строковым представлением оператора - функция возвращает значение 0}
function num_of_operator(const opr : string) : byte;
var i : byte;
begin
i := 1;
while (i <= NUM_OF_OP) and (opr <> OPERATORS.op_s[i]) do
i += 1;
if i > NUM_OF_OP then
i := 0;
num_of_operator := i;
end;
{* Возвращает слово, считанное с индекса i в строке s,
* пропуская предшествующие пустые символы и присваивая параметру i
* номер символа после считанного слова. Если нет слова - возвращает пустую строку}
function get_word(const s : string; var i : byte) : string;
var part : string;
len : byte;
begin
len := length(s);
while (s[i] <= ' ') and (i <= len) do
i += 1;
part := '';
while (s[i] > ' ') and (i <= len) do
begin
part := part + s[i];
i := i + 1;
end;
get_word := part;
end;
{* Возвращает значение "истина", если символ ch является частью таблицы чисел NUMERALS.
* Иначе - возвращает значение "ложь"}
function char_is_part_of_num_table(const ch : char) : boolean;
var i : byte;
begin
i := 1;
while (i < AMOUNT_OF_NUMERALS) and (NUMERALS[i] <> ch) do
i += 1;
char_is_part_of_num_table := ch = NUMERALS[i];
end;
{* Возвращает значение "истина", если первый символ строки str
* является частью таблицы чисел NUMERALS. Иначе - возвращает значение "ложь"}
function is_const(const str : string) : boolean;
begin
is_const := char_is_part_of_num_table(str[1]);
end;
{* Возвращает значение "истина", если приоритет оператора а больше или равен приоритету оператора b.
* Иначе - возвращает значение "ложь"}
function priority_comp(const a, b : byte) : boolean;
begin
priority_comp := OPERATORS.op_p[a] >= OPERATORS.op_p[b];
end;
{Возвращает значение разыменованного указателя p_opr. Указатель p_opr должен указывать на строковое представление оператора}
function get_operator(const p_opr : t_p_max_str_op) : t_max_str_op;
begin
get_operator := p_opr^;
end;
{* Пока приоритет оператора с номером op_n из таблицы операторов OPERATORS больше или равен
* приоритету оператора на вершине стека выражения expres - оператор с вершины стека удаляется
* и добавляется в строкове представление выражения expres}
procedure pop_operators(var expres : t_RPN_expression; const op_n : byte);
var p_opr : t_p_max_str_op;
p_head : t_p_node;
begin
p_opr := expres.st.head^.data;
p_head := expres.st.head;
while (p_head <> nil) and (priority_comp(num_of_operator(p_opr^), op_n)) do
begin
expres.expres := expres.expres + p_opr^ + ' ';
expres.st.head := p_head^.link;
dispose(p_head);
p_head := expres.st.head;
if p_head <> nil then
p_opr := expres.st.head^.data;
end;
end;
{* Пока в стеке выражения expres не встретится закрывающая скобка "(" -
* операторы будут удаляться с вершины стека и добавляться
* в строковое представление выражения expres.
* Закрывающая скобка будет удалена из стека, но не добавлена в строкове представление}
procedure end_bracket_pushing(var expres : t_RPN_expression);
var pt : t_p_max_str_op;
begin
while get_operator(expres.st.head^.data) <> '(' do
begin
pop(expres.st, pt);
expres.expres := expres.expres + pt^ + ' ';
end;
pop(expres.st, pt);
end;
{* Добавляет к номеру оператора op_n единицу, если он имеет
* бинарную форму в таблице операторов OPERATORS}
procedure binary_to_unary(var op_n : byte);
begin
case OPERATORS.op_s[op_n] of
'-' : op_n += 1;
end;
end;
{* Обновляет стек операторов и строкове представление выражения expres по правилам ОПЗ в зависимости от того,
* является ли оператор с номером op_n в таблице операторов OPERATORS унарным (определяется значением параметр is_un. Унарный - "истина", иначе - "ложь"),
* и какое строковое представление имеет}
procedure update_expression_operators(var expres : t_RPN_expression; var op_n : byte; const is_un : boolean);
var p : t_p_max_str_op;
begin
if is_un then
binary_to_unary(op_n);
p := @OPERATORS.op_s[op_n];
case p^ of
'(' : push(expres.st, p);
')' : end_bracket_pushing(expres);
else
begin
if expres.st.head <> nil then
pop_operators(expres, op_n);
push(expres.st, p);
end;
end;
end;
{* Удаляет все операторы из стека операторов выражения expres,
* добавляя их в строковое представление}
procedure pop_stack_of_expres(var expres : t_RPN_expression);
var p_opr : t_p_max_str_op;
begin
while expres.st.head <> nil do
begin
pop(expres.st, p_opr);
expres.expres := expres.expres + p_opr^ + ' ';
end;
end;
{* Возвращает строку, которая является записью строки s, содержащей математическое выражение,
* по правилам ОПЗ}
function trans_expression_to_RPN(const s : string) : string;
var part : string;
i, num_op : byte;
expres : t_RPN_expression;
is_un : boolean;
begin
create_expression(expres);
i := 1;
is_un := True;
part := get_word(s, i);
while part <> '' do
begin
num_op := num_of_operator(part);
if num_op = 0 then
expres.expres := expres.expres + part + ' '
else
update_expression_operators(expres, num_op, is_un);
is_un := num_op <> 0;
part := get_word(s, i);
end;
pop_stack_of_expres(expres);
trans_expression_to_RPN := expres.expres;
end;
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{**********************************}
{Подпрограммы создания на основе }
{строки с выражением, записанным }
{в ОПЗ, вычисляемого выражения }
{**********************************}
{* Возвращает имя переменной, указатель на которую хранится в узле p_node}
function take_variable_name_from_node(const p_node : t_p_node) : string;
var p_var : t_p_variable;
begin
p_var := p_node^.data;
take_variable_name_from_node := p_var^.name
end;
{* Возвращает значение "истина", если переменная с именем name входит в список list, присваивая параметру i её номер в списке.
* Иначе - возвращает значение "ложь"}
function is_variable_in_list(const list : t_list; const name : string; var i : byte) : boolean;
var p_nd_list : t_p_node;
begin
link_node_list_start(list, p_nd_list);
i := 1;
while (p_nd_list <> nil) and (take_variable_name_from_node(p_nd_list) <> name) do
begin
i += 1;
p_nd_list := p_nd_list^.link;
end;
is_variable_in_list := p_nd_list <> nil;
end;
{* Возвращает количество слов в строке s}
function count_words(const s : string) : byte;
var i, n : byte;
begin
n := 0;
i := 1;
while get_word(s, i) <> '' do
n += 1;
count_words := n;
end;
{* Возвращает строку, являющуюся действительной частью комплексного числа, записанного в строку complex_str;
* параметру i присваивается номер символа после действительной части.
* Если действительной части нет - возвращает строку '0', параметру i присваивается значение 1}
function take_real_part(const complex_str : string; var i : byte) : string;
var len : byte;
res : string;
begin
len := length(complex_str);
res := '';
while (i <= len) and (complex_str[i] <> '+') and (complex_str[i] <> '-') do
begin
res := res + complex_str[i];
i += 1;
end;
if complex_str[i - 1] = 'i' then
begin
i := 1;
res := '0';
end;
take_real_part := res;
end;
{* Возвращает строку, являющуюся мнимой частью комплексного числа, записанного в строку complex_str;
* параметру i присваивается номер символа, где находится мнимая единица.
* Если мнимой части нет - возвращает строку 0}
function take_imaginary_part(const complex_str : string; var i : byte) : string;
var len : byte;
res : string;
begin
len := length(complex_str);
res := '';
while i < len do
begin
res := res + complex_str[i];
i += 1;
end;
if res = '' then
res := '0';
take_imaginary_part := res;
end;
{* Присваивает комплексному числу, хранящемуся по указателю p_complex значение комплексного числа из строки complex_str}
procedure construct_complex(var p_complex : t_p_complex; const complex_str : string);
var i, code : byte;
number : string;
begin
i := 1;
number := take_real_part(complex_str, i);
val(number, p_complex^.re, code);
number := take_imaginary_part(complex_str, i);
val(number, p_complex^.im, code);
end;
{* Создает переменную с именем name и записывает указатель на неё в ячейку по указателю p_cell}
procedure form_var_cell(var p_cell : t_p_cell; const name : string);
var p_var : t_p_variable;
begin
new(p_var);
p_var^.name := name;
p_cell^.data := p_var;
end;
{* Создает комплексное число из строки complex_str и записывает указатель на него в ячейку по указателю p_cell}
procedure form_con_cell(var p_cell : t_p_cell; const complex_str : string);
var p_complex : t_p_complex;
begin
new(p_complex);
construct_complex(p_complex, complex_str);
p_cell^.data := p_complex;
end;
{* Записывает в ячейку по указателю p_cell адрес оператора со строковым представлением opr_s в таблице операторов OPERATORS}
procedure form_opr_cell(var p_cell : t_p_cell; const opr_s : string);
begin
p_cell^.data := @OPERATORS.op_s[num_of_operator(opr_s)];
end;
{* Записывает в ячейку по указателю p_cell указатель переменную, константу или оператор с данными из строки data,
* если тип ячейки по указателю p_cell равен var, con или opr соответственно }
procedure create_data_cell(var p_cell : t_p_cell; const data : string);
begin
case p_cell^.type_c of
'var' : form_var_cell(p_cell, data);
'con' : form_con_cell(p_cell, data);
'opr' : form_opr_cell(p_cell, data);
end;
end;
{* Возвращает строку с типом ячейки, в которой будут храниться данные из строки data,
* как var, con или opr, если data - это имя переменной, константа или оператор соответственно}
function cell_type(const data : string) : string;
var num_opr : byte;
type_of_cell : string;
begin
num_opr := num_of_operator(data);
if num_opr = 0 then
begin
if is_const(data) then
type_of_cell := 'con'
else
type_of_cell := 'var';
end
else
type_of_cell := 'opr';
cell_type := type_of_cell;
end;
{* Присваивает указателю значения переменной по указателю p_variable указатель на значение переменной по указателю p_var_main}
procedure add_link_to_variable(const p_var_main : t_p_variable; var p_variable : t_p_variable);
begin
p_variable^.value := p_var_main^.value;
end;
{* Создает переменную по указателю p_variable_main, присваивая её указателю на значение указатель на комплексное в динамической памяти.
* Указателю на значение переменной по указателю p_variable так же присваивается указатель на это комплексное.
* Переменной по указателю p_variable_name присваивается имя переменной по указателю p_variable}
procedure create_variable_main (var p_variable, p_variable_main : t_p_variable);
var p_complex : t_p_complex;
begin
new(p_variable_main);
new(p_complex);
p_variable_main^.value := p_complex;
p_variable^.value := p_variable_main^.value;
p_variable_main^.name := p_variable^.name;
end;
{* Обновляет список переменных list_of_var, добавляя в него указатель на переменную p_variable, или
* если переменная с таким же именем, как у переменной по указателю p_variable, уже имеется в списке -
* то указателю на значение переменной по указателю p_variable присваивается указатель на значение переменной с таким же именем,
* которая уже есть в списке list_of_var}
procedure update_list_of_variables(var list_of_var : t_list; var p_variable : t_p_variable);
var i : byte;
p_var_main : t_p_variable;
begin
if is_variable_in_list(list_of_var, p_variable^.name, i) then
begin
take_list_element_by_num(list_of_var, i, p_var_main);
add_link_to_variable(p_var_main, p_variable);
end
else
begin
create_variable_main(p_variable, p_var_main);
push_last(list_of_var, p_var_main);
end;
end;
{* Преобразует строку expres_s, в которой содержится выражение, записанное в ОПЗ, в вычисляемое выражение
* и записывает его в вычисляемое выражение expres_calc}
procedure string_into_calculated(const expres_s : string; var expres_calc : t_calculated_RPN_expression);
var part : string;
cell : t_p_cell;
j, i : byte;
begin
create_calculated_express(expres_calc);
j := 1;
for i := 1 to count_words(expres_s) do
begin
part := get_word(expres_s, j);
new(cell);
cell^.type_c := cell_type(part);
create_data_cell(cell, part);
push_last(expres_calc.expres, cell);
if cell^.type_c = 'var' then
update_list_of_variables(expres_calc.variables, cell^.data);
end;
end;
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{**********************************}
{Подпрограммы вычисления значения }
{вычисляемого выражения }
{**********************************}
{* Читает значения переменных вычисляемого выражения expres, вводимые пользователем}
procedure read_variables(var expres : t_calculated_RPN_expression);
var data : string;
p_node : t_p_node;
p_var : t_p_variable;
p_complex : t_p_complex;
begin
link_node_list_start(expres.variables, p_node);
repeat
take_implicitly_element(p_node, p_var);
write('Введите значение переменной ', p_var^.name, ': ');
readln(data);
p_complex := p_var^.value;
construct_complex(p_complex, data);
until p_node = nil;
end;
{* Присваивает по указателю p_res результат сложения комплексных чисел по указателям p_comp1 и p_comp2}
procedure addition(var p_comp1, p_comp2, p_res : t_p_complex);
begin
p_res^.re := p_comp1^.re + p_comp2^.re;
p_res^.im := p_comp1^.im + p_comp2^.im;
end;
{* Присваивает по указателю p_res результат вычитания комплексных чисел по указателям p_comp1 и p_comp2}
procedure subtraction(var p_comp1, p_comp2, p_res : t_p_complex);
begin
p_res^.re := p_comp2^.re - p_comp1^.re;
p_res^.im := p_comp2^.im - p_comp1^.im;
end;
{* Присваивает по указателю p_res результат умножения комплексных чисел по указателям p_comp1 и p_comp2}
procedure multiplication(var p_comp1, p_comp2, p_res : t_p_complex);
begin
p_res^.re := p_comp1^.re * p_comp2^.re - p_comp1^.im * p_comp2^.im;
p_res^.im := p_comp1^.re * p_comp2^.im + p_comp1^.im * p_comp2^.re;
end;
{* Присваивает по указателю p_res результат деления комплексных чисел по указателям p_comp1 и p_comp2}
procedure division(var p_comp1, p_comp2, p_res : t_p_complex);
begin
p_res^.re := (p_comp2^.re * p_comp1^.re + p_comp2^.im * p_comp1^.im) / (sqr(p_comp1^.re) + sqr(p_comp1^.im));
p_res^.im := (p_comp1^.re * p_comp2^.im - p_comp2^.re * p_comp1^.im) / (sqr(p_comp1^.re) + sqr(p_comp1^.im));
end;
{* Присваивает по указателю p_res результат преминения унарного минуса к комплексному числу по указателю p_comp}
procedure unary_minus(var p_comp, p_res : t_p_complex);
begin
p_res^.re := -p_comp^.re;
p_res^.im := -p_comp^.im;
end;
{* Присваивает по указателю p_res результат вычисления натурального логарифма комплексного числа по указателю p_comp}
procedure natural_logarithm(var p_comp, p_res : t_p_complex);
begin
p_res^.re := ln(sqrt(sqr(p_comp^.re) + sqr(p_comp^.im)));
p_res^.im := arctan(p_comp^.im / p_comp^.re);
end;
{* Если оператор по указателю p бинарный - то по указателям p1 и p2 присваиваются указатели из стека st,
* которые удаляются из самого стека.
* Если оператор унарный - то из стека удаляется только один указатель и присваивается указателю p1}
procedure take_operands(var st : t_stack; var p1, p2 : pointer; const p : t_p_string);
begin
if (p^ = '+') or (p^ = '-') or (p^ = '*') or (p^ = '/') then
begin
pop(st, p1);
pop(st, p2);
end
else
pop(st, p1);
end;
{* Возвращает символ "+" если число num больше или равно 0, иначе - возвращает символ "-"}
function sign_of_number(const num : real) : string;
var sign : string;
begin
if num >= 0 then
sign := '+'
else
sign := '-';
sign_of_number := sign;
end;
{* Возвращает строковое представление комплексного числа по указателю p_complex }
function complex_to_string(const p_complex : t_p_complex) : string;
var a, b, sign : string;
begin
sign := sign_of_number(p_complex^.im);
p_complex^.im := abs(p_complex^.im);
str(p_complex^.re : 0 : 2, a);
str(p_complex^.im : 0 : 2, b);
complex_to_string := a + sign + b + 'i';
end;
{* Выводит на экран пронумерованные промежуточные результаты вычислений вычисляемого выражения,
* которые записаны в список list_of_inter_res}
procedure print_inter_results(var list_of_inter_res : t_list);
var p_nd_list : t_p_node;
i : byte;
begin
i := 1;
link_node_list_start(list_of_inter_res, p_nd_list);
while p_nd_list <> nil do
begin
write(i, ') ', complex_to_string(p_nd_list^.data), ' ');
p_nd_list := p_nd_list^.link;
i += 1;
end;
end;
{* В зависимости от строкового представления оператора по указателю p_opr,
* к операндам вычисляемого выражения expres применяется тот или иной оператор}
procedure process_operator(var expres : t_calculated_RPN_expression; const p_opr : t_p_string);
var p_comp1, p_comp2, p_res : t_p_complex;
begin
new(p_res);
take_operands(expres.st, p_comp1, p_comp2, p_opr);
case p_opr^ of
'+' : addition(p_comp1, p_comp2, p_res);
'-' : subtraction(p_comp1, p_comp2, p_res);
'*' : multiplication(p_comp1, p_comp2, p_res);
'/' : division(p_comp1, p_comp2, p_res);
'~' : unary_minus(p_comp1, p_res);
'ln' : natural_logarithm(p_comp1, p_res);
end;
push(expres.st, p_res);
push_last(expres.inter_res, p_res);
end;
{* Присваивает указателю p_complex указатель на значение переменной, хранящейся в ячейке по указателю p_cell}
procedure take_variable_value_from_cell(const p_cell : t_p_cell; var p_complex : t_p_complex);
var p_var : t_p_variable;
begin
p_var := p_cell^.data;
p_complex := p_var^.value;
end;
{* В зависимости от типа ячейки по указателю p_cell: opr, con или var вычисляемого выражения expres происходит:
* обработка оператора; или добавление указателя на константу в стек вычисляемого выражения expres;
* или добавление указателя на значение переменной в стек вычисляемого выражения expres}
procedure process_cell(var expres : t_calculated_RPN_expression; const p_cell : t_p_cell);
var pt : pointer;
begin
case p_cell^.type_c of
'opr' : process_operator(expres, p_cell^.data);
'con' : begin
pt := p_cell^.data;
push(expres.st, pt);
end;
'var' : begin
take_variable_value_from_cell(p_cell, pt);
push(expres.st, pt);
end;
end;
end;
{* Возвращает результат вычисления вычисляемого выражения expres в виде строки. Выводит промежуточные результаты вычисления в консоль}
function calculate_expres(var expres : t_calculated_RPN_expression) : string;
var res : string;
p_cell : t_p_cell;
p_node : t_p_node;
begin
link_node_list_start(expres.expres, p_node);
repeat
take_implicitly_element(p_node, p_cell);
process_cell(expres, p_cell);
until p_node = nil;
res := complex_to_string(expres.st.head^.data);
print_inter_results(expres.inter_res);
writeln;
clear_list(expres.inter_res, sizeof(t_complex));
calculate_expres := res;
end;
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}
{* Возвращает значение "истина", если в вычисляемом выражении expres есть переменные. Иначе - возвращает значение "ложь"}
function is_have_variables(const expres : t_calculated_RPN_expression) : boolean;
begin
is_have_variables := expres.variables.start <> nil;
end;
var s1, s2 : string;
expres : t_calculated_RPN_expression;
i : byte;
begin
writeln('Выражение должно состоять из констант, знаков операций и переменных');
writeln('Константы могут быть комплексными');
writeln('Внимание! Зарезервированные имена переменных, которые нельзя применять: i');
writeln;
writeln('Пожалуйста, используйте имена переменных длинной: ', MAX_VARIABLE_NAME_LENGTH);
writeln('Разделяйте пробелами все, кроме комплексных констант. Пример: - a + b * 34+2i + 1i');
writeln('Не пропускайте, пожалуйста, знаков операций и цифр в выражении. Записи вида: "3x", "i" недопустимы.');
write('В комплексной константе, имеющей как действительную, так и мнимую часть, вы можете выбрать знак только для мнимой, ');
write('действительная часть обязана быть всегда положительной. Пример "3+2i", "3-2i" ');
writeln('Пример допустимого выражения: 1i + 2+3i + 2-3i - a - * ( 3 - ( - 2 ) )');
writeln('Примеры недопустимых записей: "-2", "-2+2i", "-3i", "(3+2+4*9)"');
writeln;
writeln('-----------');
write('Доступные операторы: ');
for i := 1 to NUM_OF_OP do
write(OPERATORS.op_s[i], ' ');
writeln;
writeln('-----------');
write('Введите выражение: ');
readln(s1);
s2 := trans_expression_to_RPN(s1);
write('Преобразованное выражение: ');
writeln(s2);
writeln('--------------------');
string_into_calculated(s2, expres);
if is_have_variables(expres) then
while True do
begin
read_variables(expres);
writeln(calculate_expres(expres));
end
else
writeln(calculate_expres(expres));
end. |
unit MyDrawingControl;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Controls, Graphics, LCLType;
type
{ TMyDrawingControl }
TMyDrawingControl = class(TCustomControl)
private
FBitmap: TPortableNetworkGraphic;
public
property Bitmap: TPortableNetworkGraphic read FBitmap write FBitmap;
procedure EraseBackground(DC: HDC); override;
procedure Paint; override;
end;
implementation
procedure TMyDrawingControl.EraseBackground(DC: HDC);
begin
//Uncomment this to enable default background erasing
//inherited EraseBackground(DC);
end;
procedure TMyDrawingControl.Paint;
begin
if Assigned(Bitmap) then
Canvas.Draw(0, 0, Bitmap);
inherited Paint;
end;
end.
|
unit Player;
interface
uses Game;
type
TPlay = (Person, Computer);
TPlayer = class
private
Play : TPlay;
Number,First,Player,Game:integer;
PocetKaret : integer;
Hand : array [1..16] of byte;
public
procedure NastavHrace (aPlay:TPlay;aNumber:integer);
procedure PripravRozdani;
procedure VemKartu (num:byte);
function KolikKaret : integer;
procedure SetridKarty;
function HodnotaKarty(num:byte) : byte;
function Licituj(aFirst,aPlayer,aGame:integer) : integer;
procedure Vylicitoval(aPlayer,aGame:integer);
end;
implementation
procedure TPlayer.NastavHrace (aPlay:TPlay; aNumber:integer);
begin
Play := aPlay;
Number := aNumber;
end;
procedure TPlayer.PripravRozdani;
var i : integer;
begin
PocetKaret := 0;
for i:=1 to 16 do
Hand[i]:=0;
end;
procedure TPlayer.VemKartu (num:byte);
begin
PocetKaret := PocetKaret+1;
Hand[PocetKaret] := num;
end;
function TPlayer.KolikKaret : integer;
begin
KolikKaret := PocetKaret;
end;
procedure TPlayer.SetridKarty;
var
i,tmp : byte;
konec : boolean;
begin
konec := True;
while Konec do
begin
Konec := False;
for i:=1 to PocetKaret-1 do
if Hand[i] > Hand[i+1] then
begin
tmp := Hand[i];
Hand[i] := Hand[i+1];
Hand[i+1] := tmp;
Konec := True;
end;
end;
end;
function TPlayer.HodnotaKarty (num:byte) : byte;
begin
HodnotaKarty := Hand[num];
end;
function TPlayer.Licituj (aFirst,aPlayer,aGame : integer) : integer;
var
lic, i, Tar, Pag, VTar, Teen, Twen:integer;
begin
First:=aFirst;
if First = Number then lic := 1
else lic := 0;
if Play = Computer then
begin
Tar := 0;
Pag := 0;
VTar := 0;
Teen := 0;
Twen := 0;
for i:= 1 to 12 do
if Hand[i] > 32 then
begin
Tar:=Tar+1;
if Hand[i] = 33 then Pag:=1;
if (Pag = 1) and (Hand[i] = 34) then Pag:=2;
if (Pag = 2) and (Hand[i] = 35) then Pag:=3;
if (Hand[i] > 46) then
begin
VTar:=Vtar+1;
if (Hand[i]>47) and (Hand[i]<52) then Teen:=Teen+1;
end;
if Hand[i] > 51 then Twen:=Twen+1;
end;
if Tar > 4 then
begin
if (Pag > 0) and (aGame < 2) then
begin
{pocet tarok tarok 15..22 tarok 20..22 tarok 16..19}
if ((Tar > 5) and (VTar > 2) and (Twen > 0) and (Teen < 4)) then lic:=2;
if ((Tar > 6) and (VTar > 2) and (Twen > 0)) then lic:=2;
if ((Tar > 7) and (VTar > 3)) then lic:=2;
if (Tar > 8) then lic:=2;
end;
if lic = 2 then
if ((Tar > 8) and (VTar > 5) and (Twen > 1)) then lic:=3;
if ((aGame < 3) and (lic < 2)) then
begin
if ((Tar > 5) and (VTar > 4) and (Twen > 1)) then lic:=3;
if ((Tar > 6) and (VTar > 4)) then lic:=3;
if (Tar > 8) then lic:=3;
end;
if lic = 3 then
if ((Tar > 8) and (VTar > 6) and (Twen > 1)) then lic:=4;
end;
end
else
begin
Form2.RadioButton1.Enabled := True;
Form2.RadioButton2.Enabled := True;
Form2.RadioButton3.Enabled := True;
Form2.RadioButton4.Enabled := True;
Form2.RadioButton5.Enabled := True;
Form2.RadioButton1.Checked := True;
if lic = 1 then
begin
Form2.RadioButton1.Enabled := False;
Form2.RadioButton2.Checked := True;
end
else
begin
Form2.RadioButton2.Enabled := False;
Form2.RadioButton1.Checked := True;
end;
if aGame > 1 then
Form2.RadioButton3.Enabled := False;
if aGame > 2 then
Form2.RadioButton4.Enabled := False;
if aGame<>4 then Form2.ShowModal;
if Form2.RadioButton3.Checked = True then lic:=2;
if Form2.RadioButton4.Checked = True then lic:=3;
if Form2.RadioButton5.Checked = True then lic:=4;
end;
Licituj:=lic;
end;
procedure TPlayer.Vylicitoval (aPlayer,aGame : integer);
begin
Player := aPlayer;
Game := aGame;
end;
end.
|
unit MPI_Syn;
interface
var
success : boolean;
procedure s; (* entry for recursive descent parser *)
implementation
uses MP_Lex;
procedure MP; forward;
procedure varDecl; forward;
procedure statSeq; forward;
procedure stat; forward;
procedure expr; forward;
procedure term; forward;
procedure fact; forward;
function syIsNot(expected : symbol) : boolean;
begin
if sy <> expected then success := FALSE;
SyIsNot := NOT success;
end;
procedure S;
begin
success := TRUE;
newSy;
MP; if not success then exit;
if sy <> eofSy then begin success := FALSE; exit; end;
end;
procedure MP;
begin
(*
while sy <> eofSy do begin
writeLn(sy);
newSy;
end;
*)
if syIsNot(programSy) then exit;
newSy;
if syIsNot(idSy) then exit;
newSy;
if syIsNot(semicolonSy) then exit;
newSy;
(* [VarDecl] *)
if sy = varSy then begin
varDecl; if not success then exit;
end;
if syIsNot(beginSy) then exit;
newSy;
StatSeq; if not success then exit;
if syIsNot(endSy) then exit;
newSy;
if syIsNot(dotSy) then exit;
newSy;
end;
procedure varDecl;
begin
if syIsNot(varSy) then exit;
newSy;
if syIsNot(idSy) then exit;
newSy;
while sy = commaSy do begin
NewSy; (* skip ',' *)
if syIsNot(idSy) then exit;
newSy;
end;
if syIsNot(colonSy) then exit;
newSy;
if syIsNot(integerSy) then exit;
newSy;
if syIsNot(semicolonSy) then exit;
newSy;
end;
procedure statSeq;
begin
stat; if not success then exit;
while sy = semicolonSy do begin
newSy; (* skip ';' *)
stat; if not success then exit;
end;
end;
procedure stat;
begin
case sy of
idSy : begin
newSy; (* skip id *)
if syIsNot(assignSy) then exit;
newSy;
Expr; if not success then exit;
end;
readSy: begin
newSy; (* skip read *)
if syIsNot(leftParSy) then exit;
newSy;
if syIsNot(idSy) then exit;
newSy;
if syIsNot(rightParSy) then exit;
newSy;
end;
writeSy: begin
newSy; (* skip write *)
if syIsNot(leftParSy) then exit;
newSy;
expr; if not success then exit;
if syIsNot(rightParSy) then exit;
newSy;
end;
end; (* case *)
end;
procedure expr;
begin
term; if not success then exit;
while (sy = plusSy) or (sy = minusSy) do begin
if sy = plusSy then begin
newSy; (* skip '+' *)
term; if not success then exit;
end else if sy = minusSy then begin
newSy; (* skip '-' *)
term; if not success then exit;
end;
end;
end;
procedure term;
begin
fact; if not success then exit;
while (sy = mulSy) or (sy = divSy) do begin
if sy = mulSy then begin
newSy; (* skip '*' *)
fact; if not success then exit;
end else if sy = divSy then begin
newSy; (* skip '/' *)
fact; if not success then exit;
end;
end;
end;
procedure fact;
begin
case sy of
idSy: begin newSy; end;
numSy: begin newSy; end;
leftParSy: begin
newSy; (* skit '(' *)
expr; if not success then exit;
if syIsNot(rightParSy) then exit;
newSy;
end;
else begin
success := FALSE;
exit;
end;
end; (* case *)
end;
begin
end.
|
unit logdataADO;
interface
uses
SysUtils, Dialogs, ADODB, Variants;
const
ctQueryNoInicializado = 'Debe indicar un query antes de usar log';
procedure Log( Fecha: TDateTime; const Datos: string );
procedure LeerLog( const usu: string; fecini, fecfin: TDateTime );
procedure SetDatosLog( Query: TAdoCommand; const Usu: string );
var
FQuery: TAdoCommand;
FUsuario: string;
implementation
procedure SetDatosLog( Query: TAdoCommand; const Usu: string );
begin
FQuery := Query;
FUsuario := Usu;
end;
procedure Log( Fecha: TDateTime; const Datos: string );
begin
if (FQuery <> nil ) then
try
FQuery.Parameters.ParamByName( 'FECHA' ).value := Fecha;
FQuery.Parameters.ParamByName( 'USUARIO' ).value := FUsuario;
FQuery.Parameters.ParamByName( 'TAREA' ).value := Datos;
FQuery.Execute;
except
on e:exception do
showmessage( 'Error al grabar registro log' + #13 + e.message );
end
else
showmessage( ctQueryNoInicializado );
end;
procedure Leerlog( const usu: string; fecini, fecfin: TDateTime );
begin
end;
end.
|
{******************************************************************************}
{ }
{ Delphi FB4D Library }
{ Copyright (c) 2018-2022 Christoph Schneider }
{ Schneider Infosystems AG, Switzerland }
{ https://github.com/SchneiderInfosystems/FB4D }
{ }
{******************************************************************************}
{ }
{ 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. }
{ }
{******************************************************************************}
unit FB4D.SelfRegistrationFra;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes,
Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
Vcl.ExtCtrls, Vcl.WinXCtrls, Vcl.Mask,
FB4D.Interfaces;
type
TOnGetAuth = function : IFirebaseAuthentication of object;
TFraSelfRegistration = class(TFrame)
AniIndicator: TActivityIndicator;
pnlStatus: TPanel;
gdpAcitivityInd: TGridPanel;
pnlCheckRegistered: TPanel;
btnCheckEMail: TButton;
btnResetPwd: TButton;
btnSignIn: TButton;
btnSignUp: TButton;
edtEMail: TLabeledEdit;
pnlPassword: TPanel;
edtPassword: TLabeledEdit;
lblStatus: TLabel;
procedure edtEMailChange(Sender: TObject);
procedure btnCheckEMailClick(Sender: TObject);
procedure btnSignInClick(Sender: TObject);
procedure btnSignUpClick(Sender: TObject);
procedure btnResetPwdClick(Sender: TObject);
private
fAuth: IFirebaseAuthentication;
fOnUserLogin: TOnUserResponse;
fOnGetAuth: TOnGetAuth;
fAllowSelfRegistration: boolean;
fRequireVerificatedEMail: boolean;
fReqInfo: string;
procedure StartTokenReferesh(const LastToken: string);
procedure OnFetchProviders(const EMail: string; IsRegistered: boolean;
Providers: TStrings);
procedure OnFetchProvidersError(const Info, ErrMsg: string);
procedure OnResetPwd(const Info: string; Response: IFirebaseResponse);
procedure OnUserError(const Info, ErrMsg: string);
procedure OnUserResponse(const Info: string; User: IFirebaseUser);
procedure OnTokenRefresh(TokenRefreshed: boolean);
procedure OnGetUserData(FirebaseUserList: TFirebaseUserList);
procedure OnVerificationMailSent(const RequestID: string;
Response: IFirebaseResponse);
public
procedure Initialize(Auth: IFirebaseAuthentication;
OnUserLogin: TOnUserResponse; const LastRefreshToken: string = '';
const LastEMail: string = ''; AllowSelfRegistration: boolean = true;
RequireVerificatedEMail: boolean = false);
procedure InitializeAuthOnDemand(OnGetAuth: TOnGetAuth;
OnUserLogin: TOnUserResponse; const LastRefreshToken: string = '';
const LastEMail: string = ''; AllowSelfRegistration: boolean = true;
RequireVerificatedEMail: boolean = false);
procedure StartEMailEntering;
function GetEMail: string;
end;
implementation
uses
FB4D.Helpers;
{$R *.dfm}
resourcestring
rsEnterEMail = 'Enter your e-mail address for sign-in or registration';
rsWait = 'Please wait for Firebase';
rsEnterPassword = 'Enter your password for registration';
rsSetupPassword = 'Setup a new password for future registrations';
rsNotRegisteredEMail = 'The entered e-mail is not registered';
rsPleaseCheckEMail = 'Please check your e-mail inbox to renew your password';
rsLoggedIn = 'Successful logged in';
rsPleaseCheckEMailForVerify =
'Please check your e-mail inbox to confirm your email address';
procedure TFraSelfRegistration.Initialize(Auth: IFirebaseAuthentication;
OnUserLogin: TOnUserResponse; const LastRefreshToken, LastEMail: string;
AllowSelfRegistration, RequireVerificatedEMail: boolean);
begin
fAuth := Auth;
fOnUserLogin := OnUserLogin;
fOnGetAuth := nil;
edtEMail.Text := LastEMail;
fAllowSelfRegistration := AllowSelfRegistration;
fRequireVerificatedEMail := RequireVerificatedEMail;
if LastRefreshToken.IsEmpty then
StartEMailEntering
else
StartTokenReferesh(LastRefreshToken);
end;
procedure TFraSelfRegistration.InitializeAuthOnDemand(OnGetAuth: TOnGetAuth;
OnUserLogin: TOnUserResponse; const LastRefreshToken, LastEMail: string;
AllowSelfRegistration, RequireVerificatedEMail: boolean);
begin
fAuth := nil;
fOnUserLogin := OnUserLogin;
fOnGetAuth := OnGetAuth;
edtEMail.Text := LastEMail;
fAllowSelfRegistration := AllowSelfRegistration;
fRequireVerificatedEMail := RequireVerificatedEMail;
if LastRefreshToken.IsEmpty then
StartEMailEntering
else
StartTokenReferesh(LastRefreshToken);
end;
procedure TFraSelfRegistration.StartEMailEntering;
begin
edtEMail.Visible := true;
btnCheckEMail.Visible := true;
btnCheckEMail.Enabled := TFirebaseHelpers.IsEMailAdress(edtEMail.Text);
lblStatus.Caption := rsEnterEMail;
btnSignIn.Visible := false;
btnResetPwd.Visible := false;
btnSignUp.Visible := false;
edtPassword.Visible := false;
edtEMail.SetFocus;
end;
procedure TFraSelfRegistration.edtEMailChange(Sender: TObject);
begin
if edtPassword.Visible then
begin
lblStatus.Caption := rsEnterEMail;
edtPassword.Visible := false;
btnCheckEMail.Visible := true;
btnSignUp.Visible := false;
btnSignIn.Visible := false;
btnResetPwd.Visible := false;
end;
btnCheckEMail.Enabled := TFirebaseHelpers.IsEMailAdress(edtEMail.Text);
end;
procedure TFraSelfRegistration.btnCheckEMailClick(Sender: TObject);
begin
if not assigned(fAuth) and assigned(fOnGetAuth) then
fAuth := fOnGetAuth;
Assert(assigned(fAuth), 'Auth is not initialized');
fAuth.FetchProvidersForEMail(trim(edtEmail.Text), OnFetchProviders,
OnFetchProvidersError);
AniIndicator.Enabled := true;
AniIndicator.Visible := true;
btnCheckEMail.Enabled := false;
lblStatus.Caption := rsWait;
end;
procedure TFraSelfRegistration.OnFetchProviders(const EMail: string;
IsRegistered: boolean; Providers: TStrings);
begin
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
if IsRegistered then
begin
btnSignUp.Visible := false;
btnSignIn.Visible := true;
btnSignIn.Enabled := true;
btnResetPwd.Visible := true;
btnResetPwd.Enabled := true;
lblStatus.Caption := rsEnterPassword;
edtPassword.Text := '';
edtPassword.Visible := true;
edtPassword.SetFocus;
btnCheckEMail.Visible := false;
end
else if fAllowSelfRegistration then
begin
btnSignUp.Visible := true;
btnSignUp.Enabled := true;
btnSignIn.Visible := false;
btnResetPwd.Visible := false;
lblStatus.Caption := rsSetupPassword;
edtPassword.Text := '';
edtPassword.Visible := true;
edtPassword.SetFocus;
btnCheckEMail.Visible := false;
end else begin
lblStatus.Caption := rsNotRegisteredEMail;
edtEMail.SetFocus;
end;
end;
procedure TFraSelfRegistration.OnFetchProvidersError(const Info, ErrMsg: string);
begin
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
lblStatus.Caption := Info + ': ' + ErrMsg;
btnCheckEMail.Enabled := true;
end;
procedure TFraSelfRegistration.btnSignInClick(Sender: TObject);
begin
fAuth.SignInWithEmailAndPassword(trim(edtEmail.Text), edtPassword.Text,
OnUserResponse, OnUserError);
AniIndicator.Enabled := true;
AniIndicator.Visible := true;
btnSignIn.Enabled := false;
btnResetPwd.Enabled := false;
lblStatus.Caption := rsWait;
end;
procedure TFraSelfRegistration.btnSignUpClick(Sender: TObject);
begin
fAuth.SignUpWithEmailAndPassword(trim(edtEmail.Text), edtPassword.Text,
OnUserResponse, OnUserError);
AniIndicator.Enabled := true;
AniIndicator.Visible := true;
btnSignUp.Enabled := false;
lblStatus.Caption := rsWait;
end;
procedure TFraSelfRegistration.btnResetPwdClick(Sender: TObject);
begin
fAuth.SendPasswordResetEMail(trim(edtEMail.Text), OnResetPwd, OnUserError);
AniIndicator.Enabled := true;
AniIndicator.Visible := true;
btnSignIn.Enabled := false;
btnResetPwd.Enabled := false;
lblStatus.Caption := rsWait;
end;
procedure TFraSelfRegistration.OnResetPwd(const Info: string; Response: IFirebaseResponse);
begin
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
btnSignIn.Enabled := true;
if Response.StatusOk then
lblStatus.Caption := rsPleaseCheckEMail
else
lblStatus.Caption := Response.ErrorMsgOrStatusText;
end;
procedure TFraSelfRegistration.StartTokenReferesh(const LastToken: string);
begin
if not assigned(fAuth) and assigned(fOnGetAuth) then
fAuth := fOnGetAuth;
Assert(assigned(fAuth), 'Auth is not initialized');
AniIndicator.Enabled := true;
AniIndicator.Visible := true;
edtEMail.Visible := false;
btnCheckEMail.Visible := false;
lblStatus.Caption := rsWait;
btnSignIn.Visible := false;
btnResetPwd.Visible := false;
btnSignUp.Visible := false;
edtPassword.Visible := false;
fReqInfo := 'AfterTokenRefresh';
fAuth.RefreshToken(LastToken, OnTokenRefresh, OnUserError);
end;
procedure TFraSelfRegistration.OnTokenRefresh(TokenRefreshed: boolean);
begin
if TokenRefreshed then
fAuth.GetUserData(OnGetUserData, OnUserError)
else
StartEMailEntering;
end;
procedure TFraSelfRegistration.OnGetUserData(FirebaseUserList: TFirebaseUserList);
var
User: IFirebaseUser;
begin
if FirebaseUserList.Count = 1 then
begin
User := FirebaseUserList[0];
if fRequireVerificatedEMail then
if User.IsEMailVerified <> tsbTrue then
begin
fAuth.SendEmailVerification(OnVerificationMailSent, OnUserError);
exit;
end;
OnUserResponse(fReqInfo, User);
end else
StartEMailEntering;
end;
procedure TFraSelfRegistration.OnUserError(const Info, ErrMsg: string);
begin
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
StartEMailEntering;
lblStatus.Caption := Info + ': ' + ErrMsg;
end;
procedure TFraSelfRegistration.OnUserResponse(const Info: string;
User: IFirebaseUser);
begin
if fRequireVerificatedEMail then
case User.IsEMailVerified of
tsbUnspecified:
begin
fReqInfo := 'GetUserData';
fAuth.GetUserData(OnGetUserData, OnUserError);
exit;
end;
tsbFalse:
begin
fAuth.SendEmailVerification(OnVerificationMailSent, OnUserError);
exit;
end;
end;
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
lblStatus.Caption := rsLoggedIn;
if assigned(fOnUserLogin) then
fOnUserLogin(Info, User);
end;
function TFraSelfRegistration.GetEMail: string;
begin
result := trim(edtEmail.Text);
end;
procedure TFraSelfRegistration.OnVerificationMailSent(const RequestID: string;
Response: IFirebaseResponse);
begin
AniIndicator.Enabled := false;
AniIndicator.Visible := false;
lblStatus.Caption := rsPleaseCheckEMailForVerify;
btnSignIn.Enabled := true;
end;
end.
|
unit RESTRequest4D.Request.Intf;
interface
uses Data.DB, REST.Client, RESTRequest4D.Request.Body.Intf, RESTRequest4D.Request.Params.Intf, REST.Types, System.SysUtils,
RESTRequest4D.Request.Authentication.Intf, RESTRequest4D.Request.Headers.Intf, RESTRequest4D.Request.Response.Intf;
type
/// <summary>
/// Interface to represent a request to a given server.
/// </summary>
IRequest = interface
['{2C882459-F4C3-4854-8F7A-F68E8F8DE98E}']
/// <summary>
/// Get defined accepted encoding.
/// </summary>
/// <returns>
/// Accepted encoding.
/// </returns>
function GetAcceptEncoding: string;
/// <summary>
/// Specifies the accepted encoding.
/// </summary>
/// <param name="AAcceptEncoding">
/// Accepted encoding.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
/// <remarks>
/// Defaults to empty string, which means "identity encoding".
/// To allow for compressed responses set to "gzip, deflate".
/// </remarks>
function SetAcceptEncoding(const AAcceptEncoding: string): IRequest;
/// <summary>
/// Get defined charset that the response is expected to be encoded in.
/// </summary>
/// <returns>
/// Charset that the response is expected to be encoded in.
/// </returns>
function GetAcceptCharset: string;
/// <summary>
/// Specifies the charset that the response is expected to be encoded in.
/// </summary>
/// <param name="AAcceptCharset">
/// Charset that the response is expected to be encoded in.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
/// <remarks>
/// Defaults to UTF-8.
/// </remarks>
function SetAcceptCharset(const AAcceptCharset: string): IRequest;
/// <summary>
/// Get difined content-type that is accepted for the response.
/// </summary>
/// <returns>
/// Content-Type that is accepted for the response.
/// </returns>
function GetAccept: string;
/// <summary>
/// <para>
/// Specifies the Content-Type that is accepted for the response.
/// </para>
/// <para>
/// Defaults to: application/json,text/plain;q=0.9,text/html;q=0.8
/// </para>
/// <para>
/// We are after JSON, which is why it has the highest quality factor (default 1.0)
/// </para>
/// </summary>
/// <param name="AAccept">
/// Content-Type that is accepted for the response.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetAccept(const AAccept: string): IRequest;
/// <summary>
/// Get defined request timeout.
/// </summary>
/// <returns>
/// Request timeout.
/// </returns>
function GetTimeout: Integer;
/// <summary>
/// Defines a new timeout for request.
/// </summary>
/// <param name="ATimeout">
/// Request timeout.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetTimeout(const ATimeout: Integer): IRequest;
/// <summary>
/// Defines a DataSet that will be assigned to an adapter to respond to requests.
/// </summary>
/// <param name="ADataSet">
/// DataSet that will be adapted.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetDataSetAdapter(const ADataSet: TDataSet): IRequest;
/// <summary>
/// Get defined dataset adapter.
/// </summary>
/// <returns>
/// Dataset Adapter.
/// </returns>
function GetDataSetAdapter: TDataSet;
/// <summary>
/// Sets the base URL of access to resources to be consumed.
/// </summary>
/// <param name="ABaseURL">
/// Base URL for access to resources.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetBaseURL(const ABaseURL: string = ''): IRequest;
/// <summary>
/// Get defined base URL.
/// </summary>
/// <returns>
/// Base URL.
/// </returns>
function GetBaseURL: string;
/// <summary>
/// Sets the resource to be consumed.
/// </summary>
/// <param name="AResource">
/// Resource name.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetResource(const AResource: string = ''): IRequest;
/// <summary>
/// Get defined value if the component needs to raise an exception on server status code return 500.
/// </summary>
/// <returns>
/// Defined raise exception on error 500.
/// </returns>
function GetRaiseExceptionOn500: Boolean;
/// <summary>
/// Defines if the component needs to raise an exception on server status code return 500.
/// </summary>
/// <param name="ARaiseException">
/// Raise exception.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
/// <remarks>
/// Default is True.
/// </remarks>
function SetRaiseExceptionOn500(const ARaiseException: Boolean = True): IRequest;
/// <summary>
/// Get defined resource.
/// </summary>
/// <returns>
/// Resource.
/// </returns>
function GetResource: string;
/// <summary>
/// Sets the suffix of the resource to be consumed.
/// </summary>
/// <param name="AResourceSufix">
/// Resource Suffix.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetResourceSuffix(const AResourceSuffix: string = ''): IRequest;
/// <summary>
/// Get defined resource suffix.
/// </summary>
/// <returns>
/// Resource suffix.
/// </returns>
function GetResourceSuffix: string;
/// <summary>
/// Defines an HTTP verb for the request.
/// </summary>
/// <param name="AMethod">
/// HTTP method.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
/// <remarks>
/// Uses REST.Types.
/// </remarks>
function SetMethod(const AMethod: TRESTRequestMethod = rmGET): IRequest;
/// <summary>
/// Get defined method.
/// </summary>
/// <returns>
/// HTTP method.
/// </returns>
/// <remarks>
/// Uses REST.Types.
/// </remarks>
function GetMethod: TRESTRequestMethod;
/// <summary>
/// Defines an token to the request.
/// </summary>
/// <param name="AToken">
/// The token value.
/// </param>
/// <returns>
/// Returns the instance itself following the fluent API pattern.
/// </returns>
function SetToken(const AToken: string): IRequest;
/// <summary>
/// Get defined token.
/// </summary>
/// <returns>
/// The token value.
/// </returns>
function GetToken: string;
/// <summary>
/// Get the full URL.
/// </summary>
/// <param name="AIncludeParams">
/// Include Added Parameters.
/// </param>
/// <returns>
/// Full URL.
/// </returns>
function GetFullRequestURL(const AIncludeParams: Boolean = True): string;
/// <summary>
/// Execute the request.
/// </summary>
/// <returns>
/// Returns the status code of the request.
/// </returns>
/// <remarks>
/// See more about status code in: https://httpstatuses.com/
/// </remarks>
function Execute: Integer;
/// <summary>
/// <para>
/// Executes a request asynchronously, i.e. run it in its own thread. There is no automatic serialization o
/// property access though, which means that while the execution thread runs, properties of all involved
/// TCustomRESTClient and TCustomRESTRequest instances should not be touched from other threads (including the main thread)
/// <br/><br/>Using ExecuteAsync is strongly recommended on mobile platforms. iOS (and likely Android) will
/// terminate an application if it considers the main thread to be unresponsive, which would be the case if
/// there is a running request which takes more than a second or two to return.
/// </para>
/// <para>
/// The idea behind this is that the UI runs in the main thread and mobile devices should respond to user
/// interaction basically immediately. Sluggish behaviour (caused by blocking the main thread) is considered
/// unacceptable on these small devices.
/// </para>
/// </summary>
/// <param name="ACompletionHandler">
/// An anonymous method that will be run after the execution completed
/// </param>
/// <param name="ASynchronized">
/// Specifies if ACompletioHandler will be run in the main thread's (True) or execution thread's (False) context
/// </param>
/// <param name="AFreeThread">
/// If True, then the execution thread will be freed after it completed
/// </param>
/// <param name="ACompletionHandlerWithError">
/// An anonymous method that will be run if an exception is raised during execution
/// </param>
/// <returns>
/// Returns a reference to the execution thread. Should only be used if AFreeThread=False, as other wise the
/// reference may get invalid unexpectedly.
/// </returns>
function ExecuteAsync(ACompletionHandler: TProc = nil; ASynchronized: Boolean = True; AFreeThread: Boolean = True;
ACompletionHandlerWithError: TProc<TObject> = nil): TRESTExecutionThread;
/// <summary>
/// Allows access to the request body.
/// </summary>
/// <returns>
/// Returns an instance of the request body interface.
/// </returns>
function Body: IRequestBody;
/// <summary>
/// Allows access to the request headers.
/// </summary>
/// <returns>
/// Returns an instance of the request parameter interface.
/// </returns>
function Headers: IRequestHeaders;
/// <summary>
/// Allows access to the request response.
/// </summary>
/// <returns>
/// Returns an instance of the request response interface.
/// </returns>
function Response: IRequestResponse;
/// <summary>
/// Allows access to the request parameters.
/// </summary>
/// <returns>
/// Returns an instance of the request parameter interface.
/// </returns>
function Params: IRequestParams;
/// <summary>
/// Allows access to the authentication of the request.
/// </summary>
/// <returns>
/// Returns an instance of the authentication interface.
/// </returns>
function Authentication: IRequestAuthentication;
end;
implementation
end.
|
unit fmuIBMPrinter;
interface
uses
// VCL
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, Buttons,
// This
untPages, untDriver;
type
{ TfmIBMPrinter }
TfmIBMPrinter = class(TPage)
btnGetShortIBMStatus: TButton;
Memo: TMemo;
btnGetIBMStatus: TButton;
btnClear: TBitBtn;
procedure btnGetShortIBMStatusClick(Sender: TObject);
procedure btnClearClick(Sender: TObject);
procedure btnGetIBMStatusClick(Sender: TObject);
private
procedure AddSeparator;
procedure AddStatusBits;
procedure AddStatusBytes;
procedure AddLine(const S1, S2: string);
procedure AddBitText2(Value, BitNumber: Integer; const BitName: string);
procedure AddBitText(Value, ByteNumber, BitNumber: Integer; const BitName: string);
end;
implementation
{$R *.DFM}
function TestBit(Value, Bit: Integer): Boolean;
begin
Result := (Value and (1 shl Bit)) <> 0;
end;
function GetStatusByteText(StatusByteNumber, Value: Integer): string;
begin
Result := Format('Байт состояния %d: %d = 0x%xh',
[StatusByteNumber, Value, Value]);
end;
{ TfmIBMPrinter }
procedure TfmIBMPrinter.AddBitText(Value, ByteNumber, BitNumber: Integer;
const BitName: string);
var
S: string;
IsBitSet: Boolean;
const
BitText: array [Boolean] of Char = (' ', 'x');
begin
IsBitSet := TestBit(Value, BitNumber);
S := Format('%d.%d [%s] %s', [ByteNumber, BitNumber, BitText[IsBitSet], BitName]);
Memo.Lines.Add(S);
end;
procedure TfmIBMPrinter.AddBitText2(Value, BitNumber: Integer;
const BitName: string);
var
S: string;
IsBitSet: Boolean;
const
BitText: array [Boolean] of Char = (' ', 'x');
begin
IsBitSet := TestBit(Value, BitNumber);
S := Format('[%s] %s', [BitText[IsBitSet], BitName]);
Memo.Lines.Add(S);
end;
procedure TfmIBMPrinter.AddSeparator;
begin
Memo.Lines.Add('-------------------------------------');
end;
{ Добавляем значения байтов состояния }
procedure TfmIBMPrinter.AddStatusBytes;
begin
AddSeparator;
Memo.Lines.Add(GetStatusByteText(1, Driver.IBMStatusByte1));
Memo.Lines.Add(GetStatusByteText(2, Driver.IBMStatusByte2));
Memo.Lines.Add(GetStatusByteText(3, Driver.IBMStatusByte3));
Memo.Lines.Add(GetStatusByteText(4, Driver.IBMStatusByte4));
Memo.Lines.Add(GetStatusByteText(5, Driver.IBMStatusByte5));
Memo.Lines.Add(GetStatusByteText(6, Driver.IBMStatusByte6));
Memo.Lines.Add(GetStatusByteText(7, Driver.IBMStatusByte7));
Memo.Lines.Add(GetStatusByteText(8, Driver.IBMStatusByte8));
AddSeparator;
end;
{ Добавляем значения байтов состояния с расшифровкой битов }
procedure TfmIBMPrinter.AddStatusBits;
var
Value: Integer;
begin
// Status Byte 1
AddSeparator;
Value := Driver.IBMStatusByte1;
Memo.Lines.Add(GetStatusByteText(1, Value));
AddBitText(Value, 1, 0, 'Command complete');
AddBitText(Value, 1, 1, 'Cash receipt right home position');
AddBitText(Value, 1, 2, 'Left home position');
AddBitText(Value, 1, 3, 'Document right home position');
AddBitText(Value, 1, 4, 'Reserved. Always 0');
AddBitText(Value, 1, 5, 'Ribbon cover open');
AddBitText(Value, 1, 6, 'Cash receipt print error');
AddBitText(Value, 1, 7, 'Command reject');
// Status Byte 2
AddSeparator;
Value := Driver.IBMStatusByte2;
Memo.Lines.Add(GetStatusByteText(2, Value));
AddBitText(Value, 2, 0, 'Document ready');
AddBitText(Value, 2, 1, 'Document present under the front sensor');
AddBitText(Value, 2, 2, 'Document present under the top sensor');
AddBitText(Value, 2, 3, 'Reserved. Always equals 1');
AddBitText(Value, 2, 4, 'Print buffer held');
AddBitText(Value, 2, 5, 'Open throat position');
AddBitText(Value, 2, 6, 'Buffer empty');
AddBitText(Value, 2, 7, 'Buffer Full');
// Status Byte 3
AddSeparator;
Value := Driver.IBMStatusByte3;
Memo.Lines.Add(GetStatusByteText(3, Value));
AddBitText(Value, 3, 0, 'Memory sector is full');
AddBitText(Value, 3, 1, 'Home error');
AddBitText(Value, 3, 2, 'Document error');
AddBitText(Value, 3, 3, 'Flash EPROM load error or MCT load error');
AddBitText(Value, 3, 4, 'Reserved. Always equals 0');
AddBitText(Value, 3, 5, 'User flash storage sector is full');
AddBitText(Value, 3, 6, 'Firmware error');
AddBitText(Value, 3, 7, 'Command complete');
// Status Byte 4
AddSeparator;
Value := Driver.IBMStatusByte4;
Memo.Lines.Add(GetStatusByteText(4, Value));
// Status Byte 5
AddSeparator;
Value := Driver.IBMStatusByte5;
Memo.Lines.Add(GetStatusByteText(5, Value));
AddBitText(Value, 5, 0, 'Printer ID Request Address command');
AddBitText(Value, 5, 1, 'EC Level');
AddBitText(Value, 5, 2, 'MICR Read');
AddBitText(Value, 5, 3, 'MCT Read');
AddBitText(Value, 5, 4, 'User flash read');
AddBitText(Value, 5, 5, 'Reserved. Defaults to 1');
AddBitText(Value, 5, 6, 'Reserved');
AddBitText(Value, 5, 7, 'Reserved');
// Status Byte 6
AddSeparator;
Value := Driver.IBMStatusByte6;
Memo.Lines.Add(GetStatusByteText(6, Value));
Memo.Lines.Add(' Contains the current line count');
// Status Byte 7
AddSeparator;
Value := Driver.IBMStatusByte7;
Memo.Lines.Add(GetStatusByteText(7, Value));
AddBitText(Value, 7, 0, 'Station selection low order bit');
AddBitText(Value, 7, 1, 'Reserved');
AddBitText(Value, 7, 2, 'Reserved');
AddBitText(Value, 7, 3, 'Cash drawer status');
AddBitText(Value, 7, 4, 'Print key pressed');
AddBitText(Value, 7, 5, 'Reserved. Defaults to 1');
AddBitText(Value, 7, 6, 'Station Selection high order bit');
AddBitText(Value, 7, 7, 'Document feed error');
// Status Byte 8
AddSeparator;
Value := Driver.IBMStatusByte8;
Memo.Lines.Add(GetStatusByteText(8, Value));
AddBitText(Value, 8, 0, 'Fiscal offline mode');
AddBitText(Value, 8, 1, 'Fiscal offline mode');
AddBitText(Value, 8, 2, 'Fiscal offline mode');
AddBitText(Value, 8, 3, 'Reserved');
AddBitText(Value, 8, 4, 'Reserved');
AddBitText(Value, 8, 5, 'Reserved');
AddBitText(Value, 8, 6, 'Reserved');
AddBitText(Value, 8, 7, 'Reserved');
AddSeparator;
end;
procedure TfmIBMPrinter.btnClearClick(Sender: TObject);
begin
Memo.Lines.Clear;
end;
procedure TfmIBMPrinter.AddLine(const S1, S2: string);
var
S: string;
begin
S := Format('%-10s %s', [S1, S2]);
Memo.Lines.Add(S);
end;
{ Длинный запрос состояния }
procedure TfmIBMPrinter.btnGetIBMStatusClick(Sender: TObject);
var
S: string;
Value: Integer;
ValueName: string;
ResultCode: Integer;
Hour, Min, Sec: Byte;
Day, Month, Year: Byte;
begin
EnableButtons(False);
try
Memo.Clear;
ResultCode := Driver.GetIBMStatus;
if ResultCode = 0 then
begin
with Memo do
begin
Lines.BeginUpdate;
try
// Порядковый номер оператора
S := IntToStr(Driver.OperatorNumber);
ValueName := 'Порядковый номер оператора';
AddLine(S, ValueName);
// Текущая дата
S := DateToStr(Driver.Date);
ValueName := 'Текущая дата';
AddLine(S, ValueName);
// Текущее время
S := TimeToStr(Driver.Time);
ValueName := 'Текущее время';
AddLine(S, ValueName);
// Номер последней закрытой смены
S := IntToStr(Driver.SessionNumber);
ValueName := 'Номер последней закрытой смены';
AddLine(S, ValueName);
// Сквозной номер последнего закрытого документа (4 байта)
S := IntToStr(Driver.IBMDocumentNumber);
ValueName := 'Сквозной номер последнего закрытого документа';
AddLine(S, ValueName);
// Номер последнего чека продаж в текущей смене (2 байта)
S := IntToStr(Driver.IBMLastSaleReceiptNumber);
ValueName := 'Количество чеков продаж';
AddLine(S, ValueName);
// Номер последнего чека покупок в текущей смене (2 байта)
S := IntToStr(Driver.IBMLastBuyReceiptNumber);
ValueName := 'Количество чеков покупок';
AddLine(S, ValueName);
// Номер последнего чека возврата продаж в текущей смене (2 байта)
S := IntToStr(Driver.IBMLastReturnSaleReceiptNumber);
ValueName := 'Количество чеков возврата продаж';
AddLine(S, ValueName);
// Номер последнего чека возврата покупок в текущей смене (2 байта)
S := IntToStr(Driver.IBMLastReturnBuyReceiptNumber);
ValueName := 'Количество чеков возврата покупок';
AddLine(S, ValueName);
// Дата начала открытой смены(3 байта ) ДД ММ ГГ
Day := Driver.IBMSessionDay;
Month := Driver.IBMSessionMonth;
Year := Driver.IBMSessionYear;
S := Format('%.2d.%.2d.%.2d', [Day, Month, Year]);
ValueName := 'Дата начала открытой смены';
AddLine(S, ValueName);
// Время начала открытой смены(3 байта ) ЧЧ ММ СС
Hour := Driver.IBMSessionHour;
Min := Driver.IBMSessionMin;
Sec := Driver.IBMSessionSec;
S := Format('%.2d:%.2d:%.2d', [Hour, Min, Sec]);
ValueName := 'Время начала открытой смены';
AddLine(S, ValueName);
// Наличные в кассе (6 байт)
S := CurrToStr(Driver.Summ1);
ValueName := 'Наличные в кассе';
AddLine(S, ValueName);
// Байты состояния
AddStatusBytes;
// Флаги
Value := Driver.IBMFlags;
Lines.Add('Флаги: ' + IntToStr(Value));
AddBitText2(Value, 0, 'Сериализована');
AddBitText2(Value, 1, 'Фискализирована');
AddBitText2(Value, 2, 'Активизирована');
AddBitText2(Value, 3, 'Смена открыта');
AddBitText2(Value, 4, '24 часа кончились');
// Расшифровка байтов состояния
AddStatusBits;
finally
Lines.EndUpdate;
end;
end;
end;
finally
EnableButtons(True);
end;
end;
{ Короткий запрос состояния }
procedure TfmIBMPrinter.btnGetShortIBMStatusClick(Sender: TObject);
var
ResultCode: Integer;
begin
EnableButtons(False);
try
Memo.Clear;
ResultCode := Driver.GetShortIBMStatus;
if ResultCode = 0 then
begin
with Memo do
begin
Lines.BeginUpdate;
try
// Порядковый номер оператора
Lines.Add('Порядковый номер оператора: ' + IntToStr(Driver.OperatorNumber));
// Байты состояния
AddStatusBytes;
// Флаги
Lines.Add('Флаги: ' + IntToStr(Driver.IBMFlags));
AddBitText2(Driver.IBMFlags, 0, 'Буфер печати пуст');
// Расшифровка байтов состояния
AddStatusBits;
finally
Lines.EndUpdate;
end;
end;
end;
finally
EnableButtons(True);
end;
end;
end.
|
{
DBAExplorer - Oracle Admin Management Tool
Copyright (C) 2008 Alpaslan KILICKAYA
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
}
unit frmProcedureProperties;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxStyles, cxCustomData, cxGraphics, cxFilter, cxData,
cxDataStorage, cxEdit, DB, cxDBData, VirtualTable, MemDS, DBAccess, Ora,
dxBar, StdCtrls, ExtCtrls, cxMemo, cxRichEdit, cxSplitter, cxTextEdit,
cxLabel, cxContainer, cxGroupBox, cxGridLevel, cxGridCustomTableView,
cxGridTableView, cxGridDBTableView, cxClasses, cxControls,
cxGridCustomView, cxGrid, jpeg, cxPC, frmBaseForm, OraProcSource,
ComCtrls, cxListView;
type
TProcedurePropertiesFrm = class(TBaseform)
pcProcedureProperties: TcxPageControl;
tsProcedureCode: TcxTabSheet;
dxBarDockControl1: TdxBarDockControl;
cxGroupBox1: TcxGroupBox;
cxLabel1: TcxLabel;
edtName: TcxTextEdit;
cxLabel2: TcxLabel;
edtOwner: TcxTextEdit;
tsProcedureGrants: TcxTabSheet;
dxBarDockControl4: TdxBarDockControl;
GridGrants: TcxGrid;
GridGrantsDBTableView1: TcxGridDBTableView;
GridGrantsDBTableView1Column1: TcxGridDBColumn;
GridGrantsDBTableView1Column2: TcxGridDBColumn;
GridGrantsDBTableView1Column3: TcxGridDBColumn;
GridGrantsDBTableView1Column4: TcxGridDBColumn;
cxGridLevel5: TcxGridLevel;
tsProcedureSynonyms: TcxTabSheet;
dxBarDockControl6: TdxBarDockControl;
GridSynonyms: TcxGrid;
GridSynonymsDBTableView1: TcxGridDBTableView;
GridSynonymsDBTableView1Column1: TcxGridDBColumn;
GridSynonymsDBTableView1Column2: TcxGridDBColumn;
cxGridLevel6: TcxGridLevel;
tsProcedureUsedBy: TcxTabSheet;
GridUsed: TcxGrid;
GridUsedDBTableView1: TcxGridDBTableView;
GridUsedDBTableView1Column1: TcxGridDBColumn;
GridUsedDBTableView1Column2: TcxGridDBColumn;
GridUsedDBTableView1Column3: TcxGridDBColumn;
GridUsedDBTableView1Column4: TcxGridDBColumn;
GridUsedDBTableView1Column5: TcxGridDBColumn;
cxGridLevel7: TcxGridLevel;
tsProcedureUses: TcxTabSheet;
GridUses: TcxGrid;
GridUsesDBTableView1: TcxGridDBTableView;
GridUsesDBTableView1Column1: TcxGridDBColumn;
GridUsesDBTableView1Column2: TcxGridDBColumn;
GridUsesDBTableView1Column3: TcxGridDBColumn;
GridUsesDBTableView1Column4: TcxGridDBColumn;
GridUsesDBTableView1Column5: TcxGridDBColumn;
cxGridLevel2: TcxGridLevel;
Panel1: TPanel;
lblDescription: TLabel;
dxBarManager1: TdxBarManager;
btnCreateProc: TdxBarButton;
btnAlterProc: TdxBarButton;
btnDropProc: TdxBarButton;
btnCompileProc: TdxBarButton;
btnRefreshProc: TdxBarButton;
btnPrivilegesView: TdxBarButton;
bbtnGrantPrivileges: TdxBarButton;
btnRefreshGrants: TdxBarButton;
bbtnCreateSynonym: TdxBarButton;
bbtnDropSynonym: TdxBarButton;
bbtnRefreshSynonym: TdxBarButton;
dsGrants: TDataSource;
dsSynonyms: TDataSource;
dsUsed: TDataSource;
dsUses: TDataSource;
vtGrants: TVirtualTable;
vtSynonyms: TVirtualTable;
vtUsed: TVirtualTable;
vtUses: TVirtualTable;
redtCode: TcxRichEdit;
cxSplitter1: TcxSplitter;
lviewError: TcxListView;
tsArguments: TcxTabSheet;
cxGrid1: TcxGrid;
cxGridDBTableView1: TcxGridDBTableView;
cxGridDBColumn1: TcxGridDBColumn;
cxGridDBColumn2: TcxGridDBColumn;
cxGridDBColumn3: TcxGridDBColumn;
cxGridDBColumn4: TcxGridDBColumn;
cxGridDBColumn5: TcxGridDBColumn;
cxGridLevel1: TcxGridLevel;
vtArguments: TVirtualTable;
dsArguments: TDataSource;
cxGridDBTableView1Column1: TcxGridDBColumn;
bbtnExecPro: TdxBarButton;
tsBody: TcxTabSheet;
redtBodyCode: TcxRichEdit;
cxSplitter2: TcxSplitter;
lviewBodyError: TcxListView;
imgToolBar: TImage;
procedure pcProcedurePropertiesPageChanging(Sender: TObject;
NewPage: TcxTabSheet; var AllowChange: Boolean);
procedure btnDropProcClick(Sender: TObject);
procedure btnCompileProcClick(Sender: TObject);
procedure btnRefreshProcClick(Sender: TObject);
procedure bbtnGrantPrivilegesClick(Sender: TObject);
procedure btnRefreshGrantsClick(Sender: TObject);
procedure bbtnCreateSynonymClick(Sender: TObject);
procedure bbtnRefreshSynonymClick(Sender: TObject);
procedure bbtnDropSynonymClick(Sender: TObject);
procedure btnAlterProcClick(Sender: TObject);
procedure bbtnExecProClick(Sender: TObject);
procedure btnCreateProcClick(Sender: TObject);
private
{ Private declarations }
FSourceName,
FOwner : string;
ProcSource: TProcSource;
procedure GetSource;
procedure GetArguments;
procedure GetUsed;
procedure GetUses;
public
{ Public declarations }
procedure Init(ObjName, OwnerName: string); override;
end;
var
ProcedurePropertiesFrm: TProcedurePropertiesFrm;
implementation
{$R *.dfm}
uses frmSchemaBrowser, Util, frmViewDetail, OraStorage,
frmTableSort, frmTableFind, OraGrants, frmGrants, OraTriger,
frmTrigerDetail, frmSynonyms, OraSynonym, frmSchemaPublicEvent,
frmProcedureEditor, frmProcedureRun, frmProcedureDetail,
VisualOptions, GenelDM;
procedure TProcedurePropertiesFrm.Init(ObjName, OwnerName: string);
var
a: boolean;
begin
inherited Show;
DMGenel.ChangeLanguage(self);
ChangeVisualGUI(self);
top := 0;
left := 0;
FSourceName := ObjName;
FOwner := OwnerName;
GetSource;
pcProcedurePropertiesPageChanging(self, pcProcedureProperties.ActivePage ,a);
end;
procedure TProcedurePropertiesFrm.pcProcedurePropertiesPageChanging(
Sender: TObject; NewPage: TcxTabSheet; var AllowChange: Boolean);
begin
inherited;
if NewPage = tsArguments then GetArguments;
if NewPage = tsProcedureUses then GetUses;
if NewPage = tsProcedureUsedBy then GetUsed;
end;
{*******************************************************************************}
{ S O U R C E }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.GetSource;
begin
if ProcSource <> nil then
FreeAndNil(ProcSource);
ProcSource := TProcSource.Create;
ProcSource.OraSession := TSchemaBrowserFrm(Application.MainForm.ActiveMDIChild).OraSession;
ProcSource.SOURCE_NAME := FSourceName;
ProcSource.OWNER := FOwner;
if ObjectType = dbProcedures then
ProcSource.SOURCE_TYPE := stProcedure;
if ObjectType = dbFunctions then
ProcSource.SOURCE_TYPE := stFunction;
if ObjectType = dbPackages then
ProcSource.SOURCE_TYPE := stPackage;
if ObjectType = dbTypes then
ProcSource.SOURCE_TYPE := stType;
tsBody.TabVisible := ProcSource.SOURCE_TYPE = stPackage;
ProcSource.SetDDL;
redtCode.Text := ProcSource.GetDDL;
CodeColors(self, 'Default', redtCode, false);
redtBodyCode.Text := ProcSource.GetBodyDDL;
CodeColors(self, 'Default', redtBodyCode, false);
edtName.Text := ProcSource.SOURCE_NAME;
edtOwner.Text := ProcSource.OWNER;
lblDescription.Caption := ProcSource.SourceStatus;
lviewError.Items.Clear;
FillViewHorizontal(ProcSource.SourceErrors, lviewError);
lviewBodyError.Items.Clear;
if ProcSource.SOURCE_TYPE = stPackage then
FillViewHorizontal(ProcSource.SourceBodyErrors, lviewBodyError);
vtGrants.close;
vtGrants.Assign(ProcSource.GrantList.DSGrantList);
vtGrants.Open;
vtSynonyms.close;
vtSynonyms.Assign(ProcSource.SynonymList.DSSynonymList);
vtSynonyms.Open;
end;
procedure TProcedurePropertiesFrm.btnDropProcClick(Sender: TObject);
begin
if ProcSource.SOURCE_NAME= '' then exit;
if ProcSource = nil then exit;
if SchemaPublicEventFrm.Init(ProcSource, oeDrop) then
TSchemaBrowserFrm(Application.MainForm.ActiveMDIChild).RefreshNode(dbProcedures);
end;
procedure TProcedurePropertiesFrm.btnCompileProcClick(Sender: TObject);
begin
if ProcSource.SOURCE_NAME= '' then exit;
if ProcSource = nil then exit;
if SchemaPublicEventFrm.Init(ProcSource, oeCompile) then
GetSource;
end;
procedure TProcedurePropertiesFrm.bbtnExecProClick(Sender: TObject);
begin
inherited;
if ProcSource.SOURCE_NAME= '' then exit;
if ProcSource = nil then exit;
ProcedureRunFrm.Init(ProcSource);
end;
procedure TProcedurePropertiesFrm.btnRefreshProcClick(Sender: TObject);
begin
GetSource;
end;
{*******************************************************************************}
{ ARGUMENTS }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.GetArguments;
begin
vtArguments.Close;
vtArguments.Assign(ProcSource.Arguments);
vtArguments.Open;
end;
{*******************************************************************************}
{ U S E D }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.GetUsed;
begin
vtUsed.Close;
vtUsed.Assign(ProcSource.UsedByList);
vtUsed.Open;
end;
{*******************************************************************************}
{ U S E S }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.GetUses;
begin
vtUses.Close;
vtUses.Assign(ProcSource.UsesList);
vtUses.Open;
end;
{*******************************************************************************}
{ G R A N T S }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.bbtnGrantPrivilegesClick(
Sender: TObject);
begin
inherited;
if GrantsFrm.Init(ProcSource.GrantList) then
btnRefreshGrants.Click;
end;
procedure TProcedurePropertiesFrm.btnRefreshGrantsClick(Sender: TObject);
begin
inherited;
ProcSource.GrantList.SetDDL;
vtGrants.close;
vtGrants.Assign(ProcSource.GrantList.DSGrantList);
vtGrants.Open;
end;
{*******************************************************************************}
{ S Y N O N Y M S }
{*******************************************************************************}
procedure TProcedurePropertiesFrm.bbtnCreateSynonymClick(Sender: TObject);
begin
inherited;
if SynonymsFrm.Init(ProcSource.SynonymList) then
bbtnRefreshSynonym.Click;
end;
procedure TProcedurePropertiesFrm.bbtnRefreshSynonymClick(Sender: TObject);
begin
inherited;
ProcSource.SynonymList.SetDDL;
vtSynonyms.close;
vtSynonyms.Assign(ProcSource.SynonymList.DSSynonymList);
vtSynonyms.Open;
end;
procedure TProcedurePropertiesFrm.bbtnDropSynonymClick(Sender: TObject);
var
SynonymList: TSynonymList;
FSynonym: TSynonym;
begin
inherited;
if not vtSynonyms.Active then exit;
new(FSynonym);
FSynonym^.Owner := FOwner;
FSynonym^.SynonymName := vtSynonyms.FieldByName('SYNONYM_NAME').AsString;
FSynonym^.TableOwner := vtSynonyms.FieldByName('TABLE_OWNER').AsString;
FSynonym^.TableName := vtSynonyms.FieldByName('TABLE_NAME').AsString;
SynonymList := TSynonymList.Create;
SynonymList.OraSession := ProcSource.OraSession;
SynonymList.TableOwner := FOwner;
SynonymList.TableName := FSourceName;
SynonymList.SynonymAdd(FSynonym);
if SchemaPublicEventFrm.Init(SynonymList, oeDrop) then
bbtnRefreshSynonym.Click;
end;
procedure TProcedurePropertiesFrm.btnAlterProcClick(Sender: TObject);
var
f : TProcedureEditorFrm;
begin
inherited;
ProcSource.Mode := UpdateMode;
f := TProcedureEditorFrm.Create(Application);
f.Init(ProcSource);
end;
procedure TProcedurePropertiesFrm.btnCreateProcClick(Sender: TObject);
var
f : TProcedureEditorFrm;
FProcSource : TProcSource;
begin
inherited;
FProcSource := ProcedureDetailFrm.Init(ProcSource);
if FProcSource <> nil then
begin
ProcSource.Mode := InsertMode;
f := TProcedureEditorFrm.Create(Application);
f.Init(FProcSource);
end;
end;
end.
|
unit VersionCompare;
interface
function NeedsUpdate(AOld, ANew: string): Boolean;
implementation
uses
Classes, Types, SysUtils, StrUtils, Math;
function NeedsUpdate(AOld, ANew: string): Boolean;
var
LUpdateOnEqual: Boolean;
LOld, LNew: TStringDynArray;
i, LOldV, LNewV: Integer;
begin
Result := False;
LOld := SplitString(AOld, '.');
LNew := SplitString(ANew, '.');
LUpdateOnEqual := Length(LNew) > Length(LOld);
for i := 0 to Min(High(LOld), High(LNew)) do
begin
if TryStrToInt(LOld[i], LOldV) and TryStrToInt(LNew[i], LNewV) then
begin
Result := LNewV > LOldV;
if Result or (LNewV < LOldV) then
begin
LUpdateOnEqual := False;
Break;
end;
end
else
begin
raise Exception.Create('Error in Versionstring');
end;
end;
Result := Result or LUpdateOnEqual;
end;
end.
|
unit NetObjClientProc;
interface
uses
NetBaseObj;
procedure NetClientConnect(ANetClient: PNetClient; AConnectAddress: PNetServerAddress);
procedure NetClientDisconnect(ANetClient: PNetClient);
procedure NetClientSetSendTimeOut(ANetClient: PNetClient; const Value: Integer);
function NetCLientCheckIsConnected(ANetClient: PNetClient): Boolean;
procedure NetClientSendBuf(ANetClient: PNetClient; ABuf: Pointer; ABufSize: Integer; var ASendCount:Integer);
function NetClientRecvBuf(ANetClient: PNetClient; const ABuffer: PAnsiChar; ABufLen: Integer; ATimeOut:Integer): Integer; //单位 秒
implementation
uses
Windows, WinSock2, NetObjClient;
procedure NetClientConnect(ANetClient: PNetClient; AConnectAddress: PNetServerAddress);
var
tmpRet: DWORD;
tmpUlong: u_long;
//strErr:string;
tmpSockAddr: WinSock2.TSockAddrIn;
tmpTimeOut: TTimeVal;
tmpFDSet: TFDSet;
begin
//FUserCancelld := FALSE;
if (Winsock2.INVALID_SOCKET = ANetClient.ConnectSocketHandle) or
(0 = ANetClient.ConnectSocketHandle) then
begin
ANetClient.ConnectSocketHandle := Winsock2.Socket(AF_INET,SOCK_STREAM,0);
if ANetClient.ConnectSocketHandle = INVALID_SOCKET then
begin
//RaiseWSExcption();
end;
end;
if nil <> AConnectAddress then
begin
ANetClient.ConnectAddress := AConnectAddress;
end;
if nil <> ANetClient.ConnectAddress then
begin
if '' = ANetClient.ConnectAddress.HOST then
begin
//raise Exception.Create('TsfSocket.Connect,HOST 为空');
end;
if 0 = ANetClient.ConnectAddress.Port then
begin
//raise Exception.Create('TsfSocket.Connect,PORT 必须大于 0');
end;
end;
if ANetClient.TimeOutConnect > 0 then
begin
//设置非阻塞方式连接
tmpUlong := 1;
tmpRet := ioctlsocket(ANetClient.ConnectSocketHandle, FIONBIO, tmpUlong);
if(tmpRet = SOCKET_ERROR) then
begin
tmpRet := Winsock2.WSAGetLastError();
//strErr := GetLastErrorErrorMessage(iRet);
// raise
// exception.CreateFmt('Connect [1] socket error %d %s',[iRet,strErr]);
end;
end;
ZeroMemory(@tmpSockAddr,SizeOf(tmpSockAddr));
tmpSockAddr.sin_family := AF_INET;
if '' = AConnectAddress.Ip then
begin
AConnectAddress.Ip := ResolveIP(ANetClient.ConnectAddress.HOST);
end;
tmpSockAddr.sin_addr.S_addr := Winsock2.inet_addr(PAnsiChar(@AConnectAddress.Ip[1]));
tmpSockAddr.sin_port := Winsock2.htons(ANetClient.ConnectAddress.Port);
// function connect(s: TSocket; name: PSockAddr; namelen: Integer): Integer; stdcall;
tmpRet := Winsock2.connect(ANetClient.ConnectSocketHandle, PSockAddr(@tmpSockAddr), SizeOf(tmpSockAddr));
if DWORD(SOCKET_ERROR) = tmpRet then
begin
tmpRet := Winsock2.WSAGetLastError();
if tmpRet <> WSAEWOULDBLOCK then
begin
//strErr := GetLastErrorErrorMessage(iRet);
//raise exception.CreateFmt('Connect socket [2] error %d %s',[iRet,strErr]);
end;
end;
if ANetClient.TimeOutConnect > 0 then
begin
//select 模型，即设置超时
tmpTimeOut.tv_sec := ANetClient.TimeOutConnect div 1000;
tmpTimeOut.tv_usec := ANetClient.TimeOutConnect mod 1000;
// ---------------------------------
//FD_ZERO(tmpFDSet);
tmpFDSet.fd_count := 0;
// ---------------------------------
//FD_SET(ANetClient.SocketHandle, tmpFDSet);
if tmpFDSet.fd_count < FD_SETSIZE then
begin
tmpFDSet.fd_array[tmpFDSet.fd_count] := ANetClient.ConnectSocketHandle;
Inc(tmpFDSet.fd_count);
end;
// ---------------------------------
tmpRet := WinSock2.select(0, 0, @tmpFDSet, 0, @tmpTimeOut);
if tmpRet = 0 then //超时
begin
WinSock2.CloseSocket(ANetClient.ConnectSocketHandle);
//FErrorCode := WSAETIMEDOUT;//10060 连接超时
//raise exception.CreateFmt('TsfSocket.Connect failure TimeOut %d ms',[ANetClient.TimeOutConnect]);
end;
//一般非锁定模式套接比较难控制，可以根据实际情况考虑 再设回阻塞模式
tmpUlong := 0;
tmpRet := ioctlsocket(ANetClient.ConnectSocketHandle, FIONBIO, tmpUlong);
if(SOCKET_ERROR = tmpRet) then
begin
//FErrorCode := Winsock2.WSAGetLastError();
//strErr := GetLastErrorErrorMessage(iRet);
//raise exception.CreateFmt('Connect socket [3] error %d %s',[FErrorCode,strErr]);
end;
end;
//FConnected := TRUE;
//ANetClient.RecvCount := 0;
//ANetClient.SendCount := 0;
end;
procedure NetClientDisconnect(ANetClient: PNetClient);
var
ErrCode:Integer;
tmpLinger: TLinger;
begin
if Winsock2.INVALID_SOCKET = ANetClient.ConnectSocketHandle then
Exit;
WinSock2.Shutdown(ANetClient.ConnectSocketHandle, SD_SEND);
//Self.FErrorCode := 0;
tmpLinger.l_onoff := 1;
tmpLinger.l_linger := 0;
if SOCKET_ERROR = Winsock2.SetSockOpt(ANetClient.ConnectSocketHandle,
SOL_SOCKET,
SO_LINGER,
@tmpLinger,
SizeOf(tmpLinger)) then
begin
// ErrCode := WSAGetLastError();
// TmpStr := IntToStr(ErrCode);
// MessageBox(0,'aaaaaaaaaaaaaaaaaaa',PChar(TmpStr),0);
end;
Winsock2.CloseSocket(ANetClient.ConnectSocketHandle);
ANetClient.ConnectSocketHandle := Winsock2.INVALID_SOCKET;
// FConnected := FALSE;
// FInputStream.Position := 0;
// FInputStream.ReadEndPosition := 0;
// Windows.ZeroMemory(FInputStream.Memory,FInputStream.Size);
end;
procedure NetClientSetReadTimeOut(ANetClient: PNetClient; const Value: Integer);
var
tmpNetTimeout: Integer;
begin
if ANetClient.TimeOutSend <> Value then
begin
tmpNetTimeout := Value;
if SOCKET_ERROR = WinSock2.Setsockopt(
ANetClient.ConnectSocketHandle,
SOL_SOCKET,
SO_RCVTIMEO,
PAnsiChar(@tmpNetTimeout),
Sizeof(tmpNetTimeout)) then
begin
//RaiseWSExcption();
end;
end;
end;
procedure NetClientSetSendTimeOut(ANetClient: PNetClient; const Value: Integer);
var
tmpNetTimeout: Integer;
begin
if ANetClient.TimeOutSend <> Value then
begin
tmpNetTimeout := Value;
if SOCKET_ERROR = WinSock2.Setsockopt(
ANetClient.ConnectSocketHandle,
SOL_SOCKET,
SO_SNDTIMEO,
PAnsiChar(@tmpNetTimeout),
Sizeof(tmpNetTimeout)) then
begin
//RaiseWSExcption();
end;
end;
end;
function NetCLientCheckIsConnected(ANetClient: PNetClient): Boolean;
var
tmpTimeOut: TTimeVal;
tmpNetTimeoutValue: Integer;
tmpFDSet: TFDSet;
i: integer;
iRet: integer;
Len: Integer;
argp: DWORD;
Buf: array[1..32] of Byte;
begin
tmpTimeOut.tv_sec := 0;
tmpTimeOut.tv_usec := 0;
tmpFDSet.fd_array[0] := ANetClient.ConnectSocketHandle;
tmpFDSet.fd_count := 1;
iRet := WinSock2.Select(0, @tmpFDSet, 0, 0, @tmpTimeOut);
Result := (iRet = 1);
if iRet = SOCKET_ERROR then
begin
//FErrorCode := WSAGetLastError();
end;
if Result then
begin
//对方优雅关闭检测
I := 0;
Len := SizeOf(Integer);
iRet := WinSock2.getsockopt(ANetClient.ConnectSocketHandle, SOL_SOCKET, SO_RCVTIMEO, @I, Len);
if iRet < 0 then
I := -1;
if I < 0 then
begin
Result := FALSE;
Exit;
end;
tmpNetTimeoutValue := 10;
if 0 <> WinSock2.Setsockopt(ANetClient.ConnectSocketHandle, SOL_SOCKET, SO_RCVTIMEO,
PAnsiChar(@tmpNetTimeoutValue),Sizeof(tmpNetTimeoutValue)) then
begin
Result := FALSE;
Exit;
end;
iRet := recv(ANetClient.ConnectSocketHandle, Buf, 1, MSG_PEEK);
Result := (iRet > 0);
//setRecvTimeOut(I);
tmpNetTimeoutValue := I;
iRet := WinSock2.Setsockopt(
ANetClient.ConnectSocketHandle,
SOL_SOCKET,
SO_RCVTIMEO,
PAnsiChar(@tmpNetTimeoutValue),
Sizeof(tmpNetTimeoutValue));
if iRet = SOCKET_ERROR then
begin
//RaiseWSExcption();
end;
end;
end;
procedure NetClientSendBuf(ANetClient: PNetClient; ABuf: Pointer; ABufSize: Integer; var ASendCount:Integer);
const
SF_SOCKET_BUFF_SIZE = 1024 * 32;
INT_BUF_SIZE = SF_SOCKET_BUFF_SIZE;
var
P: PAnsiChar;
tmpLen: Integer;
iRet: Integer;
begin
P := ABuf;
//FErrorCode := 0;
//gLock();
ASendCount := 0;
//gUnLock();
//\\
while (ABufSize > 0) do
begin
if ABufSize > INT_BUF_SIZE then
tmpLen := INT_BUF_SIZE
else
tmpLen := ABufSize;
//iRet := Winsock2.Send(Socket,P^,Len,0);
//iRet := Inner_Send(P^, Len);
iRet := Winsock2.Send(ANetClient.ConnectSocketHandle, P^, tmpLen, 0);
if iRet > 0 then
begin
//if UserCancelled then
//begin
//FErrorCode := ERROR_CANCELLED;
//raise Exception.Create('Inner_send,User_Abort');
//end;
//gLock();
//Inc(FSendCount, iRet);
//gUnLock();
end;
if WinSock2.SOCKET_ERROR = iRet then
begin
//FErrorCode := Winsock2.WSAGetLastError();
//raise Exception.CreateFmt('SendBuf ErrorCode = %d',[FErrorCode]);
Break;
end;
//gLock();
Inc(ASendCount, iRet);
//gUnLock();
Inc(P, iRet);
Dec(ABufSize, iRet);
end;
end;
function NetClientRecvBuf(ANetClient: PNetClient; const ABuffer: PAnsiChar; ABufLen: Integer; ATimeOut:Integer): Integer; //单位 秒
const
eof:AnsiString = #13#10#13#10;
var
iRet,Len:Integer;
P:PAnsiChar;
begin
Result := -1;
if ATimeOut > 0 then
NetClientSetReadTimeOut(ANetClient, ATimeOut)
else
NetClientSetReadTimeOut(ANetClient, ANetClient.TimeOutRead); //设置读超时
(*//
if FInputStream.Datalen >= 4 then
begin
P := FInputStream.Memory;
Inc(P,FInputStream.Position);
Result := sfString.PosBuff(P,PAnsiChar(eof),FInputStream.Datalen,4);
if Result > 0 then
begin
if (Result - 1) <= BufLen then
begin
FInputStream.Read(Bufffer^,Result - 1);
FInputStream.Position := FInputStream.Position + 4;
end
else if Len < 1 then raise exception.Create('ReadLnII 缓冲区内未收到#13#10#13#10');
Exit;
end;
end;
//*)
//数据归位
(*//
P := FInputStream.Memory;
Inc(P,FInputStream.Position);
Windows.MoveMemory(FInputStream.Memory,P,FInputStream.Datalen);
FInputStream.ReadEndPosition := FInputStream.Datalen;
FInputStream.Position := 0;
//*)
//\\
while(TRUE) do
begin
(*//
P := FInputStream.Memory;
Inc(P,FInputStream.ReadEndPosition);
Len := FInputStream.Size - FInputStream.ReadEndPosition;
if Len <= 0 then Break;
//*)
//iRet := Winsock2.recv(Socket,P^,Len,0);
//iRet := Inner_Recv(P^,Len);
iRet := WinSock2.recv(ANetClient.ConnectSocketHandle, ABuffer^, ABufLen, 0);
if iRet > 0 then
begin
end;
Break;
if iRet > 0 then
begin
(*//
FInputStream.ReadEndPosition := FInputStream.ReadEndPosition + iRet;
P := FInputStream.Memory;
Result := sfString.PosBuff(P,PAnsiChar(eof),FInputStream.Datalen,4);
if Result > 0 then
begin
if (Result - 1) <= BufLen then
begin
FInputStream.Read(Bufffer^,Result - 1);
FInputStream.Position := FInputStream.Position + 4;
Break;
end else
raise exception.Create('ReadLnII 缓冲区内未收到#13#10#13#10');
end;
//*)
end else if iRet = 0 then
begin
//对方已经优雅的关闭了连接
Result := 0;
//FErrorCode := ERROR_GRACEFUL_DISCONNECT;//对方优雅关闭
//raise exception.Create('ReadLnII 对方已经优雅的关闭了连接');
end else
begin
(*//
Result := -1;
FErrorCode := WSAGetLastError();
if FErrorCode <> 0 then
raise exception.Create('ReadLnII ErrorCode=' + IntToStr(FErrorCode));
break;
//*)
end;
end;//while end
end;
end.
|
Unit PLUSMEM;
Interface
Type
PufferT = Array[0..$FFF7] Of Byte;
PufferP = ^PufferT;
Function Ext_Init( Size : LongInt;
MaxBufSize : Word):Integer;
{ Ezt a fuggvenyt kell a legelejen meghivni,
a teljes memoriaszukseglet ertekevel, es a
legnagyobb tomb meretevel. }
Function Ext_Alloc( Var Handle : Integer;
Size : Word):Integer;
{ Ez a fuggveny allokalja a tombunk reszere a memoriat.
A Handle nevu valtozoban visszaadott szammal hivatkozhatunk
kesobb a tombre. }
Function Ext_Address( Handle : Integer;
Var P : Pointer):Integer;
{ Mielott egy tombot hasznalunk, ezt a fuggvenyt hivjuk meg.
A P nevu valtozoban a Handle-ben megjelolt tombre mutato
pointert kapjuk meg.}
Procedure Ext_Save;
{ Ezt a eljarast a tombok feltoltesenel hasznaljuk. Ha az
Ext_Alloc-kal lefoglalt, es az Ext_Address-szel megjelolt
tombbe betoltottuk az adatokat, hivjuk meg ezt a fuggvenyt,
es a tomb tartalma az XMS memoriaba masolodik. EMS eseten ez
az eljaras nem csinal semmit, mivel ilyenkor a tombbe irt
adatok kozvetlenul az EMS memoriaba kerulnek. }
Procedure Ext_Close;
{ Ez az eljaras felszabaditja a lefoglalt memoriat }
Procedure Ext_Enter;
{ Most mi jovunk }
Procedure Ext_Leave;
{ Visszaallitjuk az eredetit }
{
Procedure Ext_Test;
}
Implementation
Uses XMSCDW,EMSCDW{,Printer,crt};
Const
MaxBlocks = 20;
MaxPages = MaxBlocks*4;
MaxSzelet = 5;
TartalekPage = 2;
Type
TypeOfMem = (Semmi,TXMS,TEMS);
ERec = Record
Cim : LongInt;
Hossz : Word;
PagesC : Word;
Pages : Array[1..4] Of Byte;
{CHS : Word;}
End;
PRec = Array[0..MaxSzelet] Of Word;
Var
EHandle : Word;
XPuffer : PufferP;
ERecs : Array[0..MaxBlocks] Of ERec;
PRecs : Array[0..MaxPages] Of PRec;
NoOfRec : Word;
LastHandle : Word;
EmsSeg : Word;
SzabadSize : LongInt;
OsszesPage : Integer;
Const
MemType : TypeOfMem = Semmi;
Function Ext_Init;
Begin
NoOfRec := 0;
OsszesPage := 0;
FillChar(ERecs,SizeOf(ERecs),0);
FillChar(PRecs,SizeOf(PRecs),0);
Ext_Init := 0;
If Van_Ems And
(Ems_Pages_Available >= ((Size Div $4000)+TartalekPage)) Then
Begin
MemType := TEMS;
OsszesPage := Size Div $4000 + TartalekPage;
Allocate_EMS_Pages(OsszesPage,EHandle);
EmsSeg := Get_Ems_Segment;
End
Else
If VanXms And (XmsMaxBlock >= ((Size+2047) Div 1024)) Then
Begin
If MaxAvail >= MaxBufSize Then
Begin
MemType := TXMS;
GetMem(XPuffer,MaxBufSize);
XmsAlloc((Size+2047) Div 1024,EHandle);
SzabadSize := ((Size+2047) Div 1024)*1024;
End
Else
Ext_Init := -2; { Nincs eleg konvencionalis memoria }
End
Else
Ext_Init := -1; { Nincs eleg XMS vagy EMS }
End;
Function SzeletCim(PageSzam,SzeletSzam:Integer):Word;
Var Cikl : Integer;
Cim : Word;
Begin
Cim := 0;
For Cikl := 0 To SzeletSzam-1 Do
Inc(Cim,PRecs[PageSzam,Cikl]);
SzeletCim := Cim;
End;
Function VanSzabad( { megnezi van-e eleg hely a page-en }
PageSzam : Integer;
Minimum : Word;
Var UresSzelet : Word;
Var SzeletSzam : Integer):Boolean;
Begin
SzeletSzam := 0;
UresSzelet := $4000;
While (SzeletSzam <= MaxSzelet) And
(PRecs[PageSzam,SzeletSzam] <> 0) Do
Begin
Dec(UresSzelet,PRecs[PageSzam,SzeletSzam]);
Inc(SzeletSzam);
End;
VanSzabad := (SzeletSzam <= MaxSzelet) And
(UresSzelet >= Minimum);
End;
Procedure SzKeres( { Keres egy ures szeletet }
Minimum : Word;
Maximum : LongInt;
Var PageSzam : Integer; { A logikai page szam }
Var SzeletSzam : Integer; { Page-en beluli szeletszam }
Var SzeletMeret: Word); { A szelet merete }
Var Cikl : Integer;
Begin
PageSzam := -1;
Cikl := 0;
While (PageSzam=-1) And
(Cikl < OsszesPage) Do
If VanSzabad(Cikl,Minimum,SzeletMeret,SzeletSzam) Then
Begin
PageSzam := Cikl;
If (Minimum > Maximum) Or
(SzeletMeret > Maximum) Then
SzeletMeret := Maximum;
PRecs[PageSzam,SzeletSzam] := SzeletMeret;
End
Else
Inc(Cikl);
End;
Function Ext_Alloc;
Var Cikl : Integer;
MostKell : Word;
OsszKell : LongInt;
PageSz : Integer;
SzeletSz : Integer;
SzMeret : Word;
Begin
Ext_Alloc := 0;
If NoOfRec < MaxBlocks Then
Begin
INC(NoOfRec);
Handle := NoOfRec;
If Odd(Size) Then
Inc(Size);
With ERecS[Handle] Do
Case MemType Of
TXMS : If SzabadSize >= Size Then
Begin
Cim := ERecs[NoOfRec-1].Cim +
ERecs[NoOfRec-1].Hossz;
Hossz := Size;
End
Else
Ext_Alloc := -3; { nincs elegendo XMS }
TEMS : Begin
If Size > $C000 Then
Begin
MostKell := Size Mod $4000;
If MostKell = 0 Then
MostKell := $4000;
End
Else
MostKell := 1;
OsszKell := Size;
Cikl := 0;
Repeat
SzKeres(MostKell,OsszKell,PageSz,SzeletSz,SzMeret);
Inc(Cikl);
If PageSz <> -1 Then
Begin
If Cikl = 1 Then
Begin
Cim := SzeletCim(PageSz,SzeletSz);
Hossz := Size;
End;
Pages[Cikl] := PageSz;
Dec(OsszKell,SzMeret);
MostKell := $4000
End;
Until (PageSz = -1) Or (OsszKell=0);
PagesC := Cikl;
If PageSz = -1 Then
Ext_Alloc := -2; { Nem talalt megfelelo page-et ! }
End
End { Case }
End { ha van meg szabad blokk }
Else
Ext_Alloc := -1; { Tul sok tomb ! }
End;
Function Ext_Address;
Var Cikl : Integer;
Begin
LastHandle := Handle;
Case MemType Of
TXMS : Begin
P := XPuffer;
Xms_Down(EHandle,ERecs[Handle].Cim,P,ERecs[Handle].Hossz);
End;
TEMS : With ERecs[Handle] Do
Begin
For Cikl := 1 To PagesC Do
Get_Ems_PageN(EHandle,Cikl-1,Pages[Cikl]);
P := Ptr(EmsSeg,Cim);
End;
End { Case }
End;
Procedure Ext_Save;
Var P : PufferP;
Cikl : Word;
Begin
If MemType = TXMS Then
Xms_Up(EHandle,XPuffer,ERecs[LastHandle].Cim,ERecs[LastHandle].Hossz);
{
With ERecs[LastHandle] Do
Begin
CHS := 0;
If MemType = TXMS Then
P := XPuffer
Else
P := Ptr(EmsSeg,Cim);
For Cikl := 0 To Hossz-1 Do
INC(CHS,P^[Cikl])
End; }
End;
Procedure Ext_Close;
Begin
Case MemType Of
TXMS : XmsDealloc(EHandle);
TEMS : Release_Ems(EHandle)
End;
MemType := Semmi
End;
Procedure Ext_Enter;
Begin
If MemType = TEMS Then
Save_EMS(EHandle);
End;
Procedure Ext_Leave;
Begin
If MemType = TEMS Then
Restore_EMS(EHandle);
End;
{
Procedure Ext_Test;
Var Cikl,Cikl2 : Integer;
Cikl3 : Word;
CCC : Word;
P : PufferP;
Begin
For Cikl := 1 To NoOfRec Do
With ERecs[Cikl] Do
Begin
Write(lst,Cikl:2,'. <',Cim,'> ',Hossz,' Pages :');
For Cikl2 := 1 To PagesC Do
Write(Lst,Pages[Cikl2],',');
Ext_Enter;
Ext_Address(Cikl,Pointer(P));
CCC := 0;
For Cikl3 := 0 To Hossz-1 Do
Inc(CCC,P^[Cikl3]);
Ext_Leave;
Write(Lst,' ',CHS=CCC,' CHS:',CHS,' CCC:',CCC);
Writeln(Lst);
End;
For Cikl := 0 To OsszesPage-1 Do
Begin
Write(Lst,Cikl:2,'. ');
For Cikl2 := 0 To MaxSzelet Do
Write(Lst,PRecs[Cikl,Cikl2],',');
Writeln(Lst);
End;
End;
}
End. |
unit Helper.Form.TabHandlingFMX;
interface
uses
FMX.Forms,
FMX.Types,
Classes,
FMX.Controls;
type
TFormHelper = class helper for TFMXObject
procedure DoTabHandling(aParent : TFMXObject; tabOrder : Integer);
end;
implementation
procedure TFormHelper.DoTabHandling(aParent: TFMXObject; tabOrder : Integer);
var
i : Integer;
procedure FindComponentOrder(aValue : TComponent);
var
I : Integer;
begin
for I := 0 to Pred(aValue.ComponentCount) do
begin
if (aValue.Components[I].ComponentCount > 0) and (aValue.Components[I].ClassName <> 'TEdit') then
FindComponentOrder(aValue.Components[I])
else
begin
if (aValue.Components[i] is TStyledControl) then
begin
if ((aValue.Components[i] as TStyledControl).HelpContext > tabOrder) then
begin
(aValue.Components[i] as TStyledControl).SetFocus;
exit;
end;
end;
end;
end;
end;
begin
for i := 0 to Pred(aParent.ComponentCount) do
FindComponentOrder(aParent.Components[i]);
end;
end.
|
{
* ABTypedefs.h
* AddressBook Framework
*
* Copyright (c) 2002-2003 Apple Computer. All rights reserved.
*
}
{ Pascal Translation: Peter N Lewis, <peter@stairways.com.au>, 2004 }
{
Modified for use with Free Pascal
Version 210
Please report any bugs to <gpc@microbizz.nl>
}
{$mode macpas}
{$packenum 1}
{$macro on}
{$inline on}
{$calling mwpascal}
unit ABTypedefs;
interface
{$setc UNIVERSAL_INTERFACES_VERSION := $0342}
{$setc GAP_INTERFACES_VERSION := $0210}
{$ifc not defined USE_CFSTR_CONSTANT_MACROS}
{$setc USE_CFSTR_CONSTANT_MACROS := TRUE}
{$endc}
{$ifc defined CPUPOWERPC and defined CPUI386}
{$error Conflicting initial definitions for CPUPOWERPC and CPUI386}
{$endc}
{$ifc defined FPC_BIG_ENDIAN and defined FPC_LITTLE_ENDIAN}
{$error Conflicting initial definitions for FPC_BIG_ENDIAN and FPC_LITTLE_ENDIAN}
{$endc}
{$ifc not defined __ppc__ and defined CPUPOWERPC}
{$setc __ppc__ := 1}
{$elsec}
{$setc __ppc__ := 0}
{$endc}
{$ifc not defined __i386__ and defined CPUI386}
{$setc __i386__ := 1}
{$elsec}
{$setc __i386__ := 0}
{$endc}
{$ifc defined __ppc__ and __ppc__ and defined __i386__ and __i386__}
{$error Conflicting definitions for __ppc__ and __i386__}
{$endc}
{$ifc defined __ppc__ and __ppc__}
{$setc TARGET_CPU_PPC := TRUE}
{$setc TARGET_CPU_X86 := FALSE}
{$elifc defined __i386__ and __i386__}
{$setc TARGET_CPU_PPC := FALSE}
{$setc TARGET_CPU_X86 := TRUE}
{$elsec}
{$error Neither __ppc__ nor __i386__ is defined.}
{$endc}
{$setc TARGET_CPU_PPC_64 := FALSE}
{$ifc defined FPC_BIG_ENDIAN}
{$setc TARGET_RT_BIG_ENDIAN := TRUE}
{$setc TARGET_RT_LITTLE_ENDIAN := FALSE}
{$elifc defined FPC_LITTLE_ENDIAN}
{$setc TARGET_RT_BIG_ENDIAN := FALSE}
{$setc TARGET_RT_LITTLE_ENDIAN := TRUE}
{$elsec}
{$error Neither FPC_BIG_ENDIAN nor FPC_LITTLE_ENDIAN are defined.}
{$endc}
{$setc ACCESSOR_CALLS_ARE_FUNCTIONS := TRUE}
{$setc CALL_NOT_IN_CARBON := FALSE}
{$setc OLDROUTINENAMES := FALSE}
{$setc OPAQUE_TOOLBOX_STRUCTS := TRUE}
{$setc OPAQUE_UPP_TYPES := TRUE}
{$setc OTCARBONAPPLICATION := TRUE}
{$setc OTKERNEL := FALSE}
{$setc PM_USE_SESSION_APIS := TRUE}
{$setc TARGET_API_MAC_CARBON := TRUE}
{$setc TARGET_API_MAC_OS8 := FALSE}
{$setc TARGET_API_MAC_OSX := TRUE}
{$setc TARGET_CARBON := TRUE}
{$setc TARGET_CPU_68K := FALSE}
{$setc TARGET_CPU_MIPS := FALSE}
{$setc TARGET_CPU_SPARC := FALSE}
{$setc TARGET_OS_MAC := TRUE}
{$setc TARGET_OS_UNIX := FALSE}
{$setc TARGET_OS_WIN32 := FALSE}
{$setc TARGET_RT_MAC_68881 := FALSE}
{$setc TARGET_RT_MAC_CFM := FALSE}
{$setc TARGET_RT_MAC_MACHO := TRUE}
{$setc TYPED_FUNCTION_POINTERS := TRUE}
{$setc TYPE_BOOL := FALSE}
{$setc TYPE_EXTENDED := FALSE}
{$setc TYPE_LONGLONG := TRUE}
uses MacTypes;
{$ALIGN MAC68K}
const
kABMultiValueMask = $100;
type
ABPropertyType = SInt32;
const
kABErrorInProperty = 0;
kABStringProperty = 1;
kABIntegerProperty = 2;
kABRealProperty = 3;
kABDateProperty = 4;
kABArrayProperty = 5;
kABDictionaryProperty = 6;
kABDataProperty = 7;
kABMultiStringProperty = kABMultiValueMask or kABStringProperty;
kABMultiIntegerProperty = kABMultiValueMask or kABIntegerProperty;
kABMultiRealProperty = kABMultiValueMask or kABRealProperty;
kABMultiDateProperty = kABMultiValueMask or kABDateProperty;
kABMultiArrayProperty = kABMultiValueMask or kABArrayProperty;
kABMultiDictionaryProperty = kABMultiValueMask or kABDictionaryProperty;
kABMultiDataProperty = kABMultiValueMask or kABDataProperty;
// ================================================================
// Search APIs
// ================================================================
type
ABSearchComparison = SInt32;
const
kABEqual = 0;
kABNotEqual = 1;
kABLessThan = 2;
kABLessThanOrEqual = 3;
kABGreaterThan = 4;
kABGreaterThanOrEqual = 5;
kABEqualCaseInsensitive = 6;
kABContainsSubString = 7;
kABContainsSubStringCaseInsensitive = 8;
kABPrefixMatch = 9;
kABPrefixMatchCaseInsensitive = 10;
// #if MAC_OS_X_VERSION_10_3 <= MAC_OS_X_VERSION_MAX_ALLOWED
kABBitsInBitFieldMatch = 11;
// #endif
type
ABSearchConjunction = SInt32;
const
kABSearchAnd = 0;
kABSearchOr = 1;
end.
|
unit StockWeightData_Load;
interface
uses
BaseApp,
StockWeightDataAccess;
function LoadStockWeightData(App: TBaseApp; ADataAccess: TStockWeightDataAccess): Boolean;
implementation
uses
Sysutils,
BaseWinFile,
define_Price,
define_datasrc,
//UtilsLog,
define_stock_quotes,
define_dealstore_header,
define_dealstore_file;
function LoadStockWeightDataFromBuffer(ADataAccess: TStockWeightDataAccess; AMemory: pointer): Boolean; forward;
function LoadStockWeightData(App: TBaseApp; ADataAccess: TStockWeightDataAccess): Boolean;
var
tmpWinFile: TWinFile;
tmpFileUrl: WideString;
tmpFileMapView: Pointer;
begin
Result := false;
tmpFileUrl := App.Path.GetFileUrl(ADataAccess.DBType, ADataAccess.DataType, GetDealDataSourceCode(ADataAccess.DataSource), 1, ADataAccess.StockItem);
//Log('LoadStockWeightData', 'FileUrl:' + tmpFileUrl);
if App.Path.IsFileExists(tmpFileUrl) then
begin
//Log('LoadStockWeightData', 'FileUrl exist');
tmpWinFile := TWinFile.Create;
try
if tmpWinFile.OpenFile(tmpFileUrl, false) then
begin
tmpFileMapView := tmpWinFile.OpenFileMap;
if nil <> tmpFileMapView then
begin
Result := LoadStockWeightDataFromBuffer(ADataAccess, tmpFileMapView);
end else
begin
//Log('LoadStockWeightData', 'FileUrl map fail');
end;
end else
begin
//Log('LoadStockWeightData', 'FileUrl open fail');
end;
finally
tmpWinFile.Free;
end;
end;
end;
function ReadStockWeightDataHeader(ADataAccess: TStockWeightDataAccess; AMemory: pointer): PStore_Weight_Header_V1Rec;
var
tmpHead: PStore_Weight_Header_V1Rec;
begin
Result := nil;
tmpHead := AMemory;
if tmpHead.Header.HeadSize = SizeOf(TStore_Weight_Header_V1Rec) then
begin
if (tmpHead.Header.DataType = DataType_Stock) then
begin
if (tmpHead.Header.DataMode = DataMode_WeightData) then
begin
if src_unknown = ADataAccess.DataSource then
ADataAccess.DataSource := GetDealDataSource(tmpHead.Header.DataSourceId);
if ADataAccess.DataSource = GetDealDataSource(tmpHead.Header.DataSourceId) then
begin
Result := tmpHead;
end;
end;
end;
end;
end;
function LoadStockWeightDataFromBuffer(ADataAccess: TStockWeightDataAccess; AMemory: pointer): Boolean;
var
tmpHead: PStore_Weight_Header_V1Rec;
tmpStoreWeightData: PStore_Stock_WeightRec;
tmpWeightData: PRT_Weight;
tmpRecordCount: integer;
i: integer;
begin
Result := false;
//Log('LoadStockWeightData', 'LoadStockWeightDataFromBuffer');
tmpHead := ReadStockWeightDataHeader(ADataAccess, AMemory);
if nil <> tmpHead then
begin
tmpRecordCount := tmpHead.Header.RecordCount;
//Log('LoadStockWeightData', 'LoadStockWeightDataFromBuffer record count:' + IntToStr(tmpRecordCount));
Inc(tmpHead);
tmpStoreWeightData := PStore_Stock_WeightRec(tmpHead);
for i := 0 to tmpRecordCount - 1 do
begin
Result := true;
tmpWeightData := ADataAccess.CheckOutRecord(tmpStoreWeightData.WeightData.StartDate);
if nil <> tmpWeightData then
begin
end;
Inc(tmpStoreWeightData);
end;
ADataAccess.Sort;
end;
end;
end.
|
{ This module from FPC port of RX components library
Copyright (C) 2005-2010 Lagunov Aleksey alexs@yandex.ru and Lazarus team
original conception from rx library for Delphi (c)
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at your
option) any later version with the following modification:
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent modules,and
to copy and distribute the resulting executable under terms of your choice,
provided that you also meet, for each linked independent module, the terms
and conditions of the license of that module. An independent module is a
module which is not derived from or based on this library. If you modify
this library, you may extend this exception to your version of the library,
but you are not obligated to do so. If you do not wish to do so, delete this
exception statement from your version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
for more details.
You should have received a copy of the GNU Library General Public License
along with this library; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
}
unit rxsortmemds;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, DB, RxDBGrid;
type
{ TRxMemoryDataSortEngine }
TRxMemoryDataSortEngine = class(TRxDBGridSortEngine)
protected
public
procedure Sort(FieldName: string; ADataSet:TDataSet; Asc:boolean; SortOptions:TRxSortEngineOptions);override;
procedure SortList(ListField:string; ADataSet:TDataSet; Asc: array of boolean; SortOptions: TRxSortEngineOptions);override;
end;
implementation
uses rxmemds;
procedure TRxMemoryDataSortEngine.Sort(FieldName: string; ADataSet: TDataSet;
Asc: boolean; SortOptions: TRxSortEngineOptions);
begin
if Assigned(ADataSet) then
(ADataSet as TRxMemoryData).SortOnFields(FieldName, seoCaseInsensitiveSort in SortOptions, not Asc);
end;
procedure TRxMemoryDataSortEngine.SortList(ListField: string;
ADataSet: TDataSet; Asc: array of boolean; SortOptions: TRxSortEngineOptions);
begin
if Assigned(ADataSet) then
(ADataSet as TRxMemoryData).SortOnFields(ListField, seoCaseInsensitiveSort in SortOptions, Asc[0]);
end;
initialization
RegisterRxDBGridSortEngine(TRxMemoryDataSortEngine, 'TRxMemoryData');
end.
|
//Base code Font: https://github.com/RRUZ/blog/tree/master/Misc/SelectDelphiVersion
unit uDelphiInstallationCheck;
interface
uses
Controls, SysUtils, Windows, ComCtrls;
type
TDelphiVersions = (
Delphi4,
Delphi5,
Delphi6,
Delphi7,
Delphi8,
Delphi2005,
Delphi2006,
Delphi2007,
Delphi2009,
Delphi2010,
DelphiXE,
DelphiXE2,
DelphiXE3,
DelphiXE4,
DelphiXE5,
DelphiXE6,
DelphiXE7,
DelphiXE8,
DelphiSeattle10,
DelphiBerlin101);
TDelphiInstallationCheck = class(TObject)
public
procedure LoadInstalledVersions(ImageList: TImageList; ListView: TListView);
function GetDelphiVersionByName(DelphiName: string): TDelphiVersions;
function GetDelphiRegPathFromVersion(Version: TDelphiVersions): string;
end;
implementation
uses
Registry, CommCtrl, ShellAPI;
const
TDelphiVersionsNames: array [TDelphiVersions] of string = (
'Delphi 4',
'Delphi 5',
'Delphi 6',
'Delphi 7',
'Delphi 8',
'BDS 2005',
'BDS 2006',
'RAD Studio 2007',
'RAD Studio 2009',
'RAD Studio 2010',
'RAD Studio XE',
'RAD Studio XE 2',
'RAD Studio XE 3',
'RAD Studio XE 4',
'RAD Studio XE 5',
'RAD Studio XE 6',
'RAD Studio XE 7',
'RAD Studio XE 8',
'RAD Studio 10 Seattle',
'RAD Studio 10.1 Berlin'
);
TDelphiRegPaths: array [TDelphiVersions] of string = (
'\Software\Borland\Delphi\4.0',
'\Software\Borland\Delphi\5.0',
'\Software\Borland\Delphi\6.0',
'\Software\Borland\Delphi\7.0',
'\Software\Borland\BDS\2.0',
'\Software\Borland\BDS\3.0',
'\Software\Borland\BDS\4.0',
'\Software\Borland\BDS\5.0',
'\Software\CodeGear\BDS\6.0',
'\Software\CodeGear\BDS\7.0',
'\Software\Embarcadero\BDS\8.0',
'\Software\Embarcadero\BDS\9.0',
'\Software\Embarcadero\BDS\10.0',
'\Software\Embarcadero\BDS\11.0',
'\Software\Embarcadero\BDS\12.0',
'\Software\Embarcadero\BDS\14.0',
'\Software\Embarcadero\BDS\15.0',
'\Software\Embarcadero\BDS\16.0',
'\Software\Embarcadero\BDS\17.0',
'\Software\Embarcadero\BDS\18.0'
);
function RegKeyExists(const RegPath: string; const RootKey: HKEY): Boolean;
var
Reg: TRegistry;
begin
try
Reg := TRegistry.Create;
try
Reg.RootKey := RootKey;
Result := Reg.KeyExists(RegPath);
finally
Reg.Free;
end;
except
Result := False;
end;
end;
function RegReadStr(const RegPath, RegValue: string; var Str: string; const RootKey: HKEY): Boolean;
var
Reg: TRegistry;
begin
try
Reg := TRegistry.Create;
try
Reg.RootKey := RootKey;
Result := Reg.OpenKey(RegPath, True);
if Result then
Str := Reg.ReadString(RegValue);
finally
Reg.Free;
end;
except
Result := False;
end;
end;
procedure ExtractIconFileToImageList(ImageList: TImageList; const Filename: string);
var
FileInfo: TShFileInfo;
begin
if FileExists(Filename) then
begin
FillChar(FileInfo, SizeOf(FileInfo), 0);
SHGetFileInfo(PChar(Filename), 0, FileInfo, SizeOf(FileInfo), SHGFI_ICON or SHGFI_SMALLICON);
if FileInfo.hIcon <> 0 then
begin
ImageList_AddIcon(ImageList.Handle, FileInfo.hIcon);
DestroyIcon(FileInfo.hIcon);
end;
end;
end;
{ TFrmSelDelphiVer }
function TDelphiInstallationCheck.GetDelphiRegPathFromVersion(Version: TDelphiVersions): string;
begin
Result := TDelphiRegPaths[Version];
end;
function TDelphiInstallationCheck.GetDelphiVersionByName(DelphiName: string): TDelphiVersions;
var
DelphiComp: TDelphiVersions;
begin
for DelphiComp := Low(TDelphiVersions) to High(TDelphiVersions) do
if TDelphiVersionsNames[TDelphiVersions(DelphiComp)] = DelphiName then
begin
Result := TDelphiVersions(DelphiComp);
end;
end;
procedure TDelphiInstallationCheck.LoadInstalledVersions(ImageList: TImageList; ListView: TListView);
Var
Item: TListItem;
DelphiComp: TDelphiVersions;
Filename: string;
ImageIndex: Integer;
begin
for DelphiComp := Low(TDelphiVersions) to High(TDelphiVersions) do
if RegKeyExists(TDelphiRegPaths[DelphiComp], HKEY_CURRENT_USER) then
if RegReadStr(TDelphiRegPaths[DelphiComp], 'App', Filename, HKEY_CURRENT_USER) and FileExists(Filename) then
begin
Item := ListView.Items.Add;
Item.Caption := TDelphiVersionsNames[DelphiComp];
Item.SubItems.Add(Filename);
ExtractIconFileToImageList(ImageList, Filename);
ImageIndex := ImageList.Count - 1;
Item.ImageIndex := ImageIndex;
end;
end;
end.
|
unit OptionsMain;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
ElXPThemedControl, ElTree, StdCtrls, Spin;
type
TOptionsForm = class(TForm)
OptionsTree: TElTree;
procedure FormCreate(Sender: TObject);
procedure OptionsTreeItemFocused(Sender: TObject);
procedure OptionsTreeScroll(Sender: TObject;
ScrollBarKind: TScrollBarKind; ScrollCode: Integer);
private
{ Private declarations }
protected
procedure WMSize(var Message: TMessage); message WM_SIZE;
public
FocusedItem : TElTreeItem;
EditorControl : TWinControl;
end;
var
OptionsForm: TOptionsForm;
implementation
{$R *.DFM}
procedure TOptionsForm.FormCreate(Sender: TObject);
var i,
j : integer;
RootItem,
Item : TElTreeItem;
begin
for i := 0 to 2 do
begin
RootItem := OptionsTree.Items.AddItem(nil);
RootItem.Text := 'Options group';
for j := 0 to 3 do
begin
Item := OptionsTree.Items.AddItem(RootItem);
Item.IsHTML := true;
// This is just to add items of different kinds. In real applications you
// will most likely add items in design-time
Item.Tag := j;
case j of
0: Item.Text := '<html>Text option';
1: Item.Text := '<html>Spin-button option';
2: Item.Text := '<html>Checkbox option';
3: Item.Text := '<html>Combo option';
end;
Item.ColumnText.Add('');
end;
end;
OptionsTree.Show;
end;
procedure TOptionsForm.OptionsTreeItemFocused(Sender: TObject);
var Item : TElTreeItem;
R : TRect;
begin
if EditorControl <> nil then
begin
if FocusedItem <> nil then
begin
case FocusedItem.Tag of
0: begin
FocusedItem.ColumnText[0] := TEdit(EditorControl).Text;
FocusedItem.Text := '<html>Text option (<b>' + FocusedItem.ColumnText[0] + '</b>)';
end;
1: begin
FocusedItem.ColumnText[0] := IntToStr(TSpinEdit(EditorControl).Value);
FocusedItem.Text := '<html>Spin-button option (<b>' + FocusedItem.ColumnText[0] + '</b>)';
end;
2: begin
if TCheckBox(EditorControl).Checked then
FocusedItem.ColumnText[0] := 'On'
else
FocusedItem.ColumnText[0] := 'Off';
FocusedItem.Text := '<html>Checkbox option (<b>' + FocusedItem.ColumnText[0] + '</b>)';
end;
3: begin
FocusedItem.ColumnText[0] := TComboBox(EditorControl).Items[TComboBox(EditorControl).ItemIndex];
FocusedItem.Text := '<html>Combobox option (<b>' + FocusedItem.ColumnText[0] + '</b>)';
end;
end;
end;
FocusedItem := nil;
EditorControl.Free;
EditorControl := nil;
end;
Item := OptionsTree.ItemFocused;
FocusedItem := Item;
if (Item <> nil) and (Item.Level = 1) then
begin
case Item.Tag of
0: begin
EditorControl := TEdit.Create(Self);
R := OptionsTree.GetItemRect(OptionsTree.IndexInView(Item));
R.Left := Item.TextRight + 10;
R.Right := R.Left + 100;
EditorControl.BoundsRect := R;
EditorControl.Parent := OptionsTree;
TEdit(EditorControl).AutoSize := true;
TEdit(EditorControl).Text := Item.ColumnText[0];
end;
1: begin
EditorControl := TSpinEdit.Create(Self);
R := OptionsTree.GetItemRect(OptionsTree.IndexInView(Item));
R.Left := Item.TextRight + 10;
R.Right := R.Left + 100;
EditorControl.BoundsRect := R;
EditorControl.Parent := OptionsTree;
TSpinEdit(EditorControl).AutoSize := false;
TSpinEdit(EditorControl).Value := StrToIntDef(Item.ColumnText[0], 0);
end;
2: begin
EditorControl := TCheckBox.Create(Self);
R := OptionsTree.GetItemRect(OptionsTree.IndexInView(Item));
R.Left := Item.TextRight + 10;
R.Right := R.Left + 13;
R.Bottom := R.Top + 13;
EditorControl.BoundsRect := R;
EditorControl.Parent := OptionsTree;
TCheckBox(EditorControl).Checked := Item.ColumnText[0] = 'On';
end;
3: begin
EditorControl := TComboBox.Create(Self);
R := OptionsTree.GetItemRect(OptionsTree.IndexInView(Item));
R.Left := Item.TextRight + 10;
R.Right := R.Left + 100;
EditorControl.BoundsRect := R;
EditorControl.Parent := OptionsTree;
TComboBox(EditorControl).Style := csDropdownList;
TComboBox(EditorControl).Items.Add('Choice 1');
TComboBox(EditorControl).Items.Add('Choice 2');
TComboBox(EditorControl).Items.Add('Choice 3');
TComboBox(EditorControl).ItemIndex := StrToIntDef(Copy(Item.ColumnText[0], Length(Item.ColumnText[0]), 1), 1) - 1;
end;
end;
end;
end;
procedure TOptionsForm.OptionsTreeScroll(Sender: TObject;
ScrollBarKind: TScrollBarKind; ScrollCode: Integer);
var R : TRect;
begin
if (EditorControl <> nil) and
(OptionsTree.ItemFocused <> nil) then
begin
if OptionsTree.IsInView(OptionsTree.ItemFocused) then
begin
R := OptionsTree.GetItemRect(OptionsTree.IndexInView(OptionsTree.ItemFocused));
EditorControl.Top := R.Top;
EditorControl.Visible := true;
end
else
EditorControl.Visible := false;
end;
end;
procedure TOptionsForm.WMSize(var Message: TMessage);
begin
inherited;
end;
end.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.