Unit msegraphutils

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Overview

Classes, Interfaces, Objects and Records

Name	Description
Packed Record `rgbtriplety`
Record `colorinfoty`
Record `pointty`
Record `fpointty`
Record `dpointty`
Record `segmentty`
Record `graphicvectorty`
Record `sizety`
Record `rectty`
Record `framety`
Record `rectextty`
Class `egdi`
Record `rectaccessty`

Functions and Procedures

function rx(const arect: rectty): integer;

function ry(const arect: rectty): integer;

function rcx(const arect: rectty): integer;

function rcy(const arect: rectty): integer;

function rstopx(const arect: rectty): integer;

function rstopy(const arect: rectty): integer;

procedure rsetx(var arect: rectty; const avalue: integer);

procedure rsety(var arect: rectty; const avalue: integer);

procedure rsetcx(var arect: rectty; const avalue: integer);

procedure rsetcy(var arect: rectty; const avalue: integer);

procedure rsetstopx(var arect: rectty; const avalue: integer);

procedure rsetstopy(var arect: rectty; const avalue: integer);

function makesizex(const value,ovalue: integer): sizety;

function makesizey(const value,ovalue: integer): sizety;

function makeposx(const value,ovalue: integer): pointty;

function makeposy(const value,ovalue: integer): pointty;

function px(const apoint: pointty): integer;

function py(const apoint: pointty): integer;

function sx(const asize: sizety): integer;

function sy(const asize: sizety): integer;

procedure psetx(var apoint: pointty; const avalue: integer);

procedure psety(var apoint: pointty; const avalue: integer);

procedure ssetx(var asize: sizety; const avalue: integer);

procedure ssety(var asize: sizety; const avalue: integer);

procedure gdierror(error: gdierrorty; const text: msestring = ''); overload;

procedure gdierror(error: gdierrorty; sender: tobject; text: msestring = ''); overload;

function stringtocolor(const text: string): colorty;

function trystringtocolor(text: string; out value: colorty): boolean;

function colortostring(value: colorty): string;

function getcolornames: msestringarty;

function getcolorvalues: colorarty;

function makepoint(const x,y: integer): pointty;

function makesize(const cx,cy: integer): sizety;

function makerect(const x,y,cx,cy: integer): rectty; overload;

function makerect(const pos: pointty; const size: sizety): rectty; overload;

function makesegment(const a,b: pointty): segmentty;

function makeframe(const left,top,right,bottom: integer): framety;

function mp(const x,y: integer): pointty;

function ms(const cx,cy: integer): sizety;

function mr(const x,y,cx,cy: integer): rectty; overload;

function mr(const pos: pointty; const size: sizety): rectty; overload;

function mg(const a,b: pointty): segmentty;

function mf(const left,top,right,bottom: integer): framety;

function bottomright(const rect: rectty): pointty;

function isnullpoint(const point: pointty): boolean;

function isnullsize(const size: sizety): boolean;

function isnullrect(const rect: rectty): boolean;

function isnullframe(const frame: framety): boolean;

function pointisequal(const a,b: pointty): boolean;

function sizeisequal(const a,b: sizety): boolean;

function rectisequal(const a,b: rectty): boolean;

function frameisequal(const a,b: framety): boolean;

function addpoint(const a,b: pointty): pointty;

procedure addpoint1(var dest: pointty; const point: pointty);

function subpoint(const a,b: pointty): pointty;

procedure subpoint1(var dest: pointty; const point: pointty);

function distance(const a,b: pointty): integer;

function addsize(const a,b: sizety): sizety;

procedure addsize1(var dest: sizety; const size: sizety);

function subsize(const a,b: sizety): sizety;

procedure subsize1(var dest: sizety; const size: sizety);

function fitsize(const asize: sizety; const maxsize: sizety): sizety;

function rectcenter(const arect: rectty): pointty;

procedure centerrect(apos: pointty; asize: integer; out rect: rectty);

function excenterrect(const arect: rectty): rectty;

function recenterrect(const arect: rectty): rectty;

