Unit mseclasses

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Overview

Classes, Interfaces, Objects and Records

Name	Description
Class `tvirtualpersistent`
Class `townedpersistent`
Record `linkinfoty`
Class `tobjectlinker`
Class `tlinkedobject`
Class `tlinkedrecordlist`
Class `tnullinterfacedpersistent`
Class `toptionalpersistent`
Class `tlinkedpersistent`
Class `tlinkedoptionalpersistent`
Class `teventpersistent`
Class `townedeventpersistent`
Class `teventobject`
Class `tcomponentevent`
Record `skininfoty`
Class `tmsecomponent`
Class `tlinkedqueue`
Class `tlinkedobjectqueue`
Class `tpersistentqueue`
Class `tcomponentqueue`
Class `tobjectlinkrecordlist`
Record `objectdataty`
Class `tpersistenttemplate`
Class `ttemplatecontainer`
Class `tnotifylist`
Class `tmodulelist`
Class `twritermse`
Class `tobjectdatastream`
Record `setsplitpairty`
Record `setsplitinfoty`

Functions and Procedures

function ownscomponent(const owner: tcomponent; const child: tcomponent): boolean;

function ownernamepath(const acomponent: tcomponent): string;

function ownernamepath(const aroot: tcomponent; const acomponent: tcomponent): string;

function namepathowner(const acomponent: tcomponent): string;

function getnumberedname(const acomp: tcomponent; const namebase: string): string;

function ownercomponentpath(const acomponent: tcomponent): componentarty;

function componentpathowner(const acomponent: tcomponent): componentarty;

function rootcomponent(const acomponent: tcomponent): tcomponent;

procedure setcomponentorder(const owner: tcomponent; const anames: msestringarty);

function getcomponentchildren(const acomp: tcomponent; const aroot: tcomponent; const nestedowners: boolean = false; const nestedparents: boolean = false): componentarty;

function getpropinfoar(const obj: tobject): propinfopoarty; overload;

function getpropinfoar(const atypeinfo: ptypeinfo): propinfopoarty; overload;

procedure createobjectlinker(const owner: iobjectlink; onevent: objectlinkeventty; var instance: tobjectlinker);

procedure getoptionalobject(const componentstate: tcomponentstate; const instance: tobject; createproc: createprocty); overload;

procedure getoptionalobject(const aowner: tcomponent; const instance: tobject; createproc: createprocty); overload;

procedure getoptionalobject(const componentstate: tcomponentstate; var instance: tvirtualpersistent; const aclass: virtualpersistentclassty); overload;

procedure setoptionalobject(const componentstate: tcomponentstate; const value: tpersistent; var instance; createproc: createprocty); overload;

procedure setoptionalobject(const aowner: tcomponent; const value: tpersistent; var instance; createproc: createprocty); overload;

procedure setoptionalobject(const componentstate: tcomponentstate; const value: tvirtualpersistent; var instance; const aclass: virtualpersistentclassty); overload;

procedure setlinkedcomponent(const sender: iobjectlink; const source: tmsecomponent; var instance: tmsecomponent; ainterfacetype: pointer = nil);

function createmodule(aowner: tcomponent; instanceclass: msecomponentclassty; var reference): tmsecomponent;

procedure registerobjectdata(datapo: pobjectdataty; objectclass: tpersistentclass; name: string = ''); overload;

procedure registerobjectdata(datapo: pobjectdataty; const objectclassname: string; const name: string = ''); overload;

procedure unregisterobjectdata(const objectclassname: string; const name: string = '');

procedure resetchangedmodules;

procedure reloadchangedmodules;

procedure reloadmodules;

procedure msebegingloballoading;

procedure mseendgloballoading;

procedure reloadmsecomponent(Instance: tmsecomponent);

function initmsecomponent(instance: tmsecomponent; rootancestor: tclass; out needsloading: boolean): boolean;

function initmsecomponent1(instance: tcomponent; rootancestor: tclass): boolean;

function findancestorcomponent(const areader: treader; const componentname: string): tcomponent;

procedure loadmsemodule(const instance: tmsecomponent; const rootancestor: tclass);

function findmoduledata(const aclassname: string; out aparentclassname: string): pobjectdataty;

function getfproppath(const writer:twriter): string;

procedure setfproppath(const writer:twriter; const value: string);

procedure freecomponents(const acomponents: componentarty);

function copycomponent(const source: tcomponent; const aowner: tcomponent = nil; const onfindancestor: tfindancestorevent = nil; const onfindcomponentclass: tfindcomponentclassevent = nil; const oncreatecomponent: tcreatecomponentevent = nil; const onancestornotfound: tancestornotfoundevent = nil): tcomponent;

procedure refreshancestor(var deletedcomps: componentarty; const descendent,newancestor,oldancestor: tcomponent; const revert: boolean; const onfindancestor: tfindancestorevent = nil; const onfindcomponentclass: tfindcomponentclassevent = nil; const oncreatecomponent: tcreatecomponentevent = nil; const onsetmethodproperty: tsetmethodpropertyevent = nil; const onwritemethodproperty: twritemethodpropertyevent = nil; const newcomponent: pboolean = nil );

