MODULE DTPData;
IMPORT
Files, XML, WMGraphics, Strings, WMWindowManager;
CONST
TYPE
MetaInformation* = OBJECT
VAR
author*, documentName*, documentTitle* : Strings.String;
END MetaInformation;
StyleObject* = OBJECT
VAR name*: ARRAY 64 OF CHAR;
END StyleObject;
ParagraphStyleObject* = OBJECT(StyleObject)
VAR alignment* : LONGINT;
spaceBefore* : REAL;
spaceAfter* : REAL;
leftIndent* : REAL;
rightIndent* : REAL;
firstIndent* : REAL;
charStyle* : CharacterStyleObject;
PROCEDURE Clone*(): ParagraphStyleObject;
VAR newPSO: ParagraphStyleObject;
BEGIN
NEW(newPSO);
newPSO.name := name;
newPSO.alignment := alignment;
newPSO.spaceBefore := spaceBefore;
newPSO.spaceAfter := spaceAfter;
newPSO.firstIndent := firstIndent;
newPSO.leftIndent := leftIndent;
newPSO.rightIndent := rightIndent;
newPSO.charStyle := charStyle;
RETURN newPSO;
END Clone;
END ParagraphStyleObject;
CharacterStyleObject* = OBJECT(StyleObject)
VAR family* : ARRAY 32 OF CHAR;
style* : SET;
size* : REAL;
leading* : REAL;
baselineShift* : REAL;
tracking* : REAL;
kerning* : REAL;
scaleHorizontal* : REAL;
scaleVertical* : REAL;
color* : LONGINT;
bgColor* : LONGINT;
PROCEDURE Clone*(): CharacterStyleObject;
VAR newCSO: CharacterStyleObject;
BEGIN
NEW(newCSO);
newCSO.name := name;
newCSO.family := family;
newCSO.style := style;
newCSO.size := size;
newCSO.leading := leading;
newCSO.baselineShift := baselineShift;
newCSO.color := color;
newCSO.bgColor := bgColor;
newCSO.tracking := tracking;
newCSO.kerning := kerning;
newCSO.scaleHorizontal := scaleHorizontal;
newCSO.scaleVertical := scaleVertical;
RETURN newCSO;
END Clone;
END CharacterStyleObject;
GraphicStyleObject* = OBJECT(StyleObject)
VAR
END GraphicStyleObject;
CustomStyleObject* = OBJECT(StyleObject)
VAR
END CustomStyleObject;
PStyles* = POINTER TO ARRAY OF ParagraphStyleObject;
CStyles* = POINTER TO ARRAY OF CharacterStyleObject;
GStyles* = POINTER TO ARRAY OF GraphicStyleObject;
CustomStyles* = POINTER TO ARRAY OF CustomStyleObject;
Document* = OBJECT
VAR
pageWidth, pageHeight : REAL;
marginTop, marginBottom, marginLeft, marginRight : REAL;
facingPages : BOOLEAN;
meta : MetaInformation;
objectCounter*: LONGINT;
copyCounter*: LONGINT;
nofPStyles*: LONGINT;
pStyles* : PStyles;
nofCStyles*: LONGINT;
cStyles* : CStyles;
nofGStyles*: LONGINT;
gStyles* : GStyles;
nofCustomStyles*: LONGINT;
customStyles* : CustomStyles;
defaultParagraphStyle* : ParagraphStyleObject;
defaultCharacterStyle* : CharacterStyleObject;
defaultGraphicStyle* : GraphicStyleObject;
defaultCustomStyle* : CustomStyleObject;
pages* : ContentPages;
mpages* : MasterPages;
contents* : Contents; nofContents* : LONGINT;
frames* : Frames;
dollyGuide* : GuideObject;
currentPage*, firstPage*, lastPage* : PageObject;
pageNumber*, nofPages* : LONGINT;
currentMPage*, firstMPage*, lastMPage* : MasterPageObject;
mpageNumber*, nofMPages* : LONGINT;
PROCEDURE &New*(width, height, margintop,marginbottom, marginleft, marginright : REAL; facingpages : BOOLEAN);
VAR
BEGIN
pageWidth := width;
pageHeight := height;
marginTop := margintop;
marginBottom := marginbottom;
marginLeft := marginleft;
marginRight := marginright;
facingPages := facingpages;
currentPage := NIL;
firstPage := NIL;
lastPage := NIL;
pageNumber := 0;
nofPages := 0;
currentMPage := NIL;
firstMPage := NIL;
lastMPage := NIL;
mpageNumber := 0;
nofMPages := 0;
dollyGuide := NIL;
objectCounter := 0; copyCounter := 0;
NEW(pStyles, 4); nofPStyles := 0;
NEW(cStyles, 4); nofCStyles := 0;
NEW(gStyles, 4); nofGStyles := 0;
NEW(customStyles, 4); nofCustomStyles := 0;
AddDefaultStyles;
NEW(contents, 4); nofContents := 0;
END New;
PROCEDURE AddDefaultStyles;
VAR newPStyle: ParagraphStyleObject;
newCStyle: CharacterStyleObject;
BEGIN
NEW(newCStyle);
newCStyle.name := "defaultCharacterStyle";
newCStyle.family := "Oberon";
newCStyle.style := {};
newCStyle.size := 16;
newCStyle.leading := 19;
newCStyle.baselineShift := 0;
newCStyle.tracking := 0;
newCStyle.kerning := 0;
newCStyle.scaleHorizontal := 100;
newCStyle.scaleVertical := 100;
newCStyle.color := 0000000FFH;
newCStyle.bgColor := LONGINT(0FFFFFF00H);
NEW(newPStyle);
newPStyle.name := "defaultParagraphStyle";
newPStyle.alignment := 0;
newPStyle.spaceBefore := 0;
newPStyle.spaceAfter := 0;
newPStyle.leftIndent := 0;
newPStyle.rightIndent := 0;
newPStyle.firstIndent := 0;
newPStyle.charStyle := newCStyle;
defaultCharacterStyle := newCStyle;
defaultParagraphStyle := newPStyle;
AddStyle(newCStyle);
AddStyle(newPStyle);
END AddDefaultStyles;
PROCEDURE AddStyle*(style: StyleObject);
VAR newPStyles: PStyles;
newCStyles: CStyles;
newGStyles: GStyles;
newCustomStyles: CustomStyles;
pStyle: ParagraphStyleObject;
cStyle: CharacterStyleObject;
i : LONGINT;
BEGIN
IF (style IS ParagraphStyleObject) THEN
pStyle := GetParagraphStyleByName(style.name);
IF (pStyle = NIL) THEN
INC(nofPStyles);
IF nofPStyles > LEN(pStyles) THEN
NEW(newPStyles, LEN(pStyles) * 2);
FOR i := 0 TO LEN(pStyles)-1 DO newPStyles[i] := pStyles[i]; END;
pStyles := newPStyles;
END;
pStyles[nofPStyles-1] := style(ParagraphStyleObject);
ELSE
pStyle.alignment := style(ParagraphStyleObject).alignment;
pStyle.firstIndent := style(ParagraphStyleObject).firstIndent;
pStyle.leftIndent := style(ParagraphStyleObject).leftIndent;
pStyle.rightIndent := style(ParagraphStyleObject).rightIndent;
pStyle.spaceBefore := style(ParagraphStyleObject).spaceBefore;
pStyle.spaceAfter := style(ParagraphStyleObject).spaceAfter;
pStyle.charStyle := style(ParagraphStyleObject).charStyle;
END;
ELSIF (style IS CharacterStyleObject) THEN
cStyle := GetCharacterStyleByName(style.name);
IF (cStyle = NIL) THEN
INC(nofCStyles);
IF nofCStyles > LEN(cStyles) THEN
NEW(newCStyles, LEN(cStyles) * 2);
FOR i := 0 TO LEN(cStyles)-1 DO newCStyles[i] := cStyles[i]; END;
cStyles := newCStyles;
END;
cStyles[nofCStyles-1] := style(CharacterStyleObject);
ELSE
COPY(style(CharacterStyleObject).family, cStyle.family);
cStyle.size := style(CharacterStyleObject).size;
cStyle.style := style(CharacterStyleObject).style;
cStyle.leading := style(CharacterStyleObject).leading;
cStyle.baselineShift := style(CharacterStyleObject).baselineShift;
cStyle.color := style(CharacterStyleObject).color;
cStyle.bgColor := style(CharacterStyleObject).bgColor;
cStyle.tracking := style(CharacterStyleObject).tracking;
cStyle.kerning := style(CharacterStyleObject).kerning;
cStyle.scaleHorizontal := style(CharacterStyleObject).scaleHorizontal;
cStyle.scaleVertical := style(CharacterStyleObject).scaleVertical;
END;
ELSIF (style IS GraphicStyleObject) THEN
INC(nofGStyles);
IF nofGStyles > LEN(gStyles) THEN
NEW(newGStyles, LEN(gStyles) * 2);
FOR i := 0 TO LEN(gStyles)-1 DO newGStyles[i] := gStyles[i]; END;
gStyles := newGStyles;
END;
gStyles[nofGStyles-1] := style(GraphicStyleObject);
ELSIF (style IS CustomStyleObject) THEN
INC(nofCustomStyles);
IF nofCustomStyles > LEN(customStyles) THEN
NEW(newCustomStyles, LEN(customStyles) * 2);
FOR i := 0 TO LEN(customStyles)-1 DO newCustomStyles[i] := customStyles[i]; END;
customStyles := newCustomStyles;
END;
customStyles[nofCustomStyles-1] := style(CustomStyleObject);
ELSE
END;
END AddStyle;
PROCEDURE RemoveStyle*(style: StyleObject);
VAR i : LONGINT;
BEGIN
IF (style IS ParagraphStyleObject) THEN
IF (style(ParagraphStyleObject).name # "defaultParagraphStyle") THEN
i := 0; WHILE (i < nofPStyles) & (pStyles[i] # style(ParagraphStyleObject)) DO INC(i) END;
IF i < nofPStyles THEN
WHILE (i < nofPStyles-1) DO pStyles[i] := pStyles[i+1]; INC(i); END;
DEC(nofPStyles);
pStyles[nofPStyles] := NIL;
END;
END;
ELSIF (style IS CharacterStyleObject) THEN
IF (style(CharacterStyleObject).name # "defaultCharacterStyle") THEN
i := 0; WHILE (i < nofCStyles) & (cStyles[i] # style(CharacterStyleObject)) DO INC(i) END;
IF i < nofCStyles THEN
WHILE (i < nofCStyles-1) DO cStyles[i] := cStyles[i+1]; INC(i); END;
DEC(nofCStyles);
cStyles[nofCStyles] := NIL;
END;
END;
ELSIF (style IS GraphicStyleObject) THEN
IF (style(GraphicStyleObject) # defaultGraphicStyle) THEN
i := 0; WHILE (i < nofGStyles) & (gStyles[i] # style(GraphicStyleObject)) DO INC(i) END;
IF i < nofGStyles THEN
WHILE (i < nofGStyles-1) DO gStyles[i] := gStyles[i+1]; INC(i); END;
DEC(nofGStyles);
gStyles[nofGStyles] := NIL;
END;
END;
ELSIF (style IS CustomStyleObject) THEN
IF (style(CustomStyleObject) # defaultCustomStyle) THEN
i := 0; WHILE (i < nofCustomStyles) & (customStyles[i] # style(CustomStyleObject)) DO INC(i) END;
IF i < nofCustomStyles THEN
WHILE (i < nofCustomStyles-1) DO customStyles[i] := customStyles[i+1]; INC(i); END;
DEC(nofCustomStyles);
customStyles[nofCustomStyles] := NIL;
END;
END;
ELSE
END;
END RemoveStyle;
PROCEDURE GetCharacterStyleByName*(name: ARRAY OF CHAR): CharacterStyleObject;
VAR styleObject: CharacterStyleObject;
i : LONGINT;
found : BOOLEAN;
match: Strings.String;
BEGIN
styleObject := NIL;
i := 0; found := FALSE;
WHILE ((i < nofCStyles) & ~found) DO
match := Strings.NewString(cStyles[i].name);
IF Strings.Match(match^, name) THEN
styleObject := cStyles[i]; found := TRUE;
END;
INC(i);
END;
RETURN styleObject;
END GetCharacterStyleByName;
PROCEDURE GetParagraphStyleByName*(name: ARRAY OF CHAR): ParagraphStyleObject;
VAR styleObject: ParagraphStyleObject;
i : LONGINT;
found : BOOLEAN;
match: Strings.String;
BEGIN
styleObject := NIL;
i := 0; found := FALSE;
WHILE ((i < nofPStyles) & ~found) DO
match := Strings.NewString(pStyles[i].name);
IF Strings.Match(match^, name) THEN
styleObject := pStyles[i]; found := TRUE;
END;
INC(i);
END;
RETURN styleObject;
END GetParagraphStyleByName;
PROCEDURE AddContent*(content: ContentObject);
VAR newContents: Contents;
i : LONGINT;
BEGIN
INC(nofContents);
IF nofContents > LEN(contents) THEN
NEW(newContents, LEN(contents) * 2);
FOR i := 0 TO LEN(contents)-1 DO newContents[i] := contents[i]; END;
contents := newContents;
END;
contents[nofContents-1] := content;
END AddContent;
PROCEDURE RemoveContent*(content: ContentObject);
VAR i : LONGINT;
BEGIN
i := 0; WHILE (i < nofContents) & (contents[i] # content) DO INC(i) END;
IF i < nofContents THEN
WHILE (i < nofContents-1) DO contents[i] := contents[i+1]; INC(i); END;
DEC(nofContents);
contents[nofContents] := NIL;
END;
END RemoveContent;
PROCEDURE GetContentByName*(name: ARRAY OF CHAR): ContentObject;
VAR contentObject: ContentObject;
i : LONGINT;
found : BOOLEAN;
match: Strings.String;
BEGIN
contentObject := NIL;
i := 0; found := FALSE;
WHILE ((i < nofContents) & ~found) DO
match := contents[i].contentName;
IF Strings.Match(match^, name) THEN
contentObject := contents[i]; found := TRUE;
END;
INC(i);
END;
RETURN contentObject;
END GetContentByName;
PROCEDURE FixContents*;
VAR contentObject: ContentObject;
i : LONGINT;
BEGIN
i := 0;
WHILE (i < nofContents) DO
contentObject := contents[i];
contentObject.FixLinks;
INC(i);
END;
END FixContents;
PROCEDURE FixName*(name: ARRAY OF CHAR; VAR result: ARRAY OF CHAR);
VAR counterString : ARRAY 64 OF CHAR;
BEGIN
COPY(name, result);
Strings.Append(result, "c");
Strings.IntToStr(copyCounter, counterString);
Strings.Append(result, counterString);
INC(copyCounter);
WHILE (GetContentByName(result) # NIL) DO
Strings.IntToStr(copyCounter, counterString);
Strings.Append(result, counterString);
INC(copyCounter);
END;
END FixName;
PROCEDURE AddPage*(after : BOOLEAN);
VAR newpage : PageObject;
BEGIN
NEW(newpage);
IF lastPage = NIL THEN
firstPage := newpage;
lastPage := newpage;
INC(pageNumber);
ELSE
IF after THEN
newpage.next := currentPage.next;
currentPage.next := newpage;
newpage.prev := currentPage;
IF newpage.next = NIL THEN
lastPage := newpage;
ELSE
newpage.next.prev := newpage;
END;
INC(pageNumber);
ELSE
newpage.prev := currentPage.prev;
currentPage.prev := newpage;
newpage.next := currentPage;
IF newpage.prev = NIL THEN
firstPage := newpage;
ELSE
newpage.prev.next := newpage;
END;
END;
END;
currentPage := newpage;
INC(nofPages);
currentPage.SetOwner(SELF);
END AddPage;
PROCEDURE DeletePage*;
VAR
BEGIN
IF currentPage.prev # NIL THEN
IF currentPage.next # NIL THEN
currentPage.prev.next := currentPage.next;
currentPage.next.prev := currentPage.prev;
currentPage := currentPage.next;
IF currentPage.prev = NIL THEN firstPage := currentPage; END;
IF currentPage.next = NIL THEN lastPage := currentPage; END;
DEC(nofPages);
ELSE
currentPage.prev.next := currentPage.next;
currentPage := currentPage.prev;
IF currentPage.prev = NIL THEN firstPage := currentPage; END;
lastPage := currentPage;
DEC(nofPages); DEC(pageNumber);
END;
ELSE
IF currentPage.next # NIL THEN
currentPage.next.prev := currentPage.prev;
currentPage := currentPage.next;
firstPage := currentPage;
IF currentPage.next = NIL THEN lastPage := currentPage; END;
DEC(nofPages);
END;
END;
END DeletePage;
PROCEDURE NextPage*;
BEGIN
IF currentPage.next # NIL THEN
currentPage := currentPage.next;
INC(pageNumber);
END;
END NextPage;
PROCEDURE PrevPage*;
BEGIN
IF currentPage.prev # NIL THEN
currentPage := currentPage.prev;
DEC(pageNumber);
END;
END PrevPage;
PROCEDURE FirstPage*;
BEGIN
currentPage := firstPage;
pageNumber := 1;
END FirstPage;
PROCEDURE LastPage*;
BEGIN
currentPage := lastPage;
pageNumber := nofPages;
END LastPage;
PROCEDURE AddMasterPage*(after: BOOLEAN);
VAR newpage : MasterPageObject;
BEGIN
NEW(newpage);
IF lastMPage = NIL THEN
firstMPage := newpage;
lastMPage := newpage;
INC(mpageNumber);
ELSE
IF after THEN
newpage.next := currentMPage.next;
currentMPage.next := newpage;
newpage.prev := currentMPage;
IF newpage.next = NIL THEN
lastMPage := newpage;
ELSE
newpage.next.prev := newpage;
END;
INC(mpageNumber);
ELSE
newpage.prev := currentMPage.prev;
currentMPage.prev := newpage;
newpage.next := currentMPage;
IF newpage.prev = NIL THEN
firstMPage := newpage;
ELSE
newpage.prev.next := newpage;
END;
END;
END;
currentMPage := newpage;
INC(nofMPages);
currentMPage.SetOwner(SELF);
END AddMasterPage;
PROCEDURE DeleteMasterPage*;
BEGIN
IF currentMPage.prev # NIL THEN
IF currentMPage.next # NIL THEN
currentMPage.prev.next := currentMPage.next;
currentMPage.next.prev := currentMPage.prev;
currentMPage := currentMPage.next;
IF currentMPage.prev = NIL THEN firstMPage := currentMPage; END;
IF currentMPage.next = NIL THEN lastMPage := currentMPage; END;
DEC(nofMPages);
ELSE
currentMPage.prev.next := currentMPage.next;
currentMPage := currentMPage.prev;
IF currentMPage.prev = NIL THEN firstMPage := currentMPage; END;
lastMPage := currentMPage;
DEC(nofMPages); DEC(mpageNumber);
END;
ELSE
IF currentMPage.next # NIL THEN
currentMPage.next.prev := currentMPage.prev;
currentMPage := currentMPage.next;
firstMPage := currentMPage;
IF currentMPage.next = NIL THEN lastMPage := currentMPage; END;
DEC(nofMPages);
END;
END;
END DeleteMasterPage;
PROCEDURE NextMasterPage*;
BEGIN
IF currentMPage.next # NIL THEN
currentMPage := currentMPage.next;
INC(mpageNumber);
END;
END NextMasterPage;
PROCEDURE PrevMasterPage*;
BEGIN
IF currentMPage.prev # NIL THEN
currentMPage := currentMPage.prev;
DEC(mpageNumber);
END;
END PrevMasterPage;
PROCEDURE FirstMasterPage*;
BEGIN
currentMPage := firstMPage;
mpageNumber := 1;
END FirstMasterPage;
PROCEDURE LastMasterPage*;
BEGIN
currentMPage := lastMPage;
mpageNumber := nofMPages;
END LastMasterPage;
PROCEDURE SetPageWidth*(pagewidth : REAL);
BEGIN
pageWidth := pagewidth;
END SetPageWidth;
PROCEDURE GetPageWidth*(): REAL;
BEGIN
RETURN pageWidth
END GetPageWidth;
PROCEDURE SetPageHeight*(pageheight : REAL);
BEGIN
pageHeight := pageheight;
END SetPageHeight;
PROCEDURE GetPageHeight*(): REAL;
BEGIN
RETURN pageHeight
END GetPageHeight;
PROCEDURE SetMargins*(top, bottom, left, right : REAL);
BEGIN
marginTop := top;
marginBottom := bottom;
marginLeft := left;
marginRight := right;
END SetMargins;
PROCEDURE GetMarginTop*(): REAL;
BEGIN
RETURN marginTop
END GetMarginTop;
PROCEDURE GetMarginBottom*() : REAL;
BEGIN
RETURN marginBottom
END GetMarginBottom;
PROCEDURE GetMarginLeft*(): REAL;
BEGIN
RETURN marginLeft
END GetMarginLeft;
PROCEDURE GetMarginRight*(): REAL;
BEGIN
RETURN marginRight
END GetMarginRight;
PROCEDURE SetFacingPages*(fpages : BOOLEAN);
BEGIN
facingPages := fpages;
END SetFacingPages;
PROCEDURE GetFacingPages*(): BOOLEAN;
BEGIN
RETURN facingPages
END GetFacingPages;
PROCEDURE GetCurrentPage*(): PageObject;
BEGIN
RETURN currentPage;
END GetCurrentPage;
PROCEDURE GetFirstPage*(): PageObject;
BEGIN
RETURN firstPage;
END GetFirstPage;
PROCEDURE GetLastPage*(): PageObject;
BEGIN
RETURN lastPage;
END GetLastPage;
PROCEDURE GetCurrentMasterPage*(): MasterPageObject;
BEGIN
RETURN currentMPage;
END GetCurrentMasterPage;
PROCEDURE GetFirstMasterPage*(): MasterPageObject;
BEGIN
RETURN firstMPage;
END GetFirstMasterPage;
PROCEDURE GetLastMasterPage*(): MasterPageObject;
BEGIN
RETURN lastMPage;
END GetLastMasterPage;
PROCEDURE GetMasterByName*(name: Strings.String): MasterPageObject;
VAR page, result: MasterPageObject;
match: Strings.String;
BEGIN
result := NIL;
IF name # NIL THEN
page := GetFirstMasterPage();
WHILE page # NIL DO
match := page.GetName();
IF (match # NIL) & Strings.Match(match^, name^) THEN
result := page;
END;
page := page.next;
END;
END;
RETURN result;
END GetMasterByName;
PROCEDURE GetCurrentPageNumber*(): LONGINT;
BEGIN
RETURN pageNumber;
END GetCurrentPageNumber;
PROCEDURE GetCurrentMasterPageNumber*(): LONGINT;
BEGIN
RETURN mpageNumber;
END GetCurrentMasterPageNumber;
END Document;
PageObject* = OBJECT
VAR
ownerDocument* : Document;
masterpage* : MasterPageObject;
next*, prev* : PageObject;
firstFrame*, lastFrame*, currentFrame* : FrameObject;
firstGuide*, lastGuide*, currentGuide* : GuideObject;
PROCEDURE SetOwner*(doc: Document);
BEGIN
ownerDocument := doc;
END SetOwner;
PROCEDURE &New*;
VAR
BEGIN
firstFrame := NIL; lastFrame := NIL; currentFrame := NIL;
firstGuide := NIL; lastGuide := NIL; currentGuide := NIL;
next := NIL; prev := NIL;
masterpage := NIL;
END New;
PROCEDURE SetMasterPage*(master: MasterPageObject);
BEGIN
masterpage := master;
END SetMasterPage;
PROCEDURE GetMasterPage*(): MasterPageObject;
BEGIN
RETURN masterpage;
END GetMasterPage;
PROCEDURE AddFrame*(x, y, w, h : REAL);
VAR newframe : FrameObject;
BEGIN
NEW(newframe); newframe.SetExtent(x,y,w,h);
IF lastFrame = NIL THEN
firstFrame := newframe;
lastFrame := newframe;
ELSE
newframe.prev := lastFrame;
lastFrame.next := newframe;
lastFrame := newframe;
END;
currentFrame := newframe;
END AddFrame;
PROCEDURE InsertFrame*(frame: FrameObject);
VAR name : Strings.String;
content: ContentObject;
temp: ARRAY 64 OF CHAR;
BEGIN
name := frame.GetName();
content := ownerDocument.GetContentByName(name^);
IF content # NIL THEN
ownerDocument.FixName(name^, temp); name := Strings.NewString(temp);
frame.SetName(name);
content := frame.GetContent();
content.contentName := name;
ELSE
content := frame.GetContent();
END;
ownerDocument.AddContent(content);
IF lastFrame = NIL THEN
firstFrame := frame;
lastFrame := frame;
ELSE
frame.prev := lastFrame;
lastFrame.next := frame;
lastFrame := frame;
END;
currentFrame := frame;
END InsertFrame;
PROCEDURE DeleteFrame*;
VAR name: Strings.String;
content: ContentObject;
BEGIN
IF currentFrame # NIL THEN
name := currentFrame.GetName();
content := ownerDocument.GetContentByName(name^);
IF content # NIL THEN
ownerDocument.RemoveContent(content);
END;
IF (currentFrame.prev = NIL) & (currentFrame.next = NIL) THEN
currentFrame := NIL;
firstFrame := NIL;
lastFrame := NIL;
ELSIF currentFrame.prev = NIL THEN
currentFrame.next.prev := currentFrame.prev;
currentFrame := currentFrame.next;
firstFrame := currentFrame;
ELSIF currentFrame.next = NIL THEN
currentFrame.prev.next := currentFrame.next;
currentFrame := currentFrame.prev;
lastFrame := currentFrame;
ELSE
currentFrame.prev.next := currentFrame.next;
currentFrame.next.prev := currentFrame.prev;
currentFrame := currentFrame.prev;
END;
END;
END DeleteFrame;
PROCEDURE NextFrame*;
BEGIN
IF (currentFrame # NIL) & (currentFrame.next # NIL) THEN
currentFrame := currentFrame.next;
END;
END NextFrame;
PROCEDURE PrevFrame*;
BEGIN
IF (currentFrame # NIL) & (currentFrame.prev # NIL) THEN
currentFrame := currentFrame.prev;
END
END PrevFrame;
PROCEDURE AddGuide*(position : REAL; horizontal : BOOLEAN);
VAR newguide : GuideObject;
BEGIN
NEW(newguide, position, horizontal);
IF lastGuide = NIL THEN
firstGuide := newguide;
lastGuide := newguide;
ELSE
newguide.prev := lastGuide;
lastGuide.next := newguide;
lastGuide := newguide;
END;
currentGuide := newguide;
END AddGuide;
PROCEDURE DeleteGuide*;
BEGIN
IF currentGuide # NIL THEN
IF (currentGuide.prev = NIL) & (currentGuide.next = NIL) THEN
firstGuide := NIL;
lastGuide := NIL;
currentGuide := NIL;
ELSIF (currentGuide.prev = NIL) THEN
currentGuide.next.prev := currentGuide.prev;
firstGuide := currentGuide.next;
currentGuide := currentGuide.next;
ELSIF (currentGuide.next = NIL) THEN
currentGuide.prev.next := currentGuide.next;
lastGuide := currentGuide.prev;
currentGuide := currentGuide.prev;
ELSE
currentGuide.prev.next := currentGuide.next;
currentGuide.next.prev := currentGuide.prev;
END;
END;
END DeleteGuide;
PROCEDURE Move2Front*;
BEGIN
IF currentFrame # NIL THEN
IF (currentFrame.prev = NIL) & (currentFrame.next = NIL) THEN
firstFrame := currentFrame;
ELSIF (currentFrame.next = NIL) THEN
ELSIF (currentFrame.prev = NIL) THEN
currentFrame.next.prev := currentFrame.prev;
firstFrame := currentFrame.next;
lastFrame.next := currentFrame;
currentFrame.prev := lastFrame;
currentFrame.next := NIL;
ELSE
currentFrame.prev.next := currentFrame.next;
currentFrame.next.prev := currentFrame.prev;
lastFrame.next := currentFrame;
currentFrame.prev := lastFrame;
currentFrame.next := NIL;
END;
lastFrame := currentFrame;
END;
END Move2Front;
PROCEDURE Move2Back*;
VAR
BEGIN
IF currentFrame # NIL THEN
IF (currentFrame.prev = NIL) & (currentFrame.next = NIL) THEN
lastFrame := currentFrame;
ELSIF (currentFrame.next = NIL) THEN
currentFrame.prev.next := currentFrame.next;
lastFrame := currentFrame.prev;
firstFrame.prev := currentFrame;
currentFrame.prev := NIL;
currentFrame.next := firstFrame;
ELSIF (currentFrame.prev = NIL) THEN
ELSE
currentFrame.prev.next := currentFrame.next;
currentFrame.next.prev := currentFrame.prev;
firstFrame.prev := currentFrame;
currentFrame.prev := NIL;
currentFrame.next := firstFrame;
END;
firstFrame := currentFrame;
END;
END Move2Back;
PROCEDURE Move2FrontStep*;
VAR
BEGIN
IF currentFrame # NIL THEN
IF (currentFrame.prev = NIL) & (currentFrame.next = NIL) THEN
firstFrame := currentFrame;
lastFrame := currentFrame;
ELSIF (currentFrame.prev = NIL) THEN
IF currentFrame.next.next = NIL THEN
currentFrame.prev := currentFrame.next;
lastFrame.next := currentFrame;
lastFrame.prev := NIL;
currentFrame.next := NIL;
firstFrame := lastFrame;
lastFrame := currentFrame;
ELSE
currentFrame.prev := currentFrame.next;
currentFrame.next.next.prev := currentFrame;
currentFrame.next := currentFrame.next.next;
currentFrame.prev.next := currentFrame;
firstFrame := currentFrame.prev;
firstFrame.prev := NIL;
END;
ELSIF (currentFrame.next = NIL) THEN
ELSE
IF currentFrame.next.next = NIL THEN
currentFrame.prev.next := currentFrame.next;
currentFrame.next.prev := currentFrame.prev;
currentFrame.prev := currentFrame.next;
currentFrame.next.next := currentFrame;
currentFrame.next := NIL;
lastFrame := currentFrame;
ELSE
currentFrame.prev.next := currentFrame.next;
currentFrame.next.prev := currentFrame.prev;
currentFrame.prev := currentFrame.prev.next;
currentFrame.next := currentFrame.prev.next;
currentFrame.prev.next.prev := currentFrame;
currentFrame.prev.next := currentFrame;
END;
END;
END;
END Move2FrontStep;
PROCEDURE Move2BackStep*;
BEGIN
IF currentFrame # NIL THEN
IF (currentFrame.prev = NIL) & (currentFrame.next = NIL) THEN
firstFrame := currentFrame;
lastFrame := currentFrame;
ELSIF (currentFrame.prev = NIL) THEN
ELSIF (currentFrame.next = NIL) THEN
IF currentFrame.prev.prev = NIL THEN
currentFrame.next := currentFrame.prev;
firstFrame.prev := currentFrame;
firstFrame.next := NIL;
currentFrame.prev := NIL;
lastFrame := firstFrame;
firstFrame := currentFrame;
ELSE
currentFrame.next := currentFrame.prev;
currentFrame.prev.prev.next := currentFrame;
currentFrame.prev := currentFrame.prev.prev;
currentFrame.next.prev := currentFrame;
lastFrame := currentFrame.next;
lastFrame.next := NIL;
END;
ELSE
IF currentFrame.prev.prev = NIL THEN
currentFrame.next.prev := currentFrame.prev;
currentFrame.prev.next := currentFrame.next;
currentFrame.next := currentFrame.prev;
currentFrame.prev.prev := currentFrame;
currentFrame.prev := NIL;
firstFrame := currentFrame;
ELSE
currentFrame.next.prev := currentFrame.prev;
currentFrame.prev.next := currentFrame.next;
currentFrame.next := currentFrame.next.prev;
currentFrame.prev := currentFrame.next.prev;
currentFrame.next.prev.next := currentFrame;
currentFrame.next.prev := currentFrame;
END;
END;
END;
END Move2BackStep;
PROCEDURE SetCurrentFrame*(frame : FrameObject);
BEGIN
currentFrame := frame;
END SetCurrentFrame;
PROCEDURE GetCurrentFrame*(): FrameObject;
BEGIN
RETURN currentFrame;
END GetCurrentFrame;
PROCEDURE GetFirstFrame*(): FrameObject;
BEGIN
RETURN firstFrame;
END GetFirstFrame;
PROCEDURE GetLastFrame*(): FrameObject;
BEGIN
RETURN lastFrame;
END GetLastFrame;
PROCEDURE GetCurrentGuide*(): GuideObject;
BEGIN
RETURN currentGuide;
END GetCurrentGuide;
PROCEDURE GetFirstGuide*(): GuideObject;
BEGIN
RETURN firstGuide;
END GetFirstGuide;
PROCEDURE GetLastGuide*(): GuideObject;
BEGIN
RETURN lastGuide;
END GetLastGuide;
END PageObject;
MasterPageObject* = OBJECT(PageObject)
VAR
mpageName* : Strings.String;
next*, prev* : MasterPageObject;
PROCEDURE &New*;
BEGIN
New^;
mpageName := Strings.NewString("Master");
END New;
PROCEDURE SetName*(name: Strings.String);
BEGIN
mpageName := name;
END SetName;
PROCEDURE GetName*(): Strings.String;
BEGIN
RETURN mpageName;
END GetName;
END MasterPageObject;
GuideObject* = OBJECT
VAR
horizontal : BOOLEAN;
position : REAL;
prev*, next* : GuideObject;
PROCEDURE &New*(posi : REAL; horiz : BOOLEAN);
BEGIN
position := posi; horizontal := horiz;
prev := NIL; next := NIL;
END New;
PROCEDURE SetHorizontal*(isHorizontal : BOOLEAN);
BEGIN
horizontal := isHorizontal;
END SetHorizontal;
PROCEDURE GetHorizontal*() : BOOLEAN;
BEGIN
RETURN horizontal;
END GetHorizontal;
PROCEDURE SetPosition*(posi : REAL);
BEGIN
position := posi;
END SetPosition;
PROCEDURE GetPosition*() : REAL;
BEGIN
RETURN position;
END GetPosition;
PROCEDURE Clone*(): GuideObject;
VAR newguide: GuideObject;
BEGIN
NEW(newguide, GetPosition(), GetHorizontal());
RETURN newguide;
END Clone;
END GuideObject;
FrameObject* = OBJECT
VAR
frameName : Strings.String;
frameType : Strings.String;
x, y, w, h : REAL;
style : StyleObject;
content : ContentObject;
textwrapON : BOOLEAN;
twrapTop, twrapBottom, twrapLeft, twrapRight : REAL;
next*, prev* : FrameObject;
PROCEDURE &New*;
BEGIN
textwrapON := FALSE;
twrapTop := 0; twrapBottom := 0; twrapLeft := 0; twrapRight := 0;
next := NIL; prev := NIL;
frameName := Strings.NewString("newframe");
style := NIL;
content := NIL;
END New;
PROCEDURE SetName*(name : Strings.String);
VAR
BEGIN
frameName := name;
END SetName;
PROCEDURE GetName*() : Strings.String ;
VAR
BEGIN
RETURN frameName
END GetName;
PROCEDURE SetType*(type : Strings.String);
BEGIN
frameType := type;
END SetType;
PROCEDURE GetType*() : Strings.String;
VAR
BEGIN
RETURN frameType;
END GetType;
PROCEDURE FixExtent*;
VAR cx, cy, cw, ch: REAL;
BEGIN
cx := x; cy := y; cw := w; ch := h;
x := Min(cx, cx+cw); y := Min(cy, cy+ch);
w := Max(cx, cx+cw)-Min(cx, cx+cw); h := Max(cy, cy+ch)-Min(cy, cy+ch);
END FixExtent;
PROCEDURE SetExtent*(x, y, w, h: REAL);
BEGIN
SELF.x := x; SELF.y := y; SELF.w := w; SELF.h := h;
END SetExtent;
PROCEDURE SetSize*( w, h : REAL);
VAR
BEGIN
SELF.w := w; SELF.h := h;
END SetSize;
PROCEDURE SetPosition*(x, y: REAL);
BEGIN
SELF.x := x; SELF.y := y;
END SetPosition;
PROCEDURE GetX*(): REAL;
VAR
BEGIN
RETURN x;
END GetX;
PROCEDURE GetY*(): REAL;
VAR
BEGIN
RETURN y;
END GetY;
PROCEDURE GetWidth*(): REAL;
VAR
BEGIN
RETURN w;
END GetWidth;
PROCEDURE GetHeight*(): REAL;
VAR
BEGIN
RETURN h;
END GetHeight;
PROCEDURE SetStyle*(style : StyleObject);
BEGIN
SELF.style := style;
END SetStyle;
PROCEDURE GetStyle*() : StyleObject;
BEGIN
RETURN style
END GetStyle;
PROCEDURE SetContent*(content : ContentObject);
BEGIN
SELF.content := content;
END SetContent;
PROCEDURE GetContent*() : ContentObject;
BEGIN
RETURN content
END GetContent;
PROCEDURE SetWrap*(wrap : BOOLEAN);
BEGIN
textwrapON := wrap;
END SetWrap;
PROCEDURE GetWrap*() : BOOLEAN;
BEGIN
RETURN textwrapON;
END GetWrap;
PROCEDURE SetWrapSize*(t, b, l, r : REAL);
BEGIN
twrapTop := t; twrapBottom := b;
twrapLeft := l; twrapRight := r;
END SetWrapSize;
PROCEDURE GetWrapTop*(): REAL;
BEGIN
RETURN twrapTop
END GetWrapTop;
PROCEDURE GetWrapBottom*(): REAL;
BEGIN
RETURN twrapBottom
END GetWrapBottom;
PROCEDURE GetWrapLeft*(): REAL;
BEGIN
RETURN twrapLeft
END GetWrapLeft;
PROCEDURE GetWrapRight*(): REAL;
BEGIN
RETURN twrapRight
END GetWrapRight;
PROCEDURE Clone*(): FrameObject;
VAR newframe: FrameObject;
newcontent: ContentObject;
BEGIN
NEW(newframe);
newframe.SetName(GetName());
newframe.SetType(GetType());
newframe.SetExtent(GetX(), GetY(), GetWidth(), GetHeight());
newframe.SetStyle(GetStyle());
newcontent := GetContent();
newframe.SetContent(newcontent.Clone());
newframe.SetWrap(GetWrap());
newframe.SetWrapSize(GetWrapTop(), GetWrapBottom(), GetWrapLeft(), GetWrapRight());
newframe.prev := NIL; newframe.next := NIL;
RETURN newframe;
END Clone;
END FrameObject;
ContentObject* = OBJECT
VAR
contentName* : Strings.String;
redrawProc* : PROCEDURE {DELEGATE};
updatePropsPosition*: PROCEDURE {DELEGATE} (x, y: LONGINT);
contentWidth*, contentHeight*: LONGINT;
zoomFactor* : REAL;
ownerDoc*: Document;
hasFocus- : BOOLEAN;
running- : BOOLEAN;
PROCEDURE &New*;
BEGIN
hasFocus := FALSE;
running := FALSE;
END New;
PROCEDURE Clone*(): ContentObject;
VAR newObj: ContentObject;
BEGIN
NEW(newObj); newObj.contentName := Strings.NewString(contentName^);
newObj.redrawProc := redrawProc; newObj.updatePropsPosition := updatePropsPosition;
newObj.contentWidth := contentWidth; newObj.contentHeight := contentHeight; newObj.zoomFactor := zoomFactor;
newObj.ownerDoc := ownerDoc;
RETURN newObj;
END Clone;
PROCEDURE Draw*(canvas : WMGraphics.Canvas; x, y, w, h : LONGINT; zoomFactor: REAL; quality, preview: BOOLEAN);
VAR color: LONGINT;
BEGIN
color := LONGINT(0FF0000FFH);
canvas.Line(x, y, x+w, y+h, color, WMGraphics.ModeCopy);
canvas.Line(x+w, y, x, y+h, color, WMGraphics.ModeCopy);
END Draw;
PROCEDURE Redraw*;
BEGIN
IF redrawProc # NIL THEN
redrawProc;
ELSE
END;
END Redraw;
PROCEDURE UpdatePosition*(x, y: LONGINT);
BEGIN
updatePropsPosition(x, y);
END UpdatePosition;
PROCEDURE SetSize*(w, h: LONGINT);
BEGIN
contentWidth := w; contentHeight := h;
END SetSize;
PROCEDURE Resize*(zoomF: REAL);
BEGIN
zoomFactor := zoomF;
END Resize;
PROCEDURE Show*(x, y: LONGINT);
END Show;
PROCEDURE Hide*;
END Hide;
PROCEDURE Close*;
END Close;
PROCEDURE SetFocus*(focus: BOOLEAN);
BEGIN
hasFocus := focus;
END SetFocus;
PROCEDURE FocusLost*;
BEGIN
hasFocus := FALSE;
END FocusLost;
PROCEDURE FocusReceived*;
BEGIN
hasFocus := TRUE;
END FocusReceived;
PROCEDURE GetPluginPointer*(): WMWindowManager.PointerInfo;
VAR manager : WMWindowManager.WindowManager;
BEGIN
manager := WMWindowManager.GetDefaultManager();
RETURN manager.pointerStandard;
END GetPluginPointer;
PROCEDURE PointerDown*(x, y: LONGINT; keys: SET);
END PointerDown;
PROCEDURE PointerMove*(x, y: LONGINT; keys: SET);
END PointerMove;
PROCEDURE PointerUp*(x, y: LONGINT; keys: SET);
END PointerUp;
PROCEDURE PointerLeave*;
END PointerLeave;
PROCEDURE IsHit*(x, y: LONGINT): BOOLEAN;
BEGIN
RETURN TRUE;
END IsHit;
PROCEDURE KeyEvent*(ucs: LONGINT; flags: SET; VAR keyCode: LONGINT);
END KeyEvent;
PROCEDURE Start*;
BEGIN
running := TRUE;
END Start;
PROCEDURE Stop*;
BEGIN
running := FALSE;
END Stop;
PROCEDURE OnPageEnter*;
END OnPageEnter;
PROCEDURE OnPageLeave*;
END OnPageLeave;
PROCEDURE OnCreate*;
END OnCreate;
PROCEDURE OnDelete*;
END OnDelete;
PROCEDURE Load*(elem: XML.Element);
END Load;
PROCEDURE FixLinks*;
END FixLinks;
PROCEDURE Store*(VAR w: Files.Writer);
BEGIN
w.String('<node-attribute name="type" value="Frame" />'); w.Ln;
END Store;
END ContentObject;
ContentFactory* = PROCEDURE() : ContentObject;
ContentPages* = POINTER TO ARRAY OF PageObject;
MasterPages* = POINTER TO ARRAY OF MasterPageObject;
Frames* = POINTER TO ARRAY OF FrameObject;
Contents* = POINTER TO ARRAY OF ContentObject;
VAR
dollyFrame*: FrameObject;
PROCEDURE NewObject*(): ContentObject;
VAR newObject: ContentObject;
BEGIN
NEW(newObject);
RETURN newObject;
END NewObject;
PROCEDURE Min(a, b: REAL): REAL;
BEGIN
IF a <= b THEN RETURN a ELSE RETURN b END;
END Min;
PROCEDURE Max(a, b: REAL): REAL;
BEGIN
IF a >= b THEN RETURN a ELSE RETURN b END;
END Max;
END DTPData.