function inflaterect(const rect: rectty; value: integer): rectty;

function inflaterect(const rect: rectty; const value: int32; const disablededges: edgesty): rectty;

function inflaterect(const rect: rectty; const frame: framety): rectty;

procedure inflaterect1(var rect: rectty; value: integer);

procedure inflaterect1(var rect: rectty; const value: int32; const disablededges: edgesty);

procedure inflaterect1(var rect: rectty; const frame: framety);

function deflaterect(const rect: rectty; const frame: framety): rectty;

procedure deflaterect1(var rect: rectty; const frame: framety);

procedure normalizerect1(var arect: rectty);

function normalizerect(const arect: rectty): rectty;

procedure swapxy1(var arect: rectty);

function addframe(const a,b: framety): framety;

procedure addframe1(var dest: framety; const frame: framety);

function subframe(const a,b: framety): framety;

procedure subframe1(var dest: framety; const frame: framety);

function expandrectext(const a,b: rectextty): rectextty;

procedure expandrectext1(var dest: rectextty; const frame: rectextty);

procedure inflaterectext1(var ext: rectextty; const frame: framety);

function inflaterectext(const ext: rectextty; const frame: framety): rectextty;

procedure deflaterectext1(var ext: rectextty; const frame: framety);

function deflaterectext(const ext: rectextty; const frame: framety): rectextty;

procedure inflateframe1(var frame: framety; value: integer);

function inflateframe(const frame: framety; value: integer): framety;

function moverect(const rect: rectty; const dist: pointty): rectty;

procedure moverect1(var rect: rectty; const dist: pointty);

function removerect(const rect: rectty; const dist: pointty): rectty;

procedure removerect1(var rect: rectty; const dist: pointty);

procedure shiftinrect(var rect: rectty; const outerrect: rectty);

procedure centerinrect(var rect: rectty; const outerrect: rectty);

function changerectdirection(const arect: rectty; const olddirction,newdirection: graphicdirectionty): rectty;

function rotateframe(const aframe: framety; const olddirection, newdirection: graphicdirectionty): framety;

procedure rotateframe1(var aframe: framety; const olddirection, newdirection: graphicdirectionty);

function intersectrect(const a,b: rectty; out dest: rectty): boolean; overload;

function intersectrect(const a,b: rectty): rectty; overload;

procedure intersectrect1(var dest: rectty; const source: rectty);

function testintersectrect(const a,b: rectty): boolean;

function combinerect(const a,b: rectty): rectty;

procedure combinerect1(var a: rectty; const b: rectty);

function clipinrect(const point: pointty; const boundsrect: rectty): pointty; overload;

function clipinrect(const rect: rectty; const boundsrect: rectty): rectty; overload;

function clipinrect1(var point: pointty; const boundsrect: rectty): boolean; overload;

function clipinrect1(var rect: rectty; const boundsrect: rectty): boolean; overload;

function calcrectalignment(const dest: rectty; source: rectty; const alignment: alignmentsty): rectty;

function pointinrect(const point: pointty; const rect: rectty): boolean;

function pointinellipse(const point: pointty; const rect: rectty): boolean;

function rectinrect(const inner,outer: rectty): boolean;

function segment(const a,b: pointty): segmentty;

procedure vectortoline(const vector: graphicvectorty; out a,b: pointty);

function rotatedirection(const olddest,newvalue, oldvalue: graphicdirectionty): graphicdirectionty;

procedure removeduplicatedpoints(var vect: pointarty);

function hsbtorgb(hue,sat,bri: word): colorty;

Types

imagenrty = type integer;

facenrty = type integer;

pixelty = longword;

pixelaty = array[0..0] of pixelty;

ppixelaty = ˆpixelaty;

colorty = type longword;

pcolorty = ˆcolorty;

colorarty = array of colorty;

prgbtriplety = ˆrgbtriplety;

rgbtriplearty = array of rgbtriplety;

rgbtripleaty = array[0..0] of rgbtriplety;

prgbtripleaty = ˆrgbtripleaty;

colormapsty = (...);