procedure initinline(const acomponent: tcomponent);

procedure checkinline(const acomponent: tcomponent);

procedure initrootdescendent(const acomponent: tcomponent);

function issubcomponent(const root,child: tcomponent): boolean;

function fixupsetchildorder(const sender: tcomponent; const child: tcomponent; const order: integer): boolean;

function findcomponentbynamepath(const namepath: string): tcomponent;

function findcomponentbynamepath(const namepath: string; const root: tcomponent): tcomponent;

function findsubcomponentbynamepath(const namepath: string; const root: tcomponent): tcomponent;

function getlinkedcomponents(const acomponent: tcomponent): componentarty;

procedure lockfindglobalcomponent;

procedure unlockfindglobalcomponent;

function findglobalcomponentlocked: boolean;

function getenumnames(const atypeinfo: ptypeinfo): msestringarty;

function getclasspropvalue(const instance: tobject; const apropname: string; const aclass: tclass): tobject;

function getclasspropvalue(const instance: tobject; const apropname: string; const aclass: tclass; out avalue: tobject): boolean;

procedure nosupportfor(const sender: tcomponent; const avalue: tcomponent; const ainterface: ptypeinfo);

function getcorbainterface(const aobject: tobject; const aintf: ptypeinfo; out obj) : boolean;

procedure checkcorbainterface(const sender: tcomponent; const avalue: tcomponent; const ainterface: ptypeinfo; out obj);

function isinterface(const actual: ptypeinfo; const wanted: ptypeinfo): boolean;

function isinterfaceornil(const actual: ptypeinfo; const wanted: ptypeinfo): boolean;

function checkcanevent(const acomponent: tcomponent; const event: tmethod): boolean; overload;

function checkcanevent(const event: tmethod): boolean; overload;

procedure readstringar(const reader: treader; out ar: stringarty); overload;

procedure readstringar(const reader: treader; out ar: msestringarty); overload;

procedure writestringar(const writer: twriter; const ar: stringarty); overload;

procedure writestringar(const writer: twriter; const ar: msestringarty); overload;

procedure readintar(const reader: treader; out ar: int32arty);

procedure readintar(const reader: treader; out ar: int16arty);

procedure writeintar(const writer: twriter; const ar: int32arty);

procedure writeintar(const writer: twriter; const ar: int16arty);

procedure readrecordar(const reader: treader; out ar; const typeinfo: pdynarraytypeinfo; const readproc: readrecordprocty);

procedure writerecordar(const writer: twriter; const ar; const typeinfo: pdynarraytypeinfo; const writeproc: writerecordprocty);

function valuescaletorange(const reader: treader): real;

function swapmethodtable(const instance: tobject; const newtable: pointer): pointer;

function checkenumvalue(typeinfo : ptypeinfo;const name : string) : integer;

function readenum(const reader: treader; const atypeinfo: ptypeinfo): integer;

procedure writeenum(const writer: twriter; const value: integer; const atypeinfo: ptypeinfo);

function readset(const reader: treader; const atypeinfo: ptypeinfo): tintegerset;

procedure writeset(const writer: twriter; const value: tintegerset; const atypeinfo: ptypeinfo);

function readsplitset(const reader: treader; const info: setsplitinfoty; out set1,set2: tintegerset): boolean;

function setloading(const acomponent: tcomponent; const avalue: boolean): boolean;

function alive(const acomponent: tcomponent): boolean;

procedure componentexception(const acomponent: tcomponent; const atext: msestring);

function getcomponentlist(const acomponent: tcomponent): tfplist;

procedure clearcomponentlist(const acomponent: tcomponent);

procedure clearpastedcomponents;

procedure addpastedcomponentname(const acomp: tcomponent);

function findpastedcomponent(const origname: string): tcomponent;

function findpastedcomponentname(const comp: tcomponent): string;

procedure copyvarrec(const source: tvarrec; const dest: pointer);

procedure matchparams(const aparam: array of const; const defaults: array of const; const dest: array of pointer);

Types

posteventoptionty = (...);

posteventoptionsty = set of posteventoptionty;

notifyeventty = procedure (const sender: tobject) of object;

componenteventty = procedure (const acomponent: tcomponent) of object;

checkeventty = function (const sender: tobject): boolean of object;

accepteventty = procedure (const sender: tobject; var accept: boolean) of object;

eventeventty = procedure (const sender: tobject; const aevent: tobjectevent) of object;

componenteventeventty = procedure (const sender: tobject; const aevent: tcomponentevent) of object;

asynceventeventty = procedure (const sender: tobject; var atag: integer) of object;

booleanchangedeventty = procedure (const sender: tobject; const avalue: boolean) of object;