colormapty = array[colormapsty] of longwordarty;

pcolorinfoty = ˆcolorinfoty;

colorinfoarty = array of colorinfoty;

graphicdirectionty = (...);

pgraphicdirectionty = ˆgraphicdirectionty;

graphicdirectionsty = set of graphicdirectionty;

pgraphicdirectionsty = ˆgraphicdirectionsty;

alignmentty = (...);

alignmentsty = set of alignmentty;

edgety = (...);

edgesty = set of edgety;

fontstylety = (...);

fontstylesty = set of fontstylety;

ppointty = ˆpointty;

pointarty = array of pointty;

ppointarty = ˆpointarty;

pointararty = array of pointarty;

pointaty = array[0..0] of pointty;

ppointaty = ˆpointaty;

pointpoarty = array of ppointty;

pppointty = ˆppointty;

pfpointty = ˆfpointty;

fpointarty = array of fpointty;

pfpointarty = ˆfpointarty;

fpointaty = array[0..0] of fpointty;

pfpointaty = ˆfpointaty;

pdpointty = ˆdpointty;

dpointarty = array of dpointty;

pdpointarty = ˆdpointarty;

dpointaty = array[0..0] of dpointty;

pdpointaty = ˆdpointaty;

psegmentty = ˆsegmentty;

segmentarty = array of segmentty;

pframety = ˆframety;

prectty = ˆrectty;

rectarty = array of rectty;

prectarty = ˆrectarty;

prectextty = ˆrectextty;

gdierrorty = (...);

getrectintegerty = function(const arect: rectty): integer;

setrectintegerty = procedure(var arect: rectty; const avalue: integer);

getintpointty = function(const value,ovalue: integer): pointty;

getintsizety = function(const value,ovalue: integer): sizety;

getpointintty = function(const apoint: pointty): integer;

getsizeintty = function(const asize: sizety): integer;

setpointintty = procedure(var apoint: pointty; const avalue: integer);

setsizeintty = procedure(var asize: sizety; const avalue: integer);

prectaccessty = ˆrectaccessty;

Constants

redmask = $ff0000;

redshift = 16;

greenmask = $00ff00;

greenshift = 8;

bluemask = $0000ff;

blueshift = 0;

maxopacity = $00ffffff;

speccolormask = $f0000000;

speccolorshift = 28;

cl_functional = colorty($80000000);

cl_mapped = colorty($90000000);

cl_namedrgb = colorty($a0000000);

cl_user = colorty($b0000000);

cl_invalid = cl_functional + 0;

cl_default = cl_functional + 1;

cl_parent = cl_functional + 2;

cl_transparent = cl_functional + 3;

cl_brush = cl_functional + 4;

cl_brushcanvas = cl_functional + 5;

cl_none = cl_functional + 6;

cl_nonenum = 6;

cl_font = cl_functional + 7;

cl_normal = cl_functional + 8;

cl_lastfunctional = cl_functional + 9;

cl_dkshadow = cl_mapped + 0;

cl_shadow = cl_mapped + 1;

cl_mid = cl_mapped + 2;

cl_light = cl_mapped + 3;

cl_highlight = cl_mapped + 4;

cl_background = cl_mapped + 5;

cl_foreground = cl_mapped + 6;

cl_active = cl_mapped + 7;

cl_noedit = cl_mapped + 8;

cl_text = cl_mapped + 9;

cl_selectedtext = cl_mapped + 10;

cl_selectedtextbackground = cl_mapped + 11;

cl_infobackground = cl_mapped + 12;

cl_glyph = cl_mapped + 13;

cl_activegrip = cl_mapped + 14;

cl_empty = cl_mapped + 15;

cl_emptytext = cl_mapped + 16;

cl_emptytextbackground = cl_mapped + 17;

cl_zebra = cl_mapped + 18;

cl_grayed = cl_mapped + 19;

cl_grayedshadow = cl_mapped + 20;

cl_gridactive = cl_mapped + 21;

cl_gridfocus = cl_mapped + 22;

cl_gridselect = cl_mapped + 23;