stringchangedeventty = procedure (const sender: tobject; const avalue: msestring) of object;

integerchangedeventty = procedure (const sender: tobject; const avalue: integer) of object;

realchangedeventty = procedure (const sender: tobject; const avalue: realty) of object;

getintegereventty = function: integer of object;

getint64eventty = function: int64 of object;

getmsestringeventty = function: msestring of object;

getstringareventty = function: stringarty of object;

updatestringeventty = procedure(const sender: tobject; var avalue: msestring) of object;

updateansistringeventty = procedure(const sender: tobject; var avalue: ansistring) of object;

updateintegereventty = procedure(const sender: tobject; var avalue: integer) of object;

updateint64eventty = procedure(const sender: tobject; var avalue: int64) of object;

updatepointereventty = procedure(const sender: tobject; var avalue: pointer) of object;

updatebooleaneventty = procedure(const sender: tobject; var avalue: boolean) of object;

updaterealeventty = procedure(const sender: tobject; var avalue: real) of object;

updatedatetimeeventty = procedure(const sender: tobject; var avalue: tdatetime) of object;

setbooleaneventty = procedure(const sender: tobject; var avalue: boolean; var accept: boolean) of object;

setstringeventty = procedure(const sender: tobject; var avalue: msestring; var accept: boolean) of object;

setansistringeventty = procedure(const sender: tobject; var avalue: ansistring; var accept: boolean) of object;

setintegereventty = procedure(const sender: tobject; var avalue: integer; var accept: boolean) of object;

setint64eventty = procedure(const sender: tobject; var avalue: int64; var accept: boolean) of object;

setrealeventty = procedure(const sender: tobject; var avalue: realty; var accept: boolean) of object;

setdatetimeeventty = procedure(const sender: tobject; var avalue: tdatetime; var accept: boolean) of object;

setbooleanindexeventty = procedure(const sender: tobject; var avalue: boolean; var accept: boolean; const aindex: integer) of object;

setstringindexeventty = procedure(const sender: tobject; var avalue: msestring; var accept: boolean; const aindex: integer) of object;

setansistringindexeventty = procedure(const sender: tobject; var avalue: ansistring; var accept: boolean; const aindex: integer) of object;

setintegerindexeventty = procedure(const sender: tobject; var avalue: integer; var accept: boolean; const aindex: integer) of object;

setint64indexeventty = procedure(const sender: tobject; var avalue: int64; var accept: boolean; const aindex: integer) of object;

setrealindexeventty = procedure(const sender: tobject; var avalue: realty; var accept: boolean; const aindex: integer) of object;

setdatetimeindexeventty = procedure(const sender: tobject; var avalue: tdatetime; var accept: boolean; const aindex: integer) of object;

progresseventty = procedure(const sender: tobject; const avalue: real; var acancel: boolean) of object;

persistentarty = array of tpersistent;

persistentclassty = class of tpersistent;

componentarty = array of tcomponent;

componentaty = array[0..0] of tcomponent;

pcomponentaty = ˆcomponentaty;

componentclassty = class of tcomponent;

propinfopoarty = array of ppropinfo;

virtualpersistentclassty = class of tvirtualpersistent;

plinkinfoty = ˆlinkinfoty;

linkinfoaty = array[0..0] of linkinfoty;

plinkinfoaty = ˆlinkinfoaty;

plinkedobject = ˆtlinkedobject;

pmsecomponent = ˆtmsecomponent;

pobjectlinker = ˆtobjectlinker;

plinkedpersistent = ˆtlinkedpersistent;

objectlinkprocty = procedure(const info: linkinfoty) of object;

objectlinkintfprocty = procedure(const alink: pointer) of object;

objectlinkfirstprocty = procedure(const info: linkinfoty; var handled: boolean) of object;

objectlinkintffirstprocty = procedure(const alink: pointer; var handled: boolean) of object;

componenteventstatety = (...);

componenteventstatesty = set of componenteventstatety;

msecomponentstatety = (...);

msecomponentstatesty = set of msecomponentstatety;

createprocty = procedure of object;

skinoptionty = (...);

skinoptionsty = set of skinoptionty;

skinobjectkindty = (...);

msecomponenteventty = procedure(const sender: tmsecomponent) of object;

msecomponentclassty = class of tmsecomponent;

msecomponentarty = array of tmsecomponent;

pobjectdataty = ˆobjectdataty;

templateclassty = class of tpersistenttemplate;

getchildreneventty = procedure (const sender: tmsecomponent; const proc: tgetchildproc; const root: tcomponent) of object;

writerecordprocty = procedure(const writer: twriter; const data);

readrecordprocty = procedure(const reader: treader; var data);

skineventty = procedure(const ainfo: skininfoty) of object;

Constants

platformtext = 'i386-win32';

moduleclassnamename = 'moduleclassname';

compilerdefaults =
     '{$ifdef FPC}{$mode objfpc}{$h+}{$endif}';

Variables

oninitskinobject: skineventty;