cl_gridline = cl_mapped + 24;

cl_gridlinefix = cl_mapped + 25;

cl_gridframe = cl_mapped + 26;

cl_scrollbarpattern = cl_mapped + 27;

cl_scrollbarpatternclicked = cl_mapped + 28;

cl_buttondefaultrect = cl_mapped + 29;

cl_glyphactive = cl_mapped + 30;

cl_treeline = cl_mapped + 31;

cl_treelineactive = cl_mapped + 32;

cl_lastmapped = cl_mapped + 33;

cl_0 = cl_namedrgb + 0;

cl_1 = cl_namedrgb + 1;

cl_black = cl_namedrgb + 2;

cl_dkgray = cl_namedrgb + 3;

cl_gray = cl_namedrgb + 4;

cl_ltgray = cl_namedrgb + 5;

cl_white = cl_namedrgb + 6;

cl_red = cl_namedrgb + 7;

cl_green = cl_namedrgb + 8;

cl_blue = cl_namedrgb + 9;

cl_cyan = cl_namedrgb + 10;

cl_magenta = cl_namedrgb + 11;

cl_yellow = cl_namedrgb + 12;

cl_dkred = cl_namedrgb + 13;

cl_dkgreen = cl_namedrgb + 14;

cl_dkblue = cl_namedrgb + 15;

cl_dkcyan = cl_namedrgb + 16;

cl_dkmagenta = cl_namedrgb + 17;

cl_dkyellow = cl_namedrgb + 18;

cl_ltred = cl_namedrgb + 19;

cl_ltgreen = cl_namedrgb + 20;

cl_ltblue = cl_namedrgb + 21;

cl_ltcyan = cl_namedrgb + 22;

cl_ltmagenta = cl_namedrgb + 23;

cl_ltyellow = cl_namedrgb + 24;

cl_lastnamedrgb = cl_namedrgb + 25;

cl_user0 = cl_user + 0;

cl_user1 = cl_user + 1;

cl_user2 = cl_user + 2;

cl_user3 = cl_user + 3;

cl_user4 = cl_user + 4;

cl_user5 = cl_user + 5;

cl_user6 = cl_user + 6;

cl_user7 = cl_user + 7;

cl_user8 = cl_user + 8;

cl_user9 = cl_user + 9;

cl_user10 = cl_user + 10;

cl_user11 = cl_user + 11;

cl_user12 = cl_user + 12;

cl_user13 = cl_user + 13;

cl_user14 = cl_user + 14;

cl_user15 = cl_user + 15;

cl_user16 = cl_user + 16;

cl_user17 = cl_user + 17;

cl_user18 = cl_user + 18;

cl_user19 = cl_user + 19;

cl_fade0 = cl_user + 20;

cl_fade1 = cl_user + 21;

cl_fade2 = cl_user + 22;

cl_fade3 = cl_user + 23;

cl_fade4 = cl_user + 24;

cl_fade5 = cl_user + 25;

cl_fade6 = cl_user + 26;

cl_fade7 = cl_user + 27;

cl_fade8 = cl_user + 28;

cl_fade9 = cl_user + 29;

cl_lastuser = cl_user + 30;

functionalcolorcount = integer(cl_lastfunctional)-integer(cl_functional);

mappedcolorcount = integer(cl_lastmapped)-integer(cl_mapped);

namedrgbcolorcount = integer(cl_lastnamedrgb)-integer(cl_namedrgb);

usercolorcount = integer(cl_lastuser)-integer(cl_user);

mapcolorcounts: array[colormapsty] of integer = (
              0,
              functionalcolorcount,
              mappedcolorcount,
              namedrgbcolorcount,
              usercolorcount
            );

defaultfunctional: array[0..functionalcolorcount-1]
                     of colorinfoty =
   (
    (name: 'cl_invalid';  rgb:               (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_default'; rgb:                (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_parent';  rgb:                (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_transparent'; rgb:            (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_brush';  rgb:                 (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_brushcanvas'; rgb:            (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_none';  rgb:                  (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_font';  rgb:                  (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_normal';  rgb:                (blue: $ff; green: $ff; red: $ff; res: $00))  


   );

defaultmapped: array[0..mappedcolorcount-1]
                     of colorinfoty =
   (
    (name: 'cl_dkshadow'; rgb:               (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_shadow'; rgb:                 (blue: $80; green: $80; red: $80; res: $00)), 
    (name: 'cl_mid'; rgb:                    (blue: $c0; green: $c0; red: $c0; res: $00)), 
    (name: 'cl_light'; rgb:                  (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_highlight'; rgb:              (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_background';  rgb:            (blue: $d0; green: $d0; red: $d0; res: $00)), 
    (name: 'cl_foreground';  rgb:            (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_active';  rgb:                (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_noedit';  rgb:                (blue: $e0; green: $e0; red: $e0; res: $00)), 
                                
    (name: 'cl_text';  rgb:                  (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_selectedtext'; rgb:           (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_selectedtextbackground'; rgb: (blue: $c0; green: $00; red: $00; res: $00)), 
    (name: 'cl_infobackground'; rgb:         (blue: $e0; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_glyph'; rgb:                  (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_activegrip'; rgb:             (blue: $90; green: $20; red: $20; res: $00)), 
    (name: 'cl_empty';  rgb:                 (blue: $a0; green: $a0; red: $ff; res: $00)), 
    (name: 'cl_emptytext';  rgb:             (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_emptytextbackground';  rgb:   (blue: $00; green: $00; red: $ff; res: $00)), 
    (name: 'cl_zebra';  rgb:                 (blue: $ff; green: $ff; red: $e0; res: $00)), 
    (name: 'cl_grayed'; rgb:                 (blue: $80; green: $80; red: $80; res: $00)), 
    (name: 'cl_grayedshadow'; rgb:           (blue: $ff; green: $ff; red: $ff; res: $00)), 

    (name: 'cl_gridactive';  rgb:            (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_gridfocus';  rgb:             (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_gridselect';  rgb:            (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_gridline';  rgb:              (blue: $80; green: $80; red: $80; res: $00)), 
    (name: 'cl_gridlinefix'; rgb:            (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_gridframe'; rgb:              (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_scrollbarpattern'; rgb:       (blue: $ff; green: $ff; red: $ff; res: $00)), 
    (name: 'cl_scrollbarpatternclicked'; rgb:(blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_buttondefaultrect'; rgb:      (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_glyphactive'; rgb:            (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_treeline'; rgb:               (blue: $80; green: $80; red: $80; res: $00)), 
    (name: 'cl_treelineactive'; rgb:         (blue: $80; green: $80; red: $80; res: $00))  
   );

defaultnamedrgb: array[0..namedrgbcolorcount-1]
                     of colorinfoty =
   (
    (name: 'cl_0';  rgb:                     (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_1';  rgb:                     (blue: $ff; green: $ff; red: $ff; res: $00)), 

    (name: 'cl_black'; rgb:                  (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_dkgray';  rgb:                (blue: $80; green: $80; red: $80; res: $00)), 
    (name: 'cl_gray';  rgb:                  (blue: $c0; green: $c0; red: $c0; res: $00)), 
    (name: 'cl_ltgray';  rgb:                (blue: $e0; green: $e0; red: $e0; res: $00)), 
    (name: 'cl_white';  rgb:                 (blue: $ff; green: $ff; red: $ff; res: $00)), 

    (name: 'cl_red';   rgb:                  (blue: $00; green: $00; red: $ff; res: $00)), 
    (name: 'cl_green'; rgb:                  (blue: $00; green: $ff; red: $00; res: $00)), 
    (name: 'cl_blue';  rgb:                  (blue: $ff; green: $00; red: $00; res: $00)), 
    (name: 'cl_cyan';  rgb:                  (blue: $ff; green: $ff; red: $00; res: $00)), 
    (name: 'cl_magenta';  rgb:               (blue: $ff; green: $00; red: $ff; res: $00)), 
    (name: 'cl_yellow';  rgb:                (blue: $00; green: $ff; red: $ff; res: $00)), 

    (name: 'cl_dkred';   rgb:                (blue: $00; green: $00; red: $c0; res: $00)), 
    (name: 'cl_dkgreen'; rgb:                (blue: $00; green: $c0; red: $00; res: $00)), 
    (name: 'cl_dkblue';  rgb:                (blue: $c0; green: $00; red: $00; res: $00)), 
    (name: 'cl_dkcyan';  rgb:                (blue: $80; green: $80; red: $00; res: $00)), 
    (name: 'cl_dkmagenta';  rgb:             (blue: $80; green: $00; red: $80; res: $00)), 
    (name: 'cl_dkyellow';  rgb:              (blue: $00; green: $80; red: $80; res: $00)), 

    (name: 'cl_ltred';   rgb:                (blue: $a0; green: $a0; red: $ff; res: $00)), 
    (name: 'cl_ltgreen'; rgb:                (blue: $a0; green: $ff; red: $a0; res: $00)), 
    (name: 'cl_ltblue';  rgb:                (blue: $ff; green: $a0; red: $a0; res: $00)), 
    (name: 'cl_ltcyan';  rgb:                (blue: $ff; green: $ff; red: $a0; res: $00)), 
    (name: 'cl_ltmagenta';  rgb:             (blue: $ff; green: $a0; red: $ff; res: $00)), 
    (name: 'cl_ltyellow';  rgb:              (blue: $a0; green: $ff; red: $ff; res: $00))  
   );

defaultuser: array[0..usercolorcount-1]
                     of colorinfoty =
   (
    (name: 'cl_user0';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user1';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user2';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user3';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user4';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user5';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user6';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user7';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user8';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user9';  rgb:                 (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user10';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user11';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user12';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user13';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user14';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user15';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user16';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user17';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user18';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_user19';  rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade0';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade1';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade2';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade3';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade4';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade5';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade6';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade7';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade8';   rgb:                (blue: $00; green: $00; red: $00; res: $00)), 
    (name: 'cl_fade9';   rgb:                (blue: $00; green: $00; red: $00; res: $00))  
   );

nullpoint: pointty = (x: 0; y: 0);

nullsize: sizety = (cx: 0; cy: 0);

nullrect: rectty = (x: 0; y: 0; cx: 0; cy: 0);

nullframe: framety = (left: 0; top: 0; right: 0; bottom: 0);

emptyrectext: rectextty = (left: maxint; top: maxint; right: minint;
                                                       bottom: minint);

minimalframe: framety = (left: 1; top: 1; right: 1; bottom: 1);

minimaltextframe: framety = (left: 1; top: 0; right: 1; bottom: 0);

rectaccessx: rectaccessty =  (
   pos: rx;
   size: rcx;
   stop: rstopx;
   opos: ry;
   osize: rcy;
   ostop: rstopy;
   setpos: rsetx;
   setsize: rsetcx;
   setstop: rsetstopx;
   setopos: rsety;
   setosize: rsetcy;
   setostop: rsetstopy;
   makepos: makeposx;
   makeopos: makeposy;
   makesize: makesizex;
   makeosize: makesizey;
   pt: px;
   opt: py;
   si: sx;
   osi: sy;
   setpt: psetx;
   setopt: psety;
   setsi: ssetx;
   setosi: ssety;
 );

rectaccessy: rectaccessty =  (
   pos: ry;
   size: rcy;
   stop: rstopy;
   opos: rx;
   osize: rcx;
   ostop: rstopy;
   setpos: rsety;
   setsize: rsetcy;
   setstop: rsetstopy;
   setopos: rsetx;
   setosize: rsetcx;
   setostop: rsetstopx;
   makepos: makeposy;
   makeopos: makeposx;
   makesize: makesizey;
   makeosize: makesizex;
   pt: py;
   opt: px;
   si: sy;
   osi: sx;
   setpt: psety;
   setopt: psetx;
   setsi: ssety;
   setosi: ssetx;
 );