texts
stringlengths 0
715k
| names
stringlengths 8
91
|
|---|---|
5 Texts
Graphical user interfaces have introduced graphical elements into everyday computing. While this was a very positive step towards overcoming the old-style modal textual user interfaces, texts have by no means become obsolete. Even in reports containing many illustrations, texts serve as indispensible glue.
In typical database applications, no graphical contents is manipulated. The data entered and retrieved are mostly textual, and reports to be printed usually are texts arranged in a tabular fashion.
Because of the importance of texts, this chapter demonstrates how the BlackBox Component Builder's text abstraction can be used in various ways. In several examples, we will reuse the simple database module introduced in the previous chapter.
We will work "bottom-up" by providing examples first for writing new texts, then for reading existing text, and finally for modifying existing texts. When discussing these examples, we will meet text models/carriers and riders, mappers, and auxiliary abstractions such as fonts, attributes, rulers, and others.
5.1 Writing text
In the BlackBox Component Builder, texts use the Carrier-Rider-Mapper design pattern (see Chapter 3). They provide text models as carriers for texts, and text writers and text readers as riders on text models. Both types are defined in the Text subsystem's core module TextModels. A text writer maintains a current position and current attributes, which will be used when writing the next element into the text. The full definition of a writer looks as follows:
Writer = POINTER TO ABSTRACT RECORD
attr-: TextModels.Attributes;
(wr: Writer) Base (): TextModels.Model, NEW, ABSTRACT;
(wr: Writer) Pos (): INTEGER, NEW, ABSTRACT;
(wr: Writer) SetPos (pos: INTEGER), NEW, ABSTRACT;
(wr: Writer) SetAttr (attr: TextModels.Attributes), NEW;
(wr: Writer) WriteChar (ch: CHAR), NEW, ABSTRACT;
(wr: Writer) WriteView (view: Views.View; w, h: INTEGER), NEW, ABSTRACT
END;
Listing 5-1. Definition of TextModels.Writer
The most important procedure of a writer is WriteChar, it allows to write a new character at the current position. If the character position lies within an existing text (i.e., in 0 .. text.Length() - 1), the character at this text position is inserted. (This is a difference to the BlackBox files abstraction, where old data would be overwritten by the writer in this case. With texts, writers always insert and never overwrite.) If the writer's position is at the end of the text (i.e., at text.Length()), the character is appended to the text and thus makes the text one element longer. After WriteChar, the writer's text position is increased by one. The current position can be inquired by calling the writer's Pos function, and it can be modified by calling the SetPos procedure.
Since text models are capable of containing views as well as normal characters, there exists a procedure WriteView which allows to write a view, given an appropriate size (w for the width, h for the height).
Like most geometrical distances in BlackBox, a view's width and height are specified in so-called universal units of 1/36000 millimeters. This value was chosen to eliminate rounding errors for many common screen and printer resolutions. For example, an inch, a 1/300-th of an inch, a millimeter, and a desktop publishing point can be represented in units without rounding errors. Where not specified otherwise, distances can be assumed to be represented in universal units.
If no specific size for the view is desired, passing the value Views.undefined for the width and/or height allows the text to choose a suitable default size for the written view.
How is a writer created? Like all riders, a writer is created by a factory function of its carrier. For this purpose, a text model provides the procedure NewWriter, which creates a writer and connects it to the text. A writer can return its text through the Base function. A newly created writer is positioned at the end of the text.
Text elements don't have character codes only, they also have attributes. A writer's attr field contains the attributes to be used when the next character or view is written. The current attributes can be changed by calling the writer's SetAttr procedure.
In terms of attributes, the text subsystem of the BlackBox Component Builder supports colors and vertical offsets. Colors are encoded as integers (Ports.Color). Module Ports predefines the constants black, grey6, grey12, grey25, grey50, grey75, white, red, green, and blue. "grey6" means a mixture of 6% white and 94% black, which is almost black. The other grey values are increasingly lighter. Vertical offsets are measured in universal units.
Besides colors and vertical offset, a text element also has a font attribute. A font is a collection of glyphs. A glyph is a visual rendering of a character code. Different fonts may contain different glyphs for the same characters. For example, Helvetica looks different from Times and Frutiger. A font may not provide glyphs for all character codes that can be represented in Component Pascal. This is not surprising, since the CHAR datatype of Component Pascal conforms to the Unicode standard. Unicode is a 16-bit standard, and thus can represent over 65000 different characters. The first 256 characters are the Latin-1 characters. The first 128 characters of Latin-1 are the venerable ASCII characers.
If a font doesn't contain a particular glyph, BlackBox's font framework either returns a glyph from some other font for the same character, or it yields a generic "missing glyph" symbol; e.g., a small empty rectangle.
Font objects are defined in module Fonts.Font. It won't be necessary to take a closer look at this module here; it is sufficient to interpret a pointer of type Fonts.Font as the identification of a font with its particular typeface, style, weight, and size:
Typeface
This is the font family to which a font belongs; it defines a common "look and feel" for the whole family. Examples of typefaces are Helvetica, Times, or Courier. Typeface names are represented as character arrays of type Fonts.Typeface.
Style
A font may optionally be italicized, underlined, struck out or a combination thereof. Styles are represented as sets. Currently, the set elements Fonts.italic, Fonts.underline and Fonts.strikeout are defined.
Weight
A font might exist in several weights, e.g., ranging from light to normal to bold to black to ultra black. Usually, a font is either normal or bold. Weights are represented as integers. The values Fonts.normal and Fonts.bold are predefined.
Size
A font may be rendered in different sizes, taking into account the resolution of the used output device. Often, sizes are given in points. A point is 1/72-th of an inch. In BlackBox, font sizes are measured in universal units, which are chosen such that points (Ports.point) and other typographical units can be represented without round-off errors. Typical font sizes are 10 * Ports.point or 12 * Ports.point.
In principle, typeface, style, weight and size are independent of each other. This means that a given typeface can be combined with arbitrary styles, weights and sizes. However, from a typographical point of view, some combinations are more desirable than others, and may be optimized by the font designer and the underlying operating system's font machinery.
The text attributes font, color and vertical offset are packaged into objects of type TextModels.Attributes. Slightly simplified, this type looks as follows:
Attributes = POINTER TO RECORD (Stores.Store)
color-: Ports.Color;
font-: Fonts.Font;
offset-: INTEGER
END;
Listing 5-2. Simplified definition of TextModels.Attributes
This is the type of the writer's attr field. It is an extension of Stores.Store. This means that such an object can be stored persistently in a file. Other examples of stores are TextModels.Model and TextViews.View, but not TextModels.Writer. A more detailed description of stores is given in Part III.
We have now seen the capabilities of a text writer, including the text attributes that it supports. The typical use of text writers is shown in the code pattern below. A code pattern is an excerpt of a procedure which shows one or a few important aspects of the objects currently discussed. Such a code fragment constitutes a recipe that should be known by a programmer "fluent" in this topic.
VAR t: TextModels.Model; wr: TextModels.Writer; ch: CHAR;
BEGIN
t := TextModels.dir.New(); (* allocate new empty text model *)
wr := t.NewWriter(NIL);
... produce ch ...
WHILE condition DO
wr.WriteChar(ch);
... produce ch ...
END;
Listing 5-3. Code pattern for TextModels.Writer
The code pattern is not very interesting since it doesn't show how the generated text can be displayed. A text object only represents a text with its attributes. It doesn't know about how to draw this text, not even how to do text setting; i.e., how to break lines and pages such that they fit a given rectangle (view, paper size, etc.). When it is desired to make a text visible, it is necessary to provide a text view for the text object. Data objects that may be displayed in several views are generally called models. The separation of model and view is an important design pattern that was discussed in Chapter 2.
Module TextModels only exports an abstract record type for text models, no concrete implementation. Instead, it exports a directory object (TextModels.dir) which provides the necessary factory function (TextModels.dir.New). This indirection pattern for object creation was motivated in Chapter 2.
Working directly with text writers is inconvenient, they don't even support the writing of strings. For this reason, the following examples will use formatters when writing text. A formatter is a mapper (see Chapter 3) that contains a text writer and performs the mapping of higher-level symbols, such as the Component Pascal symbols, to a stream of characters that can be fed to the writer. In the next example, we we will use a formatter to write a text; a very simple "report". The text consists of the phone database contents, one line per entry. This first version of a phone database report is implemented in module ObxPDBRep0:
MODULE ObxPDBRep0;
IMPORT Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep0.
Listing 5-4. Writing the phone database using a formatter
Note that name and number are separated by a tab character (09X). Since no tab stops are defined for this text, a tab will be treated as a wide fixed-width space (whose width is a multiple of the normal space character glyph). We will later see how tab stops can be defined.
Execution of the ObxPDBRep0.GenReport command results in the following window:
Figure 5-5. Text editor window containing the phone database
The text in the newly opened window is a fully editable text view. It can be edited; stored as a BlackBox document; printed; and so on. If you look at the source code, you can recognize the following code pattern:
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View;
BEGIN
t := TextModels.dir.New();
f.ConnectTo(t);
... use formatter procedures to construct the text ...
v := TextViews.dir.New(t);
Views.OpenView(v)
Listing 5-6. Code pattern for TextMappers.Formatter and for open a text view
This code pattern occurs in many BlackBox commands, e.g., in DevDebug.ShowLoadedModules. It is useful whenever you need to write tabular reports of varying length, possibly spanning several printed pages.
It also clearly shows that texts embody several design patterns simultaneously: a text object is a model which can be observed by a view (Observer pattern), it is a carrier (Carrier-Rider-Mapper pattern), and it is a container (Composite pattern).
An interesting aspect of the above code pattern is that the text carrier t is created first, then its contents is constructed using a formatter, and only then is a view v on the text carrier created. Finally, the view is opened in its own document window.
In BlackBox it is important that a model can be manipulated before there exists any view for it. In fact, it is far more efficient to create a text before a view on it is opened, because screen updates and some internal housekeeping of the undo mechanism are avoided this way, which can cause a dramatic speed difference.
BlackBox text models represent sequences of text elements. A text element is either a Latin-1 character (SHORTCHAR), a Unicode character (a CHAR > 0FFX) or a view (an extension of type Views.View). Text stretches may be attributed with font information, color and vertical offset. Since a text model may contain views, it is a container. In the following examples, we will see how these text facilities can be used when creating new texts. Our phone book database is used as source of the material that we want to put into texts, applying different textual representations in the various examples.
The following example demonstrates how a text can be generated out of our example database. In this text, names are written in green color. The differences to module ObxPDBRep0 are marked with underlined text.
MODULE ObxPDBRep1;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
default,green:TextModels.Attributes;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
default:=f.rider.attr; (* save old text attributes for later use *)
green:=TextModels.NewColor(default,Ports.green); (* use green color *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.rider.SetAttr(green); (* change current attributes of formatter's rider *)
f.WriteString(name); (* first string *)
f.rider.SetAttr(default); (* change current attributes of formatter's rider *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep1.
Listing 5-7. Writing the phone database using green color
Note that a formatter's rider contains a set of current attributes (TextModels.Writer.attr). This value includes the current color and is read-only; it can be set with the writer's SetAttr procedure.
Our first text examples, ObxPDBRep0 and ObxPDBRep1, don't produce nice-looking output, because the phone numbers are not aligned below each other in a tabular fashion.
ObxPDBRep1 remedies this defect by inserting a ruler at the beginning of the text. This ruler defines a tab stop, which causes all phone numbers ђ separated from their phone names by tabs ђ to line up nicely. The differences to module ObxPDBRep0 are marked with underlined text.
MODULE ObxPDBRep2;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, TextRulers, ObxPhoneDB;
PROCEDUREWriteRuler(VARf:TextMappers.Formatter);
CONST cm = 10 * Ports.mm; (* universal units *)
VAR ruler: TextRulers.Ruler;
BEGIN
ruler := TextRulers.dir.New(NIL);
TextRulers.AddTab(ruler, 4 * cm); (* define a tab stop, 4 cm from the left margin *)
TextRulers.SetRight(ruler, 12 * cm); (* set right margin *)
f.WriteView(ruler) (* a ruler is a view, thus can be written to the text *)
END WriteRuler;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
WriteRuler(f);
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep2.
Listing 5-8. Writing the phone database using a formatter and a ruler
Execution of the ObxPDBRep2.GenReport command results in a window with the improved presentation of the phone database. Executing Text->ShowMarks causes the ruler to be displayed:
Figure 5-9. Text editor window containing the tabular phone database
A ruler is a view. A ruler on its own doesn't make sense. Like all controls, a ruler makes only sense in a container. Unlike many other controls, a ruler is an example of a control that can only function properly in a particular container; in this case the container must be a text model. You may copy a ruler into a form or other container, but it will just be passive and have no useful effect there. If it is embedded in a text model that is displayed in a text view, a ruler can influence the way in which the subsequent text is set. For example, a ruler can define tab stops, margins, and adjustment modes.
The attributes of a ruler are valid in the ruler's scope. The scope starts with the ruler itself and ends right before the next ruler, or at the end of the text if there follows no ruler anymore. A ruler introduces a new paragraph, possibly with its own distinct set of paragraph attributes. Inserting a paragraph character (0EX) instead of a ruler also starts a new paragraph, which inherits all paragraph attributes from the preceding ruler. Paragraph characters are the normal way to start a new paragraph; rulers are only used if particular paragraph attributes should be enforced. Note that a carriage return (0DX) doesn't start a new paragraph.
A text view contains an invisible default ruler that defines the text setting of the text before the first ruler in the text, or of all text if no ruler has been written to the text at all. Interactively, this default ruler, and default attributes, can be set with the menu commands Text->Make Default Ruler and Text->Make Default Attributes.
A ruler has many attributes that can be set. Unlike character attributes, which can be applied to arbitrary text stretches, these attributes apply to the ruler or the whole paragraph(s) in its scope.
We will discuss these attributes so that you know about ruler functionality when you need it. We won't discuss rulers in more detail though, since you can learn about the necessary details on demand if and when you need the more advanced ruler capabilities (see on-line documentation of module TextRulers).
Styles
A ruler's attributes are not directly stored in the ruler view itself. Instead, they are bundled into a separate object of type TextRulers.Attributes, which in turn is contained in an object of type TextRulers.Style.
A style is the model of one or several ruler views. If several views share the same model, the user can change the attributes of all the rulers simultaneously. For example, changing the left margin will affect all rulers bound to the same style. However, models cannot be shared across documents, which means that all rulers bound to the same style must be embedded in the same document.
TextRulers.Attributes are persistent collections of ruler attributes, much in the same way as TextModels.Attributes are persistent collections of character attributes.
Attributes = POINTER TO EXTENSIBLE RECORD (Stores.Store)
first-, left-, right-, lead-, asc-, dsc-, grid-: INTEGER;
opts-: SET;
tabs-: TextRulers.TabArray
END;
Listing 5-10. Simplified definition of TextRulers.Attributes
In the following paragraphs, we discuss the individual attributes. For these attributes, there exist auxiliary procedures in module TextRulers which make it simple to set up a text ruler in the desired way: just create a new ruler with TextRulers.dir.New(NIL), and then apply the auxiliary procedures that you need to obtain the correct attribute settings. An example was given above in the procedure WriteRuler of module ObxPDBRep2.
These auxiliary procedures greatly simplify setting up text rulers. For example, they hide that the attributes are actually not contained in the ruler itself, but rather in attributes objects which are used by style objects which are used by the rulers. Providing such simplified access to a complex feature is called a facade in the design patterns terminology [GHJV94]. Here the mechanism is particularly simple because the facade merely consists of simple procedures, there is not even a facade object that would have to be created and managed.
Tab stops
The tabs field of type TextRulers.TabArray contains information about tab stops. The number of tab stops is given in tabs.len, and must not be larger than TextRulers.maxTabs (which is currently 32). If the user enters more than maxTabs tabs, or more tabs than given in len, then the superfluous tabs will be treated as fixed size space characters. The fixed size used is an integer multiple of the width of a space in the used font, approximately 4 mm in total.
Tab = RECORD
stop: INTEGER; (* stop >= 0 *)
type: SET (* type IN {TextRulers.centerTab, TextRulers.rightTab, TextRulers.barTab} *)
END;
TabArray = RECORD
len: INTEGER; (* 0 <= len <= TextRulers.maxTabs *)
tab: ARRAY TextRulers.maxTabs OF TextRulers.Tab
(* tab[0 .. len-1] sorted in ascending order without duplicates *)
END
Listing 5-11. Definition of TextRulers.Tab and TabArray
In tabs.tab.stop, the tab's distance from the left border of the text view is specified (in universal units of course). The tab stops in the tabs.tab array must be sorted in ascending order, and there must be no duplicate values.
In addition to the stop position kept in field stop, a tab stop can be modified using a set of possible options kept in field type. In particular, these options allow to center text under a tab stop or to right-align text under a tab stop (the default is left alignment):
tab type tabs.tab[i].type
left adjusted {}
right adjusted {TextRulers.rightTab}
centered {TextRulers.centerTab}
For all of the above tab types, it can optionally be specified whether the tab itself is drawn as a vertical bar. Bar tabs are specified by including the value TextRulers.barTab in the tab type set. Since the bars occupy the whole line height, they are useful to to format simple tables.
When created with TextRulers.dir.New(NIL), a ruler has no tabs.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE AddTab (r: Ruler; x: INTEGER)
PROCEDURE MakeRightTab (r: Ruler)
PROCEDURE MakeCenterTab (r: Ruler)
PROCEDURE MakeLineTab (r: Ruler)
AddTab adds a new left-adjusted normal tab. It can be changed into a right-adjusted or centered tab by calling MakeRightTab or MakeCenterTab. Independently of the adjustment mode, the tab can be turned into a bar tab by calling MakeLineTab.
Margins
Text is set within a left and a right margin. These margins can be specified as distances from the left border of the text view. The left margin must be smaller than the right margin.
left-, right-: INTEGER (* (left >= 0) & (right >= left) *)
It is possible to signal to the text setter that it should ignore the right margin and use the text view for line breaking instead. In fact, this is the default behavior. It means that when the view size is changed, the text's line breaking will probably change also. Even if the right margins is ignored for text setting, it is still useful: a text view uses it as a hint for how wide the view should be when it is opened.
Line breaking at a fixed right margin is only needed in rare circumstances, for example when this particular paragraph should be narrower than the others. If you want line breaking to be controlled by the right margin, then you have to include TextRulers.rightFixed in the opts set (see further below).
Note that the Tools->Document Size... command allows to flexibly specify the width (and height) of a document's outermost view, the so-called root view. The width can be set to a fixed size, which is useful for page layout types of application.
Usually however, the width is defined by the page setup, which derives the view's width from the currently selected paper size, reduced by the user-specified print margins. This is adequate for letters, program sources, and similar kinds of documents.
As a third possibility, the root view's width can be bound to the window size (this is the case mentioned above, when the view uses the first ruler's right margin as a hint, whether the right margin is fixed or not). Whenever the user resizes the window, the root view is resized accordingly, such that it is kept always as large as the window allows. This is desirable in particular for on-line documentation, where the documentation should use as much screen space as granted by the user, adapting the text flow to the available width whenever the window is resized. An example for this style is the default formatting of Web pages.
Note that these features are independent of the root view's type. They work the same way for all resizable views, such as text views, form views, and most other kinds of editor view.
When created with TextRulers.dir.New(NIL), a ruler has a left margin of 0 and an implementation-specific non-fixed right margin > 0.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetLeft (r: Ruler; x: INTEGER)
PROCEDURE SetRight (r: Ruler; x: INTEGER)
PROCEDURE SetFixedRight (r: Ruler; x: INTEGER)
SetLeft and SetRight set the left or right margin. SetFixedRight sets the right margin and marks it as fixed.
First line indentation
A ruler defines the first line indentation, i.e., how much the first line after the ruler is indented from the left border of the text view. Note that it is possible to define a first line indentation that is smaller than the left margin (first < left). This is the only case where a text view draws text to the left of the specified left margin.
first-: INTEGER; (* first >= 0 *)
First line indentation is applied to the first line of each paragraph in the ruler's scope.
When created with TextRulers.dir.New(NIL), a ruler has no first line indentation (first = 0).
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetFirst (r: Ruler; x: INTEGER)
Ascender and descender
When a character is drawn, its rendering depends on its font attributes, such as typeface (Helvetica or Times?), style (straight or slanted?), weight (normal or bold?) and size. When a whole string is drawn, all characters are placed on a common base line. The ascender is the largest extent to which any character of a line extends above the base line. Some characters extend below the base line, such as "g" and "y". The descender is the largest extent to which any character of a line extends below the base line (see Figure 5-12).
A text setter should calculate base line distances in a way that one line's descender doesn't overlap the next line's ascender, in order to avoid overlapping characters. In order to avoid degenerate cases, such as empty lines or lines that only contain tiny font sizes, a ruler can specify minimal values for ascender (asc) and descender (dsc).
asc-, dsc-: INTEGER; (* (asc >= 0) & (dsc >= 0) *)
Figure 5-12. Ascender, descender, and base line
When created with TextRulers.dir.New(NIL), a ruler uses the current default font's (Fonts.dir.Default()) ascender and descender as initial values.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetAsc (r: Ruler; h: INTEGER)
PROCEDURE SetDsc (r: Ruler; h: INTEGER)
Paragraph lead
The paragraph lead defines the additional vertical space to be inserted between the first line of a paragraph and the previous paragraph's last line. Where the ruler's grid attribute (see below) is used to define a line grid, it is normally considered good style to choose a lead that is a multiple of the grid spacing, or sometimes half of the grid spacing. It allows to visually distinguish new paragraphs from mere carriage returns.
lead-: INTEGER; (* lead >= 0 *)
When created with TextRulers.dir.New(NIL), a ruler has a lead of 0.
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetLead (r: Ruler; h: INTEGER)
Line grid
If grid is zero, then lines are packed as closely as possible, so that there remains no free room between one line's descender and the next line's ascender. Different lines may have different ascenders and descenders, depending on the text and fonts that they contain. For this reason, distances between base lines need not be regular. For typographical reasons, irregular line spacing is often undesirable.
To ensure a more regular spacing of grid lines, it is possible to switch on a line grid, by setting grid to a value larger than zero. This value defines a vertical grid, onto which all base lines are forced. If a line is too high to fit on the next grid line, it is placed one or more grid distances further below (see Figure 5-14).
grid-: INTEGER; (* grid >= 0 *)
Figure 5-13. Line grid
When created with TextRulers.dir.New(NIL), a ruler has a line grid of 1.
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetGrid (r: Ruler; h: INTEGER)
Adjustment modes
For longer text stretches, it becomes necessary to break lines that don't fit between the text view's margins. This text setting may occur in several different ways. Text may be left adjusted (left flush), right adjusted (right flush), centered, or aligned to both left and right margins (full justification). These four adjustment modes can be controlled by two option flags: TextRulers.leftAdjust and TextRulers.rightAdjust.
leftAdjust rightAdjust adjustment mode
FALSE FALSE centered
FALSE TRUE right adjusted
TRUE FALSE left adjusted (default)
TRUE TRUE fully adjusted
Table 5-14. Adjustment modes
These adjustment modes can be included in or excluded from a more comprehensive option set, which is represented as a SET:
opts-: SET (* opts is subset of {leftAdjust, rightAdjust, pageBreak, rightFixed, noBreakInside, parJoin; the other set elements are reserved *)
When created with TextRulers.dir.New(NIL), a ruler's option set is {leftAdjust}.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetLeftFlush (r: Ruler)
PROCEDURE SetCentered (r: Ruler)
PROCEDURE SetRightFlush (r: Ruler)
PROCEDURE SetJustified (r: Ruler)
Page breaks
A ruler can force a page break, by including the TextRulers.pageBreak option element in the opts set.
The element TextRulers.noBreakInside is valid for the entire scope of a paragraph. As the name indicates, it forces the beginning of the paragraph to start on a new page, if this isn't the case anyway and if the page would be broken before the next paragraph.
The element TextRulers.parJoin is similar to noBreakInside, except that it additionally forces at least the first line of the next paragraph onto the same page.
When created with TextRulers.dir.New(NIL), a ruler has none of the above special attributes.
The following auxiliary proceduresare provided to modify a ruler:
PROCEDURE SetPageBreak (r: Ruler)
PROCEDURE SetNoBreakInside (r: Ruler)
PROCEDURE SetParJoin (r: Ruler)
This concludes our discussion of ruler attributes. Ruler attributes apply to the ruler, or to all the paragraphs in the ruler's scope. In contrast, character attributes apply to arbitrary stretches of characters. The BlackBox text model supports all font attributes plus color and vertical offsets.
Rulers are views that can be inserted into a text, since texts are containers. Rulers are special in that they are known to the text system, since a text view needs to know about a ruler's paragraph attributes when setting the text. However, arbitrary other views, which are not known to the text system, may be inserted into a text. Particularly interesting effects can be achieved when these views know about texts. Fold views and link views are examples of such text-aware views.
The following example shows how fold views can be generated. Fold views are standard objects of the BlackBox Component Builder; they are implemented in the StdFolds module, only using BlackBox and its Text subsystem. Fold views come in pairs: a left fold and a right fold. The left fold contains a hidden text. When the user clicks on one of the fold views, the text between the two views is swapped with the hidden text. Typically, fold views are used to hide a large text behind a short one; e.g., a book chapter may be hidden, while the chapter's name is visible. This is a way to achieve abstraction of document parts, by hiding details. For this reason, one state of a fold view is called its collapsed state, and the other is called its expanded state. Technically there is no reason why the hidden text should be longer than the visible one; the naming is more a reflection of the typical use of folds.
Figure 5-15. Fold views in collapsed and expanded states
Figure 5-16. Structure of text folds
MODULE ObxPDBRep3;
IMPORT Views, TextModels, TextMappers, TextViews, StdFolds, ObxPhoneDB;
PROCEDUREWriteOpenFold(VARf:TextMappers.Formatter;
INshortForm:ARRAYOFCHAR);
VAR fold: StdFolds.Fold; t: TextModels.Model;
BEGIN
t := TextModels.dir.NewFromString(shortForm); (* convert a string into a text model *)
fold := StdFolds.dir.New(StdFolds.expanded, "", t);
f.WriteView(fold)
END WriteOpenFold;
PROCEDUREWriteCloseFold(VAR f: TextMappers.Formatter);
VAR fold: StdFolds.Fold; len: INTEGER;
BEGIN
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
f.WriteView(fold);
fold.Flip; (* swap long-form text, now between the two fold views, with hidden short-form text *)
len := f.rider.Base().Length(); (* determine the text carrier's new length *)
f.SetPos(len) (* position the formatter to the end of the text *)
END WriteCloseFold;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
WriteOpenFold(f,name$); (* write left fold view into text, with name as its short-form text *)
(* now write the long-form text *)
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
WriteCloseFold(f); (* write closing fold, and swap short- and long-form texts *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep3.
Listing 5-17. Writing the phone database using folds
Procedure WriteCloseFold has two interesting properties. First, the fold is written in its expanded form. This is reasonable, since the expanded form is often more complex than the collapsed form, which thus can be used conveniently in WriteOpenFold (note the useful text directory procedure TextModels.dir.NewFromString). The collapsed version is more complex, and thus it is convenient to use the already existing text formatter. After the left fold view, the expanded text, and the right fold view have been written, the text is collapsed using the StdFolds.Flip procedure.
This leads us to the second interesting point. Collapsing the text modifies the text model. This invalidates all riders, and consequently all formatters, that operate on the text. For example, formatter f has always been at the end of the created text, but now that the text is collapsed, its position is beyond the end of the text and thus illegal. For this reason, the correct position is set up again.
This is a general observation when working with mutable carriers: whenever you modify a carrier's state (or whenever someone else may do so!) you possibly have to update some state of your riders. In this example, the text's length was modified, which made it necessary to update the formatter's position.
The last example in our series of demonstrations on how to generate texts uses link views. Link views are standard objects of the BlackBox Component Builder; they are implemented in the StdLinks module, only using BlackBox and its Text subsystem. Like fold views, link views are used in pairs. Their implementation uses a special interface of the text subsystem (TextControllers.FilterPollCursorMsg, TextControllers.FilterTrackMsg) to cause the cursor to turn into a hand cursor when it lies above the text stretch between the pair of link views. This behavior is known from typical hypertext systems, such as Web browsers, when the mouse is moved over a text stretch that symbolizes a hyperlink. This use of link views is what gave them their name. However, they are much more general than simple hyperlink delimiters. A hyperlink contains a passive reference to another document or to another location in the same document. For example, a document reference may be stored as a string, such as "http://www.oberon.ch" or "BlackBox/System/Rsrc/About".
Link views in contrast store a Component Pascal command, optionally with one or two string literals as parameters. The command is executed when the user clicks the mouse button when the mouse is between the two link views.
The command is stored in the left link view of a pair. Typical commands are:
DevDebug.ShowLoadedModules
StdCmds.OpenDoc('System/Rsrc/Menus')
StdCmds.OpenAux('System/Rsrc/About', 'About BlackBox')
In our example, we will create link views with commands similar to the following one:
ObxPDBRep4.Log('Daffy Duck310-555-1212')
Note: consult the documentation of module StdInterpreter, since there may be some restrictions on the possible parameter lists supported for such commands.
The Log procedure of our example module simply writes the parameter string to the log. In a more realistic example, the parameter string could be used to dial the respective number.
MODULE ObxPDBRep4;
IMPORT Views, TextModels, TextMappers, TextViews, StdLinks, StdLog, ObxPhoneDB;
CONST cmdStart = "ObxPDBRep4.Log('"; cmdEnd = "')";
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String; link:StdLinks.Link;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
link:=StdLinks.dir.NewLink(cmdStart+name+""+number+cmdEnd);
f.WriteView(link);
f.WriteString(name); (* the string shown between the pair of link views *)
link:=StdLinks.dir.NewLink("");
f.WriteView(link);
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
PROCEDURELog*(param:ARRAYOFCHAR);
BEGIN
StdLog.String(param); StdLog.Ln
END Log;
END ObxPDBRep4.
Listing 5-18. Writing the phone database using links
Note that commands are normal procedure calls; like all procedure calls from outside of a module, they can only call those procedures of the module that are exported. Thus procedure Log of the above module must be exported, otherwise the program wouldn't work.
Another interesting property of link views is that they display themselves in different ways depending on whether the text view via which the user interacts with them displays or hides marks. If there are several text views on the same model, the user can independently switch marks on or off, such as inactive soft hyphens, ruler views or link views. The text subsystem provides an interface which allows views to distinguish between the two states (TextSetters.Pref). In particular, a view may decide to hide itself when no marks are shown, by setting its width to zero in this case. This is what link views do: when text marks are switched off, they are invisible, so that only the text between them is visible. Typically, this text is blue and underlined, to indicate that it represents a link. A ruler in contrast always occupies the whole width between its paragraph's left and right margin, but it sets its height to zero when the text marks are turned off. We will learn more about how containers and embedded views can cooperate to achieve such effects in Part III of this tutorial.
The above example demonstrates that link views can cause arbitrary behavior when the user clicks between them. This generality is powerful, but it should be used with caution. A command in a document is a kind of "implicit import" relation between the document and the command's module, and thus constitutes a dependency. This is not fundamentally different from the dependencies that are caused by views embedded in the document, they also function correctly only when their implementing component(s) are available. Like all dependencies, those caused by links, buttons embedded in a control, editors embedded in documents, and so on also need to be tracked and updated when necessary.
5.2 The Model-View-Controller pattern applied to texts
The next major examples demonstrate how existing text can be read. It is assumed that the text to be processed is visible, in the topmost window. On how to access texts that are stored in files, please refer to the on-line Obx examples ObxOpen0, ObxOpen1, and ObxAscii. Before starting with the specifics of text reading, we need to discuss how the topmost window's contents can be accessed from within a Component Pascal command.
Basically, this is done by calling Controllers.FocusView(). This function returns NIL if no document is open. Otherwise it returns the topmost window's contents, which is a view.
We have learned earlier that views, whose common base type is Views.View, are the pivotal BlackBox abstractions for interactive components, such as editors and controls. Everything revolves around views. In simple cases, such as controls, a view implementation only implements an extension to Views.View, and that's all. In more complex cases, the data that are visualized by a view are split off into a separate model. This was discussed in detail in Chapter 2.
Since container implementations are among the most complex programming tasks for which the BlackBox Component Builder was designed, the framework provides some help in how a container should be constructed. The abstract design of a container is given in module Containers. This module declares extensions of the types Views.View, Models.Model and Controllers.Controller; these types constitute a mini-framework for container construction.
Typical containers are implemented in at least four modules: one for the model, one for the view, one for the controller, and one for standard commands. For example, the text subsystem contains the modules TextModels, TextViews, TextControllers, TextCmds; plus the auxiliary modules TextMappers, TextRulers and TextSetters. The form subsystem consists of FormModels, FormViews, FormControllers, and FormCmds.
Figure 5-19. Variations of the generic container module decomposition
We won't look at all the details of these types; but it is important to know that a container object is not only split into a model and one or several views, but that a view is further split into a view and a so-called controller. For the time being, we can regard the management of selections and carets as the main functionality that a controller encapsulates. This is why we now look at controllers, because some of the following examples will operate on the current selection.
Once you have a controller, you can obtain its view by calling its ThisView procedure. Other procedures allow to get or set the current selection.
There may be several views displaying the same model (many-to-one relationship), but there is exactly one controller per view (one-to-one relationship). (This holds for views derived from Containers.View; other views may or may not have a separate controller.)You can get a controller's view by calling its ThisView procedure, and you can get a container view's controller by calling its ThisController procedure.
Figure 5-20. Model-View-Controller separation
More specific container abstractions typically provide a suitable Focus function which yields the controller of the currently focused view, if there is one and if it has the desired type.
We now know enough about the container scenario that we can tell how to access focus view, model, or controller:
The following declarations are assumed:
VAR v: Views.View; m: Models.Model; c: Controllers.Controller;
Simple view:
v := Controllers.FocusView();
View with a model:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
Extension of a Containers.View:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
IF (v # NIL) & (v IS Containers.View) THEN
c := v(Containers.View).ThisController()
ELSE
c := NIL
END
Listing 5-21. Accessing focus view, model, and controller
Typical container abstractions, such as the Text and Form subsystems, use the above mechanisms to provide more convenient access functions tailored to the specific container type. For example, module TextControllers exports the function Focus, which returns the focus view's controller if and only if the focus view is a text view. Otherwise it returns NIL. This approach is appropriate, since once you have a container controller, you can easily access its view, its model, information about its selection or caret, and so on. The typical code pattern that arises is some subset of the following one, depending on the controller's parts that you need:
PROCEDURE SomeCommand*;
VAR c: TextControllers.Controller;
v: TextViews.View; t: TextModels.Model; from, to, pos: INTEGER;
...
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
...
v := c.ThisView(); (* if you need the text view... *)
...
t := v.ThisModel(); (* or if you need the text model... *)
...
IF c.HasSelection() THEN (* or if you need the selection range... *)
c.GetSelection(from, to);
...
END;
...
IF c.HasCaret() THEN (* or if you need the caret position... *)
pos := c.CaretPos();
...
END;
...
ELSE (* no open document window, or focus has wrong type *)
(* no error handling is necessary if this command is guarded by appropriate guard command *)
END
END SomeCommand;
Listing 5-22. Code pattern for TextControllers.Controller
A menu command can use the guard TextCmds.FocusGuard to make sure that the command is only executed when a text view is focus. TextCmds.SelectionGuard additionally checks whether there exists some (non-empty) text selection.
5.3 Reading text
Now that we have seen how to access the focus views' controller, we can write our first command that reads the focus view's text. The command counts the number of Latin-1 characters (1 byte), Unicode characters above Latin-1 (2 byte), and embedded views.
MODULE ObxCount0;
IMPORT TextModels, TextControllers, StdLog;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard for this command **)
VAR c: TextControllers.Controller; from, to, schars, chars, views: INTEGER;
rd: TextModels.Reader;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* get selection range; from < to *)
rd := c.text.NewReader(NIL); (* create a new reader for this text model *)
rd.SetPos(from); (* set the reader to beginning of selection *)
rd.Read; (* read the first element of the text selection *)
schars := 0; chars := 0; views := 0; (* counter variables *)
WHILE rd.Pos() # to DO (* read all elements of the text selection *)
IF rd.view # NIL THEN (* element is a view *)
INC(views)
ELSIF rd.char < 100X THEN (* element is a Latin-1 character *)
INC(schars)
ELSE (* element is Unicode character *)
INC(chars)
END;
rd.Read (* read next element of the text selection *)
END;
StdLog.String("Latin-1 characters: "); StdLog.Int(schars); StdLog.Ln;
StdLog.String("Unicode characters: "); StdLog.Int(chars); StdLog.Ln;
StdLog.String("Views: "); StdLog.Int(views); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount0.
Listing 5-23. Counting Latin-1 characters, Unicode characters, and views in a text
The above example uses a TextModels.Reader, which is the text rider type for reading. Each reader maintains a current position on its base text; there can be several independent readers on the same text simultaneously. A text reader has the following definition:
TYPE
Reader = POINTER TO ABSTRACT RECORD
eot: BOOLEAN;
attr: TextModels.Attributes;
char: CHAR;
view: Views.View;
w, h: INTEGER;
(rd: Reader) Base (): TextModels.Model, NEW, ABSTRACT;
(rd: Reader) Pos (): INTEGER, NEW, ABSTRACT;
(rd: Reader) SetPos (pos: INTEGER), NEW, ABSTRACT;
(rd: Reader) Read, NEW, ABSTRACT;
(rd: Reader) ReadChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT;
(rd: Reader) ReadPrev, NEW, ABSTRACT;
(rd: Reader) ReadPrevChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadPrevView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadPrevRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT
END;
Listing 5-24. Definition of TextModels.Reader
Given a text model text, a reader can be created by calling rd := text.NewReader(NIL). Such a newly allocated reader will be positioned at the beginning of the text; i.e., at rd.Pos() = 0. The position can be changed whenever necessary by calling rd.SetPos(pos), with pos in the range of 0..text.Length(). The reader's text model can be obtained by calling its Base procedure.
Reading of the next text element is done by calling the reader's Read procedure, which increases the reader's current position unless the end of text has been reached, in which case the reader's eot field is set. After Read is called, the character code of the read element can be found in the reader's char field. If the character value is less than 100X, the character fits in the Latin-1 range (1-byte character), otherwise it's a 2-byte Unicode character. For convenience, the auxiliary reader procedure ReadChar is provided, which performs a Read and returns the contents of char.
What happens if a view is read? In most cases, char is set to the reserved value TextModels.viewcode (2X). However, this is not necessarily the case. A text-aware view may choose to represent an arbitrary character code by using a special preference message (TextModels.Pref). In order to find out whether a view has been read, the field view should be tested. It returns the view just read, or NIL if it wasn't a view.
When a view has been read, the fields w and h indicate the size of the view in universal units. Otherwise, these fields are undefined.
It is expected that the implementation of a text model optimizes access to views. For this purpose, the auxiliary reader procedure ReadView is provided, which reads the next view after the current position, skipping as many non-view elements as necessary.
After an element (character or view) has been read, its text attributes are returned in the reader's attr field. The text attributes consist of font attributes, color and vertical offset; as described earlier. For efficiency and convenience reasons, the auxiliary reader procedure ReadRun is provided, which advances the reader position until the attributes change from their current setting. Text runs that have the same attributes can be drawn on the screen with one port procedure (Ports.Frame.DrawString), which is considerably faster than drawing them character by character.
Normally, text is read forward; from lower positions to higher positions. The reader procedures ReadPrev, ReadPrevView and ReadPrevRun are symmetrical to their Read, ReadView and ReadRun counterparts, but they read backwards. In particular, ReadPrevView is used by a text view's so-called text setter to find the most recent ruler view, which defines how the text must be set (The auxiliary procedure TextRulers.GetValidRuler implements this search.)
When one of the reading procedures has been called (whether one of the forward or one of the backward reading procedures), the reader's eot field is set. If an element could be read, eot is set to FALSE. If no element could be read (reading forward at the end of the text, or reading backward at the beginning of the text), eot is set to TRUE.
Typically, the following code pattern arises when working with a text reader. condition may be something like rd.Pos() # end or ~rd.eot.
VAR rd: TextModels.Reader; start: INTEGER;
BEGIN
... define start ...
rd := text.NewReader(NIL);
rd.SetPos(start); (* only necessary if start # 0 *)
rd.Read;
WHILE condition DO
... consume text element denoted by rd ...
rd.Read
END;
Listing 5-25. Code pattern for TextModels.Reader
The next example uses a text scanner. Scanners are reading text mappers; like formatters, they are defined in module TextMappers. Text scanners are similar to text readers, except that they operate on whole symbols rather than characters. Strings and numbers are examples of Component Pascal symbols that are supported by text scanners.
When you compare the definition of a TextMappers.Scanner with the one of TextModels.Reader, you'll note that a scanner can also return characters (field char) and views with their sizes (fields view, w, and h); that a scanner has a position (Pos, SetPos), but that a scanner cannot read backwards. Scan corresponds to a reader's Read procedure. It skips white space (blanks, carriage returns) until it either reaches the end of the text, which is signaled by setting type to TextMappers.eot, or until it has read a symbol. The type of symbol that was read is returned in type. It may be one of the TextMappers constants
char, string, int, real, bool, set, view, tab, line, para, eot, invalid.
By default, views and control characters are treated as white space and thus ignored. Using an option set (opts, SetOpts) it is possible to treat them as valid symbols, too. The set element TextMappers.returnViews indicates that views should be recognized, while TextMappers.returnCtrlChars indicates that the three control characters for tabulators (tab), carriage returns (line) and paragraphs (para) should be recognized.
When a symbol starts like a Component Pascal string or identifier, the scanner attempts to read a string. When successful, type is set to string; which may also be a short string, i.e., only containing Latin-1 characters. The option TextMappers.returnQualIdents lets the scanner recognize complete qualified identifiers as single symbols; e.g., the string ThisMod.ThatObj . The length of the string is returned in len.
If it is possible to interpret the symbol as an integer or real number, type is set accordingly, as are the fields int or real. Integer numbers are recognized in different number bases, the base that was recognized is returned in base (10 for decimal numbers).
Special characters such as !@#$ are interpreted as type = TextMappers.char, which may also be a short character, i.e., a Latin-1 character.
By default, Boolean values and sets are not interpreted, except if the option elements TextMappers.interpretBool or TextMappers.interpretSets are set. Sets use the normal Component Pascal syntax, while Booleans are represented as $TRUE and $FALSE.
The scanner field start is the position of the first character of the most recently read symbol. The fields lines and paras count the number of carriage return and paragraph characters since the last SetPos (see below).
The scanner's Skip procedure is an auxiliary procedure that advances the scanner position until all white space characters ђ as specified in the opts set ђ are skipped and the first character of the symbol has been read. This character is returned in Skip's ch parameter.
Since there may be an arbitrary number of specialized text mappers, in addition to the ones provided by TextMappers, the text model cannot create text mapper objects, like it creates text readers and writers. Instead, scanners (and formatters likewise) are connected to their texts explicitly, by calling their ConnectTo procedures. They may be called repeatedly to connect the same scanner to different models.
Scanner = RECORD
rider-: TextModels.Reader;
opts-: SET;
type: INTEGER;
start, lines, paras: INTEGER;
char: CHAR;
int, base: INTEGER;
real: REAL;
bool: BOOLEAN;
set: SET;
len: INTEGER;
string: TextMappers.String;
view: Views.View;
w, h: INTEGER;
(VAR s: Scanner) ConnectTo (text: TextModels.Model), NEW;
(VAR s: Scanner) Pos (): INTEGER, NEW;
(VAR s: Scanner) SetPos (pos: INTEGER), NEW;
(VAR s: Scanner) SetOpts (opts: SET), NEW;
(VAR s: Scanner) Scan, NEW;
(VAR s: Scanner) Skip (OUT ch: CHAR), NEW
END;
Listing 5-26. Definition of TextModels.Scanner
The following example uses a text scanner to count the number of integer numbers, real numbers, and strings found in a text.
MODULE ObxCount1;
IMPORT TextModels, TextMappers, TextControllers, StdLog;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard for this command **)
VAR c: TextControllers.Controller; from, to, ints, reals, strings: INTEGER;
s: TextMappers.Scanner;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* get selection range; from < to *)
s.ConnectTo(c.text); (* connect scanner to this text model *)
s.SetPos(from); (* set the reader to beginning of selection *)
s.Scan; (* read the first symbol of the text selection *)
ints := 0; reals := 0; strings := 0; (* counter variables *)
WHILE s.Pos() < to DO (* read all symbols starting in the text selection *)
IF s.type = TextMappers.int THEN (* symbol is an integer number *)
INC(ints)
ELSIF s.type = TextMappers.real THEN (* symbol is a real number *)
INC(reals)
ELSIF s.type = TextMappers.string THEN (* symbol is a string/identifier *)
INC(strings)
END;
s.Scan (* read next symbol of the text selection *)
END;
StdLog.String("Integers: "); StdLog.Int(ints); StdLog.Ln;
StdLog.String("Reals: "); StdLog.Int(reals); StdLog.Ln;
StdLog.String("Strings: "); StdLog.Int(strings); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount1.
Listing 5-27. Counting integers, reals, and strings in a text
The most typical code pattern for a scanner looks similar to the code pattern for a reader. condition may be something like s.Pos() < end or s.type # TextMappers.eot.
VAR s: TextMappers.Scanner; start: INTEGER;
BEGIN
... define start ...
s.ConnectTo(text);
s.SetPos(start); (* only necessary if start # 0 *)
s.Scan;
WHILE condition DO
IF s.type = TextMappers.int THEN
... consume s.int ...
ELSIF s.type = TextMappers.real THEN
... consume s.real ...
ELSIF ...
...
END;
s.Scan
END;
Listing 5-28. Code pattern for TextMappers.Scanner
5.4 Modifying text
In the previous sections, we have seen how new texts can be created using writers or formatters, and how existing texts can be read using readers or scanners. Many text commands first read a text stretch, perform some computation on it, and then replace it by the result of the computation. Examples are commands that set the font of a selection, set the color of a selection, or turn all small letters into capital letters.
The following example command reads the text selection and checks whether it is a string. If so, it interprets the string as a name and looks the name up in our example phone database. Then it replaces the name by the phone number.
MODULE ObxLookup0;
IMPORT TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard command **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* scanner has already read on character beyond string! *)
c.text.Delete(from, to); (* delete name *)
c.text.Insert(from, buf, 0, buf.Length()); (* move phone number from buffer into text *)
c.SetSelection(from, from + LEN(number$)) (* select the phone number *)
END
END
END Do;
END ObxLookup0.
Listing 5-29. Replacing a phone name by a phone number
The basic idea of the above command is that an auxiliary text object is used which acts as a buffer. The text selection is scanned, the scanned string is used as key to make a lookup in the phone database, the returned phone number is written into the buffer text, the original name is deleted from the text, and then the buffer contents is moved to where the name was. As a final step, the newly inserted text stretch is selected.
Note that the text model's Delete procedure shortens the text, while the Insert procedure makes the text longer. In particular, Insert doesn't overwrite existing text. Insert moves text, i.e., it removes them at the source and inserts them at the destination.
One way to make the above command more useful would be to accept a caret as input, instead of a selection. Then you could write a name and hit a keyboard shortcut for the command. The command then reads backwards from the caret position, until it finds the beginning of the name, and then substitutes the appropriate phone number for the name. This would be a simple way to implement keyboard macros.
Buffer texts, as used above, are particularly useful in helping to avoid screen flicker: since a buffer text is not displayed, it can be built up piecemeal, without causing any screen updates. When the buffer has been completed, its contents can be moved over to the visible destination text. This only causes one single screen update, which is fast and creates minimal flicker.
Moving text stretches from one text model to another one may be optimized if both text models have the same implementation. This is not necessarily the case, since different implementations of type TextModels.Model may coexist with each other. Two calls to TextModels.dir.New() may well return two text models that have different implementations.
For this reason, module TextModels exports the procedure Clone, which returns an empty text model of exactly the same type as its parameter. In fact, the standard text implementation even performs some further optimizations when a text model is cloned from another one, rather than allocated via TextModels.dir.New().
We can now give a (slightly simplified) definition of TextModels.Model:
TYPE
Model = POINTER TO ABSTRACT RECORD (Containers.Model)
(m: Model) NewWriter (old: TextModels.Writer): TextModels.Writer, NEW, ABSTRACT;
(m: Model) NewReader (old: TextModels.Reader): TextModels.Reader, NEW, ABSTRACT;
(m: Model) Length (): INTEGER, NEW, ABSTRACT;
(m: Model) Insert (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) InsertCopy (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) Delete (beg, end: INTEGER), NEW, ABSTRACT;
(m: Model) Append (m0: TextModels.Model), NEW, ABSTRACT;
(m: Model) Replace (beg, end: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) SetAttr (beg, end: INTEGER; attr: TextModels.Attributes), NEW, ABSTRACT;
END;
Listing 5-30. Definition of TextModels.Model
We have already met most of its procedures. InsertCopy is similar to Insert, but instead of moving, it copies a text stretch, without modifying the source. Delete removes a text stretch.
Insert, InsertCopy, and Delete are the elementary text operations. Append and Replace are provided for convenience and efficiency; they can be expressed in terms of the elementary operations:
dst.Append(src) dst.Insert(dst.Length(), src, 0, src.Length())
i.e., it moves the whole contents of the source text to the end of the destination text, thereby leaving an empty source text.
t.Replace(b, e, t1, b1, e1) t.Delete(b, e); t.Insert(b, t1, b1, e1)
i.e., it overwrites some part of the destination text by some part of the source text (which is thereby removed). Note that source and destination texts must be different.
SetAttr allows to set the text attributes of a whole text stretch.
5.5 Text scripts
When you have successfully applied the command ObxLookup0.Do to a text stretch, you can try out something that may surprise you: you can reverse ("undo") the operation by executing the Edit->Undo command! With Edit->Redo you can reverse the operation's reversal.
This capability is surprising because we have only implemented the plain Do procedure, but no code for undoing or redoing it. How come that the framework is able to undo/redo the operation anyway?
It is possible because the text model procedures which modify their model's state, such as Model.Delete and Model.Insert, are implemented in a particular way. They don't execute the modification directly. Instead, they create special operation objects and register them in the framework. The framework then can call the operation's appropriate procedure for performing the actual do/undo/redo functionality. This mechanism has been described in Chapter 3.
The following example shows how a sequence of text-modifying procedures is bracketed by BeginScript and EndScript to make the whole sequence undoable. BeginScript returns a script object, it gets the name of the compound operation as input.
MODULE ObxLookup1;
IMPORT Stores, Models, TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard command **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
script:Stores.Operation;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* scanner has already read on character beyond string! *)
Models.BeginScript(c.text,"#Obx:Lookup",script);
c.text.Delete(from, to); (* delete name *)
c.text.Insert(from, buf, 0, buf.Length()); (* move phone number from buffer into text *)
Models.EndScript(c.text,script);
c.SetSelection(from, from + LEN(number$)) (* select the phone number *)
END
END
END Do;
END ObxLookup1.
Listing 5-31. Example of a script (compound operation)
In Models.BeginScript, the name of the compound operation is given. It is mapped by the string mapping facility of BlackBox, because this name may be displayed to the user (in the undo/redo menu item).
In modules ObxLookup0 and ObxLookup1 use the following statement sequence to replace the name with the number:
c.text.Delete(from, to);
c.text.Insert(from, buf, 0, buf.Length());
To combine these two operations into a single compound operation (as experienced by the user), it was necessary to bracket the two calls with the BeginScript / EndScript pair. In this special case here, there actually would be a better solution:
c.text.Replace(from, to, buf, 0, buf.Length());
TextModels.Model.Replace is a powerful procedure of which Insert, Delete, and Append are special cases (provided for convenience):
t.Delete(beg, end) = t.Replace(beg, end, t, 0, 0)
t.Insert(pos, t0, beg, end) = t.Replace(pos, pos, t0, beg, end)
t.Append(t0) = t.Replace(t.Length(), t.Length(), t0, 0, t0.Length())
Note that InsertCopy cannot be expressed in terms of Replace:
t.InsertCopy(pos, t0, beg, end) # t.Replace(pos, pos, t0, beg, end)
The reason is that Replace, like Insert, deletes the source text. InsertCopy on the other hand is a pure copying operation which doesn't modify the source text (unless source and destination texts are identical and the destination position lies within the source text range).
5.6 Summary
We now conclude the discussion of the BlackBox Component Builder's Text subsystem. The goal of this tutorial was to give an overview over a relatively complex extension subsystem; to show the use of the previous part's design patterns; and to show the typical Text code patterns.
The treatment of the text subsystem cannot be complete, there are still many details for which the reference documentation of the various modules must be consulted. However, the general scope and typical applications should have become clearer. While we started with as little theory as possible and used simple examples only, the basic structure of a complex container subsystem will have become clearer by now.
Before we give a list of further on-line examples that you may want to study, here is a list of all standard modules of the Text subsystem (lowest module in the hierarchy first), with the most important types that they export:
module / type description
TextModels abstraction and default implementation of text models
Attributes attributes of a text elem (font, color, vertical offset)
Context link between a text model and a view embedded in it
Directory factory for text models
Model text carrier, factory for readers and writers
Reader rider for element-wise text reading
Writer rider for element-wise text writing
TextMappers abstraction and implementation of text mappers for Component Pascal symbols
Formatter mapper for symbol-wise text writing
Scanner mapper for symbol-wise text reading
TextRulers abstraction and default implementation for ruler views, which embody paragraph attributes
Attributes attributes of text ruler (tabs, margins, grid, etc.)
Directory factory for text rulers
Ruler view for rulers
Style model for rulers
TextSetters abstraction and default implementation for text setters, which perform line / page breaking
Directory factory for text setters
Reader text mapper which collects text into units of text setting
(non-breakable sequences) and determines their size
Setter object which implements a text setting algorithm
TextViews abstraction and default implementation of text views
Directory factory for text views
View view for text models
TextControllers abstraction and default implementation of text controllers
Controller controller for text views
Directory factory for text controllers
TextCmds command package with most important text commands
Table 5-32. Table of Text system modules and most important types
ObxHello0 write "Hello World" to log
ObxHello1 write "Hello World" to new text
ObxOpen0 open text document from a file, using standard file open dialog
ObxOpen1 modify a text document on a file, using standard file open and save dialogs
ObxCaps change string to uppercase, using compound operation
ObxDb manage sorted list of records
ObxTabs transform some tabs into blanks
ObxMMerge mail merge of template and database
ObxParCmd interpret text which follows a command button
ObxLinks create a directory text with hyperlinks
ObxAscii traditional text file I/O
Table 5-33. Additional Obx on-line examples of Text subsystem
| Docu/Tut-5.odc |
Part III: View Construction
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
6 View Construction
Views are the central abstraction in the BlackBox Component Builder. Everything revolves around views: most commands operate on views, windows display views, views can be internalized and externalized, views perform interaction with the user, and views may be embedded into other views.
6. 1 Introduction
This view programming tutorial consists of four sections, each of which introduces a special aspect of view programming. The section "message handling" (chapters 6.2 to 6.5) explains how the behavior of a view is defined through the view's message handlers, i.e., how the answering of preferences, controller messages and properties influences the view's relation to its environment and the view's reaction on user input. The second section explains the aspect of the model-view separation which allows multi view editing (6.6). The next section shows how the undo/redo facility of the BlackBox Component Framework can be used if the content of a view is changed with the help of operation objects (6.7). In the last section the special structure of all extensible BlackBox Component Framework modules is explained, namely the separation of the interface and the implementation of a view (6.8). Directory objects are the key to this design pattern.
6.2 Message handling
In this section, we present a sequence of increasingly more versatile implementations of a view object which displays a rectangular colored area. In particular, this view will handle Preferences, Controller messages and Properties.
Every view is a subtype of the abstract type Views.View. The concrete extension must at least implement the abstract procedure Views.Restore that draws the view's contents. The first example of our view simply draws a red rectangle. This version is about the simplest possible view implementation. Its major components are the declaration of a Views.View extension, the implementation of a Views.Restore procedure which draws the contents of the view, and a command procedure which allocates and initializes the view:
MODULE ObxViews0;
IMPORT Views, Ports;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews0.
To execute this program, invoke the following command:
"ObxViews0.Deposit; StdCmds.Open"
The result of this command is shown in Figure 6-1.
Figure 6-1: Result of "ObxViews0.Deposit; StdCmds.Open"
This simple program is completely functional already. The procedure ObxViews0.Deposit puts a newly allocated view into a system queue. The command StdCmds.Open in the command string above removes a view from this queue, and opens it in a new window. Note that whole sequences of commands must be enclosed between quotes, while for single commands the quotes may be omitted.
Instead of opening the view in a window, it could be pasted into the focus container (e.g., a text or a form):
"ObxViews0.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
Like StdCmds.Open, the command StdCmds.PasteView removes a view from the queue, but pastes it to the focus view. The above command sequence could also be used in a menu, for example.
Every document which contains an ObxViews0 view can be saved in a file, and this file can be opened again through the standard Open... menu entry. Our simple red rectangle will be displayed correctly in the newly opened document, provided the code file of the module ObxViews0 is available.
A view which has been opened in its own window can also be saved in a file. When opened again, the document then consists of this single view only.
Every view performs its output operations and mouse/keyboard polling via a Views.Frame object. In the above example, ObxViews0.View.Restore uses its frame parameter f to draw a string. A frame can be regarded as a mapper object, in this case for both input and output simultaneously (here we need not be interested in the rider and carrier for this mapper, which are both defined in module Ports). A frame embodies coordinate transformations and clipping facilities.
If the view is displayed on the screen, the frame is a mapper on a screen port. If the view is printed, the frame is a mapper on a printer port. From the view's perspective, this difference is not relevant. Thus no special code is necessary to support printing.
The view may be copied and pasted into containers such as text views or form views. Additionally, the size of the view can be changed by selecting it and then manipulating the resize handles. All this functionality is offered by the BlackBox Component Framework and requires no further coding. If this default behavior is not convenient, it can be modified. In the following we will show how this is done.
6.3 Preference messages
You might have noticed that the size of a newly opened view is rather arbitrary. However, before opening the view, the framework sends the view a message with a proposed size. The view may adapt this proposal to its own needs. To do that, the message of type Properties.SizePref must be answered in the view's HandlePropMsg procedure. Before a view is displayed for the first time, the proposed size for the width and the height of the view is Views.undefined. The following version of our sample view draws a rectangle with a width of 2 cm and a height of 1 cm. Changes compared to the previous version are written in bold face.
MODULE ObxViews1;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
END
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews1.
"ObxViews1.Deposit; StdCmds.Open"
Every newly generated view now assumes the desired predefined size. This is only possible because the view and its container cooperate, in this case via the Properties.SizePref message. A container is expected to send this message whenever it wants to change a view's size, and then adhere to the returned data. However, for the understanding of the BlackBox Component Framework it is essential to know that while a well-behaved container should follow this protocol, it is not required to do so. That's why such a message is called a preference. It describes merely a view's preference, so that the surrounding container can make allowances for the special needs of the view. But it is always the container which has the last word in such negotiations. For example, the container will not let embedded views become larger than itself. The standard document, text, and form containers are well-behaved in that they support all preferences defined in module Properties. Special containers, e.g. texts, may define additional preferences specific to their type of contents. It is important to note that a view can ignore all preferences it doesn't know or doesn't care about.
The Properties.SizePref allows us to restrict the possible values for the width and the height of a view. For example, we can enforce a minimal and a maximal size, or fix the height or width of the view, or specify a constraint between its width and height. The procedures Properties.ProportionalConstraint and Properties.GridConstraint are useful standard implementations to specify constraints. The next version of our view implementation specifies that the rectangle is always twice as wide as it is high. In addition, minimal and maximal values for the height (and thus also for the width) are specified. If the view is resized using the resize handles, the constraints are not violated. Try it out!
MODULE ObxViews2;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews2.
"ObxViews2.Deposit; StdCmds.Open"
We will look at two other preferences in this tutorial. The first one is Properties.ResizePref.
TYPE
ResizePref = RECORD (Properties.Preference)
fixed,
horFitToPage, verFitToPage,
horFitToWin, verFitToWin: BOOLEAN (* OUT *)
END;
The receiver of this message may indicate that it doesn't wish to be resized, by setting fixed to TRUE. As a consequence, the view will not display resize handles when it is selected, i.e., it cannot be resized interactively. However, the Properties.SizePref message is still sent to the view, as the initial size still needs to be determined.
If a view is a root view, i.e., the outermost view in a document or window (e.g., if opened with StdCmds.Open), then the size of the window, the size of the view, or both might be changed.
However, sometimes it is convenient if the view size is automatically adapted whenever the window is resized, e.g., for help texts which should use as much screen estate as possible. For other views, it may be preferable that their size is not determined by the window, but rather by their contents, or by the page setup of the document in which they are embedded. A view can indicate such preferences by setting the horFitToWin, verFitToWin, horFitToPage, and verFitToPage flags in the Properties.SizePref message. These flags have no effect if the view is not a root view, i.e., if it is embedded deeper inside a document.
An automatic adaptation of the view size to the actual window size can be achieved by setting the fields horFitToWin and verFitToWin. The size of the view is then bound to the window, i.e., the user can change it directly by resizing the window.
Note that if the size of the view is bound to the size of the window (either by setting horFitToWin or verFitToWin), then no Properties.SizePref messages are sent to the view, i.e., the constraints specified through Properties.SizePref are no longer enforced. Additionally, the view does not display resize handles, regardless of the fixed flag.
By setting the fields horFitToPage or verFitToPage, the width or the height of the view can be bound to the actual printer page size. The width of a text view is usually bound to the width of the page size, and can be changed via the page setup mechanism of the underlying operating system. The following example enforces that the size of a root view is bound to the size of the window:
MODULE ObxViews3;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews3.
"ObxViews3.Deposit; StdCmds.Open"
The next preference we look at is Properties.FocusPref.
TYPE
FocusPref = RECORD (Properties.Preference)
atLocation: BOOLEAN; (* IN *)
x, y: INTEGER; (* IN *)
hotFocus, setFocus, selectOnFocus: BOOLEAN (* OUT *)
END;
When an attempt is made to activate an embedded view, by clicking in it, then the Properties.FocusPref message is sent to the view. If this message is not answered the view is selected as a whole (a so-called singleton). This is the behavior of the views implemented in the examples above. To see this, place the caret on the next line and click on the commander below, then on the pasted view:
"ObxViews3.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
This behavior is adequate if a view is passive. However, if the view contains editable contents, or if there are menu commands that operate on the view, the user should be able to focus the view. The focus is where keyboard input is sent to, where the current selection or caret are displayed (if there are any such marks), and where upon some menu commands operate. In fact, menus can be made to appear whenever a view is focused, and disappear as soon as the view loses focus (more on this below). A root view is always focused when its document window is focus (i.e., is the top window).
If an embedded view wants to become focus, it must answer the Properties.FocusPref message. The view can choose whether it wants to become focus permanently or if it wants only be focus as long as the mouse button is pressed. The latter is called a hot focus. A typical example of a hot focus is a command button. If a view wants to be a hot focus, it must set the flag hotFocus. The focus is then released immediately after the mouse is released. If a view wants to become focus permanently, then the flag setFocus must be set instead. setFocus should be set for all genuine editors, such that context-sensitive menu commands can be attached to the view. In addition to the setFocus flag, a view may set the selectOnFocus flag to indicate that upon focusing by keyboard, the view's contents should be selected. Text entry fields are prime examples for this behavior: the contents of a newly focused text entry field is selected, if the user focused it not by clicking in it, but by using the tabulator key.
If the user clicks in an unfocused view, then the atLocation flag is set by the framework before sending the message. The receiving view may decide whether to become focused depending on where the user clicked. The mouse position is passed to the view in the focus preference's x and y fields. Text rulers are examples of views which become focused depending on the mouse location. If you click in the icons or in the area below the scale of a ruler, the ruler is not focused. Otherwise it is focused. Try this out with the ruler below. If you don't see a ruler, execute the Show Marks command in the Text menu.
A view is not necessarily focused through a mouse click. In forms for example, the views can be selected using the tabulator key. There, the views do not become focused through a mouse click, and the atLocation field is accordingly set to FALSE by the framework.
The next version of our example will answer the FocusPref message and set the setFocus flag. This is done by adding the following statements to the previous example's HandlePropMsg procedure:
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
If an embedded view is focused, the frame of the view is marked with a suitable focus border mark, and view-specific menus may appear while others disappear.
6.4 Controller messages
Other messages that may be interpreted by HandlePropMsg will be discussed later. Next we will see how a view can react on user input, e.g., on mouse clicks in the view or on commands called through a menu. For simple views this behavior is implemented in the procedure Views.HandleCtrlMsg. It is also possible to define a separate object, a so-called controller, that implements the interactive behavior of a view. Programming of controller objects is not described in this document, since controllers are only recommended for the most complex views.
TheViews.HandleCtrlMsg handler answers the controller messages sent to the view. A controller message is a message that is sent along exactly one path in a view hierarchy, the focus path. Every view on the focus path decides for itself whether it is the terminal of this path, i.e., whether it is the current focus, or whether the message should be forwarded to one of its embedded views. It is important to note that all controller messages which are not relevant for a particular view type can simply be ignored.
In order to be able to perform edit operations on the focus view, the framework must allow to somehow perform these operations. Mouse clicks and key strokes can always be issued. However, how the menus should look like may be decided by the view itself. For that purpose, the message Controllers.PollOpsMsg is sent to the view. Depending on its current state (e.g., its current selection) and depending on the contents of the clipboard, the focus view can inform the framework of which editing operations it currently supports. The valid operations are elements of the {Controllers.cut, Controllers.copy, Controllers.paste, Controllers.pasteView} set.
TYPE
PollOpsMsg = RECORD (Controllers.Message)
type: Stores.TypeName; (* OUT *)
pasteType: Stores.TypeName; (* IN *)
singleton: Views.View; (* OUT *)
selectable: BOOLEAN; (* OUT *)
valid: SET (* OUT *)
END;
The set of valid edit operations is returned in the valid field, where valid IN {Controllers.cut, Controllers.copy, Controllers.paste}. According to the set of valid operations, the corresponding menu entries in the Edit menu are enabled or disabled, e.g., Cut, Copy, Paste and PasteObject... (Windows) / Paste as Part (Mac OS). The field pasteType contains the concrete type of the view from which a copy would be pasted, if a paste operation occurred. Depending on this field, the view could decide whether it wants to support the paste operation or not. PollOpsMsg is sent when the user clicks in the menu bar. Its sole purpose is to enable or disable menu items, i.e., to provide user feedback.
If a view supports a selection of its contents, then selectable must be set to TRUE. As a consequence, the menu entry SelectAll will be enabled. The flag should be set regardless of whether a selection currently exists or not.
In the type field a type name may be passed. This name denotes a context for the focus view. This context is used to determine which menus are relevant for the focus view. As a convention, a view assigns the type name of its interface base type to type, e.g. "ObxViews4.View". A menu which indicates to be active on "ObxViews4.View" will be displayed if such a view is focus. The type name is used because it is easy to make unique, so that name collisions are avoided. The framework doesn't interpret the name.
The singleton field is only meaningful for container views. It denotes a container's currently selected view, if the selection consists of exactly one embedded view.
The following example view can become focus, supports the paste operation, and informs the framework that its contents is selectable. As a consequence, the menu entries Paste and Select All in the Edit menu are enabled. Additionally, it defines the context "Obx.Tutorial". Therefore the following menu appears whenever the view is focused; provided that the menu has been installed.
Note that the name of the context, in this case "Obx.Tutorial", by convention starts with the subsystem or a module name followed by a dot, in this case "Obx.". This is highly recommended, in order to make context names globally unique. Often, the name is simply the name of a view type, e.g., "TextViews.View".
A menu can either be defined in the global menu text System/Rsrc/Menus, or more appropriately in its own subsystem's menu text, in this case in Obx/Rsrc/Menus . The global menu text then only needs an INCLUDE "Obx" statement to make the Obx menus known.
MENU "New" ("Obx.Tutorial")
"Beep" "" "Dialog.Beep" ""
END
MODULE ObxViews4;
IMPORT Views, Ports, Properties, Controllers;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message; VAR focus: Views.View);
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews4.
"ObxViews4.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
Next we discuss how a view can react on actual edit messages. In particular, these are the Controllers.EditMsg for edit operations such as cut, copy, or paste, and the Controllers.TrackMsg for mouse clicks.
Whenever a key is pressed in a view or when a cut, copy or paste operation is invoked, a Controllers.EditMsg is sent to the focus view. The cut, copy and paste operations can only be generated through the environment (menu) if they have been announced with the Controllers.PollOpsMsg.
TYPE
EditMsg = RECORD (Controllers.RequestMessage)
op: INTEGER; (* IN *)
modifiers: SET; (* IN *)
char: CHAR; (* IN *)
view: Views.View; (* IN for paste, OUT for cut and copy *)
w, h: INTEGER; (* IN for paste, OUT for cut and copy *)
isSingle: BOOLEAN; (* IN for paste, OUT for cut and copy *)
clipboard: BOOLEAN (* IN *)
END;
The op field specifies which kind of operation has to be performed. If op = Controllers.cut then a copy of the focus view has to be generated. The contents of the new view is a copy of the focus view's selection. The new view is assigned to the view field. In addition, the selection is deleted in the focus view.
There is one special case: if the selection consists of exactly one view (a singleton), then a copy of the singleton should be copied to the view field, not a copy of the singleton's container. In this case, isSingle must be set to TRUE.
Except for the deletion of the selection, the same operations have to be performed if op = Controllers.copy.
If a key is pressed, then the op field has the value Controllers.pasteChar. The character to be pasted is stored in the char field. The modifiers set indicates whether a modifier or control key has been pressed. In the latter case, the char field has to be interpreted as a control character.
The paste operation is the inverse of the copy operation: a copy of the contents of the view stored in the view field has to be copied into the focus view's contents. This operation is indicated by op = Controllers.paste. The view must know the type of the view whose contents is to be pasted and must decide how to insert the pasted view's contents into its own view. For example, a text field view should support copying from a text view only.
If isSingle is TRUE, or if the contents of view cannot be pasted because it has an unknown or incompatible type, a copy of view must be pasted. Of course, this is only possible in general containers, which allow the embedding of other views.
When pasting a complete view, the desired width and height of the pasted view are given in the fields w and h. These values can be treated as hints by the receiving view. If they are not suitable, others can be used.
Whenever the mouse button is pressed in the focus view, a Controllers.TrackMsg is sent to the view. The coordinates are specified in the x and y fields (of the base type Controllers.CursorMessage). The modifiers set indicates whether modifier keys have been pressed, or whether a double click has been performed. modifiers IN {Controllers.doubleClick, Controllers.extend, Controllers.modify}. If the view wants to show a feedback while tracking the mouse, it needs to poll the mouse position in a loop, by calling the Input procedure of the passed frame. Input also returns information on whether the mouse has been released. Any feedback should directly be drawn into the frame in which the mouse button was pressed.
After the feedback loop, a possible modification of the view's contents need to be broadcast to all the frames that display the same view. Remember that the same document, and consequently all its embedded views, may be displayed in several windows (see Chapter 2). If an embedded view is visible in three windows, there exist three frames displaying the same view. Procedure Views.Update causes a restore of the view once in each of its visible frames.
As an example, we extend our view with a cross-hair marker that can be moved around. The coordinates of this marker are stored as additional fields in the view object. Note that if a view contains instance variables, it should implement the CopyFromSimpleView, Internalize and Externalize procedures in order to work properly. We refer to the next section of this view tutorial, which describes the purpose of these messages. In our example view, the marker can be moved around with the mouse, or through the cursor keys. When a cursor key is pressed, the focus view is informed by sending it an EditMsg with op = pasteChar.
From time to time a Controllers.PollCursorMsg is sent to the focus view. The view may set the form of the cursor depending on the coordinates of the mouse. The cursor field can be assigned a cursor out of {Ports.arrowCursor, Ports.textCursor, Ports.graphicsCursor, Ports.tableCursor, Ports.bitmapCursor}. The particular form of the cursor depends on the underlying operating system. In our example view, we set the cursor to a graphics cursor.
MODULE ObxViews5;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y,
0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* cursor keys *)
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y;
v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; Views.Deposit(v)
END Deposit;
END ObxViews5.
"ObxViews5.Deposit; StdCmds.Open"
There exist many other controller messages which may be sent to a view, but which are beyond the scope of this tutorial. There are messages for the generic scrolling mechanism of the BlackBox Component Framework (Controllers.PollSectionMsg, Controllers.ScrollMsg, Controllers.PageMsg), messages which implement drag & drop (Controllers.PollDropMsg, Controllers.DropMsg, Controllers.TransferMessage) and messages which control the selection (Controllers.SelectMsg). For these and other controller messages we refer to the documentation of the Controllers module.
6.5 Properties
We want to close this section with a final extension of our view: the color of the view should be changeable through the Attributes menu. The general mechanism to get and set attributes of a view from its environment are properties. A view may know about attributes such as font, color, size, but it may also know about arbitrary other attributes. Properties are set with the Properties.SetMsg and inspected with the Properties.PollMsg. Properties in one of these messages are stored in a linked list. If a view gets a Properties.SetMsg it should traverse its property list and adjust those properties it knows about. A Properties.GetMsg is sent to the view to get its properties. The view should return all properties it knows about. Properties can be inserted into a message's property list with the Properties.Insert procedure.
Every property describes up to 32 attributes. The known set defines which attributes are known to the view. The view may also specify which attributes are read-only in the readOnly set. The valid set finally defines which attributes currently have a defined value. For example, if in a text several characters with different sizes are selected, then the attribute size is known to the view, but currently does not have a valid value. The selection is not homogeneous, and thus there is no single valid value.
TYPE
Property = POINTER TO ABSTRACT RECORD
next-: Properties.Property;
known, readOnly, valid: SET; (* valid and readOnly are subsets of known *)
(p: Property) IntersectWith (q: Properties.Property; OUT equal: BOOLEAN), NEW, ABSTRACT
END;
A special property is Properties.StdProp. This property encompasses font attributes as well as color, and it is known to the BlackBox environment. The supported attributes are Properties.color, Properties.typeface, Properties.size, Properties.style, Properites.weight. The fields in the property record hold the corresponding values.
TYPE
StdProp = POINTER TO RECORD (Properties.Property)
color: Dialog.Color;
typeface: Fonts.Typeface;
size: INTEGER;
style: RECORD
val, mask: SET
END;
weight: INTEGER
END;
The last version of our view only support the color attribute of the standard property. If it receives a Properties.PollMsg message, it returns a Properties.StdProp object where only the color field is set, and where only the color attribute is defined as known and valid. On a Properties.SetMsg, the property list must be searched for a standard property whose color field is valid. When the color has been changed, the view must be updated in all its frames.
MODULE ObxViews6;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER;
c: Ports.Color
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, v.c);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y, 0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
VAR stdProp: Properties.StdProp; prop: Properties.Property;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
| msg: Properties.PollMsg DO
NEW(stdProp);
stdProp.color.val := v.c;
stdProp.valid := {Properties.color};
stdProp.known := {Properties.color};
Properties.Insert(msg.prop, stdProp)
| msg: Properties.SetMsg DO
prop := msg.prop;
WHILE prop # NIL DO
WITH prop: Properties.StdProp DO
IF Properties.color IN prop.valid THEN v.c := prop.color.val END
ELSE
END;
prop := prop.next
END;
Views.Update(v, Views.keepFrames)
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y; v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; v.c := Ports.black; Views.Deposit(v)
END Deposit;
END ObxViews6.
"ObxViews6.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
6.6 Model-View separation
In this section, we present a sequence of five increasingly more versatile versions of a view object which displays a string that may be typed in by the user. This string represents the view-specific data which it displays. We will see that multi-view editing is possible if this string is represented by a separate model object.
Let us start with a first version of this view, where the string is stored in the view itself. Every view displays its own string. A string's length is limited to 255 characters, but no error handling is performed in the following demonstration programs.
MODULE ObxViews10;
IMPORT Fonts, Ports, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* accept typing *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* append character to string *)
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews10.
"ObxViews10.Deposit; StdCmds.Open"
As described in the last section, a character typed in is sent to the view in the form of a controller message record (Controllers.Message), to be handled by the view's HandleCtrlMsg procedure. This procedure is called with a Controllers.EditMsg as actual parameter when a character was typed in, and it reacts by inserting the character contained in the message into its field s. Afterwards, it causes the view to be restored; i.e., wherever the view is visible on the display it is redrawn in its new state, displaying the string that has become one character longer.
In the above example, a view contains a variable state (the view's string field s). This state should be saved when the window's contents are saved to disk. For this purpose, a view provides two procedures, called Internalize and Externalize, whose uses are shown in the next iteration of our example program:
MODULE ObxViews11;
(* Same as ObxViews10, but the view's string can be stored and copied *)
IMPORT Fonts, Ports, Stores, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(v.i); rd.ReadString(v.s)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(v.i); wr.WriteString(v.s)
END Externalize;
PROCEDURE (v: View) CopyFromSimpleView (source: Views.View);
BEGIN
WITH source: View DO
v.i := source.i; v.s := source.s
END
END CopyFromSimpleView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* accept typing *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* append character to string *)
Views.SetDirty(v); (* mark view's document as dirty *)
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews11.
A few comments about View.Internalize and View.Externalize are in order here: First, the two procedures have a reader, respectively a writer, as variable parameters. These file mappers are set up by BlackBox itself; a view simply uses them.
Second, View.Internalize must read exactly the same (amount of) data that View.Externalize has written.
Third, a user interface typically defines some visual distinction for documents that contain modified views, i.e., for "dirty" documents. Or it may require that when the user closes a dirty document, he or she should be asked whether to save it or not. In order to make this possible, a view must tell when its contents has been modified. This is done by the Views.BeginModification /Views.EndModification calls.
In addition to View.Internalize and View.Externalize, the above view implementation also implements a CopyFromSimpleView procedure. Such a procedure should copy the view's contents, given a source view of the same type. CopyFromSimpleView should usually have the same effect as if the source's contents were externalized on a temporary file, and then internalized again by the destination view. There can be exceptions, though. For example, a text copies even temporary embedded views such as error markers, but it doesn't externalize them.
A view that contains (mutable) state should implement CopyFromSimpleView, so that it can be printed. The reason that this is necessary is that the framework makes a shallow copy of a view that is being printed, in order to avoid the original view to be changed by pagination, scrolling, or similar modifications that may be performed during printing.
Basically, ObxViews11 has shown most of what is involved in implementing a simple view class. Such simple views are often sufficient; thus it is important that they are easy to implement. However, there are cases where a more advanced view design is in order. In particular, if a window normally can only display a small part of a view's contents, multi-view editing should be supported.
Multi-view editing means that there may be several views showing the same data. The typical application of this feature is to have two or more windows displaying the same document, each of these windows showing a different part of it in its own view. Thus, if a view's data has been changed, it and all the other affected views must be notified of the change, such that they can update the display accordingly.
The following sample program, which is the same as the previous one except that it supports multi-view editing, is roughly twice as long. This indicates that the design and implementation of such views is quite a bit more involved than that of simple views. It is a major design decision whether this additional complexity is warranted by its increased convenience.
MODULE ObxViews12;
(* Same as ObxViews11, but uses a separate model for the string *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
(* Model *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* View *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View;
model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR m: Model; umsg: Models.UpdateMsg;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
m := v.model;
m.s[m.i] := msg.char; INC(m.i);
m.s[m.i] := 0X; (* append character to string *)
Views.SetDirty(v); (* mark view's document as dirty *)
Models.Broadcast(m, umsg) (* update all views on this model *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews12.
"ObxViews12.Deposit; StdCmds.Open"
Multi-view editing is realized by factoring out the view's data into a separate data structure, called a model. This model is shared between all its views, i.e., each such view contains a pointer to the model:
Figure 6.2: Two Views on one Model
A model is, like a view, an extension of a Stores.Store, which is the base type for all persistent objects. Stores define the Internalize and Externalize procedures we've already met for a view. In ObxViews12, the model stores the string and its length, while the view stores the whole model! For this purpose, a Stores.Writer provides a WriteStore and a Stores.Reader provides a ReadStore procedure.
Stores may form arbitrary graphs. For example, one or several views may refer to the same model, both models and views are store extensions. A graph of stores that may be saved in a file is called a document. In order to recognize the boundary of a document upon externalization, stores are bound to a domain. All stores of a document refer to the same domain object (Stores.Domain).
Domains are also used as containers for operations, i.e., commands performed on some store which can be undone and redone (see next chapter). The operation history is associated with a domain. Furthermore, domains define the set of objects which get notified in a broadcast (either Views.Broadcast, Views.Domaincast or Models.Broadcast).
For more information on stores and domains, see the on-line documentation of module Stores.
Now that the model is separated from the view, copying is done by the model, not by the view anymore.
View.ThisModel returns the model of the view. Its default implementation returns NIL, which should be overridden in views that contain models. This procedure is used by the framework to find all views that display a given model, in order to implement model broadcasts, as described in the next paragraph.
Views with a model implement the procedure View.CopyFromModelView instead of View.CopyFromSimpleView. Like Internalize and Externalize, CopyFromSimpleView and CopyFromModelView are exported as implement-only procedures, i.e., they can only be implemented, but not called. They are called internally in module Views, in its CopyOf and CopyWithNewModel functions.
When a model changes, all views displaying it must be updated. For this purpose, a model broadcast is generated: A model broadcast notifies all views which display a particular model about a model modification that has happened. This gives each view the opportunity to restore its contents on the screen. A model broadcast is generated in the View.HandleCtrlMsg procedure by calling Models.Broadcast. The message is received by every view which contains the correct model, via its View.HandleModelMsg procedure.
This indirection becomes important if different types of views display the same model, e.g., a tabular view and a graphical view on a spreadsheet model; and if instead of restoring the whole view ђ as has been done in our examples ђ only the necessary parts of the views are restored. These necessary parts may be completely different for different types of views.
A very sophisticated model may be able to contain ("embed") arbitrary views as part of its contents. For example, a text view may display a text model which contains not only characters (its intrinsic contents), but also graphical or other views flowing along in the text stream.
The combination of multi-view editing and hierarchical view embedding can lead to the following situation, where two text views show the same text model, which in turn contains a graphics view. Each text view lives in its own window and thus has its own frame. The graphics view is unique however, since it is embedded in the text model, which is shared by both views. Nevertheless the graphics can be visible in both text views simultaneously, and thus there can be two frames for this one view:
Figure 6-3: Two Frames on one View
As a consequence, one and the same view may be visible in several places on the screen simultaneously. In this case, this means that when the view has changed, several places must be updated: the view must restore the necessary area once for every frame on this view. As a consequence, a notification mechanism must exist which lets the view update each of its frames. This is done in a similar way as the notification mechanism for model changes: with a view broadcast. Fortunately, there is a standard update mechanism in the framework which automatically handles this second broadcast level (see below).
We now can summarize the typical events that occur when a user interacts with a view:
Controller message handling:
1) Some controller message is sent to the focus view.
2) The focus view interprets the message and changes its model accordingly.
3) The model broadcasts a model message, describing the change that has been performed.
Model message handling:
4) Every view on this model receives the model message.
5) It determines how its display should change because of this model modification.
6) It broadcasts a view message, describing how its display should change.
View message handling:
7) The view receives the view notification message once for every frame on this view.
8) Every time, the view redraws the frame contents according to the view message.
This mechanism is fundamental to the BlackBox Component Framework. If you have understood it, you have mastered the most complicated part of a view implementation. Interpreting the various controller messages, which are defined in module Controllers, is more a matter of diligence than of understanding difficult new concepts. Moreover, you only need to interpret the controller messages in which you are interested, because messages that are not relevant can simply be ignored.
Usually, steps 6, 7, and 8 are handled automatically by the framework: the view merely calls Views.Update if a whole view should be updated, or Views.UpdateIn if some rectangular part of the view should be updated. Calls of these update procedures cause a lazy update, i.e., the framework adds up the region to be updated, but does not immediately cause any redrawing. Instead, the command first runs to completion, so that all data structures of the modified views are consistent again. Only the display of the views is still the same as before the command. But then the framework restores all views that have been marked for update. This means that for every frame that displays a view, the view's Restore method is called with this frame as argument. If the view is displayed in two (or more) frames in different windows, it is restored two (or more) times; once for every frame. When the framework starts restoring frames of a window, it temporarily redirects the drawing operations of a port into a background pixelmap buffer. When all frames of this window that need updating have been restored, the framework copies the pixelmap buffer to the screen pixelmap, and turns off the redirection of drawing operations.
The effect of this buffering mechanism and of the lazy update mechanism is that minimal flickering occurs. The lazy update mechanism (also used by Apple for the Mac OS, and by Microsoft for Windows) means that even for complex editing operations, a given screen region is only restored once. This can reduce flickering, since flickering can occur when the same area is drawn several times in rapid succession. The buffering mechanism reduces flickering if drawing occurs in layers, from "bottom" to "top" (because this also means drawing several time in rapid succession). For example, you may first draw the background in one color, and then the a filled rectangle on top of it in another color. Thanks to the buffering mechanism, the user never sees the situation after the background is drawn, but before the rectangle is drawn.
The lazy update mechanism also has another advantage: it completely decouples the modification of a model from its drawing. Without this mechanism, it can become rather difficult to correctly perform screen updates for complex editing operations. For example, consider moving a selection of graphics objects in a graphics editor. The selected objects first must be deleted at their old position, this may mean that other objects that have been obscured by the selection now need to be drawn (but not the selected objects themselves!). Then the objects' positions are changed, and then they are redrawn at their new positions (if the source and target positions overlap, drawing has now happened twice). Drawing may have to be done several times, if there are several windows displaying the same data. But of course the change of object positions must only occur once. It is much less tricky to simply call Views.UpdateIn for all rectangles that (may) need updating, and to let the framework call the necessary Restore methods later!
Normally, the lazy update mechanism is sufficient. Thus a view programmer needs to use explicit view messages only if no complete restore in all frames of a view is desired. This is the case only for marks like selection, focus, or carets, or for rubberbanding or similar feedback effects during mouse tracking. Such marks can sometimes be handled more efficiently because they are involutory: applied twice, they have no effect. Thus marks are often switched on and off through custom view messages during a command, not through the delaying lazy update mechanism. But except for such light-weight marks, you should always use the lazy update mechanism described above. Note that there exists a method Ports.Frame.MarkRect explicitly for drawing such marks.
6.7 Operations
Now that we have seen the crucial ingredients of a view implementation, a less central feature can be presented. The next program is a variation of the above one, in which a controller message is not interpreted directly. Instead, an operation object is created and then executed. An operation provides a do / undo / redo capability, as shown in the program below.
The operation we define in this example is the PasteCharOp. The operation's Do procedure performs the desired modification, and must be involutory, i.e. when called twice, its effect must have been neutralized again. We use the flag PasteCharOp.do to specify whether the character PasteCharOp.char has to be inserted into or removed from the model PasteCharOp.m. In any case, the Do procedure has to update all views on the model PasteCharOp.m with a model broadcast.
The procedure NewPasteCharOp generates a new operation and the procedure Models.Do executes this operation, i.e., the operation's Do procedure is called and the operation is recorded for a later undo. The name of the operation as specified in the Models.Do command will appear in the Edit menu after the Undo or Redo entry respectively.
MODULE ObxViews13;
(* Same as ObxViews12, but generate undoable operations for character insertion *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: Model;
char: CHAR;
do: BOOLEAN
END;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: Model; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do operation's transformation *)
m.s[m.i] := op.char; INC(m.i) (* insert character into string *)
ELSE (* undo operation's transformation *)
DEC(m.i) (* remove character from string *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* toggle between "do" and "undo" *)
Models.Broadcast(m, msg) (* update all views on this model *)
END Do;
PROCEDURE NewPasteCharOp (m: Model; char: CHAR): PasteCharOp;
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
RETURN op
END NewPasteCharOp;
(* Model *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* View *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR op: Stores.Operation;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
op := NewPasteCharOp(v.model, msg.char); (* generate operation *)
Models.Do(v.model, "Typing", op) (* execute operation *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews13.
"ObxViews13.Deposit; StdCmds.Open"
Further examples which use the undo/redo mechanism through operations can be found e.g. in ObxOmosi or ObxLines.
6.8 Separation of interface and implementation
As a last version of our sample view, we modify the previous variant by exporting the Model and View types, and by separating interface and implementation of these two types. In order to do the latter, so-called directory objects are introduced, which generate (hidden) default implementations of abstract data types. A user now might implement its own version of the abstract type and offer it through its own directory object, however he can not inherit from the default implementation and thus avoids the fragile base class problem.
Real BlackBox subsystems would additionally split the module into two modules, one for the model and one for the view. A third module with commands might be introduced, if the number and complexity of commands warrant it (e.g., TextModels, TextViews, and TextCmds). Even more complicated views would further split views into views and controllers, each in its own module.
MODULE ObxViews14;
(* Same as ObxViews13, but interfaces and implementations separated, and operation directly in Insert procedure *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model* = POINTER TO ABSTRACT RECORD (Models.Model) END;
ModelDirectory* = POINTER TO ABSTRACT RECORD END;
View* = POINTER TO ABSTRACT RECORD (Views.View) END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdModel = POINTER TO RECORD (Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
StdModelDirectory = POINTER TO RECORD (ModelDirectory) END;
StdView = POINTER TO RECORD (View)
model: Model
END;
StdDirectory = POINTER TO RECORD (Directory) END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: StdModel;
char: CHAR;
do: BOOLEAN
END;
VAR
mdir-: ModelDirectory;
dir-: Directory;
(* Model *)
PROCEDURE (m: Model) Insert* (char: CHAR), NEW, ABSTRACT;
PROCEDURE (m: Model) Remove*, NEW, ABSTRACT;
PROCEDURE (m: Model) GetString* (OUT s: ARRAY OF CHAR), NEW, ABSTRACT;
(* ModelDirectory *)
PROCEDURE (d: ModelDirectory) New* (): Model, NEW, ABSTRACT;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: StdModel; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do operation's transformation *)
m.s[m.i] := op.char; INC(m.i);
ELSE (* undo operation's transformation *)
DEC(m.i) (* remove character from string *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* toggle between "do" and "undo" *)
Models.Broadcast(m, msg) (* update all views on this model *)
END Do;
(* StdModel *)
PROCEDURE (m: StdModel) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: StdModel) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: StdModel) CopyFrom (source: Stores.Store);
BEGIN
WITH source: StdModel DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
PROCEDURE (m: StdModel) Insert (char: CHAR);
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
Models.Do(m, "insertion", op)
END Insert;
PROCEDURE (m: StdModel) Remove;
VAR msg: Models.UpdateMsg;
BEGIN
DEC(m.i); m.s[m.i] := 0X;
Models.Broadcast(m, msg) (* update all views on this model *)
END Remove;
PROCEDURE (m: StdModel) GetString (OUT s: ARRAY OF CHAR);
BEGIN
s := m.s$
END GetString;
(* StdModelDirectory *)
PROCEDURE (d: StdModelDirectory) New (): Model;
VAR m: StdModel;
BEGIN
NEW(m); m.s := ""; m.i := 0; RETURN m
END New;
(* Directory *)
PROCEDURE (d: Directory) New* (m: Model): View, NEW, ABSTRACT;
(* StdView *)
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
IF st IS Model THEN
v.model := st(Model)
ELSE
(* concrete model implementation couldn't be loaded->
an alien store was created *)
rd.TurnIntoAlien(Stores.alienComponent)
(* internalization of v is cancelled *)
END
END
END Internalize;
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: StdView) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
WITH source: StdView DO
v.model := model(Model)
END
END CopyFromModelView;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR s: ARRAY 256 OF CHAR;
BEGIN
v.model.GetString(s);
f.DrawString(d, d, Ports.black, s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: StdView) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: StdView) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
v.model.Insert(msg.char) (* undoable insertion *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:StdView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 *d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New* (m: Model): View;
VAR v: StdView;
BEGIN
ASSERT(m # NIL, 20);
NEW(v); v.model := m; Stores.Join(v, m);
RETURN v
END New;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
v := dir.New(mdir.New());
Views.Deposit(v)
END Deposit;
PROCEDURE SetModelDir* (d: ModelDirectory);
BEGIN
ASSERT(d # NIL, 20);
mdir := d
END SetModelDir;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20);
dir := d
END SetDir;
PROCEDURE Init;
VAR md: StdModelDirectory; d: StdDirectory;
BEGIN
NEW(md); mdir := md;
NEW(d); dir := d
END Init;
BEGIN
Init
END ObxViews14.
"ObxViews14.Deposit; StdCmds.Open"
A simple example of a BlackBox module which follows this design is DevMarkers. The marker views are simple views without a model, therefore only a directory object to generate new views is offered. The second directory object DevMarkers.stdDir keeps the standard implementation provided by this module. It might be used to install back the default implementation or to reuse the default implementation (as an instance) in another component.
The separation of a type's definition from its implementation is recommended in the design of new BlackBox subsystems. However, simple view types which won't become publicly available or which are not meant to be extended can certainly dispense with this additional effort.
Note that the subsystem wizard (menu item Tools->Create Subsystem...) helps to generate templates for the different kinds of view. In particular, it is possible to generate separate model and view modules. The tool uses the template texts stored in Dev/Rsrc/New. You may want to study the files Models5, Views5, and Cmds5 in this directory.
| Docu/Tut-6.odc |
Appendix A: A Brief History of Pascal
Algol
The language Component Pascal is the culmination of several decades of research. It is the youngest member of the Algol family of languages. Algol, defined in 1960, was the first high-level language with a readable, structured, and systematically defined syntax. While successful as a notation for mathematical algorithms, it lacked important data types, such as pointers or characters.
Pascal
In the late sixties, several proposals for an evolutionary successor to Algol were developed. The most successful one was Pascal, defined in 1970 by Prof. Niklaus Wirth at ETH Zьrich, the Swiss Federal Institute of Technology. Besides cleaning up or leaving out some of Algol's more obscure features, Pascal added the capability to define new data types out of simpler existing ones. Pascal also supported dynamic data structures; i.e., data structures which can grow and shrink while a program is running. Pascal received a big boost when ETH released a Pascal compiler that produced a simple intermediate code for a virtual machine (P-code), instead of true native code for a particular machine. This simplified porting Pascal to other processor architectures considerably, because only a new P-code interpreter needed be written for this purpose, not a whole new compiler. One of these projects had been undertaken at the University of California, San Diego. Remarkably, this implementation (UCSD Pascal) didn't require a large and expensive mainframe computer, it ran on the then new Apple II personal computers. This gave Pascal a second important boost. The third one came when Borland released TurboPascal, a fast and inexpensive compiler, and integrated development environment for the IBM PC. Later, Borland revived its version of Pascal when it introduced the rapid application development environment Delphi.
Pascal has greatly influenced the design and evolution of many other languages, from Ada to Visual Basic.
Modula-2
In the mid-seventies, inspired by a sabbatical at the Xerox Palo Alto Research Center PARC, Wirth started a project to develop a new workstation computer. This workstation should be completely programmable in a high-level language, thus the language had to provide direct access to the underlying hardware. Furthermore, it had to support team programming and modern software engineering principles, such as abstract data types. These requirements led to the programming language Modula-2 (1979). Modula-2 retained the successful features of Pascal, and added a module system as well as a controlled way to circumvent the language's type system when doing low-level programming; e.g., when implementing device drivers. Modules could be added to the operating system at run-time. In fact, the whole operating system consisted of a collection of modules, without a distinguished kernel or similar artefact. Modules could be compiled and loaded separately, with complete type and version checking of their interfaces.
Modula-2 has made inroads in particular into safety-critical areas, such as traffic control systems.
Simula, Smalltalk, and Cedar
Wirth's interest remained with desktop computers, however, and again an important impulse came from Xerox PARC. PARC was the place where the workstation, the laser printer, the local area network, the bitmap display, and many other enabling technologies have been invented. Also, PARC adopted and made popular several older and barely known technologies, like the mouse, interactive graphics, and object-oriented programming. The latter concept, if not the term, was first applied to a high-level language in Simula (1966), another member of the Algol language family. As its name suggests, Simula used object-orientation primarily for simulation purposes. Xerox PARC's Smalltalk language (1983), however, used it for about anything. The Smalltalk project broke new ground also in user interface design: the graphical user interface (GUI) as we know it today was developed for the Smalltalk system.
At PARC, these ideas influenced other projects, e.g., the Cedar language, a Pascal-style language. Like Smalltalk and later Oberon, Cedar was not only the name of a language but also of an operating system. The Cedar operating system was impressive and powerful, but also complex and unstable.
Oberon
The Oberon project was initiated in 1985 at ETH by Wirth and his colleague Jьrg Gutknecht. It was an attempt to distill the essence of Cedar into a comprehensive, but still comprehensible, workstation operating system. The resulting system became very small and efficient, working well with only 2 MB of RAM and 10 MB of disk space. An important reason for the small size of the Oberon system was its component-oriented design: instead of integrating all desirable features into one monolithic software colossus, the less frequently used software components (modules) could be implemented as extensions of the core system. Such components were only loaded when they were actually needed, and they could be shared by all applications.
Wirth realized that component-oriented programming required some features of object-oriented programming, such as information hiding, late binding, and polymorphism.
Information hiding was the great strength of Modula-2. Late binding was supported by Modula-2 in the form of procedure variables. However, polymorphism was lacking. For this reason, Wirth added type extension: a record type could be declared as an extension of another record type. An extended type could be used wherever one of its base types might be used.
But component-oriented programming is more than object-oriented programming. In a component-based system, a component may share its data structures with arbitrary other components, about which it doesn't know anything. These components usually don't know about each other's existence either. Such mutual ignorance makes the management of dynamic data structures, in particular the correct deallocation of unused memory, a fundamentally more difficult problem than in closed software systems. Consequently, it must be left to the language implementation to find out when memory is not used anymore, in order to safely reclaim it for later use. A system service which performs such an automatic storage reclamation is called a garbage collector. Garbage collection prevents two of the most evasive and downright dangerous programming errors: memory leaks (not giving free unused memory) and dangling pointers (releasing memory too early). Dangling pointers let one component destroy data structures that belong to other components. Such a violation of type safety must be prevented, because component-based systems may contain many third-party components of unknown quality (e.g., downloaded from the Internet).
While Algol-family languages always had a reputation of being safe, complete type safety (and thus garbage collection) still was a quantum leap forward. It also was the reason why complete compatibility with Modula-2 was not possible. The resulting revision of Modula-2 was called the same way as the system: Oberon.
Oberon's module system, like the one of Modula-2, provided information hiding for entire collections of types, not only for individual objects. This allowed to define and guarantee invariants spanning several cooperating objects. In other words: it allowed developers to invent higher-level safety mechanisms, by building on the basic module safety and type safety provided by a good Oberon implementation.
Orthodox object-oriented programming languages such as Smalltalk had neglected both typing (by not supporting types) and information hiding (by restricting it to objects and classes), which was a major step backwards as far as software engineering is concerned. Oberon reconciled the worlds of object-oriented and modular programming.
As a final requirement of component-oriented programming, it had to be possible to dynamically load new components. In Oberon, the unit of loading was the same as the unit of compilation: a module.
Component Pascal
In 1992, a cooperation with Prof. H. P. Mцssenbцck led to a few additions to the original Oberon language ("Oberon-2"). It became the de-facto standard of the language.
In 1997, the ETH spin-off Oberon microsystems, Inc. (with Wirth on its board of directors) made some small extensions to Oberon-2 and called it Component Pascal, to better express its focus (component-oriented programming) and its origin (Pascal). It is the industrial-strength version of Oberon, so to say.
The main thrust of the enhancements compared to Oberon-2 was to give the designer of a framework (i.e., of module interfaces that define abstract classes for a particular problem domain) more control over the framework's custom safety properties. The benefit is that it becomes easier to ascertain the integrity of a large component-based system, which is particularly important during iterative design cycles when the framework is being developed, and later when the system architecture must be refactored to enable further evolution and maintenance.
BlackBox
Oberon microsystems developed the BlackBox Component Framework starting in 1992 (originally it was called Oberon/F). This component-oriented framework is written in Component Pascal, and simplifies the development of graphical user interface components. It comes bundled with several BlackBox extension components, including a word processor, a visual designer, an SQL database access facility, an integrated development environment, and the Component Pascal run-time system. The complete package is an advanced yet light-weight rapid application development (RAD) tool for components, called BlackBox Component Builder. It is light-weight because it is completely built out of Component Pascal modules ђ including the kernel with the garbage collector, and the Component Pascal compiler itself.
| Docu/Tut-A.odc |
Appendix B: Differences between Pascal and Component Pascal
Eliminated Features
Subrange types
Use a standard integer type instead.
Enumeration types
Use integer constants instead.
Arbitrary array ranges
Arrays are always defined over the integer range 0..max-1.
Example
A = ARRAY 16 OF INTEGER (* legal indices are in the range 0..15 *)
No general sets
Type SET denotes the integer set which may include the elements 0..31.
No explicit DISPOSE
Memory is reclaimed automatically by the garbage collector. Instead of calling DISPOSE, simply set the variable to NIL.
No variant records
Use record extension instead.
No packed structures
Use SHORTCHAR or BYTE types for byte-sized values.
No GOTO
No PRED and SUCC standard functions
Use DEC or INC on integer values instead.
No built-in input/output facilities
No file types. I/O is provided by library routines.
Changed Features
Standard procedure ENTIER instead of ROUND
Syntax for REAL constants
3.0E+4 but not 3.0e+4
Syntax for pointer type declarations
P = POINTER TO R
instead of
P = ^R
Syntax for case statement
"|" instead of ";" as case separator.
ELSE clause.
Example
CASE i * 3 - 1 OF
0: StdLog.String("zero")
| 1..9: StdLog.String("one to nine")
| 10, 20: StdLog.String("ten or twenty")
ELSE StdLog.String("something else")
END
Procedure name must be repeated
Example
PROCEDURE DrawDot (x, y: INTEGER);
BEGIN
END DrawDot;
Case is significant
Small letters are distinguished from capital letters.
Example "proc" is not the same as "Proc".
String syntax
String literals are either enclosed between " or between '. There cannot be both single and double quotes in one string. String literals of length one are assignment-compatible to character variables.
Examples
"That's great" 'Write "hello world" to the screen'
ch := "x"
ch := 'x'
Comments
Comments are enclosed between (* and *) and may be nested.
Set brackets
Set constants are given between { and } instead of [ and ].
Example {0..2, 4, j..2 * k}
Function syntax
Use keyword PROCEDURE for functions also, instead of FUNCTION.
Procedures with a return value always have a (possibly empty) parameter list in their declarations and in calls to them.
The function result is returned explicitly by a RETURN statement, instead of an assignment to the function name.
Example
PROCEDURE Fun (): INTEGER;
BEGIN
RETURN 5
END Fun;
instead of
FUNCTION Fun: INTEGER;
BEGIN
Fun := 5
END;
n := Fun() instead of n := Fun
Declarations
The sequence of declarations is
{ ConstDecl | TypeDecl | VarDecl} {ProcDecl | ForwardDecl}
instead of
[ConstDecl] [TypeDecl] [VarDecl] {ProcDecl}.
Forward declarations are necessary if a procedure is used before it is defined.
Example
PROCEDURE ^ Proc;
instead of
PROCEDURE Proc; FORWARD;
Procedure types
Procedures may not only be passed to parameters, but also to procedure-typed variables.
Example
TYPE P = PROCEDURE (x, y: INTEGER);
VAR v: P;
v := DrawDot; (* assign *)
v(3, 5); (* call DrawDot(3, 5) *)
Explicit END instead of compound statement
BEGIN can only occur before a statement sequence, but not in it. IF, WHILE, and LOOP are always terminated by END.
WITH statement
A WITH statement is a regional type guard, it does not imply a hidden variable and does not open a new scope.
See language reference for more details.
ELSIF
IF statements can have several branches.
Example
IF name = "top" THEN
StdLog.Int(0)
ELSIF name = "bottom" THEN
StdLog.Int(1)
ELSIF name = " charm" THEN
StdLog.Int(2)
ELSIF name = "beauty" THEN
StdLog.Int(3)
ELSE
StdLog.String("strange")
END
BY instead of only DOWNTO in FOR
FOR loops may use any constant value as increment or decrement.
Example
FOR i := 15 TO 0 BY -1 DO StdLog.Int(i, 0) END
Boolean expressions use short-circuit evaluation
A Boolean expression terminates as soon as its result can be determined.
Example
The following expression does not cause a run-time error when p = NIL:
IF (p # NIL) & (p.name = "quark") THEN
Constant expressions
In constant declarations, not only literals, but also constant expressions are allowed.
Example
CONST
zero = ORD("0");
one = zero + 1;
Different operators
# is used instead of <> for inequality test.
& is used instead of AND for logical conjunctions.
~ is used instead of NOT for logical negation.
Explicit conversion to included type with SHORT
Type inclusion for numeric types allows to assign values of an included type to an including type. To assign in the other direction, the standard procedure SHORT must be used.
Example
int := shortint;
shortint := SHORT(int)
New Features
Hexadecimal numbers and characters
Example
100H (* decimal 256 *)
0DX (* carriage return *)
Additional numeric types
LONGINT, SHORTINT, BYTE, SHORTREAL have been added.
Symmetric set difference
Sets can be subtracted.
New standard procedures
The new standard procedures INC, DEC, INCL, EXCL, SIZE, ASH, HALT, ASSERT, LEN, LSH, MAX, MIN, BITS, CAP, ENTIER, LONG and SHORT have been added.
LOOP with EXIT
There is a new loop statement with an explicit exit statement. See language report for more details.
ARRAY OF CHAR can be compared
Character arrays can be compared with the =, #, <, >, <=, and >= operators.
Open arrays, multidimensional arrays
Arrays without predefined sizes can be defined, possibly with several dimensions.
Examples
VAR a: POINTER TO ARRAY OF CHAR;
NEW(a, 16)
PROCEDURE ScalarProduct (a, b: ARRAY OF REAL; VAR c: ARRAY OF REAL);
TYPE Matrix = ARRAY OF ARRAY OF REAL;
PROCEDURE VectorProduct (a, b: ARRAY OF REAL; VAR c: Matrix);
Pointer dereferencing is optional
The dereferencing operator ^ can be omitted.
Example
root.next.value := 5
instead of
root^.next^.value := 5
Modules
Modules are the units of compilation, of information hiding, and of loading. Information hiding is one of the main features of object-oriented programming. Various levels of information hiding are possible: complete hiding, read-only / implement-only export, full export.
See language report for more details.
Type extension
Record types (pointer types) can be extended, thus providing for polymorphism. Polymorphism is one of the main features of object-oriented programming.
Methods
Procedures can be bound to record types (pointer types), thus providing late binding. Late binding is one of the main features of object-oriented programming. Such procedures are also called methods.
String operator
The string (sequence of characters) that is contained in an array of character can be selected by using the $-selector.
Record attributes
Records are non-extensible by default, but may be marked as EXTENSIBLE, ABSTRACT, or LIMITED.
Method attributes
Methods are non-extensible by default, but may be marked as EXTENSIBLE, ABSTRACT, or EMTPY. Newly introduced methods must be marked as NEW.
| Docu/Tut-B.odc |
BlackBox Tutorial
Table of Contents
Part I: Design Patterns
1UserInteraction
1.1 User-friendliness
1.2 Event loops
1.3 Access by multiple users
1.4 Language-specific parameters
2CompoundDocuments
2.1 Persistence
2.2 Display independence
2.3 Multi-view editing
2.4 Change propagation
2.5 Nested views
2.6 Delayed updates
2.7 Container modes
2.8 Event handling
2.9 Controls
3BlackBoxDesignPractices
3.1 Language support
3.2 Modules and subsystems
3.3 Bottleneck interfaces
3.4 Object creation
Part II: Library
4Forms
4.1 Preliminaries
4.2 Phone book example
4.3 Interactors
4.4 Guards
4.5 Notifiers
4.6 Standard controls
4.7 Complex controls and interactors
4.8 Input validation
4.9 Summary
5Texts
5.1 Writing text
5.2 The Model-View-Controller pattern applied to texts
5.3 Reading text
5.4 Modifying text
5.5 Text scripts
5.6 Summary
Part III: View Construction
6ViewConstruction
6.1 Introduction
6.2 Message handling
6.3 Preference messages
6.4 Controller messages
6.5 Properties
6.6 Model-View separation
6.7 Operations
6.8 Separation of interface and implementation
A:ABriefHistoryofPascal
B:DifferencesbetweenPascalandComponentPascal
| Docu/Tut-TOC.odc |
BlackBox Tutorial
Table of Contents
Part I: Design Patterns
1UserInteraction
1.1 User-friendliness
1.2 Event loops
1.3 Access by multiple users
1.4 Language-specific parameters
2CompoundDocuments
2.1 Persistence
2.2 Display independence
2.3 Multi-view editing
2.4 Change propagation
2.5 Nested views
2.6 Delayed updates
2.7 Container modes
2.8 Event handling
2.9 Controls
3BlackBoxDesignPractices
3.1 Language support
3.2 Modules and subsystems
3.3 Bottleneck interfaces
3.4 Object creation
Part II: Library
4Forms
4.1 Preliminaries
4.2 Phone book example
4.3 Interactors
4.4 Guards
4.5 Notifiers
4.6 Standard controls
4.7 Complex controls and interactors
4.8 Input validation
4.9 Summary
5Texts
5.1 Writing text
5.2 The Model-View-Controller pattern applied to texts
5.3 Reading text
5.4 Modifying text
5.5 Text scripts
5.6 Summary
Part III: View Construction
6ViewConstruction
6.1 Introduction
6.2 Message handling
6.3 Preference messages
6.4 Controller messages
6.5 Properties
6.6 Model-View separation
6.7 Operations
6.8 Separation of interface and implementation
A:ABriefHistoryofPascal
B:DifferencesbetweenPascalandComponentPascal
Part I: Design Patterns
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
1 User Interaction
In this section, we will discuss how a user interface can be made user-friendly. Graphical user interfaces are part of the answer. Unfortunately, this answer leads to another problem: how can such a user interface be implemented at reasonable cost? The design approach which solves this problem is surprisingly fundamental, and has deep consequences on the way we construct modern software. It is called object-oriented programming.
1.1 User-friendliness
There are at least 100 million personal computers in use today. With so many users who are not computer specialists, it is important that computers be easy to use. This implies that operating systems and applications must be user-friendly. What does this mean? There are several aspects.
First, the various applications should be consistent with one another: a function that is available in several programs should have the same user interface in all of them, so that the user does not have to learn different ways to do one and the same thing. One way to achieve this is to publish user interface guidelines that all software developers should adhere to. This approach was championed by Apple when they introduced the Macintosh. A second approach is to implement a function only once, so that it can be reused across different applications. This is the idea of component software. Apple didn't go that far, but they at least provided a number of so-called "toolbox" routines. The toolbox is a comprehensive library built into the Mac OS.
Second, the idea of the desktop metaphor, where icons graphically represent files, directories, programs, and other items, made it possible to replace arcane commands that have to be remembered and typed in by more intuitive direct manipulation: for example, an icon can be dragged with the mouse and dropped into a waste basket, instead of typing in "erase myfile" or something similar. Such a rich user interface requires a vast set of services. Not surprisingly, the Mac OS toolbox included services for windows, menus, mouse, dialog boxes, graphics, and so on. The toolbox made it possible to build applications that really adhered to the user interface guidelines. Unfortunately, programming for such an environment implied a tremendous leap in complexity. As a result, the Macintosh was much easier to use than earlier computers, but it was also much more difficult to program.
Today, the browser metaphor is an increasingly popular addition to traditional graphical user interfaces. Combined with Internet access, it opens a huge universe of documents to a computer user ђ and makes the job of a developer even more complicated.
Finally, one of the most general and most important aspects of user-friendliness is the avoidance of modes. A modal user interface separates user interactions into different classes, and gives a separate environment to each class. Switching between environments is cumbersome. For example, in a database application, a user may open a window (or "screen", "mask") for data entry. In this window, no records may be deleted, no records may be searched, no notes taken, no email read, etc. For each of these other tasks, the data entry environment would have to be left first. This is cumbersome, and reminds us of the application- rather than the document-centric way of computing discussed in the first part of this book. In complex applications, it is often difficult to remember where you currently are, what commands are available, and where you may go next. Figure 1-1 shows an example of the states and possible state transitions of a hypothetical modal application.
Figure 1-1. Navigation possibilities in a modal user interface
Non-modal user interfaces have no separate working environments, or at least let you switch between environments without losing the state of others. For example, if during data entry you want to look up something with a library browser or text searching tool, you don't lose the partial data that you have already entered. If there are separate working environments, navigation is made simple and obvious by giving explicit feedback about the environment and its capabilities.
A modern graphical user interface is a prime example of a mostly non-modal user interface. There may be several windows (environments) open at the same time, but it is clearly visible with which window you are currently interacting (usually the "top" window). You can work in one window, temporarily work in another one (thereby bringing it to the top), and later switch back to resume your work in the first window.
These user interfaces are a huge improvement over old-style modal interfaces. Users feel more comfortable because they have a better idea of where they are and what they can do. However, even modern GUIs are far from perfect. Most of them still use modal dialog boxes, i.e., windows that you can't put aside to work with another one for a while. For example, a typical modal file dialog box lets you open a file, but doesn't allow you to quickly switch to a file searching tool and back again. The dialog box "modes you in". Even the fact that you have to bring a window to the top before manipulating it constitutes an inconvenient and unnecessary mode, at least if you have a screen large enough that you can lay out all needed windows in a non-overlapping fashion. And many database products don't allow you to have several data entry or data manipulation forms open at the same time. A Web browser is the closest thing to a truly non-modal user interface today: if you have entered some incomplete data into an HTML form, and then switch to another Web page, the browser won't prevent you from doing it.
The BlackBox Component Builder is more radical than other tools in that it simply doesn't support modal dialog boxes. Every dialog box is non-modal, except for a very few built-in operating system dialog boxes such as the standard file dialog boxes. In general, you can always put dialog boxes aside and get back to them later.
1.2 Event loops
Implementing a non-modal application looks deceptively simple: the program waits for a user event, such as a mouse click or a key press; reacts in an appropriate way; waits for the next event; and so on. This programming style, with a central loop that polls the operating system for events and then calls the appropriate handlers for them, is called event-driven programming.
Figure 1-2. Event loop of a non-modal program
The event-polling loop of a typical event-driven program looks similar to the following program fragment:
PROCEDURE Main;
VAR event: OS.Event;
BEGIN
LOOP
event := OS.NextEvent(); (* poll the operating system for the next event *)
IF event IS KeyDownEvent THEN
HandleKeyDown(event)
ELSIF event IS MouseDownEvent THEN
IF MouseInMenu(event) THEN
HandleMenuEvent(event)
ELSIF MouseInWindowTitle(event) THEN
HandleTitleEvent(event)
ELSIF MouseInWindowBorder(event) THEN
HandleBorderEvent(event)
ELSIF MouseInWindowContents(event) THEN
HandleContentsEvent(event)
ELSIF...
...
END
ELSIF ...
...
END
END Main;
Listing 1-3. Event loop with cascaded selection of event handlers
In realistic programs, these cascaded IF-statements can easily span several pages of code, and are always similar. Thus it suggests itself to put this code into a library (or even better, into the operating system).
Such a library would implement the standard user interface guidelines. For example, the HandleTitleEvent would further distinguish where in the window's title bar the mouse has been clicked. Depending on the exact location, the window will be dragged to another place, zoomed, closed, etc. This is a generic behavior that can, and for consistency reasons should, only be implemented once. A procedure like HandleContentsEvent is different, though. A standard library cannot know what should happen when the user has clicked into the interior (contents) area of a window.
If we require that the library itself must never need adaptation to a particular application, then there results a peculiar kind of system structure, where a library sometimes calls the application. Such a call is called a "call-back". When we visualize an application as sitting on top of the library, it becomes obvious why such calls are also called "up-calls" and the resulting programming style as "inverted programming":
Figure 1-4. Inverted programming design pattern
A library which strongly relies on inverted programming is called a framework. It is a semi-finished product that must be customized by plugging in procedures at run-time. For some of the procedures, this can be optional: for procedure HandleTitleEvent there can be a default implementation that implements the standard user interface guidlines. Such procedures will only be replaced if unconventional behavior is desired.
Experience shows that a procedure plugged into a framework frequently refers to the same data. For example, the procedure HandleTitleEvent will often access the window in which the user has clicked. This makes it convenient to bundle the procedure and its state into a capsule. Such a capsule is called an object, and it lifts inverted programming to object-oriented programming.
Thinking about user-friendly software led us to the problem of how to reduce the amount of repetitive and complex coding of event loops, which led us straight to the inverted programming design style; to frameworks as a way of casting such a design style into code; and to object-oriented programming as a means to implement frameworks in a convenient way.
The BlackBox Component Framework hides the event loop from application programmers. It goes even further than older frameworks in that it also hides platform-specific user-interface features such as windows and menus. This was achieved by focusing on the abstraction that represents the contents of a window: the so-called View type. We will come back to this topic in Chapter 2 in more detail.
1.3 Access by multiple users
Personal computers have made computer users independent from central IT (information technology) departments, their bureaucracies, and their overloaded time-sharing servers. This independence is a good thing, if it can be combined with integration where this is useful and cost-effective. Local area networks, wide area networks, and then the Internet have made integration possible. When two computers cooperate over a network, one of them asks the other to provide a service, for example to deliver a file over the network. The computer which issues the request is called the client, the other one is called the server. The same machine may act both as a client and as a server, but often these roles are assigned in a fixed manner: the clerk at the counter of a bank's branch office always uses a client machine, and the large box in the air-conditioned vault of the bank's headquarters is always used as a server. A bank's internal network may connect thousands of clients to dozens of servers. But even the smallest network obviously requires that applications are split into two parts: a client and a server part. Consequently, this kind of architecture is called client/server computing. It allows to assign processing tasks to the machines which are most suitable. In enterprise environments, the most popular assignment is to put a centralized database on a database server, and the remaining functionality on the client machines. This is called a 2-tier architecture. It requires fat clients, i.e., client machines have to perform everything but the actual database accesses. To reduce this burden, high-end database management systems allow to execute some code on the server itself, as an interpreted stored procedure. This can greatly increase performance, because it can prevent large amounts of data being shuffled back and forth over the network.
If large numbers of clients are involved, it can become hard to keep all client installations up-to-date and consistent. This problem can be reduced using a 3-tier architecture, where special application servers are interposed between clients and servers. The "thin" clients are reduced to implementing user interfaces, the database servers handle the databases, while the application servers contain all application-specific knowledge ("business logic").
Figure 1-5. 3-tier client/server architecture pattern
A 3-tier architecture is reasonably manageable and scalable in terms of size. Note that a software system separated in this way can be scaled down, in the extreme case by putting the client, application server, and database server on a single machine. The other way around does not work: a monolithic application cannot be easily partitioned to fit a client/server architecture.
Clients and servers are coupled over a network. Communication either operates at the low abstraction level of untyped byte streams (e.g., using a sockets interface for TCP/IP communication) or at the high abstraction level of typed data. In the latter case, either distributed objects (for immediate point-to-point communication) or message objects (for multicast or delayed communication) are used.
The Comm subsystem of the BlackBox Component Framework provides a simple byte stream communication abstraction, on top of which messaging services can be built. Among other things, this has been used to implement remote controls, i.e., controls which visualize and manipulate data on a remote machine. For example, the internal state of an embedded system can be monitored in this way.
The Sql subsystem of the BlackBox Component Framework provides a simple distributed object interface specialized for accessing SQL databases. More general DCOM-based [COM] distributed objects can be accessed and implemented with the optional Direct-To-COM Component Pascal compiler.
1.4 Language-specific parameters
The global nature of today's software business often makes it necessary to produce "localized" versions of a software package. At the least, this requires translation of all string constants in the program that the user may see. For example, in a country like Switzerland, where four official languages are spoken, it is often required that the same application is available in German, French, and Italian language versions. This can even mean that the layouts of dialog boxes need to be adapted to the different languages, since the captions and control labels have different lengths in different languages.
If such language-specific aspects are hard-coded into the program sources, language-specific versions require editing and compiling the source code. This is always a sensitive point, since errors and inconsistencies can easily be introduced. It is also very inconvenient: hard-coded layouts of dialog boxes are very unintuitive to modify, and the edit-compile-run cycle is cumbersome if you only want to move or resize a control.
Many tools have been developed which provide more convenient special-purpose editors, in particular layout editors for dialog boxes. One type of tool produces source code out of the interactively produced layout, which then has to be compiled. Since a programmer have to edit the generated source code, it is easy to introduce inconsistencies between the layout and the source code.
Fortunately, there is a much better way to solve this problem, by avoiding the intermediate source-code generator and directly use the editor's output in the program. The editor saves the dialog box layout in a file, a so-called resource file. The program then reads these resources when it needs them, e.g., when it opens a dialog box. Resources can be regarded as persistent objects which are only modified if the configuration is changed.
We have seen that the problem of convenient adaptation of a program to different languages can be solved by separating language- or location-specific parameters from the source code. They are put into resource files, which can be modified by convenient special-purpose editors.
Moving user-interface aspects away from the proper application logic is a way to make client software more modular and better adaptable. If taken to the extreme, resources almost become the client software: a Web browser on a client is all that is needed to present a user interface; the resources (HTML texts) are downloaded from a server whenever needed. (However, this approach with "ultra-thin" clients becomes less credible the fatter the Web browsers themselves become.)
The BlackBox Component Framework uses its standard document format to store resources. For example, a dialog box and its controls are simply parts of a compound document stored in a file. The same view is used for layouting and for actually using a dialog box ђ no separate layout editor progam is needed. Resources can be available in several language versions simultaneously, and languages can even be switched at run-time. This is useful for customs applications or other programs used in regions where several languages are spoken.
2 Compound Documents
In the previous sections, we have discussed a variety of problems that occur with interactive systems, and we have seen various architecture and design approaches that help to solve them.
In the following sections we focus specifically on the programming problems posed by compound documents, and the design patterns that help to solve them.
2.1 Persistence
We call the object that is contained in a window a view. A view displays itself in the window, and it may interpret user input in this area, such as mouse clicks. In the most general case, a view can be opened and saved as a document. Other views may be created at run-time or are loaded from resource files. The contents of a "Find & Replace" dialog box is an example of the latter case.
In general, a view is a persistent object. This presumes a mechanism for the externalization (saving) and the internalization (opening) of a view. Using object-oriented programming, we can model a view as a specialization of a generic persistent object, which we call a store. A store can externalize and internalize its persistent state. A view is a specialized store, i.e., a subtype. In addition to externalizing and internalizing themselves, views can display themselves and can handle user input. These generic views can be further specialized, for example to text views, picture views, and so on (see Figure 2-1).
Figure 2-1. Subtype relations between views and stores
In the BlackBox Component Framework, stores are represented as type Store in module Stores; views are represented as type View in module Views; and there are various specific views such as type View in module TextViews or type View in module FormViews or type Control in module Controls (see Figure 2-2). This is only a small selection, actually there are many more view types. The store mechanism's file format is platform-independent, i.e., differences in byte ordering are compensated for.
Figure 2-2. Subtype relations between views and stores in BlackBox
Often, copying of a store is equivalent to writing it to a temporary file, and then reading it in again (externalize old object to file, then allocate and internalize new object from file). This makes it convenient to combine persistence and copying support in the same store abstraction. However, BlackBox stores are able to change their identities or to "dissolve" upon externalization to a file, in which case copying is not equivalent to externalize/internalize anymore. For example, error marker views which indicate syntax errors remove themselves upon externalization ђ yet a visible error marker can be copied with drag & drop like any other view. To allow for such flexibility, BlackBox doesn't automatically treat copying as an externalize/internalize pair. Stores have explicit Externalize, Internalize and CopyFrom methods. Upon externalization, a store gets the opportunity to substitute another store for itself, possibly NIL. This is the mechanism which allows to change its identity to another one, a so-called proxy.
2.2 Display independence
The computing world is heterogeneous, with different hardware and operating system platforms on the market. The Internet, with its millions of platforms of all flavors, has finally made it clear how important platform-independence of code and data is. This is not easy to achieve, because software and hardware can vary widely between platforms. Display devices, such as monitors and printers, are a good example. Their spatial and color resolutions can differ enormously.
To achieve platform-independent code, views and their persistent state must not refer to specific devices. Instead, the document space and the display space must be clearly separated and a suitable mapping between the two must be provided by a framework. For example, in the document space, distances are measured in well-defined units such as inches or millimeters, while in the display space, distances are measured in pixels, whatever their actual sizes may be.
To model the separation between display and document space, where the document space is populated by persistent views, we need an abstraction of a display device. We call such an object a frame. A frame is a rectangular drawing surface which provides a set of drawing operations. When it is made visible, a view obtains a frame, and via this frame it can draw on the screen (or printer). The frame performs the mapping between the document space units and the pixels of the display device, so that views never need to deal with pixel sizes directly.
Figure 2-3. Separation of display and document space
In the BlackBox Component Framework, document space units are measured in 1/36000 millimeters. This value is chosen such that it minimizes rounding errors for typical display resolutions. A BlackBox frame provides a local coordinate system for its view. For the time being, you can regard a frame as a window and a view as a document. A view which isn't displayed has no frame. Frames are light-weight objects that come and go as needed. They are created and destroyed by the framework, and need not be implemented or extended by the view programmer.
The only case where it is necessary to extend frames is when platform-specific controls or OLE objects need to be wrapped as BlackBox views. Since writing such wrappers is a messy business, the framework provides standard OLE wrappers (Windows version) and wrappers for the important (pre-OLE) standard controls.
2.3 Multi-view editing
Simple views work fine if they are small enough to fit on a screen. However, texts, tables, or graphics can easily become larger than a screen or printed page. In this case, a frame (which lies strictly within the boundaries of its display device) can only display part of the view. To see the other parts, the user must scroll the view, i.e., change the way in which it translates its data to its local coordinate system. For example, a text view's first line (its origin) may be changed from the topmost line to another one further below, thus displaying a text part further below (see Figure 2-4).
Figure 2-4. Scrolling a text view
The need for scrolling can become very inconvenient when working with two parts of a view that are far apart, because it means that the user often must scroll back and forth. This problem can be solved by multi-view editing: the same data is presented in more than one view. The views may differ in their origins only, or they may differ more thoroughly. For example, one view may present a list of number values as a table of numbers, while another view may present the same data as a pie chart (see Figure 2-5).
Figure 2-5. Different kinds of views presenting the same data
An object which represents data that may be presented by several views is called a model. The separation into view and model go back to the Smalltalk project at Xerox PARC. In the patterns terminology, the view is an observer of the model.
In the BlackBox Component Framework, the model/view separation is optional. Small fixed-size views that easily fit in a window usually don't need separate models, while larger or more refined views do. This can result in a situation like the following one, where a view has a separate model, and both together form the document which is displayed in a window:
Figure 2-6. Separation of models and views in BlackBox
The user can open a second window, which displays its own view, but for the same model. This results in the following situation:
Figure 2-7: Multiple views for the same model
Only one of the two views is externalized when the document is saved in a file. To avoid schizophreny, one window is clearly distinguished as the main window, while all others are so-called subwindows. If you close a subwindow, only this window is closed. But if you close the main window, it and all its subwindows are closed simultaneously.
2.4 Change propagation
Multi-view editing creates a consistency problem. Editing a view means that the view causes its model to change. As a result, all views presenting this model must be updated if necessary, not only the view in which the user currently works. For example, if the user changes a value in the table view of Figure 2-5, then the pie chart in the other view must be updated accordingly, because their common model has changed.
Such a change propagation is easy to implement. After the model has performed an operation on the data that it represents, it notifies all views which present it, by sending them an update message describing the operation that has been performed.
Notification could be easily done by iterating over a linear list of views anchored in the model. Such a functionality can be provided once and for all, by properly encapsulating it in a class. This change propagation class provides an interface consisting of two parts. The first part allows to register new views that want to listen to update messages ("subscribe"). The second part allows to send update messages ("publish"):
Figure 2-8. Change propagation mechanism
This mechanism has an important advantage: it decouples model and views such that the model itself need not be aware of its views, and the list of views can be encapsulated in the change propagation mechanism. Such a reduced coupling between model and views is desirable because it reduces complexity. It makes the model unaware, and thus independent, of its views. This is important in an extensible system, because it allows to add new view types without modifying the model. This would not be possible if the model had to know too much about its views.
Sometimes the mechanism described above does too much. It sends update messages to all views, independent of whether they need updating or not. For example, when a word was deleted in a text model, then some text view may display a part of the text which is not affected by the deletion at all. This view need not do anything. Of course, all the views that do display the affected text stretch must be updated accordingly.
For this reason, the BlackBox Component Framework sends update messages only to those views which have frames. Since every frame knows its view, the change propagation mechanism actually registers the frames, not the views. Even better, the framework already has a list of frames for window management, so it can reuse this list. Thus, instead of having one change propagation object per model, BlackBox uses one global change propagation service integrated into the window manager. Messages are represented as static message records. This is an unconventional but robust, efficient, and light-weight implementation of the observer pattern.
2.5 Nested views
So far, we have assumed that a view (possibly with a model) is a document, and a frame is a window. Actually, things are a bit more difficult. The reason is that views may be nested. Some views are able to contain ("embed") other views; for this reason they are called container views. Some containers are very general, and allow to embed arbitrary numbers and types of other views. For example, a text view may embed table views, bitmap views, and so on. It may even embed another text view, meaning that arbitrarily deep nesting hierarchies can be created.
How does this affect what we have said so far? Obviously, we need to generalize our notion of views and frames. A view can contain other views, which can contain still other views, etc.; i.e., views become hierarchical. In principle, those hierarchies need not even be trees, they can be arbitrary directed acyclic graphs (DAGs). This means that several views in a document may refer to the same model, but no references may go "upwards" in the document hierarchy, because this would lead to an endless recursion when drawing the document, like a TV which displays itself.
The frames represent a subset of the view hierarchy. Since a frame is always completely contained within its parent frame, the frame hierarchy is strictly a tree.
A document can now be regarded as the root of a view DAG, and a window can be regarded as the root of a frame tree.
Figure 2-9. Nested views and frames
This is a straight-forward generalization which doesn't add unexpected complexity. It is a simplified implementation of the composite design pattern. It was simplified because the type safety of Component Pascal makes it unnecessary to burden the abstract view type with container-specific operations that are meaningless for non-containers.
Unfortunately, more complexity comes in when we consider the combination of nested views and multi-view editing. First of all, multi-view editing means the separation of views and models. An embedded view belongs to the model, since it is part of the data that the container view presents. For example, a user who edits a text view may delete embedded views just like she may delete embedded characters. Figure 2-10 illustrates the situation of two container views with a container model in which some other view is embedded:
Figure 2-10. Container views with model, context, and embedded view
Note the interesting link between a model and an embedded view: the context object. It describes the location and possibly other attributes of one embedded view. The context's type is defined by the container. A context is created by the container when the view is being embedded. The embedded view can ask its context about its own location in the container, and may even obtain further information. For example, text container contexts may provide information about the embedded view's position in the text (character index), about its current font and color, and so on.
An embedded view may use its context object not only for getting information about its container, it may also cause the container to perform some action. For example, the embedded view may ask the container, via the context object, to make it smaller or larger. Containers are free to fulfill such requests, or to ignore them. In negotiations between a container and one of its embedded views, the container always wins. For example, a container doesn't allow an embedded view to become wider than the container itself.
A context object can be regarded as a call-back interface which the container installs in the embedded view as a plug-in, so the view can call back the container and obtain services from it. A context is part of a notification mechanism that allows the container to observe messages from the contained views.
In subsequent figures, context objects are not drawn expliclity in order to make the figures easier to understand. Just remember that every view carries a context that it can use when necessary.
Now that nested views and the separation of model and view are supported, it becomes possible to allow subwindows on embedded views, not only on root views. This can be quite helpful, if a small view must be edited. Just open a subwindow for it, enlarge the window, and editing becomes much easier.
Figure 2-11. Subwindow on embedded view
Compound documents introduce a further complication. For root views, scrolling state is not retained when the document is saved to disk. At least most users seem to prefer that the scrolling state of a view not be persistent. This is different for embedded views, though. Setting the origin of an embedded view is not so much for convenience (subwindows are better for that) as for publishing: the user chooses which part of the view should be visible in the container.
The same holds for an undo/redo mechanism: scrolling in a root view is not a true document editing manipulation, and thus undo/redo would add inconvenience rather than usefulness. However, the scrolling of an embedded view must be treated as a genuine editing operation, and thus should be undoable/redoable.
In summary, this means that the implementor of a view must treat non-persistent view state differently, depending whether the view is a root view or an embedded view.
Combining nested views with multi-view editing also destroys the one-to-one relationship between frames and views. As we will see shortly, this is the most far-reaching additional burden that a view implementor must handle.
To see why a view may be displayed in several frames, consider the situation in Figure 2-12:
Figure 2-12. Several frames displaying the same view
Such a situation cannot occur without nested views, because the outermost view is always copied (to allow independent scrolling, or other view-specific operations). But whenever a view is embedded in a container displayed in two different windows, then this view is displayed in two different frames. This makes the management of links between frames and views more complicated; but more importantly, it makes change propagation and screen updates more complicated.
Why? Let us assume that there are n frames which display the same view. Now the view's model is changed, and this change is propagated to all views which display the model. Since there is only one view for the model, the change propagation mechanism as we have discussed earlier will send the view an update message exactly once. However, there are n places on the screen which need updating. As a result, the view must perform n updates, by iterating over all frames that display it.
For a view, correctly maintaining the list of frames in which it is displayed is a complicated endeavour. Therefore, the BlackBox Component Framework relieves the view implementor of this error-prone task. A BlackBox view doesn't contain a frame list. Instead, the framework maintains the frame trees automatically. This was the reason that in the above figures, the arrows from frames to views only pointed in one direction, because in BlackBox the view doesn't know its frame(s). The correct frames are passed to a view whenever the framework asks the view to do something that may involve drawing. (This approach is related to the flyweight pattern.)
When the view receives an update message and decides that it needs to update its frame(s), it simply asks the framework to send another update message to all its frames. Each of these frames will then ask the view to update the frame where this is necessary. This mechanism will be discussed in more detail in the chapters on view construction.
Since there is no more one-to-one relationship between views and frames anymore, it is helpful to summarize the differences between frames and view:
aspect frame view
lives in display space document space
persistent no yes
extended by view implementor usually not yes
may contain device-specific data yes no
hierarchy tree DAG
associated with one view 0..n frames
update caused by its view its model (if any)
completely enclosed by container yes not necessarily
Table 2-13. Differences between frames and views
2.6 Delayed updates
In the previous section we have seen how updates are performed in two steps: a model notifies its views of a change, and the views notify their frames of the region which needs updating.
Now consider a complex model change. For example, a selection of graphical objects, which are part of a graphics model, are moved by some distance. It would be possible to perform an update in three phases: in the first phase, the selected objects would be removed (requiring an update); then the selected objects would be moved; and finally, the selected objects would be inserted again at their destination (requiring another update).
This approach is not very efficient, since it requires two notifications and partial updates. Furthermore, it needs careful sequencing of the actions, since some of them need the model's state prior to movement, and others need the model's state after movement.
There is a much simpler and more efficient approach. The idea is to delay the second phase of the updates, i.e., the phase where the frames for a view are redrawn. Instead of updating the frames immediately, the view only remembers the geometrical region which needs updating. In the above example, it could add the areas of the graphical objects prior to movement and their areas after movement (see Figure 2-14).
Figure 2-14. Update region of a selection which was moved
The accumulated update region is then updated in one single step after the translation of the graphical objects has been performed. In the figure above, the update region is the total hatched area, consisting of the area occupied by the selection before the movement and the area occupied by it after the movement.
The framework must support this approach by providing some mechanism to add up geometrical regions, and to redraw a frame in exactly this region ("clipping" away all unnecessary drawing, to increase performance and to minimize flicker).
This delayed or lazy updating approach is used by the BlackBox Component Framework and all major windowing systems that exist today. Its only drawback is that for long-running commands, it may be necessary to force intermediate updates in order to inform the user of the command's progress. For this reason, forced updates are also supported by the BlackBox framework.
2.7 Container modes
To create graphical user interfaces, it is convenient to create form layouts interactively, rather than burning in the coordinates of controls in the source code of a program. A visual designer, i.e., a special-purpose graphics editor can be used for interactive manipulation of form layouts. This suggests two different modes in which a form, and its controls, can be used: design-time and run-time. When a form layout is edited in a visual designer, it is design-time: the form is designed, but not yet used. The completed form can be saved and later opened for use by the end user. This is called run-time.
There are two different approaches to handling layouts at run-time: either the framework allows to open the data that has been saved by the visual designer, or it runs code that has been generated out of this saved data. The first approach requires an interpreter for the visual designer's data, the second approach requires a generator between the visual designer and actual use of a form. Typically, the generator generates source code, which is possibly completed by the programmer, and then compiled into machine code using a standard programming language compiler.
Today, the latter approach should be considered obsolete, although it is still used by many tools: it is merely an inconvenient detour. Moreover, when it forces programmers to edit the generated source code, it makes iterative changes to a layout problematic: the source code has to be regenerated without losing the changes that have been made by the programmer. This is a needless source of inconsistencies, complexity, and it slows down development.
The former approach is much simpler. The visual designer's output data is treated as a resource that can be utilized as is at run-time. This requires an interpreter for the visual designer's file format.
The most elegant approach is to use the same editor (i.e., view implementation) and thus the same file format both for design-time and run-time. As file format, the standard format of a compound document can be reused. This means that a form layout at design-time is a completely ordinary compound document. At run-time, it is still the same document, albeit its interaction with the user is different.
At design-time, a control is a passive box which can be moved around, copied or deleted, but which has no interactive behavior of its own. At run-time, a control may be focused and the control's contents may be edited. For example, the string contained in a text field control may be edited, or a button may be pressed and released again.
The direct use of compound documents as user interfaces is called compound user interfaces. Note that this generalization of compound documents renders the term "document" rather misleading, because an application may contain many forms (and thus compound user interface documents) even if it does not manipulate any documents in the traditional sense (i.e., as seen by an end-user).
The BlackBox Component Framework utilizes its support for multi-view editing to go one step further. Since a document can be opened in several views simultaneosly, it is possible to open a form layout in two windows. BlackBox allows to use form views in different modes: layout and mask mode. These modes correspond to design-time and run-time, with one major improvement: they can be used simultaneously. For example, one window may display a form in layout mode, and another window may display it in mask mode (see Figure 2-15). When the developer edits the layout in the layout mode window, any layout change is immediately reflected in the mask mode window. Vice versa, user input in the mask mode window immediately becomes visible in the layout window. This is a result of the standard change propagation mechanism of BlackBox.
Figure 2-15. Data entry form in a layout-mode view (behind) and in a mask-mode view (front)
In fact, BlackBox is even more general. In addition to layout and mask mode, it supports a few further modes. The edit mode allows to modify the layout and the contents of controls simultaneously, and a browser mode makes the form read-only except for allowing to select and copy out parts of the document.
These general modes are not only available for graphical forms. They are a capability shared by all general container views, including text views. This means that it is possible (and sometimes more convenient for the developer) to use a text view instead of a form view when assembling a dialog box. The user won't notice the difference. To simplify the construction of such powerful containers, the framework provides a comprehensive container abstraction, with an abstract container model class, an abstract container view class, and an abstract container controller class. A controller can be regarded as a split-off part of a view. It performs all user interaction, including handling of keyboard input and mouse manipulations, and it also manages selections. There is a 1:1 relation between view and controller at run-time. Separating part of a view into a controller object improves extensibility (different controllers could be implemented for the same view, and the same controller works with all concrete view implementations) and it also allows to reduce complexity: the controller of a complex view, such as a container view, can become large, which makes the separation of concerns into different types (and typically into different modules) a good idea. In terms of design patterns, a controller is a strategy object.
The container abstractions of BlackBox have been designed to abstract from specific container user interfaces. This means that details of the container look-and-feel (such as the hatched focus marks of an OLE object) are hidden from the developer. In turn, this makes it possible to implement containers in different ways for different platforms, without affecting the developer of containers. In particular, the OLE and Apple OpenDoc container look-and-feel have been implemented. While OpenDoc isn't relevant anymore, some of the human interface guidelines developed for it are still useful today.
2.8 Event handling
When a user interacts with a compound document, this interaction always occurs in one view at a time. This view is called the current focus. By clicking around, the user can change the current focus. Among other events, the focus handles keyboard events, i.e., a keypress is interpreted by the focused view. The focus view and its containing views are called the focus path, with the innermost view being the focus.
It is possible to let a user interface framework manage the current focus. This requires a central manager for the focus. A more light-weight approach is to make focus management a decentral activity: leave focus management to the individual container views, which have to deal with focus changes and focus rendering anyway. Every container simply remembers which of its embedded views is the current focus, if any. The container is oblivious whether this view is on the current focus path or not.
In BlackBox, user events are sent along the focus path as message records, starting at the outermost view. Messages records are static (stack-allocated) variables of some subtype of Controllers.Message. There are controller messages for keyboard input, mouse tracking, drag & drop, and so on. A controller message is forwarded along the focus path until one of the views either interprets it or discards it. This view by definition is the focus.
In terms of design patterns, the focus path is a chain of responsibility.
What happens when the focus view receives and interprets a controller message? The view (or its model, if it has one) performs some operation on its own state. If this operation affects persistent state of the view or model, it should be reversible ("undoable"). How is an undo/redo mechanism implemented?
The main idea is that upon receipt of a controller message, the view / model doesn't perform a state modification directly. Instead, it creates a special operation object and registers it in the framework. The framework then can call the operation's appropriate procedure for performing the actual do/undo/redo functionality.
Operations are managed per document. Every document contains two operation stacks; one is the undo stack, the other is the redo stack. Executing an operation for the first time pushes the object on the undo stack and clears the redo stack. When the user performs an undo, the operation on top of the undo stack is undone, removed from the undo stack, and pushed onto the redo stack. When the user performs a redo, the operation on top of the redo stack is redone, removed from the redo stack, and pushed onto the undo stack.
A document's undo and redo stacks are cleared when the document is saved (check point). Furthermore, they may be cleared or made shallower when the framework runs out of memory. For this purpose, the garbage collector informs the framework about low-memory conditions, so old operation objects can be thrown away.
Some operations, such as a moving drag & drop (in contrast to the normal copying drag & drop), modify two documents simultaneously. In these rare cases, two operations are created: one for the source document (e.g., a delete operation) and one for the destination document (e.g., an insert operation).
Figure 2-16. Sequence of operations and resulting modifications of undo and redo stacks.
In Figure 2-16, a sequence of operations is shown, from 1) to 8). For the last five situations, the resulting undo and redo stacks are shown. For example, after operation 5), the undo stack contains the operations Inserting, Set Properties, and Inserting (from top to bottom of stack), while the redo stack contains Deleting.
The undo/redo mechanism is only concerned with the persistent state of a document. This is the state which can be saved in a file. Modifications of temporary state, such as a view's scroll position, are not recorded as operations, and thus cannot be undone (at least for root views).
Undoable operations either modify the persistent state of a view, or of its model (controller state is mostly temporary). The framework knows to which document a persistent object belongs, because all persistent objects of a document share the same domain. Domains will be discussed in Part III where the store mechanism is discussed in more detail.
The BlackBox Component Framework is unique in that its undo/redo mechanism is component-oriented: it allows to compose undoable operations into compound operations, which are undoable as a whole. Without this capability, nested operations would be recorded as a flat sequence of atomic operations.
Consider what this would mean for the end user. It would mean that the user could execute a menu command, which causes the execution of a hierarchy of operations. So far so good. But when the user wanted to undo this command, he or she would have to execute Edit->Undo individually for every single operation of the command, instead of only once.
For this reason, BlackBox provides support for arbitrarily nested operations: modules Models and Views both export a pair of BeginScript / EndScript procedures. In this context, "script" means a sequence or hierarchy of atomic operations which is undoable as a whole. Model and view operations can be freely mixed in a script.
Abstract operations are very light-weight. They only provide one single parameterless procedure, called Do. This procedure must be implemented in a reversible way, so that if it is executed an even number of times, it has no effect. If it is executed an odd number of times, it has the same effect as when it is executed once.
In the design patterns terminology, an operation is called a command.
2.9 Controls
Controls are light-weight views that only provide very specific functionality, which only makes sense in concert with other controls and a container. Typical controls are command buttons and text entry fields. They are used in dialog boxes or date entry forms. The parameters or other data being represented by a control must somehow be manipulated by a corresponding program. For example, a Find command takes a search string as input, or the data entered into a form must be sent to an SQL database. There may even be complicated interactions between the controls of a form. For example, when a search string is empty, the Find button may be disabled. If something is typed in, the button is enabled. Such interactions can become very involved.
In principle, a control is simply an observer view on its data. This means that it would be most straight-forward to implement the data (e.g., the search string) as a model.
For BlackBox, it was felt that this approach is too heavy-weight and unconvenient. Instead, a special implementation of the observer pattern was realized, where typical applications never need to access control objects directly. They are completely "abstracted away". The programmer only deals with the observed data. In order to make the definition and manipulation of this data as convenient as possible, it is simply a global Component Pascal variable, called an interactor. A control has a symbolic name (e.g. "TextCmds.find.ignoreCase") which enables it to find its variable, using built-in metaprogramming facilities of BlackBox. In the interactor's module itself, there is no object reference to a control.
When a control is being edited, it transparently uses the standard change propagation mechanism of BlackBox, i.e., it broadcasts view messages that notify other controls which may display the same variable.
Although the interactor's module doesn't have access to its controls, it can still influence the way controls are displayed (e.g., enabled or disabled) and the way they interact with each other. This is done by exporting suitable guard and notifier procedures. They are attached to a control in the same way as its interactor link, using a suitable control property editor. The important thing is that the program need not access the controls directly, and no direct control-to-control interactions need to be programmed. This greatly simplifies the implementation and maintenance of complex user interface behaviors. The mechanism is described in more detail in Chapter 4.
In principle, the framework accesses the interactor's module (via metaprogramming) as a singleton mediator.
3 BlackBox Design Practices
In the previous chapters, various patterns and design approaches have been described. They help to solve problems that occur in interactive compound document applications. In this chapter, more general aspects are discussed which help to make a framework component-oriented, i.e., extensible through dynamically loaded black-box components.
We don't attempt to create a full design method that gives step-by-step recipes for how to design a new framework. This would not be realistic. But we want to demonstrate and motivate the practices, approaches, and patterns that have been followed in the design of the BlackBox Component Framework. Some of the design practices have even led to the incorporation of specific framework-related features into the language Component Pascal. Language support for framework design is discussed first, followed by the way Component Pascal components are managed, and the rules which govern many component collaborations in BlackBox.
3.1 Language support
A framework embodies a collection of design patterns, cast into the notation of a particular programming language. Thus the expressiveness of the language, in particular of its interface definition subset, has a major impact on how much of the framework's design can be captured directly in code. Capturing architectural decisions and design patterns explicitly in the language is important for making refactoring of a framework less risky. Refactoring of a framework and its extension components allows to prevent that old architectures grow into brittle structures that threaten to collapse under their own weight. Preventing architecture degradation is the key to keeping software systems productive over a longer period of time, especially if the software consists of components that are replaced, added, or removed incrementally over time.
A framework represents an architecture for solving a certain class of problems. A good architecture uses a minimal number of design patterns wherever they are applicable. Consistent use of design patterns make the framework easier to document and easier to comprehend.
Design patterns are abstract solutions to a problem. For a framework, they need to be formulated in terms of a concrete programming language. The programming language has a large influence on how well the design pattern can be represented and how well consistency with the pattern can be maintained.
There are two major "philosophies" of programming language design. One of them is exemplified by the language C. C is a terse systems programming language which allows to easily and efficiently manipulate memory data structures. The other approach is exemplified by Pascal. Pascal is a readable application programming language which provides a high degree of safety.
The C approach is particularly adequate for writing low-level code such as device drivers. When C was increasingly being used for applications as well, a zero errors ideology formed, which says that because programming errors must not occur, they will not occur. A "real programmer" doesn't make mistakes, and therefore doesn't need any kind of protection facilities forced upon him by the language. Safety features such as index overflow checks are for beginners only; for professionals they are merely a handicap.
However, modern psychological research has clearly shown that humans make mistakes all the time, whether they write programs, develop mathematical proofs, fly airplanes, or perform operations on a patient. Mistakes are made whether or not they are admitted. The important insight is that most mistakes can be corrected easily if they are detected early on. Detection works best in an openly communicating team, where a team member is not afraid of others double-checking his or her work (and thereby exposing the mistakes). Good airlines let their pilots train such cooperative behavior under stress. Some very forward-thinking clinics use a similar training for surgeons and their aides. They have overcome the zero errors ideology in their fields.
In the world of programming, a reverse trend has shaped the industry in the last ten years, by making C the language of choice for all kinds of programs. In terms of software engineering and safety consciousness, this was a huge step backwards behind the state-of-the-art. Large companies tried to limit the damage by imposing the use of tools that reintroduce at least a modest level of safety ђ instead of solving the problems where it costs least, namely at the language level.
But while it is difficult for a programmer to admit that he makes mistakes, it is much easier for him to acknowledge that other programmers make mistakes. This became relevant with the Internet. The Internet makes it easy and sometimes even automatic to download and execute small programs ("applets") from unknown sites. This code clearly cannot be trusted in general. Foor good reason, this has scared large corporations enough to look at safer languages again. In fact, safety concerns were the reason why the language Java was created in the first place. Superficially, Java looks similar to C++; but unlike C and C++, it is completely typesafe, like Component Pascal.
In Component Pascal, objects and their classes (record types) may be hidden completely in a module, or they may be wholly exported, i.e., they and their parts (record fields / instance variables) may be made completely visible outside of the defining module. In practice, it is useful to have even more control. For this reason, Component Pascal allows to determine for each record field whether it is fully exported, read-only exported, or hidden. The following example (Figure 3-1) shows how the asterisk ("*") is used for export, and the dash ("-") is used for the more restricted read-only export:
MODULE ObxSample;
TYPE
File* = POINTER TO RECORD
len: INTEGER (* hidden instance variable *)
END;
Rider* = POINTER TO RECORD
(* there may be several riders on one file *)
file-: File; (* read-only instance variable *)
eof*: BOOLEAN; (* fully exported instance variable *)
pos: INTEGER (* hidden instance variable *)
(* Invariant: (pos >= 0) & (pos < file.len) *)
END;
PROCEDURE (f: File) GetLength* (OUT length: INTEGER), NEW;
BEGIN
length := f.len
END GetLength;
PROCEDURE (rd: Rider) SetPos* (pos: INTEGER), NEW;
BEGIN
(* assert invariants, so that errors may not be propagated across components *)
ASSERT(pos >= 0); ASSERT(pos < rd.file.len);
rd.pos := pos
END SetPos;
...
END ObxSample.
Listing 3-1. Sample module in Component Pascal
Java does not support read-only export, but it does support protected fields, which are fields that are only visible to extensions of a class, but not to normal clients. This feature is only relevant if implementation inheritance is used across module boundaries. For reasons that go beyond the scope of this text, implementation inheritance is not a good idea across black-box abstractions, such as components, and thus should not normally be used across component boundaries or in component framework interfaces. Protected export is thus not supported by Component Pascal.
Safety means different things to different people. On the one hand, C++ can be considered safer than plain C. On the other hand, the Internet also raises concerns that go beyond mere safety; security has to be considered as well (i.e., unauthorized access, criminal attacks, and so on). Security issues are a matter of authorization and authorization checking and are generally dealt with at the operating system or hardware level. Higher-level security features are a matter of library definition and implementation. However, overheads incurred by the excessive crossing of hardware protection boundaries can be avoided if it is possible to build on strong safety properties of the used language(s), which leads us back to the question of safety. But what exactly is "safety"?
In short, "safety" of a programming language means that its definition allows to specify invariants, and that its implementation guarantees that these invariants are kept. (The availability of a trusted implementation must be assumed; this trust is usually earned by successfully surviving attacks.) In short: safety is "invariants taken seriously".
What kinds of invariants are we talking about? The most fundamental invariants are the memory invariants: memory occupied by a variable is only used in the way that the language (e.g., a type declaration) allows. In practice, this means that arbitrary type casting must be ruled out and that manual deallocation of dynamic data structures is not permitted anymore, because deallocation could happen too early, and some still used memory could be reallocated and thus being used simultaneously by two unrelated variables. These dangling pointers are usually desastrous, but can be avoided completely if garbage collection is used instead of manual deallocation. Consequently, Java and Component Pascal are garbage-collected.
Memory invariants are fundamental. More application-specific invariants are typically established over several cooperating objects. For example, an object which represents a file access path must always have a current position which lies within the length of the file, where the file is represented by a second object. This invariant spans two objects (and thus classes). It can only be guaranteed if the programming language allows to define interactions between the two objects that are private to them, so that no outside code may interfere.
Note that this is different from the "protected" relation discussed above. Rather than covering the relation between a base class and its yet unknown subclasses, the issue here is classes that have been co-designed and will always be used in conjunction. A module or package construct is a suitable structured means to allow the definition of such higher-order safety properties. Java packages are not ideal in this respect. Since Java packages are open modules, new classes can be added to a package at run-time, and may well violate the invariants that have been established earlier. Such addition of "foreign" classes to a package thus needs to be prevented by run-time management facilities that are beyond the control of the language definition. In Java, this is related to the concept of unique ownership: every package is conceptually owned by its source and only that single source should have authority to add new classes to a package. In any case, the Java package construct is an improvement over most other object-oriented languages, for example the entirely unstructured approach of C++'s friend classes, or the complete absence of a suitable construct in standard Smalltalk.
In contrast to Java packages, Component Pascal supports closed modules, or modules for short. In Component Pascal, a module is the appropriate unit of compilation, loading, and information hiding.
Applying strong typing and information hiding makes it easier to catch mistakes as early as possible, when they are still easy and inexpensive to correct. This is valuable because it helps increase the program's robustness.
But the benefits of type and module safety go even further. They also provide more flexibility. This is surprising at first sight. Why should restrictions such as types (which restrict the operations on variables) and modules (which restrict visibility) create anything else than reduced flexibility? The reason for this so-called refactoring paradoxon is two-fold. On the one hand, everything that is completely hidden in a module may be changed only by considering this one module. Local changes in the hidden part of the module don't reverberate beyond the module itself. Not even recompilation of other client modules is necessary. On the other hand, when a well-typed interface for some reason is changed, then mere recompilation of the clients will detect the interface usages that have become inconsistent, e.g., after a parameter's type or a method name was changed. A compiler thus can actually increase the confidence in a software system which has been "refactored" due to some interface changes.
By checking typed interfaces at a carefully chosen level of granularity, a balance can be struck between release-to-release binary compatibility and detection of definite inconsistencies. Component Pascal supports an expressive type system to allow the detection of such inconsistencies. For example, newly introduced methods must be marked as NEW, and VAR parameters can be specialized to IN or OUT parameters. In Java, for example, it is not possible to distinguish between a new method, an overloading attempt, and an overriding attempt. By misspelling a method name, by changing a base or a subclass, or by combining incompatible versions, this ambiguity can lead to errors that are hard to track.
A framework typically predefines interfaces for extensions of the framework. The framework may even contain code that uses these interfaces, although no implementation exists yet. The calling of code that resides "higher up" in the module hierarchy is typical for object-oriented frameworks. A language can support this typical framework control flow pattern by providing some form of interfaces, which are abstract classes to be implemented elsewhere. Component Pascal supports abstract record types with single inheritance, in a way that a complete spectrum between fully abstract and fully concrete types are possible. Java is similar to Component Pascal in this respect, except that it additionally supports a separate interface construct. A Java interface is the same thing as a fully abstract class, except that it allows multiple (interface) inheritance.
MODULE TestViews;
TYPE
View* = POINTER TO ABSTRACT RECORD
(* partially abstract type *)
context-: Context;
... some hidden fields ...
END;
Context* = POINTER TO ABSTRACT RECORD END;
(* fully abstract type *)
PROCEDURE (v: View) Restore* (l, t, r, b: INTEGER), NEW, ABSTRACT;
...
END TestViews.
Listing 3-2. Semi-abstract and abstract record types in Component Pascal
Invariants are properties that supposedly stay invariant. Thus it is questionable whether even a subtype (subclass / extended type) should be allowed to arbitrarily modify the behavior of its basetype. In object-oriented languages, such modifications can be achieved by overriding inherited methods. Java allows to make classes or methods final, to give the framework designer the possibility to prevent any kind of invariant violation through the back door of overriding. Component Pascal record types and methods are final by default, they can be marked as extensible explicitly.
Component Pascal goes beyond Java with several other language constructs. One are limited records. Those are records that may be extended and allocated only within their defining module. From the perspective of importing modules, limited types are final and not even allocatable. This makes it possible to guarantee that all allocation occurs centrally in the defining (framework) module, which gives this module full control over initialization. For example, it may provide factory functions that allocate an object and initialize it in different ways, establishing invariants before the objects are passed to client modules. This is more flexible and simpler than constructors as used in Java.
Implement-only export is a prime example of a feature motivated by typical framework design patterns. A record type's methods may be exported as implement-only, by using a dash instead of an asterisk. An implement-only method can only be called inside the defining module. But it can be implemented outside the defining module, in an implementation component of the framework. For example, the BlackBox Component Framework's store mechanism uses this feature to protect a store's Internalize and Externalize methods from being called out of their correct context. Basically, the framework (in this case the Stores module) uses the implement-only methods in all possible legal ways (i.e., implements all legal kinds of use-cases), and only exports them for implementation purposes.
For methods that represent optional interfaces, the method attribute EMPTY is supported. An empty method is a fully abstract hook that can be implemented in an extension, but unlike abstract methods it need not be implemented. For example, a view has an empty HandleCtrlMsg method which need only be implemented by views that react on user input, e.g., via mouse or keyboard.
In the Design Patterns book of Gamma et. al. ["Design Patterns, Elements of Reusable Object-Oriented Software"; Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides; Addison-Wesley, 1994; ISBN 0-201-63361-2], a list of common design problems is identified. These problems often lead to unnecessary redesigns, because the software doesn't allow for a sufficient degree of change. Several of these problems are addressed by Component Pascal:
Creating an object by specifying a class explicity
Modules allow to hide classes. A hidden class cannot be instantiated directly by a client module, since it is not visible there. This makes it possible to enfore a variety of indirect allocation mechanisms.
Abstract record types allow to separate interfaces from implementations, so that abstract record types can be exported, without risking direct allocation by clients.
Like abstract types, limited record types cannot be directly allocated by clients.
Implement-only export allows to restrict the execution of allocation and initialization sequences to the defining module, which also prevents clients from binding themselves to concrete classes by instantiating them directly.
These features can be combined to develop safe implementations of all creational patterns described in Design Patterns: abstract factories, builders, factory methods, prototypes, and singletons.
Dependence on specific operations
Static record variables can be used as light-weight (stack-allocated) message objects, instead of using hard-coded method signatures or heavy-weight (heap-allocated) message objects. Message records can be forwarded, filtered, broadcast, and so on. Yet they don't violate type safety, since addresses of static records cannot be manipulated in unsafe ways.
Message records can be used to implement the chain of responsibility and observer patterns, which decouple a message sender and its receiver(s).
Dependence on hardware and software platforms
Dependence on object representations or implementations
Portability is one of the main advantages of using a true high-level language. Component Pascal abstracts from the underlying hardware, yet its semantic gap is small enough that very efficient machine code can be generated. As in Java, type sizes are defined so that data transfer between machines doesn't create problems.
Algorithmic dependencies
Parts of an algorithm can be made replaceable by using abstract methods, empty (hook) methods, or auxiliary objects. Implement-only export makes it possible to safely assign responsibilities: correct method calling sequences must be implemented by the defining module, implementing the methods must be done by the extension programmer. This feature allows to develop safe implementations of all behavioral patterns (builder, internal iterator, strategy, template method, and so on).
Tight coupling
Modules act as visibility boundaries. Thus tight coupling is possible where it is necessary (within a module's implementation), while loose coupling is possible across module boundaries. This simplifies safe implementation of virtually all design patterns.
Extending functionality by subclassing
Classes can be hidden in modules. Final or limited classes, and final methods can be exported without risk that they may be subclassed or overridden.
Inability to alter classes conveniently
Strong typing, record and method attributes such as NEW, and run-time assertions increase the confidence that an interface can be changed in a way that all clients can be made consistent again easily and reliably. This is basic software engineering, and thus important for all kinds of designs.
All these problems have one common theme: a local change may cause ripple effects that affect the entire software system. Good languages and design practices help to design for change:
Ensure that possible design changes have local effects only.
Where this is not possible, ensure that the effects are detected by the compiler.
Where this is not possible, ensure that the effects are detected at run-time as early as possible.
It is clear that there still remains a considerable gap between current state-or-the-art languages like Component Pascal, and complete specification languages that also allow to specify the semantics of a program. In the future, it will be the challenge to close those parts of the gap which have a good enough cost/benefit ratio, i.e., which help to change a component's behavior in a controlled manner, without making programs unreadable and unwriteable for average programmers.
3.2 Modules and subsystems
In this section, we give a more concrete idea of how Component Pascal code looks like and how it is managed by the BlackBox Component Builder environment. For this purpose, we have to go into more BlackBox-specific details than in the other sections of this part of the book.
All Component Pascal code lives in modules. A module is the compilation unit of Component Pascal. A module has an interface and a hidden implementation. Syntactically this is achieved by marking some items in a module, e.g., some types and procedures, as exported. Everything not exported is invisible and thus not directly accessible from outside of the module. If a module needs services of one or several other modules, it imports them. Thereby the module declares that it requires descriptions of the interfaces of the imported modules at compile-time, and suitable implementations of these modules at run-time. Listing 3-3 shows a possible implementation of a module called ObxPhoneDB. It exports three procedures for looking up phone book entries: by index, by name, and by number. Please note the asterisks which denote items as exported, in this case the type String and the three lookup procedures:
MODULE ObxPhoneDB;
CONST
maxLen = 32; (* maximum length of name/number strings *)
maxEntries = 5; (* maximum number of entries in the database *)
TYPE
String* = ARRAY maxLen OF CHAR;
Entry = RECORD
name, number: String
END;
VAR db: ARRAY maxEntries OF Entry;
PROCEDURE LookupByIndex* (index: INTEGER; OUT name, number: String);
BEGIN (* given an index, return the corresponding <name, number> pair *)
ASSERT(index >= 0);
IF index < maxEntries THEN
name := db[index].name; number := db[index].number
ELSE
name := ""; number := ""
END
END LookupByIndex;
PROCEDURE LookupByName* (name: String; OUT number: String);
VAR i: INTEGER;
BEGIN (* given a name, find the corresponding phone number *)
i := 0; WHILE (i # maxEntries) & (db[i].name # name) DO INC(i) END;
IF i # maxEntries THEN (* name found in db[i] *)
number := db[i].number
ELSE (* name not found in db[0..maxEntries-1] *)
number := ""
END
END LookupByName;
PROCEDURE LookupByNumber* (number: String; OUT name: String);
VAR i: INTEGER;
BEGIN (* given a phone number, find the corresponding name *)
i := 0; WHILE (i # maxEntries) & (db[i].number # number) DO INC(i) END;
IF i # maxEntries THEN (* number found in db[i] *)
name := db[i].name
ELSE (* number not found in db[0..maxEntries-1] *)
name := ""
END
END LookupByNumber;
BEGIN (* initialization of database contents *)
db[0].name := "Daffy Duck"; db[0].number := "310-555-1212";
db[1].name := "Wile E. Coyote"; db[1].number := "408-555-1212";
db[2].name := "Scrooge McDuck"; db[2].number := "206-555-1212";
db[3].name := "Huey Lewis"; db[3].number := "415-555-1212";
db[4].name := "Thomas Dewey"; db[4].number := "617-555-1212"
END ObxPhoneDB.
Listing 3-3. Implementation of ObxPhoneDB
Before a module can be used, it must be loaded from disk into memory. But before it can be loaded, it must be compiled (command Dev->Compile). When compiling a module, the compiler produces a code file and a symbol file. The code file contains the executable code, which can be loaded into memory. The code file is a kind of super-lightweight DLL. The compiler also produces a symbol file, which contains a binary representation of the module's interface. If a module imports other modules, the compiler reads the symbol files of all these modules, in order to check that their interfaces are used correctly. The compilation process can be visualized in the following way:
Figure 3-4. Compilation process
When you compile a module for the first time, a new symbol file is generated. In the log window, the compiler writes a message similar to the following one:
compiling "ObxPhoneDB"
new symbol file 964 640
The first of the two numbers indicates that the machine code in the new code file is 964 bytes long. The second number indicates that the module contains 320 bytes global variables (five entries in the db variable; each entry consisting of two strings with 32 elements each; each element is a 2-byte Unicode character). If a symbol file for exactly the same interface already exists, the compiler writes a shorter message:
compiling "ObxPhoneDB" 964 640
If the interface has changed, the compiler writes a new symbol file and indicates the changes compared to the old version in the log. For example, if you just have introduced procedure LookupByNumber in the most recent version, the compiler writes:
compiling "ObxPhoneDB"
LookupByNumber is new in symbol file 964 640
Symbol files are only used at compile-time, they have no meaning at run-time. In order to load a module, only its code file is needed. Modules are loaded dynamically, i.e., there is no separate linking step as required by more static languages. To see a list of currently loaded modules, call command Info->Loaded Modules. As result, a window will be opened with a contents similar to the following one:
module name bytes used clients compiled loaded Update
StdLinks Џ20639 ЏЏ1 2.7.1996 18:42:15 29.8.1996 14:31:14
StdFolds Џ20425 ЏЏ1 2.7.1996 18:41:33 29.8.1996 14:31:12
StdCmds Џ25066 ЏЏ7 2.7.1996 18:39:12 29.8.1996 14:31:00
Config ЏЏЏ125 ЏЏ0 2.7.1996 18:38:21 29.8.1996 14:31:20
Init ЏЏЏ682 ЏЏ0 2.7.1996 18:40:21 29.8.1996 14:31:05
Controls Џ78876 ЏЏ5 7.7.1996 14:14:58 29.8.1996 14:31:00
Services ЏЏ1472 ЏЏ5 2.7.1996 18:37:14 29.8.1996 14:30:54
Containers Џ37348 Џ40 2.7.1996 18:37:51 29.8.1996 14:30:52
Properties ЏЏ8337 Џ42 2.7.1996 18:37:40 29.8.1996 14:30:49
Controllers ЏЏ6037 Џ42 2.7.1996 18:37:36 29.8.1996 14:30:49
Views Џ31589 Џ49 2.7.1996 18:37:33 29.8.1996 14:30:49
Models ЏЏ4267 Џ50 2.7.1996 18:37:27 29.8.1996 14:30:48
Converters ЏЏ2189 Џ51 14.7.1996 22:45:12 29.8.1996 14:30:48
Dialog ЏЏ8979 Џ54 2.7.1996 18:37:13 29.8.1996 14:30:48
Dates ЏЏ3848 Џ45 2.7.1996 18:37:07 29.8.1996 14:30:48
Meta Џ19275 Џ11 2.7.1996 18:37:10 29.8.1996 14:30:48
Stores Џ22302 Џ53 2.7.1996 18:37:22 29.8.1996 14:30:47
Strings Џ17547 Џ15 2.7.1996 18:37:05 29.8.1996 14:30:47
Math Џ15408 ЏЏ2 3.7.1996 1:45:05 29.8.1996 14:30:47
Ports Џ10631 Џ56 2.7.1996 18:37:17 29.8.1996 14:30:46
Fonts ЏЏ1589 Џ58 2.7.1996 18:37:15 29.8.1996 14:30:46
Files ЏЏ3814 Џ62 2.7.1996 18:36:28 linked
...
Table 3-5. List of loaded modules
The list shows all loaded modules. For each module, it shows its code size in bytes, how many other modules import it, when it has been compiled, and when it has been loaded.
It is easy to get an overview over the already loaded modules, but what about modules not yet loaded? The idea of having access to a wealth of prebuilt components raises some organizational issues. How do you find out exactly which components are available? How do you find out which of the available components provide the services that you need?
This is a matter of conventions, documentation, and supporting tools. For the BlackBox Component Builder, it is a convention that collections of related components, called subsystems, are placed into separate directories; all of which are located directly in the BlackBox directory. There are subsystems like System, Std, Host, Mac, Win, Text, Form, Dev, or Obx. The whole collection of subsystems is called the BlackBox repository. The basic idea behind the repository's structure is that everything that belongs to a component (code files, symbol files, documentation, resources) are stored together in a systematic and simple directory structure, according to the rule
Keep all constituents of a component in one place.
It is only appropriate for component-oriented software that addition and removal of a component can be performed incrementally, by adding or removing a directory. All kinds of central installation or registration mechanisms which distribute the constituents of a component should be avoided, since they inevitably lead to (unnecessary) management problems.
Figure 3-6. Standard subsystems of the BlackBox Component Builder
Each subsystem directory, e.g. Obx, may contain the following subdirectories:
Figure 3-7. Structure of a typical subsystem directory
The module source is saved in a subsystem's Mod directory. The file name corresponds to the module name without its subsystem prefix; e.g., the modules ObxPhoneDB and ObxPhoneUI are stored as Obx/Mod/PhoneDB and Obx/Mod/PhoneUI, respectively. For each source file, there may be a corresponding symbol file, e.g., Obx/Sym/PhoneDB; a corresponding code file, e.g., Obx/Code/PhoneDB; and a corresponding documentation file, e.g., Obx/Docu/PhoneDB. There may be zero or more resource documents in a subsystem, e.g., Obx/Rsrc/PhoneUI. There is not necessarily a 1:1 relationship between modules and resources, although it is generally recommended to use a module name as part of a resource name, in order to simplify maintenance.
Modules whose names have the form SubMod, e.g., TextModels, FormViews, or StdCmds, are stored in their respective subsystems given by their name prefixes, e.g., Text, Form, or Std. The subsystem prefix starts with an uppercase letter and may be followed by several other uppercase letters and then by several lowercase letters or digits. The first uppercase letter afterwards denotes the particular module in the subsystem.
Modules which belong to no subsystem, i.e., modules whose names are not in the form of SubMod, are stored in a special subsystem called System. The whole BlackBox library and framework core belongs to this category, e.g., the modules Math, Files, Stores, Models, etc.
Each subsystem directory may contain the following subdirectories:
Code Directory with the executable code files, i.e., lightweight DLLs.
For example, for module "FormCmds" there is file "Form/Code/Cmds".
A module for interfacing native DLLs (Windows DLLs or Mac OS code fragments) has no code file. Docu Directory with the fully documented interfaces and other docu.
For example, for module "FormCmds" there is file "Form/Docu/Cmds".
For a module that is only used internally, its docu file is not distributed to the customer.
Often, there are further documentation files which are not specific to a particular module of the subsystem. Such files contain one or more dashes as parts of their names, e.g., "Dev/Docu/P-S-I".
Typical files are
"Sys-Map" (overview with hyperlinks to other documents of this subsystem)
"User-Man" (user manual)
"Dev-Man" (developer manual)
Mod Directory with module sources.
For example, for module "FormCmds" there is file "Form/Mod/Cmds".
For a module that is not published in source code ("white box"), its source file is not distributed to the customer.
Rsrc Directory with the subsystem's resource documents.
For example, for module "FormCmds" there is file "Form/Rsrc/Cmds".
There may be zero, one, or more resource files for one module. If there are several files, the second gets a suffix "1", the third a suffix "2", and so on. For example, "Form/Rsrc/Cmds", "Form/Rsrc/Cmds1", "Form/Rsrc/Cmds2", etc.
Often, there are further resource files which are not specific to a particular module of the subsystem.
Typical files are
"Strings" (string resources of this subsystem)
"Menus" (menus of this subsystem)
Sym Directory with the symbol files.
For example, for module "FormCmds" there is file "Form/Sym/Cmds".
For a module that is only used internally, its symbol file is not distributed to the customer.
Table 3-8. Contents of the standard subsystem subdirectories
If you want to find out about the repository, its subsystems and their subdirectories, you can invoke the command Info->Repository. If you want to find out more about a module, you can select the module name in a text and then execute Info->Source, Info->Interface or Info->Documentation. These commands open the module's Mod, Sym or Docu files. For this purpose, Info->Interface converts the binary representation of the symbol file into a readable textual description. For example, type the string "ObxPhoneDB" into the log window, select the string, and then execute the Info->Interface browser command. As a result, the following text will be opened in a new window:
DEFINITION ObxPhoneDB;
TYPE
String = ARRAY 32 OF CHAR;
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: String);
PROCEDURE LookupByName (name: String; OUT number: String);
PROCEDURE LookupByNumber (number: String; OUT name: String);
END ObxPhoneDB.
Listing 3-9. Definition of ObxPhoneDB
A module definition as generated by the browser syntactically is a subset of the module implementation, except for the keyword MODULE which is replaced by DEFINITION. This syntax can be regarded as the interface description language (IDL) of Component Pascal. Texts in this language are usually created out of complete module sources by the browser or similar tools, and thus need not be written manually and cannot be compiled.
Since the browser command operates on the symbol file of a module, it can be used even if there is neither a true documentation nor a code file available. During prototyping, where documentation is rarely available, the symbol file browser is very convenient for quickly looking up details like the signature of a procedure, or to get an overview over the interface of an entire module. When a full documentation is available, the command Info->Documentation can be used. It opens the module's documentation file, which starts with the definition of the module's interface just like above, but then continues with an explanation of the module's purpose and a detailed description of the various items exported by the module, for example:
Module ObxPhoneDB provides access to a phone database. Access may happen by index, by name, or by number. An entry consists of a name and a phone number string. Neither may be empty. The smallest index is 0, and all entries are contiguous.
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: ARRAY OF CHAR)
Return the <name, number> pair of entry index. If the index is too large, <"", ""> is returned.
The procedure operates in constant time.
Pre
index >= 0 20
Post
index is legal
name # "" & number # ""
index is not legal
name = "" & number = ""
PROCEDURE LookupByName (name: ARRAY OF CHAR; OUT number: ARRAY OF CHAR)
Returns a phone number associated with name, or "" if no entry for name is found.
The procedure operates in linear time, depending on the size of the database.
Post
name found
number # ""
name not found
number = ""
PROCEDURE LookupByNumber (number: ARRAY OF CHAR; OUT name: ARRAY OF CHAR)
Returns the name associated with number, or "" if no entry for number is found.
The procedure operates in linear time, depending on the size of the database.
Post
number found
name # ""
number not found
name = ""
Listing 3-10. Documentation of ObxPhoneDB
Note that preconditions and postconditions are documented in a semi-formal notation. Their goal is not to give a complete formal specification, but rather to help making the plain text description less ambiguous, where this is possible without using overly complex (and thus unreadable) formal conditions. The following assertion numbers are used for run-time checking in BlackBox:
Free 0 .. 19
Preconditions 20 .. 59
Postconditions 60 .. 99
Invariants 100 .. 120
Reserved 121 .. 125
Not Yet Implemented 126
Reserved 127
Listing 3-11. Assertion numbers in BlackBox
It is well known that the detection of an error is more difficult and more expensive the later it occurs, i.e., the farther apart the cause and its effects are. This motivates the following design rule:
Let errors become manifest as early as possible.
In a component-oriented system, defects should always be contained within their components, and not be allowed to propagate into other components. The other components may even be black-boxes for which no source code is available, which makes source-level debugging impossible. Furthermore, the control flow of a large object-oriented software system is so convoluted that it is unrealistic, and thus a waste of time, to trace it beyond component boundaries for debugging purposes.
The only viable debugging approach is to design everything, from programming language to libraries to components and applications using a defensive programming style. In particular, entry points into components (procedure/method calls) should refuse to execute if their preconditions are not met:
Never let errors propagate beyond component boundaries.
Fortunately, most precondition checks are inexpensive and thus their run-time overhead is negligible. This is important because in a component-oriented system, run-time checks cannot be switched off in a production system, because there are no separate development and production systems. In practice, most components during development are already debugged ("production") black-boxes, and the others are currently being debugged white-boxes. The production components must cooperate in order to make adherence to the above rule possible, which means never switching off run-time checks.
3.3 Bottleneck interfaces
One particular pattern that we would like to discuss here is the Carrier-Rider-Mapper pattern. This pattern is used in several ways in the BlackBox Component Framework: in the text subsystem, in the file abstraction, in the frame abstraction, in the container/context abstraction, and others. Let us consider texts as an example.
We regard a text as a so-called carrier. A carrier is an object that carries (contains) data, in this case textual data. Basically, a text can be regarded as a linear stream of elements, where elements have attributes such as font, color, style and vertical offset (for subscript and superscript characters). Elements are characters or views. For all practical purposes, a view in a text can simply be regarded as a special character.
When reading a text, it is convenient not to require the specification of a text position for each and every character read. This convenience can be achieved by supporting a current position, i.e., the text itself knows where to read the next character. Each read operation automatically increments the current position.
Several client objects may use a text carrier independently. For example, a text view needs to read its text when it redraws the text on screen, and a menu command may need to read the same text as its input. These clients are independent of each other; they don't need to know about each other. For this reason, the current read position cannot be stored in the text carrier itself, since this would mean that clients could interfere with each other and lose their independence.
To avoid such interference, a carrier provides allocation functions that return so-called rider objects. A rider is an independent access path to a carrier's data. Every text rider has its own current position, and possibly further state such as the current attributes.
Figure 3-12. Carrier-Rider separation
The reason why carrier and rider are separated into different data types is the one-to-many relationship between the two: for one carrier there may be an arbitrary number (including zero) riders.
Typically, carrier and rider need to be implemented by the same component, since a rider must have intimate knowledge about the internals of its carrier. For example, text riders and text carriers are both implemented in module TextModels. A text rider contains hidden pointers to the internal data structure of a text carrier. Since this information is completely hidden by the module boundary of TextModels, no outside client can make a rider inconsistent with its carrier. This kind of invariant, guaranteed by Component Pascal's module system, is an example why information hiding beyond single classes is important for safety reasons.
In the design patterns terminology, a text rider is an external iterator. However, not all riders are necessarily iterators. For example, a context object managed by a container is not an iterator.
Text riders come in two flavors: readers and writers. Readers support the reading of characters and views, while writers support the writing of characters and views. For example, the following calls may be made:
reader.ReadView(view)
or
writer.WriteChar("X")
Often, a programmer needs to read or write complex character sequences, so that working at the level of individual characters is too cumbersome. A higher-level abstraction for reading and writing is clearly desirable. This is the purpose of the mappers. A mapper contains a rider that it uses to provide more problem-oriented operations for reading or for writing. Since there exist very different programming problems, different applications may use different mappers, possibly even while working with the same carrier.
For text manipulation, BlackBox provides module TextMappers, which defines and implements two text mappers: formatters for writing, and scanners for reading.
Figure 3-13. Carrier-Rider-Mapper separation
Both scanner and formatter work on the level of Component Pascal symbols: with integer numbers, real numbers, strings, and so on. For example, the following calls may be made:
scanner.ReadInt(int)
or
formatter.WriteReal(3.14)
If there are different mappers for the same kind of carrier, they all have to be implemented in terms of the rider interface. For this reason, the rider/carrier interface is sometimes called a bottleneck interface. The reason why riders and mappers are separated is not a one-to-many relation as with carrier and rider ђ there is a one-to-one relation between mapper and rider ђ but independent extensibility: special circumstances may require special mappers. If carriers and mappers adhere to a well-defined rider (bottleneck) interface, it is possible to add new mappers anytime, and to use them with the same carrier.
Even better: the carrier/rider interface can be an abstract interface, such that different implementations of it may exist. For example, a file carrier may be implemented differently for floppy disk files, hard disk files, CD-ROM files, and network files. But if they all implement the same bottleneck interface, then all file mappers can operate on all file implementations! Compare this with a situation where you would have to re-implement all mappers for all carriers: instead of implementing n carriers plus m mappers, you would have to implement n carriers plus n * m mappers! Wherever such an extensibility in two dimensions occurs (carrier/rider and mapper), a bottleneck interface is needed to avoid the so-called cartesian product problem, i.e., an explosion of implementations.
Note that a bottleneck interface is not extensible itself, because every extension that cannot be implemented in terms of the bottleneck interface invalidates all its existing implementations. For example, if you extend the interface of a device driver for black-and-white bitmap displays by a color extension, then all existing device driver implementations will have to be updated. Since they probably have been implemented by different companies, this can become a major problem.
The problem can be defused if the new interface extension is specified as optional: then clients must test whether the option is supported. If not, a client either has to signal that it cannot operate in this environment, or it must gracefully degrade by providing a more limited functionality. If the optional interface is supported and used, it acts as a kind of "conspiracy" between the interface implementation and its client. This is admissible, but it clearly reduces the combinations of clients and implementations that are fully functional. This underlines how crucial good bottleneck designs are, in order to avoid the need for later extensions.
Figure 3-14. Extensibility in two dimensions
In terms of design patterns, the Carrier-Rider-Mapper pattern solves the problem of flexible and convenient access to a data carrier, however it is implemented. It can be regarded to consist of two simpler and very basic design patterns: the separation of one object into several objects to allow many-to-one relations; and the separation of one object into two objects to allow for independent extensibility:
Split an abstraction into two interfaces if several clients may access an instance simultaneously, and if independent state may have to be managed for every client.
Split an abstraction into two interfaces, if it needs to be extended independently in two different dimensions.
The Carrier-Rider-Mapper separation goes back to a research project ["Insight ETHOS: On Object-Orientation in Operating Systems"; Clemens Szyperski; vdf, Zьrich, 1992, ISBN 3 7281 1948 2] predating BlackBox. This project used several design patterns and design rules (e.g., avoidance of implementation inheritance) that are also described in Design Patterns. In the Design Patterns terminology, a Rider-Mapper combination (or Carrier-Mapper combination if there is no rider) forms a bridge pattern.
In BlackBox, riders are often created and managed in a particular way. A rider is typically under exclusive control of one client object, because after all, the reason why there can be multiple riders on one carrier (and thus why the two are distinguished) is precisely to allow several clients access to the carrier's data via their private access paths. Since riders are used in such controlled environments, BlackBox usually creates riders in the following way:
rider := carrier.NewRider(rider);
The idea is that if there already exists an old rider that isn't used anymore, it can be recycled. Recycling is done by the NewRider factory method (see next section) if possible. Of course, recycling is only legal if the old rider isn't used anymore for something else (possibly by someone else); that's why it is important that the rider is maintained in a controlled environment.
Typically, a NewRider procedure is implemented in the following way:
PROCEDURE (o: Obj) NewRider (old: Rider): Rider;
VAR r: RiderImplementation;
BEGIN
IF (old # NIL) & (old IS RiderImplementation) THEN (* recycle old rider *)
r := old(RiderImplementation)
ELSE (* allocate new rider *)
NEW(r)
END;
... initialize r ...
RETURN r
END NewRider;
Listing 3-15. Rider recycling
This approach is used in BlackBox for files, texts, and forms. It can make a considerable difference in efficiency, depending on the kind of application. However, where efficiency is not a concern, it is probably a good idea to omit this mechanism, thereby avoiding any possibility for inadvertant reuse of riders in different contexts simultaneously.
3.4 Object creation
The BlackBox Component Framework is mostly a black-box design. It strictly separates interface from implementation. A client can only import, and thus directly use or manipulate, interfaces of objects. The implementations are hidden within the modules. This enforces that module clients adhere to the following design rule (Gamma et.al.):
Program to an interface, not to an implementation.
In Component Pascal, object interfaces are represented as abstract record types. An implementation of an abstract record type is a concrete extension of it. Typically, implementations are not exported and thus cannot be extended ("subclassed") in other modules, meaning that implementation inheritance cannot be used. Thus it is also enforced that extension programmers adhere to the following design rule (Gamma et.al.):
Favor object composition over class inheritance.
Concrete record types cannot even be instantianted directly: because a client cannot import an object implementation whose type is not exported, it cannot allocate an instance by calling NEW. This is desirable, because NEW would couple the client code forever to one particular object implementation; reuse of the code for other implementations wouldn't be possible anymore. But how can client code solve the black-box allocation problem; i.e., obtain an object implementation without specific knowledge of it?
Figure 3-16. Exported interface records and hidden implementation records
Instead of calling NEW it might be possible to call an allocation function instead, a so-called factory function. For example, module TextModels might export a function New that allocates and returns a text model. Internally, it would execute a NEW on the non-exported implementation type and possibly perform some initialization. This would be better than clients directly calling NEW, because the allocating module can guarantee correct initialization, and a new release of the module could perform allocation or initialization in some different way without affecting clients. However, static factory functions are still too inflexible. A proper solution of the black-box allocation problem requires a level of indirection. There are several approaches to achieve this. They are called creational patterns. BlackBox uses four major creational patterns: prototypes, factory methods, directory objects, and factory managers. They are discussed one by one.
Sometimes it is necessary to create an object of the same type as some other already existing object. In this case, the existing object is called a prototype, which provides a factory function or initialization method. BlackBox models can act as prototypes. For example, it is possible to clone a prototype and to let the prototype initialize its clone. This makes sure that the newly created object has exactly the same concrete type as the prototype, and it allows the prototype and its clone(s) to share caches for performance reasons. For example, a BlackBox text model and its clones share the same spill file that they use for buffering temporary data. Sharing avoids the proliferation of open files.
Sometimes there exists an object that can be used to create an object of another type. For this purpose, the existing object provides a factory function, a factory method. Possibly, the object may provide different factory methods which support different initialization strategies or which create different types of concrete objects.
In BlackBox, a text model provides the procedures NewReader and NewWriter, which generate new readers and writers. They are rider objects that represent access paths to a text.
Factory methods are appropriate for objects that are implemented simultaneously ("implementation covariance"). This is always the case for riders and their carriers.
But this approach is not sufficient for allocating the text models themselves. Where does the first text model come from? BlackBox uses special objects with factory methods, so-called factory objects. In BlackBox, factory objects are used in a particular way: they are installed in global variables and may be replaced at run-time, without affecting client code. For historical reasons, we call factory objects which are used for configuration purposes directory objects.
For example, module TextModels exports the type Directory which contains a New function, furthermore it exports the two variables dir and stdDir and the procedure SetDir. By default, TextModels.dir is used by client code to allocate new empty text models. TextModels.stdDir contains the default implementation of a text model, which is mostly useful during the debugging of a new text model implementation. For example, you could use the old directory while developing a new text model implementation. When the new one is ready you install its directory object by calling SetDir, thereby upgrading the text subsystem to the new implementation on the fly. From this time, newly created texts will have the new implementation. Texts with the old implementation won't be affected. If the new implementation has errors, the default implementation can be reinstalled by calling TextModels.SetDir(TextModels.stdDir). The text subsystem uses directory objects in this typical way; the same design pattern can be found in other container model abstractions; e.g., for forms models. In BlackBox, it is even used for much simpler models and views; e.g., for DevMarkers.
Note that objects allocated via directories are often persistent and their implementation thus long-lived. For this reason, several different implementations appear over time which have to be used simultaneously.
Typically, the normal default directory objects of a subsystem are installed automatically when the subsystem is loaded. If other directory objects should be installed, a Config module is used to set up the desired directory object configuration upon startup.
The name "directory object" comes from another use of the directory design pattern: in module Files, a file can be created by using the directory object Files.dir. But a Files.Directory also provides means to find out more about the current configuration of the file system (e.g., procedure Files.Directory.FileList).
File directories are interesting also because they show that a replacement directory may sometimes need to forward to the replaced directory object. For example, if the new directory implements special memory files, which are distinguished by names that begin with "M:\", then the new directory must check at each file lookup whether the name begins with the above pattern. If so, it is a memory file. If not, it is a normal file and must be handled by the old directory object.
There may exist several directory objects simultaneously. For example, if a service uses files in a particular way, it may provide its own file directory object which by default forwards to the file system's standard directory object.
Multiple directory objects and chaining of directory objects are part of the directory design pattern. This chaining part of the pattern is cascadable, if a new directory object accesses the most recent old one, instead of stdDir.
Note that unlike typical factory classes, directories are rarely extended.
Figure 3-17. Forwarding between two directory objects
Directory objects are a particularly appropriate solution when the existence of one dominating implementation of an extensible black-box type can be expected, without excluding the existence of other implementations.
On the other hand, there could also be several special directory objects for the same implementation but for different purposes. For example, there may be a special text directory object for texts that have a special default ruler useful for program texts. A program editor would then create new program text via this directory object rather than via the standard directory of the text subsystem.
A registry would be a valuable addition to directory objects. A registry is a persistent central database which stores configuration information, such as the particular directory objects to install upon startup. The problem with registries is that they contradict the decentral nature of software components, which leads to management problems such as finding registry entries that are no longer valid.
We have seen that allocation via one level of indirection is key to solving the black-box allocation problem. Directory objects are a solution involving global state. This is only desirable if this state changes rarely, and if no parallel activities occur (threads). For example, in server environments a state-free solution is often preferable. This can be achieved by parameterizing the client: the client must be passed a factory object as parameter. This makes it possible to determine the exact nature of an implementation at the "top" of a hierarchy of procedure calls, always passing the factory object "downward". This is useful since the top-level is typically much less reusable than lower-level code.
As an example, a file transfer dialog box may allow to specify the file transfer protocol along with information such as remote address, communication speed, and so on. The file transfer protocol, which indicates the implementation of a communication object, can be passed from the dialog box down to the communication software, where it is used to allocate a suitable communication object (e.g., a TCP stream object).
Instead of passing a factory object, its symbolic name may be passed. At the "bottom", a service interprets this name; if necessary loads the module which implements the corresponding factory function; and then creates an object using the factory function. In this way, the service acts as a factory manager.
This approach is used for some BlackBox services, in particular for the Sql and Comm subsystems. In both cases, the name of a module can be passed when allocating a new object. This module is expected to provide suitable factory functions. For Sql, the modules SqlOdbc and DtfDriver provide appropriate object implementations and factory functions. For Comm, the module CommTCP provides a suitable object implementation.
Factory managers are often more suitable for creating non-persistent objects, while directory objects are often more suitable for creating persistent objects.
Part II: Library
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
4 Forms
In the first chapter of this part, we concentrate on the forms-based composition of controls. "Forms-based" means that there exists a graphical layout editor, sometimes called a visual designer or screen painter, that allows to insert, move, resize, and delete controls. Controls can be made active by linking them to code pieces. For example, it can be defined what action should happen when a command button is clicked.
Controls can have different visible states, e.g., they can be enabled or disabled. This is a way to inform a user about which actions currently make sense. Setting up control states in a sensible way can make a large difference in the user-friendliness of an application. Unfortunately, these user interface features often require more programming effort than the actual application logic itself does. However, there are only a few concepts necessary to understand in order to build such user interfaces. These concepts will be explained by means of simple examples.
4.1 Preliminaries
We want to start as quickly as possible with a concrete example, but a few preliminary remarks are still in order. The reader is expected to have some basic knowledge of programming, preferably in some dialect of Pascal. Furthermore, he of she is expected to know how to use the platform (Windows or Macintosh), and the general user interface guidelines for the platform.
The BlackBox Component Builder is used as the tool to expose the various characteristics of component software in an exemplary way. The contents of the book applies both to the Windows and the Macintosh version of the BlackBox Component Builder; except for screendumps, which mostly use Windows 95. In order to minimize platform-specific remarks in the text, a few notational conventions are followed:
Mac OS folders are called directories
Path names contain "/" as directory separators, as in Unix and the World-Wide Web
File and directory names may contain both capital and small letters
Document file names are given without the ".odc" suffix used in Windows. Thus the file name Text/Rsrc/Find under Windows corresponds to Text\Rsrc\Find.odc on Windows 95, and to Text:Rsrc:Find under Mac OS.
Modifier key: on Windows this is the Ctrl key, on Mac OS it is the Option key
Menu commands: M->I is a shorthand notation for menu item I in menu M, e.g., File->New
When working in the BlackBox environment for the first time, the following may be helpful to remember: almost all modifications to BlackBox documents are undoable, making it quite safe to try out a feature. In general, multi-level undo is available; i.e., not only one, but several commands can be undone; as many as memory permits.
This book is not a replacement for the BlackBox user manual. It minimizes the use of specific BlackBox Component Builder tool features, and therefore the need for tool-specific descriptions. The text is intended to concentrate on programming, rather than on the tool. Where unavoidable, tool-specific explanations are given where they are first needed.
Most examples are also available on-line in the Obx/Mod directory of BlackBox. They can be opened and compiled immediately. At the end of every section, references to further Obx on-line examples for the same topic are given.
For readers who are not yet fluent in Component Pascal, Appendix B describes the differences beween Pascal and Component Pascal.
The Help screen of the BlackBox Component Builder gives direct or indirect access to the complete and extensive on-line documentation, e.g., to the user manual, to all the Obx ("Overview by example") examples, and so on. On the Web, additional resources may be found at http://www.oberon.ch.
4.2 Phone book example
Throughout this part of the book, we will meet variations of and additions to a specific example. The example is an exceedingly simple address database. The idea is not to present a full-fledged application with all possible bells and whistles, but rather a minimal example which doesn't hide the concepts to be explained behind large amounts of code. Nevertheless, the idea of how bells and whistles can be added, component by component, should become obvious over time.
Our phone book database contains the following fixed entries:
Daffy Duck 310-555-1212
Wile E. Coyote 408-555-1212
Scrooge McDuck 206-555-1212
Huey Lewis 415-555-1212
Thomas Dewey 617-555-1212
Table 4-1. Entries in phone book database
The database can be searched for a phone number, given a name. Alternatively, the database can be searched for a name, given a phone number; or its contents can be accessed by index. We have met a possible implementation of this database in section 3.2.
Our goal is to create a user interface for the database. The user interface is a dialog box that contains two edit fields; one for the name, and the other for the phone number. For each text field, there is a caption that indicates its purpose. Furthermore, the dialog box contains a check box which allows to specify whether the name or the phone number should be looked up, and finally there is a command button which invokes the lookup command. The following screendump shows how the dialog box will look like eventually:
Figure 4-2. Phone book database mask
To construct this mask, we start by creating a new empty form for the dialog box, using command Controls->New Form. This results in the following dialog box:
Figure 4-3. New Form dialog box
Clicking on the Empty command button opens an empty form:
Figure 4-4. Empty form
Using the commands of menu Controls , we insert the various controls we need, i.e., two captions, two edit fields, a check box, and a command button. The controls we've inserted still have generic labels such as "untitled" or "Caption". To change these visual properties, a control property inspector is used. It is opened by selecting a control and then issuing Edit->Object Properties... (Windows) or Edit->Part Info (Mac OS), respectively. Edit the "label" field in order to change the selected control's label, and click on the default button to make the change permanent.
Figure 4-5. Control property editor
Change the "label" field of each control so that you end up with a layout similar to the one of Figure 4-2. Listed in a tabular way, the labels are the following ones (from left to right, top to bottom):
Control type Label
Caption Name
Text Field
Caption Number
Text Field
Check Box Lookup by Name
Command Button Lookup
Table 4-6. List of controls in phone book dialog box
The controls can be rearranged by using the mouse or by using the layout commands in menu Layout. After having edited the layout, make sure to call Layout->Sort Views; this command sorts the controls in such a way that when being pressed, the tabulator key moves the cursor between them in the order you would expect, i.e., from left to right and from top to bottom.
Figure 4-7. Completed layout of phone book dialog box
When you are happy with the layout, you can save the dialog box just like any other document, by using File->Save. As a convention, the dialog box layouts of all examples are saved in directory Obx/Rsrc. In this case, we save the new dialog box as Obx/Rsrc/PhoneUI.
The directory name Rsrc stands for "Resources". Resources are documents that are necessary for a program to work. In particular, they are dialog box layouts and string resources. String resources allow to move strings out of a program's source code into a separately editable document.
Resources can be edited without recompiling anything. For example, you could change all labels in the above dialog box from English to German, without having access to any source code or development tool.
4.3 Interactors
Creating a dialog box layout is fine, but there also must be a way to add behavior to the dialog box. In our example, user interactions with the dialog box should lead to lookup operations in the phone book database. To achieve this, we need an actual implementation of the database. We mentioned earlier that a suitable implementation already exists. This is not surprising, since in this part of the book we talk about component object assembly, which means taking existing components and suitably integrating persistent objects that they implement.
In our example, the phone book database is a Component Pascal module called ObxPhoneDB. We have already met this module in Chapter 3. Now we want to write our first new module, whose purpose is to build a bridge between the database module ObxPhoneDB and the dialog box we've built earlier. The new module is called ObxPhoneUI, where "UI" stands for "user interface". It is a typical script module whose only purpose is to add behavior to a compound document, such that it can be used as a front-end for the application logic, which in our case is simply the phone book database.
The new module uses, i.e., imports, two existing modules. On the one hand, it is the ObxPhoneDB module. On the other hand, module Dialog:
Figure 4-8. Import relation between ObxPhoneUI and ObxPhoneDB
Dialog is part of a fundamental framework coming with the BlackBox Component Builder. The module provides various services that support user interaction. We'll meet the most important ones in this chapter.
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
END ObxPhoneUI.
Listing 4-9. First version of ObxPhoneUI
ObxPhoneUI exports a global record variable phone, which contains two string fields and a Boolean field. Depending on the current value of the Boolean field, the Lookup procedure either takes phone.name to look up the corresponding number, or phone.number to look up the corresponding name. If the lookup fails, i.e., returns the empty string, the result is turned into "not found". Either result is put into phone, i.e., phone carries both input and output parameters for the database lookup.
Since the user could change the contents of phone by interactively manipulating a control, e.g., by typing into a text entry field, a global variable like phone is called an interactor. Controls display the contents of their interactor fields and possibly let them be modified interactively. To do this, every control must first be linked to its corresponding interactor field. This is done with the control property editor that we have seen earlier. Its "Link" field should contain the field name, e.g., ObxPhoneDB.phone.name or a procedure name such as ObxPhoneDB.Lookup. Use the control property inspector to set up the link fields according to Table 4-10:
Control type Label Link
Caption Name
Text Field ObxPhoneUI.phone.name
Caption Number
Text Field ObxPhoneUI.phone.number
Check Box Lookup by Name ObxPhoneUI.phone.lookupByName
Command Button Lookup ObxPhoneUI.Lookup
Table 4-10. Links of phone book dialog box
Note that the previously disabled controls now have become enabled. What does this mean? When a control is linked, which normally happens when it is being read from a file, or in our case when the link is changed by the inspector, then the module to which the control should be linked must be loaded. If it is already loaded, nothing needs to be done. If it isn't loaded yet (remember that you can check with Info->Loaded Modules), loading is done now. If loading fails, e.g., because the module's code file doesn't yet exist, then control linking fails and the control remains disabled. Linking also fails if the control and field types don't match, e.g., if a check box is linked to a string field.
To achieve this level of functionality (and safety against incorrect use), BlackBox provides several advanced "metaprogramming" services, in particular dynamic module loading on demand and typesafe lookup of variables. The latter requires extensive run-time type information (RTTI) that is relatively uncommon in fully compiled languages.
The links of all controls are reevaluated whenever a module has been unloaded. This ensures that controls are never linked to unloaded modules.
It was one of the design goals for BlackBox to separate user interface details from program logic. For this reason, module ObxPhoneUI doesn't know about controls and forms and the like. Instead, the controls of our form have links, which tell them the interactor fields with which they should interact. For example, the command button's "ObxPhoneUI.Lookup" link tells it to activate the ObxPhoneUI.Lookup procedure when the button is pressed. This procedure in turn doesn't know about the command button (there even may be several of them), the only thing it does to acknowledge the possible existence of controls is to call
Dialog.Update(phone)
at the end of the command procedure. Dialog.Update causes an update of all controls that need updating. For example, if Lookup has assigned "not found" to phone.number, the corresponding text field(s) or similar controls need to be redrawn accordingly.
As parameter of Dialog.Update, an interactor must be passed. Calling Dialog.Update is necessary after one or several fields of this interactor have been modified by a program. If several fields have been modified, Dialog.Update should only be called once, for efficiency reasons. Note that a control calls Dialog.Update itself when the user has modified an interactor field; you only need to call it after your own code has modified the interactor.
This strong separation of user interface from program logic is uncommon. Its advantage is simplicity: as soon as you know how to define procedures and how to declare record types and global variables, you can already construct graphical user interfaces for modules. This is possible even for someone who is just beginning to learn programming. Another advantage is that you have to write no code for simple user interfaces. User interface construction happens in the forms editor (e.g., setting the position and size of a control) and with the inspector (e.g., setting the alignment of text in a text field). This makes it easier to adapt an application to different user interface requirements, without touching the application logic itself. Only if you want to exercise more control over the user interface, e.g., disabling controls or reacting on special events such as the user's typing, then you need to write small amounts of code, which can be very cleanly separated from the application logic itself. The necessary concepts, so-called guards and notifiers, will be discussed in the next two sections. If you need still more control, then you can access controls individually, as described in section 4.9.
Currently, a disavantage of the BlackBox Component Builder's approach is that all controls have to be linked to global interactor variables. If there are several controls for the same interactor field, all of them display the same value. The controls cannot have independent state of their own.
Note an interesting feature of BlackBox: if you have written a module like ObxPhoneUI in Listing 4-9, you can automatically generate a form with suitable controls in a default layout. This is done by clicking "Create" in the "New Form" dialog box instead of "Empty". This feature is useful to create temporary testing and debugging user interfaces during development, where it isn't useful to spend time with manual form construction.
We now have a dialog box layout with controls linked to module ObxPhoneUI, and this module imports the database engine ObxPhoneDB. What is still missing is a way to use the dialog box, rather than to merely edit its layout. During editing, it can be useful to immediately try out the dialog box, even before its layout is perfect. To try this out, make sure that the layout window is on top and then execute Controls->Open As Aux Dialog. A new window is opened which contains the same dialog box, but in a way that its controls can be edited, rather than its layout. The window acts as a data entry mask. Now you can type, for example, "Huey Lewis" into the name string, click on the "Lookup by Name" check box, and then click on the "Lookup" button. You'll see that the appropriate phone number appears in the "Number" field.
Figure 4-11. Layout view (left) and mask view (right) displaying the same form model
Note that the same name and number also appeared in the layout window. Even better, if you change the layout in the layout window, e.g., by moving the check box somewhat, you'll note that the layout change is immediately reflected in the other window. This is a result of the so-called Model-View-Controller implementation of BlackBox. In Part II of the book, we have discussed this design pattern in more detail. Here it is sufficient to note that several views can share the same data, e.g., a layout view and a mask view can display the same form; and that both layout and mask views are basically the same kind of view albeit in different modes. You can switch between these modes by applying the Dev->Layout Mode or Dev->Mask Mode commands.
The two modes differ in the ways they treat selection and focus. In layout mode, you can select the embedded views and edit the selection, but you cannot focus the embedded views. In mask mode, you can focus the embedded views, but you cannot select them (only their contents) and thus cannot edit their layout, i.e., their sizes, positions, etc. In other words: layout mode prevents focusing, while mask mode prevents selection.
Opening a second view in mask mode for our form layout is convenient during layout editing, but you wouldn't want any layout view open when your program should actually be used. In this case, you want to open the dialog box in mask mode by invoking a suitable menu command.
A new menu command can be introduced by editing a menu configuration text. You can open this text (which resides in System/Rsrc/Menus) by calling Info->Menus. Append the following text to its end:
MENU "Priv"
"Open..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')" ""
END
Having done this, execute Info->Update Menus. You'll notice that the new menu "Priv" has appeared. Execute its menu item "Open...". As a result, the command
StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')
will be executed. It opens the Obx/Rsrc/PhoneUI layout document, turns it into mask mode, and opens it in a window with title "Phonebook". If you want the modification of your menu text to become permanent, save the "Menus" text before closing it.
Note that the form has not been saved in mask mode (this would be inconvenient for later editing), it is only temporarily turned into mask mode by the StdCmds.OpenAuxDialog command.
4.4 Guards
In terms of genuine functionality, we have seen everything that is important about the standard set of controls. We will look at the palette of standard controls in more detail later. However, we first need to discuss important aspects of standard controls which, strictly speaking, do not increase the functionality of an application, but rather its useability, i.e., its user-friendliness.
In section 1.2 we have already discussed what user-friendliness means. For example, it means avoiding modes wherever possible. For this reason, BlackBox doesn't support modal dialog boxes.
Modes are unavoidable if a user action sometimes makes sense, and sometimes doesn't. For example, if the clipboard is empty, its contents cannot be pasted into a text. If it is not empty and contains text, pasting is possible. This cannot be helped, and is harmless if the current state is clearly visible or can easily be inquired by the user. For example, if the clipboard is empty, the Paste menu command can be visibly marked as disabled. The visual distinction gives the user early feedback that this command is currently not meaningful. This is usually much better than to let the user try out a command and then give an error message afterwards.
The following example shows a dialog box with two buttons. The Empty button is enabled, while the Create button is disabled. The Create button only becomes enabled if something has been typed into the dialog box's text field:
Figure 4-12. Enabled and disabled buttons
In summary, a good user interface always lets the user perform every meaningful action, and gives visual cues about actions that are not meaningful.
For the BlackBox, we thus need a way to provide feedback about the current state of the system, especially about which commands are currently possible and which aren't.
For this purpose, it must be possible to enable and disable controls and menu items. For example, looking up a phone number is only possible if some name has been entered, i.e., if the name field is not empty. To determine whether a command procedure, in our case the Lookup procedure, may be called, i.e., whether a corresponding control or menu item may be enabled, a suitable guard must be provided. A guard is a procedure called by the framework, whenever it might be necessary to change the state of a control or menu item. The guard inspects some global state of the system, uses this state to determine whether the guarded command currently makes sense, and then sets up an output parameter accordingly. A guard has the following form:
PROCEDURE XyzGuard* (VAR par: Dialog.Par);
BEGIN
par.disabled := ...some Boolean expression...
END XyzGuard;
A guard has the following type:
GuardProc = PROCEDURE (VAR par: Dialog.Par);
To guard procedure Lookup in our example, we extend module ObxPhoneUI in the following way:
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
PROCEDURE LookupGuard* (VAR par: Dialog.Par);
BEGIN (* disable if input string is empty *)
par.disabled := phone.lookupByName & (phone.name = "") OR
~phone.lookupByName & (phone.number = "")
END LookupGuard;
END ObxPhoneUI.
Listing 4-13. ObxPhoneUI with LookupGuard
What happens if we compile the above module? Its symbol file on disk is replaced by a new version, because the module interface has been changed from the previous version. Because the change is merely an addition of a global procedure (i.e., the new version is compatible with the old version) possible client modules importing ObxPhoneUI are not invalidated and need not be recompiled.
Compilation also produced a new code file on disk. However, the old version of ObxPhoneUI is still loaded in memory! In other words: once loaded, a module remains loaded ("terminate-and-stay-resident"). This is not a problem, since modules are extremely light-weight and consume little memory. However, a programmer of course must be able to unload modules without leaving the BlackBox Component Builder entirely, in order to try out a new version of a module. For this purpose, the command Dev->Unload is provided which unloads the module whose source code is currently focused.
Note that compilation does not automatically unload a module, since this is often undesirable. In particular, as soon as you work on several related modules concurrently, unloading one of them before the others are correctly updated would render this whole set of modules inconsistent.
For those cases where immediate unloading after compilation does make sense, like in the simple examples that we are currently discussing, the command Dev->Compile And Unload is provided.
You may use this command to try out our new version of ObxPhoneUI. Notice how the Lookup button is disabled when the Name field is empty (if Lookup by Name is chosen) or when the Number field is empty (if Lookup by Number is chosen). Typing something into the field makes Lookup enabled again; deleting all characters in the field disables it again. At the end of this section we will explain more precisely when guards are evaluated; for now it is sufficient to know that they are evaluated after every character typed into a text field control.
Guards are mostly used to enable and disable user interface elements such as controls or menu items. However, they sometimes play a more general role as well. For example, controls may not only be disabled, but they also may be made read-only or undefined.
Read-only means that a control currently cannot be modified interactively. For example, the following guards set up the output parameter's readOnly field. The first guard sets read-only if lookup is not by name, i.e., by number. Obviously, in this case a number is input and a name is output. Pure outputs should be read-only. Thus the first guard can be used as guard for the Name field. The second guard can be used for the Number field, since it sets read-only if lookup returns a number.
PROCEDURE NameGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by number *)
par.readOnly := ~phone.lookupByName
END NameGuard;
PROCEDURE NumberGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by name *)
par.readOnly := phone.lookupByName
END NumberGuard;
Listing 4-14. Read-only guards for ObxPhoneUI
Interactor fields which are exported read-only, i.e., with the "-" export mark instead of the "*" export mark, are always in read-only state regardless of what a guard specifies (otherwise this would violate module safety, i.e., the invariant that a read-only exported item can only be modified within its defining module).
The undefined state of a control means that the control currently has no meaning at all. This happens if a control displays the state of a heterogeneous selection. For example, a check box may indicate whether the text selection is all caps or all small letters. If part of the selection is capital letters and the rest small letters, then the control has no defined value. However, by clicking on the check box, the selection is made all caps and then has a defined state again. The undefined state can be set by a guard with the statement
par.undef := TRUE
The undefined state can be regarded as "write-only", i.e., the control's state cannot be read by the user because it currently has no defined value, but it can be modified and thus set to a defined value.
Of the fields disabled, readOnly and undef, at most one may be set to TRUE by a guard. This leads to four possible temporary states of the control: it is in none or in exactly one of the three special states. When a guard is called by the framework, all three Boolean fields are preset to FALSE. This is a general rule in BlackBox: Boolean values default to FALSE.
In Table 4-15, suitable guards for the layout of Figure 4-2 are listed:
Control type Link Guard
Caption
Text Field ObxPhoneUI.phone.name ObxPhoneUI.NameGuard
Caption
Text Field ObxPhoneUI.phone.number ObxPhoneUI.NumberGuard
Check Box ObxPhoneUI.phone.lookupByName
Command Button ObxPhoneUI.Lookup ObxPhoneUI.LookupGuard
Table 4-15. Guards in phone book dialog box
A guard applies to a procedure, to an interactor field, or to several procedures or interactor fields. If it applies to mainly one procedure or field, the guard's name is constructed by appending "Guard" to the (capitalized) name of the procedure/field. For example, the guard for procedure Lookup is called LookupGuard, the guard for field phone.name is called NameGuard, etc. This is a simple naming convention which makes it easier to recognize the relation between guard and guarded item. The naming convention is "soft", i.e., it is not enforced by the framework; in fact the framework doesn't know about it at all.
It is not a convention, but a necessity, to export guards. Guards are accessed by the so-called metaprogramming mechanism of BlackBox which, for safety reasons, only operates on exported items. This is consistent with the treatment of a module as a black-box, of which only the set of exported items, i.e., its interface, is accessible from the outside. If a guard isn't exported, a control cannot call it. This is similar to the fields of an interactor, which also must be exported if an interactor should be able to link to it.
If we look at the declaration of type Dialog.Par (use Info->Interface!), we see that two fields have not yet been discussed: label and checked:
Par = RECORD
disabled, checked, undef, readOnly: BOOLEAN;
label: Dialog.String
END
Field label allows to change the label of a control. For example, instead of using the label "Toggle" for a button it may be more telling to use the labels "Switch On" and "Switch Off" depending on the current state of the system. This can be done by a procedure like this:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "Switch Off"
ELSE
par.label := "Switch On"
END
END ToggleGuard;
Listing 4-16. Label guard example
Note that the guard overrides whatever label was set up in the control property inspector. This is true for all controls (and for menu items as well, see below).
It is strongly recommended not to place string literals in the source code like in the above example, because this would force a recompilation of the code if the language were changed, e.g., from English to German (see also section 1.4). In BlackBox, user interface strings such as labels or messages are generally packed into separate parameter files, so-called string resources. For each subsystem there can be one string resource file, e.g., Text/Rsrc/Strings or Form/Rsrc/Strings. A string resource file is a BlackBox text document starting with the keyword STRINGS and followed by an arbitrary number of <key, string> pairs. The key is a string, separated by a tab character from the actual string into which it will be mapped. Every <key, string> pair must be terminated by a carriage return. The pairs need not be arranged in any particular order, although it is helpful to sort them alphabetically by key, because this makes it easier to find a particular key when editing the string resources.
For example, System/Rsrc/Strings starts the following way:
STRINGS
About About BlackBox
AlienAttributes alien attributes
AlienCause alien cause
AlienComponent alien component
AlienControllerWarning alien controller (warning)
...
Table 4-17. String resources of System/Rsrc/Strings
To use string resources in our guard example, a special syntax must be used to indicate that the string is actually a key that first must be mapped using the appropriate subsystem's string resources. Assuming that in the Obx subsystem's string resources there exist "On" and "Off" keys, the following code emerges:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "#Obx:Off"
ELSE
par.label := "#Obx:On"
END
END ToggleGuard;
Listing 4-18. Label guard example with string mapping
The leading "#" indicates that a string mapping is desired. It is followed by the subsystem name, in this case "Obx". Then comes a colon, followed by the key to be mapped. A command button with this guard would either display the label "Switch Off" or "Switch On" in an English version of BlackBox, "Ausschalten" or "Einschalten" in a German version, and so on.
If there is no suitable string resource, the key is mapped to itself. For example, if there is no "Off" key in Obx/Rsrc/Strings, then "#Obx:Off" will be mapped to "Off".
The remaining field of Dialog.Par that we have not yet discussed is called checked. Actually, so far it has never been used for controls in BlackBox. It is used for menu items. Menu items are similar to controls: they can invoke actions, they may be enabled or disabled, and they have labels. For this reason it makes sense to use the same guard mechanism for them also. A menu guard is specified in the Menus text as a string after the menu label and the keyboard equivalent of the menu item. For example, the following entry for the Dev menu specifies the guard StdCmds.SetEditModeGuard:
"Edit Mode" "" "StdCmds.SetEditMode" "StdCmds.SetEditModeGuard"
A unique feature of menu items is that they may be checked. For example, in the following menu, menu item Edit Mode is checked:
Figure 4-19. Menu item with check mark
The check mark indicates which of the items has been selected most recently, and the state that has been established by the selection. The state can be changed by invoking one of the other menu items, e.g., Mask Mode as in the figure above. Basically, the four menu items form a group of possibilities from which one can be selected.
Guard procedures for menu items may set up the disabled, checked and label fields of Dialog.Par. The other fields are ignored for menus.
A guard procedure may set up several fields of its par output parameter simultaneously, e.g., it may assign the disabled and label fields for a command button. However, a guard may set at most one of the Boolean fields of par and must never modify any state outside of par, e.g., a field of an interactor or something else; i.e., it must have no side effects. It may not call any procedures which may have side effects either. The reason is that a program cannot assume much about when (and especially when not) a guard is being called by the framework.
A guard may use any interactor or set of interactors as its input, or the state of the current focus or selection. The latter is often used for menu guards. The current focus or selection is only used in control guards if the controls are in so-called tool dialog boxes, i.e., dialog boxes that operate on some document underneath. A Find & Replace dialog box operating on a focused text is a typical example of a tool dialog box. The other dialog boxes are self-contained and called auxiliary dialog boxes. Data entry masks are typical examples of auxiliary dialog boxes.
When is a guard evaluated? There are four reasons why a guard may be called: when the control's link is established, when the contents of an interactor is being edited, when the window hierarchy has changed, or when the user has clicked into the menu bar.
A control's link is established after it is newly inserted into a container, after it has been loaded from a file, after a module was unloaded, or after its link has been modified through the control property inspector or other tool.
When some piece of code modifies the contents of an interactor, it is required to call Dialog.Update for this interactor. As a result, every currently visible control is notified (see section 2.9). In turn, the control compares its actual state with the interactor field to which it is linked. If the interactor field has changed, the control redraws itself accordingly. After all controls have updated themselves, the guards of all visible controls are evaluated. For this reason, guards should be efficient and not perform too much processing.
Guards are also evaluated when the window hierarchy is changed, e.g., when a bottom window is brought to the top. This is necessary because many commands depend on the current focus or selection, which vanishes if another window comes to the top.
Menus are another reason why a guard may be called. When the user clicks in a menu bar, all guards of this menu, or even the guards of the whole menu bar, are evaluated.
Usually, a guard has the form
PROCEDURE SomeGuard* (VAR par: Dialog.Par)
Alternatively, the form
PROCEDURE SomeGuard* (n: INTEGER; VAR par: Dialog.Par)
may be used, which allows to parameterize a single guard procedure for several related commands. For example, the commands to set a selection to the colors red, green or blue are the following:
StdCmds.Color(00000FFH)
StdCmds.Color(000FF00H)
StdCmds.Color(0FF0000H)
For these commands, the following guards can be used:
StdCmds.ColorGuard(00000FFH)
StdCmds.ColorGuard(000FF00H)
StdCmds.ColorGuard(0FF0000H)
The actual signature of StdCmds.ColorGuard is
PROCEDURE ColorGuard (color: INTEGER; VAR par: Dialog.Par)
4.5 Notifiers
A control guard sets up the temporary state of a control, such as whether it is disabled or not. It has no other effect. It doesn't modify any interactor state. It doesn't add any functionality. It only lets the control give feedback about the currently available functionality, or its lack thereof. A guard is evaluated ,e.g., when the user changes the state of a control interactively. It can be regarded as a merely "cosmetic" feature whose sole purpose is to increase user-friendliness.
However, sometimes a user interaction should trigger more than the evaluation of guards only. In particular, it may sometimes be necessary to change some interactor state as a response to user interaction. For example, changing the selection in a selection box may cause the update of a corresponding counter, which counts the number of currently selected items in the selection box. Or some postprocessing of user input may be implemented, as we will see in the following example. It is an alternate implementation of our ObxPhoneUI example. Instead of having a Lookup button, this version just has two edit fields. After any character typed in, a database lookup is executed to test whether now a correct key is entered. Note that unsuccessful lookup in ObxPhoneDB results in returning an empty string.
MODULE ObxPhoneUI1;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String
END;
PROCEDURE NameNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByName(phone.name, phone.number);
Dialog.Update(phone)
END NameNotifier;
PROCEDURE NumberNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
Dialog.Update(phone)
END NumberNotifier;
END ObxPhoneUI1.
Listing 4-20. ObxPhoneUI1 with notifiers
These notifiers create dependencies between two fields of an interactor: a modification of one text field may lead to a modification of the other text field, i.e., a dependency between interactor fields is defined.
Notifiers are called right after an interaction happens, but before the guards are evaluated. A notifier has the following form:
PROCEDURE XyzNotifier* (op, from, to: INTEGER);
BEGIN
...
END XyzNotifier;
A notifier's type is
NotifierProc = PROCEDURE (op, from, to: INTEGER);
For simple notifiers, the parameters can be ignored. They give a more precise indication of what kind of modification actually took place. Which of the parameters are valid and what their meaning exactly is is defined separately for every kind of control. See the next section for details.
4.6 Standard controls
In this section, the various controls that come standard with the BlackBox Component Builder are presented. For each control, a list of data types to which it may be linked is given, and the meaning of the notifier parameters is indicated.
A control may have various properties, e.g., its label, or whether the label should be displayed in the normal system font or in a lighter, less flashy font. However, such cosmetic properties may not be implemented the same way on every platform, sometimes they may even be ignored.
A label may specify a keyboard shortcut, which on some platforms is used to navigate between controls without using the mouse. The shortcut character is indicated by preceding it with a "&" sign. Two successive "&" signs indicate a normal "&", without interpreting the following character as shortcut. Only one shortcut per label is allowed. For example, "Clear Text &Field" defines "F" as a keyboard shortcut, while "Find && &Replace" defines "R" as keyboard shortcut. The same syntax for keyboard shortcuts is used in menu commands.
The label property of every control can be modified at run-time, by using a guard procedure as demonstrated in Listing 4-16. For controls without visible label, this has no visible effect.
Two of the most important control properties, the guard and notifier names, are optional. If there is no guard for the control, it will use its default states (enabled, read-write, defined). If there is no notifier for the control, none will be called.
BlackBox attempts to minimize the number of different properties, in order to make it easier to use. This is consistent with the general trend, both under Windows and the Mac OS, towards globally controlled appearances. This means that a control should not define its colors, font, and so on individually. Instead, the user should be able to define a system-wide and consistent configuration of these properties.
However, if for some special reason this is still deemed important, specific fonts can be assigned to controls, simply by selecting the control(s) and applying the commands of the Font, Attributes or Characters menus. If the default font is set, then the system preferences will be used. This is the normal case. Note that other font attributes, such as styles, weight, or size, may be restricted on certain platforms. For example, on Mac OS the font size is always 12 points.
In the following text, all standard controls of BlackBox are described in turn: command buttons, edit fields, check boxes, radio buttons, date fields, time fields, color fields, captions, groups, list boxes, selection boxes and combo boxes. For each control, its valid properties are given, the variable types to which it may be linked, and the meaning of the op, from and to parameters of the notifier.
Note that there is no special control for currency values, you can use edit fields bound to variables of type Dialog.Currency instead.
In the following descriptions, some abbreviations are used:
pressed stands for Dialog.pressed
released stands for Dialog.released
changed stands for Dialog.changed
included stands for Dialog.included
excluded stands for Dialog.excluded
undefined means that the from or to parameter of a notifier has no defined value that can be relied upon
modifier means a 0 for single-clicks and a 1 for double-clicks
link, label, guard, notifier, and level stand for their respective control properties as defined in module Controls. There are up to five optional Boolean properties. Depending on the control, they are called differently, e.g. default font, default, cancel, sorted, left, right, multiLine, password.
Command Button
Figure 4-21. Command button
A command button is used to execute a parameterless Component Pascal command, or a whole command sequence. A button with the default property looks different than normal buttons; input of a carriage return corresponds to a mouse click in the default button. For a button with the cancel property, input of an escape character corresponds to a mouse click in it. A button should not be default and cancel button simultaneously. Note that the default and cancel properties are set and cleared individually per control, i.e., making one button a default button doesn't automatically make an existing default button a normal button again. There should be at most one default and at most one cancel button per dialog box.
A cancel button or another button that should close the dialog box in which it is contained can use the command StdCmds.CloseDialog.
properties: link, label, guard, notifier, font, default, cancel
linkable to: parameterless procedure, command sequence
op: pressed, released
from: undefined, modifier
to: undefined
Text Field
Figure 4-22. Text field
A text field displays the value of a global variable which may be a string, an integer, a floating-point number, or a variable of type Dialog.Currency or Dialog.Combo. The value of the variable can be changed by editing the field.
Whenever the contents of the linked interactor field is changed, the notifier is called. Key presses that do not change the interactor state, such as pressing arrow keys or entering leading zeroes in number fields, cause no notifier call. Changing the selection contained in the field causes no notification either.
If a modification occurs in a field that is linked to a string, real, currency, or combo variable, the notifier with (change, undefined, undefined) is called. If the field is linked to an integer value, the notifier with (change, oldvalue, newvalue) is called.
Illegal characters, e.g., characters in a field linked to an integer, are not accepted.
A text field may have a label, even though it doesn't display it. The reason for this is that keyboard shortcuts may be defined in labels, which is useful even for edit fields.
If the level property is 0 (the default), or the control is not linked to a number type, or it is linked to Dialog.Currency, then level has no effect. When linked to an integer variable the level defines the scale factor used for displaying the number, i.e., the displayed number is the linked value divided by 10level. For example, if the current value is 42 and level is 2, then 0.42 is displayed. For variable of real type, level indicates the format in the following way:
level > 0: exponential format (scientific) with at least level digits in the exponent.
level = 0: fixpoint or floatingpoint format, depending on x.
level < 0: fixpoint format with -level digits after the decimal point.
The left and right properties define the adjustment mode of the field. The following combinations are possible:
left & ~right left adjust
left & right fully adjusted (may have no effect on some platforms)
~left & ~right centered
~left & right right adjust
The default is left & ~right (left adjust).
Property multiLine defines whether a carriage return, with its resulting line break, may be accepted by the field, which then must be linked to a string variable.
Property password causes the text field to display only asterisks instead of the characters typed in. This makes it possible to use such a field for password entry.
properties: link, label, guard, notifier, level, font, left, right, multiLine,
password
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Check Box
Figure 4-23. Check box
A check box displays the value of a global variable which may be a Boolean or an element of a set. Clicking on the control toggles its state.
When the control's state is changed, the notifier with (changed, undefined, undefined) is called if the control is linked to a Boolean variable. If it is linked to an element of a set variable, (included, level, undefined) or (excluded, level, undefined) is called, depending on whether the bit is set or cleared. The value level corresponds to the element of the set to which the control is linked. It can be defined using the control property inspector. It may lie in the range 0..31.
Only the last and final state change of the control leads to a notifier call, possible intermediate state changes (by dragging the mouse outside of the control's bounding box or back inside) have no effect.
properties: link, label, guard, notifier, font, level
linkable to: BOOLEAN, SET
op: pressed, released, changed, included, excluded
from: undefined, level value, modifier
to: undefined
Radio Button
Figure 4-24. Radio button
A radio button is active at a particular value of a global integer or Boolean variable. Typically, several radio buttons are linked to the same variable. Each radio button is "on" at another value, which is defined by the level property; i.e., the button is "on" if its level value is equal to the value of the variable it is linked to. For Boolean types, "on" corresponds to TRUE and "off" corresponds to FALSE.
Only the last and final state change of the control leads to a notifier call, possible intermediate state changes (by dragging the mouse outside of the control's bounding box or back inside) have no effect.
properties: link, label, guard, notifier, font, level
linkable to: BYTE, SHORTINT, INTEGER, LONGINT, BOOLEAN
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value = level value
Date Field
Figure 4-25. Date field
A date field displays the date specified in a global variable of type Dates.Date.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, undefined, undefined). Key presses that do not change the interactor state, such as pressing left/right arrow keys, cause no notifier call. The up/down arrow keys change the date. Changing the selection in the field has no effect.
Illegal date values cannot be entered.
properties: link, label, guard, notifier, font
linkable to: Dates.Date
op: pressed, released, changed
from: undefined, modifier
to: undefined
Time Field
Figure 4-26. Time field
A time field displays the time specified in a global variable of type Dates.Time.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, undefined, undefined). Key presses that do not change the interactor state, such as pressing left/right arrow keys, cause no notifier call. The up/down arrow keys change the time. Changing the selection in the field has no effect.
Illegal time values cannot be entered.
properties: link, label, guard, notifier, font
linkable to: Dates.Time
op: pressed, released, changed
from: undefined, modifier
to: undefined
Color Field
Figure 4-27. Color field
A color field displays a color. It can be linked to variables of type INTEGER or Dialog.Color. Ports.Color is an alias of INTEGER and thus can be used also.
Whenever another color is selected, the notifier is called with (change, oldval, newval). The old and new values are integer values; for Dialog.Color type variables the val field's value is taken.
properties: link, label, guard, notifier, font
linkable to: Dialog.Color, Ports.Color = INTEGER
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Up/Down Field
Figure 4-28. Up/down field
This is a field linked to an integer variable. The value can also be changed through arrow keys.
Whenever the contents of the linked interactor field is changed, the notifier is called with (change, oldvalue, newvalue).
properties: link, label, guard, notifier, font
linkable to: BYTE, SHORTINT, INTEGER, LONGINT
op: pressed, released
from: undefined, old value, modifier
to: undefined, new value
Caption
Figure 4-29. Caption
A caption is typically used in conjunction with a text field, to indicate the nature of its contents. A caption is passive, i.e., it cannot be edited and thus cannot have a notifier.
A caption is linkable to the same types as a text field is, and it may have a guard. This is useful since ђ depending on the platform ђ a caption may have a distinct visual appearance if it (or rather its corresponding text field) is disabled, read-only, etc. This means that a caption may be disabled along with its corresponding text field, by linking both to the same interactor field. A caption's guard may modify the control's label, as is true for all controls with a visible label.
properties: link, label, guard, font, right, left
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
The left and right properties define the adjustment mode of the caption. The following combinations are possible:
left & ~right left adjust
left & right fully adjusted (may have no effect on some platforms)
~left & ~right centered
~left & right right adjust
The default is left & ~right (left adjust).
Group
Figure 4-30. Group
A group is used to visually group related controls, e.g., radio buttons that belong together. A group is passive, i.e., it cannot be edited and thus cannot have a notifier.
A group may not be linked, but it may have a guard which allows to disable or enable it. A group's guard may modify the control's label, as is true for all controls with a visible label.
properties: label, guard, font
List Box
Figure 4-31. List box (expanded and collapsed shapes)
A list box allows to select one value out of a list of choices. It is linked to a variable of type Dialog.List (see next section). If the height of the list box is large enough, a scrollable list is displayed. If it is not large enough, the box collapses into a pop-up menu.
Interactively, the selection can be changed. It is either empty or it consists of one selected item. When the user modifies the selection, the notifier is called with (changed, oldvalue, newvalue). The old/new value corresponds to the selected item's index. The top-most item corresponds to value 0, the next one below to value 1, etc. The empty selection corresponds to value -1.
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.List
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Selection Box
Figure 4-32. Selection box
A selection box allows to select a subset out of a set of choices. It is linked to a variable of type Dialog.Selection (see next section).
Interactively, the selection can be changed. Each item may be selected individually. When the user modifies the selection, the notifier is called in one of three ways:
(included, from, to): range from..to is now selected; it wasn't selected before
(excluded, from, to): range from..to is not selected now; it was selected before
(set, from, to): range from..to is now selected; any previous selection was cleared before
The three codes included and excluded and set take the place of changed used for most other controls. The notifier is called as often as necessary to include and/or exclude all necessary ranges of items.
The from/to value corresponds to the selected item's index. The topmost item corresponds to value 0, the next one below to value 1, and so on.
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Selection
op: pressed, released, included, excluded, set
from: undefined, lowest element of range, modifier
to: undefined, highest element of range
Combo Box
Figure 4-33. Combo box
A combo box is a text field whose contents can also be set via a pop-up menu. Unlike pure pop-up menus/selection boxes, a value may be entered which does not occur in the pop-up menu. The control is linked to a variable of type Dialog.Combo (see next section).
When the contents of the combo is changed, the notifier is called with (changed, undefined, undefined).
The sorted property determines whether the string items will be sorted lexically (no effect on Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Combo
op: pressed, released, changed
from: undefined, modifier
to: undefined
Each interactive control (i.e., not a caption or a group) calls its notifier ђ if there is one ђ when the user first clicks in the control with parameter op = Dialog.pressed, and later with op = Dialog.released when the mouse button is released again. This feature is used mostly to display some string in the dialog box window's status area. This is done with the calls Dialog.ShowStatus or Dialog.ShowParamStatus. For example, the following notifier indicates a command button's function to the user:
PROCEDURE ButtonNotifier* (op, from, to: LONGINT);
BEGIN
IF op = Dialog.pressed THEN
Dialog.ShowStatus("This button causes the disk to spin down")
ELSIF op = Dialog.released THEN
Dialog.ShowStatus("") (* clear the status message again *)
END
END ButtonNotifier;
Listing 4-34. Notifier displaying status messages
On some platforms, e.g., on Mac OS, there is no status area and the above code has no effect.
Sometimes it is useful to detect double-clicks, e.g., a double-click in a list box may select the item and invoke the default button. A double-click can be detected in a notifier with the test
IF (op = Dialog.pressed) & (from = 1) THEN ... (* double-click *)
For the above-mentioned case, where the reaction on a double-click should merely be the invocation of the default button, a suitable standard notifier is available:
StdCmds.DefaultOnDoubleClick
We have seen earlier that the BlackBox Component Builder provides a string mapping facility which maps keys to actual strings, by using resource files. This feature is also supported by Dialog.ShowStatus. In fact, string mapping even allows to use place holders. For example, calling
Dialog.ShowParamStatus("This ^0 causes the ^1 to ^2", control, object, verb)
allows to supply different strings for the place holders ^0, ^1 and ^2. The strings actually used are the three additional parameters control, object and verb. Note that these strings are mapped themselves before being spliced into the first string. String mapping is a feature that you can use explicitly by calling the procedure Dialog.MapParamString.
4.7 Complex controls and interactors
A list box has two kinds of contents: the string items which make up the list, and the current selection. Typically, the item list is more persistent than the selection, but it too may be changed while the control is being used. For list and selection boxes, the application is not so much interested in the item list, since this list is only a hint for the user. The application is interested in the selection that the user creates. For a list box, the selection is defined by the index of the selected item. For a selection box, the selection is defined by the set of indices of selected items. For combo boxes, the relevant state is not a selection, but the string that was entered.
For all three box controls, the item list must be built up somehow. For this purpose, module Dialog defines suitable interactor types: Dialog.List for list boxes, Dialog.Selection for selection boxes, and Dialog.Combo for combo boxes. These types are defined the following way:
List = RECORD
index: INTEGER; (* index of currently selected item *)
len-: INTEGER; (* number of list elements *)
PROCEDURE (VAR l: List) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR l: List) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR l: List) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR l: List) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Selection = RECORD
len-: INTEGER; (* number of selection elements *)
PROCEDURE (VAR s: Selection) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR s: Selection) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR s: Selection) SetResources (IN key: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) Incl (from, to: INTEGER), NEW;
(* select range [from..to] *)
PROCEDURE (VAR s: Selection) Excl (from, to: INTEGER), NEW;
(* deselect range [from..to] *)
PROCEDURE (VAR s: Selection) In (index: INTEGER): BOOLEAN, NEW
(* test whether index-th item is selected *)
END;
Combo = RECORD
item: String; (* currently entered or selected string *)
len-: INTEGER; (* number of combo elements *)
PROCEDURE (VAR c: Combo) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR c: Combo) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR c: Combo) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR c: Combo) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Listing 4-35. Definitions of List, Selection and Combo
Before a variable of one of these types can be used, it must be initialized by first defining the individual items. During use, items can be changed. For example, the following code fragment builds up a list:
list.SetLen(5); (* define length of list *)
list.SetItem(0, "Daffy Duck");
list.SetItem(1, "Wile E. Coyote");
list.SetItem(2, "Scrooge Mc Duck");
list.SetItem(3, "Huey Lewis");
list.SetItem(4, "Thomas Dewey");
Dialog.UpdateList(list); (* must be called after any change(s) to the item list *)
Listing 4-36. Setting up a list explicitly
When used with list-structured controls (list, selection, or combo boxes), Dialog.Update only updates the selection or text entry state of these controls, but not the list structure. If the list structure, i.e., the elements of the control's list, is changed, then the procedure Dialog.UpdateList must be called instead of Dialog.Update.
For fixed item lists, the individual strings should be stored in resources. This is simplified by the SetResources procedures. They look up the strings in a resource file. For example, the above statements can be replaced completely by the statement
list.SetResources("#Obx:list")
which will read the Obx/Rsrc/Strings file and look for strings with keys of the kind "list[index]", e.g., for
list[0] Daffy Duck
list[1] Wile E. Coyote
list[2] Scrooge Mc Duck
list[3] Huey Lewis
list[4] Thomas Dewey
Table 4-37. Resources for a list
The indices must start from 0 and be consecutive (no holes allowed).
Procedure SetLen is optional. Its use is recommended wherever the number of list items is known in advance. If this is not the case, it may be omitted. The list will become as large as the largest index requires.
SetLen is necessary if an existing item list should be shortened, or if it should be cleared completely.
4.8 Input validation
Validity checks are an important, and for the uninitiated sometimes a surprising, aspect of non-modal user interfaces. Among other things, non-modality also means that the user must not be forced into a mode depending on where the caret currently is and whether or not the entered data is currently valid. In particular, a user must not be forced to correctly enter some data into a field before permitting him or her to do something else.
This basically leaves two strategies for checking the validity of entered data: early or late. Early checks are performed whenever the user has manipulated a control. Late checks are performed when the user has completed input and wants to perform some action, e.g., entering the new data into a database.
Late checks are most suitable for checking global invariants, e.g., whether all necessary fields in the input mask contain some input. Early checks are most suitable for local, control-specific invariants, e.g., the correct syntax of an entered string.
We give examples of both early and late checks for our module ObxPhoneUI. Let us assume that a phone number always has the following form: 310-555-1212. For a late check, we extend the Lookup procedure (boldface text) and add a few auxiliary procedures. Note the use of the "$" operator, which makes sure the LEN function returns the length of the string, not of the array containing the string.
PROCEDURE Valid (IN s: ARRAY OF CHAR): BOOLEAN;
PROCEDURE Digits (IN s: ARRAY OF CHAR; from, to: INTEGER): BOOLEAN;
BEGIN (* check whether range [from..to] in s consists of digits only *)
WHILE (from <= to) & (s[from] >= "0") & (s[from] <= "9") DO INC(from) END;
RETURN from > to (* no non-digit found in checked range *)
END Digits;
BEGIN (* check syntax of phone number *)
RETURN (LEN(s$) = 12) & Digits(s, 0, 2) & (s[3] = "-") & Digits(s, 4, 6) &
(s[7] = "-") & Digits(s, 8, 11)
END Valid;
PROCEDURE ShowErrorMessage;
BEGIN
phone.name := "illegal syntax of number"
END ShowErrorMessage;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
IF Valid(phone.number) THEN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
ELSE
ShowErrorMessage
END
END;
Dialog.Update(phone)
END Lookup;
Listing 4-38. Late check for input validation
A more rude reminder would be to display an error message. If the BlackBox Component Builder's log window is open, the message is written to the log and the window is brought to the top if necessary. If no log is used, a dialog box is displayed. This behavior can be achieved by replacing the statement in procedure ShowErrorMessage by the following statement:
Dialog.ShowMsg("Please correct the phone number")
Now we look at an early checked alternative to the above solution to input checking. It uses a notifier to check after each character typed into the phone number field whether the number is legal so far. In contrast to the late check, it must be able to deal with partially entered phone numbers. Whenever an illegal suffix is detected, the string is simply clipped to the legal prefix.
PROCEDURE Correct (VAR s: ObxPhoneDB.String);
PROCEDURE CheckMinus (VAR s: ObxPhoneDB.String; at: INTEGER);
BEGIN
IF s[at] # "-" THEN s[at] := 0X END (* clip string *)
END CheckMinus;
PROCEDURE CheckDigits (VAR s: ARRAY OF CHAR; from, to: INTEGER);
BEGIN
WHILE from <= to DO
IF (s[from] < "0") OR (s[from] > "9") THEN
s[from] := 0X; from := to (* clip string and terminate loop *)
END;
INC(from)
END
END CheckDigits;
BEGIN (* clip string to a legal prefix if necessary *)
CheckDigits(s, 0, 2);
CheckMinus(s, 3);
CheckDigits(s, 4, 6);
CheckMinus(s, 7);
CheckDigits(s, 8, 11)
END Correct;
PROCEDURE NumberNotifier (op, from, to: INTEGER);
BEGIN
Correct(phone.number)
(* Dialog.Update is not called, because it will be called afterwards by the notifying control *)
END NumberNotifier;
Listing 4-39. Early check for input validation
Note that a focused view, e.g. a control, has no means to prevent the user from focusing another view. A view may merely change the way that it displays itself, its contents, or its marks (selection, caret). For this purpose, a view receives a Controllers.MarkMsg when the focus changes.
4.9 Accessing controls explicitly
In most circumstances, guards and notifiers allow sufficient control over a control's specific look & feel. However, sometimes you may want to exercise direct control over a control in a form. How to do this is described in this section. For example, assume that you want to write your own special alignment command, and add it to the commands of the Layout menu. To do this, you need to get access to the form view in the window that is currently being edited. The form view is a container that contains the controls that you want to manipulate. The function FormControllers.Focus delivers a handle on the currently focused form editor. This leads to the typical code pattern for accessing a form (Listing 4-40):
VAR c: FormControllers.Controller;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
...
Listing 4-40. Accessing a form's controller
A form contains controls and possibly some other types of views. The views can be edited if the enclosing form view is in layout mode. Typically, some views are selected first, and then a command is executed that operates on the selected views. The following example shifts every selected view to the right by one centimeter (Listing 4-41):
MODULE ObxControlShifter;
IMPORT Ports, Views, FormModels, FormControllers;
PROCEDURE Shift*;
VAR c: FormControllers.Controller; sel: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
sel := c.GetSelection(); (* generates a list with references to the selected views *)
WHILE sel # NIL DO
c.form.Move(sel.view, 10 * Ports.mm, 0); (* move to the right *)
sel := sel.next
END
END
END Shift;
END ObxControlShifter.
Listing 4-41. Shift all selected views to the right
This code works on selected views (whether they are controls or not). Sometimes you may want to manipulate views that are not selected. In this case, you need a form reader (FormModels.Reader) to iterate over the views in the currently focused form. The following code pattern shows how a command can iterate over the views of a form (Listing 4-42):
VAR c: FormControllers.Controller; rd: FormModels.Reader;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
...
rd.ReadView(v) (* read next view *)
END;
...
Listing 4-42. Iterating over the selected views in a form
Controls are special views (of type Controls.Control). Controls can be linked to global variables. The following example shows how the labels of all controls in a form can be listed (Listing 4-43):
MODULE ObxLabelLister;
IMPORT Views, Controls, FormModels, FormControllers, StdLog;
PROCEDURE List*;
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS Controls.Control THEN
StdLog.String(v(Controls.Control).label); StdLog.Ln
END;
rd.ReadView(v) (* read next view *)
END
END
END List;
END ObxLabelLister.
Listing 4-43. Listing the labels of all controls in a form
With the same kind of iteration, any other type of view could be found in forms as well, not only controls. For example, consider that you have a form with a "Clear" command button that causes a plotter view in the same form to be cleared. The command button is a standard control, the plotter view is your special view type. The command associated with the command button first needs to search for its plotter view, in the same form where the button is placed. The code pattern shown below demonstrates how such a command can be implemented (Listing 4-44):
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* clear v(MyPlotterView) *)
END;
rd.ReadView(v) (* read next view *)
END
END
Listing 4-44. Finding a particular view in a form
There is one potential problem with the above code pattern. Let us assume that we have a dialog box containing a command button with ObxLabelLister.List as associated command. Beneath the dialog box, we have a window with a focused form layout. Now, if you click on the dialog box' command button, which labels are listed? The ones in the form of the dialog box itself, or the ones in the focused form layout underneath? In other words: does FormControllers.Focus yield the form that contains the button you clicked on, or the form focused for editing? Depending on what the button's command does, both versions could make sense. For a form editing command like ObxControlShifter.Shift, the focused layout editor should be returned. This is the top-most document window, but it is overlaid by the dialog box window. In contrast, if you want to find your plotter view, the form of the dialog box should be returned instead. In this case, you want to search the direct "neighborhood" of the button.
One solution for the plotter view search would be to start searching in the context of the button that is currently being pressed. This can be done using the following code pattern (Listing 4-45):
VAR button: Controls.Control; m: Models.Model; rd: FormModels.Reader; v: Views.View;
BEGIN
button := Controls.par; (* during the button click, this variable contains a reference to the button *)
m := button.context.ThisModel(); (* get the model of the container view that contains the button *)
IF m IS FormModels.Model THEN (* the container is a form *)
rd := m(FormModels.Model).NewReader(NIL);
rd.ReadView(v); (* read first view *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* clear v(MyPlotterView) *)
END;
rd.ReadView(v) (* read next view *)
END
END
Listing 4-45. Finding a particular view in the same form as a button
This code assumes that the command is executed from a command button. It doesn't work if placed in a menu. In order to better decouple the user interface and the application logic, this assumption should be eliminated. BlackBox solves the problem by giving the programmer explicit control over the behavior of FormControllers.Focus. The trick is that BlackBox supports two kind of windows for dialog boxes: tool windows and auxiliary windows, in addition to the normal document windows. If the command button is in a tool window dialog box, then FormControllers.Focus yields the form in the top-most document window, or NIL if there is no such document window or if the focus of the top-most document window is not a form view. If the command button is in an auxiliary window, then FormControllers.Focus yields the dialog box' form whose command button you have clicked. The following paragraphs further explain the differences between these two kinds of windows.
Dialog boxes in tool windows are not self-contained, they provide the parameters and the control panel for an operation on a document underneath. A typical example is the "Find / Replace" dialog box that operates on a text document underneath. The command buttons in a tool dialog box invoke a command, and this command fetches the view on which it operates. In the "Find / Replace" example, this is the focused text view. Under Windows, tool windows always lie above the topmost document window; i.e., they can never be overlapped by document windows or auxiliary windows, only by other tool windows. Unlike other windows, tool windows cannot be resized or iconized, but can me moved outside of the application window. On Mac OS, tool windows look and behave like document windows, except that they have no scroll bars and cannot be resized or zoomed.
An auxiliary window on the other hand is self-contained. It contains, and operates on, its own data. At least, it knows where to find the data on which to operate (e.g., in a database). The "Phone Database" dialog box is a typical auxiliary window, like most data-entry forms. Auxiliary windows can be manipulated like normal document windows; in particular, the may be overlapped by other document or auxiliary windows.
Both kinds of dialog boxes are stored as documents in their appropriate RSRC directories. But to open them, module StdCmds provides two separate commands: OpenToolDialog and OpenAuxDialog. Both of them take a portable path name of the resource document as first parameter, and the title of the dialog box window as a second parameter. For example, the following menu commands may be used:
"Find / Replace..." "" "StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Find / Replace')" ""
"Phone Database..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phone Database')" ""
The function FormControllers.Focus returns different results, depending on whether the form is in a tool or in an auxiliary window.
For more examples on how forms can be manipulated, see also module FormCmds. It is available in source form, like the rest of the Form subsystem.
4.10 Summary
In this chapter, we have discussed the important aspects of how a graphical user interface and its supporting code is implemented in the BlackBox Component Builder. There are three parts of an application: application logic, user interface logic, and user interface resources, i.e., documents. A clean separation of these parts makes a program easier to understand, maintain, and extend.
For more examples of how the form system and controls can be used, see the on-line examples ObxAddress0, ObxAddress1, ObxAddress2, ObxOrders, ObxControls, ObxDialog, and ObxUnitConv. For advanced programmers, the sources of the complete Form subsystem may be interesting.
For more information on how to use the BlackBox development environment, consult the documentation of the following modules:
DevCompiler, DevDebug, DevBrowser, DevInspector, DevReferences,
DevMarkers, DevCmds, StdCmds, StdMenuTool, StdLog, FormCmds, TextCmds
To obtain more information on a module, select a module name and then invoke Info->Documentation.
In order to provide a straight-forward description, we only used the most important commands in this book. However, there are other useful commands in the menus Info, Dev, Controls, Tools, and Layout. For example, there are several "wizards" for the creation of new source code skeletons. Consult the files System/Docu/User-Man, Text/Docu/User-Man, Form/Docu/User-Man, and Dev/Docu/User-Man for a comprehensive user manual on how to use the framework, the editor (Text subsystem), the visual designer (Form subsystem), and the development tools (Dev subsystem).
5 Texts
Graphical user interfaces have introduced graphical elements into everyday computing. While this was a very positive step towards overcoming the old-style modal textual user interfaces, texts have by no means become obsolete. Even in reports containing many illustrations, texts serve as indispensible glue.
In typical database applications, no graphical contents is manipulated. The data entered and retrieved are mostly textual, and reports to be printed usually are texts arranged in a tabular fashion.
Because of the importance of texts, this chapter demonstrates how the BlackBox Component Builder's text abstraction can be used in various ways. In several examples, we will reuse the simple database module introduced in the previous chapter.
We will work "bottom-up" by providing examples first for writing new texts, then for reading existing text, and finally for modifying existing texts. When discussing these examples, we will meet text models/carriers and riders, mappers, and auxiliary abstractions such as fonts, attributes, rulers, and others.
5.1 Writing text
In the BlackBox Component Builder, texts use the Carrier-Rider-Mapper design pattern (see Chapter 3). They provide text models as carriers for texts, and text writers and text readers as riders on text models. Both types are defined in the Text subsystem's core module TextModels. A text writer maintains a current position and current attributes, which will be used when writing the next element into the text. The full definition of a writer looks as follows:
Writer = POINTER TO ABSTRACT RECORD
attr-: TextModels.Attributes;
(wr: Writer) Base (): TextModels.Model, NEW, ABSTRACT;
(wr: Writer) Pos (): INTEGER, NEW, ABSTRACT;
(wr: Writer) SetPos (pos: INTEGER), NEW, ABSTRACT;
(wr: Writer) SetAttr (attr: TextModels.Attributes), NEW;
(wr: Writer) WriteChar (ch: CHAR), NEW, ABSTRACT;
(wr: Writer) WriteView (view: Views.View; w, h: INTEGER), NEW, ABSTRACT
END;
Listing 5-1. Definition of TextModels.Writer
The most important procedure of a writer is WriteChar, it allows to write a new character at the current position. If the character position lies within an existing text (i.e., in 0 .. text.Length() - 1), the character at this text position is inserted. (This is a difference to the BlackBox files abstraction, where old data would be overwritten by the writer in this case. With texts, writers always insert and never overwrite.) If the writer's position is at the end of the text (i.e., at text.Length()), the character is appended to the text and thus makes the text one element longer. After WriteChar, the writer's text position is increased by one. The current position can be inquired by calling the writer's Pos function, and it can be modified by calling the SetPos procedure.
Since text models are capable of containing views as well as normal characters, there exists a procedure WriteView which allows to write a view, given an appropriate size (w for the width, h for the height).
Like most geometrical distances in BlackBox, a view's width and height are specified in so-called universal units of 1/36000 millimeters. This value was chosen to eliminate rounding errors for many common screen and printer resolutions. For example, an inch, a 1/300-th of an inch, a millimeter, and a desktop publishing point can be represented in units without rounding errors. Where not specified otherwise, distances can be assumed to be represented in universal units.
If no specific size for the view is desired, passing the value Views.undefined for the width and/or height allows the text to choose a suitable default size for the written view.
How is a writer created? Like all riders, a writer is created by a factory function of its carrier. For this purpose, a text model provides the procedure NewWriter, which creates a writer and connects it to the text. A writer can return its text through the Base function. A newly created writer is positioned at the end of the text.
Text elements don't have character codes only, they also have attributes. A writer's attr field contains the attributes to be used when the next character or view is written. The current attributes can be changed by calling the writer's SetAttr procedure.
In terms of attributes, the text subsystem of the BlackBox Component Builder supports colors and vertical offsets. Colors are encoded as integers (Ports.Color). Module Ports predefines the constants black, grey6, grey12, grey25, grey50, grey75, white, red, green, and blue. "grey6" means a mixture of 6% white and 94% black, which is almost black. The other grey values are increasingly lighter. Vertical offsets are measured in universal units.
Besides colors and vertical offset, a text element also has a font attribute. A font is a collection of glyphs. A glyph is a visual rendering of a character code. Different fonts may contain different glyphs for the same characters. For example, Helvetica looks different from Times and Frutiger. A font may not provide glyphs for all character codes that can be represented in Component Pascal. This is not surprising, since the CHAR datatype of Component Pascal conforms to the Unicode standard. Unicode is a 16-bit standard, and thus can represent over 65000 different characters. The first 256 characters are the Latin-1 characters. The first 128 characters of Latin-1 are the venerable ASCII characers.
If a font doesn't contain a particular glyph, BlackBox's font framework either returns a glyph from some other font for the same character, or it yields a generic "missing glyph" symbol; e.g., a small empty rectangle.
Font objects are defined in module Fonts.Font. It won't be necessary to take a closer look at this module here; it is sufficient to interpret a pointer of type Fonts.Font as the identification of a font with its particular typeface, style, weight, and size:
Typeface
This is the font family to which a font belongs; it defines a common "look and feel" for the whole family. Examples of typefaces are Helvetica, Times, or Courier. Typeface names are represented as character arrays of type Fonts.Typeface.
Style
A font may optionally be italicized, underlined, struck out or a combination thereof. Styles are represented as sets. Currently, the set elements Fonts.italic, Fonts.underline and Fonts.strikeout are defined.
Weight
A font might exist in several weights, e.g., ranging from light to normal to bold to black to ultra black. Usually, a font is either normal or bold. Weights are represented as integers. The values Fonts.normal and Fonts.bold are predefined.
Size
A font may be rendered in different sizes, taking into account the resolution of the used output device. Often, sizes are given in points. A point is 1/72-th of an inch. In BlackBox, font sizes are measured in universal units, which are chosen such that points (Ports.point) and other typographical units can be represented without round-off errors. Typical font sizes are 10 * Ports.point or 12 * Ports.point.
In principle, typeface, style, weight and size are independent of each other. This means that a given typeface can be combined with arbitrary styles, weights and sizes. However, from a typographical point of view, some combinations are more desirable than others, and may be optimized by the font designer and the underlying operating system's font machinery.
The text attributes font, color and vertical offset are packaged into objects of type TextModels.Attributes. Slightly simplified, this type looks as follows:
Attributes = POINTER TO RECORD (Stores.Store)
color-: Ports.Color;
font-: Fonts.Font;
offset-: INTEGER
END;
Listing 5-2. Simplified definition of TextModels.Attributes
This is the type of the writer's attr field. It is an extension of Stores.Store. This means that such an object can be stored persistently in a file. Other examples of stores are TextModels.Model and TextViews.View, but not TextModels.Writer. A more detailed description of stores is given in Part III.
We have now seen the capabilities of a text writer, including the text attributes that it supports. The typical use of text writers is shown in the code pattern below. A code pattern is an excerpt of a procedure which shows one or a few important aspects of the objects currently discussed. Such a code fragment constitutes a recipe that should be known by a programmer "fluent" in this topic.
VAR t: TextModels.Model; wr: TextModels.Writer; ch: CHAR;
BEGIN
t := TextModels.dir.New(); (* allocate new empty text model *)
wr := t.NewWriter(NIL);
... produce ch ...
WHILE condition DO
wr.WriteChar(ch);
... produce ch ...
END;
Listing 5-3. Code pattern for TextModels.Writer
The code pattern is not very interesting since it doesn't show how the generated text can be displayed. A text object only represents a text with its attributes. It doesn't know about how to draw this text, not even how to do text setting; i.e., how to break lines and pages such that they fit a given rectangle (view, paper size, etc.). When it is desired to make a text visible, it is necessary to provide a text view for the text object. Data objects that may be displayed in several views are generally called models. The separation of model and view is an important design pattern that was discussed in Chapter 2.
Module TextModels only exports an abstract record type for text models, no concrete implementation. Instead, it exports a directory object (TextModels.dir) which provides the necessary factory function (TextModels.dir.New). This indirection pattern for object creation was motivated in Chapter 2.
Working directly with text writers is inconvenient, they don't even support the writing of strings. For this reason, the following examples will use formatters when writing text. A formatter is a mapper (see Chapter 3) that contains a text writer and performs the mapping of higher-level symbols, such as the Component Pascal symbols, to a stream of characters that can be fed to the writer. In the next example, we we will use a formatter to write a text; a very simple "report". The text consists of the phone database contents, one line per entry. This first version of a phone database report is implemented in module ObxPDBRep0:
MODULE ObxPDBRep0;
IMPORT Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep0.
Listing 5-4. Writing the phone database using a formatter
Note that name and number are separated by a tab character (09X). Since no tab stops are defined for this text, a tab will be treated as a wide fixed-width space (whose width is a multiple of the normal space character glyph). We will later see how tab stops can be defined.
Execution of the ObxPDBRep0.GenReport command results in the following window:
Figure 5-5. Text editor window containing the phone database
The text in the newly opened window is a fully editable text view. It can be edited; stored as a BlackBox document; printed; and so on. If you look at the source code, you can recognize the following code pattern:
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View;
BEGIN
t := TextModels.dir.New();
f.ConnectTo(t);
... use formatter procedures to construct the text ...
v := TextViews.dir.New(t);
Views.OpenView(v)
Listing 5-6. Code pattern for TextMappers.Formatter and for open a text view
This code pattern occurs in many BlackBox commands, e.g., in DevDebug.ShowLoadedModules. It is useful whenever you need to write tabular reports of varying length, possibly spanning several printed pages.
It also clearly shows that texts embody several design patterns simultaneously: a text object is a model which can be observed by a view (Observer pattern), it is a carrier (Carrier-Rider-Mapper pattern), and it is a container (Composite pattern).
An interesting aspect of the above code pattern is that the text carrier t is created first, then its contents is constructed using a formatter, and only then is a view v on the text carrier created. Finally, the view is opened in its own document window.
In BlackBox it is important that a model can be manipulated before there exists any view for it. In fact, it is far more efficient to create a text before a view on it is opened, because screen updates and some internal housekeeping of the undo mechanism are avoided this way, which can cause a dramatic speed difference.
BlackBox text models represent sequences of text elements. A text element is either a Latin-1 character (SHORTCHAR), a Unicode character (a CHAR > 0FFX) or a view (an extension of type Views.View). Text stretches may be attributed with font information, color and vertical offset. Since a text model may contain views, it is a container. In the following examples, we will see how these text facilities can be used when creating new texts. Our phone book database is used as source of the material that we want to put into texts, applying different textual representations in the various examples.
The following example demonstrates how a text can be generated out of our example database. In this text, names are written in green color. The differences to module ObxPDBRep0 are marked with underlined text.
MODULE ObxPDBRep1;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
default,green:TextModels.Attributes;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
default:=f.rider.attr; (* save old text attributes for later use *)
green:=TextModels.NewColor(default,Ports.green); (* use green color *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.rider.SetAttr(green); (* change current attributes of formatter's rider *)
f.WriteString(name); (* first string *)
f.rider.SetAttr(default); (* change current attributes of formatter's rider *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep1.
Listing 5-7. Writing the phone database using green color
Note that a formatter's rider contains a set of current attributes (TextModels.Writer.attr). This value includes the current color and is read-only; it can be set with the writer's SetAttr procedure.
Our first text examples, ObxPDBRep0 and ObxPDBRep1, don't produce nice-looking output, because the phone numbers are not aligned below each other in a tabular fashion.
ObxPDBRep1 remedies this defect by inserting a ruler at the beginning of the text. This ruler defines a tab stop, which causes all phone numbers ђ separated from their phone names by tabs ђ to line up nicely. The differences to module ObxPDBRep0 are marked with underlined text.
MODULE ObxPDBRep2;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, TextRulers, ObxPhoneDB;
PROCEDUREWriteRuler(VARf:TextMappers.Formatter);
CONST cm = 10 * Ports.mm; (* universal units *)
VAR ruler: TextRulers.Ruler;
BEGIN
ruler := TextRulers.dir.New(NIL);
TextRulers.AddTab(ruler, 4 * cm); (* define a tab stop, 4 cm from the left margin *)
TextRulers.SetRight(ruler, 12 * cm); (* set right margin *)
f.WriteView(ruler) (* a ruler is a view, thus can be written to the text *)
END WriteRuler;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
WriteRuler(f);
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep2.
Listing 5-8. Writing the phone database using a formatter and a ruler
Execution of the ObxPDBRep2.GenReport command results in a window with the improved presentation of the phone database. Executing Text->ShowMarks causes the ruler to be displayed:
Figure 5-9. Text editor window containing the tabular phone database
A ruler is a view. A ruler on its own doesn't make sense. Like all controls, a ruler makes only sense in a container. Unlike many other controls, a ruler is an example of a control that can only function properly in a particular container; in this case the container must be a text model. You may copy a ruler into a form or other container, but it will just be passive and have no useful effect there. If it is embedded in a text model that is displayed in a text view, a ruler can influence the way in which the subsequent text is set. For example, a ruler can define tab stops, margins, and adjustment modes.
The attributes of a ruler are valid in the ruler's scope. The scope starts with the ruler itself and ends right before the next ruler, or at the end of the text if there follows no ruler anymore. A ruler introduces a new paragraph, possibly with its own distinct set of paragraph attributes. Inserting a paragraph character (0EX) instead of a ruler also starts a new paragraph, which inherits all paragraph attributes from the preceding ruler. Paragraph characters are the normal way to start a new paragraph; rulers are only used if particular paragraph attributes should be enforced. Note that a carriage return (0DX) doesn't start a new paragraph.
A text view contains an invisible default ruler that defines the text setting of the text before the first ruler in the text, or of all text if no ruler has been written to the text at all. Interactively, this default ruler, and default attributes, can be set with the menu commands Text->Make Default Ruler and Text->Make Default Attributes.
A ruler has many attributes that can be set. Unlike character attributes, which can be applied to arbitrary text stretches, these attributes apply to the ruler or the whole paragraph(s) in its scope.
We will discuss these attributes so that you know about ruler functionality when you need it. We won't discuss rulers in more detail though, since you can learn about the necessary details on demand if and when you need the more advanced ruler capabilities (see on-line documentation of module TextRulers).
Styles
A ruler's attributes are not directly stored in the ruler view itself. Instead, they are bundled into a separate object of type TextRulers.Attributes, which in turn is contained in an object of type TextRulers.Style.
A style is the model of one or several ruler views. If several views share the same model, the user can change the attributes of all the rulers simultaneously. For example, changing the left margin will affect all rulers bound to the same style. However, models cannot be shared across documents, which means that all rulers bound to the same style must be embedded in the same document.
TextRulers.Attributes are persistent collections of ruler attributes, much in the same way as TextModels.Attributes are persistent collections of character attributes.
Attributes = POINTER TO EXTENSIBLE RECORD (Stores.Store)
first-, left-, right-, lead-, asc-, dsc-, grid-: INTEGER;
opts-: SET;
tabs-: TextRulers.TabArray
END;
Listing 5-10. Simplified definition of TextRulers.Attributes
In the following paragraphs, we discuss the individual attributes. For these attributes, there exist auxiliary procedures in module TextRulers which make it simple to set up a text ruler in the desired way: just create a new ruler with TextRulers.dir.New(NIL), and then apply the auxiliary procedures that you need to obtain the correct attribute settings. An example was given above in the procedure WriteRuler of module ObxPDBRep2.
These auxiliary procedures greatly simplify setting up text rulers. For example, they hide that the attributes are actually not contained in the ruler itself, but rather in attributes objects which are used by style objects which are used by the rulers. Providing such simplified access to a complex feature is called a facade in the design patterns terminology [GHJV94]. Here the mechanism is particularly simple because the facade merely consists of simple procedures, there is not even a facade object that would have to be created and managed.
Tab stops
The tabs field of type TextRulers.TabArray contains information about tab stops. The number of tab stops is given in tabs.len, and must not be larger than TextRulers.maxTabs (which is currently 32). If the user enters more than maxTabs tabs, or more tabs than given in len, then the superfluous tabs will be treated as fixed size space characters. The fixed size used is an integer multiple of the width of a space in the used font, approximately 4 mm in total.
Tab = RECORD
stop: INTEGER; (* stop >= 0 *)
type: SET (* type IN {TextRulers.centerTab, TextRulers.rightTab, TextRulers.barTab} *)
END;
TabArray = RECORD
len: INTEGER; (* 0 <= len <= TextRulers.maxTabs *)
tab: ARRAY TextRulers.maxTabs OF TextRulers.Tab
(* tab[0 .. len-1] sorted in ascending order without duplicates *)
END
Listing 5-11. Definition of TextRulers.Tab and TabArray
In tabs.tab.stop, the tab's distance from the left border of the text view is specified (in universal units of course). The tab stops in the tabs.tab array must be sorted in ascending order, and there must be no duplicate values.
In addition to the stop position kept in field stop, a tab stop can be modified using a set of possible options kept in field type. In particular, these options allow to center text under a tab stop or to right-align text under a tab stop (the default is left alignment):
tab type tabs.tab[i].type
left adjusted {}
right adjusted {TextRulers.rightTab}
centered {TextRulers.centerTab}
For all of the above tab types, it can optionally be specified whether the tab itself is drawn as a vertical bar. Bar tabs are specified by including the value TextRulers.barTab in the tab type set. Since the bars occupy the whole line height, they are useful to to format simple tables.
When created with TextRulers.dir.New(NIL), a ruler has no tabs.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE AddTab (r: Ruler; x: INTEGER)
PROCEDURE MakeRightTab (r: Ruler)
PROCEDURE MakeCenterTab (r: Ruler)
PROCEDURE MakeLineTab (r: Ruler)
AddTab adds a new left-adjusted normal tab. It can be changed into a right-adjusted or centered tab by calling MakeRightTab or MakeCenterTab. Independently of the adjustment mode, the tab can be turned into a bar tab by calling MakeLineTab.
Margins
Text is set within a left and a right margin. These margins can be specified as distances from the left border of the text view. The left margin must be smaller than the right margin.
left-, right-: INTEGER (* (left >= 0) & (right >= left) *)
It is possible to signal to the text setter that it should ignore the right margin and use the text view for line breaking instead. In fact, this is the default behavior. It means that when the view size is changed, the text's line breaking will probably change also. Even if the right margins is ignored for text setting, it is still useful: a text view uses it as a hint for how wide the view should be when it is opened.
Line breaking at a fixed right margin is only needed in rare circumstances, for example when this particular paragraph should be narrower than the others. If you want line breaking to be controlled by the right margin, then you have to include TextRulers.rightFixed in the opts set (see further below).
Note that the Tools->Document Size... command allows to flexibly specify the width (and height) of a document's outermost view, the so-called root view. The width can be set to a fixed size, which is useful for page layout types of application.
Usually however, the width is defined by the page setup, which derives the view's width from the currently selected paper size, reduced by the user-specified print margins. This is adequate for letters, program sources, and similar kinds of documents.
As a third possibility, the root view's width can be bound to the window size (this is the case mentioned above, when the view uses the first ruler's right margin as a hint, whether the right margin is fixed or not). Whenever the user resizes the window, the root view is resized accordingly, such that it is kept always as large as the window allows. This is desirable in particular for on-line documentation, where the documentation should use as much screen space as granted by the user, adapting the text flow to the available width whenever the window is resized. An example for this style is the default formatting of Web pages.
Note that these features are independent of the root view's type. They work the same way for all resizable views, such as text views, form views, and most other kinds of editor view.
When created with TextRulers.dir.New(NIL), a ruler has a left margin of 0 and an implementation-specific non-fixed right margin > 0.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetLeft (r: Ruler; x: INTEGER)
PROCEDURE SetRight (r: Ruler; x: INTEGER)
PROCEDURE SetFixedRight (r: Ruler; x: INTEGER)
SetLeft and SetRight set the left or right margin. SetFixedRight sets the right margin and marks it as fixed.
First line indentation
A ruler defines the first line indentation, i.e., how much the first line after the ruler is indented from the left border of the text view. Note that it is possible to define a first line indentation that is smaller than the left margin (first < left). This is the only case where a text view draws text to the left of the specified left margin.
first-: INTEGER; (* first >= 0 *)
First line indentation is applied to the first line of each paragraph in the ruler's scope.
When created with TextRulers.dir.New(NIL), a ruler has no first line indentation (first = 0).
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetFirst (r: Ruler; x: INTEGER)
Ascender and descender
When a character is drawn, its rendering depends on its font attributes, such as typeface (Helvetica or Times?), style (straight or slanted?), weight (normal or bold?) and size. When a whole string is drawn, all characters are placed on a common base line. The ascender is the largest extent to which any character of a line extends above the base line. Some characters extend below the base line, such as "g" and "y". The descender is the largest extent to which any character of a line extends below the base line (see Figure 5-12).
A text setter should calculate base line distances in a way that one line's descender doesn't overlap the next line's ascender, in order to avoid overlapping characters. In order to avoid degenerate cases, such as empty lines or lines that only contain tiny font sizes, a ruler can specify minimal values for ascender (asc) and descender (dsc).
asc-, dsc-: INTEGER; (* (asc >= 0) & (dsc >= 0) *)
Figure 5-12. Ascender, descender, and base line
When created with TextRulers.dir.New(NIL), a ruler uses the current default font's (Fonts.dir.Default()) ascender and descender as initial values.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetAsc (r: Ruler; h: INTEGER)
PROCEDURE SetDsc (r: Ruler; h: INTEGER)
Paragraph lead
The paragraph lead defines the additional vertical space to be inserted between the first line of a paragraph and the previous paragraph's last line. Where the ruler's grid attribute (see below) is used to define a line grid, it is normally considered good style to choose a lead that is a multiple of the grid spacing, or sometimes half of the grid spacing. It allows to visually distinguish new paragraphs from mere carriage returns.
lead-: INTEGER; (* lead >= 0 *)
When created with TextRulers.dir.New(NIL), a ruler has a lead of 0.
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetLead (r: Ruler; h: INTEGER)
Line grid
If grid is zero, then lines are packed as closely as possible, so that there remains no free room between one line's descender and the next line's ascender. Different lines may have different ascenders and descenders, depending on the text and fonts that they contain. For this reason, distances between base lines need not be regular. For typographical reasons, irregular line spacing is often undesirable.
To ensure a more regular spacing of grid lines, it is possible to switch on a line grid, by setting grid to a value larger than zero. This value defines a vertical grid, onto which all base lines are forced. If a line is too high to fit on the next grid line, it is placed one or more grid distances further below (see Figure 5-14).
grid-: INTEGER; (* grid >= 0 *)
Figure 5-13. Line grid
When created with TextRulers.dir.New(NIL), a ruler has a line grid of 1.
The following auxiliary procedure is provided to modify a ruler:
PROCEDURE SetGrid (r: Ruler; h: INTEGER)
Adjustment modes
For longer text stretches, it becomes necessary to break lines that don't fit between the text view's margins. This text setting may occur in several different ways. Text may be left adjusted (left flush), right adjusted (right flush), centered, or aligned to both left and right margins (full justification). These four adjustment modes can be controlled by two option flags: TextRulers.leftAdjust and TextRulers.rightAdjust.
leftAdjust rightAdjust adjustment mode
FALSE FALSE centered
FALSE TRUE right adjusted
TRUE FALSE left adjusted (default)
TRUE TRUE fully adjusted
Table 5-14. Adjustment modes
These adjustment modes can be included in or excluded from a more comprehensive option set, which is represented as a SET:
opts-: SET (* opts is subset of {leftAdjust, rightAdjust, pageBreak, rightFixed, noBreakInside, parJoin; the other set elements are reserved *)
When created with TextRulers.dir.New(NIL), a ruler's option set is {leftAdjust}.
The following auxiliary procedures are provided to modify a ruler:
PROCEDURE SetLeftFlush (r: Ruler)
PROCEDURE SetCentered (r: Ruler)
PROCEDURE SetRightFlush (r: Ruler)
PROCEDURE SetJustified (r: Ruler)
Page breaks
A ruler can force a page break, by including the TextRulers.pageBreak option element in the opts set.
The element TextRulers.noBreakInside is valid for the entire scope of a paragraph. As the name indicates, it forces the beginning of the paragraph to start on a new page, if this isn't the case anyway and if the page would be broken before the next paragraph.
The element TextRulers.parJoin is similar to noBreakInside, except that it additionally forces at least the first line of the next paragraph onto the same page.
When created with TextRulers.dir.New(NIL), a ruler has none of the above special attributes.
The following auxiliary proceduresare provided to modify a ruler:
PROCEDURE SetPageBreak (r: Ruler)
PROCEDURE SetNoBreakInside (r: Ruler)
PROCEDURE SetParJoin (r: Ruler)
This concludes our discussion of ruler attributes. Ruler attributes apply to the ruler, or to all the paragraphs in the ruler's scope. In contrast, character attributes apply to arbitrary stretches of characters. The BlackBox text model supports all font attributes plus color and vertical offsets.
Rulers are views that can be inserted into a text, since texts are containers. Rulers are special in that they are known to the text system, since a text view needs to know about a ruler's paragraph attributes when setting the text. However, arbitrary other views, which are not known to the text system, may be inserted into a text. Particularly interesting effects can be achieved when these views know about texts. Fold views and link views are examples of such text-aware views.
The following example shows how fold views can be generated. Fold views are standard objects of the BlackBox Component Builder; they are implemented in the StdFolds module, only using BlackBox and its Text subsystem. Fold views come in pairs: a left fold and a right fold. The left fold contains a hidden text. When the user clicks on one of the fold views, the text between the two views is swapped with the hidden text. Typically, fold views are used to hide a large text behind a short one; e.g., a book chapter may be hidden, while the chapter's name is visible. This is a way to achieve abstraction of document parts, by hiding details. For this reason, one state of a fold view is called its collapsed state, and the other is called its expanded state. Technically there is no reason why the hidden text should be longer than the visible one; the naming is more a reflection of the typical use of folds.
Figure 5-15. Fold views in collapsed and expanded states
Figure 5-16. Structure of text folds
MODULE ObxPDBRep3;
IMPORT Views, TextModels, TextMappers, TextViews, StdFolds, ObxPhoneDB;
PROCEDUREWriteOpenFold(VARf:TextMappers.Formatter;
INshortForm:ARRAYOFCHAR);
VAR fold: StdFolds.Fold; t: TextModels.Model;
BEGIN
t := TextModels.dir.NewFromString(shortForm); (* convert a string into a text model *)
fold := StdFolds.dir.New(StdFolds.expanded, "", t);
f.WriteView(fold)
END WriteOpenFold;
PROCEDUREWriteCloseFold(VAR f: TextMappers.Formatter);
VAR fold: StdFolds.Fold; len: INTEGER;
BEGIN
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
f.WriteView(fold);
fold.Flip; (* swap long-form text, now between the two fold views, with hidden short-form text *)
len := f.rider.Base().Length(); (* determine the text carrier's new length *)
f.SetPos(len) (* position the formatter to the end of the text *)
END WriteCloseFold;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
WriteOpenFold(f,name$); (* write left fold view into text, with name as its short-form text *)
(* now write the long-form text *)
f.WriteString(name); (* first string *)
f.WriteTab; (* tab character *)
f.WriteString(number); (* second string *)
WriteCloseFold(f); (* write closing fold, and swap short- and long-form texts *)
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
END ObxPDBRep3.
Listing 5-17. Writing the phone database using folds
Procedure WriteCloseFold has two interesting properties. First, the fold is written in its expanded form. This is reasonable, since the expanded form is often more complex than the collapsed form, which thus can be used conveniently in WriteOpenFold (note the useful text directory procedure TextModels.dir.NewFromString). The collapsed version is more complex, and thus it is convenient to use the already existing text formatter. After the left fold view, the expanded text, and the right fold view have been written, the text is collapsed using the StdFolds.Flip procedure.
This leads us to the second interesting point. Collapsing the text modifies the text model. This invalidates all riders, and consequently all formatters, that operate on the text. For example, formatter f has always been at the end of the created text, but now that the text is collapsed, its position is beyond the end of the text and thus illegal. For this reason, the correct position is set up again.
This is a general observation when working with mutable carriers: whenever you modify a carrier's state (or whenever someone else may do so!) you possibly have to update some state of your riders. In this example, the text's length was modified, which made it necessary to update the formatter's position.
The last example in our series of demonstrations on how to generate texts uses link views. Link views are standard objects of the BlackBox Component Builder; they are implemented in the StdLinks module, only using BlackBox and its Text subsystem. Like fold views, link views are used in pairs. Their implementation uses a special interface of the text subsystem (TextControllers.FilterPollCursorMsg, TextControllers.FilterTrackMsg) to cause the cursor to turn into a hand cursor when it lies above the text stretch between the pair of link views. This behavior is known from typical hypertext systems, such as Web browsers, when the mouse is moved over a text stretch that symbolizes a hyperlink. This use of link views is what gave them their name. However, they are much more general than simple hyperlink delimiters. A hyperlink contains a passive reference to another document or to another location in the same document. For example, a document reference may be stored as a string, such as "http://www.oberon.ch" or "BlackBox/System/Rsrc/About".
Link views in contrast store a Component Pascal command, optionally with one or two string literals as parameters. The command is executed when the user clicks the mouse button when the mouse is between the two link views.
The command is stored in the left link view of a pair. Typical commands are:
DevDebug.ShowLoadedModules
StdCmds.OpenDoc('System/Rsrc/Menus')
StdCmds.OpenAux('System/Rsrc/About', 'About BlackBox')
In our example, we will create link views with commands similar to the following one:
ObxPDBRep4.Log('Daffy Duck310-555-1212')
Note: consult the documentation of module StdInterpreter, since there may be some restrictions on the possible parameter lists supported for such commands.
The Log procedure of our example module simply writes the parameter string to the log. In a more realistic example, the parameter string could be used to dial the respective number.
MODULE ObxPDBRep4;
IMPORT Views, TextModels, TextMappers, TextViews, StdLinks, StdLog, ObxPhoneDB;
CONST cmdStart = "ObxPDBRep4.Log('"; cmdEnd = "')";
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String; link:StdLinks.Link;
BEGIN
t := TextModels.dir.New(); (* create empty text carrier *)
f.ConnectTo(t); (* connect a formatter to the text *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
link:=StdLinks.dir.NewLink(cmdStart+name+""+number+cmdEnd);
f.WriteView(link);
f.WriteString(name); (* the string shown between the pair of link views *)
link:=StdLinks.dir.NewLink("");
f.WriteView(link);
f.WriteLn; (* carriage return *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* create a text view for the text generated above *)
Views.OpenView(v) (* open the text view in its own window *)
END GenReport;
PROCEDURELog*(param:ARRAYOFCHAR);
BEGIN
StdLog.String(param); StdLog.Ln
END Log;
END ObxPDBRep4.
Listing 5-18. Writing the phone database using links
Note that commands are normal procedure calls; like all procedure calls from outside of a module, they can only call those procedures of the module that are exported. Thus procedure Log of the above module must be exported, otherwise the program wouldn't work.
Another interesting property of link views is that they display themselves in different ways depending on whether the text view via which the user interacts with them displays or hides marks. If there are several text views on the same model, the user can independently switch marks on or off, such as inactive soft hyphens, ruler views or link views. The text subsystem provides an interface which allows views to distinguish between the two states (TextSetters.Pref). In particular, a view may decide to hide itself when no marks are shown, by setting its width to zero in this case. This is what link views do: when text marks are switched off, they are invisible, so that only the text between them is visible. Typically, this text is blue and underlined, to indicate that it represents a link. A ruler in contrast always occupies the whole width between its paragraph's left and right margin, but it sets its height to zero when the text marks are turned off. We will learn more about how containers and embedded views can cooperate to achieve such effects in Part III of this tutorial.
The above example demonstrates that link views can cause arbitrary behavior when the user clicks between them. This generality is powerful, but it should be used with caution. A command in a document is a kind of "implicit import" relation between the document and the command's module, and thus constitutes a dependency. This is not fundamentally different from the dependencies that are caused by views embedded in the document, they also function correctly only when their implementing component(s) are available. Like all dependencies, those caused by links, buttons embedded in a control, editors embedded in documents, and so on also need to be tracked and updated when necessary.
5.2 The Model-View-Controller pattern applied to texts
The next major examples demonstrate how existing text can be read. It is assumed that the text to be processed is visible, in the topmost window. On how to access texts that are stored in files, please refer to the on-line Obx examples ObxOpen0, ObxOpen1, and ObxAscii. Before starting with the specifics of text reading, we need to discuss how the topmost window's contents can be accessed from within a Component Pascal command.
Basically, this is done by calling Controllers.FocusView(). This function returns NIL if no document is open. Otherwise it returns the topmost window's contents, which is a view.
We have learned earlier that views, whose common base type is Views.View, are the pivotal BlackBox abstractions for interactive components, such as editors and controls. Everything revolves around views. In simple cases, such as controls, a view implementation only implements an extension to Views.View, and that's all. In more complex cases, the data that are visualized by a view are split off into a separate model. This was discussed in detail in Chapter 2.
Since container implementations are among the most complex programming tasks for which the BlackBox Component Builder was designed, the framework provides some help in how a container should be constructed. The abstract design of a container is given in module Containers. This module declares extensions of the types Views.View, Models.Model and Controllers.Controller; these types constitute a mini-framework for container construction.
Typical containers are implemented in at least four modules: one for the model, one for the view, one for the controller, and one for standard commands. For example, the text subsystem contains the modules TextModels, TextViews, TextControllers, TextCmds; plus the auxiliary modules TextMappers, TextRulers and TextSetters. The form subsystem consists of FormModels, FormViews, FormControllers, and FormCmds.
Figure 5-19. Variations of the generic container module decomposition
We won't look at all the details of these types; but it is important to know that a container object is not only split into a model and one or several views, but that a view is further split into a view and a so-called controller. For the time being, we can regard the management of selections and carets as the main functionality that a controller encapsulates. This is why we now look at controllers, because some of the following examples will operate on the current selection.
Once you have a controller, you can obtain its view by calling its ThisView procedure. Other procedures allow to get or set the current selection.
There may be several views displaying the same model (many-to-one relationship), but there is exactly one controller per view (one-to-one relationship). (This holds for views derived from Containers.View; other views may or may not have a separate controller.)You can get a controller's view by calling its ThisView procedure, and you can get a container view's controller by calling its ThisController procedure.
Figure 5-20. Model-View-Controller separation
More specific container abstractions typically provide a suitable Focus function which yields the controller of the currently focused view, if there is one and if it has the desired type.
We now know enough about the container scenario that we can tell how to access focus view, model, or controller:
The following declarations are assumed:
VAR v: Views.View; m: Models.Model; c: Controllers.Controller;
Simple view:
v := Controllers.FocusView();
View with a model:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
Extension of a Containers.View:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
IF (v # NIL) & (v IS Containers.View) THEN
c := v(Containers.View).ThisController()
ELSE
c := NIL
END
Listing 5-21. Accessing focus view, model, and controller
Typical container abstractions, such as the Text and Form subsystems, use the above mechanisms to provide more convenient access functions tailored to the specific container type. For example, module TextControllers exports the function Focus, which returns the focus view's controller if and only if the focus view is a text view. Otherwise it returns NIL. This approach is appropriate, since once you have a container controller, you can easily access its view, its model, information about its selection or caret, and so on. The typical code pattern that arises is some subset of the following one, depending on the controller's parts that you need:
PROCEDURE SomeCommand*;
VAR c: TextControllers.Controller;
v: TextViews.View; t: TextModels.Model; from, to, pos: INTEGER;
...
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
...
v := c.ThisView(); (* if you need the text view... *)
...
t := v.ThisModel(); (* or if you need the text model... *)
...
IF c.HasSelection() THEN (* or if you need the selection range... *)
c.GetSelection(from, to);
...
END;
...
IF c.HasCaret() THEN (* or if you need the caret position... *)
pos := c.CaretPos();
...
END;
...
ELSE (* no open document window, or focus has wrong type *)
(* no error handling is necessary if this command is guarded by appropriate guard command *)
END
END SomeCommand;
Listing 5-22. Code pattern for TextControllers.Controller
A menu command can use the guard TextCmds.FocusGuard to make sure that the command is only executed when a text view is focus. TextCmds.SelectionGuard additionally checks whether there exists some (non-empty) text selection.
5.3 Reading text
Now that we have seen how to access the focus views' controller, we can write our first command that reads the focus view's text. The command counts the number of Latin-1 characters (1 byte), Unicode characters above Latin-1 (2 byte), and embedded views.
MODULE ObxCount0;
IMPORT TextModels, TextControllers, StdLog;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard for this command **)
VAR c: TextControllers.Controller; from, to, schars, chars, views: INTEGER;
rd: TextModels.Reader;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* get selection range; from < to *)
rd := c.text.NewReader(NIL); (* create a new reader for this text model *)
rd.SetPos(from); (* set the reader to beginning of selection *)
rd.Read; (* read the first element of the text selection *)
schars := 0; chars := 0; views := 0; (* counter variables *)
WHILE rd.Pos() # to DO (* read all elements of the text selection *)
IF rd.view # NIL THEN (* element is a view *)
INC(views)
ELSIF rd.char < 100X THEN (* element is a Latin-1 character *)
INC(schars)
ELSE (* element is Unicode character *)
INC(chars)
END;
rd.Read (* read next element of the text selection *)
END;
StdLog.String("Latin-1 characters: "); StdLog.Int(schars); StdLog.Ln;
StdLog.String("Unicode characters: "); StdLog.Int(chars); StdLog.Ln;
StdLog.String("Views: "); StdLog.Int(views); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount0.
Listing 5-23. Counting Latin-1 characters, Unicode characters, and views in a text
The above example uses a TextModels.Reader, which is the text rider type for reading. Each reader maintains a current position on its base text; there can be several independent readers on the same text simultaneously. A text reader has the following definition:
TYPE
Reader = POINTER TO ABSTRACT RECORD
eot: BOOLEAN;
attr: TextModels.Attributes;
char: CHAR;
view: Views.View;
w, h: INTEGER;
(rd: Reader) Base (): TextModels.Model, NEW, ABSTRACT;
(rd: Reader) Pos (): INTEGER, NEW, ABSTRACT;
(rd: Reader) SetPos (pos: INTEGER), NEW, ABSTRACT;
(rd: Reader) Read, NEW, ABSTRACT;
(rd: Reader) ReadChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT;
(rd: Reader) ReadPrev, NEW, ABSTRACT;
(rd: Reader) ReadPrevChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadPrevView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadPrevRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT
END;
Listing 5-24. Definition of TextModels.Reader
Given a text model text, a reader can be created by calling rd := text.NewReader(NIL). Such a newly allocated reader will be positioned at the beginning of the text; i.e., at rd.Pos() = 0. The position can be changed whenever necessary by calling rd.SetPos(pos), with pos in the range of 0..text.Length(). The reader's text model can be obtained by calling its Base procedure.
Reading of the next text element is done by calling the reader's Read procedure, which increases the reader's current position unless the end of text has been reached, in which case the reader's eot field is set. After Read is called, the character code of the read element can be found in the reader's char field. If the character value is less than 100X, the character fits in the Latin-1 range (1-byte character), otherwise it's a 2-byte Unicode character. For convenience, the auxiliary reader procedure ReadChar is provided, which performs a Read and returns the contents of char.
What happens if a view is read? In most cases, char is set to the reserved value TextModels.viewcode (2X). However, this is not necessarily the case. A text-aware view may choose to represent an arbitrary character code by using a special preference message (TextModels.Pref). In order to find out whether a view has been read, the field view should be tested. It returns the view just read, or NIL if it wasn't a view.
When a view has been read, the fields w and h indicate the size of the view in universal units. Otherwise, these fields are undefined.
It is expected that the implementation of a text model optimizes access to views. For this purpose, the auxiliary reader procedure ReadView is provided, which reads the next view after the current position, skipping as many non-view elements as necessary.
After an element (character or view) has been read, its text attributes are returned in the reader's attr field. The text attributes consist of font attributes, color and vertical offset; as described earlier. For efficiency and convenience reasons, the auxiliary reader procedure ReadRun is provided, which advances the reader position until the attributes change from their current setting. Text runs that have the same attributes can be drawn on the screen with one port procedure (Ports.Frame.DrawString), which is considerably faster than drawing them character by character.
Normally, text is read forward; from lower positions to higher positions. The reader procedures ReadPrev, ReadPrevView and ReadPrevRun are symmetrical to their Read, ReadView and ReadRun counterparts, but they read backwards. In particular, ReadPrevView is used by a text view's so-called text setter to find the most recent ruler view, which defines how the text must be set (The auxiliary procedure TextRulers.GetValidRuler implements this search.)
When one of the reading procedures has been called (whether one of the forward or one of the backward reading procedures), the reader's eot field is set. If an element could be read, eot is set to FALSE. If no element could be read (reading forward at the end of the text, or reading backward at the beginning of the text), eot is set to TRUE.
Typically, the following code pattern arises when working with a text reader. condition may be something like rd.Pos() # end or ~rd.eot.
VAR rd: TextModels.Reader; start: INTEGER;
BEGIN
... define start ...
rd := text.NewReader(NIL);
rd.SetPos(start); (* only necessary if start # 0 *)
rd.Read;
WHILE condition DO
... consume text element denoted by rd ...
rd.Read
END;
Listing 5-25. Code pattern for TextModels.Reader
The next example uses a text scanner. Scanners are reading text mappers; like formatters, they are defined in module TextMappers. Text scanners are similar to text readers, except that they operate on whole symbols rather than characters. Strings and numbers are examples of Component Pascal symbols that are supported by text scanners.
When you compare the definition of a TextMappers.Scanner with the one of TextModels.Reader, you'll note that a scanner can also return characters (field char) and views with their sizes (fields view, w, and h); that a scanner has a position (Pos, SetPos), but that a scanner cannot read backwards. Scan corresponds to a reader's Read procedure. It skips white space (blanks, carriage returns) until it either reaches the end of the text, which is signaled by setting type to TextMappers.eot, or until it has read a symbol. The type of symbol that was read is returned in type. It may be one of the TextMappers constants
char, string, int, real, bool, set, view, tab, line, para, eot, invalid.
By default, views and control characters are treated as white space and thus ignored. Using an option set (opts, SetOpts) it is possible to treat them as valid symbols, too. The set element TextMappers.returnViews indicates that views should be recognized, while TextMappers.returnCtrlChars indicates that the three control characters for tabulators (tab), carriage returns (line) and paragraphs (para) should be recognized.
When a symbol starts like a Component Pascal string or identifier, the scanner attempts to read a string. When successful, type is set to string; which may also be a short string, i.e., only containing Latin-1 characters. The option TextMappers.returnQualIdents lets the scanner recognize complete qualified identifiers as single symbols; e.g., the string ThisMod.ThatObj . The length of the string is returned in len.
If it is possible to interpret the symbol as an integer or real number, type is set accordingly, as are the fields int or real. Integer numbers are recognized in different number bases, the base that was recognized is returned in base (10 for decimal numbers).
Special characters such as !@#$ are interpreted as type = TextMappers.char, which may also be a short character, i.e., a Latin-1 character.
By default, Boolean values and sets are not interpreted, except if the option elements TextMappers.interpretBool or TextMappers.interpretSets are set. Sets use the normal Component Pascal syntax, while Booleans are represented as $TRUE and $FALSE.
The scanner field start is the position of the first character of the most recently read symbol. The fields lines and paras count the number of carriage return and paragraph characters since the last SetPos (see below).
The scanner's Skip procedure is an auxiliary procedure that advances the scanner position until all white space characters ђ as specified in the opts set ђ are skipped and the first character of the symbol has been read. This character is returned in Skip's ch parameter.
Since there may be an arbitrary number of specialized text mappers, in addition to the ones provided by TextMappers, the text model cannot create text mapper objects, like it creates text readers and writers. Instead, scanners (and formatters likewise) are connected to their texts explicitly, by calling their ConnectTo procedures. They may be called repeatedly to connect the same scanner to different models.
Scanner = RECORD
rider-: TextModels.Reader;
opts-: SET;
type: INTEGER;
start, lines, paras: INTEGER;
char: CHAR;
int, base: INTEGER;
real: REAL;
bool: BOOLEAN;
set: SET;
len: INTEGER;
string: TextMappers.String;
view: Views.View;
w, h: INTEGER;
(VAR s: Scanner) ConnectTo (text: TextModels.Model), NEW;
(VAR s: Scanner) Pos (): INTEGER, NEW;
(VAR s: Scanner) SetPos (pos: INTEGER), NEW;
(VAR s: Scanner) SetOpts (opts: SET), NEW;
(VAR s: Scanner) Scan, NEW;
(VAR s: Scanner) Skip (OUT ch: CHAR), NEW
END;
Listing 5-26. Definition of TextModels.Scanner
The following example uses a text scanner to count the number of integer numbers, real numbers, and strings found in a text.
MODULE ObxCount1;
IMPORT TextModels, TextMappers, TextControllers, StdLog;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard for this command **)
VAR c: TextControllers.Controller; from, to, ints, reals, strings: INTEGER;
s: TextMappers.Scanner;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* get selection range; from < to *)
s.ConnectTo(c.text); (* connect scanner to this text model *)
s.SetPos(from); (* set the reader to beginning of selection *)
s.Scan; (* read the first symbol of the text selection *)
ints := 0; reals := 0; strings := 0; (* counter variables *)
WHILE s.Pos() < to DO (* read all symbols starting in the text selection *)
IF s.type = TextMappers.int THEN (* symbol is an integer number *)
INC(ints)
ELSIF s.type = TextMappers.real THEN (* symbol is a real number *)
INC(reals)
ELSIF s.type = TextMappers.string THEN (* symbol is a string/identifier *)
INC(strings)
END;
s.Scan (* read next symbol of the text selection *)
END;
StdLog.String("Integers: "); StdLog.Int(ints); StdLog.Ln;
StdLog.String("Reals: "); StdLog.Int(reals); StdLog.Ln;
StdLog.String("Strings: "); StdLog.Int(strings); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount1.
Listing 5-27. Counting integers, reals, and strings in a text
The most typical code pattern for a scanner looks similar to the code pattern for a reader. condition may be something like s.Pos() < end or s.type # TextMappers.eot.
VAR s: TextMappers.Scanner; start: INTEGER;
BEGIN
... define start ...
s.ConnectTo(text);
s.SetPos(start); (* only necessary if start # 0 *)
s.Scan;
WHILE condition DO
IF s.type = TextMappers.int THEN
... consume s.int ...
ELSIF s.type = TextMappers.real THEN
... consume s.real ...
ELSIF ...
...
END;
s.Scan
END;
Listing 5-28. Code pattern for TextMappers.Scanner
5.4 Modifying text
In the previous sections, we have seen how new texts can be created using writers or formatters, and how existing texts can be read using readers or scanners. Many text commands first read a text stretch, perform some computation on it, and then replace it by the result of the computation. Examples are commands that set the font of a selection, set the color of a selection, or turn all small letters into capital letters.
The following example command reads the text selection and checks whether it is a string. If so, it interprets the string as a name and looks the name up in our example phone database. Then it replaces the name by the phone number.
MODULE ObxLookup0;
IMPORT TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard command **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* scanner has already read on character beyond string! *)
c.text.Delete(from, to); (* delete name *)
c.text.Insert(from, buf, 0, buf.Length()); (* move phone number from buffer into text *)
c.SetSelection(from, from + LEN(number$)) (* select the phone number *)
END
END
END Do;
END ObxLookup0.
Listing 5-29. Replacing a phone name by a phone number
The basic idea of the above command is that an auxiliary text object is used which acts as a buffer. The text selection is scanned, the scanned string is used as key to make a lookup in the phone database, the returned phone number is written into the buffer text, the original name is deleted from the text, and then the buffer contents is moved to where the name was. As a final step, the newly inserted text stretch is selected.
Note that the text model's Delete procedure shortens the text, while the Insert procedure makes the text longer. In particular, Insert doesn't overwrite existing text. Insert moves text, i.e., it removes them at the source and inserts them at the destination.
One way to make the above command more useful would be to accept a caret as input, instead of a selection. Then you could write a name and hit a keyboard shortcut for the command. The command then reads backwards from the caret position, until it finds the beginning of the name, and then substitutes the appropriate phone number for the name. This would be a simple way to implement keyboard macros.
Buffer texts, as used above, are particularly useful in helping to avoid screen flicker: since a buffer text is not displayed, it can be built up piecemeal, without causing any screen updates. When the buffer has been completed, its contents can be moved over to the visible destination text. This only causes one single screen update, which is fast and creates minimal flicker.
Moving text stretches from one text model to another one may be optimized if both text models have the same implementation. This is not necessarily the case, since different implementations of type TextModels.Model may coexist with each other. Two calls to TextModels.dir.New() may well return two text models that have different implementations.
For this reason, module TextModels exports the procedure Clone, which returns an empty text model of exactly the same type as its parameter. In fact, the standard text implementation even performs some further optimizations when a text model is cloned from another one, rather than allocated via TextModels.dir.New().
We can now give a (slightly simplified) definition of TextModels.Model:
TYPE
Model = POINTER TO ABSTRACT RECORD (Containers.Model)
(m: Model) NewWriter (old: TextModels.Writer): TextModels.Writer, NEW, ABSTRACT;
(m: Model) NewReader (old: TextModels.Reader): TextModels.Reader, NEW, ABSTRACT;
(m: Model) Length (): INTEGER, NEW, ABSTRACT;
(m: Model) Insert (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) InsertCopy (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) Delete (beg, end: INTEGER), NEW, ABSTRACT;
(m: Model) Append (m0: TextModels.Model), NEW, ABSTRACT;
(m: Model) Replace (beg, end: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) SetAttr (beg, end: INTEGER; attr: TextModels.Attributes), NEW, ABSTRACT;
END;
Listing 5-30. Definition of TextModels.Model
We have already met most of its procedures. InsertCopy is similar to Insert, but instead of moving, it copies a text stretch, without modifying the source. Delete removes a text stretch.
Insert, InsertCopy, and Delete are the elementary text operations. Append and Replace are provided for convenience and efficiency; they can be expressed in terms of the elementary operations:
dst.Append(src) dst.Insert(dst.Length(), src, 0, src.Length())
i.e., it moves the whole contents of the source text to the end of the destination text, thereby leaving an empty source text.
t.Replace(b, e, t1, b1, e1) t.Delete(b, e); t.Insert(b, t1, b1, e1)
i.e., it overwrites some part of the destination text by some part of the source text (which is thereby removed). Note that source and destination texts must be different.
SetAttr allows to set the text attributes of a whole text stretch.
5.5 Text scripts
When you have successfully applied the command ObxLookup0.Do to a text stretch, you can try out something that may surprise you: you can reverse ("undo") the operation by executing the Edit->Undo command! With Edit->Redo you can reverse the operation's reversal.
This capability is surprising because we have only implemented the plain Do procedure, but no code for undoing or redoing it. How come that the framework is able to undo/redo the operation anyway?
It is possible because the text model procedures which modify their model's state, such as Model.Delete and Model.Insert, are implemented in a particular way. They don't execute the modification directly. Instead, they create special operation objects and register them in the framework. The framework then can call the operation's appropriate procedure for performing the actual do/undo/redo functionality. This mechanism has been described in Chapter 3.
The following example shows how a sequence of text-modifying procedures is bracketed by BeginScript and EndScript to make the whole sequence undoable. BeginScript returns a script object, it gets the name of the compound operation as input.
MODULE ObxLookup1;
IMPORT Stores, Models, TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard command **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
script:Stores.Operation;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* scanner has already read on character beyond string! *)
Models.BeginScript(c.text,"#Obx:Lookup",script);
c.text.Delete(from, to); (* delete name *)
c.text.Insert(from, buf, 0, buf.Length()); (* move phone number from buffer into text *)
Models.EndScript(c.text,script);
c.SetSelection(from, from + LEN(number$)) (* select the phone number *)
END
END
END Do;
END ObxLookup1.
Listing 5-31. Example of a script (compound operation)
In Models.BeginScript, the name of the compound operation is given. It is mapped by the string mapping facility of BlackBox, because this name may be displayed to the user (in the undo/redo menu item).
In modules ObxLookup0 and ObxLookup1 use the following statement sequence to replace the name with the number:
c.text.Delete(from, to);
c.text.Insert(from, buf, 0, buf.Length());
To combine these two operations into a single compound operation (as experienced by the user), it was necessary to bracket the two calls with the BeginScript / EndScript pair. In this special case here, there actually would be a better solution:
c.text.Replace(from, to, buf, 0, buf.Length());
TextModels.Model.Replace is a powerful procedure of which Insert, Delete, and Append are special cases (provided for convenience):
t.Delete(beg, end) = t.Replace(beg, end, t, 0, 0)
t.Insert(pos, t0, beg, end) = t.Replace(pos, pos, t0, beg, end)
t.Append(t0) = t.Replace(t.Length(), t.Length(), t0, 0, t0.Length())
Note that InsertCopy cannot be expressed in terms of Replace:
t.InsertCopy(pos, t0, beg, end) # t.Replace(pos, pos, t0, beg, end)
The reason is that Replace, like Insert, deletes the source text. InsertCopy on the other hand is a pure copying operation which doesn't modify the source text (unless source and destination texts are identical and the destination position lies within the source text range).
5.6 Summary
We now conclude the discussion of the BlackBox Component Builder's Text subsystem. The goal of this tutorial was to give an overview over a relatively complex extension subsystem; to show the use of the previous part's design patterns; and to show the typical Text code patterns.
The treatment of the text subsystem cannot be complete, there are still many details for which the reference documentation of the various modules must be consulted. However, the general scope and typical applications should have become clearer. While we started with as little theory as possible and used simple examples only, the basic structure of a complex container subsystem will have become clearer by now.
Before we give a list of further on-line examples that you may want to study, here is a list of all standard modules of the Text subsystem (lowest module in the hierarchy first), with the most important types that they export:
module / type description
TextModels abstraction and default implementation of text models
Attributes attributes of a text elem (font, color, vertical offset)
Context link between a text model and a view embedded in it
Directory factory for text models
Model text carrier, factory for readers and writers
Reader rider for element-wise text reading
Writer rider for element-wise text writing
TextMappers abstraction and implementation of text mappers for Component Pascal symbols
Formatter mapper for symbol-wise text writing
Scanner mapper for symbol-wise text reading
TextRulers abstraction and default implementation for ruler views, which embody paragraph attributes
Attributes attributes of text ruler (tabs, margins, grid, etc.)
Directory factory for text rulers
Ruler view for rulers
Style model for rulers
TextSetters abstraction and default implementation for text setters, which perform line / page breaking
Directory factory for text setters
Reader text mapper which collects text into units of text setting
(non-breakable sequences) and determines their size
Setter object which implements a text setting algorithm
TextViews abstraction and default implementation of text views
Directory factory for text views
View view for text models
TextControllers abstraction and default implementation of text controllers
Controller controller for text views
Directory factory for text controllers
TextCmds command package with most important text commands
Table 5-32. Table of Text system modules and most important types
ObxHello0 write "Hello World" to log
ObxHello1 write "Hello World" to new text
ObxOpen0 open text document from a file, using standard file open dialog
ObxOpen1 modify a text document on a file, using standard file open and save dialogs
ObxCaps change string to uppercase, using compound operation
ObxDb manage sorted list of records
ObxTabs transform some tabs into blanks
ObxMMerge mail merge of template and database
ObxParCmd interpret text which follows a command button
ObxLinks create a directory text with hyperlinks
ObxAscii traditional text file I/O
Table 5-33. Additional Obx on-line examples of Text subsystem
Part III: View Construction
Part I of the BlackBox tutorial gives an introduction to the design patterns that are used throughout BlackBox. To know these patterns makes it easier to understand and remember the more detailed design decisions in the various BlackBox modules.
Part II of the BlackBox tutorial demonstrates how the most important library components can be used: control, form, and text components.
Part III of the BlackBox tutorial demonstrates how new views can be developed, by giving a series of examples that gradually become more sophisticated.
6 View Construction
Views are the central abstraction in the BlackBox Component Builder. Everything revolves around views: most commands operate on views, windows display views, views can be internalized and externalized, views perform interaction with the user, and views may be embedded into other views.
6. 1 Introduction
This view programming tutorial consists of four sections, each of which introduces a special aspect of view programming. The section "message handling" (chapters 6.2 to 6.5) explains how the behavior of a view is defined through the view's message handlers, i.e., how the answering of preferences, controller messages and properties influences the view's relation to its environment and the view's reaction on user input. The second section explains the aspect of the model-view separation which allows multi view editing (6.6). The next section shows how the undo/redo facility of the BlackBox Component Framework can be used if the content of a view is changed with the help of operation objects (6.7). In the last section the special structure of all extensible BlackBox Component Framework modules is explained, namely the separation of the interface and the implementation of a view (6.8). Directory objects are the key to this design pattern.
6.2 Message handling
In this section, we present a sequence of increasingly more versatile implementations of a view object which displays a rectangular colored area. In particular, this view will handle Preferences, Controller messages and Properties.
Every view is a subtype of the abstract type Views.View. The concrete extension must at least implement the abstract procedure Views.Restore that draws the view's contents. The first example of our view simply draws a red rectangle. This version is about the simplest possible view implementation. Its major components are the declaration of a Views.View extension, the implementation of a Views.Restore procedure which draws the contents of the view, and a command procedure which allocates and initializes the view:
MODULE ObxViews0;
IMPORT Views, Ports;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews0.
To execute this program, invoke the following command:
"ObxViews0.Deposit; StdCmds.Open"
The result of this command is shown in Figure 6-1.
Figure 6-1: Result of "ObxViews0.Deposit; StdCmds.Open"
This simple program is completely functional already. The procedure ObxViews0.Deposit puts a newly allocated view into a system queue. The command StdCmds.Open in the command string above removes a view from this queue, and opens it in a new window. Note that whole sequences of commands must be enclosed between quotes, while for single commands the quotes may be omitted.
Instead of opening the view in a window, it could be pasted into the focus container (e.g., a text or a form):
"ObxViews0.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
Like StdCmds.Open, the command StdCmds.PasteView removes a view from the queue, but pastes it to the focus view. The above command sequence could also be used in a menu, for example.
Every document which contains an ObxViews0 view can be saved in a file, and this file can be opened again through the standard Open... menu entry. Our simple red rectangle will be displayed correctly in the newly opened document, provided the code file of the module ObxViews0 is available.
A view which has been opened in its own window can also be saved in a file. When opened again, the document then consists of this single view only.
Every view performs its output operations and mouse/keyboard polling via a Views.Frame object. In the above example, ObxViews0.View.Restore uses its frame parameter f to draw a string. A frame can be regarded as a mapper object, in this case for both input and output simultaneously (here we need not be interested in the rider and carrier for this mapper, which are both defined in module Ports). A frame embodies coordinate transformations and clipping facilities.
If the view is displayed on the screen, the frame is a mapper on a screen port. If the view is printed, the frame is a mapper on a printer port. From the view's perspective, this difference is not relevant. Thus no special code is necessary to support printing.
The view may be copied and pasted into containers such as text views or form views. Additionally, the size of the view can be changed by selecting it and then manipulating the resize handles. All this functionality is offered by the BlackBox Component Framework and requires no further coding. If this default behavior is not convenient, it can be modified. In the following we will show how this is done.
6.3 Preference messages
You might have noticed that the size of a newly opened view is rather arbitrary. However, before opening the view, the framework sends the view a message with a proposed size. The view may adapt this proposal to its own needs. To do that, the message of type Properties.SizePref must be answered in the view's HandlePropMsg procedure. Before a view is displayed for the first time, the proposed size for the width and the height of the view is Views.undefined. The following version of our sample view draws a rectangle with a width of 2 cm and a height of 1 cm. Changes compared to the previous version are written in bold face.
MODULE ObxViews1;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
END
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews1.
"ObxViews1.Deposit; StdCmds.Open"
Every newly generated view now assumes the desired predefined size. This is only possible because the view and its container cooperate, in this case via the Properties.SizePref message. A container is expected to send this message whenever it wants to change a view's size, and then adhere to the returned data. However, for the understanding of the BlackBox Component Framework it is essential to know that while a well-behaved container should follow this protocol, it is not required to do so. That's why such a message is called a preference. It describes merely a view's preference, so that the surrounding container can make allowances for the special needs of the view. But it is always the container which has the last word in such negotiations. For example, the container will not let embedded views become larger than itself. The standard document, text, and form containers are well-behaved in that they support all preferences defined in module Properties. Special containers, e.g. texts, may define additional preferences specific to their type of contents. It is important to note that a view can ignore all preferences it doesn't know or doesn't care about.
The Properties.SizePref allows us to restrict the possible values for the width and the height of a view. For example, we can enforce a minimal and a maximal size, or fix the height or width of the view, or specify a constraint between its width and height. The procedures Properties.ProportionalConstraint and Properties.GridConstraint are useful standard implementations to specify constraints. The next version of our view implementation specifies that the rectangle is always twice as wide as it is high. In addition, minimal and maximal values for the height (and thus also for the width) are specified. If the view is resized using the resize handles, the constraints are not violated. Try it out!
MODULE ObxViews2;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews2.
"ObxViews2.Deposit; StdCmds.Open"
We will look at two other preferences in this tutorial. The first one is Properties.ResizePref.
TYPE
ResizePref = RECORD (Properties.Preference)
fixed,
horFitToPage, verFitToPage,
horFitToWin, verFitToWin: BOOLEAN (* OUT *)
END;
The receiver of this message may indicate that it doesn't wish to be resized, by setting fixed to TRUE. As a consequence, the view will not display resize handles when it is selected, i.e., it cannot be resized interactively. However, the Properties.SizePref message is still sent to the view, as the initial size still needs to be determined.
If a view is a root view, i.e., the outermost view in a document or window (e.g., if opened with StdCmds.Open), then the size of the window, the size of the view, or both might be changed.
However, sometimes it is convenient if the view size is automatically adapted whenever the window is resized, e.g., for help texts which should use as much screen estate as possible. For other views, it may be preferable that their size is not determined by the window, but rather by their contents, or by the page setup of the document in which they are embedded. A view can indicate such preferences by setting the horFitToWin, verFitToWin, horFitToPage, and verFitToPage flags in the Properties.SizePref message. These flags have no effect if the view is not a root view, i.e., if it is embedded deeper inside a document.
An automatic adaptation of the view size to the actual window size can be achieved by setting the fields horFitToWin and verFitToWin. The size of the view is then bound to the window, i.e., the user can change it directly by resizing the window.
Note that if the size of the view is bound to the size of the window (either by setting horFitToWin or verFitToWin), then no Properties.SizePref messages are sent to the view, i.e., the constraints specified through Properties.SizePref are no longer enforced. Additionally, the view does not display resize handles, regardless of the fixed flag.
By setting the fields horFitToPage or verFitToPage, the width or the height of the view can be bound to the actual printer page size. The width of a text view is usually bound to the width of the page size, and can be changed via the page setup mechanism of the underlying operating system. The following example enforces that the size of a root view is bound to the size of the window:
MODULE ObxViews3;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews3.
"ObxViews3.Deposit; StdCmds.Open"
The next preference we look at is Properties.FocusPref.
TYPE
FocusPref = RECORD (Properties.Preference)
atLocation: BOOLEAN; (* IN *)
x, y: INTEGER; (* IN *)
hotFocus, setFocus, selectOnFocus: BOOLEAN (* OUT *)
END;
When an attempt is made to activate an embedded view, by clicking in it, then the Properties.FocusPref message is sent to the view. If this message is not answered the view is selected as a whole (a so-called singleton). This is the behavior of the views implemented in the examples above. To see this, place the caret on the next line and click on the commander below, then on the pasted view:
"ObxViews3.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
This behavior is adequate if a view is passive. However, if the view contains editable contents, or if there are menu commands that operate on the view, the user should be able to focus the view. The focus is where keyboard input is sent to, where the current selection or caret are displayed (if there are any such marks), and where upon some menu commands operate. In fact, menus can be made to appear whenever a view is focused, and disappear as soon as the view loses focus (more on this below). A root view is always focused when its document window is focus (i.e., is the top window).
If an embedded view wants to become focus, it must answer the Properties.FocusPref message. The view can choose whether it wants to become focus permanently or if it wants only be focus as long as the mouse button is pressed. The latter is called a hot focus. A typical example of a hot focus is a command button. If a view wants to be a hot focus, it must set the flag hotFocus. The focus is then released immediately after the mouse is released. If a view wants to become focus permanently, then the flag setFocus must be set instead. setFocus should be set for all genuine editors, such that context-sensitive menu commands can be attached to the view. In addition to the setFocus flag, a view may set the selectOnFocus flag to indicate that upon focusing by keyboard, the view's contents should be selected. Text entry fields are prime examples for this behavior: the contents of a newly focused text entry field is selected, if the user focused it not by clicking in it, but by using the tabulator key.
If the user clicks in an unfocused view, then the atLocation flag is set by the framework before sending the message. The receiving view may decide whether to become focused depending on where the user clicked. The mouse position is passed to the view in the focus preference's x and y fields. Text rulers are examples of views which become focused depending on the mouse location. If you click in the icons or in the area below the scale of a ruler, the ruler is not focused. Otherwise it is focused. Try this out with the ruler below. If you don't see a ruler, execute the Show Marks command in the Text menu.
A view is not necessarily focused through a mouse click. In forms for example, the views can be selected using the tabulator key. There, the views do not become focused through a mouse click, and the atLocation field is accordingly set to FALSE by the framework.
The next version of our example will answer the FocusPref message and set the setFocus flag. This is done by adding the following statements to the previous example's HandlePropMsg procedure:
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
If an embedded view is focused, the frame of the view is marked with a suitable focus border mark, and view-specific menus may appear while others disappear.
6.4 Controller messages
Other messages that may be interpreted by HandlePropMsg will be discussed later. Next we will see how a view can react on user input, e.g., on mouse clicks in the view or on commands called through a menu. For simple views this behavior is implemented in the procedure Views.HandleCtrlMsg. It is also possible to define a separate object, a so-called controller, that implements the interactive behavior of a view. Programming of controller objects is not described in this document, since controllers are only recommended for the most complex views.
TheViews.HandleCtrlMsg handler answers the controller messages sent to the view. A controller message is a message that is sent along exactly one path in a view hierarchy, the focus path. Every view on the focus path decides for itself whether it is the terminal of this path, i.e., whether it is the current focus, or whether the message should be forwarded to one of its embedded views. It is important to note that all controller messages which are not relevant for a particular view type can simply be ignored.
In order to be able to perform edit operations on the focus view, the framework must allow to somehow perform these operations. Mouse clicks and key strokes can always be issued. However, how the menus should look like may be decided by the view itself. For that purpose, the message Controllers.PollOpsMsg is sent to the view. Depending on its current state (e.g., its current selection) and depending on the contents of the clipboard, the focus view can inform the framework of which editing operations it currently supports. The valid operations are elements of the {Controllers.cut, Controllers.copy, Controllers.paste, Controllers.pasteView} set.
TYPE
PollOpsMsg = RECORD (Controllers.Message)
type: Stores.TypeName; (* OUT *)
pasteType: Stores.TypeName; (* IN *)
singleton: Views.View; (* OUT *)
selectable: BOOLEAN; (* OUT *)
valid: SET (* OUT *)
END;
The set of valid edit operations is returned in the valid field, where valid IN {Controllers.cut, Controllers.copy, Controllers.paste}. According to the set of valid operations, the corresponding menu entries in the Edit menu are enabled or disabled, e.g., Cut, Copy, Paste and PasteObject... (Windows) / Paste as Part (Mac OS). The field pasteType contains the concrete type of the view from which a copy would be pasted, if a paste operation occurred. Depending on this field, the view could decide whether it wants to support the paste operation or not. PollOpsMsg is sent when the user clicks in the menu bar. Its sole purpose is to enable or disable menu items, i.e., to provide user feedback.
If a view supports a selection of its contents, then selectable must be set to TRUE. As a consequence, the menu entry SelectAll will be enabled. The flag should be set regardless of whether a selection currently exists or not.
In the type field a type name may be passed. This name denotes a context for the focus view. This context is used to determine which menus are relevant for the focus view. As a convention, a view assigns the type name of its interface base type to type, e.g. "ObxViews4.View". A menu which indicates to be active on "ObxViews4.View" will be displayed if such a view is focus. The type name is used because it is easy to make unique, so that name collisions are avoided. The framework doesn't interpret the name.
The singleton field is only meaningful for container views. It denotes a container's currently selected view, if the selection consists of exactly one embedded view.
The following example view can become focus, supports the paste operation, and informs the framework that its contents is selectable. As a consequence, the menu entries Paste and Select All in the Edit menu are enabled. Additionally, it defines the context "Obx.Tutorial". Therefore the following menu appears whenever the view is focused; provided that the menu has been installed.
Note that the name of the context, in this case "Obx.Tutorial", by convention starts with the subsystem or a module name followed by a dot, in this case "Obx.". This is highly recommended, in order to make context names globally unique. Often, the name is simply the name of a view type, e.g., "TextViews.View".
A menu can either be defined in the global menu text System/Rsrc/Menus, or more appropriately in its own subsystem's menu text, in this case in Obx/Rsrc/Menus . The global menu text then only needs an INCLUDE "Obx" statement to make the Obx menus known.
MENU "New" ("Obx.Tutorial")
"Beep" "" "Dialog.Beep" ""
END
MODULE ObxViews4;
IMPORT Views, Ports, Properties, Controllers;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message; VAR focus: Views.View);
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews4.
"ObxViews4.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
Next we discuss how a view can react on actual edit messages. In particular, these are the Controllers.EditMsg for edit operations such as cut, copy, or paste, and the Controllers.TrackMsg for mouse clicks.
Whenever a key is pressed in a view or when a cut, copy or paste operation is invoked, a Controllers.EditMsg is sent to the focus view. The cut, copy and paste operations can only be generated through the environment (menu) if they have been announced with the Controllers.PollOpsMsg.
TYPE
EditMsg = RECORD (Controllers.RequestMessage)
op: INTEGER; (* IN *)
modifiers: SET; (* IN *)
char: CHAR; (* IN *)
view: Views.View; (* IN for paste, OUT for cut and copy *)
w, h: INTEGER; (* IN for paste, OUT for cut and copy *)
isSingle: BOOLEAN; (* IN for paste, OUT for cut and copy *)
clipboard: BOOLEAN (* IN *)
END;
The op field specifies which kind of operation has to be performed. If op = Controllers.cut then a copy of the focus view has to be generated. The contents of the new view is a copy of the focus view's selection. The new view is assigned to the view field. In addition, the selection is deleted in the focus view.
There is one special case: if the selection consists of exactly one view (a singleton), then a copy of the singleton should be copied to the view field, not a copy of the singleton's container. In this case, isSingle must be set to TRUE.
Except for the deletion of the selection, the same operations have to be performed if op = Controllers.copy.
If a key is pressed, then the op field has the value Controllers.pasteChar. The character to be pasted is stored in the char field. The modifiers set indicates whether a modifier or control key has been pressed. In the latter case, the char field has to be interpreted as a control character.
The paste operation is the inverse of the copy operation: a copy of the contents of the view stored in the view field has to be copied into the focus view's contents. This operation is indicated by op = Controllers.paste. The view must know the type of the view whose contents is to be pasted and must decide how to insert the pasted view's contents into its own view. For example, a text field view should support copying from a text view only.
If isSingle is TRUE, or if the contents of view cannot be pasted because it has an unknown or incompatible type, a copy of view must be pasted. Of course, this is only possible in general containers, which allow the embedding of other views.
When pasting a complete view, the desired width and height of the pasted view are given in the fields w and h. These values can be treated as hints by the receiving view. If they are not suitable, others can be used.
Whenever the mouse button is pressed in the focus view, a Controllers.TrackMsg is sent to the view. The coordinates are specified in the x and y fields (of the base type Controllers.CursorMessage). The modifiers set indicates whether modifier keys have been pressed, or whether a double click has been performed. modifiers IN {Controllers.doubleClick, Controllers.extend, Controllers.modify}. If the view wants to show a feedback while tracking the mouse, it needs to poll the mouse position in a loop, by calling the Input procedure of the passed frame. Input also returns information on whether the mouse has been released. Any feedback should directly be drawn into the frame in which the mouse button was pressed.
After the feedback loop, a possible modification of the view's contents need to be broadcast to all the frames that display the same view. Remember that the same document, and consequently all its embedded views, may be displayed in several windows (see Chapter 2). If an embedded view is visible in three windows, there exist three frames displaying the same view. Procedure Views.Update causes a restore of the view once in each of its visible frames.
As an example, we extend our view with a cross-hair marker that can be moved around. The coordinates of this marker are stored as additional fields in the view object. Note that if a view contains instance variables, it should implement the CopyFromSimpleView, Internalize and Externalize procedures in order to work properly. We refer to the next section of this view tutorial, which describes the purpose of these messages. In our example view, the marker can be moved around with the mouse, or through the cursor keys. When a cursor key is pressed, the focus view is informed by sending it an EditMsg with op = pasteChar.
From time to time a Controllers.PollCursorMsg is sent to the focus view. The view may set the form of the cursor depending on the coordinates of the mouse. The cursor field can be assigned a cursor out of {Ports.arrowCursor, Ports.textCursor, Ports.graphicsCursor, Ports.tableCursor, Ports.bitmapCursor}. The particular form of the cursor depends on the underlying operating system. In our example view, we set the cursor to a graphics cursor.
MODULE ObxViews5;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y,
0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* cursor keys *)
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y;
v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; Views.Deposit(v)
END Deposit;
END ObxViews5.
"ObxViews5.Deposit; StdCmds.Open"
There exist many other controller messages which may be sent to a view, but which are beyond the scope of this tutorial. There are messages for the generic scrolling mechanism of the BlackBox Component Framework (Controllers.PollSectionMsg, Controllers.ScrollMsg, Controllers.PageMsg), messages which implement drag & drop (Controllers.PollDropMsg, Controllers.DropMsg, Controllers.TransferMessage) and messages which control the selection (Controllers.SelectMsg). For these and other controller messages we refer to the documentation of the Controllers module.
6.5 Properties
We want to close this section with a final extension of our view: the color of the view should be changeable through the Attributes menu. The general mechanism to get and set attributes of a view from its environment are properties. A view may know about attributes such as font, color, size, but it may also know about arbitrary other attributes. Properties are set with the Properties.SetMsg and inspected with the Properties.PollMsg. Properties in one of these messages are stored in a linked list. If a view gets a Properties.SetMsg it should traverse its property list and adjust those properties it knows about. A Properties.GetMsg is sent to the view to get its properties. The view should return all properties it knows about. Properties can be inserted into a message's property list with the Properties.Insert procedure.
Every property describes up to 32 attributes. The known set defines which attributes are known to the view. The view may also specify which attributes are read-only in the readOnly set. The valid set finally defines which attributes currently have a defined value. For example, if in a text several characters with different sizes are selected, then the attribute size is known to the view, but currently does not have a valid value. The selection is not homogeneous, and thus there is no single valid value.
TYPE
Property = POINTER TO ABSTRACT RECORD
next-: Properties.Property;
known, readOnly, valid: SET; (* valid and readOnly are subsets of known *)
(p: Property) IntersectWith (q: Properties.Property; OUT equal: BOOLEAN), NEW, ABSTRACT
END;
A special property is Properties.StdProp. This property encompasses font attributes as well as color, and it is known to the BlackBox environment. The supported attributes are Properties.color, Properties.typeface, Properties.size, Properties.style, Properites.weight. The fields in the property record hold the corresponding values.
TYPE
StdProp = POINTER TO RECORD (Properties.Property)
color: Dialog.Color;
typeface: Fonts.Typeface;
size: INTEGER;
style: RECORD
val, mask: SET
END;
weight: INTEGER
END;
The last version of our view only support the color attribute of the standard property. If it receives a Properties.PollMsg message, it returns a Properties.StdProp object where only the color field is set, and where only the color attribute is defined as known and valid. On a Properties.SetMsg, the property list must be searched for a standard property whose color field is valid. When the color has been changed, the view must be updated in all its frames.
MODULE ObxViews6;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER;
c: Ports.Color
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, v.c);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y, 0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
VAR stdProp: Properties.StdProp; prop: Properties.Property;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
| msg: Properties.PollMsg DO
NEW(stdProp);
stdProp.color.val := v.c;
stdProp.valid := {Properties.color};
stdProp.known := {Properties.color};
Properties.Insert(msg.prop, stdProp)
| msg: Properties.SetMsg DO
prop := msg.prop;
WHILE prop # NIL DO
WITH prop: Properties.StdProp DO
IF Properties.color IN prop.valid THEN v.c := prop.color.val END
ELSE
END;
prop := prop.next
END;
Views.Update(v, Views.keepFrames)
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y; v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; v.c := Ports.black; Views.Deposit(v)
END Deposit;
END ObxViews6.
"ObxViews6.Deposit; StdCmds.PasteView" >< set the caret here before executing the command
6.6 Model-View separation
In this section, we present a sequence of five increasingly more versatile versions of a view object which displays a string that may be typed in by the user. This string represents the view-specific data which it displays. We will see that multi-view editing is possible if this string is represented by a separate model object.
Let us start with a first version of this view, where the string is stored in the view itself. Every view displays its own string. A string's length is limited to 255 characters, but no error handling is performed in the following demonstration programs.
MODULE ObxViews10;
IMPORT Fonts, Ports, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* accept typing *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* append character to string *)
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews10.
"ObxViews10.Deposit; StdCmds.Open"
As described in the last section, a character typed in is sent to the view in the form of a controller message record (Controllers.Message), to be handled by the view's HandleCtrlMsg procedure. This procedure is called with a Controllers.EditMsg as actual parameter when a character was typed in, and it reacts by inserting the character contained in the message into its field s. Afterwards, it causes the view to be restored; i.e., wherever the view is visible on the display it is redrawn in its new state, displaying the string that has become one character longer.
In the above example, a view contains a variable state (the view's string field s). This state should be saved when the window's contents are saved to disk. For this purpose, a view provides two procedures, called Internalize and Externalize, whose uses are shown in the next iteration of our example program:
MODULE ObxViews11;
(* Same as ObxViews10, but the view's string can be stored and copied *)
IMPORT Fonts, Ports, Stores, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(v.i); rd.ReadString(v.s)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(v.i); wr.WriteString(v.s)
END Externalize;
PROCEDURE (v: View) CopyFromSimpleView (source: Views.View);
BEGIN
WITH source: View DO
v.i := source.i; v.s := source.s
END
END CopyFromSimpleView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* accept typing *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* append character to string *)
Views.SetDirty(v); (* mark view's document as dirty *)
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews11.
A few comments about View.Internalize and View.Externalize are in order here: First, the two procedures have a reader, respectively a writer, as variable parameters. These file mappers are set up by BlackBox itself; a view simply uses them.
Second, View.Internalize must read exactly the same (amount of) data that View.Externalize has written.
Third, a user interface typically defines some visual distinction for documents that contain modified views, i.e., for "dirty" documents. Or it may require that when the user closes a dirty document, he or she should be asked whether to save it or not. In order to make this possible, a view must tell when its contents has been modified. This is done by the Views.BeginModification /Views.EndModification calls.
In addition to View.Internalize and View.Externalize, the above view implementation also implements a CopyFromSimpleView procedure. Such a procedure should copy the view's contents, given a source view of the same type. CopyFromSimpleView should usually have the same effect as if the source's contents were externalized on a temporary file, and then internalized again by the destination view. There can be exceptions, though. For example, a text copies even temporary embedded views such as error markers, but it doesn't externalize them.
A view that contains (mutable) state should implement CopyFromSimpleView, so that it can be printed. The reason that this is necessary is that the framework makes a shallow copy of a view that is being printed, in order to avoid the original view to be changed by pagination, scrolling, or similar modifications that may be performed during printing.
Basically, ObxViews11 has shown most of what is involved in implementing a simple view class. Such simple views are often sufficient; thus it is important that they are easy to implement. However, there are cases where a more advanced view design is in order. In particular, if a window normally can only display a small part of a view's contents, multi-view editing should be supported.
Multi-view editing means that there may be several views showing the same data. The typical application of this feature is to have two or more windows displaying the same document, each of these windows showing a different part of it in its own view. Thus, if a view's data has been changed, it and all the other affected views must be notified of the change, such that they can update the display accordingly.
The following sample program, which is the same as the previous one except that it supports multi-view editing, is roughly twice as long. This indicates that the design and implementation of such views is quite a bit more involved than that of simple views. It is a major design decision whether this additional complexity is warranted by its increased convenience.
MODULE ObxViews12;
(* Same as ObxViews11, but uses a separate model for the string *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
(* Model *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* View *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View;
model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR m: Model; umsg: Models.UpdateMsg;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
m := v.model;
m.s[m.i] := msg.char; INC(m.i);
m.s[m.i] := 0X; (* append character to string *)
Views.SetDirty(v); (* mark view's document as dirty *)
Models.Broadcast(m, umsg) (* update all views on this model *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews12.
"ObxViews12.Deposit; StdCmds.Open"
Multi-view editing is realized by factoring out the view's data into a separate data structure, called a model. This model is shared between all its views, i.e., each such view contains a pointer to the model:
Figure 6.2: Two Views on one Model
A model is, like a view, an extension of a Stores.Store, which is the base type for all persistent objects. Stores define the Internalize and Externalize procedures we've already met for a view. In ObxViews12, the model stores the string and its length, while the view stores the whole model! For this purpose, a Stores.Writer provides a WriteStore and a Stores.Reader provides a ReadStore procedure.
Stores may form arbitrary graphs. For example, one or several views may refer to the same model, both models and views are store extensions. A graph of stores that may be saved in a file is called a document. In order to recognize the boundary of a document upon externalization, stores are bound to a domain. All stores of a document refer to the same domain object (Stores.Domain).
Domains are also used as containers for operations, i.e., commands performed on some store which can be undone and redone (see next chapter). The operation history is associated with a domain. Furthermore, domains define the set of objects which get notified in a broadcast (either Views.Broadcast, Views.Domaincast or Models.Broadcast).
For more information on stores and domains, see the on-line documentation of module Stores.
Now that the model is separated from the view, copying is done by the model, not by the view anymore.
View.ThisModel returns the model of the view. Its default implementation returns NIL, which should be overridden in views that contain models. This procedure is used by the framework to find all views that display a given model, in order to implement model broadcasts, as described in the next paragraph.
Views with a model implement the procedure View.CopyFromModelView instead of View.CopyFromSimpleView. Like Internalize and Externalize, CopyFromSimpleView and CopyFromModelView are exported as implement-only procedures, i.e., they can only be implemented, but not called. They are called internally in module Views, in its CopyOf and CopyWithNewModel functions.
When a model changes, all views displaying it must be updated. For this purpose, a model broadcast is generated: A model broadcast notifies all views which display a particular model about a model modification that has happened. This gives each view the opportunity to restore its contents on the screen. A model broadcast is generated in the View.HandleCtrlMsg procedure by calling Models.Broadcast. The message is received by every view which contains the correct model, via its View.HandleModelMsg procedure.
This indirection becomes important if different types of views display the same model, e.g., a tabular view and a graphical view on a spreadsheet model; and if instead of restoring the whole view ђ as has been done in our examples ђ only the necessary parts of the views are restored. These necessary parts may be completely different for different types of views.
A very sophisticated model may be able to contain ("embed") arbitrary views as part of its contents. For example, a text view may display a text model which contains not only characters (its intrinsic contents), but also graphical or other views flowing along in the text stream.
The combination of multi-view editing and hierarchical view embedding can lead to the following situation, where two text views show the same text model, which in turn contains a graphics view. Each text view lives in its own window and thus has its own frame. The graphics view is unique however, since it is embedded in the text model, which is shared by both views. Nevertheless the graphics can be visible in both text views simultaneously, and thus there can be two frames for this one view:
Figure 6-3: Two Frames on one View
As a consequence, one and the same view may be visible in several places on the screen simultaneously. In this case, this means that when the view has changed, several places must be updated: the view must restore the necessary area once for every frame on this view. As a consequence, a notification mechanism must exist which lets the view update each of its frames. This is done in a similar way as the notification mechanism for model changes: with a view broadcast. Fortunately, there is a standard update mechanism in the framework which automatically handles this second broadcast level (see below).
We now can summarize the typical events that occur when a user interacts with a view:
Controller message handling:
1) Some controller message is sent to the focus view.
2) The focus view interprets the message and changes its model accordingly.
3) The model broadcasts a model message, describing the change that has been performed.
Model message handling:
4) Every view on this model receives the model message.
5) It determines how its display should change because of this model modification.
6) It broadcasts a view message, describing how its display should change.
View message handling:
7) The view receives the view notification message once for every frame on this view.
8) Every time, the view redraws the frame contents according to the view message.
This mechanism is fundamental to the BlackBox Component Framework. If you have understood it, you have mastered the most complicated part of a view implementation. Interpreting the various controller messages, which are defined in module Controllers, is more a matter of diligence than of understanding difficult new concepts. Moreover, you only need to interpret the controller messages in which you are interested, because messages that are not relevant can simply be ignored.
Usually, steps 6, 7, and 8 are handled automatically by the framework: the view merely calls Views.Update if a whole view should be updated, or Views.UpdateIn if some rectangular part of the view should be updated. Calls of these update procedures cause a lazy update, i.e., the framework adds up the region to be updated, but does not immediately cause any redrawing. Instead, the command first runs to completion, so that all data structures of the modified views are consistent again. Only the display of the views is still the same as before the command. But then the framework restores all views that have been marked for update. This means that for every frame that displays a view, the view's Restore method is called with this frame as argument. If the view is displayed in two (or more) frames in different windows, it is restored two (or more) times; once for every frame. When the framework starts restoring frames of a window, it temporarily redirects the drawing operations of a port into a background pixelmap buffer. When all frames of this window that need updating have been restored, the framework copies the pixelmap buffer to the screen pixelmap, and turns off the redirection of drawing operations.
The effect of this buffering mechanism and of the lazy update mechanism is that minimal flickering occurs. The lazy update mechanism (also used by Apple for the Mac OS, and by Microsoft for Windows) means that even for complex editing operations, a given screen region is only restored once. This can reduce flickering, since flickering can occur when the same area is drawn several times in rapid succession. The buffering mechanism reduces flickering if drawing occurs in layers, from "bottom" to "top" (because this also means drawing several time in rapid succession). For example, you may first draw the background in one color, and then the a filled rectangle on top of it in another color. Thanks to the buffering mechanism, the user never sees the situation after the background is drawn, but before the rectangle is drawn.
The lazy update mechanism also has another advantage: it completely decouples the modification of a model from its drawing. Without this mechanism, it can become rather difficult to correctly perform screen updates for complex editing operations. For example, consider moving a selection of graphics objects in a graphics editor. The selected objects first must be deleted at their old position, this may mean that other objects that have been obscured by the selection now need to be drawn (but not the selected objects themselves!). Then the objects' positions are changed, and then they are redrawn at their new positions (if the source and target positions overlap, drawing has now happened twice). Drawing may have to be done several times, if there are several windows displaying the same data. But of course the change of object positions must only occur once. It is much less tricky to simply call Views.UpdateIn for all rectangles that (may) need updating, and to let the framework call the necessary Restore methods later!
Normally, the lazy update mechanism is sufficient. Thus a view programmer needs to use explicit view messages only if no complete restore in all frames of a view is desired. This is the case only for marks like selection, focus, or carets, or for rubberbanding or similar feedback effects during mouse tracking. Such marks can sometimes be handled more efficiently because they are involutory: applied twice, they have no effect. Thus marks are often switched on and off through custom view messages during a command, not through the delaying lazy update mechanism. But except for such light-weight marks, you should always use the lazy update mechanism described above. Note that there exists a method Ports.Frame.MarkRect explicitly for drawing such marks.
6.7 Operations
Now that we have seen the crucial ingredients of a view implementation, a less central feature can be presented. The next program is a variation of the above one, in which a controller message is not interpreted directly. Instead, an operation object is created and then executed. An operation provides a do / undo / redo capability, as shown in the program below.
The operation we define in this example is the PasteCharOp. The operation's Do procedure performs the desired modification, and must be involutory, i.e. when called twice, its effect must have been neutralized again. We use the flag PasteCharOp.do to specify whether the character PasteCharOp.char has to be inserted into or removed from the model PasteCharOp.m. In any case, the Do procedure has to update all views on the model PasteCharOp.m with a model broadcast.
The procedure NewPasteCharOp generates a new operation and the procedure Models.Do executes this operation, i.e., the operation's Do procedure is called and the operation is recorded for a later undo. The name of the operation as specified in the Models.Do command will appear in the Edit menu after the Undo or Redo entry respectively.
MODULE ObxViews13;
(* Same as ObxViews12, but generate undoable operations for character insertion *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: Model;
char: CHAR;
do: BOOLEAN
END;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: Model; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do operation's transformation *)
m.s[m.i] := op.char; INC(m.i) (* insert character into string *)
ELSE (* undo operation's transformation *)
DEC(m.i) (* remove character from string *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* toggle between "do" and "undo" *)
Models.Broadcast(m, msg) (* update all views on this model *)
END Do;
PROCEDURE NewPasteCharOp (m: Model; char: CHAR): PasteCharOp;
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
RETURN op
END NewPasteCharOp;
(* Model *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* View *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR op: Stores.Operation;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
op := NewPasteCharOp(v.model, msg.char); (* generate operation *)
Models.Do(v.model, "Typing", op) (* execute operation *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews13.
"ObxViews13.Deposit; StdCmds.Open"
Further examples which use the undo/redo mechanism through operations can be found e.g. in ObxOmosi or ObxLines.
6.8 Separation of interface and implementation
As a last version of our sample view, we modify the previous variant by exporting the Model and View types, and by separating interface and implementation of these two types. In order to do the latter, so-called directory objects are introduced, which generate (hidden) default implementations of abstract data types. A user now might implement its own version of the abstract type and offer it through its own directory object, however he can not inherit from the default implementation and thus avoids the fragile base class problem.
Real BlackBox subsystems would additionally split the module into two modules, one for the model and one for the view. A third module with commands might be introduced, if the number and complexity of commands warrant it (e.g., TextModels, TextViews, and TextCmds). Even more complicated views would further split views into views and controllers, each in its own module.
MODULE ObxViews14;
(* Same as ObxViews13, but interfaces and implementations separated, and operation directly in Insert procedure *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model* = POINTER TO ABSTRACT RECORD (Models.Model) END;
ModelDirectory* = POINTER TO ABSTRACT RECORD END;
View* = POINTER TO ABSTRACT RECORD (Views.View) END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdModel = POINTER TO RECORD (Model)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
StdModelDirectory = POINTER TO RECORD (ModelDirectory) END;
StdView = POINTER TO RECORD (View)
model: Model
END;
StdDirectory = POINTER TO RECORD (Directory) END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: StdModel;
char: CHAR;
do: BOOLEAN
END;
VAR
mdir-: ModelDirectory;
dir-: Directory;
(* Model *)
PROCEDURE (m: Model) Insert* (char: CHAR), NEW, ABSTRACT;
PROCEDURE (m: Model) Remove*, NEW, ABSTRACT;
PROCEDURE (m: Model) GetString* (OUT s: ARRAY OF CHAR), NEW, ABSTRACT;
(* ModelDirectory *)
PROCEDURE (d: ModelDirectory) New* (): Model, NEW, ABSTRACT;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: StdModel; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do operation's transformation *)
m.s[m.i] := op.char; INC(m.i);
ELSE (* undo operation's transformation *)
DEC(m.i) (* remove character from string *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* toggle between "do" and "undo" *)
Models.Broadcast(m, msg) (* update all views on this model *)
END Do;
(* StdModel *)
PROCEDURE (m: StdModel) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: StdModel) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: StdModel) CopyFrom (source: Stores.Store);
BEGIN
WITH source: StdModel DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
PROCEDURE (m: StdModel) Insert (char: CHAR);
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
Models.Do(m, "insertion", op)
END Insert;
PROCEDURE (m: StdModel) Remove;
VAR msg: Models.UpdateMsg;
BEGIN
DEC(m.i); m.s[m.i] := 0X;
Models.Broadcast(m, msg) (* update all views on this model *)
END Remove;
PROCEDURE (m: StdModel) GetString (OUT s: ARRAY OF CHAR);
BEGIN
s := m.s$
END GetString;
(* StdModelDirectory *)
PROCEDURE (d: StdModelDirectory) New (): Model;
VAR m: StdModel;
BEGIN
NEW(m); m.s := ""; m.i := 0; RETURN m
END New;
(* Directory *)
PROCEDURE (d: Directory) New* (m: Model): View, NEW, ABSTRACT;
(* StdView *)
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
IF st IS Model THEN
v.model := st(Model)
ELSE
(* concrete model implementation couldn't be loaded->
an alien store was created *)
rd.TurnIntoAlien(Stores.alienComponent)
(* internalization of v is cancelled *)
END
END
END Internalize;
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: StdView) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
WITH source: StdView DO
v.model := model(Model)
END
END CopyFromModelView;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR s: ARRAY 256 OF CHAR;
BEGIN
v.model.GetString(s);
f.DrawString(d, d, Ports.black, s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: StdView) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: StdView) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* restore v in any frame that displays it *)
END HandleModelMsg;
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
v.model.Insert(msg.char) (* undoable insertion *)
END
ELSE (* ignore other messages *)
END
END HandleCtrlMsg;
PROCEDURE (v:StdView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 *d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New* (m: Model): View;
VAR v: StdView;
BEGIN
ASSERT(m # NIL, 20);
NEW(v); v.model := m; Stores.Join(v, m);
RETURN v
END New;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
v := dir.New(mdir.New());
Views.Deposit(v)
END Deposit;
PROCEDURE SetModelDir* (d: ModelDirectory);
BEGIN
ASSERT(d # NIL, 20);
mdir := d
END SetModelDir;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20);
dir := d
END SetDir;
PROCEDURE Init;
VAR md: StdModelDirectory; d: StdDirectory;
BEGIN
NEW(md); mdir := md;
NEW(d); dir := d
END Init;
BEGIN
Init
END ObxViews14.
"ObxViews14.Deposit; StdCmds.Open"
A simple example of a BlackBox module which follows this design is DevMarkers. The marker views are simple views without a model, therefore only a directory object to generate new views is offered. The second directory object DevMarkers.stdDir keeps the standard implementation provided by this module. It might be used to install back the default implementation or to reuse the default implementation (as an instance) in another component.
The separation of a type's definition from its implementation is recommended in the design of new BlackBox subsystems. However, simple view types which won't become publicly available or which are not meant to be extended can certainly dispense with this additional effort.
Note that the subsystem wizard (menu item Tools->Create Subsystem...) helps to generate templates for the different kinds of view. In particular, it is possible to generate separate model and view modules. The tool uses the template texts stored in Dev/Rsrc/New. You may want to study the files Models5, Views5, and Cmds5 in this directory.
Appendix A: A Brief History of Pascal
Algol
The language Component Pascal is the culmination of several decades of research. It is the youngest member of the Algol family of languages. Algol, defined in 1960, was the first high-level language with a readable, structured, and systematically defined syntax. While successful as a notation for mathematical algorithms, it lacked important data types, such as pointers or characters.
Pascal
In the late sixties, several proposals for an evolutionary successor to Algol were developed. The most successful one was Pascal, defined in 1970 by Prof. Niklaus Wirth at ETH Zьrich, the Swiss Federal Institute of Technology. Besides cleaning up or leaving out some of Algol's more obscure features, Pascal added the capability to define new data types out of simpler existing ones. Pascal also supported dynamic data structures; i.e., data structures which can grow and shrink while a program is running. Pascal received a big boost when ETH released a Pascal compiler that produced a simple intermediate code for a virtual machine (P-code), instead of true native code for a particular machine. This simplified porting Pascal to other processor architectures considerably, because only a new P-code interpreter needed be written for this purpose, not a whole new compiler. One of these projects had been undertaken at the University of California, San Diego. Remarkably, this implementation (UCSD Pascal) didn't require a large and expensive mainframe computer, it ran on the then new Apple II personal computers. This gave Pascal a second important boost. The third one came when Borland released TurboPascal, a fast and inexpensive compiler, and integrated development environment for the IBM PC. Later, Borland revived its version of Pascal when it introduced the rapid application development environment Delphi.
Pascal has greatly influenced the design and evolution of many other languages, from Ada to Visual Basic.
Modula-2
In the mid-seventies, inspired by a sabbatical at the Xerox Palo Alto Research Center PARC, Wirth started a project to develop a new workstation computer. This workstation should be completely programmable in a high-level language, thus the language had to provide direct access to the underlying hardware. Furthermore, it had to support team programming and modern software engineering principles, such as abstract data types. These requirements led to the programming language Modula-2 (1979). Modula-2 retained the successful features of Pascal, and added a module system as well as a controlled way to circumvent the language's type system when doing low-level programming; e.g., when implementing device drivers. Modules could be added to the operating system at run-time. In fact, the whole operating system consisted of a collection of modules, without a distinguished kernel or similar artefact. Modules could be compiled and loaded separately, with complete type and version checking of their interfaces.
Modula-2 has made inroads in particular into safety-critical areas, such as traffic control systems.
Simula, Smalltalk, and Cedar
Wirth's interest remained with desktop computers, however, and again an important impulse came from Xerox PARC. PARC was the place where the workstation, the laser printer, the local area network, the bitmap display, and many other enabling technologies have been invented. Also, PARC adopted and made popular several older and barely known technologies, like the mouse, interactive graphics, and object-oriented programming. The latter concept, if not the term, was first applied to a high-level language in Simula (1966), another member of the Algol language family. As its name suggests, Simula used object-orientation primarily for simulation purposes. Xerox PARC's Smalltalk language (1983), however, used it for about anything. The Smalltalk project broke new ground also in user interface design: the graphical user interface (GUI) as we know it today was developed for the Smalltalk system.
At PARC, these ideas influenced other projects, e.g., the Cedar language, a Pascal-style language. Like Smalltalk and later Oberon, Cedar was not only the name of a language but also of an operating system. The Cedar operating system was impressive and powerful, but also complex and unstable.
Oberon
The Oberon project was initiated in 1985 at ETH by Wirth and his colleague Jьrg Gutknecht. It was an attempt to distill the essence of Cedar into a comprehensive, but still comprehensible, workstation operating system. The resulting system became very small and efficient, working well with only 2 MB of RAM and 10 MB of disk space. An important reason for the small size of the Oberon system was its component-oriented design: instead of integrating all desirable features into one monolithic software colossus, the less frequently used software components (modules) could be implemented as extensions of the core system. Such components were only loaded when they were actually needed, and they could be shared by all applications.
Wirth realized that component-oriented programming required some features of object-oriented programming, such as information hiding, late binding, and polymorphism.
Information hiding was the great strength of Modula-2. Late binding was supported by Modula-2 in the form of procedure variables. However, polymorphism was lacking. For this reason, Wirth added type extension: a record type could be declared as an extension of another record type. An extended type could be used wherever one of its base types might be used.
But component-oriented programming is more than object-oriented programming. In a component-based system, a component may share its data structures with arbitrary other components, about which it doesn't know anything. These components usually don't know about each other's existence either. Such mutual ignorance makes the management of dynamic data structures, in particular the correct deallocation of unused memory, a fundamentally more difficult problem than in closed software systems. Consequently, it must be left to the language implementation to find out when memory is not used anymore, in order to safely reclaim it for later use. A system service which performs such an automatic storage reclamation is called a garbage collector. Garbage collection prevents two of the most evasive and downright dangerous programming errors: memory leaks (not giving free unused memory) and dangling pointers (releasing memory too early). Dangling pointers let one component destroy data structures that belong to other components. Such a violation of type safety must be prevented, because component-based systems may contain many third-party components of unknown quality (e.g., downloaded from the Internet).
While Algol-family languages always had a reputation of being safe, complete type safety (and thus garbage collection) still was a quantum leap forward. It also was the reason why complete compatibility with Modula-2 was not possible. The resulting revision of Modula-2 was called the same way as the system: Oberon.
Oberon's module system, like the one of Modula-2, provided information hiding for entire collections of types, not only for individual objects. This allowed to define and guarantee invariants spanning several cooperating objects. In other words: it allowed developers to invent higher-level safety mechanisms, by building on the basic module safety and type safety provided by a good Oberon implementation.
Orthodox object-oriented programming languages such as Smalltalk had neglected both typing (by not supporting types) and information hiding (by restricting it to objects and classes), which was a major step backwards as far as software engineering is concerned. Oberon reconciled the worlds of object-oriented and modular programming.
As a final requirement of component-oriented programming, it had to be possible to dynamically load new components. In Oberon, the unit of loading was the same as the unit of compilation: a module.
Component Pascal
In 1992, a cooperation with Prof. H. P. Mцssenbцck led to a few additions to the original Oberon language ("Oberon-2"). It became the de-facto standard of the language.
In 1997, the ETH spin-off Oberon microsystems, Inc. (with Wirth on its board of directors) made some small extensions to Oberon-2 and called it Component Pascal, to better express its focus (component-oriented programming) and its origin (Pascal). It is the industrial-strength version of Oberon, so to say.
The main thrust of the enhancements compared to Oberon-2 was to give the designer of a framework (i.e., of module interfaces that define abstract classes for a particular problem domain) more control over the framework's custom safety properties. The benefit is that it becomes easier to ascertain the integrity of a large component-based system, which is particularly important during iterative design cycles when the framework is being developed, and later when the system architecture must be refactored to enable further evolution and maintenance.
BlackBox
Oberon microsystems developed the BlackBox Component Framework starting in 1992 (originally it was called Oberon/F). This component-oriented framework is written in Component Pascal, and simplifies the development of graphical user interface components. It comes bundled with several BlackBox extension components, including a word processor, a visual designer, an SQL database access facility, an integrated development environment, and the Component Pascal run-time system. The complete package is an advanced yet light-weight rapid application development (RAD) tool for components, called BlackBox Component Builder. It is light-weight because it is completely built out of Component Pascal modules ђ including the kernel with the garbage collector, and the Component Pascal compiler itself.
Appendix B: Differences between Pascal and Component Pascal
Eliminated Features
Subrange types
Use a standard integer type instead.
Enumeration types
Use integer constants instead.
Arbitrary array ranges
Arrays are always defined over the integer range 0..max-1.
Example
A = ARRAY 16 OF INTEGER (* legal indices are in the range 0..15 *)
No general sets
Type SET denotes the integer set which may include the elements 0..31.
No explicit DISPOSE
Memory is reclaimed automatically by the garbage collector. Instead of calling DISPOSE, simply set the variable to NIL.
No variant records
Use record extension instead.
No packed structures
Use SHORTCHAR or BYTE types for byte-sized values.
No GOTO
No PRED and SUCC standard functions
Use DEC or INC on integer values instead.
No built-in input/output facilities
No file types. I/O is provided by library routines.
Changed Features
Standard procedure ENTIER instead of ROUND
Syntax for REAL constants
3.0E+4 but not 3.0e+4
Syntax for pointer type declarations
P = POINTER TO R
instead of
P = ^R
Syntax for case statement
"|" instead of ";" as case separator.
ELSE clause.
Example
CASE i * 3 - 1 OF
0: StdLog.String("zero")
| 1..9: StdLog.String("one to nine")
| 10, 20: StdLog.String("ten or twenty")
ELSE StdLog.String("something else")
END
Procedure name must be repeated
Example
PROCEDURE DrawDot (x, y: INTEGER);
BEGIN
END DrawDot;
Case is significant
Small letters are distinguished from capital letters.
Example "proc" is not the same as "Proc".
String syntax
String literals are either enclosed between " or between '. There cannot be both single and double quotes in one string. String literals of length one are assignment-compatible to character variables.
Examples
"That's great" 'Write "hello world" to the screen'
ch := "x"
ch := 'x'
Comments
Comments are enclosed between (* and *) and may be nested.
Set brackets
Set constants are given between { and } instead of [ and ].
Example {0..2, 4, j..2 * k}
Function syntax
Use keyword PROCEDURE for functions also, instead of FUNCTION.
Procedures with a return value always have a (possibly empty) parameter list in their declarations and in calls to them.
The function result is returned explicitly by a RETURN statement, instead of an assignment to the function name.
Example
PROCEDURE Fun (): INTEGER;
BEGIN
RETURN 5
END Fun;
instead of
FUNCTION Fun: INTEGER;
BEGIN
Fun := 5
END;
n := Fun() instead of n := Fun
Declarations
The sequence of declarations is
{ ConstDecl | TypeDecl | VarDecl} {ProcDecl | ForwardDecl}
instead of
[ConstDecl] [TypeDecl] [VarDecl] {ProcDecl}.
Forward declarations are necessary if a procedure is used before it is defined.
Example
PROCEDURE ^ Proc;
instead of
PROCEDURE Proc; FORWARD;
Procedure types
Procedures may not only be passed to parameters, but also to procedure-typed variables.
Example
TYPE P = PROCEDURE (x, y: INTEGER);
VAR v: P;
v := DrawDot; (* assign *)
v(3, 5); (* call DrawDot(3, 5) *)
Explicit END instead of compound statement
BEGIN can only occur before a statement sequence, but not in it. IF, WHILE, and LOOP are always terminated by END.
WITH statement
A WITH statement is a regional type guard, it does not imply a hidden variable and does not open a new scope.
See language reference for more details.
ELSIF
IF statements can have several branches.
Example
IF name = "top" THEN
StdLog.Int(0)
ELSIF name = "bottom" THEN
StdLog.Int(1)
ELSIF name = " charm" THEN
StdLog.Int(2)
ELSIF name = "beauty" THEN
StdLog.Int(3)
ELSE
StdLog.String("strange")
END
BY instead of only DOWNTO in FOR
FOR loops may use any constant value as increment or decrement.
Example
FOR i := 15 TO 0 BY -1 DO StdLog.Int(i, 0) END
Boolean expressions use short-circuit evaluation
A Boolean expression terminates as soon as its result can be determined.
Example
The following expression does not cause a run-time error when p = NIL:
IF (p # NIL) & (p.name = "quark") THEN
Constant expressions
In constant declarations, not only literals, but also constant expressions are allowed.
Example
CONST
zero = ORD("0");
one = zero + 1;
Different operators
# is used instead of <> for inequality test.
& is used instead of AND for logical conjunctions.
~ is used instead of NOT for logical negation.
Explicit conversion to included type with SHORT
Type inclusion for numeric types allows to assign values of an included type to an including type. To assign in the other direction, the standard procedure SHORT must be used.
Example
int := shortint;
shortint := SHORT(int)
New Features
Hexadecimal numbers and characters
Example
100H (* decimal 256 *)
0DX (* carriage return *)
Additional numeric types
LONGINT, SHORTINT, BYTE, SHORTREAL have been added.
Symmetric set difference
Sets can be subtracted.
New standard procedures
The new standard procedures INC, DEC, INCL, EXCL, SIZE, ASH, HALT, ASSERT, LEN, LSH, MAX, MIN, BITS, CAP, ENTIER, LONG and SHORT have been added.
LOOP with EXIT
There is a new loop statement with an explicit exit statement. See language report for more details.
ARRAY OF CHAR can be compared
Character arrays can be compared with the =, #, <, >, <=, and >= operators.
Open arrays, multidimensional arrays
Arrays without predefined sizes can be defined, possibly with several dimensions.
Examples
VAR a: POINTER TO ARRAY OF CHAR;
NEW(a, 16)
PROCEDURE ScalarProduct (a, b: ARRAY OF REAL; VAR c: ARRAY OF REAL);
TYPE Matrix = ARRAY OF ARRAY OF REAL;
PROCEDURE VectorProduct (a, b: ARRAY OF REAL; VAR c: Matrix);
Pointer dereferencing is optional
The dereferencing operator ^ can be omitted.
Example
root.next.value := 5
instead of
root^.next^.value := 5
Modules
Modules are the units of compilation, of information hiding, and of loading. Information hiding is one of the main features of object-oriented programming. Various levels of information hiding are possible: complete hiding, read-only / implement-only export, full export.
See language report for more details.
Type extension
Record types (pointer types) can be extended, thus providing for polymorphism. Polymorphism is one of the main features of object-oriented programming.
Methods
Procedures can be bound to record types (pointer types), thus providing late binding. Late binding is one of the main features of object-oriented programming. Such procedures are also called methods.
String operator
The string (sequence of characters) that is contained in an array of character can be selected by using the $-selector.
Record attributes
Records are non-extensible by default, but may be marked as EXTENSIBLE, ABSTRACT, or LIMITED.
Method attributes
Methods are non-extensible by default, but may be marked as EXTENSIBLE, ABSTRACT, or EMTPY. Newly introduced methods must be marked as NEW.
| Docu/Tut-Tot.odc |
Набор литер
ENGLISH
(c) Редакция перевода: Ф.В.Ткачев, 2009-03-20
Содержание
Списокнаборалитер
Управляющиекоды,используемыевБлэкбоксе
Набор литер для типа данных SHORTCHAR в Компонентном Паскале это 8-битный набор литер, основанный на стандарте ISO 8859-1. Он включает ASCII (American Standard Code for Information Interchange) и так называемое расширение Latin-1 для ASCII. Расширение Latin-1 включает в себя большинство букв, нужных в языках, использующих латинскую графику.
Набор литер для типа данных CHAR в Компонентном Паскале Юникод.
Как ASCII, так и Latin-1 содержат позиции для управляющих кодов, которые используются для разных целей, но которым не соответствует графический образ, т.е. графическое представление литеры.
Для системы Блэкбокс несколько знаков препинания из 16-битного стандарта Юникод были отображены на неиспользуемую верхнюю часть управляющих кодов набора Latin-1.
Список набора литер
В нижеследующем списке даны имена для каждого неуправляющего кода в наборе литер. Точно такие же соглашения используются для имен в стандарте Юникод, для которого набор литер Компонентного Паскаля является подмножеством.
<В приводимой таблице литеры, соответствующие в Latin-1 кодам латинских букв с украшениями, могут выглядеть, в зависимости от используемой гарнитуры, как буквы кириллицы.>
16-ричный Литера Название Комментарий
код
20 SPACE
21 ! EXCLAMATION MARK
22 " QUOTATION MARK
23 # NUMBER SIGN
24 $ DOLLAR SIGN
25 % PERCENT SIGN
26 & AMPERSAND
27 ' APOSTROPHE-QUOTE
28 ( OPENING PARENTHESIS
29 ) CLOSING PARENTHESIS
2A * ASTERISK
2B + PLUS SIGN
2C , COMMA
2D - HYPHEN-MINUS использовать только как минус;
касательно дефисов см. коды 90, 91 и AD
2E . PERIOD
2F / SLASH
30 0 DIGIT ZERO
31 1 DIGIT ONE
32 2 DIGIT TWO
33 3 DIGIT THREE
34 4 DIGIT FOUR
35 5 DIGIT FIVE
36 6 DIGIT SIX
37 7 DIGIT SEVEN
38 8 DIGIT EIGHT
39 9 DIGIT NINE
3A : COLON
3B ; SEMICOLON
3C < LESS-THAN SIGN
3D = EQUAL SIGN
3E > GREATER-THAN SIGN
3F ? QUESTION MARK
40 @ COMMERCIAL AT
41 A LATIN CAPITAL LETTER A
42 B LATIN CAPITAL LETTER B
43 C LATIN CAPITAL LETTER C
44 D LATIN CAPITAL LETTER D
45 E LATIN CAPITAL LETTER E
46 F LATIN CAPITAL LETTER F
47 G LATIN CAPITAL LETTER G
48 H LATIN CAPITAL LETTER H
49 I LATIN CAPITAL LETTER I
4A J LATIN CAPITAL LETTER J
4B K LATIN CAPITAL LETTER K
4C L LATIN CAPITAL LETTER L
4D M LATIN CAPITAL LETTER M
4E N LATIN CAPITAL LETTER N
4F O LATIN CAPITAL LETTER O
50 P LATIN CAPITAL LETTER P
51 Q LATIN CAPITAL LETTER Q
52 R LATIN CAPITAL LETTER R
53 S LATIN CAPITAL LETTER S
54 T LATIN CAPITAL LETTER T
55 U LATIN CAPITAL LETTER U
56 V LATIN CAPITAL LETTER V
57 W LATIN CAPITAL LETTER W
58 X LATIN CAPITAL LETTER X
59 Y LATIN CAPITAL LETTER Y
5A Z LATIN CAPITAL LETTER Z
5B [ OPENING-SQUARE BRACKET
5C \ BACKSLASH
5D ] CLOSING SQUARE BRACKET
5E ^ SPACING CIRCUMFLEX
5F _ SPACING UNDERSCORE
60 ` SPACING GRAVE
61 a LATIN SMALL LETTER A
62 b LATIN SMALL LETTER B
63 c LATIN SMALL LETTER C
64 d LATIN SMALL LETTER D
65 e LATIN SMALL LETTER E
66 f LATIN SMALL LETTER F
67 g LATIN SMALL LETTER G
68 h LATIN SMALL LETTER H
69 i LATIN SMALL LETTER I
6A j LATIN SMALL LETTER J
6B k LATIN SMALL LETTER K
6C l LATIN SMALL LETTER L
6D m LATIN SMALL LETTER M
6E n LATIN SMALL LETTER N
6F o LATIN SMALL LETTER O
70 p LATIN SMALL LETTER P
71 q LATIN SMALL LETTER Q
72 r LATIN SMALL LETTER R
73 s LATIN SMALL LETTER S
74 t LATIN SMALL LETTER T
75 u LATIN SMALL LETTER U
76 v LATIN SMALL LETTER V
77 w LATIN SMALL LETTER W
78 x LATIN SMALL LETTER X
79 y LATIN SMALL LETTER Y
7A z LATIN SMALL LETTER Z
7B { OPENING CURLY BRACKET
7C | VERTICAL BAR
7D } CLOSING CURLY BRACKET
7E ~ TILDE
7F резерв
80 .. 8A резерв
8B ‹ ZERO WIDTH SPACE (Unicode 200B)
8C .. 8E резерв
8F Џ DIGIT SPACE (отсутствует в Юникоде)
90 ђ HYPHEN (Unicode 2010)
91 NON-BREAKING HYPHEN (Unicode 2011)
92 .. 9F резерв
A0 NON-BREAKING SPACE
A1 Ў INVERTED EXCLAMATION MARK
A2 ў CENT SIGN
A3 Ј POUND SIGN
A4 CURRENCY SIGN
A5 Ґ YEN SIGN
A6 BROKEN VERTICAL BAR
A7 SECTION SIGN
A8 Ё SPACING DIAERESIS
A9 COPYRIGHT SIGN
AA Є FEMININE ORDINAL INDICATOR
AB LEFT POINTING GUILLEMET
AC NOT SIGN
AD SOFT HYPHEN
AE REGISTERED TRADE MARK SIGN
AF Ї SPACING MACRON
B0 DEGREE SIGN
B1 PLUS-OR-MINUS SIGN
B2 І SUPERSCRIPT DIGIT TWO
B3 і SUPERSCRIPT DIGIT THREE
B4 ґ SPACING ACUTE
B5 MICRO SIGN
B6 PARAGRAPH SIGN
B7 MIDDLE DOT
B8 ё SPACING CEDILLA
B9 № SUPERSCRIPT DIGIT ONE
BA є MASCULINE ORDINAL INDICATOR
BB RIGHT POINTING GUILLEMET
BC ј FRACTION ONE QUARTER
BD Ѕ FRACTION ONE HALF
BE ѕ FRACTION THREE QUARTERS
BF ї INVERTED QUESTION MARK
C0 А LATIN CAPITAL LETTER A GRAVE
C1 Б LATIN CAPITAL LETTER A ACUTE
C2 В LATIN CAPITAL LETTER A CIRCUMFLEX
C3 Г LATIN CAPITAL LETTER A TILDE
C4 Д LATIN CAPITAL LETTER A DIAERESIS
C5 Е LATIN CAPITAL LETTER A RING
C6 Ж LATIN CAPITAL LETTER A E
C7 З LATIN CAPITAL LETTER C CEDILLA
C8 И LATIN CAPITAL LETTER E GRAVE
C9 Й LATIN CAPITAL LETTER E ACUTE
CA К LATIN CAPITAL LETTER E CIRCUMFLEX
CB Л LATIN CAPITAL LETTER E DIAERESIS
CC М LATIN CAPITAL LETTER I GRAVE
CD Н LATIN CAPITAL LETTER I ACUTE
CE О LATIN CAPITAL LETTER I CIRCUMFLEX
CF П LATIN CAPITAL LETTER I DIAERESIS
D0 Р LATIN CAPITAL LETTER ETH
D1 С LATIN CAPITAL LETTER N TILDE
D2 Т LATIN CAPITAL LETTER O GRAVE
D3 У LATIN CAPITAL LETTER O ACUTE
D4 Ф LATIN CAPITAL LETTER O CIRCUMFLEX
D5 Х LATIN CAPITAL LETTER O TILDE
D6 Ц LATIN CAPITAL LETTER O DIAERESIS
D7 Ч MULTIPLICATION SIGN
D8 Ш LATIN CAPITAL LETTER 0 SLASH
D9 Щ LATIN CAPITAL LETTER U GRAVE
DA Ъ LATIN CAPITAL LETTER U ACUTE
DB Ы LATIN CAPITAL LETTER U CIRCUMFLEX
DC Ь LATIN CAPITAL LETTER U DIAERESIS
DD Э LATIN CAPITAL LETTER Y ACUTE
DE Ю LATIN CAPITAL LETTER THORN
DF Я LATIN SMALL LETTER SHARP S
E0 а LATIN SMALL LETTER A GRAVE
E1 б LATIN SMALL LETTER A ACUTE
E2 в LATIN SMALL LETTER A CIRCUMFLEX
E3 г LATIN SMALL LETTER A TILDE
E4 д LATIN SMALL LETTER A DIAERESIS
E5 е LATIN SMALL LETTER A RING
E6 ж LATIN SMALL LETTER A E
E7 з LATIN SMALL LETTER C CEDILLA
E8 и LATIN SMALL LETTER E GRAVE
E9 й LATIN SMALL LETTER E ACUTE
EA к LATIN SMALL LETTER E CIRCUMFLEX
EB л LATIN SMALL LETTER E DIAERESIS
EC м LATIN SMALL LETTER I GRAVE
ED н LATIN SMALL LETTER I ACUTE
EE о LATIN SMALL LETTER I CIRCUMFLEX
EF п LATIN SMALL LETTER I DIAERESIS
F0 р LATIN SMALL LETTER ETH
F1 с LATIN SMALL LETTER N TILDE
F2 т LATIN SMALL LETTER O GRAVE
F3 у LATIN SMALL LETTER O ACUTE
F4 ф LATIN SMALL LETTER O CIRCUMFLEX
F5 х LATIN SMALL LETTER O TILDE
F6 ц LATIN SMALL LETTER O DIAERESIS
F7 ч DIVISION SIGN
F8 ш LATIN SMALL LETTER O SLASH
F9 щ LATIN SMALL LETTER U GRAVE
FA ъ LATIN SMALL LETTER U ACUTE
FB ы LATIN SMALL LETTER U CIRCUMFLEX
FC ь LATIN SMALL LETTER U DIAERESIS
FD э LATIN SMALL LETTER Y ACUTE
FE ю LATIN SMALL LETTER THORN
FF я LATIN SMALL LETTER Y DIAERESIS
Управляющие коды, используемые в Блэкбоксе
Следующие управляющие коды используются в системе the BlackBox Component Framework:
00X nul завершающая литера для цепочек литер
01X unicode unicode mask character <маскирующая литера для юникода>
02X viewcode маскирующая литера для вьюшек [view mask character]
07X rdel удалить справа
08X del удалить слева
09X tab символ табуляции
0AX ltab символ обратной табуляции
0DX line возврат каретки (Unicode 2028, LINE SEPARATOR)
0EX para разделитель абзацев (Unicode 2029, PARAGRAPH SEPARATOR)
10X pL страница влево
11X pR страница вправо
12X pU страница вверх
13X pD страница вниз
14X dL документ влево
15X dR документ вправо
16X dU документ вверх
17X dD документ вниз
1BX esc escape key
1CX aL стрелка влево
1DX aR стрелка вправо
1EX aU стрелка вверх
1FX aD стрелка вниз
Из этих кодов только tab, line и para могут быть вставлены в текст, т.е. не рассматриваются как управляющие коды в Блэкбоксе. Код DEL (07FX) из набора ASCII не используется в Блэкбоксе и остается в резерве.
| Docu/ru/BB-Chars.odc |
Соглашения по документации
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-10-17; 2012-11-27
Документация преследует две главные цели: сообщить, как могут быть интерактивно использованы возможности программы (руководство пользователя) и как возможности программы могут быть использованы программно (руководство разработчика).
В системе Блэкбокс обслуживающие программы оформлены в подсистемы.
Обычно подсистема состоит из нескольких модулей, возможно, взаимодействующих.
В общем случае нужны три типа документации: руководство пользователя, описание интерфейса для каждого модуля, а также обзор того, как модули могут взаимодействовать друг с другом, т.е. введение в общую архитектуру подсистемы (руководство разработчика).
Подсистемы представлены на диске как каталоги, например, каталог Text.
В этом каталоге содержится вложенный каталог под названием Docu, т.е. Text/Docu.
Этот каталог с документацией может содержать следующие текстовые документы:
* Руководство пользователя, называемое User-Man.
* Карта гиперссылок на документацию, называемая Sys-Map.
* Вводная информация для программиста под названием Dev-Man.
* По одному описанию интерфейса на каждый модуль, под именем модуля без префикса подсистемы, например: Views для модуля TextViews.
Следует отметить, что все тексты документации, не являющимися непосредственными справочниками для программиста по конкретному модулю, должны содержать в имени дефис (-), чтобы обозреватель хранилища [repository browser] мог отличить документацию по модулям от прочих файлов документации.
Остальная часть данного текста описывает формат описания интерфейса модуля.
Каждое описание модуля начинается с определения модуля. Для описания модулей используется нотация Компонентного Паскаля, и в описании перечисляются все те и только те элементы модуля, которые экспортируются. Определение модуля начинается с ключевого слова DEFINITION вместо MODULE, метки экспорта опускаются (за исключением метки только для чтения); также опускаются тела процедур и тело модуля. Методы показываются в объявления соответствующей записи без ключевого слова PROCEDURE.
Примером служит гипотетический модуль Dictionaries
DEFINITION Dictionaries;
CONST maxElems = 32;
TYPE
Dictionary = POINTER TO LIMITED RECORD
elems-: INTEGER;
(d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER), NEW;
(d: Dictionary) Get (key: INTEGER; OUT string: ARRAY OF CHAR), NEW
END;
VAR someDict: Dictionary;
PROCEDURE Init;
END Dictionaries.
В расширенной записи не указаны унаследованные процедуры, только новые процедуры или процедуры с измененными сигнатурами или уточненными спецификациями семантики. Изменение сигнатуры может быть вызвано ковариантным результатом функции, т.е. если процедура возвращает указатель на расширение типа, возвращаемого базовой процедурой. Или это может быть вызвано изменением атрибутов метода (конечный, ABSTRACT, EMPTY, EXTENSIBLE), например, мог быть реализован и сделан конечным абстрактный метод.
За описанием модуля следует краткое описание абстракций, предоставляемых модулем.
Модуль предоставляет некий конкретный тип Dictionary для работы со словарями цепочек литер.
Затем следует список констант без их значений.
CONST maxElems
Максимальное число элементов словаря.
Затем следуют типы модуля:
TYPE Dictionary
LIMITED
Управляет словарем литерных цепочек с целочисленным ключом.
Атрибуты записи приводятся во второй строке, как показано выше. Атрибуты записи могут отсутствовать (запись является конечной по умолчанию) или быть EXTENSIBLE, ABSTRACT или LIMITED.
Если тип является расширением другого типа, то это показывается следующим образом:
Dictionary (OtherModule.Dictionary).
Затем перечисляются поля записи:
elems-: INTEGER 0 <= elems <= maxElems
Текущее количество элементов в словаре.
Как и в вышеприведенном примере, может также быть приведен инвариант для значений полей записи.
Затем приводятся процедуры, связанные с данным типом:
PROCEDURE (d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER)
NEW
Для каждого метода уточняется, является ли процедура конечной (final, по умолчанию), расширяемой (extensible), абстрактной (abstract) или пустой (empty).
Абстрактные процедуры не должны вызываться.
Пустые процедуры не должны вызываться в расширяющей их процедуре (т.е. посредством супервызова в реализации процедуры).
Во второй строке даются атрибуты метода, которые могут либо отсутствовать (метод является конечным по умолчанию), либо один из EXTENSIBLE, ABSTRACT или EMPTY. Для вновь вводимых методов перед этим атрибутом указывается NEW.
Методы, экспортируемые только для реализации (implement-only), могут быть вызваны только внутри своего определяющего модуля. Этот модуль может, таким образом, обеспечить предусловия для метода перед каждым его вызовом, поскольку все такие вызовы происходят в этом модуле. При корректной реализации эти предусловия никогда не могут нарушиться, так как другие модули не могут вызвать метод. Это позволяет проектировщику расширений предполагать, что предусловия выполнены, и проверять их нет необходимости. Поэтому предусловиям в методах, экспортированных только для реализации, не приписываются номера ошибок, вместо этого они помечаются как гарантированные, то есть описываемый модуль ручается за них.
Затем следует разъяснение действий процедуры:
Поместить цепочку в словарь d и получить в ответ key. Если цепочка уже есть в словаре, то возвращается тот же ключ, который был возвращен при первой вставке. Если строки еще нет в словаре, то она туда вставляется и возвращается еще не занятое значение ключа.
После разъяснений простым текстом могут быть указаны некоторые предусловия для процедуры. Эти предусловия приводятся в полуформальной нотации:
Pre
20 string # ''
Это означает, что если предусловие нарушается (т.е. string = ''), то выполняемая в данный момент команда прерывается с номером исключения 20. Вместо номера могут также быть указаны следующие сообщения:
invalid index
type guard check
Поэтому второе предусловие могло бы быть таким:
invalid index string in d or d.elems < maxElems
В более старых частях документации номера предусловий могут быть даны после выражения, а не перед ним. Со временем вся документация должна быть приведена к одному новому, более удобочитаемому стилю.
После предусловий могут быть указаны некоторые постусловия:
Post
string in d'
old key returned
~(string in d')
string in d
d.elems = d.elems' + 1
new key returned
Это постусловие содержит два случая, а именно, что происходит, когда цепочка уже содержится в d, и что присходит, если цепочки в d еще нет. Текст условий выровнен по левому краю, а соответствующие результаты сдвинуты вправо на один отступ. Иногда могут быть использованы вложенные условия с дальнейшим отступом.
Для ссылки на значения перед выполнением процедуры к выражению добавляется апостроф, если это нужно для ясности (т.е. если значение вообще может измениться). Так, выражение
d.elems = d.elems' + 1
означает, что значение d.elems увеличилось на единицу.
В общем, для подобных выражений используется синтаксис Компонентного Паскаля, но допускаются послабления, например, могут использоваться простые вспомогательные процедуры, в дальнейшем не описываемые.
Результаты функций в общем случае называются result.
Объем формализма остается небольшим. Делается попытка ограничить формальные спецификации несколькими простыми условиями или объяснением особо тонких случаев. Не ставится цель дать полное формальное определение семантики библиотеки, поэтому формализм не может полностью заменить разъяснения, сделанные обычным текстом, примеры или графические иллюстрации.
Тем не менее, представляется, что проверки прежде всего предусловий часто оказываются полезными даже в таком неполном и полуформальном виде, как для целей документирования, так и для отладки.
PROCEDURE (d: Dictionsry) Get (key: INTEGER; OUT string: ARRAY OF CHAR)
NEW
Извлекает литерную цепочку из словаря по ключу key. Если значение не найдено параметру string присваивается пустое значение.
Post
key in d
return corresponding string
~(key in d)
return ""
Процедуры, унаследованные при расширении типа, обычно здесь не приводятся. Исключение составляют процедуры, изменившие свою семантику. Изменения семантики ограничены ослаблением предусловий или усилением постусловий.
После всех типов перечисляются глобальные переменные:
VAR someDict: Dictionary someDict # NIL
Эта переменная содержит словарь.
Указанный необязательный инвариант устанавливается в теле модуля.
Наконец, перечисляются процедуры, экспортируемые модулем:
PROCEDURE Init (d: Dictionary)
Инициализирует словарь. Любой словарь может быть размещен только один раз
Pre
20 d not yet inicialized
В Блэкбоксе все процедуры, чьи имена начинаются с Init, могут быть вызваны для объекта только один раз. | Docu/ru/BB-Docu.odc |
Лицензия для распространения с открытыми исходниками системы Блэкбокс
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2010-09-16
Данный перевод служит исключительно информационным целям и для юридических целей не может заменить оригинальный текст.
Ниже следует лицензия, применимая к данной копии программных компонент системы Блэкбокс (the BlackBox Component Builder) и сопроводительной документации (в совокупности называемых далее ПО). Для получения лицензии на использование ПО на иных условиях, чем те, которые изложены здесь, или для покупки технической поддержки данного ПО, пожалуйста, свяжитесь с компанией Oberon Microsystems, Inc., по следующему адресу:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
Copyright (c) 1994 - 2005 Oberon microsystems, Inc., Switzerland. All rights reserved.
Дальнейшее распространение и использование ПО в исходниках или двоичной форме, с изменениями или без таковых, разрешены при соблюдении следующих условий:
1. Распространяемые копии исходников должны содержать сообщение об авторских правах, приведенное выше, данный список условий и следующий далее отказ от ответственности.
2. Распространяемые копии ПО в двоичном виде должны воспроизводить в документации или других материалах, сопровождающих ПО, приведенное выше сообщение об авторских правах, данный список условий и следующий далее отказ от ответственности.
3. Дальнейшее распространение в любой форме должно сопровождаться информацией о том, как можно получить полный комплект исходников ПО и любого сопровождающего ПО, использующего данное ПО. Исходники должны быть либо включены в распространяемую копию, либо быть доступны по цене, не превышающей стоимости распространения плюс номинального гонорара, и должны быть свободно распространяемыми на разумных условиях. Для исполняемого файла исходный код подразумевает исходники всех включенных модулей. Сюда не включаются исходники модулей или файлов, которые обычно сопровождают основные компоненты операционной системы, под управлением которой запускается исполняемый файл.
4. Ни имя компании Oberon Microsystems, Inc. , ни имена авторов дополнений и изменений к данному ПО, не могут быть использованы для продвижения ПО, производного от данного ПО, без специального предварительного письменного разрешения.
ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ КОМПАНИЕЙ OBERON MICROSYSTEMS, INC. КАК ЕСТЬ, И ЛЮБЫЕ ЯВНЫЕ ИЛИ ПОДРАЗУМЕВАЕМЫЕ ГАРАНТИИ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ПОДРАЗУМЕВАЕМЫМИ ГАРАНТИЯМИ КОММЕРЧЕСКОЙ ПОЛЕЗНОСТИ, ПРИГОДНОСТИ ДЛЯ КОНКРЕТНЫХ ЦЕЛЕЙ ИЛИ ОТСУТСВИЯ НАРУШЕНИЙ ПРАВ, ОТРИЦАЮТСЯ. КОМПАНИЯ OBERON MICROSYSTEMS, INC. НИ В КАКИХ ОБСТОЯТЕЛЬСТВАХ НЕ БУДЕТ НЕСТИ ОТВЕТСТВЕННОСТЬ НИ ЗА КАКИЕ ПРЯМЫЕ, КОСВЕННЫЕ, СЛУЧАЙНЫЕ, ЧАСТНЫЕ, ПРИМЕРНЫЕ ИЛИ ПОНЕСЕННЫЕ В КАЧЕСТВЕ ПОСЛЕДСТВИЙ ПОТЕРИ (ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ПОСТАВКАМИ ТОВАРОВ ИЛИ УСЛУГ НА ЗАМЕНУ; ПОТЕРЯМИ В ПОЛЬЗОВАНИИ, ДАННЫХ ИЛИ ПРИБЫЛЕЙ; ИЛИ ПЕРЕРЫВАМИ В ДЕЛОВОЙ ДЕЯТЕЛЬНОСТИ), КАК БЫ ОНИ НИ БЫЛИ ПРИЧИНЕНЫ, И КАКИМИ БЫ АРГУМЕНТАМИ ОНИ НИ ОБОСНОВЫВАЛИСЬ КОНТРАКТОМ, ПРИНЦИПОМ STRICT LIABILITY ИЛИ ВРЕДЯЩИМ ДЕЙСТВИЕМ (В ТОМ ЧИСЛЕ ХАЛАТНОСТЬЮ ИЛИ КАК-ТО ИНАЧЕ), ЯВИВШИЕСЯ ЛЮБОГО РОДА СЛЕДСТВИЕМ ИСПОЛЬЗОВАНИЯ ДАННОГО ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ, ДАЖЕ ЕСЛИ ОНА БЫЛА ПРЕДУПРЕЖДЕНА О ВОЗМОЖНОСТИ ТАКИХ ПОТЕРЬ.
| Docu/ru/BB-License.odc |
Политика лицензирования системы Блэкбокс
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2010-09-16
Данный перевод служит исключительно информационным целям и для юридических целей не может заменить оригинальный текст.
Начиная с версии 1.5, BlackBox Component Builder (Блэкбокс) является продуктом, распространяемым с открытыми исходниками (open source product). Полный исходный код, документация и файлы, необходимые для сборки продукта, доступны для скачивания на нашем интернет-сайте www.oberon.ch.
Наша лицензия на ПО в открытых кодах близко следует лицензии Sleepycat Software's Berkeley DB Open Source License ("The Sleepycat License", www.sleepycat.com).
Лицензия на ПО с открытыми исходниками разрешает вам использовать Блэкбокс бесплатно при условии, что если вы используете данное ПО в распространяемых вами приложениях, полный исходный код вашего приложения должен быть доступен для распространения на разумных условиях. Если вы не хотите предоставлять исходный код своего приложения, вы можете приобрести специальную лицензию у компании Oberon Microsystems, Inc. Чтобы получить информацию о ценах или ответы на дальнейшие вопросы по лицензированию, или если у вас есть замечания по лицензированию, то вы можете связаться с нами по следующему адресу:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
TheBlackBoxComponentBuilderOpenSourceLicense
Что означает распространение?
Термин распространение в лицензии BlackBox Open Source License означает, что ваше приложение передается одной или более третьей стороне. Передача приложения клиентам, даже в альфа или бета-версиях, является распространением. Передача копии приложения заказчикам, аффилированным фирмам и лицам, материнским и дочерним фирмам, деловым партнерам, а также лицам и компаниям, предоставляющим поддержку по контракту, также является распространением.
Следующие действия НЕ являются распространением:
Построение приложения для внутреннего или внешнего использования вашей организацией, развернутого и управляемого на клиентских или серверных машинах вашей организации.
Построение web-сервисов на основе BlackBox и предоставление к ним доступа.
Резервное копирование и другие операции по архивации ПО.
Не имеет значения, берете ли вы деньги за ваше приложение или нет. Единственным критерием является его распространение.
Что означает использование ПО?
Мы говорим, что программа А использует программу Б, если Б должна быть предођставлена и удовлетворять своим спецификациям для того, что своим спецификациям удовлетворяла А. Другими словами, Б должно быть предоставлено и корректно работать для корректной работы А. Такое определение восходит к David Lorge Parnas.
Что вы должны включить в открытые исходные коды?
В соответствии с лицензией BlackBox Open Source License вы должны предоставить полные исходники для приложения, использующего Блэкбокс. Вы не обязаны предоставлять исходный код для компонентов, которые входят в операционную систему, на которой выполняется ваше приложение, например, системные заголовочные файлы или библиотеки.
Какую лицензию для открытых исходников вам следует использовать?
Лицензии, признаваемые организацией opensource.org, удовлетворяют условию компании Oberon Microsystems, Inc. свободно распространяемые на разумных условиях.
Разумеется, распространение приложения, использующего Блэкбокс, с лицензией для открытых исходников не меняет требований лицензии BlackBox Open Source License, и исходники Блэкбокса должны перераспространяться только на ее условиях. Лицензия для открытых исходников Sleepycat, на которой базируется лицензия BlackBox Open Source License, совместима с GPL, так что ПО с лицензией GPL может использовать Блэкбокс без нарушения условий любой из этих двух лицензий.
Кто является владельцем системы BlackBox Component Builder?
Все исходники (в настоящем и в будущем), которые включены в Блэкбокс, являются интеллектуальной собственностью компании Oberon Microsystems, Inc. Изменения исходников (в том числе исправление ошибок) будут приняты, только если они предоставляђются в собственность компании Oberon Microsystems, Inc. Изменения, выполненные третьей стороной, должны быть отмечены комментариями в исходниках. Если бы мы разрешили изменения, которыми мы не владеем, мы не имели бы прав на предоставление специальных лицензий нашим коммерческим пользователям.
Что, если какие-либо разработчики хотят помочь, но не желают отдать исходный код в собсвенность компании Oberon Microsystems, Inc.?
Они могут разрабатывать такой код, и распространять свою собственную версию Блэкбокса до тех пор, пока выполняют условия лицензии BlackBox Open Source License. Компания Oberon Microsystems, Inc. не может включить такие изменения в свой дистрибутив Блэкбокса. Если вы хотите, чтобы ваши коды стали частью дистрибутива, предоставляемого компанией Oberon Microsystems, Inc., вам следует передать права собственности на исходные коды компании Oberon Microsystems, Inc. Нет никаких гарантий, что компания Oberon Microsystems, Inc. включит в свой дистрибутив Блэкбокса изменения и дополнения, сделанные на стороне в инициативном порядке.
| Docu/ru/BB-Licensing-Policy.odc |
Лицензия для распространения с открытыми исходниками системы Блэкбокс
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-03-20
Данный перевод служит исключительно информационным целям и для юридических целей не может заменить оригинальный текст.
Ниже следует лицензия, применимая к данной копии программных компонент системы Блэкбокс (the BlackBox Component Builder) и сопроводительной документации (в совокупности называемых далее ПО). Для получения лицензии на использование ПО на иных условиях, чем те, которые изложены здесь, или для покупки технической поддержки данного ПО, пожалуйста, свяжитесь с компанией Oberon Microsystems, Inc., по следующему адресу:
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zьrich
Switzerland
Net: [email protected]
Tel: +41 (0) 44 445 17 51
Fax: +41 (0) 44 445 17 52
Copyright (c) 1994 - 2005 Oberon microsystems, Inc., Switzerland. All rights reserved.
Дальнейшее распространение и использование ПО в исходниках или двоичной форме, с изменениями или без таковых, разрешены при соблюдении следующих условий:
1. Распространяемые копии исходников должны содержать сообщение об авторских правах, приведенное выше, данный список условий и следующий далее отказ от ответственности.
2. Распространяемые копии ПО в двоичном виде должны воспроизводить в документации или других материалах, сопровождающих ПО, приведенное выше сообщение об авторских правах, данный список условий и следующий далее отказ от ответственности.
3. Дальнейшее распространение в любой форме должно сопровождаться информацией о том, как можно получить полный комплект исходников ПО и любого сопровождающего ПО, использующего данное ПО. Исходники должны быть либо включены в распространяемую копию, либо быть доступны по цене, не превышающей стоимости распространения плюс номинального гонорара, и должны быть свободно распространяемыми на разумных условиях. Для исполняемого файла исходный код подразумевает исходники всех включенных модулей. Сюда не включаются исходники модулей или файлов, которые обычно сопровождают основные компоненты операционной системы, под управлением которой запускается исполняемый файл.
4. Ни имя компании Oberon Microsystems, Inc. , ни имена авторов дополнений и изменений к данному ПО, не могут быть использованы для продвижения ПО, производного от данного ПО, без специального предварительного письменного разрешения.
ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ КОМПАНИЕЙ OBERON MICROSYSTEMS, INC. КАК ЕСТЬ, И ЛЮБЫЕ ЯВНЫЕ ИЛИ ПОДРАЗУМЕВАЕМЫЕ ГАРАНТИИ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ПОДРАЗУМЕВАЕМЫМИ ГАРАНТИЯМИ КОММЕРЧЕСКОЙ ПОЛЕЗНОСТИ, ПРИГОДНОСТИ ДЛЯ КОНКРЕТНЫХ ЦЕЛЕЙ ИЛИ ОТСУТСВИЯ НАРУШЕНИЙ ПРАВ, ОТРИЦАЮТСЯ. КОМПАНИЯ OBERON MICROSYSTEMS, INC. НИ В КАКИХ ОБСТОЯТЕЛЬСТВАХ НЕ БУДЕТ НЕСТИ ОТВЕТСТВЕННОСТЬ НИ ЗА КАКИЕ ПРЯМЫЕ, КОСВЕННЫЕ, СЛУЧАЙНЫЕ, ЧАСТНЫЕ, ПРИМЕРНЫЕ ИЛИ ПОНЕСЕННЫЕ В КАЧЕСТВЕ ПОСЛЕДСТВИЙ ПОТЕРИ (ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ПОСТАВКАМИ ТОВАРОВ ИЛИ УСЛУГ НА ЗАМЕНУ; ПОТЕРЯМИ В ПОЛЬЗОВАНИИ, ДАННЫХ ИЛИ ПРИБЫЛЕЙ; ИЛИ ПЕРЕРЫВАМИ В ДЕЛОВОЙ ДЕЯТЕЛЬНОСТИ), КАК БЫ ОНИ НИ БЫЛИ ПРИЧИНЕНЫ, И КАКИМИ БЫ АРГУМЕНТАМИ ОНИ НИ ОБОСНОВЫВАЛИСЬ КОНТРАКТОМ, ПРИНЦИПОМ STRICT LIABILITY ИЛИ ВРЕДЯЩИМ ДЕЙСТВИЕМ (В ТОМ ЧИСЛЕ ХАЛАТНОСТЬЮ ИЛИ КАК-ТО ИНАЧЕ), ЯВИВШИЕСЯ ЛЮБОГО РОДА СЛЕДСТВИЕМ ИСПОЛЬЗОВАНИЯ ДАННОГО ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ, ДАЖЕ ЕСЛИ ОНА БЫЛА ПРЕДУПРЕЖДЕНА О ВОЗМОЖНОСТИ ТАКИХ ПОТЕРЬ.
| Docu/ru/BB-Open-Source-License.odc |
Путеводитель
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-03-20
Содержание
Двавидакомпонентов
Команды
Объектыизображения(вьюшки,views)
Обзор
Оглавление
Два вида компонентов
Блэкбокс включает в себя компонентную среду или каркас (framework), которая окажется новой концепцией для большинства программистов. Настоящий документ представляет собой краткий обзор разновидностей компонентов, которые есть в Блэкбоксе, случаев, когда нужен каждый из них, и того, где следует искать необходимую документацию.
В Блэкбоксе выделяются две основные категории компонентов: команды (command) и т.наз. объекты изображения или вьюшки (view; см. опереводетерминов). Команды сопоставимы с традиционными скриптами и макросами, за исключением того, что они реализованы в настоящем языке программирования, в противовес ограниченным либо неэффективным специализированным скриптовым языкам. Это означает, что если задача усложнится, ее программное решение может быть усложнено в нужной степени, и вам не придется внезапно переключаться на другой язык. Таким образом, диапазон применимости команд охватывает как простые задачи автоматизации, так и такие сложные задачи, такие как компиляция. Основное назначение команд организация совместной работы объектов изображения (вьюшек), которые являются визуальными объектами системы Блэкбокс.
Команды
Программы часто строятся вокруг форм ввода данных; это и есть формы (form) в Блэкбоксе. Модуль Controls и подсистема Forms предоставляют необходимую поддержку для построения пользовательских интерфейсов, основанных на формах.
Часто нужно создавать и тексты, например, при генерации отчетов. Для этого можно использовать все возможности текстовой подсистемы Блэкбокса, включая выбор шрифтов, размера печати, цвета, а также вставлять в текст другие компоненты-вьюшки, например, метки (stamp views) или ссылки (link views), и так далее. Примером команды, которая совместно использует подсистемы для работы с формами и текстами, является ObxOrders.
Прежде чем изучать этот сложный пример, полезно взглянуть на более простые программы работы с тесктами и формами. Подсистема Obx (Overview by example обзор с помощью примеров) содержит разнообразные примеры такого рода.
Программы в Блэкбоксе обычно работают с документами и их частями, а не напрямую с файлами и окнами. Файлы используются лишь для простых баз данных или для работы с унаследованными данными (legacy data). В ряде случаев можно преобразовать такие данные в типы данных системы Блэкбокс, если написать новые конвертеры. Соответствующий пример есть в подсистеме Obx.
Объекты изображения (вьюшки, views)
Если средств встроенных подсистем оказывается недостаточно, то возникает необходимость разработать новый компонент Блэкбокса. Обычно речь идет о новом компоненте для составных документов, т.е. о реализации новой разновидности объектов изображения (вьюшек). В противоположность программам в старом стиле, вьюшка владеет лишь частью документа, а не целым экраном и даже не целым окном. Если вьюшка является самой внешней, корневой (root view), то эффект неотличим от традиционного приложения. Однако вьюшку всегда можно еще и внедрить в тексты, формы и т.д.
Примерами объектов изображения (вьюшек) являются текстовые вьюшки (text views), вьюшки-формы (form views), гипертекстовые вьюшки-ссылки (link views); вьюшки-метки (stamp views); часы; логотип компании Oberon Microsystems, картинки, коммандеры (кнопки, которые вызывают команду на исполнение), вьюшки для оформления складок в тексте (fold views), сообщения об ошибках, выдаваемые компилятором, элементы управления (кнопки, флажки, поля ввода) и т.д. Перед тем как приступать к реализации вашей собственной разновидности вьюшек, посмотрите уже существующие, чтобы получить представление о о всем многообразии способов использования вьюшек. Иногда не нужно реализовывать совсем новую сложную подсистему для решения задачи, а достаточно создать дополнительную вьюшку, которая расширит функциональность, например, текстовой подсистемы.
Вьюшки могут иметь либо, наоборот, не иметь модель (model). Модель это структура данных, которую вьюшка (объект изображения) представляет в визуальной форме. Впростейших случаях, когда вьюшки не имеют редактируемого сохраняемого состояния, в модели нет необходимости. Примерами могут быть логотипы, элементы управления и т.д. Сдругой стороны, полноценные редакторы должны работать с отдельной моделью. Такие более сложные вьюшки обычно реализуются в нескольких модулях, тогда как простые обычно реализуются в единственном модуле.
Сложные объекты изображения могут содержать другие вьюшки. Такие составные вьюшки называются контейнерами (containers). Существуют три полезных категории контейнеров:
Обертка (wrapper) содержит другое изображение и изменяет либо расширяет его поведение. Обычно обертка имеет один размер с оборачиваемым изображением. Например, вьюшка, реализующая терминал, может быть оберткой для обыкновенной текстовой вьюшки, добавляя коммуникационные средства, в то время как текстовая вьюшка обеспечивает изображение передаваемой информации.
Специальный контейнер (special container) содержит одну или несколько внедренных вьюшек. Контейнер знает типы внедренных вьюшек и их расположение. При этом вьюшки не могут быть добавлены или удалены. Например, такой специальный контейнер может содержать вверху изображение запроса, куда можно вводить запросы к базе данных, и большую текстовую вьюшку внизу, где изображаются результаты запроса. Другой пример приводится в ObxTwins.
Общий контейнер (general container) может содержать произвольное количество внедренных вьюшек, и они могут изменяться со временем. Это наиболее общая и сложная разновидность объектов изображения, подобная встроенным подсистемам для работы с текстами и формами. Примеры для других разновидностей вьюшек есть в Obx.
Вьюшки могут не иметь программного интерфейса, иметь простой процедурный интерфейс (обычно основанный на использовании т.наз. свойств (properties), см. Controls) или полноценный расширяемый интерфейс. В последнем случае рекомендуется отделять экспортируемый интерфейс от скрытой реализации, предоставляемой по умолчанию, чтобы достичь максимальной расширяемости.
Обзор
Как начать знакомиться с системой Блэкбокс? Мы советуем начать с вводных текстов КраткаяисторияПаскаля и Краткийобзор.
Документация делится на четыре большие части:
Руководствопользователя описывает интерфейс пользователя и наиболее важные команды Блэкбокса.
Учебник объясняет основные шаблоны проектирования Блэкбокс (главы с 1-й по 3-ю). В главе4 обсуждается графический интерфейс пользователя, формы и управляющие элементы. Текстовая подсистема описывается в главе5. Последняя глава6 знакомит с программированием объектов изображения (вьюшек, views).
Примеры богатый набор примеров с исходными текстами, упорядоченных по категориям и сложности.
Руководство программиста содержит по одному файлу документации на каждый программный модуль. В каждой подсистеме имеется документ с названием Sys-Map, содержащий ссылки на тексты для отдельных модулей.
Отдельно от примеров Obx и обучающих примеров есть и другая документация для наиболее важных типов программ Блэкбокс, она доступна в Dev/Rsrc/New. Там находятся шаблоны документов, которые можно использовать для новых программ. Имена модулей шаблонных документов будут изменены автоматически командой меню Инструменты->Создать подсистему... (Tools->Create Subsystem...). Эта команда также создает структуру каталогов для новой подсистемы (см. DevSubTool).
Программисты, которым необходим интерфейс к программам за пределами Блэкбокса, могут ознакомиться с текстом Особенности,зависящиеотплатформы.
Полезно обратиться к сопроводительной документации через меню помощи или из оглавления ниже.
Оглавление
Быстрое знакомство
Краткийобзор
Примеры
ЏЏЏВходдляПрофи
Учебник
1Взаимодействиеспользователем Для удобства печати:
2Составныедокументы полную версию учебника можно
3ПриёмыпроектированиявБлэкбоксе распечатать из этого документа
4Формы
5 Тексты
6Построениеобъектовизображения(вьюшек)
A:КраткаяисторияПаскаля
B:ОтПаскалякКомпонентномуПаскалю
Руководства пользователя
Среда
ПодсистемаText
ПодсистемаForm
ПодсистемаDev
ПодсистемаStd--стандартныекоманды
Руководства разработчика
ЯдросистемыБлэкбокс
ПодсистемаText
ПодсистемаForm
ПодсистемаDev
ПодсистемаSql
Компонентный Паскаль
Сообщениеоязыке
ЧтоновоговКомпонентномПаскале
Наборлитер
Соглашенияподокументации
Соглашенияпооформлениюкода
Разное
Лицензия
Лицензионнаяполитика
Разработчики
Особенности,зависящиеотплатформы | Docu/ru/BB-Road.odc |
Cоглашения по оформлению программ
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-03-20
Содержание
1.СамоеЏважное
2.Оберон
3.ЏЭлементарныеЏтипы
4.Шрифтовыеатрибуты
5.ЏКомментарии
6.ТочкиЏсЏзапятыми
7.Разыменование
8.Регистр
9.Имена
10.Пробелы
11.Пример
12.ЗаголовокОткрытогоисходногоЏкода
Этот текст описывает соглашения относительно правил программирования и форматирования исходного кода, которые использовались при создании системы Блэкбокс (BlackBox Component Framework). По документации существуют аналогичные соглашения.
Некоторые правила программирования важнее остальных. В первом разделе описаны самые важные правила. Остальные разделы содержат правила косметического характера, описывающие, как выглядят программы, опубликованных компанией Oberon microsystems. Если эти правила вам нравятся, смело пользуйтесь ими. Они могут сделать ваши программы более легкими для понимания теми, кто будет использовать их для проектирования, документирования и кодирования в BlackBox.
1. Самое важное
Наиболее важные соглашения по программированию нацелены на то, чтобы обеспечить развиваемость (evolvability) программ. Это означает, что нужно максимально облегчить внесение надежных изменений в существующие программы, даже если программы были написаны давно или кем-то другим. Развиваемость часто может быть повышена путем увеличения степени локализованности частей программы: если можно четко ограничить тот отрезок программного текста, на который могут повлиять изменения в исправляемой части программы, то легче определить всю цепочку необходимых дальнейших изменений. Всущности, речь здесь о том, чтобы удержать под контролем всю цепную реакцию изменений.
Предусловия (preconditions) один из наиболее полезных инструментов для обнаружения непредусмотренных последствий цепной реакции изменений. Проверки предусловий позволяют отловить семантические ошибки на максимально ранней стадии, то есть максимально близко к их источникам. Хорошо расставленные проверки (операторы ASSERT) могут радикально сократить время отладки после больших изменений в проекте.
Везде, где можно, используйте статические средства, чтобы выразить все, что вам известно о структуре программы. В частности, используйте для этой цели систему типов и модули Компонентного Паскаля, чтобы компилятор смог помочь вам выявить несоответствия и, тем самым, стать эффективным инструментом реструктуризации.
Выполняйте проверки предусловий. Не позволяйте вызывающей программе входить в ваш модуль, если не выполнены предусловия входных точек вашего модуля (процедур, методов). Таким образом вы избежите распространения чужих ошибок в вашем собственном коде.
Используйте следующие номера в соответствии с принятыми в Блэкбоксе правилами:
Свободные 0 .. Џ19 использовать для временных точек останова
Предусловия 20 .. Џ59 допустимость параметров на входе процедуры
Постусловия 60 .. Џ99 допустимость результатов в конце процедуры
Инварианты 100 .. 120 допустимость промежуточных состояний
(выявление локальных ошибок)
Резерв 121 .. 125 зарезервировано на будущее
Еще не реализовано 126 процедура еще не реализована
Резерв 127 зарезервировано на будущее
Должно быть как можно меньше глобальных переменных.
Значения глобальных переменных могут изменяться из любого места программы, в любое время. Это затрудняет отслеживание всех возможных взаимодействий (т.наз. побочных эффектов) с такими переменными. Тем самым увеличивается вероятность внесения ошибок при изменении их использования.
Процедуры-функции, т.е. процедуры, возвращающие результат, не должны менять глобальные переменные или VAR параметры в качесте побочного эффекта. Легче иметь дело с такими функциями, которые являются истинными функциями в математическом смысле, т.е. не имеют побочных эффектов. Но допустимо вместе с возвращением результата функции присваивать значений OUT параметрам.
Используйте ELSE в CASE или WITH, только если входные данные допускают расширение.
Ветку ELSE в операторе CASE x OF или WITH x DO следует использовать, только если х действительно является расширяемым. Если х не расширяемо, то все возможные варианты должны быть известны статически и могут быть перечислены в списке альтернатив.
2. Оберон
Не используйте в новых программах специальные функции языка Оберон, которые не являются частью Компонентного Паскаля. В частности, это тип LONGREAL и процедура COPY. Старайтесь избегать супервызовов (используйте композицию вместо наследования) и процедурных типов (используйте вместо них объекты и методы).
3. Элементарные типы
По умолчанию используйте типы INTEGER, REAL и CHAR. Типы BYTE, SHORTINT, LONGINT, SHORTREAL и SHORTCHAR следует использовать только тогда, когда для этого есть веские причины. Эти вспомогательные типы введены для обеспечения взаимодействия с другими программами, для упаковки очень больших структур или для вычисления очень больших целых чисел. Это правило, конечно, важнее для экспортируемых интерфейсов, чем для скрытых реализаций.
4. Шрифтовые атрибуты
Программы пишутся как плоский текст, цветом, заданным по умолчанию, со следующими исключениями:
Комментарии пишутся курсивом: (* это комментарий *)
Экспортированные элементы, за исключением полей записи и сигнатур методов в объявлениях записей, пишутся жирным шрифтом: PROCEDURE Do*;
Ключевые слова, соответствующие нелокальной передаче управления, пишутся жирным шрифтом, например, RETURN, EXIT и HALT
Текстовые фрагменты, которые тестируются и подвержены изменениям, временно могут быть записаны другим цветом
5. Комментарии
Комментарии, которые являются частью описания интерфейса (в отличие от простого описания реализации), оформляются дополнительными звездочкам, своего рода метками экспорта для комментариев, например, (** охрана для команды xyz **)
6. Точки с запятой
Точки с запятой используются для разделения операторов, а не для их завершения. Это означает, что не должно быть избыточных точек с запятой.
Хорошо
IF done THEN
Print(result)
END
Плохо
IF done THEN
Print(result);
END
7. Разыменование
Оператор разыменования ^ следует убирать отовсюду, где это возможно.
Хорошо
h.next := p.prev.next
Плохо
h^.next := p^.prev^.next
8. Регистр
Вообще говоря, каждый идентификатор начинается с маленькой буквы, за исключением следующих случаев:
Имя модуля всегда начинается с большой буквы
Имя типа всегда начинается с большой буквы
Имя процедуры всегда начинается с большой буквы, это верно также для процедурных констант, типов, переменных, параметров и полей записи.
Хорошо
null = 0X;
DrawDot = PROCEDURE (x, y: INTEGER);
PROCEDURE Proc (i, j: INTEGER; Draw: DrawDot);
Плохо
NULL = 0X;
PROCEDURE isEmpty (q: Queue): BOOLEAN;
R = RECORD
draw: DrawDot
END;
Не используйте идентификаторы (кроме однобуквенных), состоящих только из заглавных букв. Их следует зарезервировать для языка.
9. Имена
Для имен обычных процедур берутся глаголы, например, РисоватьТочку (DrawDot)
Для имен процедур-функций используются существительные или предикаты, например, NewObject(), IsEmpty(q)
Тип запись объявляйте только при необходимости (FooDesc for each Foo are normally not needed anymore)
Процедуры с именами на Init обладают тем свойством, что при повторном вызове они либо ничего не делают, либо приводят к аварийной остановке. Напротив, процедуры для многократной (пере)установки состояния начинаются префиксом Set.
Примеры
PROCEDURE InitDir (dir: Directory);
PROCEDURE (p: Port) Init (unit, colors: LONGINT);
Процедуры-охранники имеют те же имена, что и охраняемые команды, но с суффиксом Guard.
Пример
PROCEDURE PasteChar;
PROCEDURE PasteCharGuard (VAR par: Dialog.Par);
10. Пробелы
Новый уровень отступа создается добавлением еще одного символа табуляции
Между элементами списков <объявлений>, между фактическими параметрами и между операторами вставляется один пробел.
Хорошо
VAR a, b, c: INTEGER;
DrawRect(l, t, r, b);
a := i * 8 + j - m[i, j];
Плохо
VAR a,b,c: INTEGER;
DrawRect(l,t,r,b);
a:=b;
a := i*8 + j - m[i,j];
Ставится один пробел между именем процедуры (или ее меткой экспорта) и списком параметров в описании, но не в вызове
Хорошо
PROCEDURE DrawDot* (x, y: INTEGER);
DrawDot(3, 5);
Плохо
PROCEDURE DrawDot*(x, y: INTEGER);
DrawDot (3, 5);
Открывающие и закрывающие ключевые слова стоят на одном уровне отступа либо записаны в одной строке
Секции IMPORT, CONST, TYPE, VAR, PROCEDURE имеют стоят на один отступ глубже по сравнению с уровнем окружения.
Цикл LOOP никогда не пишется в одной строке
PROCEDURE X и END X всегда выровнены
Если вся конструкция не помещается в одной строке, за ключевым словом не ставится описание типа или оператор
Содержимое операторов IF, WHILE, REPEAT, LOOP, FOR, CASE стоит на один отступ глубже, если оно не помещается в одной строке.
Хорошо
IF expr THEN S0 ELSE S1 END;
REPEAT S0 UNTIL expr;
WHILE expr DO S0 END;
IF expr THEN
S0
ELSE
S1
END;
REPEAT
S0
UNTIL expr;
LOOP
S0;
IF expr THEN EXIT END;
S1
END;
i := 0; WHILE i # 15 DO DrawDot(a, i); INC(i) END;
TYPE View = POINTER TO RECORD (Views.ViewDesc) END;
IMPORT Views, Containers,
TextModels, TextViews;
VAR a, b: INTEGER;
s: TextMappers.Scanner;
Плохо
IF expr THEN S0
ELSE S1 END;
PROCEDURE P;
BEGIN ... END P;
BEGIN i := 0;
j := a + 2;
...
REPEAT i := 0;
j := a + 2;
...
11. Пример
MODULE StdExample;
IMPORT Models, Views, Controllers;
CONST null = 0X;
TYPE
View* = POINTER TO RECORD (Views.View)
a*, b*: INTEGER
END;
VAR view-: View;
PROCEDURE Calculate* (x, y: INTEGER);
VAR area: LONGINT;
PROCEDURE IsOdd (x: INTEGER): BOOLEAN;
BEGIN
RETURN ODD(x)
END IsOdd;
BEGIN
area := x * y;
IF IsOdd(area) THEN area := 1000 END
END Calculate;
BEGIN
Calculate(7, 9)
END StdExample.
12. Заголовок Открытого исходного кода
Модули, опубликованные под лицензией BlackBoxComponentBuilderOpenSourceLicense, включают текстовый заголовок, оформленный по следующем образцу:
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
| Docu/ru/BB-Rules.odc |
Сообщение о языке Компонентный Паскаль
ENGLISH
Copyright 1994-2001 by Oberon microsystems, Inc., Switzerland.
All rights reserved. No part of this publication may be reproduced in any form or by any means, without prior written permission by Oberon microsystems. The only exception is the free electronic distribution of the education version of BlackBox (see the accompanying copyrightnotice for details).
Oberon microsystems, Inc.
Technoparkstrasse 1
CH-8005 Zuerich
Switzerland
Oberon is a trademark of Prof. Niklaus Wirth.
Component Pascal is a trademark of Oberon microsystems, Inc.
All other trademarks and registered trademarks belong to their respective owners.
Authors
Oberon microsystems, Inc.
March 2001
Authors of Oberon-2 report
H. Moessenboeck, N. Wirth
Institut fuer Computersysteme, ETH Zuerich
October 1993
Author of Oberon report
N. Wirth
Institut fuer Computersysteme, ETH Zuerich
1987
Перевод на русский язык: Ф.В.Ткачев, Институт ядерных исследований РАН, Москва, 2001-2003, 2009; исправление опечаток: 2010; замечания о типе SET: 2011.
Перевод был первоначально выполнен для спецкурса Современное программирование. Введение в объектные и компонентные технологии, читаемого переводчиком на физическом факультете МГУ с 2001 г.
Перевод сверен с документацией BlackBox v.1.5.
Терминология перевода ориентируется на существующие переводы книг Н.Вирта на русский язык (переводчики: Д.Б.Подшивалов, В.А.Серебряков и В.М.Ходукин, В.М.Курочкин, а также новый перевод книги Алгоритмы и структуры данных. Новая версия для Оберона (ДМК Пресс, 2010), заново выполненный переводчиком). В некоторых случаях в квадратных скобках даны английские выражения оригинала, а в угловых вставки и замечания переводчика. Обсуждение терминологии можно найти в документе Docu/ru/RuComments.
С.З.Свердлов ранее и независимо выполнил перевод на русский язык описания языка Оберон-2, предшественника Компонентного Паскаля (перевод С.З.Свердлова доступен в Сети по адресу http://www.uni-vologda.ac.ru/oberon/o2rus.htm).
Содержание
1.Введение
2.Синтаксис
3.Словарьиизображение
4.Описанияиправилавидимости
5.Описанияконстант
6.Описаниятипов
6.1Элементарныетипы
6.2Массивовыетипы
6.3Записевыетипы
6.4Указательныетипы
6.5Процедурныетипы
6.6Типылитерных цепочек
7.Описанияпеременных
8.Выражения
8.1Операнды
8.2Операции
9.Операторы
9.1Присваивания
9.2Вызовыпроцедур
9.3Операторныепоследовательности
9.4УсловныеоператорыIF
9.5ОператорывыбораCASE
9.6ЦиклсусловиемпродолженияWHILE
9.7ЦиклсусловиемокончанияREPEAT
9.8ЦиклсшагомFOR
9.9БезусловныйциклLOOP
9.10ОператорывозвратаRETURNивыходаEXIT
9.11ОператорыконкретизациитипаWITH
10.Описанияпроцедур
10.1Формальныепараметры
10.2Методы
10.3Предопределенныепроцедуры
10.4Финализация
11.Модули
ПриложениеA:Определениятерминов
ПриложениеB:СинтаксисКомпонентногоПаскаля
ПриложениеC:Диапазонызначенийэлементарныхтипов
ПриложениеD:Обязательныетребованияксредевыполнения
1. Введение
Компонентный Паскаль усовершенствованная версия языка Оберон-2, разработанная компанией Oberon microsystems. Компания Oberon microsystems благодарит Х.Мёссенбёка и Н.Вирта за дружеское разрешение использовать их Сообщение о языке Оберон-2 в качестве основы данного документа.
Компонентный Паскаль язык общего назначения в традиции языков Паскаль, Модула-2 и Оберон. Его самые важные черты блочная структура, модульность, раздельная компиляция, статическая типизация [static typing] и строгий контроль согласованности типов (в том числе через границы модулей), расширенное переопределение типов [type extension] вместе с методами, динамическая загрузка модулей, а также автоматический сбор мусора.
Переопределение типов делает Компонентный Паскаль объектно-ориентированным языком. Объект переменная абстрактного типа данных, состоящая из приватных данных (т.е. его состояния) и процедур, оперирующих с этими данными. Абстрактные типы данных определяются как записи, допускающие <расширенное> переопределение [extensible records]. В Компонентном Паскале для большей части понятий объектно-ориентированных языков используется установившийся словарь императивных языков, чтобы минимизировать число терминов для сходных понятий.
<Так как буквальный перевод терминологии оригинала оказывается громоздким в силу разной структуры английского и русского языков, в переводе для описания типов использованы термины потомок [extention] и предок [base type]. К тому же в оригинале употребляются разные по смыслу термины base type и basic type, в которых путаются сами носители английского языка.>
Полная защищенность типов переменных [complete type safety] и требование динамической объектной модели делают Компонентный Паскаль компонентно-ориентированным языком.
Данное сообщение не является учебником. Его краткость намеренна. Его функция служить справочником для программистов. Большинство недоговоренностей оставлено намеренно, либо потому, что соответствующее уточнение может быть выведено из сформулированных правил языка, либо потому, что уточнение потребовало бы конкретизации определения там, где универсальная конкретизация не кажется полезной.
Приложение A определяет некоторые термины, используемые для выражения правил проверки типов в Компонентном Паскале. В тексте такие термины даны курсивом, чтобы указать на их специальный смысл (например, одинаковый тип).
Рекомендуется минимизировать использование процедурных типов и супер-вызовов, т.к. они считаются устаревшими средствами. Они пока сохранены, чтобы облегчить использование существующих программ на Обероне-2. Поддержка этих средств может быть уменьшена в последующих выпусках продукта. В дальнейшем тексте то, что касается этих устаревших средств, отмечено красным цветом.
2. Синтаксис
Для описания синтаксиса Компонентного Паскаля используется расширенный формализм Бэкуса-Наура (РФБН). Альтернативы разделяются символом |. Квадратные скобки [ и ] означают необязательность заключенного в них выражения, а фигурные скобки { и } означают его возможное повторение (0 или более раз). В случае необходимости для группирования лексем используются круглые скобки ( и ). Нетерминальные лексемы начинаются с большой буквы (например, Statement). Терминальные лексемы либо начинаются с маленькой буквы (например, ident), либо записаны только большими буквами (например, BEGIN), либо обозначаются литерными цепочками (например, :=).
3. Словарь и изображение
Изображение (терминальных) лексем посредством литер использует стандарт ISO8859-1, т.е. расширение Latin1 набора литер ASCII. Такие лексемы суть идентификаторы, числа, операции и ограничители. Следует соблюдать следующие лексические правила. Пробелы и концы строк не должны появляться внутри лексем (за исключением комментариев, а также пробелов в литерных цепочках). Они игнорируются, если они не нужны для разделения двух последовательных лексем. Большие и маленькие буквы различаются.
1. Идентификаторы суть последовательности букв, цифр и символов подчеркивания. Первая литера не должна быть цифрой.
ident = (letter | _) {letter | _ | digit}.
letter = A .. Z | a .. z | А..Ц | Ш..ц | ш..я.
digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9.
Примеры: x Scan Oberon2 GetSymbol firstLetter
<В русифицированной версии системы Блэкбокс 1.5, доступной в рамках проекта Информатика-21 по адресу http://www.inr.ac.ru/~info21/software.htm, в идентификаторах допустимы все русские буквы.>
2. Числа суть целые или вещественные константы (без знака). Типом целой константы является INTEGER, если значение константы принадлежит диапазону значений типа INTEGER, или LONGINT в противном случае (см. 6.1). Если константа задана с суффиксом 'H' или 'L', представление является 16-ричным, в противном случае представление десятичное. Суффикс 'H' используется для записи 32-битных констант в диапазоне -2147483648 .. 2147483647. Разрешается не более восьми значащих 16-ричных цифр. Суффикс 'L' используется для записи 64-битных констант.
Вещественное число всегда содержит десятичную точку. Оно также может содержать десятичный масштабный множитель. Буква E означает умножить на 10 в степени. Вещественное число всегда имеет тип REAL.
number = integer | real.
integer = digit {digit} | digit {hexDigit} ( H | L ).
real = digit {digit} . {digit} [ScaleFactor].
ScaleFactor = E [+ | -] digit {digit}.
hexDigit = digit | A | B | C | D | E | F.
Примеры:
1234567 INTEGER 1234567
0DH INTEGER 13
12.3 REAL 12.3
4.567E8 REAL 456700000
0FFFF0000H INTEGER -65536
0FFFF0000L LONGINT 4294901760
3. Литеры [characters] обозначаются своим порядковым номером в 16-ричной нотации, за которым следует буква X.
character = digit {hexDigit} X.
4. Литерные цепочки [strings] последовательности литер, заключенные в одиночные (') или двойные (") кавычки. Открывающая кавычка должна всегда совпадать с закрывающей, и не содержаться внутри цепочки. Число литер в цепочке называется ее длиной. Цепочка длины 1 может использоваться всюду, где разрешена литерная константа, и наоборот.
string = " {char} " | ' {char} '.
Примеры: "Component Pascal" "Don't worry!" "x"
5. Операции и ограничители [operators and delimiters] суть специальные литеры, пары литер или ключевые слова, перечисленные ниже. Ключевые слова содержат только большие буквы и не могут использоваться как идентификаторы.
+ := ABSTRACT EXTENSIBLE POINTER
- ^ ARRAY FOR PROCEDURE
* = BEGIN IF RECORD
/ # BY IMPORT REPEAT
~ < CASE IN RETURN
& > CLOSE IS THEN
. <= CONST LIMITED TO
, >= DIV LOOP TYPE
; .. DO MOD UNTIL
| : ELSE MODULE VAR
$ ELSIF NIL WHILE
( ) EMPTY OF WITH
[ ] END OR
{ } EXIT OUT
6. Комментарии могут вставляться между любой парой лексем в программе. Они представляют собой произвольные последовательности литер, открывающиеся скобкой (* и закрывающиеся скобкой *). Комментарии могут быть вложены друг в друга. Они не влияют на смысл программы.
4. Описания и правила видимости
Каждый идентификатор, встречающийся в программе, должен быть введен с помощью описания [declaration], за исключением случаев, когда это предопределенный [predeclared] идентификатор. Описания также задают некоторые перманентные свойства объекта, такие как является ли он константой, типом, переменной или процедурой. Тогда идентификатор используется для ссылок на связанный с ним объект.
Область видимости объекта x текстуально распространяется от точки его описания до конца блока (модуля, процедуры или записи), которому принадлежит описание и по отношению к которому объект, таким образом, считается локальным. Из этой области исключаются области видимости объектов с таким же именем, описанных в блоках, вложенных в данный. Правила видимости таковы:
1. Идентификатор может обозначать только один объект в данной области видимости (т.е. никакой идентификатор не может быть объявлен в блоке дважды);
2. На объект можно сослаться только в его области видимости;
3. Описание типа T, содержащее ссылки на другой тип T1 могут стоять в точках, где T1 еще не известен. Описание типа T1 должно следовать далее в том же блоке, в котором локализован T;
4. Идентификаторы полей записей (см. 6.3) или методов (см. 10.2) могут встречаться только в составных именах [designators].
За идентификатором, описанным в блоке модуля, в его описании может следовать метка экспорта (* или -), чтобы указать, что он экспортируется. Идентификатор x, экспортированный из модуля M, можно использовать в других модулях при условии, что они импортируют M (см гл.Џ11). В таких модулях идентификатор обозначается как M.x и называется уточненным идентификатором [qualified identifier]. Переменные и поля записей, отмеченные в своих описаниях символом -, доступны в импортирующих модулях только для чтения [are read-only] (в случае переменных и полей) или только для реализации [implement-only] (в случае методов).
Qualident = [ident .] ident.
IdentDef = ident [* | -].
Следующие идентификаторы являются предопределенными; их значения описаны в указанных разделах:
ABS (10.3) INTEGER (6.1)
ANYPTR (6.1) FALSE (6.1)
ANYREC (6.1) LEN (10.3)
ASH (10.3) LONG (10.3)
ASSERT (10.3) LONGINT (6.1)
BITS (10.3) MAX (10.3)
BOOLEAN (6.1) MIN (10.3)
BYTE (6.1) NEW (10.3)
CAP (10.3) ODD (10.3)
CHAR (6.1) ORD (10.3)
CHR (10.3) REAL (6.1)
DEC (10.3) SET (6.1)
ENTIER (10.3) SHORT (10.3)
EXCL (10.3) SHORTCHAR (6.1)
HALT (10.3) SHORTINT (6.1)
INC (10.3) SHORTREAL (6.1)
INCL (10.3) SIZE (10.3)
INF (6.1) TRUE (6.1)
5. Описания констант
Описание константы связывает идентификатор с некоторым неизменяемым значением.
ConstantDeclaration = IdentDef = ConstExpression.
ConstExpression = Expression.
Константное выражение это выражение, которое может быть вычислено при простом текстуальном просмотре без фактического выполнения программы. Его операнды суть константы (гл. 8) или предопределенные функции (10.3), которые могут быть вычислены при компиляции. Примеры константных выражений:
N = 100
limit = 2*N - 1
fullSet = {MIN(SET) .. MAX(SET)}
6. Описания типов
Тип данных определяет множество значений, которое может принимать переменная этого типа, а также применимые к ней операции. Описание типа связывает идентификатор с типом. В случае структурированных типов (массивовых и записевых) оно также определяет структуру переменных этого типа. Структурированный тип не может содержать себя.
TypeDeclaration = IdentDef = Type.
Type = Qualident | ArrayType | RecordType | PointerType | ProcedureType.
Примеры:
Table = ARRAY N OF REAL
Tree = POINTER TO Node
Node = EXTENSIBLE RECORD
key : INTEGER;
left, right: Tree
END
CenterTree = POINTER TO CenterNode
CenterNode = RECORD (Node)
width: INTEGER;
subnode: Tree
END
Object = POINTER TO ABSTRACT RECORD END;
Function = PROCEDURE (x: INTEGER): INTEGER
6.1 Элементарные типы
Элементарные типы обозначаются предопределенными идентификаторами. Соответствующие операции определены в 8.2, а предопределенные процедуры-функции в 10.3. Значения элементарных типов таковы:
1. BOOLEAN логические значения TRUE и FALSE
2. SHORTCHAR литеры набора Latin1 (0X .. 0FFX)
3. CHAR литеры набора Unicode (0X .. 0FFFFX)
4. BYTE целые от MIN(BYTE) до MAX(BYTE)
5. SHORTINT целые от MIN(SHORTINT) до MAX(SHORTINT)
6. INTEGER целые от MIN(INTEGER) до MAX(INTEGER)
7. LONGINT целые от MIN(LONGINT) до MAX(LONGINT)
8. SHORTREAL вещественные числа от MIN(SHORTREAL) до MAX(SHORTREAL), значение INF
9. REAL вещественные числа от MIN(REAL) до MAX(REAL), значение INF
10. SET множества целых чисел из диапазона от 0 до MAX(SET)
Типы 4-7 суть целые типы, типы 8 и 9 суть вещественные типы, а вместе они называются числовыми типами. Они образуют иерархию; старший тип включает младший (включение касается значений):
REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE
Типы 2 и 3 суть литерные типы со следующей иерархией типов:
CHAR >= SHORTCHAR
<Тип SET является, по-существу, элегантным средством работы с битами в машинном слове, пронумерованными от 0 до MAX(SET), т.е. до 31 (см. Приложение C). Фактически числа, составляющие некоторое значение типа SET, это номера битов, выставленных в 1, причем остальные биты считаются выставленными в нуль. Преобразовать SET в INTEGER и обратно можно с помощью предопределенных функций BITS и ORD, описанных в разделе 10.3. Об операциях для значений типа SET см. ниже раздел 8.2.3 Операции над множествами.>
6.2 Массивовые типы [array types]
Массив структура, состоящая из некоторого количества элементов, имеющих один и тот же тип, называемый типом элементов. Количество элементов массива называется его длиной. Элементы массива выбираются с помощью индексов, являющихся целыми числами из диапазоне от 0 до длина минус 1.
ArrayType = ARRAY [Length {, Length}] OF Type.
Length = ConstExpression.
Тип вида
ARRAY L0, L1, ..., Ln OF T
интерпретируется как сокращенная запись для
ARRAY L0 OF
ARRAY L1 OF
...
ARRAY Ln OF T
Массивы, описанные без длины, называются открытыми массивами. Их использование ограничено базовыми типами для указателей (см. 6.4), типами элементов открытых массивов, а также типами формальных параметров (см. 10.1). Примеры:
ARRAY 10, N OF INTEGER
ARRAY OF CHAR
6.3 Записевые типы [record types]
Запись это структура, состоящая из фиксированного количества элементов, называемых полями, которые могут иметь разные типы. Описание записевого типа указывает имя и тип каждого поля. Область видимости идентификаторов полей распространяется от точки их описания до конца данного типа, но они также видимы внутри составных имен, обозначающих поля переменных данного типа (см. 8.1). Если записевый тип экспортируется, то идентификаторы полей, которые нужно иметь видимыми вне описывающего модуля, должны быть соответствующим образом помечены. Они называются публичными полями; непомеченные элементы называются приватными полями.
RecordType = RecAttributes RECORD [(BaseType)]
FieldList {; FieldList} END.
RecAttributes = [ABSTRACT | EXTENSIBLE | LIMITED].
BaseType = Qualident.
FieldList = [IdentList : Type].
IdentList = IdentDef {, IdentDef}.
Использование каждого записевого типа ограничено наличием или отсутствием одного из следующих атрибутов:
ABSTRACT, EXTENSIBLE и LIMITED.
Переменные записевого типа, помеченного как ABSTRACT, не могут быть размещены [instantiated]: не может существовать ни переменных, ни полей такого типа. Абстрактные типы <т.е. описанные с атрибутом ABSTRACT> используются только как типы-предки для других записевых типов (см. ниже).
Переменные записевого типа, имеющего атрибут LIMITED, могут размещаться [allocated] только внутри того модуля, где описан данный тип. Ограничение применимо как к статическому размещению посредством описания переменных (гл. 7), так и к динамическому размещению с помощью стандартной процедуры NEW (10.3).
Записевый тип, помеченный как ABSTRACT или EXTENSIBLE, допускает расширенное переопределение, т.е. можно определить новый записевый тип как расширение такого типа. В примере
T0 = EXTENSIBLE RECORD x: INTEGER END
T1 = RECORD (T0) y: REAL END
T1 является (непосредственным) потомком типа T0, а T0 (непосредственным) предком для T1 (см. Приложение A). Тип-потомок T1 состоит из полей типа-предка и полей, объявленных в T1. Все идентификаторы, описанные в типе-потомке, должны быть отличны от идентификаторов, описанных в его предке. Базовый тип абстрактного записевого типа должен быть абстрактным.
Кроме того, в качестве типа-предка можно использовать указательный тип. В этом случае в качестве типа-предка описываемого записевого типа используется базовый записевый тип данного указателя.
Нельзя экспортировать записевый тип, являющийся потомком скрытого (т.е. не экспортированного) записевого типа.
Каждая запись является неявным потомком предопределенного типа ANYREC. ANYREC не содержит никаких полей и может использоваться только в описаниях указателей и параметров-переменных.
Сводка атрибутов:
атрибут переопределение размещение
отсутствует нет да
EXTENSIBLE да да
ABSTRACT да нет
LIMITED только в определяющем модуле
Примеры описаний записевых типов:
RECORD
day, month, year: INTEGER
END
LIMITED RECORD
name, firstname: ARRAY 32 OF CHAR;
age: INTEGER;
salary: REAL
END
6.4 Указательные типы [pointer types]
Переменные, имеющие указательный тип P, принимают в качестве значений указатели на переменные некоторого типа T. T называется базовым типом [pointer base type] для P и должен быть записевым или массивовым типом. Указательные типы наследуют отношение потомок-предок для своих базовых типов: если тип T1 является потомком типа T, а P1 является типом POINTER TO T1, то P1 также является потомком типа P.
PointerType = POINTER TO Type.
Если p переменная типа P = POINTER TO T, то вызов предопределенной процедуры NEW(p) (см. 10.3) размещает переменную типа T в свободной памяти. Если T записевый тип или массивовый тип с фиксированной длиной, то размещение следует выполнять оператором NEW(p); если T n-мерный открытый массив, то размещение следует выполнять оператором NEW(p, e0, ..., en-1), где T размещается с длинами, задаваемыми выражениями e0, ..., en-1. В обоих случаях указатель на размещенную переменную присваивается переменной p. p имеет тип P. Разыменованная [referenced] переменная p^ (читается: p-разыменованная), имеет тип T. Любой указатель может принимать значение NIL, которое не указывает ни на какую переменную вообще.
Все поля и элементы вновь размещенной записи или массива очищаются; в частности, значения все содержащиеся в них указательные и процедурные переменные устанавливаются в NIL.
Предопределенный тип ANYPTR определяется как POINTER TO ANYREC. Поэтому любой указатель на какой-либо записевый тип является потомком типа ANYPTR. Процедуру NEW применять к переменным типа ANYPTR нельзя.
6.5 Процедурные типы
Переменные процедурного типа T имеют в качестве значения некоторую процедуру или NIL. Если переменной типа T присвоена процедура P, то списки формальных параметров (см. 10.1) для P и T должны соответствовать (см. Приложение A). P не может быть ни предопределенной процедурой, ни методом, ни быть локальной в другой процедуре.
ProcedureType = PROCEDURE [FormalParameters].
6.6 Типы литерных цепочек [string types]
Значения типов литерных цепочек суть последовательности литер, оканчивающиеся нуль-литерой (0X). Длина цепочки это количество литер в ней, исключая нуль-литеру.
Цепочки могут либо быть константами, либо храниться в массиве литер. Для типов цепочек нет предопределенных идентификаторов, т.к. они для описаний не нужны.
Константные цепочки, состоящие только из литер в диапазоне 0X..0FFX, и цепочки, хранящиеся в массиве элементов типа SHORTCHAR, имеют тип Shortstring, все остальные тип String.
7. Описания переменных
Описания переменных вводят переменные, определяя для них идентификатор и тип данных.
VariableDeclaration = IdentList : Type.
Переменные записевых и указательных типов имеют как статический тип (тот тип, с которым они описаны будем просто называть его их типом) и динамический тип (тип их значения при выполнении программы). Для указателей и параметров-переменных записевых типов динамический тип может быть потомком их статического типа. Статический тип определяет, какие поля записи доступны. Динамический тип используется для вызова методов (см. 10.2).
Примеры описаний переменных (см. примеры в гл. 6):
i, j, k: INTEGER
x, y: REAL
p, q: BOOLEAN
s: SET
F: Function
a: ARRAY 100 OF REAL
w: ARRAY 16 OF
RECORD
name: ARRAY 32 OF CHAR;
count: INTEGER
END
t, c: Tree
8. Выражения
Выражения это конструкции, описывающие вычислительные правила, в соответствии с которыми комбинируются константы и текущие значения переменных для вычисления других значений посредством применения операций и процедур-функций. Выражения состоят из операндов и операций. Круглые скобки могут использоваться для выражения конкретных связей между операциями и операндами.
8.1 Операнды
За исключением конструкторов множеств и буквальных констант (т.е. чисел, литер или цепочек), операнды обозначаются составными именами [designators]. Составное имя содержит идентификатор, обозначающий константу, переменную или процедуру. Этот идентификатор может быть уточнен идентификатором модуля (см. гл. 4 и 11), и кроме того за ним могут следовать селекторы, если обозначаемый объект является элементом массива или полем записи.
Designator = Qualident {. ident | [ ExpressionList ] | ^ |
( Qualident ) | ActualParameters} [ $ ].
ExpressionList = Expression {, Expression}.
ActualParameters = ( [ExpressionList] ).
Если a составное имя, обозначающее массив, то a[e] обозначает тот элемент массива a, у которого индекс равен значению выражения e в данный момент. Тип значения e должен быть целым. Составное имя, имеющее вид a[e0, e1, ..., en], является сокращением для a[e0][e1]...[en]. Если r является составным именем, обозначающим запись, то r.f обозначает поле f записи r или метода f динамического типа записи r (10.2). Если a или r доступны только для чтения, то это же справедливо для a[e] и r.f.
Если p составное имя, обозначающее указатель, то p^ обозначает переменную, на которую ссылается p. Составные имена p^.f, p^[e] и p^$ можно сокращать до p.f, p[e] и p$, т.е. селекторы записи, массива и литерной цепочки подразумевают разыменование [dereferencing]. Разыменование также подразумевается, если указатель присваивается переменной типа запись или типа массив (9.1), если указатель используется как фактический параметр, соответствующий формальному параметру типа запись или типа массив (10.1), или если указатель используется как аргумент стандартной процедуры LEN (10.3).
Охрана типа [type guard] v(T) удостоверяет, что динамический тип переменной v есть T (или потомок типа T), т.е. выполнение программы аварийно прекращается, если динамический тип переменной v не T (и не потомок T). Тогда внутри составного имени переменная v считается имеющей статический тип T. Охрана применима, если
1. v является IN или VAR параметром записевого типа или v является указателем на запись, и если
2. T является потомком статического типа переменной v
Если обозначаемый объект константа или переменная, то составное имя ссылается на ее значение в данный момент. Если это процедура, то составное имя ссылается на эту процедуру, исключая случаи, когда за ним следует (возможно, пустой) список параметров, и в этих случаях оно подразумевает вызов процедуры и представляет получающийся результат. Фактические параметры должны соответствовать формальным как в обычных вызовах процедур (см. 10.1).
Если a составное имя, обозначающее массив литер, то a$ обозначает литерную цепочку, оканчивающуюся нуль-литерой, содержащуюся в a. Если a не содержит литеру 0X, то использование a$ приводит к ошибке при выполнении программы. Селектор $ применяется неявно, если a используется как операнд конкатенации (8.2.4), операции отношения (8.2.5) или одной из предопределенных процедур LONG и SHORT (10.3).
Примеры составных имен (см. примеры в гл. 7):
i (INTEGER)
a[i] (REAL)
w[3].name[i] (CHAR)
t.left.right (Tree)
t(CenterTree).subnode (Tree)
w[i].name$ (String)
8.2 Операции [operators]
В выражениях синтаксически различаются операторы четырех классов с разными приоритетами (т.е. силой связывания]). Операция ~ имеет наивысший приоритет, за ней следуют мультипликативные операции, аддитивные операции и, наконец, отношения. Операции с одинаковым приоритетом связывают операнды слева направо. Например, x-y-z обозначает (x-y)-z.
Expression = SimpleExpression [Relation SimpleExpression].
SimpleExpression = [+ | -] Term {AddOperator Term}.
Term = Factor {MulOperator Factor}.
Factor = Designator | number | character | string | NIL | Set |
( Expression ) | ~ Factor.
Set = { [Element {, Element}] }.
Element = Expression [.. Expression].
Relation = = | # | < | <= | > | >= | IN | IS.
AddOperator = + | - | OR.
MulOperator = * | / | DIV | MOD | &.
Имеющиеся операции перечислены в нижеследующих таблицах. Некоторые операции применимы к операндам различных типов, обозначая различные операции. В этих случаях фактическая операция определяется типами операндов. Операнды должны быть совместимы по выражению по отношению к операции (см. Приложение A).
8.2.1 Логические операции
OR логическое ИЛИ p OR q если p, то TRUE, иначе q
& логическое И p & q если p, то q, иначе FALSE
~ отрицание ~ p не p
Эти операции применимы к операндам типа BOOLEAN и дают результат типа BOOLEAN. Второй операнд логического ИЛИ вычисляется только если результат первого равен FALSE. Второй операнд логического И вычисляется, только если результат первого равен TRUE.
8.2.2 Арифметические операции
+ сумма
- разность
* произведение
/ вещественное частное
DIV целое частное
MOD остаток
Операции +, -, * и / применимы к операндам числовых типов. Типом результата будет REAL в случае операции деления (/) или если один из операндов имеет тип REAL. В противном случае типом результата будет SHORTREAL, если тип одного из операндов SHORTREAL, LONGINT если тип одного из операндов LONGINT, или INTEGER в любом другом случае. Если результат вещественной операции слишком велик, чтобы представлять вещественное число, то он заменяется на предопределенное значение INF с тем же знаком, что и исходный результат. Заметим, что это правило применимо и к 1.0/0.0, но не к 0.0/0.0, т.к. последнее выражение не имеет определенного результата вообще и приводит к ошибке при выполнении программы. Если используются одноместные операции, - обозначает перемену знака, а + обозначает тождественную операцию. Операции DIV и MOD применимы только к целым операндам. Они связаны следующими формулами:
x = (x DIV y) * y + (x MOD y)
0 <= (x MOD y) < y или0>=(xMODy)>y
Заметим, что:xDIVy=ENTIER(x/y)
Примеры:
x y x DIV y x MOD y
5 3 1 2
-5 3 -2 1
5 -3 -2 -1
-5 -3 1 -2
Заметим, что:
(-5) DIV 3 = -2
но
-5 DIV 3 = -(5 DIV 3) = -1
8.2.3 Операции над множествами
+ объединение
- разность (x - y = x * (-y))
* пересечение
/ симметричная разность (x / y = (x-y) + (y-x))
Операции над множествами применимы к операндам типа SET и дают результат типа SET. Одноместный минус обозначает дополнение множества x, т.е. -x обозначает множество целых от 0 до MAX(SET), которые не являются элементами множества x. Операции над множествами не являются ассоциативными ((a+b)-c # a+(b-c)).
Конструктор множества определяет значение множества перечислением его элементов между фигурными скобками. Элементы должны быть целыми в диапазоне 0..MAX(SET). Диапазон a..b обозначает все целые i такие, что i>=aиi<=b.
<В разделе 6.1 отмечалось, что тип SET это высокоуровневое средство работы с битами в машинном слове. Конструктор множества фактически указывает, какие биты слова выставляются в 1. При этом описанные выше теоретико-множественные операции компилируются непосредственно в побитовые логические операции. Например, объединение, пересечение и дополнение множеств соответствуют побитовым логическим И, ИЛИ и отрицанию. Математический результат, подкрепляющий такую возможность элементарная теорема об эквивалентности булевых алгебр алгебрам подмножеств. Напомним, что преобразования между типами SET и INTEGER осуществляются с помощью предопределенных функций BITS и ORD, описанных в разделе 10.3.>
8.2.4 Операции над цепочками
+ конкатенация
Операция конкатенации применяется к операндам, имеющим типы цепочек. Получающаяся цепочка состоит из литер первого операнда, за которыми следуют литеры второго операнда. Если оба операнда имеют тип Shortstring, то типом результата будет Shortstring, в противном случае тип результата будет String.
8.2.5 Отношения
= равно
# неравно
< меньше
<= меньше или равно
> больше
>= больше или равно
IN принадлежность множеству
IS проверка типа
Отношения дают результат типа BOOLEAN. Отношения =, #, <, <=, > и >= применимы к числовым типам, литерным типам и типам литерных цепочек. Отношения = и # применимы также к BOOLEAN и SET, а также к указательным и процедурным типам (включая значение NIL). x IN s означает x является элементом s. x должен быть целым в диапазоне 0..MAX(SET), а s иметь тип SET. v IS T означает динамический тип переменной v равен T (или потомку типа T) и называется проверкой типа. Она применима, если
1. v является IN или VAR параметром записевого типа или указателем на записевый тип, и если
2. T является потомком статического типа v
Примеры выражений (см. примеры в гл. 7):
1991 INTEGER
i DIV 3 INTEGER
~p OR q BOOLEAN
(i+j) * (i-j) INTEGER
s - {8, 9, 13} SET
i + x REAL
a[i+j] * a[i-j] REAL
(0<=i) & (i<100) BOOLEAN
t.key = 0 BOOLEAN
k IN {i..j-1} BOOLEAN
w[i].name$ <= "John" BOOLEAN
t IS CenterTree BOOLEAN
9. Операторы [statements]
Операторы обозначают действия. Есть элементарные и структурированные операторы. Элементарные операторы не содержат частей, которые сами являлись бы операторами. Это: присваивание, вызов процедуры, оператор возврата RETURN и оператор выхода EXIT. Структурированные операторы состоят из частей, которые сами являются операторами. Они используются для выражения последовательного, условного, выборочного и повторяющегося выполнения. Оператор может быть пустым, и в этом случае он обозначает отсутствие действия. Пустой оператор разрешен, чтобы ослабить правила пунктуации в операторных последовательностях.
Statement = [ Assignment | ProcedureCall | IfStatement | CaseStatement |
WhileStatement | RepeatStatement |
ForStatement | LoopStatement | WithStatement |
EXIT | RETURN [Expression] ].
9.1 Присваивания
Присваивание заменяет текущее значение переменной новым, определяемым неким выражением. Выражение должно быть совместимым по присваиванию с переменной (см. Приложение A). Операция присваивания записывается как := и произносится становится равной.
Assignment = Designator := Expression.
Если выражение e типа Te присваивается переменной v типа Tv, происходит следующее:
1. если Tv и Te имеют записевый тип, то присваиваются все поля этого типа;
2. если Tv и Te имеют указательные типы, то динамическим типом v становится динамический тип e;
3. если Tv массив литерного типа, а e литерная цепочка длины m < LEN(v), то v[i] становится равным ei для i = 0..m-1, а v[m] становится равным 0X. Если m >= LEN(v), то в процессе выполнения генерируется ошибка.
Примеры присваиваний (см. примеры в гл. 7):
i := 0
p := i = j
x := i + 1
k := Log2(i+j)
F := Log2 (* см. 10.1 *)
s := {2, 3, 5, 7, 11, 13}
a[i] := (x+y) * (x-y)
t.key := i
w[i+1].name := "John"
t := c
9.2 Вызовы процедур
Вызов процедуры активизирует процедуру. Он может содержать список фактических параметров, которые замещают соответствующие формальные параметры, определенные в описании процедуры (см. гл. 10). Соответствие устанавливается по положению параметров в списках фактических и формальных параметров. Имеется два типа параметров: параметры-переменные и параметры-значения.
Если формальный параметр является параметром-переменной, то соответствующий фактический параметр должен быть составным именем некоторой переменной. Если он обозначает элемент структурированной переменной, то соответствующие селекторы вычисляются при подстановке фактического параметра вместо формального, т.е. до выполнения процедуры. Если формальный параметр параметр-значение, то соответствующий фактический параметр должен быть выражением. Это выражение вычисляется до активизации процедуры, а получающееся значение присваивается формальному параметру (см. также 10.1).
ProcedureCall = Designator [ActualParameters].
Примеры:
WriteInt(i*2+1) (* см. 10.1 *)
INC(w[k].count)
t.Insert("John") (* см. 11 *)
9.3 Операторные последовательности
Операторная последовательность обозначает последовательность действий, указанных отдельными операторами, разделенными точками с запятой.
StatementSequence = Statement {; Statement}.
9.4 Условный оператор IF
IfStatement =
IF Expression THEN StatementSequence
{ELSIF Expression THEN StatementSequence}
[ELSE StatementSequence]
END.
Оператор IF задает условное выполнение охраняемых операторных последовательностей. Логическое выражение, предшествующее операторной последовательности, называется его охраной. Охраны вычисляются в том порядке, в котором они встречаются в тексте, до тех пор, пока одна из них не даст значение TRUE, после чего выполняется соответствующая операторная последовательность. Если ни одна охрана не будет удовлетворена, выполняется операторная последовательность, следующая за лексемой ELSE, если таковая имеется.
Пример:
IF (ch >= "A") & (ch <= "Z") THEN ReadIdentifier
ELSIF (ch >= "0") & (ch <= "9") THEN ReadNumber
ELSIF (ch = "'") OR (ch = '"') THEN ReadString
ELSE SpecialCharacter
END
9.5 Оператор выбора CASE
Оператор CASE указывает выбор и выполнение некоторой операторной последовательности в зависимости от значения некоторого выражения. Сначала вычисляется выражение выбора, затем выполняется та операторная последовательность, чей список меток выбора содержит полученное значение. Выражение выбора должно иметь целый или литерный тип, который включает значения всех меток выбора. Метки выбора константы, и никакое значение не может встречаться более одного раза. Если значение выражения не встречается в качестве метки, то выполняется операторная последовательность, следующая за лексемой ELSE, если таковая имеется, в противном случае программа аварийно останавливается.
CaseStatement = CASE Expression OF Case {| Case}
[ELSE StatementSequence] END.
Case = [CaseLabelList : StatementSequence].
CaseLabelList = CaseLabels {, CaseLabels}.
CaseLabels = ConstExpression [.. ConstExpression].
Пример:
CASE ch OF
"A" .. "Z": ReadIdentifier
| "0" .. "9": ReadNumber
| "'", '"': ReadString
ELSE SpecialCharacter
END
9.6 Цикл с условием продолжения (WHILE)
Оператор цикла WHILE описывает выполнение операторной последовательности, повторяющееся, пока некое логическое выражение (его охрана) дает TRUE. Охрана проверяется заново перед каждым вычислением операторной последовательности.
WhileStatement = WHILE Expression DO StatementSequence END.
Примеры:
WHILE i > 0 DO i := i DIV 2; k := k + 1 END
WHILE (t # NIL) & (t.key # i) DO t := t.left END
9.7 Цикл с условием окончания (REPEAT)
Оператор цикла REPEAT описывает выполнение операторной последовательности, повторяющееся до тех пор, пока некое логическое выражение не даст TRUE. Последовательность выполняется хотя бы один раз.
RepeatStatement = REPEAT StatementSequence UNTIL Expression.
9.8 Цикл с шагом (FOR)
Оператор цикла FOR описывает выполнение операторной последовательности, повторяющееся для последовательности значений, присваиваемых целой переменной, называемой управляющей переменной цикла.
ForStatement =
FOR ident := Expression TO Expression [BY ConstExpression]
DO StatementSequence END.
Оператор
FOR v := beg TO end BY step DO statements END
эквивалентен следующему
temp := end; v := beg;
IF step > 0 THEN
WHILE v <= temp DO statements; v := v + step END
ELSE
WHILE v >= temp DO statements; v := v + step END
END
temp имеет одинаковый тип с переменной v. step должно быть ненулевым константным выражением. Если выражение step не указано, оно берется равным 1.
Примеры:
FOR i := 0 TO 79 DO k := k + a[i] END
FOR i := 79 TO 1 BY -1 DO a[i] := a[i-1] END
9.9 Безусловный цикл LOOP
Оператор LOOP описывает повторяющееся выполнение операторной последовательности. Оно прекращается выполнением оператора выхода EXIT внутри этой последовательности (см. 9.10).
LoopStatement = LOOP StatementSequence END.
Пример:
LOOP
ReadInt(i);
IF i < 0 THEN EXIT END;
WriteInt(i)
END
Циклы LOOP полезны для выражения повторяющихся вычислений с несколькими точками выхода или в тех случаях, когда условие выхода находится в середине повторяющейся операторной последовательности.
9.10 Операторы возврата RETURN и выхода EXIT
Оператор возврата RETURN указывает прекращение процедуры. Он обозначается лексемой RETURN, за которой следует выражение, если речь идет о процедуре-функции. Тип выражения должен быть совместим по присваиванию (см. ПриложениеA) с типом результата, указанным в заголовке процедуры (см. гл. 10).
Процедуры-функции требуют наличия оператора возврата, указывающего значение-результат. В собственно процедурах оператор возврата неявно подразумевается в конце тела процедуры. Поэтому любой явный оператор возврата появляется как дополнительная (вероятно, исключительная) точка выхода.
Оператор выхода обозначается лексемой EXIT. Он означает, что выполнение охватывающего оператора LOOP должно быть прекращено, а выполнение программы должно быть продолжено с оператора, следующего за этим оператором LOOP. Оператор EXIT контекстуально, хотя и не синтаксически, связан с содержащим его оператором LOOP.
9.11 Операторы конкретизации типа WITH
Оператор WITH выполняет операторную последовательность в зависимости от результата проверки типа и применяет охрану типа к каждому вхождению проверяемой переменной внутри операторной последовательности.
WithStatement = WITH [ Guard DO StatementSequence ]
{| [ Guard DO StatementSequence} ]
[ELSE StatementSequence] END.
Guard = Qualident : Qualident.
Если v параметр-переменная записевого типа или указательная переменная, и если ее статический тип T0, то значение оператора
WITH v: T1 DO S1 | v: T2 DO S2 ELSE S3 END
таково: если динамическим типом переменной v оказался T1, то выполняется операторная последовательность S1, в которой v рассматривается как если бы ее статическим типом был T1; в противном случае если динамическим типом v оказался T2, то выполняется S2, в которой v рассматривается как если бы ее статическим типом был T2; в противном случае выполняется S3. T1 и T2 должны быть потомками типа T0. Если ни одна проверка типа не дала положительного результата и если отсутствует ELSE (вместе c соответствующей операторной последовательностью), то программа аварийно останавливается.
Пример:
WITH t: CenterTree DO i := t.width; c := t.subnode END
10. Описания процедур
Описание процедуры состоит из заголовка процедуры и тела процедуры. Заголовок задает идентификатор процедуры и ее формальные параметры. Для методов он также задает принимающий параметр [receiver parameter] и атрибуты (см. 10.2). Тело содержит объявления и операторы. Идентификатор процедуры повторяется в конце ее описания.
Есть два вида процедур: обычные процедуры и процедуры-функции. Процедура-функция активизируется составным именем функции, выступающим в качестве части выражения, и дает результат, являющийся операндом выражения. Обычные процедуры активизируются вызовом процедуры. Процедура является процедурой-функцией, если список ее формальных параметров задает некоторый тип результата. Тело процедуры-функции должно содержать оператор возврата, который определяет ее результат.
Все константы, переменные, типы и процедуры, описанные внутри тела процедуры, являются локальными по отношению к этой процедуре. Поскольку процедуры тоже могут описываться как локальные объекты, описания процедур могут быть вложены друг в друга. Вызов процедуры внутри ее описания означает рекурсивную активизацию.
Локальным переменным указательных или процедурных типов присваивается значение NIL перед выполнением тела процедуры.
Объекты, описанные в контексте, окружающем процедуру, видимы также и в тех частях процедуры, где они не перекрыты локально определенным объектом с точно тем же именем.
ProcedureDeclaration = ProcedureHeading [; ProcedureBody ident ].
ProcedureHeading = PROCEDURE [Receiver] IdentDef
[FormalParameters] MethAttributes.
ProcedureBody = DeclarationSequence
[BEGIN StatementSequence] END.
DeclarationSequence = {CONST {ConstantDeclaration ;} |
TYPE {TypeDeclaration ;} |
VAR {VariableDeclaration ;} }
{ProcedureDeclaration ; | ForwardDeclaration ;}.
ForwardDeclaration = PROCEDURE ^ [Receiver] IdentDef
[FormalParameters] MethAttributes.
Если в описании процедуры указан принимающий параметр [receiver], то процедура считается методом, связанным с типом принимающего параметра (см. 10.2). Упреждающее описание служит для того, чтобы разрешить ссылки на процедуру, чье фактическое описание содержится дальше по тексту. Списки формальных параметров упреждающего и фактического описаний должны соответствовать (см. Приложение A), а имена соответствующих параметров должны быть идентичными.
10.1 Формальные параметры
Формальные параметры суть идентификаторы, описанные в списке формальных параметров процедуры. Они соответствуют фактическим параметрам, указанным в вызове процедуры. Соответствие между формальными и фактическими параметрами устанавливается при вызове процедуры. Есть два вида параметров: параметры-значения и параметры-переменные, последние отмечены в списке формальных параметров одним из описателей VAR, IN или OUT. Параметры-значения представляют собой локальные переменные, которым в качестве начального значения присваивается значение соответствующего фактического параметра. Параметры-переменные соответствуют фактическим параметрам, являющимся переменным, и они представляют эти переменные. Параметры-переменные могут использоваться только для ввода данных (IN), только для вывода данных (OUT) или для ввода и вывода (VAR). Описатель IN можно использовать только для параметров, являющихся массивами или записями. Внутри процедуры IN-параметры доступны только для чтения. Как и локальные переменные, OUT-параметры указательных или процедурных типов инициализируются в NIL. Значения других выходных параметров должны рассматриваться как неопределенные до первого присваивания в процедуре. Область видимости формального параметра распространяется от его описания до конца процедурного блока, в котором он описан. Процедура-функция без параметров должна иметь пустой список параметров. Она должна вызываться с помощью составного имени, у которого есть пустой список фактических параметров. Тип результата процедуры не может быть ни записью, ни массивом.
FormalParameters = ( [FPSection {; FPSection}] ) [: Type].
FPSection = [VAR | IN | OUT] ident {, ident} : Type.
Пусть f формальный параметр, и пусть a соответствующий фактический параметр. Если f открытый массив, то a должен быть совместим по массивам с f, и длины f берутся из a. В противном случае a должен быть совместим по параметрам c f (см. Приложение A).
Примеры описаний процедур:
PROCEDURE ReadInt (OUT x: INTEGER);
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; Read(ch);
WHILE ("0" <= ch) & (ch <= "9") DO
i := 10 * i + (ORD(ch) - ORD("0")); Read(ch)
END;
x := i
END ReadInt
PROCEDURE WriteInt (x: INTEGER); (* 0 <= x < 100000 *)
VAR i: INTEGER; buf: ARRAY 5 OF INTEGER;
BEGIN
i := 0;
REPEAT buf[i] := x MOD 10; x := x DIV 10; INC(i) UNTIL x = 0;
REPEAT DEC(i); Write(CHR(buf[i] + ORD("0"))) UNTIL i = 0
END WriteInt
PROCEDURE WriteString (IN s: ARRAY OF CHAR);
VAR i: INTEGER;
BEGIN
i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO Write(s[i]); INC(i) END
END WriteString
PROCEDURE Log2 (x: INTEGER): INTEGER;
VAR y: INTEGER; (* assume x > 0 *)
BEGIN
y := 0; WHILE x > 1 DO x := x DIV 2; INC(y) END;
RETURN y
END Log2
PROCEDURE Modify (VAR n: Node);
BEGIN
INC(n.key)
END Modify
10.2 Методы
Процедуры, описанные глобально, могут быть связаны с каким-либо записевым типом, описанным в том же модуле. Такие процедуры называют методами, связанными с данным записевым типом. Связь выражается посредством указания типа принимающего параметра в заголовке описания процедуры. Получающий параметр может быть VAR или IN параметром типа T или параметром-значением типа POINTER TO T, где T записевый тип. Метод связан с типом T и считается в нем локальным.
ProcedureHeading = PROCEDURE [Receiver] IdentDef
[FormalParameters] MethAttributes.
Receiver = ( [VAR | IN] ident : ident ).
MethAttributes = [, NEW] [, (ABSTRACT | EMPTY | EXTENSIBLE)].
Если метод M связан с типом T0, он также неявно связан с любым потомком T1 типа T0. Однако если метод M' (с тем же именем, что и у M) описан как связанный с T1, он становится связан с T1 вместо M. M' считается переопределением M для T1. Списки формальных параметров M и M' должны соответствовать,кроме случаев, когда M процедура-функция, возвращающая указательный тип. В последнем случае тип результата функции M' должен быть потомком типа результата M(ковариантность) (см. Приложение A). Если M и T1 экспортируются (см. гл. 4), то M' тоже должен экспортироваться.
Если M не экспортируется, то M' тоже не должен экспортироваться. Если M и M' экспортируются, их метки экспорта должны быть одинаковыми.
Для ограничения и документирования предполагаемого использования метода используются следующие атрибуты:
NEW, ABSTRACT, EMPTY и EXTENSIBLE
<соответственно: новый, абстрактный, пустой и переопределяемый>.
Необходимо использовать атрибут NEW для всех вновь вводимых методов, и его нельзя использовать для переопределяющих методов. Этот атрибут помогает обнаружить несогласованности в определениях методов, связанных с типом и его потомками; такие несогласованности могут возникнуть при переименованиях методов.
Описания абстрактных и пустых методов состоят только из заголовка процедуры. Абстрактные методы не могут вызываться. Записевый тип, с которым связан абстрактный метод, должен быть абстрактным. Метод, переопределяемый абстрактным методом, должен быть абстрактным. Абстрактный метод экспортируемого записевого типа должен экспортироваться. Вызов пустого метода не имеет никакого эффекта. Пустые методы не могут быть процедурами-функциями и не могут иметь OUT параметров. Записевый тип, с которым связаны новые пустые методы, должен быть переопределяемым или абстрактным. Метод, переопределенный пустым методом, должен быть пустым или абстрактным. Абстрактные или пустые методы некоторого типа обычно переопределяются (реализуются) в его потомках. Они не должны вызываться супер-вызовами. Конкретный (не абстрактный) записевый тип, являющийся потомком абстрактного типа, должен реализовать все абстрактные методы своего типа-предка.
Конкретные методы (имеющие процедурное тело) должны быть либо переопределяемыми, либо конечными (т.е. описанными без атрибутов). Конечный метод не может переопределяться в потомках своего типа. Записевый тип, содержащий переопределяемые методы, должен быть переопределяемым или абстрактным.
Если v составное имя, а M метод, то v.M обозначает метод M, связанный с динамическим типом v. Заметим, что такой метод может отличаться от одноименного метода, связанного со статическим типом переменной v. v передается принимающему параметру метода M' по правилам передачи параметров, указанным в 10.1.
Если r принимающий параметр, описанный как имеющий тип T, то r.M^ означает метод M, связанный с типом-предком типа T (супер-вызов). В упреждающем и фактическом описаниях метода принимающие параметры должны быть соответствующих типов. Списки формальных параметров обоих описаний должны соответствовать (Приложение A), а имена соответствующих параметров должны быть идентичны.
Методы, помеченные символом -, считаются экспортированными только для реализации. Такой метод может быть переопределен в любом импортирующем модуле, но может вызываться только в модуле, содержащем описание метода. (В настоящее время компилятор допускает супер-вызовы методов, экспортированных только для реализации, вне их определяющего модуля. Это допускается временно для облегчения переноса программ.)
Примеры:
PROCEDURE (t: Tree) Insert (node: Tree), NEW, EXTENSIBLE;
VAR p, father: Tree;
BEGIN p := t;
REPEAT father := p;
IF node.key = p.key THEN RETURN END;
IF node.key < p.key THEN p := p.left ELSE p := p.right END
UNTIL p = NIL;
IF node.key < father.key THEN
father.left := node
ELSE
father.right := node
END;
node.left := NIL; node.right := NIL
END Insert
PROCEDURE (t: CenterTree) Insert (node: Tree); (* redefinition *)
BEGIN
WriteInt(node(CenterTree).width);
t.Insert^ (node) (* calls the Insert method of Tree *)
END Insert
PROCEDURE (obj: Object) Draw (w: Window), NEW, ABSTRACT
PROCEDURE (obj: Object) Notify (e: Event), NEW, EMPTY
10.3 Предопределенные процедуры
Следующая таблица дает список предопределенных процедур. Некоторые процедуры являются обобщенными, т.е. они применимы к разным типам операндов. v представляет переменную, x и y выражения, а T тип. Первая подходящая строка дает правильный тип результата.
Процедуры-функции
Имя Тип аргументов Тип результата Функция
ABS(x) <= INTEGER INTEGER абсолютное значение
вещественный тип,
LONGINT тип x
ASH(x, y) x: <= INTEGER INTEGER арифметический сдвиг (x * 2^y)
x: LONGINT LONGINT
y: целый тип
BITS(x) INTEGER SET {i | ODD(x DIV 2^i)}
CAP(x) литерный тип тип x x буква из набора Latin-1:
соответствующая большая буква
CHR(x) целый тип CHAR литера с порядковым номером
x
ENTIER(x) вещественный тип LONGINT наибольшее целое, не
превосходящее x
LEN(v, x) v: массив; x: целая INTEGER длина v в измерении x
константа (первое измерение = 0)
LEN(v) массивовый тип INTEGER эквивалентно LEN(v, 0)
String <цепочка> INTEGER длина цепочки
(не считая 0X)
LONG(x) BYTE SHORTINT тождество
SHORTINT INTEGER
INTEGER LONGINT
SHORTREAL REAL
SHORTCHAR CHAR
Shortstring String
MAX(T) T = элементарный тип T максимальное значение для типа T
T = SET INTEGER максимальный элемент множества
MAX(x, y) <= INTEGER INTEGER большее значение из x и y
целый тип LONGINT
<= SHORTREAL SHORTREAL
числовой тип REAL
SHORTCHAR SHORTCHAR
литерный тип CHAR
MIN(T) T = элементарный тип T минимальное значение для типа T
T = SET INTEGER 0
MIN(x, y) <= INTEGER INTEGER меньшее значение из x и y
целый тип LONGINT
<= SHORTREAL SHORTREAL
числовой тип REAL
SHORTCHAR SHORTCHAR
литерный тип CHAR
ODD(x) целый тип BOOLEAN x MOD 2 = 1
ORD(x) CHAR INTEGER порядковый номер литеры x
SHORTCHAR SHORTINT порядковый номер литеры x
SET INTEGER (SUM i: i IN x: 2^i)
SHORT(x) LONGINT INTEGER тождество
INTEGER SHORTINT тождество
SHORTINT BYTE тождество
REAL SHORTREAL тождество (возможно усечение)
CHAR SHORTCHAR проекция
String Shortstring проекция
SIZE(T) любой тип INTEGER количество байт, требуемое для T
SIZE не может применяться в константных выражениях, т.к. его значение зависит от фактической реализации компилятора.
Собственно процедуры
Имя Типы аргументов Функция
ASSERT(x) x: логическое выражение остановить программу, если не x
ASSERT(x, n) x: логическое выражение; остановить программу, если не x
n: целая константа
DEC(v) целый тип v := v - 1
DEC(v, n) v, n: целый тип v := v - n
EXCL(v, x) v: SET; x: целый тип, v := v - {x}
0 <= x <= MAX(SET)
HALT(n) целая константа остановить программу
INC(v) целый тип v := v + 1
INC(v, n) v, n: целый тип v := v + n
INCL(v, x) v: SET; x: целый тип, v := v + {x}
0 <= x <= MAX(SET)
NEW(v) указатель на запись или разместить v ^
фиксированный массив
NEW(v, x0, ..., xn) v: указатель на открытый разместить v ^ с
массив; длинами x0.. xn
xi: целый тип
В ASSERT(x, n) и HALT(n) интерпретация n определяется конкретной реализацей.
10.4 Финализация
Предопределенный метод с именем FINALIZE связан с каждым записевым типом как если бы он был описан как связанный с типом ANYREC:
PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;
Метод FINALIZE может быть реализован для любого указательного типа. Этот метод вызывается в неопределенное время после того, как объект этого типа (или соответствующего базового типа) стал недоступен через другие указатели (перестал быть глобально доступным) и до того как память, занимаемая объектом, утилизуется системой.
Не рекомендуется вновь делать этот объект глобально доступным внутри этого метода, и этот метод не вызывается повторно, если объект снова станет недоступным. Порядок финализации нескольких недоступных объектов не определен.
11. Модули
Модуль это набор описаний констант, типов, переменных и процедур вместе с некоторой операторной последовательностью для присваивания начальных значений переменным <а также с некоторой операторной последовательностью финализации>. Модуль представляет собой текст, компилируемый как целое.
Module = MODULE ident ; [ImportList] DeclarationSequence
[BEGIN StatementSequence]
[CLOSE StatementSequence] END ident ..
ImportList = IMPORT Import {, Import} ;.
Import = [ident :=] ident.
Список импорта указывает имена импортируемых модулей. Если модуль A импортируется модулем M, и A экспортирует идентификатор x, то внутри M на x ссылаются как A.x. Если A импортируется как B := A, то на объект x следует ссылаться как B.x. Благодаря этому возможно использовать краткие псевдонимы для имен модулей в уточненных идентификаторах. Модуль не может импортировать сам себя. Идентификаторы, которые нужно экспортировать (т.е. которые должны быть видимы в модулях-клиентах), должны быть надлежащим образом помечены в описаниях (см. главу 4).
Операторная последовательность, следующая за BEGIN, выполняется, когда модуль добавляется к системе (загружается), что выполняется после загрузки импортируемых модулей. Следовательно, циклический импорт модулей невозможен. Отдельные экспортированные процедуры могут быть активизированы системой, и такие процедуры служат командами.
Содержимое переменных, описанных в модуле, очищается перед выполнением тела модуля. Это подразумевает, что все переменные указательных или процедурных типов инициализируются в NIL.
Операторная последовательность, следующая за CLOSE, выполняется, когда модуль удаляется из системы.
Пример:
MODULE Trees; (* exports: Tree, Node, Insert, Search, Write, Init *)
IMPORT StdLog;
TYPE
Tree* = POINTER TO Node;
Node* = RECORD (* exports read-only: Node.name *)
name-: POINTER TO ARRAY OF CHAR;
left, right: Tree
END;
PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR), NEW;
VAR p, father: Tree;
BEGIN
p := t;
REPEAT father := p;
IF name = p.name^ THEN RETURN END;
IF name < p.name^ THEN p := p.left ELSE p := p.right END
UNTIL p = NIL;
NEW(p); p.left := NIL; p.right := NIL;
NEW(p.name, LEN(name$) + 1); p.name^ := name$;
IF name < father.name^ THEN father.left := p ELSE father.right := p END
END Insert;
PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree, NEW;
VAR p: Tree;
BEGIN
p := t;
WHILE (p # NIL) & (name # p.name^) DO
IF name < p.name^ THEN p := p.left ELSE p := p.right END
END;
RETURN p
END Search;
PROCEDURE (t: Tree) Write*, NEW;
BEGIN
IF t.left # NIL THEN t.left.Write END;
StdLog.String(t.name); StdLog.Ln;
IF t.right # NIL THEN t.right.Write END
END Write;
PROCEDURE Init* (t: Tree);
BEGIN
NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL
END Init;
BEGIN
StdLog.String("Trees loaded"); StdLog.Ln
CLOSE
StdLog.String("Trees removed"); StdLog.Ln
END Trees.
Приложение A: Определения терминов
Литерные типы SHORTCHAR, CHAR
Целые типы BYTE, SHORTINT, INTEGER, LONGINT
Вещественные типы SHORTREAL, REAL
Числовые типы целые и вещественные типы
Типы литерных цепочек Shortstring, String
Основные типы BOOLEAN, SET, литерные и числовые типы
Одинаковые типы [Same types]
Две переменные a и b с типами Ta и Tb имеют одинаковый тип, если
1. Ta и Tb оба обозначены одним и тем же идентификатором типа, или
2. Ta описан в описании типа вида Ta = Tb, или
3. a и b появляются в одном списке идентификаторов в описании переменных, полей записи или формальных параметров.
Эквивалентные типы [Equal types]
Два типа Ta и Tb эквивалентны, если
1. Ta и Tb имеют одинаковый тип, или
2. Ta и Tb суть типы открытых массивов с эквивалентными типами элементов, или
3. Ta и Tb суть процедурные типы, чьи списки формальных параметров соответствуют.
4. Ta и Tb суть указательные типы с эквивалентными базовыми типами.
Соответствие списков формальных параметров [Matching formal parameter lists]
Два списка формальных параметров соответствуют, если
1. они имеют одинаковое число параметров, и
2. они имеют либо эквивалентные типы результатов функции, либо не имеют никаких, и
3. параметры в соответствующих позициях имеют эквивалентные типы, и
4. параметры в соответствующих позициях суть оба либо параметры-значения, либо IN, OUT или VAR параметры.
Включение типов [Type inclusion]
Числовые и литерные типы включают (значения) меньших типов того же класса в соответствии со следующими иерархиями:
REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE
CHAR >= SHORTCHAR
Типы-потомки и типы-предки [Type extension]
Если дано описание типа Tb = RECORD (Ta) ... END, то Tb является непосредственным потомком типа Ta, а Ta непосредственным предком типа Tb. Какой-либо тип Tb является потомком [extension] типа Ta (Ta является предком для Tb), если
1. Ta и Tb суть одинаковые типы, или
2. Tb непосредственный потомок некоторого потомка типа Ta, или
3. Ta имеет тип ANYREC.
Если Pa = POINTER TO Ta и Pb = POINTER TO Tb, то Pb потомок типа Pa (Pa предок для Pb), если Tb является потомком типа Ta.
Совместимость по присваиванию [Assignment compatible]
Выражение e типа Te является совместимым по присваиванию с переменной v типа Tv, если выполняется одно из следующих условий:
1. Te и Tv эквивалентны и не являются ни типами открытых массивов, ни записевыми типами, описанными с атрибутами ABSTRACT, EXTENSIBLE или LIMITED;
2. Te и Tv числовые или литерные типы, и Tv включает Te;
3. Te и Tv указательные типы, и Te потомок типа Tv;
4. Tv указательный или процедурный тип, и e есть NIL;
5. Tv числовой тип, а e константное выражение, чье значение содержится в Tv;
6. Tv массив CHAR, Te String или Shortstring, и LEN(e) < LEN(v);
7. Tv массив SHORTCHAR, Te Shortstring, и LEN(e) < LEN(v);
8.Tv процедурный тип, а e имя процедуры, чьи формальные параметры соответствуют параметрам Tv.
Совместимость по массивам [Array compatible]
Фактический параметр a типа Ta является совместимым по массивам с формальным параметром f типа Tf, если
1. Tf и Ta эквивалентны, или
2. Tf открытый массив, Ta произвольный массив, и типы их элементов совместимы по массивам, или
3. Tf открытый массив CHAR, и Ta имеет тип String, или
4. Tf открытый массив SHORTCHAR, и Ta имеет тип Shortstring.
Совместимость по параметрам [Parameter compatible]
Фактический параметр a типа Ta является совместимым по параметрам с формальным параметром f типа Tf, если
1. Tf и Ta эквивалентны, или
2. f параметр-значение, а Ta совместим по присваиванию с Tf, или
3. f IN или VAR параметр, Tf и Ta записевые типы, и Ta потомок типа Tf.
Совместимость по выражению [Expression compatible]
Для некоторой операции типы ее операндов совместимы по выражению, если они подчиняются правилам, суммированным в следующей таблице. Первая подходящая строка дает правильный тип результата. Тип T1 должен быть расширением типа T0:
операция первый операнд второй операнд тип результата
+ - * DIV MOD <= INTEGER <= INTEGER INTEGER
целый тип целый тип LONGINT
/ целый тип целый тип REAL
+ - * / <= SHORTREAL <= SHORTREAL SHORTREAL
числовой тип числовой тип REAL
SET SET SET
+ Shortstring Shortstring Shortstring
тип цепочек тип цепочек String
OR & ~ BOOLEAN BOOLEAN BOOLEAN
= # < <= > >= числовой тип числовой тип BOOLEAN
литерный тип литерный тип BOOLEAN
тип цепочек тип цепочек BOOLEAN
= # BOOLEAN BOOLEAN BOOLEAN
SET SET BOOLEAN
NIL, указательный тип NIL, указательный тип
T0 или T1 T0 или T1 BOOLEAN
процедурный тип T, NIL процедурный тип T, NIL BOOLEAN
IN целый тип SET BOOLEAN
IS T0 тип T1 BOOLEAN
Константные выражения вычисляются при компиляции с максимальной точностью (LONGINT для целых типов, REAL для вещественных типов) и результат трактуется как буквальный <т.е. заданный непосредственно своим изображением> численный параметр с тем же значением.
Приложение B: Синтаксис Компонентного Паскаля
Module = MODULE ident ; [ImportList] DeclSeq
Џ<модуль> [BEGIN StatementSeq]
[CLOSE StatementSeq] END ident ..
ImportList = IMPORT [ident :=] ident {, [ident :=] ident} ;.
Џ<список импорта>
DeclSeq = { CONST {ConstDecl ; } | TYPE {TypeDecl ;} |
Џ<последовательность описаний> VAR {VarDecl ;}} {ProcDecl ; | ForwardDecl ;}.
ConstDecl = IdentDef = ConstExpr.
Џ<описание константы>
TypeDecl = IdentDef = Type.
Џ<описание типа>
VarDecl = IdentList : Type.
Џ<описание переменной>
ProcDecl = PROCEDURE [Receiver] IdentDef [FormalPars] MethAttributes
Џ<описание процедуры> [; DeclSeq [BEGIN StatementSeq] END ident].
MethAttributes = [, NEW] [, (ABSTRACT | EMPTY | EXTENSIBLE)].
Џ<атрибуты методов>
ForwardDecl = PROCEDURE ^ [Receiver] IdentDef [FormalPars] MethAttributes.
Џ<упреждающее описание>
FormalPars = ( [FPSection {; FPSection}] ) [: Type].
Џ<формальные параметры>
FPSection = [VAR | IN | OUT] ident {, ident} : Type.
Џ<раздел формальных параметров>
Receiver = ( [VAR | IN] ident : ident ).
Џ<принимающий параметр>
Type = Qualident
Џ<тип> | ARRAY [ConstExpr {, ConstExpr}] OF Type
| [ABSTRACT | EXTENSIBLE | LIMITED]
RECORD [(Qualident)] FieldList {; FieldList} END
| POINTER TO Type
| PROCEDURE [FormalPars].
FieldList = [IdentList : Type].
Џ<список полей>
StatementSeq = Statement {; Statement}.
Џ<операторная последовательность>
Statement = [ Designator := Expr
Џ<оператор> | Designator [( [ExprList] )]
| IF Expr THEN StatementSeq
{ELSIF Expr THEN StatementSeq}
[ELSE StatementSeq] END
| CASE Expr OF Case {| Case}
[ELSE StatementSeq] END
| WHILE Expr DO StatementSeq END
| REPEAT StatementSeq UNTIL Expr
| FOR ident := Expr TO Expr [BY ConstExpr]
DO StatementSeq END
| LOOP StatementSeq END
| WITH [ Guard DO StatementSeq ]
{| [ Guard DO StatementSeq ] }
[ELSE StatementSeq] END
| EXIT
| RETURN [Expr]
].
Case = [CaseLabels {, CaseLabels} : StatementSeq].
Џ<вариант выбора>
CaseLabels = ConstExpr [.. ConstExpr].
Џ<метки выбора>
Guard = Qualident : Qualident.
Џ<охрана>
ConstExpr = Expr.
Џ<константное выражение>
Expr = SimpleExpr [Relation SimpleExpr].
Џ<выражение>
SimpleExpr = [+ | -] Term {AddOp Term}.
Џ<простое выражение>
Term = Factor {MulOp Factor}.
Џ<слагаемое>
Factor = Designator | number | character | string | NIL | Set |
Џ<сомножитель> ( Expr ) | ~ Factor.
Set = { [Element {, Element}] }.
Џ<множество>
Element = Expr [.. Expr].
Relation = = | # | < | <= | > | >= | IN | IS.
Џ<отношение>
AddOp = + | - | OR.
Џ<аддитивная операция>
MulOp = * | / | DIV | MOD | &.
Џ<мультипликативная операция>
Designator = Qualident {. ident | [ ExprList ] | ^ | ( Qualident )
Џ<составное имя> | ( [ExprList] )} [ $ ].
ExprList = Expr {, Expr}.
Џ<список выражений>
IdentList = IdentDef {, IdentDef}.
Џ<список идентификаторов>
Qualident = [ident .] ident.
Џ<уточненный идентификатор>
IdentDef = ident [* | -].
Џ<определение идентификатора>
ПриложениеC:Диапазоны значений [domains]элементарных типов
Тип Диапазон значений
BOOLEAN FALSE, TRUE
SHORTCHAR 0X .. 0FFX
CHAR 0X .. 0FFFFX
BYTE -128 .. 127
SHORTINT -32768 .. 32767
INTEGER -2147483648 .. 2147483647
LONGINT -9223372036854775808 .. 9223372036854775807
SHORTREAL -3.4E38 .. 3.4E38, INF (32-битный формат IEEE)
REAL -1.8E308 .. 1.8E308, INF (64-битный формат IEEE)
SET подмножество из 0 .. 31
ПриложениеD: Обязательные требования к среде выполнения
Определение Компонентного Паскаля опирается на три фундаментальных предположения.
1)ЏВо время исполнения программ доступна информация, позволяющая проверять динамический тип объекта. Это нужно для реализации проверок типов и охраны типов.
2)ЏОтсутствует процедура DISPOSE <освобождение памяти, занятой более не используемыми объектами>. Память не может быть освобождена по явной инструкции программиста, поскольку это создало бы проблемы безопасности, связанные с утечками памяти [memory leaks] и с висячими указателями [dangling pointers]. За исключением таких встроенных систем, где не используется динамическое управление памятью, или где ее можно разместить только однажды и никогда не нужно освобождать, требуется автоматический сбор мусора.
3)ЏМодули и по крайней мере их экспортированные процедуры (команды) и экспортированные типы должны быть доступны динамически. В случае необходимости это может вызывать загрузку модулей. Программный интерфейс, используемый для загрузки модулей или для доступа к указанной мета-информации, не определяется языком, но компилятор должен сохранять эту информацию при генерации кода.
За исключением полностью слинкованных приложений, в которых при исполнения не нужно загружать никакие модули, для модулей требуется динамический загрузчик. Встроенные системы являются важными примерами приложений, которые могут быть полностью слинкованы.
Реализация, которая не удовлетворяет этим требованиям к компилятору и среде выполнения, не считается удовлетворяющей определению Компонентного Паскаля. | Docu/ru/CP-Lang.odc |
Что нового в Компонентном Паскале?
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-10-05
За несколькими небольшими исключениями, Компонентный Паскаль является надмножеством языка Оберон2. По сравнению с Обероном-2, в нем сделаны несколько уточнений и усовершенствований, которые и перечислены в данном тексте. Некоторые из отличий были реализованы уже в предыдущих версиях системы Блэкбокс (BlackBox Component Framework), и все они реализованы в версии 1.3 и более поздних.
Пересмотр языка был вызван опытом разработки системы Блэкбокс и стремлением улучшить поддержку спецификации, документирования, разработки, экплуатации и реструктуризации компонентных каркасов. Цель состояла в том, чтобы дать архитектору каркаса средства для более полного контроля внутренней самосогласованности больших компонентных систем. Контроль внутренней самосогласованности системы ключ к увеличению надежности, сокращению эксплуатационных издержек и большей уверенности в правильности развивающейся системы.
Обращалось внимание на то, чтобы язык оставался маленьким, простым для использования и изучения. Новые возможности будут замечены прежде всего проектировщиками каркасов, в меньшей степени теми, кто наращивает или расширяет каркас, и еще менее программистами, просто использующими каркас. Это гарантирует, что различные категории разработчиков не будут грузиться тем, чего их задачи реально не требуют.
Более выразительная система типов
Ковариантные значения функций, возвращающих указатели
Функции, cвязанные с типами и возвращающие указатель, могут быть переопределены таким образом, чтобы возвращать переопределенный тип. Например, функция
PROCEDURE (v: View) ThisModel (): Model
может быть переопределена в подтипе MyView, наследующем типу View, со следующей сигнатурой
PROCEDURE (v: MyView) ThisModel (): MyModel
где MyModel является подтипом Model. Заметим, что ковариантные функции являются безопасными с точки зрения строгой типизации; они просто усиливают постусловие функции, что всегда допустимо. Это позволяет сделать объявления типов более точными.
Совместимость указателей
Правила совместимости для указателей были ослаблены и упрощены. Теперь указатели совместимы по структуре; то есть два указательных типа, имеющих общий базовый тип, являются совместимыми. Это может быть полезно в основном в сигнатурах процедур, где раньше было невозможно использовать функции, подобные следующей:
PROCEDURE P (p: POINTER TO ARRAY OF INTEGER)
Указательные значения функций
В типе значения, возвращаемого функцией, теперь может стоять описание типа, а не просто идентификатор. Например, теперь допустимо писать:
PROCEDURE Bla (): POINTER TO Rec
и из-за упрощенных правил совместимости (см. предыдущий пункт) их использование может быть реально полезным.
IN и OUT
Эти режимы передачи параметров подобны режиму VAR, за исключением некоторых ограничений. IN-параметры не могут быть напрямую изменены в процедуре, параметры OUT считаются неопределенными при входе в процедуру (за исключением указателей и процедурных переменных, которые устанавливаются в NIL перед входом в процедуру). Дла записевых OUT-параметров, типы формальных и фактических параметров должны совпадать.
Такие режимы передачи параметров важны для сигнатур процедур распределенных объектов, и они могут способствовать увеличению удобства и эффективности. Но важнее всего то, что они позволяют делать объявления интерфейсов более точными и самодокументированными. В частности, там, где VAR-параметры ранее использовались только в целях эффективности, теперь можно использовать IN-ппараметры. IN-параметры допускаются только для записевых и массивовых типов.
Пример:
PROCEDURE ShowModes (value: INTEGER; VAR inout: INTEGER;
(* параметры по значению и по ссылке *)
IN in: ARRAY OF SET;
(* IN для быстродействия *)
OUT res: INTEGER): INTEGER;
(* OUT параметр и значение функции *)
Поскольку IN и OUT являются конкретизациями VAR, через IN-параметры нельзя передавать константы. Есть только одно исключение: явные цепочки литер можно передавать через параметры, описанные как открытые IN-массивы, поскольку такие цепочки в любом случае реализованы компилятором как переменные только для чтения.
Новые методы (атрибут NEW)
Компонетный Паскаль требует, чтобы введение нового метода отмечалось явно. Для этого к сигнатуре метода добавляется атрибут NEW. В переопределяемых методах указывать NEW нельзя. В следующем примере метод SomeMethod заново введен в T и унаследован типом T1, который является расширением T:
PROCEDURE (t: T) SomeMethod (x, y: INTEGER), NEW;
BEGIN
...
END SomeMethod;
PROCEDURE (t: T1) SomeMethod (x, y: INTEGER);
BEGIN
...
END SomeMethod;
NEW показывает, что метод новый и не является переопределением. Требование явно помечать новые методы оказывается полезным при изменениях в каркасе, что часто происходит как на начальных итерациях разработки проекта, так и позже, когда архитектура ПО подвергается переработке. NEW позволяет компилятору отследить, например, чтобы при изменении имени базового метода переопределяющие методы тоже были переименованы. Кроме того, при введении нового метода компилятор может проверить, нет ли его уже в базовом типе. Эти проверки облегчают сохранение согласованности между компонентами после изменений в интерфейсах каркаса.
Записевые типы по умолчанию и с атрибутами EXTENSIBLE, ABSTRACT и LIMITED
Компонентный Паскаль использует единственное средство для обозначения как интерфейсов объектов, так и их реализаций записевые типы. Эта унификация позволяет зафиксировать одни аспекты реализации интерфейса, оставляя открытыми другие. Такая гибкость часто желательна в сложных каркасах. Но такие архитектурные решения важно выражать как можно точнее, так как они могут повлиять на большое число клиентов.
В этих целях записевый тип в Компонентном Паскале может иметь атрибуты, которые позволяют проектировщику интерфейса явно сформулировать несколько фундаментальных архитектурных решений. Важно, что компилятор может проверить соответствие этим решениям. Такими тщательно подобранными атрибутами являются EXTENSIBLE, ABSTRACT и LIMITED. Они позволяют различать четыре разные комбинации возможностей расширения и размещения [allocation]:
атрибут расширение размещение присваивание записей
отсутствует (FINAL) нет да да
EXTENSIBLE да да нет
ABSTRACT да нет нет
LIMITED нет* нет* нет
*за исключением определяющего модуля
Записевые типы могут быть либо расширяемыми, либо не расширяемыми (конечными). По умолчанию, записевый тип является конечным. Конечные типы позволяют закрыть тип, так что проектировщик может исчерпывающим образом проанализировать реализацию типа, например, чтобы усовершенствовать ее, не нарушив работу клиентов.
Записевые типы могут допускать размещение (статических и динамических переменных), либо размещение может быть запрещено (ABSTRACT) или ограничено определяющим модулем (LIMITED). Другими словами, размещение и расширение типов с атрибутом LIMITED возможно только в том модуле, где они определяются, но не в импортирующем модуле.
Конечные типы обычно являются простыми, вспомогательными типами данных, например:
Point = RECORD
x, y: INTEGER
END
Переменные таких типов могут копироваться операторами присваивания, например, pt := pt2. Компилятору никогда не нужно генерировать скрытую проверку типа, которая иногда необходима для такого присваивания в Обероне.
С другой стороны, расширяемые записи не могут ни копироваться, ни передаваться по значению (так как параметры, передаваемые по значению, требуют присваивания записей).
Конечные типы, подобно расширяемым типам, могут быть расширениями других типов записей и могут иметь методы.
Расширяемые типы объявляются следующим образом:
Frame = EXTENSIBLE RECORD
l-, t-, r-, b-: INTEGER
END
Простые типы с атрибутом EXTENSIBLE используются редко, вместо них чаще используют типы с атрибутом ABSTRACT, которые являются частным случаем расширяемых типов и не допускают размещение соответствующих переменных. В следующем абзаце дается более точное описание смысла данного ограничения.
Типы значений никогда не могут быть абстрактными, но типы переменных могут быть абстрактными. Тип значения может отличаться от типа содержащей его переменной, только если переменная ссылочная, то есть является указателем, VAR, IN или OUT параметром. Следовательно, только такие переменные могут иметь абстрактный тип. Во всех других случаях, например, для статических переменных, полей записей, базовых типов массивов и параметров, передаваемых по значению, должны быть использованы неабстрактные типы либо указатели (возможно, на абстрактные типы). Так как операция NEW порождает значение типа аргумента, NEW может использоваться только для переменных неабстрактного типа.
Пример абстрактного типа:
TextView = POINTER TO ABSTRACT RECORD (Views.View) END
Абстрактные типы средство проектирования, они описывают интерфейсы объектов. Они являются основным средством моделирования интерфейсов компонентов в Компонентном Паскале. Определение записей с атрибутом ABSTRACT позволяет точнее указать использование записи как интерфейсной конструкции в отличие от реализации.
Тем не менее, абстрактный тип может иметь все виды методов (см. ниже), то есть он не обязан быть полностью абстрактным.
Ограниченные типы, определяемые с атрибутом LIMITED, особый случай конечных типов. Их особенность в том, что соответствующие записи могут размещаться только в определяющем модуле, и их нельзя копировать. Например, клиент не может выполнить NEW для переменных таких типов. Так как размещение целиком контролируется определяющим модулем, проектировщик этого модуля может гарантировать, что вновь размещаемые переменные корректно инициализируются до их передачи клиентским модулям. Это означает, что клиенты видят только переменные, удовлетворяющие инвариантам типа (которые устанавливаются при инициализации). Проектировщик волен изменить внутреннее представление с меньшим риском нарушить функционирование клиентского кода; отпадает необходимость в методах отложенной инициализации; невозможны поздние ошибки при выполнении программы из-за неверной инициализации; наконец, невозможно рарушить инварианты копированием (например, инварианты с участием скрытых полей записи).
Для создания новых экземпляров динамических ограниченных типов обычно предусматриваются фабричные функции или объекты.
Пример:
Semaphore = POINTER TO LIMITED RECORD END;
PROCEDURE New (level: INTEGER): Semaphore;
В системе Блэкбокс большинство абстракций представлено абстрактными типами, для которых даются реализации (неэкспортированными) конечными типами. Это еще один способ гарантировать корректную инициализацию, но он слишком неудобен для простых нерасширяемых абстракций. Кроме того, клиенты не могут заменить LIMITED-типы своими расширениями. Это важно, поскольку позволяет защитить нерасширяемые службы, такие как ядро реального времени, от использования с недопустимыми типами.
Синтаксис записей
Синтаксис записей выглядит следующим образом:
RecordType = [EXTENSIBLE | ABSTRACT | LIMITED]
RECORD ["(" QualIdent ")"] FieldList {";" FieldList} END.
Заметим, что программисту чисто клиентских приложений никогда не потребуется писать эти атрибуты. То же самое касается проектировщиков расширений каркаса. Но проектировщик каркаса может сэкономить усилия благодаря их использованию, поскольку эти атрибуты представляют собой важную часть документации, которую можно извлечь из исходного кода автоматически.
Целью введения этих атрибутов было увеличить статическую выразительность интерфейсов, чтобы нужные архитектурные решения могли быть выписаны явно, причем так, чтобы компилятор мог проверить соответствие клиентской реализации интерфейсному контракту. В языке, предназначенном только для реализации, нет нужды в этих новых атрибутах, и только язык для компонентно-ориентированной реализации и проектирования нуждается в выразительных средствах для подобных проектных ограничений. Контроль таких ограничений позволяет проектировщику каркаса ввести важные инварианты, касающиеся всей программной системы (= системной архитектуры), повышая таким образом безопасность, сопровождаемость и развиваемость.
Некоторые из новых атрибутов также повышают удобство; например, абстрактным методам не нужно тело процедуры. Такое дополнительное удобство приветствуется, но само по себе не могло быть весомой причиной для введения описанных атрибутов.
Стандартные и расширяемые методы (без атрибутов и атрибут EXTENSIBLE)
Подобно записевым типам, методы этих типов тоже могут иметь атрибуты. Допустимы вариант по умолчанию (без атрибута), EXTENSIBLE (расширяемый), ABSTRACT (абстрактный) и EMPTY (пустой).
Как и для записевых типов, методы по умолчанию являются конечными:
PROCEDURE (t: T) StaticProcedure (x, y: INTEGER), NEW;
BEGIN
...
END StaticProcedure;
Методы, которые одновременно новые и конечные, могут трактоваться компилятором как обычные процедуры, так как они не требуют позднего связывания. Тем не менее, их использование может быть уместным, если они с очевидностью принадлежат конкретному типу.
С другой стороны, расширяемые (переопределяемые) методы должны помечаться как таковые, например:
PROCEDURE (t: T) Method (x, y: INTEGER), NEW, EXTENSIBLE;
BEGIN
...
END Method;
Гораздо чаще используются астрактные или пустые методы, которые являются частными случаями расширяемых методов (см. ниже).
Метод объявляется конечным простым отбрасыванием атрибута EXTENSIBLE:
PROCEDURE (t: T) FinalInheritedMethod (x, y: INTEGER);
BEGIN
...
END FinalInheritedMethod;
Если проектировать каркас в стиле черного ящика, то большинство методов, которые нужно будет реализовывать при расширении каркаса, будут иметь вышеуказанный тип, когда никаких специальных атрибутов в сигнатуре метода не требуется. Это разумно, потому что больше программистов занимаются расширением каркасов, нежели их проектированием, следовательно, писать расширения должно быть как можно удобней.
Конечные методы могут быть привязаны к любому типу записей. Расширяемые методы могут быть привязаны только к расширяемым типам (т.е. EXTENSIBLE или ABSTRACT).
Поскольку конечные методы не могут быть переопределены, то инварианты, которые они гарантируют, и постусловия, которые они устанавливают, не могут быть нарушены. Заметим, что корректное расширение метода подразумевает, что расширяющий метод является в некотором смысле усовершенствованным вариантом расширяемого. Семантически это значит, что расширяющий метод может принимать более слабые предусловия или устанавливает более сильные постусловия по сравнению с расширяемым методом.
Абстрактные методы (атрибут ABSTRACT)
Абстрактный метод объявляется следующим образом:
PROCEDURE (t: T) SomeMethod (s: SET), NEW, ABSTRACT;
PROCEDURE (t: T) CovariantMethod2 (): NarrowedType, ABSTRACT;
Абстрактные методы расширяемы (переопределяемы). Компилятор проверяет, что конкретный тип реализует все абстрактные методы, которые он унаследовал. Конкретное расширение абстрактного метода (или типа) может считаться его реализацией. Абстрактные методы не имеют тела процедуры, они существуют лишь в виде сигнатур. Поэтому больше нет необходимости писать тело процедуры с оператором HALT.
Пустые методы (атрибут EMPTY)
Метод может быть объявлен как пустой (empty). Пустые методы являются расширяемыми. Пустые методы очень похож на асбтрактные в том, что они являются заглушками для функциональности, которая может быть предоставлена в дальнейших расширениях. Однако пустые методы являются конкретными и могут вызываться. Если они не расширялись (т.е. не были реализованы), то их вызов не дает никакого эффекта.
Пустые методы представляют собой необязательные интерфейсы. Например, тип View в системе Блэкбокс имеет пустой метод для обработки сигналов от пользователя (HandleCtrlMsg). Интерактивные объекты изображения (вьюшки) реализуют этот метод, а пассивные его игнорируют.
Пустая процедура не может содержать кода. Поэтому пустой метод не имеет тела и не может быть вызван посредством супервызов.
Пустые процедуры не могут быть функциям и не могут иметь OUT-параметров.
Пример:
PROCEDURE (t: T) Broadcast (msg: Message), NEW, EMPTY;
Синтаксис методов
Синтаксис методов выглядит следующим образом:
TBProc = PROCEDURE Receiver IdentDef [FormalPars] [Attribution].
Attribution = ["," NEW] ["," (EXTENSIBLE | ABSTRACT | EMPTY)].
Заметим, что программисту чисто клиентских приложений никогда не потребуется писать эти атрибуты. То же самое касается проектировщиков расширений каркаса. Но проектировщик каркаса может сэкономить усилия благодаря их использованию, поскольку эти атрибуты представляют собой важную часть документации, которую можно извлечь из исходного кода автоматически.
Экспорт методов только для реализации
Теперь также можно экспортировать методы только для реализации, для чего используется метка экспорта - вместо *. Экспорт только для реализации означает, что метод может быть реализован вне определяющего модуля, но не может быть оттуда вызван.
Решение о том, как экспортируется метод обычным образом или только для реализации, принимается при определении метода (новый метод с атрибутом NEW). Дальнейшие расширения должны использовать тот же режим экпорта, либо вообще не экспортировать метод.
Методы, экспортированные только для реализации, вызываются из того модуля, где метод был введен; вызовы таких методов идут вверх по модульной иерархии (восходящий вызов). Для каркасов характерны такие восходящие вызовы. Экпорт только для реализации позволяет лишить клиентов каркаса возможности нарушить его инварианты, но в то же время дать им возможность предоставлять новые реализации типов каркаса.
Каждый каркас имеет два лица: интерфейс для клиентов и интерфейс для проектировщиков, так называемый интерфейс специализации. Эти два интерфейса могут частично перекрываться. Экспорт только для реализации позволяет явно пометить те части интерфейса, которые относятся только к интерфейсу специализации.
Супервызовы
Из-за так называемой семантической проблемы хрупких базовых классов рекомендуется по-возможности избегать супервызовов. Новое ПО можно проектировать так, чтобы они не требовались, отдавая предпочтение композиции перед наследованием реализации. Супервызовы считаются устаревшим средством. Для обратной совместимости они временно сохранены. В перспективе поддержка супервызовов может быть уменьшена.
Процедурные типы
Процедурные типы обладают меньшей гибкостью, чем объекты с методами. Даже в обычных примерах использования процедурных типов в ПО для числовых расчетов можно получить выигрыш, моделируя их посредством объектов. Объекты расширяемы, а процедурные типы нет. Процедурные типы могут создавать значительные трудности для безопасной выгрузки модулей. Пока что они сохранены для обратной совместимости, а также для реализации низкоуровневого интерфейсного кода (обратные вызовы, callbacks). В перспективе поддержка процедурных типов может быть уменьшена.
ANYREC и ANYPTR
Каждая базовая запись считается расширением нового стандартного абстрактного типа ANYREC, даже если она объявлена без указания базового типа. ANYREC это пустая запись, которая является кореннем всей иерархии записей. ANYPTR это новый стандартный тип, который соотвествует конструкции POINTER TO ANYREC.
Эти новые типы облегчают взаимодействие между независимо разрабатываемыми каркасами, давая возможность использовать параметры без какой-либо информации об их типах.
Подразумеваются следующие псевдоопределения:
ANYREC = ABSTRACT RECORD END;
ANYPTR = POINTER TO ANYREC;
PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;
Процедура FINALIZE пустая. Она может быть реализована для расширений указательных типов. Процедура вызывается в неопределенный момент времени после того, как объект становится недоступным через другие указатели (не имеет глобального якоря), и перед тем, как объект уничтожается. Методы FINALIZE необходимы для освобождения ресурсов, которые не являются объектами непосредственно Компонентного Паскаля; например, селекторов файлов, дескрипторов шрифтов, указателей на окна операционной системы и т.п.
Порядок финализации неопределен. Объект финализируется только один раз.
Поддержка литерных цепочек (strings)
Явные цепочечные типы (string types)
Можно различать цепочечное значение (конкретные литеры) и переменную, в которой это значение содержится (массив литер). Некоторые операции в Компонентном Паскале производятся над цепочечными значениями (например, сравнение на равенство), другие над переменной (например, присваивание). Компилятор может автоматически определять, какая интерпретация нужна в каждой конкретной ситуации. К сожалению, есть ситуации, когда допустимы обе интерпретации. Например, подстановка цепочки литер на место параметра, передаваемого по значению (который тоже является массивом литер) должна интерпретироваться как присваивание. Но часто более эффективно копировать только цепочечное значение, а не весь массив. Это имеет место, например, при передаче имени пути для системы Unix, объявляемого как литерный массив из 2048 элементов, но обычно реально содержащего только несколько литер.
В Компонентном Паскале можно явно указать, что имеется в виду цепочечное значение, а не переменная-массив. Для этого служит оператор $; например:
OpenFile(pathname$)
где OpenFile объявлена как
PROCEDURE OpenFile (name: ARRAY 2048 CHAR)
Дополнительная выгода здесь в том, что теперь более привлекательно объявлять параметры как массивы литер с фиксированным числом элементов, как в предыдущем примере. В Обероне это неудобно, так как тип фактического параметра часто не совместим с формальным. Так как цепочечные значения всегда совместимы с массивами литер, эта проблема исчезает в Компонентном Паскале. Это важно, поскольку указание фиксированного размера для массива точнее передает смысл, если известно, что длина возможных значений ограничена. Заметим, что объявление открытого массива означало бы согласие принимать массив любой длины (так что при выполении программы никогда не может возникнуть ошибка выхода за границу диапазона!).
Конкатенация цепочек
Оператор + теперь позволяет выполнять конкатенацию цепочек. Целевая переменная должна быть достаточной длины, чтобы вместить цепочку-результат.
Отсутствие COPY
Вспомогательная процедура COPY теперь не нужна, так как оператор $ делает ее лишней. Например,
COPY(a, varpar) заменяется на varpar := a$
Фиксированные диапазоны значений типов
Чтобы добиться полностью переносимого кода, необходимо полностью задать диапазоны значений для всех элементарных типов. Элементарные типы Компонентного Паскаля составляют надмножество для элементарных типов Java.
Тип Размер Область значений
SHORTCHAR 1 byte набор литер Latin-1
(первая страница Unicode и надмножество ASCII)
CHAR 2 byte набор литер Unicode
BYTE 1 byte целое со знаком
SHORTINT 2 byte целое со знаком
INTEGER 4 byte целое со знаком
LONGINT 8 byte целое со знаком
SHORTREAL 32 bit IEEE
REAL 64 bit IEEE
SET 4 byte набор бит
BOOLEAN 1 byte FALSE или TRUE
Тип LONGREAL был исключен. Специальные длинные константы с плавающей точкой были исключены; например, следует использовать 1.0E2 вместо 1.0D2. Идентификатор LONGREAL зарезервирован для возможного использования в будущем. Вещественные константы всегда представляют значения типа REAL (64-бит).
Шестнадцатеричные константы теперь могут быть заданы либо как 4-байтовые (например, 0FFFFFFFFH), либо как 8-байтовые константы (например, 0FFFFFFFFFFFFFFFFL). Это позволяет отличать отрицательные шестнадцатеричные константы типа INTEGER от положительных констант типа LONGINT. Например, 0FFFFFFFF обозначает -1, когда интерпретируется как INTEGER, но 4294967295, когда интерпретируется как LONGINT.
Целочисленные константы всегда представляют значения типа INTEGER (4 байт). Присваивание целочисленной константы меньшему типу (например, BYTE) допустимо, если константа лежит в диапазоне значений целевого типа. Целые константы других типов могут быть созданы только с использованием SHORT или LONG, но достаточно большие константы автоматически получают тип LONGINT.
Целая арифметика теперь всегда выполняется с 32-битной точностью, кроме выражений с участием значений типа LONGINT. В последнем случае используется 64-битная точность. Это правило уменьшает вероятность труднообнаружимых переполнений в промежуточных результатах, если последние вычисляются с недостаточной точность.
Арифметика с плавающей точкой всегда выполняется с 64-битной точностью.
Прочее
Семантика DIV уточнена определением результата деления на отрицательные числа.
Введено новое вещественное значение INF для бесконечности. Это значение может порождаться, например, при вещественном делении на нуль. Значение бесконечность для чисел с плавающей точкой определено стандартом IEEE для чисел с плавающей точкой.
Более полно определено, когда подразумевается разыменование указателя. Например, это теперь возможно при передаче указательной переменной формальному параметру записевого типа.
Записевые типы можно объявлять как расширения других типов записей, указывая в качестве базового типа указательный тип (вместо записевого). Это делает излишним явное именование записевого типа, если переменные этого типа используются только через указатели.
В пределах одной области видимости имена любых типов могут использоваться до их объявления. Старые опережающие объявления указателей, вроде T = POINTER TO TDesc, по-прежнему допустимы как простой частный случай нового правила, но они больше не являются необходимыми.
BITS новая стандартная функция; она преобразует значения INTEGER в значения SET, так что BITS(1) дает {0}. Это позволяет, например, писать лучше переносимые драйверы устройств, так как результаты вычислений здесь не зависят от порядка бит процессора (который отличается, например, для 68k и PowerPC).
ORD теперь может также применяться к значениям SET (операция, обратная к BITS).
MIN и MAX теперь могут также принимать два параметра; например, real0 := MAX(someInt, real1). Они выбирают минимальное/максимальное значение их двух указанных, которые должны иметь числовой тип.
LEN может также быть применима к цепочкам литер. LEN(chararray) возвращает длину переменной-массива chararray, в то время как LEN(chararray$) возвращает длину значения-цепочки литер. Заметим, что литерный массив должен иметь хотя бы на один элемент больше, чем число литер в цепочечном значении, чтобы вместить завершающую литеру 0X.
Обозначения переменных (designators) теперь обобщены для поддержки разыменований и т.п. в результатах функций. Например, теперь допустим следующий код:
length := view.ThisModel()(TextModels.Model).Length() или
view.Context().GetSize(w, h)
Такое расширение синтаксических возможностей для обозначения переменных облегчает использование методов вместо полей записей. Методы обеспечивают большую гибкость, чем поля записей, и упрощают реализацию оберток (передачу вызовов методов обернутым объектам (forwarding)).
Глобальные переменные, включая динамические, размещаемые посредством NEW, теперь имеют определенное начальное значение (FALSE, 0X, 0, 0.0, {}, NIL, ""). Локальные (то есть стековые) переменные не инициализируются, за исключением указателей и процедурных переменных, которые устанавливаются в NIL из соображений безопасности.
Приложение к Сообщению о языке определяет минимальные требования к среде, которым должна удовлетворять любая реализация Компонентного Паскаля. В частности, команды, динамическая загрузка и сборщик мусора являются основополагающими требованиями для компонентно-ориентированных систем. Как и для всех динамических языков, это приложение является признанием того, что язык не может рассматриваться совершенно независимо от своей среды. Объектная модель, независимо от того, включается ли она в определение языка или используется как внешний сервис, всегда является частью среды.
Для упрощения взаимодействия с существующими библиотеками, написанными на языке C, в идентификаторах допускается литера подчеркивание.
Правила для меток экспорта были упрощены по сравнению с Обероном: расширяющей (переопределяющий) метод может иметь только такую же метку экспорта, что и расширяемый метод. Единственное исключение метод, связанный с неэкспортируемой записью; в этом случае он не может быть экспортирован.
Модуль теперь имеет необязательную секцию CLOSE, после секции BEGIN. Секция CLOSE вызывается перед выгрузкой модуля. Секция BEGIN модуля вызывается после выполнения секций BEGIN всех импортированных модулей. Секция CLOSE должна выполняться только после выполнения секций CLOSE всех импортированных модулей.
Подводя итог, подчеркнем, что новое определение языка содержит одно значительное добавление: более выразительное подмножество языка определения интерфейса (IDL) (NEW; EXTENSIBLE; ABSTRACT; LIMITED; EMPTY; экспорт методов только для реализации), что дает возможность указывать архитектурные свойства компонентного каркаса.
Другие пункты это, в основном, уточнение деталей, опирающееся на десятилетний опыт использования языка. Особого внимания заслуживают новая, более общая и систематическая трактовка литерных цепочек, а также новая спецификация размеров элементарных типов.
Благодарности
Я хотел бы поблагодарить своих коллег по компании Oberon microsystems Бета Хеба, Доминика Грунца, Маттиаса Хаузнера и Даниеля Диеса (Beat Heeb, Dominik Gruntz, Matthias Hausner, and Daniel Diez) за их ценный вклад в эту работу. В частности, без усилий Бета (Beat Heeb) этот проект был бы невозможен. Самые важные предложения извне были получены от Клеменса Шиперского, Технологический университет г. Квинсленд, Австралия (Clemens Szyperski, Queensland University of Technology, Australia) и Вольфганга Века из Академии Эбо, Финляндия (Wolfgang Weck, Еbo Akademi, Finland). Наконец, я хотел бы поблагодарить профессора Никлауса Вирта (Niklaus Wirth) за комментарии по первому варианту Сообщения о языке Компонентный Паскаль, а также за то, он заложил такой замечательный фундамент для нашей работы.
| Docu/ru/CP-New.odc |
Соглашения по документации
ENGLISH
Редакция перевода: Ф.В.Ткачев, 2009-10-17; 2012-11-27
Документация преследует две главные цели: сообщить, как могут быть интерактивно использованы возможности программы (руководство пользователя) и как возможности программы могут быть использованы программно (руководство разработчика).
В системе Блэкбокс обслуживающие программы оформлены в подсистемы.
Обычно подсистема состоит из нескольких модулей, возможно, взаимодействующих.
В общем случае нужны три типа документации: руководство пользователя, описание интерфейса для каждого модуля, а также обзор того, как модули могут взаимодействовать друг с другом, т.е. введение в общую архитектуру подсистемы (руководство разработчика).
Подсистемы представлены на диске как каталоги, например, каталог Text.
В этом каталоге содержится вложенный каталог под названием Docu, т.е. Text/Docu.
Этот каталог с документацией может содержать следующие текстовые документы:
* Руководство пользователя, называемое User-Man.
* Карта гиперссылок на документацию, называемая Sys-Map.
* Вводная информация для программиста под названием Dev-Man.
* По одному описанию интерфейса на каждый модуль, под именем модуля без префикса подсистемы, например: Views для модуля TextViews.
Следует отметить, что все тексты документации, не являющиеся непосредственными справочниками для программиста по конкретному модулю, должны содержать в имени дефис (-), чтобы обозреватель хранилища [repository browser] мог отличить документацию по модулям от прочих файлов документации.
Остальная часть данного текста описывает формат описания интерфейса модуля.
Каждое описание модуля начинается с определения модуля. Для описания модулей используется нотация Компонентного Паскаля, и в описании перечисляются все те и только те элементы модуля, которые экспортируются. Определение модуля начинается с ключевого слова DEFINITION вместо MODULE, метки экспорта опускаются (за исключением метки только для чтения); также опускаются тела процедур и тело модуля. Методы показываются в объявления соответствующей записи без ключевого слова PROCEDURE.
Примером служит гипотетический модуль Dictionaries
DEFINITION Dictionaries;
CONST maxElems = 32;
TYPE
Dictionary = POINTER TO LIMITED RECORD
elems-: INTEGER;
(d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER), NEW;
(d: Dictionary) Get (key: INTEGER; OUT string: ARRAY OF CHAR), NEW
END;
VAR someDict: Dictionary;
PROCEDURE Init;
END Dictionaries.
В расширенной записи не указаны унаследованные процедуры, только новые процедуры или процедуры с измененными сигнатурами или уточненными спецификациями семантики. Изменение сигнатуры может быть вызвано ковариантным результатом функции, т.е. если процедура возвращает указатель на расширение типа, возвращаемого базовой процедурой. Или это может быть вызвано изменением атрибутов метода (конечный, ABSTRACT, EMPTY, EXTENSIBLE), например, мог быть реализован и сделан конечным абстрактный метод.
За описанием модуля следует краткое описание абстракций, предоставляемых модулем.
Модуль предоставляет некий конкретный тип Dictionary для работы со словарями цепочек литер.
Затем следует список констант без их значений.
CONST maxElems
Максимальное число элементов словаря.
Затем следуют типы модуля:
TYPE Dictionary
LIMITED
Управляет словарем литерных цепочек с целочисленным ключом.
Атрибуты записи приводятся во второй строке, как показано выше. Атрибуты записи могут отсутствовать (запись является конечной по умолчанию) или быть EXTENSIBLE, ABSTRACT или LIMITED.
Если тип является расширением другого типа, то это показывается следующим образом:
Dictionary (OtherModule.Dictionary).
Затем перечисляются поля записи:
elems-: INTEGER 0 <= elems <= maxElems
Текущее количество элементов в словаре.
Как и в вышеприведенном примере, может также быть приведен инвариант для значений полей записи.
Затем приводятся процедуры, связанные с данным типом:
PROCEDURE (d: Dictionary) Put (string: ARRAY OF CHAR; OUT key: INTEGER)
NEW
Для каждого метода уточняется, является ли процедура конечной (final, по умолчанию), расширяемой (extensible), абстрактной (abstract) или пустой (empty).
Абстрактные процедуры не должны вызываться.
Пустые процедуры не должны вызываться в расширяющей их процедуре (т.е. посредством супервызова в реализации процедуры).
Во второй строке даются атрибуты метода, которые могут либо отсутствовать (метод является конечным по умолчанию), либо один из EXTENSIBLE, ABSTRACT или EMPTY. Для вновь вводимых методов перед этим атрибутом указывается NEW.
Методы, экспортируемые только для реализации (implement-only), могут быть вызваны только внутри своего определяющего модуля. Этот модуль может, таким образом, обеспечить предусловия для метода перед каждым его вызовом, поскольку все такие вызовы происходят в этом модуле. При корректной реализации эти предусловия никогда не могут нарушиться, так как другие модули не могут вызвать метод. Это позволяет проектировщику расширений предполагать, что предусловия выполнены, и проверять их нет необходимости. Поэтому предусловиям в методах, экспортированных только для реализации, не приписываются номера ошибок, вместо этого они помечаются как гарантированные, то есть описываемый модуль ручается за них.
Затем следует разъяснение действий процедуры:
Поместить цепочку в словарь d и получить в ответ key. Если цепочка уже есть в словаре, то возвращается тот же ключ, который был возвращен при первой вставке. Если строки еще нет в словаре, то она туда вставляется и возвращается еще не занятое значение ключа.
После разъяснений простым текстом могут быть указаны некоторые предусловия для процедуры. Эти предусловия приводятся в полуформальной нотации:
Pre
20 string # ''
Это означает, что если предусловие нарушается (т.е. string = ''), то выполняемая в данный момент команда прерывается с номером исключения 20. Вместо номера могут также быть указаны следующие сообщения:
invalid index
type guard check
Поэтому второе предусловие могло бы быть таким:
invalid index string in d or d.elems < maxElems
В более старых частях документации номера предусловий могут быть даны после выражения, а не перед ним. Со временем вся документация должна быть приведена к одному новому, более удобочитаемому стилю.
После предусловий могут быть указаны некоторые постусловия:
Post
string in d'
old key returned
~(string in d')
string in d
d.elems = d.elems' + 1
new key returned
Это постусловие содержит два случая, а именно, что происходит, когда цепочка уже содержится в d, и что присходит, если цепочки в d еще нет. Текст условий выровнен по левому краю, а соответствующие результаты сдвинуты вправо на один отступ. Иногда могут быть использованы вложенные условия с дальнейшим отступом.
Для ссылки на значения перед выполнением процедуры к выражению добавляется апостроф, если это нужно для ясности (т.е. если значение вообще может измениться). Так, выражение
d.elems = d.elems' + 1
означает, что значение d.elems увеличилось на единицу.
В общем, для подобных выражений используется синтаксис Компонентного Паскаля, но допускаются послабления, например, могут использоваться простые вспомогательные процедуры, в дальнейшем не описываемые.
Результаты функций в общем случае называются result.
Объем формализма остается небольшим. Делается попытка ограничить формальные спецификации несколькими простыми условиями или объяснением особо тонких случаев. Не ставится цель дать полное формальное определение семантики библиотеки, поэтому формализм не может полностью заменить разъяснения, сделанные обычным текстом, примеры или графические иллюстрации.
Тем не менее, представляется, что проверки прежде всего предусловий часто оказываются полезными даже в таком неполном и полуформальном виде, как для целей документирования, так и для отладки.
PROCEDURE (d: Dictionsry) Get (key: INTEGER; OUT string: ARRAY OF CHAR)
NEW
Извлекает литерную цепочку из словаря по ключу key. Если значение не найдено параметру string присваивается пустое значение.
Post
key in d
return corresponding string
~(key in d)
return ""
Процедуры, унаследованные при расширении типа, обычно здесь не приводятся. Исключение составляют процедуры, изменившие свою семантику. Изменения семантики ограничены ослаблением предусловий или усилением постусловий.
После всех типов перечисляются глобальные переменные:
VAR someDict: Dictionary someDict # NIL
Эта переменная содержит словарь.
Указанный необязательный инвариант устанавливается в теле модуля.
Наконец, перечисляются процедуры, экспортируемые модулем:
PROCEDURE Init (d: Dictionary)
Инициализирует словарь. Любой словарь может быть размещен только один раз
Pre
20 d not yet inicialized
В Блэкбоксе все процедуры, чьи имена начинаются с Init, могут быть вызваны для объекта только один раз. | Docu/ru/Docu.ru.BB-Docu.odc |
Документация системы Блэкбокс (BlackBox Component Builder)
ENGLISH (c) Перевод на русский язык:
ООО ОЦПИ "Метасистемы", 2005-2008
Информатика-21, 2005-2009
Переводчики Опереводетерминологии
Легкий старт Привет,профи! Краткийобзор Полезныесведения Путеводитель Примеры
Компонентное ПО: Компоненты BlackBox шаг за шагом Оглавление
Часть I 1Взаимодействиеспользователем
2Составныедокументы 3ШаблоныпроектированиявБлэкбоксе
Часть II 4Формы 5Тексты
Часть III 6Построениеобъектовпредставления(вьюшек)
Приложения A:КраткаяисторияПаскаля B:ОтличияКомпонентногоПаскаля
Руководства Руководства Компонентный
пользователя разработчика Паскаль Остальное
Среда Среда Сообщениеоязыке Лицензия
ПодсистемаText ПодсистемаText Чтоновоговязыке? Лицензионнаяполитика
ПодсистемаForm ПодсистемаForm Наборлитер Разработчики
ПодсистемаDev ПодсистемаDev Одокументации Особенностиплатформы
Другиекоманды ПодсистемаSql Обоформлениипрограмм
| Docu/ru/Help.odc |
О создателях системы Блэкбокс из компании Oberon microsystems, Inc.
Система Блэкбокс (BlackBox Component Builder) построен на фундаменте, который заложили в университете ETH, Цюрих, профессора Никлаус Вирт (Niklaus Wirth) и Юрг Гуткнехт (Jьrg Gutknecht) (система и язык Оберон), Ханспетер Мёссенбёк (Hanspeter Mцssenbцck) (расширения языка, приведшие к Оберон-2) и несколько бывших ассистентов, в том числе Режи Крелье (Rйgis Crelier), Йозеф Темпл (Josef Templ) и Штефан Лудвиг (Stefan Ludwig).
В компании Оберон майкросистемз (Oberon microsystems), в разработке Блэкбокса принимали участие следующие (возможно, бывшие) сотрудники:
- Беат Хеб (Beat Heeb)
- Куно Пфистер (Cuno Pfister)
- Клеменс Шиперски (Clemens Szyperski)
- Томас Амберг (Thomas Amberg)
- Даниэль Диес (Daniel Diez)
- Кристиан Ди Джорджо (Christian Di Giorgio)
- Марк Фрай (Marc Frei)
- Доминик Грунц (Dominik Gruntz)
- Маттиас Хаузнер (Matthias Hausner)
- Штефан Кох (Stephan Koch)
- Иван Посва (Ivan Posva)
- Бенгт Рутиссон (Bengt Rutisson)
- Вольфганг Век (Wolfgang Weck)
- Юрг Вулльшлегер (Jьrg Wullschleger)
| Docu/ru/Ominc-Contributors.odc |
Пакет русскоязычной документации
BlackBox Component Builder 1.5
Версия от 19.01.2008 г., r116 (Метасистемы).
Редакция сентябрь, 2012 (проект Информатика-21).
Замечания и предложения можно
высказать на форуме http://forum.oberoncore.ru/
или послать на адрес [email protected].
Над переводом работали:
ООО ОЦПИ "Метасистемы":
И.Е. Ермаков, Е.А. Семашко, Е.Э. Темиргалеев
Институт ядерных исследований РАН:
Ф.В.Ткачев
Московский авиационный институт:
Л.Н. Чернышев, студенты Адаменко Оскар и Забелин И.С.
Томский государственный университет:
А.И. Попков, А.С. Ильин
А также:
И.Х. Хайруллин, А.В. Козлов, В.В. Лось
Комплектование и настройка пакета:
Б.В. Рюмшин (проект OberonCore)
Редактирование для проекта Инфоматика-21:
Ф.В.Ткачев | Docu/ru/RuAuthors.odc |
О переводе терминологии
Ф.В.Ткачев, 2009 ... этот документ имеер характер рабочего.
Некоторыепринципыпереводатерминологии
Модельобъектчтения/записи/отрисовки/...
Словарик
Первоначальная версия перевода документации системы Блэкбокс была выполнена усилиями свободногосообщества. Поэтому имеет место как неровное качество перевода, так и разнобой в терминологии. Ито, и другое потихоньку исправляется.
Критику окончательных решений, принятых при составлении словаря, лучше всего направлять на эту ветку форума. Или на адрес [email protected].
Предполагается, что критика взвешенно учтет аргументы, сформулированные ниже.
За ряд небанальных замечаний aвтор признателен С.Ю.Губанову, а также всем участникам вышеуказанной ветки форума.
Некоторые принципы перевода терминологии
Приводимые ниже принципы не являются попарно непротиворечивыми, и найти удачный баланс бывает трудно, но приходится пытаться.
Одни слова возбуждают смысл в голове мгновенно, рефлекторно, причем смысл этот может оказаться не совсем тот, который желателен.
Другие для своей интерпретации требуют усилия, часто неосознаваемого, о чем интуитивно знает каждый преподаватель, объясняющий смысл конструкций языка программирования, давая их сначала на родном языке:
ПОКА выполняется условие ДЕЛАТЬ список инструкций КОНЕЦ.
Общие требования: термины должны быть удобными точными, ясными, доходчивыми и по-возможности краткими.
Требование ясности и доходчивости подразумевает, при прочих равных, предпочтительность слов родного звучания и происхождения, именно такие слова возбуждают смысл в голове напрямую. (С.Ю.Губанов напомнил, что наличие родной терминологии для некоторой области деятельности отражает степень освоенности этой области; ср. старые типографские термины выключка, отбивка с какими-нибудь новыми программерскими паттернами и рефакторингом.)
Требование точности может означать нежелательность использования широко употребительных слов с ветвистым кустом значений, особенно эмоциональных или способных вызвать ошибочные ассоциации.
Требование удобства подразумевает вписанность термина в грамматическую систему языка, иначе теряется гибкость выражения и дополнительные усилия тратятся на интерпретацию текста. Для этого может понадобиться придумать новое слово (как Д.Б.Подшивалов придумал массивовый тип; см. словарик ниже), что само по себе не может служить основой отрицания.
Требование точности подразумевает разведение смыслов многозначных слов.
Удобство, с другой стороны, придает немалый дополнительный вес варианту перевода, фонетически близкому к оригиналу (глубина влияния чистой фонетики на выбор перевода видна, например, в случае термина string; см. словарик ниже).
Критерию фонетической близости удовлетворяет транскрипция.
Японская культура дает яркий пример незакомплексованной ассимиляции иноязычной терминологии в родной язык, что, впрочем, сильно облегчается нефлективной структурой японского языка.
В русской культуре тоже существует традиция, идущая от первых иностранных академиков, почти не знавших русский язык; эта традиция состоит в том, чтобы широко зачастую без особой нужды использовать транскрипции иноязычных слов (в том числе для передачи неспециальных смыслов).
С одной стороны транскрипции удобны, т.к. при этом разводятся значения (размытое бытовое и точное терминологическое).
С другой стороны, результатом нередко бывает избыточная громоздкость.
В-третьих, этим иногда откровенно злоупотребляют для надувания щек (в том числе и бессознательно, а также коллективно).
В-четвёртых, как часть этой традиции имеем боязнь показаться несерьезными-ненаучными-некультурными-отсталыми (бытовщина) из-за использовании ярких словечек родного происхождения в научно-технических текстах.
Но та же типографская отбивка доказывает ровно обратное.
Короче, традиция неоднозначная.
Несерьезные требования имеют характер вкусовщины, когда непривычность уху выставляется впереди всех остальных требований. Возьмем клик и щелк как варианты передачи click. Понятие очень узкое, специфическое, и брать для его передачи общеупотребительное и эмоционально окрашенное щелчок несколько странно.
Ведь понятия надо бы разводить, а не грузить общеупотребительное слово специальными новыми смыслами.
Каким бы корявым ни казался поначалу клик, корявость исключительно дело привычки: какая-нибудь типографская шпация ничем в этом плане не лучше.
Зато клик не имеет пересекающихся контекстов с редким русским кликать, но имеет фонетическое сходство с английским оригиналом, а это само по себе сильный фактор.
Справочная служба русского языка даёт взвешенную рекомендацию употреблять клик, четко соблюдая специальное управление (клик по). (Они еще советуют заключать слово в кавычки, но это слишком неудобно и само отпало, мы честно пытались.)
Короче, сама по себе непривычность для уха, вызывающая негативные реакции сугубо по причине своей непривычности, скорее, последний аргумент, а не первый.
Модель объект доступа/чтения/отрисовки/...
Эта удобная модель построения русскоязычных терминов для важного класса понятий, используемых в проектировании программного обеспечения, абстрагирована из диссертации А.Е.Недори (Институт систем информатики им. А.П.Ершова СО РАН); ссылка: http://www.kronos.ru/literature/nedorya/cand.4.
Используется у нас неоднократно.
Достоинства модели гибкость, универсальность, нейтрально-деловое звучание.
Недостаток два слова там, где в оригинале одно (rider = объект доступа).
Поэтому нередко удобно официальный термин, построенный по этой модели, дублировать жаргонным вариантом (объект доступа/бегунок для rider, объект отрисовки/вьюшка для view). Для парадных ситуаций используется длинный официальный вариант; для рутинных обсуждений жаргонный. Кроме того, возможность использовать дополнительный синоним способствует ясности изложения в некоторых сложных ситуациях.
Словарик
В список в первую очередь включаются термины, вызвавшие у переводчиков затруднения.
BlackBox [система] Блэкбокс. Не прижились варианты вроде БлекБокс.
BlackBox Component Builder [система] Блэкбокс.
BlackBox Component Framework [компонентный] каркас системы Блэкбокс.
framework [компонентный] каркас, компонентная среда. В сущности, обобщение понятия библиотека процедур, в котором добавлены типы (классы) и, самое главное, протоколы взаимодействия типов (допустимые последовательности вызовов соответствующих процедур-методов). Слово каркас по-другому практически не употребляется в компьютерной литературе, что делает его удобным для данного случая.
component компонент; компонентный. Мужской род существительного для сферы информационных технологий установлен стандартом ГОСТ 34.003-90. См.
http://ru.wikipedia.org/wiki/. Однако здесь речь только о компонентах программной системы. В любых других случаях (математика, компоненты записей и т.п.) используется женский род.
component-oriented programming компонентно-ориентированное программирование. Следующий после объектно-ориентированного программирования шаг в развитии технологий программирования. Подробнее см. статью на сайте проекта Информатика-21: http://www.inr.ac.ru/~info21/info/qtocop.htm
refactoring переработка, реструктуризация, рефакторинг (re-fac- = пере-дел-). Вариант перевода рефакторинг уже заметно укоренился (причем инструменты рефакторинга стали даже своеобразным фетишем программистов-профессионалов или желающих казаться таковыми). Но заметим, что если речь о компонентных каркасах, то рефакторинг не несет никакого нового смысла по сравнению с переработкой и тем более с реструктуризацией. Ктому же есть глагол refactor, который громоздко (да и странновато) переводить как выполнять рефакторинг.
Куст глагола refactor хорошо укоренен в структуре английского языка, там он уместен и, что важно понимать, неизбежен, т.к. хорошего универсального эквивалента для русской переработки в английском, как ни странно, нет. Хотя есть restructuring, который употребителен при разговоре о реструктуризации долгов, но также и корпоративного управления, что на каком-то уровне абстракции близко по смыслу к реструктуризации компонентного каркаса.
view объект отрисовки; вьюшка.
Это один из центральных и постоянно употребляемых терминов системы Блэкбокс, вызвавший наибольшие затруднения и долгие диспуты. Предлагались отображение, представление, вид, позже более удачное изображение.
Последним найден вариант объект отрисовки. Он привлекателен тем, что, во-первых, абсолютно точно передает смысл: речь в точности об объектах, основной функционал которых отрисовывать изображение на экране/бумаге. Во-вторых, отрисовка совершенно не нагружена посторонними смыслами, в том числе нет путаницы между процессом и его результатом (как с изображением), а также с основными математическими терминами (как с отображением).
Формальный термин объект отрисовки построен по стандартной модели. С другой стороны, неформальный перевод вьюшка доказал свою неизбежность и удобство в работе благодаря фонетической близости английскому оригиналу, родному звучанию (что особенно важно в преподавании), а также благодаря своей краткости: есть пример, когда в абзаце из неполных восьми строк этот термин встречается десять раз. Однако вьюшка еще недостаточно привычна, а по звучанию слишком неформальна, чтобы оставаться без парадного прикрытия, коим и служит объект отрисовки.
Если неформальное звучание вьюшки вызывает неприязнь, то следует подумать, почему еще большей неприязни не вызывает мышка на столе.
frame фрейм. Есть адвокаты и у перевода кадр: почему-то считается, что это родное слово и хороший русский язык, в отличие от фрейма. Нет сомнения, что в первой лекции по отрисовыванию вьюшек, объясняя, что такое f: Views.Frame, полезно сослаться на фото- или кино- кадр. Однако фонетическое сходство пробивает себе дорогу и в менее очевидных случаях (см. ниже о string). В данном случае похоже, что постоянное торчание конструкта f: Views.Frame на виду в соответствующих контекстах побеждает приверженность к хорошему русскому языку. Тем более, что есть и процедурный фрейм (не говоря о фреймах в психологии).
type safety защищенность типов, защита типов. Часто это переводят почти буквально как безопасность типов, что ошибочно (и это ошибка хроническая у переводчиков-непрофессионалов), т.к. русская конструкция с родительным падежом привносит мешающие смысловые оттенки туда, где в оригинале применен совершенно абстрактный compound. Защищенность или защита сразу и точно возбуждает в голове правильный смысл (ведь речь именно о защите переменных от ошибочного присваивания им значений чуждых типов). Защита как особый девайс явно фигурирует в семантическом поле английского слова safety (смотреть нужно, конечно, английские толковые словари: ... 2. A device designed to prevent accidents ... 3. Footbal. ... One of two defensive backs; a safetyman. 4. Slang. A condom.).
basic type элементарный тип, атомарный тип. У слова основной слишком размытое значение, а здесь важно подчеркнуть неделимость, в отличие от составных типов. Н.Вирт в учебниках тоже вынужденно употребляет elementary и atomic вместо туманного basic. Перевод базовый тип лучше сохранить для ситуации с указателями.
base type 1. базовый тип, тип-база, если речь идет о типе, для которого определяется соответствующий указатель; 2. то же, что и basic type (англоговорящие тоже путаются в подобных случаях).
array type массивовый тип. Удачно придумано Д.Б.Подшиваловым (перевод старой версии книги Н.Вирта Алгоритмы и структуры данных, 1989). Такой способ перевода наиболее точно соответствует грамматической структуре русского языка, что обеспечивает необходимую гибкость и точность выражения. Можно надеяться, что с 1989 г. прилагательное массивовый утратило налет непривычности. Вариант тип массив неграмматичен и потому неудобен, а тип массивов (опять этот неуместный родительный падеж) лучше оставить для ситуаций, где обсуждается тип конкретных массивов.
Во всяком случае употребляются эти термины (массивовый и записевый) не так часто, но зато в контекстах, где требуется полная ясность (определения и правила языка).
array variable переменная-массив, массивовая переменная. В данном случае конструкция переменная-массив точно передает смысл. Но нет вреда и от единообразного варианта массивовая переменная.
record type записевый тип. (Ср. замечание об array type. Странно, что Подшивалов использовал чуть другой вариант: записной.)
record variable переменная-запись, записевая переменная; ср. array variable.
type-bound procedure процедура, связанная с типом (т.е. метод method).
extension расширение, расширенное переопределение (типов: type extension); переопределение (методов); реализация (абстрактных типов и методов).
extend расширять (типы); переопределять (методы); реализовывать (абстрактные сущности)
В случае методов (процедур, связанных с типами) вариант переопределение наиболее точно соответствует современному (полученному в многолетнем опыте) пониманию ограничений, которых следует придерживаться при использовании механизмов ООП (отказ от супервызовов и от наследования реализации в пользу композиции). И если заботиться о повышении культуры будущих программеров, то лучше сызмала внедрять в юные умы переопределение.
В случае абстрактных типов и методов следовало бы говорить, если стремиться к точности, о реализации.
Однако трудно предотвратить использование производных от корня расшир- во всех случаях. Тут речь о разных сторонах единого механизма, так что неудивительна тенденция (в текстах на всех языках) к использованию одного общего термина. С другой стороны, разные стороны тоже нужно различать, а термин для общей идеи, в общем, есть полиморфизм.
static typing статическая типизация.
log [рабочий, системный] журнал. Изначально logbook бортовой журнал на корабле, куда записывались показания лога девайса для измерения скорости вместе с показаниями хронометра, астролябии, сведениями о ветрах и штормах и т.п.
persistent сохраняемый. См. http://www.lingvoda.ru/forum/actualthread.aspx?tid=4130.
lazy initialization ленивая инициализация. Более формальный вариант: отложенная.
factory function, object фабричная функция, фабричный объект; фабрика.
maintainability сопровождаемость.
evolvability развиваемость. Чрезвычайно важное понятие, на которое приходится часто ссылаться, и здесь просто не обойтись без особого ярлыка. Правда, развитие в большей степени подразумевает некое усложнение, чем эволюция, допускающая изменения в любую сторону и назад, и в бок. Но эволюционируемость вряд ли возможна как практичный термин.
maintainability сопровождаемость. Понятие родственное, но более узкое, чем развиваемость.
Развиваемость, переделка/рефакторинг <-> сопровождаемость, исправления/корректировка.
string цепочка (литерная цепочка или цепочка литер). Будем предпочитать цепочку. Строка путается с переводом на новую строку в командах печати и форматирования текстов, а также нехороша в случае terminal string в компиляторном контексте.
Хотя прилагательное строковый поудобней произносить, чем цепочечный, ну и есть фонетическое сходство str и стр.
Видим силу влияния фонетики на терминологию, которое играет тем сильнее, чем меньше обученность и смысловая щепетильность говорящего. Это, похоже, подтверждается
1) важностью варианта цепочка прежде всего для специальных тем, где народ более щепетильный (форматирование текстов и построение компиляторов);
2) частым употреблением строки в мануалах, переведенных нещепетильными переводчиками-партизанами. Явно от старинных мануалов для Турбо Паскаля и qbasic'а тянется след строки к школьным учебникам и учителям.
string resource текстовый ресурс
resource file файл (текстовых) ресурсов
character литера. Не буква (что слишком неточно) и не символ (слишком общий термин; пусть останется философам и компиляторщикам). Прилагательное: литерная.
Однако для специальных литер (управляющих и т.п.) обычно сохраняется слово символ: символ табуляции и т.п.
terminating character завершающая литера.
control codes управляющие символы (псевдо-литеры без изображения).
literal буквальная константа (т.е. представленная своим изображением, так что в программном тексте ее нужно понимать буквально).
target (variable, type) целевая (переменная, тип). Переменная (и ее тип), в которую должен быть записан результат (обычно переменная в левой части оператора присваивания).
wrapper обертка.
precondition, postcondition предусловие, постусловие.
forward declaration упреждающее объявление.
boolean логический, булевский. Возможно, следует предпочесть вариант логический. Но исключить булевский при всюду торчащем BOOLEAN трудно (конкретных противопоказаний здесь, в отличие от строки, нет).
constant константа, константный, если речь идет о понятии языка (сущности, описанные в разделах CONST), а не о математических постоянных.
constant expression константное выражение, т.е. построенное из констант и допускающее вычисление при компиляции.
disclaimer отказ от ответственности.
information hiding упрятывание информации.
embedded вставленный, внедренный, вложенный, встроенный. При работе в Блэкбоксе чаще всего речь идет о какой-нибудь вьюшке, вставленной в текст, форму или другой составной документ.
rider объект доступа, бегунок.
reader|writer объект чтения|записи.
icon иконка. У иконки очень сильные позиции в народе. Microsoft, признавая устойчивость иконки, упирают на значок но ведь им нельзя ошибиться в плане политкорректности.
click cущ. клик; глагол кликнуть по. Принимаем этот вариант как основной, имея в виду взвешенные рекомендации Справочной службы русского языка, но ставить слово всюду в кавычки нереально.
Переводчики использовали также майкрософтовский щелчок; щелкать (см. ниже Обсуждение).
double-click дважды кликнуть; в инструкциях: двойной клик
right-click кликнуть правой кнопкой мыши; в инструкциях: правый клик
В инструкциях-описаниях действий: двойной клик по имени модуля, правый клик, Документация.
(кликнуть по стрелке, чтобы закрыть)
Обсуждение
Диспуты. Насчет click'а поломано немало копий. Ср. многолетнюю дискуссию в Ассоциации лексикографов Lingvo, форум Школа технического перевода, ветка Kuzmin. Подумайте еще раз о кликах?
Смысл термина. Кликнуть по (чему-то на экране) навести курсор мыши на (что-то) и однократно быстро нажать и отпустить левую кнопку мыши.
Понятие конкретное, специфическое и слишком часто употребляемое, чтобы можно было обойтись без явного слова, именно это понятие обозначающего.
Благозвучность и т.п. Мышь тоже слово странное в официальном техническом контексте. Но прижилось, ибо без него обойтись трудно.
Интерференция с родным русским кликать/звать ничтожна, т.к. кликать не является общеупотребительным и бытует только в специфических контекстах.
Почему не щелк-. Щелкать слишком общеупотребительное слово в русском языке, притом прочно связанное с эмоционально окрашенной фразеологией (щ. по лбу, по носу, не щелкай клювом).
Щелк- навязывает Майкрософт, однако в их переводческой политике сильно дают себя знать опасения быть обвиненными в засорении русского языка, и они перестраховываются.
Почему не нажать и т.п. обороты. Пример: инструкция в начале обсуждения кликнуть по стрелке, чтобы закрыть. Нажать стрелку? Все время изворачиваться, чтобы передать одно и то же конкретное понятие, утомительно. Есть специальное понятие нужен специальный термин.
Цитата из вышеупомянутой ветки форума:
... ввод слова "клик" именно в жаргонном значении позволил бы решить кучу проблем получилось бы узкоспециализированное слово, обозначающее нажатие кнопки мыши при наведенном на цель (ссылка/кнопка) курсоре.
Обсуждение (кликнуть по стрелке, чтобы открыть/закрыть)
permanent сохраняемый, т.е. такой, который может сохраняться на диске между запусками среды или компа.
source (text, code) исходник; исходный текст. Нет никакой причины не использовать исходник всюду: термин недвусмысленный, нейтральный, удобный и уже знакомый даже детям.
Used internally. Для внутреннего использования в каркасе Блэкбокса.
guard охрана; процедура охраны (для команд меню и т.п.).
dirty грязное (об окне, в котором показывается документ, претерпевший изменения, которые, вероятно, надо сохранить).
caret (текстовый) курсор.
interactor интерактор, т.е. переменная (обычно запись), в которую записываются данные, вводимые / показываемые в элементах управления диалогового окна.
stamp штамп, специальная вьюшка (StdStamps).
Из модуля Stores:
Store объект хранения
internalize загрузить
еxternalize выгрузить
alien неопознанный
Из модуля Dialog:
control элемент управления (широко применяется в комьпютерной литературе)
mapped string настроенная литерная цепочка
resource file файл (текстовых) ресурсов
notifier уведомитель (процедура или объект), т.е. процедура, которая вызывается при изменении элемента управления в диалоге; см. *******
combo box control элемент управления с выпадающим списком
node узел (для орграфов; напр., Ф.А.Новиков, Дискретная математика, 2-е изд., Питер) //было: вершина
status bar строка текущего состояния (http://lingvo.yandex.ru/)
menu bar строка меню (http://lingvo.yandex.ru/)
title bar строка заголовка (http://lingvo.yandex.ru/)
interactor (запись-) интерактор. Запись, поля которой служат для хранения значений, показываемых в диалоговых окнах Блэкбокса. Они связаны с соответствующими элементами управления соответствующих диалоговых форм.
property sheet редактор свойств. Термин встречается в документации Блэкбокса. Буквально: листок/страница свойств. Для объектов, находящихся в фокусе, через контекстное меню обычно можно вызвать (команда Properties.../Свойства...) диалоговое окно, позволяющие менять параметры (свойства) объектов. Вот это диалоговое окно, в котором видны значения параметров (свойств), и называется property sheet.
property editor редактор свойств. В сущности, то же, что и property sheet. (коммент про "тоже устают")
tab закладка.
deep copy глубокая копия. При копировании динамической структуры данных, связанной указателями, можно копировать указатели, а можно полностью копировать и сами записи. Если копируются все записи, составляющие структуру, то это и есть глубокая копия.
shallow copy почти антоним к глубокой копии.
deposit понятие каркаса Блэкбокса. Означает создание объекта и постановку его в некую глобальную очередь (вроде системного буфера копирования) для последующего открытия в отдельном окне или для вставки в документ-контейнер.
pop-up menu выпадающее меню
run-time environment среда выполнения (программ). Совершенно нет нужды явно упоминать здесь время.
выполнение предпочитаем исполнению (т.к. обычно говорим выполнить программу)
linking связывание. Связывание (а не компоновка или сборка) точнее передает суть дела в нашем, динамическом случае (dynamic linking), когда модули по мере необходимости загружаются в разное время в разные области памяти и каждый раз взаимно связываются соответствующими указателями.
Старые термины компоновка, сборка описывает архаичную ситуацию (static linking), когда программа с необходимыми библиотеками собирается в непрерывный блок двоичных данных (exe-файл и т.п.), который целиком грузится в память и выполняется.
То есть: статическая сборка; динамическое связывание.
Directory фабричный объект (номенклатура книжки Гамма и др. "Паттерны...")
subdirectory папка, подпапка
Типографские термины
header, running head колонтитул
font шрифт
typeface гарнитура
size кегль
leading отбивка
hotkey горячая (устоявшийся перевод, даётся в словарях). Неплохо, но слишком длинно: комбинация/клавиша быстрого вызова.
Drag & Drop, drag-and-drop, drag-n-drop как существительное, обозначающее понятие из области интерфейсов человек-компьютер, хорошего перевода не имеет. Словать http://lingvo.yandex.ru/ даёт варианты: перетаскивание, перенос с последующим высвобождением, буксировка. Ч , употребляется как цельный иероглиф.
Глагол drag (как описание действия мышкой) бросить, перетащить (мышкой).
Drag & Pick механизм, введённый в Блэкбоксе. Перетащить-и-подобрать/взять/позаимствовать (атрибуты текста-цели).
selection выделенный фрагмент, выделенный текст, выделение? (встречалась маркировка)
clipboard буфер обмена
focus view объект отрисовки, находящийся в фокусе; владеющий фокусом; вьюшка в фокусе. Это вьюшка, в данный момент интерпретирующая сигналы от клавиатуры и мыши. Это может быть текстовый документ в переднем окне. Или это может быть вьюшка, вставленная в текст. В последнем случае вьюшка выделяется специальной рамкой со штриховкой по периметру.
focus фокус. Сокращение от focus view.
to focus (a view) установить фокус на (вьюшку); передать фокус (вьюшке)
restore (a view) отрисовать (вьюшку)
restoration отрисовка
edit правка, редактирование
disable отключить; дезактивировать
factory фабрика, фабричный (см. Гамма и др. Шаблоны...).
modifier key клавиша-модификатор (Ctrl в Windows, Option в Mac OS)
keyboard modifiers ....... Shift, Alt etc.
scroller объект прокрутки.
drag
string constant
search string
blank space пробел(ы), белые литеры?
change propagation распространение изменений?
*****************************
*****************************
Документ System//User-Man
layout эскиз
String resource текстовый ресурс
converter конвертер
Stationary шаблон?
property sheet список свойств (обычно диалог-инспектор)
manifest file нет перевода.
default button кнопка-по-умолчанию
*****************************
*****************************
? .
" " - , , .
*****************************
*****************************
| Docu/ru/RuComments.odc |
(c) 2005-2008 ООО ОЦПИ МЕТАСИСТЕМЫ
http://metasystems.ru/
(c) 2001-2009 Коллектив переводчиков.
(с) 2001-2012 проект Информатика-21
http://www.inr.ac.ru/~info21/ | Docu/ru/RuVersion.odc |
Часть первая: подходы к проектированию
ENGLISH
В первой части руководства по BlackBox дано введение в проектные схемы, которые используются в BlackBox. Знание этих схем облегчает понимание и запоминание более детальных проектных решений в различных модулях BlackBox.
Вторая часть руководства по BlackBox демонстрирует, как использовать самые важные библиотечные компоненты: формы, элементы управления и текстовые компоненты.
Третья часть руководства по BlackBox показывает, как могут быть созданы новые визуальные представления с помощью примеров от простого к сложному.
1 Взаимодействие с пользователем
В этом разделе мы обсудим, как пользовательский интерфейс можно сделать дружелюбным к пользователю. Графические пользовательские интерфейсы только часть ответа. К сожалению, этот ответ ведет к другой проблеме: как реализовать подобный пользовательский интерфейс с наименьшими затратами? Подход к проектированию, который решает эти проблемы, удивительно фундаментальный и имеет глубокое влияние на способы создания современного ПО. Он называется объектно-ориентированным программированием.
1.1 Дружелюбность к пользователю
Сегодня в мире используется не менее 100 миллионов персональных компьютеров. При таком большом числе пользователей, которые не являются специалистами по компьютерам, важна легкость использования компьютеров. Это подразумевает, что операционная система и приложения должны быть дружелюбными к пользователю. Что это значит? Здесь есть несколько аспектов.
Во-первых, различные приложения должны быть согласованы друг с другом: функция, которая доступна в различных программах должна иметь сходный пользовательский интерфейс во всех этих программах, так, чтобы пользователю не нужно было учиться делать различными способами одно и то же. Первый способ опубликовать правила построения пользовательского интерфейса, которых должны придерживаться все разработчики ПО. Такой подход был впервые применен компанией Apple в системе Macintosh. Второй подход реализовать функцию только один раз, чтобы ее можно многократно использовать в различных приложениях. Это идея компонентного ПО. Разработчики Apple так далеко не пошли, но они по крайнем мере дали много стандартных процедур в довольно богатой инструментальной библиотеке Toolbox, встроенной в Mac OS.
Во-вторых, метафора рабочего стола, где значки графически представляют файлы, каталоги, программы и другие сущности, позволила заменить труднозапоминаемые команды, которые нужно набирать с клавиатуры, более интуитивными прямыми действиями: например, значок с помощью мыши может быть брошен в мусорную корзину вместо набора с клавиатуры команды вроде "erase myfile". Подобный богатый пользовательский интерфейс требует обширной функциональности. Не удивительно, что инструментальная библиотека Toolbox Mac OS включает процедуры поддержки для работы с окнами, меню, мышью, диалоговыми окнами, графикой и др. Toolbox делает возможным построение приложений, которые действительно придерживаются обнародованных правил построения пользовательского интерфейса. К сожалению, программирование в такой среде означает огромный скачок в сложности. В результате Macintosh оказался гораздо проще в использовании, но и гораздо труднее для программирования.
Сегодня метафора проводника все более популярное добавление к традиционным графическим пользовательским интерфейсам. Вместе с доступом к Интернету она открывает пользователю компьютера целую вселенную документов и еще больше усложняет работу разработчика.
Наконец, один из наиболее общих и важных аспектов дружелюбности к пользователю - это исключение модальных диалогов [modes]. Модальный пользовательский интерфейс разделяет взаимодействие с пользователем на различные классы и дает свой контекст для каждого класса. Переключение между контекстами громоздко. Например, в программе для работы с базой данных пользователь может открыть окно для ввода данных. В этом окне нельзя удалить записи, осуществить поиск записей, сделать примечания, прочитать электронную почту и т.д. Для каждой из этих задач следует вначале покинуть окружение ввода данных. Это громоздко и напоминает способ вычислений, ориентированный более на приложение, чем на документ. При работе со сложными программами часто трудно уследить, в каком контексте вы сейчас находитесь, какие команды здесь доступны и куда вы можете пойти далее.
Рисунок 1-1 иллюстрирует пример состояний и возможные переходы состояний гипотетического модального приложения.
Рисунок 1-1. Возможности навигаации в модальном пользовательском интерфейсе.
Немодальные пользовательские интерфейсы не имеют раздельных рабочих контекстов [working environment] или, по крайней мере, позволяют вам переключаться между контекстами без потери состояний других. Например, если по ходу ввода данных вы захотите взглянуть на что-то с помощью браузера библиотек или утилиты текстового поиска, вы не потеряете часть данных, которую уже ввели. Если нет раздельных рабочих контекстов, то навигация становится простой и очевидной, если система дает информацию пользователю о текущем состоянии контекста и его возможностях.
Современный графический пользовательский интерфейс основной пример преимущественно немодального пользовательского интерфейса. Здесь одновременно могут быть открыты несколько окон (контекстов), но хорошо видно, с каким окном вы сейчас взаимодействуете (это обычно "верхнее" окно). Вы можете, работая в одном окне, временно поработать в другом (тем самым сделав его "верхним"), и затем переключится обратно, чтобы продолжить работу в первом окне.
Эти пользовательские интерфейсы огромное улучшение по сравнению со старомодными модальными интерфейсами. Пользователи чувствуют себя более комфортно, потому что им понятнее, где они находятся и что могут делать. Тем не менее, даже современные ГПИ далеки от совершенства. Большинство из них все еще используют модальные диалоговые окна, т.е. окна, которые вы не можете оставить, чтобы временно поработать в других. Например, типичное модальное диалоговое окно позволяет открыть файл, но не позволяет непосредственно переключиться на утилиту поиска файлов и обратно. Диалоговое окно "связывает" пользователя. Даже необходимость перевести окно наверх, прежде чем можно будет работать с ним, создает неудобную и не необходимую модальность, по крайней мере если есть достаточно большой экран, чтобы можно было расположить все нужные окна без перекрытий. И многие программы для работы с базами данных не разрешают держать открытыми одновременно несколько форм ввода данных или форм для манипуляций с данными. Веб браузер ближе всего сегодня к истинно немодальному пользовательскому интерфейсу: если вы ввели неполные данные в HTML-форму и затем решили переключится на другую веб страницу, то браузер не помешает вам это сделать.
BlackBox Component Builder более радикален, чем остальные инструменты, в том, что он просто не поддерживает модальные окна. Все диалоговые окна немодальные, за исключением очень малого числа встроенных в операционную систему, таких как стандартное окно открытия файлов. В общем случае, вы можете всегда оставить диалоговое окно и вернуться к нему позже.
1.2 Циклы обработки событий
Реализация немодальной программы выглядит обманчиво просто: программа ожидает пользовательские события, такие как щелчок мышкой или нажатие клавиши, реагирует подходящим образом, ожидает следующего события и т.д. Такой стиль программирования с центральным циклом, который опрашивает операционную систему о событиях и затем вызывает подходящие обработчики для них, называется программированием, управляемым событиями.
Рисунок 1-2. Цикл обработки событий для немодальной программы
Цикл опроса событий типичной программы, управляемой событиями, выглядит подобно следующему программному фрагменту:
PROCEDURE Main;
VAR event: OS.Event;
BEGIN
LOOP
event := OS.NextEvent(); (* запросить у ОС информацию о следующем событии *)
IF event IS KeyDownEvent THEN
HandleKeyDown(event)
ELSIF event IS MouseDownEvent THEN
IF MouseInMenu(event) THEN
HandleMenuEvent(event)
ELSIF MouseInWindowTitle(event) THEN
HandleTitleEvent(event)
ELSIF MouseInWindowBorder(event) THEN
HandleBorderEvent(event)
ELSIF MouseInWindowContents(event) THEN
HandleContentsEvent(event)
ELSIF...
...
END
ELSIF ...
...
END
END Main;
Листинг 1-3. Цикл обработки событий с каскадным выбором обработчиков событий.
В реальной программе такие каскады условных операторов могут запросто занимать несколько страниц листинга, и они всегда похожи. Таким образом, напрашивается мысль заложить этот код в библиотеку (или, еще лучше, в операционную систему). В такой библиотеке можно было бы реализовывать стандартные правила построения пользовательского интерфейса. Например, процедура HandleTitleEvent различала бы, в каком именно месте заголовка окна произошел щелчок мышкой. В зависимости от точного положения окно будет перемещено на другое место, увеличено, закрыто и т.п. Это универсальное поведение, которое может и для единообразия должно быть реализовано единожды. Однако процедуры типа HandleContentsEvent имеют иной характер: стандартная библиотека не может знать, что должно произойти, когда пользователь щелкнул внутри окна.
Если мы требуем, чтобы сама библиотека никогда не нуждалась в адаптации к конкретному приложению, то получается система со специфической структурой, в которой библиотека иногда вызывает процедуры приложения. Такой вызов называется обратным [call-back]. Если мы изобразим приложение находящимся над библиотекой, то станет очевидным, почему такие вызовы также называются отложенными вызовами [up-call], а полученный стиль программирования "перевернутым" программированием [inverted programming].
Рисунок 1-4. Образец проектирования "перевернутого" программирования.
Библиотека, которая систематически основана на "перевернутом" программировании, называется каркасом [framework]. Это полузаконченный продукт, который должен достраиваться с помощью динамического подключения процедур. Для некоторых процедур это может быть необязательным: процедура HandleTitleEvent может иметь реализацию по умолчанию, в которой реализованы стандартные правила построения пользовательского интерфейса. Такие процедуры могут быть заменены, только если возникнет нужда в нестандартном поведении.
Опыт показывает, что процедура, подключенная к каркасу, многократно обращается к одим и тем же данным. Например, процедура HandleTitleEvent будет часто обращаться к окну, в котором пользователь щелкнул мышкой. Поэтому удобно "упаковать" процедуру и соответствующие данные (ее состояние) в капсулу. Такая капсула называется объектом, и тем самым "перевернутое" программирование развивается до объектно-ориентированного программирования.
Итак, рассуждая о программах, дружелюбных к пользователю, мы пришли к задаче уменьшения объема повторяющегося и сложного кода в циклах обработки событий, которая в свою очередь привела нас к стилю "перевернутого" программирования; к каркасам, как способу реализации этого стиля программирования в коде; и к объектно-ориентированному программированию как удобному средству реализации каркасов.
BlackBox Component Builder скрывает цикл обработки событий от программистов прикладных программ. Он даже идет дальше каркасов-предшественников в том, что скрывает и платформо-зависимые черты, такие как окна и меню. Этого удалось добиться, сосредоточившись на абстракциях, которые представляют содержимое окна: так называемый тип View. Мы расскажем об этом более подробно в Главе 2.
1.3 Многопользовательский доступ
Благодаря персональным компьютерам пользователи стали независимы от централизованных отделов ИТ (информационных технологий), их бюрократизма и перегруженных серверов, работающих в режиме разделения времени. Эта независимость хорошая вещь, если она может быть соединена с интеграцией там, где это полезно и выгодно. Локальные сети, глобальные сети и затем Интернет сделали интеграцию возможной. Когда два компьютера взаимодействует через сеть, один из них запрашивает другой о предоставлении некоего сервиса, например, о передаче файла через сеть. Компьютер, который выдает запросы, называют клиентом, другой сервером. Одна и та же машина может функционировать и как клиент, и как сервер, но эти роли часто фиксированы: клерк в филиале банка всегда использует компьютер-клиент, а большая стойка в кондиционируемом хранилище штаб-квартиры банка всегда функционирует как сервер. Внутренняя сеть банка может соединять тысячи клиентов и дюжины серверов. Но даже самая маленькая сеть, очевидно, требует разделения приложений на две части: клиентскую и серверную. Поэтому такой тип архитектуры называют клиент/серверными вычислениями. Он позволяет распределить разные задачи между наиболее подходящими машинами. На уровне предприятия наиболее популярное разпределение ролей возложить обязанности обслуживания централизованной базы данных на сервер базы данных, а оставшуюся функциональность на машины-клиенты. Это называется двухуровневой архитектурой. Она требует толстых клиентов, т.е. машины-клиенты должны выполнять все, кроме собственно доступа к базе данных. Чтобы уменьшить эту нагрузку, наиболее развитые системы управления базами данных позволяют выполнять некоторый код на самом сервере как интерпретируемые хранимые процедуры. Это может существенно увеличить производительность за счет уменьшения объема данных, пересылаемых по сети в обоих направлениях.
Если количество клиентов большое, то становится трудно вовремя обновлять и поддерживать согласованность программного обеспечения на всех машинах-клиентах. Данная проблема может быть уменьшена с помощью трехуровневой архитектуры, где между клиентами и серверами находятся специальные серверы приложений. Функции "тонких" клиентов сокращены до реализации пользовательских интерфейсов, серверы баз данных управляют базами данных, а серверы приложений реализуют все знание о конкретных приложениях ("бизнес-логика").
Рисунок 1-5. Проектная схема трехуровневой клиент/серверной архитектуры.
Трехуровневая архитектура неплохо управляема и масштабируема по размеру. Заметим, что программная система, разделенная таким путем, может быть в крайнем случае "ужата" за счет размещения клиента, сервера приложений и сервера баз данных на одной машине. Обратное неверно: монолитную программу нелегко разделить в соответствии с архитектурой клиент/сервер.
Клиенты и серверы соединены через сеть. Связь осуществляется либо на низком уровне абстракции нетипизированных потоков байтов (например, используя интерфейс сокетов для TCP/IP коммуникации), либо на высоком уровне абстракции типизированных данных. В последнем случае используются либо распределенные объекты (для непосредственной коммуникации точка-точка), либо объекты сообщений (для групповой или отложенной коммуникации).
Подсистема Comm компонентного каркаса BlackBox предоставляет простую абстракцию коммуникации через поток байтов, на основе которой могут быть построены службы сообщений. Между прочим, это может быть использовано для реализации удаленных элементов управления, т.е. таких, которые отображают и манипулируют данными на удаленной машине. Например, таким способом можно проверять внутреннее состояние встроенной системы.
Подсистема Sql BlackBox Component Framework обеспечивает простой интерфейс распределенных объектов, специализированный для доступа к реляционным базам данных (SQL-серверам). Более общие распределенные объекты, основанные на технологии DCOM [COM], могут быть доступны и реализованы при помощи компилятора Direct-To-COM для языка Компонентный Паскаль.
1.4 Настройки на разные языки пользователей
Глобальная природа современного бизнеса програмного обеспечения часто требует выпуска "локализованных" версий программного пакета. Это требует, как минимум, перевода в программе всех строковых констант, которые может увидеть пользователь. Например, в такой стране как Швейцария с ее четырьмя официальными языками,часто требуется, чтобы у одного и того же программного продукта были версии на немецком, французском и итальянском языках. Может даже потребоваться адаптировать к разным языкам формат диалоговых окон, т.к. заголовки и ярлыки элементов управления имеют разную длину в различных языках.
Если такие зависимые от языка аспекты жестко закодированы в исходном тексте программы, то локализация версии требуют редактирования и компиляции исходного кода. Это всегда деликатный вопрос, т.к. легко могут быть внесены ошибки и несогласованности. Кроме того, это очень неудобно: из-за отсутствия наглядности трудно менять неинтуитивно "впаянный" непосредственно в исходный текст программы формат диалоговых окон, и слишком громоздко выполнять полный цикл редактирования, компиляции и запуска, если нужно всего лишь изменить расположение или размер элемента управления. Разработано много утилит, которые предлагают более удобные специализированные редакторы, в частности, редакторы диалоговых окон. Например, такая утилита может генерировать программный код из интерактивно построенного диалогового окна, и этот код затем компилируется. Так как программист должен редактировать сгенерированный исходный код, легко внести рассогласованность между расположением элементов управления и программным текстом.
К счастью, существует намного лучший способ решить эту проблему, избежав промежуточного генератора исходного кода и использования выдачи редактора непосредственно в программе. Редактор сохраняет информацию о формате диалогового окна в так называемом файле ресурсов. Программа затем считывает такие ресурсы в нужный момент, например, при открытии диалогового окна. Такие ресурсы могут рассматриваться как сохраняемые объекты, которые достаточно модифицировать только при изменении конфигурации программной системы.
Итак, проблема удобной адаптации программы к различным естественным языкам может быть решена выделением параметров, зависящих от языка и региона, из исходного кода. Их располагают в ресурсных файлах, которые могут быть изменены удобными специализированными редакторами.
Разделение деталей пользовательского интерфейса и собственно программной логики это способ сделать клиентское ПО более модульным и лучше адаптируемым. В предельном случае ресурсы почти становятся клиентским ПО: веб браузер на клиентской машине это все что нужно для пользовательского интерфейса; ресурсы (HTML тексты) загружаются с сервера по мере необходимости. (Однако такой подход с "ультра тонкими" клиентами становится менее разумным с увеличением сложности самих браузеров.)
Black Box Component Framework использует свой стандартный формат документов для хранения ресурсов. Например, диалоговое окно и его элементы управления просто части некоего составного документа, хранимого в файле. То же визуальное представление используется для проектирования диалогового окна и при его фактическом использовании при этом нет необходимости в отдельном редакторе. Ресурсы могут быть доступны в версиях для нескольких языков одновременно, и языки могут даже переключаться во время исполнения. Это полезно для специализированных программных приложений, используемых в регионах, где разговаривают на нескольких языках. | Docu/ru/Tut-1.odc |
2 Составные документы
ENGLISH
В предыдущих разделах мы обсудили разнообразные проблемы, которые появляются в интерактивных системах, и мы увидели различные архитектуры и подходы к проектированию, которые помогают их решить.
В следующих разделах мы сосредоточим внимание на проблемах программирования, которые ставят составные документы, и на проектных схемах, помогающих их решить.
2.1 Перманентность
Мы называем объект, который содержится в окне, отображением. Отображение отражает себя в окне, и оно может интерпретировать пользовательский ввод в этой области, такой как щелчок мышкой. В наиболее общем случае отображение можно открыть и сохранить как документ. Другие отображения могут быть созданы динамически или загружены из файлов ресурсов. Элементы управления диалогового окна "Найти и заменить" пример последнего случая.
В общем, отображение перманентный объект. Это предполагает механизм для выгрузки и загрузки визуального представления. Используя объектно-ориентированное программирование, мы можем моделировать отображение как уточнение общего перманентного объекта, который называется хранилище. Оно может выгрузить и загрузить свое перманентное состояние. Отображение это уточненное хранилища, т.е. подтип. В дополнение к выгрузке и загрузке себя, отображение может изображать себя и может обрабатывать пользовательский ввод. Эти общие отображения могут быть уточнены дальше, например, до визуальных представлений текста, визуальных представлений рисунков и т.п. (см. рис. 2-1).
Рисунок 2-1. Соотношения подтипов между визуальными представлениями и хранилищами.
В BlackBox Component Framework хранилища представлены как тип Store в модуле Stores; отображения представлены как тип View в модуле Views; и существует множество различных специфичных отображений, такие как тип View в модуле TextViews, или тип View в модуле FormViews, или тип Control в модуле Controls (см. рис. 2-2). Это только малая часть, в реальности имеется много больше типов отображений. Формат файлов механизма хранилища является независимым от платформы, т.е. скомпенсированы различия в порядке байтов.
Рисунок 2-2. Соотношения подтипов между визуальными представлениями и хранилищами в BlackBox
Часто копирование хранилища эквивалентно записи его во временный файл и последующему его прочтению (выгрузка старого объекта в файл, затем создание и загрузка нового объекта из файла). Это делает удобным объединение поддержки перманентности и копирования в одной и той же абстракции хранителя. Тем не менее, хранилища в BlackBox способны изменить свою сущность или "исчезнуть" при выгрузке в файл, в этом случае копирование не эквивалентно более выгрузке/загрузке. Например, отображения маркера ошибки, которые указывают синтаксическую ошибку, убирают себя при выгрузке хотя видимый маркер ошибки может быть скопирован с помощью механизма drag-n-drop, так же как другие отображения. Чтобы позволить такую гибкость, BlackBox не трактует автоматически копирование как пару выгрузка/загрузка. Хранилища имеют явные методы Externalize, Internalize и CopyFrom. При выгрузке оно получает возможность подставить вместо себя другое хранилище, возможно, NIL. Это механизм, позволяющий изменить свою сущность на другую, т.н. заместитель [proxy].
2.2. Независимость от устройства отображения
Вычислительный мир гетерогенен, с различными аппаратными и операционными платформами на рынке. Интернет, с его миллионами платформ на любой вкус, окончательно сделал ясным, как важна независимость кода и данных от платформы. Этого нелегко достичь, потому что программное и аппаратное обеспечение может широко изменятся между платформами. Устройства отображения, такие как мониторы и принтеры, хороший пример. Их пространственное и цветовое разрешения могут чрезвычайно различаться.
Для того чтобы достичь независимого от платформы кода, отображения и их перманентное состояние не должны ссылаться на конкретные устройства. Вместо этого пространство документа и пространство устройства отображения должны быть четко разделены, и подходящее отображение между ними должно обеспечиваться средой. Например, в пространстве документа расстояния измеряются в хорошо определенных единицах, таких как дюймы или миллиметры, тогда как в пространстве устройства отображения расстояния измеряются в пикселях, каким бы ни был их реальный размер.
Для моделирования разделения между пространствами устройства отображения и документа, где пространство документа сформировано перманентными отображениями, нам нужна абстракция устройства отображения. Мы называем такой объект фреймом [frame]. Фрейм это прямоугольная поверхность для рисования, которая обеспечивает множество операций рисования. Когда он делается видимым, отображение получает фрейм и через этот фрейм он может нарисовать на экране (или принтере). Фрейм выполняет отображение между единицами пространства документа и пикселями на устройстве отображения, так что визуальному представлению никогда не нужно иметь дело с размерами пикселов напрямую.
Рисунок 2-3. Разделения пространств устройства отображения и документа
В BlackBox Component Framework единицы пространства документа измеряются в 1/36000 мм. Это значение выбрано так, чтобы минимизировать ошибки округления для типичных разрешений экрана. Фрейм BlackBox'а обеспечивает локальную систему координат для своего визуального представления. Пока вы можете рассматривать фрейм как окно, а отображение как документ. Отображение, которое не изображено, не имеет фрейма. Фреймы это "легкие" объекты, которые создаются и удаляются по необходимости. Они создаются и разрушаются каркасом, и нет необходимости реализовывать или расширять их программисту отображений.
Единственный случай, где необходимо расширять фреймы, это когда для ависимых от платформы элементов управления или OLE-объектов нужно создать свернутые отображения BlackBox'а. Т.к. написание таких отображений "грязная" работа, каркас обеспечивает стандартные сверкти OLE (версия для Windows) и свертки для важных (до OLE) стандартных элементов управления.
2.3 Редактирование нескольких отображений
Простые отображения хорошо работают, если они достаточно малы, чтобы уместиться на экране. Однако, тексты, таблицы или графика могут легко стать больше чем экран или печатаемая страница. В этом случае фрейм (который лежит строго в границах своего устройства отображения) может показывать только часть отображения. Чтобы увидеть другие части, пользователь должен прокрутить отображение, т.е. изменить способ того, как оно переводит свои данные в локальную систему координат. Например, начало отображения текста может быть изменено от самой верхней строки к другой, более низкой, изображая часть текста, расположенную ниже (см. рис. 2-4).
Рисунок 2-4. Прокрутка текстового отображения
Необходимость прокрутки может стать очень неудобной при работе с двумя частями текстового отображения, которые значительно удалены, потому что это значит, что пользователь должен часто прокручивать его вперед и назад. Эта проблема может быть решена с помощью редактирования нескольких отображений: одни и те же данные представлены в более чем одном отображении. Эти отображения могут отличаться только своим началом, или они могут отличаться существенней. Например, одно отображение может представлять список числовых значений как таблицу чисел, когда другое может представлять те же данные как круговую диаграмму (см. рис. 2-5).
Рисунок 2-5. Различные типы отображений, представляющие одни и те же данные
Объект, представляющий данные, которые могут быть представлены в различных отображениях, называется моделью. Разделение на отображение и модель возвращается к проекту Smalltalk в Xerox PARC. В терминологии проектных схем отображение это наблюдатель модели.
В Компонентном Каркасе BlackBox разделение модель/отображение опционально. Маленькие фиксированного размера отображения, которые легко умещаются в окне, обычно не нуждаются в раздельных моделях, тогда как большие или более чистые нуждаются. Это может происходить в ситуации, подобной следующей, где отображение имеет раздельную модель, и оба вместе они формируют документ, который изображается в окне:
Рисунок 2-6. Разделение моделей и отображений в BlackBox.
Пользователь может открыть второе окно, которое изображает свое собственное отображение, но для той же модели. Это происходит в следующей ситуации:
Рисунок 2-7. Множество отображений для одной и той же модели
Только одно из двух отображений выгружается, когда документ сохраняется в файл. Чтобы избежать путаницы, одно окно четко различается как главное окно, когда все другие являются так наз. дочерними окнами [subwindow]. Если вы закроете дочернее окно, только это окно закроется. Но если вы закроете главное окно, оно само и все другие дочерние окна закроются одновременно.
2.4 Распространение изменений
Редактирование из нескольких представлений создает проблему согласованности. Редактирование отображения значит, что отображение заставляет измениться свою модель. Как результат, все отображения, представляющие эту модель, должны быть обновлены, если это необходимо, не только отображение, в котором пользователь сейчас работает. Например, если пользователь изменяет значение в отображении таблицы рисунка 2-5, то круговая диаграмма в другом отображении должна соответственно обновиться, потому что их общая модель изменилась.
Такое распространение изменений легко реализовать. После того, как модель выполнила операцию над данными, которые она представляет, она уведомляет все отображения, которые ее представляют, посылая им сообщение об обновлении, описывающее операцию, которая была выполнена.
Уведомление может быть легко сделано с помощью прохода по линейному списку отображения, фиксированных в модели. Такая функциональность может быть обеспечена раз и навсегда подходящей инкапсуляцией ее в класс. Это класс распространения изменений обеспечивает интерфейс, состоящий из двух частей. Первая часть позволяет регистрировать новые отображения, которые хотят прослушивать сообщения об обновлении ("подписка"). Вторая часть позволяет посылать сообщения об обновлении ("публикация"):
Рисунок 2-8. Механизм распространения изменений
Этот механизм обладает важным преимуществом; он разделяет модель и отображение так, что самой модели нет необходимости знать о своих отображениях, и список отображений может быть инкапсулирован в механизм распространения изменений. Такая связь между моделью и отображения желательна, потому что она уменьшает сложность. Она делает модель независимой от своих отображений. Это важно для расширяемой системы, потому что позволяет добавлять новые типы отображений без изменения модели. Такое было бы невозможно, если модель должна была знать слишком много о своих отображениях.
Иногда механизм, описанный выше, делает слишком много. Он посылает сообщения об обновлении всем отображениям, независимо от того, нужно их обновлять или нет. Например, когда слово удалено в текстовой модели, то некоторое отображения текста может отображать часть текста, на которую совершенно не повлияло удаление. Это отображения не должно ничего делать. Конечно, все отображения, которые отражают измененную часть текста, должны быть соответственно обновлены.
По этой причине, Компонентный Каркас BlackBox посылает сообщения об обновлении только тем отображениям, которые имеют фреймы. Т.к. каждый фрейм знает свое отображение, механизм распространения изменений в действительности регистрирует фреймы, а не отображения. Каркас уже имеет список фреймов для управления окнами, поэтому можно многократно использовать этот список. Таким образом, вместо того, чтобы держать один объект распространения изменений для каждой модели, BlackBox использует один глобальный сервис распространения изменений, встроенный в оконный менеджер. Сообщения представлены как статичные записи сообщений. Это нетрадиционная, но крепкая, эффективная и легкая реализация проектной схемы наблюдатель.
2.5 Вложенные отображения
До сих пор мы принимали, что отображение (возможно с моделью) это документ, и фрейм это окно. В действительности, все немного сложнее. Причина в том, что отображения могут быть вложенными. Некоторые отображения могут содержать ("внедрять") другие отображения; по этой причине они называются отображениями контейнеров. Некоторые контейнеры очень общие и позволяют внедрять любое число и любые типы других отображений. Например, отображение текста может внедрять отображения таблиц, рисунков и т.д. Оно может даже внедрять другое отображение текста, имеется в виду то, что можно создать иерархии вложенностей любой глубины.
Как это влияет на то, о чем мы до сих пор говорили? Очевидно, нам нужно обобщить нашу нотацию отображений и фреймов. Отображение может содержать другие отображения, которые могут содержать другие отображения и т.д.; т.е. отображения становятся иерархичными. В принципе, эти иерархии могут даже не быть деревьями, они могут быть произвольными ориентированными ацикличными графами. Это значит, что некоторые отображения в документе могут ссылаться на одну и ту же модель, но ссылки не могут идти "вверх" в иерархии документа, потому что это привело бы к бесконечной рекурсии при прорисовке документа, сродни телевизору, изображающего себя.
Фреймы представляют подмножество иерархии отображений. Т.к. фрейм всегда полностью содержится в своем родительском фрейме, иерархия фреймов строго является деревом.
Документ можно теперь рассматривать как корень ориентированного ацикличного графа отображений, и окно можно рассматривать как корень дерева фреймов.
Рисунок 2-9. Вложенные отображения и фреймы
Это понятное обобщение, которое не добавляет неожиданной сложности. Это упрощенная реализация проектной схемы компоновщик [composite]. Она была упрощена, потому что типовая безопасность Компонентного Паскаля делает ненужным абстрактный тип отображения со специфичным для контейнера операциями, которые бессмысленны для неконтейнеров.
К сожалению, больше сложности появляются, когда мы рассматриваем комбинацию вложенных отображений и редактирование нескольких отображений. Прежде всего, редактирование нескольких отображений означает разделение отображений и моделей. Внедренное отображение принадлежит модели, т.к. это часть данных, которые отображает отображение контейнера. Например, пользователь, редактирующий отображение текста, может удалить внедренные отображения, также как он может удалить внедренные символы. Рисунок 2-10 иллюстрирует ситуацию двух отображений контейнера с моделью контейнера, в который внедрено другое отображение:
Рисунок 2-10. Отображения контейнеров с моделью, контекстом и внедренным отображением
Заметьте интересную связь между моделью и внедренным отображением: объект контекста. Он описывает положение и, возможно, другие атрибуты одного внедренного отображения. Тип контекста определяется контейнером. Контекст создается контейнером, когда отображение внедряется. Внедренное отображение может спросить свой контекст о своем положении в контейнере и может даже получить большую информацию. Например, контекст текстового контейнера может обеспечить информацию о позиции внедренного отображения в тексте (индекс символа), о его текущем шрифте и цвете и т.д.
Внедренное отображение может использовать свой объект контекста не только для получения информации о контейнере, оно может также заставить контейнер выполнить некоторое действие. Например, внедренное отображение может попросить контейнер через объект контекста уменьшить или увеличить себя. Контейнеры могут выполнить подобные запросы или проигнорировать их. В переговорах между контейнером и одним из его внедренных отображений контейнер всегда выигрывает. Например, контейнер не позволяет внедренному отображению стать шире, чем сам контейнер.
Объект контекста можно рассматривать как интерфейс обратного вызова, который контейнер устанавливает во внедренном отображении как подключаемый модуль, поэтому отображение может обратиться к контейнеру и получить его сервисы. Контекст часть механизма оповещения, который позволяет контейнеру просматривать сообщения от содержащихся отображений.
В последующих рисунках объекты контекста не изображены явно, чтобы рисунки было легче понимать. Просто помните, что каждое отображение носит контекст, который оно может использовать по необходимости.
Сейчас, когда поддерживаются вложенные отображения и разделение модели и отображения, становится возможным разрешить использовать дочерние окна на внедренных отображениях, не только на корневых отображениях. Это может быть очень полезным, если нужно редактировать маленькое отображение. Просто откройте дочернее окно для него, увеличьте окно, и редактирование станет намного проще.
Рисунок 2-11. Дочернее окно на внедренном отображении.
Составные документы привносят дополнительную сложность. Для корневых отображений состояние прокрутки не сохраняется, когда документ сохраняется на диске. По крайней мере, большинство
пользователей предпочитают, чтобы состояние прокрутки отображения не было сохраняемым. Но все же для внедренных отображений ситуация другая. Установка начальной позиции внедренного отображения не столько для удобства (дочерние окна лучше подходят для этого), сколько для печати: пользователь выбирает, какая часть отображения должна быть видима в контейнере.
То же верно для механизма отмены/повтора: прокрутка в корневом отображения не является редактированием документа, и поэтому механизм отмены/повтора добавил бы больше неудобства, чем пользы. Тем не менее, прокрутка внедренного отображения должна рассматриваться как истинная операция редактирования, и поэтому должна быть отменяемой/повторяемой. В итоге, это значит, что реализатор отображения должен трактовать неперсистентное состояние отображения различно, в зависимости от того, является ли оно корневым или внедренным.
Объединение вложенных отображений с редактированием нескольких представлений также разрушает отношение один к одному между фреймами и отображениями. Как мы скоро увидим, это наиболее далеко идущее бремя, которое реализатор должен нести.
Чтобы понять, почему отображения может быть отображено в различных фреймах, рассмотрим ситуацию на рисунке 2-12:
Рисунок 2-12. Несколько фреймов, отображающих одно и то же отображение.
Такая ситуация не может возникнуть без вложенных отображений потому что самое внешнее отображение всегда копируется (чтобы позволить независимую прокрутку или другие специфичные для него операции). Но когда отображение внедрено в контейнер, изображаемый в двух различных окнах, тогда это отображения изображается в двух различных фреймах. Это делает управление ссылками между фреймами и отображениями более сложным; но, что более важно, это делает более сложным распространение изменений и обновление экрана.
Почему? Давайте предположим, что имеется n фреймов, которые отображают одно и то же отображение. Теперь модель отображения изменилась, и это изменение распространено всем отображениям, которые отображают модель. Т.к. есть только одно отображение для модели, то механизм распространения изменений, который мы обсудили ранее, пошлет отображению сообщение об обновлении ровно один раз. Тем не менее, есть n мест на экране, которые нужно обновить. Как результат, отображение должно выполнить n обновлений, пройдя по всем фреймам, которые его отображают.
Для отображения корректно поддерживать список фреймов, в которых оно отображается, сложная задача. Поэтому Компонентный Каркас BlackBox освобождает реализатора отображения от этой склонной к ошибкам задачи. Отображение в BlackBox'е не содержит список фреймов. Вместо этого каркас поддерживает деревья фреймов автоматически. Это было причиной, по которой на рисунке выше стрелки от фреймов к отображениям направлены только в одну сторону, потому что в BlackBox'е отображение не знает свой фрейм(ы). Корректные фреймы передаются отображению, когда каркас просит отображение сделать что-то, что может включать в себя рисование. (Такой подход связан с проектной схемой приспособленец [flyweight].)
Когда отображение получает сообщение об обновлении и решает, что нужно обновить свои фрейм(ы), оно просто спрашивает каркас послать другое сообщение об обновлении всем своим фреймам. Каждый из этих фреймов попросит отображение обновить фрейм, когда это необходимо. Этот механизм будет более подробно обсужден в главах, посвященных построению отображений.
Т.к. теперь больше нет отношения один к одному между отображениями и фреймами, полезно подытожить различия между фреймами и отображениями:
аспект фрейм отображение
живет в пространстве устройства отображения пространстве документа
persistent нет да
расширяется реализатором обычно нет да
может содержать зависимые
от устройства данные да нет
иерархия дерево ацикличный орграф
связан с одним отображением 0..n фреймами
обновление провоцируется его отображением его моделью (если есть)
полностью содержится в контейнере да не обязательно
Таблица 2-13. Различия между фреймами и отображениями
2.6 Отложенное обновление
В предыдущей секции мы увидели, как обновления выполняются в два шага: модель уведомляет свои отображения об изменении, и визуальные представления уведомляют свои фреймы об области, которую нужно обновить.
Теперь рассмотрим сложное изменение модели. Например, выделенные графические объекты, которые являются частью модели графиков, перемещаются на некоторое расстояние. Это возможно было бы выполнить в три фазы: в первой фазе выделенные объекты были бы удалены (требование обновления), затем выделенные объекты были бы перемещены, и, наконец, выделенные объекты были бы вставлены снова в их позицию назначения (требование другого обновления). Этот подход не очень эффективен, т.к. он требует двух уведомлений и частичных обновлений. Кроме того, необходима осторожность в последовательности действий, т.к. некоторым из них нужно состояние модели до перемещения, а другим после перемещения.
Есть куда более простой и более эффективный подход. Идея отложить вторую фазу обновлений, т.е. фазу, когда перерисовываются фреймы отображения. Вместо немедленного обновления фреймов отображение запоминает только геометрическую область, которую нужно обновить. В вышеприведенном примере оно могло добавить области графических объектов до перемещения и их области после перемещения (см. рис. 2-14).
Рисунок 2-14. Область обновления выделения, которое было перемещено
Накопленная область обновления потом обновляется за один единственный шаг после того, как было осуществлено перемещение графических объектов. В рисунке выше область обновления это вся заштрихованная область, состоящая из области, занятой выделенными объектами до перемещения, и области, занятой ими после перемещения.
Каркас должен поддерживать этот подход, обеспечивая некий механизм для добавления геометрических областей и перерисовки фрейма точно в этой области ("отсекая" все ненужное рисование для увеличения скорости и минимизации мерцания).
Подход отложенного или ленивого обновления используется в Компонентном Каркасе BlackBox и во всех основных оконных системах, которые сегодня существуют. Единственный недостаток в том, что для долго выполняющихся команд может быть необходимым заставить проделать немедленные обновления, чтобы информировать пользователя о степени выполнения команды. По этой причине вынужденные обновления также поддерживаются каркасом BlackBox'а.
2.7 Режимы контейнера
При создании графического пользовательского интерфейса удобно создавать строение формы интерактивно, нежели "прошивать" координаты элементов управления в исходном коде программы. Визуальный конструктор, т.е. графический редактор специального назначения, можно использовать для интерактивного изменения строения форм. Это предполагает два различных режима использования формы и ее элементов управления: разработки и исполнения. Когда редактируется строение формы в визуальном конструкторе это режим разработки: форма строится, но еще не используется. Законченную форму можно сохранить и позже открыть для использования конечным пользователем. Это называется режимом исполнения.
Существует два различных подхода для управления строением в режиме исполнения: либо каркас позволяет открывать данные, которые были сохранены визуальным конструктором, либо он исполняет код, который был сгенерирован из этих сохраненных данных. Первый подход требует интерпретатор для данных визуального конструктора, второй подход требует генератора между визуальным конструктором и действительным использованием формы. Обычно генератор генерирует исходный код, который, возможно, завершается программистом и потом компилируется в машинный код, используя стандартный компилятор языка программирования.
Сегодня последний подход следует считать устаревшим, хотя он еще используется во многих утилитах: это просто неудобная излишняя работа. Более того, когда это заставляет программиста редактировать сгенерированный исходный код, последовательные изменения строения формы становятся проблематичными: исходный код должен сгенерироваться заново без потерь изменений, которые сделал программист. Это ненужный источник несогласованностей, сложности и это замедляет разработку.
Первый подход намного проще. Вывод визуального конструктора рассматривается как ресурс, который может быть использован как есть во время исполнения. Это требует интерпретатора формата файла визуального конструктора.
Наиболее элегантный подход использовать тот же редактор (т.е. реализацию визуального представления) и, следовательно, тот же формат файла и для режима разработки, и для режима исполнения. В качестве формата файла можно снова использовать стандартный формат составного документа. Это значит, что строение формы в режиме разработки полностью является обычным составным документом. В режиме исполнения это все тот же документ, только его взаимодействие с пользователем различно.
В режиме разработки элемент управления пассивный прямоугольник, который можно перемещать, копировать и удалять, но у него нет своего интерактивного поведения. В режиме исполнения элемент управления может получить фокус и его содержимое можно редактировать. Например, строку, содержащуюся в элементе управления текстовое поле, можно редактировать, или кнопку можно нажать и отпустить.
Прямое использование составных документов как пользовательских интерфейсов называется составными пользовательскими интерфейсами. Заметьте, это обобщение составных документов делает термин "документ" вводящим в заблуждение, потому что программа может содержать много форм (и, следовательно, документов составного пользовательского интерфейса), даже если она не обрабатывает документы в традиционном смысле (т.е. как видимых конечным пользователем).
Компонентный каркас BlackBox использует свою поддержку редактирования нескольких отображений, чтобы сделать шаг вперед. Т.к. документ можно открыть в нескольких отображениях одновременно, возможно открыть строение формы в двух окнах. BlackBox позволяет использовать отображения форм в различных режимах: строения и маски. Эти режимы соответствуют режиму разработки и режиму исполнения, но с одним важным улучшением: они могут использоваться одновременно. Например, одно окно может отображать форму в режиме строения, а другое окно в режиме маски (см. рис. 2-15). Когда разработчик редактирует строение формы в окне режима строения, любое изменение строения немедленно отображается в окне режима маски. Наоборот, пользовательский ввод в окне режима маски немедленно становится видимым в окне строения. Это результат стандартного механизма распространения изменений BlackBox'а.
Рисунок 2-15. Форма ввода данных в режиме строения (позади) и в режиме маски (впереди)
В действительности, BlackBox более общий. В дополнение к режимам строения и маски, он поддерживает еще несколько режимов. Режим редактирования позволяет изменять расположение и содержимое элементов управления одновременно, а режим просмотра делает форму доступной только для чтения за исключением выделения и копирования частей документа.
Эти общие режимы доступны не только в графических формах. Они возможности, разделяемые всеми общими отображениями контейнеров, включая представления текстов. Это значит, что возможно (и, иногда, более удобно для разработчика) использовать отображение текста вместо отображения формы при сборке диалогового окна. Пользователь не заметит разницы. Чтобы упростить построение таких мощных контейнеров, каркас обеспечивает исчерпывающую абстракцию контейнера с абстрактным классом модели контейнера, с абстрактным классом отображения контейнера и с абстрактным классом контроллера контейнера. Контроллер можно рассматривать как отделившуюся часть отображения. Он выполняет все взаимодействие с пользователем, включая обработку ввода с клавиатуры и манипуляций мышью, и он также управляет выделениями. Отношение между отображением и контроллером во время исполнения один к одному. Выделение части визуального представления в объект контроллера повышает расширяемость (различные контроллеры могут быть реализованы для одного и того же отображения, и один и тот же контроллер работает со всеми конкретными реализациями отображения), и это также позволяет уменьшить сложность: контроллер сложного отображения, такого как отображение контейнера, может стать большим, что делает разделение вещей на различные типы (и, обычно, в различные модули) хорошей идеей. В терминах проектных схем контроллер это объект стратегии.
Абстракции контейнеров BlackBox'а были разработаны, чтобы абстрагироваться от специфичных пользовательских интерфейсов контейнеров. Это значит, что детали внешнего вида контейнера (такие как обозначение фокуса OLE-объекта пунктирным прямоугольником) спрятаны от разработчика. В свою очередь, это позволяет реализовать контейнеры различным образом для различных платформ, без влияния на разработчика контейнеров. В частности, реализован внешний вид контейнеров, похожих на OLE и Aplle OpenDoc. Тогда как OpenDoc более неуместен, некоторые принципы пользовательского интерфейса, разработанные для него, полезны и сегодня.
2.8 Обработка событий
Когда пользователь взаимодействует с составным документом, это взаимодействие всегда происходит в одном отображении в одно время. Это отображение называется текущим фокусом. Щелчком в другом месте пользователь может изменить текущий фокус. Среди других событий фокус обрабатывает события от клавиатуры, т.е. нажатие клавиши интерпретируется отображением, обладающим фокусом. Отображение, обладающее фокусом, и все содержащие его отображения называются путем к фокусу, где самое внутреннее отображение является фокусом.
Есть возможность позволить каркасу пользовательского интерфейса управлять текущим фокусом. Это требует централизованного управления фокусом. Более легкий подход сделать управление фокусом децентрализованной деятельностью: оставить управление фокусом индивидуальным отображениям контейнеров, которые все равно должны иметь дело с изменениями фокуса и передачей фокуса. Каждый контейнер просто запоминает, какой из его внедренных отображений является текущим фокусом, если такой есть. Контейнер не обращает внимания, находится ли это отображение в текущем пути к фокусу или нет.
В BlackBox пользовательские события посылаются по пути к фокусу как записи сообщений, начиная с самого внешнего отображения. Записи сообщений статичные (распределяемы в стеке) переменные некоторого подтипа от Controllers.Message. Существуют сообщения контроллера для ввода с клавиатуры, перемещения мыши, механизма drag-n-drop и т.д. Сообщение контроллера продвигается по пути к фокусу, пока одно из отображений либо проинтерпретирует, либо отклонит его. Это отображение является по определению фокусом.
В терминах проектных схем, путь к фокусу это "цепочка обязанностей".
Что происходит, когда отображение, обладающее фокусом, получает и интерпретирует сообщение контроллера? Отображение (или ее модель, если есть) выполняет некоторую операцию над своим состоянием. Если эта операция влияет на персистентное состояние отображения или модели, она должна быть обратимой ("отменяемой").
Как реализован механизм отмены/повтора?
Главная идея в том, что при получении сообщения контроллера отображение/модель не выполняет непосредственного изменения состояния. Вместо этого, оно создает специальный объект операции и регистрирует его в каркасе. Каркас потом вызывает подходящую процедуру операции для выполнения фактической функциональности сделать/отменить/повторить.
Управление операциями осуществляется отдельно для каждого документа. Каждый документ содержит два стека операций; один стек отмены, другой стек повторения. Выполнение операции в первый раз заталкивает объект в стек отмены и очищает стек повторения. Когда пользователь выполняет отмену, операция из вершины стека отмены отменяется, удаляется из этого стека и заталкивается в стек повторения. Когда пользователь выполняет повторение, операция из вершины стека повторения повторяется, удаляется из этого стека и заталкивается в стек отмены. Стеки отмены и повторения документа очищаются при сохранении документа (точка проверки). Кроме того, они могут быть очищены или уменьшены, когда каркас превышает лимит памяти. Для этой цели сборщик мусора информирует каркас о состоянии исчерпания памяти, так что старые объекты операций могут быть удалены.
Некоторые операции, такие как перемещающие drag-n-drop (в отличие от обычного копирующего drag-n-drop), изменяют одновременно два документа. В таких редких случаях, создаются две операции: одна для документа-источника (например, операция удаления) и одна для документа-получателя (например, операция вставки).
Рисунок 2-16. Последовательность операций и получившиеся изменения стеков отмены и повторения.
На рисунке 2-16 показана последовательность операций от 1) до 8). Для последних пяти ситуаций показаны получившиеся стеки отмены и повторения. Например, после операции 5) стек отмены содержит операции Вставка, Установка свойств и Вставка (от вершины к дну стека), а стек повторения содержит Удаление.
Механизм отменить/повторить имеет отношение только к перситентному состоянию документа. Это состояние, которое можно сохранить в файле. Изменения временного состояния, такие как позиция прокрутки визуального представления, не записываются как операции, и, следовательно, их нельзя отменить (по крайней мере, для корневых отображений).
Отменяемые операции либо изменяют персистентное состояние отображения либо его модели (состояние контроллера, в основном, временное). Каркас знает, к каким документам принадлежит персистентный объект, потому что все персистеные объекты документа разделяют один и тот же домен. Домены будут обсуждаться в Части III, где механизм хранилища обсуждается более подробно.
Компонентный Каркас BlackBox уникален в том, что его механизм отмены/повтора является компонентно-ориентированным: он позволяет осуществлять композицию отменяемых операций в составные операции, отменяемые как целое. Без этой способности вложенные операции записывались бы как плоская последовательность атомарных операций.
Рассмотрим, что бы это значило для конечного пользователя. Это бы значило, что пользователь мог выполнить команду меню, которая приводит к выполнению иерархии операций. До сих пор хорошо. Но, когда пользователь захочет отменить эту команду, он или она должен выполнить Правка->Отменить индивидуально для каждой отдельной операции команды вместо одной.
По этой причине BlackBox обеспечивает поддержку для произвольно вложенных операций: модули Models и Views оба экспортируют пару процедур BeginScript / EndScript. В этом контексте, "script" означает последовательность или иерархию атомарных операций, отменяемых как целое. Операции модели и отображения можно произвольно смешивать в скрипте. Абстрактные операции очень легкие. Они обеспечивают только одиночную процедуру без параметров, называемую Do. Эта процедура должна быть реализована обратимым образом, так что если она выполнена четное число раз, она не имеет эффекта. Если она выполнена нечетное число раз, она имеет тот же эффект, что и при выполнении один раз. В терминах проектных схем операция называется командой.
2.9 Элементы управления
Элементы управления это "легкие" отображения, которые обеспечивают только очень специфичную функциональность, которая приобретает смысл только в соединении с другими элементами управления и контейнером. Типичные элементы управления командные кнопки и поля ввода текста. Они используются в диалоговых окнах или формах ввода данных. Параметры или другие данные, представляемые элементами управления, должны как-то обрабатываться соответствующей программой. Например, команда Найти берет строку поиска как вход, или данные, введенные в форму, должны посылаться реляционной базе данных. Могут существовать даже сложные взаимодействия между элементами управления и формой. Например, когда строка поиска пуста, кнопка Найти может быть недоступной. Если что-то набрано, кнопка доступна. Такие взаимодействия могут стать очень запутанными. В принципе, элемент управления это просто наблюдатель своих данных. Это означает, что наиболее прямолинейно было бы реализовать данные (например, строку поиска) как модель.
Для BlackBox'а оказалось, что этот подход слишком сложен и неудобен. Вместо этого, была осуществлена специальная реализация проектной схемы наблюдатель, в котором типичная программа никогда не нуждается в прямом доступе к объектам элементов управления. Они совершенно абстрагированы. Программист имеет дело только с наблюдаемыми данными. Чтобы сделать определение и изменение этих данных как можно удобнее, они просто являются глобальными переменными языка Компонентный Паскаль, называемые interactor. Элемент управления имеет символическое имя (например, "TextCmds.find.ignoreCase"), которое позволяет ему найти свою переменную, используя встроенные возможности метапрограммирования BlackBox'а. В самом модуле интерактора нет ссылки на элемент управления.
Когда элемент управления редактируется, он прозрачно использует стандартный механизм распространения изменений BlackBox'а, т.е. он посылает сообщения отображения, которые уведомляют другие элементы управления, которые могут отображать ту же переменную. Хотя модуль интерактора не имеет доступ к своим элементам управления, он все же может влиять на способ отображения элементов управления (например, доступность/недоступность) и способ их взаимодействия друг с другом. Это делается экспортом подходящих процедур охранника и уведомителя. Они присоединяются к элементу управления таким же образом, как и ссылка на интерактор, используя подходящий редактор свойств элементов управления. Важно, что программа не нуждается в прямом доступе к элементам управления, и нет необходимости программировать прямые взаимодействия элементов управления. Это значительно упрощает реализацию и поддержку сложных поведений пользовательского интерфейса. Этот механизм более подробно описан в Главе 4.
В принципе, каркас получает доступ к модулю интерактора (через метапрограммирование) как одиночный посредник. | Docu/ru/Tut-2.odc |
3 Приемы проектирования в Блэкбоксе
ENGLISH
В предыдущих главах были описаны различные приемы и подходы к проектированию. Они помогают решить проблемы, которые возникают в составных интерактивных приложениях. В этой главе обсуждаются более общие аспекты, которые помогают создать компонентно-ориентированный каркас, расширяемый за счет динамически загружаемых блэкбоксовых компонентов.
Мы не пытаемся создать полный метод проектирования, который бы давал пошаговые инструкции, как проектировать новый каркас. Это нереально. Но мы хотим продемонстрировать и обосновать приемы, подходы и образцы, которым следовали при проектировании Компонентного Каркаса Блэкбокса. Некоторые из приемов проектирования даже привели к включению специфических "каркасных" функций в язык Компонентный Паскаль. Вначале обсуждается языковая поддержка проектирования каркаса, затем обеспечение компонент Компонентного Паскаля и правил, которые регулируют компонентное сотрудничество в Блэкбоксе.
3.1 Языковая поддержка
Каркас представляет собой коллекцию образцов проектирования, приведенную к нотации конкретного языка программирования. Поэтому выразительные возможности языка, в особенности его подмножества определения интерфейса, оказывают главное влияние на то, какая доля проекта каркаса может быть воплощена напрямую в коде. Выражение архитектурных решений и деталей проекта явно в языке важно для уменьшения рисков, связанных с переделками каркаса. Реконструкция каркаса и его компонентов расширения позволяет избежать превращения старых архитектур в хрупкие структуры, грозящие рухнуть под их собственным весом. Предупреждение архитектурной деградации является ключом к поддержанию программных систем продуктивными долгое время, особенно если ПО состоит из компонентов, которые меняются, добавляются или удаляются с течением времени по нарастающей.
Каркас представляет архитектуру для решения определенного класса проблем. Хорошая архитектура использует минимальное число типовых (базовых) элементов, где бы они ни применялись. Последовательное применение типовых элементов упрощает документирование каркаса и облегчает его понимание.
Типовые элементы являются абстрактными решениями проблемы. Для построения каркаса они должны быть сформулированы в терминах конкретного языка программирования. Язык программирования оказывает большое влияние на то, как типовой элемент может быть представлен и как могут поддерживаться его логичность и постоянство.
Есть две основных "философии" построения языка программирования. Одна из них представлена языком Си. Си есть сжатый язык системного программирования, который позволяет легко и эффективно манипулировать структурой памяти данных. Другой подход представлен Паскалем. Паскаль - это читабельный язык прикладного программирования, который обеспечивает высокий уровень безопасности.
Подход Си особенно хорош для написания низкоуровневого кода, такого, как драйверы устройств. Когда Си стал все больше применяться для проектирования приложений, возникла идеология безошибочного программирования (zero errors ideology), которая провозглашает, что, поскольку ошибки программирования не должны случаться, они не будут случаться. "Настоящий программист" не делает ошибок и поэтому нет нужды в средствах защиты, "давящих" на него со стороны языка. Функции безопасности, такие, как контроль переполнения индекса, нужны начинающим программистам, а для профессионалов они только помеха.
Однако современные психологические исследования показывают, что люди делают ошибки все время, независимо от того, пишут ли они программы, выполняют математические доказательства, пилотируют самолеты или оперируют больного. Ошибки допускаются независимо от того, признаются они или нет. Важно понимать, что большинство ошибок тем легче исправить, чем раньше их удается выявить. Обнаружение ошибок работает лучше в команде, взаимодействующей открыто, где член команды не боится двойного контроля его работы другими (выявляющими ошибки). Хорошие авиапредприятия отрабатывают коллективные действия своих пилотов в условиях стресса. Некоторые прогрессивно мыслящие клиники используют похожий тренинг для хирургов и их ассистентов. Они отбросили идеологию безошибочной работы в своих областях.
В мире программирования в последние десять лет преобладает обратная тенденция в силу того, что язык Си стал основным для всех видов программ. В терминах техники программирования и осознания безопасности это был огромный шаг назад от современного состояния. Большие компании пытаются ограничить потери навязыванием дорогостоящих инструментов, которые привносят лишь ограниченный уровень безопасности, вместо решения проблем там, где они (решения) стоят намного меньше, а именно, на уровне языка.
Но, в то время как программисту трудно признать, что делает ошибки, ему намного легче признать, что другие программисты делают ошибки. Это стало очевидно с появлением Интернета. Интернет позволяет легко, а иногда даже автоматически загрузить и выполнить маленькие программы (аплеты) с неизвестных сайтов. Этому коду вообще оказалось нельзя доверять. К счастью, это вынудило большие компании пересмотреть языки с точки зрения безопасности. Фактически, требования безопасности явились причиной выдвижения языка Java на первое место. Поверхностно Java похож на C++, но, в отличие от Cи и C++, он является полностью защищенным по типам, как Компонентный Паскаль.
В Компонентном Паскале объекты и их классы (типы записей) могут быть полностью спрятаны в модуле или они могут быть полностью экспортированы, т.е. они и их части (поля записи / отдельные переменные) могут быть полностью видимы снаружи определяющего их модуля. На практике полезно иметь еще больше контроля. По этой причине Компонентный Паскаль позволяет определить для каждого поля записи, является ли оно полностью экспортируемым, экспортируемым только для чтения или скрытым. Следующий пример (листинг 3-1) показывает, как звездочка ("*") применяется для экспорта и минус ("-") для более ограниченного экспорта "только для чтения":
MODULE ObxSample;
TYPE
File* = POINTER TO RECORD
len: INTEGER (* пример скрытой переменной *)
END;
Rider* = POINTER TO RECORD
(* здесь может быть несколько курьеров на один файл *)
file-: File; (* пример переменной "только для чтения" *)
eof*: BOOLEAN; (* пример переменной полного экспорта *)
pos: INTEGER (* пример скрытой переменной *)
(* Инвариант: (pos >= 0) & (pos < file.len) *)
END;
PROCEDURE (f: File) GetLength* (OUT length: INTEGER), NEW;
BEGIN
length := f.len
END GetLength;
PROCEDURE (rd: Rider) SetPos* (pos: INTEGER), NEW;
BEGIN
(* защита инвариантов, чтобы ошибки не могли проскочить сквозь компоненты *)
ASSERT(pos >= 0); ASSERT(pos < rd.file.len);
rd.pos := pos
END SetPos;
...
END ObxSample.
Листинг 3-1. Образец модуля на Компонентном Паскале
Java не поддерживает экспорт только для чтения, но он поддерживает защищенные поля, которые являются видимыми только расширениям класса, но не нормальным клиентам. Это свойство уместно, только если наследование выполнения используется с пересечением модульных границ. По причинам, которые лежат за рамками этого текста, наследование выполнения не является хорошей идеей в блэкбоксовых абстракциях, таких, как компоненты, и поэтому не может нормально переноситься через границы компонент или в интерфейсах компонент каркаса. Защищенный экспорт поэтому не поддерживается в Компонентном Паскале.
Безопасность означает разные вещи для разных людей. С одной стороны, C++ может считаться безопаснее Си. С другой стороны, Интернет вызывает озабоченность, которая выходит за пределы просто безопасности; должна также предусматриваться защита (от несанкционированного доступа, криминальных атак и т.д.). Предметами охраны являются способы авторизации и обычно имеют дело на уровне операционной системы или оборудования. Функции защиты более высокого уровня являются предметом библиотечных определений и исполнения. Однако сопутствующих потерь из-за чрезмерного проникновения сквозь аппаратные механизмы защиты можно избежать, если строить защиту на строгих свойствах безопасности используемого языка(ов), что возвращает нас к вопросу о безопасности. Но что точно есть "безопасность"?
Если коротко, безопасность языка программирования означает, что его спецификация позволяет указывать инварианты, и что его выполнение гарантирует, что эти инварианты поддерживаются. (Возможность доверенного выполнения должна предполагаться, эта уверенность должна подтверждаться выживанием после атак.) Коротко: безопасность есть "инварианты, принятые всерьез".
Какие типы инвариантов мы рассматриваем? Большинство фундаментальных инвариантов есть инварианты памяти: память, занятая переменными, может использоваться только таким путем, который допускает язык (например, описание типа). На практике это означает, что произвольный выбор типа должен быть запрещен и что ручное удаление динамических структур данных (освобождение памяти) не должно допускаться, поскольку освобождение может случиться слишком рано и некоторая часть все еще используемой памяти может быть снова распределена и, таким образом, будет использоваться одновременно двумя независимыми переменными. Такие висячие указатели гибельны, но их можно полностью избежать, если вместо ручного освобождения используется автоматическая сборка мусора. Поэтому Java и Компонентный Паскаль используют автоматическую сборку мусора.
Инварианты памяти фундаментальны. Более специфичные для приложения инварианты обычно устанавливаются поверх нескольких взаимодействующих объектов. Например, объект, который представляет путь к файлу, всегда должен иметь текущую позицию, которая лежит внутри файла, где файл представляется вторым объектом. Этот инвариант связывает два объекта (и таким образом классы). Только это может гарантировать, что если язык программирования позволяет определить взаимодействие между двумя объектами, которые являются частными для него, то внешний код не может на него повлиять.
Заметим, что это отличается от "защищенного" отношения, рассмотренного выше. В отличие от
установки отношения между классом и его неизвестными еще подклассами, потомок здесь является классом и который был построен совместно и всегда будет использоваться в связи. Модуль или пакет модулей является подходящим структурированным средством, которое позволяет определить такие свойства безопасности наивысшего уровня. Пакеты Java в этом отношении не идеальны. Поскольку пакеты Java являются открытыми модулями, новые классы могут быть добавлены в пакет во время исполнения (at run-time), и могут полностью нарушать инварианты, которые были установлены ранее. Такое дополнение "чужих" классов в пакет необходимо защищать средствами периода исполнения, которые не подчиняются языковым определениям. В Java это связано с концепцией уникального владения: каждый пакет, по идее, принадлежит его источнику и только этот единственный источник имеет право добавлять новые классы в пакет. В любом случае пакет Java является улучшением по сравнению с многими другими объектно-ориентированными языками, например, полностью неструктурированным подходом дружественных классов в С++, или полным отсутствием подходящего конструкта в стандартном Smalltalk.
В противоположность пакетам Java Компонентный Паскаль поддерживает закрытые модули, или, для краткости, модули. В Компонентном Паскале модуль является отдельной единицей компиляции, загрузки и сокрытия информации.
Применение строгой типизации и сокрытия информации облегчает обнаружение ошибок на возможно более ранней стадии, когда их легко и недорого исправить. Это ценно, поскольку позволяет повысить программную устойчивость.
Но преимущество типовой и модульной безопасности простирается дальше. Оно обеспечивает большую гибкость. На первый взгляд это кажется удивительным. Почему ограничения, такие как типы (которые ограничивают операции над переменными) и модули (которые ограничивают видимость) создают что-то еще, кроме уменьшения гибкости? Причина этого парадокса переработки (refactoring paradoxon) двоякая. С одной стороны, всё, что полностью скрыто в модуле, может быть изменено вмешательством в этот единственный модуль. Локальные изменения в скрытой части модуля никак не отдаются за его пределами. Даже не требуется перекомпиляция других модулей-клиентов. С другой стороны, когда строго типизированный интерфейс по какой-то причине меняется, простая перекомпиляция выявит несоответствие в используемом интерфейсе, например, изменение типа или имени метода. Компилятор, таким образом, реально может повысить уверенность в программной системе, которая была модифицирована некоторыми интерфейсными изменениями.
Контролируя типизированный интерфейс на аккуратно выбранном уровне детализации (разбиения на модули), можно достичь баланса между бинарной совместимостью версий и выявлением определенных несоответствий. Компонентный Паскаль поддерживает строгую типизацию, позволяющую выявлять такие несоответствия. Например, вновь введенный метод должен быть помечен как NEW, и VAR параметры могут быть уточнены как IN или OUT параметры. В Java, например, невозможно различить новый метод, попытку перезагрузки или переопределения (overriding). Ошибка в имени метода, изменении базы или подкласса, или комбинация несовместимых версий может приводить к ошибкам, которые трудно локализовать.
Каркас обычно предопределяет интерфейсы для расширений каркаса. Каркас даже может содержать код, который использует эти интерфейсы, хотя собственно исполнение еще не существует. Вызов кода, который resides "higher up" в модульной иерархии, типично для объектно-ориентированных каркасов. Язык может поддерживать этот типичную для каркаса схему потока управления через определенную форму интерфейсов, которые являются абстрактными классами, которые можно применять где угодно. Компонентный Паскаль поддерживает записи абстрактных типов с единственным наследованием таким образом, что возможен широкий спектр от полностью абстрактных до полностью конкретных типов. Java похож на Компонентный Паскаль в этом отношении, за тем исключением, что он дополнительно поддерживает конструкт раздельный интерфейс. Интерфейс Java - это то же, что и полностью абстрактный класс, за исключением того, что он допускает множественное (интерфейсное) наследование.
MODULE TestViews;
TYPE
View* = POINTER TO ABSTRACT RECORD
(* частично абстрактный тип *)
context-: Context;
... some hidden fields ...
END;
Context* = POINTER TO ABSTRACT RECORD END;
(* полностью абстрактный тип *)
PROCEDURE (v: View) Restore* (l, t, r, b: INTEGER), NEW, ABSTRACT;
...
END TestViews.
Листинг 3-2. Полуабстрактный и абстрактный типы записей в Компонентном Паскале
Инварианты являются свойствами, которые предположительно остаются неизменными. Тогда возникает вопрос, может ли подтип (подкласс / расширенный тип) произвольно менять поведение своего базового типа. В объектно-ориентированных языках такие модификации могут быть достигнуты поправками [?, overriding] унаследованных методов. Java позволяет делать классы или методы финальными [final], давать проектировщику каркаса возможность предотвратить любой вид нарушения инварианта через "заднее крыльцо" правок [?, overriding].Типы записей Компонентного Паскаля являются финальными по умолчанию, они могут быть явно помечены как расширяемые.
Компонентный Паскаль превосходит Java в нескольких других языковых конструктах. Один является ограниченными [limited] записями. Это записи, которые могут быть расширены и размещены только внутри описывающего их модуля. С точки зрения перспективы импорта модулей ограниченные типы являются финальными и даже не размещаемыми. Это позволяет гарантировать, что все размещения происходят централизованно в определяющем (каркасе) модуле, что дает этому модулю полный контроль над инициализацией. Например, это позволяет предлагать фабричные [разработчиками] функции, которые размещают объект и инициализируют его разными способами, устанавливая инварианты перед тем, как объект попадет в клиентский модуль. Этот механизм гибче и проще, чем конструкторы, которые используются в Java.
Экспорт "только для исполнения" - это главный пример свойства, являющегося причиной типичных шаблонов проектирования каркаса. Методы типа запись могут быть экспортированы "только для исполнения" путем указания дефиса вместо звездочки. Метод "только для исполнения" может вызываться только внутри определяющего модуля. Но он может быть исполнен [implemented] вне определяющего модуля в исполняющем компоненте каркаса. Например, механизм сохранения Компонентного Каркаса Блэкбокса использует это свойство, чтобы защитить методы загрузки и выгрузки [Internalize и Externalize] от вызова их вне корректного контекста. По существу, каркас (в данном случае модуль Stores) использует методы "только для исполнения" всеми возможными законными способами (выполняет все законные способы применения) и экспортирует их только для целей исполнения.
Для методов, которые представляют интерфейсные варианты, поддерживается атрибутный метод EMPTY (пустой). Пустой метод есть полностью абстрактная ловушка, которая может быть использована в расширении, но в отличие от абстрактных методов ее не требуется использовать (?). Например, образ [вид, view] имеет пустой метод HandleCtrlMsg, который необходимо применять только в образах, которые реагируют на пользовательский ввод, например, через мышь или клавиатуру.
В книге Design Patterns (Проектные шаблоны) ["Design Patterns, Elements of Reusable Object-Oriented Software"; Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides; Addison-Wesley, 1994; ISBN 0-201-63361-2] обозначен список общих проблем проектирования. Эти проблемы часто ведут к необходимости перепроектирования, поскольку ПО не дает достаточной свободы для внесения изменений. Некоторые из этих проблем решены в Компонентном Паскале:
Создание объекта указанием класса явно
Модули позволяют скрывать классы. Скрытый класс не может быть прямо подтвержден клиентским модулем, поскольку он там невидим. Это позволяет навязать множество непрямых механизмов размещения. Абстрактные типы записей позволяют отделить интерфейсы от исполнения, так что абстрактные типы записей могут быть экспортированы без риска прямого размещения клиентами.
Как и абстрактные типы, ограниченные [limited] типы не могут быть напрямую размещены клиентами.
Экспорт "только для исполнения" ограничить последовательности размещения и инициализации определяющим модулем, что также предохраняет клиентов от обязанности самим уточнять классы прямым подтверждением их.
Эти свойства можно комбинировать для разработки безопасных исполнений всеми создающими шаблонами, описанными в Design Patterns: abstract factories, builders, factory methods, prototypes и singletons.
Зависимость от некоторых операций
Переменные типа статическая запись могут использоваться как легковесные (размещенные на стеке) объекты сообщений, вместо использования жестко кодированных сигнатур методов (?) или тяжеловесных (размещенных на куче) объектов сообщений. Записи сообщений могут быть пересланы, отфильтрованы, опубликованы и так далее. Но они не могут нарушить безопасность типа, поскольку адресация статических записей не может меняться небезопасным способом.
Записи сообщений могут использоваться для выполнения цепочки обязательств и шаблонов наблюдателя (?), которая развязывает отправителя сообщения и его получателя(ей).
Зависимость от оборудования и программных платформ
Зависимость от представлений или исполнений объекта
Переносимость - это одно из главных преимуществ использования настоящего языка высокого уровня. Компонентный Паскаль абстрагируется от обеспечивающего его оборудования, кроме того, его семантический интервал достаточно мал, чтобы мог быть сгенерирован очень эффективный машинный код. Как в Java, размеры типов определяются так, что перенос данных между машинами не создает проблем.
Алгоритмические зависимости
Части алгоритма могут заменяться с использованием абстрактных методов, пустых (hook) методов или простых объектов. Экспорт "только для исполнения" делает возможным безопасное назначение обязанностей: последовательности корректных вызовов методов должны выполняться определением модуля, исполнение методов должно выполняться расширяющим программистом. Это свойство позволяет разрабатывать безопасные исполнения всех поведенческих шаблонов (строитель, внутренний итератор, стратегия, временный метод и так далее).
Плотное сопряжение
Модули действуют как границы видимости. Поэтому плотное сопряжение возможно, где оно необходимо (внутри модульного исполнения), тогда как неплотное сопряжение возможно на модульных границах. Это упрощает безопасное исполнение в принципе все шаблонов проектирования.
Расширение функциональности подклассами
Классы могут быть скрыты в модулях. Финальные или ограниченные классы и финальные методы могут экспортироваться без риска того, что могут сделать подклассами или исказить.
Неспособность удобно менять классы
Строгая типизация, атрибуты записи и метода, такие, как NEW, и утверждения (assertions) периода исполнения повышают уверенность, что интерфейс может быть изменен таким образом, что все клиенты снова могут быть сделаны согласованными легко и надежно. Это основа программного проектирования и поэтому важна для всех видов проектов.
Все эти проблемы имеют одну общую тему: локальное изменение может вызвать волновой эффект, который отразится на программной системе в целом. Хорошие языки и приемы проектирования помогают проектировать с учетом возможности изменений в будущем:
Гарантировать, что возможные проектные изменения имеют только локальные эффекты.
Где это невозможно, гарантировать, что эффекты обнаруживаются компилятором.
Где это невозможно, гарантировать, что эффекты обнаруживаются во время исполнения как можно раньше.
Ясно, что еще остается существенный разрыв между современными языками, такими как Компонентный Паскаль, и языками полных спецификаций, которые также позволяют задать семантику программы. В будущем придется закрыть такие части этого разрыва, которые имеют достаточно хорошее отношение цена/качество, т.е. помогают изменить поведение компонент контролируемым образом, без того, чтобы программы становились неудобоваримыми для средних программистов.
3.2 Модули и подсистемы
В этом разделе мы опишем более конкретно, как выглядит код Компонентного Паскаля и как он управляется Блэкбоксом. Для этой цели мы должны более детально рассмотреть особенности Блэкбокса, чем в других разделах этой книги.
Весь код Компонентного Паскаля живет внутри модулей. Модуль есть единица компиляции Компонентного Паскаля. Модуль имеет интерфейс и скрытое исполнение. Синтаксически это достигается пометкой некоторых элементов в модуле, например, некоторых типов и процедур, как экспортируемые. Всё, что не экспортировано, невидимо, и поэтому напрямую недоступно извне модуля. Если модулю нужен сервис одного или нескольких других модулей, он импортирует их. Поэтому модуль объявляет, что ему требуются описания интерфейсов импортированных модулей в период компиляции, и подходящее исполнение в период выполнения. Листинг 3-3 показывает возможное исполнение модуля, названного ObxPhoneDB. Он экспортирует три процедуры для входа в телефонный справочник: по индексу, по имени и по номеру. Обратите внимание на звездочки, которые помечают элементы как экспортируемые, в нашем случае это тип String и три процедуры входа:
MODULE ObxPhoneDB;
CONST
maxLen = 32; (* максимальная длина строк имя/число *)
maxEntries = 5; (* максимальное число входов в базу данных *)
TYPE
String* = ARRAY maxLen OF CHAR;
Entry = RECORD
name, number: String
END;
VAR db: ARRAY maxEntries OF Entry;
PROCEDURE LookupByIndex* (index: INTEGER; OUT name, number: String);
BEGIN (* дан индекс, возвращается соответствующая пара <name, number> *)
ASSERT(index >= 0);
IF index < maxEntries THEN
name := db[index].name; number := db[index].number
ELSE
name := ""; number := ""
END
END LookupByIndex;
PROCEDURE LookupByName* (name: String; OUT number: String);
VAR i: INTEGER;
BEGIN (* дано имя, поиск соответствующего номера телефона *)
i := 0; WHILE (i # maxEntries) & (db[i].name # name) DO INC(i) END;
IF i # maxEntries THEN (* имя найдено в db[i] *)
number := db[i].number
ELSE (*имя не найдено в db[0..maxEntries-1] *)
number := ""
END
END LookupByName;
PROCEDURE LookupByNumber* (number: String; OUT name: String);
VAR i: INTEGER;
BEGIN (* дан номер телефона, поиск соответствующего имени *)
i := 0; WHILE (i # maxEntries) & (db[i].number # number) DO INC(i) END;
IF i # maxEntries THEN (* номер найден в db[i] *)
name := db[i].name
ELSE (* номер не найден в db[0..maxEntries-1] *)
name := ""
END
END LookupByNumber;
BEGIN (* инициализация содержимого справочника *)
db[0].name := "Даффи Дьюк"; db[0].number := "310-555-1212";
db[1].name := "Виль Е. Койот"; db[1].number := "408-555-1212";
db[2].name := "Скрудж МакДьюк"; db[2].number := "206-555-1212";
db[3].name := "Хью Льюис"; db[3].number := "415-555-1212";
db[4].name := "Томас Деви"; db[4].number := "617-555-1212"
END ObxPhoneDB.
Даффи Дьюк 310-555-1212
Виль Е. Койот 408-555-1212
Скрудж МакДьюк 206-555-1212
Хью Льюис 415-555-1212
Томас Деви 617-555-1212
Листинг 3-3. Исполнение of ObxPhoneDB
Перед тем, как модуль использовать, его необходимо загрузить с диска в оперативную память. Но перед тем, как он может быть загружен, его необходимо откомпилировать (команда Разработка -> Компилировать). Компилируя модуль, компилятор порождает кодовый файл и символьный файл. Кодовый файл содержит исполняемый код, который может быть загружен в память. Кодовый файл есть разновидность суперлегкой DLL (динамически загружаемой библиотеки). Компилятор также производит символьный файл, который содержит бинарное представление интерфейса модуля. Если модуль импортирует другие модули, компилятор читает символьные файлы этих модулей, чтобы проверить, что их интерфейсы используются корректно. Процесс компиляции можно изобразить так:
Рис. 3-4. Процесс компиляции
Когда вы компилируете модуль первый раз, генерируется новый символьный файл. В рабочем журнале компилятор пишет примерно следующее:
компилируется "ObxPhoneDB"
new symbol file 564 640
Первые два числа показывают, что машинный код в новом кодовом файле имеет длину 564 байта.
Второе число показывает, что модуль содержит 640 байт глобальных переменных (пять входов в переменной db; каждый вход состоит из двух строк по 32 элемента в каждой; каждый элемент имеет 2-байтный Юникод-символ). Если символьный файл точно для такого интерфейса уже существует, компилятор выдает более короткое сообщение:
компилируется "ObxPhoneDB" 564 640
Если интерфейс изменился, компилятор пишет новый символьный файл и указывает в рабочем журнале, какие изменения появились по сравнению со старой версией. Например, если вы только что изменили процедуру LookupByNumber, компилятор пишет:
компилируется "ObxPhoneDB"
LookupByNumber is new in symbol file 964 640
Символьный файл используется только во время компиляции, он не используется во время выполнения. Чтобы загрузить модуль, достаточно его кодового файла. Модули загружаются динамически, т.е. нет отдельного шага линкования, как в большинстве статических языков. Чтобы увидеть список загруженных модулей, выполните Инфо->Загруженные модули. Откроется окно с содержимым, похожим на следующее:
имя модуля байт использовано клиенты скомпилирован загружен Обновить
DevCompiler 6945 0 29.12.2004 18:47:13 09.07.2005 22:26:56
DevCPV486 35884 1 29.12.2004 18:47:13 09.07.2005 22:26:56
DevCPC486 46245 1 29.12.2004 18:47:13 09.07.2005 22:26:56
DevCPL486 17736 2 29.12.2004 18:47:13 09.07.2005 22:26:56
...
Config 2133 0 26.06.2005 4:39:44 09.07.2005 22:26:25
Init 411 0 29.12.2004 18:48:43 09.07.2005 22:26:25
Controls 58307 6 26.06.2005 2:32:05 09.07.2005 22:26:25
...
Files 426 67 29.12.2004 18:47:00 слинкован
Kernel 27353 69 26.06.2005 2:34:23 слинкован
National 3635 14 26.06.2005 1:50:57 слинкован
...
StdLoader 8104 0 29.12.2004 18:47:00 слинкован
Таблица 3-5. Список загруженных модулей
Список показывает все загруженные модули. Для каждого модуля показан его размер, сколько других модулей он импортирует, когда он был откомпилирован и когда он был загружен.
Легко получить список уже загруженных модулей, но что с модулями, которые еще не загружены? Желание иметь доступ к богатству заранее подготовленных компонентов поднимает некоторые организационные проблемы. Как вам точно определить, какие компоненты доступны? Как вам определить, какие из доступных компонентов дают то, что вам нужно?
Это предмет соглашений, документации и поддерживающего инструментария. В Блэкбоксе решено, что коллекция связанных компонентов, называемая подсистема, размещается в отдельным папках; все они находятся в корневой папке Блэкбокса. Там есть такие подсистемы, как System, Std, Host, Mac, Win, Text, Form, Dev или Obx. Полная коллекция подсистемы называется депозитарий (хранилище) Блэкбокса. Идея, лежащая в основе структуры депозитария, состоит в том, чтобы всё, что принадлежит компоненту (кодовые файлы, символьные файлы, документация, исходные тексты) сохранялось вместе в систематической и простой структуре папок в соответствии с правилом
Держать все составляющие компонента в одном месте.
Единственно подходящим для компонентно-ориентированного ПО является вариант, когда добавление и удаление компонентов может выполняться по нарастающей, добавлением или удалением папки. Все виды механизмов централизованной инсталляции или регистрации, которые распространяют составляющие компонента, должны быть исключены, поскольку они неизбежно ведут к (ненужным) проблемам управления.
Рис. 3-6. Стандартные подсистемы Блэбокса
Каждая папка подсистемы, как Obx, может содержать следующие подпапки:
Рис. 3-7. Структура типичной папки подсистемы
Исходный модуль сохраняется в папке Mod подсистемы. Имя файла соответствует имени модуля, но без префикса подсистемы; например, модули ObxPhoneDB и ObxPhoneUI сохранены как Obx/Mod/PhoneDB и Obx/Mod/PhoneUI соответственно. Для каждого исходного файла может быть соответствующий символьный файл, например, Obx/Sym/PhoneDB; соответствующий кодовый файл
Obx/Code/PhoneDB; и соответствующий файл документации, например, Obx/Docu/PhoneDB. Также может быть 0 или более ресурсных документов в подсистеме, например, Obx/Rsrc/PhoneUI. Причем нет необходимости в соотношении 1:1 между модулями и ресурсами, хотя обычно рекомендуется использовать имя модуля как часть имени ресурса для упрощения поддержки.
Модули, чьи имена имеют форму SubMod, такие, как TextModels, FormViews или StdCmds, сохраняются в их соответствующих подсистемах, заданных префиксами имен, например, Text, Form или Std. Имя подсистемы начинается с заглавной буквы и далее могут идти несколько заглавных и затем несколько строчных букв или цифр. Первая заглавная буква после этого обозначает отдельный модуль в подсистеме.
Модули, которые не принадлежат подсистеме, т.е. модули, имена которых не имеют формы SubMod, сохраняются в специальной подсистеме, названной System. Вся библиотека Блэкбокса и ядро каркаса принадлежат к этой категории, это модули Math, Files, Stores, Models и т.д.
Каждая папка подсистемы может содержать следующие вложенные папки:
Code Папка с исполняемыми кодовыми файлами, т.е. легкими DLL.
Например, для модуля "FormCmds" там есть файл "Form/Code/Cmds".
Модуль для связи с настоящими DLL ОС (Windows DLL или кодовые
фрагменты Mac OS) не имеют кодового файла.
Docu Папка с полностью документированными интерфейсами и другими docu.
Например, для модуля "FormCmds" там есть файл "Form/Docu/Cmds".
Для модуля, который используется только внутренне (для служебных целей
Блэбокса), его файл docu не поставляется.
Часто есть общие файлы документации, которые не относятся к отдельному
модулю подсистемы. Такие файлы содержат один или более дефисов в их
именах, например, "Dev/Docu/P-S-I".
Типичными файлами являются
"Sys-Map" (обзор гиперссылок на другие документы этой подсистемы)
"User-Man" (руководство пользователя)
"Dev-Man" (руководство разработчика)
DocuRu Папка с переводами на русский язык документов из Docu.
Mod Папка с исходными модулями.
Например, для модуля "FormCmds" там есть файл "Form/Mod/Cmds".
Для модуля, который не публикуется в исходном виде ("белый ящик" =
"white box"), его исходный текст не поставляется пользователям.
Rsrc Папка с ресурсными документами подсистемы.
Например, для модуля "FormCmds" там есть файл "Form/Rsrc/Cmds".
Может быть ноль, один или более ресурсных файлов для одного документа.
Если есть несколько файлов, второй получает суффикс "1", третий суффикс
"2" и так далее. Например, "Form/Rsrc/Cmds", "Form/Rsrc/Cmds1",
"Form/Rsrc/Cmds2" и т.д.
Часто есть добавочные файлы, которые не относятся к отдельному модулю
подсистемы. Типичными файлами являются
"Strings" (строковые ресурсы этой подсистемы)
"Menus" (меню этой подсистемы)
Sym Папка с символьными файлами.
Например, для модуля "FormCmds" там есть файл "Form/Sym/Cmds".
Для модуля, который используется только внутренне, его символьный файл
не поставляется.
Таблица 3-8. Содержание стандартных папок подсистемы
Если вы что-то хотите найти в депозитарии, его подсистемах или их папках, вы можете выполнить команду Инфо->Обзор подсистем. Если вы хотите найти больше сведений о модуле, вы можете выделить имя модуля в тексте и затем выполнить Инфо->Исходный текст, или Инфо->Документация. Эти команды открывают модульные файлы Mod, Sym или Docu. Для этой цели Инфо->Интерфейс преобразует бинарное представление символьного файла в читабельное текстовое описание. Например, наберите строку "ObxPhoneDB" в рабочем журнале, выделите строку и затем выполните команду просмотра Инфо->Интерфейс. В результате в новом окне будет открыт следующий текст:
DEFINITION ObxPhoneDB;
TYPE
String = ARRAY 32 OF CHAR;
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: String);
PROCEDURE LookupByName (name: String; OUT number: String);
PROCEDURE LookupByNumber (number: String; OUT name: String);
END ObxPhoneDB.
Листинг 3-9. Определение ObxPhoneDB
Модульное определение, сгенерированное браузером синтаксически, является подмножеством модульного исполнения, за тем исключением, что ключевое слово MODULE заменено на DEFINITION. Этот синтаксис можно назвать языком описания интерфейса (IDL) Компонентного Паскаля. Тексты в этом языке обычно создаются по полным исходным текстам модулей браузером или аналогичным инструментом, так что нет нужды писать их вручную или компилировать.
Поскольку команды браузера оперируют с символьным файлом модуля, он может быть использован, даже когда еще нет ни настоящей документации, ни кодового файла. Во время прототипирования, когда документация редко имеется, просмотр символьного файла очень удобен для быстрого получения деталей, таких, как сигнатура процедуры, или обзора интерфейса всего модуля. Когда доступна полная документация, может использоваться команда Инфо->Документация. Она открывает файл документации модуля, который начинается с определения модульного интерфейса, точно так, как показано выше, но затем продолжается назначением модуля и детальным описанием различных элементов, экспортированных модулем, например:
Модуль ObxPhoneDB обеспечивает доступ к телефонному справочнику. Доступ может быть по индексу, по имени или по номеру. Вход состоит из строки имени и телефонного номера. Ничто не может быть пустым. Минимальный индекс есть 0, и все входы являются смежными.
PROCEDURE LookupByIndex (index: INTEGER; OUT name, number: ARRAY OF CHAR)
Возвращает пару <name, number> входа index. Если индекс слишком большой, возвращается <"", "">.
Процедура выполняется за постоянное время.
Pre
index >= 0 20
Post
index правильный
name # "" & number # ""
index неправильный
name = "" & number = ""
PROCEDURE LookupByName (name: ARRAY OF CHAR; OUT number: ARRAY OF CHAR)
Возвращает телефонный номер, связанный с name, или "", если не найден вход для name.
Процедура выполняется за линейное время, в зависимости от размера базы данных (справочника).
Post
name найдено
number # ""
name не найдено
number = ""
PROCEDURE LookupByNumber (number: ARRAY OF CHAR; OUT name: ARRAY OF CHAR)
Возвращает имя, связанное с number, или "", если не найден вход для number.
Процедура выполняется за линейное время, в зависимости от размера базы данных (справочника).
Post
number найдено
name # ""
number не найдено
name = ""
Листинг 3-10. Документация ObxPhoneDB
Отметим, что предусловия и постусловия задокументированы в полуформальной нотации. Их целью не является дать полную формальную спецификацию, но помочь сделать простой текст описания менее двусмысленным, где это возможно, без наворотов сложных (и потому нечитабельных) формальных условий. В Блэкбоксе используются следующие номера утверждений для контроля периода исполнения:
Свободны 0 .. 19
Предусловия 20 .. 59
Постусловия 60 .. 99
Инварианты 100 .. 120
Резервировано 121 .. 125
Еще не использовано 126
Резервировано 127
Листинг 3-11. Номера утверждений в Блэкбоксе
Хорошо известно, что определение ошибки тем более затруднено и дороже обходится, чем позже она обнаруживается, т.е. чем дальше разнесены источник и его эффекты. Это позволяет сформулировать правило:
Позволяйте ошибкам заявлять о себе как можно раньше.
В компонентно-ориентированных системах дефекты всегда должны содержаться в их компонентах
и не распространяться на другие компоненты. Другие компоненты даже могут быть черными ящиками и не иметь исходных текстов, что делает отладку на уровне исходных текстов невозможной. Более того, поток передачи управления в больших объектно-ориентированных программных системах настолько запутанный, что нереально, и это пустая трата времени, проследить его за пределами границ компонентов для целей отладки.
Единственный жизнеспособный отладочный подход есть проектирование всего, от языка программирования до библиотек, до компонентов и приложений, используя оборонительный стиль программирования. В частности, входные точки в компоненты (вызовы процедур/методов) должны останавливать исполнение, если их предусловия не обеспечены:
Никогда не позволяйте ошибкам проникать сквозь границы компонентов.
К счастью, большинство проверок предусловий недорого и поэтому их отключение при исполнении не имеет смысла. Это важно, поскольку в компонентно-ориентированной системе проверки периода исполнения не могут быть выключены в конечной (готовой) системе, поэтому разрабатываемая и готовая системы не различаются. На практике большинство компонентов уже отлажено в режиме черного ящика ("продукция"), а другие отлаживаются в режиме белого ящика. Готовые компоненты должны взаимодействовать, чтобы доказать приверженность сформулированному выше правилу, которое означает никогда не отключать проверки периода исполнения.
3.3 Интерфейсы типа узкое горло
Один частный шаблон, который мы обсудим здесь, есть шаблон Носитель-Курьер-Преобразователь (Carrier-Rider-Mapper). Этот шаблон используется несколькими путями в Компонентном Каркасе Блэкбокса: в текстовой подсистеме, в файловой абстракции, в рамочной абстракции, в абстракции контейнер/контекст и других. Давайте рассмотрим в качестве примера текст.
Пусть текст будет носителем. Носитель есть объект, который несет (содержит) данные, в этом случае текстовые данные. По сути, текст можно рассматривать как линейный поток элементов, где элементы имеют такие атрибуты, как шрифт, цвет, стиль и вертикальный сдвиг (для верхних и нижних индексов). Элементы являются символами или образами (views). Для всех практических целей образ в тексте можно рассматривать просто как специальный символ.
Когда читается текст, удобно не требовать указания позиции для любого и каждого прочитанного символа. Это удобство может быть достигнуто поддержкой текущей позиции, т.е. текст сам знает, где читать следующий символ. Каждая операция чтения автоматически увеличивает текущую позицию. Некоторые клиентские объекты могут использовать текстовый носитель одновременно. Например, текстовому образу нужно читать его текст, когда он перерисовывает текст на экране, и команда меню может нуждаться в чтении текста как своего входа. Эти клиенты независимы друг от друга; им незачем знать друг о друге. По этой причине текущая позиция чтения не может сохраняться в самом текстовом носителе, поскольку это может означать, что клиенты будут взаимодействовать друг с другом и потеряют независимость.
Чтобы избежать такого взаимодействия, носитель имеет функции размещения, которые возвращают так называемые объекты-курьеры (rider). Курьер - это независимый доступ к данным носителя. Каждый текстовый курьер имеет собственную текущую позицию и может далее оставаться таковым как текущие атрибуты.
Рис. 3-12. Носитель-Курьер (Carrier-Rider) разделение
Причиной, почему носитель и курьер разделены на разные типы данных, является отношение один-ко-многим между сущностями: для одного носителя может быть произвольное число (включая ноль) курьеров.
Обычно требуется, чтобы носитель и курьер исполнялись одним и тем же компонентом, поскольку курьер должен иметь хорошее знание о внутренностях его носителя. Например, текстовые курьеры и текстовые носители оба используются в модуле TextModels. Текстовый курьер содержит скрытые указатели на внутреннюю структуру данных текстового носителя. Поскольку эта информация полностью скрыта за границами модуля TextModels, внешний клиент не может сделать курьер несовместимым с его носителем. Этот тип инварианта, гарантированный модульной системой Компонентного Паскаля, является примером того, почему сокрытие информации за пределами отдельных классов является важным по соображениям безопасности.
В терминологии проектирования шаблонов текстовый курьер есть внутренний итератор. Однако не все курьеры с необходимостью итераторы. Например, контекстный объект, управляемый контейнером, не является итератором.
Текстовые курьеры бывают двух видов: "анализаторы" (reader) и "синтезаторы" (writer). Анализаторы поддерживают чтение символов и образов, тогда как синтезаторы поддерживают запись символов и образов. Например, могут быть сделаны следующие вызовы:
reader.ReadView(view)
или
writer.WriteChar("X")
Часто программисту нужно читать или писать сложные последовательности символов, так что работа на уровне отдельных символов слишком неудобна. Желательны высокоуровневые абстракции для чтения и записи. Это является целью преобразователей (mappers). Преобразователь содержит курьера, которого он использует для обеспечения более проблемно-ориентированных операций для записи или для чтения. Поскольку существуют очень разные проблемы программирования, разные приложения могут использовать разных преобразователей, возможно даже работающих с одним и тем же носителем.
Для текстовых манипуляций Блэкбокс предлагает модуль TextMappers, который определяет и исполняет два текстовых преобразователя: форматер для записи и сканер для чтения.
Рис. 3-13. разделение Carrier-Rider-Mapper
Как сканер, так и форматер работают на уровне символов Компонентного Паскаля: с целыми числами, вещественными числами, строками и т.д. Например, следующие вызовы могут быть:
scanner.ReadInt(int)
или
formatter.WriteReal(3.14)
Если есть разные преобразователи для одного вида носителя, они все должны исполняться в терминах интерфейса курьера. По этой причине интерфейс курьер/носитель иногда называется интерфейсом узкого горла. Причина, по которой курьеры и преобразователи разделены, не только в отношении один-ко-многим как между носителем и курьером, так в отношении один-ко-многим между преобразователем и курьером, но и в независимой расширяемости: особые обстоятельства могут требовать особых преобразователей. Если носители и курьеры строго придерживаются хорошо спроектированного курьерского интерфейса (типа узкое горло), можно добавлять новых преобразователей в любое время и использовать их с тем же носителем.
Даже лучше: интерфейс носитель/курьер может быть абстрактным интерфейсом, так что могут быть разные исполнения его. Например, файловый носитель может быть исполнен по-разному для файлов на гибком диске, файлов на жестком диске, файлах CD-ROM и сетевых файлов. Но если все они исполняют один и тот же интерфейс, то все файловые преобразователи могут работать со всеми файловыми исполнениями. Сравните это с ситуацией, где вы вынуждены заново исполнить все преобразователи для всех носителей: вместо исполнения n носителей плюс m преобразователей, вынуждены исполнить n носителей плюс n * m преобразователей! Там, где случается такое расширение в двух измерениях (носитель/курьер и преобразователь), интерфейс узкого горла необходим, чтобы избежать так называемого декартова произведения проблем, т.е. взрыва [количества] исполнений.
Отметим, что интерфейс узкого горла сам не расширяемый, поскольку каждое расширение, которое не может быть выполнено в терминах интерфейса узкого горла, сводит на нет все его существующие исполнения. Например, если вы расширяете драйвера устройства для отображения черно-белой точечной картинки цветным расширением, то все существующие исполнения драйвера устройства должны быть обновлены. Поскольку это может быть сделано разными компаниями, это может стать главной проблемой.
Проблема может быть снята, если новое расширение интерфейса определено как опция: тогда клиенты должны тестировать, где опция поддерживается. Если нет, то клиент либо должен сигнализировать, что он не может работать с этим оборудованием, либо он должен изящно деградировать, предлагая более ограниченную функциональность. Если опциональный интерфейс поддерживается и используется, он действует как вид конспирации между исполнением интерфейса и его клиентом. Это приемлемо, но, несомненно, уменьшает комбинации клиентов и исполнений, которые полностью функциональны. Это подчеркивает, насколько важны хорошие проекты узкого горла, чтобы исключить необходимость в последующих расширениях.
Рис. 3-14. Расширяемость в двух измерениях
В терминах проектных шаблонов, шаблон Носитель-Курьер-Преобразователь (Carrier-Rider-Mapper) решает проблему гибкости и удобства доступа к носителю данных, однако он является исполняемым. Он может рассматриваться как состоящий из двух простых и наиболее важных шаблонов (схем, приемов, методов) проектирования: разделение одного объекта на несколько объектов, чтобы обеспечить отношение многие-к-одному; и разбиение одного объекта на два объекта для обеспечения независимой расширяемости:
Разбейте абстракцию на два интерфейса, если некоторые клиенты в отдельных случаях должны входить одновременно, и если независимое состояние должно осуществляться для каждого клиента.
Разбейте абстракцию на два интерфейса, если может потребоваться ее расширить независимо в двух различных измерениях.
Разделение Носитель-Курьер-Преобразователь возвращает к исследовательскому проекту ["Insight ETHOS: On Object-Orientation in Operating Systems"; Clemens Szyperski; vdf, Zьrich, 1992, ISBN 3 7281 1948 2], предшествовавшему Блэкбоксу. Этот проект использовал некоторые шаблоны проектирования и правила проектирования (например, исключение наследования исполнения), которые также описаны в Design Patterns. В терминологии Design Patterns комбинация Курьер-Преобразователь (или Носитель-Преобразователь, если нет курьера) формирует шаблон мост (bridge).
В Блэкбоксе курьеры часто создаются и управляются особым образом. Курьер обычно находится под исключительным контролем одного клиентского объекта, Поскольку, кроме всего прочего, причиной, почему могут быть множественные курьеры на одного носителя (и, таким образом, почему два различных), является именно желание позволить нескольким клиентам иметь доступ к данным носителя через его частные пути доступа. Поскольку курьеры создаются в таких управляемых окружениях, Блэкбокс обычно создает курьеры следующим путем:
rider := carrier.NewRider(rider);
Идея в том, что если уже существует старый курьер, который больше не используется, он может быть переработан. Переработка делается фабричным методом NewRider (см.следующий раздел), если возможно. Конечно, переработка законна только тогда, когда старый курьер больше нигде не используется для чего-либо еще (возможно кем-то еще); вот почему так важно, что курьер поддерживается в контролируемом окружении.
Обычно процедура NewRider применяется следующим образом:
PROCEDURE (o: Obj) NewRider (old: Rider): Rider;
VAR r: RiderImplementation;
BEGIN
IF (old # NIL) & (old IS RiderImplementation) THEN (* переработать старый курьер *)
r := old(RiderImplementation)
ELSE (* разместить новый курьер *)
NEW(r)
END;
... initialize r ...
RETURN r
END NewRider;
Листинг 3-15. Переработка курьера
Этот подход используется в Блэкбоксе для файлов, текстов и форм. Он может давать существенную разницу в эффективности в зависимости от типа приложения. Однако там, где эффективность несущественна, хорошее идеей будет избегать этот механизм, чтобы исключить любую возможность
небрежного использования курьеров в разных контекстах одновременно.
3.4 Создание объекта
Компонентный Каркас Блэкбокса в основном спроектирован как черный ящик. Он строго отделяет интерфейс от исполнения. Клиент может только импортировать и, таким образом, напрямую использовать или манипулировать интерфейсами объектов. Исполнения спрятаны внутри модулей. Это вынуждает модульных клиентов подчиняться следующему правилу проектирования (Gamma et.al.):
Программа для интерфейса, а не для исполнения.
В Компонентном Паскале объектные интерфейсы представлены типами абстрактных записей. Исполнение записи абстрактного типа есть ее конкретное расширение. Обычно исполнения не экспортируются и поэтому не могут быть расширены ("subclassed") в других модулях, что означает невозможность наследования исполнения. Это также позволяет сформулировать правило для программистов, занимающихся расширениями (Gamma et.al.):
Приоритет композиции объекта, а не наследованию классов.
Конкретные типы записей даже не могут быть прямо подтверждены: поскольку клиент не может импортировать объектное использование, чей тип не экспортирован, он не может разместить пример вызовом NEW. Это желательно, поскольку NEW будет привязывать клиентский код навсегда к одному частному исполнению объекта; повторное использование кода для других исполнений станет невозможным где-либо еще. Но как код клиента может решить проблему размещения черного ящика, т.е. получить исполнение объекта без специфических знаний о нем?
Рис. 3-16. Экспортированные интерфейсные записи и скрытые записи исполнения
Вместо вызова NEW может быть возможен вызов функции размещения, так называемой фабричной функции. Например, модуль TextModels может экспортировать функцию New, которая размещает и возвращает текстовую модель. Внутренне она выполняет NEW над неэкспортируемым типом исполнения и, возможно, выполняет некоторую инициализацию. Это лучше, чем прямой вызов клиентами NEW, поскольку модуль размещения может гарантировать корректную инициализацию и новая реализация (версия) модуля может выполнять размещение или инициализацию несколько иным путем, не влияющим на клиента. Однако, фабричные статичные функции являются слишком негибкими. Надлежащее решение проблемы размещения черного ящика требует уровня окольных путей. Есть несколько подходов, чтобы этого достигнуть. Они названы созидательными шаблонами. Блэкбокс использует 4 созидательных шаблона: прототипы, фабричные методы, каталожные объекты и фабричные управляющие. Они объясняются ниже один за другим.
Иногда требуется создать объект того же типа, что и некоторый уже существующий объект. В этом случае существующий объект называется прототипом, который дает фабричную функцию или метод инициализации. Модели Блэкбокса могут действовать как прототипы. Это дает уверенность, что вновь созданный объект имеет точно тот же конкретный тип, что и прототип, и позволяет прототипу и его клону(ам) совместно использовать буферы при необходимости. Например, текстовая модель Блэкбокса и ее клоны разделяют один вспомогательный файл, который они используют для размещения временных данных. Разделение предотвращает размножение открытых файлов.
Иногда существует объект, который может использоваться для создания объекта другого типа. Для этой цели существующий объект предлагает фабричную функцию, фабричный метод. Возможно, может предлагать разные фабричные методы, которые поддерживают разные стратегии инициализации или которые создают разные типы конкретных объектов.
В Блэкбоксе текстовая модель предлагает процедуры NewReader и NewWriter, которые генерируют новых анализаторов и синтезаторов. Они являются курьерскими объектами, которые представляют пути доступа к тексту.
Фабричные функции предназначены для объектов, которые исполняются одновременно ("implementation covariance"). Это всегда случай для курьеров и их носителей.
Но этот подход недостаточен для размещения самих текстовых моделей. Когда появляется первая текстовая модель? Блэкбокс использует специальные объекты с фабричными методами, так называемые фабричные объекты (factory objects). В Блэкбоксе фабричные объекты используются особым образом: они установлены в глобальные переменные и могут быть заменены во время исполнения без влияния на код клиента. По историческим причинам мы называем фабричные объекты, которые используются для конфигурационных целей, директивными объектами (directory objects).
Например, модуль TextModels экспортирует тип Directory, который содержит функцию New. Более того, он экспортирует две переменные dir и stdDir и процедуру SetDir. По умолчанию TextModels.dir используется кодом клиента для размещения новых пустых текстовых моделей. TextModels.stdDir содержит исполнение по умолчанию текстовой модели, что часто полезно при отладке исполнения новой текстовой модели. Например, вы можете использовать старую папку при разработке исполнения новой текстовой модели. Когда новое исполнение готово, вы устанавливаете его объект-каталог вызовом SetDir, таким образом обновляя на лету текстовую подсистему под новое исполнение. Тексты со старым исполнением этим не затрагиваются. Если новое исполнение содержит ошибки, умалчиваемое исполнение может быть переустановлено вызовом TextModels.SetDir(TextModels.stdDir). Текстовая подсистема использует объекты типа каталог их обычным способом. Тот же шаблон проектирования может быть найден в других контейнерных модельных абстракциях; например, для моделей форм. В Блэкбоксе они используются для гораздо более простых моделей и образов; например, для DevMarkers.
Отметим, что объекты, размещенные через папки, часто являются устойчивыми и их исполнения поэтому долгоживущими. По этой причине некоторые различные исполнения появляются через время, которое должно использоваться одновременно. Обычно по умолчанию нормальные объекты папок подсистемы установлены автоматически, когда подсистема загружена. Если другие объекты папок должны быть установлены, используется модуль Config для установки конфигурации желаемых объектов папок при старте.
Имя "объект-каталог" ("directory object") пришло из другого использования шаблона проектирования каталога: в модуле Files файл может быть создан использованием объекта-каталога Files.dir. Но Files.Directory также предлагает средства для нахождения большей информации о текущей конфигурации файловой системы (например, процедур Files.Directory.FileList). Файловые каталоги также интересны, поскольку они показывают, что заменяемый каталог может иногда может нуждаться в продвижении к замененному объекту-каталогу (?). Например, если новый каталог обеспечивает специальные файлы памяти, которые отличаются именами, начинающимися на "M:\", тогда новый каталог должен контролировать каждый файл, проверяя, начинается ли его имя шаблоном, приведенным выше. Если так, то это файл памяти. Если нет, это нормальный файл и должен поддерживаться старым объектом-каталогом.
Может существовать одновременно несколько разных объектов-каталогов. Например, если сервис использует файлы особым образом, он может обеспечивать его собственный объект - файловую папку, которая по умолчанию пересылается стандартному объекту-каталогу файловой системы.
Множественные объекты-каталоги и связывающие объекты-каталоги являются частью шаблона проектирования каталога. Эта связующая часть шаблона является каскадируемой, если новый объект выходит на самый последний старый вместо stdDir.
Отметим, что, в отличие от типичных фабричных классов, каталоги редко расширяют.
Рис. 3-17. Переход между двумя объектами-каталогами
Объекты-каталоги - очень подходящее решение, когда может ожидаться существование одного доминирующего исполнения расширяемого типа черного ящика, без исключения существования других исполнений.
С другой стороны, также могут быть некоторые специальные объекты-каталоги для того же исполнения, но для других целей. Например, может быть специальный объект текстовый каталог для текстов, которые имеют специальную линейку, полезную для программных текстов. Редактор программ предпочтет создавать новые программные тексты через этот каталог, а не через стандартный каталог текстовой подсистемы.
Registry (реестр) будет хорошим дополнением к объектам-каталогам. Реестр - это устойчивая центральная база данных, которая сохраняет информацию конфигурации, такую, как индивидуальные объекты-каталоги для установки при загрузке. Проблема с реестрами состоит в том, что они противоречат децентрализованной природе программных компонентов, что ведет к проблемам управления, таким как поиск реестровых входов, которые больше не адекватны.
Мы видели, что размещение через один обходной уровень есть ключ к проблеме размещения черного ящика. Объекты-каталоги являются решением, включающим глобальное состояние. Это желательно, только если это состояние меняется редко и не происходит параллельно иной активности (пересечений). Например, в серверных окружениях решение без учета состояния часто предпочтительнее. Это может быть достигнуто параметризацией клиента: клиент должен принять фабричный объект как параметр. Это делает возможным определить точную природу исполнения на "вершине" иерархии процедурных вызовов, всегда пропуская фабричный объект "вниз". Это полезно, поскольку верхний уровень обычно гораздо меньше повторно используется, чем низкоуровневый код.
Как пример, диалоговая форма передачи файла может позволять задавать протокол передачи файлов вместе с такой информацией, как обратный адрес, скорость передачи и т.д. Протокол передачи файлов, который указывает исполнение коммуникационного объекта, может быть передан из диалоговой формы коммуникационному ПО, где он используется для размещения подходящего коммуникационного объекта (например, потоковый объект TCP).
Вместо передачи фабричного объекта может быть передано его символическое имя. "Внизу" сервис интерпретирует это имя; если необходимо, загружает модуль, который исполняет соответствующую фабричную функцию; и затем создает объект, используя фабричную функцию. Таким образом, сервис действует как фабричный менеджер.
Этот подход используется для некоторых сервисов Блэкбокса, в частности, для подсистем Sql и Comm. В обоих случаях имя модуля может передаваться, когда размещается новый объект. Этот модуль, как ожидается, предоставит подходящие фабричные функции. Для Sql модули SqlOdbc и DtfDriver поставляют подходящие исполнения объекта и фабричные функции. Для Comm модуль CommTCP поставляет подходящее исполнение объекта.
Фабричные менеджеры часто больше подходят для создания временных (несохраняемых, non-persistent) объектов, тогда как объекты-каталоги больше подходят для создания постоянных (несохраняемых, persistent) объектов. | Docu/ru/Tut-3.odc |
Часть II: Библиотека
ENGLISH
В части I учебника по BlackBox представлено введение в шаблоны проектирования, применяемые в BlackBox. Знание этих шаблонов облегчает понимание и запоминание более детальных проектных решений в различных модулях BlackBox.
Часть II учебника BlackBox поясняет применение наиболее важных компонентов библиотек: элементов управления, форм и текстовых элементов.
Часть III учебника BlackBox демонстрирует разработку отображений, рассматривая серию постепенно усложняющихся примеров.
4 Формы
В первой главе этой части мы сконцентрируемся на структуре формоориентированных элементов управления. "Формоориентированный" означает наличие редактора с графическим макетированием, иногда называемого "визуальным дизайнером" или "экранным художником", который позволяет вставлять, перемещать, изменять размеры, и удалять элементы управления. Элементы управления можно сделать активными, соединив их с фрагментом кода. Например, можно определить действие, которое будет выполняться при щелчке на кнопке.
Элементы управления могут иметь разный статус видимости, например, могут быть доступными или недоступными. Это способ показать пользователю какие действия могут быть доступны. Выставление статуса элементов управления может привести к значительным изменениям в приложении, дружественном к пользователю. К сожалению, такие особенности интерфейса часто требуют больше усилий от программиста, чем собственно логика работы приложения. Тем не менее, необходимо понимать лишь небольшое количество концепций способов построения подобных пользовательских интерфейсов. Эти концепции будут разъяснены с применением простых примеров.
4.1 Введение
Мы хотим как можно скорее начать с конкретных примеров, но небольшие вводные замечания все же необходимы. Ожидается, что читатель уже знаком с основами программирования, желательно на одном их диалектов Паскаля. Более того, ожидается, что он знаком с платформой (Windows или Macintosh) и основными принципами пользовательского интерфейса платформы.
В BlackBox Component Builder показывается типичное применение различных элементов программ. Содержание книги может быть применено как для Windows, так и для Macintosh-версии BlackBox, за исключением экранных снимков, сделанных в основном с применением Windows 95. Для минимизации платформенной специфики в тексте, применяются следующие соглашения:
* Mac OS folders называются "каталогами",
* В путях применяется символ "/" как разделитель каталогов как в Unix и World-Wide Web,
* Наименования файлов и каталогов могут содержать как прописные, так и строчные буквы,
* Наименования файлов документов даются без расширения ".odc", применяемого в Windows. Так, наименование файла "Text/Rsrc/Find" соответствует "Text\Rsrc\Find.odc" в Windows 95 и "Text:Rsrc:Find" в MacOS,
* Клавиша-модификатор: в Windows - Ctrl, в MacOS - Option,
* Команды меню: M->I - сокращение для пункта I из меню M, например File->New
При работе в оболочке BlackBox полезно помнить следующее: практически все изменения в документах BlackBox могут быть отменены, что делает безопасным эксперименты с различными тонкостями. В общем, доступно многократная отмена, то есть не только одна, но и несколько команд могут быть отменены, столько сколько позволяет объем памяти.
Эта книга не заменяет руководство пользователя по BlackBox. В ней задействовано минимальное число специфических средств BlackBox, поэтому требуется описание этих средств. Текст предполагает концентрацию на программировании в ущерб описанию средств. Там, где это необходимо, разъяснения особенностей средств даются при первом упоминании.
Для читателей, не владеющих Component Pascal свободно, в приложении b описываются различия между Pascal и Component Pascal.
Окно помощи BlackBox дает прямой или косвенный доступ к полной и обширной интерактивной документации, такой как руководство пользователя, все примеры ("Overview by example") и прочее. Во всемирной паутине дополнительные источники могут быть найдены по адресу http://www.oberon.ch.
4.2 Пример "Телефонная книга"
На протяжении всей части книги мы рассмотрим изменения и дополнения характерного примера. Этот пример - чрезвычайно упрощенная база данных. Идея не в представлении полноценного приложения со всеми возможными "примочками", а в минимальном примере, который бы не прятал объясняемые концепции за большими кусками кода. Тем не менее, идеи как добавить "примочки" компонент за компонентом видна все время.
Наша база данных телефонов содержит следующие фиксированные значения:
Daffy Duck 310-555-1212
Wile E. Coyote 408-555-1212
Scroodge McDuck 206-555-1212
Huey Lewis 415-555-1212
Thomas Dewey 617-555-1212
Таблица 4-1. Состав базы данных телефонов
В базе данных может быть найден телефонный номер по имени. Напротив, в базе данных можно отыскать имя по телефонному номеру, или содержимое базы данных может быть доступно по индексу. Мы уже видели возможную реализацию такой базы данных в разделе 3.2.
Наша задача - создать интерфейс для базы данных. Пользовательский интерфейс представляет собой диалоговое окно, содержащее два поля; одно под имя, второе под телефонный номер. У каждого поля есть заголовок, поясняющий назначение. Более того, диалоговое окно содержит переключатель, который позволяет определить, по какому из полей: имени или телефонному номеру, осуществляется поиск, и, наконец, кнопку, которая вызывает команду поиска. Следующий экранный снимок показывает, как будет выглядеть диалоговое окно окончательно:
Рисунок 4-2. Образец окна поиска в базе данных
Для построения окна поиска начнем с создания пустой формы диалогового окна, используя команду Contorls->New Form. В результате будет вызвано диалоговое окно:
Рисунок 4-3. Диалог новой формы
Щелчок на кнопке "Empty" открывает пустую форму:
Рисунок 4-4. Пустая форма
Используя команды из меню Controls, мы вставляем те элементы управления, которые необходимы, а именно: два заголовка, два однострочных редактора, переключатель и кнопку. Вставленные элементы управления имеют обобщенные названия вроде "untitled" (безымянный) или "Caption" (заголовок). Для изменения этих визуальных свойств применяется инспектор свойств. Он открывается путем выбора элемента управления и затем: Edit->Object Properties... (Windows) или Edit->Part Info (Mac OS) соответственно. Отредактируйте поле "label" в на форме для изменения заголовка выбранного элемента управления и щелкните на кнопке по умолчанию для сохранения изменений.
Рисунок 4-5. Редактор свойств компонента
Измените поле "label" для всех элементов управления так, чтобы в конце вы получили макет подобно рисунку 4-2. При переходе в порядке табуляции поля "label" будут следующими (слева-направо, сверху-вниз):
Тип элемента управления Заголовок
Caption Name
Text Field
Caption Number
Text Field
Check Box Lookup by Name
Command Button Lookup
Таблица 4-6. Список элементов управления диалога телефонной книги
Элементы управления можно разместить по-другому, используя мышь или команды разметки из меню Layout. После изменения разметки макета, обязательно вызовите Layout->Sort Views; эта команда отсортирует элементы управления в том порядке, в котором они будут обходиться, перемещения по клавише табуляции между ними будут происходит в традиционном порядке, то есть слева-направо и сверху-вниз.
Рисунок 4-7. Окончательный макет диалога телефонной книги
Когда вы останетесь довольны макетом, следует сохранить диалоговое окно как и любой другой документа, используя команду File->Save. По соглашению, макеты диалоговых окон всех примеров сохранены в каталоге Obx/Rsrc. В нашем случае, мы сохраним диалоговое окно как Obx/Rsrc/PhoneUI.
Каталог под именем Rsrc необходим для "ресурсов". Ресурсы - это документы, необходимые для работы программ. В частности таких как макеты диалоговых окон и строковых ресурсов. Строковые ресурсы позволяют вынести строки за пределы программного кода в отдельный редактируемый документ.
Ресурсы могут быть отредактированы без перекомпиляции чего-либо. Например, вы можете изменить все заголовки в представленном выше диалоговом окне с английского на немецкий без необходимости доступа с источнику кода или инструментов разработки.
4.3 Интеракторы
Создание диалогового окна - это хорошо, но необходим еще способ добавить линию поведения для диалогового окна. В нашем случае пользовательский интерфейс диалогового окна должен обеспечивать операции поиска в базе данных телефонов. Чтобы это выполнить, нужно реализовать это для базы данных. Мы уже упоминали выше, что подходящая реализация уже существует. Не должно вызывать удивление, так как в данной части книги рассказывается о сборке компонентов, что имеется ввиду соединени имеющихся компонентов и подходящих экземпляров объектов, которые они реализуют.
В нашем примере, база данных телефонов представлена в модуле Component Pascal под именем ObxPhoneDB. Мы уже знакомы с этим модулем по главе 3. Сейчас мы хотим создать наш первый новый модуль, назначение которого состоит в построении моста между модулем базы данных ObxPhoneDB и диалоговым окном, созданным нами ранее. Новый модуль назовем ObxPhoneUI, где "UI" означает "Пользовательский Интерфейс". Это типичный модуль с программным кодом, основной целью которого является обеспечение работы составного документа, который может использоваться как представление логики приложения, такого, как в нашем случае, как простая база данных телефонов.
Новый модуль использует, то есть импортирует, два существующих модуля. Один - это ObxPhoneDB, другой - Dialog:
Рисунок 4-8. Важные связи между ObxPhoneUI и ObxPhoneDB
Dialog - часть основополагающего каркаса, имеющегося в BlackBox Component Builder. Этот модуль обеспечивает различные службы для поддержки пользовательского интерфейса. С наиболее важными мы уже встречались в этой главе.
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
END ObxPhoneUI.
Листинг 4-9. Первая версия ObxPhoneUI
ObxPhoneUI экспортирует глобальную запись phone, которая содержит два строковых и одно логическое поля. В зависимости от текущего значения логического поля, процедура Lookup берет phone.name для поиска соответствующего номера или phone.number для поиска соответствующего имени. Если поиск неудачен, то есть возвращена пустая строка, то результат переключается на "не найдено". Оба результата помещаются в phone, то есть phone несет одновременно входной и выходной параметр поиска в базе данных.
Когда пользователь желает изменить содержимое phone изменяя содержимое элементов управления, например, заполняя текстовые поля, используется глобальная переменная типа phone, называемая интерактором. Элементы управления отображают содержимое полей интерактора и, если возможно, позволяют изменять их интерактивно. Для этого каждый элемент управления вначале должен быть присоединен к соответствующему полю интерактора. Это выполняется с помощью редактора свойств элементов управления, который мы видели ранее. Поле "Link" должна содержать имя поля, например ObxPhoneDB.phone.name или имя процедуры, например ObxPhoneDB.Lookup. Используйте инспектор свойств элемента управления для выставления связей согласно таблице 4-10:
Control type Label Link
Caption Name
Text Field ObxPhoneUI.phone.name
Caption Number
Text Field ObxPhoneUI.phone.number
Check Box Lookup by Name ObxPhoneUI.phone.lookupByName
Command Button Lookup ObxPhoneUI.Lookup
Таблица 4-10. Связи телефонной базы и диалогового окна.
Обратите внимание, что элемент управления бывший до этого недоступным сейчас стал доступным. Что это значит? Когда элемент управления связан, как это обычно случается при чтении формы из файла или, как в нашем случае, связь изменена из инспектора, модуль, связанный с этим элементом должен быть загружен. Если модуль уже загружен, ничего не требуется делать дополнительно. Если он еще не был загружен (это можно проверить по Info->Loaded Modules), загрузка происходит немедленно. Если загрузка оборвалась, например, код модуля еще не существует, связка элемента управления нарушается и он остается недоступным. Связывание так же оканчивается неудачей, когда элемент управления и поле не совместимы по типу, например кнопка независимой фиксации связана со строковым полем.
Для достижения такого уровня функциональности (и безопасности против неверного применения), BlackBox обеспечивает ряд улучшенных служб "метапрограммирования", а именно динамическая загрузка модулей по требованию и проверка типов переменных (typesafe lookup of variables). Последнее требование расширяет информацию о типе на этапе выполнения (RTTI), что сравнительно необычно для полностью компилирующих языков.
Связи всех элементов управления переопределяются каждый раз, когда модуль выгружается. Это гарантирует, что элементы управления никогда не ссылаются на незагруженные модули.
Одна из целей дизайна BlackBox и состоит в разделении деталей пользовательского интерфейса и программной логики. По этой причине модуль ObxPhoneUI ничего не знает об элементах управления, формах и т.п. Например, связка по кнопке "ObxPhoneUI.Lookup" говорит о необходимости активировать процедуру ObxPhoneUI.Lookup, когда кнопка будет нажата. В свою очередь, процедура ничего не знает о командной кнопке (или даже о нескольких), а только оповещает возможные элементы управления, вызывая Dialog.Update(phone) в конце процедуры. Dialog.Update инициирует обновление всех элементов управления, которые это требуют. Например, если Lookup получило значение "не найдено" для phone.number, то связанные текстовые поля и подобные элементы управления должны быть перерисованы соответствующим образом.
Как параметр для Dialog.Update должен быть передан интерактор (interactor). Вызов Dialog.Update необходим после программного изменения одного или нескольких полей интерактора. В случае модификации нескольких полей, Dialog.Update следует вызывать только одни раз из соображений эффективности. Необходимо отметить, что элементы управления вызывают Dialog.Update самостоятельно, когда пользователь изменяет поля интерактора, необходимость в принудительном вызове возникает только когда интерактор изменяется программным кодом.
Строгое разделение интерфейса пользователя и программной логики весьма необычно. Преимущество разделения - в простоте: как только мы узнаем как определять процедуры и как объявлять записи и глобальные переменные, вы уже можете создавать графический интерфейс пользователя для модуля. Это возможно даже для тех, кто только начал заниматься программированием. Другое преимущество: вам не требуется писать код для простого пользовательского интерфейса. Создание пользовательского интерфейса осуществляется посредством редактора форм (то есть установкой места и размера элементов управления) и инспектора (то есть, установкой выравнивания текста и собственно текста для строковых полей). Это позволяет легко изменять пользовательский интерфейс под различные требования без затрагивания логики приложения. Только если вы хотите получить больший контроль над пользовательским интерфейсом, например доступность элементов управления или реакция на особые события, такие как печать с клавиатуры, необходимо написать небольшой кусок кода, который может быть очень просто отделен от логики непосредственно приложения. Необходимые концепции, так же называемые охранники (guards) и уведомления (notifiers) будут обсуждаться в следующих двух разделах. Если вам все еще нужны другие элементы управления, можно изучить самостоятельно, как рассказано в разделе 4.9.
В настоящее время к недостаткам BlackBox Component Builder можно отнести необходимость применения глобальных переменных в качестве интерактора для связи с элементами управления. Если имеется несколько элементов управления с одинаковыми полями интерактора, все из них отображают одинаковое значение. Сами по себе элементы управления не могут имеют самостоятельного статуса.
Следует отметить интересную особенность BlackBox: если написан модуль, подобный ObxPhoneUI из листинга 4-9, то возможна автоматическая генерация формы с подходящими элементами управления по умолчанию. Это происходит при нажатии кнопки "Create" в диалоге "New Form" вместо кнопки "Empty". Эта особенность полезна при создании тестовых или отладочных интерфейсов в процессе разработки, когда нецелесообразны затраты времени на ручное построение форм.
Сейчас уже имеется дизайн диалогового окна с элементами управления, связанными с модулем ObxPhoneUI и этот модуль импортирует механизм управления базой данных ObxPhoneDB. Сейчас все еще отсутствует способ применения диалогового окна вместо простого редактирования его дизайна. В процессе редактирования очень полезно сразу же попробовать диалоговое окно, даже если оно еще не совершенно. Для того, чтобы опробовать, убедитесь, что макет является самым верхним окном и затем выполните Controls->Open As Aux Dialog. Новое открывшееся окно содержит такой же диалог, но может быть отредактировано содержимое элементов управления вместо изменения разметки этих элементов. Окно ведет себя как маска ввода. Сейчас можно напечатать, например, "Huey Lewis" в строке имени, отметить флаг "Lookup by Name" и щелкнуть по кнопке "Lookup". Можно увидеть, что соответствующий номер появился в поле "Number".
Рисунок 4-11. Дизайн (слева) и работа (справа) для одной и той же формы.
Следует отметить, что то же имя и номер так же отразились и в окне разметки. Более того, если вы измените разметку в дизайнере, например, подвинете кнопку независимой фиксации, можно увидеть, что изменения немедленно отразятся и в соседнем окне. Такое поведение так же называется Model-View-Controller, реализованной в BlackBox. В Части II книги этот шаблон проектирования уже детально обсуждался. Сейчас достаточно сказать, что несколько просмотров могут совместно использовать одни и те же данные, то есть дизайн и рабочий диалог могут отображать одну и ту же форму; и разметка, и диалог явления одного порядка, хотя и в разных формах. Переключение между двумя режимами осуществляется посредством команд: Dev->Layout Mode или Dev->Mask Mode.
Два режима работы различаются способом обработки выделения и активности. В режиме разметки можно выделить внедренный просмотр и отредактировать выделение, но нельзя сделать активным элемент просмотра. В режиме работы вы можете активизировать просмотр, но не можете выделить сам элемент управления (только его содержимое) и поэтому не можете изменить его разметку, то есть его размер, местоположение и т.п. Другими словами: режим разметки запрещает активацию, режим работы запрещает выделение.
Открытие второго окна формы в рабочем режиме удобно в процессе разработки, но не желательно, чтобы окно разметки открывалось в момент реальной работы программы. В таком случае следует открывать диалоговое окно в рабочем режиме применяя подходящие команды меню.
Новая команда меню может появиться после редактирования текста конфигурации. Можно открыть этот текст (расположенный в System/Rsrc/Menus) выполнив команду Info->Menus. Допишите следующий текст в конец файла:
MENU "Priv"
"Open..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')" ""
END
Затем следует выполнить Info->Update Menus. Появится сообщение, что появилось новое меню "Priv". Выполните пункт меню "Open..." В результате будет выполнена команда
StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phonebook')
Она окрывает макет Obx/Rsrc/PhoneUI, переключает его в режим ввода и открывает его с заголовком "Phonebook". Если необходимо, чтобы изменения меню стали постоянными, сохраните текст меню перед его закрытием.
Необходимо отметить, что форма не сохраняется в режиме ввода (это было бы неудобно для последующего редактирования), она только временно переключается в режим ввода командой StdCmds.OpenAuxDialog.
4.4 Охранники
В рамках чистой функциональности мы узнали все необходимое о стандартных наборах элементов управления. Позднее будет рассказано о палитре стандартных компонентов более подробно. Тем не менее вначале необходимо обсудить важные моменты стандартных элементов управления, которые, строго говоря, не добавляют функциональности приложению, а необходимы только для удобства пользователя, то есть для дружественности к пользователю.
В разделе 1.2 уже было обсуждено что значит дружественный к пользователю. Например, это означает уход от модальности везде, где это возможно. По этой причине BlackBox не поддерживает модальных диалоговых окон. Подобный способ действия необходим, если действия пользователя в одних случаях возможны, а в других случаях - нет. Например, если буфер обмена пуст, его содержимое не может быть вставлено в текст. Если он не пустой и содержит текст, то вставка возможна. С этим ничего не поделаешь, поэтому текущий статус должен быть виден или легко получен пользователем. Например, если буфер обмена пуст, команда меню Paste должна быть визуально отмечена недоступной. Видимые различия дают пользователю раннее предупреждение, что данная команда не доступна. Это гораздо лучше, чем позволить пользователю выполнить команду, а затем получить сообщение об ошибке. Следующий пример показывает диалоговое окно с двумя кнопками. Кнопка Empty доступна, только когда кнопка Create недоступна. Кнопка Create становится доступной только в случае, если что-то было напечатано в текстовом поле диалогового окна:
Рисунок 4-12. Доступные и недоступные кнопки.
Таким образом, хороший пользовательский интерфейс всегда дает пользователю информацию о всех доступных действиях и дает визуальной предупреждение о недоступности действий.
Таким образом, BlackBox должен предоставить способ обеспечить обратную связь в системе, особенно для текущей доступности или недоступности команд.
В этих целях должно быть возможным разрешать или запрещать элементы управления и пункты меню. Например, поиск телефонного номера возможен только в случае, если введено имя, то есть если текстовое поле имени не пусто. Для определения когда процедура команды, в нашем случае - процедура Lookup, может быть вызвана, то есть когда соответствующий элемент управления или пункт меню может быть доступен, должен быть определен подходящий охранник. Охранник - это процедура, вызываемая из среды каждый раз, когда требуется изменить статус элемента управления или пункта меню. Охранник проверяет состояния нескольких глобальных параметров системы, применяет эти состояния для определения доступности подопечных охраннику команд и выставляет соответствующим образом выходной параметр. Охранник имеет следующий вид:
PROCEDURE XyzGuard* (VAR par: Dialog.Par);
BEGIN
par.disabled := ...some Boolean expression...
END XyzGuard;
Охранник описывается следующим типом:
GuardProc = PROCEDURE (VAR par: Dialog.Par);
Для процедуры охранника Lookup из нашего примера мы дополним модуль ObxPhoneUI следующим образом:
MODULE ObxPhoneUI;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String;
lookupByName*: BOOLEAN
END;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
END;
Dialog.Update(phone)
END Lookup;
PROCEDURE LookupGuard* (VAR par: Dialog.Par);
BEGIN (* disable if input string is empty *)
par.disabled := phone.lookupByName & (phone.name = "") OR
~phone.lookupByName & (phone.number = "")
END LookupGuard;
END ObxPhoneUI.
Листинг 4-13. ObxPhoneUI с LookupGuard
Что случится после компиляции приведенного выше модуля? Его символьный файл на диске заменится новой версией, так как интерфейс модуля поменялся по сравнению с предыдущей версией. Так как изменения заключаются в простом добавлении глобальной процедуры (то есть новая версия совместима со старой версией), возможные зависимые модули, импортирующие модуль ObxPhoneUI не теряют актуальности и не требуют перекомпиляции.
Компиляция так же породит новый файл кода на диске. Тем не менее, старая версия ObxPhoneUI по-прежнему остается загруженной в памяти! Другими словами: однажды будучи загруженным, модуль остается в памяти ("выполнить и оставаться в памяти"). Это не проблема, так как модули чрезвычайно малы и занимают мало памяти. Тем не менее программист конечно же должен иметь возможность выгрузит модули без необходимости выхода из оболочки BlackBox Component Builder для того, чтобы опробовать новый версии модулей. Для этой цели служит команда Dev->Unload, выполняющая выгрузку модуля, код которого в настоящее время активен.
Необходимо отметить, что компиляция не выгружает модули автоматически, что часто бывает неудобно. В частности, если ведется работа с несколькими взаимосвязанными модулями одновременно, выгрузка одного из них раньше перед тем как другие корректно обновятся может привести к тому, что весь набор модулей придет в противоречивое состояние.
Для таких случаев, когда немедленная выгрузка модулей после компиляции существенна, как в простом обсуждаемом примере, существует команда Dev->Compile And Unload.
Ее можно использовать для проверки новой версии модуля ObxPhoneUI. Необходимо отметить, что кнопка Lookup недоступна, когда поле Name пусто (если выбран режим "Поиск по имени") или когда поле Number пусто (если выбран режим "Поиск по номеру"). Ввод каких-либо символов в поле делает кнопку доступной, удаление всех символов - недоступной. В конце этого раздела будет более подробно разъяснено, когда именно срабатывает охранник, сейчас достаточно знать, что охранник срабатывает после ввода каждого символа в элемент управления.
Охранники чаще всего применяются для обеспечения доступности/недоступности элементов интерфейса, таких как элементы управления или пункты меню. Тем не менее, иногда охранники выступают в более общей роли. Например, элемент управления может быть не только недоступен, но еще и быть только для чтения или не определен.
"Только для чтения" означает, что элемент управления не может быть модифицирован. Например, следующий охранник выставляет "Только для чтения" для полей выходного параметра. Первый охранник выставляет "только для чтения", если поиск идет не по имени, то есть по номеру. Очевидно, в этом случае номер - входной, а имя - выходной параметры. Параметр для чистого вывода должен быть только для чтения. Таким образом, первый охранник может использоваться как охранник для поля Name. Другой охранник может быть применен для поля Number, так как выставляет только для чтения, если поиск возвращает номер.
PROCEDURE NameGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by number *)
par.readOnly := ~phone.lookupByName
END NameGuard;
PROCEDURE NumberGuard* (VAR par: Dialog.Par);
BEGIN (* make read-only if lookup is by name *)
par.readOnly := phone.lookupByName
END NumberGuard;
Листинг 4-14. Охранники "Только для чтения" для ObxPhoneUI
Поля интерактора, экспортированные только для чтения, то есть с символом "-" вместо "*", всегда имеют статус "только для чтения" вне зависимости от действий охранника (в противном случае нарушилась бы безопасность модуля, так как элементы, экспортируемые "только для чтения" могут быть изменены только в определяемом модуле - это инвариант).
Статус "не определено" для элемента управления означает, что элемент не имеет значения вовсе. Это возможно, если элемент управления отражает статус разнородного выделения. Например, кнопка независимой фиксации может отображать состоит ли выделенный текст из всех прописных или строчных букв. Если часть выделения состоит из прописных букв, а часть - из строчных букв, то элемент управления не имеет определенного значения. Тем не менее, после щелчка на кнопке независимой фиксации, в выделении все буквы преобразовываются в прописные и вновь получает определенное значение. Неопределенное значение может быть установлено из охранника следующим выражением:
par.undef := TRUE
Неопределенное значение может быть приравнено к значению "только для записи", так как значение элемента управления не может быть прочитано пользователем, так как оно еще не определено, но может быть изменено, тем самым выставляется какое-то значение.
Из полей disabled, readOnly и undef, только одно может быть установлено охранником в TRUE. Это приводит к тому, что возможно четыре состояния элемента управления: одно из указанных выше полей или ни одного имеет установленный статус. Когда охранник вызывается оболочкой, все три логических поля устанавливаются в FALSE. Это одно из общих правил в BlackBox: логические поля по умолчанию выставляются в FALSE.
В таблице 4-15 представлены подходящие охранники для макета с рисунка 4-2:
Control type Link Guard
Caption
Text Field ObxPhoneUI.phone.name ObxPhoneUI.NameGuard
Caption
Text Field ObxPhoneUI.phone.number ObxPhoneUI.NumberGuard
Check Box ObxPhoneUI.phone.lookupByName
Command Button ObxPhoneUI.Lookup ObxPhoneUI.LookupGuard
Таблица 4-15. Охранники диалогового окна базы данных телефонов
Охранник может применятся к процедуре, к полю интерактора или к нескольким процедурам или полям интерактора. Если он применяется в большей части к одной процедуре или к полю, то имя охранника формируется добавлением слова "Guard" к (с большой буквы) имени процедуры или поля. Например, охранник для процедуры Lookup называется LookupGuard, охранник для поля phone.name называется NameGuard и т.п. Такое простое соглашение о наименование делает более легким определение связи между охранником и подопечным элементом. Соглашение об именовании "мягкое", то есть не навязывается оболочкой, фактически оболочка не знает об этом вовсе.
Экспорт охранников не просто соглашение, а необходимость. Доступ к охранникам осуществляется так называемым механизмом метапрограммирования BlackBox, который по соображениям безопасности оперирует только набором экспортируемых элементов, то есть интерфейсов, доступных извне. Если охранник не экспортируется, элемент управления не может его вызвать. Подобная ситуация с полями интерактора, которые так же должны быть экспортированы, если интерактор будет связан с ними.
Если заглянуть в описание типа Dialog.Par (применяя Info->Interface...), то можно увидеть что еще не описаны два поля: label и checked:
Par = RECORD
disabled, checked, undef, readOnly: BOOLEAN;
label: Dialog.String
END
Поле label позваляет изменить заголовок элемента управления. Например, вместо заголовка кнопки "Toggle" можно применить заголовки "Switch On" и "Switch Off" в зависимости от текущего состояния системы. Этого можно добиться подобной процедурой:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "Switch Off"
ELSE
par.label := "Switch On"
END
END ToggleGuard;
Листинг 4-16. Пример охранника заголовка
Следует отметить, что охранник перекрывает все заголовки, которые были установлены для элемента управления из инспектора. Это верно для всех элементов управления (и для всех пунктов меню также, смотри ниже).
Настоятельно не рекомендуется размещать строковые литералы в коде программы, как в примере выше, так как при изменении языка, например с английского на немецкий (см. так же раздел 1.4) потребуется принудительная перекомпиляция. В Черном Ящике строки, относящиеся к пользовательскому интерфейсу, такие как заголовки или сообщения чаще всего заносятся в отдельный файл параметров, так же называемый ресурсом строк. Для каждой из подсистем может существовать один ресурсный файл, например Text/Rsrc/Strings или Form/Rsrc/Strings. Ресурс строк представляет из себя текстовый документ Черного Ящика, начинающийся с ключевого слова STRING и нескольких пар вида <ключ, строка>. Ключ представляет из себя строку, отделенную символом табуляции от собственно строки, которую заменяет. Каждая пара <ключ, строка> должна заканчиваться символом возврата каретки. Пары не должны быть упорядочены каким-либо образом, но полезно отсортировать их в алфавитном порядке ключей, так как тогда будет удобней искать обыкновенный ключ в процессе редактирования строкового ресурса.
Например, System/Rsrc/Strings начинается так:
STRINGS
About About BlackBox
AlienAttributes alien attributes
AlienCause alien cause
AlienComponent alien component
AlienControllerWarning alien controller (warning)
Таблица 4-17. Ресурс строк System/Rsrc/Strings
Для использования строковых ресурсов в нашем примере, необходимо использовать специальный синтаксис, который показывает, что строка в действительности является ключем, который должен быть заменен подходящим значением из строкового ресурса. Таким образом, в подсистеме Obx в строковом ресурсе имеются ключи "On" и "Off", следующий код их использует:
PROCEDURE ToggleGuard* (VAR par: Dialog.Par);
BEGIN
IF someInteractor.isOn THEN
par.label := "#Obx:Off"
ELSE
par.label := "#Obx:On"
END
END ToggleGuard;
Листинг 4-18. Охранник заголовка с применением карты строк
Ведущий символ "#" показывает, что необходима подстановка строк. Затем следует название подсистемы, в нашем случае "Obx". Затем следует двоеточие, после которого идет ключ для замены. Кнопка с таким охранником будет отображать заголовки "Switch Off" или "Switch On" в английской версии BlackBox, "Ausschalten" или "Einschalten" в немецкой версии и т.п.
Если нет подходящего строкового ресурса, ключ заменяется на собственное значение. Например, если не будет ключа "Off" в Obx/Rsrc/Strings, то "#Obx:Off" будет заменено на "Off".
Из Dialog.Par осталось не рассмотренным поле под названием checked. В действительности, оно никогда не применяется для элементов управления BlackBox. Оно применяется для пунктов меню. Пункты меню подобны элементам управления: они могут запускать какие-то действия, могут быть доступными/недоступными, могут иметь заголовки. По этой причине к ним применяется такой же механизм охранников. Охранник для меню определяется в тексте Menus как строка после метки пункта меню и клавиатурного эквивалента. Например, следующий фрагмент представляет определение охранника меню Dev:
"Edit Mode" "" "StdCmds.SetEditMode" "StdCmds.SetEditModeGuard"
Отличительная черта элемента меню состоит в том, что он может быть отмечен. Например, в следующей меню пункт Edit Mode отмечен:
Рисунок 4-19. Пункт меню с отметкой
Отметка показывает, какой пункт был выбран самым последним, и какой статус был установлен по данному выделению. Состояние может быть изменено вовлечением других пунктов меню, например Mask Mode, как на рисунке выше. В общем, четыре пункта меню образут группу, из которых только один может быть выбран.
Процедура охранника для пункта меню может выставить значения disabled, checked и label для Dialog.Par. Другие поля для меню игнорируются.
Процедура охранника может выставлять несколько полей для выходного параметра par одновременно, то есть может быть установлено поле disabled и label для кнопки. Тем не менее, охранник может выставлять как минимум одно логическое поле из par и никогда не должен изменять состояние вне рамок par, то есть поля интерактора или что-то подобное, то есть не должно быть побочных эффектов. Так же не должно быть вызовов других процедур, имеющих побочный эффект. Это сделано по причине того, что программа не может знать когда (а особенно когда "не") оболочка вызывает охранника. Охранник может использовать интерактор или несколько интеракторов как входные параметры, или текущее выделение или фокусировку. Последнее часто используется для охранников меню. Текущую фокусировку или выделение применяется в охранниках только для элементов управления так же называемых диалоговый панели инструментов, то есть диалоги, оперирующие содержимым нижеследующего документа. Диалоговое окно Find & Replace, работающее с текущим окном текста - типичный пример инструментального диалогового окна. Другие ока являеются самодостаточными и называются вспомогательными диалоговыми окнами. Маска ввода данных - типичный пример вспомогательного диалогового окна.
Когда срабатывает охранник? Существует четыре причины вызова охранника: когда установлена связь с элементом управления, когда изменяется содержимое интерактора, когда изменяется иерархия окна или когда пользователь щелкает на меню.
Связь элемента управления устанавливается после вставки в контейнер, после загрузки из файла, после выгрузки модуля или после того как связь была изменена в инспекторе свойств или другими средствами. Когда кусок кода изменяет содержимое интеркатора, необходимо вызвать Dialog.Update для этого интерактора. В результате каждый визуальный элемент управления получает уведомление (см. раздел 2.9). В ответ элементы управления сравнивают текущие состояния со значениями полей связанного интерактора. Если поля интерактора изменились, элемент управления соответствующим образом перерисовывается. После того, как все элементы управления обновили свое содержимое, вычисляются охранники всех визуальных элементов управления. По этой причине охранники должны быть оптимальными и не занимать много времени на обработку.
Охранники так же вычисляются, когда изменяется иерархия окон, то есть когда нижнее окно перемещается наверх. Это необходимо, так как многие команды зависят от текущего фокуса и выделения, которые могут исчезнуть, когда другое окно перемещается наверх.
Другая причина вызова охранников - меню. Когда пользователь щелкает на меню, все охранники этого меню или охранник меню целиком пересчитывается.
Чаще всего охранник имеет форму:
PROCEDURE SomeGuard* (VAR par: Dialog.Par)
Другая форма охранника
PROCEDURE SomeGuard* (n: INTEGER; VAR par: Dialog.Par)
может применяться, когда требуется передать параметр для одного охранника нескольких связанных команд. Например, ниже приведены команды для выставления выделения в красный, зеленый или синий:
StdCmds.Color(00000FFH)
StdCmds.Color(000FF00H)
StdCmds.Color(0FF0000H)
Для этих команд могут быть применены следующие охранники
StdCmds.ColorGuard(00000FFH)
StdCmds.ColorGuard(000FF00H)
StdCmds.ColorGuard(0FF0000H)
Имеющаяся реализация заголовка StdCmds.ColorGuard:
PROCEDURE ColorGuard (color: INTEGER; VAR par: Dialog.Par)
4.5. Уведомления
Охранник элемента управления выставляет текущее состояние элемента, например: доступен или нет. Других действий не производится. Не изменяются какие-либо данные интерактора. Не добавляется какой-либо функциональности. Лишь добавляется обратная связь для элемента управления о текущей функциональности или ее возможности. Охранник пересчитывается только когда пользователь что-либо изменит в элементе управления. Такое положение может быть представлено как простая "косметическая" особенность, служащая исключительно для увеличения дружественности интерфейса.
Тем не менее, иногда действия пользователя должны инициировать больше, чем простое срабатывание охранника. В частности иногда необходимо изменить какое-либо состояние интерактора в ответ на действия пользователя. Например, изменение выделения в окне может повлечь необходимость обновления соответствующего счетчика, который показывает число выделенных элементов в окне. Или требуется реализация какой-либо последующей обработки пользовательского ввода, как будет показано на примере ниже. Это будет альтернативная реализация примера ObxPhoneUI. Вместо кнопки Lookup, новая версия имеет всего два текстовых поля. После каждого ввода символа база данных выполняет поиск, пока не будет найден правильный ключ. Необходимо отметить, что неудачный поиск в ObxPhoneDB возвращает пустую строку.
MODULE ObxPhoneUI1;
IMPORT Dialog, ObxPhoneDB;
VAR
phone*: RECORD
name*, number*: ObxPhoneDB.String
END;
PROCEDURE NameNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByName(phone.name, phone.number);
Dialog.Update(phone)
END NameNotifier;
PROCEDURE NumberNotifier* (op, from, to: INTEGER);
BEGIN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
Dialog.Update(phone)
END NumberNotifier;
END ObxPhoneUI1.
Листинг 4-20. Модуль ObxPhoneUI1 с уведомлениями.
Данное уведомление устанавливает зависимость между двумя полями интерактора: изменение одного поля может привести к изменению другого текстового поля, то есть определяется связь между двумя полями интерактора.
Уведомление вызывается сразу после взаимодействия, но до вычисления охранника. Уведомление имеет следующую форму:
PROCEDURE XyzNotifier* (op, from, to: INTEGER);
BEGIN
...
END XyzNotifier;
Тип уведомления:
NotifierProc = PROCEDURE (op, from, to: INTEGER);
Для простого уведомления параметры можно игнорировать. Параметры позволяют более точно определить какое именно изменение произошло. Какой из параметров определен и что именно он означает определено отдельно для каждого вида элементов управления. Для пояснения смотри следующий раздел.
4.6 Стандартные элементы управления
В данном разделе представлены различные элементы управления, принятые за стандарт в BlackBox Component Builder. Для каждого элемента управления приводится список возможных типов данных, с которыми можно связать элемент, и смысл и значения параметров уведомления.
Элементы управления могут иметь различные свойства, например заголовки или начертание заголовка стандартным системным шрифтом или более бледным, тонким. Тем не менее, подобные косметические свойства могут быть не реализованы на всех или части платформ, поэтому иногда просто игнорируются.
Заголовки могут иметь специальные метки (keyboard shortcut), которые позволяют на некоторых платформах перемещаться между элементами без применения мыши. Символ метки определяется по предшествующему знаку "&" (амперсанд). Два последовательных символа "&" обозначают нормальный "&" без присвоения последующему символу признака метки. На один заголовок допустима только одна метка. Например: "Clear Text &Field" определяет "F" в качестве метки, в то время как "Find && &Replace" определяет "R" как клавиатурную метку. Подобное описание меток применяется и для команд меню.
Свойства заголовка для всех элементов управления могут быть изменены в процессе выполнения посредством охранника, как было показано в листинге 4-16. Для элементов управления без видимого заголовка не будет видимого эффекта.
Два наиболее важных свойства элементов управления: охранник и уведомление - не обязательны. Если не определен охранник элемента, будет применяться значение по умолчанию (доступно, для чтения и записи, определено). Если не определено уведомление для элемента, ничего не будет вызываться.
В BlackBox сделана попытка минимизировать число различных свойств для облегчения их использования. Это согласуется с общими направлениями развития, как в Windows, так и в Mac OS, а так же в рамках общего развития элементов управления. Это означает, что для каждого отдельного элемента управления не следует специально назначать свойства цвета, шрифтов и т.п. Вместо этого пользователь должен назначить системные установки и конфигурацию этих свойств.
Тем не менее, если существуют весомые причины, можно назначит специальный шрифт для элементов управления простым выделением этого элемента и выполнением команд меню Font, Attributes или Characters. Если установлен шрифт по умолчанию, то будут выставлены общесистемные настройки. Это нормальное явление. Следует отметить, что различные атрибуты шрифтов, такие как стиль, жирность, размер, могут быть зафиксированы в некоторых платформах. Например, в Mac OS системный шрифт всегда 12 пунктов.
В нижеследующем тексте описаны стандартные элементы управления BlackBox в следующем порядке: кнопки (command buttons), редакторы (edit fields), кнопки независимой фиксации (check boxes), кнопки зависимой фиксации (radio buttons), поля ввода даты (date fields), поля ввода времени (time fields), поля ввода цвета (color fields), заголовки (captions), группы (groups), выпадающие списки (list boxes), списки (selection boxes), комбинированные списки (combo boxes). Для каждого элемента управления представлены его свойства, возможные типы переменных для связи, значения параметров op, from и to в уведомлениях.
Следует отметить, что не существует специального типа для ввода валюты, взамен следует использовать редактор, связанный с типом Dialog.Currency.
В приведенном описании применяются следующие сокращения:
pressed - Dialog.pressed
released - Dialog.released
changed - Dialog.changed
included - Dialog.included
excluded - Dialog.excluded
undefined означает, что параметр from или to уведомления не содержит определенного значения ( в котором можно быть уверенным).
modifier означает 0 для простого щелчка и 1 для двойного щелчка
link, label, guard, notifier и level определены для соответствующего элемента управления в модуле Controls.
Может быть до 5 дополнительных логических свойств. В зависимости от элемента управления они могут называться по-разному, например: default font, default, cancel, sorted, left, right, multiLine, password.
Кнопка (Command Button)
Рисунок 4-21. Кнопка
Кнопка предназначена для выполнения непараметризированной команды Component Pascal или целой последовательности команд. Кнопка по умолчанию отличается по внешнему виду от обычных кнопок; нажатие клавиши "Enter" соответствует щелчку мыши по кнопке по умолчанию. Для кнопки со свойством cancel, нажатие клавиши "ESC" соответствует щелчку мыши на данной кнопке. Кнопка не может быть одновременно "По умолчанию" и "Отмена". Следует отметить, что выставление свойств "По умолчанию" и "Отмена" выполняется для каждого элемента управления, то есть установка одной кнопки "по умолчанию" не превращает предыдущую кнопку со свойством "по умолчанию" в нормальную. Для диалогового окна следует выставлять не больше одной кнопки по умолчанию и не больше одной кнопки cancel. Кнопка отмены или любая другая кнопка, предназначенная для закрытия диалогового окна должна содержать команду StdCmds.CloseDialog.
properties: link, label, guard, notifier, font, default, cancel
linkable to: parameterless procedure, command sequence
op: pressed, released
from: undefined, modifier
to: undefined
Редактор (Text Field)
Рисунок 4-22. Редактор
Редактор отражает значение глобальной переменной, которая может иметь строковый, целый, дробный типы или различные типы Dialog.Currency или Dialog.Combo. Значение переменной может быть изменено в редакторе.
При любом изменении содержимого связанного поля интерактора вызывается уведомление. Нажатие клавиш, которые не изменяют состояние интерактора, таки как нажатие стрелок, ввод ведущих нулей для чиловых полей, не приводит к вызову уведомления. Изменение выделения содержимого поля так же не приводит к вызову уведомления.
Если изменение происходит для поля, связанного с типом строка, дробное число, валюта или переменной комбинированного списка, вызывается уведомление с параметрами (change, undefined, undefined). Если поле связано с целочисленным значением, вызывается уведомление с параметрами (change, oldvalue, newvalue).
Недопустимые символы, например, буквы для полей связанных с числовыми типами, не вводятся.
Редактор может иметь заголовок, но он не показывается. Причина - метка клавиши может быть определена в заголовке, это может быть полезно для полей ввода.
Если значение свойства level 0 (по умолчанию) или элемент не связан с числовым полем или связан с типом Dialog.Currency, то свойство level не имеет эффекта. Если связь установлена с целочисленной переменной, level определяет масштаб для отображения числа, то есть связанное число отображается в разделенном на 10 в степени level. Например, если текущее значение 42 и level 2, то отображается значение 0,42. Для действительных чисел level показывает формат следующим образом:
level > 0: экспоненциальный (научный) формат, при этом не менее level цифр в мантиссе
level = 0: формат с фиксированной или плавающей точкой в зависимости от x
level < 0: фиксированный формат с level цифр после запятой.
Свойства left и right определяют режим выравнивания содержимого поля. Возможны следующие комбинации:
left & ~right выравнивание по левому краю
left & right выравнивание по содержимому (может не срабатывать на некоторых платформах)
~left & ~right выравнивание по центру
~left & right выравнивание по правому краю
По умолчанию принято left & ~right (выравнивание по левому краю)
Свойство multiLine определяет возможность ввода символа возврата каретки и, соответственно, появление разрыва строки в указанное поле, которое должно быть связано со строковой переменной.
Свойство password определяет необходимость замены содержимого поля на символы снежинок при печати. Это свойство позволяет использовать строку для ввода паролей.
properties: link, label, guard, notifier, level, font, left, right, multiLine,
password
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Кнопка независимой фиксации (Check Box)
Рисунок 4-23. Кнопка независимой фиксации
Кнопка независимой фиксации отображает значение глобальной переменной логического типа или типа элемента множества. Щелчок на элементе управления изменяет его статус.
Если элемент связан с логическим типом, то при изменении элемента вызываетя уведомление с параметрами (changed, undefined, undefined). Если связь установлена с элементом из множества, то вызываемые параметры будут (included, level, undefined) или (excluded, level, undefined) в зависимости от того, устанавливается или сбрасывается фиксация. Значение level соответствует элементу из множества, с которым элемент управления связан. Связь может быть определена из инспектора свойств элемента управления. Значение может находиться в пределах 0..31.
Только последнее и завершающее изменение статуса элемента управления приводит к вызову уведомления, возможные промежуточные изменения (перемещение мыши за пределы границ окна и обратно в область) не возымеют действия.
properties: link, label, guard, notifier, font, level
linkable to: BOOLEAN, SET
op: pressed, released, changed, included, excluded
from: undefined, level value, modifier
to: undefined
Кнопка с зависимой фиксацией (Radio Button)
Рисунок 4-24. Кнопка с зависимой фиксацией.
Кнопка зависимой фиксации становится активной при конкретном значении глобальной целочисленной или логической переменной. Обычно несколько кнопок с зависимой фиксацией связаны с одной переменной. Каждая кнопка установлена для разных значений, которые устанавливаются свойством level, то есть кнопка "включается", когда значение свойства level становится равно значению связанной переменной. Для логической переменной "установлено" соответствует Истине, "сброшено" соответствует Лжи.
Только последнее и законченное изменение элемента управления приводит к вызову уведомления, возможные промежуточные состояния не имеют действия.
properties: link, label, guard, notifier, font, level
linkable to: BYTE, SHORTINT, INTEGER, LONGINT, BOOLEAN
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value = level value
Поле ввода даты (Date Field)
Рисунок 4-25. Поле ввода даты
Поле ввода даты отображает дату из глобальной переменной типа Dates.Date. При любом изменении поля связанного интерактора вызывается уведомление с параметрами (change, undefined, undefined). Нажатие клавиш, которые не изменяют значение интерактора, таких как стрелки влево, вправо, не приводят к вызову уведомления. Клавиши стрелок вверх, вниз изменяют дату. Изменение выделения не дает никакого эффекта. Неверная дата не может быть введена.
properties: link, label, guard, notifier, font
linkable to: Dates.Date
op: pressed, released, changed
from: undefined, modifier
to: undefined
Поле ввода времени (Time Field)
Рисунок 4-26. Поле ввода времени
Поле ввода времени отображает время из глобальной переменной типа Dates.Time. При любом изменении связанного интерактора вызывается уведомление с параметрами (change, undefined, undefined). Нажатия клавиш, которые не приводят к изменению значений интерактора, таких как стрелки влево, вправо, не не приводит в вызову уведомления. Стрелки вверх, вниз изменяют время. Изменения выделения в поле не оказывает влияния. Неверное значение времени не может быть введено.
properties: link, label, guard, notifier, font
linkable to: Dates.Time
op: pressed, released, changed
from: undefined, modifier
to: undefined
Поле выбора цвета (Color Field)
Figure 4-27. Поле выбора цвета
Поле выбора цвета отображает цвета. Оно может быть связано с переменной типа INTEGER или Dialog.Color. Тип Ports.Color является переопределением для INTEGER, поэтому так же может быть использован.
При выборе любого другого цвета вызывается уведомление с параметрами (change, oldval, newval). Старое и новое значение являются целыми числами, для переменной типа Dialog.Color имеется поле val.
properties: link, label, guard, notifier, font
linkable to: Dialog.Color, Ports.Color = INTEGER
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Промотка (Up/Down Field)
Рисунок 4-28. Промотка
Такое поле связано с целочисленной переменной. Значение так же может быть изменено с помощью клавиш со стрелками. При любом изменении связанного поля интерактора происходит вызов уведомления с параметрами (change, oldvalue, newvalue).
properties: link, label, guard, notifier, font
linkable to: BYTE, SHORTINT, INTEGER, LONGINT
op: pressed, released
from: undefined, old value, modifier
to: undefined, new value
Заголовок (Caption)
Рисунок 4-29. Заголовок
Заголовок обычно применяется в сочетании с редактором для описания его содержимого. Заголовок пассивен, то есть не может быть отредактирован, поэтому не имеет уведомления.
Заголовок может быть связан к тем же типам переменных, что и редактор, и может иметь охранника. Это полезно (в зависимости от платформы) при отображении заголовка с разными визуальными эффектами, если он (или в равной степени его соответствующий редактор) недоступен, только для чтения и т.п. Это означает, что заголовок может быть недоступным вместе с соответствующим редактором, если их связать с одним и тем же полем интерактора. Охранник заголовка может изменить заголовок элемента управления, что актуально для элементов с видимым заголовком.
properties: link, label, guard, font, right, left
linkable to: ARRAY const OF CHAR,
BYTE, SHORTINT, INTEGER, LONGINT, SHORTREAL, REAL,
Dialog.Currency, Dialog.Combo
Свойства left и right определяют режим выравнивания заголовка. Возможны следующие комбинации:
left & ~right выравнивание по левому краю
left & right выравнивание по содержимому (может не срабатывать на некоторых платформах)
~left & ~right выравнивание по центру
~left & right выравнивание по правому краю
По умолчанию принято left & ~right (выравнивание по левому краю)
Группа (Group)
Рисунок 4-30. Группа
Группа применяется для визуального объединения связанных элементов, например: несколько кнопок зависимой фиксации. Группа - пассивный элемент, то есть не может быть отредактирована, а значит не имеет уведомления.
Группа может быть не связана с чем-либо, но может обладать охранником, делающим ее доступной или недоступной. Как и для всех элементов управления с видимым заголовком, охранник может менять менять заголовок группы.
properties: label, guard, font
Выпадающий список (List Box)
Рисунок 4-31. Выпадающий список (свернутая и распахнутая формы)
Выпадающий список позволяет выбрать одно значение из списка выбора. Он связан с переменной типа Dialog.List (смотри следующий раздел). Если высота списка не достаточна, отображается список с полосой прокрутки. Если и этого недостаточно, список сворачивается во всплывающее меню.
Выделение может быть изменено пользователем. Выделение может состоять из одного элемента списка или не содержать элементов. Когда пользователь изменяет выделение, вызывается уведомление с параметрами (changed, oldvalue, newvalue). Старое/новое значение соответствует индексу выделенного элемента списка. Самый верхний элемент имеет индекс 0, следующий элемент - индекс 1 и т.п. Если ничего не выделено, индекс равен -1.
Свойство sorted определяет необходимость сортировки строк в алфавитном порядке (не действует в Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.List
op: pressed, released, changed
from: undefined, old value, modifier
to: undefined, new value
Список (Selection Box)
Рисунок 4-32. Список
Список позволяет выделить несколько элементов из предложенного набора выбора. Он связан с переменной типа Dialog.Selection (смотри следующий раздел).
Выделение может быть изменено пользователем. Каждый элемент может быть выделен отдельно. Когда пользователь изменяет выделение, вызывается уведомление следующими тремя возможными способами:
(included, from, to): диапазон from..to сечас выделен; не то, что выделено до этого
(excluded, from, to): диапазон from..to сейчас не выделено; было выделено до того
(set, from, to): диапазон from..to сейчас выделено; до этого не были выделены.
Три кода included, excluded, set выставляются на месте changed и применяются в большинстве других элементов управления. Уведомление вызывается по мере необходимости при включении и/или исключении всех необходимых элементов в диапазоны.
Значения from, to соответствуют индексам элементов. Первый элемент соответствует значению 0, следующий 1 и т.п.
Свойство sorted определяет необходимость сортировки строк в алфавитном порядке (не действует в Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Selection
op: pressed, released, included, excluded, set
from: undefined, lowest element of range, modifier
to: undefined, highest element of range
Комбобокс (Combo Box)
Рисунок 4-33. Комбобокс
Комбобокс - это текстовый редактор, содержащий еще и множество значений в стиле всплывающего меню. В отличие от настоящих всплывающих меню и списков, могут быть введены и значения не содержащиеся в списке всплывающего меню. Элемент управления связывается с переменной типа Dialog.Combo (смотри следующий раздел).
При изменении содержимого комбобокса вызывается уведомитель с параметрами (changed, undefined, undefined).
Свойство sorted определяет необходимость сортировки строк в алфавитном порядке (не действует в Mac OS).
properties: link, label, guard, notifier, font, sorted
linkable to: Dialog.Combo
op: pressed, released, changed
from: undefined, modifier
to: undefined
Каждый интерактивный элемент управления (за исключением заголовка или группы) вызывает уведомление (если оно есть) когда пользователь в первый раз щелкнет на элементе управления с параметром op = Dialog.pressed и затем с параметром op = Dialog.released, когда кнопка мыши освобождается. Эта особенность используется по большей части для отображения какой-либо строки в статусной строке диалогового окна. Это можно сделать с помощь вызова Dialog.ShowStatus или Dialog.ShowParamStatus. Например, следующее уведомление показывает функцию кнопки пользователю:
PROCEDURE ButtonNotifier* (op, from, to: LONGINT);
BEGIN
IF op = Dialog.pressed THEN
Dialog.ShowStatus("This button causes the disk to spin down")
ELSIF op = Dialog.released THEN
Dialog.ShowStatus("") (* clear the status message again *)
END
END ButtonNotifier;
Листинг 4-34. Уведомление для отображения данных в статусной строке.
На некоторых платформах, таких как Mac OS, нет статусной строки, поэтому указанный выше код не дает результата.
Часто бывает полезным определить двойной щелчок, например, двойной щелчок на списке может выделить элемент и запустить кнопку по умолчанию. Двойной щелчок распознается уведомлением следующим образом:
IF (op = Dialog.pressed) & (from = 1) THEN ... (* double-click *)
Для упомянутого выше случая, в котором реакция на двойной щелчок сводится к простому выполнению команды кнопки по умолчанию, доступно более подходящее стандартное уведомление:
StdCmds.DefaultOnDoubleClick
Как уже упоминалось ранее, в BlackBox Component Builder обеспечивается возможность подмены строк с помощью карты ключей к собственно строкам, с применением ресурсного файла. Эта особенность так же поддерживается Dialog.ShowStatus. Например, вызов
Dialog.ShowParamStatus("This ^0 causes the ^1 to ^2", control, object, verb)
позволяет обеспечить разные строки для символов-заполнителей ^0, ^1, ^2. В действительности будут использованы строки из трех дополнительных параметров control, object и verb. Следует отметить, что строки подменяются перед их сцеплением в первую строку. Особенность подмены строк можно использовать исключительно в вызове процедуры Dialog.MapParamString.
4.7 Составные элементы управления и интеракторы
Выпадающий список имеет содержание 2-х видов: элемент в строке, который взят из списка и текущее выделение. Как правило, список элементов более постоянен, чем выделение, но и он так же может меняться в процессе использования. В случает списка или выделения приложению малоинтересен сам список элементов, так как он является только подсказкой для пользователя. Для приложения интересно выделение, установленное пользователем. Для списка выделение определяется индексом выделенного элемента. Для списка с множественным выбором выделение определяется множеством индексов выделенных элементов. Для комбобокса допустимо не только выделение, но и введенная строка.
Для всех трех типов списочных структур список элементов должен быть как-то построен. Для этой цели в модуле Dialog определяется подходящий интерактор: Dialog.List для списка, Dialog.Selection для списка, Dialog.Combo для комбобокса. Эти типы определяются следующим способом:
List = RECORD
index: INTEGER; (* индекс текущего выбранного элемента *)
len-: INTEGER; (* число элементов списка *)
PROCEDURE (VAR l: List) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR l: List) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR l: List) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR l: List) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Selection = RECORD
len-: INTEGER; (* число выделенных элементов *)
PROCEDURE (VAR s: Selection) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR s: Selection) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR s: Selection) SetResources (IN key: ARRAY OF CHAR), NEW;
PROCEDURE (VAR s: Selection) Incl (from, to: INTEGER), NEW;
(* выбрать диапазон [от..до] *)
PROCEDURE (VAR s: Selection) Excl (from, to: INTEGER), NEW;
(* отменить выделение диапазона [от..до] *)
PROCEDURE (VAR s: Selection) In (index: INTEGER): BOOLEAN, NEW
(* проверить, выделен ли элемент с номером index *)
END;
Combo = RECORD
item: String; (* текущая введенная или выделенная строка *)
len-: INTEGER; (* число элементов *)
PROCEDURE (VAR c: Combo) SetLen (len: INTEGER), NEW;
PROCEDURE (VAR c: Combo) SetItem (index: INTEGER; IN item: ARRAY OF CHAR), NEW;
PROCEDURE (VAR c: Combo) GetItem (index: INTEGER; OUT item: String), NEW;
PROCEDURE (VAR c: Combo) SetResources (IN key: ARRAY OF CHAR), NEW
END;
Листинг 4-35. Определения для списка, выделения и комбобокса
Перед использованием переменных любого из указанных типов, необходимо проинициализировать отдельные элементы. В процессе использования элементы могут быть изменены. Например, следующий фрагмент кода строит список:
list.SetLen(5); (* определить длину списка *)
list.SetItem(0, "Daffy Duck");
list.SetItem(1, "Wile E. Coyote");
list.SetItem(2, "Scrooge Mc Duck");
list.SetItem(3, "Huey Lewis");
list.SetItem(4, "Thomas Dewey");
Dialog.UpdateList(list); (* должен быть вызван после любых изменений элемента списка *)
Листинг 4-36. Явное построение списка
В случае применения спискоориентированной структуры (выпадающий список, список, комбобокс), Dialog.Update обновляет только выделение или текстовый ввод элемента управления, но не содержимое списка. Если изменяется структура, то есть элементы списка, то требуется вызывать процедуру Dialog.UpdateList вместо Dialog.Update.
Для фиксированных списков рекомендуется сохранять отдельные строки в ресурсах. Это облегчается применением процедур SetResources. Они ищут строки в ресурсном файле. Например, для полной замены вышеприведенного фрагмента может служить выражение:
list.SetResources("#Obx:list")
которое читает файл Obx/Rsrc/Strings и ищет вхождения ключей подобно "list[index]", например:
list[0] Daffy Duck
list[1] Wile E. Coyote
list[2] Scrooge Mc Duck
list[3] Huey Lewis
list[4] Thomas Dewey
Таблица 4-37. Ресурс списка
Индексы должны начинаться с 0 и быть последовательными (без пропусков). Процедура SetLen не обязательна. Ее рекомендуется использовать, когда заранее известно число элементов в списке. Для других случаев ее можно опускать. Списки становятся больше по мере роста индексов элементов. SetLen необходима, когда требуется сократить имеющийся список или когда его необходимо целиком очистить.
4.8 Контроль ввода
Контроль правильности ввода и невведения чего-нибудь противоестественного - один из аспектов немодального пользовательского интерфейса. Между прочим, немодальность также означает, что пользователь не должен вмешиваться в режим, зависящий от текущего положения символа вставки (курсора) и проверять, правильно ли введены текущие данные или нет.
В частности это означает, что нельзя заставлять пользователя вводить каки-либо данные прежде чем разрешить дальнейшие действия.
Существует две основные стратегии проверки правильности введенных данных: ранний и поздний. Ранняя проверка проводится в момент работы с элементом управления. Поздняя проверка проводится после полного ввода данных и попытке совершить над ними какое-либо действие, например: ввод новых данных в базу данных. Поздняя проверка в большинстве случаев подходит при проверке глобально определенных инвариантов, например: во все ли необходимые поля введены данные. Ранняя проверка больше подходит для локальных, использующих особенности элемента управления, инвариантов, например: исправление синтаксиса введенной строки.
Приведем примеры как ранней, так и поздней проверки для модуля ObxPhoneUI. Примем, что телефонный номер всегда имеет формат: 310-555-1212. Для поздней проверки будет дополнена процедура Lookup (выделенный шрифт) и добавлены несколько вспомогательных процедур. Необходимо отметить, что оператор "$", который используется с LEN возвращает длину строки, а не длину массива.
PROCEDURE Valid (IN s: ARRAY OF CHAR): BOOLEAN;
PROCEDURE Digits (IN s: ARRAY OF CHAR; from, to: INTEGER): BOOLEAN;
BEGIN (* проверить, содержит ли s в диапазоне [от..до] только цифры *)
WHILE (from <= to) & (s[from] >= "0") & (s[from] <= "9") DO INC(from) END;
RETURN from > to (* нет найденных нецифр в диапазоне *)
END Digits;
BEGIN (* проверить синтаксис телефонного номера *)
RETURN (LEN(s$) = 12) & Digits(s, 0, 2) & (s[3] = "-") & Digits(s, 4, 6) &
(s[7] = "-") & Digits(s, 8, 11)
END Valid;
PROCEDURE ShowErrorMessage;
BEGIN
phone.name := "illegal syntax of number"
END ShowErrorMessage;
PROCEDURE Lookup*;
BEGIN
IF phone.lookupByName THEN
ObxPhoneDB.LookupByName(phone.name, phone.number);
IF phone.number = "" THEN phone.number := "not found" END
ELSE
IF Valid(phone.number) THEN
ObxPhoneDB.LookupByNumber(phone.number, phone.name);
IF phone.name = "" THEN phone.name := "not found" END
ELSE
ShowErrorMessage
END
END;
Dialog.Update(phone)
END Lookup;
Листинг 4-38. Поздняя проверка правильности ввода.
Грубо говоря, напоминание показывает сообщение об ошибке. Если открыто окно рабочего журнала, то сообщение пишется в него, а само это окно перемещается на передний план. Если журнал не используется, ShowErrorMessage выполняет следующее выражение:
Dialog.ShowMsg("Please correct the phone number")
Рассмотрим альтернативное решение для проверки ввода: ранняя проверка. Для ее реализации применяется уведомление для проверки вода телефонного номера посимвольно на предмет разрешен ли символ или нет. В отличие от поздней проверки, в ранней необходимо оперировать с частично введенными телефонными номерами. Когда обнаружен неверный ввод, строка просто обрезается до легального значения.
PROCEDURE Correct (VAR s: ObxPhoneDB.String);
PROCEDURE CheckMinus (VAR s: ObxPhoneDB.String; at: INTEGER);
BEGIN
IF s[at] # "-" THEN s[at] := 0X END (* clip string *)
END CheckMinus;
PROCEDURE CheckDigits (VAR s: ARRAY OF CHAR; from, to: INTEGER);
BEGIN
WHILE from <= to DO
IF (s[from] < "0") OR (s[from] > "9") THEN
s[from] := 0X; from := to (* clip string and terminate loop *)
END;
INC(from)
END
END CheckDigits;
BEGIN (* обрезать строку до легального символа, если необходимо *)
CheckDigits(s, 0, 2);
CheckMinus(s, 3);
CheckDigits(s, 4, 6);
CheckMinus(s, 7);
CheckDigits(s, 8, 11)
END Correct;
PROCEDURE NumberNotifier (op, from, to: INTEGER);
BEGIN
Correct(phone.number)
(* Dialog.Update не вызывается, потому что он может быть вызван после с помощью уведомления *)
END NumberNotifier;
Листинг 4-39. Ранняя проверка ввода.
Следует отметить, что активное выделение, то есть элемент управления не может предотвратить перевод фокуса ввода на другое выделение. Выделение может только просто изменять собственное отображение, содержание или состояние. Для этой цели выделение получает Contorllers.MarkMsg при изменении фокуса ввода.
4.9 Прямой доступ к элементам управления
В большинстве случаев механизм охранников и уведомлений предоставляет достаточный контроль над поведением элементов управления в стиле "Посмотри и почувствуй" (Look&Feel). Тем не менее, иногда необходим прямой доступ к элементам управления на форме. Его описание и представлено в этом разделе. Например, предположим, что необходимо написать свою собственную команду выравнивания и добавиь ее в команды меню Layout. Для выполнения этого необходим доступ к форме представления в текущем редактируемом окне. Форма представления является контейнером для элементов управления, которыми хотим манипулировать. Функция FormControllers.Focus предоставляет ссылку на текущую форму с фокусом ввода в редакторе. Таким образом типичный код доступа выглядит следующим образом (Листинг 4-40):
VAR c: FormControllers.Controller;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
...
Листинг 4-40. Доступ к элементу управления формы
Форма содержит элементы управления и возможно некоторые другие визуальные элементы. При переводе формы в режим разметки, ее можно редактировать. Обычно элемент в начале выделяется, а затем над ним выполняются команды. Следующий пример смещает все выделенные элементы на один сантиметр вправо (листинг 4-41):
MODULE ObxControlShifter;
IMPORT Ports, Views, FormModels, FormControllers;
PROCEDURE Shift*;
VAR c: FormControllers.Controller; sel: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
sel := c.GetSelection(); (* генерируется список со ссылками на выбранные отображения *)
WHILE sel # NIL DO
c.form.Move(sel.view, 10 * Ports.mm, 0); (* сдвинуть вправо *)
sel := sel.next
END
END
END Shift;
END ObxControlShifter.
Листинг 4-41. Смещение всех выделенных элементов вправо.
Этот код работает с выделенными элементами (вне зависимости от того являются ли они управляющими). Иногда требуется оперировать с элементами, которые не выделены. В таком случае необходим считыватель форм (FormModels.Reader) для выполнения последовательных действий над всеми элементами формы с текущим фокусом ввода. Следующий пример кода показывает как команды оперируют со всеми элементами из формы (листинг 4-42):
VAR c: FormControllers.Controller; rd: FormModels.Reader;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* считать первое отображение *)
WHILE v # NIL DO
...
rd.ReadView(v) (* считать следующее отображение *)
END;
...
Листинг 4-42. Последовательный перебор всех элементов на форме
Элементы управления - это специальные элементы (типа Contorls.Control). Элементы управления могут быть связаны с глобальными переменными. Следующий пример показывает как получить в список все заголовки элементов управления на форме (листинг 4-43):
MODULE ObxLabelLister;
IMPORT Views, Controls, FormModels, FormControllers, StdLog;
PROCEDURE List*;
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* считать первое отображение *)
WHILE v # NIL DO
IF v IS Controls.Control THEN
StdLog.String(v(Controls.Control).label); StdLog.Ln
END;
rd.ReadView(v) (* считать следующее отображение *)
END
END
END List;
END ObxLabelLister.
Листинг 4-43. Создание списка заголовков всех элементов управления формы
Подобные операции могут быть проведены с любыми другими элементами на форме, не только с управляющими элементами. Например, допустим, что есть форма с кнопкой "Clear", которая приводит к очистке точечного просмотра. Кнопка - стандартный элемент управления, точечный просмотр - специальный тип. Команда, сопоставленная кнопке сперва должна найти точечный просмотр в той же форме, что и кнопка. Ниже приведен пример кода, демонстрирующего реализацию этой команды (листинг 4-44):
VAR c: FormControllers.Controller; rd: FormModels.Reader; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
rd := c.form.NewReader(NIL);
rd.ReadView(v); (* считать первое отображение *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* очичстить v(MyPlotterView) *)
END;
rd.ReadView(v) (* считать следующее отображение *)
END
END
Листинг 4-44. Поиск обычного просмотра на форме
Имеется одна потенциальная проблема в приведенном выше коде. Допустим, что имеется диалоговое окно, содержащее кнопку с командой ObxLabelLister.List. Под диалоговым окном имеется окно с фокусом ввода. Теперь, если щелкнуть на кнопке диалогового окна, какие заголовки будут собраны в список? Заголовки собственно с диалогового окна или заголовки с окна с фокусом ввода, расположенного под диалоговым? Другими словами: FormControllers.Focus обрабатывает окно, содержащее кнопку по которой только что щелкнули или форму, имеющую элемент управления с фокусом ввода? В зависимости от того, что делает команда по кнопке, оба варианта могут иметь место. Для команды редактирования формы подобных ObxContorlShifter.Shift будет возвращены данные с формы с фокусом ввода. Это самое верхнее документное окно, только перекрытое диалоговым окном. Наоборот: если требуется найти точечный просмотр, возвращена будет форма диалогового окна. В данном случае ищутся прямые "ближайшие соседи" кнопки.
Решение для поиска точечного просмотра будет начало поиска с контекста только что нажатой кнопки. Это можно сделать как указано в нижеследующем примере (листинг 4-45):
VAR button: Controls.Control; m: Models.Model; rd: FormModels.Reader; v: Views.View;
BEGIN
button := Controls.par; (* во время клика на кнопку, эта переменная содержит ссылку на кнопку *)
m := button.context.ThisModel(); (* получить модель контейнера отображения, которое содержит кнопку*)
IF m IS FormModels.Model THEN (* контейнер - это форма *)
rd := m(FormModels.Model).NewReader(NIL);
rd.ReadView(v); (* считать первое отображение *)
WHILE v # NIL DO
IF v IS MyPlotterView THEN
(* очистить v(MyPlotterView) *)
END;
rd.ReadView(v) (* считать второе отображение *)
END
END
Листинг 4-45. Поиск обычного просмотра в том же окне, что и кнопка
В этом коде предполагается, что команда будет выполнятся с кнопки. Она не будет работать из меню. В порядке лучшего разделения пользовательского интерфейса и программной логики этого предположения следует избегать. В BlackBox данная проблема решена предоставлением программисту исключительного контроля над поведением FormControllers.Focus. Хитрость состоит в том, что BlackBox поддерживает два вида окна диалоговых форм: инструментальное окно (tool windows) и вспомогательное окно (auxilary windows) в дополнение к обычному окну документа. Если кнопка расположена на инструментальном окне, FormControllers.Focus обрабатывает форму, являющуюся самым верхним окном документа или возвращает NIL, если такого окна документа не имеется или если фокус ввода самого верхнего окна документа не находится на форме. Если кнопка расположена на вспомогательном окне, FormContorllers.Focus обрабатывает форму диалогового окна, на которой эта кнопка расположена. В следующих абзацах приведено дальнейшее разъяснение различий между двумя видами окон.
Диалоговое окно в виде инструментального окна не является самостоятельным, оно обеспечивает параметры и элементы управления для операций в нижележащем документе. Типичный пример: диалог "Find / Replace", который оперирует с содержимым нижележащего документа. Кнопка диалогового окна запускает команду и эта команда выполняется в представлении, с которым она оперирует. В примере "Find / Replace" - это окно с текстом, имеющим фокус ввода. Под Windows инструментальное окно всегда является самым верхним окном, то есть никогда не перекрывается окнами документов или вспомогательными окнами, только другими инструментальными окнами. В отличие от других окон, инструментальные окна не могут менять размеры или минимизироваться, но могут перемещаться за пределы окна приложения. В Mac OS инструментальные окна частично похожи на обычные, за исключением отсутствия полос прокрутки и возможности изменения размеров.
С другой стороны, вспомогательные окна самодостаточны. Они содержат и оперируют со своими собственными данными. Как минимум, они знают как искать данные для своих операций (например в базе данных). Диалог "Phone Database" - типичное вспомогательное окно, как и большинство форм ввода данных. Над вспомогательными окнами можно выполнять все операции как и над обычными окнами, они так же могут перекрываться другими обычными или вспомогательными окнами.
Оба вида диалоговых окон хранятся как документы в определенном RSRC каталоге. Но для их открытия в модуле StdCmds определено две разных команды: OpenToolDialog и OpenAuxDialog. Каждая из них принимает переносимое имя файла ресурса как первый параметр и заголовок диалогового окна как второй параметр. Например, могут быть использованы следующие команды меню:
"Find / Replace..." "" "StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Find / Replace')" ""
"Phone Database..." "" "StdCmds.OpenAuxDialog('Obx/Rsrc/PhoneUI', 'Phone Database')" ""
Функция FormControllers.Focus возвращает разный результат, в зависимости от того является ли форма инструментальным или вспомогательным окном.
Дальнейшие примеры операция с формами можно найти в модуле FormCmds. Он доступен в исходных кодах и основан на подсистеме Form.
4.10 Резюме
В этой главе обсуждались важные аспекты реализации графического пользовательского интерфейса и его воплощении в виде кодов в BlackBox Component Builder. Имеется три части приложения: логика приложения, логика интерфейса и ресурсы, то есть документы. Четкое разделение этих частей делает программы более понятными, поддерживаемыми и расширяемыми.
В качестве примеров применения системы форм и элементов управления смотри встроенные примеры ObxAddress0, ObxAddress1, ObxAddress2, ObxOrders, ObxControld, ObxDialog и ObxUnitConv. Для более опытных программистов могут быть интересны исходные коды всей подсистемы Form.
За дополнительной информацией об использовании среды разработки BlackBox обращайтесь к документации следующих модулей:
DevCompiler, DevDebug, DevBrowser, DevInspector, DevReferences, DevMarkers, DevCmds, StdCmds, StdMenuTool, StdLog, FormCmds, TextCmds.
Для того, чтобы узнать больше о модуле, выделите его имя и выполните команду Info->Documentation. В порядке возрастающего описания были описаны только наиболее важные команды. Тем не менее, имеются другие полезные команды в меню Info, Dev, Controls, Tools и Layout. Например, несколько "мастеров" для создания основы нового кода. Обратитесь к файлам System/Docu/User-Man, Text/Docu/User-Man, Form/Docu/User-Man и Dev/Docu/User-Man за исчерпывающим руководством пользователя по структуре, редактору (подсистема Text), визуальному проектированию (подсистема Form) и средствам разработки (подсистема Dev). | Docu/ru/Tut-4.odc |
5 Тексты
ENGLISH
Графические интерфейсы пользователя ввели графические элементы в повседневную компьютерную жизнь. Это значительный шаг вперед в сравнении с модальным текстовым интерфейсом, но простой текст нисколько не устарел. Даже в отчетах с большим количеством иллюстраций текст служит необходимым связующим звеном.
В типичном приложении баз данных не выполняются операции над графической информацией. Данные, которые вводятся и выбираются, в большинстве своем являются текстом, и отчеты обычно печатаются в виде текста, оформленного в таблицы.
В виду важности текста в этой главе описывается как можно использовать текстовые абстракции BlackBox Component Builder для различных целей. В нескольких примерах будет использован модуль простейшей базы данных, представленный в предыдущей главе.
Работа будет осуществляться "снизу-вверх" (bottom-up), на примерах будет показано вначале как записать новый текст, затем прочитать имеющийся текст и в конце как изменить имеющийся текст. В процессе обсуждения примеров встретятся текстовые модели/носители, курьеры, отображатели и дополнительные абстракции, такие как шрифты, атрибуты, линейки и др.
5.1 Запись текста
В BlackBox Component Builder'е тексты используются в рамках схемы проектирования носитель-курьер-отображатель (см. главу 3). Они обеспечивает текстовые модели в качестве носителей для текста, текстовых записывателей и считывателей в качестве курьеров для текстовых моделей. Оба типа описаны в центральном модуле TextModels подсистемы Text. Записыватель текста хранит текущую позицию и текущие атрибуты, которые будут использованы при записи очередного элемента в текст. Ниже приведено полное определение записывателя:
Writer = POINTER TO ABSTRACT RECORD
attr-: TextModels.Attributes;
(wr: Writer) Base (): TextModels.Model, NEW, ABSTRACT;
(wr: Writer) Pos (): INTEGER, NEW, ABSTRACT;
(wr: Writer) SetPos (pos: INTEGER), NEW, ABSTRACT;
(wr: Writer) SetAttr (attr: TextModels.Attributes), NEW;
(wr: Writer) WriteChar (ch: CHAR), NEW, ABSTRACT;
(wr: Writer) WriteView (view: Views.View; w, h: INTEGER), NEW, ABSTRACT
END;
Листинг 5-1. Определение типа TextModels.Writer
Наиболее важной процедурой записывателя является WriteChar, она позволяет записать новый символ в текущую позицию. Если позиция символа находится внутри текста (т.е. в диапазоне 0..text.Length() - 1), символ вставляется на эту позицию в тексте. (Это отличается от абстракции файла BlackBox'а, в которой в данном случае старые данные будут переписаны записывателем. В случае текстов записыватели всегда вставляют, но не перезаписывают.) Если записыватель указывает на позицию в конце текста (т.е. text.Length()), символ дописывается к тексту, что сделает текст на один элемент длиннее. После выполнения процедуры WriteChar позиция записывателя в тексте увеличивается на единицу. Текущую позицию записывателя можно узнать, вызвав функцию записывателя Pos, и ее можно изменить, вызвав процедуру SetPos.
В связи с тем, что модель текста может содержать отображения (view) наряду с обычными символами, имеется процедура WriteView, позволяющая записать отображение с конкретными указанными размерами (w для ширины, h для высоты). Как и большинство геометрических размеров в BlackBox, ширина и высота отображения определяется в так называемых универсальных единицах, составляющих 1/36000 мм. Это значение выбрано для исключения ошибок округления для большинства разрешений экрана и принтера. Например, дюйм, 1/300 часть дюйма, миллиметр и полиграфический пункт могут быть выражены в универсальных единицах без ошибок округления. Если не указано иное, предполагается, что размеры выражены в универсальных единицах.
Если не требуется указывать определенный размер для отображения, то передаются значение Views.undefined для ширины и/или высоты, что позволяет тексту выбрать подходящий размер для записываемого отображения.
Как создается записыватель? Как и все курьеры, записыватели создаются с помощью фабричной функции их носителей. Для этой цели текстовая модель предоставляет процедуру NewWriter, которая создает записывателя и соединяет его с текстом. Записыватель может вернуть текст посредством функции Base. Вновь созданный записыватель позиционируется на конец текста.
Элемент текста содержит не только собственно символ, но также и атрибуты символа. В поле attr записывателя содержатся атрибуты, которые будут применяться при записи следующего символа или отображения. Текущие атрибуты могут быть изменены вызовом процедуры записывателя SetAttr.
В качестве атрибутов текстовая подсистема BlackBox Component Builder поддерживает цвет и вертикальное смещение. Цвета закодированы целыми числами (Ports.Color). Модуль Ports содержит предопределенные константы black (черный), grey6 (серый 6), grey12 (серый 12), grey25, grey50, grey75, white (белый), red (красный), green (зеленый) и blue (синий). "grey6" означает смесь 6% белого и 94% черного, т.е. почти черный. Другие значения серого постепенно становятся все светлее. Вертикальное смещение измеряется в универсальных единицах.
Помимо цвета и вертикального смещения текстовые элементы также имеют атрибут шрифта. Шрифт - это коллекция изображений. Изображения представляют собой визуальное отображение кода символа. Разные шрифты могут содержать различные изображения для одного и того же символа. Например, Helvetica выглядит иначе, чем Times или Futiger. Шрифты могут поддерживать не все коды символов, представленных в Component Pascal. Это не удивительно, так как тип CHAR для Component Pascal соответствует стандарту Unicode. Unicode - 16-ти битный стандарт, что означает возможность определения более 65000 различных символов. Первый 256 символов - символы из Latin-1. Первые 128 символов из Latin-1 - наиболее значимые символы набора ASCII.
Если в шрифте не определено какое-либо изображение, каркас BlackBox'а вернет изображение этого символа из какого-нибудь другого шрифта, либо символ "отсутствующее изображение", т.е. маленький пустой прямоугольник. Объекты шрифта определены в модуле Fonts. Сейчас нет необходимости более подробно рассматривать этот модуль здесь, достаточно интерпретировать указатель типа Fonts.Font как идентификатор штифта с какими-то конкретными значениями начертания, стиля написания, жирности и размера.
Начертание (typeface)
Начертание определяется группой шрифтов, к которой он принадлежит, оно определяет внешний вид для всей группы в целом. Примеры начертаний: Helvetica, Times, Courier. Наименования начертаний представлены в виде символьного массива типа Fonts.Typeface.
Стиль написания (Style)
Штифт дополнительно может быть написан наклонно, подчеркнут, зачеркнут или содержать все эти комбинации. Стили написания представлены в виде множества. На данный момент определены элементы Fonts.italic, Fonts.underline и Fonts.strikeout.
Жирность (weight)
Шрифты могут быть разной жирности, то есть в диапазоне от светлого к нормальному и от полужирного к жирному. Обычно шрифт бывает нормальным или полужирным. Жирность определяется как целое число. Имеются предопределенные значения Fonts.normal и Fonts.bold.
Размер (size)
Шрифты могут отображаться различными размерами, в зависимости от разрешения применяемого устройства вывода. Часто размер задается в пунктах. Пункт 1/72 часть дюйма. В BlackBox размер шрифта измеряется в универсальных единицах, которые подобраны так, что пункты (Ports.point) и другие полиграфические единицы могут быть представлены без ошибок округления. Обычные размеры шрифта: 10 или 12 пунктов.
(10 * Ports.point or 12 * Ports.point)
В принципе, начертание, стиль, жирность и размер не зависят друг от друга. Это означает, что данное начертание может быть произвольного стиля написания, жирности и размера. Тем не менее, с точки зрения полиграфистов, некоторые комбинации более предпочтительны, чем другие и могут быть оптимизированы разработчиком шрифта или механизмами операционной системой, связанными со шрифтом.
Атрибуты текста: шрифт, цвет, вертикальное смещение собраны в объекте типа TextModels.Attributes. Слегка упрощая, этот тип определен как:
Attributes = POINTER TO RECORD (Stores.Store)
color-: Ports.Color;
font-: Fonts.Font;
offset-: INTEGER
END;
Листинг 5-2. Упрощенное определение TextModels.Attributes
Это - тип поля attr записывателя. Он является расширением типа Stores.Store. Это означает, что подобный объект можно сохранять в файл. Другие примеры хранимых объектов: TextModels.Model и TextViews.View, но не TextModels.Writer. Более детальное описание приведено в части III.
Сейчас рассмотрим возможности записывателя текстов, включая поддерживаемые атрибуты текста. Типичное использование писателей текста приведено в нижеследующем образце кода. Образец кода - выдержка из процедуры, показывающий один или несколько важных аспектов обсуждаемых объектов. Подобный фрагмент кода является рецептом, который должен знать владеющий этой темой программист.
VAR t: TextModels.Model; wr: TextModels.Writer; ch: CHAR;
BEGIN
t := TextModels.dir.New(); (* разместим новую пустую текстовую модель*)
wr := t.NewWriter(NIL);
... produce ch ...
WHILE condition DO
wr.WriteChar(ch);
... produce ch ...
END;
Листинг 5-3. Образец кода из TextModels.Writer
Фрагмент кода не очень интересен, потому что не показывает, каким образом сгенерированный текст можно отобразить на экране. Объект текста представляет лишь текст с его атрибутами. Он не знает о том, как изобразить этот текст, даже не знает, как его форматировать; т.е. не знает каким образом разбить текст на строки и страницы так, чтобы они уместились в заданном прямоугольнике (отображении, листе бумаги и т.п.). Когда необходимо отобразить текст, нужно обеспечить отображение текста для текстового объекта. Объекты данных, которые могут быть представлены в нескольких отображениях, обычно называются моделями (models). Отделение модели от отображения важная проектная схема, которая обсуждалась в главе 2.
Модуль TextModels только экспортирует абстрактный тип записей для текстовых моделей без конкретной реализации. Взамен он экспортирует объект директория (TextModels.dir), который обеспечивает необходимую фабричную функцию (TextModels.dir.New). Этот косвенный способ создания объекта был обоснован в главе 2.
Работа непосредственно с записывателем текста неудобна, так как он не поддерживает запись строк. По этой причине нижеследующий пример использует форматеры для записи текстов. Форматер - это отображатель (смотри главу 3), который содержит текстовый записыватель и обеспечивает отображение высокоуровневых символов, таких как символы Component Pascal в поток простых символов, которые могут быть переданы для работы записывателю. В следующем примере применяется форматер для записи текста, очень простой "отчет". Текст представляет собой содержимое базы данных телефонов, по одной строке на запись. Это первая версия отчета по базе данных телефонов реализована в модуле ObxPDBrep0:
MODULE ObxPDBRep0;
IMPORT Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* создание пустого носителя текста *)
f.ConnectTo(t); (* соединение фоматера к тексту *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* первая строка *)
f.WriteTab; (* символ табуляции *)
f.WriteString(number); (* вторая строка *)
f.WriteLn; (* возврат каретки *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* создание отображения текста для созданного выше текста *)
Views.OpenView(v) (* открытие отображения текста в собственном окне *)
END GenReport;
END ObxPDBRep0.
Листинг 5-4. Запись базы данных телефонов с применением форматера.
Следует отметить, что имена и телефоны разделены символом табуляции (09X). Так как позиции табуляции не определены для данного текста, то символ табуляции воспринимается как широкий пробел фиксированного размера (ширина которого равна нескольким ширинам символа обычного пробела). Позже будет разъяснено, каким образом можно определить позиции табуляции.
Результат выполнения команды ObxPDBRep0 приведен на следующем рисунке:
Рисунок 5-5. Окно текстового редактора, содержащее базу данных телефонов.
Текст во вновь открытом окне представляет собой полноценно редактируемое отображение текста. Его можно редактировать, сохранить как документ BlackBox, распечатать и т.п. Если посмотреть на исходный код, то можно увидеть следующий шаблон кода:
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View;
BEGIN
t := TextModels.dir.New();
f.ConnectTo(t);
... использование процедур форматера для создания текста ...
v := TextViews.dir.New(t);
Views.OpenView(v)
Листинг 5-6. Шаблон кода для TextMappers.Formatter и для открытия текстового отображения.
Этот шаблон кода встречается во многих командах BlackBox'а, например, DevDebug.ShowLoadedModules. Он удобен во всех случаях, когда нужно написать табличные отчеты различной длины, возможно разделенный на несколько печатных страниц. Так же четко видно, что текст вобрал в себя несколько шаблонов проектирования: объект текста является моделью, которая наблюдается визуальным отображением (проектная схема Наблюдатель), носителем (проектная схема Носитель-Курьер-Отображатель) и контейнером (проектная схема Компоновщик).
Интересная особенность приведенного выше фрагмента кода: вначале создается текстовый носитель t, затем его содержимое формируется с помощью форматера, и только затем создается отображение v для носителя. В завершение, отображение открывается в собственном окне документа.
В BlackBox'е важно, что модель может подвергаться изменениям до того, как будет создано какое-либо его отображение. Фактически, намного эффективнее создавать текст до открытия его отображения, потому что обновление экрана и некоторые внутренние ресурсы для обеспечения механизма отката в таком случае не требуется, что заметно сказывается на скорости.
В BlackBox'е текстовая модель представлена в виде последовательности текстовых элементов. Текстовыми элементами могут быть символы из набора Latin-1 (SHORTCHAR), символы набора Unicode (a CHAR > 0FFX) или отображение (расширение типа Views.View). Текст может иметь атрибуты шрифта, цвета и вертикального смещения. Поскольку модель текста может содержать отображения, то это - контейнер. В следующем примере показано, каким образом данные возможности можно использовать при создании нового текста. База данных телефонов будет использоваться как источник данных для вывода в отчет, при этом будут применяться различные представления для текста в различных примерах.
Следующий пример показывает каким образом можно генерировать текст из нашей тестовой базы данных. В этом тексте наименования выводятся зеленым цветом. Различия с модулем ObxPDBRep0 выделены подчеркнутым текстом.
MODULE ObxPDBRep1;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, ObxPhoneDB;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
default,green:TextModels.Attributes;
BEGIN
t := TextModels.dir.New(); (* создание пустого носителя *)
f.ConnectTo(t); (* соединение форматера с текстом*)
default:=f.rider.attr; (* сохранение старых атрибутов для дальнейшего использования *)
green:=TextModels.NewColor(default,Ports.green); (* используем зеленый цвет *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.rider.SetAttr(green); (* поменять текущие атрибуты курьера форматера *)
f.WriteString(name); (* первая строка *)
f.rider.SetAttr(default); (* поменять текущие атрибуты курьера форматера *)
f.WriteTab; (* символ табуляции *)
f.WriteString(number); (* вторая строка *)
f.WriteLn; (* перевод каретки *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* создать текстовой отображение для сгенерированного ранее текста *)
Views.OpenView(v) (* открыть отображение в своем собственном окне *)
END GenReport;
END ObxPDBRep1.
Листинг 5-7. Вывод базы данных телефонов в зеленом цвете
Следует отметить, что курьер форматера содержит текущий набор атрибутов (TextModels.Writer.attr). Он включает в себя текущий цвет и доступен только для чтения; текущий набор может быть установлен с помощью процедуры записывателя SetAttr.
Первые примеры: ObxPDBRep0 и ObxPDBRep1 - не выводят красивых отчетов, потому что телефонные номера не выровнены по вертикали один под другим в табличном стиле.
ObxPDBRep2 исправляет этот дефект, вставив линейку в начало текста. Эта линейка определяет позиции табуляции, которая выровняет все телефонные номера, отделенные от имен знаком табуляции. Отличия от модуля ObxPDBRep0 помечены подчеркнутым текстом.
MODULE ObxPDBRep2;
IMPORT Ports, Views, TextModels, TextMappers, TextViews, TextRulers, ObxPhoneDB;
PROCEDUREWriteRuler(VARf:TextMappers.Formatter);
CONST cm = 10 * Ports.mm; (* универсальные определения *)
VAR ruler: TextRulers.Ruler;
BEGIN
ruler := TextRulers.dir.New(NIL);
TextRulers.AddTab(ruler, 4 * cm); (* определить остановку табуляции, 4 cm от левого отступа *)
TextRulers.SetRight(ruler, 12 * cm); (* определить правый отступ *)
f.WriteView(ruler) (* линейка - это отображение, оно может быть записано в текст *)
END WriteRuler;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* создать пустого текстового носителя *)
f.ConnectTo(t); (* соединить форматер с текстом *)
WriteRuler(f);
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
f.WriteString(name); (* первая строка *)
f.WriteTab; (* символ табуляции *)
f.WriteString(number); (* вторая строка *)
f.WriteLn; (* возврат каретки *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* создать текстовой отображение для сгенерированного ранее текста *)
Views.OpenView(v) (* открыть отображение в своем собственном окне *)
END GenReport;
END ObxPDBRep2.
Листинг 5-8. Запись телефонной базы данных с применением форматера и линейки
Выполнение ObxPDBRep2.GenReport приводит к появлению окна с улучшенным представлением телефонной базы данных. Выполнение Text->Show Marks приводит к отображению линейки:
Рисунок 5-9. Текстовый редактор содержащий таблицу базы данных
Линейки являются отображениями. Сами по себе они ничего не значат. Как и остальные элементы управления линейки работают только внутри контейнера. В отличие от большинства других элементов управления, линейки являются примером элементов, которые работают правильно только внутри определенного контейнера, в данном случае, внутри текстовой модели. Можно скопировать линейку на форму или другой контейнер, но она останется пассивной и не даст никакого полезного эффекта. Если она внедрена в текстовую модель, которая отображается в визуальном представлении текста, то линейка может повлиять на способ форматирования следующего за ней текста. Например, линейка может определять позиции табуляции, отступы и тип выравнивания.
Параметры линейки действуют в определенной области. Она начинается от начала линейки и заканчивается перед следующей линейкой или доходит до конца текста, если других линеек дальше нет. Линейки определяют новый параграф, возможно со своим собственным набором атрибутов. Вставка символа начала параграфа (0EX) вместо линейки так же начинает новый параграф, но все его параметры наследуются от последней линейки. Символ параграфа - нормальный способ начать новый параграф, линейки необходимы только при необходимости изменения атрибутов параграфа. Следует отметить, что символ возврата каретки (0DX) не начинает новый параграф.
Текстовое отображение содержит невидимую линейку по умолчанию, которая определяет форматирование текста до первой линейки или всего текста в случае, если линейка не была вставлена вовсе. Линейку по умолчанию, а также настройки по умолчанию можно изменить интерактивно командой меню Text->Make Default Ruler и Text->Make Default Attributes.
У линейки есть много атрибутов, которые можно изменить. В отличие от параметров символов, которые можно применить к произвольному куску текста, атрибуты линейки применяются к линейке или ко всем параграфам в ее области действия.
Мы обсудим эти атрибуты, так что вы узнаете о функциональности линеек, когда вам это нужно. Однако мы не будем обсуждать линейки более подробно, т.к. вы можете изучить нужные детали, когда вам потребуется более продвинутые возможности линеек (см. документацию к модулю TextRulers).
Стили
Атрибуты линеек не хранятся в линейках отображения напрямую. Вместо этого они привязаны к отдельному объекту типа TextRulers.Attributes, который в свою очередь, содержится внутри объекта типа TextRulers.Style. Стиль - модель одного или нескольких отображений линеек. Если несколько отображений связаны с одной и той же моделью, то пользователь может изменить атрибуты всех линеек одновременно. Например, изменение левого отступа вступит в силу для всех линеек, основанных на данном стиле. Тем не менее, модель не может распределяться на несколько документов, что означает, что все границы линеек стилей должны быть внедрены в тот же документ.
TextRulers.Attributes представляют собой коллекцию атрибутов линеек, подобно тому как TextModels.Attributes представляют собой коллекцию атрибутов символов.
Attributes = POINTER TO EXTENSIBLE RECORD (Stores.Store)
first-, left-, right-, lead-, asc-, dsc-, grid-: INTEGER;
opts-: SET;
tabs-: TextRulers.TabArray
END;
Листинг 5-10. Упрощенное описание TextRules.Attributes
В следующем параграфе будут описаны индивидуальные атрибуты. Для работы с этими атрибутами имеются вспомогательные процедуры в модуле TextRulers, которое облегчают установку линеек текста желаемым образом: создается новая линейка при помощи процедуры TextRulers.dir.New(NIL), а затем применяются вспомогательные процедуры для достижения требуемых атрибутов. Пример имеется в приведенной выше процедуре WriteRuler модуля ObxPdBRep2. Эти вспомогательные процедуры значительно облегчают установку текстовых линеек. Например, они прячут то, что атрибуты принадлежат не непосредственно линейкам, а специальному объекту атрибутов, который затем используется линейками. В терминологии шаблонов проектирования [GHJV94] обеспечение облегченного доступа к составным свойствам называется фасадом. Этот механизм простой, потому что фасад состоит из простых процедур, не требуется создавать и управлять какой-то дополнительный объект фасада.
Отступы табуляции
Поле tabs типа TextRulers.TabArray содержит информацию об отступах табуляции. Число отступов табуляции задано в tabs.len и не может быть больше TextRulers.maxTabs (текущее значение 32). Если пользователь вводит больше, чем maxTabs позиций отступов табуляции, или больше, чем заданое len, то лишние позиции будут заменены на пробелы фиксированной ширины. Фиксированная ширина вычисляется как умножение ширины пробела на целое число текущего шрифта, в общем, приблизительно 4 мм.
Tab = RECORD
stop: INTEGER; (* отступ >= 0 *)
type: SET (* тип IN {TextRulers.centerTab, TextRulers.rightTab, TextRulers.barTab} *)
END;
TabArray = RECORD
len: INTEGER; (* 0 <= len <= TextRulers.maxTabs *)
tab: ARRAY TextRulers.maxTabs OF TextRulers.Tab
(* tab[0 .. len-1] отсортированы в возрастающем порядке без дубликатов *)
END
Листинг 5-11. Определение TextRulers.Tab и TabArray
В tabs.tab.stop задается расстояние от левого края текста отображения (конечно же, в универсальных единицах). Отступы табуляции в массиве tabs.tab должны быть отсортированы в порядке возрастания и не должны содержать повторяющихся значений.
В дополнении к позиции отступа, хранящейся в поле stop, может храниться и набор дополнительных возможностей, хранящийся в поле type. В частности, эти возможности позволяют центрировать или выравнивать по правому краю текст внутри абзацного отступа (по умолчанию он выравнивается по левой границе):
tab type tabs.tab[i].type
left adjusted {}
right adjusted {TextRulers.rightTab}
centered {TextRulers.centerTab}
В дополнение к вышеперечисленным типам есть возможность дополнительно определить будет ли отрисовываться вертикальная прографка (vertical bar). Прографка определяется включением в набор type значения TextRulers.barTab. Так как прографка занимает всю высоту строки, ее удобно применять для простых таблиц.
После вызова TextRulers.dir.New(NIL), линейка не содержит отступов табуляции.
Следующие вспомогательные процедуры обеспечивают изменения линеек:
PROCEDURE AddTab (r: Ruler; x: INTEGER)
PROCEDURE MakeRightTab (r: Ruler)
PROCEDURE MakeCenterTab (r: Ruler)
PROCEDURE MakeLineTab (r: Ruler)
AddTab добавляет нормальный левовыровненный отступ табуляции. Он может быть изменен на правовыровненный или центральный вызовом MakeRight или MakeCenterTab. Вне зависимости от режима выравнивания, отступ табуляции может быть переведен в отступ с прографкой вызовом MakeLineTab.
Поля
Текст представляет из себя набор с левым и правым полем. Эти поля можно определить как расстояние от левого края отображения текста. Левое поле должно быть меньше правого поля.
left-, right-: INTEGER (* (left >= 0) & (right >= left) *)
Иногда необходимо уведомить разметчика текста о необходимости игнорировать правое поле и использовать для отображения текста символ разрыва строки. Фактически, это поведение по умолчанию. Это означает, что при изменении размера отображения могут так же измениться разрывы строки. Даже если правое поле игнорируется, оно все равно еще полезно: текстовое отображение получает примерную оценку насколько широко следует его открыть.
Разрывы строк при фиксированном правом поле необходимы в очень редких обстоятельствах, например, когда следующий параграф необходимо уместить рядом с предыдущим. Если необходимо, чтобы строки разрывались только по правому полю, то необходимо включить TextRulers.rightFixed в набор opts (смотри ниже).
Следует отметить, что команда Tools->Document Size... позволяет гибко назначить ширину (и высоту) первоначального отображения документа, так же называемого корневым отображением (root view). Ширина может быть назначена фиксированным размером, что полезно для приложений с разметкой страниц.
Тем не менее, чаще всего ширина определяется настройками страницы, которая наследует ширину и высоту отображения для текущей выбранной страницы, урезанные на пользовательские поля. Это отвечает требованиям таких документов как: письма, программный код и т.п.
Третьей возможностью может быть ограничение ширины корневого отображения рамками размеров окна (как упоминалось выше, когда отображение использует размер правого поля из линейки как подсказку, вне зависимости от того фиксирована ли правое поле или нет). При любом изменении размеров окна, корневое отображение изменяет размер соответствующим образом, чтобы в окне уместилось столько информации, сколько возможно. Это удобно для типичного окна встроенной документации, в котором информация должна занимать столько места на экране, сколько для этого позволит пользователь, текст должен адаптироваться по ширине вне зависимости от изменения размеров окна. Примером подобного стиля является форматирование по умолчанию для Веб-страницы.
Следует отметить, что эта особенность не зависит от типа корневого отображения. Она работает подобным образом для всех отображений, способных менять размеры, таких как текстовое отображение, форма и большинство других редакторов.
При создании при помощи TextRulers.dir.New(NIL) линейка получает левое поле равное 0 и правое нефиксированное поле больше 0 в зависимости от специфики реализации.
Следующие вспомогательные процедуры обеспечивают изменение линейки:
PROCEDURE SetLeft (r: Ruler; x: INTEGER)
PROCEDURE SetRight (r: Ruler; x: INTEGER)
PROCEDURE SetFixedRight (r: Ruler; x: INTEGER)
SetLeft и SetRight устанавливают левое и правое поле. SetFixedRight выставляет правое поле и делает его фиксированным.
Отступ первой строки
Линейки задают отступ первой строки, то есть насколько первая строка после линейки будет сдвинута от левой границы текстового отображения. Следует отметить, что можно задать отступ первой строки меньше, чем левое поле (first < left). Это возможно только в случае, если текстовое отображение выводит текст при определенном значении левого поля.
first-: INTEGER; (* first >= 0 *)
Отступ первой строки применяется для всех первый строк каждого параграфа в пределах действия линейки.
При создании линейки с помощью TextRulers.dir.New(NIL) линейка не имеет отступа для первой строки (first = 0). Следующая вспомогательная процедура обеспечивает изменение для линейки:
PROCEDURE SetFirst (r: Ruler; x: INTEGER)
Над- и подстрочные элементы
При при отрисовке символа его изображение зависит от атрибутов шрифта, таких как гарнитура (Helvetica или Times?), стиль (обычное или наклонное?), начертание (нормальное или жирное) и размер. При отрисовке строки целиком все символы размещаются на обычной базовой линии. Надстрочный элемент - максимальный выступ символа над базовой линией. Некоторые символы имеют выступ под базовую линию, например "у", "р". Подстрочный элемент - максимальный выступ любого символа под базовую линию (см. рис. 5-12). Разметчик текста должен вычислять расстояние между базовыми линиями для предотвращения перекрытия надстрочных и подстрочных элементов соседних строк во избежание наложения символов. Во избежание вырожденных случаев, таких как пустая строка или строка с экстремальными размерами шрифтов, линейки могут задать минимальные значения для надстрочных (asc) и подстрочных (des) элементов.
asc-, dsc-: INTEGER; (* (asc >= 0) & (dsc >= 0) *)
Рисунок 5-12. Над-, подстрочные элементы и базовая линия
При создании линейки с помощью TextRulers.dir.New(NIL) для надстрочных и подстрочных элементов используются значения текущего шрифта по умолчанию (Fonts.dir.Default()) в качестве начальных значений.
Следующие вспомогательные процедуры обеспечивают изменение линейки:
PROCEDURE SetAsc (r: Ruler; h: INTEGER)
PROCEDURE SetDsc (r: Ruler; h: INTEGER)
Отбивка параграфа
Отбивка параграфа определяет дополнительное расстояние по вертикали, добавляемое между последней строкой предыдущего параграфа и первой строкой следующего параграфа. При использовании разметки сетки строк (смотри ниже), считается хорошим стилем выставлять отбивку кратной строке, чаще всего половине строки. Отбивка позволяет визуально отличить новый параграф от простого перевода каретки.
lead-: INTEGER; (* lead >= 0 *)
При создании линейки с помощью TextRulers.dir.New(NIL) отбивка устанавливается в 0.
Следующая вспомогательная процедура обеспечивает изменение линейки:
PROCEDURE SetLead (r: Ruler; h: INTEGER)
Сетка линеек
Если значение grid равно нулю, то линии располагаются настолько близко, насколько это возможно, чтобы не оставалось свободного месте между надстрочными и подстрочными элементами соседних строк. Разные строки могут иметь разные надстрочные и подстрочные элементы, в зависимости от текста и шрифта содержимого. По этой причине расстояние между базовыми линиями необходимо делать нерегулярным. Из соображений типографики, нерегулярное расстояние между строками часто нежелательно.
Для закрепления регулярного расположения сетки линеек возможно установка сетки линеек путем присвоения значению grid значения больше нуля. Это значение определяет вертикальную сетку, согласно которой принудительно выставляются базовые линии. В случае, если строка слишком высокая для размещения на следующем участке сетки, то она располагается на одну или несколько позиций сетки ниже (см рисунок 5-14).
grid-: INTEGER; (* grid >= 0 *)
Рисунок 5-13. Сетка строк
В момент создания с помощью TextRulers.dir.New(NIL) линейка имеет значение линий сетки равное 1. Следующая вспомогательная процедура обеспечивает изменение линейки:
PROCEDURE SetGrid (r: Ruler; h: INTEGER)
Режимы выравнивания
Для длинных участков текста бывает необходимо разрывать строки между полями отображения. В зависимости от настроек, поведение текста может быть различным. Текст может быть выровнен по левому краю (левая выключка), по правому краю (правая выключка), центрирован или выровнен одновременно по левому и правому полям (полная выключка). Эти четыре режима выравнивания контролируются двумя флагами: TextRulers.leftAdjust и TextRulers.rightAdjust
leftAdjust rightAdjust adjustment mode
FALSE FALSE centered
FALSE TRUE right adjusted
TRUE FALSE left adjusted (default)
TRUE TRUE fully adjusted
Таблица 5-14. Режимы выравнивания
режимы выравнивания могут быть включены или выключены исчерпывающим набором, оформленным в виде множества:
opts-: SET (* opts это подмножество {leftAdjust, rightAdjust, pageBreak, rightFixed, noBreakInside, parJoin; другое множество элементов зарезервировано *)
В момент создания с помощью TextRulers.dir.New(NIL) значение набора выравнивания установлено в {leftAdjust}.
Следующие вспомогательные процедуры обеспечивают модификации линейки:
PROCEDURE SetLeftFlush (r: Ruler)
PROCEDURE SetCentered (r: Ruler)
PROCEDURE SetRightFlush (r: Ruler)
PROCEDURE SetJustified (r: Ruler)
Разрывы страницы
Линейки могут выполнять принудительный переход на новую страницу путем включения TextRulers.pageBreak в набор opts. Элемент TextRulers.noBreakInside действует на всей области видимости или на параграф. Это означает принудительный перенос начала параграфа на новую страницу, кроме случая, когда страница начинается сразу после конца параграфа.
Элемент TextRulers.parJoin подобен noBreakInside за исключением дополнительной проверки, что как минимум первая строка следующего параграфа будет на той же странице.
В момент создания линейки с помощью TextRulers.dir.New(NIL) в ней не содержится перечисленных выше атрибутов. Следующие вспомогательные процедуры обеспечивают модификации линеек:
PROCEDURE SetPageBreak (r: Ruler)
PROCEDURE SetNoBreakInside (r: Ruler)
PROCEDURE SetParJoin (r: Ruler)
На этом описание атрибутов линеек завершено. Атрибуты линеек применяются ко всем линейкам или параметрам в пределах видимости. Атрибуты символов напротив применяются только для конкретного участка текста. Текстовая модель Черного Ящика поддерживает все атрибуты текста плюс цвет и вертикальное смещение.
Линейки - отображения, которые могут быть вставлены в текст, поскольку текст является контейнером. Линейки по определению знают, что такое текстовая система, но текстовому отображению необходимо знать о параметрах параграфов, выставляемых с помощью линеек. Тем не менее, несколько других отображений, которые ничего не знают о текстовой системе, могут быть вставлены в текст. В частности интересные эффекты могут быть достигнуты, если отображения знают о тексте. Закладки (Fold views) и ссылки (link views) - примеры подобного текстоориентированного отображения.
Следующий пример показывает каким образом можно создать закладку. Закладка - стандартный элемент системы BlackBox Component Builder; она реализована в модуле StdFolds с применением только BlackBox и текстовой подсистемы. Закладки идут парами: левая закладка и правая закладка. Левая закладка содержит скрытый текст. Когда пользователь щелкает на одном из отображений закладки, текст между значками заменяется на скрытый текст. Обычно закладки применяются для подмены большого участка текста его короткой характеристикой, например, глава книги может быть спрятана, если виден только заголовок главы. Это один из способов увеличения абстракции документа путем сокрытия деталей. По этой причине одно состояние отображения закладки называется свернытым, другое называется развернутым состоянием. Нет технических причин для того, чтобы скрытый текст был короче, чем видимый; отображение наименования лишь пример наиболее типичного использования закладок.
Рисунок 5-15. Отображение закладки в свернутом и развернутом состояниях
Рисунок 5-16. Структура текстовой закладки
MODULE ObxPDBRep3;
IMPORT Views, TextModels, TextMappers, TextViews, StdFolds, ObxPhoneDB;
PROCEDUREWriteOpenFold(VARf:TextMappers.Formatter;
INshortForm:ARRAYOFCHAR);
VAR fold: StdFolds.Fold; t: TextModels.Model;
BEGIN
t := TextModels.dir.NewFromString(shortForm); (* конвертирование строки в текстовую модель *)
fold := StdFolds.dir.New(StdFolds.expanded, "", t);
f.WriteView(fold)
END WriteOpenFold;
PROCEDUREWriteCloseFold(VAR f: TextMappers.Formatter);
VAR fold: StdFolds.Fold; len: INTEGER;
BEGIN
fold := StdFolds.dir.New(StdFolds.expanded, "", NIL);
f.WriteView(fold);
fold.Flip; (* замена длинного текста, теперь между двумя отображениями закладками, с коротким текстом *)
len := f.rider.Base().Length(); (* определить, что носитель имеет новую длину *)
f.SetPos(len) (* установить позицию форматера в конец текста *)
END WriteCloseFold;
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String;
BEGIN
t := TextModels.dir.New(); (* создать пустой текстовый носитель *)
f.ConnectTo(t); (* соединить форматер с текстом *)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
WriteOpenFold(f,name$); (* записать левую закладку-отображение в текст, с ее именем в качестве короткого текста *)
(* теперь записать длинный текст *)
f.WriteString(name); (* первая строка *)
f.WriteTab; (* символ табуляции *)
f.WriteString(number); (* вторая строка *)
WriteCloseFold(f); (* записать закрывающую закладку, заменить длинный и короткий текст *)
f.WriteLn; (* возврат каретки *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* создать текстовое отображение для текста, сгенерированного выше *)
Views.OpenView(v) (* открыть отображение в своем собственном окне*)
END GenReport;
END ObxPDBRep3.
Листинг 5-17. Запись телефонной базы данных с применением закладок
Процедура WriteCloseFold обладает двумя интересными особенностями. Во-первых, закладка записывается в развернутом состоянии. На это есть причина: часто развернутая форма более сложна, чем свернутая, поэтому более удобно использовать WriteOpenFold (следует отметить, удобную процедуру TextModels.dir.NewFromString). Если свернутая форма более сложная, более удобно воспользоваться уже имеющимся форматером. После записи левой части, развернутого текста и правой части закладки, текст может быть свернут процедурой StdFolds.Flip.
Это приводит ко второму интересному моменту: свертывание текста приводит к изменению текстовой модели. Это приводит к устареванию всех курьеров, и, как результат, всех форматеров, базирующихся на тексте. Например, форматер f всегда должен находится в конце созданного текста, но когда текст свернули, его принадлежность к концу текста не соответствует действительности. По этой причине необходимо заново выставить его позицию.
Это является общим поведением при работе с переменными носителями: при любом изменении статуса носителя (вне зависимости от того, кто это сделал) необходимо обновить некоторые статусы состояний курьеров. В данном примере изменяется длина текста, что приводит к необходимости обновления позиции форматера.
В последнем примере из текущей серии будет показано как создать текст с использованием ссылочных отображений. Ссылки - стандартный элемент BlackBox Component Builder; они реализованы в модуле StdLinks только на основе базовой подсистемы и подсистемы Text. Подобно закладкам, ссылки используются парами. Их реализация применяет специальный интерфейс текстовой подсистемы (TextControllers.FilterPollCursorMsg, TextControllers.FilterTrackMsg), который заменяет стандартный указатель мыши на изображение пальца (hand cursor) при наведении его на текст между отображениями ссылки. Такое поведения известно по типичным гипертекстовым системам, подобным броузерам, когда перемещение указателя мыши по тексту символизирует гиперссылку. Прямое назначение ссылки следует из его названия. Тем не менее имеется более общее назначение, чем простая разметка. Гиперссылка содержит пассивную связь с другим документом или с другим местом этого же документа. Например, ссылка на документ может быть сохранена в виде строки: "http://www.oberon.ch" или "BlackBox/System/Rsrc/About"
В отличие от команд Component Pascal, ссылка дополнительно может иметь один или два строковых параметра. Команда выполняется после щелчка мыши пользователя при нахождении ее указателя на тексте между двумя отображениями ссылки.
Команда сохранена в левой части пары отображений ссылки. Типичная команда:
DevDebug.ShowLoadedModules
StdCmds.OpenDoc('System/Rsrc/Menus')
StdCmds.OpenAux('System/Rsrc/About', 'About BlackBox')
В нашем примере необходимо создать отображения ссылки со следующей примерной командой:
ObxPDBRep4.Log('Daffy Duck310-555-1212')
Замечание: необходимо проконсультироваться по модулю StdInterpret, так как могут иметься некоторые ограничения по поддержке возможного списка параметров или команд.
Процедура Log в приведенном примере просто записывает строку, переданную как параметр, в рабочий журнал. В более реалистичном примере параметр может применяться для набора соответствующего номера.
MODULE ObxPDBRep4;
IMPORT Views, TextModels, TextMappers, TextViews, StdLinks, StdLog, ObxPhoneDB;
CONST cmdStart = "ObxPDBRep4.Log('"; cmdEnd = "')";
PROCEDURE GenReport*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: TextViews.View;
i: INTEGER; name, number: ObxPhoneDB.String; link:StdLinks.Link;
BEGIN
t := TextModels.dir.New(); (* создать пустого текстового носителя *)
f.ConnectTo(t); (* соединить форматер с текстом*)
i := 0;
ObxPhoneDB.LookupByIndex(i, name, number);
WHILE name # "" DO
link:=StdLinks.dir.NewLink(cmdStart+name+""+number+cmdEnd);
f.WriteView(link);
f.WriteString(name); (* строка показывается между двумя ссылочными отображениями *)
link:=StdLinks.dir.NewLink("");
f.WriteView(link);
f.WriteLn; (* возврат каретки *)
INC(i);
ObxPhoneDB.LookupByIndex(i, name, number)
END;
v := TextViews.dir.New(t); (* создать текстовое отображение для текста, сгенерированного выше *)
Views.OpenView(v) (*открыть отображение в своем собственном окне *)
END GenReport;
PROCEDURELog*(param:ARRAYOFCHAR);
BEGIN
StdLog.String(param); StdLog.Ln
END Log;
END ObxPDBRep4.
Листинг 5-18. Запись телефонной БД с применением ссылок.
Следует отметить, что команды являются вызовами обычной процедуры; как и все вызовы процедур за пределами модуля, возможен только вызов процедуры объявленной как экспортируемая. Процедура Log из представленного модуля должна быть экспортирована, в противном случае программа не будет работать.
Другим интересным свойством отображений ссылки является разный способ отрисовки в зависимости от того заказал пользователь отображать или прятать метки для текстового отображения. При наличии нескольких текстовых отображений одной модели пользователь может независимо переключать отметки для отображения или для скрытия, а так же деактивировать мягкие переносы линеек или отображений ссылки. Текстовая подсистема обеспечивает интерфейс, который позволяет отображениям различать два состояния (TextSetters.Pref). В частности, отображение может принять решение для своего сокрытия, когда не отображаются метки, выставляя собственную ширину в ноль. Это то, что и делает отображение ссылки: когда текстовые отметки выключены, они невидимы, а виден только текст между ними. Обычно текст отображается подчеркнутым и синим цветом, для обозначения ссылки. Линейки, напротив, всегда занимают все пространство между левым и правым полем параграфа, но всегда выставляют свою ширину в ноль при выключенном отображении метки. О взаимодействии контейнеров и внедренных отображениях для достижения подобных эффектов будет рассказано дальше в части III этого учебника.
В приведенном выше примере показано, что отображения ссылок могут вести себя разными путями при щелчке пользователя между ними. В общем, это мощное средство, но его нужно использовать с осторожностью. Команды в документе представляют собой вид "безусловного импорта" взаимосвязей между документами и командными модулями и поэтому порождают зависимости. Это не является фундаментальным отличием от случая зависимостей между внедренным в документ отображениям, они так же функционируют правильно только при доступности задействованного компонента(ов). Подобно всем зависимостям, как в случае ссылки, внедрения кнопки на элемент управления, внедрения редактора в документ и других, их необходимо отслеживать и обновлять по мере необходимости.
5.2 Шаблон Модель-Отображение-Контроллер в применении к текстам
Следующий основной пример показывает, как можно прочитать имеющийся текст. Предполагается, что обрабатываемый текст видимый, в самом верхнем окне. По доступу к тестам, сохраненным в файле обращайтесь к встроенной документации Obx на примерах ObxOpen0, ObxOpen1 и ObxAscii. Перед началом рассказа о специфике чтения текстов необходимо рассказать каким образом можно получить доступ к содержимому самого верхнего окна с помощью команд Component Pascal.
По существу это делается вызовом Controllers.FocusView(). Функция возвращает NIL если нет открытого документа. В других случаях возвращается содержимое самого верхнего окна, то есть отображение.
Ранее было сказано, что отображения, основанные на общем типе Views.View есть центральная абстракция BlackBox для интерактивных компонентов, таких как редакторы и элементы управления. Все вращается вокруг отображений. В простых случаях, таких как элементы управления, реализация отображений представляет собой расширения Views.View и все. В более сложных случаях данные отображаются пользователю в отображениях, разделенных на несколько моделей. Это подробно обсуждалось в главе 2.
Так как реализация контейнеров является одной из самых сложных задач программирования с применением BlackBox, среда разработки обеспечивает помощь в методике построения контейнеров. Абстрактный проект контейнера приведен в модуле Containers. В модуле определены расширения типов Views.View, Models.Model и Controllers.Controller, которые представляют собой миниоболочку для построения контейнеров.
Обычный контейнер состоит как минимум из четырех модулей: один для модели, один для отображения, один для контроллеров (controller) и один для стандартных команд. Например, текстовая подсистема состоит из модулей: TextModels, TextViews, TextControllers, TextCmds и дополнительные модули: TextMappers, TextRulers и TextSetters. Подсистема форм состоит из: FormModels, FormViews, FormControllers и FormCmds.
Рисунок 5-19. Варианты декомпозиции основных контейнеров
Сейчас не рассматриваются эти типы детально; но необходимо знать, что объекты контейнеров не только разделены на модели или несколько отображений, но так же и то, что отображения разделяются в дальнейшем на отображения и так называемые контроллеры. Со временем будет уделено внимание управлению выделением и положению фокуса ввода, так как основная функциональность сосредоточена в контроллере. Поэтому сейчас заостряется внимание на контроллерах, потому что последующие примеры оперируют с текущим выделением.
Если имеется контроллер, то извлечь его отображение можно вызовом процедуры ThisView. Другие процедуры позволяют получить или выставить текущее выделение.
Может быть несколько отображений, показываемых в одной модели (отношение один-ко-многим), но всегда только один контроллер на одно отображение (отношение один-к-одному). (Именно поэтому отображения произведены от Containers.View, другие отображения могут содержать, а могут и не содержать отдельные контроллеры). Можно получить отображение для контроллера с помощью процедуры ThisView, и можно получить контроллер для отображения с помощью процедуры ThisController.
Рисунок 5-20. Строение абстракции Модель-Отображение-Контроллер. (Model-View-Controller separation)
Для более специфических абстракций контейнеров обычно предоставляется подходящая функция Focus, которая извлекает контроллер для текущего отображения, обладающего фокусом, если и когда оно имеет подходящий тип.
Теперь достаточно знаний о сценариях для контейнеров для доступа к отображениям, моделям и контроллерам, попадающим в фокус.
Примем следующие объявления:
VAR v: Views.View; m: Models.Model; c: Controllers.Controller;
Простое отображение:
v := Controllers.FocusView();
Отображение по модели:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
Расширение Containers.View:
v := Controllers.FocusView();
IF v # NIL THEN m := v.ThisModel() ELSE m := NIL END;
IF (v # NIL) & (v IS Containers.View) THEN
c := v(Containers.View).ThisController()
ELSE
c := NIL
END
Листинг 5-21. Доступ к отображению, модели и контроллеру, обладающими фокусом
Типичная абстракция контейнера, подобная текстовой подсистеме или подсистеме форм, использует указанный выше механизм для обеспечения более удобных функций доступа, основанных на особенностях типа контейнера. Например, модуль TextControllers экспортирует функцию Focus, которая возвращает фокус контроллера отображения когда и если отображение с фокусом является текстовым отображением. В других случаях возвращается NIL. Этот подход оправдан, так как если имеется контроллер контейнера, необходим легкий доступ к его отображению, модели, информации о выделении или положении фокуса ввода и т.п. Типичный шаблон кода является подмножеством нижеприведенного, в зависимости от того какая часть контролера необходима:
PROCEDURE SomeCommand*;
VAR c: TextControllers.Controller;
v: TextViews.View; t: TextModels.Model; from, to, pos: INTEGER;
...
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
...
v := c.ThisView(); (*если нужно текстовое отображение... *)
...
t := v.ThisModel(); (*или нужна текстовая модель... *)
...
IF c.HasSelection() THEN (* или нужен диапазон выделения... *)
c.GetSelection(from, to);
...
END;
...
IF c.HasCaret() THEN (* или нужна позиция знака вставки... *)
pos := c.CaretPos();
...
END;
...
ELSE (* не открывается окно документа, или фокус имеет неверный тип *)
(* не обрабатывать ошибку необходимо если эта команда охраняется подходящей командой охранника *)
END
END SomeCommand;
Листинг 5-22. Шаблон кода для TextControllers.Controller
Команда меню может использовать охранника TextCmds.FocusGuard для уверенности, что команда должна быть доступна только при наличии фокуса на текстовом отображении. TextCmds.SelectionGuard дополнительно проверяет наличие (непустого) выделения текста.
5.3 Чтение текста
Сейчас рассмотрим каким образом можно получить доступ к контроллеру отображения, имеющего фокус, напишем команду для чтения текста из отображения, имеющего фокус. Команда подсчитает количество символов из набора Latin-1 (1 байт), Unicode (над Latine-1, 2 байта) и количество внедренных отображений.
MODULE ObxCount0;
IMPORT TextModels, TextControllers, StdLog;
PROCEDURE Do*;
(** используйте TextCmds.SelectionGuard в качестве охранника для этой команды **)
VAR c: TextControllers.Controller; from, to, schars, chars, views: INTEGER;
rd: TextModels.Reader;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* взять диапазон выделения; от < до *)
rd := c.text.NewReader(NIL); (* создать нового считывателя для текстовой модели *)
rd.SetPos(from); (* установить считывателя на начало выделения *)
rd.Read; (* считать первый элемент текстового выделения *)
schars := 0; chars := 0; views := 0; (* переменные для подсчета *)
WHILE rd.Pos() # to DO (* прочесть все элементы выделения *)
IF rd.view # NIL THEN (* элемент - это отображение *)
INC(views)
ELSIF rd.char < 100X THEN (* элемент - это символ Latin-1 *)
INC(schars)
ELSE (* элемент - это символ Unicode *)
INC(chars)
END;
rd.Read (* считать следующий элемент *)
END;
StdLog.String("Latin-1 characters: "); StdLog.Int(schars); StdLog.Ln;
StdLog.String("Unicode characters: "); StdLog.Int(chars); StdLog.Ln;
StdLog.String("Views: "); StdLog.Int(views); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount0.
Листинг 5-23. Посчет числа символов Latin-1, Unicode и отображений в тексте
В приведенном выше примере используется TextModels.Reader, который является курьером для операции чтения. Каждый считыватель сохраняет свою текущую позицию в его базовом тексте; может быть несколько независимых считывателей для одного и того же текста одновременно. Считыватель текста имеет следующее определение:
TYPE
Reader = POINTER TO ABSTRACT RECORD
eot: BOOLEAN;
attr: TextModels.Attributes;
char: CHAR;
view: Views.View;
w, h: INTEGER;
(rd: Reader) Base (): TextModels.Model, NEW, ABSTRACT;
(rd: Reader) Pos (): INTEGER, NEW, ABSTRACT;
(rd: Reader) SetPos (pos: INTEGER), NEW, ABSTRACT;
(rd: Reader) Read, NEW, ABSTRACT;
(rd: Reader) ReadChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT;
(rd: Reader) ReadPrev, NEW, ABSTRACT;
(rd: Reader) ReadPrevChar (OUT ch: CHAR), NEW, ABSTRACT;
(rd: Reader) ReadPrevView (OUT v: Views.View), NEW, ABSTRACT;
(rd: Reader) ReadPrevRun (OUT attr: TextModels.Attributes), NEW, ABSTRACT
END;
Листинг 5-24. Определение TextModels.Reader
Для данной текстовой модели text может быть создан считыватель вызовом rd := text.NewReader(NIL). Вновь размещенный считыватель позиционируется на начало текста, то есть на позицию rd.Pos() = 0. Позиция может быть изменена при необходимости с помощью вызова rd.SetPos(pos), где pos находится в диапазоне 0..text.Length(). Текстовая модель для считывателя может быть получена вызовом процедуры Base.
Чтение следующего элемента текста осуществляется процедурой считывателя Read, которая увеличивает текущую позицию считывателя, пока не достигнут конец текста. В этом случае устанавливается поле считывателя eot. После вызова Read прочитанный символ доступен из поля char. Если значение символа меньше, чем 100X, символ попадает в диапазон Latin-1 (1-байтовый символ), в противном случае это - 2-байтовый символ Unicode. Для удобства поддерживается вспомогательная процедура ReаdChar, которая выполняет Read и возвращает содержимое char.
Что случится, если будет прочитано отображение? В большинстве случаев поле char выставится в зарезервированное значение TextModels.viewcode (2X). Тем не менее, в этом нет необходимости. Текстоориентированные отображения могут предоставлять несколько кодов символов с применением специального сообщения предпочтений (TextModels.Pref). При необходимости определить факт прочтения отображения, необходимо проверить поле view. Оно возвращает только что прочитанное отображение или NIL, если прочитано не отображение.
Предсказуемо наличие реализации для текстовой модели оптимизированного доступа к отображениям. Для этой цели служит процедура ReadView, которая читает следующее отображение после текущей позиции, при необходимости пропуская все элементы, не являющиеся отображениями.
После прочтения элемента (символа или отображения) его текстовые атрибуты возвращаются в поле читателя attr. Текстовые атрибуты состоят из атрибутов шрифта, цвета и вертикального смещения и описаны выше. По соображениям эффективности и удобства поддерживается вспомогательная процедура ReadRun, которая перемещает позицию считывателя до смены атрибутов в сравнении с текущей позицией. Фрагмент текста, имеющий одинаковые атрибуты может быть отрисован на экране одной процедурой (Port.Frame.DrawString), что значительно быстрее отображения символов одного за другим. Обычно текст читается вперед от меньшей позиции к большей. Процедуры считывателя ReadPrev, ReadPrevView и ReadPrevRun симметричны своим аналогам Read, ReadView и ReadRun, но чтение осуществляется в обратном порядке (назад). В частности, ReadPrevView применяется для текстовых отображений, так же называемых установщиками текста для поиска наиболее близкого отображения линейки, чтобы определить какие параметры текста необходимо выставить (этот поиск осуществляется во вспомогательной процедуре TextRulers.GetValidRuler).
При вызове одной из процедур чтения (вне зависимости от того читают ли они вперед или назад), устанавливается значение поля считывателя eot. Если элемент может быть прочтен, eot выставляется в FALSE. Если ни один из элементов не может быть прочтен (чтение за концом или началом файла) eot выставляется в TRUE.
Обычно применяется следующий шаблон при работе с текстовыми считывателями. Условие может быть чем-то вроде rd.Pos() # end или ~rd.eot.
VAR rd: TextModels.Reader; start: INTEGER;
BEGIN
... define start ...
rd := text.NewReader(NIL);
rd.SetPos(start); (* необходимо только если старт # 0 *)
rd.Read;
WHILE condition DO
... олределить текстовй элемент обозначенный при помощи rd ...
rd.Read
END;
Листинг 5-25. Шаблон кода для TextModels.Reader
Следующий пример использует сканер текста. Сканеры читают текстовые отображатели; как и форматеры они определены в модуле TextMappers. Текстовые сканеры подобны текстовым считывателям за исключением того, что они работают с образом целиком, в отличие от (текстовых) символов. Строки и числа являются примерами символов Component Pascal, которые поддерживаются текстовыми сканерами.
Если сравнить определение TextMappers.Scanner с определением TextModels.Reader, можно заменить, что сканер так же может вернуть символ (поле char) и отображение вместе с размерами (поля view, w и h), что сканер обладает позицией (Pos, SetPos), но сканер не может читать назад. Scan соответствует процедуре считывателя Read. Она пропускает пустые места (пробелы, возврат каретки), пока не будет достигнут конец текста, что указывается выставлением поля type в TextMappers.eot или пока не будет прочитан символ. Тип прочитанного символа (образа) возвращается в type. Он может быть одним из констант модуля TextMappers:
char, string, int, real, bool, set, view, tab, line, para, eot, invalid.
По умолчанию отображения и управляющие символы распознаются как пустое пространство, поэтому игнорируются. Применение дополнительного набора (opts, SetOpts) позволяет распознавать их как действующие символы. Элемент набора TextMappers.returnViews указывает, что отображения распознаются, TextMappers.returnCtrlChars указывают, что три управляющих символа: табуляция, возврат каретки и параграф так же распознаются. Если символ начинается как строка Component Pascal или идентификатор, сканер пытается прочитать строку. В случае успеха type выставляется в string; которая так же может быть и короткой строкой, то есть содержать только символы Latin-1. Опция TextMappers.returnQualIdents позволяет сканеру различать целиком определенные идентификаторы как один символ, то есть строку ThisMod.ThatObj. Длина строки возвращается в len.
Если возможно преобразовать символ в целое или дробное число, type выставляется в соответствующий тип, а так же выставляется поле int или real. Целые числа распознаются в различных системах исчисления, распознанная система исчисления возвращается в base (10 для десятичных чисел)
Специальные символы !@#$ распознаются как тип TextMappers.char, которые могут быть так же короткими символами, то есть символами Latin-1.
По умолчанию логические значения и множества не интерпретируются за исключением случая, когда выставлены параметры TextMappers.interpretBool или TextMappers.interpretSets. Для множеств применяется обычный синтаксис Component Pascal, логические значения представлены как $TRUE и $FALSE.
Поле сканера start содержит позицию первого символа, который будет сейчас считан. Поля lines и paras содержат количество символов возврата каретки и параграфа с последнего обращения к процедуре SetPos (см. ниже). Процедура сканера Skip является вспомогательной процедурой для достижений сканером первого непустого символа (как указано в множестве opts) и чтения его. Этот символ возвращается в параметре ch в процедуре Skip's.
Так как может быть несколько специализированных текстовых отображателей, в дополнение к ним поддерживается TextMappers, текстовая модель не может создать объект текстового отображателя, подобно тому как она создает текстовые считыватели и записыватели. Вместо этого сканеры (так же как и форматтеры) в явном виде соединяются с текстом путем вызова процедуры ConnectTo. Она может быть вызвана повторно для соединения того же сканера с другой моделью.
Scanner = RECORD
rider-: TextModels.Reader;
opts-: SET;
type: INTEGER;
start, lines, paras: INTEGER;
char: CHAR;
int, base: INTEGER;
real: REAL;
bool: BOOLEAN;
set: SET;
len: INTEGER;
string: TextMappers.String;
view: Views.View;
w, h: INTEGER;
(VAR s: Scanner) ConnectTo (text: TextModels.Model), NEW;
(VAR s: Scanner) Pos (): INTEGER, NEW;
(VAR s: Scanner) SetPos (pos: INTEGER), NEW;
(VAR s: Scanner) SetOpts (opts: SET), NEW;
(VAR s: Scanner) Scan, NEW;
(VAR s: Scanner) Skip (OUT ch: CHAR), NEW
END;
Листинг 5-26. Определение TextModels.Scanner
В следующем примере применяется текстовый сканер для подсчета числа целых, дробный чисел и строк, найденных в тексте.
MODULE ObxCount1;
IMPORT TextModels, TextMappers, TextControllers, StdLog;
PROCEDURE Do*;
(** use TextCmds.SelectionGuard as guard for this command **)
VAR c: TextControllers.Controller; from, to, ints, reals, strings: INTEGER;
s: TextMappers.Scanner;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to); (* получить диапазон выделения; от < до *)
s.ConnectTo(c.text); (* соединить сканер с этой текстовой моделью *)
s.SetPos(from); (* установить считывателя на начало *)
s.Scan; (* прочитать первый символ *)
ints := 0; reals := 0; strings := 0; (* переменные для подсчета *)
WHILE s.Pos() < to DO (* прочесть все символы с начала выделения *)
IF s.type = TextMappers.int THEN (* символ - это целое число *)
INC(ints)
ELSIF s.type = TextMappers.real THEN (* символ - это вещественное число *)
INC(reals)
ELSIF s.type = TextMappers.string THEN (* символ - это строка/идентификатор *)
INC(strings)
END;
s.Scan (* прочитать следующий символ выделения *)
END;
StdLog.String("Integers: "); StdLog.Int(ints); StdLog.Ln;
StdLog.String("Reals: "); StdLog.Int(reals); StdLog.Ln;
StdLog.String("Strings: "); StdLog.Int(strings); StdLog.Ln;
StdLog.Ln
END
END Do;
END ObxCount1.
Листинг 5-27. Подсчет целочисленных, дробных чисел и строк в тексте
Наиболее типичный шаблон кода для применения сканера выглядит подобно шаблону для считывателя. Условие может содержать что-то вроде: s.pos() < end или s.type # TextMappers.eot.
VAR s: TextMappers.Scanner; start: INTEGER;
BEGIN
... define start ...
s.ConnectTo(text);
s.SetPos(start); (* необходимо, только если start # 0 *)
s.Scan;
WHILE condition DO
IF s.type = TextMappers.int THEN
... consume s.int ...
ELSIF s.type = TextMappers.real THEN
... consume s.real ...
ELSIF ...
...
END;
s.Scan
END;
Листинг 5-28. Шаблон кода для TextMappers.Scanner
5.4 Изменение текста
В предыдущих разделах было рассмотрено как создать новый текст с помощью записывателей или форматеров и как существующий текст может быть прочитан с помощью считывателей или сканеров. Многие текстовые команды сперва читают участок текста, проводят над ним какие-то вычисления, затем заменяют его на результат вычисления. Примерами могут служить команды по установке шрифта, цвета, переключения регистра для выделенного участка. Следующий пример команды читает текст выделения и проверяет на наличие строк. Найденные строки интерпретируются как имена и по этим именам осуществляется поиск в телефонной базе данных из нашего примера. Затем имя заменяется на его телефонный номер.
MODULE ObxLookup0;
IMPORT TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** используйте TextCmds.SelectionGuard в качестве охранника команды **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* сканер уже считал символ до строки! *)
c.text.Delete(from, to); (*удалить имя*)
c.text.Insert(from, buf, 0, buf.Length()); (* переместить телефонный номер из буфера в текст *)
c.SetSelection(from, from + LEN(number$)) (* выбрать телефонный номер*)
END
END
END Do;
END ObxLookup0.
Листинг 5-29. Замена имени на телефонный номер
Основная идея вышеприведенной команды состоит в том, что вспомогательный текстовый объект используется как буфер для операции. Выделенный текстовый фрагмент сканируется, отсканированная строка используется как ключ для поиска в базе данных телефона и возвращается телефонный номер в виде записи в текстовом буфере, затем первоначальное имя удаляется из текста, затем содержимое буфера помещается на место удаленного имени. В качестве заключительного шага вновь вставленный текст помечается как выделенный. Следует отметить, что процедура текстовой модели Delete укорачивает текст, в то время как процедура Insert удлиняет его. В частности, Insert не перезаписывает имеющийся текст. Insert перемещает текст, то есть удаляет его из источника и вставляет его в назначение.
Один из способов сделать упомянутую выше команду удобней заключается в замене выделения на введение символа с клавиатуры. Затем можно написать имя и нажать клавиатурное сокращение для команды. Команда прочитает текст назад от позиции курсора ввода до начала имени и заменит его на подходящий для этого имени номер телефона. Подобный способ является простым способом реализации клавиатурных макросов.
Перемещение участков текста из одной текстовой модели в другую текстовую модель может быть оптимизировано в случае, если обе текстовые модели имеют одну реализацию. В этом нет необходимости, так как различные реализации типа TextModels.Models могут взаимно существовать в одно время. Два вызова TextModels.dir.New() могут вернуть две правильные текстовые модели, имеющие различные реализации.
По этой причине в модуле TextModels экспортируется процедура Clone, которая возвращает пустую текстовую модель с типом, в точности соответствующим типу ее параметра. Фактически стандартная реализация текста даже реализует некоторые дополнительные возможности оптимизации при создании текстовой модели с помощью "клонирования", чем при размещении посредством TextModels.dir.New().
Ниже приводится слегка упрощенное определение TextModels.Model:
TYPE
Model = POINTER TO ABSTRACT RECORD (Containers.Model)
(m: Model) NewWriter (old: TextModels.Writer): TextModels.Writer, NEW, ABSTRACT;
(m: Model) NewReader (old: TextModels.Reader): TextModels.Reader, NEW, ABSTRACT;
(m: Model) Length (): INTEGER, NEW, ABSTRACT;
(m: Model) Insert (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) InsertCopy (pos: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) Delete (beg, end: INTEGER), NEW, ABSTRACT;
(m: Model) Append (m0: TextModels.Model), NEW, ABSTRACT;
(m: Model) Replace (beg, end: INTEGER; m0: TextModels.Model;
beg0, end0: INTEGER), NEW, ABSTRACT;
(m: Model) SetAttr (beg, end: INTEGER; attr: TextModels.Attributes), NEW, ABSTRACT;
END;
Листинг 5-30. Определение TextModels.Model
Практически все процедуры уже были упомянуты. InsertCopy подобна Insert, но вместо перемещения копирует участок текста без изменения источника. Delete удаляет фрагмент текста.
Insert, InsertCopy и Delete являются элементарными текстовыми операциями. Append и Replace поддерживается для удобства и эффективности: они могут быть выражены в терминах элементарных операций.
dst.Append(src) dst.Insert(dst.Length(), src, 0, src.Length())
То есть она перемещает все содержимое текста-источника в конец текста-назначения, таким образом оставляя текст источник пустым.
t.Replace(b, e, t1, b1, e1) t.Delete(b, e); t.Insert(b, t1, b1, e1)
То есть она перезаписывает часть текста-назначения на некоторую часть текста-источника (который таким образом удаляется). Необходимо отметить, что тексты источника и назначения должны быть разными.
SetAttr позволяет выставить текстовые атрибуты для всего участка текста.
5.5 Текстовые сценарии
После успешного применения команды ObxLookup0.Do для участка текста можно попробовать нечто удивительное: можно отменить команду ("undo"), выполнив команду меню Edit->Undo! С помощью Edit->Redo можно отменить отмену операции.
Эта возможность удивительна, так как была реализована только простая процедура Do, но не код для ее отмены или повторного применения. Как случилось, что среда разработки все равно смогла отменить/повторить операцию?
Это возможно, потому что процедуры текстовой модели, которые изменяют статус модели, такие как Model.Delete и Model.Insert реализованы особым образом. Они не выполняют изменения напрямую. Вместо этого они создают специальный объект операции и регистрируют его в оболочке. Оболочка может вызвать соответствующую процедуру для операции для реализации фактической функциональности выполнения/отмены/повторения. Этот механизм был описан в главе 3.
Следующий пример показывает последовательность процедур, модифицирующих текст, заключенную в скобки BeginScript и EndScript для того, чтобы сделать последовательность целиком откатываемой. BeginScript возвращает объект сценария (script), он задает имя для всей составной операции как ввод.
MODULE ObxLookup1;
IMPORT Stores, Models, TextModels, TextMappers, TextControllers, ObxPhoneDB;
PROCEDURE Do*;
(** используйте TextCmds.SelectionGuard в качестве охранника команды **)
VAR c: TextControllers.Controller; buf: TextModels.Model; from, to: INTEGER;
s: TextMappers.Scanner; f: TextMappers.Formatter; number: ObxPhoneDB.String;
script:Stores.Operation;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(from, to);
s.ConnectTo(c.text);
s.SetPos(from);
s.Scan;
IF s.type = TextMappers.string THEN
buf := TextModels.CloneOf(c.text);
f.ConnectTo(buf);
ObxPhoneDB.LookupByName(s.string$, number);
f.WriteString(number);
from := s.start; to := s.Pos() - 1; (* сканер уже прочел символ до строки! *)
Models.BeginScript(c.text,"#Obx:Lookup",script);
c.text.Delete(from, to); (* удалить имя *)
c.text.Insert(from, buf, 0, buf.Length()); (* переместить телефонный номер из буфера в текст *)
Models.EndScript(c.text,script);
c.SetSelection(from, from + LEN(number$)) (* выбрать телефонный номер *)
END
END
END Do;
END ObxLookup1.
Листинг 5-31. Пример сценария (составной операции)
В Models.BeginScript задается имя составной операции. Оно отображается с помощью возможностей отображения строк BlackBox с целью отображения этого имени для пользователя (в команде меню undo/redo).
В моделях ObxLookup0 и ObxLookup1 применяются следующие последовательности операторов для замены имени на номер:
c.text.Delete(from, to);
c.text.Insert(from, buf, 0, buf.Length());
Объединение этих двух операторов в одну составную операцию (как ожидает пользователь) приводит к необходимости заключения этих двух вызовов в операторные скобки BeginScript/EndScript. В данном специальном случае будет лучше, если применить:
c.text.Replace(from, to, buf, 0, buf.Length());
TextModels.Model.Replace является мощной процедурой, которая представляет собой частный случай операций Insert, Delete и Append (поддерживаются для удобства):
t.Delete(beg, end) = t.Replace(beg, end, t, 0, 0)
t.Insert(pos, t0, beg, end) = t.Replace(pos, pos, t0, beg, end)
t.Append(t0) = t.Replace(t.Length(), t.Length(), t0, 0, t0.Length())
Следует отметить, что InsertCopy не может быть выражено в терминах Replace:
t.InsertCopy(pos, t0, beg, end) # t.Replace(pos, pos, t0, beg, end)
По этой причине Replace, подобно Insert удаляет текст источника. С другой стороны, InsertCopy является операцией чистого копирования без модификации текста источника (кроме случаев, когда текст-источник и текст-назначения идентичны и позиция текста-назначения лежит в диапазоне текста-источника)
5.6 Резюме
На этом обсуждение текстовой подсистемы BlackBox Component Builder заканчивается. Основной целью этого учебника является обзор связанного комплекса расширений подсистем, использование шаблонов проектирования из предыдущей главы, показ типичных примеров кода текстовой подсистемы.
Познание текстовой подсистемы не может быть завершено, поскольку остается много деталей, относящихся к документации разных моделей. Тем не менее, главная цель и типичные способы применения должны быть ясны. Так как в начале было изложено немного теории и применялись только простые примеры, базовая структура подсистемы составных контейнеров должна быть ясна уже сейчас.
Перед тем как дать список примеров из встроенной помощи, которые следует изучить, приведем список всех стандартных модулей текстовой подсистемы (самый нижний модуль, иерархически, самый первый) с указанием важных типов, экспортируемых из них:
module / type description
TextModels - абстрактная и реализация по умолчанию для текстовых моделей
Attributes - атрибуты текстовых элементов (шрифт, цвет, вертикальное смещение)
Context - связь между текстовой моделью и внедренным отображением
Directory - фабрика текстовых моделей
Model - текстовый пользователь, фабрика для считывателей и записывателей
Reader - курьер для элементоориентированного чтения текста
Writer - курьер для элементоориентированной записи текста
TextMapper - абстрактная и реальная реализация текстовых мапперов для символов Component
Pascal
Formatter - отогбражатель для символьноориентированной записи текста
Scanner - отображатель для символьноориентированного чтения текста
TextRulers - абстрактная и реализация по умолчанию для отображения линеек, которые задают
атрибуты параграфа
Attributes - атрибуты текстовых линеек (табуляция, отступы, сетка и т.п.)
Directory - фабрика для текстовых линеек
Ruler - отображения для линеек
Style - модели линеек
TextSetters - абстрактная и реализация по умолчанию для текстовых установщиков,
обеспечивающих разрыв строки/страницы
Directory - для текстовых установщиков
Reader - текстовый отображатель, разделяющий текст по своим полям по текстовым установкам
и определение их размера
Setter - объект, реализующих алгоритм установки текстовых параметров
TextViews - абстрактная и реализация по умолчанию для текстовых отображений
Directory - фабрика текстовых отображений
View - отображение текстовых моделей
TextControllers - абстрактная и реализация по умолчанию для текстовых контроллеров
Controller - контроллер для текстового отображения
Directory - фабрика текстовых контроллеров
TextCmds - командный пакет для наиболее важных текстовых команд
Таблица 5-32. - таблица модулей и наиболее важных типов для текстовых подсистем
ObxHello0 - пишет "Hello World" в рабочий журнал
ObxHello1 - пишет "Hello World" в новый текст
ObxOpen0 - открывает текстовый документ из файла с применением стандартного диалога открытия
файла
ObxOpen1 - Изменение текстового документа в файле с применением стандартных диалогов открытия
и сохранения файлов
ObxCaps - приводит строку к верхнему регистру с применением составных операций
ObxDbd - управление отсортированным списком записей
ObxMMerge - слияние для почты шаблона и базы данных
ObxLinks - создает текст с гиперссылками
ObxAscii - обычный текстовый файл
Таблица 5-33. Дополнительные встроенные примеры по текстовой подсистеме
| Docu/ru/Tut-5.odc |
Часть III: Конструирование отображений
ENGLISH
В части I учебника по BlackBox дается введение в схемы проектирования, применяемые в BlackBox. Знание этих схем облегчает понимание и запоминание частных решений в различных модулях BlackBox.
Часть II учебника по BlackBox демонстрирует применение наиболее важных библиотек компонентов: элементы управления, формы, текстовые компоненты.
Часть III учебника по BlackBox демонстрирует разработку новых отображений на серии усложняющихся примеров от самых простых к более сложным.
6 Конструирование отображений
Отображения являются центральной абстракцией BlackBox Component Builder. Всё вращается вокруг них: большинство команд выполняются над отображениями, окна показывают отображения, отображения могут быть загружены и выгружены, с помощью отображений проводится взаимодействие с пользователем и отображения могут быть внедрены в другие отображения.
6.1 Введение
Учебник программирования отображений состоит из четырех разделов, каждый из которых представляет особый аспект программирования отображений. В разделе "обработка сообщений" ("message handling") (главы с 6.2 по 6.5) разъясняется поведение отображений, определенное для обработки сообщений отображений, то есть какие могут быть ответы, сообщения элементов управления и свойства потока взаимодействия отображений с окружающей средой и как отображения реагируют на пользовательский ввод. Во втором разделе (6.7) объясняются аспекты разделения моделей и отображений, которые разрешают многооконное редактирование отображений. В следующем разделе (6.7) показывается, как могут быть использованы объекты операций для возможностей отката/повтора BlackBox Component Framework при изменении содержимого отображения. В последнем разделе (6.8) объясняется особая структура всех расширяемых модулей BlackBox Component Framework, а именно разделение интерфейса и реализации отображений. Фабричный объект (directory object) является ключевой схемой проектирования.
6.2 Обработка сообщений
В этом разделе представлена последовательность реализаций отображения, со все более возрастающими возможностями, которое показывает прямоугольную закрашенную область. В частности, отображение обрабатывает Preferences, Controller messages и Properties.
Каждое отображение является подтипом абстрактного типа Views.View. Конкретное расширение должно как минимум реализовывать абстрактную процедуру Views.Restore, которая отрисовывает содержимое отображения. Первый пример нашего отображения просто рисует красные прямоугольник. Эта версия представляет собой простейшую из возможных реализацию отображения. Главными компонентами являются определение расширения от Views.View, реализация процедуры Views.Restore, которая отрисовывает содержимое отображения и управляющая процедура для размещения и инициализации отображения:
MODULE ObxViews0;
IMPORT Views, Ports;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews0.
Для выполнения этой программы запустите следующую команду:
"ObxViews0.Deposit; StdCmds.Open"
Результат этой команды представлен на рисунке 6-1.
Рисунок 6-1. Результат "ObxViews0.Deposit; StdCmds.Open"
Эта простая программа уже полностью функциональна. Процедура ObxViews0.Deposit заносит вновь размещенное отображение в системную очередь. Команда StdCmds.Open, приведенная выше в командной строке, извлекает отображение из очереди и открывает его в новом окне. Следует отметить, что последовательность команд должна быть заключена в кавычки, в то время как для одиночной команды кавычки можно опустить.
Вместо того, чтобы открыть отображение в окне, его можно поместить в контейнер, обладающий фокусом ввода (то есть в текст или форму):
"ObxViews0.Deposit; StdCmds.PasteView" ><перед выполнением команды поместите курсор сюда
Как и StdCmds.Open, команда StdCmds.PasteView извлекает отображение из очереди, но вставляет его в отображение, обладающее фокусом ввода. Вышеприведенная последовательность команд может быть использована, например, в меню.
Каждый документ, содержащий отображение ObxViews0 может быть сохранен в файл, который затем может быть открыт вновь с помощью стандартной команды меню Open... Простой красный прямоугольник должен быть отображен правильно во вновь открытом документе, что обеспечивается доступностью файла кода модуля ObxViews0.
Отображение, которое было открыто в собственном окне, так же могло быть сохранено в файле. При повторном открытии документ состоит только из этого единственного отображения.
Каждое отображение осуществляет операции вывода и обработки мыши/клавиатуры через объект Views.Frame. В приведенном выше примере ObxViews0.View.Restore использует собственную рамку как параметр f для отрисовки строки. Рамка может считаться объектом отображателя, в данном случае как ввода, так и вывода одновременно (здесь будет интересно уточнить о курьерах и носителях для этого отображателя, но оба они определены в модуле Ports). Рамка реализует в себе преобразование координат и возможности обрезки.
В случае, если отображение отрисовывается на экране, рамка является отображателем для порта экрана. Если отображение распечатывается, рамка является отображателем для порта принтера. С точки зрения отображения эта разница не существенна. Так, не требуется специального кода в случае необходимости поддержки печати.
Отображения могут быть скопированы и вставлены в контейнеры, такие как текстовые отображения или отображения в виде форм. Дополнительно может быть изменен размер отображения, если его выбрать и изменить размер. Вся эта функциональность поддерживается каркасом (BlackBox Component Framework) и не требует дополнительного кодирования. Если поведение по умолчанию неудобно, его можно изменить. В дальнейшем будет показано, как это сделать.
6.3 Сообщения свойств по умолчанию
Следует отметить, что размер вновь открытого отображения может быть различным. Тем не менее, перед открытием отображения оболочка посылает отображению сообщение с предполагаемыми размерами. Отображение может приспособить предлагаемые размеры для собственных нужд. Для этого сообщение типа Properties.SizePrep должно быть обработано в процедуре отображения HandlePropMsg. Перед первой отрисовкой отображения предполагаемые размер для ширины и высоты отображения задан в Views.undefined. В следующей версии примера отображения рисунок отрисовывается с шириной 2 и высотой 1 см. Внесенные в сравнении с предыдущей версией изменения отмечены жирным шрифтом.
MODULE ObxViews1;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
END
ELSE (* игнорировать другие сообщения *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews1.
"ObxViews1.Deposit; StdCmds.Open"
Теперь каждое вновь созданное отображение принимает желаемые предопределенные по умолчанию размеры. Это возможно, потому что отображение и контейнер взаимодействуют, в данном случае, посредством сообщения Properties.SizePref. Предполагается, что контейнер посылает это сообщение каждый раз, когда он хочет изменить размеры отображения, а затем принимает возвращенные данные. Тем не менее, для понимания каркаса BlackBox необходимо знать, что контейнер с правильным поведением (well-begaved) должен следовать этому протоколу, но данное следование не обязательно. Именно поэтому подобное сообщение называется "предпочтением". Оно описывает лишь пожелания отображения, но охватывающий контейнер может навязать следование специальным правилам для отображения. Контейнер всегда имеет право последнего слова в подобных переговорах. Например, контейнер не может позволить отображению быть больше собственных размеров. Стандартные контейнеры: документ, текст и формы - являются контейнерами с правильным поведением и поддерживают все предпочтения, определенные в модуле Properties. Специализированные контейнеры, такие как тексты, могут определить дополнительные предпочтения, специфические для типа содержимого. Как важный момент следует отметить, что отображения могут игнорировать все предпочтения, которые они не знают или о которых не беспокоятся.
Properties.SizePref позволяет ограничить возможные размеры по ширине и высоте отображения. Например, можно задать принудительно минимальный и максимальный размер или зафиксировать высоту и ширину отображения или определить ограничения на их ширину и высоту. Процедуры Properties.ProportionalConstraint и Properties.GridConstraint являются полезным стандартом реализации ограничений. Следующая версия реализации отображения определяет, что прямоугольник всегда имеет ширину в два раза больше его высоты. Дополнительно определяются минимальные и максимальные размеры для высоты (тем самым, и для ширины). Если размер отображения изменяется с помощью обработчика изменения размеров, ограничения не нарушаются. Это можно проверить.
MODULE ObxViews2;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
ELSE (* игнорировать другие сообщения *)
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews2.
"ObxViews2.Deposit; StdCmds.Open"
В этом учебнике рассматривается еще два других предпочтения. Первое - Properties.ResizePref.
TYPE
ResizePref = RECORD (Properties.Preference)
fixed,
horFitToPage, verFitToPage,
horFitToWin, verFitToWin: BOOLEAN (* OUT *)
END;
Получатель этого сообщения может показать, что он не желает изменять размеры, выставив fixed в TRUE. Как следствие отображение не показывает метки для изменения размера при выделении, поэтому не может изменять размеры интерактивно. Тем не менее, сообщение Properties.SizePref все еще посылается отображению и начальный размер все еще необходимо определить.
Если отображение является корневым, то есть самое дальнее от центра отображение в документе или окне (то есть открытое с помощью StdCmds.Open), размер окна, размер отображения или оба сразу могут быть изменены.
Тем не менее, иногда бывает удобно автоматически приводить размер отображения к изменению размера окна, то есть помочь текстам занимать как можно больше места на экране. Для других отображений было бы предпочтительней, если их размер определялся бы не окном, а содержимым или настройками страницы внедренного документа. Отображение может использовать эти возможности выставив значения horFitToWin, verFitToWin, horFitToPage и verFitToPage для сообщения Properties.SizePref. Эти значения не имеют силы, если отображение не является корневым, то есть является внедренным в документ.
Автоматическое приведение размеров отображения по текущему размеру окна может быть достигнуто путем выставления полей horFitToWin и verFitToWin. Размер отображения ограничен окном, то есть пользователь может изменить размер напрямую, изменяя размеры окна.
Следует отметить, что если размеры отображения ограничены размерами окна (а так же путем выставления hotFitToWin или verFitToWin), то сообщение Properties.SizePref для отображения не посылается, то есть ограничения, заданные в Properties.SizePref, больше не применяются. Дополнительно для отображения не показываются метки изменения размеров, вне зависимости от состяния fixed.
При установке полей horFitToPage или verFitToPage ширина или высота отображения может быть ограничена фактическим размером бумаги в принтере. Ширина текстового отображения обычно ограничена шириной листа бумаги и может быть изменена путем изменения установок размеров бумаги, которое поддерживается средствами операционной системы. Следующий пример принудительно выставляет размер корневого отображения по размерам окна:
MODULE ObxViews3;
IMPORT Views, Ports, Properties;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews3.
"ObxViews3.Deposit; StdCmds.Open"
Теперь рассмотрим Properties.FocusPref.
TYPE
FocusPref = RECORD (Properties.Preference)
atLocation: BOOLEAN; (* IN *)
x, y: INTEGER; (* IN *)
hotFocus, setFocus, selectOnFocus: BOOLEAN (* OUT *)
END;
При попытке активации внедренного отображения по щелчку на нем, отображению посылается сообщение Properties.FocusPref. Если на сообщение не было ответа, отображение выделяется целиком (так же называется singleton). Это поведение для отображения, реализованное в вышеприведенном примере. В подтверждение, разместите курсор на следующей строке и щелкните на коммандере, затем на вставленном отображении:
"ObxViews3.Deposit; StdCmds.PasteView" >< перед выполнением команды установите курсор здесь
Такое поведение применено для пассивоного отображения. Тем не менее, если содержимое отображение можно редактировать или имеются команды меню, выполняющие действия над отображением, пользователь должен иметь возможность получить фокус ввода на отображение. Фокус ввода - это место, куда осуществляется ввод данных с клавиатуры, где показывается текущее выделение и положение курсора (или какая-то другая подобная метка) и где выполняются некоторые команды меню. Фактически меню доступны, только в случае обладания отображением фокуса ввода, и меню становятся недоступными, когда отображение теряет фокус ввода (ниже об этом будет сказано подробнее). Корневое отображение всегда имеет фокус ввода, если фокус ввода имеет окно документа (то есть верхнее окно).
В случае, если внедренное отображение может получать фокус ввода, то оно должно отвечать на сообщение Properties.FocusPref. Отображение может определить, захватывается ли фокус ввода или фокус переводится только на время, в течение которого нажата кнопка мыши. Последняя ситуация называется "горячий фокус" (hot focus). Типичный пример горячего фокуса - кнопка. Для того, чтобы отображение приобрело свойство горячего фокуса, необходимо выставить флаг hotFocus. В этом случае фокус ввода переводится дальше сразу после отпускания кнопки мыши. Когда требуется захватить фокус ввода, необходимо выставить флаг setFocus. setFocus следует выставлять для всех редакторов, чтобы контекстнозависимые команды меню могли применяться к отображению. В дополнение к флагу setFocus для отображения может быть выставлен флаг selectOnFocus для того, чтобы при наведении с помощью клавиатуры содержимое отображения выделялось. Текстовые поля ввода являются первым примером подобного поведения: содержимое элемента, только что получившего фокус - выделено, если пользователь попал не него не с помощью мыши, а с применением клавиатуры.
Если пользователь щелкнет на отображении без фокуса ввода, то каркас выставляет флаг alLocation перед посылкой сообщения. Отображение-получатель может решить, каким образом сфокусироваться в зависимости от того, где щелкнул пользователь. Позиция мыши передается отображению в полях x и y предпочтения фокуса (focus preference). Текстовые линейки - примеры отображения которые фокусируются в зависимости от положения мыши. Если кликаются иконки в области ниже шкалы линейки, то линейка не получает фокус. В противном случае - получает. Это можно попробовать прямо сейчас на линейке. Показать/скрыть линейки можно с помощью команды меню Text->ShowMarks.
Отображение получают фокус не только после щелчка мыши. Например отображения могут быть выбраны с помощью клавиш управления курсора. В случае, если отображение фокусируется без участия мыши, каркас выставляет поле atLocation в FALSE.
В следующей версии примера будет обработано сообщение FocusPref и выставлен флаг setFocus. Это достигается добавлением в процедуру HandlePropMsg предыдущего примера следующего кода:
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
Если внедренное отображение получает фокус, отрисовывается рамка отображения с соответствующими отметками, активируются специфические для отображения пункты меню, а остальные - дезактивируются.
6.4 Управляющие сообщения
Другие сообщения, которые могут быть обработаны процедурой HandlerPropMsg будут рассмотрены позже. Дальше будет рассмотрено, как отображения реагируют на пользовательский ввод, то есть на щелчки мыши в отображении или команды, вызываемые из меню. Для простых отображений такое поведение реализуется процедурой Views.HandleCtrlMsg. Так же возможно определить отдельный объект, называемый контроллером, которые реализует поведение отображения при взаимодействии с пользователем. Программирование объектов контроллера здесь не рассматривается, так как применение контроллеров - только рекомендация для большинства сложных отображений.
Обработчки Views.HandleCtrlMsg отвечает на управляющие сообщения (controller messages), посылаемые к отображению. Каждое отображение в цепочки обработки фокуса самостоятельно решает завершить ли обработку сообщения, то есть обладает ли оно фокусом, или передать сообщение к другому внедренному отображению. Важно отметить, что все сообщения контроллеров, которые не подходят к типу отображения, игнорируются.
Для того, чтобы было возможно выполнять редактирование в отображении, обладающем фокусом ввода, каркас должен каким-то образом разрешить эти операции. Щелчки мыши и нажатия клавиш могут быть всегда. Тем не менее, внешний вид меню зависит от решения, принятого непосредственно отображением. Для этой цели отображению посылается сообщение Controllers.PollOpsMsg. В зависимости от текущего статуса (например, текущего выделения) и содержимого буфера обмена, отображение, обладающее фокусом ввода, может информировать каркас о том, какие операции редактирования сейчас возможны. Доступные операции содержатся в множестве элементов: {Controllers.cut, Controllers.copy, Controllers.paste, Controllers.pasteView}.
TYPE
PollOpsMsg = RECORD (Controllers.Message)
type: Stores.TypeName; (* OUT *)
pasteType: Stores.TypeName; (* IN *)
singleton: Views.View; (* OUT *)
selectable: BOOLEAN; (* OUT *)
valid: SET (* OUT *)
END;
Множество доступных операций редактирования возвращается в поле valid, где valid среди {Controllers.cut, Controllers.copy, Controllers.paste}. В зависимости от набора доступных операций становятся доступными или недоступными соответствующие пункты меню Edit, то есть Cut, Copy, Paste и PasteObject...(Windows)/Paste as Part (MacOS). Поле pasteType содержит конкретный тип отображения, копия которого будет вставлена, если произойдет операция вставки. В зависимости от значения поля отображения может решить разрешить или запретить операцию вставки. PollOpsMsg посылается, когда пользователь щелкнул на меню. Единственное его назначение - разрешить или запретить элементы меню, то есть осуществление обратной связи с пользователем.
Если отображение поддерживает выделение содержимого, то selectable должно быть установлено в TRUE. Как следствие станет доступной команда меню Select All. Этот флаг следует установить вне зависимоси от того есть или нет текущее выделение.
В поле type передается имя типа. Это имя является контекстом для отображения, обладающего фокусом ввода. Этот контекст применяется для определения соответствующего меню для отображения, обладающего фокусом ввода. По соглашению отображение задает в поле type свой базовый тип интерфейса, то есть "ObxViews4.View". Меню с отметкой активности для "ObxViews4.View" будет показыватся для отображения, обладающего фокусом. Имя типа применяется для облегчения поддержки уникальности и избежания конфликта имен. Оболочка никак не интерпретирует имена.
Поле singleton применяется для подчеркивания роли отображения-контейнера. Оно обозначает контейнер текущего выделенного отображения, если выделение состоит целиком из внедренного отображения.
Следующий пример отображения может получать фокус ввода, поддерживает операцию вставки и может информировать оболочку о возможности выделения содержимого. Вследствие этого пункты меню Paste и Select All из меню Edit доступны. Дополнительно определяется контекст "Obx.Tutorial". Поэтому следующее меню появляется всегда, когда отображение выделено; обеспечивается, если меню установлено.
Следует отметить, что имя контекста, в нашем случае "Obx.Tutorial", для удобства начинается с имени подсистемы или модуля с последующей точкой, в нашем случае "Obx.". Такое именование настоятельно рекомендуется в целях обеспечения глобальной уникальности имен. Часто это имя - наименование типа отображения, например: "TextViews.View".
Меню так же может быть объявлено в тексте глобального меню System/Rsrc/Menus или, более характерно, в собственном файле меню подсистемы, в данном случае Obx/Rsrc/Menus. Для того, чтобы меню Obx было видно в главном меню, в его текст необходимо добавить выражение INCLUDE "Obx".
MENU "New" ("Obx.Tutorial")
"Beep" "" "Dialog.Beep" ""
END
MODULE ObxViews4;
IMPORT Views, Ports, Properties, Controllers;
TYPE View = POINTER TO RECORD (Views.View) END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN
msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN
msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE (* ignore other messages *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message; VAR focus: Views.View);
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
ELSE
END
END HandleCtrlMsg;
stdTables
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
END ObxViews4.
"ObxViews4.Deposit; StdCmds.PasteView" >< перед выполнением коменды установите курсор здесь
Далее будет рассмотрено, каким образом отображение может отреагировать на сообщение о редактировании. В частности имеются Controllers.EditMsg для операций редактирования, таких как вырезать, скопировать, вставить и Controllers.TrackMsg для щелчка мыши.
При любом нажатии клавиши в отображении или при вырезании, копировании или вставке Controllers.EditMsg посылается в отображение, обладающее фокусом ввода. Операции вырезания, копирования или вставки могут так же генерироваться средой окружения (через меню), если они были объявлены в Contollers.PollOpsMsg.
TYPE
EditMsg = RECORD (Controllers.RequestMessage)
op: INTEGER; (* IN *)
modifiers: SET; (* IN *)
char: CHAR; (* IN *)
view: Views.View; (* IN для вставки, OUT для вырезания и копирования *)
w, h: INTEGER; (* IN для вставки, OUT для вырезания и копирования *)
isSingle: BOOLEAN; (* IN для вставки, OUT для вырезания и копирования *)
clipboard: BOOLEAN (* IN *)
END;
Поле op определяет какого типа операция будет произведена. Если op = Controllers.cut, то для отображения, обладающего фокусом ввода, будет сгенерировано копирование. Содержимым нового отображения будет копия выделения в отображении, обладающем фокусом ввода. Новое отображение присваивается полю view. В дополнение, выделение удаляется из отображения, обладающего фокусом ввода.
Есть один специальный случай: если выделение состоит только из одиночного отображения (синглетон - a singleton), то в поле view копируется сам синглетон, но не копия контейнера синглетона. В этом случае isSingle выставляется в TRUE.
За исключением операции удаления выделенного фрагмента, при значении op = Controllers.copy выполняются те же действия.
Если нажата клавиша на клавиатуре, поле op получает значение Controllers.pasteChar. Символ, который будет вставлен, хранится в поле char. Множество modifiers содержит нажатия вспомогательных клавиш. В последнем случае поле char должно интерпретироваться как управляющий символ.
Операция вставки (paste) является обратной к операции копирования (copy): копия содержимого отображения, находящаяся в поле view перемещается в состав отображения, обладающего фокусом ввода. Эта операция обозначается op = Controllers.paste. Отображение-приемник должно знать тип отображения, чье содержимое будет вставлено и должно решить каким образом содержимое вставляемого отображения будет размещено внутри себя. Например, текстовое отображение должно поддерживать копирование только из текстовых отображений. Если поле isSingle имеет значение TRUE или если содержимое отображения не может быть вставлено, потому что оно принадлежит неизвестному типу, то должна быть вставлена копия самого отображения (но не содержимого). Конечно, это возможно только для универсального контейнера, который позволяет внедрять отображения.
Когда вставляется отображение целиком, то предопределенные ширина и высота передаются в полях w и h. Эти значения могут использоваться как ориентир для отображения-приемника. Если они не подходят, могут использоваться другие.
При любом нажатии кнопок мыши в отображении, обладающем фокусом ввода, отображению посылается сообщение Controllers.TrackMsg. Координаты находятся в полях x и y (базового типа Controllers.CursorMessage). Множество modifiers фиксирует нажатие модифицирующих клавиш и факт двойного щелчка. modifiers in {Controllers.doubleClick, Controllers.extend, Controllers.Modify}. Если отображению необходимо отразить обратную связь при перемещении мыши, необходимо регистрировать позицию мыши в цикле, вызывая процедуру Input рамки (frame), в котором перемещается мышь. Процедура Input так же возвращает информацию о том, где была отпущена мышь. Любая обратная связь должна быть напрямую отражена в окне, в котором была нажата кнопка мыши.
После цикла обратной связи возможные изменения содержимого отображения должны быть распространены на все окна, показывающие это отображение. Необходимо помнить, что один документ, а, следовательно, все его внедренные отображения, могут показываться в нескольких окнах. Если внедренное отображение видно в трех окнах (windows), значит существует три рамки (frames), показывающие одно отображение. Процедура Views.Update приводит к обновлению отображения во всех видимых рамках (frame).
В качестве примера расширим возможности тестового отображения маркером в виде креста с возможностью его перемещения. Следует отметить, что если отображение содержит экземпляры переменных (Instance variables), необходимо реализовать процедуры CopyFromSimpleView, Internalize и Externalize для корректной работы. В следующих разделах учебника будет рассказано назначение этих сообщений. В представленном примере отображения маркер может передвигаться мышью или клавишами перемещения курсора. При нажатии на такую клавишу отображение, имеющее фокус ввода, информируется об этом с помощью сообщения EditMsg с параметром op = pasteChar.
Периодически отображению, обладающему фокусом ввода, посылается сообщение Controllers.PollCursorMsg. Отображение может выставить форму курсора в зависимости от координат мыши. Полю cursor могут быть присвоены значения из набора: {Port.arrowCursor, Ports.textCursor, Ports.graphicsCursor, Ports.tableCursor, Ports.bitmapCursor}. Конкретная форма курсора зависит от особенностей операционной системы. В приведенном примере выставляется графический курсор.
MODULE ObxViews5;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, Ports.red);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y,
0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* клавиши курсора *)
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y;
v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; Views.Deposit(v)
END Deposit;
END ObxViews5.
"ObxViews5.Deposit; StdCmds.Open"
Существует много других управляющих сообщений, которые могут быть посланы отображению, но в данной книге ограничимся учебными целями. Имеются сообщения, реализующие общий механизм прокрутки BlackBox Component Framework (Controllers.PollSelectionMsg, Contollers.ScrollMsg, Controllers.PageMsg), сообщения, реализующие механизм drag&drop (Controllers.PollDropMsg, Controllers.DropMsg, Controllers.TransferMessage) и сообщения для контроля выделения (Controllers.SelectMsg). За справкой по этим и другим управляющим сообщениям следует обращаться к встроенной документации модуля Controllers.
6.5. Свойства
Этот раздел завершает расширение сквозного примера отображения: теперь цвет отображения можно изменить с помощью пункта меню Attr[ibutes]. Общий механизм получения или выставления свойств отображения через среду окружения реализован в виде свойств (properties). Отображение может обладать информацией об атрибутах, таких как: шрифт, цвет, размер и еще несколько других атрибутов. Свойства (properties) выставляются с помощью процедуры Properties.SetMsg и проверяются с помощью процедуры Properties.PollMsg. Свойства представляют собой сообщения, связанные в список. Когда отображение получает Properties.SetMsg, оно проходит список свойств и приводит в соответствие те из них, о которых у него есть информация. Properties.GetMsg посылается отображению, если необходимо затребовать значение свойства. Отображение возвращает все значения свойств, о которых есть информация. Свойство может быть вставлено в список свойств сообщения с помощью процедуры Properties.Insert.
Каждое свойство описывает до 32 атрибутов. Множество known определяет, какие атрибуты известны отображению. Множество так же может определить, какие атрибуты являются атрибутами "только для чтения" с помощью множества readOnly. Множество valid указывает, какие из атрибутов имеют выставленное значение. Например, если в тексте выделено несколько символов разного размера, атрибут size будет поддерживаться для отображения, но его текущее значение не будет определено. Так как выделение не является однородным, то не может быть одного корректного значения.
TYPE
Property = POINTER TO ABSTRACT RECORD
next-: Properties.Property;
known, readOnly, valid: SET; (* valid and readOnly are subsets of known *)
(p: Property) IntersectWith (q: Properties.Property; OUT equal: BOOLEAN), NEW, ABSTRACT
END;
Имеется специальное свойство Properties.StdProp. Это свойство заключает в себе атрибуты шрифта так же как цвет и известно для среды окружения BlackBox. Поддерживаются атрибуты: Properties.color, Properties.typeface, Properties.size, Properties.style, Properties.weight. В этих полях записи содержатся соответствующие значения.
TYPE
StdProp = POINTER TO RECORD (Properties.Property)
color: Dialog.Color;
typeface: Fonts.Typeface;
size: INTEGER;
style: RECORD
val, mask: SET
END;
weight: INTEGER
END;
Последняя версия отображения поддерживает только атрибут цвета для стандартного свойства. При получении сообщения Properties.PollMsg возвращается объект типа Properties.StdProp, в котором установлено только поле для цвета и только атрибут цвета установлена как поддерживаемый и корректный. При Properties.SetMsg в списке свойств отыскивается стандартное свойство, у которого корректно поле цвета. После того, как цвет отображения изменен, его следует обновить во всех рамках.
MODULE ObxViews6;
IMPORT Views, Ports, Properties, Controllers;
TYPE
View = POINTER TO RECORD (Views.View)
x, y: INTEGER;
c: Ports.Color
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawRect(l, t, r, b, Ports.fill, v.c);
f.DrawLine(v.x, t, v.x, b, 0, Ports.white); f.DrawLine(l, v.y, r, v.y, 0, Ports.white)
END Restore;
PROCEDURE (v: View) HandlePropMsg (VAR msg: Properties.Message);
CONST min = 5 * Ports.mm; max = 50 * Ports.mm;
VAR stdProp: Properties.StdProp; prop: Properties.Property;
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 20 * Ports.mm; msg.h := 10 * Ports.mm
ELSE
Properties.ProportionalConstraint(2, 1, msg.fixedW, msg.fixedH,
msg.w, msg.h);
IF msg.h < min THEN msg.h := min; msg.w := 2 * min
ELSIF msg.h > max THEN msg.h := max; msg.w := 2 * max
END
END
| msg: Properties.ResizePref DO
msg.horFitToWin := TRUE; msg.verFitToWin := TRUE
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
| msg: Properties.PollMsg DO
NEW(stdProp);
stdProp.color.val := v.c;
stdProp.valid := {Properties.color};
stdProp.known := {Properties.color};
Properties.Insert(msg.prop, stdProp)
| msg: Properties.SetMsg DO
prop := msg.prop;
WHILE prop # NIL DO
WITH prop: Properties.StdProp DO
IF Properties.color IN prop.valid THEN v.c := prop.color.val END
ELSE
END;
prop := prop.next
END;
Views.Update(v, Views.keepFrames)
ELSE (* пропустить остальные сообщения *)
END
END HandlePropMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR x, y, w, h: INTEGER; m: SET; isDown: BOOLEAN;
BEGIN
WITH msg: Controllers.PollOpsMsg DO
msg.valid := {Controllers.paste}; msg.selectable := TRUE;
msg.type := "Obx.Tutorial"
| msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
IF msg.char = 1DX THEN INC(v.x, Ports.mm)
ELSIF msg.char = 1CX THEN DEC(v.x, Ports.mm)
ELSIF msg.char = 1EX THEN DEC(v.y, Ports.mm)
ELSIF msg.char = 1FX THEN INC(v.y, Ports.mm)
END;
Views.Update(v, Views.keepFrames)
END
| msg: Controllers.TrackMsg DO
v.x := msg.x; v.y := msg.y; v.context.GetSize(w, h); v.Restore(f, 0, 0, w, h);
REPEAT
f.Input(x, y, m, isDown);
IF (x # v.x) OR (y # v.y) THEN
v.x := x; v.y := y; v.Restore(f, 0, 0, w, h)
END
UNTIL ~isDown;
Views.Update(v, Views.keepFrames)
| msg: Controllers.PollCursorMsg DO
msg.cursor := Ports.graphicsCursor
ELSE (* пропустить остальные сообщения *)
END
END HandleCtrlMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.x := 0; v.y := 0; v.c := Ports.black; Views.Deposit(v)
END Deposit;
END ObxViews6.
"ObxViews6.Deposit; StdCmds.PasteView" >< перед выполнением коменды установите курсор здесь
6.6 Разделение модели и отображения
В этом разделе будет представлена серия из пяти примеров с возрастающей сложностью, которые показывают строку, введенную пользователем. Эта строка представляет собой данные отображения, которые показываются на экране. Будет показана возможность редактирования строки в нескольких отображениях, представленных объектами из разных модулей.
В первой версии отображения строка сохраняется непосредственно в отображении. Каждое отображение показывает свою собственную строку. Длина строки ограничена 255 символами, обработка ошибок не производится.
MODULE ObxViews10;
IMPORT Fonts, Ports, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* позиция следующего свободного места в строке *)
s: ARRAY 256 OF CHAR (* строка *)
END;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* принять ввод *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* добавить символ к строке *)
Views.Update(v, Views.keepFrames) (* восстановить v в любой рамке, которая его показывает *)
END
ELSE (* пропустить остальные сообщения *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews10.
"ObxViews10.Deposit; StdCmds.Open"
Как было указано в последнем разделе, напечатанный символ передается отображению в виде записи управляющего сообщения для последующей обработки процедурой отображения HandleCtrlMsg. В эту процедуру в качестве параметра передается Controllers.EditMsg с введенным символом, в качестве результата работы процедуры введенный символ вставляется в поле s. После этого необходимо обновить отображение, то есть везде, где это отображение видно, его необходимо перерисовать в новом статусе. При этом введенная строка становится на один символ длиннее.
В приведенном выше примере отображение содержит содержательную составляющую (строковое поле s отображения). Эта составляющая должна сохраняться, когда содержимое окна сохраняется на диске. С этой целью отображение поддерживает две процедуры с именами Internalize и Externalize, применение которых показано в очередном обновлении сквозного примера.
MODULE ObxViews11;
(* То же, что и ObxViews10, но строка отображения может быть сохранена и скопирована *)
IMPORT Fonts, Ports, Stores, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
View = POINTER TO RECORD (Views.View)
i: INTEGER; (* position of next free slot in string *)
s: ARRAY 256 OF CHAR (* string *)
END;
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(v.i); rd.ReadString(v.s)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(v.i); wr.WriteString(v.s)
END Externalize;
PROCEDURE (v: View) CopyFromSimpleView (source: Views.View);
BEGIN
WITH source: View DO
v.i := source.i; v.s := source.s
END
END CopyFromSimpleView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN (* принять ввод *)
v.s[v.i] := msg.char; INC(v.i); v.s[v.i] := 0X; (* добавить символ к строке *)
Views.SetDirty(v); (* пометить документ отображения как испорченный *)
Views.Update(v, Views.keepFrames) (* восстановить v в любой рамке, которая его отображает *)
END
ELSE (* пропустить остальные сообщения *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
NEW(v); v.s := ""; v.i := 0;
Views.Deposit(v)
END Deposit;
END ObxViews11.
Несколько комментариев по поводу View.Internalize и View.Externalize:
Во-первых: обе процедуры получают в качестве параметра считыватель и записыватель соответственно. Отображатели файла (file mappers) создаются самостоятельно системой BlackBox, отображение просто использует их.
Во-вторых: View.Internalize должна считать в точности те данные (общее количество), которые записаны View.Externalize.
В-третьих: интерфейс пользователя имеет некоторые отличия для документов, содержащих модифицированные отображения, то есть для "грязных" документов. Им может потребоваться дополнительный вопрос о сохранении содержимого при закрытии документа. Для обеспечения этой возможности отображение должно сообщить, когда его сообщение содержит целиком обновленные данные. Это достигается вызовами процедур Views.BeginModification/Views.EndModification.
В дополнение к View.Internalize и View.Externalize в приведенной выше реализации отображения еще появляется процедура CopyFromSimpleView. Такая процедура должна копировать в себя содержимое переданного отображения того же типа. CopyFromSimpleView обычно имеет тот же эффект, что и операция выброса (externalized) во временный файл с последующим затягиванием (internalized) в отображение-назначение. Кончено же могут быть и исключения. Например, копии текста, содержащие временные метки ошибок не выбрасывают (externalized) их в хранилище.
Для отображений, содержащих (изменившуюся) составляющую, следует реализовывать CopyFromSimpleView для возможности их печати. Это необходимо, потому что оболочка делает собственную копию, которая собственно и печатается, во избежание изменений в оригинальном отображении в процессе разметки страниц, прокруток и других изменений, возможных во время печати.
В общем в ObxViews11 затронуто большинство возможностей класса простого отображения. Подобное простое отображение часто бывает достаточно, если легкость реализации имеет большую важность. Тем не менее, в некоторых случаях требуется более продвинутый дизайн отображения. В частности, если окно обычно показывает малую часть содержимого отображения, то необходима поддержка многооконного редактирования (multi-view editing).
Многооконное редактирование (multi-view editing) означает, что может быть несколько отображений, содержащих одни и те же данные. Типичным применением этой возможности является возможность показа различных частей одного документа, причем каждая часть показывается в своем окне. Так, если данные отображения изменяются, все задействованные отображения должны быть оповещены об этом, чтобы можно было обновить соответствующие изображения.
Следующий пример программы, который отличается от предыдущего только поддержкой многооконного редактирования (multi-view editing), примерно в 2 раза длиннее. Это показывает, что дизайн и реализация подобных отображений требует бОльших усилий, чем простое отображение. Такое главное дизайнерское решение, несмотря на дополнительные сложности, оправдывается возрастающим удобством.
MODULE ObxViews12;
(* То же, что и ObxViews11, но использует отдельную модель для строк *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* позиция следующего свободного места в строке *)
s: ARRAY 256 OF CHAR (* строка *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
(* Модель *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* Отображение *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View;
model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* восстановить v в любой рамке, которая его отображает *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR m: Model; umsg: Models.UpdateMsg;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
m := v.model;
m.s[m.i] := msg.char; INC(m.i);
m.s[m.i] := 0X; (* добавить символ к строке *)
Views.SetDirty(v); (* пометить документ отображения как "испорченный" *)
Models.Broadcast(m, umsg) (* обновить все отображения этой модели*)
END
ELSE (* пропустить остальные сообщения *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews12.
"ObxViews12.Deposit; StdCmds.Open"
Многооконное редактирование (multi-view editing) реализуется путем выделения данных отображения в отдельную структуру, называемую моделью (model). Эта модель используется совместно всеми отображениями, то есть каждое такое отображение содержит ссылку на модель.
Рисунок 6-2. Два отображения для одной модели.
Модель, как и отображение, является расширением Stores.Store, который, в свою очередь, является базовым типом для всех устойчивых (persistent) объектов. Для хранилищ (Stores) определены процедуры Internalize и Externalize, которые уже были рассмотрены для отображения. В ObxViews12 модель хранит строку и ее длину, в то время как отображение хранит модель целиком. С этой целью Stores.Writer поддерживает WriteStore и StoresReader поддерживает ReadStore процедуры.
Хранилища (Stores) могут состоять из нескольких графических образов. Например, одно или несколько отображений могут ссылаться на одну модель, а модели и отображения содержат расширения. Графический образ хранилища может быть сохранен в файле, называемом документ (document). Для возможности распознавания границ документа при выгрузке, хранилища ограничены доменом (domain). Все хранилища из документа относятся к одному и тому же доменному объекту (Stores.Domain).
Домены так же используются в качестве контейнера для операций, то есть команд, выполняемых над хранилищем (store) с возможностью их отмены и повторения (см. следующую главу). История операций привязана к домену. Более того, домены определяют набор объектов, которые получают широковещательные сообщения. (Views.Broadcast, Views.Domaincast, Models.Broadcast).
За дальнейшей информацией о хранилищах (stores) и доменах обращайтесь к встроенной документации модуля Stores.
Теперь, когда модель отделена от отображения, копирование выполняется только для модели, но не для отображения.
Процедура View.ThisModel возвращает модель для отображения. Реализация по умолчанию возвращает NIL, то есть ее нужно перекрыть для отображений, содержащих модели. Эта процедура используется оболочкой для поиска всех отображений, показывающих данную модель с целью реализации широковещания для модели, как показано в следующем параграфе.
Отображения с моделями реализуют процедуру View.CopyFromModelView взамен View.CopyFromSimpleView. Подобно Internalize и Externalize, процедура CopyFromSimpleView и CopyFromModelView экспортируются как процедуры для реализации, то есть они только реализуются, но не вызываются. Они вызываются внутренними механизмами модуля Views в функциях CopyOf и CopyWithNewModel.
При изменении модели все отображения, показывающие модель, должны быть обновлены. Для этой цели генерируется широковещание (broadcast) для модели: модель вещает сообщения всем отображениям, содержащим конкретную модель, с информацией о случившихся изменениях в модели.
Это дает возможность отображению обновить содержимое экрана. Широковещание модели происходит в процедуре View.HandleCtrlMsg путем вызова Models.Broadcast. Сообщения получает каждое отображение, содержащее корректную модель, посредством процедуры View.HandleModelMsg.
Такая косвеная связь важна, если одну модель представляют разные типы отображений, например, табличное и графическое представление модели табличных данных, и, вместо обновления всего отображения (как сделано в предыдущих примерах), обновляется только необходимая часть отображения. Необходимая для обновления часть может быть совершенно разной для разных типов отображений.
Очень сложные модели могут содержать (или в них могут быть внедрены) несколько отображений в качестве составных частей. Например, текстовое отображение может изображать не только текстовую модель, содержащую только символы (натуральное содержимое), но и графические или другие отображения, обособленно следующие в текстовом потоке.
Комбинация многооконного (multi-view) редактирования и иерархического внедрения отображений может привести к ситуации, когда два текстовых отображения показывают одну текстовую модель, которая в свою очередь, содержит графическое отображение. Каждое текстовое отображение существует в собственном окне, поэтому имеет собственные рамки. Тем не менее, графическое отображение уникально тем, что внедрено в текстовую модель, которая, в свою очередь, разделяется обеими текстовыми отображениями. Тем не менее, графика может показываться одновременно в обеих текстовых отображениях, а, значит, может быть две рамки для этого отображения.
Рисунок 6-3. Две рамки в одном отображении.
Вследствие этого, одно и то же отображение может показываться в нескольких местах экрана одновременно. В таком случае это означает, что при изменении отображения должны обновиться несколько участков: отображение должно восстановить необходимые участки для каждой рамки отображения. Как следствие, механизм сообщений должен обеспечить обновление отображений для каждой его рамки. Это достигается подобно механизму сообщений при изменении моделей: с помощью широковещания для отображения (view broadcast). К счастью, стандартный механизм обновлений внутри оболочки автоматически обрабатывает второй уровень широковещания (см. ниже).
Сейчас сведем вместе типичные события, происходящие при взаимодействии пользователя и отображения.
Обработка управляющих сообщений:
1. Какое-либо управляющее сообщение посылается отображению, обладающему фокусом ввода.
2. Отображение, обладающее фокусом ввода, интерпретирует сообщение и соответствующим образом изменяет свою модель.
3. Модель осуществляет широковещание сообщений, описывающих случившиеся изменения.
Обработка сообщений модели.
4. Каждое отображение для данной модели получает сообщение модели.
5. Они определяют, как должно измениться изображение в связи с изменениями модели.
6. Они (отображения) осуществляют широковещание сообщений отображения, описывающих как должно измениться изображение.
Обработка сообщений отображения
7. Каждое отображение получает уведомительное сообщение по одному на каждую рамку отображения.
8. Каждый раз отображение перерисовывает свои рамки в соответствии с сообщениями отображения.
Этот механизм является основополагающим для BlackBox Component Framework. Его понимание является наиболее важной и сложной частью реализации отображений. Интерпретация различных управляющих сообщений, определенных в модуле Controllers, является более чем необходимой для понимания трудностей новой концепции. Более того, необходимо интерпретировать только интересующие нас управляющие сообщения, потому что неподходящие сообщения следует просто игнорировать.
Обычно шаги 6, 7 и 8 обрабатываются каркасом автоматически: отображения просто вызывают Views.Update для обновления всего отображения целиком или Views.UpdateIn для обновления какой-либо прямоугольной области. Вызов этих процедур обновления приводит к так называемому ленивому обновлению (lazy update), то есть оболочка помечает область для обновления, но перерисовка НЕ производится сразу. Вместо этого вначале завершаются команды, чтобы все структуры данных изменяемого отображения пришли в согласованное состояние. Только изображения отображений остаются теми же, что и до выполнения команд. Только после этого оболочка перерисовывает все области отображения, помеченные к обновлению. Это означает, что для каждой рамки, отрисованной в отображении, вызывается метод отображения Restore и в качестве аргумента передается рамка. Если отображение показывается в двух (или более) рамках разных окон, то обновляется два (или более) число раз, по одному разу на каждую рамку. Когда оболочка обновляет рамки внутри окна, происходит временное перенаправление операции в порт фонового пиксельного буфера. После обновления всех рамок окна, подлежащих перерисовке, оболочка копирует пиксельный буфер в пиксели экрана и отключает перенаправление операции перерисовки.
Эффектом от механизма буферизации и механизма ленивого обновления является минимизация мерцания. Механизм ленивого обновления (как для Apple MacOS, так и для Microsoft Windows) означает, что для сложных операций редактирования данная область экрана будет обновляться однократно. Это позволяет подавить мерцание, так как оно может возникнуть при быстрой многократной перерисовке какой-либо области. Механизм буферизации подавляет мерцание при отрисовке слоев "снизу-вверх" (так как это так же означает быструю многократную перерисовку). Например, вначале может отрисовываться фон одним цветом, а затем поверх рисуется прямоугольник с заливкой другого цвета. Благодаря механизму буферизации пользователь никогда не увидит ситуацию, когда фон отрисован, а прямоугольник - еще нет.
Механизм ленивого обновления обладает еще одним преимуществом: целиком разделяется изменение модели и ее отрисовка. Без этого механизма было бы действительно сложно правильно реализовать обновление экрана при сложном редактировании. Например, рассмотрим перемещение выделения графического объекта в графическом редакторе. Вначале выделенный объект должен быть уделен со старой позиции, что означает, что объекты, которые ранее были скрыты, должны быть перерисованы (но не сам выделенный объект). Затем позиция объекта изменяется и он должен быть перерисован в новой позиции (если исходная и конечная позиции перекрываются, перерисовка произойдет дважды). Перерисовка может потребоваться несколько раз, так как одни и те же данные могут показываться в нескольких окнах. Но, конечно же, изменение позиции объекта происходит только единожды. Гораздо менее мудрено просто вызвать Views.UpdateIn для прямоугольников, которые требуют (могут требовать) обновления и позволить оболочке вызвать требуемые Restore позже.
Обычно механизма ленивого обновления вполне достаточно. Таким образом программирование отображений с использованием чистых сообщений отображения (explicit view messages) применяется, только если не требуется полного обновления всех рамок отображения. То есть для спецсимволов типа: отметки выделения, фокуса, каретки, "резиновых" рамок и тому подобных обратных связей в процессе перемещения мыши. Подобные метки иногда могут быть обработаны более эффективно, так как они являются непроизвольными: двойное их применение приводит к их подавлению. Поэтому часто метки переключаются пользовательскими сообщениями отображения в процессе команды, но не посредством механизма отложенного ленивого обновления. За исключением подобных легковесных отметок, всегда следует применять описанный выше механизм ленивого обновления. Следует отметить наличие метода Ports.Frame.MarkRect, служащего специально для отрисовки подобных меток.
6.7 Операции
Теперь, после того, как рассмотрены критические составляющие реализации отображений, можно представить второстепенные особенности. В следующей программе, являющейся вариантом приведенных выше, управляющие сообщения не интерпретируются напрямую. Вместо этого создается и выполняется объект операции (operation object). Операция обеспечивает возможности отката, как показано в нижеследующей программе.
В этом примере определяется операция PasteCharOp. Процедура Do операции, выполняющая желаемые модификации, должна быть непроизвольной (involutory), то есть при повторном вызове она нейтрализует предыдущий вызов. Флаг PasteCharOp.do применяется для обозначения того, был ли символ PasteCharOp.char вставлен или удален из модели PasteCharOp.m. В любом случае процедура Do обязана обновить все отображения для модели PasteCharOp.m с помощью широковещания модели.
Процедура NewPasteCharOp создает новую операцию, процедура Models.Do выполняет эту операцию, то есть вызывается процедура Do операции, а собственно операция записывается для возможности дальнейшего отката. Наименование операции, определенной в команде Models.Do появляется в меню Edit после пунктов Undo или Redo соответственно.
MODULE ObxViews13;
(* Такой же, как ObxViews12, но генерирует операции с возможность отмены для вставки символа *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model = POINTER TO RECORD (Models.Model)
i: INTEGER; (* позиция следующего свободного места в строке *)
s: ARRAY 256 OF CHAR (* строка *)
END;
View = POINTER TO RECORD (Views.View)
model: Model
END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: Model;
char: CHAR;
do: BOOLEAN
END;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: Model; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do изменение операции *)
m.s[m.i] := op.char; INC(m.i) (* вставка символа в строку *)
ELSE (* отмена операции *)
DEC(m.i) (* удаление символа из строки *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* переключатель между "do" и "undo" *)
Models.Broadcast(m, msg) (* обновить все отображения модели*)
END Do;
PROCEDURE NewPasteCharOp (m: Model; char: CHAR): PasteCharOp;
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
RETURN op
END NewPasteCharOp;
(* Модель *)
PROCEDURE (m: Model) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: Model) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: Model) CopyFrom (source: Stores.Store);
BEGIN
WITH source: Model DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
(* Отображение *)
PROCEDURE (v: View) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
v.model := st(Model)
END
END Internalize;
PROCEDURE (v: View) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: View) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
v.model := model(Model)
END CopyFromModelView;
PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
f.DrawString(d, d, Ports.black, v.model.s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: View) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: View) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* восстановить v в любой рамке, отображающей его *)
END HandleModelMsg;
PROCEDURE (v: View) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
VAR op: Stores.Operation;
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
op := NewPasteCharOp(v.model, msg.char); (* сгенерировать операцию *)
Models.Do(v.model, "Typing", op) (* выполнить операцию *)
END
ELSE (* пропустить остальные сообщения *)
END
END HandleCtrlMsg;
PROCEDURE (v:View) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 * d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
PROCEDURE Deposit*;
VAR v: View; m: Model;
BEGIN
NEW(m); m.i := 0; m.s := "";
NEW(v); v.model := m; Stores.Join(v, m);
Views.Deposit(v)
END Deposit;
END ObxViews13.
"ObxViews13.Deposit; StdCmds.Open"
Другие примеры с применением механизма отката/повтора посредством операций можно найти, например, в ObxOmosi или ObxLines.
6.8 Разделение интерфейса и реализации
В качестве последней версии простого отображения, изменим предыдущий вариант путем экспорта типов Model и View и разделения интерфейса и реализации этих двух типов. Для выполнения последнего вводится так называемые фабричные объекты (directory objects), которые создают (скрытые) предопределенные реализации абстрактных типов данных. Теперь пользователь обязан реализовать собственные версии абстрактных типов и предоставить их через собственный фабричный объект, который не может быть унаследован от реализации по умолчанию во избежание проблемы хрупких базовых классов.
Рабочие подсистемы BlackBox могут дополнительно разделять модуль на два: один для модели, другой для отображения. Может быть введен и третий модуль с командами, если число и сложность команд тревожно высоко (например: TextModels, TextViews и TextCmds). Еще более сложное отображение следует, в свою очередь, разделять на отображения и контроллеры, каждый в своем модуле.
MODULE ObxViews14;
(* Такой же как ObxViews13, но интерфейсы и реализация разделены, и операция напрямую в процедуре вставки *)
IMPORT Fonts, Ports, Stores, Models, Views, Controllers, Properties;
CONST d = 20 * Ports.point;
TYPE
Model* = POINTER TO ABSTRACT RECORD (Models.Model) END;
ModelDirectory* = POINTER TO ABSTRACT RECORD END;
View* = POINTER TO ABSTRACT RECORD (Views.View) END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdModel = POINTER TO RECORD (Model)
i: INTEGER; (* позиция следующего пустого места в строке *)
s: ARRAY 256 OF CHAR (* строка *)
END;
StdModelDirectory = POINTER TO RECORD (ModelDirectory) END;
StdView = POINTER TO RECORD (View)
model: Model
END;
StdDirectory = POINTER TO RECORD (Directory) END;
PasteCharOp = POINTER TO RECORD (Stores.Operation)
model: StdModel;
char: CHAR;
do: BOOLEAN
END;
VAR
mdir-: ModelDirectory;
dir-: Directory;
(* Модель*)
PROCEDURE (m: Model) Insert* (char: CHAR), NEW, ABSTRACT;
PROCEDURE (m: Model) Remove*, NEW, ABSTRACT;
PROCEDURE (m: Model) GetString* (OUT s: ARRAY OF CHAR), NEW, ABSTRACT;
(* ModelDirectory *)
PROCEDURE (d: ModelDirectory) New* (): Model, NEW, ABSTRACT;
(* PasteCharOp *)
PROCEDURE (op: PasteCharOp) Do;
VAR m: StdModel; msg: Models.UpdateMsg;
BEGIN
m := op.model;
IF op.do THEN (* do изменение операции *)
m.s[m.i] := op.char; INC(m.i);
ELSE (* отменить изменение операции *)
DEC(m.i) (* удалить символ из строки *)
END;
m.s[m.i] := 0X;
op.do := ~op.do; (* переключатель между "do" и "undo" *)
Models.Broadcast(m, msg) (* обновить все отображения модели*)
END Do;
(* StdModel *)
PROCEDURE (m: StdModel) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadInt(m.i); rd.ReadString(m.s)
END
END Internalize;
PROCEDURE (m: StdModel) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteInt(m.i); wr.WriteString(m.s)
END Externalize;
PROCEDURE (m: StdModel) CopyFrom (source: Stores.Store);
BEGIN
WITH source: StdModel DO
m.i := source.i; m.s := source.s
END
END CopyFrom;
PROCEDURE (m: StdModel) Insert (char: CHAR);
VAR op: PasteCharOp;
BEGIN
NEW(op); op.model := m; op.char := char; op.do := TRUE;
Models.Do(m, "insertion", op)
END Insert;
PROCEDURE (m: StdModel) Remove;
VAR msg: Models.UpdateMsg;
BEGIN
DEC(m.i); m.s[m.i] := 0X;
Models.Broadcast(m, msg) (* обновить все отображения этой модели*)
END Remove;
PROCEDURE (m: StdModel) GetString (OUT s: ARRAY OF CHAR);
BEGIN
s := m.s$
END GetString;
(* StdModelDirectory *)
PROCEDURE (d: StdModelDirectory) New (): Model;
VAR m: StdModel;
BEGIN
NEW(m); m.s := ""; m.i := 0; RETURN m
END New;
(* Directory *)
PROCEDURE (d: Directory) New* (m: Model): View, NEW, ABSTRACT;
(* StdView *)
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR version: INTEGER; st: Stores.Store;
BEGIN
rd.ReadVersion(0, 0, version);
IF ~rd.cancelled THEN
rd.ReadStore(st);
IF st IS Model THEN
v.model := st(Model)
ELSE
(* реализация конкретной модели не может быть загружена->
было создано хранилище-нелегал *)
rd.TurnIntoAlien(Stores.alienComponent)
(* загрузка v отменена *)
END
END
END Internalize;
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
BEGIN
wr.WriteVersion(0);
wr.WriteStore(v.model)
END Externalize;
PROCEDURE (v: StdView) CopyFromModelView (source: Views.View; model: Models.Model);
BEGIN
WITH source: StdView DO
v.model := model(Model)
END
END CopyFromModelView;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR s: ARRAY 256 OF CHAR;
BEGIN
v.model.GetString(s);
f.DrawString(d, d, Ports.black, s, Fonts.dir.Default())
END Restore;
PROCEDURE (v: StdView) ThisModel (): Models.Model;
BEGIN
RETURN v.model
END ThisModel;
PROCEDURE (v: StdView) HandleModelMsg (VAR msg: Models.Message);
BEGIN
Views.Update(v, Views.keepFrames) (* восстановить v в любой рамке, отображающей его *)
END HandleModelMsg;
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame;
VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.EditMsg DO
IF msg.op = Controllers.pasteChar THEN
v.model.Insert(msg.char) (* отменяемая вставка *)
END
ELSE (* пропустить другие сообщения *)
END
END HandleCtrlMsg;
PROCEDURE (v:StdView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w = Views.undefined) OR (msg.h = Views.undefined) THEN
msg.w := 10 * d; msg.h := 2 *d
END
| msg: Properties.FocusPref DO
msg.setFocus := TRUE
ELSE
END
END HandlePropMsg;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New* (m: Model): View;
VAR v: StdView;
BEGIN
ASSERT(m # NIL, 20);
NEW(v); v.model := m; Stores.Join(v, m);
RETURN v
END New;
PROCEDURE Deposit*;
VAR v: View;
BEGIN
v := dir.New(mdir.New());
Views.Deposit(v)
END Deposit;
PROCEDURE SetModelDir* (d: ModelDirectory);
BEGIN
ASSERT(d # NIL, 20);
mdir := d
END SetModelDir;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20);
dir := d
END SetDir;
PROCEDURE Init;
VAR md: StdModelDirectory; d: StdDirectory;
BEGIN
NEW(md); mdir := md;
NEW(d); dir := d
END Init;
BEGIN
Init
END ObxViews14.
"ObxViews14.Deposit; StdCmds.Open"
Модуль DevMarkers представляет собой простой пример модуля BlackBox, отвечающий такому дизайну. Отображение маркера является простым отображением без модели, поэтому предоставляется только фабричный объект для создания новых отображений. Второй фабричный объект DevMarkers.StdDir сохраняет стандартную реализацию, обеспечиваемую данным модулем. Он может применяться для восстановления реализации по умолчанию или для повторного использования реализации по умолчанию (как экземпляр) в другом компоненте.
Разделение определения типов и их реализации рекомендуется при проектировании новой подсистемы BlackBox. Однако простые типы отображения не для широкого применения или не для дальнейшего расширения могут распространяться без таких дополнительных усилий.
Следует отметить, что мастер подсистем (subsystem wizard) (пункт меню Tools -> Create Subsystem...) помогает создавать шаблоны различных видов отображений. В частности возможно создавать раздельные модули для модели и отображений. Инструмент использует текстовые шаблоны, хранящиеся в Dev/Rsrc/New. Может быть интересным изучение файлов Models5, Views5 и Cmds5 в этом каталоге. | Docu/ru/Tut-6.odc |
Приложение A: Краткая история языка Паскаль
ENGLISH
Английский оригинал: Oberon microsystems, 1994-2001.
Перевод на русский язык: Ф.В.Ткачев, апрель 2001, 2009.
Замечания переводчика даны в угловых скобках <>.
Некоторые термины оригинала приведены в квадратных скобках [].
Алгол
Язык Компонентный Паскаль является кульминацией нескольких десятилетий исследовательской работы. Это самый младший член семейства алголоподобных языков. Алгол, определенный в 1960, был первым языком высокого уровня с синтаксисом, который был легко читаем, структурирован и описан формальным образом. Несмотря на его успешное использование в качестве нотации для математичесих алгоритмов, в нем недоставало важных типов данный, таких как указатели и литеры.
Паскаль
В конце 60-х гг. было выдвинуто несколько предложений об эволюционном развитии Алгола. Самым успешным оказался Паскаль, определенный в 1970 профессором Никлаусом Виртом из ETH, швейцарского Федерального политехнического университета в Цюрихе. Наряду с очищением языка от некоторых непрозрачных средств Алгола, в Паскале добавлена возможность объявления новых структур данных, построенных из уже существующих более простых. Паскаль также поддерживал динамические структуры данных, т.е. такие структуры данных, которые могут расти или уменьшаться во время выполнения программы. Паскаль получил мощный импульс к распространению, когда в ETH был выпущен компилятор, порождавший простой промежуточный код для виртуальной машины (P-код) вместо родного кода для конкретного процессора. Это существенно упростило перенос Паскаля на другие процессорные архитектуры, т.к. для этого нужно было только написать новый интерпретатор для P-кода вместо всего нового компилятора. Один из таких проектов был предпринят в Университете Калифорнии в Сан-Диего. Замечательно, что эта реализация (UCSD Pascal) не требовала мощного компьютера [mainframe] и могла работать на новых тогда персональных компьютерах семейства Apple II. Это дало распространению Паскаля второй серьезный импульс. Третьим был выпуск компанией Борланд продукта Турбо Паскаль, содержавшего быстрый и недорогой компилятор вместе с интегрированной средой разработки программ для компьютеров IBM PC. Позднее Борланд возродил свою версию Паскаля, выпустив среду быстрой разработки приложений Дельфи.
Паскаль сильно повлиял на дизайн и эволюцию многих других языков, от Ada до Visual Basic.
Модула-2
В середине 70-х гг., вдохновленный годичным академическим отпуском, проведенным в исследовательском центре PARC компании Xerox в г. Пало Альто, Вирт начал проект по созданию нового компьютера класса рабочая станция <проект Lilith>. Компьютер должен был быть полностью программируемым на языке высокого уровня, так что язык должен был обеспечить прямой доступ к аппаратному уровню. Далее, он должен был поддерживать коллективное программирование и современные принципы разработки программного обеспечения, такие как абстрактные типы данных. Эти требования были реализованы в языке программирования Модула-2 (1979). Модула-2 сохранила успешно зарекомендовавшие себя средства Паскаля и добавила систему модулей, а также контролируемые возможности обойти систему типов языка в случаях программирования низкого уровня, например, при написании драйверов устройств. Модули могли добавляться к операционной системе непосредственно во время работы. На самом деле вся операционная система представляла собой набор модулей без выделенного ядра или иного подобного объекта. Модули могли компилироваться и загружаться раздельно, причем обеспечивалась полная проверка типов и версий их интерфейсов.
Успех Модулы-2 был наиболее значителен в задачах с высокими требованиями на надежность, таких как системы управления движением. <Например, бортовое программное обеспечение на запускаемых в настоящее время российских спутниках связи пишется на Модуле-2 с помощью кросс-среды разработки приложений, описанной А.А.Колташевым в докладе на конференции JMLC'2003; см. Modular Programming Languages. Lecture Notes in Computer Science (LNCS 2789), Springer-Verlag, 2003, cc. 98-101>
Simula, Smalltalk и Cedar
Однако Вирт продолжал интересоваться прежде всего настольными компьютерами, и опять важный импульс пришел из центра PARC компании Xerox. В этом центре были изобретены рабочая станция, лазерный принтер, локальная сеть, графический дисплей и многие другие технологии, расширяющие возможности использования компьютеров человеком. Кроме того, в центре PARC были популяризированы некоторые более старые и малоизвестные технологии, такие как мышь, интерактивная графика и, наконец, объектно ориентированное программирование. Эта последняя концепция (хотя и не сам термин) была впервые использована в языке высокого уровня Симула (1966) еще одном из семейства алголоподобных языков. Как и предполагает имя, язык Simula использовал объектные технологии прежде всего для целей моделирования [simulation]. Однако язык Smalltalk (1983), разработанный в центре PARC компании Xerox, использовал их практически для всего, что угодно. Проект Smalltalk был также пионерским в плане дизайна пользовательского интерфейса: графический интерфейс пользователя (GUI), каким мы его теперь знаем, был разработан для системы Smalltalk.
В центре PARC эти идеи повлияли на другие проекты, например, паскалеподобный язык Cedar. Как и Smalltalk и позднее Оберон, Cedar представлял собой не только язык программирования, но и операционную систему. Операционная система Cedar была весьма впечатляющей и мощной, однако сложной и нестабильной.
Оберон [Oberon]
Проект Оберон был начат в 1985 в ETH Виртом и его коллегой Юргом Гуткнехтом [Jurg Gutknecht]. Это была попытка выделить все существенное из системы Cedar в виде универсальной, но все же обозримой операционной системы для рабочих станций. Получившаяся система оказалась очень маленькой и эффективной, прекрасно работала в оперативной памяти размером всего 2 MB и требовала при этом лишь 10 MB памяти на диске. Важной причиной малого размера системы Оберон был ее компонентный дизайн: вместо интеграции всех желаемых средств в один монолитный программный колосс, менее часто используемые программные компоненты (модули) могли быть реализованы как расширение ядра системы. Такие компоненты загружались, только когда они были действительно нужны, и они могли совместно использоваться всеми приложениями.
Вирт понял, что компонентно-ориентированное программирование требовало некоторых средств объектно-ориентированного программирования, таких как упрятывание информации [information hiding], позднее связывание [late binding] и полиморфизм.
Упрятывание информации было сильной чертой Модулы-2. Позднее связывание поддерживалось в Модуле-2 посредством процедурных переменных. Однако там не было полиморфизма. Поэтому Вирт добавил расширенное переопределение типов [type extension]: записевый тип мог быть объявлен как расширение <потомок> другого записевого типа <предка>. Тип-потомок можно было использовать всюду вместо одного из его предков.
Но компонентно-ориентированное программирование выходит за рамки объектно-ориентированного. В системе, построенной из компонентов, компонент может разделять свои структуры данных с произвольным числом других компонентов, о которых она ничего не знает. Эти компоненты обычно также не знают о существовании друг друга. Такое взаимное незнание делает управление динамическими структурами данных, и в частности правильное освобождение уже ненужной памяти, принципиально более трудной проблемой, чем в закрытых программных системах. Следовательно, необходимо оставить на долю реализации языка всю работу по определению момента, когда какая-то область памяти более не нужна, чтобы повторно использовать ее без ущерба для безопасности системы. Системный сервис, выполняющий такую автоматическую утилизацию памяти, называется сборщик мусора [garbage collector]. Сбор мусора предотвращает две из числа наиболее труднонаходимых и попросту опасных ошибок в программах: утечки памяти [memory leaks] (когда более не используемая память не освобождается) и висячие ссылки [dangling pointers] (преждевременное освобождение памяти). Висячие ссылки позволяют одному компоненту разрушить структуры данных, принадлежащие другим. Такое нарушение защиты типов [type safety] должно быть предотвращено, т.к. компонентные системы могут содержать многие независимо написанные компоненты неизвестного качества (например, полученные из Интернета).
Хотя алголоподобные языки всегда имели высокую репутацию в плане безопасности, введение полной защиты типов (и, следовательно, сбора мусора) явилось качественным скачком. Именно по этой причине полная совместимость с Модулой-2 оказалась невозможной. Получившаяся модификация Модулы-2 была названа как и вся система Оберон.
Система модулей в Обероне, как и в Модуле-2, обеспечивала упрятывание информации для целых семейств типов, а не только для отдельных объектов. Это позволило определять и гарантировать инварианты для нескольких взаимодействующих объектов. Другими словами, разработчики получили возможность разрабатывать механизмы защиты более высокого уровня, отталкиваясь от базовых средств защиты на уровне модулей и защиты типов, обеспечиваемых хорошей реализацией Оберона.
Ортодоксальные объектно-ориентированные языка типа Smalltalk пренебрегали как типизацией переменных (вообще не поддерживая типы), так и упрятыванием информации (ограничивая ее объектами и классами), что явилось большим шагом назад в технологии разработки программного обеспечения. Оберон примирил миры объектно-ориентированного и модульного программирования.
Последнее требование компонентно-ориентированного программирования возможность динамически загружать новые компоненты. В Обероне единица загрузки та же, что и единица компиляции модуль.
Компонентный Паскаль
В 1992 г. сотрудничество с профессором Х.П.Мёссенбёком (H.P. Mossenbock) привело к нескольким добавлениям к первоначальному языку Оберон (Оберон-2). Так возник фактический стандарт языка. <На данный момент (2009) это утверждение потеряло свой первоначальный смысл, т.к. Оберон-2 потеснен Компонентным Паскалем. прим. перев.>
В 1997 г. компания Oberon microsystems, Inc., отпочковавшаяся от ETH (с Виртом в составе совета директоров), сделала некоторые небольшие добавления к Оберону-2 и назвала его Компонентный Паскаль, чтобы четче выразить как его нацеленность (компонентно-ориентированное программирование), так и его происхождение (Паскаль). Это промышленная версия Оберона, являющаяся наследницей первоначального Паскаля и Модулы-2.
Главная идея уточнений по сравнению с Обероном-2 была в том, чтобы дать проектировщику компонентного каркаса [framework] (т.е. интерфейсов модулей, определяющих абстрактные классы для конкретной проблемной области) более полный контроль над ее проектируемыми свойствами в плане безопасности. Положительным результатом стало то, что теперь легче обеспечить целостность больших компонентных систем, что особенно важно во время итеративных циклов проектирования, когда библитека разрабатывается, и позднее, когда архитектура системы должна быть переработана [refactored], чтобы обеспечить дальнейшую эволюцию и поддержку.
BlackBox
Компания Oberon microsystems разрабатывала компонентную библиотеку <каркас> BlackBox Component Framework начиная с 1992 г. (сначала библиотека называлась Oberon/F). Эта библиотека написана на Компонентном Паскале и упрощает разработку компонентов графического пользовательского интерфейса. Она поставляется с несколькими компонентами, включая текстовый редактор, систему визуального проектирования, средство доступа к базам данных SQL, интегрированную среду разработки, а также систему поддержки выполнения программ на Компонентном Паскале. Весь пакет представляет собой развитый, но весьма нетребовательный к системным ресурсам инструмент быстрой разработки компонентных приложений, названный BlackBox Component Builder (Блэкбокс). Он нетребователен к системным ресурсам, т.к. полностью построен из модулей Компонентного Паскаля включая ядро со сборщиком мусора, а также самого компилятора языка Компонентный Паскаль. Это иллюстрация как мощи концепции компонентного программного обеспечения вообще, так и адекватности языка Компонентный Паскаль в частности.
Недавно диапазон приложений системы BlackBox Component Builder был значительно расширен за счет среды кросс-программирования Denia, которая является компонентом, расширающим систему Блэкбокс. Denia позволяет выполнять кросс-программирование на Компонентном Паскале для новой операционной системы реального времени Portos, которая тоже полностью реализована на Компонентном Паскале. Portos предназначен для встроенных систем и приложений с жесткими требованиям реального времени [hard real-time requirements], например, в робототехнике и промышленной автоматизации.
| Docu/ru/Tut-A.odc |
Приложение B: Отличия Компонентного Паскаля от Паскаля
ENGLISH
Английский оригинал: Oberon microsystems, 1994-2001.
Перевод на русский язык: Ф.В.Ткачев, апрель 2001, март 2009.
Исключенные средства
Типы-диапазоны
Используйте один из стандартных целых типов.
Перечислимые типы
Используйте вместо них целые константы.
Произвольные диапазоны для массивов
Массивы теперь всегда определены над целым диапазоном 0..max-1.
Пример
A = ARRAY 16 OF INTEGER (* разрешены индексы из диапазона 0..15 *)
Нет общих множеств
Тип SET теперь описывает набор целых чисел, который может включать элементы 0..31.
Нет явного оператора DISPOSE
Неиспользуемая более память автоматически собирается сборщиком мусора. Вместо DISPOSE, просто присвойте переменной значение NIL.
Нет вариантных записей
Используйте расширение (расширенное переопределение) записей.
Нет упакованных структур
Используйте типы SHORTCHAR или BYTE для значений, умещающихся в байт.
Нет GOTO
Нет стандартных функций PRED и SUCC
Используйте DEC и INC для целых значений.
Нет встроенных средств ввода/вывода
Нет файловых типов. Ввод/вывод обеспечивается библиотечными процедурами.
Измененные средства
Стандартная процедура ENTIER вместо ROUND
Синтаксис для констант типа REAL
3.0E+4, но не 3.0e+4
Синтаксис для объявлений указательных типов
P = POINTER TO R
вместо
P = ^R
Синтаксис для оператора CASE
"|" вместо ";" в качестве разделителя случаев.
Предложение ELSE.
Пример
CASE i * 3 - 1 OF
0: StdLog.String("нуль")
| 1..9: StdLog.String("от единицы до девяти")
| 10, 20: StdLog.String("десять или двадцать")
ELSE StdLog.String("что-то еще")
END
Имя процедуры должно быть повторено
Пример
PROCEDURE DrawDot (x, y: INTEGER);
BEGIN
END DrawDot;
Большие и малые буквы различаются
Пример "proc" не то же самое, что "Proc".
Синтаксис литерных цепочек
Литерные цепочки-константы заключаются между " или между '. В одной цепочке не может быть одновременно одиночных и двойных кавычек. Литерные цепочки-константы единичной длины могут присваиваться литерным переменным.
Пример
"That's great" 'Write "hello world" to the screen'
ch := "x"
ch := 'x'
Комментарии
Комментарии заключаются между (* и *) и могут быть вложены.
Скобки для множеств
Константы-множества задаются между { и } вместо [ и ].
Пример {0..2, 4, j..2 * k}
Синтаксис функций
Используйте ключевое слово PROCEDURE также и для функций вместо FUNCTION.
Процедуры, возвращающие значение, всегда должны иметь (возможно пустой) список параметров в своих объявлениях и в вызовах.
Результат функции возвращается явно оператором RETURN, вместо присваивания имени функции.
Пример
PROCEDURE Fun (): INTEGER;
BEGIN
RETURN 5
END Fun;
вместо
FUNCTION Fun: INTEGER;
BEGIN
Fun := 5
END;
n := Fun() вместо n := Fun
Объявления
Последовательность объявлений теперь имеет вид
{ ConstDecl | TypeDecl | VarDecl} {ProcDecl | ForwardDecl}
вместо
[ConstDecl] [TypeDecl] [VarDecl] {ProcDecl}.
Упреждающее (forward) объявление необходимо, если процедура используется до ее определения.
Пример
PROCEDURE ^ Proc;
вместо
PROCEDURE Proc; FORWARD;
Процедурные типы
Процедуры могут быть не только переданы в качестве параметров, но и присваиваться переменным процедурных типов.
Пример
TYPE P = PROCEDURE (x, y: INTEGER);
VAR v: P;
v := DrawDot; (* присваивание *)
v(3, 5); (* вызов DrawDot(3, 5) *)
Явные END вместо составных операторов
BEGIN может появляться только перед последовательностью операторов, но не внутри ее.
IF, WHILE и LOOP всегда заканчиваются ключевым словом END.
Оператор WITH
Оператор WITH является охраной типа, действующей в соответствующем программном фрагменте, он не подразумевает наличие скрытой переменной и не открывает новый диапазон видимости для переменных.
См. детали в описании языка.
ELSIF
Операторы IF могут иметь несколько ветвей.
Пример
IF name = "top" THEN
StdLog.Int(0)
ELSIF name = "bottom" THEN
StdLog.Int(1)
ELSIF name = " charm" THEN
StdLog.Int(2)
ELSIF name = "beauty" THEN
StdLog.Int(3)
ELSE
StdLog.String("strange")
END
BY вместо только DOWNTO в FOR
Циклы FOR могут использовать любое константное значение в качестве приращения (положительного или отрицательного).
Пример
FOR i := 15 TO 0 BY -1 DO StdLog.Int(i, 0) END
Логические выражения используют сокращенное вычисление
Вычисление логического выражения прекращается, как только его результат определен.
Пример
Следующее выражение не вызывает ошибки при выполнении, когда p = NIL:
IF (p # NIL) & (p.name = "quark") THEN
Константные выражения
В объявлениях констант допустимы не только буквальные константы, но и константные выражения.
Пример
CONST
zero = ORD("0");
one = zero + 1;
Разные операции
# используется вместо <> для проверки на неравенство.
& используется вместо AND для логической конъюнкции.
~ используется вместо NOT для логического отрицания.
Явное преобразование к меньшему типу с помощью SHORT
Включение типов для числовых типов позволяет присваивать значения меньшего типа переменной большего типа. Присваивание в обратном направлении должно использовать стандартную процедуру SHORT.
Пример
int := shortint;
shortint := SHORT(int)
Новые средства
Шестнадцатеричные числа и литеры
Пример
100H (* десятичное 256 *)
0DX (* возврат каретки *)
Дополнительные числовые типы
Добавлены типы LONGINT, SHORTINT, BYTE, SHORTREAL.
Симметрическая разность множеств
Множества могут вычитаться.
Новые стандартные процедуры
Добавлены новые стандартные процедуры INC, DEC, INCL, EXCL, SIZE, ASH, HALT, ASSERT, LEN, LSH, MAX, MIN, BITS, CAP, ENTIER, LONG и SHORT.
LOOP с EXIT
Имеется новый оператор цикла с явным операторов выхода. См. детали в сообщении о языке.
ARRAY OF CHAR могут сравниваться
Литерные массивы могут сравниваться с помощью операций =, #, <, >, <= и >=.
Открытые массивы, многомерные массивы
Можно определять массивы, не указывая их размера, возможно, с несколькими измерениями.
Пример
VAR a: POINTER TO ARRAY OF CHAR;
NEW(a, 16)
PROCEDURE ScalarProduct (a, b: ARRAY OF REAL; VAR c: ARRAY OF REAL);
TYPE Matrix = ARRAY OF ARRAY OF REAL;
PROCEDURE VectorProduct (a, b: ARRAY OF REAL; VAR c: Matrix);
Разыменование указателей не обязательно
Операция разыменования ^ может быть опущена.
Пример
root.next.value := 5
вместо
root^.next^.value := 5
Модули
Модули суть единицы компиляции, упрятывания информации, а также загрузки. Упрятывание информации -- одна из главных черт объектно-ориентированного программирования. Возможны разные уровни упрятывания информации: полное упрятывание, экспорт только для чтения/реализации, полный экспорт.
См. детали в сообщении о языке.
Расширенное переопределение (расширение) типов
Типы записей (указательные типы) могут переопределяться, обеспечивая таким образом полиморфизм. Полиморфизм -- одно из главных средств объектно-ориентированного программирования.
Методы
Процедуры могут быть связаны с типами записей (указательными типами), таким образом обеспечивая позднее связывание [late binding]. Позднее связывание является одним из главных средств объектно-ориентированного программирования. Такие процедуры еще называются методами.
Операция с цепочками литер
Литерная цепочка, содержащаяся в литерном массиве, может быть выбрана посредством селектора $.
Атрибуты записей
По умолчанию записи не могут быть расширены (переопределены), но могут быть помечены как EXTENSIBLE, ABSTRACT или LIMITED.
Атрибуты методов
По умолчанию методы не могут быть расширены (переопределены), но могут быть помечены как EXTENSIBLE, ABSTRACT или EMTPY. Вновь вводимые методы должны быть помечены как NEW.
| Docu/ru/Tut-B.odc |
Учебник по BlackBox
ENGLISH
Оглавление
Часть I: Подходы к проектированию
1Взаимодействиеспользователем
1.1 Дружественность к пользователю
1.2 Циклы обработки сообщений
1.3 Многопользовательский доступ
1.4 Настройки на разные языки пользователей
2Составныедокументы
2.1 Перманентность
2.2 Независимость от устройства отображения
2.3 Редактирование нескольких отображений
2.4 Распространение изменений
2.5 Вложенные отображения
2.6 Отложенное обновление
2.7 Режимы контейнера
2.8 Обработка событий
2.9 Элементы управления
3Приемыпроектирования
3.1 Языковая поддержка
3.2 Модули и подсистемы
3.3 Интерфейсы типа узкое горло
3.4 Создание объекта
Часть II: Библиотека
4Формы
4.1 Введение
4.2 Пример "Телефонная книга"
4.3 Интеракторы
4.4 Охранники
4.5 Уведомления
4.6 Стандартные элементы управления
4.7 Составные элементы управления и интеракторы
4.8 Контроль ввода
4.9 Прямой доступ к элементам управления
4.10 Резюме
5Тексты
5.1 Запись текста
5.2 Шаблон Модель-Отображение-Контроллер в применении к текстам
5.3 Чтение текста
5.4 Изменение текста
5.5 Текстовые сценарии
5.6 Резюме
Часть III: Конструирование отображений
6Конструированиеотображений
6.1 Введение
6.2 Обработка сообщений
6.3 Сообщения свойств по умолчанию
6.4 Управляющие сообщения
6.5 Свойства
6.6 Разделение модели и отображения
6.7 Операции
6.8 Разделение интерфейса и реализации
Приложение A:КраткаяисторияПаскаля
ПриложениеB:ОтличиеКомпонентногоПаскаляотПаскаля
| Docu/ru/Tut-TOC.odc |
FormCmds
DEFINITION FormCmds;
IMPORT Dialog;
VAR
grid: RECORD
resolution: INTEGER;
metricSystem: BOOLEAN
END;
PROCEDURE AlignLeft;
PROCEDURE AlignRight;
PROCEDURE AlignTop;
PROCEDURE AlignBottom;
PROCEDURE AlignToRow;
PROCEDURE AlignToColumn;
PROCEDURE InitGridDialog;
PROCEDURE SetGrid;
PROCEDURE SelectOffGridViews;
PROCEDURE ForceToGrid;
PROCEDURE SetAsFirst;
PROCEDURE SetAsLast;
PROCEDURE SortViews;
PROCEDURE InsertAround;
PROCEDURE FocusGuard (VAR par: Dialog.Par);
PROCEDURE SelectionGuard (VAR par: Dialog.Par);
PROCEDURE SingletonGuard (VAR par: Dialog.Par);
END FormCmds.
Command package for form views. Its main purpose is to support layout editing, through various alignment and grid control commands.
A possible menu using the above commands:
MENU "Layout" ("FormViews.View")
"Align &Left" "" "FormCmds.AlignLeft" "FormCmds.SelectionGuard"
"Align &Right" "" "FormCmds.AlignRight" "FormCmds.SelectionGuard"
"Align &Top" "" "FormCmds.AlignTop" "FormCmds.SelectionGuard"
"Align &Bottom" "" "FormCmds.AlignBottom" "FormCmds.SelectionGuard"
"Align To Ro&w" "" "FormCmds.AlignToRow" "FormCmds.SelectionGuard"
"Align To &Column" "" "FormCmds.AlignToColumn" "FormCmds.SelectionGuard"
SEPARATOR
"Set &Grid..." "" "FormCmds.InitGridDialog;
StdCmds.OpenToolDialog('Form/Rsrc/Cmds', 'Set Grid')"
"FormCmds.FocusGuard"
"&Select Off-Grid Views" "" "FormCmds.SelectOffGridViews" ""
"&Force To Grid" "" "FormCmds.ForceToGrid" "FormCmds.SelectionGuard"
SEPARATOR
"Set F&irst/Back" "" "FormCmds.SetAsFirst" "FormCmds.SingletonGuard"
"Set L&ast/Front" "" "FormCmds.SetAsLast" "FormCmds.SingletonGuard"
"Sort &Views" "" "FormCmds.SortViews" "FormCmds.FocusGuard"
SEPARATOR
"Insert Group Box" "" "FormCmds.InsertAround" "FormCmds.FocusGuard"
END
VAR grid: RECORD
Interactor for the grid dialog box (Form/Rsrc/Cmds).
resolution: INTEGER resolution > 0
If metricSystem, then resolution specifies how many grid positions exist for one millimeter.
If ~metricSystem, then resolution specifies how many grid positions exist for 1/16 inch.
A higher value means that higher precision is possible.
metricSystem: BOOLEAN
Determines whether the metric system (millimeters) is used or not (1/16 inches).
PROCEDURE AlignBottom
Guard: FormCmds.SelectionGuard
Move all selected views such that their bottom sides are aligned to the bottommost view in the selection.
PROCEDURE AlignLeft
Guard: FormCmds.SelectionGuard
Move all selected views such that their left sides are aligned to the leftmost view in the selection.
PROCEDURE AlignRight
Guard: FormCmds.SelectionGuard
Move all selected views such that their right sides are aligned to the rightmost view in the selection.
PROCEDURE AlignTop
Guard: FormCmds.SelectionGuard
Move all selected views such that their top sides are aligned to the topmost view in the selection.
PROCEDURE AlignBottom
Guard: FormCmds.SelectionGuard
Move all selected views such that their bottom sides are aligned to the bottommost view in the selection.
PROCEDURE AlignToRow
Guard: FormCmds.SelectionGuard
Move all selected views such that their vertical centers become aligned horizontally.
PROCEDURE AlignToColumn
Guard: FormCmds.SelectionGuard
Move all selected views such that their horizontal centers become aligned vertically.
PROCEDURE InitGridDialog
Guard: FormCmds.FocusGuard
Sets up grid.resolution and grid.metricSystem according to the values of the focus controller.
PROCEDURE SetGrid
Guard: FormCmds.FocusGuard
Sets the focus view's grid and gridFactor to the values determined by grid.resolution and grid.metricSystem.
PROCEDURE SelectOffGridViews
Guard: FormCmds.FocusGuard
Selects all views in the focus form whose top-left corners don't lie on the grid.
PROCEDURE ForceToGrid
Guard: FormCmds.FocusGuard
Moves all views in the focus form such that their top-left corners come to lie on the grid.
PROCEDURE SetAsFirst
Guard: FormCmds.SingletonGuard
Sets the selected view to the first position ("bottom").
PROCEDURE SetAsLast
Guard: FormCmds.SingletonGuard
Sets the selected view to the last position ("top").
PROCEDURE SortViews
Guard: FormCmds.FocusGuard
Sorts the back-to-front order of all views in a form such that they are geometrically sorted, i.e., a view whose upper edge is further up, or at the same hight but further to the left, is considered to come before ("lower") than the other one.
PROCEDURE InsertAround
Guard: FormCmds.SelectionGuard
Inserts a group box around the currently selected views.
PROCEDURE FocusGuard (VAR par: Dialog.Par)
This guard disables the current menu item if the current front focus isn't a form view.
PROCEDURE SelectionGuard (VAR par: Dialog.Par)
This guard disables the current menu item if the current front focus isn't a form view, or if it doesn't contain a selection.
PROCEDURE SingletonGuard (VAR par: Dialog.Par)
This guard disables the current menu item if the current front focus isn't a form view, or if it doesn't contain a singleton.
| Form/Docu/Cmds.odc |
FormControllers
DEFINITION FormControllers;
IMPORT Views, Controllers, Containers, FormModels, FormViews;
CONST noSelection = Containers.noSelection; noFocus = Containers.noFocus;
TYPE
Controller = POINTER TO ABSTRACT RECORD (Containers.Controller)
form-: FormModels.Model;
view-: FormViews.View;
(c: Controller) ThisView (): FormViews.View, EXTENSIBLE;
(c: Controller) Select (view: Views.View), NEW, ABSTRACT;
(c: Controller) Deselect (view: Views.View), NEW, ABSTRACT;
(c: Controller) IsSelected (view: Views.View): BOOLEAN, NEW, ABSTRACT;
(c: Controller) GetSelection (): List, NEW, ABSTRACT;
(c: Controller) SetSelection (l: List), NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD (Controllers.Directory)
(d: Directory) New (): Controller, EXTENSIBLE;
(d: Directory) NewController (opts: SET): Controller, ABSTRACT
END;
List = POINTER TO RECORD
next: List;
view: Views.View
END;
VAR dir-, stdDir-: Directory;
PROCEDURE Focus (): Controller;
PROCEDURE Insert (c: Controller; view: Views.View; l, t, r, b: INTEGER);
PROCEDURE SetDir (d: Directory);
PROCEDURE Install;
END FormControllers.
FormControllers are standard controllers for FormViews. Note that forms can only be used in a non-modal way, i.e., a program doesn't wait until the user is finished with the form. In other words: the user is in control, not the computer.
TYPE Controller (Containers.Controller)
ABSTRACT
Standard controllers for form views.
form-: FormModels.Model form # NIL
The controller's model.
view-: FormViews.View view # NIL & view.ThisModel() = form
The controller's view.
PROCEDURE (c: Controller) ThisView (): FormViews.View
EXTENSIBLE
Covariant narrowing of function result.
PROCEDURE (c: Controller) Select (view: Views.View)
NEW, ABSTRACT
Adds a view to the current selection, if it isn't selected already.
Pre
view in c.form 20
~(noSel IN c.opts) 21
Post
c.IsSelected(view)
c.ThisFocus() = NIL
PROCEDURE (c: Controller) Deselect (view: Views.View)
NEW, ABSTRACT
Removes a view from the current selection, if it is selected.
Pre
view in c.form 20
Post
~c.IsSelected(view)
PROCEDURE (c: Controller) IsSelected (view: Views.View): BOOLEAN
NEW, ABSTRACT
Determines whether the given view is currently selected or not. NIL is not considered selected.
Pre
view = NIL OR view in c.form 20
PROCEDURE (c: Controller) GetSelection (): List
NEW, ABSTRACT
Returns the list of selected subviews.
Post
all views of the result list are in c.form
PROCEDURE (c: Controller) SetSelection (l: List)
NEW, ABSTRACT
Removes the existing selection, and selects the subviews of l.
Pre
all views of l are in c.form 20
TYPE Directory
ABSTRACT
Directory for form view controllers.
PROCEDURE (d: Directory) New (): Controller
EXTENSIBLE
Covariant extension of Controllers.Directory.New.
PROCEDURE (d: Directory) NewController (opts: SET): Controller
ABSTRACT
Covariant extension of Controllers.Directory.NewController.
VAR dir-, stdDir-: Directory dir # NIL & stdDir # NIL
Controller directories.
PROCEDURE Focus (): Controller
Returns the focus controller, if the focus currently is a form view, otherwise it returns NIL.
PROCEDURE Insert (c: Controller; view: Views.View; l, t, r, b: INTEGER)
Inserts view into c's view at the position (l, t, r, b). If necessary, the position is slightly corrected (rounded) such that view's top-left corner comes to lie on the grid. The size of view is not changed, however.
PROCEDURE SetDir (d: Directory)
Set directory d.
Pre
d # NIL 20
Post
dir = d
PROCEDURE Install
Used internally.
| Form/Docu/Controllers.odc |
Form Subsystem
Developer Manual
See TutorialFormSubsystem
| Form/Docu/Dev-Man.odc |
FormGen
DEFINITION FormGen;
IMPORT Dialog;
VAR
new: RECORD
link: Dialog.String
END;
PROCEDURE Create;
PROCEDURE Empty;
PROCEDURE CreateGuard (VAR par: Dialog.Par);
END FormGen.
FormGen is a generator for a form layout. It takes the name of an interactor variable (any exported record) as input and creates a default layout for the fields of the interactor. The following list describes the mapping from field types to controls.
BYTE, SHORTINT, INTEGER Field
SHORTREAL, REAL Field
ARRAY OF CHAR Field
BOOLEAN CheckBox
Dates.Date DateField
Dates.Time TimeField
Dialog.Color ColorField
Dialog.Currency Field
Dialog.List ListBox
Dialog.Selection SelectionBox
Dialog.Combo ComboBox
Alternatively, a dialog for all interactors of a module can be generated, by entering the module name into the dialog box field. In this case, a group box is generated for every exported record variable, and a command button for every exported parameterless procedure.
A possible menu using the above commands:
MENU "Form"
"&New Form..." "" "StdCmds.OpenAuxDialog('Form/Rsrc/Gen', 'New Form')" ""
END
VAR new
Interactor for the form generator dialog.
link: Dialog.String
The name of the interactor for which a default layout should be generated. The name must be an identifier qualified with the module name, e.g., "FormGen.new", or only a module name, e.g., "FormGen".
PROCEDURE Create
Guard: CreateGuard
Create a default layout for the interactor specified in link.
PROCEDURE Empty
Create an empty form layout.
PROCEDURE CreateGuard
Guard for Create.
| Form/Docu/Gen.odc |
FormModels
DEFINITION FormModels;
IMPORT Ports, Models, Views, Containers;
CONST minView Size = 4 * Ports.point; maxViewSize = 1000 * Ports.mm;
TYPE
Model = POINTER TO ABSTRACT RECORD (Containers.Model)
(m: Model) Insert (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(m: Model) Delete (v: Views.View), NEW, ABSTRACT;
(m: Model) Resize (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(m: Model) PutAbove (v, pos: Views.View), NEW, ABSTRACT;
(m: Model) Move (v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(m: Model) Copy (VAR v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(m: Model) NewReader (old: Reader): Reader, NEW, ABSTRACT;
(m: Model) NewWriter (old: Writer): Writer, NEW, ABSTRACT;
(m: Model) ViewAt (x, y: INTEGER): Views.View, NEW, ABSTRACT;
(m: Model) NofViews (): INTEGER, NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD
(d: Directory) New (): Model, NEW, ABSTRACT
END;
Context = POINTER TO ABSTRACT RECORD (Models.Context)
(c: Context) ThisModel (): Model, ABSTRACT;
(c: Context) GetRect (OUT l, t, r, b: INTEGER), NEW, ABSTRACT
END;
Reader = POINTER TO ABSTRACT RECORD
view: Views.View;
l, t, r, b: INTEGER;
(r: Reader) Set (pos: Views.View), NEW, ABSTRACT;
(r: Reader) ReadView (OUT v: Views.View), NEW, ABSTRACT
END;
Writer = POINTER TO ABSTRACT RECORD
(w: Writer) Set (pos: Views.View), NEW, ABSTRACT;
(w: Writer) WriteView (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT
END;
UpdateMsg = RECORD (Models.UpdateMsg)
l, t, r, b: INTEGER
END;
VAR dir-, stdDir-: Directory;
PROCEDURE New (): Model;
PROCEDURE CloneOf (source: Model): Model;
PROCEDURE Copy (source: Model): Model;
PROCEDURE SetDir (d: Directory);
END FormModels.
FormModels are container models which contain views. They have no further intrinsic contents. Form models can be used to arrange rectangular views in arbitrary layouts. Their main use is as data entry forms and as dialog box layouts.
CONST minViewSize
This is the minimal width and height of a view which is embedded in a form model.
CONST maxViewSize
This is the maximal width and height of a view which is embedded in a form model.
TYPE Model (Containers.Model)
ABSTRACT
Form models are container models (-> Containers), which may contain rectangular views and nothing else.
PROCEDURE (m: Model) Insert (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT, Operation
Insert view v with bounding box (l, t, r, b).
Pre
v # NIL 20
v.context = NIL 22
l <= r 23
t <= b 24
Post
v in m
v.context # NIL & v.context.ThisModel() = m
PROCEDURE (m: Model) Delete (v: Views.View)
NEW, ABSTRACT, Operation
Remove v from m.
Pre
v in m 20
Post
~(v in m)
PROCEDURE (m: Model) Resize (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT, Operation
Redefine bounding box of v.
Pre
v in m 20
l <= r 21
t <= b 22
PROCEDURE (m: Model) PutAbove (v, pos: Views.View)
NEW, ABSTRACT, Operation
Change the vertical order of view v, such that it comes to lie directly above p if pos # NIL, otherwise it is put to the bottom of the view list.
Pre
v in m 20
pos = NIL OR pos in m 21
PROCEDURE (m: Model) Move (v: Views.View; dx, dy: INTEGER)
NEW, ABSTRACT, Operation
Move view v by (dx, dy), without changing its size.
Pre
v in m 20
PROCEDURE (m: Model) Copy (VAR v: Views.View; dx, dy: INTEGER)
NEW, ABSTRACT, Operation
Create a copy of v and put it at v's bounding box shifted by (dx, dy). Parameter v returns the copy.
Pre
v # NIL 20
v.context # NIL 21
v.context.ThisModel() = m 22
Post
v # NIL & v # v'
PROCEDURE (m: Model) NewReader (old: Reader): Reader
NEW, ABSTRACT
Returns a reader connected to m. An old reader may be passed as input parameter, if it isn't in use anymore.
Post
result # NIL
PROCEDURE (m: Model) NewWriter (old: Writer): Writer
NEW, ABSTRACT
Returns a writer connected to m. An old writer may be passed as input parameter, if it isn't in use anymore.
Post
result # NIL
PROCEDURE (m: Model) ViewAt (x, y: INTEGER): Views.View
NEW, ABSTRACT
Returns the topmost view in m which encloses position (x, y).
Post
result # NIL
where (l, t, r, b) is the bounding box of v: (l <= x <= r) & (t <= y <= b)
result = NIL
no view at (x, y)
PROCEDURE (m: Model) NofViews (): INTEGER
NEW, ABSTRACT
Returns the number of views currently in m.
Post
result >= 0
TYPE Directory
ABSTRACT
Directory for the allocation of concrete form models.
PROCEDURE (d: Directory) New (): Model
NEW, ABSTRACT
Create and return a new concrete form model.
Post
result # NIL
TYPE Context (Models.Context)
NEW, ABSTRACT
Context of a view in a form.
PROCEDURE (c: Context) ThisModel (): Model
ABSTRACT
Returns the form which contains the context. Covariant narrowing of result type.
PROCEDURE (c: Context) GetRect (OUT l, t, r, b: INTEGER)
NEW, ABSTRACT
Returns the bounding box of the context's view.
Post
l < r & t < b
TYPE Reader
ABSTRACT
Input rider on a form model.
view: Views.View
Most recently read view.
l, t, r, b: INTEGER view # NIL => l < r & t < b
Bounding box of most recently read view.
PROCEDURE (r: Reader) Set (pos: Views.View)
NEW, ABSTRACT
Set position of reader r to the view above pos (i.e., the next view to be read will be the one directly above pos) or to the bottom if pos = NIL.
Pre
pos in Base(r) OR pos = NIL 20
PROCEDURE (r: Reader) ReadView (OUT v: Views.View)
NEW, ABSTRACT
Reads the next view, in ascending order. If there is none, v is set to NIL. The reader's view and l, t, r, b fields will be set accordingly (l, t, r, b are undefined if view is NIL).
Post
v = r.view
TYPE Writer
ABSTRACT
Output rider on a form.
PROCEDURE (w: Writer) Set (pos: Views.View)
Interface
Set position of writer w to the view above pos (i.e., the next view to be written will be inserted directly above pos) or to the bottom if pos = NIL.
Pre
pos in Base(r) OR pos = NIL 20
PROCEDURE (w: Writer) WriteView (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT
Insert view v at the current position in w's form.
Pre
v # NIL 20
v.context = NIL 22
l <= r 23
t <= b 24
Post
v.context # NIL
TYPE UpdateMsg
This message indicates that a rectangular part of a form needs to be updated on the screen.
The receiver must not switch on any marks as a reaction to having received this message.
UpdateMsgs are sent by concrete form model implementations after any view modifications.
UpdateMsgs are not extended.
VAR dir-, stdDir-: Directory; dir # NIL & stdDir # NIL
Form model directories.
PROCEDURE New (): Model
Returns a new model. Equivalent to dir.New().
Post
result # NIL
PROCEDURE CloneOf (source: Model): Model
Returns a new empty model of the same type as source.
Pre
source # NIL 20
Post
result # NIL
PROCEDURE Copy (source: Model): Model
Returns a new model of the same type as source, with a copy of the contents of source.
Pre
source # NIL 20
Post
result # NIL
PROCEDURE SetDir (d: Directory)
Assign directory.
Pre
d # NIL 20
Post
dir = d
| Form/Docu/Models.odc |
Map to the Form Subsystem
UserManual
FormCmds form command package
FormGen creation of default layout
FormControllers form controllers
FormViews form views
FormModels form models
| Form/Docu/Sys-Map.odc |
Form Subsystem
User Manual
Contents
1CreatingandSavingForms
2BasicEditing
3NavigationKeys
4Drag&Drop
5Drag&Pick
6LayoutandMaskModes
7ControlsandInteractors
8ControlProperties
The form subsystem implements a simple form editor, which can be used to create dialog boxes or data entry masks.
1 Creating and Saving Forms
The command Controls->NewForm... creates dialog boxes and other forms that match exported global variables. All such forms are nonђmodal. Almost all dialog boxes in BlackBox are nonђmodal, as long as the conventions for the underlying platform permit.
To get started, enter "TextCmds.find" into the Link field of the Controls->NewForm... dialog box. By clicking the default button, a dialog box is automatically created which has fields Find and Replace, and buttons like Find Next and Replace All. These fields and buttons directly match the record fields of variable find in module TextCmds. To verify this, select the string "TextCmds.find", and execute command Info->Interface. The browser will display the definition of the record type.
The size of a form view can be adjusted by selecting the whole document (Edit->SelectDocument) and then dragging the graphical handles.
The dialog box created by Controls->NewForm... exhibits a simple default arrangement of controls (e.g., buttons, edit fields), shown as an editable layout. The controls may be re-arranged, renamed, or otherwise modified using the menus Layout and Controls. The former menu appears automatically whenever a form becomes focused.
Instead of creating an initial layout out of an existing global variable, form creation may start with an empty form (click on the NewForm dialog box's Empty button), and then successively insert new controls via the Controls menu. Later, such controls may be linked to suitable global variables.
An edited dialog box can be saved by saving the window of the form layout. The BlackBox Component Framework saves dialog boxes in the standard document format. By convention, BlackBox forms are saved in the appropriate Rsrc directory (-> Subsystems and Global Modules). For example, the standard Text->Find&Replace dialog box is stored in Text/Rsrc/Find.
2 Basic Editing
A view can be inserted into a form layout by invoking one of the Insert Xyz commands of menu Controls, e.g., the command Controls->Insert Command Button. Arbitrary other views could also be inserted, or copied from the clipboard or via drag & drop.
Views in a form can be selected. If one single view is selected ( a "singleton"), it shows resize handles that can be manipulated to change the view's size. If several views are selected, they show a selection mark like singletons do, but no resize handles.
A view can be selected either by clicking in it, or by dragging over an area which intersects the view(s). If the shift key is pressed during selection, the newly touched view(s) are toggled, i.e., a selected view is deselected and vice versa. If the shift key is not pressed during selection, any existing selection is removed prior to creating the new selection. Consequently, a simple click outside of any view removes the existing selection and does not create a new one. Pressing esc achieves the same effect.
Some attributes of selected views can be modified using the Attributes menu (and the Fonts menu under the Mac OS). In this way, the typeface, style, and size of the labels of many controls can be changed.
The command Controls->Insert Group Box works like the other insert commands, with one exception: if there is a selection, the group box is placed and sized such that it forms a bounding box around the selected views.
Mac OS:
Changing the size of a control's label has no effect, it always remains 12 point.
A selection can be cut, copied, and pasted using the clipboard. It can be deleted with the backspace or delete keys.
Menu Layout contains a variety of commands which are useful for editing a form layout. The Align Left, Align Right, Align Top, and Align Bottom commands align the left, right, top, or bottom borders of all selected views. Alignment occurs to the view which lies furthest in the alignment direction. For example, Align Left finds the selected view whose left border lies furthest left, and then moves all other views (without resizing them) so that their left borders are aligned to the same x-coordinate.
Align To Row aligns all selected views in vertical direction, so that all their vertical centers come to lie on the same y-coordinate, which is the average of the old y-coordinates. Similarly, Align To Column aligns all selected view in the horizontal direction, so that they form a single column.
The dialog box Set Grid... allows to set the grid. Most commands which move or resize a view round the view's borders to this grid. The dialog box allows you to choose between a grid based on millimeters or on 1/16 inches. The grid resolution allows you to specify how many grid values exist for these units (for one millimeter, or for one sixteenth of an inch). A higher value means preciser placement is possible. Roughly every centimeter or half an inch, dotted lines are drawn on the grid, as visual aids for editing.
Select Off-Grid Views selects all views of which at least one of its four borders is not aligned to the form's grid. Force To Grid shifts and resizes them by a minimal distance so that they are aligned again.
Conceptually the views are arranged in z-order, i.e., each view is either "above" or "below" another view. Normally, views in a form should not overlap, and thus this z-ordering has no immediate effect. But the same ordering is used for moving the focus between controls, by using the tab key. The focus is moved from the bottom-most towards the top-most view when tabbing through a dialog box. The commands Set First/Back and Set Last/Front allow to change the z-order of a selected singleton. Sort Views sorts the z-orders of all views in a form such that a view further to the left and top is reached before another view (which is further "up" in the hierarchy). This command can be applied after a layout has been edited, to update the z-order to make it intuitive again.
Recalc Focus Size operates on a focused form layout view. It calculates the bounding box of the views which are contained in the form, offsets this bounding box by a small margin, and then sets the form view's width and height to this size. This is more convenient than using Edit->SelectDocument and then resizing the view manually.
The commands Set Default Button and Set Cancel Button make a selected button into a default or a cancel button. A default button reacts to the input of a return or enter key as if the mouse had been pressed inside; a cancel button reacts to the input of an esc key as if the mouse had been pressed inside.
Like other views that have separate models, a form view can be opened in several windows simultaneously.
3 Navigation Keys
Arrow keys can be used to move a selection to the left, right, upwards, or downwards by one point. If the modifier key is pressed before the arrow key, the selection moves by a larger distance.
4 Drag & Drop
When clicking into a selection, and moving the cursor around, the selected views can be moved around accordingly. Moving occurs on a grid, the minimal distance is the same as when using the modifier key together with an arrow key.
By holding down the modifier key when the mouse button is released at the end of dragging, copies of the selected views are dropped, and become selected.
Drag & Drop also works across windows, and even between different containers. If a singleton is dragged & dropped into another kind of container (e.g., a text container), then a copy of this view is dropped. If a whole selection is dropped, the selected views are wrapped into a form view and this form view is dropped to the other container.
5 Drag & Pick
Drag & Pick is also supported in forms. In forms, another view's size can be picked up. This is very convenient for layout editing. For example, select several controls which have different sizes, hold down the alt key (Windows) / command key (Mac OS), and then drag to another view. When you release the mouse over this view, all selected views will be made the same size as this one.
6 Layout and Mask Modes
Forms can be used in two different modes. Normally, a form is used in layout mode, i.e. its layout can be freely edited. The views (typically controls) embedded in a form however, cannot be edited directly, because they can only be selected, but not focused. For layout editing, it would be very inconvenient if a click in one of the form's controls would focus it, instead of only selecting it. Forms are saved in layout mode, and opened in document windows.
For using a form as a dialog box or data entry mask, a form can be opened in mask mode instead, in an auxiliary window (data entry mask) or in a tool window (dialog box for the manipulation of a document beneath the dialog box). A form in mask mode cannot be modified. However, its embedded views may be focused, e.g. a text entry field may be focused, or a button may be clicked. In contrast to layout mode, embedded views cannot be selected, resized, or moved around.
In mask mode, no focus border is shown around the currently focused view. In layout mode, a grid is shown.
When a form in layout mode is focus, another window can be opened in mask mode, by using either Controls->Open As Tool Dialog or Controls->Open As Aux Dialog. In this way, a form can be tried out while it is still being edited. Layout changes in the layout mode form are immediately reflected in the other window, and input in the other window is immediately reflected in the layout.
Forms need not be saved in mask mode. They are saved in layout mode, and thus can be opened, edited, and saved again via the normal File menu commands. A data entry mask is opened via the StdCmds.OpenAuxDialog command; and a dialog box is opened via the StdCmds.OpenToolDialog command. These commands open a form document into an auxiliary/tool window and force it into mask mode. For example, the following commands show the difference between the two modes by opening the same (layout mode) form in the two possible ways:
"StdCmds.OpenAuxDialog('Form/Rsrc/Gen', 'New Form')"
"StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Find & Replace')"
"StdCmds.OpenDoc('Form/Rsrc/Gen')"
"StdCmds.OpenDoc('Text/Rsrc/Cmds')"
The latter two commands correspond to the File->Open command and allow editing.
The difference between auxiliary and tool dialog boxes is that auxiliary dialog boxes are self-contained, e.g. dialog boxes to set up configuration parameters or data entry masks. Tool dialog boxes on the other hand operate on windows below them, e.g. the Find&Replace dialog box operates on the text beneath the dialog box.
These OpenAuxDialog/OpenToolDialog commands accept portable path names as input. A portable path name is a string which denotes a file in a machine-independent way. It uses the "/" character as separator, i.e. like in Unix or the World-Wide Web.
These commands are usually applied in menu items, for example the following command sequence:
"TextCmds.InitFindDialog; StdCmds.OpenToolDialog('Text/Rsrc/Find', 'Find & Replace')"
In this command sequence, the first command initializes the TextCmds.find interactor with the currently selected text stretch. The second command opens a dialog box with the Text/Rsrc/Find file's form, whose controls are linked to the interactor's fields upon opening of the dialog box.
See also modules FormGen, TextCmds, and StdCmds.
7 Controls and Interactors
Controls are specialized views. Like every view, any control can be inserted into any general container, be it a text, a spreadsheet, or whatever other container is available. However, most controls are put into forms.
Each control can be linked to a variable, more exactly to the field of a globally declared record variable, a so-called interactor. When the control is allocated (newly created or read from a document), BlackBox tries to link the control to its variable, using the advanced metaprogramming capabilities of the BlackBox Component Framework core. In this way, the link between control and variable can be built up automatically when a dialog box is created or loaded, and correct linking (which includes correct typing) can be guaranteed even after a dialog box layout had been edited. The separation of interactor from controls makes it possible to hide many user-interface details from a program, e.g. the layout of a dialog box or other "cosmetic" properties of controls.
The BlackBox Component Framework provides command buttons, check boxes, radio buttons, fields, captions, list boxes, selection boxes, combo boxes, date, time, color, up/down fields, and groups as standard controls.
8 Control Properties
Controls have various properties, e.g. the label displayed in a button, or the interactor field to which the control is linked. The inspector is a tool used to inspect and to modify the properties of standard controls. To open the inspector dialog box on a control, first select the control, and then execute Edit->ObjectProperties... (Windows) / Edit->PartInfo (Mac OS).
To learn more about the inspector, see the documentation for module DevInspector.
For more information on the Form subsystem's programming interface, consult the on-line documentation of the modules FormModels, FormViews, FormControllers, FormGen, FormCmds, and Controls. Note that most of these modules are distributed in source form also, and thus serve as an example of a complex subsystem. Simpler examples are given in the Obx subsystem, in particular the examples ObxAddress0, ObxAddress1, ObxAddress2, ObxOrders, ObxControls, and ObxDialog. A tutorial on the form subsystem is given in Chapter4 of the accompanying book on component software and the BlackBox Component Framework.
| Form/Docu/User-Man.odc |
FormViews
DEFINITION FormViews;
IMPORT Ports, Views, Controllers, Containers, FormModels;
CONST minBorder = 4 * Ports.point; maxBorder = 100 * Ports.mm;
TYPE
View = POINTER TO ABSTRACT RECORD (Containers.View)
(v: View) ThisModel (): FormModels.Model, EXTENSIBLE;
(v: View) SetBorder (border: INTEGER), NEW, ABSTRACT;
(v: View) Border (): INTEGER, NEW, ABSTRACT;
(v: View) SetGrid (grid, gridFactor: INTEGER), NEW, ABSTRACT;
(v: View) Grid (): INTEGER, NEW, ABSTRACT;
(v: View) GridFactor (): INTEGER, NEW, ABSTRACT;
(v: View) SetBackground (background: Ports.Color), NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD
(d: Directory) New (f: FormModels.Model): View, NEW, ABSTRACT
END;
VAR
dir-, stdDir-: Directory;
ctrldir-: Controllers.Directory;
PROCEDURE Focus (): View;
PROCEDURE FocusModel (): FormModels.Model;
PROCEDURE RoundToGrid (v: View; VAR x, y: INTEGER);
PROCEDURE New (): View;
PROCEDURE Deposit;
PROCEDURE SetDir (d: Directory);
PROCEDURE SetCtrlDir (d: Containers.Directory);
END FormViews.
FormViews are the standard views on FormModels.
CONST minBorder, maxBorder
The border of a form view is the minimal distance between any of the view borders and the bounding box of the embedded views. The preferred border can be set to a value in the range [minBorder .. maxBorder].
TYPE View (Views.View)
ABSTRACT
PROCEDURE (v: View) ThisModel (): FormModels.Model
EXTENSIBLE
Result type is narrowed.
PROCEDURE (v: View) SetBorder (border: INTEGER)
NEW, ABSTRACT, Operation
Sets the view's preferred border (preferred minimal distance between any view edge and the closest embedded view).
Pre
border >= 0 20
Post
border < minBoder
v.border = minBorder
border > maxBorder
v.border = maxBorder
minBorder <= border <= maxBorder
v.border = border
PROCEDURE (v: View) Border (): INTEGER
NEW, ABSTRACT
Returns the view's border.
Post
minBorder <= result <= maxBorder
PROCEDURE (v: View) SetGrid (grid, gridFactor: INTEGER)
NEW, ABSTRACT, Operation
Sets the view's preferred grid (preferred grid on which any embedded view's top-left corner should be aligned) and grid factor (when the grid is shown, every gridFactor-th grid unit a dotted line is displayed).
Pre
grid > 0 20
gridFactor > 0 21
Post
v.Grid() = grid & v.GridFactor() = gridFactor
PROCEDURE (v: View) Grid (): INTEGER
NEW, ABSTRACT
Returns the current grid.
Post
result > 0
PROCEDURE (v: View) GridFactor (): INTEGER
NEW, ABSTRACT
Returns the current grid factor.
Post
result > 0
PROCEDURE (v: View) SetBackground (background: Ports.Color)
NEW, ABSTRACT
Sets a form's background color. Default is Ports.dialogBackground.
TYPE Directory
ABSTRACT
Directory for form views.
PROCEDURE (d: Directory) New (m: FormModels.Model): View
Interface
Return a new view on m
Pre
m # NIL 20
Post
result # NIL
result.ThisModel() = m
VAR dir, stdDir-: Directory dir # NIL & stdDir # NIL
Directory and standard directory for form views.
VAR ctrldir-: Controllers.Directory ctrldir # NIL
Form controller directory, installed by module FormControllers upon loading.
PROCEDURE Focus (): View
Returns the focus form view, if it is one.
PROCEDURE FocusModel (): FormModels.Model
Returns the model of the focus form view, if it is one.
PROCEDURE RoundToGrid (v: View; VAR x, y: INTEGER)
Rounds the coordinate (x, y) to the closest point on v's grid.
Pre
v # NIL 20
x > 0 & y > 0 21
Post
x MOD v.grid = 0
y MOD v.grid = 0
PROCEDURE New (): View
Returns a new form view with a new empty form model, i.e., returns FormViews.dir.New(FormModels.dir.New()).
PROCEDURE Deposit
Deposit creates a new form view with a new empty form model and deposits the view.
Deposit is called internally.
PROCEDURE SetDir (d: Directory)
Assigns view directory.
Pre
d # NIL 20
Post
dir = d
PROCEDURE SetCtrlDir (d: Containers.Directory)
Assigns the controller directory for form views.
Pre
d # NIL 20
| Form/Docu/Views.odc |
FormCmds
DEFINITION FormCmds;
IMPORT Dialog;
VAR
grid: RECORD
resolution: INTEGER;
metricSystem: BOOLEAN
END;
PROCEDURE AlignLeft;
PROCEDURE AlignRight;
PROCEDURE AlignTop;
PROCEDURE AlignBottom;
PROCEDURE AlignToRow;
PROCEDURE AlignToColumn;
PROCEDURE InitGridDialog;
PROCEDURE SetGrid;
PROCEDURE SelectOffGridViews;
PROCEDURE ForceToGrid;
PROCEDURE SetAsFirst;
PROCEDURE SetAsLast;
PROCEDURE SortViews;
PROCEDURE InsertAround;
PROCEDURE FocusGuard (VAR par: Dialog.Par);
PROCEDURE SelectionGuard (VAR par: Dialog.Par);
PROCEDURE SingletonGuard (VAR par: Dialog.Par);
END FormCmds.
Пакет команд для отображений форм. Его главное назначение - поддержка редактирования расположения (отображений на форме) посредством различных команд выравнивания и управления сеткой.
Можно создать следующее меню с использованием этих команд:
MENU "Layout" ("FormViews.View")
"Align &Left" "" "FormCmds.AlignLeft" "FormCmds.SelectionGuard"
"Align &Right" "" "FormCmds.AlignRight" "FormCmds.SelectionGuard"
"Align &Top" "" "FormCmds.AlignTop" "FormCmds.SelectionGuard"
"Align &Bottom" "" "FormCmds.AlignBottom" "FormCmds.SelectionGuard"
"Align To Ro&w" "" "FormCmds.AlignToRow" "FormCmds.SelectionGuard"
"Align To &Column" "" "FormCmds.AlignToColumn" "FormCmds.SelectionGuard"
SEPARATOR
"Set &Grid..." "" "FormCmds.InitGridDialog;
StdCmds.OpenToolDialog('Form/Rsrc/Cmds', 'Set Grid')"
"FormCmds.FocusGuard"
"&Select Off-Grid Views" "" "FormCmds.SelectOffGridViews" ""
"&Force To Grid" "" "FormCmds.ForceToGrid" "FormCmds.SelectionGuard"
SEPARATOR
"Set F&irst/Back" "" "FormCmds.SetAsFirst" "FormCmds.SingletonGuard"
"Set L&ast/Front" "" "FormCmds.SetAsLast" "FormCmds.SingletonGuard"
"Sort &Views" "" "FormCmds.SortViews" "FormCmds.FocusGuard"
SEPARATOR
"Insert Group Box" "" "FormCmds.InsertAround" "FormCmds.FocusGuard"
END
VAR grid: RECORD
Интерактор для диалогового окна сетки (Form/Rsrc/Cmds).
resolution: INTEGER resolution > 0
Если metricSystem, тогда resolution указывает число линий сетки в одном миллиметре. Если ~metricSystem, тогда resolution указывает число линий сетки в 1/16 дюйма. Чем больше значение, тем выше возможная точность.
metricSystem: BOOLEAN
Определяет, будет ли использоваться метрическая система (миллиметры) или нет (1/16-ые дюймов).
PROCEDURE AlignLeft
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их левые границы будут выравнены по границе самого левого отображения в выделении.
PROCEDURE AlignRight
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их правые границы будут выравнены по границе самого правого отображения в выделении.
PROCEDURE AlignTop
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их врехние границы будут выравнены по границе самого верхнего отображения в выделении.
PROCEDURE AlignBottom
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их нижние границы будут выравнены по границе самого нижнего отображения в выделении.
PROCEDURE AlignToRow
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их вертикальные центры выравниваются по горизонтали.
PROCEDURE AlignToColumn
Охрана: FormCmds.SelectionGuard
Перемещает все выделенные отображения таким образом, что их горизонтальные центры выравниваются по вертикали.
PROCEDURE InitGridDialog
Охрана: FormCmds.FocusGuard
Устанавливает значения полей grid.resolution и grid.metricSystem в соответствии со значениями диспетчера (т. е. отображения, с которым он связан), обладающего фокусом.
PROCEDURE SetGrid
Охрана: FormCmds.FocusGuard
Устанавливает значения grid и gridFactor в сфокусированном отображении равными значениям grid.resolution и grid.metricSystem.
PROCEDURE SelectOffGridViews
Охрана: FormCmds.FocusGuard
Выделяет все отображения на сфокусированной форме, левые верхние углы которых не лежат на сетке.
PROCEDURE ForceToGrid
Охрана: FormCmds.FocusGuard
Перемещает все отображения на сфокусированной форме таким образом, чтобы их левые верхние углы оказались на сетке.
PROCEDURE SetAsFirst
Охрана: FormCmds.SingletonGuard
Помещает выделенное отображение на первую позицию (на задний план - под всеми).
PROCEDURE SetAsLast
Охрана: FormCmds.SingletonGuard
Помещает выделенное отображение на последнюю позицию (на передний план - над всеми).
PROCEDURE SortViews
Охрана: FormCmds.FocusGuard
Сортирует порядок расположения (над/под) отображений на форме согласно их геометрическому расположению, т. е., отображение, верхняя граница которого выше, или на том же уровне, но левая левее, располагается перед другим (под ним).
PROCEDURE InsertAround
Охрана: FormCmds.SelectionGuard
Вставляет рамку (GroupBox) т. о., чтобы она окружала все выделенные отображения.
PROCEDURE FocusGuard (VAR par: Dialog.Par)
Охранник, делающий недоступным элемент меню, если передним фокусом не обладает отображение формы.
PROCEDURE SelectionGuard (VAR par: Dialog.Par)
Охранник, делающий недоступным элемент меню, если передним фокусом не обладает отображение формы, или на форме отсутствует выделение.
PROCEDURE SingletonGuard (VAR par: Dialog.Par)
Охранник, делающий недоступным элемент меню, если передним фокусом не обладает отображение формы, или на форме нет синглетона (выделения, содержащего одиночное отображение).
| Form/Docu/ru/Cmds.odc |
FormControllers
DEFINITION FormControllers;
IMPORT Views, Controllers, Containers, FormModels, FormViews;
CONST noSelection = Containers.noSelection; noFocus = Containers.noFocus;
TYPE
Controller = POINTER TO ABSTRACT RECORD (Containers.Controller)
form-: FormModels.Model;
view-: FormViews.View;
(c: Controller) ThisView (): FormViews.View, EXTENSIBLE;
(c: Controller) Select (view: Views.View), NEW, ABSTRACT;
(c: Controller) Deselect (view: Views.View), NEW, ABSTRACT;
(c: Controller) IsSelected (view: Views.View): BOOLEAN, NEW, ABSTRACT;
(c: Controller) GetSelection (): List, NEW, ABSTRACT;
(c: Controller) SetSelection (l: List), NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD (Controllers.Directory)
(d: Directory) New (): Controller, EXTENSIBLE;
(d: Directory) NewController (opts: SET): Controller, ABSTRACT
END;
List = POINTER TO RECORD
next: List;
view: Views.View
END;
VAR dir-, stdDir-: Directory;
PROCEDURE Focus (): Controller;
PROCEDURE Insert (c: Controller; view: Views.View; l, t, r, b: INTEGER);
PROCEDURE SetDir (d: Directory);
PROCEDURE Install;
END FormControllers.
Модуль FormControllers содержит стандартные диспетчеры для отображений форм из FormViews. Заметьте, что формы могут быть только немодальными, т. е. программа не будет ждать, пока пользователь закончит работать с формой. Говоря другими словами: управляет пользователь, а не компьютер.
TYPE Controller (Containers.Controller)
ABSTRACT
Стандартные диспетчеры для отображений форм.
form-: FormModels.Model form # NIL
Модель отображения формы, с которым связан диспетчер.
view-: FormViews.View view # NIL & view.ThisModel() = form
Отображение формы, с которым связан диспетчер.
PROCEDURE (c: Controller) ThisView (): FormViews.View
EXTENSIBLE
Ковариант, с соответствующим результатом функции.
PROCEDURE (c: Controller) Select (view: Views.View)
NEW, ABSTRACT
Добавляет отображение в текущее выделение, если оно ещё не выделено.
Предусловия
view in c.form 20
~(noSel IN c.opts) 21
Постусловия
c.IsSelected(view)
c.ThisFocus() = NIL
PROCEDURE (c: Controller) Deselect (view: Views.View)
NEW, ABSTRACT
Удаляет отображение из текущего выделения, если оно выделено.
Предусловия
view in c.form 20
Постусловия
~c.IsSelected(view)
PROCEDURE (c: Controller) IsSelected (view: Views.View): BOOLEAN
NEW, ABSTRACT
Определяет, выделено или нет данное отображение.
Предусловия
view # NIL 20
view in c.form 21
PROCEDURE (c: Controller) GetSelection (): List
NEW, ABSTRACT
Возвращает список выделенных отображений.
Постусловия
все отображения в списке принадлежат модели c.form
PROCEDURE (c: Controller) SetSelection (l: List)
NEW, ABSTRACT
Снимает текущее выделение и выделяет отображения из данного списка l.
Предусловия
все отображения в l принадлежат модели c.form 20
TYPE Directory
ABSTRACT
Фабрика диспетчеров форм.
PROCEDURE (d: Directory) New (): Controller
EXTENSIBLE
Ковариантное расширение Controllers.Directory.New.
PROCEDURE (d: Directory) NewController (opts: SET): Controller
ABSTRACT
Ковариантное расширение Controllers.Directory.NewController.
VAR dir-, stdDir-: Directory dir # NIL & stdDir # NIL
Фабрика и стандартная фабрика диспетчеров форм.
PROCEDURE Focus (): Controller
Если отображение формы обладает фокусом, возвращает его диспетчер, иначе возвращает NIL.
PROCEDURE Insert (c: Controller; view: Views.View; l, t, r, b: INTEGER)
Вставляет отображение view в отображение формы диспетчера c c ограничивающим прямоугольником (l, t, r, b). При необходимости, положение слегка корректируется (округляется) таким образом, чтобы его верхний левый угол лежал на сетке. Оданко размер view при этом не меняется.
PROCEDURE SetDir (d: Directory)
Установка фабрики диспетчеров форм.
Предусловия
d # NIL 20
Постусловия
dir = d
PROCEDURE Install
Используется внутренне.
| Form/Docu/ru/Controllers.odc |
Подсистема Form
Руководство разработчика
См. руководствопоподсистемеForm в учебнике по Блэкбокс. | Form/Docu/ru/Dev-Man.odc |
FormGen
DEFINITION FormGen;
IMPORT Dialog;
VAR
new: RECORD
link: Dialog.String
END;
PROCEDURE Create;
PROCEDURE Empty;
PROCEDURE CreateGuard (VAR par: Dialog.Par);
END FormGen.
Модуль FormGen - автоматический генератор форм. В качестве входного параметра он получает имя переменной-интерактора и создает форму, на которой размещаются элементы управления для полей интерактора. Ниже следует список соответствия между типами полей и элементами управления.
BYTE, SHORTINT, INTEGER Field
SHORTREAL, REAL Field
ARRAY OF CHAR Field
BOOLEAN CheckBox
Dates.Date DateField
Dates.Time TimeField
Dialog.Color ColorField
Dialog.Currency Field
Dialog.List ListBox
Dialog.Selection SelectionBox
Dialog.Combo ComboBox
Также может быть создана форма для всех интеракторов модуля, если в поле диалога вводится его имя. В этом случае, для каждой экспортированной переменой типа запись создается рамка (GroupBox), и для каждой процедуры без параметров - кнопка (CommandButton).
Для команд модуля FormGen можно создать следующее меню:
MENU "Form"
"&New Form..." "" "StdCmds.OpenAuxDialog('Form/Rsrc/Gen', 'New Form')" ""
END
VAR new
Интерактор для диалога создания формы.
link: Dialog.String
Имя интерактора, для которого будет создана форма. Имя должно быть уточненным идентификатором, например, "FormGen.new", или просто именем модуля, например, "FormGen".
PROCEDURE Create
Охрана: CreateGuard
Создает форму для интерактора, указанного в поле link.
PROCEDURE Empty
Создает пустую форму.
PROCEDURE CreateGuard
Охрана для Create.
| Form/Docu/ru/Gen.odc |
FormModels
DEFINITION FormModels;
IMPORT Ports, Models, Views, Containers;
CONST minView Size = 4 * Ports.point; maxViewSize = 1000 * Ports.mm;
TYPE
Model = POINTER TO ABSTRACT RECORD (Containers.Model)
(m: Model) Insert (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(m: Model) Delete (v: Views.View), NEW, ABSTRACT;
(m: Model) Resize (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(m: Model) PutAbove (v, pos: Views.View), NEW, ABSTRACT;
(m: Model) Move (v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(m: Model) Copy (VAR v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(m: Model) NewReader (old: Reader): Reader, NEW, ABSTRACT;
(m: Model) NewWriter (old: Writer): Writer, NEW, ABSTRACT;
(m: Model) ViewAt (x, y: INTEGER): Views.View, NEW, ABSTRACT;
(m: Model) NofViews (): INTEGER, NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD
(d: Directory) New (): Model, NEW, ABSTRACT
END;
Context = POINTER TO ABSTRACT RECORD (Models.Context)
(c: Context) ThisModel (): Model, ABSTRACT;
(c: Context) GetRect (OUT l, t, r, b: INTEGER), NEW, ABSTRACT
END;
Reader = POINTER TO ABSTRACT RECORD
view: Views.View;
l, t, r, b: INTEGER;
(r: Reader) Set (pos: Views.View), NEW, ABSTRACT;
(r: Reader) ReadView (OUT v: Views.View), NEW, ABSTRACT
END;
Writer = POINTER TO ABSTRACT RECORD
(w: Writer) Set (pos: Views.View), NEW, ABSTRACT;
(w: Writer) WriteView (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT
END;
UpdateMsg = RECORD (Models.UpdateMsg)
l, t, r, b: INTEGER
END;
VAR dir-, stdDir-: Directory;
PROCEDURE New (): Model;
PROCEDURE CloneOf (source: Model): Model;
PROCEDURE Copy (source: Model): Model;
PROCEDURE SetDir (d: Directory);
END FormModels.
Модуль FormModels содержит модели форм - модели-контейнеры, которые содержат отображения и только отображения. Другого внутренного содержимого у них нет (как, например, текст в текстовых моделях). Модели форм предназначены для размещения прямоугольных отображений произвольным образом. Главное их назначение - использование в качестве форм для ввода данных и в качестве схем разметки диалогового окна.
CONST minViewSize
Минимальные ширина и высота отображения, внедренного в модель формы.
CONST maxViewSize
Максимальные ширина и высота отображения, внедренного в модель формы.
TYPE Model (Containers.Model)
ABSTRACT
Модели форм - модели-контейнеры (см. Containers), которые могут содержать только прямоугольные отображения.
PROCEDURE (m: Model) Insert (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT, Операция
Вставляет отображение v в m; прямоугольник (l, t, r, b) определяет его границы. (l, t) - координаты левого верхнего угла; (r, b) - нижнего правого.
Предусловия
v # NIL 20
v.context = NIL 22
l <= r 23
t <= b 24
Постусловия
v in m
v.context # NIL & v.context.ThisModel() = m
PROCEDURE (m: Model) Delete (v: Views.View)
NEW, ABSTRACT, Операция
Удаляет v из m.
Предусловия
v in m 20
Постусловия
~(v in m)
PROCEDURE (m: Model) Resize (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT, Операция
Переопределят ограничивающий прямоугольник v.
Предусловия
v in m 20
l <= r 21
t <= b 22
PROCEDURE (m: Model) PutAbove (v, pos: Views.View)
NEW, ABSTRACT, Операция
Изменяет вертикальный порядок отображения v таким образом, что оно оказывается расположенным точно над pos, если pos # NIL; иначе оно располагается на форме как самое нижнее..
Предусловия
v in m 20
pos = NIL OR pos in m 21
PROCEDURE (m: Model) Move (v: Views.View; dx, dy: INTEGER)
NEW, ABSTRACT, Операция
Перемещает отображение v на (dx, dy), не меняя его размер.
Предусловия
v in m 20
PROCEDURE (m: Model) Copy (VAR v: Views.View; dx, dy: INTEGER)
NEW, ABSTRACT, Операция
Создает копиию v и размещает её в ограничивающий прямоугольник v, смещенный на (dx, dy). В параметре v возвращается копия.
Предусловия
v # NIL 20
v.context # NIL 21
v.context.ThisModel() = m 22
Постусловия
v # NIL & v # v'
PROCEDURE (m: Model) NewReader (old: Reader): Reader
NEW, ABSTRACT
Возвращает считыватель, подключенный к m. В качестве входного параметра может быть передан уже существующий и более нигде не использующийся считыватель.
Постусловия
result # NIL
PROCEDURE (m: Model) NewWriter (old: Writer): Writer
NEW, ABSTRACT
Возвращает записыватель, подключенный к m. В качестве входного параметра может быть передан уже существующий и более нигде не использующийся записыватель.
Постусловия
result # NIL
PROCEDURE (m: Model) ViewAt (x, y: INTEGER): Views.View
NEW, ABSTRACT
Возвращает самое верхнее отображение в m, к которому относится точка (x, y).
Постусловия
result # NIL
(l <= x <= r) & (t <= y <= b), здесь (l, t, r, b) - ограничивающий прямоугольник v
result = NIL
нет отображения в точке (x, y)
PROCEDURE (m: Model) NofViews (): INTEGER
NEW, ABSTRACT
Возвращает число содержащихся в m отображений.
Постусловия
result >= 0
TYPE Directory
ABSTRACT
Фабрика моделей форм.
PROCEDURE (d: Directory) New (): Model
NEW, ABSTRACT
Создает и возвращает новую модель формы.
Постусловия
result # NIL
TYPE Context (Models.Context)
NEW, ABSTRACT
Контекст отображения на форме.
PROCEDURE (c: Context) ThisModel (): Model
ABSTRACT
Возвращает модель формы, содержащую контекст.
PROCEDURE (c: Context) GetRect (OUT l, t, r, b: INTEGER)
NEW, ABSTRACT
Возвращает ограничивающий прямоугольник отображения, принадлежащего данному контексту.
Постусловия
l < r & t < b
TYPE Reader
ABSTRACT
Считывающий курьер (считыватель) модели формы.
view: Views.View
Последнее считанное отображение.
l, t, r, b: INTEGER view # NIL => l < r & t < b
Ограничивающий прямоугольник последнего считанного отображения.
PROCEDURE (r: Reader) Set (pos: Views.View)
NEW, ABSTRACT
Устнавливает положение считывателя r на отображение над pos (т. е. следующим будет прочитано отображение, расположенное точно над pos) или в самый низ, если pos = NIL.
Предусловия
pos in Base(r) OR pos = NIL 20
PROCEDURE (r: Reader) ReadView (OUT v: Views.View)
NEW, ABSTRACT
Читает следующее отображение, в восходящем порядке. Если больше отображений нет, v устанавливается в NIL. Поля считывателя view и l, t, r, b устанавливаются соответсвтующим образом (l, t, r, b не определены, если view = NIL).
Постусловия
v = r.view
TYPE Writer
ABSTRACT
Записывающий курьер (записыватель) модели формы.
PROCEDURE (w: Writer) Set (pos: Views.View)
Интерфейс
Устнавливает положение записывателя w на отображение над pos (т. е. следующее записываемое отображение будет вставлено точно над pos) или в самый низ, если pos = NIL.
Предусловия
pos in Base(r) OR pos = NIL 20
PROCEDURE (w: Writer) WriteView (v: Views.View; l, t, r, b: INTEGER)
NEW, ABSTRACT
Вставляет в форму на текущее положение записывателя w отображение v.
Предусловия
v # NIL 20
v.context = NIL 22
l <= r 23
t <= b 24
Постусловия
v.context # NIL
TYPE UpdateMsg
Это сообщение указывает, что прямоугольная часть формы на экране требует обновления. Получатель не должен включать какие-либо пометки в качестве реакции на это сообщение. UpdateMsgs посылается конкретными реализациями моделей форм после любых изменений отображений.
Тип UpdateMsg не расширяем.
VAR dir-, stdDir-: Directory; dir # NIL & stdDir # NIL
Фабрика и стандартная фабрика моделей форм.
PROCEDURE New (): Model
Возвращает новую модель. Эквивалентно dir.New().
Постусловия
result # NIL
PROCEDURE CloneOf (source: Model): Model
Возвращает новую пустую модель того же типа, что и source.
Предусловия
source # NIL 20
Постусловия
result # NIL
PROCEDURE Copy (source: Model): Model
Возвращает новую модель того же типа, что и source, с копией содержимого source.
Предусловия
source # NIL 20
Постусловия
result # NIL
PROCEDURE SetDir (d: Directory)
Устанавливает фабрику моделей форм.
Предусловия
d # NIL 20
Постусловия
dir = d
| Form/Docu/ru/Models.odc |
Карта подсистемы Form
ENGLISH
Руководство пользователя
Руководство разработчика
FormCmds пакет команд формы
FormGen авт-е создание формы
FormControllers диспетчеры форм
FormViews отображения форм
FormModels модели форм
| Form/Docu/ru/Sys-Map.odc |
Подсистема Form
Руководство пользователя
ENGLISH
Содержание
1Созданиеисохранениеформ
2Основыредактирования
3Клавишинавигации
4Перетаскивание
5Перетаскиваниесуказанием
6Режимыразметкиимаски
7Элементыуправленияиинтеракторы
8Свойстваэлементовуправления
Подсистема форм реализует простой редактор форм, который может использоваться для создания диалоговых окон и форм ввода данных.
1 Создание и сохранение форм
Команда Формы->Новая форма... (Controls->New Form) создает диалоговый окна и другие формы, которые устанавливаются в соответствие экспортированным глобальным переменным. Все такие формы являются немодальными. Абсолютно все диалоговые окна в BlackBox немодальны, настолько, насколько позволяет основная платформа.
Для начала откройте диалог Новая форма и введите "TextCmds.find" в поле Link. После нажатия кнопки ОК будет автоматически создан макет диалогового окна с текстовыми полями Find и Replace и несколькими флажками. Эти поля и флажки непосредственно соответствуют полям записи переменной find в модуле TextCmds. Чтобы убедиться в этом, выделите строчку "TextCmds.find", и выполните команду Инфо->Интерфейс (Info->Интерфейс). Будет показано определение соответствующего типа записи.
Размер отображения формы можно менять, выделяя документ целиком (Правка->Выделить документ) и затем перемещая узлы рамки.
В диалоговом окне, создаваемом командой Новая форма, элементы управления (кнопки, поля ввода и т.д.) упорядочиваются стандартным образом, однако их расположение можно менять. Элементы управления могут быть переупорядочены, переименованы или изменены другим образом с помощью меню Формы (Controls) или Разметка (Layout). Последнее появляется автоматически, когда форма получает фокус.
Вместо начальной разметки по существующей глобальной переменной, можно начать создание с пустой формы (кнопка Пустая / Empty в диалоговом окне Новая форма) и затем успешно добавлять новые элементы управления через меню Controls. Позднее эти элементы можно будет связать с различными глобальными переменными.
Редактируемое диалоговое окно можно сохранить, сохраняя окно документа, в котором велась разметка. BlackBox Component Builder сохраняет диалоговые окна в стандартном формате документа. По соглашению, формы BlackBox сохраняются в подходящей директории Rsrc (см. Подсистемы и глобальные модули). Например, стандартное окно поиска и замены хранится в Text/Rsrc/Find.
2 Основы редактирования
Отображение может быть вставлено в форму одной из команд Вставить АВС (Insert ABC) в меню Формы (Controls), например, Вставить командную кнопку. Можно вставить любое другое отображение, копировав его через буфер обмена или перетаскиванием.
Отображения на форме могут быть выделены. Если выделено одиночное отображение ("синглтон"), то видны узлы рамки, с помощью которых можно изменять размер отображения. Если выделено несколько отображений, показываются границы выделения, но без узлов.
Отображение можно выделить как щелчком мыши на нем, так и обведя мышью территорию, которая содержит отображение(я). Если во время выделения нажата клавиша shift, то при щелчке по выделенному отображению выделение снимается, а по невыделенному - отображение добавляется к выделенным. Если клавиша shift не нажата, то существующее выделение снимается и заменяется новым. Следовательно, одиночный щелчок на пустом месте снимает текущее выделение. Тот же эффект дает нажатие esc.
Некоторые атрибуты выделенных отображений можно изменять через меню Атрибуты (и меню Шрифт в MacOS). Таким образом можно изменить шрифт, стиль и размер надписей для большинства элементов управления.
Команда Формы->Вставить группу (Insert GroupBox) работает также, как и остальные команды вставки, за одним исключением: если есть выделение, то группа размещается так, чтобы включить в себя выделенные отображения.
Mac OS:
Изменение размера надписей не имеет эффекта, он всегда равен 12 пунктам.
Выделение может быть вырезано, копировано и вставлено с помощью буфера обмена. Оно может быть удалено клавишами backspace или delete.
Меню Разметка содержит различные команды, которые полезны при редактировании форм. Команды Выровнять слева, Выровнять справа, Выровнять сверху, Выровнять снизу (Align Left, Align Right, Align Top, Align Bottom) выравнивают соответствующие границы всех выделенных отображений. Выравнивание ведется по самому левому/правому/верхнему/нижнему краю. При выравнивании отображения сдвигаются, а их размер остается прежним.
Выровнять ряд (Align To Row) выравнивает все выделенные отображения в вертикальном направлении так, что все вертикальные центры устанавливаются на одной линии. Ее координата y вычисляется как среднее арифметическое всех старых координат y. Точно также Выровнять колонку (Align To Column) выравнивает выделенные отображения в горизонтальном направлении, формируя из них одну колонку.
Диалоговое окно Включить сетку... (Set Grid) устанавливает сетку. Большинство команд, которые перемещают или изменяют размер, будут округлять его по этой сетке. Диалоговое окно позволит вам выбрать между сеткой, построенной по миллиметрам или по 1/16 дюйма. Разрешение сетки задает размер ячейки в выбранных единицах. Большие значения позволяют легче выравнивать элементы. Через каждый сантиметр или пол-дюйма по сетке рисуются пунктирные линии, помогающие в редактировании.
Выбрать невыровненные (Select Off-Grid Views) выделяет все отображения, у которых хотя бы один край не выровнен по сетке. Выстроить по сетке (Force To Grid) передвигает и изменяет их размер на минимально возможное расстояние, чтобы выровнять их по сетке.
В принципе, отображения упорядочены по оси z, то есть каждое находится впереди или позади другого. При нормальном расположении отображения на форме не должны перекрываться, и их z-упорядочивание не имеет видимого эффекта. Но это упорядочивание учитывается при перемещении фокуса между элементами с помощью клавиши tab. Фокус перемещается от заднего к переднему отображению. Команды Cделать первым/задним и Сделать последним/передним (Set First/Back и Set Last/Front) позволяют изменять z-порядок выбранного синглтона. Сортировать отображения (Sort Views) упорядочивает все отображения по оси z слева направо и сверху вниз. Эту команду лучше применять после того, как выполнена разметка формы, чтобы вновь сделать порядок интуитивным.
Пересчитать размер (Recalc Focus Size) действует на фокусированный макет формы. Команда расчитывает прямоугольник, ограничивающий все отображения, расположенные на форме, добавляет небольшие поля и затем изменяет высоту и ширину формы. Это более удобно, чем использовать Правка->Выделить документ и затем менять размер вручную.
Команда Назначить основную кнопку и Назначить кнопку отмены (Set Default Button и Set Cancel Button) делает выделенную кнопку основной или кнопкой отмены. Основная кнопка реагирует на нажатие клавиши return / enter как на нажатие мыши, кнопка отмены реагирует на нажатие esc.
Подобно другим отображениям, которые имеют независимые модели, отображение формы может быть открыто одновременно в нескольких окнах.
3 Клавиши навигации
Клавиши-стрелки могут использоваться для перемещения выделенных элементов влево, вправо, вверх или вниз на одну точку. Если при этом удерживается клавиша модификатора, выделение перемещается на большее расстояние.
4 Перетаскивание
При щелчке на выделении и перемещении курсора мыши выделенные отображения перемещаются в новое место. Перемещение учитывает сетку.
Если в конце перетаскивания нажата клавиша модификатора, то перетаскивается копия выделенного отображения, и выделение переносится на нее.
Перетаскивание работает также между окнами и даже между различными контейнерам. Если синглтон перетаскивается в контейнер другого типа (например, текстовый контейнер), тогда происходит копирование. Если перетаскивается полное выделение, то выделенные отображения переносятся на отображение формы и эта форма помещается в другой контейнер.
5 Перетаскивание с указанием
Перетаскивание с указанием также поддерживается в формах. Может быть перенесен размер другого отображения. Это очень удобно для разметки. Например, выделите несколько элементов управления различного размера, удерживайте клавишу alt (Windows) / command (MacOS) и перетащите курсор на другое отображение. Когда вы отпустите мышь на этом отображении, все выделенные элементы примут его размер.
6 Режимы разметки и маски
Формы могут использоваться в двух различных режимах. Обычно применяется режим разметки (layout mode), то есть, форма может свободно редактироваться. Отображения (обычно элементы управления), внедренные на форму, не могут редактироваться напрямую, поскольку они могут только выделяться, но не получать фокус. Для разметки было бы неудобно, если щелок мышью на одном из элементов передавал бы ему фокус, вместо того, чтобы его выделить. Формы сохраняются в режиме разметки и открываются в окнах документов.
Для использования формы в качестве диалогового окна или формы ввода данных она может быть открыта в режиме маски, во вспомогательном окне (форма ввода данных) или в инструментальном окне (диалог для операций на документе, расположенном под ним). Форма не может редактироваться в режиме маски. Однако ее внедренные отображения могут получать фокус, то есть, текстовое поле может принимать данные, а кнопка - нажиматься. Но теперь внедренные отображения нельзя выделять, перемещать и менять их размер.
В режиме маски рамка фокуса не показывается вокруг фокусированного отображения.
Когда форма в режиме разметки имеет фокус, другое окно с ней может быть открыто в режиме маски, с помощью команды Формы->Открыть как инструм. диалог или Формы->Открыть как вспом. диалог (Controls->Open As Tool Dialog или Controls->Open As Aux Dialog). Таким образом можно опробовать форму прямо в процессе ее создания. Изменения в окне разметки тотчас сказываются в окне маски, а ввод в окно маски передается в окно разметки.
Не нужно сохранять формы в режиме маски. Они сохраняются в режиме разметки и могут впоследствии открываться, редактироваться и сохраняться обычными командами меню Файл. Форма ввода данных открывается командой StdCmds.OpenAuxDialog, диалоговое окно открывается командой StdCmds.OpenToolDialog Эти команды открывают документ формы во вспомогательном / инструментальном окне и переводят его в режим маски. Например, следующие команды показывают различия между режимами, открывая один и тот же документ различными способами:
"StdCmds.OpenAuxDialog('Form/Rsrc/Gen', 'New Form')"
"StdCmds.OpenToolDialog('Text/Rsrc/Cmds', 'Find & Replace')"
"StdCmds.OpenDoc('Form/Rsrc/Gen')"
"StdCmds.OpenDoc('Text/Rsrc/Cmds')"
Две последние команды соответствуют команде Файл->Открыть и допускают редактирование.
Различие между вспомогательными и инструментальными диалоговыми окнами заключается в том, что вспомогательные диалоговые окна самодостаточны, т.е. используются для установки параметров или ввода данных. С другой стороны, инструментальные диалоговые окна работают с окнами, которые расположены под ними, как, например, диалог Найти и заменить.
Команды OpenAuxDialog/OpenToolDialog принимают портируемые имена файлов. Портируемое имя - это строка, которая задает файл машинно-независимым образом. В нем используется в качестве разделителя символ "/", как в Unix и Интернет.
Эти команды обычно применяются в пунктах меню, например, как показано ниже:
"TextCmds.InitFindDialog; StdCmds.OpenToolDialog('Text/Rsrc/Find', 'Find & Replace')"
Здесь первая команда инициализирует интерактор TextCmds.find текущим фрагментом текста. Вторая команда открывает диалог с формой Text/Rsrc/Find, элементы которого связываются при открытии окна с полями интерактора.
См. также модули FormGen, TextCmds и StdCmds.
7 Элементы управления и интеракторы
Элементы управления представляют собой специализированные отображения. Подобно любому отображению, они могут быть вставлены в любой общий контейнер: в текст, электронную таблицу и т.п. Однако большинство элементов управления помещаются на формы.
Каждый элемент управления может быть связын с переменной, точнее, с полем глобально объявленной переменной записи - так называемого интерактора. Когда элемент размещается (заново создается или считывается из документа), BlackBox пробует связать элемент с его переменной, используя возможности метапрограммирования ядра BlackBox Component Framework. Таким образом, связь между элементом управления и переменной может быть создана автоматически, когда диалоговое окно создается или загружается. Отделение интерактора от элементов управления делает возможным скрыть от программы множество деталей пользовательского интерфейса, например, разметку диалогового окна или другие "косметические" нюансы.
BlackBox Component Framework по умолчанию поддерживает командные кнопки, флажки, переключатели, поля, надписи, выпадающие списки, списки выбора, списки ввода, поля даты, времени, цвета, числового значения и группы (command buttons, check boxes, radio buttons, fields, captions, list boxes, selection boxes, combo boxes, date, time, color, up/down fields, groups).
8 Свойства элементов управления
Элементы управления имеют различные свойства, например, надпись на кнопке или поле интерактора, с которым связан элемент. Инспектор - это инструмент, который используется для просмотра и изменения свойств стандартных элементов. Чтобы открыть диалог инспектора для элемента управления, сначала выберите элемент, а затем выполните Правка->Свойства объекта... (Windows) / Правка->Информация о части (MacOS) (Edit->ObjectProperties.../ Edit->PartInfo)
Чтобы подробнее изучить инспектор, ознакомьтесь с документацией к модулю DevInspector.
Для дальнейшего ознакомления с программным интерфейсом подсистемы Form обратитесь к документации модулей FormModels, FormViews, FormControllers, FormGen, FormCmds и Controls. Поскольку большинство этих модулей распространяется в исходных текстах, вы имеете возможность познакомиться с примером комплексной подсистемы. Более простые примеры даются в подсистеме Obx, конкретно - примеры ObxAddress0, ObxAddress1, ObxAddress2, ObxOrders, ObxControls и ObxDialog. Учебник по системе форм дается в Главе4 сопроводительной книги по компонентному ПО и BlackBox Component Framework.
| Form/Docu/ru/User-Man.odc |
FormViews
DEFINITION FormViews;
IMPORT Ports, Views, Controllers, Containers, FormModels;
CONST minBorder = 4 * Ports.point; maxBorder = 100 * Ports.mm;
TYPE
View = POINTER TO ABSTRACT RECORD (Containers.View)
(v: View) ThisModel (): FormModels.Model, EXTENSIBLE;
(v: View) SetBorder (border: INTEGER), NEW, ABSTRACT;
(v: View) Border (): INTEGER, NEW, ABSTRACT;
(v: View) SetGrid (grid, gridFactor: INTEGER), NEW, ABSTRACT;
(v: View) Grid (): INTEGER, NEW, ABSTRACT;
(v: View) GridFactor (): INTEGER, NEW, ABSTRACT;
(v: View) SetBackground (background: Ports.Color), NEW, ABSTRACT
END;
Directory = POINTER TO ABSTRACT RECORD
(d: Directory) New (f: FormModels.Model): View, NEW, ABSTRACT
END;
VAR
dir-, stdDir-: Directory;
ctrldir-: Controllers.Directory;
PROCEDURE Focus (): View;
PROCEDURE FocusModel (): FormModels.Model;
PROCEDURE RoundToGrid (v: View; VAR x, y: INTEGER);
PROCEDURE New (): View;
PROCEDURE Deposit;
PROCEDURE SetDir (d: Directory);
PROCEDURE SetCtrlDir (d: Containers.Directory);
END FormViews.
Модуль FormViews содержит стандартные отображения для моделей форм из FormModels.
CONST minBorder, maxBorder
Рамка отображения формы - минимальное среди всех расстояний между границами отображения и ограничивающими прямоугольниками внедренных отображений. Предпочитаемая рамка может быть выбрана из диапазона [minBorder .. maxBorder].
TYPE View (Views.View)
ABSTRACT
PROCEDURE (v: View) ThisModel (): FormModels.Model
EXTENSIBLE
Тип результата говорит сам за себя.
PROCEDURE (v: View) SetBorder (border: INTEGER)
NEW, ABSTRACT, Операция
Установка предпочитаемой рамки отображения (желаемое минимальное среди всех расстояний между границами отображения и ближайшим к ним внедрённым отображением).
Предусловия
border >= 0 20
Постусловия
border < minBoder
v.border = minBorder
border > maxBorder
v.border = maxBorder
minBorder <= border <= maxBorder
v.border = border
PROCEDURE (v: View) Border (): INTEGER
NEW, ABSTRACT
Возвращает рамку отображения.
Постусловия
minBorder <= result <= maxBorder
PROCEDURE (v: View) SetGrid (grid, gridFactor: INTEGER)
NEW, ABSTRACT, Операция
Установка предпочтительной для отображения сетки grid (предпочитаемая сетка - сетка, по которой будут выровнены левые верхние углы всех внерённых отображений) и коэффициента сетки gridFactor (при показе сетки, каждая её gridFactor-я линия будет изображена пунктирной линией).
Предусловия
grid > 0 20
gridFactor > 0 21
Постусловия
v.Grid() = grid & v.GridFactor() = gridFactor
PROCEDURE (v: View) Grid (): INTEGER
NEW, ABSTRACT
Возвращает текущую сетку.
Постусловия
result > 0
PROCEDURE (v: View) GridFactor (): INTEGER
NEW, ABSTRACT
Возвращает текущий коэффициент сетки.
Постусловия
result > 0
PROCEDURE (v: View) SetBackground (background: Ports.Color)
NEW, ABSTRACT
Установка цвета фона формы. По умолчанию используется Ports.dialogBackground.
TYPE Directory
ABSTRACT
Фабрика отображений формы.
PROCEDURE (d: Directory) New (m: FormModels.Model): View
Интерфейс
Возвращает новое отображение на m.
Предусловия
m # NIL 20
Постусловия
result # NIL
result.ThisModel() = m
VAR dir, stdDir-: Directory dir # NIL & stdDir # NIL
Фабрика и стандартная фабрика отображений форм.
VAR ctrldir-: Controllers.Directory ctrldir # NIL
Фабрика диспетчеров форм, инсталлируемая модулем FormControllers во время загрузки.
PROCEDURE Focus (): View
Возвращает сфокусированное отображение формы, если таковое существует.
PROCEDURE FocusModel (): FormModels.Model
Возвращает модель сфокусированного отображения формы, если таковое существует.
PROCEDURE RoundToGrid (v: View; VAR x, y: INTEGER)
Округляет координаты (x, y) до ближайшей точки на сетке v.
Предусловия
v # NIL 20
x > 0 & y > 0 21
Постусловия
x MOD v.grid = 0
y MOD v.grid = 0
PROCEDURE New (): View
Возвращает новое отображение формы на новой пустой модели формы, т. е. возвращает FormViews.dir.New(FormModels.dir.New()).
PROCEDURE Deposit
Процедура Deposit создает новое отображение формы на новой пустой модели формы и помещает его в буфер обмена.
Deposit вызывается внутренне.
PROCEDURE SetDir (d: Directory)
Установка фабрики отображений форм.
Предусловия
d # NIL 20
Постусловия
dir = d
PROCEDURE SetCtrlDir (d: Containers.Directory)
Установка фабрики диспетчеров отображений форм.
Предусловия
d # NIL 20
| Form/Docu/ru/Views.odc |
MODULE FormCmds;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Strings, Dialog, Ports, Stores, Models, Views, Properties, Controls, Containers,
FormModels, FormViews, FormControllers, StdCmds;
CONST
mm = Ports.mm; inch16th = Ports.inch DIV 16;
left = 0; top = 1; right = 2; bottom = 3; row = 4; column = 5;
VAR
grid*: RECORD
resolution*: INTEGER; (* resolution > 0 *)
metricSystem*: BOOLEAN
END;
find*: RECORD
from*, to*: ARRAY 256 OF CHAR;
link*, label*, guard*, notifier*: BOOLEAN;
END;
PROCEDURE FindExtrema (c: FormControllers.Controller; OUT l, t, r, b, h, v: INTEGER;
OUT s: FormControllers.List);
VAR n: INTEGER; p: FormControllers. List; q: FormModels.Reader; w: Views.View;
BEGIN (* there is at least one view selected *)
l := MAX(INTEGER); t := MAX(INTEGER); r := MIN(INTEGER); b := MIN(INTEGER);
h := 0; v := 0; n := 0; s := NIL;
q := c.form.NewReader(NIL); q.Set(NIL); q.ReadView(w);
WHILE w # NIL DO
IF c.IsSelected(w) THEN
INC(h, q.l); INC(h, q.r); INC(v, q.t); INC(v, q.b); INC(n, 2);
NEW(p); p.next := s; s := p; p.view := w;
IF q.l < l THEN l := q.l END;
IF q.t < t THEN t := q.t END;
IF q.r > r THEN r := q.r END;
IF q.b > b THEN b := q.b END
END;
q.ReadView(w)
END;
h := h DIV n; v := v DIV n
END FindExtrema;
PROCEDURE Move (c: FormControllers.Controller; s: FormControllers. List; p, side: INTEGER;
name: Stores.OpName);
VAR script: Stores.Operation; w, h: INTEGER; l, t, r, b: INTEGER; s0: FormControllers.List;
BEGIN
s0 := s;
Models.BeginScript(c.form, name, script);
WHILE s # NIL DO
s.view.context(FormModels.Context).GetRect(l, t, r, b); w := r - l; h := b - t;
IF side = left THEN
l := p; r := l + w
ELSIF side = top THEN
t := p; b := t + h
ELSIF side = right THEN
r := p; l := r - w
ELSIF side = bottom THEN
b := p; t := b - h
ELSIF side = row THEN
t := p - h DIV 2; b := t + h
ELSIF side = column THEN
l := p - w DIV 2; r := l + w
END;
c.form.Resize(s.view, l, t, r, b);
s := s.next
END;
Models.EndScript(c.form, script);
WHILE s0 # NIL DO c.Select(s0.view); s0 := s0.next END
END Move;
PROCEDURE AlignLeft*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, l, left, "#Form:AlignLeft")
END
END AlignLeft;
PROCEDURE AlignRight*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, r, right, "#Form:AlignRight")
END
END AlignRight;
PROCEDURE AlignTop*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, t, top, "#Form:AlignTop")
END
END AlignTop;
PROCEDURE AlignBottom*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, b, bottom, "#Form:AlignBottom")
END
END AlignBottom;
PROCEDURE AlignToRow*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, v, row, "#Form:AlignHorizontal")
END
END AlignToRow;
PROCEDURE AlignToColumn*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller; l, t, r, b, h, v: INTEGER; s: FormControllers.List;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
FindExtrema(c, l, t, r, b, h, v, s); Move(c, s, h, column, "#Form:AlignVertical")
END
END AlignToColumn;
PROCEDURE SelectOffGridViews*;
VAR c: FormControllers.Controller; v: Views.View; h: FormModels.Reader;
l, t, r, b, l0, t0, r0, b0: INTEGER;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
c.SelectAll(FALSE);
h := c.form.NewReader(NIL);
h.ReadView(v);
WHILE v # NIL DO
v.context(FormModels.Context).GetRect(l, t, r, b);
l0 := l; t0 := t; r0 := r; b0 := b;
FormViews.RoundToGrid(c.view, l0, t0);
FormViews.RoundToGrid(c.view, r0, b0);
IF (l0 # l) OR (t0 # t) OR (r0 # r) OR (b0 # b) THEN c.Select(v) END;
h.ReadView(v)
END
END
END SelectOffGridViews;
PROCEDURE Selection (c: FormControllers.Controller): FormControllers.List;
VAR p, q: FormControllers. List; h: FormModels.Reader; v: Views.View;
BEGIN
p := NIL;
h := c.form.NewReader(NIL); h.Set(NIL); h.ReadView(v);
WHILE v # NIL DO
IF c.IsSelected(v) THEN NEW(q); q.next := p; p := q; q.view := v END;
h.ReadView(v)
END;
RETURN p
END Selection;
PROCEDURE ForceToGrid*;
(** Guard: SelectionGuard **)
VAR c: FormControllers.Controller;
l, t, r, b: INTEGER; sel, sel0: FormControllers.List; s: Stores.Operation;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
Models.BeginScript(c.form, "#Form:ForceToGrid", s);
sel := Selection(c); sel0 := sel;
WHILE sel # NIL DO
sel.view.context(FormModels.Context).GetRect(l, t, r, b);
FormViews.RoundToGrid(c.view, l, t);
FormViews.RoundToGrid(c.view, r, b);
c.form.Resize(sel.view, l, t, r, b);
sel := sel.next
END;
Models.EndScript(c.form, s);
WHILE sel0 # NIL DO c.Select(sel0.view); sel0 := sel0.next END
END
END ForceToGrid;
PROCEDURE SortViews*;
(** Guard: FocusGuard **)
VAR c: FormControllers.Controller; script: Stores.Operation;
r: FormModels.Reader; p, q: Views.View;
PROCEDURE IsAbove (p, q: Views.View): BOOLEAN;
VAR l0, l1, t0, t1, r, b: INTEGER;
BEGIN
p.context(FormModels.Context).GetRect(l0, t0, r, b);
q.context(FormModels.Context).GetRect(l1, t1, r, b);
RETURN (t0 < t1) OR (t0 = t1) & (l0 <= l1)
END IsAbove;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & (c.form.NofViews() > 1) THEN
c.SelectAll(FALSE);
Models.BeginScript(c.form, "#Form:ChangeZOrder", script);
r := c.form.NewReader(NIL);
REPEAT (* bubble sort *)
r.Set(NIL); r.ReadView(p); r.ReadView(q);
WHILE (q # NIL) & IsAbove(p, q) DO p := q; r.ReadView(q) END;
IF q # NIL THEN c.form.PutAbove(p, q) END
UNTIL q = NIL;
Models.EndScript(c.form, script);
c.SelectAll(TRUE)
END
END SortViews;
PROCEDURE SetAsFirst*;
(** Guard: SingletonGuard **)
(** send to back **)
VAR c: FormControllers.Controller; v: Views.View;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
v := c.Singleton();
IF v # NIL THEN
c.form.PutAbove(v, NIL);
c.SetSingleton(v)
END
END
END SetAsFirst;
PROCEDURE SetAsLast*;
(** Guard: SingletonGuard **)
(** bring to front **)
VAR c: FormControllers.Controller; v, p, q: Views.View; r: FormModels.Reader;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
v := c.Singleton();
IF v # NIL THEN
r := c.form.NewReader(NIL); r.Set(v); p := v;
REPEAT q := p; r.ReadView(p) UNTIL p = NIL;
c.form.PutAbove(v, q);
c.SetSingleton(v)
END
END
END SetAsLast;
PROCEDURE InsertAround*;
(** Guard: SelectionGuard **)
CONST d = 3 * Ports.mm;
VAR c: FormControllers.Controller; v: Views.View; rd: FormModels.Reader; l, t, r, b: INTEGER;
s: Stores.Operation;
BEGIN
ASSERT(Views.Available() = 1, 20);
c := FormControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
l := MAX(INTEGER); t := MAX(INTEGER); r := MIN(INTEGER); b := MIN(INTEGER);
rd := c.form.NewReader(NIL); rd.ReadView(v);
WHILE v # NIL DO
IF c.IsSelected(v) THEN
IF rd.l < l THEN l := rd.l END;
IF rd.t < t THEN t := rd.t END;
IF rd.r > r THEN r := rd.r END;
IF rd.b > b THEN b := rd.b END
END;
rd.ReadView(v)
END;
ASSERT(l < r, 100);
DEC(l, d); DEC(t, 3 * d); INC(r, d); INC(b, d);
FormViews.RoundToGrid(c.view, l, t);
FormViews.RoundToGrid(c.view, r, b);
Views.Fetch(v);
Models.BeginScript(c.form, "#Form:InsertAround", s);
c.form.Insert(v, l, t, r, b);
c.form.PutAbove(v, NIL);
Models.EndScript(c.form, s);
c.SetSingleton(v)
ELSE
StdCmds.PasteView
END
END InsertAround;
PROCEDURE InitGridDialog*;
(** Guard: FocusGuard **)
VAR c: FormControllers.Controller; g: INTEGER;
BEGIN
c := FormControllers.Focus();
IF c # NIL THEN
g := c.view.Grid();
IF g MOD mm = 0 THEN
grid.resolution := g DIV mm;
grid.metricSystem := TRUE
ELSIF g MOD inch16th = 0 THEN
grid.resolution := g DIV inch16th;
grid.metricSystem := FALSE
ELSIF Dialog.metricSystem THEN
grid.resolution := g DIV mm;
grid.metricSystem := TRUE
ELSE
grid.resolution := g DIV inch16th;
grid.metricSystem := FALSE
END;
Dialog.Update(grid)
END
END InitGridDialog;
PROCEDURE SetGrid*;
(** Guard: FocusGuard **)
VAR c: FormControllers.Controller; n: INTEGER;
BEGIN
c := FormControllers.Focus();
IF (c # NIL) & (grid.resolution > 0) THEN
IF grid.metricSystem THEN
n := 10 DIV grid.resolution;
IF n < 1 THEN n := 1 END;
c.view.SetGrid(grid.resolution * mm, n)
ELSE
n := 8 DIV grid.resolution;
IF n < 1 THEN n := 1 END;
c.view.SetGrid(grid.resolution * inch16th, n)
END
END
END SetGrid;
(** renaming of controls **)
PROCEDURE Rename*;
(** Guard: StdCmds.ContainerGuard **)
VAR c: Containers.Controller; v: Views.View;
msg: Properties.PollMsg; p, q: Properties.Property;
setMsg: Properties.SetMsg;
PROCEDURE Replace(VAR s: ARRAY OF CHAR; IN from, to: ARRAY OF CHAR);
VAR pos: INTEGER;
BEGIN
Strings.Find(s, from, 0, pos);
WHILE pos >= 0 DO
Strings.Replace(s, pos, LEN(from$), to);
Strings.Find(s, from, pos + LEN(to$), pos);
END
END Replace;
BEGIN
c := Containers.Focus();
IF c # NIL THEN
c.GetFirstView(Containers.any, v);
WHILE v # NIL DO
msg.prop := NIL; Views.HandlePropMsg(v, msg);
p := msg.prop; WHILE (p # NIL) & ~(p IS Controls.Prop) DO p := p.next END;
IF p # NIL THEN
q := Properties.CopyOf(p);
WITH q: Controls.Prop DO
IF find.label & (Controls.label IN q.valid) THEN Replace(q.label, find.from, find.to) END;
IF find.link & (Controls.link IN q.valid) THEN Replace(q.link, find.from, find.to) END;
IF find.guard & (Controls.guard IN q.valid) THEN Replace(q.guard, find.from, find.to) END;
IF find.notifier & (Controls.notifier IN q.valid) THEN Replace(q.notifier, find.from, find.to) END
END;
setMsg.prop := q;
Views.HandlePropMsg(v, setMsg);
END;
c.GetNextView(Containers.any, v)
END
END
END Rename;
(** standard form-related guards **)
PROCEDURE FocusGuard* (VAR par: Dialog.Par);
(** in non-FormView menus; otherwise implied by menu type **)
BEGIN
par.disabled := FormViews.Focus() = NIL
END FocusGuard;
PROCEDURE SelectionGuard* (VAR par: Dialog.Par);
(** in non-FormView menus; otherwise use "SelectionGuard" **)
VAR c: FormControllers.Controller;
BEGIN
c := FormControllers.Focus();
par.disabled := (c = NIL) OR ~c.HasSelection()
END SelectionGuard;
PROCEDURE SingletonGuard* (VAR par: Dialog.Par);
(** in non-FormView menus; otherwise use "SingletonGuard" **)
VAR c: FormControllers.Controller;
BEGIN
c := FormControllers.Focus();
par.disabled := (c = NIL) OR (c.Singleton() = NIL)
END SingletonGuard;
BEGIN
find.link := TRUE; find.label := TRUE; find.guard := TRUE; find.notifier := TRUE
END FormCmds.
| Form/Mod/Cmds.odc |
MODULE FormControllers;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Services, Ports, Stores, Models, Views, Controllers, Properties, Containers,
FormModels, FormViews;
CONST
noSelection* = Containers.noSelection; noFocus* = Containers.noFocus;
rdel = 7X; ldel = 8X;
arrowLeft = 1CX; arrowRight = 1DX; arrowUp = 1EX; arrowDown = 1FX;
(* range of currently supported versions *)
minVersion = 0; maxBaseVersion = 0; maxStdVersion = 0;
TYPE
Controller* = POINTER TO ABSTRACT RECORD (Containers.Controller)
form-: FormModels.Model;
view-: FormViews.View
END;
Directory* = POINTER TO ABSTRACT RECORD (Containers.Directory) END;
List* = POINTER TO RECORD
next*: List;
view*: Views.View
END;
StdController = POINTER TO RECORD (Controller)
sel: List; (* (sel = NIL) OR (c.ThisFocus() = NIL) *)
reader: FormModels.Reader;
lastX, lastY: INTEGER
END;
StdDirectory = POINTER TO RECORD (Directory) END;
MarkMsg = RECORD (Views.Message)
list: List;
show: BOOLEAN
END;
PollFocusMsg = RECORD (Controllers.PollFocusMsg)
c: Controller
END;
VAR dir-, stdDir-: Directory;
(** Controller **)
PROCEDURE (c: Controller) Internalize2- (VAR rd: Stores.Reader), EXTENSIBLE;
VAR thisVersion: INTEGER;
BEGIN
rd.ReadVersion(minVersion, maxBaseVersion, thisVersion)
END Internalize2;
PROCEDURE (c: Controller) Externalize2- (VAR wr: Stores.Writer), EXTENSIBLE;
BEGIN
wr.WriteVersion(maxBaseVersion)
END Externalize2;
PROCEDURE (c: Controller) InitView2* (view: Views.View), EXTENSIBLE;
BEGIN
IF view # NIL THEN
ASSERT(view IS FormViews.View, 25);
c.view := view(FormViews.View); c.form := c.view.ThisModel()
ELSE
c.form := NIL; c.view := NIL
END
END InitView2;
PROCEDURE (c: Controller) ThisView* (): FormViews.View, EXTENSIBLE;
BEGIN
RETURN c.view
END ThisView;
PROCEDURE (c: Controller) Select* (view: Views.View), NEW, ABSTRACT;
PROCEDURE (c: Controller) Deselect* (view: Views.View), NEW, ABSTRACT;
PROCEDURE (c: Controller) IsSelected* (view: Views.View): BOOLEAN, NEW, ABSTRACT;
PROCEDURE (c: Controller) GetSelection* (): List, NEW, ABSTRACT;
PROCEDURE (c: Controller) SetSelection* (l: List), NEW, ABSTRACT;
(** Directory **)
PROCEDURE (d: Directory) NewController* (opts: SET): Controller, ABSTRACT;
PROCEDURE (d: Directory) New* (): Controller, EXTENSIBLE;
BEGIN
RETURN d.NewController({})
END New;
(* auxiliary procedures *)
PROCEDURE MarkList (c: StdController; f: Views.Frame; h: List; show: BOOLEAN);
VAR l, t, r, b, s: INTEGER;
BEGIN
IF ~(Containers.noSelection IN c.opts) THEN
s := 2 * f.unit;
WHILE h # NIL DO
c.view.GetRect(f, h.view, l, t, r, b);
f.MarkRect(l - s, t - s, r + s, b + s, s, Ports.hilite, show);
h := h.next
END
END
END MarkList;
PROCEDURE Toggle (c: StdController; view: Views.View);
BEGIN
IF c.IsSelected(view) THEN c.Deselect(view) ELSE c.Select(view) END
END Toggle;
(* StdController *)
PROCEDURE (c: StdController) Internalize2 (VAR rd: Stores.Reader);
VAR thisVersion: INTEGER;
BEGIN
c.Internalize2^(rd);
IF ~rd.cancelled THEN
rd.ReadVersion(minVersion, maxStdVersion, thisVersion);
c.sel := NIL; c.lastX := -1
END
END Internalize2;
PROCEDURE (c: StdController) Externalize2 (VAR wr: Stores.Writer);
BEGIN
c.Externalize2^(wr);
wr.WriteVersion(maxStdVersion)
END Externalize2;
PROCEDURE (c: StdController) CopyFrom (source: Stores.Store);
BEGIN
c.CopyFrom^(source);
c.sel := NIL; c.lastX := -1
END CopyFrom;
PROCEDURE (c: StdController) RestoreMarks2 (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
IF (c.lastX <= f.l ) OR (c.lastX >= f.r) OR (c.lastY <= f.t) OR (c.lastY >= f.b) THEN
c.lastX := (f.l + f.r) DIV 2; c.lastY := (f.t + f.b) DIV 2
END
END RestoreMarks2;
PROCEDURE (c: StdController) HandleViewMsg (f: Views.Frame; VAR msg: Views.Message);
BEGIN
WITH msg: MarkMsg DO
MarkList(c, f, msg.list, msg.show)
ELSE
c.HandleViewMsg^(f, msg)
END
END HandleViewMsg;
PROCEDURE (c: StdController) HandleCtrlMsg (f: Views.Frame; VAR msg: Views.CtrlMessage;
VAR focus: Views.View);
BEGIN
WITH msg: PollFocusMsg DO
c.HandleCtrlMsg^(f, msg, focus);
msg.c := c
ELSE
c.HandleCtrlMsg^(f, msg, focus)
END
END HandleCtrlMsg;
(* subclass hooks *)
PROCEDURE (c: StdController) GetContextType (OUT type: Stores.TypeName);
BEGIN
type := "FormViews.View"
END GetContextType;
PROCEDURE (c: StdController) GetValidOps (OUT valid: SET);
BEGIN
valid := {Controllers.pasteChar, Controllers.paste};
IF c.sel # NIL THEN valid := valid + {Controllers.cut, Controllers.copy} END
END GetValidOps;
PROCEDURE (c: StdController) NativeModel (model: Models.Model): BOOLEAN;
BEGIN
ASSERT(model # NIL, 20);
RETURN model IS FormModels.Model
END NativeModel;
PROCEDURE (c: StdController) NativeView (view: Views.View): BOOLEAN;
BEGIN
ASSERT(view # NIL, 20);
RETURN view IS FormViews.View
END NativeView;
PROCEDURE (c: StdController) NativeCursorAt (f: Views.Frame; x, y: INTEGER): INTEGER;
BEGIN
ASSERT(f # NIL, 20);
RETURN Ports.graphicsCursor
END NativeCursorAt;
PROCEDURE (c: StdController) MakeViewVisible (v: Views.View);
VAR l, t, r, b: INTEGER;
BEGIN
ASSERT(v # NIL, 20);
ASSERT(v.context # NIL, 21);
ASSERT(v.context.ThisModel() = c.form, 22);
v.context(FormModels.Context).GetRect(l, t, r, b);
c.view.context.MakeVisible(l, t, r, b)
END MakeViewVisible;
PROCEDURE (c: StdController) GetFirstView (selection: BOOLEAN; OUT v: Views.View);
VAR rd: FormModels.Reader;
BEGIN
IF selection THEN
IF c.sel # NIL THEN v := c.sel.view ELSE v := NIL END
ELSE
rd := c.form.NewReader(c.reader); c.reader := rd;
rd.ReadView(v)
END
END GetFirstView;
PROCEDURE (c: StdController) GetNextView (selection: BOOLEAN; VAR v: Views.View);
VAR h: List; rd: FormModels.Reader;
BEGIN (* could be optimized *)
ASSERT(v # NIL, 20);
IF selection THEN
h := c.sel; WHILE (h # NIL) & (h.view # v) DO h := h.next END; ASSERT(h # NIL, 21);
IF h.next # NIL THEN v := h.next.view ELSE v := NIL END
ELSE
rd := c.form.NewReader(c.reader); c.reader := rd;
rd.Set(v); rd.ReadView(v)
END
END GetNextView;
PROCEDURE (c: StdController) GetSelectionBounds (f: Views.Frame; OUT x, y, w, h: INTEGER);
VAR g: Views.Frame; sel: List; l, t, r, b, gw, gh, border: INTEGER;
BEGIN
IF c.Singleton() # NIL THEN
c.GetSelectionBounds^(f, x, y, w, h)
ELSE
l := MAX(INTEGER); t := MAX(INTEGER); r := MIN(INTEGER); b := MIN(INTEGER);
sel := c.sel;
WHILE sel # NIL DO
g := Views.ThisFrame(f, sel.view);
IF g # NIL THEN
sel.view.context.GetSize(gw, gh);
IF g.gx < l THEN l := g.gx END;
IF g.gy < t THEN t := g.gy END;
IF g.gx + gw > r THEN r := g.gx + gw END;
IF g.gy + gh > b THEN b := g.gy + gh END;
END;
sel := sel.next
END;
IF (l < r) & (t < b) THEN
border := c.view.Border();
x := l - f.gx - border; y := t - f.gy - border;
w := r - l + 2 * border; h := b - t + 2 * border
ELSE
x := 0; y := 0; w := 0; h := 0
END
END
END GetSelectionBounds;
PROCEDURE (c: StdController) MarkDropTarget (src, dst: Views.Frame;
sx, sy, dx, dy, w, h, rx, ry: INTEGER;
type: Stores.TypeName;
isSingle, show: BOOLEAN);
CONST dm = 4 * Ports.point; dp = 18 * Ports.point;
VAR vx, vy, l, t, r, b: INTEGER; sc: Containers.Controller; s: Views.View;
BEGIN (* cf. Drop *)
IF ~isSingle & (src # NIL) & (src.view IS FormViews.View) THEN (* mark local form selection *)
vx := dx - sx; vy := dy - sy;
sc := src.view(FormViews.View).ThisController();
IF sc # NIL THEN
WITH sc: Controller DO
sc.GetFirstView(Containers.selection, s);
WHILE s # NIL DO
s.context(FormModels.Context).GetRect(l, t, r, b); w := r - l; h := b - t;
INC(l, vx); INC(t, vy); FormViews.RoundToGrid(c.view, l, t);
dst.MarkRect(l, t, l + w, t + h, 0, Ports.invert, show);
sc.GetNextView(Containers.selection, s)
END
END
END
ELSIF (w > 0) & (h > 0) THEN (* mark non-local form or singleton selection *)
vx := dx - rx; vy := dy - ry;
FormViews.RoundToGrid(c.view, vx, vy);
IF ~isSingle & Services.Extends(type, "FormViews.View") THEN (* general form selection *)
dst.MarkRect(vx - dm, vy, vx + dp, vy + dst.unit, 0, Ports.invert, show);
dst.MarkRect(vx, vy - dm, vx + dst.unit, vy + dp, 0, Ports.invert, show);
INC(vx, w); INC(vy, h);
dst.MarkRect(vx - dp, vy, vx + dm, vy + dst.unit, 0, Ports.invert, show);
dst.MarkRect(vx, vy - dp, vx + dst.unit, vy + dm, 0, Ports.invert, show)
ELSE (* singleton selection *)
dst.MarkRect(vx, vy, vx + w, vy + h, 0, Ports.invert, show)
END
ELSE (* cross-hair mark for non-form, non-singleton selections *)
FormViews.RoundToGrid(c.view, dx, dy);
dst.MarkRect(dx - dm, dy, dx + dp, dy + dst.unit, 0, Ports.invert, show);
dst.MarkRect(dx, dy - dm, dx + dst.unit, dy + dp, 0, Ports.invert, show)
END
END MarkDropTarget;
PROCEDURE (c: StdController) TrackMarks (f: Views.Frame; x, y: INTEGER;
units, extend, add: BOOLEAN);
VAR dx, dy, x0, y0, dx0, dy0: INTEGER; isDown: BOOLEAN; h: Views.View; m: SET;
PROCEDURE InvertRect (f: Views.Frame; x, y, dx, dy: INTEGER);
VAR l, t, r, b: INTEGER;
BEGIN
IF dx >= 0 THEN l := x; r := x + dx ELSE l := x + dx; r := x END;
IF dy >= 0 THEN t := y; b := y + dy ELSE t := y + dy; b := y END;
f.MarkRect(l, t, r, b, 0, Ports.dim50, TRUE)
END InvertRect;
PROCEDURE SelectArea (c: StdController; l, t, r, b: INTEGER; toggle: BOOLEAN);
VAR h: INTEGER; rd: FormModels.Reader; v: Views.View; p, q: List; empty: BOOLEAN;
BEGIN
IF l > r THEN h := l; l := r; r := h END;
IF t > b THEN h := t; t := b; b := h END;
rd := c.form.NewReader(c.reader); c.reader := rd;
rd.ReadView(v); p := NIL; empty := c.sel = NIL;
WHILE v # NIL DO
IF (rd.l < r) & (rd.t < b) & (rd.r > l) & (rd.b > t) THEN
IF toggle THEN Toggle(c, v)
ELSIF ~empty THEN c.Select(v)
ELSE NEW(q); q.next := p; p := q; q.view := v
END
END;
rd.ReadView(v)
END;
(* this optimization prevents the appearance of a temporary singleton *)
IF ~toggle & empty THEN c.SetSelection(p) END
END SelectArea;
BEGIN
dx := 0; dy := 0; (* vector from (x, y) *)
InvertRect(f, x, y, dx, dy);
REPEAT
f.Input(x0, y0, m, isDown);
dx0 := x0 - x; dy0 := y0 - y;
IF (dx0 # dx) OR (dy0 # dy) THEN
InvertRect(f, x, y, dx, dy);
dx := dx0; dy := dy0;
InvertRect(f, x, y, dx, dy)
END
UNTIL ~isDown;
InvertRect(f, x, y, dx, dy);
c.lastX := x0; c.lastY := y0;
IF (dx # 0) OR (dy # 0) THEN
SelectArea(c, x, y, x + dx, y + dy, extend OR add)
ELSE
h := c.form.ViewAt(x, y);
IF h # NIL THEN
IF extend OR add THEN Toggle(c, h) ELSE c.Select(h) END
END
END
END TrackMarks;
PROCEDURE (c: StdController) Resize (view: Views.View; l, t, r, b: INTEGER);
BEGIN
c.form.Resize(view, l, t, r, b)
END Resize;
PROCEDURE (c: StdController) DeleteSelection;
VAR script: Stores.Operation; h: List;
BEGIN
Models.BeginScript(c.form, "#System:Deletion", script);
h := c.sel; WHILE h # NIL DO c.form.Delete(h.view); h := h.next END;
Models.EndScript(c.form, script)
END DeleteSelection;
PROCEDURE MoveRelativeLocalSel (c: StdController; src, dst: Views.Frame;
dx, dy: INTEGER; grid: BOOLEAN);
VAR script: Stores.Operation; sel, h: List; l, t, r, b, newl, newt: INTEGER;
BEGIN
IF (dx # 0) OR (dy # 0) THEN
sel := c.GetSelection();
Models.BeginScript(c.form, "#System:Moving", script);
h := sel;
WHILE h # NIL DO
h.view.context(FormModels.Context).GetRect(l, t, r, b);
newl := l + dx; newt := t + dy;
IF grid THEN FormViews.RoundToGrid(c.view, newl, newt) END;
c.form.Move(h.view, newl - l, newt - t);
h := h.next
END;
Models.EndScript(c.form, script);
c.SetSelection(sel)
END
END MoveRelativeLocalSel;
PROCEDURE (c: StdController) MoveLocalSelection (src, dst: Views.Frame; sx, sy,
dx, dy: INTEGER);
BEGIN
MoveRelativeLocalSel(c, src, dst, dx - sx, dy - sy, TRUE)
END MoveLocalSelection;
PROCEDURE (c: StdController) CopyLocalSelection (src, dst: Views.Frame; sx, sy,
dx, dy: INTEGER);
VAR script: Stores.Operation; q: Views.View; h, s, t: List;
BEGIN
dx := dx - sx; dy := dy - sy;
IF (dx # 0) OR (dy # 0) THEN
FormViews.RoundToGrid(c.view, dx, dy);
Models.BeginScript(c.form, "#System:Copying", script);
h := c.GetSelection(); s := NIL;
WHILE h # NIL DO
q := h.view; c.form.Copy(q, dx, dy);
NEW(t); t.next := s; s := t; t.view := q;
h := h.next
END;
Models.EndScript(c.form, script);
c.SetSelection(s)
END
END CopyLocalSelection;
PROCEDURE (c: StdController) SelectionCopy (): Containers.Model;
VAR f: FormModels.Model; rd: FormModels.Reader; wr: FormModels.Writer;
v: Views.View; dx, dy: INTEGER;
PROCEDURE GetOffset (p: List; border: INTEGER; OUT dx, dy: INTEGER);
VAR l, t, vl, vt, vr, vb: INTEGER;
BEGIN
IF p # NIL THEN
l := MAX(INTEGER); t := MAX(INTEGER);
WHILE p # NIL DO
p.view.context(FormModels.Context).GetRect(vl, vt, vr, vb);
IF vl < l THEN l := vl END;
IF vt < t THEN t := vt END;
p := p.next
END;
dx := l - border; dy := t - border
ELSE
dx := 0; dy := 0
END
END GetOffset;
BEGIN
f := FormModels.CloneOf(c.form);
GetOffset(c.sel, c.view.Border(), dx, dy);
rd := c.form.NewReader(NIL); wr := f.NewWriter(NIL);
rd.ReadView(v);
WHILE v # NIL DO
IF c.IsSelected(v) THEN
wr.WriteView(Views.CopyOf(v, Views.deep), rd.l - dx, rd.t - dy, rd.r - dx, rd.b - dy)
END;
rd.ReadView(v)
END;
RETURN f
END SelectionCopy;
PROCEDURE (c: StdController) NativePaste (m: Models.Model; f: Views.Frame);
VAR x, y, cw, ch: INTEGER; v: Views.View; rd: FormModels.Reader;
wr: FormModels.Writer; n, i: INTEGER; script: Stores.Operation;
BEGIN
x := c.lastX; y := c.lastY;
c.view.context.GetSize(cw, ch);
IF (x <= f.l) OR (x >= f.r) OR (y <= f.t) OR (y >= f.b) THEN
x := (f.l + f.r) DIV 2; y := (f.r + f.b) DIV 2
END;
c.lastX := x; c.lastY := y;
FormViews.RoundToGrid(c.view, x, y);
WITH m: FormModels.Model DO
Models.BeginScript(c.form, "#System:Insertion", script);
rd := m.NewReader(NIL); wr := c.form.NewWriter(NIL); wr.Set(c.form.Top());
rd.ReadView(v); n := 0;
WHILE v # NIL DO
wr.WriteView(Views.CopyOf(v, Views.shallow), x + rd.l, y + rd.t, x + rd.r, y + rd.b);
INC(n);
rd.ReadView(v)
END;
Models.EndScript(c.form, script);
(* n views have been inserted at the top => select them *)
c.SelectAll(Containers.deselect);
i := c.form.NofViews() - n; ASSERT(i >= 0, 100);
rd := c.form.NewReader(rd);
WHILE i # 0 DO rd.ReadView(v); DEC(i) END; (* skip old views *)
WHILE n # 0 DO rd.ReadView(v); c.Select(v); DEC(n) END
END
END NativePaste;
PROCEDURE (c: StdController) ArrowChar (f: Views.Frame; ch: CHAR; units, select: BOOLEAN);
VAR d: INTEGER;
BEGIN
IF units THEN d := c.view.Grid() ELSE d := f.unit END;
IF ch = arrowLeft THEN
MoveRelativeLocalSel(c, f, f, -d, 0, units)
ELSIF ch = arrowRight THEN
MoveRelativeLocalSel(c, f, f, +d, 0, units)
ELSIF ch = arrowUp THEN
MoveRelativeLocalSel(c, f, f, 0, -d, units)
ELSIF ch = arrowDown THEN
MoveRelativeLocalSel(c, f, f, 0, +d, units)
END
END ArrowChar;
PROCEDURE (c: StdController) ControlChar (f: Views.Frame; ch: CHAR);
BEGIN
IF (ch = ldel) OR (ch = rdel) THEN c.DeleteSelection END
END ControlChar;
PROCEDURE (c: StdController) PasteChar (ch: CHAR);
END PasteChar;
PROCEDURE (c: StdController) PasteView (f: Views.Frame; v: Views.View; w, h: INTEGER);
VAR minW, maxW, minH, maxH, x, y: INTEGER;
BEGIN
x := c.lastX; y := c.lastY;
IF (x <= f.l) OR (x >= f.r) OR (y <= f.t) OR (y >= f.b) THEN
x := (f.l + f.r) DIV 2; y := (f.t + f.b) DIV 2
END;
c.lastX := x; c.lastY := y;
FormViews.RoundToGrid(c.view, x, y);
c.form.GetEmbeddingLimits(minW, maxW, minH, maxH);
Properties.PreferredSize(v, minW, maxW, minH, maxH, minW, minH, w, h);
c.form.Insert(v, x, y, x + w, y + h); c.Select(v)
END PasteView;
PROCEDURE (c: StdController) Drop (src, dst: Views.Frame; sx, sy, dx, dy,
w, h, rx, ry: INTEGER; v: Views.View; isSingle: BOOLEAN);
VAR minW, maxW, minH, maxH, l, t, sw, sh: INTEGER;
s: Views.View; p, q: List;
m: FormModels.Model; rd: FormModels.Reader; wr: FormModels.Writer;
BEGIN (* cf. MarkDropTarget *)
DEC(dx, rx); DEC(dy, ry);
IF ~isSingle & (v IS FormViews.View) THEN
m := v(FormViews.View).ThisModel();
rd := m.NewReader(NIL); wr := c.form.NewWriter(NIL);
rd.ReadView(s); p := NIL;
WHILE s # NIL DO
l := rd.l + dx; t := rd.t + dy; sw := rd.r - rd.l; sh := rd.b - rd.t;
FormViews.RoundToGrid(c.view, l, t);
s := Views.CopyOf(s, Views.shallow);
wr.WriteView(s, l, t, l + sw, t + sh);
NEW(q); q.next := p; p := q; q.view := s;
rd.ReadView(s)
END;
c.SetSelection(p)
ELSE
FormViews.RoundToGrid(c.view, dx, dy);
c.form.GetEmbeddingLimits(minW, maxW, minH, maxH);
Properties.PreferredSize(v, minW, maxW, minH, maxH, minW, minH, w, h);
c.form.Insert(v, dx, dy, dx + w, dy + h); c.Select(v)
END
END Drop;
(* selection *)
PROCEDURE (c: StdController) HasSelection (): BOOLEAN;
BEGIN
RETURN c.sel # NIL
END HasSelection;
PROCEDURE (c: StdController) Selectable (): BOOLEAN;
BEGIN
RETURN c.form.NofViews() # 0
END Selectable;
PROCEDURE (c: StdController) SetSingleton (s: Views.View);
VAR l: List;
BEGIN
c.SetSingleton^(s);
IF s # NIL THEN NEW(l); l.view := s; c.sel := l ELSE c.sel := NIL END
END SetSingleton;
PROCEDURE (c: StdController) SelectAll (select: BOOLEAN);
VAR s: FormModels.Reader; v: Views.View; l, h: List; msg: MarkMsg;
BEGIN
IF select THEN
ASSERT(~(Containers.noSelection IN c.opts), 20);
c.SetFocus(NIL);
s := c.form.NewReader(c.reader); c.reader := s;
s.Set(NIL); s.ReadView(v);
IF c.form.NofViews() = 1 THEN
ASSERT(v # NIL, 100);
c.SetSingleton(v)
ELSE
IF (c.sel # NIL) & (c.sel.next = NIL) THEN c.SetSingleton(NIL) END;
l := NIL;
WHILE v # NIL DO
IF ~c.IsSelected(v) THEN NEW(h); h.next := l; l := h; h.view := v END;
s.ReadView(v)
END;
msg.list := l;
h := c.sel; WHILE (h # NIL) & (h.next # NIL) DO h := h.next END;
IF h = NIL THEN c.sel := l ELSE h.next := l END;
IF msg.list # NIL THEN msg.show := TRUE; Views.Broadcast(c.view, msg) END
END
ELSIF c.sel # NIL THEN
IF c.sel.next = NIL THEN (* singleton *)
c.SetSingleton(NIL)
ELSE
msg.list := c.sel; c.sel := NIL;
msg.show := FALSE; Views.Broadcast(c.view, msg)
END
END
END SelectAll;
PROCEDURE (c: StdController) InSelection (f: Views.Frame; x, y: INTEGER): BOOLEAN;
VAR g: Views.Frame;
BEGIN
g := Views.FrameAt(f, x, y);
IF g # NIL THEN
RETURN c.IsSelected(g.view)
ELSE
RETURN FALSE
END
END InSelection;
PROCEDURE (c: StdController) MarkSelection (f: Views.Frame; show: BOOLEAN);
BEGIN
IF c.sel = NIL THEN (* skip *)
ELSIF c.sel.next = NIL THEN
Containers.MarkSingleton(c, f, show)
ELSE
MarkList(c, f, c.sel, show)
END
END MarkSelection;
(* caret *)
PROCEDURE (c: StdController) HasCaret (): BOOLEAN;
BEGIN
RETURN TRUE
END HasCaret;
PROCEDURE (c: StdController) MarkCaret (f: Views.Frame; show: BOOLEAN);
END MarkCaret;
(* FormController protocol *)
PROCEDURE (c: StdController) Select (view: Views.View);
VAR l, h, sel: List; msg: MarkMsg;
BEGIN
ASSERT(view # NIL, 20); ASSERT(view.context.ThisModel() = c.form, 21);
ASSERT(~(Containers.noSelection IN c.opts), 22);
l := c.sel; WHILE (l # NIL) & (l.view # view) DO l := l.next END;
IF l = NIL THEN (* view is not yet selected *)
sel := c.sel;
IF sel = NIL THEN
c.SetSingleton(view)
ELSE
NEW(l); l.view := view;
IF sel.next = NIL THEN
c.SetSingleton(NIL); ASSERT(c.sel = NIL, 100);
l.next := sel; c.sel := l;
msg.list := l
ELSE
l.next := sel; c.sel := l;
NEW(h); h.view := view;
msg.list := h
END;
msg.show := TRUE; Views.Broadcast(c.view, msg)
END
END
END Select;
PROCEDURE (c: StdController) Deselect (view: Views.View);
VAR l, h: List; msg: MarkMsg;
BEGIN
ASSERT(view # NIL, 20); ASSERT(view.context.ThisModel() = c.form, 21);
l := c.sel; h := NIL; WHILE (l # NIL) & (l.view # view) DO h := l; l := l.next END;
IF l # NIL THEN (* l is selection node of view, h its predecessor *)
IF (h = NIL) & (l.next = NIL) THEN (* singleton *)
c.SetSingleton(NIL)
ELSE
IF h = NIL THEN c.sel := l.next ELSE h.next := l.next END;
msg.list:= l; l.next := NIL; msg.show := FALSE; Views.Broadcast(c.view, msg);
IF (c.sel # NIL) & (c.sel.next = NIL) THEN (* singleton *)
view := c.sel.view;
msg.list := c.sel; c.sel := NIL;
msg.show := TRUE; Views.Broadcast(c.view, msg);
c.SetSingleton(view)
END
END
END
END Deselect;
PROCEDURE (c: StdController) IsSelected (view: Views.View): BOOLEAN;
VAR l: List;
BEGIN
ASSERT(view # NIL, 20); ASSERT(view.context.ThisModel() = c.form, 21);
l := c.sel; WHILE (l # NIL) & (l.view # view) DO l := l.next END;
RETURN l # NIL
END IsSelected;
PROCEDURE (c: StdController) GetSelection (): List;
VAR l, h, s: List;
BEGIN
l := NIL; s := c.sel;
WHILE s # NIL DO NEW(h); h.next := l; l := h; h.view := s.view; s := s.next END;
RETURN l
END GetSelection;
PROCEDURE (c: StdController) SetSelection (l: List);
VAR msg: MarkMsg;
BEGIN
c.SelectAll(FALSE); ASSERT(c.sel = NIL, 100);
IF l = NIL THEN (* skip *)
ELSIF l.next = NIL THEN
c.SetSingleton(l.view)
ELSE
msg.list := l; c.sel := l;
msg.show := TRUE; Views.Broadcast(c.view, msg)
END
END SetSelection;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) NewController (opts: SET): Controller;
VAR c: StdController;
BEGIN
NEW(c); c.SetOpts(opts); RETURN c
END NewController;
(** miscellaneous **)
PROCEDURE Focus* (): Controller;
VAR msg: PollFocusMsg;
BEGIN
msg.c := NIL;
Controllers.Forward(msg);
RETURN msg.c
END Focus;
PROCEDURE Insert* (c: Controller; view: Views.View; l, t, r, b: INTEGER);
VAR w, h: INTEGER;
BEGIN
w := r - l; h := b - t;
FormViews.RoundToGrid(c.view, l, t);
c.form.Insert(view, l, t, l + w, t + h)
END Insert;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20); dir := d
END SetDir;
PROCEDURE Install*;
BEGIN
FormViews.SetCtrlDir(dir)
END Install;
PROCEDURE Init;
VAR d: StdDirectory;
BEGIN
NEW(d); SetDir(d); stdDir := d
END Init;
BEGIN
Init
END FormControllers.
| Form/Mod/Controllers.odc |
MODULE FormGen;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Strings, Meta, Dates, Files, Ports, Views, Properties, Dialog, Containers, Documents,
Controls, StdDialog, StdCmds, FormModels, FormViews, FormControllers;
CONST
defaultDelta = 4 * Ports.point;
minW = 10 * Ports.mm; minH = 4 * Ports.mm;
maxW = 200 * Ports.mm; maxH = 50 * Ports.mm;
TYPE
ProcVal = RECORD (Meta.Value)
p: PROCEDURE
END;
VAR
new*: RECORD
link*: Dialog.String
END;
list: RECORD (Meta.Value) p*: POINTER TO Dialog.List END;
select: RECORD (Meta.Value) p*: POINTER TO Dialog.Selection END;
combo: RECORD (Meta.Value) p*: POINTER TO Dialog.Combo END;
date: RECORD (Meta.Value) p*: POINTER TO Dates.Date END;
time: RECORD (Meta.Value) p*: POINTER TO Dates.Time END;
color: RECORD (Meta.Value) p*: POINTER TO Dialog.Color END;
currency: RECORD (Meta.Value) p*: POINTER TO Dialog.Currency END;
tree: RECORD (Meta.Value) p*: POINTER TO Dialog.Tree END;
PROCEDURE GetSize (v: Views.View; VAR w, h: INTEGER);
BEGIN
w := Views.undefined; h := Views.undefined;
Properties.PreferredSize(v, minW, maxW, minH, maxH, minW, minH, w, h)
END GetSize;
PROCEDURE Gen (f: FormModels.Model; fv: FormViews.View; VAR path, name: ARRAY OF CHAR;
wr: FormModels.Writer; var: Meta.Item; VAR x, y, max: INTEGER; VAR first: BOOLEAN);
VAR v, str: Views.View; dummy, delta, x0, y0, m, w, h, i: INTEGER; n: Meta.Name;
p: Controls.Prop; s: Meta.Scanner; elem: Meta.Item; ok, back: BOOLEAN; pv: ProcVal;
BEGIN
dummy := 0; delta := defaultDelta; FormViews.RoundToGrid(fv, dummy, delta);
NEW(p); p.guard := ""; p.notifier := ""; p.label := ""; p.level := 0;
p.opt[0] := FALSE; p.opt[1] := FALSE; p.opt[2] := FALSE; p.opt[3] := FALSE; p.opt[4] := FALSE;
back := FALSE;
FormViews.RoundToGrid(fv, x, y);
v := NIL; w := Views.undefined; x0 := x; y0 := y;
IF (name[0] >= "0") & (name[0] <= "9") THEN p.link := path + "[" + name + "]"
ELSIF name # "" THEN p.link := path + "." + name
ELSE p.link := path$
END;
IF var.obj = Meta.modObj THEN (* traverse module *)
s.ConnectTo(var); s.Scan; m := 0;
WHILE ~ s.eos DO
s.GetObjName(n);
Gen(f, fv, p.link, n, wr, s.this, x, y, m, first);
s.Scan
END;
IF m > max THEN max := m END;
ELSIF var.obj = Meta.procObj THEN
var.GetVal(pv, ok);
IF ok THEN (* command *)
IF first THEN p.opt[Controls.default] := TRUE END;
p.label := name$; v := Controls.dir.NewPushButton(p);
p.opt[Controls.default] := FALSE; first := FALSE
END
ELSIF var.obj = Meta.varObj THEN
IF (var.typ IN {Meta.byteTyp, Meta.sIntTyp, Meta.longTyp, Meta.intTyp, Meta.sRealTyp, Meta.realTyp})
OR (var.typ = Meta.arrTyp) & (var.BaseTyp() = Meta.charTyp) THEN
p.opt[Controls.left] := TRUE; v := Controls.dir.NewField(p)
ELSIF var.typ = Meta.boolTyp THEN
p.label := name$; v := Controls.dir.NewCheckBox(p)
ELSIF var.typ = Meta.procTyp THEN
var.GetVal(pv, ok);
IF ok THEN (* command *)
IF first THEN p.opt[Controls.default] := TRUE END;
p.label := name$; v := Controls.dir.NewPushButton(p);
p.opt[Controls.default] := FALSE; first := FALSE
END
ELSIF var.typ = Meta.recTyp THEN
IF var.Is(list) THEN v := Controls.dir.NewListBox(p)
ELSIF var.Is(select) THEN v := Controls.dir.NewSelectionBox(p)
ELSIF var.Is(combo) THEN v := Controls.dir.NewComboBox(p)
ELSIF var.Is(date) THEN v := Controls.dir.NewDateField(p)
ELSIF var.Is(time) THEN v := Controls.dir.NewTimeField(p)
ELSIF var.Is(color) THEN v := Controls.dir.NewColorField(p)
ELSIF var.Is(currency) THEN p.opt[Controls.left] := TRUE; v := Controls.dir.NewField(p)
ELSIF var.Is(tree) THEN
p.opt[Controls.haslines] := TRUE; p.opt[Controls.hasbuttons] := TRUE;
p.opt[Controls.atroot] := TRUE; p.opt[Controls.foldericons] := TRUE;
v := Controls.dir.NewTreeControl(p)
ELSE (* traverse record *)
s.ConnectTo(var); s.Scan; m := 0;
IF name # "" THEN INC(x, delta); INC(y, 4 * delta) END;
WHILE ~ s.eos DO
s.GetObjName(n);
Gen(f, fv, p.link, n, wr, s.this, x, y, m, first);
s.Scan
END;
IF m > max THEN max := m END;
IF (name # "") & (m > 0) THEN (* insert group *)
p.label := name$; v := Controls.dir.NewGroup(p);
w := m; x := x0; h := y + delta - y0; y := y0; back := TRUE
END
END
ELSIF var.typ = Meta.arrTyp THEN (* traverse array *)
i := 0; m := 0;
IF name # "" THEN INC(x, delta); INC(y, 4 * delta) END;
WHILE i < var.Len() DO
var.Index(i, elem);
Strings.IntToString(i, n);
Gen(f, fv, p.link, n, wr, elem, x, y, m, first);
INC(i)
END;
IF m > max THEN max := m END;
IF (name # "") & (m > 0) THEN (* insert group *)
p.label := name$; v := Controls.dir.NewGroup(p);
w := m; x := x0; h := y + delta - y0; y := y0; back := TRUE
END
END
END;
IF v # NIL THEN
IF (name # "") & (p.label = "") THEN
p.label := name$;
str := Controls.dir.NewCaption(p); GetSize(str, w, h);
wr.WriteView(str, x, y, x + w, y + h); INC(x, w + delta);
FormViews.RoundToGrid(fv, x, y)
END;
IF ~back THEN GetSize(v, w, h) END;
wr.WriteView(v, x, y, x + w, y + h); INC(x, w + delta);
IF back THEN f.PutAbove(v, NIL) END;
y := y + h + delta
END;
IF x > max THEN max := x END;
x := x0
END Gen;
PROCEDURE NewDialog (name: ARRAY OF CHAR): Views.View;
VAR var: Meta.Item; x, y, max: INTEGER; wr: FormModels.Writer; d: Documents.Document;
f: FormModels.Model; v: FormViews.View; first: BOOLEAN; n: ARRAY 4 OF CHAR;
c: Containers.Controller;
BEGIN
f := NIL; v := NIL;
Meta.LookupPath(name, var);
IF (var.obj = Meta.varObj) OR (var.obj = Meta.modObj) THEN
x := defaultDelta; y := defaultDelta; max := 50 * Ports.point; first := TRUE;
f := FormModels.dir.New();
v := FormViews.dir.New(f); c := v.ThisController();
IF c # NIL THEN
c.SetOpts(Containers.layout)
ELSE
v.SetController(FormControllers.dir.NewController(Containers.layout))
END;
wr := f.NewWriter(NIL); wr.Set(NIL); n := "";
Gen(f, v, name, n, wr, var, x, y, max, first);
d := Documents.dir.New(v, max, y)
ELSE Dialog.ShowParamMsg("#Form:VariableNotFound", name, "", "")
END;
RETURN v
END NewDialog;
PROCEDURE Create*;
VAR v: Views.View; i, j: INTEGER; mod, name: Files.Name; loc: Files.Locator;
w: FormViews.View; c: Containers.Controller;
BEGIN
v := NIL;
IF new.link = "" THEN
w := FormViews.dir.New(FormModels.dir.New()); c := w.ThisController();
IF c # NIL THEN
c.SetOpts({FormControllers.noFocus})
ELSE
w.SetController(FormControllers.dir.NewController({FormControllers.noFocus}))
END;
v := w
ELSE
v := NewDialog(new.link)
END;
IF v # NIL THEN
mod := new.link$; new.link := ""; name := "";
StdCmds.CloseDialog;
IF mod # "" THEN
i := 0; WHILE (mod[i] # 0X) & (mod[i] # ".") DO INC(i) END;
IF mod[i] # 0X THEN (* module.variable *)
mod[i] := 0X; INC(i); j := 0;
WHILE mod[i] # 0X DO name[j] := mod[i]; INC(i); INC(j) END;
name[j] := 0X
END;
StdDialog.GetSubLoc(mod, "Rsrc", loc, mod);
IF name = "" THEN name := mod$ END;
loc.res := 77
ELSE
loc := NIL; name := ""
END;
Views.Open(v, loc, name, NIL);
Views.BeginModification(Views.notUndoable, v);
Views.EndModification(Views.notUndoable, v)
END
END Create;
PROCEDURE Empty*;
BEGIN
new.link := ""; Create
END Empty;
PROCEDURE CreateGuard* (VAR par: Dialog.Par);
BEGIN
IF new.link = "" THEN par.disabled := TRUE END
END CreateGuard;
END FormGen.
| Form/Mod/Gen.odc |
MODULE FormModels;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Ports, Stores, Models, Views, Properties, Containers;
CONST
minViewSize* = 4 * Ports.point; (** size of smallest embedded view **)
maxViewSize* = 1000 * Ports.mm; (** size of largest embedded view **)
(* range of currently supported versions *)
minVersion = 0; maxBaseVersion = 0; maxStdVersion = 0;
TYPE
(* interface types *)
Model* = POINTER TO ABSTRACT RECORD (Containers.Model) END;
Directory* = POINTER TO ABSTRACT RECORD END;
Context* = POINTER TO ABSTRACT RECORD (Models.Context) END;
Reader* = POINTER TO ABSTRACT RECORD
view*: Views.View; (** most recently read view **)
l*, t*, r*, b*: INTEGER (** bounding box of most recently read view **)
END;
Writer* = POINTER TO ABSTRACT RECORD END;
UpdateMsg* = RECORD (Models.UpdateMsg)
(** the receiver of this message must not switch on any marks **)
l*, t*, r*, b*: INTEGER (** (l < r) & (b < t) **)
END;
(* concrete types *)
StdDirectory = POINTER TO RECORD (Directory) END;
StdModel = POINTER TO RECORD (Model)
contexts: StdContext (* list of views in form, ordered from bottom to top *)
END;
StdContext = POINTER TO RECORD (Context)
next: StdContext; (* next upper view *)
form: StdModel; (* form # NIL *)
view: Views.View; (* view # NIL *)
l, t, r, b: INTEGER (* (r - l >= minViewSize) & (b - t >= minViewSize) *)
END;
StdReader = POINTER TO RECORD (Reader)
form: StdModel; (* form # NIL *)
pos: StdContext (* next ReadView: read view above pos *)
END;
StdWriter = POINTER TO RECORD (Writer)
form: StdModel; (* form # NIL *)
pos: StdContext (* next WriteView: insert view above pos *)
END;
FormOp = POINTER TO RECORD (Stores.Operation)
del, ins: StdContext; (* ((del = NIL) # (ins = NIL)) OR (del = ins) *)
pos: StdContext (* ins # NIL => next Do: insert ins above pos *)
END;
ResizeOp = POINTER TO RECORD (Stores.Operation)
context: StdContext; (* context # NIL *)
l, t, r, b: INTEGER (* (r - l >= minViewSize) & (b - t >= minViewSize) *)
END;
ReplaceViewOp = POINTER TO RECORD (Stores.Operation)
context: StdContext; (* context # NIL *)
view: Views.View (* view # NIL *)
END;
VAR dir-, stdDir-: Directory; (** (dir # NIL) & (stdDir # NIL) **)
(** Model **)
PROCEDURE (f: Model) GetEmbeddingLimits* (OUT minW, maxW,
minH, maxH: INTEGER), EXTENSIBLE;
BEGIN
minH := minViewSize; minW := minViewSize;
maxH := maxViewSize; maxW := maxViewSize
END GetEmbeddingLimits;
PROCEDURE (f: Model) Insert* (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(**
v # NIL 20
v.init 21
v.context = NIL 22
l <= r 23
t <= b 24
**)
PROCEDURE (f: Model) Delete* (v: Views.View), NEW, ABSTRACT;
(** v in f 20 **)
PROCEDURE (f: Model) Resize* (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(**
v in f 20
l <= r 21
t <= b 22
**)
PROCEDURE (f: Model) Top* (): Views.View, NEW, ABSTRACT;
PROCEDURE (f: Model) PutAbove* (v, pos: Views.View), NEW, ABSTRACT;
(**
v in f 20
(pos = NIL) OR (pos in f) 21
**)
PROCEDURE (f: Model) Move* (v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(** v in f 20 **)
PROCEDURE (f: Model) Copy* (VAR v: Views.View; dx, dy: INTEGER), NEW, ABSTRACT;
(** v in f 20 **)
PROCEDURE (f: Model) NewReader* (old: Reader): Reader, NEW, ABSTRACT;
PROCEDURE (f: Model) NewWriter* (old: Writer): Writer, NEW, ABSTRACT;
PROCEDURE (f: Model) ViewAt* (x, y: INTEGER): Views.View, NEW, ABSTRACT;
PROCEDURE (f: Model) NofViews* (): INTEGER, NEW, ABSTRACT;
(** Directory **)
PROCEDURE (d: Directory) New* (): Model, NEW, ABSTRACT;
(** Context **)
PROCEDURE (c: Context) ThisModel* (): Model, ABSTRACT;
PROCEDURE (c: Context) GetRect* (OUT l, t, r, b: INTEGER), NEW, ABSTRACT;
(** Reader **)
PROCEDURE (rd: Reader) Set* (pos: Views.View), NEW, ABSTRACT;
(** (pos = NIL) OR (pos in r's form) 20 **)
PROCEDURE (rd: Reader) ReadView* (OUT v: Views.View), NEW, ABSTRACT;
(** Writer **)
PROCEDURE (wr: Writer) Set* (pos: Views.View), NEW, ABSTRACT;
(** (pos = NIL) OR (pos in w's form) 20 **)
PROCEDURE (wr: Writer) WriteView* (v: Views.View; l, t, r, b: INTEGER), NEW, ABSTRACT;
(**
v # NIL 20
v.init 21
v.context = NIL 22
l <= r 23
t <= b 24
**)
(* StdModel *)
PROCEDURE ThisContext (f: StdModel; view: Views.View): StdContext;
VAR c: StdContext;
BEGIN
c := f.contexts; WHILE (c # NIL) & (c.view # view) DO c := c.next END;
RETURN c
END ThisContext;
PROCEDURE NewContext (form: StdModel; view: Views.View; l, t, r, b: INTEGER): StdContext;
VAR c: StdContext;
BEGIN
ASSERT(form # NIL, 100); ASSERT(view.context = NIL, 101);
IF r - l < minViewSize THEN r := l + minViewSize END;
IF b - t < minViewSize THEN b := t + minViewSize END;
NEW(c); c.form := form; c.view := view; c.l := l; c.t := t; c.r := r; c.b := b;
Stores.Join(form, view);
view.InitContext(c);
RETURN c
END NewContext;
PROCEDURE InsertAbove (c, pos: StdContext);
BEGIN
IF pos = NIL THEN
c.next := NIL; c.form.contexts := c
ELSE
c.next := pos.next; pos.next := c
END
END InsertAbove;
PROCEDURE (f: StdModel) Internalize (VAR rd: Stores.Reader);
VAR thisVersion, l, t, r, b, x: INTEGER; top, h: StdContext; v: Views.View;
BEGIN
rd.ReadVersion(minVersion, maxStdVersion, thisVersion);
IF ~rd.cancelled THEN
rd.ReadVersion(0, 0, thisVersion); rd.ReadInt(x); (* backward compatibility with Rel. 1.3 *)
Views.ReadView(rd, v); top := NIL;
WHILE v # NIL DO
rd.ReadInt(l); rd.ReadInt(t); rd.ReadInt(r); rd.ReadInt(b);
h := NewContext(f, v, l, t, r, b);
InsertAbove(h, top); top := h;
Views.ReadView(rd, v)
END
END
END Internalize;
PROCEDURE (f: StdModel) Externalize (VAR wr: Stores.Writer);
VAR c: StdContext;
BEGIN
wr.WriteVersion(maxStdVersion);
wr.WriteVersion(0); wr.WriteInt(0); (* backward compatibility with Rel. 1.3 *)
c := f.contexts;
WHILE c # NIL DO
IF Stores.ExternalizeProxy(c.view) # NIL THEN
Views.WriteView(wr, c.view);
wr.WriteInt(c.l); wr.WriteInt(c.t);
wr.WriteInt(c.r); wr.WriteInt(c.b)
END;
c := c.next
END;
wr.WriteStore(NIL)
END Externalize;
PROCEDURE (f: StdModel) CopyFrom (source: Stores.Store);
VAR c, top, h: StdContext;
BEGIN
WITH source: StdModel DO
c := source.contexts; top := NIL;
WHILE c # NIL DO
h := NewContext(f, Views.CopyOf(c.view, Views.deep), c.l, c.t, c.r, c.b);
InsertAbove(h, top); top := h;
c := c.next
END
END
END CopyFrom;
PROCEDURE (f: StdModel) InitFrom (source: Containers.Model);
BEGIN
f.contexts := NIL
END InitFrom;
PROCEDURE (f: StdModel) ReplaceView (old, new: Views.View);
VAR op: ReplaceViewOp; c: StdContext;
BEGIN
c := ThisContext(f, old); ASSERT(c # NIL, 20);
ASSERT(new # NIL, 21); ASSERT((new.context = NIL) OR (new.context = c), 23);
IF old # new THEN
(* Stores.InitDomain(new, f.domain); *) Stores.Join(f, new);
new.InitContext(c); (* both views share same context *)
NEW(op); op.context := c; op.view := new;
Models.Do(f, "#System:ReplaceView", op)
END
END ReplaceView;
PROCEDURE (f: StdModel) Insert (v: Views.View; l, t, r, b: INTEGER);
VAR op: FormOp; c, h, top: StdContext;
BEGIN
ASSERT(v # NIL, 20); ASSERT(v.context = NIL, 22);
ASSERT(l <= r, 23); ASSERT(t <= b, 24);
h := f.contexts; top := NIL; WHILE h # NIL DO top := h; h := h.next END;
c := NewContext(f, v, l, t, r, b);
NEW(op); op.del := NIL; op.ins := c; op.pos := top;
Models.Do(f, "#System:Insertion", op)
END Insert;
PROCEDURE (f: StdModel) Delete (v: Views.View);
VAR op: FormOp; c: StdContext;
BEGIN
c := ThisContext(f, v); ASSERT(c # NIL, 20);
NEW(op); op.del := c; op.ins := NIL; op.pos := NIL;
Models.Do(f, "#System:Deletion", op)
END Delete;
PROCEDURE (f: StdModel) Resize (v: Views.View; l, t, r, b: INTEGER);
VAR op: ResizeOp; c: StdContext;
BEGIN
c := ThisContext(f, v); ASSERT(c # NIL, 20);
ASSERT(r >= l, 21); ASSERT(b >= t, 22);
IF r - l < minViewSize THEN r := l + minViewSize END;
IF b - t < minViewSize THEN b := t + minViewSize END;
NEW(op); op.context := c; op.l := l; op.t := t; op.r := r; op.b := b;
Models.Do(f, "#System:Resizing", op)
END Resize;
PROCEDURE (f: StdModel) Top (): Views.View;
VAR h, top: StdContext;
BEGIN
top := NIL; h := f.contexts;
WHILE h # NIL DO top := h; h := h.next END;
IF top # NIL THEN RETURN top.view ELSE RETURN NIL END
END Top;
PROCEDURE (f: StdModel) PutAbove (v, pos: Views.View);
VAR op: FormOp; c, d: StdContext;
BEGIN
c := ThisContext(f, v); ASSERT(c # NIL, 20);
d := ThisContext(f, pos); ASSERT((pos = NIL) OR (d # NIL), 21);
IF v # pos THEN
NEW(op); op.del := c; op.ins := c; op.pos := d;
Models.Do(f, "#Form:ChangeZOrder", op)
END
END PutAbove;
PROCEDURE (f: StdModel) Move (v: Views.View; dx, dy: INTEGER);
VAR op: ResizeOp; c: StdContext;
BEGIN
c := ThisContext(f, v); ASSERT(c # NIL, 20);
IF (dx # 0) OR (dy # 0) THEN
NEW(op); op.context := c;
op.l := c.l + dx; op.t := c.t + dy; op.r := c.r + dx; op.b := c.b + dy;
Models.Do(f, "#System:Moving", op)
END
END Move;
PROCEDURE (f: StdModel) Copy (VAR v: Views.View; dx, dy: INTEGER);
VAR op: FormOp; c, h, top: StdContext;
BEGIN
c := ThisContext(f, v); ASSERT(c # NIL, 20);
h := f.contexts; top := NIL; WHILE h # NIL DO top := h; h := h.next END;
h := NewContext(f, Views.CopyOf(v, Views.deep), c.l + dx, c.t + dy, c.r + dx, c.b + dy);
NEW(op); op.del := NIL; op.ins := h; op.pos := top;
Models.Do(f, "#System:Copying", op);
v := h.view
END Copy;
PROCEDURE (f: StdModel) NewReader (old: Reader): Reader;
VAR r: StdReader;
BEGIN
IF (old = NIL) OR ~(old IS StdReader) THEN NEW(r) ELSE r := old(StdReader) END;
r.view := NIL; r.l := 0; r.t := 0; r.r := 0; r.b := 0;
r.form := f; r.pos := NIL;
RETURN r
END NewReader;
PROCEDURE (f: StdModel) NewWriter (old: Writer): Writer;
VAR w: StdWriter;
BEGIN
IF (old = NIL) OR ~(old IS StdWriter) THEN NEW(w) ELSE w := old(StdWriter) END;
w.form := f; w.pos := NIL;
RETURN w
END NewWriter;
PROCEDURE (f: StdModel) ViewAt (x, y: INTEGER): Views.View;
VAR c, top: StdContext;
BEGIN
c := f.contexts; top := NIL;
WHILE c # NIL DO
IF (x >= c.l) & (y >= c.t) & (x < c.r) & (y < c.b) THEN top := c END;
c := c.next
END;
IF top = NIL THEN RETURN NIL ELSE RETURN top.view END
END ViewAt;
PROCEDURE (f: StdModel) NofViews (): INTEGER;
VAR c: StdContext; n: INTEGER;
BEGIN
n := 0; c := f.contexts; WHILE c # NIL DO INC(n); c := c.next END;
RETURN n
END NofViews;
(* StdContext *)
PROCEDURE (c: StdContext) ThisModel (): Model;
BEGIN
RETURN c.form
END ThisModel;
PROCEDURE (c: StdContext) GetSize (OUT w, h: INTEGER);
BEGIN
w := c.r - c.l; h := c.b - c.t
END GetSize;
PROCEDURE (c: StdContext) SetSize (w, h: INTEGER);
VAR w0, h0: INTEGER;
BEGIN
w0 := c.r - c.l; h0 := c.b - c.t; ASSERT(w0 > 0, 100); ASSERT(h0 > 0, 101);
Properties.PreferredSize(
c.view, minViewSize, maxViewSize, minViewSize, maxViewSize, w0, h0, w, h);
IF (w # w0) OR (h # h0) THEN
c.form.Resize(c.view, c.l, c.t, c.l + w, c.t + h)
END
END SetSize;
PROCEDURE (c: StdContext) Normalize (): BOOLEAN;
BEGIN
RETURN FALSE
END Normalize;
PROCEDURE (c: StdContext) GetRect (OUT l, t, r, b: INTEGER);
BEGIN
l := c.l; t := c.t; r := c.r; b := c.b
END GetRect;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New (): Model;
VAR f: StdModel;
BEGIN
NEW(f); RETURN f
END New;
(* StdReader *)
PROCEDURE (rd: StdReader) Set (pos: Views.View);
VAR c: StdContext;
BEGIN
IF pos = NIL THEN c := NIL ELSE c := ThisContext(rd.form, pos); ASSERT(c # NIL, 20) END;
rd.view := NIL; rd.l := 0; rd.t := 0; rd.r := 0; rd.b := 0;
rd.pos := c
END Set;
PROCEDURE (rd: StdReader) ReadView (OUT v: Views.View);
VAR c: StdContext;
BEGIN
c := rd.pos;
IF c = NIL THEN c := rd.form.contexts ELSE c := c.next END;
IF c # NIL THEN
rd.view := c.view; rd.l := c.l; rd.t := c.t; rd.r := c.r; rd.b := c.b;
rd.pos := c
ELSE
rd.view := NIL; rd.l := 0; rd.t := 0; rd.r := 0; rd.b := 0
END;
v := rd.view
END ReadView;
(* StdWriter *)
PROCEDURE (wr: StdWriter) Set (pos: Views.View);
VAR c: StdContext;
BEGIN
IF pos = NIL THEN c := NIL ELSE c := ThisContext(wr.form, pos); ASSERT(c # NIL, 20) END;
wr.pos := c
END Set;
PROCEDURE (wr: StdWriter) WriteView (v: Views.View; l, t, r, b: INTEGER);
VAR op: FormOp; c: StdContext;
BEGIN
ASSERT(v # NIL, 20); ASSERT(v.context = NIL, 22);
ASSERT(l <= r, 23); ASSERT(t <= b, 24);
c := NewContext(wr.form, v, l, t, r, b);
NEW(op); op.del := NIL; op.ins := c; op.pos := wr.pos;
wr.pos := c;
Models.Do(wr.form, "#System:Insertion", op)
END WriteView;
(* operations *)
PROCEDURE Update (c: StdContext);
VAR msg: UpdateMsg;
BEGIN
msg.l := c.l; msg.t := c.t; msg.r := c.r; msg.b := c.b; Models.Broadcast(c.form, msg)
END Update;
PROCEDURE (op: FormOp) Do;
VAR f: StdModel; c, p, pos: StdContext;
BEGIN
(* delete *)
pos := NIL;
c := op.del;
IF c # NIL THEN
f := c.form; ASSERT(f # NIL, 100);
p := f.contexts; ASSERT(p # NIL, 101);
IF p = c THEN
f.contexts := c.next
ELSE
WHILE p.next # c DO p := p.next; ASSERT(p # NIL, 102) END;
pos := p; p.next := c.next
END;
c.next := NIL;
Update(c)
END;
(* insert *)
c := op.ins;
IF c # NIL THEN
f := c.form; ASSERT(f # NIL, 103);
p := f.contexts;
IF op.pos = NIL THEN
c.next := f.contexts; f.contexts := c
ELSE
c.next := op.pos.next; op.pos.next := c
END;
Update(c)
END;
(* swap ins and del for undo *)
p := op.del; op.del := op.ins; op.ins := p; op.pos := pos
END Do;
PROCEDURE (op: ResizeOp) Do;
VAR c: StdContext; l, t, r, b: INTEGER;
BEGIN
c := op.context;
(* save old state of context *)
l := c.l; t := c.t; r := c.r; b := c.b;
Update(c);
(* set new state of context *)
c.l := op.l; c.t := op.t; c.r := op.r; c.b := op.b;
Update(c);
(* old state is new undo state *)
op.l := l; op.t := t; op.r := r; op.b := b
END Do;
PROCEDURE (op: ReplaceViewOp) Do;
VAR c: StdContext; view: Views.View;
BEGIN
c := op.context;
(* save old state of context *)
view := c.view;
(* set new state of context *)
c.view := op.view;
Update(c);
(* old state is new undo state *)
op.view := view
END Do;
(** miscellaneous **)
PROCEDURE New* (): Model;
BEGIN
RETURN dir.New()
END New;
PROCEDURE CloneOf* (source: Model): Model;
BEGIN
ASSERT(source # NIL, 20);
RETURN Containers.CloneOf(source)(Model)
END CloneOf;
PROCEDURE Copy* (source: Model): Model;
BEGIN
ASSERT(source # NIL, 20);
RETURN Stores.CopyOf(source)(Model)
END Copy;
PROCEDURE SetDir* (d: Directory);
(** d # NIL 20 **)
BEGIN
ASSERT(d # NIL, 20); dir := d
END SetDir;
PROCEDURE Init;
VAR d: StdDirectory;
BEGIN
NEW(d); dir := d; stdDir := d
END Init;
BEGIN
Init
END FormModels.
| Form/Mod/Models.odc |
MODULE FormViews;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
purpose = ""
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Dialog, Ports, Stores, Models, Views, Controllers, Properties, Containers, FormModels;
CONST
(** minimal border between form view and any embedded view: **)
minBorder* = 4 * Ports.point; maxBorder* = 100 * Ports.mm;
maxSize = 600 * Ports.mm;
(* range of currently supported versions *)
minVersion = 0; maxBaseVersion = 2; maxStdVersion = 1;
TYPE
View* = POINTER TO ABSTRACT RECORD (Containers.View) END;
Directory* = POINTER TO ABSTRACT RECORD END;
StdView = POINTER TO RECORD (View)
border: INTEGER;
grid: INTEGER; (* grid > 0 *)
gridFactor: INTEGER; (* gridFactor > 0 *)
background: Ports.Color;
cache: FormModels.Reader (* reuse form reader *)
END;
StdDirectory = POINTER TO RECORD (Directory) END;
ViewOp = POINTER TO RECORD (Stores.Operation)
view: StdView; (* view # NIL *)
border: INTEGER; (* border >= minBorder *)
grid: INTEGER; (* grid > 0 *)
gridFactor: INTEGER; (* gridFactor > 0 *)
background: Ports.Color
END;
VAR
dir-, stdDir-: Directory;
ctrldir-: Containers.Directory;
(** View **)
PROCEDURE (v: View) Internalize2- (VAR rd: Stores.Reader), EXTENSIBLE;
VAR thisVersion: INTEGER;
BEGIN
IF ~rd.cancelled THEN
rd.ReadVersion(minVersion, maxBaseVersion, thisVersion);
IF~ rd.cancelled THEN
IF thisVersion IN {0, 1} THEN
WITH v: StdView DO (* backward compatibility with Rel. 1.3 *)
rd.ReadInt(v.border);
rd.ReadInt(v.grid);
rd.ReadXInt(v.gridFactor);
IF thisVersion = 1 THEN
rd.ReadInt(v.background)
ELSE
v.background := Ports.defaultColor
END
END
END
END
END
END Internalize2;
PROCEDURE (v: View) Externalize2- (VAR wr: Stores.Writer), EXTENSIBLE;
BEGIN
wr.WriteVersion(maxBaseVersion)
END Externalize2;
PROCEDURE (v: View) ThisModel* (): FormModels.Model, EXTENSIBLE;
VAR m: Containers.Model;
BEGIN
m := v.ThisModel^();
IF m = NIL THEN RETURN NIL ELSE RETURN m(FormModels.Model) END
END ThisModel;
PROCEDURE (v: View) SetBorder* (border: INTEGER), NEW, ABSTRACT;
(** border >= 0 20 **)
PROCEDURE (v: View) Border* (): INTEGER, NEW, ABSTRACT;
PROCEDURE (v: View) SetGrid* (grid, gridFactor: INTEGER), NEW, ABSTRACT;
(**
grid > 0 20
gridFactor > 0 21
**)
PROCEDURE (v: View) Grid* (): INTEGER, NEW, ABSTRACT;
PROCEDURE (v: View) GridFactor* (): INTEGER, NEW, ABSTRACT;
PROCEDURE (v: View) SetBackground* (background: Ports.Color), NEW, ABSTRACT;
(** Directory **)
PROCEDURE (d: Directory) New* (f: FormModels.Model): View, NEW, ABSTRACT;
(**
f # NIL 20
f.init 21
**)
(* ViewOp *)
PROCEDURE (op: ViewOp) Do;
VAR border, grid, gridFactor: INTEGER; background: Ports.Color;
BEGIN
(* save old state of view *)
border := op.view.border; grid := op.view.grid; gridFactor := op.view.gridFactor;
background := op.view.background;
(* set new state of view *)
op.view.border := op.border; op.view.grid := op.grid; op.view.gridFactor := op.gridFactor;
op.view.background := op.background;
Views.Update(op.view, Views.keepFrames);
(* old state is new undo state *)
op.border := border; op.grid := grid; op.gridFactor := gridFactor;
op.background := background
END Do;
(* StdView *)
PROCEDURE (v: StdView) Internalize2 (VAR rd: Stores.Reader);
VAR thisVersion: INTEGER;
BEGIN
v.Internalize2^(rd);
IF ~rd.cancelled THEN
rd.ReadVersion(minVersion, maxStdVersion, thisVersion);
IF thisVersion # 0 THEN
rd.ReadInt(v.border);
rd.ReadInt(v.grid);
rd.ReadInt(v.gridFactor);
rd.ReadInt(v.background)
END
END
END Internalize2;
PROCEDURE (v: StdView) Externalize2 (VAR wr: Stores.Writer);
BEGIN
v.Externalize2^(wr);
wr.WriteVersion(maxStdVersion);
wr.WriteInt(v.border);
wr.WriteInt(v.grid);
wr.WriteInt(v.gridFactor);
wr.WriteInt(v.background)
END Externalize2;
PROCEDURE (v: StdView) CopyFromModelView2 (source: Views.View; model: Models.Model);
BEGIN
WITH source: StdView DO
v.border := source.border;
v.grid := source.grid;
v.gridFactor := source.gridFactor;
v.background := source.background
END
END CopyFromModelView2;
PROCEDURE (d: StdView) AcceptableModel (m: Containers.Model): BOOLEAN;
BEGIN
RETURN m IS FormModels.Model
END AcceptableModel;
PROCEDURE (v: StdView) InitModel2 (m: Containers.Model);
BEGIN
ASSERT(m IS FormModels.Model, 23)
END InitModel2;
PROCEDURE (v: StdView) GetRect (f: Views.Frame; view: Views.View; OUT l, t, r, b: INTEGER);
BEGIN
view.context(FormModels.Context).GetRect(l, t, r, b)
END GetRect;
PROCEDURE (v: StdView) SetBorder (border: INTEGER);
VAR op: ViewOp;
BEGIN
ASSERT(border >= 0, 20);
IF border < minBorder THEN
border := minBorder
ELSIF border > maxBorder THEN
border := maxBorder
END;
NEW(op); op.view := v; op.border := border;
op.grid := v.grid; op.gridFactor := v.gridFactor;
op.background := v.background;
Views.Do(v, "#Form:BorderChange", op)
END SetBorder;
PROCEDURE (v: StdView) Border (): INTEGER;
BEGIN
RETURN v.border
END Border;
PROCEDURE (v: StdView) SetGrid (grid, gridFactor: INTEGER);
VAR op: ViewOp;
BEGIN
ASSERT(grid > 0, 20); ASSERT(gridFactor > 0, 21);
NEW(op); op.view := v; op.border := v.border;
op.grid := grid; op.gridFactor := gridFactor;
op.background := v.background;
Views.Do(v, "#Form:GridChange", op)
END SetGrid;
PROCEDURE (v: StdView) Grid (): INTEGER;
BEGIN
RETURN v.grid
END Grid;
PROCEDURE (v: StdView) GridFactor (): INTEGER;
BEGIN
RETURN v.gridFactor
END GridFactor;
PROCEDURE (v: StdView) SetBackground (background: Ports.Color);
VAR op: ViewOp;
BEGIN
NEW(op); op.view := v; op.border := v.border;
op.grid := v.grid; op.gridFactor := v.gridFactor;
op.background := background;
Views.Do(v, "#Form:BackgroundChange", op)
END SetBackground;
PROCEDURE (v: StdView) GetBackground (VAR color: Ports.Color);
BEGIN
IF v.background = Ports.defaultColor THEN
color := Ports.dialogBackground
ELSE
color := v.background
END
END GetBackground;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR form: FormModels.Model; ctrl: Containers.Controller;
focus, q: Views.View; k, w, h, x, y: INTEGER; s: FormModels.Reader;
BEGIN
form := v.ThisModel();
IF form # NIL THEN
ctrl := v.ThisController();
IF ctrl # NIL THEN focus := ctrl.ThisFocus() ELSE focus := NIL END;
s := form.NewReader(v.cache); v.cache := s;
s.Set(NIL); s.ReadView(q); k := 0;
WHILE q # NIL DO
IF (s.r >= l) & (s.b >= t) & (s.l < r) & (s.t < b) THEN
Views.InstallFrame(f, q, s.l, s.t, k, q = focus)
END;
s.ReadView(q); INC(k)
END
ELSE
f.DrawRect(l, t, r, b, Ports.fill, Ports.grey12)
END;
IF (ctrl # NIL) & ~(Containers.noCaret IN ctrl.opts) THEN
k := v.grid * v.gridFactor; ASSERT(k > 0, 100);
v.context.GetSize(w, h);
IF w > maxSize THEN w := maxSize END;
IF h > maxSize THEN h := maxSize END;
x := l - l MOD k;
WHILE x <= w DO
f.MarkRect(x, 0, x + f.unit, h, Ports.fill, Ports.dim50, Ports.show);
INC(x, k)
END;
y := t - t MOD k;
WHILE y <= h DO
f.MarkRect(0, y, w, y + f.unit, Ports.fill, Ports.dim50, Ports.show);
INC(y, k)
END
END
END Restore;
PROCEDURE (v: StdView) HandleModelMsg2 (VAR msg: Models.Message);
BEGIN
WITH msg: Models.UpdateMsg DO
WITH msg: FormModels.UpdateMsg DO
Views.UpdateIn(v, msg.l, msg.t, msg.r, msg.b, Views.rebuildFrames)
ELSE
Views.Update(v, Views.rebuildFrames) (* catch all update messages *)
END
ELSE
END
END HandleModelMsg2;
PROCEDURE GetBounds (v: StdView; VAR w, h: INTEGER);
VAR form: FormModels.Model; r, b: INTEGER; p: FormModels.Reader; q: Views.View;
BEGIN
form := v.ThisModel();
IF form # NIL THEN
p := form.NewReader(v.cache); v.cache := p;
p.Set(NIL); (* set reader to bottom of view list *)
p.ReadView(q); (* read bottom-most view *)
IF q # NIL THEN
r := 0; b := 0;
WHILE q # NIL DO
IF p.r > r THEN r := p.r END;
IF p.b > b THEN b := p.b END;
p.ReadView(q)
END;
w := r + v.border; h := b + v.border
ELSE
w := 0; h := 0
END
ELSE
w := 0; h := 0
END
END GetBounds;
PROCEDURE AssertRange (border: INTEGER; VAR w, h: INTEGER);
VAR min: INTEGER;
BEGIN (* prevent illegal values *)
min := 2 * border + FormModels.minViewSize;
IF w = Views.undefined THEN w := 100 * Ports.mm
ELSIF w < min THEN w := min
ELSIF w > maxSize THEN w := maxSize
END;
IF h = Views.undefined THEN h := 70 * Ports.mm
ELSIF h < min THEN h := min
ELSIF h > maxSize THEN h := maxSize
END
END AssertRange;
PROCEDURE (v: StdView) HandlePropMsg2 (VAR p: Properties.Message);
VAR sp: Properties.StdProp; q: Properties.Property;
BEGIN
WITH p: Properties.BoundsPref DO
GetBounds(v, p.w, p.h)
| p: Properties.SizePref DO
AssertRange(v.border, p.w, p.h)
| p: Properties.PollMsg DO
NEW(sp); sp.valid := {Properties.color}; sp.known := sp.valid;
sp.color.val := v.background; p.prop := sp
| p: Properties.SetMsg DO
q := p.prop;
WHILE q # NIL DO
WITH q: Properties.StdProp DO
IF (Properties.color IN q.valid) & (q.color.val # v.background) THEN
v.SetBackground(q.color.val)
END;
ELSE
END;
q :=q.next
END
| p: Containers.DropPref DO
p.okToDrop := TRUE
ELSE
END
END HandlePropMsg2;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New (f: FormModels.Model): View;
VAR v: StdView; grid, gridFactor: INTEGER;
BEGIN
ASSERT(f # NIL, 20);
NEW(v); v.InitModel(f);
IF ctrldir # NIL THEN v.SetController(ctrldir.New()) END;
v.SetBorder(minBorder);
IF Dialog.metricSystem THEN
grid := 2 * Ports.mm; gridFactor := 5 (* place at 2 mm resolution *)
ELSE
grid := Ports.inch DIV 16; gridFactor := 8 (* place at 1/16 inch resolution *)
END;
v.SetGrid(grid, gridFactor);
v.background := Ports.defaultColor;
RETURN v
END New;
(** miscellaneous **)
PROCEDURE Focus* (): View;
VAR v: Views.View;
BEGIN
v := Controllers.FocusView();
IF (v # NIL) & (v IS View) THEN RETURN v(View) ELSE RETURN NIL END
END Focus;
PROCEDURE FocusModel* (): FormModels.Model;
VAR v: View;
BEGIN
v := Focus();
IF v # NIL THEN RETURN v.ThisModel() ELSE RETURN NIL END
END FocusModel;
PROCEDURE RoundToGrid* (v: View; VAR x, y: INTEGER);
VAR grid: INTEGER;
BEGIN
grid := v.Grid();
x := x + grid DIV 2;
y := y + grid DIV 2;
x := x - x MOD grid;
y := y - y MOD grid
END RoundToGrid;
PROCEDURE New* (): View;
BEGIN
RETURN dir.New(FormModels.dir.New())
END New;
PROCEDURE Deposit*;
BEGIN
Views.Deposit(New())
END Deposit;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20); dir := d
END SetDir;
PROCEDURE SetCtrlDir* (d: Containers.Directory);
BEGIN
ASSERT(d # NIL, 20); ctrldir := d
END SetCtrlDir;
PROCEDURE Init;
VAR d: StdDirectory; res: INTEGER;
BEGIN
Dialog.Call("FormControllers.Install", "#Form:CntrlInstallFailed", res);
NEW(d); dir := d; stdDir := d
END Init;
BEGIN
Init
END FormViews.
| Form/Mod/Views.odc |
Form/Rsrc/Cmds.odc |
|
Form/Rsrc/Cmds2.odc |
|
Form/Rsrc/Gen.odc |
|
MENU "Разметка" ("FormViews.View")
SEPARATOR
"Выровнять влево" "" "FormCmds.AlignLeft" "FormCmds.SelectionGuard"
"Выровнять вправо" "" "FormCmds.AlignRight" "FormCmds.SelectionGuard"
"Выровнять вверх" "" "FormCmds.AlignTop" "FormCmds.SelectionGuard"
"Выровнять вниз" "" "FormCmds.AlignBottom" "FormCmds.SelectionGuard"
"Выровнять центры по горизонтали" "" "FormCmds.AlignToRow" "FormCmds.SelectionGuard"
"Выровнять центры по вертикали" "" "FormCmds.AlignToColumn" "FormCmds.SelectionGuard"
SEPARATOR
"Set &Grid..." "" "FormCmds.InitGridDialog; StdCmds.OpenToolDialog('Form/Rsrc/Cmds', 'Set Grid')"
"FormCmds.FocusGuard"
"&Select Off-Grid Views" "" "FormCmds.SelectOffGridViews" ""
"&Force To Grid" "" "FormCmds.ForceToGrid" "FormCmds.SelectionGuard"
SEPARATOR
"Сделать первым/задним" "" "FormCmds.SetAsFirst" "FormCmds.SingletonGuard"
"Сделать последним/передним" "F5" "FormCmds.SetAsLast" "FormCmds.SingletonGuard"
"Сортировать элементы диалога" "" "FormCmds.SortViews" ""
SEPARATOR
"Заменить..." "" "StdCmds.OpenToolDialog('Form/Rsrc/Cmds2', '#Form:Replace Strings in Control Field')" "StdCmds.ContainerGuard"
SEPARATOR
"Пересчитать размер" "" "StdCmds.RecalcFocusSize" ""
END
| Form/Rsrc/Menus.odc |
STRINGS
OK, Apply, Cancel, Close см. System
(Form)Cmds (Form)Cmds
&Resolution: Разрешение:
&mm мм
1/16 &inch 1/16 дюйма
Set Установить
(Form)Cmds2 (Form)Cmds2
Replace this: Заменить:
with this: на:
Replace &All Заменить все
in: в:
Link Field поле связи
Label Field поле ярлыка
Guard Field поле охраны
Notifier Field поле уведомителя
(Form)Cmds2 (Form)Cmds2
&Link: Связать с:
&Empty Пустая
Replace Strings in Control Field Замена строк в полях элементов упр-я
Set Grid Set Grid
AlignBottom Выровнять снизу
AlignHorizontal Выровнять горизонтально
AlignLeft Выровнять слева
AlignRight Выровнять справа
AlignTop Выровнять сверху
AlignVertical Выровнять вертикально
BorderChange Border Change
ChangeZOrder Change Z Order
CntrlInstallFailed form controller installation failed
ForceToGrid Выровнять по сетке
Globals Globals
GridChange Изменение сетки
InsertAround Вставка вокруг
ModuleNotFound модуль ^0 не найден
SetEnabled Set Enabled
SetName Задать имя
VariableNoRecord переменная ^0 не является записью или пустым указателем
VariableNotFound переменная ^0 не найдена
VariableNotFoundIn переменная ^0 не найдена в ^1
FormViews.StdViewDesc standard Form view
FormModels.StdModelDesc standard Form model
FormControllers.StdControllerDesc standard Form controller
| Form/Rsrc/Strings.odc |
HostBitmaps
This module has a private interface, it is only used internally. | Host/Docu/Bitmaps.odc |
HostCFrames
This module has a private interface, it is only used internally. | Host/Docu/CFrames.odc |
HostClipboard
This module has a private interface, it is only used internally. | Host/Docu/Clipboard.odc |
HostCmds
This module has a private interface, it is only used internally. | Host/Docu/Cmds.odc |
HostDialog
This module has a private interface, it is only used internally. | Host/Docu/Dialog.odc |
HostFiles
This module has a private interface, it is only used internally. | Host/Docu/Files.odc |
HostFonts
This module has a private interface, it is only used internally. | Host/Docu/Fonts.odc |
HostMail
This module has a private interface, it is only used internally. | Host/Docu/Mail.odc |
HostMechanisms
This module has a private interface, it is only used internally. | Host/Docu/Mechanisms.odc |
HostMenus
This module has a private interface, it is only used internally. | Host/Docu/Menus.odc |
HostPackedFiles
This module has a private interface, it is only used internally. | Host/Docu/PackedFiles.odc |
HostPictures
This module has a private interface, it is only used internally. | Host/Docu/Pictures.odc |
HostPorts
This module has a private interface, it is only used internally. | Host/Docu/Ports.odc |
HostPrinters
This module has a private interface, it is only used internally. | Host/Docu/Printers.odc |
HostRegistry
This module has a private interface, it is only used internally. | Host/Docu/Registry.odc |
HostTabFrames
This module has a private interface, it is only used internally. | Host/Docu/TabFrames.odc |
HostTextConv
This module has a private interface, it is only used internally. | Host/Docu/TextConv.odc |
HostWindows
This module has a private interface, it is only used internally. | Host/Docu/Windows.odc |
MODULE HostBitmaps;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, WinApi, WinOle,
Files, Fonts, Ports, Stores, Models, Views, Controllers, Containers, Properties, Dialog, Converters,
HostPorts, HostWindows;
CONST
minVersion = 0; maxVersion = 1;
TYPE
Model = POINTER TO RECORD
file: Files.File;
pos, len: INTEGER;
ref: WinApi.HBITMAP
END;
StdView = POINTER TO RECORD (Views.View)
model: Model;
w, h: INTEGER; (* in pixels *)
bits: INTEGER; (* bit per pixel *)
END;
BITMAPINFO8 = RECORD [untagged]
header: WinApi.BITMAPINFOHEADER;
colors: ARRAY 256 OF INTEGER
END;
RootContext = POINTER TO RECORD (Models.Context)
w, h: INTEGER
END;
RootView = POINTER TO RECORD (Views.View)
view: Views.View;
END;
(* helpers for painting to bitmap *)
PROCEDURE (c: RootContext) ThisModel (): Models.Model;
BEGIN
RETURN NIL
END ThisModel;
PROCEDURE (c: RootContext) GetSize (OUT w, h: INTEGER);
BEGIN
w := c.w; h := c.h
END GetSize;
PROCEDURE (c: RootContext) Normalize (): BOOLEAN;
BEGIN
RETURN TRUE
END Normalize;
PROCEDURE (d: RootView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
BEGIN
Views.InstallFrame(f, d.view, 0, 0, 0, FALSE)
END Restore;
PROCEDURE (d: RootView) GetNewFrame (VAR frame: Views.Frame);
VAR f: Views.RootFrame;
BEGIN
NEW(f); frame := f
END GetNewFrame;
PROCEDURE (d: RootView) GetBackground (VAR color: Ports.Color);
BEGIN
color := Ports.background
END GetBackground;
PROCEDURE Paint (dc: WinApi.HDC; v: Views.View; w, h, unit: INTEGER);
VAR d: RootView; c: RootContext; p: HostPorts.Port; f: Views.RootFrame; g: Views.Frame;
BEGIN
NEW(p);
p.Init(unit, Ports.screen);
p.SetSize(w, h);
p.SetDC(dc, 0);
NEW(c);
c.w := w * p.unit;
c.h := h * p.unit;
NEW(d);
d.view := Views.CopyOf(v, Views.shallow);
Stores.Join(d, d.view);
d.InitContext(c);
d.view.InitContext(c);
Stores.InitDomain(d);
d.GetNewFrame(g); f := g(Views.RootFrame); f.ConnectTo(p);
Views.SetRoot(f, d, FALSE, {});
Views.AdaptRoot(f);
Views.RestoreRoot(f, 0, 0, c.w, c.h);
END Paint;
PROCEDURE GetHeader (v: StdView; OUT hdr: WinApi.BITMAPINFOHEADER; OUT colors: INTEGER);
BEGIN
hdr.biSize := SIZE(WinApi.BITMAPINFOHEADER);
hdr.biWidth := v.w;
hdr.biHeight := v.h;
hdr.biPlanes := 1;
hdr.biBitCount := SHORT(v.bits);
IF v.bits = 8 THEN (* use 8 bit & run length encoding *)
hdr.biCompression := WinApi.BI_RLE8;
colors := 256
ELSIF v.bits = 24 THEN (* use 24 bit true color *)
hdr.biCompression := WinApi.BI_RGB;
colors := 0
ELSIF v.bits = 0 THEN (* use jpeg *)
hdr.biCompression := 4 (* WinApi.BI_JPEG *);
colors := 0
ELSE
HALT(100) (* unsupported format *)
END;
hdr.biSizeImage := 0;
hdr.biXPelsPerMeter := 0;
hdr.biYPelsPerMeter := 0;
hdr.biClrUsed := 0;
hdr.biClrImportant := 0
END GetHeader;
PROCEDURE Evaluate (v: StdView; dc: WinApi.HDC);
VAR len, adr, res, colors, i: INTEGER;
rd: Stores.Reader; info: BITMAPINFO8; data: POINTER TO ARRAY OF BYTE;
BEGIN
rd.ConnectTo(v.model.file);
rd.SetPos(v.model.pos);
len := v.model.len;
GetHeader(v, info.header, colors);
i := 0; WHILE i < colors DO rd.ReadInt(info.colors[i]); INC(i); DEC(len, 4) END;
NEW(data, len);
rd.rider.ReadBytes(data^, 0, len);
v.model.ref := WinApi.CreateCompatibleBitmap(dc, v.w, v.h);
info.header.biSizeImage := len;
res := WinApi.SetDIBits(dc, v.model.ref, 0, v.h, SYSTEM.ADR(data[0]),
SYSTEM.VAL(WinApi.BITMAPINFO, info), WinApi.DIB_RGB_COLORS);
IF res = 0 THEN
res := WinApi.GetLastError();
IF res = WinApi.ERROR_NOT_ENOUGH_MEMORY THEN HALT(101) ELSE HALT(100) END
END;
ASSERT(v.model.ref # 0, 102)
END Evaluate;
(* Model *)
PROCEDURE (m: Model) FINALIZE;
VAR res: INTEGER;
BEGIN
IF m.ref # 0 THEN
res := WinApi.DeleteObject(m.ref);
m.ref := 0
END
END FINALIZE;
(* View *)
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR m: Model; thisVersion: INTEGER;
BEGIN
v.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxVersion, thisVersion);
IF rd.cancelled THEN RETURN END;
rd.ReadInt(v.w);
rd.ReadInt(v.h);
IF thisVersion > 0 THEN rd.ReadInt(v.bits) ELSE v.bits := 24 END;
NEW(m); m.file := rd.rider.Base();
rd.ReadInt(m.len);
m.pos := rd.Pos();
m.ref := 0; (* lazy allocation of bitmap data *)
v.model := m;
rd.SetPos(m.pos + m.len)
END Internalize;
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
VAR len, res, colors, i: INTEGER;
r: Files.Reader; b: BYTE; info: BITMAPINFO8; data: POINTER TO ARRAY OF BYTE;
BEGIN
v.Externalize^(wr);
wr.WriteVersion(maxVersion);
wr.WriteInt(v.w);
wr.WriteInt(v.h);
wr.WriteInt(v.bits);
IF v.model.file # NIL THEN
len := v.model.len;
wr.WriteInt(len);
r := v.model.file.NewReader(NIL); r.SetPos(v.model.pos);
WHILE len # 0 DO r.ReadByte(b); wr.WriteSChar(SHORT(CHR(b))); DEC(len) END
ELSE
ASSERT(v.model.ref # 0, 100);
GetHeader(v, info.header, colors);
res := WinApi.GetDIBits(WinApi.GetDC(HostWindows.main), v.model.ref, 0, v.h, 0,
SYSTEM.VAL(WinApi.BITMAPINFO, info), WinApi.DIB_RGB_COLORS);
IF res = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
len := info.header.biSizeImage;
NEW(data, len);
res := WinApi.GetDIBits(WinApi.GetDC(HostWindows.main), v.model.ref, 0, v.h,
SYSTEM.ADR(data[0]),
SYSTEM.VAL(WinApi.BITMAPINFO, info), WinApi.DIB_RGB_COLORS);
IF res = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
INC(len, 4 * colors);
wr.WriteInt(len);
i := 0; WHILE i < colors DO wr.WriteInt(info.colors[i]); INC(i) END;
wr.rider.WriteBytes(data^, 0, LEN(data));
v.model.len := len
END;
END Externalize;
PROCEDURE (v: StdView) CopyFromSimpleView (source: Views.View);
BEGIN
WITH source: StdView DO
v.model := source.model;
v.w := source.w;
v.h := source.h;
v.bits := source.bits;
END
END CopyFromSimpleView;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR rd: HostPorts.Rider; res, w, h: INTEGER; dc, pdc, bdc, bdc1: WinApi.HDC; memBM: WinApi.HBITMAP;
BEGIN
ASSERT(v.model # NIL, 20);
v.context.GetSize(w, h);
dc := f.rider(HostPorts.Rider).port.homedc;
IF WinApi.WindowFromDC(dc) = 0 THEN dc := WinApi.GetDC(HostWindows.main) END;
IF v.model.ref = 0 THEN Evaluate(v, dc) END;
IF Views.IsPrinterFrame(f) THEN (* need to make a print copy of the existing bitmap *)
bdc1 := WinApi.CreateCompatibleDC(dc);
res := WinApi.SelectObject(bdc1, v.model.ref);
pdc := f.rider(HostPorts.Rider).port.dc;
bdc := WinApi.CreateCompatibleDC(pdc);
memBM := WinApi.CreateCompatibleBitmap(pdc, v.w, v.h);
res := WinApi.SelectObject(bdc, memBM);
res := WinApi.BitBlt(bdc, 0, 0, v.w, v.h, bdc1, 0, 0, 00CC0020H); (* copy *)
res := WinApi.DeleteDC(bdc1)
ELSE
bdc := WinApi.CreateCompatibleDC(dc);
res := WinApi.SelectObject(bdc, v.model.ref)
END;
f.rider(HostPorts.Rider).DrawBitmap(bdc, v.w, v.h, f.gx, f.gy, w, h);
res := WinApi.DeleteDC(bdc)
END Restore;
PROCEDURE (v: StdView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w > Views.undefined) & (msg.h > Views.undefined) THEN
Properties.ProportionalConstraint(v.w, v.h, msg.fixedW, msg.fixedH, msg.w, msg.h)
ELSE
IF (v.w > 0) & (v.h > 0) THEN (* default sizes *)
msg.w := v.w * HostWindows.unit; msg.h := v.h * HostWindows.unit
END
END
ELSE
END
END HandlePropMsg;
PROCEDURE TurnToBitmap* (bits: INTEGER);
VAR v: Views.View; f: Views.Frame; rd: HostPorts.Rider; dc, bdc: WinApi.HDC; bm: WinApi.HBITMAP;
res, w, h: INTEGER; obj: StdView;
BEGIN
ASSERT((bits = 0) OR (bits = 8) OR (bits = 24), 20);
v := Containers.FocusSingleton();
IF v # NIL THEN
f := Controllers.FocusFrame();
f := Views.ThisFrame(f, v);
rd := f.rider(HostPorts.Rider);
dc := rd.port.homedc;
bdc := WinApi.CreateCompatibleDC(dc);
res := WinApi.SetBkMode(bdc, WinApi.TRANSPARENT);
v.context.GetSize(w, h);
w := w DIV f.unit; h := h DIV f.unit;
bm := WinApi.CreateCompatibleBitmap(dc, w, h);
res := WinApi.SelectObject(bdc, bm);
Paint(bdc, v, w, h, f.unit);
res := WinApi.DeleteDC(bdc);
NEW(obj); obj.w := w; obj.h := h; obj.bits := bits;
NEW(obj.model); obj.model.ref := bm;
Containers.Focus().ThisView().ThisModel().ReplaceView(v, obj)
END
END TurnToBitmap;
(*
PROCEDURE TurnThisToBitmap* (v: Views.View; owner: Containers.Model; bits: INTEGER);
VAR dc, bdc: WinApi.HDC; bm: WinApi.HBITMAP; res, w, h: INTEGER; obj: StdView;
BEGIN
dc := WinApi.GetDC(HostWindows.main);
bdc := WinApi.CreateCompatibleDC(dc);
res := WinApi.SetBkMode(bdc, WinApi.TRANSPARENT);
v.context.GetSize(w, h);
w := w DIV HostWindows.unit; h := h DIV HostWindows.unit;
bm := WinApi.CreateCompatibleBitmap(dc, w, h);
res := WinApi.SelectObject(bdc, bm);
Paint(bdc, v, w, h, HostWindows.unit);
res := WinApi.DeleteDC(bdc);
NEW(obj); obj.w := w; obj.h := h; obj.bits := bits;
NEW(obj.model); obj.model.ref := bm;
owner.ReplaceView(v, obj)
END TurnThisToBitmap;
*)
PROCEDURE ViewToBitmap* (v: Views.View; bits: INTEGER): Views.View;
VAR dc, bdc: WinApi.HDC; bm: WinApi.HBITMAP; res, w, h: INTEGER; obj: StdView;
BEGIN
ASSERT(v # NIL, 20);
IF v IS StdView THEN
RETURN v
ELSE
ASSERT((bits = 0) OR (bits = 8) OR (bits = 24), 21);
dc := WinApi.GetDC(HostWindows.main);
bdc := WinApi.CreateCompatibleDC(dc);
res := WinApi.SetBkMode(bdc, WinApi.TRANSPARENT);
v.context.GetSize(w, h);
w := w DIV HostWindows.unit; h := h DIV HostWindows.unit;
bm := WinApi.CreateCompatibleBitmap(dc, w, h);
res := WinApi.SelectObject(bdc, bm);
Paint(bdc, v, w, h, HostWindows.unit);
res := WinApi.DeleteDC(bdc);
NEW(obj); obj.w := w; obj.h := h; obj.bits := bits;
NEW(obj.model); obj.model.ref := bm;
RETURN obj
END
END ViewToBitmap;
PROCEDURE ImportBitmap* (f: Files.File; OUT s: Stores.Store);
TYPE Str = POINTER TO ARRAY [untagged] OF CHAR;
VAR name: Str; bm: WinApi.HBITMAP; obj: StdView; res: INTEGER;
sname: ARRAY 260 OF SHORTCHAR; info: WinApi.BITMAP;
BEGIN
name := SYSTEM.VAL(Str, SYSTEM.VAL(INTEGER, f) + 40); (* f(HostFiles.File).name *)
sname := SHORT(name$);
bm := WinApi.LoadImage(0, sname, WinApi.IMAGE_BITMAP, 0, 0, ORD(WinApi.LR_LOADFROMFILE));
IF bm = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
res := WinApi.GetObject(bm, SIZE(WinApi.BITMAP), SYSTEM.ADR(info));
NEW(obj); obj.w := info.bmWidth; obj.h := info.bmHeight;
IF info.bmBitsPixel > 8 THEN obj.bits := 24 ELSE obj.bits := 8 END;
NEW(obj.model); obj.model.ref := bm;
s := obj
END ImportBitmap;
PROCEDURE ExportBitmap* (v: Stores.Store; f: Files.File);
VAR w: Stores.Writer; info: BITMAPINFO8; i, col, res: INTEGER; data: POINTER TO ARRAY OF BYTE;
BEGIN
ASSERT(v # NIL, 20); ASSERT(f # NIL, 21);
WITH v: StdView DO
GetHeader(v, info.header, col);
res := WinApi.GetDIBits(WinApi.GetDC(HostWindows.main), v.model.ref, 0, v.h, 0,
SYSTEM.VAL(WinApi.BITMAPINFO, info), WinApi.DIB_RGB_COLORS);
IF res = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
NEW(data, info.header.biSizeImage);
res := WinApi.GetDIBits(WinApi.GetDC(HostWindows.main), v.model.ref, 0, v.h,
SYSTEM.ADR(data[0]),
SYSTEM.VAL(WinApi.BITMAPINFO, info), WinApi.DIB_RGB_COLORS);
IF res = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
w.ConnectTo(f);
w.SetPos(0);
(* file header *)
w.WriteSInt(4D42H); (* type *)
w.WriteInt(14 + 40 + 4 * col + LEN(data)); (* size *)
w.WriteInt(0);
w.WriteInt(14 + 40 + 4 * col); (* offset *)
(* bitmap header *)
w.WriteInt(info.header.biSize);
w.WriteInt(info.header.biWidth);
w.WriteInt(info.header.biHeight);
w.WriteSInt(info.header.biPlanes);
w.WriteSInt(info.header.biBitCount);
w.WriteInt(info.header.biCompression);
w.WriteInt(info.header.biSizeImage);
w.WriteInt(info.header.biXPelsPerMeter);
w.WriteInt(info.header.biYPelsPerMeter);
w.WriteInt(info.header.biClrUsed);
w.WriteInt(info.header.biClrImportant);
(* colors *)
i := 0; WHILE i < col DO w.WriteInt(info.colors[i]); INC(i) END;
(* bits *)
w.rider.WriteBytes(data^, 0, LEN(data))
ELSE
END
END ExportBitmap;
PROCEDURE ImportDPictAsBitmap* (VAR med: WinOle.STGMEDIUM;
OUT v: Views.View; OUT w, h: INTEGER; OUT isSingle: BOOLEAN
);
VAR hm: WinApi.HMETAFILEPICT; mp: WinApi.PtrMETAFILEPICT;
dc, bdc: WinApi.HDC; res, u: INTEGER; bm: WinApi.HBITMAP; obj: StdView; s: SET;
BEGIN
hm := med.u.hMetaFilePict;
mp := SYSTEM.VAL(WinApi.PtrMETAFILEPICT, WinApi.GlobalLock(hm));
CASE mp.mm OF
| 1: u := HostWindows.unit
| 2: u := Ports.point DIV 20
| 3: u := Ports.mm DIV 100
| 4: u := Ports.inch DIV 100
| 5: u := Ports.inch DIV 1000
| 6: u := Ports.mm DIV 10
| 7: u := Ports.mm DIV 100
| 8: u := Ports.mm DIV 100
END;
w := mp.xExt * u; h := mp.yExt * u;
NEW(obj); obj.bits := 24;
obj.w := w DIV HostWindows.unit;
obj.h := h DIV HostWindows.unit;
dc := WinApi.GetDC(HostWindows.main);
bdc := WinApi.CreateCompatibleDC(dc);
res := WinApi.SetBkMode(bdc, WinApi.TRANSPARENT);
bm := WinApi.CreateCompatibleBitmap(dc, obj.w, obj.h);
res := WinApi.SelectObject(bdc, bm);
res := WinApi.SetMapMode(bdc, mp.mm);
res := WinApi.SetViewportOrgEx(bdc, 0, 0, NIL);
res := WinApi.SetViewportExtEx(bdc, obj.w, obj.h, NIL);
s := WinApi.SetTextAlign(bdc, {});
res := WinApi.PlayMetaFile(bdc, mp.hMF);
res := WinApi.GlobalUnlock(hm);
res := WinApi.DeleteDC(bdc);
WinOle.ReleaseStgMedium(med);
NEW(obj.model); obj.model.ref := bm;
v := obj; isSingle := FALSE
END ImportDPictAsBitmap;
PROCEDURE ImportDBitmap* (VAR med: WinOle.STGMEDIUM;
OUT v: Views.View; OUT w, h: INTEGER; OUT isSingle: BOOLEAN
);
VAR obj: StdView; res: INTEGER;
bm, bm0: WinApi.HBITMAP; info: WinApi.BITMAP; dc, bdc, bdc0: WinApi.HDC;
BEGIN
ASSERT(med.tymed = WinOle.TYMED_GDI, 20);
bm0 := med.u.hBitmap;
ASSERT(bm0 # 0, 20);
res := WinApi.GetObject(bm0, SIZE(WinApi.BITMAP), SYSTEM.ADR(info));
NEW(obj);
obj.w := info.bmWidth;
obj.h := info.bmHeight;
IF info.bmBitsPixel > 8 THEN obj.bits := 24 ELSE obj.bits := 8 END;
dc := WinApi.GetDC(HostWindows.main);
bdc0 := WinApi.CreateCompatibleDC(dc);
res := WinApi.SelectObject(bdc0, bm0);
bdc := WinApi.CreateCompatibleDC(dc);
bm := WinApi.CreateCompatibleBitmap(dc, obj.w, obj.h);
res := WinApi.SelectObject(bdc, bm);
res := WinApi.BitBlt(bdc, 0, 0, obj.w, obj.h, bdc0, 0, 0, 00CC0020H); (* copy *)
IF res = 0 THEN res := WinApi.GetLastError(); HALT(100) END;
res := WinApi.DeleteDC(bdc0);
res := WinApi.DeleteDC(bdc);
WinOle.ReleaseStgMedium(med);
NEW(obj.model); obj.model.ref := bm;
v := obj; w := obj.w * HostWindows.unit; h := obj.h * HostWindows.unit; isSingle := FALSE
END ImportDBitmap;
PROCEDURE ExportDBitmap* (v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN;
VAR med: WinOle.STGMEDIUM
);
BEGIN
ASSERT(v # NIL, 20);
WITH v: StdView DO
IF v.model.ref = 0 THEN Evaluate(v, WinApi.GetDC(HostWindows.main)) END;
med.tymed := WinOle.TYMED_GDI;
med.u.hBitmap := v.model.ref;
med.pUnkForRelease := NIL
ELSE
END
END ExportDBitmap;
END HostBitmaps.
| Host/Mod/Bitmaps.odc |
MODULE HostCFrames;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(* ColorField, DateField, TimeField, UpDownField *)
IMPORT
SYSTEM, WinApi, WinCtl, USER32, KERNEL32, GDI32,
Kernel, Strings, Dates, Fonts, Ports, Views,
Controllers, Dialog, HostFonts, HostRegistry, HostPorts, HostWindows, StdCFrames;
CONST
ENTER = 0DX; ESC = 1BX; DEL = 07X; BS = 08X; TAB = 09X; LTAB = 0AX;
AL = 1CX; AR = 1DX; AU = 1EX; AD = 1FX;
PL = 10X; PR = 11X; PU = 12X; PD = 13X;
DL = 14X; DR = 15X; DU = 16X; DD = 17X;
dlgWindowExtra = 30;
dropDownHeight = 30 * Ports.point;
upDownWidth = 11 * Ports.point;
numColors = 7;
scrollRange = 16384;
TYPE
Procedure = PROCEDURE;
Info = RECORD
wnd, ctrl, ud: USER32.Handle;
x1, y1, w1, h1, x2, y2, w2, h2: INTEGER;
hasFocus, dropDown, readOnly, undef: BOOLEAN;
bkgnd: Ports.Color
END;
PushButton = POINTER TO RECORD (StdCFrames.PushButton)
i: Info
END;
CheckBox = POINTER TO RECORD (StdCFrames.CheckBox)
i: Info
END;
RadioButton = POINTER TO RECORD (StdCFrames.RadioButton)
i: Info
END;
ScrollBar = POINTER TO RECORD (StdCFrames.ScrollBar)
i: Info
END;
Field = POINTER TO RECORD (StdCFrames.Field)
i: Info;
isUpdate: BOOLEAN;
del: BOOLEAN (* needed know when an empty field is allowed. not perfect. *)
END;
UpDownField = POINTER TO RECORD (StdCFrames.UpDownField)
i: Info;
val: INTEGER;
isUpdate: BOOLEAN
END;
DateField = POINTER TO RECORD (StdCFrames.DateField)
i: Info;
isUpdate: BOOLEAN;
cnt, val: INTEGER (* input state: val = current val, cnt = number of key strokes *)
END;
TimeField = POINTER TO RECORD (StdCFrames.TimeField)
i: Info;
isUpdate: BOOLEAN;
cur: INTEGER
END;
ColorField = POINTER TO RECORD (StdCFrames.ColorField)
i: Info;
color: Ports.Color
END;
ListBox = POINTER TO RECORD (StdCFrames.ListBox)
i: Info
END;
SelectionBox = POINTER TO RECORD (StdCFrames.SelectionBox)
i: Info;
num: INTEGER
END;
ComboBox = POINTER TO RECORD (StdCFrames.ComboBox)
i: Info;
edit: USER32.Handle
END;
Caption = POINTER TO RECORD (StdCFrames.Caption)
i: Info
END;
Group = POINTER TO RECORD (StdCFrames.Group)
i: Info
END;
TFInfo = RECORD
tn: Dialog.TreeNode;
wndAdr: INTEGER
END;
TreeFrame = POINTER TO RECORD (StdCFrames.TreeFrame)
i: Info;
inUpdateList: BOOLEAN;
treeArray: POINTER TO ARRAY OF TFInfo;
curindex, selIndex: INTEGER;
folderimg, openimg, leafimg: INTEGER;
himl: WinCtl.Ptr_IMAGELIST
END;
Directory = POINTER TO RECORD (StdCFrames.Directory) END;
TrapCleaner = POINTER TO RECORD (Kernel.TrapCleaner) END;
BrushCache = POINTER TO RECORD
next: BrushCache;
col: Ports.Color;
brush: GDI32.Handle
END;
VAR
instance: USER32.Handle;
SubclassCtl: PROCEDURE(wnd: USER32.Handle);
CtlColor: PROCEDURE(msg, wPar, lPar: INTEGER): INTEGER;
scW, scH: INTEGER; (* screen width and height *)
updateAllowed: BOOLEAN;
listBoxHandler: USER32.WndProc;
osVersion: INTEGER;
colors: ARRAY numColors OF Ports.Color;
(* date format *)
dateSep: SHORTCHAR; (* separator character *)
yearPart, monthPart, dayPart: INTEGER; (* first = 1, last = 3 *)
del1, del2: INTEGER; (* position of separators *)
(* time format *)
timeSep: SHORTCHAR; (* separator character *)
lastPart: INTEGER; (* 3 for 24h format, 4 for 12h format *)
desig: ARRAY 2, 8 OF SHORTCHAR; (* AM, PM strings *)
inHandleMouse*: BOOLEAN; (* to disable the main window handler in HostMenus *)
brushes: BrushCache;
(* auxiliary procedures *)
PROCEDURE ConvertFromUnicode (VAR s: ARRAY OF CHAR);
VAR i: INTEGER;
BEGIN
i := 0;
WHILE s[i] # 0X DO
IF s[i] = 20ACX THEN s[i] := 80X END; (* euro *)
INC(i)
END
END ConvertFromUnicode;
PROCEDURE ConvertToUnicode (VAR s: ARRAY OF CHAR);
VAR i: INTEGER;
BEGIN
i := 0;
WHILE s[i] # 0X DO
IF s[i] = 80X THEN s[i] := 20ACX END; (* euro *)
INC(i)
END
END ConvertToUnicode;
PROCEDURE GetSize (f: StdCFrames.Frame; VAR x, y, w, h: INTEGER);
VAR u, x0, y0: INTEGER;
BEGIN
u := f.unit; f.view.context.GetSize(w, h); x0 := f.gx; y0 := f.gy;
x := x0 DIV u; y := y0 DIV u;
w := (x0 + w) DIV u - x; h := (y0 + h) DIV u - y;
IF (SubclassCtl # NIL)
& ((f IS Field) OR (f IS UpDownField) OR (f IS TimeField) OR (f IS DateField)
OR (f IS ColorField) OR (f IS ListBox) OR (f IS SelectionBox) OR (f IS ComboBox)) THEN
INC(x, 1); INC(y, 1); DEC(w, 2); DEC(h, 2) (* space for 3d border *)
END
END GetSize;
PROCEDURE Adapt (f: StdCFrames.Frame; VAR i: Info);
VAR res, x, y, w, h, cx, cy, cw, ch, udw, n, h0, h1: INTEGER; r: HostPorts.Rider;
BEGIN
IF i.wnd # 0 THEN
r := f.rider(HostPorts.Rider);
IF r.port.wnd # 0 THEN (* port is a window *)
GetSize(f, x, y, w, h);
IF i.dropDown THEN
n := USER32.SendMessageA(i.ctrl, USER32.CBGetCount, 0, 0);
h0 := USER32.SendMessageA(i.ctrl, USER32.CBGetItemHeight, -1, 0);
h1 := USER32.SendMessageA(i.ctrl, USER32.CBGetItemHeight, 0, 0);
IF n < 1 THEN n := 1 ELSIF n > 8 THEN n := 8 END;
h := h0 + h1 * n + 8
END;
cx := r.l; cy := r.t; cw := r.r - r.l; ch := r.b - r.t;
IF (cx # i.x1) OR (cy # i.y1) OR (cw # i.w1) OR (ch # i.h1) THEN
i.x1 := cx; i.y1 := cy; i.w1 := cw; i.h1 := ch;
res := USER32.MoveWindow(i.wnd, cx, cy, cw, ch, 0)
END;
DEC(x, cx); DEC(y, cy);
IF (x # i.x2) OR (y # i.y2) OR (w # i.w2) OR (h # i.h2) THEN
i.x2 := x; i.y2 := y; i.w2 := w; i.h2 := h;
IF i.ud # 0 THEN
udw := upDownWidth DIV f.unit;
res := USER32.MoveWindow(i.ud, x + w - udw, y + 1, udw, h - 2, 0);
DEC(w, udw);
IF SubclassCtl # NIL THEN DEC(w) END
END;
res := USER32.MoveWindow(i.ctrl, x, y, w, h, 0)
END
END
END
END Adapt;
PROCEDURE BkGndColor (f: Views.Frame): Ports.Color;
VAR bgnd: Ports.Color; g: Views.Frame;
BEGIN
g := f;
REPEAT
g := Views.HostOf(g);
bgnd := Views.transparent;
g.view.GetBackground(bgnd)
UNTIL bgnd # Views.transparent;
RETURN bgnd
END BkGndColor;
PROCEDURE Open (f: StdCFrames.Frame; class, name: USER32.StringPtr;
style, ex: SET; VAR i: Info);
VAR res, x, y, w, h, cx, cy, cw, ch, udw: INTEGER; p: HostPorts.Port; s: SET; r: Ports.Rider;
BEGIN
f.noRedraw := TRUE;
r := f.rider; GetSize(f, x, y, w, h);
r.GetRect(cx, cy, cw, ch); cw := cw - cx; ch := ch - cy;
p := f.rider(HostPorts.Rider).port;
IF p.wnd # 0 THEN (* port is a window *)
i.bkgnd := BkGndColor(f);
s := {27, 30}; (* disabled, child *)
i.wnd := USER32.CreateWindowExA({}, "Oberon Ctrl", "", s, cx, cy, cw, ch, p.wnd, 0, instance, 0);
IF i.wnd # 0 THEN
DEC(x, cx); DEC(y, cy);
res := USER32.SetWindowLongA(i.wnd, dlgWindowExtra, SYSTEM.VAL(INTEGER, f));
i.ctrl := USER32.CreateWindowExA(ex, class, name, style, x, y, w, h, i.wnd, 0, instance, 0);
IF i.ctrl # 0 THEN
IF (SubclassCtl # NIL) & ~(f IS PushButton) THEN SubclassCtl(i.ctrl) END;
IF f.font # NIL THEN
res := USER32.SendMessageA(i.ctrl, USER32.WMSetFont, f.font(HostFonts.Font).dev.id, 0)
END;
IF (f IS UpDownField) OR (f IS TimeField) OR (f IS DateField) THEN
style := {23, 28, 30} + WinCtl.UDS_ALIGNRIGHT + WinCtl.UDS_ARROWKEYS;
udw := upDownWidth DIV f.unit;
i.ud := WinCtl.CreateUpDownControl(style, x + w - udw, y, udw, h, i.wnd, 0, instance, 0, 1, 0, 0)
END;
Adapt(f, i);
res := USER32.ShowWindow(i.wnd, 1);
res := USER32.ShowWindow(i.ctrl, 1);
IF i.ud # 0 THEN res := USER32.ShowWindow(i.ud, 1) END
ELSE res := USER32.DestroyWindow(i.wnd); i.wnd := 0
END
ELSE i.ctrl := 0
END
ELSE (* port is a printer -> define temp windows *)
i.wnd := 0; i.ctrl := 0
(*
s := {27, 31}; (* disabled, popup *)
i.wnd := USER32.CreateWindowExA({}, "Oberon Ctrl", "", s, scW - cw, scH - ch, cw, ch, 0, 0, instance, 0);
res := USER32.SetWindowLongA(i.wnd, dlgWindowExtra, SYSTEM.VAL(LONGINT, f));
i.ctrl := USER32.CreateWindowExA({}, class, name, style, x - cx, y - cy, w, h, i.wnd, 0, instance, 0)
*)
END
END Open;
PROCEDURE Paint (f: StdCFrames.Frame; VAR i: Info);
VAR res, u: INTEGER; r: HostPorts.Rider;
BEGIN
r := f.rider(HostPorts.Rider); u := f.unit;
r.port.CloseBuffer;
updateAllowed := TRUE;
res := USER32.InvalidateRect(i.wnd, NIL, 0);
res := USER32.InvalidateRect(i.ctrl, NIL, 0);
res := USER32.UpdateWindow(i.wnd);
res := USER32.UpdateWindow(i.ctrl);
IF i.ud # 0 THEN res := USER32.UpdateWindow(i.ud) END;
updateAllowed := FALSE
END Paint;
PROCEDURE PaintRect (f: StdCFrames.Frame; VAR i: Info; l, t, r, b: INTEGER);
VAR res, u: INTEGER; ri: HostPorts.Rider; rect: GDI32.Rect;
BEGIN
ri := f.rider(HostPorts.Rider); u := f.unit;
ri.port.CloseBuffer;
updateAllowed := TRUE;
rect.left := l DIV f.unit; rect.top := t DIV f.unit; rect.right := r DIV f.unit; rect.bottom := b DIV f.unit;
rect.left := rect.left; rect.top := rect.top; rect.right := rect.right; rect.bottom := rect.bottom ;
(* round up if possible *)
IF rect.left > i.x1 THEN rect.left := rect.left - 1 END;
IF rect.top > i.y1 THEN rect.top := rect.top - 1 END;
IF rect.right < i.x1 + i.w1 THEN rect.right := rect.right + 1 END;
IF rect.bottom < i.y1 + i.h1 THEN rect.bottom := rect.bottom + 1 END;
res := USER32.InvalidateRect(i.wnd, rect, 0);
res := USER32.InvalidateRect(i.ctrl, rect, 0);
res := USER32.UpdateWindow(i.wnd);
res := USER32.UpdateWindow(i.ctrl);
IF i.ud # 0 THEN res := USER32.UpdateWindow(i.ud) END;
updateAllowed := FALSE
END PaintRect;
PROCEDURE ExtractLine (IN s: ARRAY OF SHORTCHAR; beg: INTEGER; fnt: Fonts.Font; maxW: INTEGER;
OUT line: Dialog.String; OUT lineW, end: INTEGER
);
VAR i, len, w: INTEGER; ch: CHAR;
BEGIN
len := LEN(s$);
ASSERT(beg >= 0, 20); ASSERT(beg < LEN(s$), 21); ASSERT(maxW > 0, 22); ASSERT(fnt # NIL, 23);
i := 0; end := beg; lineW := 0; w := 0;
REPEAT
ch := s[i + beg];
IF ch <= " " THEN end := i + beg; lineW := w END;
line[i] := ch; INC(i); line[i] := 0X; w := fnt.StringWidth(line);
IF (w <= maxW) & ((ch = "-") OR (ch = "_")) THEN end := i + beg; lineW := w END
UNTIL (i + beg = len) OR (w > maxW);
IF w <= maxW THEN end := beg + i; line[end - beg] := 0X; lineW := w
ELSIF end # beg THEN line[end - beg] := 0X
ELSE end := beg + i - 1; line[i - 1] := 0X; lineW := fnt.StringWidth(line)
END;
ASSERT(end > beg, 80)
END ExtractLine;
PROCEDURE PrintSString (f: Views.Frame; w: INTEGER;
IN string: ARRAY OF SHORTCHAR; fnt: Fonts.Font; col: Ports.Color;
x0, y0: INTEGER; left, right, multiLine: BOOLEAN
);
VAR x, sw, asc, dsc, fw, beg, end, len, n: INTEGER; s: Dialog.String;
BEGIN
fnt.GetBounds(asc, dsc, fw); sw := fnt.SStringWidth(string);
w := MAX(fw, w - 2 * x0); (* ensures that always at least one character fits *)
beg := 0; len := LEN(string$); n := 0;
WHILE beg < len DO
IF multiLine THEN ExtractLine(string, beg, fnt, w, s, sw, end)
ELSE s := string$; sw := fnt.StringWidth(s); end := len
END;
IF ~left & ~right THEN x := (w - sw) DIV 2 ELSIF right & ~left THEN x := w - sw ELSE x := 0 END;
f.DrawString(x0 + x, n * (asc + dsc) + y0, col, s, fnt);
beg := end; INC(n);
IF (beg < len) & (string[beg] = " ") THEN INC(beg) END
END
END PrintSString;
PROCEDURE Print (f: StdCFrames.Frame; d, x, y: INTEGER; label: ARRAY OF SHORTCHAR);
VAR w, h, sw, a, asc, dsc, fw: INTEGER; font: Fonts.Font; on: BOOLEAN;
BEGIN
IF f.font # NIL THEN font := f.font ELSE font := HostFonts.dlgFont END;
f.view.context.GetSize(w, h);
font.GetBounds(asc, dsc, fw);
IF x < 0 THEN sw := font.SStringWidth(label); x := (w - sw) DIV 2 END;
IF y < 0 THEN y := (h + asc - dsc) DIV 2
ELSIF y = 0 THEN y := asc
END;
a := (h - 8 * Ports.point) DIV 2;
IF d = -1 THEN
f.DrawRect(2 * Ports.point, a, 10 * Ports.point, a + 8 * Ports.point, f.dot, Ports.defaultColor);
IF (f IS CheckBox) & (f(CheckBox).Get # NIL) THEN
f(CheckBox).Get(f(CheckBox), on);
IF on THEN
f.DrawLine(
2 * Ports.point + 2 * f.dot, a + 4 * Ports.point, 5 * Ports.point, a + 8 * Ports.point - 2 * f.dot,
2 * Ports.point, Ports.defaultColor
);
f.DrawLine(
5 * Ports.point, a + 8 * Ports.point - 2 * f.dot, 10 * Ports.point - 2 * f.dot, a + 2 * f.dot,
2 * Ports.point, Ports.defaultColor
)
END
END
ELSIF d = -2 THEN f.DrawOval(2 * Ports.point, a, 10 * Ports.point, a + 8 * Ports.point, f.dot, Ports.defaultColor);
IF f(RadioButton).Get # NIL THEN f(RadioButton).Get(f(RadioButton), on);
IF on THEN f.DrawOval(2*Ports.point + 2*f.dot, a+2*f.dot,
10*Ports.point - 2*f.dot, a + 8*Ports.point-2*f.dot, Ports.fill, Ports.black)
END
END
ELSIF d = -3 THEN
f.DrawRect(0, MIN(asc - f.dot, h), w, MAX(asc - f.dot, h), f.dot, Ports.defaultColor);
f.DrawRect(x, y - asc, x + font.SStringWidth(label), y + dsc, Ports.fill, Ports.background)
ELSIF d > 0 THEN f.DrawRect(0, 0, w, h, d, Ports.defaultColor)
END;
(*
WITH f: Field DO
IF f.right & ~f.left THEN x := w - x - font.SStringWidth(label)
ELSIF ~f.right & ~f.left THEN x := (w DIV 2) - (font.SStringWidth(label) DIV 2)
END
| f: Caption DO
IF f.right & ~f.left THEN x := w - x - font.SStringWidth(label)
ELSIF ~f.right & ~f.left THEN x := (w DIV 2) - (font.SStringWidth(label) DIV 2)
END
ELSE
END;
f.DrawSString(x, y, Ports.defaultColor, label, font)
*)
WITH f: Field DO
PrintSString(f, w, label, font, Ports.defaultColor, x, y, f.left, f.right, f.multiLine)
| f: Caption DO
PrintSString(f, w, label, font, Ports.defaultColor, x, y, f.left, f.right, TRUE)
ELSE
PrintSString(f, w, label, font, Ports.defaultColor, x, y, TRUE, FALSE, FALSE)
END
END Print;
PROCEDURE SendKey (ch: SHORTCHAR; wnd: USER32.Handle);
VAR res, code: INTEGER;
BEGIN
CASE ch OF
| 10X: code := 21H
| 11X: code := 22H
| 12X: code := 21H
| 13X: code := 22H
| 14X: code := 24H
| 15X: code := 23H
| 16X: code := 24H
| 17X: code := 23H
| 1CX: code := 25H
| 1DX: code := 27H
| 1EX: code := 26H
| 1FX: code := 28H
| DEL: code := 2EH
ELSE code := 0
END;
IF code # 0 THEN
res := USER32.SendMessageA(wnd, USER32.WMKeyDown, code, 0);
res := USER32.SendMessageA(wnd, USER32.WMKeyUp, code, 0)
ELSE
res := USER32.SendMessageA(wnd, USER32.WMChar, ORD(ch), 0)
END
END SendKey;
PROCEDURE (t: TrapCleaner) Cleanup;
BEGIN
inHandleMouse := FALSE
END Cleanup;
PROCEDURE HandleMouse (wnd: USER32.Handle; x, y: INTEGER; buttons: SET);
VAR res, b, hc, m: INTEGER; pt: USER32.Point; w: USER32.Handle; msg: USER32.Message;
tc: TrapCleaner;
BEGIN
NEW(tc); Kernel.PushTrapCleaner(tc); inHandleMouse := TRUE;
res := USER32.ReleaseCapture(); b := 0;
IF HostPorts.left IN buttons THEN INC(b) END;
IF HostPorts.right IN buttons THEN INC(b, 2) END;
IF Controllers.extend IN buttons THEN INC(b, 4) END;
IF Controllers.modify IN buttons THEN INC(b, 8) END;
pt.x := x; pt.y := y;
REPEAT
w := wnd; wnd := USER32.ChildWindowFromPoint(wnd, pt);
res := USER32.ClientToScreen(w, pt);
hc := USER32.SendMessageA(wnd, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
res := USER32.ScreenToClient(wnd, pt)
UNTIL (hc # 1) OR (w = wnd);
IF hc > 1 THEN
res := USER32.ClientToScreen(wnd, pt);
IF ODD(b) THEN m := USER32.WMNCLButtonDown ELSE m := USER32.WMNCRButtonDown END;
res := USER32.SendMessageA(wnd, m, hc, pt.x + pt.y * 65536)
ELSE
res := USER32.GetClassLongA(wnd, -26); (* classStyle *)
IF (Controllers.doubleClick IN buttons) & ODD(res DIV 8) THEN (* DblClks IN classStyle *)
IF ODD(b) THEN m := USER32.WMLButtonDblClk ELSE m := USER32.WMRButtonDblClk END
ELSE
IF ODD(b) THEN m := USER32.WMLButtonDown ELSE m := USER32.WMRButtonDown END
END;
res := USER32.SendMessageA(wnd, m, b, pt.x + pt.y * 65536)
END;
REPEAT
res := USER32.GetMessageA(msg, 0, 0, 0);
IF (msg.message >= USER32.WMMouseMove) & (msg.message <= USER32.WMMButtonDblClk) THEN
b := msg.wParam
END;
res := USER32.TranslateMessage(msg);
res := USER32.DispatchMessageA(msg)
UNTIL b MOD 4 = 0;
inHandleMouse := FALSE; Kernel.PopTrapCleaner(tc)
END HandleMouse;
PROCEDURE HandleWheel (wnd: USER32.Handle; x, y: INTEGER; op, nofLines: INTEGER;
VAR done: BOOLEAN
);
VAR res: INTEGER;
BEGIN
IF op = Controllers.incPage THEN
res := WinApi.SendMessage(wnd, WinApi.WM_VSCROLL, WinApi.SB_PAGEDOWN, WinApi.NULL)
ELSIF op = Controllers.decPage THEN
res := WinApi.SendMessage(wnd, WinApi.WM_VSCROLL, WinApi.SB_PAGEUP, WinApi.NULL)
ELSE
IF op = Controllers.incLine THEN
op := WinApi.SB_LINEDOWN
ELSE
op := WinApi.SB_LINEUP
END;
WHILE nofLines > 0 DO
res := WinApi.SendMessage(wnd, WinApi.WM_VSCROLL, op, WinApi.NULL);
DEC(nofLines)
END
END;
done := TRUE
END HandleWheel;
PROCEDURE Mark (on, focus: BOOLEAN; VAR i: Info);
VAR res: INTEGER;
BEGIN
IF focus THEN
IF on THEN
IF ~i.hasFocus THEN
res := USER32.SendMessageA(i.ctrl, USER32.WMSetFocus, 0, 0);
i.hasFocus := TRUE
END
ELSE
IF i.hasFocus THEN
res := USER32.SendMessageA(i.ctrl, USER32.WMKillFocus, 0, 0);
i.hasFocus := FALSE
END
END
END
END Mark;
PROCEDURE SetLabel (IN in: ARRAY OF CHAR; OUT out: ARRAY OF SHORTCHAR);
VAR s: Dialog.String;
BEGIN
Dialog.MapString(in, s); ConvertFromUnicode(s); out := SHORT(s)
END SetLabel;
PROCEDURE CheckLabel (IN label: ARRAY OF CHAR; ctrl: INTEGER);
VAR res: INTEGER; lbl, s: ARRAY 256 OF SHORTCHAR; s0: Dialog.String;
BEGIN
Dialog.MapString(label, s0);
ConvertFromUnicode(s0); lbl := SHORT(s0);
res := USER32.GetWindowTextA(ctrl, s, LEN(s));
IF s # lbl THEN res := USER32.SetWindowTextA(ctrl, lbl) END
END CheckLabel;
(* PushButton *)
PROCEDURE (f: PushButton) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: PushButton) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: PushButton) Update;
VAR res: INTEGER; style: SET;
BEGIN
IF ~f.disabled & ~f.readOnly THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN
IF f.default THEN
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style + {0}))
END;
res := USER32.EnableWindow(f.i.ctrl, 1)
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
IF f.default THEN
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style - {0}))
END;
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
CheckLabel(f.label, f.i.ctrl);
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: PushButton) Restore (l, t, r, b: INTEGER);
VAR style: SET; lbl: ARRAY 256 OF SHORTCHAR;
BEGIN
SetLabel(f.label, lbl);
IF f.i.ctrl = 0 THEN (* lazy allocation *)
style := {16, 30}; (* pushbutton, tabstop, child *)
IF f.default & ~f.disabled THEN INCL(style, 0) END; (* default *)
Open(f, "BUTTON", lbl, style, {}, f.i)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, f.dot, -1, -1, lbl) END
END Restore;
PROCEDURE (f: PushButton) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE Execute (f: PushButton);
VAR old: USER32.Handle;
BEGIN
IF f.Do # NIL THEN
old := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor]);
Dialog.ShowStatus("");
f.Do(f);
old := USER32.SetCursor(old)
END
END Execute;
PROCEDURE (f: PushButton) KeyDown (ch: CHAR);
BEGIN
ASSERT(~f.disabled, 100);
Execute(f)
END KeyDown;
PROCEDURE (f: PushButton) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* CheckBox *)
PROCEDURE (f: CheckBox) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: CheckBox) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: CheckBox) Update;
VAR res: INTEGER; value: BOOLEAN;
BEGIN
IF ~f.disabled THEN
f.Get(f, value);
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.undef THEN res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 2, 0)
ELSIF value THEN res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 1, 0)
ELSE res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 0, 0)
END;
IF f.readOnly THEN res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.TRUE, 0)
ELSE res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.FALSE, 0)
END
ELSE
res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.FALSE, 0);
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
CheckLabel(f.label, f.i.ctrl);
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: CheckBox) Restore (l, t, r, b: INTEGER);
VAR style: SET; lbl: ARRAY 256 OF SHORTCHAR;
BEGIN
SetLabel(f.label, lbl);
IF f.i.ctrl = 0 THEN (* lazy allocation *)
(*
f.Get(f, value); (* update f.undef *)
IF f.undef THEN style := {1, 2, 16, 30} (* auto 3state, tabstop, child *)
ELSE style := {0, 1, 16, 30} (* auto checkbox, tabstop, child *)
END;
*)
style := {0, 2, 16, 30}; (* 3state, tabstop, child *)
Open(f, "BUTTON", lbl, style, {}, f.i)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, -1, 12 * Ports.point, -1, lbl) END
END Restore;
PROCEDURE (f: CheckBox) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: CheckBox) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch >= " " THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(" "), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(" "), 0)
END
END KeyDown;
PROCEDURE (f: CheckBox) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* RadioButton *)
PROCEDURE (f: RadioButton) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: RadioButton) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: RadioButton) Update;
VAR res: INTEGER; value: BOOLEAN;
BEGIN
IF ~f.disabled THEN
f.Get(f, value);
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.undef THEN res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 0, 0)
ELSIF value THEN res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 1, 0)
ELSE res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 0, 0)
END;
IF f.readOnly THEN res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.TRUE, 0)
ELSE res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.FALSE, 0)
END
ELSE
res := USER32.SendMessageA(f.i.ctrl, USER32.BMSetCheck, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, WinApi.BM_SETSTATE, WinApi.FALSE, 0);
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END;
CheckLabel(f.label, f.i.ctrl);
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: RadioButton) Restore (l, t, r, b: INTEGER);
VAR lbl: ARRAY 256 OF SHORTCHAR;
BEGIN
SetLabel(f.label, lbl);
IF f.i.ctrl = 0 THEN (* lazy allocation *)
Open(f, "BUTTON", lbl, {0, 3, 16, 30}, {}, f.i) (* auto radiobutton, tabstop, child *)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, -2, 12 * Ports.point, -1, lbl) END
END Restore;
PROCEDURE (f: RadioButton) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: RadioButton) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(" "), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(" "), 0)
END KeyDown;
PROCEDURE (f: RadioButton) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* ScrollBar *)
PROCEDURE (f: ScrollBar) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: ScrollBar) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: ScrollBar) Update;
VAR res, size, sect, pos, p, q, m: INTEGER; i: HostWindows.ScrollInfo;
BEGIN
IF ~f.disabled THEN
f.Get(f, size, sect, pos);
IF size > sect THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
p := KERNEL32.MulDiv(pos, scrollRange, size - sect);
IF (Dialog.platform # 11) & (HostWindows.GetScrollInfo # NIL) THEN
i.size := SIZE(HostWindows.ScrollInfo); i.mask := {0, 1, 2}; (* range, page, pos *)
res := HostWindows.GetScrollInfo(f.i.ctrl, USER32.SBCtl, i);
IF (res # 0) THEN
IF sect > 0 THEN q := KERNEL32.MulDiv(sect, scrollRange, size - sect); m := scrollRange + q
ELSE q := -1; m := scrollRange
END;
IF (i.pos # p) OR (i.page # q + 1) THEN
i.pos := p; i.page := q + 1; i.max := m;
res := HostWindows.SetScrollInfo(f.i.ctrl, USER32.SBCtl, i, 1)
END
ELSIF p # USER32.GetScrollPos(f.i.ctrl, USER32.SBCtl) THEN
res := USER32.SetScrollPos(f.i.ctrl, USER32.SBCtl, p, 1)
END
ELSIF p # USER32.GetScrollPos(f.i.ctrl, USER32.SBCtl) THEN
res := USER32.SetScrollPos(f.i.ctrl, USER32.SBCtl, p, 1)
END
(*
IF USER32.GetScrollPos(f.i.ctrl, USER32.SBCtl) # pos THEN
res := USER32.SetScrollRange(f.i.ctrl, USER32.SBCtl, 0, size, 1);
res := USER32.SetScrollPos(f.i.ctrl, USER32.SBCtl, pos, 1)
END
*)
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: ScrollBar) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; style: SET;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
style := {(*1,*) 16, 30}; (* topalign, tabstop, child *)
f.view.context.GetSize(w, h);
IF h > w THEN INCL(style, 0) END; (* vertical *)
Open(f, "SCROLLBAR", "", style, {}, f.i);
res := USER32.SetScrollRange(f.i.ctrl, USER32.SBCtl, 0, scrollRange, 1)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, f.dot, -1, -1, "") END
END Restore;
PROCEDURE (f: ScrollBar) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: ScrollBar) KeyDown (ch: CHAR);
BEGIN
ASSERT(~f.disabled, 100);
SendKey(SHORT(ch), f.i.ctrl)
END KeyDown;
PROCEDURE (f: ScrollBar) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* Field *)
PROCEDURE (f: Field) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: Field) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE InsLF (VAR x: ARRAY OF CHAR);
VAR i, j: INTEGER;
BEGIN
i := 0; j := 0;
WHILE x[i] # 0X DO
IF x[i] = 0DX THEN INC(j) END;
INC(i); INC(j)
END;
x[j] := 0X;
WHILE i # j DO
DEC(i); DEC(j);
IF x[i] = 0DX THEN x[j] := 0AX; DEC(j) END;
x[j] := x[i]
END
END InsLF;
PROCEDURE DelLF (VAR x: ARRAY OF CHAR);
VAR i, j: INTEGER;
BEGIN
i := 0; j := 0;
WHILE x[i] # 0X DO
IF x[i] = 0AX THEN INC(i) END;
x[j] := x[i]; INC(i); INC(j)
END;
x[j] := 0X
END DelLF;
PROCEDURE Equal (f: Field; VAR x, y: ARRAY OF CHAR): BOOLEAN;
BEGIN
DelLF(y);
RETURN f.Equal(f, x, y)
END Equal;
PROCEDURE (f: Field) Update;
VAR res: INTEGER; s, s1: ARRAY 512 OF CHAR; ps, ps1: POINTER TO ARRAY OF CHAR;
ss: ARRAY 512 OF SHORTCHAR; pss: POINTER TO ARRAY OF SHORTCHAR; style: SET;
BEGIN
IF f.maxLen > 255 THEN
NEW(ps, 2 * f.maxLen + 1); NEW(ps1, 2 * f.maxLen + 1); NEW(pss, 2 * f.maxLen + 1);
IF f.undef OR f.disabled THEN ps[0] := 0X ELSE f.Get(f, ps^) END;
res := USER32.GetWindowTextA(f.i.ctrl, pss^, LEN(pss^)); ps1^ := pss^$; ConvertToUnicode(ps1^);
IF (USER32.GetWindowTextLengthA(f.i.ctrl) >= LEN(ps^)) OR ~Equal(f, ps^, ps1^) THEN
f.isUpdate := TRUE;
IF f.multiLine THEN InsLF(ps^) END;
ConvertFromUnicode(ps^);
pss^ := SHORT(ps^$); res := USER32.SetWindowTextA(f.i.ctrl, pss^);
f.isUpdate := FALSE
END
ELSE
IF f.undef OR f.disabled THEN s := "" ELSE f.Get(f, s) END;
res := USER32.GetWindowTextA(f.i.ctrl, ss, LEN(s1)); s1 := ss$; ConvertToUnicode(s1);
IF (USER32.GetWindowTextLengthA(f.i.ctrl) >= LEN(s)) OR ~Equal(f, s, s1) THEN
f.isUpdate := TRUE;
IF f.multiLine THEN InsLF(s) END;
ConvertFromUnicode(s);
ss := SHORT(s$); res := USER32.SetWindowTextA(f.i.ctrl, ss);
f.isUpdate := FALSE
END
END;
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
IF (f.readOnly # f.i.readOnly) OR (f.undef # f.i.undef) THEN
(*
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style / {11}));
*)
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly; f.i.undef := f.undef
END;
IF f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: Field) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; style: SET;
s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
IF h > dropDownHeight THEN
style := {2, 6, 16, 23, 30}; (* multiline, autovscroll, tabstop, border, child *)
IF f.multiLine THEN INCL(style, 21) END (* ver scroll *)
ELSE
style := {7, 16, 23, 30} (* autohscroll, tabstop, border, child *)
END;
(*
IF f.readOnly THEN INCL(style, 11) END; (* readonly *)
*)
f.i.readOnly := f.readOnly; f.i.undef := f.undef;
IF f.right & ~f.left THEN style := style + {1, 2} (* right align, multiline *)
ELSIF ~f.left THEN style := style + {0, 2} (* center, multiline *)
END;
IF f.password THEN INCL(style, 5) END; (* password *)
Open(f, "EDIT", "", style, WinApi.WS_EX_CLIENTEDGE, f.i);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMLimitText, f.maxLen, 0);
f.Update;
IF f.front & ~f.disabled THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, 23H, 0)
END
ELSE f.Update
END;
IF f.i.wnd # 0 THEN
Paint(f, f.i)
ELSE
f.Get(f, s); ss := SHORT(s$);
Print(f, f.dot, 2 * Ports.point, 0, ss)
END
END Restore;
PROCEDURE (f: Field) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: Field) KeyDown (ch: CHAR);
BEGIN
ASSERT(~f.disabled, 100);
IF f.multiLine OR (ch # 0DX) THEN
f.del := FALSE;
IF (ch = DEL) OR (ch = BS) THEN f.del := TRUE END;
IF ch = 20ACX THEN ch := 80X END; (* euro *)
SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: Field) Edit (op: INTEGER; VAR v: Views.View; VAR w, h: INTEGER;
VAR singleton, clipboard: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF clipboard THEN
IF op = Controllers.cut THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCut, 0, 0)
ELSIF op = Controllers.copy THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCopy, 0, 0)
ELSIF op = Controllers.paste THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMPaste, 0, 0)
END
END
END Edit;
PROCEDURE (f: Field) Idle;
BEGIN
END Idle;
PROCEDURE (f: Field) Select (from, to: INTEGER);
VAR res: INTEGER;
BEGIN
IF to = MAX(INTEGER) THEN to := -1 END;
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, from, to)
END Select;
PROCEDURE (f: Field) GetSelection (OUT from, to: INTEGER);
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(f.i.ctrl, USER32.EMGetSel, SYSTEM.ADR(from), SYSTEM.ADR(to));
IF from = -1 THEN to := -1 ELSIF to = -1 THEN to := MAX(INTEGER) END
END GetSelection;
PROCEDURE (f: Field) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
PROCEDURE (f: Field) Length (): INTEGER;
VAR res: INTEGER;
BEGIN
res := USER32.GetWindowTextLengthA(f.i.ctrl);
RETURN res
END Length;
PROCEDURE (f: Field) GetCursor (x, y: INTEGER; modifiers: SET; VAR cursor: INTEGER);
VAR res, hc: INTEGER; pt: USER32.Point;
BEGIN
pt.x := (x - 1) DIV f.unit + 1; pt.y := (y - 1) DIV f.unit + 1;
res := USER32.ClientToScreen(f.i.wnd, pt);
hc := USER32.SendMessageA(f.i.ctrl, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
IF hc = 1 THEN cursor := Ports.textCursor END
END GetCursor;
(* UpDownField *)
PROCEDURE (f: UpDownField) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: UpDownField) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0; f.i.ud := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: UpDownField) Update;
VAR res, val: INTEGER; s: ARRAY 16 OF CHAR; ss: ARRAY 16 OF SHORTCHAR; style: SET; upd: BOOLEAN;
BEGIN
IF ~f.disabled THEN
IF f.undef THEN upd := TRUE ELSE f.Get(f, val); upd := val # f.val END;
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 1); upd := TRUE
END;
IF f.readOnly THEN
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
ELSE
IF USER32.IsWindowEnabled(f.i.ud) = 0 THEN res := USER32.EnableWindow(f.i.ud, 1) END
END;
IF upd THEN
f.isUpdate := TRUE;
IF f.undef THEN ss := ""
ELSE Strings.IntToString(val, s); ss := SHORT(s$)
END;
res := USER32.SetWindowTextA(f.i.ctrl, ss);
f.val := val; f.isUpdate := FALSE
END;
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
IF (f.readOnly # f.i.readOnly) OR (f.undef # f.i.undef) THEN
(*
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style / {11}));
*)
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly; f.i.undef := f.undef
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
f.isUpdate := TRUE;
res := USER32.SetWindowTextA(f.i.ctrl, "");
f.isUpdate := FALSE;
res := USER32.EnableWindow(f.i.ctrl, 0)
END;
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: UpDownField) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; style: SET; s: ARRAY 16 OF CHAR; ss: ARRAY 16 OF SHORTCHAR;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
style := {7, 16, 23, 30}; (* autohscroll, tabstop, border, child *)
(*
IF f.readOnly THEN INCL(style, 11) END; (* readonly *)
*)
f.i.readOnly := f.readOnly; f.i.undef := f.undef;
ss := "0"; f.val := 0;
Open(f, "EDIT", ss, style, WinApi.WS_EX_CLIENTEDGE, f.i);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMLimitText, 16, 0);
f.Update;
IF f.front & ~f.disabled THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, 23H, 0)
END
ELSE f.Update
END;
IF f.i.wnd # 0 THEN
Paint(f, f.i)
ELSE
f.Get(f, w);
Strings.IntToString(w, s); ss := SHORT(s$);
Print(f, f.dot, 2 * Ports.point, 0, ss)
END
END Restore;
PROCEDURE (f: UpDownField) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: UpDownField) KeyDown (ch: CHAR);
VAR val: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF (ch = AU) OR (ch = AD) THEN
val := f.val;
IF ch = AU THEN
IF val <= f.max - f.inc THEN val := val + f.inc ELSE val := f.max END
ELSE
IF val >= f.min + f.inc THEN val := val - f.inc ELSE val := f.min END
END;
IF val # f.val THEN f.Set(f, val); f.Update END
ELSIF (ch # 0DX) THEN
SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: UpDownField) Edit (op: INTEGER; VAR v: Views.View; VAR w, h: INTEGER;
VAR singleton, clipboard: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF clipboard THEN
IF op = Controllers.cut THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCut, 0, 0)
ELSIF op = Controllers.copy THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCopy, 0, 0)
ELSIF op = Controllers.paste THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMPaste, 0, 0)
END
END
END Edit;
PROCEDURE (f: UpDownField) Idle;
BEGIN
END Idle;
PROCEDURE (f: UpDownField) Select (from, to: INTEGER);
VAR res: INTEGER;
BEGIN
IF to = MAX(INTEGER) THEN to := -1 END;
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, from, to)
END Select;
PROCEDURE (f: UpDownField) GetSelection (OUT from, to: INTEGER);
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(f.i.ctrl, USER32.EMGetSel, SYSTEM.ADR(from), SYSTEM.ADR(to));
IF from = -1 THEN to := -1 ELSIF to = -1 THEN to := MAX(INTEGER) END
END GetSelection;
PROCEDURE (f: UpDownField) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
PROCEDURE (f: UpDownField) GetCursor (x, y: INTEGER; modifiers: SET; VAR cursor: INTEGER);
VAR res, hc: INTEGER; pt: USER32.Point;
BEGIN
pt.x := (x - 1) DIV f.unit + 1; pt.y := (y - 1) DIV f.unit + 1;
res := USER32.ClientToScreen(f.i.wnd, pt);
hc := USER32.SendMessageA(f.i.ctrl, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
IF hc = 1 THEN cursor := Ports.textCursor END
END GetCursor;
(* TimeField *)
PROCEDURE GetTimePart (VAR time: Dates.Time; part: INTEGER; VAR val, min, max: INTEGER);
BEGIN
IF part = -1 THEN part := lastPart END;
IF part = 4 THEN val := time.hour DIV 12; min := 0; max := 1
ELSIF part = 3 THEN val := time.second; min := 0; max := 59
ELSIF part = 2 THEN val := time.minute; min := 0; max := 59
ELSIF lastPart = 3 THEN val := time.hour; min := 0; max := 23
ELSE val := (time.hour - 1) MOD 12 + 1; min := 1; max := 12
END
END GetTimePart;
PROCEDURE SetTimePart (VAR time: Dates.Time; part: INTEGER; val: INTEGER);
BEGIN
IF part = -1 THEN part := lastPart END;
IF part = 4 THEN time.hour := val * 12 + time.hour MOD 12
ELSIF part = 3 THEN time.second := val
ELSIF part = 2 THEN time.minute := val
ELSIF lastPart = 3 THEN time.hour := val
ELSE time.hour := time.hour DIV 12 * 12 + val MOD 12
END
END SetTimePart;
PROCEDURE TimeToString (VAR time: Dates.Time; VAR str: ARRAY OF SHORTCHAR);
VAR val, min, max, i, j, k: INTEGER;
BEGIN
GetTimePart(time, 1, val, min, max);
str[0] := SHORT(CHR(val DIV 10 + ORD("0")));
str[1] := SHORT(CHR(val MOD 10 + ORD("0")));
str[2] := timeSep;
GetTimePart(time, 2, val, min, max);
str[3] := SHORT(CHR(val DIV 10 + ORD("0")));
str[4] := SHORT(CHR(val MOD 10 + ORD("0")));
str[5] := timeSep;
GetTimePart(time, 3, val, min, max);
str[6] := SHORT(CHR(val DIV 10 + ORD("0")));
str[7] := SHORT(CHR(val MOD 10 + ORD("0")));
IF lastPart = 3 THEN
str[8] := 0X
ELSE
str[8] := " ";
i := 9; j := 0; k := time.hour DIV 12;
WHILE desig[k, j] # 0X DO str[i] := desig[k, j]; INC(i); INC(j) END;
str[i] := 0X
END
END TimeToString;
PROCEDURE (f: TimeField) Select, NEW;
VAR res: INTEGER; sel: INTEGER;
BEGIN
f.GetSel(f, sel);
IF sel = -1 THEN sel := lastPart END;
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, 3 * sel - 3, 3 * sel - 1)
END Select;
PROCEDURE (f: TimeField) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: TimeField) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0; f.i.ud := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: TimeField) Update;
VAR res: INTEGER; s, s1: ARRAY 20 OF SHORTCHAR; time: Dates.Time; style: SET;
BEGIN
IF ~f.disabled THEN
IF f.undef THEN s := "" ELSE f.Get(f, time); TimeToString(time, s) END;
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.readOnly THEN
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
ELSE
IF USER32.IsWindowEnabled(f.i.ud) = 0 THEN res := USER32.EnableWindow(f.i.ud, 1) END
END;
res := USER32.GetWindowTextA(f.i.ctrl, s1, LEN(s1));
IF s # s1 THEN
f.isUpdate := TRUE;
res := USER32.SetWindowTextA(f.i.ctrl, s);
f.isUpdate := FALSE
END;
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
IF (f.readOnly # f.i.readOnly) OR (f.undef # f.i.undef) THEN
(*
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style / {11}));
*)
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly; f.i.undef := f.undef
END;
f.Select
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
f.isUpdate := TRUE;
res := USER32.SetWindowTextA(f.i.ctrl, "");
f.isUpdate := FALSE;
res := USER32.EnableWindow(f.i.ctrl, 0)
END;
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: TimeField) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; style: SET; s: ARRAY 20 OF SHORTCHAR; time: Dates.Time;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
style := {7, 16, 23, 30}; (* autohscroll, tabstop, border, child *)
(*
IF f.readOnly THEN INCL(style, 11) END; (* readonly *)
*)
f.i.readOnly := f.readOnly; f.i.undef := f.undef;
Open(f, "EDIT", "", style, WinApi.WS_EX_CLIENTEDGE, f.i);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMLimitText, 16, 0);
f.Update;
IF f.front & ~f.disabled THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, 23H, 0)
END
ELSE f.Update
END;
IF f.i.wnd # 0 THEN
Paint(f, f.i)
ELSE
f.Get(f, time);
TimeToString(time, s);
Print(f, f.dot, 2 * Ports.point, 0, s)
END
END Restore;
PROCEDURE (f: TimeField) MouseDown (x, y: INTEGER; buttons: SET);
VAR res: INTEGER; sel: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
f.GetSel(f, sel);
IF sel = 0 THEN f.SetSel(f, 1); f.Select END;
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMGetSel, 0, 0);
sel := res MOD 65536 DIV 3 + 1;
IF sel >= lastPart THEN sel := -1 END;
f.cur := 0; f.SetSel(f, sel); f.Select
END
END MouseDown;
PROCEDURE (f: TimeField) KeyDown (ch: CHAR);
VAR sel, s, val, v, min, max: INTEGER; time: Dates.Time;
BEGIN
ASSERT(~f.disabled, 100);
f.GetSel(f, sel); s := sel;
IF s = -1 THEN s := lastPart END;
f.Get(f, time);
GetTimePart(time, s, val, min, max); v := val;
IF (ch = TAB) OR (ch = AR) THEN
s := s MOD lastPart + 1; f.cur := 0
ELSIF (ch = LTAB) OR (ch = AL) THEN
DEC(s); f.cur := 0;
IF s <= 0 THEN s := lastPart END
ELSIF (ch = PL) OR (ch = DL) THEN
s := 1; f.cur := 0
ELSIF (ch = PR) OR (ch = DR) THEN
s := lastPart; f.cur := 0
ELSIF (ch = DEL) OR (ch = BS) THEN
v := min
ELSIF ch = AU THEN
IF v < max THEN INC(v) ELSE v := min END
ELSIF ch = AD THEN
IF v > min THEN DEC(v) ELSE v := max END
ELSIF (ch >= "0") & (ch <= "9") & (s < 4) THEN
v := v * 10 MOD 100 + ORD(ch) - ORD("0");
IF v > max THEN v := v MOD 10 ELSIF v < min THEN v := min END
ELSIF s = 4 THEN
IF (ch = " ") OR (CAP(ch) = CAP(desig[1 - v, 0])) THEN v := 1 - v END
END;
IF s = lastPart THEN s := -1 END;
IF v # val THEN
SetTimePart(time, s, v); f.Set(f, time); f.Update
ELSIF s # sel THEN
f.SetSel(f, s); f.Select
END
END KeyDown;
PROCEDURE (f: TimeField) Edit (op: INTEGER; VAR v: Views.View; VAR w, h: INTEGER;
VAR singleton, clipboard: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF clipboard THEN
IF op = Controllers.copy THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCopy, 0, 0)
END
END
END Edit;
PROCEDURE (f: TimeField) Mark (on, focus: BOOLEAN);
VAR res: INTEGER;
BEGIN
Mark(on, f.front, f.i);
IF ~on & focus THEN
f.SetSel(f, 0); f.cur := 0;
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, 0, 0)
END
END Mark;
PROCEDURE (f: TimeField) GetCursor (x, y: INTEGER; modifiers: SET; VAR cursor: INTEGER);
VAR res, hc: INTEGER; pt: USER32.Point;
BEGIN
pt.x := (x - 1) DIV f.unit + 1; pt.y := (y - 1) DIV f.unit + 1;
res := USER32.ClientToScreen(f.i.wnd, pt);
hc := USER32.SendMessageA(f.i.ctrl, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
IF hc = 1 THEN cursor := Ports.textCursor END
END GetCursor;
(* DateField *)
PROCEDURE GetDatePart (VAR date: Dates.Date; part: INTEGER; OUT val, min, max: INTEGER);
(* GetDatePart picks the day, month or year part out of a given date and asigns it to the out
parameter val, together with the min and max possible values for this part
*)
BEGIN
IF part = -1 THEN part := 3 END;
IF part = yearPart THEN val := date.year; min := 1; max := 9999
ELSIF part = monthPart THEN val := date.month; min := 1; max := 12
ELSE
val := date.day; min := 1;
IF date.month = 0 THEN
max := 31
ELSIF date.month = 2 THEN
IF (date.year MOD 4 = 0)
& ((date.year < 1583) OR (date.year MOD 100 # 0) OR (date.year MOD 400 = 0))
THEN
max := 29
ELSE max := 28
END
ELSIF date.month IN {1, 3, 5, 7, 8, 10, 12} THEN max := 31
ELSE max := 30
END
END
END GetDatePart;
PROCEDURE SetDatePart (VAR date: Dates.Date; part: INTEGER; val: INTEGER);
(* SetDatePart sets the day, month or year part in a given date to the value specivied
by the parameter val.
If the month is set, the day is adjusted to the possible range of days in this month.
If the day is set, then the month may be changed in order to obtain a valid date
*)
VAR v, min, max: INTEGER;
BEGIN
IF part = -1 THEN part := 3 END;
IF part = yearPart THEN date.year := val
ELSIF part = monthPart THEN date.month := val
ELSE date.day := val
END;
GetDatePart(date, dayPart, v, min, max);
IF (part = monthPart) THEN (* adjust day if month value is set and day > max *)
IF v > max THEN date.day := max END
ELSIF part = yearPart THEN (* adjust month is day value is set and day > max *)
IF v > max THEN INC(date.month) END
END
END SetDatePart;
PROCEDURE DateToString (VAR date: Dates.Date; VAR str: ARRAY OF SHORTCHAR);
VAR val, min, max, p, i: INTEGER;
BEGIN
p := 1; i := 0;
WHILE p <= 3 DO
IF p > 1 THEN str[i] := dateSep; INC(i) END;
GetDatePart(date, p, val, min, max);
IF max = 9999 THEN
str[i] := SHORT(CHR(val DIV 1000 MOD 10 + ORD("0"))); INC(i);
str[i] := SHORT(CHR(val DIV 100 MOD 10 + ORD("0"))); INC(i)
END;
str[i] := SHORT(CHR(val DIV 10 MOD 10 + ORD("0"))); INC(i);
str[i] := SHORT(CHR(val MOD 10 + ORD("0"))); INC(i);
INC(p)
END;
str[i] := 0X
END DateToString;
PROCEDURE (f: DateField) Select, NEW;
VAR res: INTEGER; sel, a, b: INTEGER;
BEGIN
f.GetSel(f, sel);
IF sel = 1 THEN a := 0; b := del1
ELSIF sel = 2 THEN a := del1 + 1; b := del2
ELSE a := del2 + 1; b := del2 + 5
END;
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, a, b)
END Select;
PROCEDURE (f: DateField) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: DateField) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0; f.i.ud := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: DateField) Update;
VAR res: INTEGER; s, s1: ARRAY 20 OF SHORTCHAR; date: Dates.Date; style: SET; sel: INTEGER;
BEGIN
IF ~f.disabled THEN
IF f.undef THEN s := ""
ELSE f.Get(f, date);
IF f.cnt > 0 THEN f.GetSel(f, sel); SetDatePart(date, sel, f.val) END;
DateToString(date, s)
END;
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.readOnly THEN
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
ELSE
IF USER32.IsWindowEnabled(f.i.ud) = 0 THEN res := USER32.EnableWindow(f.i.ud, 1) END
END;
res := USER32.GetWindowTextA(f.i.ctrl, s1, LEN(s1));
IF s # s1 THEN
f.isUpdate := TRUE;
res := USER32.SetWindowTextA(f.i.ctrl, s);
f.isUpdate := FALSE
END;
style := BITS(USER32.GetWindowLongA(f.i.ctrl, -16)); (* window style *)
IF (f.readOnly # f.i.readOnly) OR (f.undef # f.i.undef) THEN
(*
res := USER32.SetWindowLongA(f.i.ctrl, -16, ORD(style / {11}));
*)
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly; f.i.undef := f.undef
END;
f.Select
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
f.isUpdate := TRUE;
res := USER32.SetWindowTextA(f.i.ctrl, "");
f.isUpdate := FALSE;
res := USER32.EnableWindow(f.i.ctrl, 0)
END;
IF USER32.IsWindowEnabled(f.i.ud) # 0 THEN res := USER32.EnableWindow(f.i.ud, 0) END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: DateField) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; style: SET; s: ARRAY 20 OF SHORTCHAR; date: Dates.Date;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
style := {7, 16, 23, 30}; (* autohscroll, tabstop, border, child *)
(*
IF f.readOnly THEN INCL(style, 11) END; (* readonly *)
*)
f.i.readOnly := f.readOnly; f.i.undef := f.undef;
Open(f, "EDIT", "", style, WinApi.WS_EX_CLIENTEDGE, f.i);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMLimitText, 16, 0);
f.Update;
IF f.front & ~f.disabled THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, 23H, 0)
END
ELSE f.Update
END;
IF f.i.wnd # 0 THEN
Paint(f, f.i)
ELSE
f.Get(f, date);
DateToString(date, s);
Print(f, f.dot, 2 * Ports.point, 0, s)
END
END Restore;
PROCEDURE ActualizeDate(f: DateField);
VAR sel: INTEGER; date: Dates.Date; val, min, max: INTEGER;
BEGIN
IF f.cnt > 0 THEN
f.GetSel(f, sel); IF sel = -1 THEN sel := 3 END;
f.Get(f, date);
IF (sel = yearPart) & (f.cnt <= 2) THEN
IF f.val < 50 THEN f.val := f.val + 2000
ELSIF f.val < 100 THEN f.val := f.val + 1900
END
END;
GetDatePart(date, sel, val, min, max);
IF (min <= f.val) & (f.val <= max) THEN
SetDatePart(date, sel, f.val); f.Set(f, date)
END;
f.cnt := 0;
f.Update
END
END ActualizeDate;
PROCEDURE (f: DateField) MouseDown (x, y: INTEGER; buttons: SET);
VAR res: INTEGER; sel: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
ActualizeDate(f);
f.GetSel(f, sel);
IF sel = 0 THEN f.SetSel(f, 1); f.Select END;
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMGetSel, 0, 0);
res := res MOD 65536;
IF res <= del1 THEN sel := 1
ELSIF res <= del2 THEN sel := 2
ELSE sel := -1
END;
f.SetSel(f, sel); f.Select
END
END MouseDown;
PROCEDURE (f: DateField) KeyDown (ch: CHAR);
VAR sel, s, val, min, max: INTEGER; date: Dates.Date;
BEGIN
ASSERT(~f.disabled, 100);
f.GetSel(f, sel); s := sel;
IF s = -1 THEN s := 3 END;
f.Get(f, date);
GetDatePart(date, s, val, min, max);
IF (ch = TAB) OR (ch = AR) THEN
s := s MOD 3 + 1;
ActualizeDate(f)
ELSIF ((ch = ".") OR (ch = ",")) & (f.cnt > 0) THEN
s := s MOD 3 + 1;
ActualizeDate(f)
ELSIF (ch = LTAB) OR (ch = AL) THEN
IF s = 0 THEN s := 1 END;
s := (s - 2) MOD 3 + 1;
ActualizeDate(f)
ELSIF (ch = PL) OR (ch = DL) THEN
s := 1;
ActualizeDate(f)
ELSIF (ch = PR) OR (ch = DR) THEN
s := 3;
ActualizeDate(f)
ELSIF (ch = DEL) OR (ch = BS) THEN
f.cnt := 4; f.val := min;
ActualizeDate(f)
ELSIF ch = AU THEN
IF f.cnt = 0 THEN f.cnt := 4; f.val := val END;
IF f.val < max THEN INC(f.val) ELSE f.val := min END;
ActualizeDate(f)
ELSIF ch = AD THEN
IF f.cnt = 0 THEN f.cnt := 4; f.val := val END;
IF f.val > min THEN DEC(f.val) ELSE f.val := max END;
ActualizeDate(f)
ELSIF (ch >= "0") & (ch <= "9") THEN
IF s = yearPart THEN
IF f.cnt = 0 THEN
f.val := ORD(ch) - ORD("0"); INC(f.cnt);
f.Update
ELSE
f.val := f.val * 10 + ORD(ch) - ORD("0");
INC(f.cnt);
IF f.cnt = 4 THEN ActualizeDate(f) ELSE f.Update END
END
ELSE
IF f.cnt = 0 THEN
f.val := ORD(ch) - ORD("0"); f.cnt := 1;
f.Update
ELSE
f.val := f.val * 10 MOD 100 + ORD(ch) - ORD("0");
IF (s = dayPart) & (max < f.val) & (f.val <= 31) THEN
INC(date.month); f.Set(f, date); max := 31
END;
IF f.val > max THEN f.val := f.val MOD 10 END;
ActualizeDate(f);
INC(s)
END
END
END;
IF s = 3 THEN s := -1 END;
IF s # sel THEN
f.SetSel(f, s); f.Select
END
END KeyDown;
PROCEDURE (f: DateField) Edit (op: INTEGER; VAR v: Views.View; VAR w, h: INTEGER;
VAR singleton, clipboard: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF clipboard THEN
IF op = Controllers.copy THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMCopy, 0, 0)
END
END
END Edit;
PROCEDURE (f: DateField) Mark (on, focus: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF ~on THEN ActualizeDate(f) END;
Mark(on, f.front, f.i);
IF ~on & focus THEN
f.SetSel(f, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.EMSetSel, 0, 0)
END
END Mark;
PROCEDURE (f: DateField) GetCursor (x, y: INTEGER; modifiers: SET; VAR cursor: INTEGER);
VAR res, hc: INTEGER; pt: USER32.Point;
BEGIN
pt.x := (x - 1) DIV f.unit + 1; pt.y := (y - 1) DIV f.unit + 1;
res := USER32.ClientToScreen(f.i.wnd, pt);
hc := USER32.SendMessageA(f.i.ctrl, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
IF hc = 1 THEN cursor := Ports.textCursor END
END GetCursor;
(* ColorField *)
PROCEDURE (f: ColorField) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: ColorField) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: ColorField) Update;
VAR res, i, j: INTEGER; c: Ports.Color;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.undef THEN j := -1
ELSE
f.Get(f, c); j := 0;
WHILE (j < numColors) & (c # colors[j]) DO INC(j) END
END;
i := USER32.SendMessageA(f.i.ctrl, USER32.CBGetCurSel, 0, 0);
IF (i # j) OR (j = numColors) & (c # f.color) THEN
f.color := c;
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, j, 0)
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, -1, 0);
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
IF f.readOnly # f.i.readOnly THEN
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: ColorField) Restore (l, t, r, b: INTEGER);
VAR res, w, h, i: INTEGER; style: SET;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
f.i.dropDown := TRUE; f.i.readOnly := f.readOnly;
(* drop down list, auto scroll, ownerdrawn, tabstop, ver scroll, border, child *)
style := {0, 1, 4, 6, 16, 21, 23, 30};
Open(f, "COMBOBOX", "", style, WinApi.WS_EX_CLIENTEDGE, f.i); i := 0;
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetExtendedUI, 1, 0);
WHILE i < numColors DO
res := USER32.SendMessageA(f.i.ctrl, USER32.CBAddString, 0, colors[i]);
INC(i)
END;
res := USER32.SendMessageA(f.i.ctrl, USER32.CBAddString, 0, -1);
Adapt(f, f.i)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, f.dot, -1, -1, "") END
END Restore;
PROCEDURE (f: ColorField) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: ColorField) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch = " " THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(ch), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(ch), 0)
ELSE SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: ColorField) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* ListBox *)
PROCEDURE (f: ListBox) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: ListBox) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: ListBox) Update;
VAR res, i, j: INTEGER;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF f.undef THEN i := -1 ELSE f.Get(f, i) END; j := i;
IF f.i.dropDown THEN
IF (i < 0) OR (i >= USER32.SendMessageA(f.i.ctrl, USER32.CBGetCount, 0, 0)) THEN j := -1
ELSIF f.sorted THEN
j := 0;
WHILE i # USER32.SendMessageA(f.i.ctrl, USER32.CBGetItemData, j, 0) DO INC(j) END
END;
i := USER32.SendMessageA(f.i.ctrl, USER32.CBGetCurSel, j, 0);
IF i # j THEN res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, j, 0) END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
IF (i < 0) OR (i >= USER32.SendMessageA(f.i.ctrl, USER32.LBGetCount, 0, 0)) THEN j := -1
ELSIF f.sorted THEN
j := 0;
WHILE i # USER32.SendMessageA(f.i.ctrl, USER32.LBGetItemData, j, 0) DO INC(j) END
END;
i := USER32.SendMessageA(f.i.ctrl, USER32.LBGetCurSel, j, 0);
IF i # j THEN res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetCurSel, j, 0) END
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
IF f.i.dropDown THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, -1, 0)
ELSE
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetCurSel, -1, 0)
END;
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
IF f.readOnly # f.i.readOnly THEN
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: ListBox) UpdateList;
VAR res, i: INTEGER; s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
IF f.i.dropDown THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBResetContent, 0, 0);
i := 0; f.GetName(f, i, s);
Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$);
WHILE ss # "" DO
res := USER32.SendMessageA(f.i.ctrl, USER32.CBAddString, 0, SYSTEM.ADR(ss));
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetItemData, res, i);
INC(i); f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$)
END;
Adapt(f, f.i)
ELSE
res := USER32.SendMessageA(f.i.ctrl, USER32.LBResetContent, 0, 0);
i := 0; f.GetName(f, i, s);
Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$);
WHILE ss # "" DO
res := USER32.SendMessageA(f.i.ctrl, USER32.LBAddString, 0, SYSTEM.ADR(ss));
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetItemData, res, i);
INC(i); f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$)
END
END;
f.Update
END UpdateList;
PROCEDURE (f: ListBox) Restore (l, t, r, b: INTEGER);
VAR i, res, w, h: INTEGER; style: SET; s: ARRAY 512 OF CHAR;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.view.context.GetSize(w, h);
IF h > dropDownHeight THEN
f.i.dropDown := FALSE; f.i.readOnly := f.readOnly;
style := {0, 16, 21, 23, 30}; (* notify, tabstop, ver scroll, border, child *)
IF f.sorted THEN INCL(style, 1) END; (* sort *)
Open(f, "LISTBOX", "", style, WinApi.WS_EX_CLIENTEDGE, f.i)
ELSE
f.i.dropDown := TRUE;
style := {0, 1, 6, 16, 21, 23, 30}; (* drop down list, auto scroll, tabstop, ver scroll, border, child *)
IF f.sorted THEN INCL(style, 8) END; (* sort *)
Open(f, "COMBOBOX", "", style, WinApi.WS_EX_CLIENTEDGE, f.i);
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetExtendedUI, WinApi.TRUE, 0)
END;
f.UpdateList
ELSE
f.Update
END;
IF f.i.wnd # 0 THEN Paint(f, f.i)
ELSE
f.Get(f, i); f.GetName(f, i, s);
Print(f, f.dot, 2 * Ports.point, 0, SHORT(s$))
END
END Restore;
PROCEDURE (f: ListBox) DblClickOk (x, y: INTEGER): BOOLEAN;
VAR res, i: INTEGER; rect: WinApi.RECT;
BEGIN
f.Get(f, i);
res := USER32.SendMessageA(f.i.ctrl, WinApi.LB_GETITEMRECT, i, SYSTEM.ADR(rect));
IF res = WinApi.LB_ERR THEN RETURN FALSE END;
x := x DIV f.unit; y := y DIV f.unit;
RETURN (x >= rect.left) & (x <= rect.right) & (y >= rect.top) & (y <= rect.bottom)
END DblClickOk;
PROCEDURE (f: ListBox) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: ListBox) WheelMove (x, y: INTEGER; op, nofLines: INTEGER; VAR done: BOOLEAN);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleWheel(f.i.ctrl, x DIV f.unit, y DIV f.unit, op, nofLines, done)
END
END WheelMove;
PROCEDURE (f: ListBox) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch = " " THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(ch), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(ch), 0)
ELSE
IF ch = 20ACX THEN ch := 80X END; (* euro *)
SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: ListBox) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* SelectionBox *)
PROCEDURE (f: SelectionBox) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: SelectionBox) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: SelectionBox) DblClickOk (x, y: INTEGER): BOOLEAN;
VAR res, i: INTEGER; s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
sel: BOOLEAN; rect: WinApi.RECT;
BEGIN
i := 0; f.GetName(f, i, s); ConvertFromUnicode(s); ss := SHORT(s$);
x := x DIV f.unit; y := y DIV f.unit;
WHILE ss # "" DO
f.Get(f, i, sel);
IF sel THEN
res := USER32.SendMessageA(f.i.ctrl, WinApi.LB_GETITEMRECT, i, SYSTEM.ADR(rect));
IF res = WinApi.LB_ERR THEN RETURN FALSE END;
IF (x >= rect.left) & (x <= rect.right) & (y >= rect.top) & (y <= rect.bottom) THEN RETURN TRUE END
END;
INC(i); f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$)
END;
RETURN FALSE
END DblClickOk;
PROCEDURE (f: SelectionBox) Update;
VAR res, i, j, a, b: INTEGER; sel: BOOLEAN;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
i := 0;
WHILE i < f.num DO j := i;
IF f.sorted THEN
j := USER32.SendMessageA(f.i.ctrl, USER32.LBGetItemData, i, 0)
END;
f.Get(f, j, sel);
IF sel & ~f.undef THEN a := 1 ELSE a := 0 END;
b := USER32.SendMessageA(f.i.ctrl, USER32.LBGetSel, i, 0);
IF a # b THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetSel, a, i) END;
INC(i)
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetSel, 0, -1);
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
IF f.readOnly # f.i.readOnly THEN
res := USER32.InvalidateRect(f.i.ctrl, NIL, 1);
f.i.readOnly := f.readOnly
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: SelectionBox) UpdateRange (op, from, to: INTEGER);
VAR res, i, a, b: INTEGER; sel: BOOLEAN;
BEGIN
ASSERT((from >= 0) & (from <= to) & (to < f.num), 100);
IF (op = Dialog.set) OR (from # to) THEN f.Update; RETURN END;
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
i := from;
IF f.sorted THEN
i := 0;
WHILE USER32.SendMessageA(f.i.ctrl, USER32.LBGetItemData, i, 0) # from DO INC(i) END
END;
f.Get(f, from, sel);
IF sel THEN a := 1 ELSE a := 0 END;
b := USER32.SendMessageA(f.i.ctrl, USER32.LBGetSel, i, 0);
IF a # b THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetSel, a, i) END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END
END UpdateRange;
PROCEDURE (f: SelectionBox) UpdateList;
VAR res, i: INTEGER; s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
res := USER32.SendMessageA(f.i.ctrl, USER32.LBResetContent, 0, 0);
i := 0; f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$);
WHILE ss # "" DO
res := USER32.SendMessageA(f.i.ctrl, USER32.LBAddString, 0, SYSTEM.ADR(ss));
res := USER32.SendMessageA(f.i.ctrl, USER32.LBSetItemData, res, i);
INC(i); f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$)
END;
f.num := i;
f.Update
END UpdateList;
PROCEDURE (f: SelectionBox) Restore (l, t, r, b: INTEGER);
VAR style: SET;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.i.readOnly := f.readOnly;
style := {0, 3, 16, 21, 23, 30} + WinApi.LBS_EXTENDEDSEL;
(* notify, multiple sel, tabstop, ver scroll, border, child *)
IF f.sorted THEN INCL(style, 1) END; (* sort *)
Open(f, "LISTBOX", "", style, WinApi.WS_EX_CLIENTEDGE, f.i);
f.UpdateList
ELSE
f.Update
END;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, f.dot, -1, -1, "") END
END Restore;
PROCEDURE (f: SelectionBox) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: SelectionBox) WheelMove (x, y: INTEGER; op, nofLines: INTEGER; VAR done: BOOLEAN);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleWheel(f.i.ctrl, x, y, op, nofLines, done)
END
END WheelMove;
PROCEDURE (f: SelectionBox) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch = " " THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(ch), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(ch), 0)
ELSE
IF ch = 20ACX THEN ch := 80X END; (* euro *)
SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: SelectionBox) Select (from, to: INTEGER);
BEGIN
END Select;
PROCEDURE (f: SelectionBox) GetSelection (OUT from, to: INTEGER);
BEGIN
from := 0; to := MAX(INTEGER)
END GetSelection;
PROCEDURE (f: SelectionBox) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
(* ComboBox *)
PROCEDURE (f: ComboBox) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: ComboBox) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: ComboBox) Update;
VAR res: INTEGER; s: ARRAY 256 OF CHAR; ss, ss1: ARRAY 256 OF SHORTCHAR;
BEGIN
IF ~f.disabled THEN
IF f.undef THEN ss := "" ELSE f.Get(f, s); ConvertFromUnicode(s); ss := SHORT(s$) END;
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END;
res := USER32.GetWindowTextA(f.i.ctrl, ss1, LEN(ss1));
IF (USER32.GetWindowTextLengthA(f.i.ctrl) >= LEN(ss)) OR (ss # ss1) THEN
IF ~f.i.dropDown THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBFindStringExact, -1, SYSTEM.ADR(ss));
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, res, 0)
END;
res := USER32.SetWindowTextA(f.i.ctrl, ss)
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetCurSel, -1, 0);
res := USER32.SetWindowTextA(f.i.ctrl, "");
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: ComboBox) UpdateList;
VAR res, i: INTEGER; s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBResetContent, 0, 0);
i := 0; f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$);
WHILE ss # "" DO
res := USER32.SendMessageA(f.i.ctrl, USER32.CBAddString, 0, SYSTEM.ADR(ss));
INC(i); f.GetName(f, i, s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s$)
END;
Adapt(f, f.i);
f.Update
END UpdateList;
PROCEDURE (f: ComboBox) Restore (l, t, r, b: INTEGER);
VAR res, w, h: INTEGER; s: ARRAY 256 OF CHAR; ss: ARRAY 256 OF SHORTCHAR;
style: SET; pt: USER32.Point;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.Get(f, s); ConvertFromUnicode(s); ss := SHORT(s$); f.view.context.GetSize(w, h);
style := {6, 16, 21, 23, 30}; (* auto scroll, tabstop, ver scroll, border, child *)
IF f.sorted THEN INCL(style, 8) END; (* sort *)
f.i.dropDown := h <= dropDownHeight;
IF f.i.dropDown THEN INCL(style, 1) ELSE INCL(style, 0) END; (* dropdown / simple *)
Open(f, "COMBOBOX", ss, style, WinApi.WS_EX_CLIENTEDGE, f.i);
pt.x := 4; pt.y := 4;
f.edit := USER32.ChildWindowFromPoint(f.i.ctrl, pt); (* hack found in win api manual ! *)
res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetExtendedUI, 1, 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.CBLimitText, 255, 0);
f.UpdateList
ELSE
f.Update
END;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, f.dot, -1, -1, "") END
END Restore;
PROCEDURE (f: ComboBox) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: ComboBox) KeyDown (ch: CHAR);
BEGIN
ASSERT(~f.disabled, 100);
IF ch = 20ACX THEN ch := 80X END; (* euro *)
SendKey(SHORT(ch), f.edit)
END KeyDown;
PROCEDURE (f: ComboBox) Edit (op: INTEGER;
VAR v: Views.View; VAR w, h: INTEGER; VAR singleton, clipboard: BOOLEAN
);
VAR res: INTEGER;
BEGIN
IF clipboard THEN
IF op = Controllers.cut THEN
res := USER32.SendMessageA(f.edit, USER32.WMCut, 0, 0)
ELSIF op = Controllers.copy THEN
res := USER32.SendMessageA(f.edit, USER32.WMCopy, 0, 0)
ELSIF op = Controllers.paste THEN
res := USER32.SendMessageA(f.edit, USER32.WMPaste, 0, 0)
END
END
END Edit;
PROCEDURE (f: ComboBox) Idle;
END Idle;
PROCEDURE (f: ComboBox) Select (from, to: INTEGER);
VAR res: INTEGER;
BEGIN
IF to > 32767 THEN to := -1 END;
IF from < 0 THEN res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetEditSel, 0, 65535)
ELSE res := USER32.SendMessageA(f.i.ctrl, USER32.CBSetEditSel, 0, from MOD 65536 + to * 65536)
END
END Select;
PROCEDURE (f: ComboBox) GetSelection (OUT from, to: INTEGER);
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(f.i.ctrl, USER32.CBGetEditSel, SYSTEM.ADR(from), SYSTEM.ADR(to));
IF from = -1 THEN to := -1 ELSIF to = -1 THEN to := MAX(INTEGER) END
END GetSelection;
PROCEDURE (f: ComboBox) Mark (on, focus: BOOLEAN);
VAR res: INTEGER;
BEGIN
IF f.front THEN
IF on THEN
IF ~f.i.hasFocus THEN
res := USER32.SendMessageA(f.edit, USER32.WMSetFocus, 0, 0);
f.i.hasFocus := TRUE
END
ELSE
IF f.i.hasFocus THEN
res := USER32.SendMessageA(f.edit, USER32.WMKillFocus, 0, 0);
f.i.hasFocus := FALSE
END
END
END
END Mark;
PROCEDURE (f: ComboBox) Length (): INTEGER;
VAR res: INTEGER;
BEGIN
res := USER32.GetWindowTextLengthA(f.i.ctrl);
RETURN res
END Length;
PROCEDURE (f: ComboBox) GetCursor (x, y: INTEGER; modifiers: SET; VAR cursor: INTEGER);
VAR res, hc: INTEGER; pt: USER32.Point;
BEGIN
pt.x := (x - 1) DIV f.unit + 1; pt.y := (y - 1) DIV f.unit + 1;
res := USER32.ClientToScreen(f.i.wnd, pt);
hc := USER32.SendMessageA(f.edit, USER32.WMNCHitTest, 0, pt.x + pt.y * 65536);
IF hc = 1 THEN cursor := Ports.textCursor END
(*
u := f.unit; pt.x := x DIV u - 1; pt.y := y DIV u - 1;
wnd := USER32.ChildWindowFromPoint(f.i.ctrl, pt);
IF wnd = f.edit THEN cursor := Ports.textCursor
ELSE cursor := Ports.arrowCursor
END
u := f.unit; pt.x := x DIV u; pt.y := y DIV u;
res := USER32.ClientToScreen(f.i.wnd, pt);
ChildWindowAt(f.i.wnd, pt, wnd, hc);
res := USER32.ScreenToClient(wnd, pt);
res := USER32.SendMessageA(wnd, USER32.WMSetCursor, wnd, hc + USER32.WMMouseMove * 65536);
cursor := -1
*)
END GetCursor;
(* Caption *)
PROCEDURE (f: Caption) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: Caption) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f:Caption ) Update;
VAR res: INTEGER;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END;
CheckLabel(f.label, f.i.ctrl);
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: Caption) Restore (l, t, r, b: INTEGER);
VAR lbl: ARRAY 256 OF SHORTCHAR; style: SET;
BEGIN
SetLabel(f.label, lbl);
IF f.i.ctrl = 0 THEN (* lazy allocation *)
style := {30};
IF f.left THEN style := style + WinApi.SS_LEFT
ELSIF f.right THEN style := style + WinApi.SS_RIGHT
ELSE style := style + WinApi.SS_CENTER
END;
Open(f, "STATIC", lbl, style, {}, f.i) (* left, child *)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, 0, 2 * Ports.point, 0, lbl) END
END Restore;
(* Group *)
PROCEDURE (f: Group) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: Group) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END
(*f.Close^*)
END Close;
PROCEDURE (f: Group) Update;
VAR res: INTEGER;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN res := USER32.EnableWindow(f.i.ctrl, 1) END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN res := USER32.EnableWindow(f.i.ctrl, 0) END
END;
CheckLabel(f.label, f.i.ctrl);
res := USER32.UpdateWindow(f.i.ctrl)
END Update;
PROCEDURE (f: Group) Restore (l, t, r, b: INTEGER);
VAR lbl: ARRAY 256 OF SHORTCHAR;
BEGIN
SetLabel(f.label, lbl);
IF f.i.ctrl = 0 THEN (* lazy allocation *)
Open(f, "BUTTON", lbl, {0, 1, 2, 30}, {}, f.i) (* group box, child *)
END;
f.Update;
IF f.i.wnd # 0 THEN Paint(f, f.i) ELSE Print(f, -3, 2 * Ports.point, 0, lbl) END
END Restore;
(* TreeFrame *)
PROCEDURE (f: TreeFrame) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: TreeFrame) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := USER32.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END;
IF f.himl # NIL THEN res := WinCtl.ImageList_Destroy(f.himl) END
END Close;
PROCEDURE (f: TreeFrame) Recreate (), NEW;
VAR res: INTEGER; style: SET;
icex: WinCtl.INITCOMMONCONTROLSEX; ok: WinApi.BOOL; hbmp: WinApi.HANDLE;
BEGIN
f.Close(); f.i.readOnly := f.readOnly;
icex.dwSize := SIZE(WinCtl.INITCOMMONCONTROLSEX);
icex.dwICC := WinCtl.ICC_TREEVIEW_CLASSES;
ok := WinCtl.InitCommonControlsEx(icex);
style := WinApi.WS_VISIBLE + WinApi.WS_CHILD + WinApi.WS_BORDER + WinCtl.TVS_SHOWSELALWAYS
+ WinCtl.TVS_DISABLEDRAGDROP;
IF f.haslines THEN style := style + WinCtl.TVS_HASLINES END;
IF f.hasbuttons THEN style := style + WinCtl.TVS_HASBUTTONS END;
IF f.atroot THEN style := style + WinCtl.TVS_LINESATROOT END;
Open(f, WinCtl.WC_TREEVIEW, "", style, {}, f.i); (* 3 *)
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TV_FIRST + 033, 100, 0); (* TVM_SETSCROLLTIME*)
IF f.foldericons THEN
(* Create an imagelist and associate it with the control *)
IF f.himl # NIL THEN ok := WinCtl.ImageList_Destroy(f.himl) END;
f.himl := WinCtl.ImageList_Create(16, 16, {}, 3, 0);
IF f.himl # NIL THEN
hbmp := WinApi.LoadImage(
instance, "#6", WinApi.IMAGE_ICON, 16, 16, ORD(WinApi.LR_LOADTRANSPARENT));
f.folderimg := WinCtl.ImageList_ReplaceIcon(f.himl, -1, hbmp);
ok := WinApi.DestroyIcon(hbmp);
hbmp := WinApi.LoadImage(
instance, "#7", WinApi.IMAGE_ICON, 16, 16, ORD(WinApi.LR_LOADTRANSPARENT));
f.openimg := WinCtl.ImageList_ReplaceIcon(f.himl, -1, hbmp);
ok := WinApi.DestroyIcon(hbmp);
hbmp := WinApi.LoadImage(
instance, "#8", WinApi.IMAGE_ICON, 16, 16, ORD(WinApi.LR_LOADTRANSPARENT));
f.leafimg := WinCtl.ImageList_ReplaceIcon(f.himl, -1, hbmp);
ok := WinApi.DestroyIcon(hbmp);
res := USER32.SendMessageA(
f.i.ctrl, WinCtl.TVM_SETIMAGELIST, WinCtl.TVSIL_NORMAL, SYSTEM.VAL(INTEGER, f.himl))
END
END
END Recreate;
PROCEDURE (f: TreeFrame) UpdateNT4, NEW;
VAR res: INTEGER;
BEGIN
IF ~f.disabled THEN
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 1)
END
ELSE
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
res := USER32.UpdateWindow(f.i.ctrl);
IF ~f.disabled & (f.readOnly # f.i.readOnly) THEN
IF f.readOnly OR ~f.i.hasFocus THEN res := USER32.SendMessageA(f.i.ctrl, USER32.WMKillFocus, 0, 0)
END;
f.i.readOnly := f.readOnly
END
END UpdateNT4;
PROCEDURE (f: TreeFrame) Update;
VAR res: INTEGER;
BEGIN
IF Dialog.platform = Dialog.windowsNT4 THEN f.UpdateNT4; RETURN END;
IF ~f.disabled & ~f.readOnly THEN
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TV_FIRST + 029, 0, -1); (* TVM_SETBKCOLOR *)
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 1)
END
ELSIF ~f.disabled & f.readOnly THEN
res := USER32.SendMessageA(
f.i.ctrl, WinCtl.TV_FIRST + 029, 0, Ports.dialogBackground); (* TVM_SETBKCOLOR *)
IF USER32.IsWindowEnabled(f.i.ctrl) = 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 1)
END
ELSE
res := USER32.SendMessageA(
f.i.ctrl, WinCtl.TV_FIRST + 029, 0, Ports.dialogBackground); (* TVM_SETBKCOLOR *)
IF USER32.IsWindowEnabled(f.i.ctrl) # 0 THEN
res := USER32.EnableWindow(f.i.ctrl, 0)
END
END;
res := USER32.UpdateWindow(f.i.ctrl);
IF ~f.disabled & (f.readOnly # f.i.readOnly) THEN
IF f.readOnly THEN
(* Selection has to be focused since it won't be visible on a gray backround otherwise *)
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0)
ELSE
IF ~f.i.hasFocus THEN res := USER32.SendMessageA(f.i.ctrl, USER32.WMKillFocus, 0, 0) END
END;
f.i.readOnly := f.readOnly
END;
res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0)
END Update;
PROCEDURE (f: TreeFrame) WinInsertItem (
VAR tn: Dialog.TreeNode; pWndAdr: INTEGER; OUT wndAdr: INTEGER
), NEW;
VAR res: INTEGER; p: Dialog.TreeNode;
tvi: WinCtl.TVITEMA; tvins: WinCtl.TVINSERTSTRUCTA;
s: Dialog.String; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
ASSERT(tn # NIL, 20);
f.treeArray[f.curindex].tn := tn;
p := f.Parent(f, tn);
tvi.mask := WinCtl.TVIF_TEXT + WinCtl.TVIF_PARAM + WinCtl.TVIF_IMAGE + WinCtl.TVIF_SELECTEDIMAGE;
tn.GetName(s); Dialog.MapString(s, s); ConvertFromUnicode(s); ss := SHORT(s);
tvi.pszText := ss; tvi.cchTextMax := LEN(ss); tvi.lParam := f.curindex;
IF tn.IsFolder() THEN
IF tn.IsExpanded() THEN tvi.iImage := f.openimg
ELSE tvi.iImage := f.folderimg
END
ELSE
tvi.iImage := f.leafimg
END;
tvi.iSelectedImage := tvi.iImage; tvins.item := tvi;
tvins.hParent := SYSTEM.VAL(WinCtl.Ptr_TREEITEM, pWndAdr);
IF f.sorted THEN tvins.hInsertAfter := SYSTEM.VAL(WinCtl.Ptr_TREEITEM, WinCtl.TVI_SORT)
ELSE tvins.hInsertAfter := SYSTEM.VAL(WinCtl.Ptr_TREEITEM, WinCtl.TVI_LAST)
END;
wndAdr := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_INSERTITEM, 0, SYSTEM.ADR(tvins));
f.treeArray[f.curindex].wndAdr := wndAdr;
IF p # NIL THEN
IF p.IsExpanded() THEN
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_EXPAND, WinCtl.TVE_EXPAND, pWndAdr)
ELSE
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_EXPAND, WinCtl.TVE_COLLAPSE, pWndAdr)
END
END;
INC(f.curindex)
END WinInsertItem;
PROCEDURE (f: TreeFrame) InsertNode(tn: Dialog.TreeNode; pWndAdr: INTEGER), NEW;
VAR wndAdr: INTEGER;
BEGIN
IF tn # NIL THEN
f.WinInsertItem(tn, pWndAdr, wndAdr);
f.InsertNode(f.Child(f, tn), wndAdr);
f.InsertNode(f.Next(f, tn), pWndAdr)
END
END InsertNode;
PROCEDURE (f: TreeFrame) UpdateList;
VAR res, len, i: INTEGER; done: BOOLEAN; sel: Dialog.TreeNode;
BEGIN
f.inUpdateList := TRUE;
len := 0; f.curindex := 0; sel := f.Selected(f);
len := f.NofNodes(f); IF len > 0 THEN NEW(f.treeArray, len) END;
(* Throw away the old windows control and create a new one *)
f.Recreate();
(* Go through the tree and insert new nodes into the treeview *)
f.InsertNode(f.Child(f, NIL), WinCtl.TVI_ROOT);
(* Select the node that is selected *)
IF sel = NIL THEN
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_SELECTITEM, WinCtl.TVGN_CARET, 0)
ELSE
i := 0; done := FALSE;
WHILE (i < len) & (~done) DO
IF sel = f.treeArray[i].tn THEN
res := USER32.SendMessageA(
f.i.ctrl, WinCtl.TVM_SELECTITEM, WinCtl.TVGN_CARET, f.treeArray[i].wndAdr);
done := TRUE
END;
INC(i)
END
END;
f.Select(f, sel);
f.Update;
IF f.i.hasFocus THEN res := USER32.SendMessageA(f.i.ctrl, USER32.WMSetFocus, 0, 0) END;
f.inUpdateList := FALSE
END UpdateList;
PROCEDURE (f: TreeFrame) ExpandCollapse(index, action: INTEGER), NEW;
VAR res: INTEGER; tn: Dialog.TreeNode; tvi: WinCtl.TVITEMA;
BEGIN
tn := f.treeArray[index].tn;
IF action = WinCtl.TVE_COLLAPSE THEN
f.SetExpansion(f, tn, FALSE)
ELSIF action = WinCtl.TVE_EXPAND THEN
f.SetExpansion(f, tn, TRUE)
ELSIF action = WinCtl.TVE_TOGGLE THEN
f.SetExpansion(f, tn, ~tn.IsExpanded())
END;
tvi.mask := WinCtl.TVIF_IMAGE + WinCtl.TVIF_SELECTEDIMAGE;
tvi.hItem := SYSTEM.VAL(WinCtl.Ptr_TREEITEM, f.treeArray[index].wndAdr);
IF tn.IsExpanded() THEN
tvi.iImage := f.openimg; tvi.iSelectedImage := f.openimg
ELSE
tvi.iImage := f.folderimg; tvi.iSelectedImage := f.folderimg
END;
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_SETITEM, 0, SYSTEM.ADR(tvi))
END ExpandCollapse;
PROCEDURE (f: TreeFrame) DblClickOk (x, y: INTEGER): BOOLEAN;
VAR res: INTEGER; hinf: WinCtl.TVHITTESTINFO;
BEGIN
hinf.pt.x := x DIV f.unit; hinf.pt.y := y DIV f.unit;
res := USER32.SendMessageA(f.i.ctrl, WinCtl.TVM_HITTEST, 0, SYSTEM.ADR(hinf));
IF hinf.hItem = NIL THEN
RETURN FALSE
ELSE
RETURN SYSTEM.VAL(INTEGER, hinf.hItem) = f.treeArray[f.selIndex].wndAdr
END
END DblClickOk;
PROCEDURE (f: TreeFrame) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: TreeFrame) WheelMove (x, y: INTEGER; op, nofLines: INTEGER; VAR done: BOOLEAN);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleWheel(f.i.ctrl, x, y, op, nofLines, done)
END
END WheelMove;
PROCEDURE (f: TreeFrame) Restore (l, t, r, b: INTEGER);
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
f.UpdateList
ELSE
f.Update
END;
IF f.i.wnd # 0 THEN PaintRect(f, f.i, l, t, r, b) ELSE Print(f, f.dot, -1, -1, "") END
END Restore;
PROCEDURE (f: TreeFrame) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch = " " THEN
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyDown, ORD(ch), 0);
res := USER32.SendMessageA(f.i.ctrl, USER32.WMKeyUp, ORD(ch), 0)
ELSE
IF ch = 20ACX THEN ch := 80X END;
SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: TreeFrame) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
PROCEDURE (f: TreeFrame) GetSize (OUT w, h: INTEGER);
VAR rect: GDI32.Rect; res: INTEGER;
BEGIN
res := USER32.GetWindowRect(f.i.wnd, rect);
w := (rect.right - rect.left) * f.unit; h := (rect.bottom - rect.top) * f.unit
END GetSize;
(* Directory *)
PROCEDURE (d: Directory) GetPushButtonSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 56 * Ports.point END;
IF h = Views.undefined THEN h := 18 * Ports.point END
END GetPushButtonSize;
PROCEDURE (d: Directory) GetCheckBoxSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 60 * Ports.point END;
IF h = Views.undefined THEN h := 12 * Ports.point END
END GetCheckBoxSize;
PROCEDURE (d: Directory) GetRadioButtonSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 60 * Ports.point END;
IF h = Views.undefined THEN h := 12 * Ports.point END
END GetRadioButtonSize;
PROCEDURE (d: Directory) GetScrollBarSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 120 * Ports.point END;
IF h = Views.undefined THEN h := 12 * Ports.point END
END GetScrollBarSize;
PROCEDURE (d: Directory) GetFieldSize (max: INTEGER; VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN
IF max = 0 THEN w := 80 * Ports.point
ELSIF max < 10 THEN w := 32 * Ports.point
ELSIF max < 15 THEN w := 56 * Ports.point
ELSIF max < 30 THEN w := 80 * Ports.point
ELSIF max < 100 THEN w := 120 * Ports.point
ELSE w := 150 * Ports.point
END
END;
IF h = Views.undefined THEN h := 17 * Ports.point END
END GetFieldSize;
PROCEDURE (d: Directory) GetUpDownFieldSize (max: INTEGER; VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 56 * Ports.point END;
IF h = Views.undefined THEN h := 17 * Ports.point END
END GetUpDownFieldSize;
PROCEDURE (d: Directory) GetDateFieldSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 72 * Ports.point END;
IF h = Views.undefined THEN h := 17 * Ports.point END
END GetDateFieldSize;
PROCEDURE (d: Directory) GetTimeFieldSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 72 * Ports.point END;
IF h = Views.undefined THEN h := 17 * Ports.point END
END GetTimeFieldSize;
PROCEDURE (d: Directory) GetColorFieldSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 36 * Ports.point END;
IF h = Views.undefined THEN h := 18 * Ports.point END
END GetColorFieldSize;
PROCEDURE (d: Directory) GetListBoxSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 100 * Ports.point END;
IF h = Views.undefined THEN h := 18 * Ports.point END
END GetListBoxSize;
PROCEDURE (d: Directory) GetSelectionBoxSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 100 * Ports.point END;
IF h = Views.undefined THEN h := 54 * Ports.point END
END GetSelectionBoxSize;
PROCEDURE (d: Directory) GetComboBoxSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 100 * Ports.point END;
IF h = Views.undefined THEN h := 18 * Ports.point END
END GetComboBoxSize;
PROCEDURE (d: Directory) GetCaptionSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 50 * Ports.point END;
IF h = Views.undefined THEN h := 12 * Ports.point END
END GetCaptionSize;
PROCEDURE (d: Directory) GetGroupSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 100 * Ports.point END;
IF h = Views.undefined THEN h := 100 * Ports.point END
END GetGroupSize;
PROCEDURE (d: Directory) GetTreeFrameSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 100 * Ports.point END;
IF h = Views.undefined THEN h := 100 * Ports.point END
END GetTreeFrameSize;
PROCEDURE (d: Directory) NewPushButton (): StdCFrames.PushButton;
VAR f: PushButton;
BEGIN
NEW(f); RETURN f
END NewPushButton;
PROCEDURE (d: Directory) NewCheckBox (): StdCFrames.CheckBox;
VAR f: CheckBox;
BEGIN
NEW(f); RETURN f
END NewCheckBox;
PROCEDURE (d: Directory) NewRadioButton (): StdCFrames.RadioButton;
VAR f: RadioButton;
BEGIN
NEW(f); RETURN f
END NewRadioButton;
PROCEDURE (d: Directory) NewScrollBar (): StdCFrames.ScrollBar;
VAR f: ScrollBar;
BEGIN
NEW(f); RETURN f
END NewScrollBar;
PROCEDURE (d: Directory) NewField (): StdCFrames.Field;
VAR f: Field;
BEGIN
NEW(f); RETURN f
END NewField;
PROCEDURE (d: Directory) NewUpDownField (): StdCFrames.UpDownField;
VAR f: UpDownField;
BEGIN
NEW(f); RETURN f
END NewUpDownField;
PROCEDURE (d: Directory) NewDateField (): StdCFrames.DateField;
VAR f: DateField;
BEGIN
NEW(f); RETURN f
END NewDateField;
PROCEDURE (d: Directory) NewTimeField (): StdCFrames.TimeField;
VAR f: TimeField;
BEGIN
NEW(f); RETURN f
END NewTimeField;
PROCEDURE (d: Directory) NewColorField (): StdCFrames.ColorField;
VAR f: ColorField;
BEGIN
NEW(f); RETURN f
END NewColorField;
PROCEDURE (d: Directory) NewListBox (): StdCFrames.ListBox;
VAR f: ListBox;
BEGIN
NEW(f); RETURN f
END NewListBox;
PROCEDURE (d: Directory) NewSelectionBox (): StdCFrames.SelectionBox;
VAR f: SelectionBox;
BEGIN
NEW(f); RETURN f
END NewSelectionBox;
PROCEDURE (d: Directory) NewComboBox (): StdCFrames.ComboBox;
VAR f: ComboBox;
BEGIN
NEW(f); RETURN f
END NewComboBox;
PROCEDURE (d: Directory) NewCaption (): StdCFrames.Caption;
VAR f: Caption;
BEGIN
NEW(f); RETURN f
END NewCaption;
PROCEDURE (d: Directory) NewGroup (): StdCFrames.Group;
VAR f: Group;
BEGIN
NEW(f); RETURN f
END NewGroup;
PROCEDURE (d: Directory) NewTreeFrame (): StdCFrames.TreeFrame;
VAR f: TreeFrame;
BEGIN
NEW(f); f.inUpdateList := FALSE; RETURN f
END NewTreeFrame;
(* control window class *)
(* Used for common controls, not standard controls *)
PROCEDURE HandleNotifyMsg (wnd: USER32.Handle; lParam, out: INTEGER);
VAR
c: StdCFrames.Frame;
pnmhdr: WinApi.PtrNMHDR; pnmtv: WinCtl.PtrNMTREEVIEW;
ret: INTEGER;
BEGIN
ret := WinApi.FALSE;
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
pnmhdr := SYSTEM.VAL(WinApi.PtrNMHDR, lParam);
WITH c: TreeFrame DO
IF c.i.ctrl # 0 THEN
IF ~c.inUpdateList & c.readOnly & (pnmhdr.code = WinCtl.TVN_SELCHANGING) THEN
ret := WinApi.TRUE
ELSIF pnmhdr.code = WinCtl.TVN_SELCHANGED THEN
pnmtv := SYSTEM.VAL(WinCtl.PtrNMTREEVIEW, lParam);
c.selIndex := pnmtv.itemNew.lParam;
c.Select(c, c.treeArray[c.selIndex].tn)
ELSIF pnmhdr.code = WinCtl.TVN_ITEMEXPANDED THEN
pnmtv := SYSTEM.VAL(WinCtl.PtrNMTREEVIEW, lParam);
c.ExpandCollapse(pnmtv.itemNew.lParam, pnmtv.action)
END
END
ELSE
END;
SYSTEM.PUT(out, ret)
END HandleNotifyMsg;
PROCEDURE HandleCommand (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR res, nc, i, j: INTEGER; c: StdCFrames.Frame; s: ARRAY 512 OF CHAR;
ps: POINTER TO ARRAY OF CHAR; b: BOOLEAN;
ss: ARRAY 512 OF SHORTCHAR; pss: POINTER TO ARRAY OF SHORTCHAR;
BEGIN
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
nc := wParam DIV 65536;
WITH c: PushButton DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.BNClicked THEN Execute(c)
END
END
| c: CheckBox DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.BNClicked THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.BMGetCheck, 0, 0);
IF i = 0 THEN i := 1 ELSE i := 0 END;
res := USER32.SendMessageA(c.i.ctrl, USER32.BMSetCheck, i, 0);
c.undef := FALSE; c.Set(c, i = 1)
(*
c.undef := res = 2;
c.Set(c, res = 1)
*)
END
END
| c: RadioButton DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.BNClicked THEN
res := USER32.SendMessageA(c.i.ctrl, USER32.BMGetCheck, 0, 0);
c.Set(c, res # 0)
END
END
| c: Field DO
IF c.i.ctrl # 0 THEN
IF (nc = WinApi.EN_CHANGE) & ~c.isUpdate THEN
IF ~c.left THEN (* right center alignment implies multiline which sends two update messages *)
IF c.maxLen > 255 THEN
NEW(ps, 2 * c.maxLen + 1); NEW(pss, 2 * c.maxLen + 1);
res := USER32.GetWindowTextA(c.i.ctrl, pss^, LEN(ps^)); ps^ := pss^$;
IF c.multiLine THEN DelLF(ps^) END;
ConvertToUnicode(ps^);
IF c.del OR (ps$ # "") THEN c.Set(c, ps^) END
ELSE
res := USER32.GetWindowTextA(c.i.ctrl, ss, LEN(ss)); s := ss$;
IF c.multiLine THEN DelLF(s) END;
ConvertToUnicode(s);
IF c.del OR (s$ # "") THEN c.Set(c, s) END
END
ELSE
IF c.maxLen > 255 THEN
NEW(ps, 2 * c.maxLen + 1); NEW(pss, 2 * c.maxLen + 1);
res := USER32.GetWindowTextA(c.i.ctrl, pss^, LEN(ps^)); ps^ := pss^$;
IF c.multiLine THEN DelLF(ps^) END;
ConvertToUnicode(ps^);
c.Set(c, ps^)
ELSE
res := USER32.GetWindowTextA(c.i.ctrl, ss, LEN(ss)); s := ss$;
IF c.multiLine THEN DelLF(s) END;
ConvertToUnicode(s);
c.Set(c, s)
END
END
END
END
| c: UpDownField DO
IF c.i.ctrl # 0 THEN
IF (nc = USER32.ENChange) & ~c.isUpdate THEN
res := USER32.GetWindowTextA(c.i.ctrl, ss, LEN(ss)); s := ss$;
Strings.StringToInt(s, c.val, res);
c.Set(c, c.val)
END
END
| c: ColorField DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.CBNSelChange THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.CBGetCurSel, 0, 0);
IF i = numColors THEN
Dialog.GetColor(c.color, i, b);
IF b THEN c.Set(c, i); c.Update END
ELSIF i >= 0 THEN
c.color := colors[i]; c.Set(c, c.color)
END
END
END
| c: ListBox DO
IF c.i.ctrl # 0 THEN
IF c.i.dropDown THEN
IF nc = USER32.CBNSelChange THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.CBGetCurSel, 0, 0);
IF c.sorted THEN i := USER32.SendMessageA(c.i.ctrl, USER32.CBGetItemData, i, 0) END;
IF i >= 0 THEN c.Set(c, i) END
END
ELSE
IF nc = USER32.LBNSelChange THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.LBGetCurSel, 0, 0);
IF c.sorted THEN i := USER32.SendMessageA(c.i.ctrl, USER32.LBGetItemData, i, 0) END;
IF i >= 0 THEN c.Set(c, i) END
END
END
END
| c: SelectionBox DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.LBNSelChange THEN
(*
i := USER32.SendMessageA(c.i.ctrl, USER32.LBGetAnchorIndex, 0, 0);
j := USER32.SendMessageA(c.i.ctrl, USER32.LBGetCaretIndex, 0, 0);
res := USER32.SendMessageA(c.i.ctrl, USER32.LBGetSel, i, 0);
IF c.sorted THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.LBGetItemData, i, 0);
j := USER32.SendMessageA(c.i.ctrl, USER32.LBGetItemData, j, 0)
END;
IF (i >= 0) & (i < c.num) THEN
Log.Int(i); Log.Int(j); Log.Ln; Log.Int(wParam); Log.Int(lParam); Log.Int(res); Log.Ln;
IF (res # 0) THEN c.Incl(c, i, i) ELSE c.Excl(c, i, i) END
END
*)
i := 0;
WHILE i < c.num DO
j := i;
res := USER32.SendMessageA(c.i.ctrl, USER32.LBGetSel, j, 0);
IF c.sorted THEN j := USER32.SendMessageA(c.i.ctrl, USER32.LBGetItemData, j, 0) END;
c.Get(c, j, b);
IF (res # 0) & ~b THEN c.Incl(c, j, j)
ELSIF (res = 0) & b THEN c.Excl(c, j, j)
END;
INC(i)
END
END
END
| c: ComboBox DO
IF c.i.ctrl # 0 THEN
IF nc = USER32.CBNEditChange THEN
res := USER32.GetWindowTextA(c.i.ctrl, ss, LEN(ss));
s := ss$; c.Set(c, s)
ELSIF nc = USER32.CBNSelChange THEN
i := USER32.SendMessageA(c.i.ctrl, USER32.CBGetCurSel, 0, 0);
IF i >= 0 THEN
res := USER32.SendMessageA(c.i.ctrl, USER32.CBGetLBText, i, SYSTEM.ADR(ss));
s := ss$; c.Set(c, s)
END
END
END
ELSE
END
END HandleCommand;
PROCEDURE HandleScroll (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR nc, size, sect, pos: INTEGER; c: StdCFrames.Frame; arrows: BOOLEAN;
BEGIN
arrows := FALSE;
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
WITH c: ScrollBar DO
IF c.i.ctrl # 0 THEN
Views.ValidateRoot(Views.RootOf(c));
nc := wParam MOD 65536; c.Get(c, size, sect, pos);
IF (nc = USER32.SBThumbPos) OR
HostWindows.visualScroll & (nc = USER32.SBThumbTrack) THEN
c.Set(c, KERNEL32.MulDiv(SHORT(wParam DIV 65536), size - sect, scrollRange))
ELSIF nc = USER32.SBLineUp THEN c.Track(c, StdCFrames.lineUp, pos)
ELSIF nc = USER32.SBLineDown THEN c.Track(c, StdCFrames.lineDown, pos)
ELSIF nc = USER32.SBPageUp THEN c.Track(c, StdCFrames.pageUp, pos)
ELSIF nc = USER32.SBPageDown THEN c.Track(c, StdCFrames.pageDown, pos)
END;
c.Update
END
| c: UpDownField DO
IF c.i.ctrl # 0 THEN arrows := TRUE END
| c: TimeField DO
IF c.i.ctrl # 0 THEN arrows := TRUE END
| c: DateField DO
IF c.i.ctrl # 0 THEN arrows := TRUE END
ELSE
END;
IF arrows THEN
nc := wParam MOD 65536;
IF nc = USER32.SBThumbPos THEN
IF wParam DIV 65536 # 0 THEN c.KeyDown(AU)
ELSE c.KeyDown(AD)
END
END
END
END HandleScroll;
PROCEDURE HandleDraw (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR res: INTEGER; c: StdCFrames.Frame; p: USER32.PDrawItemStruct;
brush: GDI32.Handle; rect: GDI32.Rect; col: Ports.Color;
BEGIN
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
p := SYSTEM.VAL(USER32.PDrawItemStruct, lParam);
WITH c: ColorField DO
IF 0 IN p.itemState THEN
rect := p.itemRect;
brush := GDI32.CreateSolidBrush(HostPorts.selBackground);
res := USER32.FillRect(p.dc, rect, brush);
res := GDI32.DeleteObject(brush);
INC(rect.left); INC(rect.top); DEC(rect.right); DEC(rect.bottom);
brush := GDI32.CreateSolidBrush(Ports.background);
res := USER32.FillRect(p.dc, rect, brush);
res := GDI32.DeleteObject(brush)
ELSE
IF c.disabled OR c.readOnly THEN
brush := GDI32.CreateSolidBrush(Ports.dialogBackground)
ELSE
brush := GDI32.CreateSolidBrush(Ports.background)
END;
res := USER32.FillRect(p.dc, p.itemRect, brush);
res := GDI32.DeleteObject(brush)
END;
IF (p.itemId = numColors) & (p.itemRect.top > 20) THEN
brush := GDI32.CreateSolidBrush(HostPorts.textCol);
rect.top := p.itemRect.bottom - 6; rect.bottom := rect.top + 2;
rect.left := p.itemRect.left + 4; rect.right := rect.left + 2;
res := USER32.FillRect(p.dc, rect, brush);
rect.left := p.itemRect.left + 8; rect.right := rect.left + 2;
res := USER32.FillRect(p.dc, rect, brush);
rect.left := p.itemRect.left + 12; rect.right := rect.left + 2;
res := USER32.FillRect(p.dc, rect, brush)
ELSIF p.itemId >= 0 THEN
rect := p.itemRect; INC(rect.left, 2); INC(rect.top, 2); DEC(rect.right, 2); DEC(rect.bottom, 2);
IF p.itemId = numColors THEN col := c.color
ELSIF (p.itemId >= 0) & (p.itemId < LEN(colors)) THEN col := colors[p.itemId]
ELSE col := HostPorts.textCol
END;
brush := GDI32.CreateSolidBrush(col);
res := USER32.FillRect(p.dc, rect, brush);
res := GDI32.DeleteObject(brush)
END
END
END HandleDraw;
PROCEDURE ColorBrush (col: Ports.Color): GDI32.Handle;
VAR p: BrushCache;
BEGIN
IF col = Ports.white THEN RETURN GDI32.GetStockObject(GDI32.WhiteBrush)
ELSIF col = Ports.dialogBackground THEN RETURN HostPorts.dialogBrush
ELSE
p := brushes;
WHILE (p # NIL) & (p.col # col) DO p := p.next END;
IF p # NIL THEN RETURN p.brush
ELSE
NEW(p); p.col := col; p.brush := GDI32.CreateSolidBrush(col); p.next := brushes; brushes := p;
RETURN p.brush
END
END
END ColorBrush;
PROCEDURE [2] CtrlHandler (wnd: USER32.Handle; message, wParam, lParam: INTEGER): INTEGER;
VAR res: INTEGER; c: StdCFrames.Frame; p: USER32.PMeasureItemStruct;
BEGIN
IF message = USER32.WMCommand THEN
Kernel.Try(HandleCommand, wnd, wParam, lParam);
RETURN 0
ELSIF message = WinApi.WM_NOTIFY THEN
res := -1;
Kernel.Try(HandleNotifyMsg, wnd, lParam, SYSTEM.ADR(res));
IF res # -1 THEN RETURN res ELSE RETURN 0 END
ELSIF (message = USER32.WMHScroll) OR (message = USER32.WMVScroll) THEN
Kernel.Try(HandleScroll, wnd, wParam, lParam);
RETURN 0
ELSIF message = USER32.WMDrawItem THEN
Kernel.Try(HandleDraw, wnd, wParam, lParam);
RETURN 1
ELSIF message = USER32.WMMeasureItem THEN
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
WITH c: ColorField DO
p := SYSTEM.VAL(USER32.PMeasureItemStruct, lParam);
IF p.itemId = -1 THEN p.itemHeight := 11 * Ports.point DIV c.unit + 1
ELSE p.itemHeight := 11 * Ports.point DIV c.unit - 1
END;
RETURN 1
ELSE
END
ELSIF (message >= USER32.WMCtlColorMsgBox) & (message <= USER32.WMCtlColorStatic) THEN
c := SYSTEM.VAL(StdCFrames.Frame, USER32.GetWindowLongA(wnd, dlgWindowExtra));
IF ((c IS Field) OR (c IS UpDownField) OR (c IS TimeField) OR (c IS DateField)
OR (c IS ListBox) OR (c IS SelectionBox) OR (c IS ColorField))
& (c.disabled OR c.readOnly) THEN
res := GDI32.SetBkColor(wParam, Ports.dialogBackground);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN HostPorts.dialogBrush
ELSIF (c IS TreeFrame) & (c.disabled OR c.readOnly) & (Dialog.platform # Dialog.windowsNT4) THEN
res := GDI32.SetBkColor(wParam, Ports.dialogBackground);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN HostPorts.dialogBrush
ELSIF ((c IS Field) OR (c IS UpDownField) OR (c IS TimeField) OR (c IS DateField))
& ~c.disabled & c.undef THEN
res := GDI32.SetBkMode(wParam, 1); (* transparent *)
res := GDI32.SetTextColor(wParam, 0C0C0C0H);
RETURN HostPorts.dim50Brush
ELSIF c IS Caption THEN
res := GDI32.SetTextColor(wParam, HostPorts.dialogTextCol);
res := GDI32.SetBkColor(wParam, c(Caption).i.bkgnd);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN ColorBrush(c(Caption).i.bkgnd)
ELSIF CtlColor # NIL THEN
res := CtlColor(message, wParam, lParam);
IF res # 0 THEN RETURN res END
ELSIF c IS CheckBox THEN
res := GDI32.SetTextColor(wParam, HostPorts.dialogTextCol);
res := GDI32.SetBkColor(wParam, c(CheckBox).i.bkgnd);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN ColorBrush(c(CheckBox).i.bkgnd)
ELSIF c IS RadioButton THEN
res := GDI32.SetTextColor(wParam, HostPorts.dialogTextCol);
res := GDI32.SetBkColor(wParam, c(RadioButton).i.bkgnd);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN ColorBrush(c(RadioButton).i.bkgnd)
ELSIF c IS Group THEN
res := GDI32.SetTextColor(wParam, HostPorts.dialogTextCol);
res := GDI32.SetBkColor(wParam, c(Group).i.bkgnd);
res := GDI32.SetBkMode(wParam, 2); (* opaque *)
RETURN ColorBrush(c(Group).i.bkgnd)
END
ELSIF message = USER32.WMEraseBkGnd THEN
RETURN 1
END;
RETURN USER32.DefWindowProcA(wnd, message, wParam, lParam)
END CtrlHandler;
PROCEDURE SetDefFonts*;
BEGIN
StdCFrames.defaultFont := HostFonts.dlgFont;
StdCFrames.defaultLightFont := Fonts.dir.This(
HostFonts.dlgFont.typeface, HostFonts.dlgFont.size, HostFonts.dlgFont.style, Fonts.normal)
END SetDefFonts;
PROCEDURE Install;
VAR dir: Directory;
BEGIN
NEW(dir); StdCFrames.SetDir(dir)
END Install;
PROCEDURE InitClass;
VAR class: USER32.WndClass;
BEGIN
class.cursor := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCArrow));
class.icon := USER32.LoadIconA(instance, USER32.MakeIntRsrc(1));
class.menuName := NIL;
class.className := "Oberon Ctrl";
class.backgnd := 0; (* no background *)
class.style := {};
class.instance := instance;
class.wndProc := CtrlHandler;
class.clsExtra := 0;
class.wndExtra := dlgWindowExtra + 4;
USER32.RegisterClassA(class)
END InitClass;
PROCEDURE InitNationalInfo;
VAR res: INTEGER; str: ARRAY 8 OF SHORTCHAR;
BEGIN
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_SDATE, str, LEN(str));
dateSep := str[0];
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_STIME, str, LEN(str));
timeSep := str[0];
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_IDATE, str, LEN(str));
IF str = "1" THEN dayPart := 1; monthPart := 2; yearPart := 3; del1 := 2; del2 := 5
ELSIF str = "2" THEN yearPart := 1; monthPart := 2; dayPart := 3; del1 := 4; del2 := 7
ELSE monthPart := 1; dayPart := 2; yearPart := 3; del1 := 2; del2 := 5
END;
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_ITIME, str, LEN(str));
IF str = "1" THEN
lastPart := 3
ELSE
lastPart := 4;
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_S1159, str, LEN(str));
desig[0] := str$;
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_S2359, str, LEN(str));
desig[1] := str$
END
END InitNationalInfo;
PROCEDURE InitColors;
BEGIN
colors[0] := 000000FFH;
colors[1] := 0000FF00H;
colors[2] := 00FF0000H;
colors[3] := 0000FFFFH;
colors[4] := 00FFFF00H;
colors[5] := 00FF00FFH;
colors[6] := 00000000H
END InitColors;
PROCEDURE Init;
VAR v: INTEGER;
BEGIN
StdCFrames.setFocus := TRUE;
SetDefFonts;
scW := USER32.GetSystemMetrics(0); (* screen width *)
scH := USER32.GetSystemMetrics(1); (* screen height *)
instance := KERNEL32.GetModuleHandleA(NIL);
v := KERNEL32.GetVersion();
osVersion := v MOD 256 * 100 + v DIV 256 MOD 256;
InitClass;
InitNationalInfo;
InitColors;
Install
(*
IF HostWindows.ctl3d # 0 THEN
SYSTEM.PUT(
SYSTEM.ADR(SubclassCtl), KERNEL32.GetProcAddress(HostWindows.ctl3d, "Ctl3dSubclassCtl"));
SYSTEM.PUT(
SYSTEM.ADR(CtlColor), KERNEL32.GetProcAddress(HostWindows.ctl3d, "Ctl3dCtlColorEx"))
END
*)
END Init;
BEGIN
Init
END HostCFrames.
| Host/Mod/CFrames.odc |
MODULE HostClipboard;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
COM, WinApi, WinOle,
Services, Stores, Views, Documents, OleData, HostWindows;
TYPE
EmptyView = POINTER TO RECORD (Views.View) END;
VAR
cloneAttributes*: BOOLEAN; (* set by HostCmds, used by Importers *)
isText*: BOOLEAN; (* set by HostCmds, used by GetClipView *)
doc: Documents.Document; (* contents of clipboard window *)
isSingleton: BOOLEAN; (* contents of clipboard is singleton view *)
width, height: INTEGER; (* size of clipboard content *)
empty: Views.View; (* contents of empty clipboard *)
cbdata: WinOle.IDataObject; (* data object registred via OLE *)
PROCEDURE Register* (v: Views.View; w, h: INTEGER; isSingle: BOOLEAN);
VAR res: COM.RESULT;
BEGIN
doc.SetView(v, w, h);
width := w; height := h;
isSingleton := isSingle;
cbdata := OleData.ViewData(v, w, h, isSingle);
res := WinOle.OleSetClipboard(cbdata)
END Register;
PROCEDURE GetClipView* (
type: Stores.TypeName; VAR v: Views.View; VAR w, h: INTEGER; VAR isSingle: BOOLEAN
);
VAR dobj: WinOle.IDataObject; res: COM.RESULT;
BEGIN
v := NIL;
IF WinOle.OleIsCurrentClipboard(cbdata) = WinApi.S_OK THEN
v := Views.CopyOf(doc.ThisView(), Views.deep);
w := width; h := height; isSingle := isSingleton;
IF (type # "") & ~Services.Is(v, type) THEN v := NIL END
ELSE
res := WinOle.OleGetClipboard(dobj);
IF res >= 0 THEN
IF isText THEN
OleData.GetTextDataView(dobj, v, w, h, isSingle)
ELSE
OleData.GetDataView(dobj, type, v, w, h, isSingle)
END;
IF v # NIL THEN
doc.SetView(Views.CopyOf(v, Views.deep), w, h);
width := w; height := h;
isSingleton := isSingle
END
END
END
END GetClipView;
PROCEDURE ConvertibleTo* (type: Stores.TypeName): BOOLEAN;
VAR dobj: WinOle.IDataObject; res: COM.RESULT;
BEGIN
IF WinOle.OleIsCurrentClipboard(cbdata) = WinApi.S_OK THEN
RETURN (type = "") OR Services.Is(doc.ThisView(), type)
ELSE
res := WinOle.OleGetClipboard(dobj);
IF res >= 0 THEN
RETURN OleData.DataConvTo(dobj, type)
END
END;
RETURN FALSE
END ConvertibleTo;
PROCEDURE Flush*;
VAR res: COM.RESULT;
BEGIN
IF WinOle.OleIsCurrentClipboard(cbdata) = WinApi.S_OK THEN
res := WinOle.OleFlushClipboard()
END
END Flush;
PROCEDURE Dump*;
VAR res: COM.RESULT; dobj: WinOle.IDataObject;
BEGIN
res := WinOle.OleGetClipboard(dobj);
OleData.DumpData(dobj)
END Dump;
PROCEDURE (v: EmptyView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
END Restore;
PROCEDURE Init;
VAR e: EmptyView;
BEGIN
NEW(e); empty := e;
(* init document to be used to display the clipboard *)
doc := Documents.dir.New(empty, Views.undefined, Views.undefined);
HostWindows.OpenClipboard(doc)
END Init;
BEGIN
Init
END HostClipboard.
HostClipboard.Flush
HostClipboard.Dump | Host/Mod/Clipboard.odc |
MODULE HostCmds;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
Kernel, Ports, Printers, Files,
Stores, Views, Controllers, Dialog, Printing,
Converters, Sequencers, Documents, Windows,
StdDialog, StdCmds,
HostFiles, HostWindows, HostDialog, HostClipboard;
CONST
(* hints *)
impAll = 0; (* can import all file types *)
expDoc = 1; (* imported view should be stored as document *)
VAR quit*: BOOLEAN;
(** File menu **)
PROCEDURE Open*;
(** open an existing document or view **)
VAR loc: Files.Locator; name: Files.Name; v: Views.View;
s: Stores.Store; done: BOOLEAN; w: Windows.Window; conv: Converters.Converter;
BEGIN
HostDialog.GetIntSpec(loc, name, conv);
IF loc # NIL THEN
w := Windows.dir.First();
WHILE (w # NIL) & ((w.loc = NIL) OR (w.name = "") OR (w.loc.res = 77) OR
~Files.dir.SameFile(loc, name, w.loc, w.name) OR (w.conv # conv)) DO
w := Windows.dir.Next(w)
END;
IF w # NIL THEN s := w.doc
ELSE
Converters.Import(loc, name, conv, s);
IF s # NIL THEN StdDialog.RecalcView(s(Views.View)) END
END;
IF s # NIL THEN
v := s(Views.View);
IF (conv # NIL) & (expDoc IN conv.opts) THEN conv := NIL END;
Views.Open(v, loc, name, conv)
ELSE Dialog.ShowParamMsg("#System:FailedToOpen", name, "", "")
END
END
END Open;
PROCEDURE OpenCopyOf*;
VAR loc: Files.Locator; name: Files.Name; conv: Converters.Converter; v: Views.View;
BEGIN
v := Views.Old(TRUE, loc, name, conv);
IF v # NIL THEN
IF v.context # NIL THEN
v := Views.CopyOf(v.context(Documents.Context).ThisDoc(), Views.deep);
Stores.InitDomain(v)
ELSE v := Views.CopyOf(v, Views.deep)
END;
Views.Open(v, NIL, "", conv)
END
END OpenCopyOf;
PROCEDURE SaveWindow (w: Windows.Window; rename: BOOLEAN);
VAR title: Views.Title; loc: Files.Locator; name: Files.Name; v: Views.View;
conv: Converters.Converter; stat: BOOLEAN; i: INTEGER;
BEGIN
IF (w # NIL) & (rename OR ~(Windows.neverDirty IN w.flags)) THEN
v := w.doc.OriginalView();
loc := w.loc; name := w.name$; conv := w.conv;
IF name = "" THEN Dialog.MapString("#System:untitled", name) END;
IF (loc = NIL) OR (loc.res = 77) OR (conv # NIL) & (conv.exp = "") THEN rename := TRUE END;
IF rename THEN HostDialog.GetExtSpec(v, loc, name, conv) END;
IF loc # NIL THEN
Dialog.ShowStatus("#Host:Saving");
Converters.Export(loc, name, conv, v);
IF loc.res = 0 THEN
IF w.seq.Dirty() THEN
w.seq.BeginModification(Sequencers.notUndoable, NIL);
w.seq.EndModification(Sequencers.notUndoable, NIL); (* clear sequencer *)
w.seq.SetDirty(FALSE)
END;
IF rename THEN
i := 0;
WHILE (i < LEN(title) - 1) & (name[i] # 0X) DO title[i] := name[i]; INC(i) END;
title[i] := 0X;
w.SetTitle(title); w.SetSpec(loc, name, conv)
END;
Dialog.ShowStatus("#Host:Saved")
ELSE
Dialog.ShowStatus("#Host:Failed")
END
END;
IF ~quit THEN Kernel.Cleanup END
END
END SaveWindow;
PROCEDURE Save*;
(** save document shown in target window under old name **)
VAR w: Windows.Window;
BEGIN
w := Windows.dir.Focus(Controllers.targetPath);
SaveWindow(w, FALSE)
END Save;
PROCEDURE SaveAs*;
(** save document shown in target window under new name **)
VAR w: Windows.Window;
BEGIN
w := Windows.dir.Focus(Controllers.targetPath);
SaveWindow(w, TRUE)
END SaveAs;
PROCEDURE SaveCopyAs*;
(** save copy of document shown in target window under new name **)
VAR w: Windows.Window; loc: Files.Locator; name: Files.Name; v: Views.View;
conv: Converters.Converter;
BEGIN
w := Windows.dir.Focus(Controllers.targetPath);
IF (w # NIL) THEN
v := w.doc.OriginalView();
loc := w.loc; name := w.name$; conv := w.conv;
IF name = "" THEN Dialog.MapString("#System:untitled", name) END;
HostDialog.GetExtSpec(v, loc, name, conv);
IF loc # NIL THEN
Dialog.ShowStatus("#Host:Saving");
Converters.Export(loc, name, conv, v);
IF loc.res = 0 THEN Dialog.ShowStatus("#Host:Saved")
ELSE Dialog.ShowStatus("#Host:Failed")
END
END;
IF ~quit THEN Kernel.Cleanup END
END
END SaveCopyAs;
PROCEDURE CloseWindow (w: Windows.Window);
VAR res: INTEGER; msg: Sequencers.CloseMsg;
BEGIN
IF w # NIL THEN
IF ~w.sub THEN
msg.sticky := FALSE; w.seq.Notify(msg);
IF ~msg.sticky THEN
IF w.seq.Dirty() & ~(Windows.neverDirty IN w.flags) THEN
HostDialog.CloseDialog(w, quit, res);
IF res = HostDialog.save THEN
SaveWindow(w, FALSE); (* if saving is canceled, document remains dirty *)
IF w.seq.Dirty() THEN quit := FALSE
ELSE Windows.dir.Close(w)
END
ELSIF res = HostDialog.cancel THEN quit := FALSE
ELSE Windows.dir.Close(w)
END
ELSE Windows.dir.Close(w)
END
ELSE quit := FALSE
END
ELSE Windows.dir.Close(w)
END;
IF ~quit THEN Kernel.Cleanup END
END
END CloseWindow;
PROCEDURE Close*;
(** close top window **)
BEGIN
CloseWindow(Windows.dir.First())
END Close;
(*
PROCEDURE PageSetup*;
(** ask user for page size, margins and decoration of the front window's document **)
VAR win: Windows.Window; d: Documents.Document;
w, h, l, t, r, b, dl, dt, dr, db: LONGINT; decorate: BOOLEAN; s: Stores.Operation;
BEGIN
win := Windows.dir.Focus(Controllers.targetPath);
IF win # NIL THEN
d := win.doc;
d.PollPage(w, h, l, t, r, b, decorate);
HostDialog.PageSetup(w, h, l, t, r, b, decorate);
IF w > 0 THEN
IF Windows.noResize IN win.flags THEN
d.PollRect(dl, dt, dr, db);
r := l + (dr - dl); b := t + (db - dt)
END;
d.SetPage(w, h, l, t, r, b, decorate)
END
END
END PageSetup;
*)
PROCEDURE HasSel (w: Windows.Window): BOOLEAN;
VAR ops: Controllers.PollOpsMsg;
BEGIN
ops.type := ""; ops.singleton := NIL; ops.selectable := FALSE; ops.valid := {};
w.ForwardCtrlMsg(ops);
RETURN ops.singleton # NIL
END HasSel;
PROCEDURE PrintSel (w: Windows.Window; from, to, copies: INTEGER);
VAR wt, title: Views.Title; i: INTEGER; edit: Controllers.EditMsg;
BEGIN
edit.op := Controllers.copy; edit.view := NIL;
edit.clipboard := FALSE; w.ForwardCtrlMsg(edit);
ASSERT(edit.view # NIL, 100);
w.GetTitle(wt); title := "[";
i := 1; WHILE (wt[i - 1] # 0X) & (i < LEN(title)) DO title[i] := wt[i - 1]; INC(i) END;
IF i >= LEN(title) - 1 THEN i := LEN(title) - 2 END;
title[i] := "]"; title[i + 1] := 0X;
Printing.PrintView(edit.view, (*edit.w, edit.h,*) Printing.NewDefaultPar(title))
END PrintSel;
PROCEDURE PrintDoc (w: Windows.Window; from, to, copies: INTEGER);
VAR pw, ph, l, t, r, b: INTEGER; decorate: BOOLEAN;
msg: Controllers.ScrollMsg; page: Printing.PageInfo; header, footer: Printing.Banner;
BEGIN
w.doc.PollPage(pw, ph, l, t, r, b, decorate);
page.first := 1; page.from := from; page.to := to; page.alternate := FALSE;
w.GetTitle(page.title);
IF decorate THEN
header.gap := 5 * Ports.mm; header.right := "&d&;&p";
ELSE
header.gap := 0; header.right := "";
END;
footer.gap := 0; footer.right := "";
Printing.PrintView(w.doc, Printing.NewPar(page, header, footer, copies));
(*
msg.focus := FALSE; msg.vertical := TRUE;
msg.op := Controllers.gotoPos; msg.pos := 0;
msg.done := FALSE; w.ForwardCtrlMsg(msg);
Views.UpdateRoot(w.frame, w.frame.l, w.frame.t, w.frame.r, w.frame.b, Views.rebuildFrames)
*)
END PrintDoc;
PROCEDURE PrintThis (w: Windows.Window; from, to, copies: INTEGER; selection: BOOLEAN);
BEGIN
IF copies > 0 THEN
IF selection THEN
PrintSel(w, from, to, copies)
ELSE
PrintDoc(w, from, to, copies)
END
END
END PrintThis;
(*
PROCEDURE PrintSelection*;
(** print the front window's selection **)
VAR win: Windows.Window; pr: Printers.Printer;
from, to, copies: INTEGER; selection, hasSel: BOOLEAN;
BEGIN
win := Windows.dir.Focus(Controllers.path);
IF win # NIL THEN
hasSel := HasSel(win); selection := hasSel;
HostDialog.PrintDialog(hasSel, pr, from, to, copies, selection);
PrintThis(pr, win, from, to, copies, selection)
END
END PrintSelection;
*)
PROCEDURE Print*;
(** print the front window's document **)
VAR win: Windows.Window;
from, to, copies: INTEGER; selection: BOOLEAN;
BEGIN
IF Printers.dir.Available() THEN
win := Windows.dir.Focus(Controllers.targetPath);
IF win # NIL THEN
WHILE win.sub DO win := win.link END;
selection := FALSE;
HostDialog.PrintDialog(HasSel(win), from, to, copies, selection);
PrintThis(win, from, to, copies, selection)
END;
Kernel.Cleanup
END
END Print;
PROCEDURE Quit*;
(** stop if all windows can be closed **)
VAR w: Windows.Window;
BEGIN
quit := TRUE;
w := Windows.dir.First();
WHILE (w # NIL) & (HostWindows.inPlace IN w.flags) DO w := Windows.dir.Next(w) END;
WHILE (w # NIL) & quit DO
CloseWindow(w);
w := Windows.dir.First();
WHILE (w # NIL) & (HostWindows.inPlace IN w.flags) DO w := Windows.dir.Next(w) END
END
END Quit;
PROCEDURE SaveAll*;
VAR w: Windows.Window; res: INTEGER;
BEGIN
quit := FALSE;
w := Windows.dir.First();
WHILE (w # NIL) & (HostWindows.inPlace IN w.flags) DO w := Windows.dir.Next(w) END;
res := HostDialog.save;
WHILE (w # NIL) & (res # HostDialog.cancel) DO
IF ~w.sub & w.seq.Dirty() & ~(Windows.neverDirty IN w.flags) THEN
HostDialog.CloseDialog(w, FALSE, res);
IF res = HostDialog.save THEN
SaveWindow(w, FALSE) (* if saving is canceled, document remains dirty *)
END;
Kernel.Cleanup
END;
w := Windows.dir.Next(w)
END
END SaveAll;
(** Edit menu **)
PROCEDURE Cut*;
(** move the focus document's selection into the clipboard **)
VAR msg: Controllers.EditMsg;
BEGIN
msg.op := Controllers.cut;
msg.clipboard := TRUE;
msg.view := NIL; msg.w := Views.undefined; msg.h := Views.undefined;
Controllers.Forward(msg);
IF msg.view # NIL THEN HostClipboard.Register(msg.view, msg.w, msg.h, msg.isSingle) END
END Cut;
PROCEDURE Copy*;
(** move a copy of the focus document's selection into the clipboard **)
VAR msg: Controllers.EditMsg;
BEGIN
msg.op := Controllers.copy;
msg.clipboard := TRUE;
msg.view := NIL; msg.w := Views.undefined; msg.h := Views.undefined;
Controllers.Forward(msg);
IF msg.view # NIL THEN HostClipboard.Register(msg.view, msg.w, msg.h, msg.isSingle) END
END Copy;
PROCEDURE Paste*;
(** let focus document insert a copy of the clipboard's contents **)
VAR ops: Controllers.PollOpsMsg; msg: Controllers.EditMsg;
BEGIN
HostClipboard.cloneAttributes := TRUE;
HostClipboard.isText := TRUE;
Controllers.PollOps(ops);
HostClipboard.isText := ops.type = "TextViews.View";
IF Controllers.paste IN ops.valid THEN
msg.clipboard := TRUE;
HostClipboard.GetClipView(ops.pasteType, msg.view, msg.w, msg.h, msg.isSingle);
IF msg.view # NIL THEN
msg.op := Controllers.paste; Controllers.Forward(msg)
END
END;
HostClipboard.cloneAttributes := FALSE;
HostClipboard.isText := TRUE;
END Paste;
PROCEDURE PasteObject*;
(** let focus document insert a copy of the clipboard's contents **)
VAR ops: Controllers.PollOpsMsg; v: Views.View; w, h: INTEGER; s: BOOLEAN;
BEGIN
HostClipboard.cloneAttributes := FALSE;
Controllers.PollOps(ops);
IF Controllers.paste IN ops.valid THEN
HostClipboard.GetClipView(ops.pasteType, v, w, h, s);
IF v # NIL THEN
Controllers.PasteView(v, w, h, TRUE)
END
END
END PasteObject;
PROCEDURE PasteToWindow*;
VAR v: Views.View; w, h: INTEGER; d: Documents.Document; s: BOOLEAN;
BEGIN
HostClipboard.cloneAttributes := FALSE;
HostClipboard.GetClipView("", v, w, h, s);
IF v # NIL THEN
d := Documents.dir.New(v, w, h);
Views.OpenView(d)
END
END PasteToWindow;
PROCEDURE OpenDoc* (file: ARRAY OF CHAR);
VAR w: Windows.Window;
BEGIN
w := Windows.dir.Focus(FALSE);
IF (w.loc # NIL) & (w.loc IS HostFiles.Locator) & (w.loc(HostFiles.Locator).path # "") THEN
StdCmds.OpenDoc(w.loc(HostFiles.Locator).path + "\" + file)
ELSE
StdCmds.OpenDoc(file)
END
END OpenDoc;
(* Guards *)
PROCEDURE SaveGuard* (VAR par: Dialog.Par);
VAR w: Windows.Window;
BEGIN
w := Windows.dir.Focus(Controllers.targetPath);
IF (w = NIL) OR (Windows.neverDirty IN w.flags) OR ~w.seq.Dirty() THEN par.disabled := TRUE END
END SaveGuard;
PROCEDURE PrintGuard* (VAR par: Dialog.Par);
VAR w: Windows.Window;
BEGIN
w := Windows.dir.Focus(Controllers.targetPath);
IF (w = NIL) OR ~Printers.dir.Available() THEN par.disabled := TRUE END
END PrintGuard;
PROCEDURE PrinterGuard* (VAR par: Dialog.Par);
BEGIN
IF ~Printers.dir.Available() THEN par.disabled := TRUE END
END PrinterGuard;
PROCEDURE CutGuard* (VAR par: Dialog.Par);
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.PollOps(ops);
IF ~(Controllers.cut IN ops.valid) THEN par.disabled := TRUE END
END CutGuard;
PROCEDURE CopyGuard* (VAR par: Dialog.Par);
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.PollOps(ops);
IF ~(Controllers.copy IN ops.valid) THEN par.disabled := TRUE END
END CopyGuard;
PROCEDURE PasteGuard* (VAR par: Dialog.Par);
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.PollOps(ops);
IF ~(Controllers.paste IN ops.valid)
OR ~HostClipboard.ConvertibleTo(ops.pasteType) THEN par.disabled := TRUE END
END PasteGuard;
PROCEDURE PasteObjectGuard* (VAR par: Dialog.Par);
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.PollOps(ops);
IF ~(Controllers.paste IN ops.valid)
OR ~HostClipboard.ConvertibleTo("") THEN par.disabled := TRUE END
END PasteObjectGuard;
PROCEDURE PasteToWindowGuard* (VAR par: Dialog.Par);
BEGIN
IF ~HostClipboard.ConvertibleTo("") THEN par.disabled := TRUE END
END PasteToWindowGuard;
BEGIN
quit := FALSE
END HostCmds.
| Host/Mod/Cmds.odc |
MODULE HostDialog; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20120930, Fyodor Tkachov, proposal by Alexander Iljin, added ELSE in WaitDialogClose, see http://forum.oberoncore.ru/viewtopic.php?p=62705#p62705,
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, ShowParamStatus, 512 -> 513 to fully comply with the original
- 20070117, Alexander Iljin
- 20051020, Ilya Ermakov, added external access way to printer parameters
- 20051015, Ilya Ermakov, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
WinApi, KERNEL32, GDI32, USER32, COMDLG32, SYSTEM,
Kernel, Strings, Dates, Fonts, Ports, Files, Stores, Views, Controllers, Properties,
Printers, Dialog, Windows, Converters, Services,
HostFonts, HostFiles, HostRegistry, HostPorts, HostWindows, HostPrinters,
StdCmds,
HostCFrames (* don't remove *),
i21sysCharacters;
CONST
(** CloseDialog res **)
save* = 1; cancel* = 2;
dirtyString = "#Host:SaveChanges";
TYPE
Preview = POINTER TO RECORD (Views.View) END;
UpdateMsg = RECORD (Views.Message) END;
DatesHook = POINTER TO RECORD (Dates.Hook) END;
DialogHook = POINTER TO RECORD (Dialog.GetHook) END;
ShowHook = POINTER TO RECORD (Dialog.ShowHook) END;
GetSpecHook = POINTER TO RECORD (Views.GetSpecHook) END;
LanguageHook = POINTER TO RECORD (Dialog.LanguageHook) END;
VAR
window-: Windows.Window; (** window created/selected by most recent Old or Open **)
oldWindow-: BOOLEAN; (** most recent Old or Open selected existing window **)
osVersion-: INTEGER;
extType*: Files.Type;
impType*: RECORD
list*: Dialog.List;
done: BOOLEAN
END;
setup*: RECORD
decorate*: BOOLEAN;
left*, right*, top*, bottom*: REAL;
w, h: INTEGER;
hs, vs: REAL
END;
prefs*: RECORD
useTTMetric*: BOOLEAN;
visualScroll*: BOOLEAN;
statusbar*: INTEGER;
thickCaret*: BOOLEAN;
caretPeriod*: INTEGER
END;
ShowOleStatus*: PROCEDURE (w: Windows.Window; s: ARRAY OF CHAR);
actualPath*: ARRAY 256 OF SHORTCHAR;
fn: COMDLG32.FileNameData;
ftype: ARRAY 16 OF SHORTCHAR;
filter: ARRAY 2048 OF SHORTCHAR;
fname: ARRAY 260 OF SHORTCHAR;
prt: COMDLG32.PrintDlgData;
font: COMDLG32.ChooseFontData;
logFont: GDI32.LogFont;
col: COMDLG32.ChooseColorData;
customColors: ARRAY 16 OF Ports.Color;
prefFName, prefDName: Fonts.Typeface;
prefFSize, prefDSize, prefDWght: INTEGER;
prefDStyle: SET;
typeList: ARRAY 64 OF Converters.Converter;
defConv: Converters.Converter;
all: Converters.Converter;
dialogHook: DialogHook;
PROCEDURE Append (VAR s: ARRAY OF CHAR; VAR idx: INTEGER; IN t: ARRAY OF CHAR);
VAR len, i: INTEGER; ch: CHAR;
BEGIN
i := 0; ch := t[0]; len := LEN(s) - 1;
WHILE (idx < len) & (ch # 0X) DO s[idx] := ch; INC(idx); INC(i); ch := t[i] END;
s[idx] := 0X
END Append;
PROCEDURE SAppend (VAR s: ARRAY OF SHORTCHAR; VAR idx: INTEGER; IN t: ARRAY OF CHAR);
VAR len, i: INTEGER; ch: SHORTCHAR;
BEGIN
i := 0; ch := SHORT(t[0]); len := LEN(s) - 1;
WHILE (idx < len) & (ch # 0X) DO s[idx] := ch; INC(idx); INC(i); ch := SHORT(t[i]) END;
s[idx] := 0X
END SAppend;
PROCEDURE SSAppend (VAR s: ARRAY OF SHORTCHAR; VAR idx: INTEGER; IN t: ARRAY OF SHORTCHAR);
VAR len, i: INTEGER; ch: SHORTCHAR;
BEGIN
i := 0; ch := t[0]; len := LEN(s) - 1;
WHILE (idx < len) & (ch # 0X) DO s[idx] := ch; INC(idx); INC(i); ch := t[i] END;
s[idx] := 0X
END SSAppend;
PROCEDURE MapConv (cmd: ARRAY OF CHAR; VAR name: ARRAY OF CHAR);
VAR i: INTEGER; sub, str: Dialog.String;
BEGIN
str := cmd$; i := 0;
WHILE str[i] >= "0" DO INC(i) END;
str[i] := 0X;
Kernel.SplitName(str, sub, str);
IF sub = "" THEN sub := "System" END;
str := "#"; i := 1;
Append(str, i, sub);
Append(str, i, ":");
Append(str, i, cmd);
Dialog.MapString(str, name)
END MapConv;
PROCEDURE WaitDialogClose;
(* simulates modal dialog *)
VAR res: INTEGER; w: HostWindows.Window; msg: USER32.Message;
BEGIN
w := HostWindows.dir.First();
REPEAT
IF USER32.PeekMessageA(msg, 0, 0, 0, 1) # 0 THEN
IF (msg.wnd = w.wnd) OR (msg.message = USER32.WMPaint) THEN
res := USER32.TranslateMessage(msg);
res := USER32.DispatchMessageA(msg)
END
ELSE (* http://forum.oberoncore.ru/viewtopic.php?p=62705#p62705 *)
WinApi.Sleep(1)
END
UNTIL w.wnd = 0
END WaitDialogClose;
PROCEDURE ShowParamStatus* (IN str, p0, p1, p2: ARRAY OF CHAR);
VAR res: INTEGER; st: ARRAY 513 OF CHAR; w: Windows.Window;
BEGIN
st := str$;
Dialog.MapParamString(st, p0, p1, p2, st);
i21sysCharacters.ToUnicode(st, st );
w := Windows.dir.Focus(Controllers.targetPath);
IF (w # NIL) & (HostWindows.inPlace IN w.flags) & (ShowOleStatus # NIL) THEN
ShowOleStatus(w, " " + st)
ELSE
st := " " + st;
res := WinApi.SetWindowTextW(HostWindows.status, st);
res := USER32.UpdateWindow(HostWindows.status)
END
END ShowParamStatus;
PROCEDURE ShowParamMsg* (IN str, p0, p1, p2: ARRAY OF CHAR);
VAR res: INTEGER; st: ARRAY 512 OF CHAR; sst: ARRAY 512 OF SHORTCHAR;
an: ARRAY 32 OF SHORTCHAR;
BEGIN
ASSERT(str # "", 20);
(*
IF Dialog.showsStatus THEN
ShowParamStatus(str, p0, p1, p2)
ELSE
*)
Dialog.MapParamString(str, p0, p1, p2, st); sst := SHORT(st$); an := SHORT(Dialog.appName$);
res := USER32.MessageBoxA(HostWindows.ActualWnd(), sst, an, {4, 5})
(*
END
*)
END ShowParamMsg;
PROCEDURE (h: ShowHook) ShowParamMsg (IN str, p0, p1, p2: ARRAY OF CHAR);
BEGIN
ShowParamMsg(str, p0, p1, p2)
END ShowParamMsg;
PROCEDURE (h: ShowHook) ShowParamStatus (IN str, p0, p1, p2: ARRAY OF CHAR);
BEGIN
ShowParamStatus(str, p0, p1, p2)
END ShowParamStatus;
(** general OK dialog **)
PROCEDURE (hook: DialogHook) GetOK (IN str, p0, p1, p2: ARRAY OF CHAR; form: SET; OUT res: INTEGER);
VAR r: INTEGER; st: ARRAY 512 OF CHAR; sst: ARRAY 512 OF SHORTCHAR;
an: ARRAY 32 OF SHORTCHAR; type: SET;
BEGIN
ASSERT(str # "", 20);
Dialog.MapParamString(str, p0, p1, p2, st); sst := SHORT(st$); an := SHORT(Dialog.appName$);
IF Dialog.yes IN form THEN
IF Dialog.cancel IN form THEN type := WinApi.MB_YESNOCANCEL + WinApi.MB_ICONQUESTION
ELSE type := WinApi.MB_YESNO + WinApi.MB_ICONQUESTION
END
ELSE
IF Dialog.cancel IN form THEN type := WinApi.MB_OKCANCEL + WinApi.MB_ICONWARNING
ELSE type := WinApi.MB_OK + WinApi.MB_ICONWARNING
END
END;
r := USER32.MessageBoxA(HostWindows.ActualWnd(), sst, an, type);
IF r = WinApi.IDOK THEN res := Dialog.ok
ELSIF r = WinApi.IDCANCEL THEN res := Dialog.cancel
ELSIF r = WinApi.IDYES THEN res := Dialog.yes
ELSIF r = WinApi.IDNO THEN res := Dialog.no
ELSE res := 0
END
END GetOK;
(** time **)
PROCEDURE (hook: DatesHook) GetTime (OUT d: Dates.Date; OUT t: Dates.Time);
VAR dt: WinApi.SYSTEMTIME;
BEGIN
WinApi.GetLocalTime(dt);
d.year := dt.wYear; d.month := dt.wMonth; d.day := dt.wDay;
t.hour := dt.wHour; t.minute := dt.wMinute; t.second := dt.wSecond
END GetTime;
PROCEDURE (hook: DatesHook) GetUTCTime (OUT d: Dates.Date; OUT t: Dates.Time);
VAR dt: WinApi.SYSTEMTIME;
BEGIN
WinApi.GetSystemTime(dt);
d.year := dt.wYear; d.month := dt.wMonth; d.day := dt.wDay;
t.hour := dt.wHour; t.minute := dt.wMinute; t.second := dt.wSecond
END GetUTCTime;
PROCEDURE (hook: DatesHook) GetUTCBias (OUT bias: INTEGER);
VAR res: INTEGER; info: WinApi.TIME_ZONE_INFORMATION;
BEGIN
bias := 0;
res := WinApi.GetTimeZoneInformation(info);
IF res # -1 THEN
IF BITS(res) = WinApi.TIME_ZONE_ID_DAYLIGHT THEN bias := info.Bias + info.DaylightBias
ELSE bias := info.Bias + info.StandardBias
END
END
END GetUTCBias;
(** import type dialog **)
PROCEDURE ImpOk*;
BEGIN
impType.done := TRUE;
StdCmds.CloseDialog
END ImpOk;
(** file dialogs **)
PROCEDURE (hook: DialogHook) GetIntSpec (
IN defType: Files.Type; VAR loc: Files.Locator; OUT name: Files.Name
);
(* asks user for a file name (for file internalization) *)
VAR res, i, j: INTEGER; lfn: ARRAY 260 OF CHAR;
BEGIN
(* set filter *)
ftype := SHORT(defType$); i := 0;
IF ftype = "" THEN ftype := "odc" END;
IF ftype # "*" THEN
SAppend(filter, i, "*."); SSAppend(filter, i, ftype); INC(i);
SAppend(filter, i, "*."); SSAppend(filter, i, ftype); INC(i)
ELSE ftype := ""
END;
SAppend(filter, i, "*.*"); INC(i);
SAppend(filter, i, "*.*"); INC(i);
filter[i] := 0X;
(* open dialog *)
fn.filterIndex := 1;
fname := "";
IF loc # NIL THEN (* set old dir *)
actualPath := SHORT(loc(HostFiles.Locator).path$); i := 0
(*
WHILE actualPath[i] # 0X DO INC(i) END;
actualPath[i] := "\"; actualPath[i+1] := 0X
*)
END;
fn.flags := {2, 3, 11, 12, 19}; (* hideReadOnly, noChangeDir, pathMustExist, fileMustExist, new look *)
fn.owner := HostWindows.ActualWnd();
IF COMDLG32.GetOpenFileNameA(fn) # 0 THEN
i := 0; j := fn.fileOffset;
WHILE fname[j] # 0X DO name[i] := fname[j]; INC(i); INC(j) END;
name[i] := 0X; fname[fn.fileOffset - 1] := 0X;
actualPath := fname$; lfn := fname$;
loc := HostFiles.NewLocator(lfn)
ELSE
loc := NIL;
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END GetIntSpec;
PROCEDURE GetIntSpec* (VAR loc: Files.Locator; VAR name: Files.Name; VAR conv: Converters.Converter);
(* asks user for a file name (for file internalization) *)
VAR res, i, j, n: INTEGER; t: Dialog.String; c: Converters.Converter; lfn: ARRAY 260 OF CHAR;
BEGIN
(* set filter *)
ftype := "odc";
IF loc # NIL THEN
defConv := conv;
IF conv # NIL THEN ftype := SHORT(conv.fileType$) END
END;
typeList[0] := Converters.list; (* document converter *)
Dialog.MapString("#Host:Document", t);
i := 0; SAppend(filter, i, t); SAppend(filter, i, " (*.odc)"); INC(i);
SAppend(filter, i, "*.odc"); INC(i); n := 1;
fn.filterIndex := 1;
c := Converters.list;
WHILE c # NIL DO
IF (c.imp # "") & (c.fileType # "odc") THEN
typeList[n] := c;
MapConv(c.imp, t); SAppend(filter, i, t);
SAppend(filter, i, " (*."); SAppend(filter, i, c.fileType);
SAppend(filter, i, ")"); INC(i);
SAppend(filter, i, "*."); SAppend(filter, i, c.fileType); INC(i);
IF defConv = c THEN fn.filterIndex := n + 1 END;
INC(n)
END;
c := c.next
END;
Dialog.MapString("#Host:AllFiles", t);
SAppend(filter, i, t); SAppend(filter, i, " (*.*)"); INC(i);
SAppend(filter, i, "*.*"); INC(i);
filter[i] := 0X;
IF defConv = all THEN fn.filterIndex := n + 1 END;
(* open dialog *)
IF loc # NIL THEN fname := SHORT(name$)
ELSE fname := ""
END;
IF loc # NIL THEN (* set old dir *)
actualPath := SHORT(loc(HostFiles.Locator).path$); i := 0;
WHILE actualPath[i] # 0X DO INC(i) END;
actualPath[i] := "\"; actualPath[i+1] := 0X
END;
fn.flags := {2, 3, 11, 12, 19}; (* hideReadOnly, noChangeDir, pathMustExist, fileMustExist, new look *)
fn.owner := HostWindows.ActualWnd();
IF COMDLG32.GetOpenFileNameA(fn) # 0 THEN
i := 0; j := fn.fileOffset;
WHILE fname[j] # 0X DO name[i] := fname[j]; INC(i); INC(j) END;
name[i] := 0X; fname[fn.fileOffset - 1] := 0X;
actualPath := fname$; lfn := fname$;
loc := HostFiles.NewLocator(lfn);
IF fn.filterIndex <= n THEN
conv := typeList[fn.filterIndex - 1];
defConv := conv
ELSE (* ask for desired file type *)
impType.list.SetLen(n);
Dialog.MapString("#Host:Document", t); impType.list.SetItem(0, t);
i := 1;
WHILE i < n DO
MapConv(typeList[i].imp, t); impType.list.SetItem(i, t);
INC(i)
END;
impType.list.index := 0;
impType.done := FALSE;
Dialog.Call("StdCmds.OpenToolDialog('HostDialog.impType', '#Host:OpenFile')", " ", res);
WaitDialogClose;
IF impType.done THEN
conv := typeList[impType.list.index]
ELSE
loc := NIL; conv := NIL
END;
defConv := all
END
ELSE
loc := NIL; conv := NIL;
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END GetIntSpec;
PROCEDURE (h: GetSpecHook) GetIntSpec (VAR loc: Files.Locator; VAR name: Files.Name;
VAR conv: Converters.Converter);
BEGIN
GetIntSpec(loc, name, conv)
END GetIntSpec;
PROCEDURE [2] HookProc (wnd: USER32.Handle; msg, wParam, lParam: INTEGER): INTEGER;
(* 06.11.02. not needed anymore.
For earlier Windows versions, this procedure was supposed to transfer the file-type from
the "Save as type" control to the "File name" control. But since Windows 98, it seems neither
to work properly nor to be need anymore. *)
VAR i, j: INTEGER; s: ARRAY 256 OF SHORTCHAR; t: ARRAY 8 OF SHORTCHAR; edit: USER32.Handle;
BEGIN
IF (msg = USER32.WMCommand) & (lParam # 0) & (wParam = 10470H) THEN
i := USER32.GetWindowTextA(lParam, s, LEN(s));
DEC(i);
IF s[i] = ")" THEN DEC(i) END;
j := i;
WHILE (j >= 0) & (s[j] # ".") DO DEC(j) END;
IF (j > 0) & (s[j-1] = "*") & (j >= i - 3) & (j < i) THEN
t[0] := s[j+1]; t[1] := s[j+2]; t[2] := s[j+3]; t[i-j] := 0X;
edit := USER32.GetDlgItem(USER32.GetParent(lParam), 480H);
IF edit # 0 THEN
i := USER32.GetWindowTextA(edit, s, LEN(s)); j := i - 1;
WHILE (j >= 0) & (s[j] # ".") DO DEC(j) END;
IF j < 0 THEN j := i END;
s[j] := "."; s[j+1] := t[0]; s[j+2] := t[1]; s[j+3] := t[2]; s[j+4] := 0X;
i := USER32.SetWindowTextA(edit, s)
END
END
END;
RETURN 0
END HookProc;
PROCEDURE (hook: DialogHook) GetExtSpec (
IN default: Files.Name; IN defType: Files.Type; VAR loc: Files.Locator; OUT name: Files.Name
);
(* ask user for a file name (for file externalization) *)
VAR res, i, j: INTEGER; lfn: ARRAY 260 OF CHAR;
BEGIN
(* set filter *)
ftype := SHORT(defType$); i := 0;
IF ftype = "" THEN ftype := "odc" END;
IF ftype # "*" THEN
SAppend(filter, i, "*."); SSAppend(filter, i, ftype); INC(i);
SAppend(filter, i, "*."); SSAppend(filter, i, ftype); INC(i)
ELSE ftype := ""
END;
SAppend(filter, i, "*.*"); INC(i);
SAppend(filter, i, "*.*"); INC(i);
filter[i] := 0X;
(* open dialog *)
fn.filterIndex := 1;
fname := SHORT(default$);
IF loc # NIL THEN (* set old dir *)
actualPath := SHORT(loc(HostFiles.Locator).path$); i := 0
(*
WHILE actualPath[i] # 0X DO INC(i) END;
actualPath[i] := "\"; actualPath[i+1] := 0X
*)
END;
fn.flags := {1, 2, 3, 11, 19}; (* overwritePrompt, hideReadOnly, noChangeDir, pathMustExist, new look *)
fn.owner := HostWindows.ActualWnd();
res := COMDLG32.GetSaveFileNameA(fn);
IF (res = 0) & (COMDLG32.CommDlgExtendedError() = 3002H) THEN
fname := "";
res := COMDLG32.GetSaveFileNameA(fn)
END;
IF res # 0 THEN
i := 0; j := fn.fileOffset;
WHILE fname[j] # 0X DO name[i] := fname[j]; INC(i); INC(j) END;
name[i] := 0X; fname[fn.fileOffset - 1] := 0X;
actualPath := fname$; lfn := fname$;
loc := HostFiles.NewLocator(lfn)
ELSE
loc := NIL;
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END GetExtSpec;
PROCEDURE GetExtSpec* (
s: Stores.Store; VAR loc: Files.Locator; VAR name: Files.Name; VAR conv: Converters.Converter
);
(* ask user for a file name (for file externalization) *)
VAR res, i, j, n: INTEGER; t: ARRAY 64 OF CHAR; c: Converters.Converter;
lfn: ARRAY 260 OF CHAR;
BEGIN
(* set filter *)
IF conv # NIL THEN ftype := SHORT(conv.fileType$) ELSE ftype := "odc" END;
typeList[0] := Converters.list; (* document converter *)
c := Converters.list; fn.filterIndex := 1;
Dialog.MapString("#Host:Document", t);
i := 0; SAppend(filter, i, t); SAppend(filter, i, " (*.odc)"); INC(i);
SAppend(filter, i, "*.odc"); INC(i); n := 1;
WHILE c # NIL DO
IF (c.exp # "") & ((c.storeType = "") OR Services.Is(s, c.storeType)) & (c.fileType # "odc") THEN
typeList[n] := c;
MapConv(c.exp, t); SAppend(filter, i, t);
SAppend(filter, i, " (*."); SAppend(filter, i, c.fileType);
SAppend(filter, i, ")"); INC(i);
SAppend(filter, i, "*."); SAppend(filter, i, c.fileType); INC(i);
IF c = conv THEN fn.filterIndex := n + 1 END;
INC(n)
END;
c := c.next
END;
filter[i] := 0X;
(* open dialog *)
fname := SHORT(name$); i := 0;
(* overwritePrompt, hideReadOnly, noChangeDir, (* en hook, *) pathMustExist *)
fn.flags := {1, 2, 3, (* 5 ,*) 11};
IF osVersion >= 400 THEN INCL(fn.flags, 19) END; (* new look *)
WHILE fname[i] # 0X DO INC(i) END;
WHILE (i > 0) & (fname[i] # ".") DO DEC(i) END;
IF i > 0 THEN
IF (conv # NIL) & (conv.exp = "") THEN
ftype := "odc"; fname[i] := 0X
ELSIF osVersion >= 400 THEN
j := 0;
WHILE (ftype[j] # 0X) & (CAP(fname[i+j+1]) = CAP(ftype[j])) DO INC(j) END;
IF fname[i+j+1] = ftype[j] THEN fname[i] := 0X END
END
END;
IF loc # NIL THEN (* set old dir *)
actualPath := SHORT(loc(HostFiles.Locator).path$); i := 0;
WHILE actualPath[i] # 0X DO INC(i) END;
actualPath[i] := "\"; actualPath[i+1] := 0X
END;
fn.owner := HostWindows.ActualWnd();
res := COMDLG32.GetSaveFileNameA(fn);
IF (res = 0) & (COMDLG32.CommDlgExtendedError() = 3002H) THEN
fname := "";
res := COMDLG32.GetSaveFileNameA(fn)
END;
IF res # 0 THEN
i := 0; j := fn.fileOffset;
WHILE fname[j] # 0X DO name[i] := fname[j]; INC(i); INC(j) END;
name[i] := 0X; fname[fn.fileOffset - 1] := 0X;
actualPath := fname$; lfn := fname$;
loc := HostFiles.NewLocator(lfn);
conv := typeList[fn.filterIndex - 1]
ELSE
loc := NIL;
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END GetExtSpec;
PROCEDURE (h: GetSpecHook) GetExtSpec (
s: Stores.Store; VAR loc: Files.Locator; VAR name: Files.Name; VAR conv: Converters.Converter
);
BEGIN
GetExtSpec(s, loc, name, conv)
END GetExtSpec;
(* printer dialogs *)
(* page setup previewer view *)
PROCEDURE (v: Preview) Restore (f: Views.Frame; l, t, r, b: INTEGER);
CONST scale = 16; rmm = Ports.mm DIV scale; size = 460 * rmm;
VAR u, w, h, x, y, uu: INTEGER;
BEGIN
u := f.unit;
IF Dialog.metricSystem THEN uu := 10 * rmm ELSE uu := Ports.inch DIV scale END;
w := setup.w DIV scale;
h := setup.h DIV scale;
x := (size - w) DIV 2;
y := (size - h) DIV 2;
l := SHORT(ENTIER(setup.left * uu));
t := SHORT(ENTIER(setup.top * uu));
r := SHORT(ENTIER(setup.right * uu));
b := SHORT(ENTIER(setup.bottom * uu));
f.DrawRect(x, y, x + w, y + h, Ports.fill, Ports.background);
f.DrawRect(x - u, y - u, x + w + u, y + h + u, 0, Ports.defaultColor);
IF setup.decorate THEN
IF t < 14 * rmm THEN t := 14 * rmm END;
f.DrawRect(x + l, y + 10 * rmm, x + l + 20 * rmm, y + 10 * rmm + u, Ports.fill, Ports.defaultColor);
f.DrawRect(x + w - r - 8 * rmm, y + 10 * rmm, x + w - r, y + 10 * rmm + u, Ports.fill, Ports.defaultColor)
END;
IF (w - r > l) & (h - b > t) THEN
f.DrawRect(x + l, y + t, x + w - r, y + h - b, 0, Ports.defaultColor)
END
END Restore;
PROCEDURE (v: Preview) HandleViewMsg (f: Views.Frame; VAR msg: Views.Message);
BEGIN
WITH msg: UpdateMsg DO
Views.Update(v, Views.keepFrames)
ELSE
END
END HandleViewMsg;
PROCEDURE Deposit*;
VAR v: Preview;
BEGIN
NEW(v); Views.Deposit(v)
END Deposit;
(* page setup dialog *)
PROCEDURE SetupNotify* (op, from, to: INTEGER);
VAR msg: UpdateMsg;
BEGIN
IF op = Dialog.changed THEN
Views.Omnicast(msg)
END
END SetupNotify;
PROCEDURE SetupOk*;
VAR win: Windows.Window; w, h, l, t, r, b, uu: INTEGER;
BEGIN
win := Windows.dir.Focus(Controllers.targetPath);
IF win # NIL THEN
IF Dialog.metricSystem THEN uu := 10 * Ports.mm ELSE uu := Ports.inch END;
w := setup.w; h := setup.h;
l := SHORT(ENTIER(setup.left * uu));
t := SHORT(ENTIER(setup.top * uu));
r := w - SHORT(ENTIER(setup.right * uu));
b := h - SHORT(ENTIER(setup.bottom * uu));
IF (0 <= l) & (l < r) & (r <= w) & (0 <= t) & (t < b) & (b <= h) THEN
win.doc.SetPage(w, h, l, t, r, b, setup.decorate);
StdCmds.CloseDialog
ELSE
Dialog.Beep
END
END
END SetupOk;
PROCEDURE InitPageSetup*;
VAR win: Windows.Window; w, h, l, t, r, b, uu: INTEGER; p: Printers.Printer;
BEGIN
win := Windows.dir.Focus(Controllers.targetPath);
IF win # NIL THEN
IF Dialog.metricSystem THEN uu := Ports.mm DIV 10 ELSE uu := Ports.inch DIV 100 END;
win.doc.PollPage(w, h, l, t, r, b, setup.decorate);
p := Printers.dir.Current();
IF p # NIL THEN HostPrinters.GetPage(p, w, h) END;
(* resolve doc - printer page size conflict !!! *)
r := w - r; b := h - b;
setup.left := l DIV uu / 100;
setup.right := r DIV uu / 100;
setup.top := t DIV uu / 100;
setup.bottom := b DIV uu / 100;
setup.w := w; setup.h := h;
setup.hs := setup.right + setup.left;
setup.vs := setup.bottom + setup.top
(*
Dialog.Call("OpenToolDialog('HostDialog.setup', 'Page Setup')", " ", res)
*)
END
END InitPageSetup;
PROCEDURE PrintDialog* (
hasSelection: BOOLEAN; VAR from, to, copies: INTEGER; VAR selection: BOOLEAN
);
VAR res: INTEGER;
devNames, devMode: GDI32.Handle;
BEGIN
prt.flags := {18 (*, 20 *)}; (* use dev mode copies, hide print to file *)
IF ~hasSelection THEN INCL(prt.flags, 2) END; (* no selection *)
prt.copies := 1;
prt.owner := HostWindows.ActualWnd();
HostPrinters.GetPrinterDev(Printers.dir.Current(), devNames, devMode);
prt.devNames := devNames;
prt.devMode := devMode;
prt.fromPage := 1; prt.toPage := 1;
res := COMDLG32.PrintDlgA(prt);
IF (res = 0) & (COMDLG32.CommDlgExtendedError() = 4106) THEN
prt.devMode := 0;
res := COMDLG32.PrintDlgA(prt)
END;
IF (res = 0) & (COMDLG32.CommDlgExtendedError() = 4108) THEN
prt.devMode := 0; prt.devNames := 0;
res := COMDLG32.PrintDlgA(prt)
END;
HostPrinters.SetCurrent(prt.devNames, prt.devMode);
IF res # 0 THEN
IF 0 IN prt.flags THEN selection := TRUE; from := 0; to := 0 (* print selection *)
ELSIF 1 IN prt.flags THEN selection := FALSE; from := prt.fromPage - 1; to := prt.toPage - 1 (* print pages *)
ELSE selection := FALSE; from := 0; to := 32767 (* print all *)
END;
copies := prt.copies
ELSE
copies := 0;
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END
END PrintDialog;
PROCEDURE PrintSetup*;
VAR res: INTEGER; pt: Printers.Printer;
devNames, devMode: GDI32.Handle;
BEGIN
prt.flags := {6}; (* PrintSetup *)
prt.owner := HostWindows.ActualWnd();
HostPrinters.GetPrinterDev(Printers.dir.Current(), devNames, devMode);
prt.devNames := devNames;
prt.devMode := devMode;
res := COMDLG32.PrintDlgA(prt);
IF (res = 0) & (COMDLG32.CommDlgExtendedError() = 4108) THEN
prt.devMode := 0; prt.devNames := 0;
res := COMDLG32.PrintDlgA(prt)
END;
(*
IF res = 0 THEN
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
*)
HostPrinters.SetCurrent(prt.devNames, prt.devMode);
pt := Printers.dir.Current();
IF pt # NIL THEN HostPrinters.GetPage(pt, setup.w, setup.h) END;
SetupNotify(Dialog.changed, 0, 0)
END PrintSetup;
PROCEDURE CloseDialog* (w: Windows.Window; quit: BOOLEAN; VAR res: INTEGER);
VAR r: INTEGER; title: Views.Title; text: ARRAY 256 OF CHAR;
stext: ARRAY 256 OF SHORTCHAR; an: ARRAY 32 OF SHORTCHAR;
BEGIN
w.GetTitle(title);
Dialog.MapParamString(dirtyString, title, 0DX, 0DX, text);
stext := SHORT(text$); an := SHORT(Dialog.appName$);
r := USER32.MessageBoxA(w(HostWindows.Window).wnd, stext, an, {0, 1, 5});
IF r = 6 THEN res := save
ELSIF r = 2 THEN res := cancel
ELSE res := 0
END;
r := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END CloseDialog;
PROCEDURE (hook: DialogHook) GetColor (in: Ports.Color; OUT out: Ports.Color; OUT set: BOOLEAN);
VAR res: INTEGER;
BEGIN
col.rgb := in;
IF col.rgb = Ports.defaultColor THEN col.rgb := HostPorts.textCol END;
col.owner := HostWindows.ActualWnd();
set := COMDLG32.ChooseColorA(col) # 0;
out := col.rgb;
IF ~set THEN
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END GetColor;
PROCEDURE ColorDialog*;
(* open color dialog and set selection to choosen color *)
VAR set: BOOLEAN; p: Properties.StdProp; col: Ports.Color;
BEGIN
Properties.CollectStdProp(p);
IF ~(Properties.color IN p.known) THEN p.color.val := Ports.black END;
(* ColorDialog0(p.color.val, col, set); *)
dialogHook.GetColor(p.color.val, col, set);
IF set THEN StdCmds.Color(col) END
END ColorDialog;
PROCEDURE FontDialog0 (full: BOOLEAN; VAR typeface: ARRAY OF CHAR; VAR size: INTEGER;
VAR color: Ports.Color; VAR weight: INTEGER; VAR style: SET; VAR set: BOOLEAN
);
VAR res: INTEGER;
BEGIN
logFont.height := -((size + HostWindows.unit DIV 2) DIV HostWindows.unit);
logFont.weight := weight;
logFont.italic := Fonts.italic IN style;
logFont.underlined := Fonts.underline IN style;
logFont.strikeOut := Fonts.strikeout IN style;
logFont.faceName := SHORT(typeface$);
font.owner := HostWindows.ActualWnd();
IF full THEN
font.flags := {0, 6, 8, 11, 16} (* screenFonts, initToLogFont, effects, noVectorFonts, forceFontExist *)
ELSE
font.flags := {0, 6, 11, 20, 21} (* screenFonts, initToLogFont, noVectorFonts, no style, no size *)
END;
IF color = Ports.defaultColor THEN font.rgb := HostPorts.textCol ELSE font.rgb := color END;
set := COMDLG32.ChooseFontA(font) # 0;
IF set THEN
typeface := logFont.faceName$;
size := font.pointSize * Ports.point DIV 10;
ASSERT((size + HostWindows.unit DIV 2) DIV HostWindows.unit = ABS(logFont.height), 120);
weight := SHORT(logFont.weight);
style := {};
IF logFont.italic THEN INCL(style, Fonts.italic) END;
IF logFont.underlined THEN INCL(style, Fonts.underline) END;
IF logFont.strikeOut THEN INCL(style, Fonts.strikeout) END;
IF font.rgb = HostPorts.textCol THEN color := Ports.defaultColor ELSE color := font.rgb END
ELSE
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 0, 100)
END;
res := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor])
END FontDialog0;
PROCEDURE FontDialog*;
(** open font dialog and set selection to choosen attributes **)
VAR set: BOOLEAN; p, p0: Properties.StdProp;
BEGIN
Properties.CollectStdProp(p0);
IF Properties.typeface IN p0.known THEN
NEW(p); p.typeface := p0.typeface$;
p.size := p0.size; p.color.val := p0.color.val;
p.weight := p0.weight; p.style := p0.style;
FontDialog0(TRUE, p.typeface, p.size, p.color.val, p.weight, p.style.val, set);
IF set THEN
p.valid := {Properties.typeface, Properties.style, Properties.weight, Properties.size, Properties.color};
p.style.mask := {Fonts.italic, Fonts.underline, Fonts.strikeout};
Properties.EmitProp(NIL, p)
END
END
END FontDialog;
PROCEDURE TypefaceDialog*;
(** open font dialog and set selection to choosen typeface **)
VAR set: BOOLEAN; p, p0: Properties.StdProp; s: INTEGER; c: Ports.Color; w: INTEGER; st: SET;
BEGIN
Properties.CollectStdProp(p0);
IF Properties.typeface IN p0.known THEN
NEW(p); p.typeface := p0.typeface$;
FontDialog0(FALSE, p.typeface, s, c, w, st, set);
IF set THEN
p.valid := {Properties.typeface};
Properties.EmitProp(NIL, p)
END
END
END TypefaceDialog;
(* preferences dialog *)
PROCEDURE DefFont*;
VAR tf: Fonts.Typeface; size: INTEGER; color: Ports.Color; w: INTEGER; style: SET; set: BOOLEAN;
BEGIN
tf := prefFName;
size := prefFSize;
w := Fonts.normal;
style := {};
color := Ports.defaultColor;
FontDialog0(TRUE, tf, size, color, w, style, set);
IF set THEN
prefFName := tf; prefFSize := size
END
END DefFont;
PROCEDURE DlgFont*;
VAR tf: Fonts.Typeface; size: INTEGER; color: Ports.Color; w: INTEGER; style: SET; set: BOOLEAN;
BEGIN
tf := prefDName;
size := prefDSize;
w := prefDWght;
style := prefDStyle;
color := Ports.defaultColor;
FontDialog0(TRUE, tf, size, color, w, style, set);
IF set THEN
prefDName := tf; prefDSize := size; prefDStyle := style; prefDWght := w
END
END DlgFont;
PROCEDURE PrefOk*;
VAR res: INTEGER; rect: USER32.Rect;
BEGIN
HostFonts.SetDefaultFont(prefFName, prefFSize);
HostFonts.SetDialogFont(prefDName, prefDSize, prefDStyle, prefDWght);
HostFonts.SetTTMetric(prefs.useTTMetric);
HostWindows.SetVisualScroll(prefs.visualScroll);
IF prefs.statusbar = 1 THEN Dialog.showsStatus := TRUE; HostWindows.memInStatus := FALSE
ELSIF prefs.statusbar = 2 THEN Dialog.showsStatus := TRUE; HostWindows.memInStatus := TRUE
ELSE Dialog.showsStatus := FALSE
END;
Dialog.Call("StdCmds.UpdateAll", "", res);
Dialog.Call("StdCmds.RecalcAllSizes", "", res);
Dialog.Call("TextCmds.UpdateDefaultAttr", "", res);
HostCFrames.SetDefFonts;
HostRegistry.WriteBool("noStatus", ~Dialog.showsStatus);
HostRegistry.WriteBool("memStatus", HostWindows.memInStatus);
res := USER32.GetClientRect(HostWindows.main, rect);
HostWindows.ResizeMainWindow(0, rect.right, rect.bottom);
Dialog.thickCaret := prefs.thickCaret;
Dialog.caretPeriod := prefs.caretPeriod;
HostRegistry.WriteBool("thickCaret", Dialog.thickCaret);
HostRegistry.WriteInt("caretPeriod", Dialog.caretPeriod)
END PrefOk;
PROCEDURE InitPrefDialog*;
BEGIN
prefFName := HostFonts.defFont.alias;
prefFSize := HostFonts.defFont.size;
prefDName := HostFonts.dlgFont.typeface;
prefDSize := HostFonts.dlgFont.size;
prefDStyle := HostFonts.dlgFont.style;
prefDWght := HostFonts.dlgFont.weight;
prefs.useTTMetric := HostFonts.useTTMetric;
prefs.visualScroll := HostWindows.visualScroll;
IF ~Dialog.showsStatus THEN prefs.statusbar := 0
ELSIF HostWindows.memInStatus THEN prefs.statusbar := 2
ELSE prefs.statusbar := 1
END;
prefs.thickCaret := Dialog.thickCaret;
prefs.caretPeriod := Dialog.caretPeriod
END InitPrefDialog;
(* date / time *)
PROCEDURE (hook: DatesHook) DateToString (d: Dates.Date; format: INTEGER; OUT str: ARRAY OF CHAR);
VAR res, pos, i: INTEGER; time: WinApi.SYSTEMTIME; fmt: ARRAY 64 OF CHAR;
(*sfmt, sstr: ARRAY 64 OF SHORTCHAR;*)
BEGIN
(* Alexander Iljin: original, non-unicode code *)
time.wYear := SHORT(d.year); time.wMonth := SHORT(d.month); time.wDay := SHORT(d.day);
IF format = Dates.short THEN
res := WinApi.GetDateFormat(
HostRegistry.localeId, WinApi.DATE_SHORTDATE, time, NIL, sstr, LEN(sstr))
(*
IF weekday THEN
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_SSHORTDATE, sfmt, LEN(sfmt));
sfmt := "ddd, " + sfmt;
res := WinApi.GetDateFormat(HostRegistry.localeId, {}, time, sfmt, sstr, LEN(sstr));
ELSE
res := WinApi.GetDateFormat(
HostRegistry.localeId, WinApi.DATE_SHORTDATE, time, NIL, sstr, LEN(sstr))
END
*)
ELSIF format = Dates.long THEN
res := WinApi.GetDateFormat(HostRegistry.localeId, WinApi.DATE_LONGDATE, time, NIL, sstr, LEN(sstr))
ELSE
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_SLONGDATE, sfmt, LEN(sfmt));
fmt := sfmt$;
IF format # Dates.abbreviated THEN (* remove weekday *)
Strings.Find(fmt, "dddd", 0, pos); i := pos + 4;
IF pos < 0 THEN Strings.Find(fmt, "ddd", 0, pos); i := pos + 3 END;
IF pos >= 0 THEN
WHILE (fmt[i] # 0X) & (CAP(fmt[i]) < "A") OR (CAP(fmt[i]) > "Z") DO INC(i) END;
Strings.Replace(fmt, pos, i - pos, "")
END
END;
IF format # Dates.plainLong THEN (* abbreviated *)
Strings.Find(fmt, "dddd", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "ddd") END;
Strings.Find(fmt, "MMMM", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "MMM") END
END;
sfmt := SHORT(fmt$);
res := WinApi.GetDateFormat(HostRegistry.localeId, {}, time, sfmt, sstr, LEN(sstr))
END;
(*
ELSE
IF (format = Dates.abbreviated) OR ~weekday THEN
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_SLONGDATE, sfmt, LEN(sfmt));
fmt := sfmt$;
IF format = Dates.abbreviated THEN
Strings.Find(fmt, "dddd", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "ddd") END;
Strings.Find(fmt, "MMMM", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "MMM") END
END;
IF ~weekday THEN
Strings.Find(fmt, "dddd", 0, pos); i := pos + 4;
IF pos < 0 THEN Strings.Find(fmt, "ddd", 0, pos); i := pos + 3 END;
IF pos >= 0 THEN
WHILE (fmt[i] # 0X) & (CAP(fmt[i]) < "A") OR (CAP(fmt[i]) > "Z") DO INC(i) END;
Strings.Replace(fmt, pos, i - pos, "")
END
END;
sfmt := SHORT(fmt$);
res := WinApi.GetDateFormat(HostRegistry.localeId, {}, time, sfmt, sstr, LEN(sstr));
ELSE
res := WinApi.GetDateFormat(
HostRegistry.localeId, WinApi.DATE_LONGDATE, time, NIL, sstr, LEN(sstr))
END
END;
*)
(*
IF format = Dates.abbreviated THEN
res := WinApi.GetLocaleInfo(HostRegistry.localeId, WinApi.LOCALE_SLONGDATE, sfmt, LEN(sfmt));
fmt := sfmt$;
Strings.Find(fmt, "dddd", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "ddd") END;
Strings.Find(fmt, "MMMM", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "MMM") END;
sfmt := SHORT(fmt$);
res := WinApi.GetDateFormat(HostRegistry.localeId, {}, time, sfmt, sstr, LEN(sstr));
ELSE
IF format = Dates.long THEN flags := WinApi.DATE_LONGDATE
ELSE flags := WinApi.DATE_SHORTDATE
END;
res := WinApi.GetDateFormat(HostRegistry.localeId, flags, time, NIL, sstr, LEN(sstr));
END;
*)
IF res # 0 THEN str := sstr$ ELSE str := "?" END
(* Alexander Iljin: Unicode version *)
time.wYear := SHORT(d.year); time.wMonth := SHORT(d.month); time.wDay := SHORT(d.day);
IF format = Dates.short THEN
res := WinApi.GetDateFormatW(
HostRegistry.localeId, WinApi.DATE_SHORTDATE, time, NIL, str, LEN(str))
ELSIF format = Dates.long THEN
res := WinApi.GetDateFormatW(
HostRegistry.localeId, WinApi.DATE_LONGDATE, time, NIL, str, LEN(str))
ELSE
res := WinApi.GetLocaleInfoW(
HostRegistry.localeId, WinApi.LOCALE_SLONGDATE, fmt, LEN(fmt));
IF format # Dates.abbreviated THEN (* remove weekday *)
Strings.Find(fmt, "dddd", 0, pos); i := pos + 4;
IF pos < 0 THEN Strings.Find(fmt, "ddd", 0, pos); i := pos + 3 END;
IF pos >= 0 THEN
WHILE (fmt[i] # 0X) & (CAP(fmt[i]) < "A") OR (CAP(fmt[i]) > "Z") DO INC(i) END;
Strings.Replace(fmt, pos, i - pos, "")
END
END;
IF format # Dates.plainLong THEN (* abbreviated *)
Strings.Find(fmt, "dddd", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "ddd") END;
Strings.Find(fmt, "MMMM", 0, pos);
IF pos >= 0 THEN Strings.Replace(fmt, pos, 4, "MMM") END
END;
res := WinApi.GetDateFormatW(HostRegistry.localeId, {}, time, fmt, str, LEN(str))
END;
IF res = 0 THEN str := "?" END
END DateToString;
PROCEDURE (hook: DatesHook) TimeToString (t: Dates.Time; OUT str: ARRAY OF CHAR);
VAR res: INTEGER; time: WinApi.SYSTEMTIME;
BEGIN
time.wHour := SHORT(t.hour); time.wMinute := SHORT(t.minute);
time.wSecond := SHORT(t.second); time.wMilliseconds := 0;
(* Alexander Iljin: original, non-unicode code *)
res := WinApi.GetTimeFormat(HostRegistry.localeId, {}, time, NIL, sstr, LEN(sstr));
IF res # 0 THEN str := sstr$ ELSE str := "?" END
(* Alexander Iljin: Unicode version *)
res := WinApi.GetTimeFormatW(HostRegistry.localeId, {}, time, NIL, str, LEN(str));
IF res = 0 THEN str := "?" END
END TimeToString;
PROCEDURE (hook: LanguageHook) SetLanguage (
lang: Dialog.Language; persistent: BOOLEAN; OUT ok: BOOLEAN
);
BEGIN
ok := (lang = "") OR (LEN(lang$) = 2);
IF ok & persistent THEN HostRegistry.WriteString("language", SHORT(lang)) END
END SetLanguage;
PROCEDURE (hook: LanguageHook) GetPersistentLanguage (OUT lang: Dialog.Language);
VAR res: INTEGER; s: ARRAY 32 OF SHORTCHAR;
BEGIN
HostRegistry.ReadString("language", s, res);
IF res = 0 THEN
ASSERT((s = "") OR (LEN(s$) = 2), 100);
lang := s$
ELSE lang := ""
END
END GetPersistentLanguage;
PROCEDURE Start* (name: ARRAY OF CHAR);
VAR res: INTEGER; str: ARRAY 256 OF SHORTCHAR;
BEGIN
str := SHORT(name$);
res := KERNEL32.WinExec(str, 1)
END Start;
(* initialization *)
PROCEDURE InitDialogs;
VAR i: INTEGER;
BEGIN
(* file dialog data structure *)
fn.size := SIZE(COMDLG32.FileNameData);
fn.instance := 0;
fn.customFilter := NIL;
fn.filter := filter; fn.filterIndex := 1;
i := KERNEL32.GetCurrentDirectoryA(LEN(actualPath), actualPath);
fn.initialDir := actualPath;
fn.title := NIL; fn.fileTitle := NIL;
fn.file := fname; fn.maxFile := LEN(fname);
fn.defExt := ftype; ftype := "$";
fn.hook := HookProc;
(* print dialog data structure *)
prt.size := SIZE(COMDLG32.PrintDlgData);
prt.devMode := 0;
prt.devNames := 0;
prt.minPage := 1;
prt.maxPage := -1;
(* font dialog data structure *)
font.size := SIZE(COMDLG32.ChooseFontData);
font.dc := 0;
font.logFont := SYSTEM.VAL(GDI32.LogFontPtr, SYSTEM.ADR(logFont));
font.rgb := 0;
font.instance := 0;
font.style := NIL;
font.fontType := 2000H; (* screenFontType *)
logFont.width := 0;
logFont.escapement := 0;
logFont.orientation := 0;
logFont.charSet := 0;
logFont.outPrecision := 0;
logFont.clipPrecision := 0;
logFont.quality := 0;
logFont.pitchAndFamily := 0;
(* color dialog data structure *)
col.size := SIZE(COMDLG32.ChooseColorData);
col.custColors := customColors;
col.flags := {0}; (* rgbInit *)
i := 0;
WHILE i < 16 DO customColors[i] := 0FFFFFFH; INC(i) END
END InitDialogs;
PROCEDURE Init*;
VAR n, v, res: INTEGER; b: BOOLEAN;
getSpecHook: GetSpecHook;
datesHook: DatesHook;
showHook: ShowHook;
languageHook: LanguageHook;
BEGIN
NEW(all);
v := KERNEL32.GetVersion();
osVersion := v MOD 256 * 100 + v DIV 256 MOD 256;
IF v >= 0 THEN
IF osVersion < 400 THEN Dialog.platform := Dialog.windowsNT3
ELSIF osVersion < 500 THEN Dialog.platform := Dialog.windowsNT4
ELSE Dialog.platform := Dialog.windows2000
END
ELSIF osVersion < 400 THEN Dialog.platform := Dialog.windows32s
ELSIF osVersion < 410 THEN Dialog.platform := Dialog.windows95
ELSE Dialog.platform := Dialog.windows98
END;
HostRegistry.ReadBool("noStatus", b, res); Dialog.showsStatus := (res # 0) OR ~b;
HostRegistry.ReadBool("memStatus", b, res); HostWindows.memInStatus := (res = 0) & b;
HostRegistry.ReadBool("thickCaret", b, res); IF res = 0 THEN Dialog.thickCaret := b END;
HostRegistry.ReadInt("caretPeriod", n, res); IF res = 0 THEN Dialog.caretPeriod := n END;
NEW(showHook); Dialog.SetShowHook(showHook);
(*
Hooks.showParamMsg := ShowParamMsg;
Hooks.showParamStatus := ShowParamStatus;
*)
NEW(dialogHook); Dialog.SetGetHook(dialogHook);
(*
Hooks.getOK := GetOK;
Hooks.getIntSpec := GetIntSpec0;
Hooks.getExtSpec := GetExtSpec0;
Hooks.getColor := ColorDialog0;
*)
(*
Sequencers.GetIntSpec := GetIntSpec;
Sequencers.GetExtSpec := GetExtSpec;
*)
NEW(getSpecHook); Views.SetGetSpecHook(getSpecHook);
HostFiles.MapParamString := Dialog.MapParamString;
NEW(datesHook); Dates.SetHook(datesHook);
(*
Hooks.getTime := GetTime;
Hooks.dateToString := DateToString;
Hooks.timeToString := TimeToString
*)
NEW(languageHook); Dialog.SetLanguageHook(languageHook); Dialog.ResetLanguage
END Init;
BEGIN
Init;
InitDialogs
END HostDialog.
| Host/Mod/Dialog.odc |
MODULE HostFiles; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Files, Kernel, KERNEL32, USER32, SYSTEM, WinApi, Ch := i21sysCharacters;
CONST
tempName = "odcxxxxx.tmp";
docType = "odc";
serverVersion = TRUE;
pathLen* = 260;
nofbufs = 4; (* max number of buffers per file *)
bufsize = 2 * 1024; (* size of each buffer *)
invalid = KERNEL32.InvalidHandle;
temp = 0; new = 1; shared = 2; hidden = 3; exclusive = 4; closed = 5; (* file states *)
create = -1;
ok = 0;
invalidName = 1; invalidNameErr = 123;
notFound = 2; fileNotFoundErr = 2; pathNotFoundErr = 3;
existsAlready = 3; fileExistsErr = 80; alreadyExistsErr = 183;
writeProtected = 4; writeProtectedErr = 19;
ioError = 5;
accessDenied = 6; accessDeniedErr = 5; sharingErr = 32; netAccessDeniedErr = 65;
notEnoughMem = 80; notEnoughMemoryErr = 8;
notEnoughDisk = 81; diskFullErr = 39; tooManyOpenFilesErr = 4; noSystemResourcesErr = 1450;
noMoreFilesErr = 18;
cancel = -8; retry = -9;
TYPE
FullName* = ARRAY pathLen OF CHAR;
Locator* = POINTER TO RECORD (Files.Locator)
path-: FullName; (* without trailing "/" *)
maxLen-: INTEGER; (* maximum name length *)
caseSens-: BOOLEAN; (* case sensitive file compares *)
rootLen-: INTEGER (* for network version *)
END;
Buffer = POINTER TO RECORD
dirty: BOOLEAN;
org, len: INTEGER;
data: ARRAY bufsize OF BYTE
END;
File = POINTER TO RECORD (Files.File)
state: INTEGER;
name: FullName;
ref: KERNEL32.Handle;
loc: Locator;
swapper: INTEGER; (* index into file table / next buffer to swap *)
len: INTEGER;
bufs: ARRAY nofbufs OF Buffer;
t: LONGINT (* time stamp of last file operation *)
END;
Reader = POINTER TO RECORD (Files.Reader)
base: File;
org, offset: INTEGER;
buf: Buffer
END;
Writer = POINTER TO RECORD (Files.Writer)
base: File;
org, offset: INTEGER;
buf: Buffer
END;
Directory = POINTER TO RECORD (Files.Directory)
temp, startup: Locator
END;
Identifier = RECORD (Kernel.Identifier)
name: FullName
END;
Searcher = RECORD (Kernel.Identifier)
t0: INTEGER;
f: File
END;
Counter = RECORD (Kernel.Identifier)
count: INTEGER
END;
ShortName = ARRAY pathLen OF SHORTCHAR;
VAR
MapParamString*: PROCEDURE(in, p0, p1, p2: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
main*: INTEGER; (* main window *)
appName-: FullName;
dir: Directory;
wildcard: Files.Type;
startupDir: FullName;
startupLen: INTEGER;
res: INTEGER;
PROCEDURE Error (n: INTEGER): INTEGER;
VAR res: INTEGER;
BEGIN
IF n = ok THEN res := ok
ELSIF n = invalidNameErr THEN res := invalidName
ELSIF (n = fileNotFoundErr) OR (n = pathNotFoundErr) THEN res := notFound
ELSIF (n = fileExistsErr) OR (n = alreadyExistsErr) THEN res := existsAlready
ELSIF n = writeProtectedErr THEN res := writeProtected
ELSIF (n = sharingErr) OR (n = accessDeniedErr) OR (n = netAccessDeniedErr) THEN res := accessDenied
ELSIF n = notEnoughMemoryErr THEN res := notEnoughMem
ELSIF (n = diskFullErr) OR (n = tooManyOpenFilesErr) THEN res := notEnoughDisk
ELSE res := -n
END;
RETURN res
END Error;
PROCEDURE Diff (VAR a, b: ARRAY OF CHAR; caseSens: BOOLEAN): INTEGER;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN
i := 0;
REPEAT
cha := a[i]; chb := b[i]; INC(i);
IF cha # chb THEN
IF ~caseSens THEN
cha := Ch.Cap(cha);
chb := Ch.Cap(chb);
END;
IF cha = "\" THEN cha := "/" END;
IF chb = "\" THEN chb := "/" END;
IF cha # chb THEN RETURN ORD(cha) - ORD(chb) END
END
(*
IF (cha = chb)
OR ~caseSens & (CAP(cha) = CAP(chb)) & (CAP(cha) >= "A") & ((CAP(cha) <= "Z") OR (cha >= "А"))
OR ((cha = "/") OR (cha = "\")) & ((chb = "/") OR (chb = "\")) THEN (* ok *)
ELSE RETURN 1
END
*)
UNTIL cha = 0X;
RETURN 0
END Diff;
PROCEDURE NewLocator* (IN fname: ARRAY OF CHAR): Locator;
VAR loc: Locator; res, n, max, i: INTEGER; root: FullName; ch: CHAR; f: SET; s: ShortName;
BEGIN
NEW(loc); loc.path := fname$; i := 0;
WHILE loc.path[i] # 0X DO INC(i) END;
IF (loc.path[i-1] = "/") OR (loc.path[i-1] = "\") THEN loc.path[i-1] := 0X END;
i := 0; n := 1;
IF ((fname[0] = "\") OR (fname[0] = "/")) & ((fname[1] = "\") OR (fname[1] = "/")) THEN n := 4 END;
REPEAT
ch := fname[i]; root[i] := ch; INC(i);
IF (ch = "/") OR (ch = "\") THEN DEC(n) END
UNTIL (ch = 0X) OR (n = 0);
IF ch = 0X THEN root[i-1] := "\" END;
root[i] := 0X; s := SHORT(root$);
res := KERNEL32.GetVolumeInformationA(s, NIL, 0, n, max, f, NIL, 0);
IF res = 0 THEN
max := 12; f := {} (* FAT values *)
END;
loc.maxLen := max; loc.caseSens := FALSE; (* 0 IN f; *) (* NT erroneously returns true here *)
RETURN loc
END NewLocator;
PROCEDURE GetType (IN name: ARRAY OF CHAR; VAR type: Files.Type);
VAR i, j: INTEGER; ch: CHAR;
BEGIN
i := 0; j := 0;
WHILE name[i] # 0X DO INC(i) END;
WHILE (i > 0) & (name[i] # ".") DO DEC(i) END;
IF i > 0 THEN
INC(i); ch := name[i];
WHILE (j < LEN(type) - 1) & (ch # 0X) DO
ch := Ch.Lower(ch);
type[j] := ch; INC(j);
INC(i); ch := name[i]
END
END;
type[j] := 0X
END GetType;
PROCEDURE Append (IN path, name: ARRAY OF CHAR; type: Files.Type; max: INTEGER;
VAR res: ARRAY OF CHAR
);
VAR i, j, n, m, dot: INTEGER; ch: CHAR;
BEGIN
i := 0;
WHILE path[i] # 0X DO res[i] := path[i]; INC(i) END;
IF path # "" THEN
ASSERT((res[i-1] # "/") & (res[i-1] # "\"), 100);
res[i] := "\"; INC(i)
END;
j := 0; ch := name[0]; n := 0; m := max; dot := -1;
IF max = 12 THEN m := 8 END;
WHILE (i < LEN(res) - 1) & (ch # 0X) DO
IF (ch = "/") OR (ch = "\") THEN
res[i] := ch; INC(i); n := 0; m := max; dot := -1;
IF max = 12 THEN m := 8 END
ELSIF (n < m) OR (ch = ".") & (n = 8) THEN
res[i] := ch; INC(i); INC(n);
IF ch = "." THEN dot := n;
IF max = 12 THEN m := n + 3 END
END
END;
INC(j); ch := name[j]
END;
IF (dot = -1) & (type # "") THEN
IF max = 12 THEN m := n + 4 END;
IF (n < m) & (i < LEN(res) - 1) THEN res[i] := "."; INC(i); INC(n); dot := n END
END;
IF n = dot THEN j := 0;
WHILE (n < m) & (i < LEN(res) - 1) & (type[j] # 0X) DO res[i] := type[j]; INC(i); INC(j) END
END;
res[i] := 0X
END Append;
PROCEDURE CloseFileHandle (f: File; VAR res: INTEGER);
BEGIN
IF (f.ref = invalid) OR (KERNEL32.CloseHandle(f.ref) # 0) THEN res := ok (* !!! *)
ELSE res := KERNEL32.GetLastError()
END;
f.ref := invalid
END CloseFileHandle;
PROCEDURE CloseFile (f: File; VAR res: INTEGER);
VAR s: INTEGER; n: ShortName;
BEGIN
IF f.state = exclusive THEN
f.Flush;
res := WinApi.FlushFileBuffers(f.ref)
END;
s := f.state; f.state := closed;
CloseFileHandle (f, res);
IF (s IN {temp, new, hidden}) & (f.name # "") THEN
n := SHORT(f.name$);
res := KERNEL32.DeleteFileA(n)
END
END CloseFile;
PROCEDURE (f: File) FINALIZE;
VAR res: INTEGER;
BEGIN
IF f.state # closed THEN CloseFile(f, res) END
END FINALIZE;
PROCEDURE (VAR id: Identifier) Identified (): BOOLEAN;
VAR f: File;
BEGIN
f := id.obj(File);
RETURN (f.state IN {shared, exclusive}) & (Diff(f.name, id.name, f.loc.caseSens) = 0)
END Identified;
PROCEDURE ThisFile (VAR name: FullName): File;
VAR id: Identifier; p: ANYPTR;
BEGIN
id.typ := SYSTEM.TYP(File); id.name := name$;
p := Kernel.ThisFinObj(id);
IF p # NIL THEN RETURN p(File)
ELSE RETURN NIL
END
END ThisFile;
PROCEDURE (VAR s: Searcher) Identified (): BOOLEAN;
VAR f: File;
BEGIN
f := s.obj(File);
IF (f.ref # invalid) & ((s.f = NIL) OR (f.t < s.f.t)) THEN s.f := f END;
RETURN FALSE
END Identified;
PROCEDURE SearchFileToClose;
VAR s: Searcher; p: ANYPTR; (* res: LONGINT; *)
BEGIN
s.typ := SYSTEM.TYP(File); s.f := NIL;
p := Kernel.ThisFinObj(s);
IF s.f # NIL THEN
res := KERNEL32.CloseHandle(s.f.ref); s.f.ref := invalid;
IF res = 0 THEN res := KERNEL32.GetLastError(); HALT(100) END
END
END SearchFileToClose;
PROCEDURE NewFileRef (state: INTEGER; VAR name: FullName): KERNEL32.Handle;
VAR n: ShortName;
BEGIN
n := SHORT(name$);
IF state = create THEN
RETURN KERNEL32.CreateFileA(n, {KERNEL32.GenericRead, KERNEL32.GenericWrite}, {},
0, KERNEL32.CreateNew, {KERNEL32.FileAttrTemp}, 0)
ELSIF state = shared THEN
RETURN KERNEL32.CreateFileA(n, {KERNEL32.GenericRead}, {KERNEL32.FileShareRead},
0, KERNEL32.OpenExisting, {}, 0)
ELSE
RETURN KERNEL32.CreateFileA(n, {KERNEL32.GenericRead, KERNEL32.GenericWrite}, {},
0, KERNEL32.OpenExisting, {}, 0)
END
END NewFileRef;
PROCEDURE OpenFile (state: INTEGER; VAR name: FullName; VAR ref, res: INTEGER);
BEGIN
ref := NewFileRef(state, name);
IF ref = invalid THEN
res := KERNEL32.GetLastError();
IF (res = tooManyOpenFilesErr) OR (res = noSystemResourcesErr) THEN
Kernel.Collect;
ref := NewFileRef(state, name);
IF ref = invalid THEN
res := KERNEL32.GetLastError();
IF (res = tooManyOpenFilesErr) OR (res = noSystemResourcesErr) THEN
SearchFileToClose;
ref := NewFileRef(state, name);
IF ref = invalid THEN
res := KERNEL32.GetLastError()
ELSE res := ok
END
END
ELSE res := ok
END
END
ELSE res := ok
END
END OpenFile;
PROCEDURE GetTempFileName (VAR path, name: FullName; num: INTEGER);
VAR i: INTEGER; str: ARRAY 16 OF CHAR;
BEGIN
str := tempName; i := 7;
WHILE i > 2 DO
str[i] := CHR(num MOD 10 + ORD("0")); DEC(i); num := num DIV 10
END;
Append(path, str, "", 8, name)
END GetTempFileName;
PROCEDURE CreateFile (f: File; VAR res: INTEGER);
VAR num, n: INTEGER;
BEGIN
IF f.name = "" THEN
num := KERNEL32.GetTickCount(); n := 200;
REPEAT
GetTempFileName(f.loc.path, f.name, num); INC(num); DEC(n);
OpenFile(create, f.name, f.ref, res)
UNTIL (res # fileExistsErr) & (res # alreadyExistsErr) & (res # 87) OR (n = 0)
ELSE
OpenFile(f.state, f.name, f.ref, res)
END
END CreateFile;
PROCEDURE Delete (VAR fname, path: FullName; VAR res: INTEGER);
VAR num, n, s: INTEGER; f: File; new: FullName; attr: SET; fn, nn: ShortName;
BEGIN
ASSERT(fname # "", 100);
f := ThisFile(fname); fn := SHORT(fname$);
IF f = NIL THEN
IF KERNEL32.DeleteFileA(fn) # 0 THEN res := ok
ELSE res := KERNEL32.GetLastError()
END
ELSE (* still in use => make it anonymous *)
IF f.ref # invalid THEN res := KERNEL32.CloseHandle(f.ref); f.ref := invalid END; (* !!! *)
attr := KERNEL32.GetFileAttributesA(fn);
ASSERT(attr # {0..MAX(SET)}, 101);
IF ~(KERNEL32.FileAttrReadOnly IN attr) THEN
s := SHORT(f.state); num := KERNEL32.GetTickCount(); n := 200;
REPEAT
GetTempFileName(path, new, num); INC(num); DEC(n);
nn := SHORT(new$);
IF KERNEL32.MoveFileA(fn, nn) # 0 THEN res := ok
ELSE res := KERNEL32.GetLastError()
END
UNTIL (res # fileExistsErr) & (res # alreadyExistsErr) & (res # 87) OR (n = 0);
IF res = ok THEN
f.state := hidden; f.name := new$
END
ELSE
res := writeProtectedErr
END
END
END Delete;
PROCEDURE FlushBuffer (f: File; i: INTEGER);
VAR buf: Buffer; res, h: INTEGER;
BEGIN
buf := f.bufs[i];
IF (buf # NIL) & buf.dirty THEN
IF f.ref = invalid THEN CreateFile(f, res) (* ASSERT(res = ok, 100) *) END;
IF f.ref # invalid THEN
h := 0; h := KERNEL32.SetFilePointer(f.ref, buf.org, h, 0);
IF (KERNEL32.WriteFile(f.ref, SYSTEM.ADR(buf.data), buf.len, h, 0) = 0) OR (h < buf.len) THEN
res := KERNEL32.GetLastError(); HALT(101)
END;
buf.dirty := FALSE; f.t := Kernel.Time()
END
END
END FlushBuffer;
(* File *)
PROCEDURE (f: File) NewReader (old: Files.Reader): Files.Reader;
VAR r: Reader;
BEGIN (* portable *)
ASSERT(f.state # closed, 20);
IF (old # NIL) & (old IS Reader) THEN r := old(Reader) ELSE NEW(r) END;
IF r.base # f THEN
r.base := f; r.buf := NIL; r.SetPos(0)
END;
r.eof := FALSE;
RETURN r
END NewReader;
PROCEDURE (f: File) NewWriter (old: Files.Writer): Files.Writer;
VAR w: Writer;
BEGIN (* portable *)
ASSERT(f.state # closed, 20); ASSERT(f.state # shared, 21);
IF (old # NIL) & (old IS Writer) THEN w := old(Writer) ELSE NEW(w) END;
IF w.base # f THEN
w.base := f; w.buf := NIL; w.SetPos(f.len)
END;
RETURN w
END NewWriter;
PROCEDURE (f: File) Length (): INTEGER;
BEGIN (* portable *)
RETURN f.len
END Length;
PROCEDURE (f: File) Flush;
VAR i: INTEGER;
BEGIN (* portable *)
i := 0; WHILE i # nofbufs DO FlushBuffer(f, i); INC(i) END
END Flush;
PROCEDURE GetPath (VAR fname, path: FullName);
VAR i: INTEGER;
BEGIN
path := fname$; i := 0;
WHILE path[i] # 0X DO INC(i) END;
WHILE (i > 0) & (path[i] # "\") & (path[i] # "/") & (path[i-1] # ":") DO DEC(i) END;
path[i] := 0X
END GetPath;
PROCEDURE CreateDir (VAR path: FullName; VAR res: INTEGER);
VAR sec: KERNEL32.SecurityAttributes; p: FullName; s: ShortName;
BEGIN
ASSERT(path # "", 100);
sec.len :=SIZE(KERNEL32.SecurityAttributes);
sec.secDesc := 0; sec.inherit := 0; s := SHORT(path$);
res := KERNEL32.CreateDirectoryA(s, sec);
IF res = 0 THEN res := KERNEL32.GetLastError() ELSE res := ok END;
IF (res = fileNotFoundErr) OR (res = pathNotFoundErr) THEN
GetPath(path, p);
CreateDir(p, res); (* recursive call *)
IF res = ok THEN
res := KERNEL32.CreateDirectoryA(s, sec);
IF res = 0 THEN res := KERNEL32.GetLastError() ELSE res := ok END
END
END
END CreateDir;
PROCEDURE CheckPath (VAR path: FullName; ask: BOOLEAN; VAR res: INTEGER);
VAR s: ARRAY 300 OF CHAR; t: ARRAY 32 OF CHAR;
ss: ARRAY 300 OF SHORTCHAR; st: ARRAY 32 OF SHORTCHAR;
BEGIN
IF ask THEN
IF MapParamString # NIL THEN
MapParamString("#Host:CreateDir", path, "", "", s);
MapParamString("#Host:MissingDirectory", "", "", "", t)
ELSE
s := path$; t := "Missing Directory"
END;
ss := SHORT(s$); st := SHORT(t$);
res := USER32.MessageBoxA(main, ss, st, {0, 6}) (* ok cancel, icon information *)
ELSE
res := 1
END;
IF res = 1 THEN CreateDir(path, res)
ELSIF res = 2 THEN res := cancel
END
END CheckPath;
PROCEDURE CheckDelete (VAR fname, path: FullName; ask: BOOLEAN; VAR res: INTEGER);
VAR s: ARRAY 300 OF CHAR; t: ARRAY 16 OF CHAR;
ss: ARRAY 300 OF SHORTCHAR; st: ARRAY 16 OF SHORTCHAR;
BEGIN
REPEAT
Delete(fname, path, res);
IF (res = writeProtectedErr) OR (res = sharingErr) OR (res = accessDeniedErr)
OR (res = netAccessDeniedErr)
THEN
IF ask THEN
IF MapParamString # NIL THEN
IF res = writeProtectedErr THEN
MapParamString("#Host:ReplaceWriteProtected", fname, 0DX, "", s)
ELSIF (res = accessDeniedErr) OR (res = netAccessDeniedErr) THEN
MapParamString("#Host:ReplaceAccessDenied", fname, 0DX, "", s)
ELSE
MapParamString("#Host:ReplaceInUse", fname, 0DX, "", s)
END;
MapParamString("#Host:FileError", "", "", "", t)
ELSE
s := fname$; t := "File Error"
END;
ss := SHORT(s$); st := SHORT(t$);
res := USER32.MessageBoxA(main, ss, st, {0, 2, 4, 5}); (* retry cancel, icon warning *)
IF res = 2 THEN res := cancel
ELSIF res = 4 THEN res := retry
END
ELSE
res := cancel
END
ELSE
res := ok
END
UNTIL res # retry
END CheckDelete;
PROCEDURE (f: File) Register (name: Files.Name; type: Files.Type; ask: BOOLEAN; OUT res: INTEGER);
VAR b: INTEGER; fname: FullName; fn, nn: ShortName;
BEGIN
ASSERT(f.state = new, 20); ASSERT(name # "", 21);
Append(f.loc.path, name, type, f.loc.maxLen, fname);
CheckDelete(fname, f.loc.path, ask, res);
ASSERT(res # 87, 100);
IF res = ok THEN
IF f.name = "" THEN
f.name := fname$;
OpenFile(create, f.name, f.ref, res);
IF res = ok THEN
f.state := exclusive; CloseFile(f, res);
fn := SHORT(f.name$);
b := KERNEL32.SetFileAttributesA(fn, {KERNEL32.FileAttrArchive})
END
ELSE
f.state := exclusive; CloseFile(f, res);
fn := SHORT(f.name$); nn := SHORT(fname$);
IF KERNEL32.MoveFileA(fn, nn) # 0 THEN
res := ok; f.name := fname$;
fn := SHORT(f.name$);
b := KERNEL32.SetFileAttributesA(fn, {KERNEL32.FileAttrArchive})
ELSE
res := KERNEL32.GetLastError();
ASSERT(res # 87, 101);
fn := SHORT(f.name$);
b := KERNEL32.DeleteFileA(fn)
END
END
END;
res := Error(res)
END Register;
PROCEDURE (f: File) Close;
VAR res: INTEGER;
BEGIN (* portable *)
IF f.state # closed THEN
(*
IF f.state = exclusive THEN
CloseFile(f, res)
ELSE
CloseFileHandle(f, res)
END
*)
CloseFile(f, res)
END
END Close;
(* Locator *)
PROCEDURE (loc: Locator) This* (IN path: ARRAY OF CHAR): Locator;
VAR new: Locator; i: INTEGER;
BEGIN
IF path = "" THEN
NEW(new); new^ := loc^
ELSIF path[1] = ":" THEN (* absolute path *)
new := NewLocator(path);
new.rootLen := 0
ELSIF (path[0] = "\") OR (path[0] = "/") THEN
IF (path[1] = "\") OR (path[1] = "/") THEN (* network path *)
new := NewLocator(path);
new.rootLen := 0
ELSE
NEW(new); new^ := dir.startup^;
new.res := invalidName;
RETURN new
END
ELSE
NEW(new); Append(loc.path, path, "", loc.maxLen, new.path);
i := 0; WHILE new.path[i] # 0X DO INC(i) END;
IF (new.path[i-1] = "/") OR (new.path[i-1] = "\") THEN new.path[i-1] := 0X END;
new.maxLen := loc.maxLen;
new.caseSens := loc.caseSens;
new.rootLen := loc.rootLen
END;
new.res := ok;
RETURN new
END This;
(* Reader *)
PROCEDURE (r: Reader) Base (): Files.File;
BEGIN (* portable *)
RETURN r.base
END Base;
(*
PROCEDURE (r: Reader) Available (): INTEGER;
BEGIN (* portable *)
ASSERT(r.base # NIL, 20);
RETURN r.base.len - r.org - r.offset
END Available;
*)
PROCEDURE (r: Reader) SetPos (pos: INTEGER);
VAR f: File; org, offset, i, count, res: INTEGER; buf: Buffer;
BEGIN
f := r.base; ASSERT(f # NIL, 20); ASSERT(f.state # closed, 25);
ASSERT(pos >= 0, 22); ASSERT(pos <= f.len, 21);
offset := pos MOD bufsize; org := pos - offset;
i := 0; WHILE (i # nofbufs) & (f.bufs[i] # NIL) & (org # f.bufs[i].org) DO INC(i) END;
IF i # nofbufs THEN
buf := f.bufs[i];
IF buf = NIL THEN (* create new buffer *)
NEW(buf); f.bufs[i] := buf; buf.org := -1
END
ELSE (* choose an existing buffer *)
f.swapper := (f.swapper + 1) MOD nofbufs;
FlushBuffer(f, f.swapper); buf := f.bufs[f.swapper]; buf.org := -1
END;
IF buf.org # org THEN
IF org + bufsize > f.len THEN buf.len := f.len - org ELSE buf.len := bufsize END;
count := buf.len;
IF count > 0 THEN
IF f.ref = invalid THEN CreateFile(f, res) (* ASSERT(res = ok, 100) *) END;
IF f.ref # invalid THEN
i := 0; i := KERNEL32.SetFilePointer(f.ref, org, i, 0);
IF (KERNEL32.ReadFile(f.ref, SYSTEM.ADR(buf.data), count, i, 0) = 0) OR (i < count) THEN
res := KERNEL32.GetLastError(); res := Error(res); HALT(101)
END;
f.t := Kernel.Time()
END
END;
buf.org := org; buf.dirty := FALSE
END;
r.buf := buf; r.org := org; r.offset := offset; r.eof := FALSE
(* 0<= r.org <= r.base.len *)
(* 0 <= r.offset < bufsize *)
(* 0 <= r.buf.len <= bufsize *)
(* r.offset <= r.base.len *)
(* r.offset <= r.buf.len *)
END SetPos;
PROCEDURE (r: Reader) Pos (): INTEGER;
BEGIN (* portable *)
ASSERT(r.base # NIL, 20);
RETURN r.org + r.offset
END Pos;
PROCEDURE (r: Reader) ReadByte (OUT x: BYTE);
BEGIN (* portable *)
IF (r.org # r.buf.org) OR (r.offset >= bufsize) THEN r.SetPos(r.org + r.offset) END;
IF r.offset < r.buf.len THEN
x := r.buf.data[r.offset]; INC(r.offset)
ELSE
x := 0; r.eof := TRUE
END
END ReadByte;
PROCEDURE (r: Reader) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER);
VAR from, to, count, restInBuf: INTEGER;
BEGIN (* portable *)
ASSERT(beg >= 0, 21);
IF len > 0 THEN
ASSERT(beg + len <= LEN(x), 23);
WHILE len # 0 DO
IF (r.org # r.buf.org) OR (r.offset >= bufsize) THEN r.SetPos(r.org + r.offset) END;
restInBuf := r.buf.len - r.offset;
IF restInBuf = 0 THEN r.eof := TRUE; RETURN
ELSIF restInBuf <= len THEN count := restInBuf
ELSE count := len
END;
from := SYSTEM.ADR(r.buf.data[r.offset]); to := SYSTEM.ADR(x) + beg;
SYSTEM.MOVE(from, to, count);
INC(r.offset, count); INC(beg, count); DEC(len, count)
END;
r.eof := FALSE
ELSE ASSERT(len = 0, 22)
END
END ReadBytes;
(* Writer *)
PROCEDURE (w: Writer) Base (): Files.File;
BEGIN (* portable *)
RETURN w.base
END Base;
PROCEDURE (w: Writer) SetPos (pos: INTEGER);
VAR f: File; org, offset, i, count, res: INTEGER; buf: Buffer;
BEGIN
f := w.base; ASSERT(f # NIL, 20); ASSERT(f.state # closed, 25);
ASSERT(pos >= 0, 22); ASSERT(pos <= f.len, 21);
offset := pos MOD bufsize; org := pos - offset;
i := 0; WHILE (i # nofbufs) & (f.bufs[i] # NIL) & (org # f.bufs[i].org) DO INC(i) END;
IF i # nofbufs THEN
buf := f.bufs[i];
IF buf = NIL THEN (* create new buffer *)
NEW(buf); f.bufs[i] := buf; buf.org := -1
END
ELSE (* choose an existing buffer *)
f.swapper := (f.swapper + 1) MOD nofbufs;
FlushBuffer(f, f.swapper); buf := f.bufs[f.swapper]; buf.org := -1
END;
IF buf.org # org THEN
IF org + bufsize > f.len THEN buf.len := f.len - org ELSE buf.len := bufsize END;
count := buf.len;
IF count > 0 THEN
IF f.ref = invalid THEN CreateFile(f, res) (* ASSERT(res = ok, 100) *) END;
IF f.ref # invalid THEN
i := 0; i := KERNEL32.SetFilePointer(f.ref, org, i, 0);
IF (KERNEL32.ReadFile(f.ref, SYSTEM.ADR(buf.data), count, i, 0) = 0) OR (i < count) THEN
res := KERNEL32.GetLastError(); res := Error(res); HALT(101)
END;
f.t := Kernel.Time()
END
END;
buf.org := org; buf.dirty := FALSE
END;
w.buf := buf; w.org := org; w.offset := offset
(* 0<= w.org <= w.base.len *)
(* 0 <= w.offset < bufsize *)
(* 0 <= w.buf.len <= bufsize *)
(* w.offset <= w.base.len *)
(* w.offset <= w.buf.len *)
END SetPos;
PROCEDURE (w: Writer) Pos (): INTEGER;
BEGIN (* portable *)
ASSERT(w.base # NIL, 20);
RETURN w.org + w.offset
END Pos;
PROCEDURE (w: Writer) WriteByte (x: BYTE);
BEGIN (* portable *)
ASSERT(w.base.state # closed, 25);
IF (w.org # w.buf.org) OR (w.offset >= bufsize) THEN w.SetPos(w.org + w.offset) END;
w.buf.data[w.offset] := x; w.buf.dirty := TRUE;
IF w.offset = w.buf.len THEN INC(w.buf.len); INC(w.base.len) END;
INC(w.offset)
END WriteByte;
PROCEDURE (w: Writer) WriteBytes (IN x: ARRAY OF BYTE; beg, len: INTEGER);
VAR from, to, count, restInBuf: INTEGER;
BEGIN (* portable *)
ASSERT(beg >= 0, 21); ASSERT(w.base.state # closed, 25);
IF len > 0 THEN
ASSERT(beg + len <= LEN(x), 23);
WHILE len # 0 DO
IF (w.org # w.buf.org) OR (w.offset >= bufsize) THEN w.SetPos(w.org + w.offset) END;
restInBuf := bufsize - w.offset;
IF restInBuf <= len THEN count := restInBuf ELSE count := len END;
from := SYSTEM.ADR(x) + beg; to := SYSTEM.ADR(w.buf.data[w.offset]);
SYSTEM.MOVE(from, to, count);
INC(w.offset, count); INC(beg, count); DEC(len, count);
IF w.offset > w.buf.len THEN INC(w.base.len, w.offset - w.buf.len); w.buf.len := w.offset END;
w.buf.dirty := TRUE
END
ELSE ASSERT(len = 0, 22)
END
END WriteBytes;
(* Directory *)
PROCEDURE (d: Directory) This (IN path: ARRAY OF CHAR): Files.Locator;
BEGIN
RETURN d.startup.This(path)
END This;
PROCEDURE (d: Directory) New (loc: Files.Locator; ask: BOOLEAN): Files.File;
VAR f: File; res: INTEGER; attr: SET; s: ShortName;
BEGIN
ASSERT(loc # NIL, 20); f := NIL; res := ok;
WITH loc: Locator DO
IF loc.path # "" THEN
s := SHORT(loc.path$);
attr := KERNEL32.GetFileAttributesA(s);
IF attr = {0..MAX(SET)} THEN (* error *)
res := KERNEL32.GetLastError();
IF (res = fileNotFoundErr) OR (res = pathNotFoundErr) THEN
IF loc.res = 76 THEN CreateDir(loc.path, res)
ELSE CheckPath(loc.path, ask, res)
END
ELSE res := pathNotFoundErr
END
ELSIF ~(KERNEL32.FileAttrDirectory IN attr) THEN res := fileExistsErr
END
END;
IF res = ok THEN
NEW(f); f.loc := loc; f.name := "";
f.state := new; f.swapper := -1; f.len := 0; f.ref := invalid
END
ELSE res := invalidNameErr
END;
loc.res := Error(res);
RETURN f
END New;
PROCEDURE (d: Directory) Temp (): Files.File;
VAR f: File;
BEGIN
NEW(f); f.loc := d.temp; f.name := "";
f.state := temp; f.swapper := -1; f.len := 0; f.ref := invalid;
RETURN f
END Temp;
PROCEDURE GetShadowDir (loc: Locator; OUT dir: FullName);
VAR i, j: INTEGER;
BEGIN
dir := startupDir$; i := startupLen; j := loc.rootLen;
WHILE loc.path[j] # 0X DO dir[i] := loc.path[j]; INC(i); INC(j) END;
dir[i] := 0X
END GetShadowDir;
PROCEDURE (d: Directory) Old (loc: Files.Locator; name: Files.Name; shrd: BOOLEAN): Files.File;
VAR res, i, j: INTEGER; f: File; ref: KERNEL32.Handle; fname: FullName; type: Files.Type; s: BYTE;
BEGIN
ASSERT(loc # NIL, 20); ASSERT(name # "", 21);
res := ok; f := NIL;
WITH loc: Locator DO
Append(loc.path, name, "", loc.maxLen, fname);
f := ThisFile(fname);
IF f # NIL THEN
IF ~shrd OR (f.state = exclusive) THEN loc.res := Error(sharingErr); RETURN NIL
ELSE loc.res := ok; RETURN f
END
END;
IF shrd THEN s := shared ELSE s := exclusive END;
OpenFile(s, fname, ref, res);
IF ((res = fileNotFoundErr) OR (res = pathNotFoundErr)) & (loc.rootLen > 0) THEN
GetShadowDir(loc, fname);
Append(fname, name, "", loc.maxLen, fname);
f := ThisFile(fname);
IF f # NIL THEN
IF ~shrd OR (f.state = exclusive) THEN loc.res := Error(sharingErr); RETURN NIL
ELSE loc.res := ok; RETURN f
END
END;
OpenFile(s, fname, ref, res)
END;
IF res = ok THEN
NEW(f); f.loc := loc;
f.swapper := -1; i := 0;
GetType(name, type);
f.InitType(type);
ASSERT(ref # invalid, 107);
f.ref := ref; f.name := fname$; f.state := s; f.t := Kernel.Time();
f.len := KERNEL32.GetFileSize(ref, j)
END
END;
loc.res := Error(res);
RETURN f
END Old;
PROCEDURE (d: Directory) Delete* (loc: Files.Locator; name: Files.Name);
VAR res: INTEGER; fname: FullName;
BEGIN
ASSERT(loc # NIL, 20);
WITH loc: Locator DO
Append(loc.path, name, "", loc.maxLen, fname);
Delete(fname, loc.path, res)
ELSE res := invalidNameErr
END;
loc.res := Error(res)
END Delete;
PROCEDURE (d: Directory) Rename* (loc: Files.Locator; old, new: Files.Name; ask: BOOLEAN);
VAR res, i: INTEGER; oldname, newname: FullName; f: File; on, nn, tn: ShortName; attr: SET;
BEGIN
ASSERT(loc # NIL, 20);
WITH loc: Locator DO
Append(loc.path, old, "", loc.maxLen, oldname); Append(loc.path, new, "", loc.maxLen, newname);
on := SHORT(oldname$); nn := SHORT(newname$);
attr := KERNEL32.GetFileAttributesA(on);
IF ORD(attr) # -1 THEN
f := ThisFile(oldname);
IF (f # NIL) & (f.ref # invalid) THEN res := KERNEL32.CloseHandle(f.ref); f.ref := invalid END;
IF Diff(oldname, newname, loc.caseSens) # 0 THEN
CheckDelete(newname, loc.path, ask, res);
IF res = ok THEN
IF KERNEL32.MoveFileA(on, nn) # 0 THEN
IF f # NIL THEN (* still in use => update file table *)
f.name := newname$
END
ELSE res := KERNEL32.GetLastError()
END
END
ELSE (* destination is same file as source *)
tn := on$; i := LEN(tn$) - 1;
REPEAT
tn[i] := SHORT(CHR(ORD(tn[i]) + 1));
IF KERNEL32.MoveFileA(on, tn) # 0 THEN res := ok
ELSE res := KERNEL32.GetLastError()
END
UNTIL (res # fileExistsErr) & (res # alreadyExistsErr) & (res # 87);
IF res = ok THEN
IF KERNEL32.MoveFileA(tn, nn) = 0 THEN res := KERNEL32.GetLastError() END
END
END
ELSE res := fileNotFoundErr
END
ELSE res := invalidNameErr
END;
loc.res := Error(res)
END Rename;
PROCEDURE (d: Directory) SameFile* (loc0: Files.Locator; name0: Files.Name;
loc1: Files.Locator; name1: Files.Name): BOOLEAN;
VAR p0, p1: FullName;
BEGIN
ASSERT(loc0 # NIL, 20); ASSERT(loc1 # NIL, 21);
WITH loc0: Locator DO Append(loc0.path, name0, "", loc0.maxLen, p0) END;
WITH loc1: Locator DO Append(loc1.path, name1, "", loc1.maxLen, p1) END;
RETURN Diff(p0, p1, loc0(Locator).caseSens) = 0
END SameFile;
PROCEDURE (d: Directory) FileList* (loc: Files.Locator): Files.FileInfo;
VAR i, res, diff: INTEGER; info, first, last: Files.FileInfo; s: FullName;
find: KERNEL32.Handle; fd: KERNEL32.FindData;
st: KERNEL32.SystemTime; ss: ShortName;
BEGIN
ASSERT(loc # NIL, 20);
first := NIL; last :=NIL;
WITH loc: Locator DO
Append(loc.path, wildcard, wildcard, loc.maxLen, s);
ss := SHORT(s$); find := KERNEL32.FindFirstFileA(ss, fd);
IF find # invalid THEN
REPEAT
IF ~(KERNEL32.FileAttrDirectory IN fd.attributes)
& (LEN(fd.name$) < LEN(info.name)) THEN
info := first; last := NIL; s := fd.name$;
WHILE (info # NIL) & (Diff(info.name, s, loc.caseSens) < 0) DO last := info; info := info.next END;
NEW(info);
info.name := fd.name$;
info.length := fd.sizeLow;
res := KERNEL32.FileTimeToSystemTime(fd.lastWrite, st);
info.modified.year := st.year;
info.modified.month := st.month;
info.modified.day := st.day;
info.modified.hour := st.hour;
info.modified.minute := st.minute;
info.modified.second := st.second;
info.attr := {};
IF KERNEL32.FileAttrHidden IN fd.attributes THEN INCL(info.attr, Files.hidden) END;
IF KERNEL32.FileAttrReadOnly IN fd.attributes THEN INCL(info.attr, Files.readOnly) END;
IF KERNEL32.FileAttrSystem IN fd.attributes THEN INCL(info.attr, Files.system) END;
IF KERNEL32.FileAttrArchive IN fd.attributes THEN INCL(info.attr, Files.archive) END;
s := fd.name$;
GetType(s, info.type);
IF last = NIL THEN info.next := first; first := info ELSE info.next := last.next; last.next := info END
END;
i := KERNEL32.FindNextFileA(find, fd)
UNTIL i = 0;
res := KERNEL32.GetLastError(); i := KERNEL32.FindClose(find)
ELSE res := KERNEL32.GetLastError()
END;
IF res = noMoreFilesErr THEN res := ok END;
(* check startup directory *)
IF (loc.rootLen > 0) & ((res = ok) OR (res = fileNotFoundErr) OR (res = pathNotFoundErr)) THEN
GetShadowDir(loc, s);
Append(s, wildcard, wildcard, loc.maxLen, s);
ss := SHORT(s$); find := KERNEL32.FindFirstFileA(ss, fd);
IF find # invalid THEN
REPEAT
IF ~(KERNEL32.FileAttrDirectory IN fd.attributes)
& (LEN(fd.name$) < LEN(info.name)) THEN
info := first; last := NIL; s := fd.name$;
IF info # NIL THEN diff := Diff(info.name, s, loc.caseSens) END;
WHILE (info # NIL) & (diff < 0) DO
last := info; info := info.next;
IF info # NIL THEN diff := Diff(info.name, s, loc.caseSens) END
END;
IF (info = NIL) OR (diff # 0) THEN
NEW(info);
info.name := fd.name$;
info.length := fd.sizeLow;
res := KERNEL32.FileTimeToSystemTime(fd.lastWrite, st);
info.modified.year := st.year;
info.modified.month := st.month;
info.modified.day := st.day;
info.modified.hour := st.hour;
info.modified.minute := st.minute;
info.modified.second := st.second;
info.attr := {};
IF KERNEL32.FileAttrHidden IN fd.attributes THEN INCL(info.attr, Files.hidden) END;
IF KERNEL32.FileAttrReadOnly IN fd.attributes THEN INCL(info.attr, Files.readOnly) END;
IF KERNEL32.FileAttrSystem IN fd.attributes THEN INCL(info.attr, Files.system) END;
IF KERNEL32.FileAttrArchive IN fd.attributes THEN INCL(info.attr, Files.archive) END;
s := fd.name$;
GetType(s, info.type);
IF last = NIL THEN info.next := first; first := info ELSE info.next := last.next; last.next := info END
END
END;
i := KERNEL32.FindNextFileA(find, fd)
UNTIL i = 0;
res := KERNEL32.GetLastError(); i := KERNEL32.FindClose(find)
ELSE res := KERNEL32.GetLastError()
END;
IF res = noMoreFilesErr THEN res := ok END
END;
loc.res := Error(res)
ELSE loc.res := invalidName
END;
RETURN first
END FileList;
PROCEDURE (d: Directory) LocList* (loc: Files.Locator): Files.LocInfo;
VAR i, res, diff: INTEGER; first, last, info: Files.LocInfo; s: FullName;
find: KERNEL32.Handle; fd: KERNEL32.FindData;
ss: ShortName;
BEGIN
ASSERT(loc # NIL, 20);
first := NIL; last :=NIL;
WITH loc: Locator DO
Append(loc.path, wildcard, wildcard, loc.maxLen, s);
ss := SHORT(s$); find := KERNEL32.FindFirstFileA(ss, fd);
IF find # invalid THEN
REPEAT
IF (KERNEL32.FileAttrDirectory IN fd.attributes) & (fd.name[0] # ".") & (LEN(fd.name$) < LEN(info.name))
THEN
info := first; last := NIL; s := fd.name$;
WHILE (info # NIL) & (Diff(info.name, s, loc.caseSens) < 0) DO last := info; info := info.next END;
NEW(info);
info.name := fd.name$;
info.attr := {};
IF KERNEL32.FileAttrHidden IN fd.attributes THEN INCL(info.attr, Files.hidden) END;
IF KERNEL32.FileAttrReadOnly IN fd.attributes THEN INCL(info.attr, Files.readOnly) END;
IF KERNEL32.FileAttrSystem IN fd.attributes THEN INCL(info.attr, Files.system) END;
IF KERNEL32.FileAttrArchive IN fd.attributes THEN INCL(info.attr, Files.archive) END;
IF last = NIL THEN info.next := first; first := info ELSE info.next := last.next; last.next := info END
END;
i := KERNEL32.FindNextFileA(find, fd)
UNTIL i = 0;
res := KERNEL32.GetLastError(); i := KERNEL32.FindClose(find)
ELSE res := KERNEL32.GetLastError()
END;
IF res = noMoreFilesErr THEN res := ok END;
(* check startup directory *)
IF (loc.rootLen > 0) & ((res = ok) OR (res = fileNotFoundErr) OR (res = pathNotFoundErr)) THEN
GetShadowDir(loc, s);
Append(s, wildcard, wildcard, loc.maxLen, s);
ss := SHORT(s$); find := KERNEL32.FindFirstFileA(ss, fd);
IF find # invalid THEN
REPEAT
IF (KERNEL32.FileAttrDirectory IN fd.attributes)
& (fd.name[0] # ".") & (LEN(fd.name$) < LEN(info.name))
THEN
info := first; last := NIL; s := fd.name$;
IF info # NIL THEN diff := Diff(info.name, s, loc.caseSens) END;
WHILE (info # NIL) & (diff < 0) DO
last := info; info := info.next;
IF info # NIL THEN diff := Diff(info.name, s, loc.caseSens) END
END;
IF (info = NIL) OR (diff # 0) THEN
NEW(info);
info.name := fd.name$;
info.attr := {};
IF KERNEL32.FileAttrHidden IN fd.attributes THEN INCL(info.attr, Files.hidden) END;
IF KERNEL32.FileAttrReadOnly IN fd.attributes THEN INCL(info.attr, Files.readOnly) END;
IF KERNEL32.FileAttrSystem IN fd.attributes THEN INCL(info.attr, Files.system) END;
IF KERNEL32.FileAttrArchive IN fd.attributes THEN INCL(info.attr, Files.archive) END;
IF last = NIL THEN info.next := first; first := info ELSE info.next := last.next; last.next := info END
END
END;
i := KERNEL32.FindNextFileA(find, fd)
UNTIL i = 0;
res := KERNEL32.GetLastError(); i := KERNEL32.FindClose(find)
ELSE res := KERNEL32.GetLastError()
END;
IF res = noMoreFilesErr THEN res := ok END
END;
loc.res := Error(res)
ELSE loc.res := invalidName
END;
RETURN first
END LocList;
PROCEDURE (d: Directory) GetFileName (name: Files.Name; type: Files.Type; OUT filename: Files.Name);
BEGIN
Append("", name, type, LEN(filename), filename)
END GetFileName;
(** Miscellaneous **)
PROCEDURE (VAR id: Counter) Identified (): BOOLEAN;
VAR f: File;
BEGIN
f := id.obj(File);
IF f.state # closed THEN INC(id.count) END;
RETURN FALSE
END Identified;
PROCEDURE NofFiles* (): INTEGER;
VAR p: ANYPTR; cnt: Counter;
BEGIN
cnt.typ := SYSTEM.TYP(File);
cnt.count := 0; p := Kernel.ThisFinObj(cnt);
RETURN cnt.count
END NofFiles;
PROCEDURE GetModDate* (f: Files.File; VAR year, month, day, hour, minute, second: INTEGER);
VAR res: INTEGER; ft: KERNEL32.FileTime; st: KERNEL32.SystemTime;
BEGIN
ASSERT(f IS File, 20);
res := KERNEL32.GetFileTime(f(File).ref, NIL, NIL, ft);
res := KERNEL32.FileTimeToSystemTime(ft, st);
year := st.year; month := st.month; day := st.day;
hour := st.hour; minute := st.minute; second := st.second
END GetModDate;
PROCEDURE SetRootDir* (path: ARRAY OF CHAR);
VAR i: INTEGER;
BEGIN
dir.startup := NewLocator(path);
dir.startup.rootLen := 0; i := 0;
WHILE startupDir[i] # 0X DO INC(i) END;
startupLen := i
END SetRootDir;
(* обработка командной строки в том числе. "-" заменяется на "/", "--" заменится на "//" ! *)
PROCEDURE GetName (VAR p: KERNEL32.StringPtr; VAR i: INTEGER; VAR name, opt: FullName);
VAR ch, tch: CHAR; j: INTEGER;
BEGIN
j := 0; ch := p[i]; tch := " ";
WHILE ch = " " DO INC(i); ch := p[i] END;
IF (ch = "'") OR (ch = '"') THEN tch := ch; INC(i); ch := p[i] END;
WHILE (ch >= " ") & (ch # tch) DO
name[j] := ch;
(*
IF (ch >= "a") & (ch <= "z") OR ( (ch >= "а") & (ch <="я") ) OR (ch = "ё") THEN
ch := National.Cap(ch)
ELSIF ch = "-" THEN ch := "/" (* вполне допустимое имя файла ааа-ббб будет исправлено на ааа/ббб ??*)
END;
*)
ch := Ch.Cap(ch); (* меняет только маленькие буквы *)
IF ch = "-" THEN ch := "/" END;
opt[j] := ch; INC(j); INC(i); ch := p[i]
END;
IF ch > " " THEN INC(i); ch := p[i] END;
WHILE (ch # 0X) & (ch <= " ") DO INC(i); ch := p[i] END;
name[j] := 0X; opt[j] := 0X
END GetName;
PROCEDURE Init;
VAR res, res1, i, j: INTEGER; path, opt: FullName; attr: SET; p: KERNEL32.StringPtr; s0, s: ShortName;
find: KERNEL32.Handle; fd: KERNEL32.FindData;
BEGIN
wildcard := "*"; NEW(dir);
res := KERNEL32.GetModuleFileNameA(0, s, LEN(s)); path := s$;
GetPath(path, startupDir);
dir.startup := NewLocator(startupDir);
dir.startup.rootLen := 0; i := 0;
WHILE startupDir[i] # 0X DO INC(i) END;
startupLen := i;
find := KERNEL32.FindFirstFileA(s, fd);
IF find # invalid THEN
appName := fd.name$; res := KERNEL32.FindClose(find)
ELSE
INC(i); j := 0;
WHILE s[i] # 0X DO appName[j] := s[i]; INC(i); INC(j) END
END;
i := 0; j := -1;
WHILE appName[i] # 0X DO
IF appName[i] = "." THEN j := i END;
INC(i)
END;
IF j > 0 THEN appName[j] := 0X END;
p := KERNEL32.GetCommandLineA(); i := 0; res := 1;
REPEAT
GetName(p, i, path, opt);
IF opt = "/USE" THEN
GetName(p, i, path, opt); s0 := SHORT(path$);
res1 := WinApi.ExpandEnvironmentStringsA(s0, s, LEN(s) - 2);
IF (res1 = 0) OR (res1 > LEN(s) - 2) THEN s := s0 ELSE path := s$ END;
attr := KERNEL32.GetFileAttributesA(s);
IF (attr # {0..MAX(SET)}) & (KERNEL32.FileAttrDirectory IN attr) THEN res := 0
ELSIF (path[1] = ":") & ((path[2] = 0X) OR (path[2] = "\") & (path[3] = 0X))
& (KERNEL32.GetDriveTypeA(s) >= 2) THEN res := 0
END
END
UNTIL (res = 0) OR (p[i] < " ");
IF serverVersion & (res = 0) THEN
i := 0; WHILE path[i] # 0X DO INC(i) END;
IF (path[i-1] = "/") OR (path[i-1] = "\") THEN DEC(i); path[i] := 0X END;
dir.startup := NewLocator(path);
dir.startup.rootLen := SHORT(i)
END;
res := KERNEL32.GetTempPathA(LEN(s), s); path := s$;
dir.temp := NewLocator(path);
Files.SetDir(dir);
main := 0
END Init;
BEGIN
Init
END HostFiles.
| Host/Mod/Files.odc |
MODULE HostFonts; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20051015, Ilya Ermakov, corrected WinApi.CreateFont - to russian CHARSET param
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT SYSTEM, KERNEL32, GDI32, USER32, Kernel, Fonts, HostRegistry, i21sysCharacters;
CONST
defSize = 8 * Fonts.point; (* size of default font *)
(*
grid = 16384; (* true type design grid *)
*)
grid = 4096;
figureSpace = 8FX;
TYPE
WTab = ARRAY 256 OF INTEGER;
DevFont* = POINTER TO RECORD
unit-: INTEGER;
id-: GDI32.Handle;
next-: DevFont;
noGap-: BOOLEAN;
wtab-: WTab (* rastered width in pixels *)
END;
Font* = POINTER TO RECORD (Fonts.Font)
asc-, dsc-, w-: INTEGER;
dev-: DevFont; (* rastered fonts *)
wtab-, ftab-, ttab-: WTab; (* univeral width in units *)
id-: GDI32.Handle; (* font used for metric*)
alias-: Fonts.Typeface; (* alias # typeface & typeface # "*" == alien font *)
a, b: INTEGER (* coefficients for metric *)
END;
Directory = POINTER TO RECORD (Fonts.Directory) END;
Identifier = RECORD (Kernel.Identifier)
tface: Fonts.Typeface;
size: INTEGER;
style: SET;
weight: INTEGER;
END;
Counter = RECORD (Kernel.Identifier)
count: INTEGER
END;
Traverser = RECORD (Kernel.Identifier)
END;
Par = RECORD [untagged]
first, last: Fonts.TypefaceInfo
END;
ParPtr = POINTER TO Par;
VAR
sysFont-, defFont-, dlgFont-, dlgBoldFont-: Font;
isUnicode-, useTTMetric-: BOOLEAN;
dfName, dgName: Fonts.Typeface;
dfSize, dgSize, dgWght: INTEGER;
dgStyle: SET;
dir: Directory;
defUnit: INTEGER; (* screen resolution *)
dc: USER32.Handle;
fontId: GDI32.Handle;
(* width tab setup *)
PROCEDURE NewDevFont (
typeface: ARRAY OF CHAR; size, unit: INTEGER; style: SET; weight: INTEGER
): DevFont;
VAR df: DevFont; res, it, ul, so, i: INTEGER; s: ARRAY LEN(Fonts.Typeface) OF SHORTCHAR;
BEGIN
IF size = 8 * Fonts.point THEN INC(size, Fonts.point DIV 4) END;
it := 0; ul := 0; so := 0;
IF Fonts.italic IN style THEN it := 1 END;
IF Fonts.underline IN style THEN ul := 1 END;
IF Fonts.strikeout IN style THEN so := 1 END;
NEW(df); df.unit := unit; df.next := NIL;
s := SHORT(typeface$);
df.id := GDI32.CreateFontA(-((size + unit DIV 2) DIV unit), 0, 0, 0, weight, it, ul, so, i21sysCharacters.HostFontsCHARSET, 0, 2, 1, 4, s);
RETURN df
END NewDevFont;
PROCEDURE GetRasterWidth (dc: GDI32.Handle; VAR wtab: WTab);
VAR res, i, x: INTEGER; str: ARRAY 4 OF SHORTCHAR; p: GDI32.Point;
BEGIN
res := GDI32.GetTextExtentPoint32A(dc, "x", 1, p);
IF res = 0 THEN (* win32s *)
res := GDI32.GetTextExtentPointA(dc, "x", 1, p)
END;
i := 0; str := " x"; x := p.x;
WHILE i < 256 DO
str[0] := SHORT(CHR(i));
res := GDI32.GetTextExtentPoint32A(dc, str, 2, p);
IF res = 0 THEN (* win32s *)
res := GDI32.GetTextExtentPointA(dc, str, 2, p)
END;
wtab[i] := p.x - x; INC(i)
END
END GetRasterWidth;
PROCEDURE SetupWTabs (f: Font);
VAR res, a, b, asc, dsc, max, x, i: INTEGER; tm: GDI32.TextMetric;
df: DevFont; abc: ARRAY 256 OF GDI32.ABC; dc, old: USER32.Handle;
BEGIN
dc := USER32.GetDC(0);
old := GDI32.SelectObject(dc, f.dev.id);
res := GDI32.GetTextMetricsA(dc, tm);
IF useTTMetric & ODD(tm.pitchAndFamily DIV 4) THEN (* use true type metric *)
df := NewDevFont(f.alias, grid, 1, f.style, f.weight);
res := GDI32.SelectObject(dc, df.id);
res := GDI32.GetTextMetricsA(dc, tm);
a := f.size MOD grid; b := f.size DIV grid; f.id := df.id;
res := GDI32.GetCharABCWidthsA(dc, 0, 255, abc);
IF res # 0 THEN
i := 0; max := 0;
WHILE i < 256 DO
x := -abc[i].a;
IF x > 0 THEN f.ftab[i] := x * a DIV grid + x * b END;
x := -abc[i].c;
IF x > 0 THEN f.ttab[i] := x * a DIV grid + x * b END;
x := abc[i].a + abc[i].b + abc[i].c; x := x * a DIV grid + x * b;
IF x > max THEN max := x END;
f.wtab[i] := x; INC(i)
END
ELSE
max := f.w
END
ELSE (* use screen metric *)
a := 0; b := defUnit; f.id := f.dev.id;
GetRasterWidth(dc, f.wtab);
(*
res := GDI32.GetCharWidth32A(dc, 0, 255, f.wtab);
IF res = 0 THEN (* win32s *)
res := GDI32.GetCharWidthA(dc, 0, 255, f.wtab)
END;
*)
i := 0; max := 0;
WHILE i < 256 DO
x := f.wtab[i] * b;
IF x > max THEN max := x END;
f.wtab[i] := x; INC(i)
END
END;
f.wtab[ORD(figureSpace)] := f.wtab[ORD("0")];
f.ftab[ORD(figureSpace)] := f.ftab[ORD("0")];
f.ttab[ORD(figureSpace)] := f.ttab[ORD("0")];
x := tm.ascent + tm.extLeading; f.asc := x * a DIV grid + x * b;
f.dsc := tm.descent * a DIV grid + tm.descent * b;
f.w := max; f.a := a; f.b := b;
res := GDI32.SelectObject(dc, old);
res := USER32.ReleaseDC(0, dc)
END SetupWTabs;
PROCEDURE Cleanup (f: Font);
VAR res: INTEGER; df: DevFont;
BEGIN
df := f.dev;
IF f.id # df.id THEN res := GDI32.DeleteObject(f.id) END;
WHILE df # NIL DO
res := GDI32.DeleteObject(df.id);
df := df.next
END;
f.id := 0; f.dev := NIL
END Cleanup;
(* width methods for unicode *)
PROCEDURE (f: Font) wTab* (dc: USER32.Handle; ch: CHAR): INTEGER, NEW;
VAR res, w: INTEGER; abc: ARRAY 1 OF GDI32.ABC; wt: ARRAY 1 OF INTEGER;
BEGIN
ch := i21sysCharacters.UnicodeOf(ch);
res := GDI32.GetCharABCWidthsW(dc, ORD(ch), ORD(ch), abc);
IF res # 0 THEN
w := abc[0].a + abc[0].b + abc[0].c;
w := w * f.a DIV grid + w * f.b
ELSE
res := GDI32.GetCharWidth32W(dc, ORD(ch), ORD(ch), wt);
IF res # 0 THEN w := wt[0] * f.a DIV grid + wt[0] * f.b
ELSE
res := GDI32.GetCharWidthW(dc, ORD(ch), ORD(ch), wt);
IF res # 0 THEN w := wt[0] * f.a DIV grid + wt[0] * f.b
ELSE w := f.wtab[1]
END
END
END;
RETURN w
END wTab;
PROCEDURE (f: Font) fTab* (dc: USER32.Handle; ch: CHAR): INTEGER, NEW;
VAR res, w: INTEGER; abc: ARRAY 1 OF GDI32.ABC;
BEGIN
ch := i21sysCharacters.UnicodeOf(ch);
res := GDI32.GetCharABCWidthsW(dc, ORD(ch), ORD(ch), abc);
IF (res # 0) & (abc[0].a < 0) THEN
w := -abc[0].a;
w := w * f.a DIV grid + w * f.b
ELSE w := 0
END;
RETURN w
END fTab;
PROCEDURE (f: Font) tTab* (dc: USER32.Handle; ch: CHAR): INTEGER, NEW;
VAR res, w: INTEGER; abc: ARRAY 1 OF GDI32.ABC;
BEGIN
ch := i21sysCharacters.UnicodeOf(ch);
res := GDI32.GetCharABCWidthsW(dc, ORD(ch), ORD(ch), abc);
IF (res # 0) & (abc[0].c < 0) THEN
w := -abc[0].c;
w := w * f.a DIV grid + w * f.b
ELSE w := 0
END;
RETURN w
END tTab;
(** Font **)
PROCEDURE (f: Font) GetBounds* (OUT asc, dsc, w: INTEGER);
BEGIN
asc := f.asc; dsc := f.dsc; w := f.w
END GetBounds;
PROCEDURE (f: Font) SStringWidth* (IN s: ARRAY OF SHORTCHAR): INTEGER;
VAR i, d, w: INTEGER; ch: CHAR;
BEGIN
w := 0;
IF s # "" THEN
i := 0; ch := s[0];
WHILE ch # 0X DO INC(w, f.wtab[ORD(ch)]); INC(i); ch := s[i] END;
w := w + f.ftab[ORD(s[0])] + f.ttab[ORD(s[i-1])]
END;
RETURN w
END SStringWidth;
PROCEDURE (f: Font) StringWidth* (IN s0: ARRAY OF CHAR): INTEGER;
VAR res, i, d, w: INTEGER; lc: CHAR; ch: SHORTCHAR;
str: ARRAY 1024 OF SHORTCHAR; dc, old: USER32.Handle;
s: ARRAY 1024 OF CHAR;
BEGIN
i21sysCharacters.ToUnicode(s0, s);
IF isUnicode THEN
dc := USER32.GetDC(0);
old := GDI32.SelectObject(dc, f.id);
w := 0;
IF s[0] # 0X THEN
i := 0; lc := s[0];
WHILE lc # 0X DO INC(w, f.wTab(dc, lc)); INC(i); lc := s[i] END;
w := w + f.fTab(dc, s[0]) + f.tTab(dc, s[i-1])
END;
res := GDI32.SelectObject(dc, old);
res := USER32.ReleaseDC(0, dc);
RETURN w
ELSE
ch := 1X;
res := KERNEL32.WideCharToMultiByte(0, {}, s, -1, str, LEN(str), ch, NIL);
str[res] := 0X;
RETURN f.SStringWidth(str)
END
END StringWidth;
PROCEDURE (f: Font) IsAlien* (): BOOLEAN;
BEGIN
RETURN (f.typeface # Fonts.default) & (f.alias # f.typeface)
END IsAlien;
PROCEDURE (f: Font) FINALIZE-;
BEGIN
Cleanup(f)
END FINALIZE;
(* Directory *)
PROCEDURE SetupDevFont (dc: USER32.Handle; df: DevFont);
VAR res: INTEGER; abc: ARRAY 1 OF GDI32.ABC;
BEGIN
res := GDI32.GetCharABCWidthsA(dc, ORD("H"), ORD("H"), abc);
IF res # 0 THEN (* true type *)
df.noGap := (res # 0) & (abc[0].a <= 0);
res := GDI32.GetCharWidth32A(dc, 0, 255, df.wtab);
IF res = 0 THEN (* win32s *)
res := GDI32.GetCharWidthA(dc, 0, 255, df.wtab)
END
ELSE (* raster *)
df.noGap := FALSE;
GetRasterWidth(dc, df.wtab)
END;
df.wtab[ORD(figureSpace)] := df.wtab[ORD("0")]
END SetupDevFont;
PROCEDURE InsertDevFont* (dc: USER32.Handle; font: Font; VAR df: DevFont; unit: INTEGER);
VAR res: INTEGER;
BEGIN
df := NewDevFont(font.alias, font.size, unit, font.style, font.weight);
res := GDI32.SelectObject(dc, df.id);
SetupDevFont(dc, df);
df.next := font.dev.next; font.dev.next := df (* screen font remains at list head *)
END InsertDevFont;
PROCEDURE Setup (f: Font; typeface: ARRAY OF CHAR; size: INTEGER; style: SET; weight: INTEGER);
VAR res: INTEGER; tm: GDI32.TextMetric; name: Fonts.Typeface; dc, old: USER32.Handle;
s: ARRAY LEN(Fonts.Typeface) OF SHORTCHAR;
BEGIN
dc := USER32.GetDC(0);
old := GDI32.SelectObject(dc, f.dev.id);
res := GDI32.GetTextFaceA(dc, LEN(s), s); name := s$;
res := GDI32.GetTextMetricsA(dc, tm);
f.alias := name$;
IF typeface = Fonts.default THEN
name := Fonts.default
ELSIF (typeface = "") OR (typeface = ".") THEN
size := ((tm.height - tm.intLeading) * defUnit + (Fonts.point DIV 2)) DIV Fonts.point * Fonts.point;
(* IF size = 8 * Fonts.point THEN INC(size, Fonts.point DIV 4) END; *)
weight := SHORT(tm.weight);
IF typeface = "." THEN name := Fonts.default END;
IF tm.italic # 0 THEN INCL(style, Fonts.italic) END;
IF tm.underlined # 0 THEN INCL(style, Fonts.underline) END;
IF tm.struckOut # 0 THEN INCL(style, Fonts.strikeout) END;
ELSIF name # typeface THEN
f.dev := NewDevFont(dfName, size, defUnit, style, weight);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, f.dev.id));
f.alias := dfName$;
name := typeface$
END;
IF size # 0 THEN
SetupDevFont(dc, f.dev);
IF f.size = 0 THEN f.Init(name, size, style, weight) END;
res := GDI32.SelectObject(dc, old);
res := USER32.ReleaseDC(0, dc);
SetupWTabs(f)
END;
ASSERT(f.size > 0)
END Setup;
PROCEDURE (VAR id: Identifier) Identified (): BOOLEAN;
VAR f: Font;
BEGIN
f := id.obj(Font);
RETURN (f.typeface = id.tface) & (f.size = id.size) & (f.style = id.style) & (f.weight = id.weight)
END Identified;
PROCEDURE (d: Directory) This (typeface: Fonts.Typeface; size: INTEGER; style: SET; weight: INTEGER): Font;
VAR res: INTEGER; f: Font; i: Identifier; p: ANYPTR;
BEGIN
ASSERT(size > 0, 20);
style := style * {Fonts.italic, Fonts.underline, Fonts.strikeout};
size := size - size MOD Fonts.point;
(* IF size = 8 * Fonts.point THEN INC(size, Fonts.point DIV 4) END; *)
IF typeface = "L Frutiger Light" THEN typeface := "Frutiger 45 Light"
ELSIF typeface = "R Frutiger Roman" THEN typeface := "Frutiger 55 Roman"
ELSIF typeface = "B Frutiger Black" THEN typeface := "Frutiger 55 Roman"; weight := Fonts.bold
END;
i.tface := typeface$; i.size := size; i.style := style; i.weight := weight;
i.typ := SYSTEM.TYP(Font);
p := Kernel.ThisFinObj(i);
IF p # NIL THEN f := p(Font)
ELSE (* not found in cache, search Windows fonts *)
IF typeface = "" THEN
f := sysFont
ELSE
NEW(f);
IF typeface = Fonts.default THEN
f.dev := NewDevFont(dfName, size, defUnit, style, weight)
ELSE
f.dev := NewDevFont(typeface, size, defUnit, style, weight)
END;
Setup(f, typeface, size, style, weight)
END
END;
RETURN f
END This;
PROCEDURE (d: Directory) Default (): Fonts.Font;
BEGIN
RETURN defFont
END Default;
PROCEDURE CallBack (
VAR elf: GDI32.EnumLogFont; VAR ntm: GDI32.NewTextMetric; type, par: INTEGER
): INTEGER;
VAR p: ParPtr; info: Fonts.TypefaceInfo;
BEGIN
p := SYSTEM.VAL(ParPtr, par);
NEW(info);
info.typeface := elf.logFont.faceName$;
IF p.last = NIL THEN p.first := info ELSE p.last.next := info END;
p.last := info;
RETURN 1
END CallBack;
PROCEDURE (d: Directory) TypefaceList* (): Fonts.TypefaceInfo;
VAR res: INTEGER; dc: GDI32.Handle; par: Par;
BEGIN
dc := USER32.GetDC(0);
par.first := NIL; par.last := NIL;
res := GDI32.EnumFontFamiliesA(dc, NIL, CallBack, SYSTEM.ADR(par));
res := USER32.ReleaseDC(0, dc);
RETURN par.first
END TypefaceList;
(** miscellaneous **)
PROCEDURE (VAR id: Counter) Identified (): BOOLEAN;
BEGIN
INC(id.count); RETURN FALSE
END Identified;
PROCEDURE NofFonts* (): INTEGER;
VAR p: ANYPTR; cnt: Counter;
BEGIN
cnt.typ := SYSTEM.TYP(Font); cnt.count := 0; p := Kernel.ThisFinObj(cnt);
RETURN cnt.count
END NofFonts;
PROCEDURE InstallDir*;
BEGIN
Fonts.SetDir(dir)
END InstallDir;
PROCEDURE (VAR id: Traverser) Identified (): BOOLEAN;
VAR f: Font;
BEGIN
f := id.obj(Font);
IF (f.typeface = Fonts.default) & (f.alias # dfName) THEN
Cleanup(f);
f.dev := NewDevFont(dfName, f.size, defUnit, f.style, f.weight);
Setup(f, Fonts.default, f.size, f.style, f.weight)
ELSE
SetupWTabs(f)
END;
RETURN FALSE
END Identified;
PROCEDURE SetTTMetric* (on: BOOLEAN);
VAR t: Traverser; p: ANYPTR;
BEGIN
IF useTTMetric # on THEN
useTTMetric := on;
t.typ := SYSTEM.TYP(Font); p := Kernel.ThisFinObj(t);
HostRegistry.WriteBool("FontTTMetric", useTTMetric)
END
END SetTTMetric;
PROCEDURE SetDefaultFont* (tf: Fonts.Typeface; size: INTEGER);
VAR s: ARRAY LEN(Fonts.Typeface) OF SHORTCHAR; t: Traverser; p: ANYPTR;
BEGIN
ASSERT(tf # "", 20); ASSERT(size > 0, 21);
IF tf = Fonts.default THEN tf := dfName$ END;
IF (dfName # tf) OR (dfSize # size) THEN
dfName := tf$; dfSize := size;
t.typ := SYSTEM.TYP(Font); p := Kernel.ThisFinObj(t);
defFont := dir.This(Fonts.default, dfSize, {}, Fonts.normal);
s := SHORT(dfName$);
HostRegistry.WriteString("DefFontName", s);
HostRegistry.WriteInt("DefFontSize", dfSize)
END
END SetDefaultFont;
PROCEDURE SetDialogFont* (tf: Fonts.Typeface; size: INTEGER; style: SET; weight: INTEGER);
VAR s: ARRAY LEN(Fonts.Typeface) OF SHORTCHAR; i: INTEGER;
BEGIN
ASSERT(tf # "", 20); ASSERT(size > 0, 21);
IF (dgName # tf) OR (dgSize # size) OR (dgStyle # style) OR (dgWght # weight) THEN
dgName := tf$; dgSize := size; dgStyle := style; dgWght := weight;
dlgFont := dir.This(dgName, dgSize, dgStyle, dgWght);
dlgBoldFont := dir.This(dgName, dgSize, dgStyle, Fonts.bold);
s := SHORT(dgName$);
HostRegistry.WriteString("DlgFontName", s);
HostRegistry.WriteInt("DlgFontSize", dgSize);
i := 0;
IF Fonts.italic IN dgStyle THEN INC(i, 1) END;
IF Fonts.underline IN dgStyle THEN INC(i, 2) END;
IF Fonts.strikeout IN dgStyle THEN INC(i, 4) END;
IF dgWght > Fonts.normal THEN INC(i, 8) END;
HostRegistry.WriteInt("DlgFontStyle", i);
END
END SetDialogFont;
PROCEDURE Init;
VAR res, i: INTEGER; s: ARRAY 2 OF CHAR; df: ARRAY LEN(Fonts.Typeface) OF SHORTCHAR;
BEGIN
df := ""; dfSize := 0; dgSize := 0; dgStyle := {}; dgWght := Fonts.normal; i := 0;
HostRegistry.ReadString("DefFontName", df, res); dfName := df$;
HostRegistry.ReadInt("DefFontSize", dfSize, res);
HostRegistry.ReadString("DlgFontName", df, res); dgName := df$;
HostRegistry.ReadInt("DlgFontSize", dgSize, res);
HostRegistry.ReadInt("DlgFontStyle", i, res);
IF ODD(i) THEN INCL(dgStyle, Fonts.italic) END;
IF ODD(i DIV 2) THEN INCL(dgStyle, Fonts.underline) END;
IF ODD(i DIV 4) THEN INCL(dgStyle, Fonts.strikeout) END;
IF ODD(i DIV 8) THEN dgWght := Fonts.bold END;
HostRegistry.ReadBool("FontTTMetric", useTTMetric, res);
NEW(dir); Fonts.SetDir(dir);
dc := USER32.GetDC(0);
defUnit := 72 * Fonts.point DIV GDI32.GetDeviceCaps(dc, GDI32.LogPixelsY);
isUnicode := GDI32.TextOutW(dc, 0, 0, s, 0) # 0;
res := USER32.ReleaseDC(0, dc);
NEW(sysFont); NEW(sysFont.dev); sysFont.dev.unit := defUnit; sysFont.dev.next := NIL;
sysFont.dev.id := GDI32.GetStockObject(GDI32.SystemFont);
Setup(sysFont, "", 0, {}, 0);
NEW(defFont); NEW(defFont.dev); defFont.dev.unit := defUnit; defFont.dev.next := NIL;
IF (dfName # "") & (dfSize > 5 * Fonts.point) & (dfSize < 100 * Fonts.point) THEN
defFont := dir.This(Fonts.default, dfSize, {}, Fonts.normal)
ELSE
i := (defSize + defUnit DIV 2) DIV defUnit;
IF i < 11 THEN i := 11 END;
(* Исправлена ошибка в значении параметра CHARSET - Ермаков И.Е. *)
defFont.dev.id := GDI32.CreateFontA(-i, 0, 0, 0, Fonts.normal, 0, 0, 0, i21sysCharacters.HostFontsCHARSET, 7, 2, 1, 38, "");
Setup(defFont, ".", 0, {}, 0);
dfName := defFont.alias$
END;
NEW(dlgFont); NEW(dlgFont.dev); dlgFont.dev.unit := defUnit; dlgFont.dev.next := NIL;
IF (dgName # "") & (dgSize > 5 * Fonts.point) & (dgSize < 100 * Fonts.point) THEN
dlgFont := dir.This(dgName, dgSize, dgStyle, dgWght);
dlgBoldFont := dir.This(dgName, dgSize, dgStyle, Fonts.bold)
ELSE
dlgFont.dev.id := GDI32.GetStockObject(GDI32.AnsiVarFont);
Setup(dlgFont, "", 0, {}, 0);
dgName := dlgFont.alias$;
dlgBoldFont := dir.This(dlgFont.typeface, dlgFont.size, dlgFont.style, Fonts.bold);
IF KERNEL32.GetVersion() MOD 256 < 4 THEN dlgFont := dlgBoldFont END
END;
END Init;
BEGIN
Init
END HostFonts.
| Host/Mod/Fonts.odc |
MODULE HostMail;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- it is intended that CheckDll is called inside the procedures SendNote/SendDocument and not in the guards.
There were suspicious/unsolvable problems with these calls (under Windows 3.11) which lead to nasty
error messages. As a consequence, the menu items are always enabled before they are executed for the first time.
"
**)
IMPORT
SYSTEM, WinCmc, WinApi,
Files, Dialog, Converters, Views, Windows,
TextModels, TextViews, TextControllers, HostFiles;
CONST
tempFile = "_mail_.odc";
VAR
tempLoc: HostFiles.Locator;
checked: BOOLEAN;
sendDocument: PROCEDURE(adr, subject, note: WinCmc.string; flgs: WinCmc.flags;
paths, names, delimiter: WinCmc.string; id: WinCmc.ui_id): WinCmc.return_code;
PROCEDURE CheckDll*;
VAR dll: WinApi.HINSTANCE;
BEGIN
IF ~checked THEN
dll := WinApi.LoadLibrary("MAPI32");
IF dll # 0 THEN
SYSTEM.PUT(SYSTEM.ADR(sendDocument), WinApi.GetProcAddress(dll, "cmc_send_documents"));
END;
checked := TRUE
END
END CheckDll;
PROCEDURE SendNote*;
VAR c: TextControllers.Controller; r: TextModels.Reader; res: WinCmc.return_code;
s: POINTER TO ARRAY OF SHORTCHAR; ch: CHAR; beg, end, i: INTEGER; p: WinCmc.string;
BEGIN
CheckDll;
IF sendDocument # NIL THEN
c := TextControllers.Focus(); p := NIL;
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
r := c.text.NewReader(NIL); r.SetPos(beg);
NEW(s, (end - beg) * 2 + 1); r.ReadChar(ch); i := 0;
WHILE ~r.eot & (r.Pos() <= end) DO
IF (r.view = NIL) & (ch < 100X) THEN
s[i] := SHORT(ch); INC(i);
IF ch = 13X THEN s[i] := 10X; INC(i) END
END;
r.ReadChar(ch)
END;
s[i] := 0X; p := s^;
END;
res := sendDocument(NIL, NIL, p,
WinCmc.ERROR_UI_ALLOWED + WinCmc.LOGON_UI_ALLOWED + WinCmc.SEND_UI_REQUESTED,
NIL, NIL, ", ", 0)
END
END SendNote;
PROCEDURE SendDocument*;
VAR w: Windows.Window; res: WinCmc.return_code; name: HostFiles.FullName; title: Views.Title;
ss: ARRAY 260 OF SHORTCHAR; st: ARRAY 64 OF SHORTCHAR;
BEGIN
CheckDll;
IF sendDocument # NIL THEN
w := Windows.dir.First();
IF w # NIL THEN
Converters.Export(tempLoc, tempFile, NIL, w.doc.ThisView());
name := tempLoc.path + "\" + tempFile;
IF w.name # "" THEN title := w.name$
ELSE w.GetTitle(title); title := title + ".odc"
END;
ss := SHORT(name$); st := SHORT(title$);
res := sendDocument(NIL, NIL, NIL,
WinCmc.ERROR_UI_ALLOWED
+ WinCmc.LOGON_UI_ALLOWED
+ WinCmc.SEND_UI_REQUESTED,
ss, st, ", ", 0);
Files.dir.Delete(tempLoc, tempFile)
END
END
END SendDocument;
PROCEDURE SendNoteGuard* (VAR par: Dialog.Par);
BEGIN
IF checked & (sendDocument = NIL) THEN par.disabled := TRUE END
END SendNoteGuard;
PROCEDURE SendDocumentGuard* (VAR par: Dialog.Par);
BEGIN
IF checked & (sendDocument = NIL) OR (Windows.dir.First() = NIL) THEN par.disabled := TRUE END
END SendDocumentGuard;
PROCEDURE Init;
VAR res: INTEGER; path: HostFiles.FullName; sp: ARRAY 260 OF SHORTCHAR;
BEGIN
res := WinApi.GetTempPath(LEN(sp), sp); path := sp$;
tempLoc := HostFiles.NewLocator(path);
END Init;
BEGIN
Init
END HostMail.xy
| Host/Mod/Mail.odc |
MODULE HostMechanisms;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT COM,
USER32, WinOle, WinApi, OleData,
Services, Ports, Stores, Models, Sequencers, Views, Controllers, Properties,
Dialog, Mechanisms, Containers, Documents, Windows,
HostPorts;
CONST
handleSize = Ports.point * 11 DIV 2;
clipMiddleHandle = handleSize DIV 2 + 2 * Ports.point;
infiniteMiddleHandle = 48 * Ports.point;
targetBorderSize = 2;
outside = 0; left = 1; top = 2; right = 3; bottom = 4;
pick = -1; escape = -2;
both = 31; iclick = 30;
fixed = 31; (* controller option *)
TYPE
IDropSource = POINTER TO RECORD (WinOle.IDropSource)
key: SET
END;
IDropTarget = POINTER TO RECORD (WinOle.IDropTarget)
win: Windows.Window;
wnd: WinApi.HWND;
x, y: INTEGER;
key, effect: SET;
source: Views.Frame;
srcX, srcY: INTEGER;
type: Stores.TypeName;
isSingle: BOOLEAN;
w, h, rx, ry: INTEGER;
END;
Hook = POINTER TO RECORD (Mechanisms.Hook) END;
VAR
sourceFrame: Views.Frame; (* source of drag & drop *)
sourceX, sourceY: INTEGER;
targetFrame: Views.Frame; (* target of drag & drop *)
targetX, targetY: INTEGER;
dropView: Views.View; (* view to drop *)
isSingleton: BOOLEAN;
dropW, dropH: INTEGER;
relX, relY: INTEGER;
(** focus borders **)
PROCEDURE Fixed (host: Views.Frame; v: Views.View): BOOLEAN;
VAR sp: Properties.ResizePref; c: Containers.Controller;
BEGIN
c := host.view(Containers.View).ThisController();
IF c.opts * {Containers.noCaret, Documents.pageWidth..Documents.winHeight, fixed} # {} THEN
RETURN TRUE
END;
sp.fixed := FALSE; Views.HandlePropMsg(v, sp); RETURN sp.fixed
END Fixed;
PROCEDURE PaintFocusBorder (f: Views.Frame; focus: Views.View; l, t, r, b: INTEGER);
VAR u, s, w, h, mx, my, l0, t0, r0, b0: INTEGER;
PROCEDURE PaintHandle (x, y: INTEGER; l, t, r, b: BOOLEAN);
BEGIN
IF l THEN f.DrawRect(x - u, y, x, y + s, Ports.fill, Ports.background) END;
IF t THEN f.DrawRect(x, y - u, x + s, y, Ports.fill, Ports.background) END;
IF r THEN f.DrawRect(x + s, y, x + s + u, y + s, Ports.fill, Ports.background) END;
IF b THEN f.DrawRect(x, y + s, x + s, y + s + u, Ports.fill, Ports.background) END;
f.DrawRect(x, y, x + s, y + s, Ports.fill, Ports.defaultColor)
END PaintHandle;
BEGIN
f.rider.GetRect(l0, t0, r0, b0);
s := (handleSize - f.dot) DIV f.unit;
f.rider.SetRect(l0 - s, t0 - s, r0 + s, b0 + s);
u := f.dot; s := s * f.unit;
w := r - l; h := b - t;
f.DrawRect(l, t - s, r, t, Ports.fill, Ports.background);
f.DrawRect(l, b, r, b + s, Ports.fill, Ports.background);
f.DrawRect(l - s, t - s, l, b + s, Ports.fill, Ports.background);
f.DrawRect(r, t - s, r + s, b + s, Ports.fill, Ports.background);
DEC(s, u);
f.MarkRect(l, t - s, r, t, Ports.fill, HostPorts.focusPat, Ports.show);
f.MarkRect(l, b, r, b + s, Ports.fill, HostPorts.focusPat, Ports.show);
f.MarkRect(l - s, t - s, l, b + s, Ports.fill, HostPorts.focusPat, Ports.show);
f.MarkRect(r, t - s, r + s, b + s, Ports.fill, HostPorts.focusPat, Ports.show);
IF ~Fixed(f, focus) THEN
PaintHandle(l - s, t - s, FALSE, FALSE, TRUE, TRUE);
PaintHandle(r, t - s, TRUE, FALSE, FALSE, TRUE);
PaintHandle(l - s, b, FALSE, TRUE, TRUE, FALSE);
PaintHandle(r, b, TRUE, TRUE, FALSE, FALSE);
IF w > 2 * clipMiddleHandle THEN
mx := (l + r - s) DIV 2;
PaintHandle(mx, t - s, TRUE, FALSE, TRUE, FALSE);
PaintHandle(mx, b, TRUE, FALSE, TRUE, FALSE)
END;
IF h > 2 * clipMiddleHandle THEN
my := (t + b - s) DIV 2;
PaintHandle(l - s, my, FALSE, TRUE, FALSE, TRUE);
PaintHandle(r, my, FALSE, TRUE, FALSE, TRUE)
END
END;
f.DrawRect(l - u, t - u, r + u, b + u, u, Ports.defaultColor);
f.rider.SetRect(l0, t0, r0, b0)
END PaintFocusBorder;
PROCEDURE (hook: Hook) FocusBorderCursor* (f: Views.Frame; view: Views.View; l, t, r, b: INTEGER;
x, y: INTEGER): INTEGER;
VAR s, u, w, h, mx, my: INTEGER; cursor: INTEGER;
PROCEDURE CheckHandle (x0, y0: INTEGER; c: INTEGER);
BEGIN
IF (x >= x0 - u) & (x <= x0 + s) & (y >= y0 - u) & (y <= y0 + s) THEN
cursor := c
END
END CheckHandle;
BEGIN
u := f.dot; s := handleSize - 2 * u;
IF (x < l - s) OR (x > r + s) OR (y < t - s) OR (y > b + s) THEN
cursor := Mechanisms.outside
ELSE
cursor := Mechanisms.inside
END;
w := r - l; h := b - t;
IF ~Fixed(f, view) THEN
CheckHandle(l - s, t - s, HostPorts.resizeLCursor);
CheckHandle(r, t - s, HostPorts.resizeRCursor);
CheckHandle(l - s, b, HostPorts.resizeRCursor);
CheckHandle(r, b, HostPorts.resizeLCursor);
IF w > 2 * clipMiddleHandle THEN
mx := (l + r - s) DIV 2;
CheckHandle(mx, t - s, HostPorts.resizeVCursor);
CheckHandle(mx, b, HostPorts.resizeVCursor)
END;
IF h > 2 * clipMiddleHandle THEN
my := (t + b - s) DIV 2;
CheckHandle(l - s, my, HostPorts.resizeHCursor);
CheckHandle(r, my, HostPorts.resizeHCursor)
END
END;
RETURN cursor
END FocusBorderCursor;
PROCEDURE RestoreBorderArea (f: Views.Frame; l, t, r, b: INTEGER);
(* restore area under destructive border mark *)
VAR g: Views.RootFrame; res, s, dx, dy: INTEGER;
BEGIN
g := Views.RootOf(f);
dx := f.gx - g.gx; dy := f.gy - g.gy;
s := (handleSize - f.dot) DIV f.unit * f.unit;
INC(l, dx); INC(t, dy); INC(r, dx); INC(b, dy);
(*
Views.UpdateRoot(g, l - s, t - s, r + s, b + s, FALSE);
*)
Views.ValidateRoot(g);
Views.RestoreRoot(g, l - s, t - s, r + s, b + s);
(*
Views.RestoreRoot(g, l - s, t - s, r + s, t);
Views.RestoreRoot(g, l - s, t, l, b);
Views.RestoreRoot(g, r, t, r + s, b);
Views.RestoreRoot(g, l - s, b, r + s, b + s)
*)
END RestoreBorderArea;
PROCEDURE (hook: Hook) MarkFocusBorder* (
host: Views.Frame; focus: Views.View; l, t, r, b: INTEGER; show: BOOLEAN
);
BEGIN
IF focus # NIL THEN
IF show THEN
PaintFocusBorder(host, focus, l, t, r, b)
ELSE
RestoreBorderArea(host, l, t, r, b)
END
END
END MarkFocusBorder;
(** selection borders **)
PROCEDURE PaintSelBorder (f: Views.Frame; view: Views.View; l, t, r, b: INTEGER);
VAR res, u, d, w, h, mx, my: INTEGER; sizeable: BOOLEAN; l0, t0, r0, b0: INTEGER;
PROCEDURE PaintHandle (x, y: INTEGER);
VAR s: INTEGER; ci, co: Ports.Color;
BEGIN
DEC(x, d); DEC(y, d); s := d * 2 + u;
IF sizeable THEN ci := HostPorts.selBackground; co := HostPorts.selTextCol
ELSE ci := HostPorts.selTextCol; co := HostPorts.selBackground
END;
f.DrawRect(x, y, x + s, y + s, Ports.fill, co);
INC(x, u); INC(y, u); DEC(s, 2 * u);
f.DrawRect(x, y, x + s, y + s, Ports.fill, ci);
(*
f.DrawRect(x, y, x + s, y + s, Ports.fill, ci);
f.DrawRect(x, y, x + s, y + s, 0, co)
*)
END PaintHandle;
BEGIN
d := (handleSize - f.dot) DIV f.unit DIV 2;
f.rider.GetRect(l0, t0, r0, b0);
f.rider.SetRect(l0 - d - 1, t0 - d - 1, r0 + d + 1, b0 + d + 1);
d := d * f.unit; u := f.dot;
w := r - l; h := b - t; sizeable := ~Fixed(f, view);
DEC(l, u); DEC(t, u);
(*
f.SaveRect(l - d, t - d, r + u + d, b + u + d, res);
*)
f.DrawRect(l, t, r + u, b + u, u, HostPorts.selBackground);
IF f.front THEN
IF (w > clipMiddleHandle) & (h > clipMiddleHandle) THEN
PaintHandle(l, t);
PaintHandle(r, t);
PaintHandle(l, b);
PaintHandle(r, b);
IF w > 2 * clipMiddleHandle THEN
mx := (l + r) DIV 2;
PaintHandle(mx, t);
PaintHandle(mx, b)
END;
IF h > 2 * clipMiddleHandle THEN
my := (t + b) DIV 2;
PaintHandle(l, my);
PaintHandle(r, my)
END
ELSIF sizeable THEN
PaintHandle(r, b)
END
END;
f.rider.SetRect(l0, t0, r0, b0)
END PaintSelBorder;
PROCEDURE (hook: Hook) SelBorderCursor* (f: Views.Frame; view: Views.View; l, t, r, b: INTEGER;
x, y: INTEGER): INTEGER;
VAR d, u, w, h, mx, my: INTEGER; cursor: INTEGER;
PROCEDURE CheckHandle (x0, y0: INTEGER; c: INTEGER);
BEGIN
IF (x >= x0 - d) & (x <= x0 + d) & (y >= y0 - d) & (y <= y0 + d) THEN
cursor := c
END
END CheckHandle;
BEGIN
IF (x < l) OR (x > r) OR (y < t) OR (y > b) THEN cursor := Mechanisms.outside
ELSE cursor := Mechanisms.inside
END;
IF (view # NIL) & ~Fixed(f, view) THEN
d := (handleSize - f.dot) DIV f.unit DIV 2 * f.unit;
w := r - l; h := b - t; u := f.dot;
DEC(l, u); DEC(t, u);
IF (w > clipMiddleHandle) & (h > clipMiddleHandle) THEN
CheckHandle(l, t, HostPorts.resizeLCursor);
CheckHandle(r, t, HostPorts.resizeRCursor);
CheckHandle(l, b, HostPorts.resizeRCursor);
CheckHandle(r, b, HostPorts.resizeLCursor);
IF w > 2 * clipMiddleHandle THEN
mx := (l + r) DIV 2;
CheckHandle(mx, t, HostPorts.resizeVCursor);
CheckHandle(mx, b, HostPorts.resizeVCursor)
END;
IF h > 2 * clipMiddleHandle THEN
my := (t + b) DIV 2;
CheckHandle(l, my, HostPorts.resizeHCursor);
CheckHandle(r, my, HostPorts.resizeHCursor)
END
ELSE
CheckHandle(r, b, HostPorts.resizeLCursor)
END
END;
RETURN cursor
END SelBorderCursor;
PROCEDURE RestoreViewArea (f: Views.Frame; l, t, r, b: INTEGER);
(* restore area under destructive selection mark *)
VAR g: Views.RootFrame; res, d, u, dx, dy: INTEGER;
BEGIN
(*
d := (handleSize - f.dot) DIV f.unit DIV 2 * f.unit + f.dot;
f.RestoreRect(l - d, t - d, r + d, b + d, TRUE)
*)
g := Views.RootOf(f);
dx := f.gx - g.gx; dy := f.gy - g.gy;
d := (handleSize - f.dot) DIV f.unit DIV 2 * f.unit + f.dot;
INC(l, dx); INC(t, dy); INC(r, dx); INC(b, dy);
Views.ValidateRoot(g);
Views.RestoreRoot(g, l - d, t - d, r + d, b + d)
END RestoreViewArea;
PROCEDURE (hook: Hook) MarkSingletonBorder* (
host: Views.Frame; view: Views.View; l, t, r, b: INTEGER; show: BOOLEAN
);
BEGIN
IF view # NIL THEN
IF show THEN
PaintSelBorder(host, view, l, t, r, b)
ELSE
RestoreViewArea(host, l, t, r, b)
END
END
(*
IF view # NIL THEN InvertSelBorder(host, view, l, t, r, b, show) END
*)
END MarkSingletonBorder;
(*
PROCEDURE MarkBorder* (host: Ports.Frame; view: Stores.Store; l, t, r, b: INTEGER);
VAR s: INTEGER;
BEGIN
IF view # NIL THEN
s := markBorderSize * host.dot;
host.MarkRect(l - s, t - s, r + s, b + s, s, Ports.dim50, Ports.show)
END
END MarkBorder;
*)
PROCEDURE (hook: Hook) TrackToResize* (host: Views.Frame; view: Views.View;
minW, maxW, minH, maxH: INTEGER;
VAR l, t, r, b: INTEGER; VAR op: INTEGER;
VAR x, y: INTEGER; VAR buttons: SET);
VAR area: SET; isDown: BOOLEAN; c: INTEGER; m: SET; p: Properties.SizePref;
x1, y1, dx, dy, dl, dt, dr, db, l0, t0, r0, b0, l1, t1, r1, b1, w, h, dw, dh: INTEGER;
BEGIN
l0 := l; t0 := t; r0 := r; b0 := b; dl := 0; dt := 0; dr := 0; db := 0;
x1 := (l + r) DIV 2; y1 := (t + b) DIV 2;
IF (r - l <= 2 * clipMiddleHandle) OR (ABS(x - x1) > handleSize DIV 2) THEN
IF x < x1 THEN dl := 1 ELSE dr := 1 END
END;
IF (b - t <= 2 * clipMiddleHandle) OR (ABS(y - y1) > handleSize DIV 2) THEN
IF y < y1 THEN dt := 1 ELSE db := 1 END
END;
IF (Controllers.extend IN buttons) & (dl # dr) THEN dl := 1; dr := 1 END;
IF (Controllers.extend IN buttons) & (dt # db) THEN dt := 1; db := 1 END;
host.MarkRect(l, t, r, b, 0, Ports.dim50, Ports.show);
REPEAT
host.Input(x1, y1, m, isDown);
IF x1 < host.l THEN x1 := host.l ELSIF x1 > host.r THEN x1 := host.r END;
IF y1 < host.t THEN y1 := host.t ELSIF y1 > host.b THEN y1 := host.b END;
dx := x1 - x; dy := y1 - y;
l1 := l0 + dl * dx; t1 := t0 + dt * dy; r1 := r0 + dr * dx; b1 := b0 + db * dy;
w := r1 - l1; h := b1 - t1;
IF (w > 0) & (h > 0) THEN
p.fixedH := (dl = 0) & (dr = 0); p.fixedW := (dt = 0) & (db = 0);
p.w := w; p.h := h; Views.HandlePropMsg(view, p); w := p.w; h := p.h;
IF w < minW THEN w := minW ELSIF w > maxW THEN w := maxW END;
IF h < minH THEN h := minH ELSIF h > maxH THEN h := maxH END;
dw := w - (r1 - l1); dh := h - (b1 - t1);
DEC(l1, dl * dw); DEC(t1, dt * dh);
IF (dl + dr = 0) & (dw # 0) THEN INC(r1, dw) ELSE INC(r1, dr * dw) END;
IF (dt + db = 0) & (dh # 0) THEN INC(b1, dh) ELSE INC(b1, db * dh) END;
IF (l1 # l) OR (t1 # t) OR (r1 # r) OR (b1 # b) THEN
host.MarkRect(l, t, r, b, 0, Ports.dim50, Ports.hide);
l := l1; t := t1; r := r1; b := b1;
host.MarkRect(l, t, r, b, 0, Ports.dim50, Ports.show)
END
END
UNTIL ~isDown;
host.MarkRect(l, t, r, b, 0, Ports.dim50, Ports.hide);
x := x1; y := y1; buttons := {};
IF (l # l0) OR (t # t0) OR (r # r0) OR (b # b0) THEN op := Mechanisms.resize
ELSE op := Mechanisms.cancelResize
END
END TrackToResize;
(* IDropSource *)
PROCEDURE (this: IDropSource) QueryContinueDrag (
escapePressed: WinApi.BOOL; keyState: SET
): COM.RESULT;
BEGIN
IF this.key = {} THEN
this.key := keyState * (WinApi.MK_LBUTTON + WinApi.MK_MBUTTON + WinApi.MK_RBUTTON)
END;
IF escapePressed # 0 THEN RETURN WinApi.DRAGDROP_S_CANCEL
ELSIF keyState * this.key = {} THEN RETURN WinApi.DRAGDROP_S_DROP
ELSE RETURN WinApi.S_OK
END
END QueryContinueDrag;
PROCEDURE (this: IDropSource) GiveFeedback (effect: SET): COM.RESULT;
BEGIN
RETURN WinApi.DRAGDROP_S_USEDEFAULTCURSORS
END GiveFeedback;
(* IDropTarget *)
PROCEDURE InstallDropTarget* (wnd: WinApi.HWND; win: Windows.Window);
VAR drop: IDropTarget; res: COM.RESULT;
BEGIN
NEW(drop); drop.win := win; drop.wnd := wnd;
res := WinOle.RegisterDragDrop(wnd, drop);
END InstallDropTarget;
PROCEDURE RemoveDropTarget* (wnd: WinApi.HWND);
VAR res: COM.RESULT;
BEGIN
res := WinOle.RevokeDragDrop(wnd);
END RemoveDropTarget;
PROCEDURE PollDrop (d: IDropTarget; show: BOOLEAN);
VAR msg: Controllers.PollDropMsg; w, h: INTEGER;
BEGIN
(* x, y in port coordinates of w *)
d.win.port.GetSize(w, h);
msg.x := d.x * d.win.port.unit;
msg.y := d.y * d.win.port.unit;
(* msg.x, msg.y in coordinates of target root frame *)
msg.source := d.source; msg.sourceX := d.srcX; msg.sourceY := d.srcY;
msg.mark := Controllers.mark; msg.show := show;
msg.type := d.type; msg.isSingle := d.isSingle;
msg.w := d.w; msg.h := d.h; msg.rx := d.rx; msg.ry := d.ry;
msg.dest := NIL;
d.win.ForwardCtrlMsg(msg);
(* msg.x, msg.y in coordinates of target frame *)
targetFrame := msg.dest; targetX := msg.x; targetY := msg.y
END PollDrop;
PROCEDURE Drop (d: IDropTarget; v: Views.View; w, h: INTEGER; isSingle: BOOLEAN);
VAR msg: Controllers.DropMsg; pw, ph: INTEGER;
BEGIN
(* x, y in port coordinates of w *)
d.win.port.GetSize(pw, ph);
msg.x := d.x * d.win.port.unit;
msg.y := d.y * d.win.port.unit;
(* msg.x, msg.y in coordinates of target root frame *)
msg.source := d.source; msg.sourceX := d.srcX; msg.sourceY := d.srcY;
msg.view := v; msg.isSingle := isSingle;
msg.w := w; msg.h := h; msg.rx := d.rx; msg.ry := d.ry;
d.win.ForwardCtrlMsg(msg)
END Drop;
PROCEDURE AppendMenu (menu: USER32.Handle; id: INTEGER; name: Dialog.String);
VAR res: INTEGER; sn: ARRAY 256 OF SHORTCHAR;
BEGIN
Dialog.MapString(name, name); sn := SHORT(name$);
res := USER32.AppendMenuA(menu, {}, id, sn);
END AppendMenu;
PROCEDURE ShowPopup (f: Views.Frame; x, y: INTEGER; VAR effect: SET);
VAR menu: USER32.Handle; res: INTEGER;
wnd: USER32.Handle; msg: USER32.Message; pt: USER32.Point;
BEGIN
menu := USER32.CreatePopupMenu();
AppendMenu(menu, 32000, "#Host:MoveHere");
AppendMenu(menu, 32001, "#Host:CopyHere");
AppendMenu(menu, 32002, "#Host:LinkHere");
IF effect * WinOle.DROPEFFECT_MOVE = {} THEN
res := USER32.EnableMenuItem(menu, 32000, {USER32.MFGrayed})
END;
IF effect * WinOle.DROPEFFECT_COPY = {} THEN
res := USER32.EnableMenuItem(menu, 32001, {USER32.MFGrayed})
END;
IF effect * WinOle.DROPEFFECT_LINK = {} THEN
res := USER32.EnableMenuItem(menu, 32002, {USER32.MFGrayed})
END;
res := USER32.AppendMenuA(menu, {USER32.MFSeparator}, 0, NIL);
AppendMenu(menu, 32003, "#System:Cancel");
wnd := f.rider(HostPorts.Rider).port.wnd;
pt.x := (x + f.gx) DIV f.unit; pt.y := (y + f.gy) DIV f.unit;
res := USER32.ClientToScreen(wnd, pt);
res := USER32.TrackPopupMenu(menu, {1}, pt.x, pt.y, 0, wnd, NIL);
res := USER32.DestroyMenu(menu);
effect := WinOle.DROPEFFECT_NONE;
IF USER32.PeekMessageA(msg, wnd, USER32.WMCommand, USER32.WMCommand, 1) # 0 THEN
IF msg.wParam = 32000 THEN effect := WinOle.DROPEFFECT_MOVE
ELSIF msg.wParam = 32001 THEN effect := WinOle.DROPEFFECT_COPY
ELSIF msg.wParam = 32002 THEN effect := WinOle.DROPEFFECT_LINK
END
END
END ShowPopup;
PROCEDURE Effect (mask, keyState: SET): SET;
VAR effect: SET;
BEGIN
IF (mask * WinOle.DROPEFFECT_LINK # {})
& (((WinApi.MK_SHIFT + WinApi.MK_CONTROL) - keyState = {})
OR (mask * (WinOle.DROPEFFECT_MOVE + WinOle.DROPEFFECT_COPY) = {})) THEN
effect := WinOle.DROPEFFECT_LINK
ELSIF (mask * WinOle.DROPEFFECT_COPY # {})
& ((keyState * WinApi.MK_CONTROL # {})
OR ((WinApi.MK_LBUTTON + WinApi.MK_RBUTTON) - keyState = {})
OR (mask * WinOle.DROPEFFECT_MOVE = {})) THEN effect := WinOle.DROPEFFECT_COPY
ELSIF mask * WinOle.DROPEFFECT_MOVE # {} THEN effect := WinOle.DROPEFFECT_MOVE
ELSE effect := WinOle.DROPEFFECT_NONE
END;
RETURN effect
END Effect;
PROCEDURE (this: IDropTarget) DragEnter (dataObj: WinOle.IDataObject; keyState: SET; pt: WinApi.POINT;
VAR effect: SET): COM.RESULT;
VAR res, w, h, x, y: INTEGER; s: BOOLEAN;
BEGIN
IF sourceFrame # NIL THEN
this.source := sourceFrame;
this.srcX := sourceX; this.srcY := sourceY;
Services.GetTypeName(dropView, this.type);
this.isSingle := isSingleton;
this.w := dropW; this.h := dropH;
this.rx := relX; this.ry := relY
ELSE
OleData.GetDataType(dataObj, this.type, this.w, this.h, this.rx, this.ry, this.isSingle);
this.source := NIL
END;
IF (this.type # "") & (this.win # NIL) THEN
res := WinApi.ScreenToClient(this.wnd, pt);
this.x := pt.x; this.y := pt.y; this.key := keyState;
PollDrop(this, Controllers.show)
END;
IF (this.type # "") & (this.win = NIL) OR (targetFrame # NIL) THEN
effect := Effect(effect, keyState)
ELSE effect := WinOle.DROPEFFECT_NONE
END;
this.effect := effect;
RETURN WinApi.S_OK
END DragEnter;
PROCEDURE (this: IDropTarget) DragOver (keyState: SET; pt: WinApi.POINT; VAR effect: SET): COM.RESULT;
VAR res: INTEGER;
BEGIN
IF (this.type # "") & (this.win # NIL) THEN
res := WinApi.ScreenToClient(this.wnd, pt);
IF (pt.x # this.x) OR (pt.y # this.y) THEN
PollDrop(this, Controllers.hide);
this.x := pt.x; this.y := pt.y;
PollDrop(this, Controllers.show)
END
END;
IF (this.type # "") & (this.win = NIL) OR (targetFrame # NIL) THEN
effect := Effect(effect, keyState);
ELSE effect := WinOle.DROPEFFECT_NONE
END;
this.effect := effect;
RETURN WinApi.S_OK
END DragOver;
PROCEDURE (this: IDropTarget) DragLeave (): COM.RESULT;
BEGIN
IF (this.type # "") & (this.win # NIL) THEN
PollDrop(this, Controllers.hide);
END;
targetFrame := NIL; this.source := NIL;
RETURN WinApi.S_OK
END DragLeave;
PROCEDURE (this: IDropTarget) Drop (dataObj: WinOle.IDataObject; keyState: SET; pt: WinApi.POINT;
VAR effect: SET): COM.RESULT;
VAR res, w, h: INTEGER; v: Views.View; s: BOOLEAN;
c: Containers.Controller; q: ANYPTR; m: Containers.Model; p: Properties.BoundsPref;
BEGIN
IF this.effect # WinOle.DROPEFFECT_NONE THEN
IF this.win # NIL THEN
res := WinApi.ScreenToClient(this.wnd, pt);
PollDrop(this, Controllers.hide);
IF targetFrame # NIL THEN
Windows.dir.Select(this.win, Windows.eager);
IF WinApi.MK_LBUTTON * this.key = {} THEN (* nonstandard drag *)
ShowPopup(targetFrame, targetX, targetY, effect)
ELSE effect := this.effect
END;
IF (effect # WinOle.DROPEFFECT_NONE) & (sourceFrame = NIL) THEN
IF Services.Is(targetFrame.view, "TextViews.View") THEN
OleData.GetTextDataView(dataObj, v, w, h, s)
ELSE
OleData.GetDataView(dataObj, "", v, w, h, s)
END;
IF v # NIL THEN Drop(this, v, w, h, s)
ELSE effect := WinOle.DROPEFFECT_NONE
END
END
ELSE effect := WinOle.DROPEFFECT_NONE
END
ELSE (* drop to new window *)
effect := this.effect;
IF sourceFrame # NIL THEN
w := dropW; h := dropH;
IF isSingleton THEN
v := Views.CopyOf(dropView, Views.deep)
ELSE
c := dropView(Containers.View).ThisController();
m := c.SelectionCopy();
v := Views.CopyWithNewModel(dropView, m);
p.w := w; p.h := h; Views.HandlePropMsg(v, p); w := p.w; h := p.h
END
ELSE OleData.GetDataView(dataObj, "", v, w, h, s)
END;
IF v # NIL THEN Views.OpenView(Documents.dir.New(v, w, h));
Views.BeginModification(Views.notUndoable, v);
Views.EndModification(Views.notUndoable, v)
ELSE effect := WinOle.DROPEFFECT_NONE
END
END
ELSE effect := WinOle.DROPEFFECT_NONE
END;
RETURN WinApi.S_OK
END Drop;
(* drag & drop *)
PROCEDURE (hook: Hook) TrackToDrop* (f: Views.Frame; view: Views.View;
isSingle: BOOLEAN; w, h, rx, ry: INTEGER;
VAR dest: Views.Frame; VAR destX, destY: INTEGER; VAR op: INTEGER;
VAR x, y: INTEGER; VAR buttons: SET);
VAR res: COM.RESULT; mask, mode: SET; p: HostPorts.Port; pt: WinApi.POINT;
dsrc: IDropSource; data: WinOle.IDataObject;
BEGIN
sourceFrame := f; sourceX := x; sourceY := y;
dropView := view; isSingleton := isSingle;
dropW := w; dropH := h; relX := rx; relY := ry;
data := OleData.ViewDropData(view, w, h, rx, ry, isSingle, ~isSingle);
NEW(dsrc); dsrc.key := {};
mask := WinOle.DROPEFFECT_COPY;
IF op # Mechanisms.copy THEN mask := mask + WinOle.DROPEFFECT_MOVE END;
res := WinOle.DoDragDrop(data, dsrc, mask, mode);
op := Mechanisms.cancelDrop;
IF res = WinApi.DRAGDROP_S_DROP THEN
IF mode * WinOle.DROPEFFECT_MOVE # {} THEN op := Mechanisms.move
ELSIF mode * WinOle.DROPEFFECT_COPY # {} THEN op := Mechanisms.copy
END
END;
IF targetFrame # NIL THEN (* reconstruct final mouse coordinates in f *)
p := targetFrame.rider(HostPorts.Rider).port;
pt.x := (targetX + targetFrame.gx) DIV p.unit;
pt.y := (targetY + targetFrame.gy) DIV p.unit;
res := WinApi.ClientToScreen(p.wnd, pt);
p := f.rider(HostPorts.Rider).port;
res := WinApi.ScreenToClient(p.wnd, pt);
x := pt.x * p.unit - f.gx;
y := pt.y * p.unit - f.gy
END;
dest := targetFrame; destX := targetX; destY := targetY;
sourceFrame := NIL; targetFrame := NIL; dropView := NIL
END TrackToDrop;
PROCEDURE PickMode (f, dest: Views.Frame; x, y: INTEGER): INTEGER;
VAR mode, cursor: INTEGER;
BEGIN
IF USER32.GetAsyncKeyState(1BH) < 0 THEN mode := escape; cursor := Ports.arrowCursor
(*
ELSIF Home(f, x, y) THEN mode := Mechanisms.cancelPick; cursor := Ports.arrowCursor
*)
ELSIF dest = NIL THEN mode := Mechanisms.cancelPick; cursor := HostPorts.stopCursor
ELSE
cursor := HostPorts.pickCursor;
IF Services.SameType(dest.view, f.view) THEN
mode := Mechanisms.pick
ELSE mode := Mechanisms.pickForeign
END
END;
f.SetCursor(cursor);
RETURN mode
END PickMode;
PROCEDURE (hook: Hook) TrackToPick* (f: Views.Frame;
VAR dest: Views.Frame; VAR destX, destY: INTEGER; VAR op: INTEGER;
VAR x, y: INTEGER; VAR buttons: SET);
VAR d, d0: Views.Frame;
dx, dy, x0, y0, x1, y1: INTEGER; isDown: BOOLEAN; m: SET;
BEGIN
x0 := x; y0 := y;
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.show, dest, destX, destY);
(* MarkTarget(dest, dest # f); *)
op := PickMode(f, dest, x, y);
REPEAT
(* CheckWindow(TRUE); *)
f.Input(x1, y1, m, isDown);
IF (x1 # x) OR (y1 # y) THEN
Properties.PollPick(x1, y1, f, x0, y0, Properties.noMark, Properties.show, d, dx, dy);
IF (d # dest) OR (dx # destX) OR (dy # destY) THEN
d0 := dest;
(* MarkTarget(dest, (dest # f) & (d # d0)); *)
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.hide, dest, destX, destY);
x := x1; y := y1;
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.show, d, dx, dy);
dest := d; destX := dx; destY := dy;
(* MarkTarget(dest, (dest # f) (* ~home *) & (d # d0)); *)
ELSE
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.hide, d, dx, dy);
x := x1; y := y1;
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.show, d, dx, dy)
END
END;
op := PickMode(f, dest, x, y)
UNTIL ~isDown OR (op = escape);
Properties.PollPick(x, y, f, x0, y0, Properties.mark, Properties.hide, d, dx, dy);
IF op = escape THEN
REPEAT f.Input(x, y, m, isDown) UNTIL ~isDown;
op := Mechanisms.cancelPick
END;
(* MarkTarget(dest, dest # f); *)
(* CheckWindow(FALSE) *)
buttons := {}
END TrackToPick;
PROCEDURE (hook: Hook) PopUpAndSelect* (f: Views.Frame;
n, this: INTEGER;
string: ARRAY OF ARRAY OF CHAR;
enabled, checked: ARRAY OF BOOLEAN;
VAR i: INTEGER;
VAR x, y: INTEGER; VAR buttons: SET);
VAR res, j: INTEGER; menu, wnd: USER32.Handle; pt: USER32.Point;
t: ARRAY 256 OF CHAR; st: ARRAY 256 OF SHORTCHAR; s: SET;
BEGIN
ASSERT(0 < n, 20); ASSERT(n <= LEN(string), 21);
ASSERT(LEN(enabled) = LEN(string), 22);
ASSERT(LEN(checked) = LEN(string), 23);
ASSERT(wnd # 0, 100);
menu := USER32.CreatePopupMenu(); j := 0;
WHILE j < n DO
IF string[j] = "-" THEN
res := USER32.AppendMenuA(menu, {USER32.MFSeparator}, 0, NIL)
ELSE
Dialog.MapString(string[j], t); st := SHORT(t$);
res := USER32.AppendMenuA(menu, {}, 32000 + j, st);
IF ~enabled[j] THEN
res := USER32.EnableMenuItem(menu, 32000 + j, {USER32.MFGrayed})
ELSIF checked[j] THEN
res := USER32.CheckMenuItem(menu, 32000 + j, {USER32.MFChecked})
END
END;
INC(j)
END;
pt.x := (x + f.gx) DIV f.unit; pt.y := (y + f.gy) DIV f.unit;
res := USER32.ClientToScreen(wnd, pt);
s := {1, 2}; (* track right, center align *)
res := USER32.TrackPopupMenu(menu, s, pt.x, pt.y + 2, 0, wnd, NIL);
res := USER32.DestroyMenu(menu);
END PopUpAndSelect;
PROCEDURE Init*;
VAR h: Hook;
BEGIN
(* Sequencers.MarkBorder := MarkBorder; *)
NEW(h); Mechanisms.SetHook(h);
END Init;
BEGIN
Init
END HostMechanisms.
| Host/Mod/Mechanisms.odc |
MODULE HostMenus; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111212, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20061225, Alexander Iljin, Added UpdateType to fix bug in PopupMenu
- 20061208, Ilya Ermakov, full-screen mode support
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Log, Services,
SYSTEM, KERNEL32, GDI32, USER32, SHELL32, WinApi, Kernel,
Fonts, Files, Strings, Ports, Stores, Properties, Printers, Dialog,
Models, Views, Controllers, Containers, Converters,
Documents, Windows, Controls,
StdDialog, StdInterpreter, StdCmds, HostFonts, HostPorts,
HostFiles, HostWindows, HostDialog, HostClipboard, HostCmds, HostCFrames,
i21sysCharacters;
CONST
debug = FALSE;
idlePeriod = 50; (* ms *)
gcCycle = 100;
titleLen = 64;
(* hints *)
impAll = 0; (* can import all file types *)
expDoc = 1; (* imported view should be stored as document *)
HYPHEN = 90X; NBHYPHEN = 91X; SOFTHYPHEN = 0ADX;
NBSPACE = 0A0X; NUMSPACE = 8FX;
iClose = 100; (* known in HostWindows *)
iUndo = 112; iCut = 114; iCopy = 115; iPaste = 116;
iObject = 120; iPopup = 160; iProperties = 163;
iObjEdit = 161; iObjOpen = 162; iVerb0 = 200;
iOpen = 102; iUpdateMenus = 111; iExit = 110;
(* custom menus *)
firstId = 300;
(* apllication states *)
running = 0; hidden = 1; embedded = 2; noAppWin = 3;
(* File for specifying command line options *)
cmdLinePath = "System/Rsrc"; cmdLineFile = "CommandLine.txt";
TYPE
Item* = POINTER TO RECORD (StdDialog.Item)
id-, code-: INTEGER;
shift-, ctrl-, del: BOOLEAN
END;
Menu* = POINTER TO RECORD
next-: Menu;
menu-, type-: Dialog.String;
firstItem-, lastItem: Item;
menuH-: USER32.Handle;
isWinMenu-: BOOLEAN;
isPopup-: BOOLEAN;
class-: INTEGER;
hot, maxId: INTEGER
END;
TypeMsg* = EXTENSIBLE RECORD (Properties.Message)
type*: ARRAY 64 OF CHAR (** OUT, preset to "" **)
END;
VAR
(* active menu bar state *)
menus-: Menu;
menuBar-: USER32.Handle;
lastId-: INTEGER; (* last custom menu id *)
disablePipe*: BOOLEAN;
winMenu, popMenu: USER32.Handle;
type: Stores.TypeName;
(* new menu bar state *)
newMenuBar, newWinMenu, newPopMenu: USER32.Handle;
nextId: INTEGER; (* id of next menu item *)
firstMenu, lastMenu, curMenu: Menu;
gc: INTEGER; (* how many events must be executed before next GC *)
defMenu: USER32.Handle; (* default menu *)
objMenu: USER32.Handle; (* object menu (verbs) *)
shiftStr, ctrlStr, spaceStr: Dialog.String;
minusCode: INTEGER; (* key code for "-" *)
num: INTEGER;
msgId: INTEGER;
locks-: INTEGER;
state: INTEGER;
openUsed: BOOLEAN;
openParam: ARRAY 256 OF SHORTCHAR;
isCont*, isObj*: BOOLEAN;
UpdateOleMenus*: PROCEDURE;
TranslateOleKeys1*: PROCEDURE (VAR msg: WinApi.MSG; VAR done: BOOLEAN);
TranslateOleKeys2*: PROCEDURE (VAR msg: WinApi.MSG; VAR done: BOOLEAN);
PROCEDURE [1] FINIT 0DBH, 0E3H;
PROCEDURE [1] FCLEX 0DBH, 0E2H;
PROCEDURE [1] FLDCW 0D9H, 06DH, 0FCH; (* -4, FP *)
PROCEDURE [1] FSTCW 0D9H, 07DH, 0FCH; (* -4, FP *)
PROCEDURE [1] FSTSW 0DDH, 07DH, 0FCH; (* -4, FP *)
PROCEDURE CheckFpu;
VAR cw: SET;
BEGIN
FSTCW;
IF cw * {0..5, 8..11} # {1, 2, 3, 4, 5, 8, 9} THEN
cw := cw - {0..5, 8..11} + {1, 2, 3, 4, 5, 8, 9};
FCLEX; FLDCW
END
END CheckFpu;
PROCEDURE Collect*;
BEGIN
gc := 0
END Collect;
(* hidden application support *)
PROCEDURE Lock*;
BEGIN
INC(locks);
IF state = embedded THEN state := hidden END
END Lock;
PROCEDURE Unlock*;
VAR res: INTEGER;
BEGIN
DEC(locks);
IF (state = hidden) & (locks = 0) THEN
HostClipboard.Flush;
res := USER32.DestroyWindow(HostWindows.main)
END
END Unlock;
(* shortcut support *)
PROCEDURE Append (VAR a: ARRAY OF CHAR; b: ARRAY OF CHAR); (* a := a + b *)
VAR i, j: INTEGER;
BEGIN
i := 0; j := 0;
WHILE a[i] # 0X DO INC(i) END;
WHILE b[j] # 0X DO a[i] := b[j]; INC(i); INC(j) END;
a[i] := 0X
END Append;
PROCEDURE SetShortcut (VAR i: Item; VAR name: Dialog.String);
VAR j, n: INTEGER; ch, nch: CHAR; a: ARRAY 4 OF CHAR;
BEGIN
i.shift := FALSE; i.ctrl := FALSE; i.code := 0; j := 0; ch := i.shortcut[0];
WHILE (ch # 0X) & (i.code = 0) DO INC(j);
IF (ch >= "a") & (ch <= "z") THEN ch := CAP(ch) END;
nch := i.shortcut[j];
IF ch = "*" THEN i.shift := TRUE
ELSIF ch = "^" THEN i.ctrl := TRUE
ELSIF (ch >= "A") & (ch <= "Z") OR (ch >= "0") & (ch <= "9") OR (ch = " ") THEN
IF (nch >= "a") & (nch <= "z") THEN nch := CAP(nch) END;
IF nch = 0X THEN i.code := ORD(ch); i.ctrl := TRUE
ELSIF ch = "B" THEN (* в качестве клавиши можно указывать BackSpace*)
i.code := 8;
ELSIF ch = "F" THEN
n := 0;
WHILE (nch >= "0") & (nch <= "9") DO
n := 10 * n + ORD(nch) - ORD("0"); INC(j); nch := i.shortcut[j]
END;
IF (n >= 1) & (n <= 16) THEN i.code := 70H - 1 + n END
END
END;
ch := nch
END;
IF i.code # 0 THEN
Append(name, " "); (* tab *)
IF i.shift THEN Append(name, shiftStr) END;
IF i.ctrl THEN Append(name, ctrlStr) END;
IF i.code >= 70H THEN
a[0] := "F"; n := i.code - 70H + 1; j := 1;
IF n > 9 THEN a[1] := "1"; DEC(n, 10); INC(j) END;
a[j] := CHR(n + ORD("0")); a[j+1] := 0X;
Append(name, a)
ELSIF i.code = ORD(" ") THEN Append(name, spaceStr)
ELSIF i.code = 8 THEN Append(name, "BackSpace")
ELSE a[0] := CHR(i.code); a[1] := 0X; Append(name, a)
END
END
END SetShortcut;
(* hotkey support *)
PROCEDURE NextWord (VAR name: Dialog.String; i: INTEGER): INTEGER;
BEGIN
WHILE (name[i] # 0X) & (name[i] # " ") DO INC(i) END;
WHILE name[i] = " " DO INC(i) END;
IF (CAP(name[i]) < "A") OR (CAP(name[i]) > "Z") THEN i := -1 END;
RETURN i
END NextWord;
PROCEDURE SetHotkey (VAR name: Dialog.String; i: INTEGER);
VAR j: INTEGER;
BEGIN
IF name[i] # "&" THEN
j := i;
WHILE name[j] # 0X DO INC(j) END;
WHILE j >= i DO name[j+1] := name[j]; DEC(j) END;
name[i] := "&"
END
END SetHotkey;
PROCEDURE GetHotkey (VAR name: Dialog.String; VAR pos: INTEGER; VAR used: SET);
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; ch := name[0];
WHILE ch # 0X DO
IF ch = "&" THEN
ch := name[i + 1];
IF ch = "&" THEN INC(i)
ELSE
pos := i; ch := CAP(ch);
IF (ch >= "A") & (ch <= "Z") THEN INCL(used, ORD(ch) - ORD("A")) END;
RETURN
END
END;
INC(i); ch := name[i]
END;
pos := -1
END GetHotkey;
PROCEDURE FirstFree (VAR name: Dialog.String; VAR used: SET): INTEGER;
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; ch := CAP(name[0]);
WHILE (name[i] # 0X) & ((ch < "A") OR (ch > "Z") OR (ORD(ch) - ORD("A") IN used)) DO
INC(i); ch := CAP(name[i])
END;
IF ch # 0X THEN INCL(used, ORD(ch) - ORD("A"))
ELSE i := -1
END;
RETURN i
END FirstFree;
PROCEDURE SetHotkeys (VAR tab: ARRAY OF Dialog.String; n: INTEGER);
VAR i, j: INTEGER; ch: CHAR; pos: POINTER TO ARRAY OF INTEGER; used: SET;
BEGIN
NEW(pos, LEN(tab));
used := {}; i := 0;
WHILE i < n DO GetHotkey(tab[i], pos[i], used); INC(i) END;
i := 0;
WHILE i < n DO
IF pos[i] = -1 THEN
ch := CAP(tab[i, 0]);
IF (ch >= "A") & (ch <= "Z") & ~(ORD(ch) - ORD("A") IN used) THEN
INCL(used, ORD(ch) - ORD("A"));
pos[i] := 0
END
END;
INC(i)
END;
i := 0;
WHILE i < n DO
IF pos[i] = -1 THEN
j := NextWord(tab[i], 0);
WHILE j >= 0 DO
ch := CAP(tab[i, j]);
IF ~(ORD(ch) - ORD("A") IN used) THEN
INCL(used, ORD(ch) - ORD("A"));
pos[i] := j; j := -1
ELSE
j := NextWord(tab[i], j)
END
END
END;
INC(i)
END;
i := 0;
WHILE i < n DO
IF pos[i] = -1 THEN pos[i] := FirstFree(tab[i], used) END;
IF pos[i] >= 0 THEN SetHotkey(tab[i], pos[i]) END;
INC(i)
END
END SetHotkeys;
PROCEDURE UpdateHotkey (VAR old, new: Dialog.String);
VAR i, j: INTEGER; used: SET; ch: CHAR;
BEGIN
GetHotkey(new, i, used);
IF i = -1 THEN
used := {}; GetHotkey(old, i, used);
IF used # {} THEN
used := -used; i := -1; j := 0;
WHILE j >= 0 DO
ch := CAP(new[j]);
IF ~(ORD(ch) - ORD("A") IN used) THEN
i := j; j := -1
ELSE
j := NextWord(new, j)
END
END;
IF i = -1 THEN i := FirstFree(new, used) END;
IF i >= 0 THEN SetHotkey(new, i) END
END
END
END UpdateHotkey;
(* custom menus *)
PROCEDURE AppendMenu (menu: USER32.Handle; id: INTEGER; name: Dialog.String);
VAR res: INTEGER; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
Dialog.MapString(name, name); ss := SHORT(name$);
res := USER32.AppendMenuA(menu, {}, id, ss)
END AppendMenu;
PROCEDURE FirstMenu* (): Menu;
BEGIN
RETURN menus
END FirstMenu;
PROCEDURE DeleteAll*;
BEGIN
WHILE USER32.RemoveMenu(menuBar, 0, {USER32.MFByPosition}) # 0 DO END;
firstMenu := NIL; lastMenu := NIL; curMenu := NIL;
newWinMenu := 0; newPopMenu := 0;
nextId := firstId
END DeleteAll;
PROCEDURE Open* (menu, type: ARRAY OF CHAR);
BEGIN
ASSERT(curMenu = NIL, 20); ASSERT(menu # "", 21);
NEW(curMenu); curMenu.next := NIL;
curMenu.menuH := USER32.CreatePopupMenu();
(* curMenu.menu := menu$; *)
Dialog.MapString(menu, curMenu.menu);
curMenu.type := type$;
curMenu.firstItem := NIL
END Open;
PROCEDURE AddItem* (item, string, shortcut, filter: Dialog.String);
VAR i: Item; id: INTEGER;
BEGIN
ASSERT(curMenu # NIL, 20); ASSERT(item # "", 21); ASSERT(string # "", 22);
IF string = "HostMenus.WindowList" THEN
curMenu.isWinMenu := TRUE
ELSE
NEW(i); i.next := NIL;
IF curMenu.lastItem = NIL THEN curMenu.firstItem := i ELSE curMenu.lastItem.next := i END;
curMenu.lastItem := i;
StdDialog.AddItem(i, item, string, filter, shortcut);
IF string = "HostMenus.ObjectMenu" THEN id := iObject
ELSE id := nextId; INC(nextId)
END;
i.id := id;
IF id > curMenu.maxId THEN curMenu.maxId := id END
END
END AddItem;
PROCEDURE ChangeItem (m: Menu; i: Item; VAR name: Dialog.String);
VAR res: INTEGER; old: Dialog.String; so: ARRAY 256 OF SHORTCHAR;
BEGIN
res := USER32.GetMenuStringA(m.menuH, i.id, so, LEN(old), {}); old := so$;
UpdateHotkey(old, name);
SetShortcut(i, name)
END ChangeItem;
PROCEDURE AddSeparator*;
VAR i: Item;
BEGIN
ASSERT(curMenu # NIL, 20);
NEW(i); i.next := NIL;
IF curMenu.lastItem = NIL THEN curMenu.firstItem := i ELSE curMenu.lastItem.next := i END;
curMenu.lastItem := i;
StdDialog.AddItem(i, "", "", "", "");
i.id := 0
END AddSeparator;
PROCEDURE Close*;
VAR res, j, n: INTEGER; i: StdDialog.Item;
tab: POINTER TO ARRAY OF Dialog.String; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
ASSERT(curMenu # NIL, 20);
i := curMenu.firstItem; n := 0;
WHILE i # NIL DO i := i.next; INC(n) END;
NEW(tab, n);
i := curMenu.firstItem; j := 0;
WHILE i # NIL DO Dialog.MapString(i.item, tab[j]); (* tab[j] := i.item^$; *)i := i.next; INC(j) END;
SetHotkeys(tab, j);
i := curMenu.firstItem; j := 0;
WHILE i # NIL DO
WITH i: Item DO
IF i.item^ # "" THEN
SetShortcut(i, tab[j]); ss := SHORT(tab[j]$);
IF i.id = iObject THEN
res := USER32.AppendMenuA(curMenu.menuH, {USER32.MFPopup}, objMenu, ss)
ELSE
res := USER32.AppendMenuA(curMenu.menuH, {}, i.id, ss)
END
ELSIF i.next # NIL THEN
res := USER32.AppendMenuA(curMenu.menuH, {USER32.MFSeparator}, 0, NIL)
END
END;
i := i.next; INC(j)
END;
IF curMenu.menu = "*" THEN curMenu.isPopup := TRUE END;
IF curMenu.type = "WindowMenu" THEN curMenu.isWinMenu := TRUE; curMenu.type := "" END;
IF curMenu.isWinMenu THEN newWinMenu := curMenu.menuH
ELSIF curMenu.type = "PopupMenu" THEN newPopMenu := curMenu.menuH
END;
IF lastMenu = NIL THEN firstMenu := curMenu ELSE lastMenu.next := curMenu END;
lastMenu := curMenu; curMenu := NIL
END Close;
PROCEDURE InitMenus*;
VAR m, n, old: Menu; res, i: INTEGER; used, u: SET; tp: Stores.TypeName; oldBar: USER32.Handle;
ss: ARRAY 256 OF SHORTCHAR;
BEGIN
ASSERT(curMenu = NIL, 20);
IF firstMenu # NIL THEN
used := {}; m := firstMenu;
WHILE m # NIL DO GetHotkey(m.menu, m.hot, used); m := m.next END;
m := firstMenu; i := 0;
WHILE m # NIL DO
IF (m.hot = -1) & (m.type = "") THEN m.hot := FirstFree(m.menu, used) END;
IF m.isWinMenu THEN m.class := 4; i := 100
ELSIF m.isPopup THEN m.class := 10
ELSIF i = 0 THEN m.class := 0
ELSIF i < 3 THEN m.class := 1
ELSIF i < 100 THEN m.class := 3
ELSE m.class := 5
END;
m := m.next; INC(i)
END;
m := firstMenu;
WHILE m # NIL DO
IF m.hot = -1 THEN
tp := m.type$; u := used; n := m;
WHILE n # NIL DO
IF (n.hot = -1) & (n.type = tp) THEN n.hot := FirstFree(n.menu, u) END;
n := n.next
END
END;
IF m.hot >= 0 THEN SetHotkey(m.menu, m.hot) END;
m := m.next
END;
newMenuBar := USER32.CreateMenu();
m := firstMenu;
WHILE m # NIL DO
IF ((m.type = "") OR (m.type = type)) & ~m.isPopup THEN
ss := SHORT(m.menu$);
res := USER32.AppendMenuA(newMenuBar, {USER32.MFPopup}, m.menuH, ss)
END;
m := m.next
END;
oldBar := menuBar; menuBar := newMenuBar;
winMenu := newWinMenu; popMenu := newPopMenu;
old := menus; menus := firstMenu; lastId := nextId;
IF UpdateOleMenus # NIL THEN UpdateOleMenus() END;
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDISetMenu, menuBar, winMenu);
IF res # 0 THEN
res := USER32.DrawMenuBar(HostWindows.main);
m := old;
WHILE m # NIL DO (* prevent submenus from being deleted *)
WHILE USER32.RemoveMenu(m.menuH, 0, {USER32.MFByPosition}) # 0 DO END;
res := USER32.DestroyMenu(m.menuH);
m := m.next
END;
res := USER32.DestroyMenu(oldBar)
END
END
END InitMenus;
(* Menu Dispatching *)
PROCEDURE Cascade*;
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDICascade, 2, 0)
END Cascade;
PROCEDURE TileHorizontal*;
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDITile, 3, 0)
END TileHorizontal;
PROCEDURE TileVertical*;
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDITile, 2, 0)
END TileVertical;
PROCEDURE ArrangeIcons*;
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDIIconArrange, 0, 0)
END ArrangeIcons;
PROCEDURE Exit*;
VAR res: INTEGER;
BEGIN
res := USER32.SendMessageA(HostWindows.main, USER32.WMClose, 0, 0)
END Exit;
PROCEDURE SetFocus;
VAR c: Containers.Controller; f: Views.Frame; v, s: Views.View;
BEGIN
f := Controllers.FocusFrame(); v := f.view;
WITH v: Containers.View DO
c := v.ThisController();
s := c.Singleton();
IF s # NIL THEN c.SetFocus(s) END
ELSE
END
END SetFocus;
PROCEDURE OpenWindow;
VAR c: Containers.Controller; f: Views.Frame; v, s: Views.View; doc: Documents.Document;
win: Windows.Window; title: Views.Title;
BEGIN
f := Controllers.FocusFrame(); v := f.view;
WITH v: Containers.View DO
c := v.ThisController();
s := c.Singleton();
IF (s # NIL) & (s.ThisModel() # NIL) THEN
win := Windows.dir.Focus(Controllers.frontPath); ASSERT(win # NIL, 100);
doc := win.doc.DocCopyOf(s);
c := doc.ThisController();
c.SetOpts(c.opts - {Documents.pageWidth, Documents.pageHeight}
+ {Documents.winWidth, Documents.winHeight});
(* Stores.InitDomain(doc, v.domain); done by DocCopyOf *)
win.GetTitle(title);
Windows.dir.OpenSubWindow(Windows.dir.New(), doc, {Windows.isAux}, title)
END
ELSE
END
END OpenWindow;
PROCEDURE HandleVerb (n: INTEGER);
VAR v: Views.View; dvm: Properties.DoVerbMsg;
BEGIN
v := Containers.FocusSingleton();
IF v # NIL THEN
dvm.frame := Views.ThisFrame(Controllers.FocusFrame(), v);
dvm.verb := SHORT(n);
Views.HandlePropMsg(v, dvm)
END
END HandleVerb;
PROCEDURE CheckVerb (v: Views.View; n: INTEGER; VAR pvm: Properties.PollVerbMsg);
BEGIN
pvm.verb := SHORT(n);
pvm.label := "";
pvm.disabled := FALSE; pvm.checked := FALSE;
Views.HandlePropMsg(v, pvm)
END CheckVerb;
PROCEDURE PrimaryVerb*;
VAR v: Views.View; pvm: Properties.PollVerbMsg;
BEGIN
v := Containers.FocusSingleton();
IF v # NIL THEN
CheckVerb(v, 0, pvm);
IF pvm.label # "" THEN HandleVerb(0)
ELSE SetFocus
END
END
END PrimaryVerb;
(*
PROCEDURE ObjProperties*;
VAR res: INTEGER; p, q: Properties.Property; s: Views.View;
BEGIN
Properties.CollectProp(p);
s := Containers.FocusSingleton();
IF s # NIL THEN
q := p;
WHILE (q # NIL) & ~(q IS Controls.Prop) DO q := q.next END;
IF q # NIL THEN
Dialog.Call(
"DevInspector.InitDialog; StdCmds.OpenToolDialog('DevInspector.inspect', '#Host:ControlInspector')"
, "", res);
IF res = 0 THEN RETURN END
END
END;
q := p;
WHILE (q # NIL) & ~(q IS Properties.StdProp) DO q := q.next END;
IF (q # NIL) & (Properties.typeface IN p.known) THEN
HostDialog.FontDialog
END
END ObjProperties;
*)
PROCEDURE ObjectMenu*;
BEGIN
HALT(127)
END ObjectMenu;
PROCEDURE WindowList*;
BEGIN
HALT(127)
END WindowList;
(*
PROCEDURE PropertiesGuard* (VAR par: Dialog.Par);
VAR res: INTEGER; p, q: Properties.Property; s: Views.View;
BEGIN
Properties.CollectProp(p);
s := Containers.FocusSingleton();
IF s # NIL THEN
q := p;
WHILE (q # NIL) & ~(q IS Controls.Prop) DO q := q.next END;
IF q # NIL THEN RETURN END
END;
q := p;
WHILE (q # NIL) & ~(q IS Properties.StdProp) DO q := q.next END;
IF (q # NIL) & (Properties.typeface IN p.known) THEN RETURN END;
par.disabled := TRUE
END PropertiesGuard;
*)
PROCEDURE ObjectMenuGuard* (VAR par: Dialog.Par);
VAR v: Views.View; pvm: Properties.PollVerbMsg; i, id, res: INTEGER; msg: TypeMsg; str: Dialog.String;
BEGIN
v := Containers.FocusSingleton();
IF v # NIL THEN
(* remove old object menu entries *)
WHILE USER32.RemoveMenu(objMenu, 0, {USER32.MFByPosition}) # 0 DO END;
(* insert verbs *)
i := 0; id := iVerb0;
CheckVerb(v, 0, pvm);
IF pvm.label = "" THEN
AppendMenu(objMenu, iObjEdit, "#Host:Edit");
AppendMenu(objMenu, iObjOpen, "#Host:Open");
IF v.ThisModel() = NIL THEN
res := USER32.EnableMenuItem(objMenu, iObjOpen, {USER32.MFGrayed})
END;
INC(i); INC(id);
CheckVerb(v, i, pvm)
END;
WHILE (id < firstId) & (pvm.label # "") DO
str := pvm.label$;
AppendMenu(objMenu, id, str);
IF pvm.disabled THEN res := USER32.EnableMenuItem(objMenu, id, {USER32.MFGrayed}) END;
IF pvm.checked THEN res := USER32.CheckMenuItem(objMenu, id, {USER32.MFChecked}) END;
INC(i); INC(id);
CheckVerb(v, i, pvm)
END;
msg.type := "";
Views.HandlePropMsg(v, msg);
IF msg.type # "" THEN
Dialog.MapString("#Host:Object", str);
par.label := msg.type + " " + str
ELSE
Dialog.MapString("#Host:Object", par.label)
END
ELSE
par.disabled := TRUE;
Dialog.MapString("#Host:Object", par.label)
END
END ObjectMenuGuard;
PROCEDURE ^ UpdateType ();
PROCEDURE PopupMenu*;
VAR f: Views.Frame; res, x, y: INTEGER; d: BOOLEAN; pt: USER32.Point; m: SET;
menu: Menu; menuH: USER32.Handle;
BEGIN
f := Controllers.FocusFrame();
IF (f # NIL) & f.front THEN
UpdateType();
menu := menus;
WHILE (menu # NIL) & (~menu.isPopup OR (menu.type # "") & (menu.type # type)) DO
menu := menu.next
END;
IF menu # NIL THEN menuH := menu.menuH ELSE menuH := popMenu END;
IF USER32.GetCapture() # 0 THEN f.Input(x, y, m, d)
ELSE x := (f.l + f.r) DIV 2; y := (f.t + f.b) DIV 2
END;
pt.x := (x + f.gx) DIV f.unit; pt.y := (y + f.gy) DIV f.unit;
res := USER32.ClientToScreen(f.rider(HostPorts.Rider).port.wnd, pt);
res := USER32.TrackPopupMenu(menuH, {1}, pt.x, pt.y + 2, 0, HostWindows.main, NIL)
END
END PopupMenu;
(* menu dispatching *)
PROCEDURE PrepareMenu (wnd, menu: USER32.Handle; lParam: INTEGER);
(* this procedure is called after the user has clicked into the menu bar, but before
showing the menu; to prepare item enabling/disabling, check marks, etc. *)
VAR res, n: INTEGER; failed, ok: BOOLEAN; par: Dialog.Par; m: Menu; i: StdDialog.Item; str: Dialog.String;
ss: ARRAY 256 OF SHORTCHAR;
BEGIN
m := menus;
WHILE (m # NIL) & (m.menuH # menu) DO m := m.next END;
IF m # NIL THEN
i := m.firstItem; n := 0;
WHILE i # NIL DO
WITH i: Item DO
IF i.filter^ # "" THEN (* custom menu item with custom guard *)
StdDialog.CheckFilter(i, failed, ok, par);
IF ~failed THEN
IF par.label = "-" THEN
IF ~i.del THEN
res := USER32.RemoveMenu(m.menuH, n, {USER32.MFByPosition});
i.del := TRUE
END;
DEC(n)
ELSE
IF i.del THEN
res := USER32.InsertMenuA(m.menuH, n, {USER32.MFByPosition}, i.id, "+");
i.del := FALSE
END;
IF par.label # i.item$ THEN
Dialog.MapString(par.label, str);
ChangeItem(m, i, str); ss := SHORT(str$);
IF i.id = iObject THEN
res := USER32.ModifyMenuA(
m.menuH, n, {USER32.MFByPosition, USER32.MFPopup}, objMenu, ss)
ELSE
res := USER32.ModifyMenuA(m.menuH, n, {USER32.MFByPosition}, i.id, ss)
END
END;
IF par.disabled THEN
res := USER32.EnableMenuItem(
m.menuH, n, {USER32.MFByPosition, USER32.MFGrayed})
ELSE
res := USER32.EnableMenuItem(m.menuH, n, {USER32.MFByPosition})
END;
IF par.checked & ~ODD(USER32.GetMenuState(m.menuH, n, {USER32.MFByPosition}))
THEN
res := USER32.CheckMenuItem(
m.menuH, n, {USER32.MFByPosition, USER32.MFChecked})
ELSE
res := USER32.CheckMenuItem(m.menuH, n, {USER32.MFByPosition})
END;
IF ~ok THEN
(* mark with "?" !!! *)
res := USER32.EnableMenuItem(
m.menuH, n, {USER32.MFByPosition, USER32.MFGrayed})
END
END
END
END
END;
i := i.next; INC(n)
END
END
END PrepareMenu;
PROCEDURE HandleCustomMenu (id: INTEGER);
VAR m: Menu; i: StdDialog.Item;
BEGIN
m := menus;
WHILE (m # NIL) & (m.maxId < id) DO m := m.next END;
IF m # NIL THEN i := m.firstItem;
WHILE (i # NIL) & (i(Item).id # id) DO i := i.next END;
IF i # NIL THEN StdDialog.HandleItem(i) END
END
END HandleCustomMenu;
PROCEDURE MenuCommand (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR res, id: INTEGER; old: USER32.Handle;
BEGIN
old := USER32.SetCursor(HostPorts.cursors[HostPorts.busyCursor]);
Dialog.ShowStatus("");
DEC(gc); id := wParam MOD 65536;
CASE id OF
| iClose: HostCmds.Close
| iUndo: StdCmds.Undo
| iCut: HostCmds.Cut
| iCopy: HostCmds.Copy
| iPaste: HostCmds.Paste
| iOpen: HostCmds.Open
| iExit: Exit
| iUpdateMenus: Dialog.Call("StdMenuTool.UpdateAllMenus", "", res)
| iPopup: PopupMenu
| iObjEdit: SetFocus
| iObjOpen: OpenWindow
| iProperties: StdCmds.ShowProp
ELSE
IF id < firstId THEN HandleVerb(id - iVerb0)
ELSE
res := 0; (* prevent from parasitic anchors on stack *)
HandleCustomMenu(id)
END
END;
Properties.IncEra;
old := USER32.SetCursor(old)
END MenuCommand;
PROCEDURE TranslateAccelerators (VAR msg: USER32.Message; filter: SET; VAR done: BOOLEAN);
VAR m: Menu; i: StdDialog.Item; id, code: INTEGER; ctrl, shift, alt: BOOLEAN; ch: CHAR;
failed, ok: BOOLEAN; par: Dialog.Par;
BEGIN
IF (msg.message = USER32.WMSysKeyDown) OR (msg.message = USER32.WMKeyDown) THEN
code := msg.wParam; id := 0; ch := 0X;
shift := USER32.GetKeyState(10H) < 0;
ctrl := USER32.GetKeyState(11H) < 0;
alt := ODD(msg.lParam DIV 20000000H);
IF 1 IN filter THEN
IF shift & (code = 79H) THEN id := iPopup (* shift F10 *)
ELSIF alt THEN
IF code = 08H THEN id := iUndo (* alt bs *)
ELSIF code = 0DH THEN id := iProperties (* alt enter *)
ELSIF code = 5DH THEN id := iProperties (* alt application *)
ELSIF (code = minusCode) & shift THEN ch := NBHYPHEN
ELSIF (code = ORD(" ")) & shift THEN ch := NBSPACE
END
ELSIF ctrl THEN
IF code = ORD(" ") THEN
IF shift THEN ch := NUMSPACE END
ELSIF code = 2DH THEN
id := iCopy (* ctrl insert *)
ELSIF code = minusCode THEN
IF shift THEN ch := SOFTHYPHEN ELSE ch := HYPHEN END
END
ELSIF shift THEN
IF code = 2EH THEN id := iCut (* shift delete *)
ELSIF code = 2DH THEN id := iPaste (* shift insert *)
END
ELSIF code = 5DH THEN id := iPopup (* application *)
ELSIF code = 1BH THEN done := TRUE (* esc *)
END
END;
IF (id = 0) & ~alt & (ctrl OR (code >= 70H) & (code <= 7FH)) (* function key *) THEN
m := menus;
WHILE (m # NIL) & (id = 0) DO
IF ((m.type = "") OR (m.type = type)) & ~m.isPopup & (m.class IN filter) THEN
i := m.firstItem;
WHILE (i # NIL) &
((i(Item).code # code) OR (i(Item).ctrl # ctrl) OR (i(Item).shift # shift)) DO i := i.next END;
IF i # NIL THEN
IF i.filter^ # "" THEN StdDialog.CheckFilter(i, failed, ok , par) END;
IF (i.filter^ = "") OR ~failed & ~par.disabled THEN id := i(Item).id END
END
END;
m := m.next
END
END;
IF id # 0 THEN
msg.message := USER32.WMCommand; msg.wParam := id + 65536;
msg.wnd := HostWindows.main; msg.lParam := 0; done := TRUE
ELSIF ch # 0X THEN
msg.message := USER32.WMChar; msg.wParam := ORD(ch); done := TRUE
END
END
END TranslateAccelerators;
PROCEDURE OpenFile (VAR name: ARRAY OF SHORTCHAR; l, t, r, b: INTEGER; VAR ok: BOOLEAN);
VAR res: INTEGER; loc: Files.Locator; np: KERNEL32.StringPtr; path: HostFiles.FullName;
file: Files.Name; v: Views.View; conv: Converters.Converter; f: Files.File;
sp: ARRAY 260 OF SHORTCHAR;
BEGIN
ok := FALSE;
res := KERNEL32.GetFullPathNameA(name, LEN(path), sp, np);
IF np # NIL THEN
file := np^$;
IF file # "" THEN
DEC(SYSTEM.VAL(INTEGER, np)); np^[0] := 0X; path := sp$;
loc := HostFiles.NewLocator(path);
f := Files.dir.Old(loc, file, Files.shared);
IF f # NIL THEN
conv := Converters.list;
WHILE (conv # NIL) & (conv.fileType # f.type) DO conv := conv.next END;
IF conv = NIL THEN
conv := Converters.list;
WHILE (conv # NIL) & ~(impAll IN conv.opts) DO conv := conv.next END
END;
IF f.type = "" THEN file := file + "." END;
v := Views.Old(Views.dontAsk, loc, file, conv);
IF v # NIL THEN
HostWindows.dir.l := l; HostWindows.dir.t := t; HostWindows.dir.r := r; HostWindows.dir.b := b;
Views.Open(v, loc, file, conv); ok := TRUE;
HostWindows.dir.l := 0; HostWindows.dir.t := 0; HostWindows.dir.r := 0; HostWindows.dir.b := 0
END
END
END
END
END OpenFile;
PROCEDURE IncludingFileCommandLine(
IN line: ARRAY [untagged] OF SHORTCHAR
): POINTER TO ARRAY OF SHORTCHAR;
VAR f: Files.File; r: Files.Reader; i, len: INTEGER;
header: ARRAY 12 OF BYTE; keyword: ARRAY 12 OF CHAR;
b: POINTER TO ARRAY OF BYTE;
l2: POINTER TO ARRAY OF SHORTCHAR;
BEGIN
len := LEN(line$);
f := Files.dir.Old(Files.dir.This(cmdLinePath), cmdLineFile, Files.shared);
IF (f # NIL) & (f.Length() > LEN(header)) THEN
r := f.NewReader(NIL); r.ReadBytes(header, 0, LEN(header));
FOR i := 0 TO LEN(header) - 1 DO keyword[i] := CHR(header[i]) END;
keyword[LEN(keyword) - 1] := 0X;
IF keyword = 'COMMANDLINE' THEN
NEW(b, f.Length() - LEN(header)); NEW(l2, LEN(b) + len + 1);
r.ReadBytes(b, 0, LEN(b));
FOR i := 0 TO len - 1 DO l2[i] := line[i] END; l2[i] := " ";
FOR i := 0 TO LEN(b) - 1 DO l2[i + len + 1] := SHORT(CHR(b[i])) END;
RETURN l2
END
END;
NEW(l2, len);
FOR i := 0 TO len - 1 DO l2[i] := line[i] END;
RETURN l2
END IncludingFileCommandLine;
(* обработка командной строки *)
PROCEDURE ReadCommandLine (IN line: ARRAY [untagged] OF SHORTCHAR; open: BOOLEAN);
VAR name, opt: ARRAY 260 OF SHORTCHAR; i, l, t, r, b, res: INTEGER;
ok: BOOLEAN; ln: ARRAY 260 OF CHAR;
PROCEDURE CopyName;
VAR ch, tch: SHORTCHAR; j: INTEGER;
BEGIN
j := 0; ch := line[i]; tch := " ";
WHILE ch = " " DO INC(i); ch := line[i] END;
IF (ch = "'") OR (ch = '"') THEN tch := ch; INC(i); ch := line[i] END;
WHILE (ch >= " ") & (ch # tch) DO
name[j] := ch;
(*
IF (ch >= "a") & (ch <= "z") OR (ch >= "а") OR (ch = "ё") THEN
ch := SHORT(National.Cap(ch))
ELSIF ch = "-" THEN ch := "/"
END;
*)
ch := SHORT( i21sysCharacters.Cap(ch) );
IF ch = "-" THEN ch := "/" END;
opt[j] := ch; INC(j); INC(i); ch := line[i]
END;
IF ch > " " THEN INC(i); ch := line[i] END;
WHILE (ch # 0X) & (ch <= " ") DO INC(i); ch := line[i] END;
name[j] := 0X; opt[j] := 0X
END CopyName;
BEGIN
l := 0; t := 0; r := 0; b := 0; i := 0;
CopyName; (* skip program name *)
WHILE line[i] > " " DO
CopyName;
IF opt = "/LOAD" THEN (* load module *)
CopyName; ln := name$;
IF open THEN Kernel.LoadMod(ln) END
ELSIF opt = "/USE" THEN (* use directory *)
CopyName (* working directory: handled in HostFiles *)
ELSIF opt = "/P" THEN (* print file *) (* to be completed !!! *)
CopyName;
IF open THEN
OpenFile(name, 0, 0, 0, 0, ok);
IF ok THEN HostCmds.Print END
END
ELSIF opt = "/PT" THEN (* print file to printer *)
CopyName; CopyName; CopyName; CopyName (* to be completed !!! *)
ELSIF opt = "/EMBEDDING" THEN (* start as server *)
IF ~open THEN state := embedded END
ELSIF opt = "/NOAPPWIN" THEN (* start without application window *)
IF ~open THEN state := noAppWin; HostWindows.noAppWin := TRUE END
ELSIF opt = "/NOSCROLL" THEN (* no scroll bars in application window *)
HostWindows.noClientScroll := TRUE
ELSIF opt = "/FULLSIZE" THEN
HostWindows.fullSize := TRUE
ELSIF opt = "/FULLSCREEN" THEN
HostWindows.fullScreen := TRUE
ELSIF opt = "/LTRB" THEN (* window position *)
CopyName; ln := name$; Strings.StringToInt(ln, l, res);
CopyName; ln := name$; Strings.StringToInt(ln, t, res);
CopyName; ln := name$; Strings.StringToInt(ln, r, res);
CopyName; ln := name$; Strings.StringToInt(ln, b, res)
ELSIF opt = "/LANG" THEN
CopyName; ln := name$;
IF LEN(ln$) = 2 THEN Strings.ToLower(ln, ln); Dialog.SetLanguage(ln$, Dialog.nonPersistent) END
ELSIF opt = "/O" THEN (* open file *)
CopyName; openUsed := TRUE;
IF open THEN OpenFile(name, l, t, r, b, ok) END;
openParam := '/O "' + name$ + '"';
l := 0; t := 0; r := 0; b := 0
ELSIF opt = "/PAR" THEN
CopyName;
Dialog.commandLinePars := name$
ELSE (* open file *)
IF open THEN OpenFile(name, l, t, r, b, ok) END;
l := 0; t := 0; r := 0; b := 0
END
END
END ReadCommandLine;
PROCEDURE DropFiles (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR i, n, res: INTEGER; name: ARRAY 260 OF SHORTCHAR; ok: BOOLEAN;
BEGIN
IF state = noAppWin THEN RETURN END;
n := SHELL32.DragQueryFileA(wParam, -1, name, LEN(name)); i := 0;
WHILE i < n DO
res := SHELL32.DragQueryFileA(wParam, i, name, LEN(name));
OpenFile(name, 0, 0, 0, 0, ok);
IF ok THEN res := USER32.SetForegroundWindow(HostWindows.main) END;
INC(i)
END;
SHELL32.DragFinish(wParam)
END DropFiles;
(* main window handler *)
PROCEDURE Quit (wnd: USER32.Handle; wParam, lParam: INTEGER);
BEGIN
HostCmds.Quit
END Quit;
PROCEDURE UpdateMenus;
VAR res: INTEGER; m: Menu; old: USER32.Handle; ss: ARRAY 256 OF SHORTCHAR;
BEGIN
old := menuBar; menuBar := USER32.CreateMenu();
m := menus;
WHILE m # NIL DO
IF ((m.type = "") OR (m.type = type)) & ~m.isPopup THEN
ss := SHORT(m.menu$);
res := USER32.AppendMenuA(menuBar, {USER32.MFPopup}, m.menuH, ss)
END;
m := m.next
END;
res := USER32.SendMessageA(HostWindows.client, USER32.WMMDISetMenu, menuBar, winMenu);
res := USER32.DrawMenuBar(HostWindows.main);
WHILE USER32.RemoveMenu(old, 0, {USER32.MFByPosition}) # 0 DO END;
res := USER32.DestroyMenu(old)
END UpdateMenus;
PROCEDURE UpdateType;
VAR ops: Controllers.PollOpsMsg;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
Controllers.PollOps(ops);
IF (ops.type # type) & (menus # NIL) & (USER32.GetMenu(HostWindows.main) = menuBar) THEN
type := ops.type$;
UpdateMenus
END;
Controllers.ResetCurrentPath()
END UpdateType;
PROCEDURE TimerTick (wnd: USER32.Handle; wParam, lParam: INTEGER);
BEGIN
IF ~Log.synch THEN Log.FlushBuf END;
IF ~HostCFrames.inHandleMouse THEN HostWindows.Idle END;
UpdateType()
END TimerTick;
PROCEDURE Flush (wnd: USER32.Handle; wParam, lParam: INTEGER);
BEGIN
HostClipboard.Flush
END Flush;
PROCEDURE [2] ApplWinHandler (wnd: USER32.Handle; message, wParam, lParam: INTEGER): INTEGER;
TYPE PPS = POINTER TO USER32.PaintStruct; PR = POINTER TO USER32.Rect;
VAR res: INTEGER; w: USER32.Handle; r: USER32.Rect; hit: BOOLEAN;
Proc: PROCEDURE; s: ARRAY 256 OF SHORTCHAR;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
CASE message OF
| USER32.WMClose, USER32.WMQueryEndSession:
Kernel.Try(Quit, wnd, wParam, lParam);
IF HostCmds.quit THEN
HostWindows.SaveWindowState;
IF locks = 0 THEN
Kernel.Try(Flush, wnd, 0, 0)
ELSE
state := hidden;
res := USER32.ShowWindow(HostWindows.main, USER32.SWHide);
Controllers.ResetCurrentPath();
RETURN 0
END
ELSE gc := 0;
Controllers.ResetCurrentPath();
RETURN 0
END
| USER32.WMDestroy:
USER32.PostQuitMessage(0);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMActivate:
IF debug THEN Log.String("activate hack"); Log.Ln END;
res := USER32.GetUpdateRect(wnd, r, 1); (* forces a WMEraseBkGnd msg (fixes bug in Win32s!) *)
IF wParam MOD 65536 # 0 THEN HostWindows.ActivateMain(TRUE) END
| USER32.WMNCActivate:
IF wParam MOD 65536 = 0 THEN HostWindows.ActivateMain(FALSE) END
| USER32.WMCommand:
Controllers.SetCurrentPath(Controllers.frontPath);
(* prevent from parasitic anchors on stack *)
res := 0; w := 0; r.left := 0; r.top := 0; r.right := 0; r.bottom := 0; hit := FALSE;
Kernel.Try(MenuCommand, wnd, wParam, lParam);
Controllers.ResetCurrentPath()
| USER32.WMInitMenuPopup:
Controllers.SetCurrentPath(Controllers.frontPath);
Kernel.Try(PrepareMenu, wnd, wParam, lParam);
Controllers.ResetCurrentPath()
(*
| USER32.WMRenderFormat:
Kernel.Try(Export, wnd, wParam, 0)
| USER32.WMRenderAllFormats:
Kernel.Try(Export, wnd, 0, 0)
| USER32.WMPaintClipboard:
pps := SYSTEM.VAL(PPS, KERNEL32.GlobalLock(lParam));
HostWindows.PaintClipboard(wParam, pps^);
res := KERNEL32.GlobalUnlock(lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMSizeClipboard:
pr := SYSTEM.VAL(PR, KERNEL32.GlobalLock(lParam));
HostWindows.SizeClipboard(wParam, pr.right, pr.bottom);
res := KERNEL32.GlobalUnlock(lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMHScrollClipboard:
HostWindows.ScrollClipboard(wParam, lParam MOD 65536, lParam DIV 65536 MOD 65536, FALSE);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMVScrollClipboard:
HostWindows.ScrollClipboard(wParam, lParam MOD 65536, lParam DIV 65536 MOD 65536, TRUE);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMAskCBFormatName:
SYSTEM.MOVE(SYSTEM.ADR("BlackBox"), lParam, 9);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMDestroyClipboard:
HostClipboard.Destroy;
Controllers.ResetCurrentPath();
RETURN 0
*)
| USER32.WMSysColorChange:
IF HostWindows.ctl3d # 0 THEN
SYSTEM.PUT(
SYSTEM.ADR(Proc), KERNEL32.GetProcAddress(HostWindows.ctl3d, "Ctl3dColorChange"));
IF Proc # NIL THEN Proc() END
END;
HostPorts.ResetColors;
res := GDI32.DeleteObject(HostPorts.dialogBrush);
HostPorts.dialogBrush := GDI32.CreateSolidBrush(Ports.dialogBackground)
| USER32.WMDropFiles:
Kernel.Try(DropFiles, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMTimer:
Kernel.Try(TimerTick, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMSize:
HostWindows.ResizeMainWindow(wParam, lParam MOD 65536, lParam DIV 65536);
Controllers.ResetCurrentPath();
IF HostWindows.mainHook # NIL THEN
HostWindows.mainHook.Resize(lParam MOD 65536, lParam DIV 65536)
END;
RETURN 0
| USER32.WMSetFocus:
IF HostWindows.mainHook # NIL THEN HostWindows.mainHook.Focus(TRUE) END
| USER32.WMKillFocus:
IF HostWindows.mainHook # NIL THEN HostWindows.mainHook.Focus(FALSE) END
| USER32.WMActivateApp:
IF HostWindows.mainHook # NIL THEN HostWindows.mainHook.Activate(wParam # 0) END
| USER32.WMCtlColorStatic: (* status bar colors *)
res := GDI32.SetTextColor(wParam, HostPorts.dialogTextCol);
res := GDI32.SetBkColor(wParam, Ports.dialogBackground);
Controllers.ResetCurrentPath();
RETURN HostPorts.dialogBrush
ELSE
IF (message = msgId) & ~disablePipe THEN
IF (wParam >= 0FFFFC000H) & (wParam < 0) THEN
HostWindows.ShowMain; state := running;
IF USER32.IsIconic(HostWindows.main) # 0 THEN
res := USER32.ShowWindow(HostWindows.main, WinApi.SW_RESTORE)
END;
res := WinApi.GlobalGetAtomName(SHORT(wParam), s, LEN(s));
ReadCommandLine(s, TRUE);
res := WinApi.GlobalAddAtom("<file_opened>");
res := WinApi.GlobalDeleteAtom(SHORT(wParam))
END;
Controllers.ResetCurrentPath();
RETURN 0
END
END;
Controllers.ResetCurrentPath();
RETURN USER32.DefFrameProcA(wnd, HostWindows.client, message, wParam, lParam)
END ApplWinHandler;
(* Initialization *)
PROCEDURE CreateDefaultMenu;
VAR res: INTEGER;
BEGIN
defMenu := USER32.CreatePopupMenu();
res := USER32.AppendMenuA(defMenu, {}, iOpen, "&Open");
res := USER32.AppendMenuA(defMenu, {}, iUpdateMenus, "&Menu");
res := USER32.AppendMenuA(defMenu, {USER32.MFSeparator}, 0, NIL);
res := USER32.AppendMenuA(defMenu, {}, iExit, "E&xit");
menuBar := USER32.CreateMenu(); winMenu := 0; popMenu := 0;
res := USER32.AppendMenuA(menuBar, {USER32.MFPopup}, defMenu, "&File")
END CreateDefaultMenu;
PROCEDURE DestroyMenus; (* module terminator *)
VAR res: INTEGER; m: Menu; Proc: PROCEDURE(i: USER32.Handle);
BEGIN
m := menus;
WHILE m # NIL DO
res := USER32.DestroyMenu(m.menuH);
m := m.next
END;
IF HostWindows.ctl3d # 0 THEN
SYSTEM.PUT(SYSTEM.ADR(Proc), KERNEL32.GetProcAddress(HostWindows.ctl3d, "Ctl3dUnregister"));
IF Proc # NIL THEN Proc(KERNEL32.GetModuleHandleA(NIL)) END
END
END DestroyMenus;
(* main event loop *)
PROCEDURE Loop;
VAR res, n: INTEGER; msg: USER32.Message; done: BOOLEAN; f: SET; w: HostWindows.Window;
BEGIN
HostWindows.dir.invisible := FALSE;
IF state = hidden THEN HostWindows.ShowMain; state := running END;
gc := 0; n := 0;
WHILE USER32.GetMessageA(msg, 0, 0, 0) # 0 DO
CheckFpu;
IF USER32.IsWindowVisible(HostWindows.main) # 0 THEN state := running END;
done := FALSE;
IF isCont & (TranslateOleKeys1 # NIL) THEN
TranslateOleKeys1(SYSTEM.VAL(WinApi.MSG, msg), done)
END;
IF ~done & ~isObj THEN
done := USER32.TranslateMDISysAccel(HostWindows.client, msg) # 0
END;
IF ~done THEN
IF isObj THEN f := {1, 3, 5} ELSIF isCont THEN f := {0, 2, 4} ELSE f := {0..5} END;
TranslateAccelerators(msg, f, done);
IF ~done & isObj & (TranslateOleKeys2 # NIL) THEN
TranslateOleKeys2(SYSTEM.VAL(WinApi.MSG, msg), done)
ELSE done := FALSE
END;
IF ~done THEN
res := USER32.TranslateMessage(msg);
res := USER32.DispatchMessageA(msg)
END;
Services.actionHook.Loop
END;
INC(n);
IF (n > num) OR (USER32.PeekMessageA(msg, 0, 0, 0, 0) = 0) THEN
Windows.dir.Update(NIL); n := 0
END;
IF state = hidden THEN DEC(gc) END;
IF ((gc <= 0) OR Kernel.WouldFinalize()) & ~HostCmds.quit THEN
msg.message := 0; msg.wnd := 0; msg.wParam := 0; msg.lParam := 0;
msg.time := 0; msg.pt.x := 0; msg.pt.y := 0; res := 0;
Kernel.Collect; gc := gcCycle
END;
IF state = noAppWin THEN
w := HostWindows.dir.First();
WHILE (w # NIL) & ~(Windows.isTool IN w.flags) DO w := HostWindows.dir.Next(w) END;
IF w = NIL THEN Exit ELSE w := NIL END
END
END;
Kernel.Quit(msg.wParam)
(* never returns *)
END Loop;
PROCEDURE OpenApp*;
VAR res: INTEGER; Proc: PROCEDURE(i: USER32.Handle); atom: SHORTINT;
BEGIN
IF HostWindows.ctl3d # 0 THEN
SYSTEM.PUT(
SYSTEM.ADR(Proc), KERNEL32.GetProcAddress(HostWindows.ctl3d, "Ctl3dAutoSubclass"));
IF Proc # NIL THEN Proc(KERNEL32.GetModuleHandleA(NIL)) END
END;
ReadCommandLine(IncludingFileCommandLine(KERNEL32.GetCommandLineA()), FALSE);
IF openUsed THEN
atom := WinApi.GlobalAddAtom(openParam);
IF atom # 0 THEN
res := WinApi.SendMessage(-1, msgId, atom, 0);
KERNEL32.Sleep(100);
res := WinApi.GlobalDeleteAtom(atom);
atom := WinApi.GlobalFindAtom("<file_opened>");
IF atom # 0 THEN res := WinApi.GlobalDeleteAtom(atom) END;
IF (atom # 0) OR (res # 0) THEN Kernel.Quit(1) END
END
END;
HostWindows.CreateMainWindows(menuBar, winMenu, ApplWinHandler);
IF state = running THEN HostWindows.ShowMain END;
res := USER32.SetTimer(HostWindows.main, 1, idlePeriod, NIL);
SHELL32.DragAcceptFiles(HostWindows.main, 1);
HostWindows.dir.invisible := TRUE
END OpenApp;
PROCEDURE Run*;
BEGIN
ReadCommandLine(IncludingFileCommandLine(KERNEL32.GetCommandLineA()), TRUE);
Kernel.Start(Loop)
END Run;
PROCEDURE SetNum* (n: INTEGER);
BEGIN
num := n
END SetNum;
PROCEDURE Init;
VAR res: INTEGER; s: ARRAY 256 OF SHORTCHAR;
BEGIN
state := running;
HostCmds.quit := FALSE;
CreateDefaultMenu;
objMenu := USER32.CreatePopupMenu();
lastId := firstId; menus := NIL;
type := "undef";
HostPorts.dialogBrush := GDI32.CreateSolidBrush(Ports.dialogBackground);
minusCode := USER32.VkKeyScanA("-");
IF minusCode # -1 THEN minusCode := minusCode MOD 256 END;
Dialog.MapString("#Host:Shift", shiftStr);
Dialog.MapString("#Host:Ctrl", ctrlStr);
Dialog.MapString("#Host:Space", spaceStr);
gc := 0; num := 10;
res := KERNEL32.GetModuleFileNameA(0, s, LEN(s));
msgId := WinApi.RegisterWindowMessage(s)
END Init;
BEGIN
Kernel.InstallCleaner(Collect);
Init
CLOSE
Kernel.RemoveCleaner(Collect);
DestroyMenus
END HostMenus.
| Host/Mod/Menus.odc |
MODULE HostPackedFiles; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20050626, Fyodor Tkachov, russification edited
- 20050430, Ivan Goryachev, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(* This module depends on the implementation of DevPacker. *)
IMPORT SYSTEM, Files, HostFiles (*, Dialog*), i21sysCharacters;
CONST
packTag* = 12681268H;
version = 1; (* same as in DevPacker *)
TYPE
Directory = POINTER TO RECORD (Files.Directory) END;
PackedDirectory = POINTER TO RECORD (Files.Directory) END;
FileList = POINTER TO RECORD
path, name: Files.Name;
adr, len: INTEGER;
year, month, day, hour, minute, second: INTEGER;
next: FileList
END;
Locator = POINTER TO RECORD
name: Files.Name;
files: FileList;
sublocs: Locator;
next: Locator
END;
File = POINTER TO RECORD (Files.File)
l: FileList;
f: Files.File
END;
Reader = POINTER TO RECORD (Files.Reader)
r: Files.Reader;
base: File
END;
VAR
orgdir: Files.Directory;
stdDir-, packedDir-: Files.Directory;
roots: Locator;
exefile: Files.File;
curloc: HostFiles.Locator;
(* Auxiliary procedures *)
PROCEDURE DebugPrint(IN str: ARRAY OF CHAR);
BEGIN
(*
Dialog.ShowMsg(str)
*)
END DebugPrint;
PROCEDURE ReadInt (r: Files.Reader; OUT x: INTEGER);
VAR b: ARRAY 4 OF BYTE;
BEGIN
r.ReadBytes(b, 0, 4);
x := b[0] MOD 256 + 256 * (b[1] MOD 256 + 256 * (b[2] MOD 256 + 256 * (b[3] MOD 256)))
END ReadInt;
PROCEDURE ReadChar (r: Files.Reader; OUT x: CHAR);
VAR b: ARRAY 2 OF BYTE;
BEGIN
r.ReadBytes(b, 0, 2);
x := SYSTEM.VAL(CHAR, b)
END ReadChar;
PROCEDURE ReadString (r: Files.Reader; OUT x: ARRAY OF CHAR);
VAR i: INTEGER; ch: CHAR;
BEGIN
i := 0; REPEAT ReadChar(r, ch); x[i] := ch; INC(i) UNTIL ch = 0X
END ReadString;
PROCEDURE Diff (VAR a, b: ARRAY OF CHAR; caseSens: BOOLEAN): INTEGER;
VAR i: INTEGER; cha, chb: CHAR;
BEGIN
i := 0;
REPEAT
cha := a[i]; chb := b[i]; INC(i);
IF cha # chb THEN
IF ~caseSens THEN
cha := i21sysCharacters.Cap(cha);
chb := i21sysCharacters.Cap(chb);
END;
IF cha = "\" THEN cha := "/" END;
IF chb = "\" THEN chb := "/" END;
IF cha # chb THEN RETURN ORD(cha) - ORD(chb) END
END
UNTIL cha = 0X;
RETURN 0
END Diff;
PROCEDURE GetType(name: Files.Name; OUT type: Files.Type);
VAR l, i: INTEGER;
BEGIN
l := LEN(name$); type := "";
WHILE (l > 0) & (name[l - 1] # '.') DO DEC(l) END;
FOR i := 0 TO LEN(name$) - l DO type[i] := name[l + i] END
END GetType;
PROCEDURE GetNextSubLoc (path: Files.Name; beg: INTEGER; OUT res: Files.Name; OUT end: INTEGER);
VAR i: INTEGER;
BEGIN
i := 0; res := "";
WHILE (beg < LEN(path$)) & (path[beg] # '/') & (path[beg] # '\') & (path[beg] # ':') DO
res[i] := path[beg];
INC(beg); INC(i)
END;
res[i] := 0X; end := beg
END GetNextSubLoc;
PROCEDURE GetLoc(path: Files.Name; create: BOOLEAN): Locator;
VAR end, diff: INTEGER;sp: Files.Name; loc, tl, last: Locator;
BEGIN
sp := "";
IF path = '' THEN
DebugPrint("Cannot use an empty path.");
RETURN NIL
ELSIF (path[0] = '/') OR (path[0] = '\') THEN (* network path *)
IF (path[1] = '/') OR (path[1] = '\') THEN
GetNextSubLoc(path, 2, sp, end)
ELSE
DebugPrint("Invalid network path.");
RETURN NIL
END
ELSIF path[1] = ':' THEN (* absolute path *)
GetNextSubLoc(path, 0, sp, end)
ELSE
DebugPrint("No absolute path.");
RETURN NIL
END;
IF sp # "" THEN
loc := roots; last := loc;
IF loc # NIL THEN diff := Diff(sp, loc.name, FALSE) END;
WHILE (loc # NIL) & (diff > 0) DO
last := loc; loc := loc.next;
IF loc # NIL THEN diff := Diff(sp, loc.name, FALSE) END
END;
IF ((loc = NIL) OR (diff # 0)) & ~create THEN RETURN NIL END;
IF (loc = NIL) OR (diff < 0) THEN
NEW(loc); loc.name := sp;
IF roots = NIL THEN
roots := loc
ELSE
loc.next := last.next; last.next := loc
END
END;
GetNextSubLoc(path, 3, sp, end);
WHILE sp # "" DO
tl := loc.sublocs; last := NIL;
IF tl # NIL THEN diff := Diff(sp, tl.name, FALSE) END;
WHILE (tl # NIL) & (diff > 0) DO
last := tl; tl := tl.next;
IF tl # NIL THEN diff := Diff(sp, tl.name, FALSE) END
END;
IF (tl = NIL) OR (diff < 0) THEN
IF create THEN
NEW(tl); tl.name := sp;
IF last = NIL THEN
tl.next := loc.sublocs; loc.sublocs := tl
ELSE
tl.next := last.next; last.next := tl
END
ELSE
RETURN NIL
END
END;
loc := tl;
GetNextSubLoc(path, end + 1, sp, end)
END;
RETURN loc
END;
RETURN NIL
END GetLoc;
PROCEDURE ReadResourceTable;
VAR r: Files.Reader; tableadr, int, noff, i: INTEGER; str: Files.Name; l: FileList; loc: Locator;
BEGIN
roots := NIL; r := exefile.NewReader(NIL);
r.SetPos(exefile.Length() - 12);
ReadInt(r, int);
IF int = packTag THEN
ReadInt(r, int);
IF int = version THEN
ReadInt(r, tableadr);
r.SetPos(tableadr); ReadInt(r, noff);
NEW(roots);
FOR i := 0 TO noff - 1 DO
(* Files are packed in reversed alphabetical order,
so adding files at the beginning of the list renders an alphabetically sorted list. *)
NEW(l);
ReadString(r, str); l.path := str; ReadString(r, str); l.name := str;
ReadInt(r, int); l.adr := int; ReadInt(r, int); l.len := int;
ReadInt(r, int); l.year := int; ReadInt(r, int); l.month := int; ReadInt(r, int); l.day := int;
ReadInt(r, int); l.hour := int; ReadInt(r, int); l.minute := int; ReadInt(r, int); l.second := int;
loc := GetLoc(curloc.path + '/' + l.path, TRUE);
l.next := loc.files; loc.files := l
END
END
END
END ReadResourceTable;
PROCEDURE Get (path: HostFiles.FullName; name: Files.Name): Files.File;
VAR
l: FileList; f: File; loc: Locator;
type: Files.Type;
diff: INTEGER;
BEGIN
loc := GetLoc(path$, FALSE);
IF loc # NIL THEN l := loc.files ELSE RETURN NIL END;
IF l # NIL THEN diff := Diff(l.name, name, FALSE) END;
WHILE (l # NIL) & (diff < 0) DO
l := l.next;
IF l # NIL THEN diff := Diff(l.name, name, FALSE) END
END;
IF (l # NIL) & (diff = 0) THEN
NEW(f); f.l := l; f.f := exefile;
GetType(name, type); f.InitType(type);
RETURN f
END;
RETURN NIL
END Get;
(* Files.Directory *)
PROCEDURE (d: Directory) Delete (loc: Files.Locator; name: Files.Name);
BEGIN
orgdir.Delete(loc, name)
END Delete;
PROCEDURE (d: Directory) FileList (floc: Files.Locator): Files.FileInfo;
VAR pi, fi, tfi, nfi, last: Files.FileInfo; diff: INTEGER; caseSens: BOOLEAN;
BEGIN
ASSERT(floc IS HostFiles.Locator, 20);
fi := orgdir.FileList(floc); (* Gives an alphabetically sorted list of files. *)
pi := packedDir.FileList(floc); (* Gives an alphabetically sorted list of files. *)
nfi := NIL; last := NIL; tfi := NIL;
(* Both fi and l are alphabetically sorted. And the returned list also has to be alphabetically sorted. *)
caseSens := floc(HostFiles.Locator).caseSens;
WHILE (pi # NIL) & (fi # NIL) DO
diff := Diff(pi.name, fi.name, caseSens);
IF diff >= 0 THEN
tfi := fi;
fi := fi.next;
IF diff = 0 THEN pi := pi.next END
ELSE
tfi := pi;
pi := pi.next
END;
IF nfi = NIL THEN nfi := tfi ELSE last.next := tfi END;
last := tfi
END;
IF pi # NIL THEN
IF nfi = NIL THEN nfi := pi ELSE last.next := pi END
ELSIF fi # NIL THEN
IF nfi = NIL THEN nfi := fi ELSE last.next := fi END
END;
RETURN nfi
END FileList;
PROCEDURE (d: Directory) GetFileName (name: Files.Name; type: Files.Type; OUT filename: Files.Name);
BEGIN
orgdir.GetFileName(name, type, filename)
END GetFileName;
PROCEDURE (d: Directory) LocList (floc: Files.Locator): Files.LocInfo;
VAR pi, li, nli, last: Files.LocInfo; diff: INTEGER; caseSens: BOOLEAN;
BEGIN
li := orgdir.LocList(floc);
pi := packedDir.LocList(floc);
caseSens := floc(HostFiles.Locator).caseSens;
nli := NIL;
(* Both pi and li are alphabetically ordered. *)
WHILE (pi # NIL) & (li # NIL) DO
diff := Diff(pi.name, li.name, caseSens);
IF diff >= 0 THEN
IF nli = NIL THEN nli := li ELSE last.next := li END; last := li;
li := li.next;
IF diff = 0 THEN pi := pi.next END
ELSE
IF nli = NIL THEN nli := pi ELSE last.next := pi END; last := pi;
pi := pi.next
END
END;
IF pi = NIL THEN
IF nli = NIL THEN nli := li ELSE last.next := li END
ELSE
IF nli = NIL THEN nli := pi ELSE last.next := pi END
END;
RETURN nli
END LocList;
PROCEDURE (d: Directory) New (loc: Files.Locator; ask: BOOLEAN): Files.File;
BEGIN
RETURN orgdir.New(loc, ask)
END New;
PROCEDURE (d: Directory) Old (loc: Files.Locator; name: Files.Name; shared: BOOLEAN): Files.File;
VAR f: Files.File;
BEGIN
f := orgdir.Old(loc, name, shared);
IF f = NIL THEN f := packedDir.Old(loc, name, shared) END;
RETURN f
END Old;
PROCEDURE (d: Directory) Rename (loc: Files.Locator; old, new: Files.Name; ask: BOOLEAN);
BEGIN
orgdir.Rename(loc, old, new, ask)
END Rename;
PROCEDURE (d: Directory) SameFile (
loc0: Files.Locator; name0: Files.Name; loc1: Files.Locator; name1: Files.Name
): BOOLEAN;
BEGIN
RETURN orgdir.SameFile(loc0, name0, loc1, name1)
END SameFile;
PROCEDURE (d: Directory) Temp (): Files.File;
BEGIN
RETURN orgdir.Temp()
END Temp;
PROCEDURE (d: Directory) This (IN path: ARRAY OF CHAR): Files.Locator;
BEGIN
RETURN orgdir.This(path)
END This;
(* PackedDirectory *)
PROCEDURE (d: PackedDirectory) Delete (loc: Files.Locator; name: Files.Name);
BEGIN
loc.res := 4 (* write-protection *)
END Delete;
PROCEDURE (d: PackedDirectory) FileList (floc: Files.Locator): Files.FileInfo;
VAR nfi, tfi, last: Files.FileInfo; loc: Locator; l: FileList; type: Files.Type; hloc: HostFiles.Locator;
BEGIN
ASSERT(floc IS HostFiles.Locator, 20);
hloc := floc(HostFiles.Locator);
loc := GetLoc(hloc.path$, FALSE);
nfi := NIL;
IF loc # NIL THEN
l := loc.files; last := NIL; tfi := NIL;
(* l is alphabetically sorted. And the returned list also has to be alphabetically sorted. *)
WHILE l # NIL DO
GetType(l.name, type);
NEW(tfi); tfi.name := l.name; tfi.type := type; tfi.attr := {Files.readOnly};
tfi.modified.year := l.year; tfi.modified.month := l.month; tfi.modified.day := l.day;
tfi.modified.hour := l.hour; tfi.modified.minute := l.minute; tfi.modified.second := l.second;
IF nfi = NIL THEN nfi := tfi ELSE last.next := tfi END;
last := tfi;
l := l.next
END
END;
RETURN nfi
END FileList;
PROCEDURE (d: PackedDirectory) GetFileName (name: Files.Name; type: Files.Type; OUT filename: Files.Name);
BEGIN
orgdir.GetFileName(name, type, filename)
END GetFileName;
PROCEDURE (d: PackedDirectory) LocList (floc: Files.Locator): Files.LocInfo;
VAR nli, tli, last: Files.LocInfo; loc: Locator; hloc: HostFiles.Locator;
BEGIN
hloc := floc(HostFiles.Locator); nli := NIL;
loc := GetLoc(hloc.path$, FALSE);
IF loc # NIL THEN loc := loc.sublocs END;
(* loc is alphabetically ordered. *)
WHILE loc # NIL DO
NEW(tli); tli.name := loc.name; tli.attr := {Files.readOnly};
IF nli = NIL THEN nli := tli ELSE last.next := tli END;
last := tli;
loc := loc.next
END;
RETURN nli
END LocList;
PROCEDURE (d: PackedDirectory) New (loc: Files.Locator; ask: BOOLEAN): Files.File;
BEGIN
loc.res := 4; (* write-protection *)
RETURN NIL
END New;
PROCEDURE (d: PackedDirectory) Old (loc: Files.Locator; name: Files.Name; shared: BOOLEAN): Files.File;
VAR f: Files.File;
BEGIN
f := NIL;
IF shared THEN
WITH loc: HostFiles.Locator DO
f := Get(loc.path, name)
ELSE
DebugPrint("HostPackedFiles: Directory.Old - This operation requires HostFiles. ")
END
END;
RETURN f
END Old;
PROCEDURE (d: PackedDirectory) Rename (loc: Files.Locator; old, new: Files.Name; ask: BOOLEAN);
BEGIN
loc.res := 4 (* write-protection *)
END Rename;
PROCEDURE (d: PackedDirectory) SameFile (loc0: Files.Locator; name0: Files.Name; loc1: Files.Locator; name1: Files.Name): BOOLEAN;
BEGIN
RETURN orgdir.SameFile(loc0, name0, loc1, name1)
END SameFile;
PROCEDURE (d: PackedDirectory) Temp (): Files.File;
BEGIN
RETURN orgdir.Temp()
END Temp;
PROCEDURE (d: PackedDirectory) This (IN path: ARRAY OF CHAR): Files.Locator;
BEGIN
RETURN orgdir.This(path)
END This;
(* Files.Reader *)
PROCEDURE (r: Reader) Base (): File;
BEGIN
RETURN r.base
END Base;
PROCEDURE (r: Reader) Pos (): INTEGER;
BEGIN
RETURN r.r.Pos() - r.base.l.adr
END Pos;
PROCEDURE (r: Reader) SetPos (pos: INTEGER);
BEGIN
ASSERT(pos <= r.base.l.len, 20);
r.r.SetPos(pos + r.base.l.adr);
r.eof := FALSE
END SetPos;
PROCEDURE (r: Reader) ReadByte (OUT x: BYTE);
BEGIN
IF (r.r.Pos() - r.base.l.adr) >= r.base.l.len THEN
r.eof := TRUE; x := 0
ELSE
r.r.ReadByte(x)
END
END ReadByte;
PROCEDURE (r: Reader) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER);
BEGIN
ASSERT(beg >= 0, 20); ASSERT(len >= 0, 21);
ASSERT(beg + len <= LEN(x), 22);
len := MIN(r.base.l.len, len);
r.r.ReadBytes(x, beg, len);
IF (r.r.Pos() - r.base.l.adr) >= r.base.l.len THEN r.eof := TRUE END
END ReadBytes;
(* Files.File *)
PROCEDURE (f: File) Close;
BEGIN
(* Do nothing since all packed files are opened on the exe file which should stay open. *)
END Close;
PROCEDURE (f: File) Flush;
BEGIN
(* Do nothing since all packed files are read only. *)
END Flush;
PROCEDURE (f: File) Length(): INTEGER;
BEGIN
RETURN f.l.len
END Length;
PROCEDURE (f: File) NewReader(old: Files.Reader): Files.Reader;
VAR r: Reader; hr: Files.Reader;
BEGIN
ASSERT(f.f # NIL, 20); ASSERT(f.l # NIL, 21);
hr := f.f.NewReader(old);
IF hr = NIL THEN RETURN NIL END;
hr.SetPos(f.l.adr);
NEW(r); r.base := f; r.r := hr; r.eof := FALSE;
RETURN r
END NewReader;
PROCEDURE (f: File) NewWriter(old: Files.Writer): Files.Writer;
BEGIN
(* Return NIL since all packed files are read only. *)
RETURN NIL
END NewWriter;
PROCEDURE (f: File) Register (name: Files.Name; type: Files.Type; ask: BOOLEAN; OUT res: INTEGER);
BEGIN
HALT(20)
(* Do nothing since all packed files are opened using Old and only files opened using New can be registered. *)
END Register;
(* Inititlization and uninitialization *)
PROCEDURE SetFilesDir*;
BEGIN
orgdir := Files.dir;
IF orgdir # NIL THEN
IF roots # NIL THEN
curloc := Files.dir.This("")(HostFiles.Locator);
Files.SetDir(stdDir)
END
ELSE
END
END SetFilesDir;
PROCEDURE RestoreFilesDir*;
BEGIN
IF orgdir # NIL THEN Files.SetDir(orgdir) END
END RestoreFilesDir;
PROCEDURE IsInstalled*;
BEGIN
IF Files.dir IS Directory THEN
DebugPrint("HostPackedFiles is installed")
ELSE
DebugPrint("HostPackedFiles is NOT installed")
END
END IsInstalled;
PROCEDURE GetModDate* (f: Files.File; VAR year, month, day, hour, minute, second: INTEGER);
BEGIN
ASSERT(f IS File);
WITH f: File DO
year := f.l.year; month := f.l.month; day := f.l.day;
hour := f.l.hour; minute := f.l.minute; second := f.l.second
END
END GetModDate;
PROCEDURE Init;
VAR loc: Files.Locator; appName: Files.Name; pDir: PackedDirectory; sDir: Directory;
BEGIN
loc := Files.dir.This(""); Files.dir.GetFileName(HostFiles.appName$, "EXE", appName);
exefile := Files.dir.Old(loc, appName, Files.shared);
IF exefile # NIL THEN
curloc := loc(HostFiles.Locator);
ReadResourceTable;
NEW(pDir); packedDir := pDir; NEW(sDir); stdDir := sDir;
SetFilesDir
ELSE
DebugPrint("HostPackedFiles: Could not open " + appName)
END
END Init;
BEGIN
Init
CLOSE
RestoreFilesDir;
IF exefile # NIL THEN exefile.Close END
END HostPackedFiles.
HostPackedFiles.SetFilesDir
HostPackedFiles.RestoreFilesDir
HostPackedFiles.PackStat
HostPackedFiles.IsInstalled
| Host/Mod/PackedFiles.odc |
MODULE HostPictures;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, KERNEL32, GDI32, USER32, COM, WinOle, WinApi,
Files, Fonts, Ports, Stores, Models, Views, Controllers, Properties, Dialog, Converters,
HostPorts, HostWindows, HostClipboard;
CONST
clip = 0X; fit = 1X; approximate = 2X; (* modes *)
macPict = 0; winPict = 1; (* types *)
minVersion = 0; maxVersion = 0;
TYPE
Model = POINTER TO RECORD
file: Files.File;
pos, len: INTEGER;
ref: GDI32.Handle;
data: POINTER TO ARRAY OF BYTE
END;
StdView = POINTER TO RECORD (Views.View)
model: Model;
unit: INTEGER;
w, h: INTEGER;
mode: SHORTCHAR;
type: BYTE
END;
(* Mac Pictures *)
PROCEDURE ReadWord (rd: Files.Reader; VAR x: INTEGER);
VAR b: BYTE;
BEGIN
rd.ReadByte(b); x := 256 * (b MOD 256);
rd.ReadByte(b); x := x + b MOD 256
END ReadWord;
PROCEDURE ReadByte (rd: Files.Reader; VAR x: INTEGER);
VAR b: BYTE;
BEGIN
rd.ReadByte(b); x := b;
END ReadByte;
PROCEDURE Skip (rd: Files.Reader; n: INTEGER);
BEGIN
rd.SetPos(rd.Pos() + n)
END Skip;
PROCEDURE DrawMacPicture (v: StdView; f: Views.Frame; w, h: INTEGER);
VAR rd: Files.Reader; res, end, len, x, y, z, l, t, r, b, u: INTEGER; op: INTEGER; v2, clipped: BOOLEAN;
fgnd, bgnd: Ports.Color; str: ARRAY 256 OF SHORTCHAR; size, style: INTEGER;
p: HostPorts.Port; dc: GDI32.Handle; poly: ARRAY 512 OF GDI32.Point; bt: BYTE;
rl, rt, rr, rb, dl, dt, dr, db, ol, ot, or, ob, al, at, ar, ab, as, aa, gl, gt, gr, gb, ow, oh, lx, ly, tx, ty, plen: INTEGER;
actPen, actBrush, nullPen, nullBrush, fillBrush, bgndBrush, bitmap, font: GDI32.Handle;
PROCEDURE Point (VAR x, y: INTEGER);
BEGIN
ReadWord(rd, y); y := (y + 32768) MOD 65536 - 32768;
ReadWord(rd, x); x := (x + 32768) MOD 65536 - 32768
END Point;
PROCEDURE Data (n: INTEGER);
VAR b: BYTE;
BEGIN
WHILE n > 0 DO rd.ReadByte(b); DEC(n) END
END Data;
PROCEDURE Region (VAR l, t, r, b: INTEGER);
VAR len: INTEGER;
BEGIN
ReadWord(rd, len); ReadWord(rd, t); ReadWord(rd, l);
ReadWord(rd, b); ReadWord(rd, r); Data(len - 10)
END Region;
PROCEDURE Poly (VAR poly: ARRAY OF GDI32.Point; VAR len: INTEGER);
VAR i: INTEGER;
BEGIN
ReadWord(rd, len); len := (len - 10) DIV 4;
ReadWord(rd, i); ReadWord(rd, i);
ReadWord(rd, i); ReadWord(rd, i); i := 0;
WHILE i < len DO Point(poly[i].x, poly[i].y); INC(i) END
END Poly;
PROCEDURE Pattern (VAR brush: GDI32.Handle);
VAR pat: ARRAY 8 OF SHORTINT; i: INTEGER; b: BYTE;
BEGIN
res := GDI32.SelectObject(dc, nullBrush);
res := GDI32.DeleteObject(brush);
res := GDI32.DeleteObject(bitmap);
i := 0;
WHILE i < 8 DO rd.ReadByte(b); pat[i] := SHORT(255 - b MOD 256); INC(i) END;
bitmap := GDI32.CreateBitmap(8, 8, 1, 1, SYSTEM.ADR(pat));
brush := GDI32.CreatePatternBrush(bitmap)
END Pattern;
PROCEDURE Pen (x, y: INTEGER);
BEGIN
IF x < y THEN x := y END;
res := GDI32.SelectObject(dc, nullPen);
res := GDI32.DeleteObject(actPen);
IF x = 0 THEN actPen := nullPen ELSE actPen := GDI32.CreatePen(6, x, Ports.black) END
END Pen;
PROCEDURE String (VAR s: ARRAY OF SHORTCHAR; VAR len: INTEGER);
VAR b: BYTE; i: INTEGER;
BEGIN
rd.ReadByte(b); len := b MOD 256; i := 0;
WHILE i < len DO
rd.ReadByte(b);
(* mac to windows *)
IF b >= ORD(" ") THEN s[i] := SHORT(CHR(b)); INC(i) ELSE DEC(len) END
END;
s[i] := 0X;
END String;
PROCEDURE PixMap (VAR rowBytes, height: INTEGER; VAR v2: BOOLEAN);
VAR x: INTEGER;
BEGIN
ReadWord(rd, rowBytes); v2 := rowBytes >= 32768;
ReadWord(rd, x); height := x;
ReadWord(rd, x);
ReadWord(rd, x); height := x - height;
ReadWord(rd, x);
IF v2 THEN
DEC(rowBytes, 32768);
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x);
Point(x, y); Point(x, y);
Point(x, y); Point(x, y);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x)
END
END PixMap;
PROCEDURE ColorTab;
VAR x, n: INTEGER;
BEGIN
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, n);
WHILE n >= 0 DO
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x);
DEC(n)
END
END ColorTab;
PROCEDURE PixData (rowBytes, height: INTEGER; v2: BOOLEAN);
VAR n, m: INTEGER; b: BYTE;
BEGIN
IF rowBytes < 8 THEN
Skip(rd, rowBytes * height)
ELSIF v2 THEN
WHILE height > 0 DO
IF rowBytes > 250 THEN ReadWord(rd, n) ELSE rd.ReadByte(b); n := b MOD 256 END;
REPEAT
ReadByte(rd, m); DEC(n);
IF m >= 0 THEN
WHILE m >= 0 DO rd.ReadByte(b); DEC(n); DEC(m) END
ELSE
ASSERT(m # -128, 100);
rd.ReadByte(b); DEC(n)
END
UNTIL n <= 0;
DEC(height)
END
ELSE
WHILE height > 0 DO
IF rowBytes > 250 THEN ReadWord(rd, n) ELSE rd.ReadByte(b); n := b MOD 256 END;
Skip(rd, n); DEC(height)
END
END
END PixData;
PROCEDURE BitMap (isRegion: BOOLEAN);
VAR x, y, w, h, l, t, r, b: INTEGER; v2: BOOLEAN;
BEGIN
PixMap(w, h, v2);
IF v2 THEN ColorTab END;
Point(x, y); Point(x, y); Point(x, y); Point(x, y); ReadWord(rd, x);
IF isRegion THEN Region(l, t, r, b) END;
PixData(w, h, v2)
END BitMap;
PROCEDURE PixPattern;
VAR type, x, w, h: INTEGER; v2: BOOLEAN;
BEGIN
ReadWord(rd, type); Data(8);
IF type = 1 THEN
PixMap(w, h, v2); ColorTab; PixData(w, h, v2)
ELSIF type = 2 THEN
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x)
ELSE HALT(100)
END
END PixPattern;
PROCEDURE Setup;
BEGIN
CASE op MOD 8 OF
| 0: res := GDI32.SelectObject(dc, nullBrush); res := GDI32.SelectObject(dc, actPen)
| 1: res := GDI32.SelectObject(dc, actBrush); res := GDI32.SelectObject(dc, nullPen)
| 2: res := GDI32.SelectObject(dc, bgndBrush); res := GDI32.SelectObject(dc, nullPen)
| 4: res := GDI32.SelectObject(dc, fillBrush); res := GDI32.SelectObject(dc, nullPen)
| 3, 5..7: res := GDI32.SelectObject(dc, nullBrush); res := GDI32.SelectObject(dc, nullPen)
END
END Setup;
PROCEDURE SetLn;
BEGIN
res := GDI32.SelectObject(dc, actPen)
END SetLn;
PROCEDURE NewFont;
VAR res, weight: INTEGER; old: GDI32.Handle;
BEGIN
IF ODD(style) THEN weight := 700 ELSE weight := 400 END;
old := font;
font := GDI32.CreateFontA(
-size, 0, 0, 0, weight, style DIV 2 MOD 2, style DIV 4 MOD 2, 0, 0, 3, 2, 1, 6, "Arial");
res := GDI32.SelectObject(dc, font);
res := GDI32.DeleteObject(old)
END NewFont;
PROCEDURE LineTo (x, y: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.LineTo(dc, lx, ly)
ELSE res := GDI32.MoveToEx(dc, lx, ly, NIL)
END
END LineTo;
PROCEDURE Text (x, y: INTEGER);
VAR res, len: INTEGER; str: ARRAY 256 OF SHORTCHAR;
BEGIN
String(str, len);
IF ~clipped THEN res := GDI32.TextOutA(dc, x, y, str, len) END
END Text;
PROCEDURE Rectangle (l, t, r, b: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.Rectangle(dc, l, t, r, b) END
END Rectangle;
PROCEDURE RoundRect (l, t, r, b, w, h: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.RoundRect(dc, l, t, r, b, w, h) END
END RoundRect;
PROCEDURE Ellipse (l, t, r, b: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.Ellipse(dc, l, t, r, b) END
END Ellipse;
PROCEDURE Polyline (VAR poly: ARRAY OF GDI32.Point; len: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.Polyline(dc, poly, len) END
END Polyline;
PROCEDURE Polygon (VAR poly: ARRAY OF GDI32.Point; len: INTEGER);
VAR res: INTEGER;
BEGIN
IF ~clipped THEN res := GDI32.Polygon(dc, poly, len) END
END Polygon;
BEGIN
rd := v.model.file.NewReader(NIL);
rd.SetPos(v.model.pos); end := v.model.pos + v.model.len;
ReadWord(rd, x); Point(l, t); Point(r, b); v.w := r - l; v.h := b - t; v2 := FALSE;
p := f.rider(HostPorts.Rider).port;
p.CloseBuffer;
dc := p.dc; u := p.unit;
res := GDI32.SaveDC(dc);
res := GDI32.SelectClipRgn(dc, 0);
f.rider.GetRect(rl, rt, rr, rb);
res := GDI32.IntersectClipRect(dc, rl, rt, rr, rb);
res := GDI32.SetMapMode(dc, 8); (* anisotropic *)
res := GDI32.SetViewportOrgEx(dc, f.gx DIV u, f.gy DIV u, NIL);
res := GDI32.SetViewportExtEx(dc, w DIV u, h DIV u, NIL);
res := GDI32.SetWindowOrgEx(dc, l, t, NIL);
res := GDI32.SetWindowExtEx(dc, r - l, b - t, NIL);
res := GDI32.SetBkColor(dc, Ports.white);
res := GDI32.SetTextColor(dc, Ports.black);
f.rider(HostPorts.Rider).FixOrigin;
nullPen := GDI32.GetStockObject(GDI32.NullPen);
nullBrush := GDI32.GetStockObject(GDI32.NullBrush);
actPen := GDI32.CreatePen(6, 1, Ports.black);
actBrush := GDI32.GetStockObject(GDI32.BlackBrush);
fillBrush := GDI32.GetStockObject(GDI32.BlackBrush);
bgndBrush := GDI32.GetStockObject(GDI32.WhiteBrush);
bitmap := 0; font := 0;
tx := 0; ty := 0; lx := 0; ly := 0; size := 10; style := 0; NewFont;
clipped := FALSE;
REPEAT
rd.ReadByte(bt); op := bt MOD 256;
IF v2 THEN rd.ReadByte(bt); op := 256 * op + bt MOD 256 END;
CASE op OF
| 0: (* nop *)
| 1: (* clip *) Region(l, t, r, b); clipped := (l = 0) & (t = 0) & (r = 0) & (b = 0)
| 2: (* bgnd pattern *) Pattern(bgndBrush)
| 3: (* text font *) ReadWord(rd, x)
| 4: (* text face *) rd.ReadByte(bt); style := bt; NewFont
| 5: (* text mode *) ReadWord(rd, x)
| 6: (* space extra *) Point(x, y)
| 7: (* pen size *) Point(x, y); Pen(x, y);
| 8: (* pen mode *) ReadWord(rd, x)
| 9: (* pen pattern *) Pattern(actBrush)
| 0AH: (* fill pattern *) Pattern(fillBrush)
| 0BH: (* oval size *) Point(ow, oh)
| 0CH: (* origin *) Point(x, y)
| 0DH: (* text size *) ReadWord(rd, size); NewFont
| 0EH: (* foreground *) ReadWord(rd, x); ReadWord(rd, y); fgnd := x * 65536 + y
| 0FH: (* background *) ReadWord(rd, x); ReadWord(rd, y); bgnd := x * 65536 + y
| 10H: (* text ratio *) Point(x, y); Point(x, y)
| 11H: (* version *) rd.ReadByte(bt); v2 := bt = 2
| 12H: (* bg pix pattern *) PixPattern
| 13H: (* pen pix pattern *) PixPattern
| 14H: (* fill pix pattern *) PixPattern
| 15H: (* fract pen pos *) ReadWord(rd, x)
| 16H: (* char extra *) ReadWord(rd, x)
| 17H..19H: (* ??? *)
| 1AH: (* rgb fg col *) ReadWord(rd, x); ReadWord(rd, y); ReadWord(rd, z)
| 1BH: (* rgb bg col *) ReadWord(rd, x); ReadWord(rd, y); ReadWord(rd, z)
| 1CH: (* hilite mode *)
| 1DH: (* rgb hl col *) ReadWord(rd, x); ReadWord(rd, y); ReadWord(rd, z)
| 1EH: (* def hilite *)
| 1FH: (* rgb op col *) ReadWord(rd, x); ReadWord(rd, y); ReadWord(rd, z)
| 20H: (* line *) Point(lx, ly); res := GDI32.MoveToEx(dc, lx, ly, NIL); Point(lx, ly); SetLn; LineTo(lx, ly)
| 21H: (* line from *) Point(lx, ly); SetLn; LineTo(lx, ly)
| 22H: (* short line *) Point(lx, ly); res := GDI32.MoveToEx(dc, lx, ly, NIL);
ReadByte(rd, z); INC(lx, z); ReadByte(rd, z); INC(ly, z); SetLn; LineTo(lx, ly)
| 23H: (* short line from *) ReadByte(rd, z); INC(lx, z); ReadByte(rd, z); INC(ly, z); SetLn; LineTo(lx, ly)
| 24H..27H: (* ??? *) ReadWord(rd, len); Data(len)
| 28H: (* long text *) Point(tx, ty); Text(tx, ty)
| 29H: (* dh text *) rd.ReadByte(bt); INC(tx, bt MOD 256); Text(tx, ty)
| 2AH: (* dv text *) rd.ReadByte(bt); INC(ty, bt MOD 256); Text(tx, ty)
| 2BH: (* dhv text *) rd.ReadByte(bt); INC(tx, bt MOD 256); rd.ReadByte(bt); INC(ty, bt MOD 256); Text(tx, ty)
| 2CH: (* font typeface ? *) ReadWord(rd, len); ReadWord(rd, x); String(str, z)
| 2DH..2FH: (* ??? *) ReadWord(rd, len); Data(len)
| 30H..37H: (* rect *) Point(rl, rt); Point(rr, rb); Setup; Rectangle(rl, rt, rr, rb)
| 38H..3FH: (* same rect *); Setup; Rectangle(rl, rt, rr, rb)
| 40H..47H: (* rrect *) Point(dl, dt); Point(dr, db); Setup; RoundRect(dl, dt, dr, db, ow, oh)
| 48H..4FH: (* same rrect *); Setup; RoundRect(dl, dt, dr, db, ow, oh)
| 50H..57H: (* oval *) Point(ol, ot); Point(or, ob); Setup; Ellipse(ol, ot, or, ob)
| 58H..5FH: (* same oval *); Setup; Ellipse(ol, ot, or, ob)
| 60H..67H: (* arc *) Point(al, at); Point(ar, ab); Point(aa, as);
| 68H..6FH: (* same arc *) Point(aa, as);
| 70H: (* poly *) Poly(poly, plen); SetLn; Polyline(poly, plen)
| 71H..77H: (* poly *) Poly(poly, plen); Setup; Polygon(poly, plen)
| 78H: (* same poly *) SetLn; Polyline(poly, plen)
| 79H..7FH: (* same poly *) Setup; Polygon(poly, plen)
| 80H..87H: (* rgn *) Region(gl, gt, gr, gb)
| 88H..8FH: (* same rgn *)
| 90H: (* bits rect *) BitMap(FALSE)
| 91H: (* bits rgn *) BitMap(TRUE)
| 92H..97H: (* ??? *) ReadWord(rd, len); Data(len)
| 98H: (* packed bits rect *) BitMap(FALSE)
| 99H: (* packed bits rgn *) BitMap(TRUE)
| 9AH..9FH: (* ??? *) ReadWord(rd, len); Data(len)
| 0A0H: (* short comment *) ReadWord(rd, x);
| 0A1H: (* long comment *) ReadWord(rd, x); ReadWord(rd, len); Data(len)
| 0A2H..0AFH: (* ??? *) ReadWord(rd, len); Data(len)
| 0B0H..0CFH: (* ??? *)
| 0D0H..0FEH: (* ??? *) ReadWord(rd, x); ReadWord(rd, len); Data(x * 65536 + len)
| 0FFH: (* end *)
ELSE
IF op < 8000H THEN (* ??? *) Data(op DIV 256 * 2)
ELSIF op < 8100H THEN (* ??? *)
ELSE (* ??? *) ReadWord(rd, x); ReadWord(rd, len); Data(x * 65536 + len)
END
END;
IF v2 & ODD(rd.Pos() - v.model.pos) THEN rd.ReadByte(bt) END;
UNTIL (op = 0FFH) OR (rd.Pos() >= end);
res := GDI32.RestoreDC(dc, -1);
res := GDI32.DeleteObject(actPen);
res := GDI32.DeleteObject(actBrush);
res := GDI32.DeleteObject(fillBrush);
res := GDI32.DeleteObject(bgndBrush);
res := GDI32.DeleteObject(bitmap);
res := GDI32.DeleteObject(font)
END DrawMacPicture;
(*
PROCEDURE Dump (v: StdView);
VAR rd: Files.Reader; op, end, len, x, y: INTEGER; v2: BOOLEAN; b: BYTE;
PROCEDURE Point;
VAR x: INTEGER;
BEGIN
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
END Point;
PROCEDURE Data (n: INTEGER);
BEGIN
WHILE n > 0 DO
rd.ReadByte(b); DEC(n);
Sub.Char(" "); Sub.IntForm(b, 16, 2, "0", FALSE);
END
END Data;
PROCEDURE Region;
VAR len: INTEGER;
BEGIN
ReadWord(rd, len);
Point; Point;
Data(len - 10)
END Region;
PROCEDURE Text;
VAR b: BYTE; len: INTEGER;
BEGIN
rd.ReadByte(b); len := b MOD 256;
Sub.String(' "');
WHILE len > 0 DO rd.ReadByte(b); Sub.Char(CHR(b MOD 256)); DEC(len) END;
Sub.Char('"')
END Text;
PROCEDURE PixMap (VAR rowBytes, height: INTEGER; VAR v2: BOOLEAN);
VAR x: INTEGER;
BEGIN
ReadWord(rd, rowBytes); v2 := rowBytes >= 32768;
Sub.Int(rowBytes);
ReadWord(rd, x); Sub.Int(x); height := x;
ReadWord(rd, x); Sub.Int(x);
ReadWord(rd, x); Sub.Int(x); height := x - height;
ReadWord(rd, x); Sub.Int(x);
IF v2 THEN
DEC(rowBytes, 32768);
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x);
Point; Point;
Point; Point;
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x);
ReadWord(rd, x)
END
END PixMap;
PROCEDURE ColorTab;
VAR x, n: INTEGER;
BEGIN
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, n); Sub.Int(n);
WHILE n >= 0 DO
ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x); ReadWord(rd, x);
DEC(n)
END
END ColorTab;
PROCEDURE PixData (rowBytes, height: INTEGER; v2: BOOLEAN);
VAR n, m, k: INTEGER; b: BYTE;
BEGIN
IF rowBytes < 8 THEN
Skip(rd, rowBytes * height)
ELSIF v2 THEN
WHILE height > 0 DO
IF rowBytes > 250 THEN ReadWord(rd, n) ELSE rd.ReadByte(b); n := b MOD 256 END;
k := 0;
REPEAT
rd.ReadByte(b); DEC(n); m := b;
IF m >= 0 THEN
WHILE m >= 0 DO rd.ReadByte(b); DEC(n); DEC(m); INC(k) END
ELSE
ASSERT(m # -128, 100);
rd.ReadByte(b); DEC(n); INC(k, 1 - m)
END
UNTIL n <= 0;
ASSERT(n = 0, 101);
ASSERT(k = rowBytes, 102);
(* Skip(rd, n); *) DEC(height)
END
ELSE
WHILE height > 0 DO
IF rowBytes > 250 THEN ReadWord(rd, n) ELSE rd.ReadByte(b); n := b MOD 256 END;
Skip(rd, n); DEC(height)
END
END
END PixData;
PROCEDURE PixPattern;
VAR type, w, h: INTEGER; v2: BOOLEAN;
BEGIN
ReadWord(rd, type); Data(8);
IF type = 1 THEN
PixMap(w, h, v2); ColorTab; PixData(w, h, v2)
ELSIF type = 2 THEN
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
ELSE HALT(100)
END
END PixPattern;
PROCEDURE Bits (region: BOOLEAN);
VAR w, h: INTEGER; v2: BOOLEAN;
BEGIN
PixMap(w, h, v2);
IF v2 THEN ColorTab END;
Point; Point; Point; Point; ReadWord(rd, x); Sub.Int(x);
IF region THEN Region END;
PixData(w, h, v2)
END Bits;
BEGIN
rd := v.model.file.NewReader(NIL);
rd.SetPos(v.model.pos); end := v.model.pos + v.model.len;
ReadWord(rd, x); Sub.Int(x); Point; Point; Sub.Ln; v2 := FALSE;
REPEAT
Sub.Int(rd.Pos()); Sub.Char(" ");
rd.ReadByte(b); op := b MOD 256;
IF v2 THEN rd.ReadByte(b); op := 256 * op + b MOD 256 END;
Sub.IntForm(op, 16, 4, "0", FALSE); Sub.Char(" ");
CASE op OF
| 0: Sub.String("nop")
| 1: Sub.String("clip "); Region
| 2: Sub.String("bkd pattern "); Data(8)
| 3: Sub.String("text font "); ReadWord(rd, x); Sub.Int(x)
| 4: Sub.String("text face "); rd.ReadByte(b); Sub.Int(b MOD 256)
| 5: Sub.String("text mode "); ReadWord(rd, x); Sub.Int(x)
| 6: Sub.String("space extra "); Point
| 7: Sub.String("pen size "); Point
| 8: Sub.String("pen mode "); ReadWord(rd, x); Sub.Int(x)
| 9: Sub.String("pen pattern "); Data(8)
| 0AH: Sub.String("pen pattern "); Data(8)
| 0BH: Sub.String("oval size "); Point
| 0CH: Sub.String("origin "); Point
| 0DH: Sub.String("text size "); ReadWord(rd, x); Sub.Int(x)
| 0EH: Sub.String("foreground "); ReadWord(rd, x); ReadWord(rd, y); Sub.Int(x * 65536 + y)
| 0FH: Sub.String("background "); ReadWord(rd, x); ReadWord(rd, y); Sub.Int(x * 65536 + y)
| 10H: Sub.String("text ratio "); Point; Point
| 11H: Sub.String("version "); rd.ReadByte(b); Sub.Int(b MOD 256); v2 := b = 2
| 12H: Sub.String("bg pix pattern "); PixPattern
| 13H: Sub.String("pen pix pattern "); PixPattern
| 14H: Sub.String("fill pix pattern "); PixPattern
| 15H: Sub.String("fract pen pos "); ReadWord(rd, x); Sub.Int(x)
| 16H: Sub.String("char extra "); ReadWord(rd, x); Sub.Int(x)
| 17H..19H: Sub.String("???")
| 1AH: Sub.String("rgb fg col ");
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
| 1BH: Sub.String("rgb bg col ");
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
| 1CH: Sub.String("hilite mode")
| 1DH: Sub.String("rgb hl col ");
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
| 1EH: Sub.String("def hilite")
| 1FH: Sub.String("rgb op col ");
ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, x); Sub.Int(x)
| 20H: Sub.String("line "); Point; Point
| 21H: Sub.String("line from "); Point
| 22H: Sub.String("short line ");
Point; rd.ReadByte(b); Sub.Int(b MOD 256); rd.ReadByte(b); Sub.Int(b MOD 256)
| 23H: Sub.String("short line from ");
rd.ReadByte(b); Sub.Int(b MOD 256); rd.ReadByte(b); Sub.Int(b MOD 256)
| 24H..27H: Sub.String("??? "); ReadWord(rd, len); Data(len)
| 28H: Sub.String("long text "); Point; Text
| 29H: Sub.String("dh text "); rd.ReadByte(b); Sub.Int(b MOD 256); Text
| 2AH: Sub.String("dv text "); rd.ReadByte(b); Sub.Int(b MOD 256); Text
| 2BH: Sub.String("dhv text ");
rd.ReadByte(b); Sub.Int(b MOD 256); rd.ReadByte(b); Sub.Int(b MOD 256); Text
| 2CH..2FH: Sub.String("??? "); ReadWord(rd, len); Data(len)
| 30H..37H: Sub.String("rect "); Point; Point
| 38H..3FH: Sub.String("same rect")
| 40H..47H: Sub.String("rrect "); Point; Point
| 48H..4FH: Sub.String("same rrect")
| 50H..57H: Sub.String("oval "); Point; Point
| 58H..5FH: Sub.String("same oval")
| 60H..67H: Sub.String("arc "); Point; Point; Point
| 68H..6FH: Sub.String("same arc "); Point
| 70H..77H: Sub.String("poly "); Region
| 78H..7FH: Sub.String("same poly")
| 80H..87H: Sub.String("rgn "); Region
| 88H..8FH: Sub.String("same rgn")
| 90H: Sub.String("bits rect "); Bits(FALSE)
| 91H: Sub.String("bits rgn "); Bits(TRUE)
| 92H..97H: Sub.String("??? "); ReadWord(rd, len); Data(len)
| 98H: Sub.String("packed bits rect "); Bits(FALSE)
| 99H: Sub.String("packed bits rgn "); Bits(TRUE)
| 9AH..9FH: Sub.String("??? "); ReadWord(rd, len); Data(len)
| 0A0H: Sub.String("short comment "); ReadWord(rd, x); Sub.Int(x)
| 0A1H: Sub.String("long comment "); ReadWord(rd, x); Sub.Int(x); ReadWord(rd, len); Data(len)
| 0A2H..0AFH: Sub.String("??? "); ReadWord(rd, len); Data(len)
| 0B0H..0CFH: Sub.String("???")
| 0D0H..0FEH: Sub.String("??? "); ReadWord(rd, x); ReadWord(rd, len); Data(x * 65536 + len)
| 0FFH: Sub.String("end")
ELSE
IF op < 8000H THEN Sub.String("??? "); Data(op DIV 256 * 2)
ELSIF op < 8100H THEN Sub.String("???")
ELSE Sub.String("??? "); ReadWord(rd, x); ReadWord(rd, len); Data(x * 65536 + len)
END
END;
IF v2 & ODD(rd.Pos() - v.model.pos) THEN rd.ReadByte(b) END;
Sub.Ln
UNTIL (op = 0FFH) OR (rd.Pos() >= end)
END Dump;
*)
PROCEDURE Evaluate (v: StdView);
VAR len, adr: INTEGER; rd: Files.Reader; ch: SHORTCHAR;
BEGIN
len := v.model.len;
IF v.model.data = NIL THEN
rd := v.model.file.NewReader(NIL);
rd.SetPos(v.model.pos);
NEW(v.model.data, len);
rd.ReadBytes(v.model.data^, 0, len)
END;
v.model.ref := GDI32.SetMetaFileBitsEx(len, v.model.data^);
ASSERT(v.model.ref # 0, 100);
END Evaluate;
(* Model *)
PROCEDURE (m: Model) FINALIZE;
VAR res: INTEGER;
BEGIN
IF m.ref # 0 THEN
res := GDI32.DeleteMetaFile(m.ref);
m.ref := 0
END
END FINALIZE;
(* View *)
PROCEDURE (v: StdView) Internalize (VAR rd: Stores.Reader);
VAR m: Model; thisVersion: INTEGER;
BEGIN
v.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxVersion, thisVersion);
IF rd.cancelled THEN RETURN END;
rd.ReadByte(v.type);
IF (v.type # winPict) & (v.type # macPict) THEN rd.TurnIntoAlien(Stores.alienComponent); RETURN END;
rd.ReadInt(v.unit);
rd.ReadInt(v.w);
rd.ReadInt(v.h);
rd.ReadSChar(v.mode);
NEW(m); m.file := rd.rider.Base();
rd.ReadInt(m.len);
m.pos := rd.Pos();
m.ref := 0; (* lazy allocation of metafile *)
v.model := m;
rd.SetPos(m.pos + m.len)
END Internalize;
PROCEDURE (v: StdView) Externalize (VAR wr: Stores.Writer);
VAR len, res: INTEGER; r: Files.Reader; b: BYTE;
BEGIN
v.Externalize^(wr);
wr.WriteVersion(maxVersion);
wr.WriteByte(v.type);
wr.WriteInt(v.unit);
wr.WriteInt(v.w);
wr.WriteInt(v.h);
wr.WriteSChar(v.mode);
len := v.model.len;
wr.WriteInt(len);
IF v.model.data # NIL THEN
wr.rider.WriteBytes(v.model.data^, 0, len)
ELSIF v.model.file # NIL THEN
r := v.model.file.NewReader(NIL); r.SetPos(v.model.pos);
WHILE len # 0 DO r.ReadByte(b); wr.WriteSChar(SHORT(CHR(b))); DEC(len) END
ELSE
ASSERT(v.model.ref # 0, 100);
NEW(v.model.data, len);
res := GDI32.GetMetaFileBitsEx(v.model.ref, len, v.model.data^);
wr.rider.WriteBytes(v.model.data^, 0, len)
END
END Externalize;
PROCEDURE (v: StdView) ThisModel (): Models.Model;
BEGIN
RETURN NIL
END ThisModel;
PROCEDURE (v: StdView) CopyFromSimpleView (source: Views.View);
BEGIN
(* v.CopyFrom^(source); *)
WITH source: StdView DO
v.model := source.model;
v.type := source.type;
v.mode := source.mode;
v.w := source.w;
v.h := source.h;
v.unit := source.unit
END
END CopyFromSimpleView;
PROCEDURE (v: StdView) Restore (f: Views.Frame; l, t, r, b: INTEGER);
VAR rd: HostPorts.Rider; res, u, w, h: INTEGER;
BEGIN
ASSERT(v.model # NIL, 20);
v.context.GetSize(w, h);
IF v.type = winPict THEN
IF v.model.ref = 0 THEN Evaluate(v) END;
f.rider(HostPorts.Rider).DrawMetafile(v.model.ref, ORD(v.mode), f.gx, f.gy, w, h)
ELSIF v.type = macPict THEN
DrawMacPicture(v, f, w, h)
END
END Restore;
PROCEDURE (v: StdView) GetBkgndFor (
f: Views.Frame; VAR col: Ports.Color; VAR homogeneous: BOOLEAN
), NEW;
BEGIN
col := Ports.background
END GetBkgndFor;
PROCEDURE (v: StdView) HandlePropMsg (VAR msg: Properties.Message);
BEGIN
WITH msg: Properties.SizePref DO
IF (msg.w > Views.undefined) & (msg.h > Views.undefined) THEN
IF (v.type = macPict) & (v.w # 0) & (v.h # 0) OR (v.mode = 7X) THEN (* isotropic mode *)
Properties.ProportionalConstraint(ABS(v.w), ABS(v.h), msg.fixedW, msg.fixedH, msg.w, msg.h)
END
ELSE
IF (v.w > 0) & (v.h > 0) THEN (* default sizes *)
msg.w := ABS(v.w); msg.h := ABS(v.h)
END
END
ELSE
END
END HandlePropMsg;
(*
PROCEDURE (v: StdView) HandleCtrlMsg (f: Views.Frame; VAR msg: Controllers.Message;
VAR focus: Views.View);
BEGIN
WITH msg: Controllers.TrackMsg DO
IF v.type = macPict THEN Dump(v) END
ELSE
END
END HandleCtrlMsg;
*)
PROCEDURE GenMetafileMedium (
mf: WinApi.HMETAFILEPICT; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM
);
BEGIN
sm.tymed := WinOle.TYMED_MFPICT;
sm.u.hMetaFilePict := mf;
sm.pUnkForRelease := unk
END GenMetafileMedium;
PROCEDURE MediumMetafile (VAR sm: WinOle.STGMEDIUM): WinApi.HMETAFILEPICT;
BEGIN
ASSERT(sm.tymed = WinOle.TYMED_MFPICT, 20);
RETURN sm.u.hMetaFilePict
END MediumMetafile;
PROCEDURE ImportDPict* (
VAR med: WinOle.STGMEDIUM; OUT v: Views.View; OUT w, h: INTEGER; OUT isSingle: BOOLEAN
);
VAR sv: StdView; res, len, sw, sh, u, mode: INTEGER; mf: WinApi.HMETAFILE;
hm: WinApi.HMETAFILEPICT; mp: WinApi.PtrMETAFILEPICT;
BEGIN
hm := MediumMetafile(med);
ASSERT(hm # 0, 20);
mp := SYSTEM.VAL(WinApi.PtrMETAFILEPICT, WinApi.GlobalLock(hm));
NEW(sv); sv.type := winPict;
mode := mp.mm;
CASE mode OF
| 1: u := HostWindows.unit
| 2: u := Ports.point DIV 20
| 3: u := Ports.mm DIV 100
| 4: u := Ports.inch DIV 100
| 5: u := Ports.inch DIV 1000
| 6: u := Ports.mm DIV 10
| 7: u := Ports.mm DIV 100
| 8: u := Ports.mm DIV 100
END;
sw := mp.xExt;
sh := mp.yExt;
mf := mp.hMF;
sv.w := sw * u; sv.h := sh * u; sv.unit := u;
sv.mode := SHORT(CHR(mode));
NEW(sv.model);
len := GDI32.GetMetaFileBitsEx(mf, 0, NIL);
NEW(sv.model.data, len);
res := GDI32.GetMetaFileBitsEx(mf, len, sv.model.data^);
sv.model.len := len;
res := KERNEL32.GlobalUnlock(hm);
v := sv; w := ABS(sv.w); h := ABS(sv.h); isSingle := FALSE
END ImportDPict;
PROCEDURE ExportDPict* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
VAR res, u: INTEGER; mf: WinApi.HMETAFILE;
hm: WinApi.HMETAFILEPICT; mp: WinApi.PtrMETAFILEPICT;
BEGIN
ASSERT(v # NIL, 20);
WITH v: StdView DO
IF v.type = winPict THEN
IF v.model.ref = 0 THEN Evaluate(v) END;
hm := KERNEL32.GlobalAlloc({1, 13}, SIZE(WinApi.METAFILEPICT)); (* movable, sharable *)
IF hm # 0 THEN
mp := SYSTEM.VAL(WinApi.PtrMETAFILEPICT, WinApi.GlobalLock(hm));
CASE ORD(v.mode) OF
| 1: u := HostWindows.unit
| 2: u := Ports.point DIV 20
| 3: u := Ports.mm DIV 100
| 4: u := Ports.inch DIV 100
| 5: u := Ports.inch DIV 1000
| 6: u := Ports.mm DIV 10
| 7: u := Ports.mm DIV 100
| 8: u := Ports.mm DIV 100
END;
mp.mm := ORD(v.mode);
mp.xExt := v.w DIV u;
mp.yExt := v.h DIV u;
mp.hMF := GDI32.SetMetaFileBitsEx(v.model.len, v.model.data^);
res := KERNEL32.GlobalUnlock(hm);
GenMetafileMedium(hm, NIL, med)
END
END
ELSE
END
END ExportDPict;
(*
PROCEDURE ImportCBPict*;
VAR v: StdView; res, len, adr, w, h, u, mode: LONGINT; ref, hnd: KERNEL32.Handle;
BEGIN
hnd := USER32.GetClipboardData(HostClipboard.metafile);
ASSERT(hnd # 0, 20);
adr := KERNEL32.GlobalLock(hnd);
NEW(v); v.type := winPict;
SYSTEM.GET(adr, mode); INC(adr, 4);
SYSTEM.GET(adr, w); INC(adr, 4);
SYSTEM.GET(adr, h); INC(adr, 4);
SYSTEM.GET(adr, ref);
CASE mode OF
| 1: u := HostWindows.unit
| 2: u := Ports.point DIV 20
| 3: u := Ports.mm DIV 100
| 4: u := Ports.inch DIV 100
| 5: u := Ports.inch DIV 1000
| 6: u := Ports.mm DIV 10
| 7: u := Ports.mm DIV 100
| 8: u := Ports.mm DIV 100
END;
v.w := w * u; v.h := h * u;
v.mode := CHR(mode);
NEW(v.model);
len := GDI32.GetMetaFileBitsEx(ref, 0, NIL);
NEW(v.model.data, len);
res := GDI32.GetMetaFileBitsEx(ref, len, v.model.data^);
v.model.len := len;
res := KERNEL32.GlobalUnlock(hnd);
HostClipboard.RegisterImp(v)
END ImportCBPict;
PROCEDURE ImportC*;
VAR v: StdView; pic: MemoryMgr.Handle; s, d, len: LONGINT; ch: CHAR;
BEGIN
len := HostClipboard.len;
pic := MemoryMgr.NewHandle(len); MemoryMgr.HLock(pic);
s := HostClipboard.adr; d := SYSTEM.ADR(pic^);
WHILE len # 0 DO
SYSTEM.GET(s, ch); SYSTEM.PUT(d, ch); INC(s); INC(d); DEC(len)
END;
NEW(v); v.Init;
v.model := NewModel(SYSTEM.VAL(QuickDraw.PicHandle, pic));
HostClipboard.view := v
END ImportC;
PROCEDURE ExportC*;
VAR v: StdView; s, d, len: LONGINT; scrap: MemoryMgr.Ptr; ch: CHAR;
BEGIN
IF HostClipboard.view IS StdView THEN
v := HostClipboard.view(StdView);
ASSERT(v.model.picture # NIL, 20);
len := v.model.len;
scrap := MemoryMgr.NewPtr(len);
IF MemoryMgr.err = 0 THEN
HostClipboard.adr := SYSTEM.VAL(LONGINT, scrap);
HostClipboard.len := len;
s := SYSTEM.ADR(v.model.picture^); d := HostClipboard.adr;
WHILE len # 0 DO
SYSTEM.GET(s, ch); SYSTEM.PUT(d, ch); INC(s); INC(d); DEC(len)
END
END
END
END ExportC;
PROCEDURE ImportF*;
VAR v: StdView; pic: MemoryMgr.Handle; r: Files.Reader; d, len: LONGINT; ch: CHAR;
BEGIN
ASSERT(Converters.file # NIL, 20);
len := Converters.file.Length() - 512;
pic := MemoryMgr.NewHandle(len); ASSERT(pic # NIL, 21);
MemoryMgr.HLock(pic);
d := SYSTEM.ADR(pic^);
r := Converters.file.NewReader(NIL); r.SetPos(512);
WHILE len # 0 DO
r.ReadByte(ch); SYSTEM.PUT(d, ch); INC(d); DEC(len)
END;
NEW(v); v.Init;
v.model := NewModel(SYSTEM.VAL(QuickDraw.PicHandle, pic));
Converters.store := v
END ImportF;
*)
PROCEDURE PictType* (v: Views.View): INTEGER;
BEGIN
WITH v: StdView DO RETURN v.type
ELSE RETURN -1
END
END PictType;
END HostPictures.
| Host/Mod/Pictures.odc |
MODULE HostPorts; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080215, Fyodor Tkachov, reviewed
- 20061105, Ilya Ermakov, russification
- 20060915, Alexander Iljin, Added a call to UpdateWindow to Rider.Input to fix ScrollWhileTracking painting bug, which appeared after previous patch.
- 20060903, Alexander Iljin, Deleted a call to ValidateRect from Port.CloseBuffer to fix painting bug.
- 20060524, Alexander Iljin, Rider.Input updated to allow Services.Actions call it.
- 20060325, Marco Ciot, Rider.Input changed for the benefit of background task response.
- 20050714, bh/mf, Bezier algorithm corrected
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, WinApi, KERNEL32, GDI32, USER32,
Kernel, Fonts, Ports, Dialog, HostFonts, Services, i21sysCharacters;
CONST
resizeHCursor* = 16; resizeVCursor* = 17; resizeLCursor* = 18; resizeRCursor* = 19; resizeCursor* = 20;
busyCursor* = 21; stopCursor* = 22;
moveCursor* = 23; copyCursor* = 24; linkCursor* = 25; pickCursor* = 26;
focusPat* = 5;
extend = 1; modify = 2; (* same as Controllers.extend and Controllers.modify !!! *)
(** buttons **)
left* = 16; middle* = 17; right* = 18;
shift* = 24; ctrl* = 25; opt* = 26; cmd* = 27; alt* = 28;
copy = 00CC0020H; (* raster code for source copy *)
xor = 00A50065H; (* raster code for xor function *)
figureSpace = 8FX;
TYPE
Port* = POINTER TO RECORD (Ports.Port)
w-, h-: INTEGER;
dc-: USER32.Handle; (* actual dc *)
wnd-: USER32.Handle; (* used for invalidation, may be null *)
homedc-: USER32.Handle; (* unbuffered dc *)
map: GDI32.Handle; (* buffer bitmap *)
bl, bt, br, bb: INTEGER; (* buffer rectangle *)
bx, by: INTEGER (* bitmap pattern offset *)
END;
Rider* = POINTER TO EXTENSIBLE RECORD (Ports.Rider)
l-, t-, r-, b-: INTEGER;
port-: Port;
dx, dy: INTEGER; (* scroll offset *)
map: GDI32.Handle; (* save bitmap *)
dc: USER32.Handle; (* save dc *)
sl, st, sr, sb: INTEGER (* save rect *)
END;
VAR
(* system colors *)
textCol-, selBackground-, selTextCol-,
dialogTextCol-, dialogShadowCol-, dialogLightCol-: Ports.Color;
dialogBrush*, dim50Brush-: GDI32.Handle;
debug*, noBuffer*, flag*: BOOLEAN;
cursors-: ARRAY 32 OF USER32.Handle;
nullBrush, nullPen: GDI32.Handle;
invertBrush, dim25Brush, dim75Brush, focusBrush: GDI32.Handle;
grgn: GDI32.Handle;
mx, my: INTEGER; (* actual mouse coordinates *)
mb: SET; (* actual mouse buttons & modifiers *)
PROCEDURE Wait;
VAR t: LONGINT;
BEGIN
t := Kernel.Time() + Kernel.timeResolution;
REPEAT UNTIL Kernel.Time() > t
END Wait;
(** Port **)
PROCEDURE (p: Port) SetSize* (w, h: INTEGER);
BEGIN
ASSERT(w >= 0, 20); ASSERT(h >= 0, 21);
p.w := w; p.h := h
END SetSize;
PROCEDURE (p: Port) GetSize* (OUT w, h: INTEGER);
BEGIN
w := p.w; h := p.h
END GetSize;
PROCEDURE (p: Port) NewRider* (): Rider;
VAR h: Rider;
BEGIN
NEW(h); h.port := p; RETURN h
END NewRider;
PROCEDURE (p: Port) SetDC* (dc, wnd: GDI32.Handle), NEW;
VAR res: INTEGER;
BEGIN
ASSERT(p.unit # 0, 20); ASSERT(dc # 0, 21);
p.dc := dc; p.homedc := dc;
res := GDI32.SetBkMode(dc, GDI32.Transparent);
res := GDI32.SetTextAlign(dc, 24);
res := GDI32.SetPolyFillMode(dc, 2);
res := GDI32.SelectObject(dc, nullPen);
res := GDI32.SelectObject(dc, nullBrush);
p.wnd := wnd
END SetDC;
PROCEDURE (p: Port) OpenBuffer* (l, t, r, b: INTEGER);
VAR res: INTEGER; dc: USER32.Handle; pt: USER32.Point;
BEGIN
ASSERT(p.dc # 0, 20);
IF l < 0 THEN l := 0 END;
IF t < 0 THEN t := 0 END;
IF r > p.w THEN r := p.w END;
IF b > p.h THEN b := p.h END;
IF (l < r) & (t < b) THEN
p.bl := l; p.bt := t; p.br := r; p.bb := b;
IF ~noBuffer THEN
dc := GDI32.CreateCompatibleDC(p.homedc);
IF dc # 0 THEN
IF p.wnd # 0 THEN (* byte align bitmap to screen *)
pt.x := l; pt.y := 0;
res := USER32.ClientToScreen(p.wnd, pt);
pt.x := pt.x DIV 8 * 8;
res := USER32.ScreenToClient(p.wnd, pt);
l := pt.x
END;
p.map := GDI32.CreateCompatibleBitmap(p.homedc, r - l, b - t);
IF p.map # 0 THEN
res := GDI32.SelectObject(dc, p.map);
res := GDI32.SetBkMode(dc, GDI32.Transparent);
res := GDI32.SetTextAlign(dc, 24);
res := GDI32.SetPolyFillMode(dc, 2);
res := GDI32.SetWindowOrgEx(dc, l, t, NIL);
res := GDI32.SelectObject(dc, nullPen);
res := GDI32.SelectObject(dc, nullBrush);
p.dc := dc; p.bx := l; p.by := t;
ELSE
res := GDI32.DeleteDC(dc)
END
END
END
END
END OpenBuffer;
PROCEDURE (p: Port) CloseBuffer*;
VAR res: INTEGER; rect: USER32.Rect;
BEGIN
IF p.map # 0 THEN
res := GDI32.SelectClipRgn(p.homedc, 0);
res := GDI32.BitBlt(p.homedc, p.bl, p.bt, p.br - p.bl, p.bb - p.bt, p.dc, p.bl, p.bt, copy);
res := GDI32.DeleteDC(p.dc);
res := GDI32.DeleteObject(p.map)
END;
(* Alexander Iljin: Original code - may cripple the update region if it was changed by OS. *)
IF p.wnd # 0 THEN
rect.left := p.bl; rect.top := p.bt; rect.right := p.br; rect.bottom := p.bb;
res := USER32.ValidateRect(p.wnd, rect)
END;
(* Alexander Iljin: fixed painting bug. *) (*
IF p.wnd # 0 THEN
rect.left := p.bl; rect.top := p.bt; rect.right := p.br; rect.bottom := p.bb;
res := USER32.ValidateRect(p.wnd, rect)
END;
*)
p.dc := p.homedc; p.map := 0;
p.bx := 0; p.by := 0
END CloseBuffer;
(** Rider **)
PROCEDURE (rd: Rider) Base* (): Ports.Port, EXTENSIBLE;
BEGIN
ASSERT(rd.port # NIL, 20); ASSERT(rd.port.dc # 0, 21);
RETURN rd.port
END Base;
PROCEDURE (rd: Rider) SetRect* (l, t, r, b: INTEGER);
BEGIN
ASSERT((l <= r) & (t <= b), 20);
ASSERT(rd.port # NIL, 21);
rd.l := l; rd.t := t; rd.r := r; rd.b := b
END SetRect;
PROCEDURE (rd: Rider) GetRect* (OUT l, t, r, b: INTEGER);
BEGIN
l := rd.l; t := rd.t; r := rd.r; b := rd.b
END GetRect;
PROCEDURE SetClipRegion (rd: Rider; dc: USER32.Handle);
VAR res, res1: INTEGER; rect: USER32.Rect; rgn: GDI32.Handle; pts: ARRAY 2 OF GDI32.Point;
BEGIN
IF rd.port.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
END SetClipRegion;
PROCEDURE (rd: Rider) InitPort* (port: Port), NEW;
BEGIN
ASSERT(rd.port = NIL, 20); ASSERT(port # NIL, 21); ASSERT(port.dc # 0, 22);
rd.port := port; rd.dx := 0; rd.dy := 0
END InitPort;
PROCEDURE (rd: Rider) Move* (dx, dy: INTEGER);
BEGIN
INC(rd.dx, dx); INC(rd.dy, dy)
END Move;
PROCEDURE (rd: Rider) DrawRect* (l, t, r, b, s: INTEGER; col: Ports.Color);
VAR res, h: INTEGER; p: Port; dc, oldb, oldp: USER32.Handle; pt: GDI32.Point;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF col = Ports.defaultColor THEN col := textCol END;
IF s = 0 THEN s := 1 END;
IF (s < 0) OR (r-l < 2*s) OR (b-t < 2*s) THEN
INC(r); INC(b);
IF (col # textCol) & (col # Ports.background) THEN
IF (Dialog.platform = 11) & (p.dc = p.homedc) & (p.wnd # 0) THEN (* win32s *)
pt.x := 0; pt.y := 0; res := USER32.ClientToScreen(p.wnd, pt);
res := GDI32.FixBrushOrgEx(dc, (rd.dx + pt.x) MOD 8, (rd.dy + pt.y) MOD 8, NIL)
ELSE
res := GDI32.SetBrushOrgEx(dc, (rd.dx - p.bx) MOD 8, (rd.dy - p.by) MOD 8, NIL)
END
END;
oldb := GDI32.SelectObject(dc, GDI32.CreateSolidBrush(col));
oldp := GDI32.SelectObject(dc, nullPen);
res := GDI32.Rectangle(dc, l, t, r, b);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldb));
res := GDI32.SelectObject(dc, oldp)
ELSE
h := s DIV 2; INC(l, h); INC(t, h); h := (s-1) DIV 2; DEC(r, h); DEC(b, h);
oldb := GDI32.SelectObject(dc, nullBrush);
oldp := GDI32.SelectObject(dc, GDI32.CreatePen(GDI32.PSSolid, s, col));
res := GDI32.Rectangle(dc, l, t, r, b);
res := GDI32.SelectObject(dc, oldb);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldp))
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END DrawRect;
PROCEDURE (rd: Rider) DrawOval* (l, t, r, b, s: INTEGER; col: Ports.Color);
VAR res, h: INTEGER; p: Port; dc, oldb, oldp: USER32.Handle; pt: GDI32.Point; rect: GDI32.Rect;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF col = Ports.defaultColor THEN col := textCol END;
IF s < 0 THEN
INC(r); INC(b);
IF (col # textCol) & (col # Ports.background) THEN
IF (Dialog.platform = 11) & (p.dc = p.homedc) & (p.wnd # 0) THEN (* win32s *)
pt.x := 0; pt.y := 0; res := USER32.ClientToScreen(p.wnd, pt);
res := GDI32.FixBrushOrgEx(dc, (rd.dx + pt.x) MOD 8, (rd.dy + pt.y) MOD 8, NIL)
ELSE
res := GDI32.SetBrushOrgEx(dc, (rd.dx - p.bx) MOD 8, (rd.dy - p.by) MOD 8, NIL)
END
END;
oldb := GDI32.SelectObject(dc, GDI32.CreateSolidBrush(col));
oldp := GDI32.SelectObject(dc, nullPen);
res := GDI32.Ellipse(dc, l, t, r, b);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldb));
res := GDI32.SelectObject(dc, oldp)
ELSE
IF s = 0 THEN s := 1 END;
h := s DIV 2; INC(l, h); INC(t, h); h := (s-1) DIV 2; DEC(r, h); DEC(b, h);
oldb := GDI32.SelectObject(dc, nullBrush);
oldp := GDI32.SelectObject(dc, GDI32.CreatePen(GDI32.PSSolid, s, col));
res := GDI32.Ellipse(dc, l, t, r, b);
res := GDI32.SelectObject(dc, oldb);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldp))
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END DrawOval;
PROCEDURE (rd: Rider) DrawLine* (x0, y0, x1, y1, s: INTEGER; col: Ports.Color);
VAR res: INTEGER; pt: GDI32.Point; p: Port; dc, oldb, oldp: GDI32.Handle;
BEGIN
ASSERT(s >= 0, 20);
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF col = Ports.defaultColor THEN col := textCol END;
IF s <= 0 THEN s := 1 END;
oldp := GDI32.SelectObject(dc, GDI32.CreatePen(GDI32.PSSolid, s, col));
res := GDI32.MoveToEx(dc, x0, y0, pt);
res := GDI32.LineTo(dc, x1, y1);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldp));
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END DrawLine;
PROCEDURE (rd: Rider) DrawPath* (
IN pts: ARRAY OF Ports.Point; n, s: INTEGER; col: Ports.Color; path: INTEGER
);
TYPE
PAP = POINTER TO ARRAY [1] OF GDI32.Point;
VAR
res, i, j, k: INTEGER; p: Port; dc, oldp, oldb: GDI32.Handle;
pap: PAP; pt: GDI32.Point; poly: ARRAY 256 OF GDI32.Point;
polyPtr: POINTER TO ARRAY OF Ports.Point; polyLen: INTEGER;
PROCEDURE Bezier(x0, y0, xd0, yd0, x1, y1, xd1, yd1: INTEGER);
VAR x, y, xd, yd, i: INTEGER;
BEGIN
IF ABS(x0 + xd0 - x1) + ABS(x0 + xd1 - x1) + ABS(y0 + yd0 - y1) + ABS(y0 + yd1 - y1) < 8 THEN
IF k > polyLen - 2 THEN
NEW(polyPtr, polyLen * 2);
i := 0; WHILE i < polyLen DO polyPtr[i] := SYSTEM.VAL(Ports.Point, pap[i]); INC(i) END;
polyLen := polyLen * 2; pap := SYSTEM.VAL(PAP, SYSTEM.ADR(polyPtr^))
END;
pap[k].x := x0; pap[k].y := y0; INC(k)
ELSE
x := ((xd0 - xd1) DIV 4 + x0 + x1 + 1) DIV 2;
y := ((yd0 - yd1) DIV 4 + y0 + y1 + 1) DIV 2;
xd := ((x1 - x0) * 3 - (xd0 + xd1) DIV 2 + 2) DIV 4;
yd := ((y1 - y0) * 3 - (yd0 + yd1) DIV 2 + 2) DIV 4;
Bezier(x0, y0, xd0 DIV 2, yd0 DIV 2, x, y, xd, yd);
Bezier(x, y, xd, yd, x1, y1, xd1 DIV 2, yd1 DIV 2)
END
END Bezier;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF col = Ports.defaultColor THEN col := textCol END;
pap := SYSTEM.VAL(PAP, SYSTEM.ADR(pts));
ASSERT(n >= 0, 20); ASSERT(n <= LEN(pts), 21);
ASSERT(s >= Ports.fill, 23);
IF s < 0 THEN
IF (Dialog.platform = 11) & (p.dc = p.homedc) & (p.wnd # 0) THEN (* win32s *)
pt.x := 0; pt.y := 0; res := USER32.ClientToScreen(p.wnd, pt);
res := GDI32.FixBrushOrgEx(dc, (rd.dx + pt.x) MOD 8, (rd.dy + pt.y) MOD 8, NIL)
ELSE
res := GDI32.SetBrushOrgEx(dc, (rd.dx - p.bx) MOD 8, (rd.dy - p.by) MOD 8, NIL)
END;
oldb := GDI32.SelectObject(dc, GDI32.CreateSolidBrush(col));
oldp := GDI32.SelectObject(dc, nullPen);
IF path = Ports.closedPoly THEN
ASSERT(n >= 2, 20);
res := GDI32.Polygon(dc, pap^, n)
ELSE
ASSERT(n >= 3, 20);
ASSERT(path = Ports.closedBezier, 22);
ASSERT(n MOD 3 = 0, 24);
pap := SYSTEM.VAL(PAP, SYSTEM.ADR(poly)); polyLen := LEN(poly);
i := 0; k := 0;
WHILE i < n DO
j := i+3;
IF j = n THEN j := 0 END;
Bezier(pts[i].x, pts[i].y, (pts[i+1].x - pts[i].x) * 3, (pts[i+1].y - pts[i].y) * 3,
pts[j].x, pts[j].y, (pts[j].x - pts[i+2].x) * 3, (pts[j].y - pts[i+2].y) * 3);
INC(i, 3)
END;
res := GDI32.Polygon(dc, pap^, k)
END;
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldb));
res := GDI32.SelectObject(dc, oldp)
ELSE
IF s = 0 THEN s := 1 END;
oldb := GDI32.SelectObject(dc, nullBrush);
oldp := GDI32.SelectObject(dc, GDI32.CreatePen(GDI32.PSSolid, s, col));
IF path = Ports.closedPoly THEN
ASSERT(n >= 2, 20);
res := GDI32.Polygon(dc, pap^, n)
ELSIF path = Ports.openPoly THEN
ASSERT(n >= 2, 20);
res := GDI32.Polyline(dc, pap^, n)
ELSE
IF path = Ports.closedBezier THEN
ASSERT(n >= 3, 20);
ASSERT(n MOD 3 = 0, 24)
ELSE
ASSERT(n >= 4, 20);
ASSERT(path = Ports.openBezier, 25);
ASSERT(n MOD 3 = 1, 24)
END;
pap := SYSTEM.VAL(PAP, SYSTEM.ADR(poly)); polyLen := LEN(poly);
i := 0;
WHILE i < n-2 DO
k := 0; j := i+3;
IF j = n THEN j := 0 END;
Bezier(pts[i].x, pts[i].y, (pts[i+1].x - pts[i].x) * 3, (pts[i+1].y - pts[i].y) * 3,
pts[j].x, pts[j].y, (pts[j].x - pts[i+2].x) * 3, (pts[j].y - pts[i+2].y) * 3);
pap[k].x := pts[j].x; pap[k].y := pts[j].y; INC(k);
res := GDI32.Polyline(dc, pap^, k);
INC(i, 3)
END
END;
res := GDI32.SelectObject(dc, oldb);
res := GDI32.DeleteObject(GDI32.SelectObject(dc, oldp))
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END DrawPath;
PROCEDURE (rd: Rider) MarkRect* (l, t, r, b, s, mode: INTEGER; show: BOOLEAN);
VAR res: INTEGER; p: Port; dc, old: GDI32.Handle; pt: GDI32.Point;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF (Dialog.platform = 11) & (p.dc = p.homedc) & (p.wnd # 0) THEN (* win32s *)
pt.x := 0; pt.y := 0; res := USER32.ClientToScreen(p.wnd, pt);
res := GDI32.FixBrushOrgEx(dc, (rd.dx + pt.x) MOD 8, (rd.dy + pt.y) MOD 8, NIL)
ELSE
res := GDI32.SetBrushOrgEx(dc, (rd.dx - p.bx) MOD 8, (rd.dy - p.by) MOD 8, NIL)
END;
IF (mode = Ports.invert) OR (mode = Ports.hilite) THEN
old := GDI32.SelectObject(dc, invertBrush)
ELSIF mode = Ports.dim25 THEN
res := GDI32.UnrealizeObject(dim25Brush); old := GDI32.SelectObject(dc, dim25Brush)
ELSIF mode = Ports.dim50 THEN
res := GDI32.UnrealizeObject(dim50Brush); old := GDI32.SelectObject(dc, dim50Brush)
ELSIF mode = Ports.dim75 THEN
res := GDI32.UnrealizeObject(dim75Brush); old := GDI32.SelectObject(dc, dim75Brush)
ELSE (* mode = focusPat *)
res := GDI32.UnrealizeObject(focusBrush); old := GDI32.SelectObject(dc, focusBrush)
END;
res := GDI32.SetTextColor(dc, Ports.black);
IF l < -32768 THEN l := -32768 END; (* ??? *)
IF t < -32768 THEN t := -32768 END;
IF r > 32767 THEN r := 32767 END;
IF b > 32767 THEN b := 32767 END;
IF s = 0 THEN s := 1 END;
IF (s < 0) OR (r-l < 2*s) OR (b-t < 2*s) THEN
res := GDI32.PatBlt(dc, l, t, r-l, b-t, xor);
ELSE
res := GDI32.PatBlt(dc, l, t, s, b-t, xor); DEC(r, s);
res := GDI32.PatBlt(dc, r, t, s, b-t, xor); INC(l, s);
res := GDI32.PatBlt(dc, l, t, r-l, s, xor); DEC(b, s);
res := GDI32.PatBlt(dc, l, b, r-l, s, xor);
END;
old := GDI32.SelectObject(dc, old);
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END MarkRect;
PROCEDURE (rd: Rider) Scroll* (dx, dy: INTEGER);
VAR res: INTEGER; p: Port; dc, par: GDI32.Handle; rect, rt: GDI32.Rect; pt: GDI32.Point;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
(*
IF p.wnd # 0 THEN res := USER32.UpdateWindow(p.wnd) END;
*)
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
rect.left := rd.l; rect.top := rd.t; rect.right := rd.r; rect.bottom := rd.b;
res := USER32.ScrollDC(dc, dx, dy, rect, rect, grgn, rt);
IF p.wnd # 0 THEN
res := USER32.InvalidateRgn(p.wnd, grgn, 1);
par := USER32.GetParent(p.wnd);
IF (par # 0) & (USER32.GetTopWindow(par) # p.wnd) THEN
res := USER32.UpdateWindow(p.wnd)
END
END;
(* pattern origin correction *)
INC(rd.dx, dx); INC(rd.dy, dy);
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
;IF debug THEN Wait END
END Scroll;
PROCEDURE (rd: Rider) SetCursor* (cursor: INTEGER);
VAR old: USER32.Handle;
BEGIN
old := USER32.SetCursor(cursors[cursor])
END SetCursor;
PROCEDURE SetMouseState* (x, y: INTEGER; but: SET; isDown: BOOLEAN);
BEGIN
mx := x; my := y; mb := but
END SetMouseState;
PROCEDURE (rd: Rider) Input* (OUT x, y: INTEGER; OUT modifiers: SET; OUT isDown: BOOLEAN);
VAR msg: USER32.Message; wnd, mw: USER32.Handle; pt: USER32.Point; res: INTEGER; set: SET;
BEGIN
Services.actionHook.Step; (* mc:060325 *)
KERNEL32.Sleep(1);
wnd := rd.port.wnd; mw := USER32.GetCapture();
(* Alexander Iljin: fixed scrolling update problem *)(* Alexander Iljin: fixed scrolling update problem *)
res := USER32.UpdateWindow(wnd);
IF USER32.PeekMessageA(msg, mw, USER32.WMMouseMove, USER32.WMMButtonDblClk, 1) # 0 THEN
mx := (msg.lParam + 32768) MOD 65536 - 32768; my := msg.lParam DIV 65536;
IF (mw # 0) & (wnd # mw) THEN
pt.x := mx; pt.y := my; res := USER32.ClientToScreen(mw, pt);
res := USER32.ScreenToClient(wnd, pt); mx := pt.x; my := pt.y
END;
mb := {};
set := SYSTEM.VAL(SET, msg.wParam);
IF WinApi.MK_LBUTTON * set # {} THEN INCL(mb, left) END;
IF WinApi.MK_MBUTTON * set # {} THEN INCL(mb, middle) END;
IF WinApi.MK_RBUTTON * set # {} THEN INCL(mb, right) END;
IF WinApi.MK_CONTROL * set # {} THEN INCL(mb, ctrl) END;
IF WinApi.MK_SHIFT * set # {} THEN INCL(mb, shift) END;
IF USER32.GetAsyncKeyState(12H) < 0 THEN INCL(mb, alt) END;
(*
Windows.dir.Update(NIL)
*)
END;
IF WinApi.GetSystemMetrics(WinApi.SM_SWAPBUTTON) # 0 THEN
IF USER32.GetAsyncKeyState(1) >= 0 THEN EXCL(mb, right) END;
IF USER32.GetAsyncKeyState(2) >= 0 THEN EXCL(mb, left) END
ELSE
IF USER32.GetAsyncKeyState(1) >= 0 THEN EXCL(mb, left) END;
IF USER32.GetAsyncKeyState(2) >= 0 THEN EXCL(mb, right) END
END;
IF USER32.GetAsyncKeyState(4) >= 0 THEN EXCL(mb, middle) END;
IF WinApi.GetAsyncKeyState(WinApi.VK_SHIFT) < 0 THEN
mb := mb + {shift, extend} ELSE mb := mb - {shift, extend}
END;
IF WinApi.GetAsyncKeyState(WinApi.VK_CONTROL) < 0 THEN
mb := mb + {ctrl, modify} ELSE mb := mb - {ctrl, modify}
END;
IF WinApi.GetAsyncKeyState(WinApi.VK_MENU) < 0 THEN INCL(mb, alt) ELSE EXCL(mb, alt) END;
(*
(* alt handling *)
res := USER32.PeekMessageA(msg, 0, USER32.WMSysKeyDown, USER32.WMSysKeyDown, 1);
*)
x := mx; y := my; modifiers := mb; isDown := mb * {left, middle, right} # {}
END Input;
PROCEDURE (rd: Rider) DrawSString* (
x, y: INTEGER; col: Ports.Color; IN s: ARRAY OF SHORTCHAR; font: Fonts.Font
);
VAR res, i, a, b, c, w, u, n: INTEGER; p: Port; dc, old: GDI32.Handle; ch: SHORTCHAR;
df: HostFonts.DevFont; dx: ARRAY 1024 OF INTEGER; s1: ARRAY 1024 OF SHORTCHAR; fsp: BOOLEAN;
BEGIN
ASSERT(rd.port # NIL, 100);
WITH font: HostFonts.Font DO
p := rd.port; dc := p.dc; u := p.unit;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
IF df = NIL THEN HostFonts.InsertDevFont(dc, font, df, u)
ELSE old := GDI32.SelectObject(dc, df.id)
END;
IF col = Ports.defaultColor THEN col := textCol END;
res := GDI32.SetTextColor(dc, col);
IF df.noGap THEN INC(x) END; (* caret pos optimization *)
INC(x, font.ftab[ORD(s[0])] DIV u);
a := LEN(s) - 1; n := 0; ch := s[0]; fsp := FALSE;
WHILE (n < a) & (ch # 0X) DO
IF ch = figureSpace THEN fsp := TRUE END;
INC(n); ch := s[n]
END;
IF (df.id = font.id) & ~fsp THEN (* native metric *)
res := GDI32.TextOutA(dc, x, y, s, n)
ELSE (* adapt to meta metric *)
a := 0; b := 0; i := 0; ch := s[0];
WHILE i < n DO
c := df.wtab[ORD(ch)]; INC(a, c); dx[i] := c;
INC(b, font.wtab[ORD(ch)]);
s1[i] := s[i];
IF ch = figureSpace THEN s1[i] := " " END;
INC(i); ch := s[i]
END;
n := i; c := b DIV u - a; i := 0; w := 0; a := 0;
WHILE i < n DO
INC(w, c); b := w DIV n; INC(dx[i], b - a); a := b; INC(i)
END;
res := GDI32.ExtTextOutA(dc, x, y, {}, NIL, s1, n, dx)
END
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
END DrawSString;
PROCEDURE (rd: Rider) SCharIndex* (
x, pos: INTEGER; IN s: ARRAY OF SHORTCHAR; font: Fonts.Font
): INTEGER;
VAR d, u, i, n, a, b, c, w: INTEGER; df: HostFonts.DevFont; ch: SHORTCHAR; dc: GDI32.Handle;
BEGIN
ASSERT(rd.port # NIL, 100);
WITH font: HostFonts.Font DO
u := rd.port.unit; df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
IF df = NIL THEN HostFonts.InsertDevFont(rd.port.dc, font, df, u) END;
a := 0; b := 0; n := LEN(s) - 1; i := 0; ch := s[0];
WHILE (i < n) & (ch # 0X) DO
INC(a, df.wtab[ORD(ch)]);
INC(b, font.wtab[ORD(ch)]);
INC(i); ch := s[i]
END;
n := i; c := b DIV u - a; i := 0; w := 0; a := 0;
INC(x, font.ftab[ORD(s[0])] DIV u);
d := df.wtab[ORD(s[0])];
WHILE (i < n) & (pos > x + d DIV 2) DO
INC(w, c); b := w DIV n; INC(d, b - a); a := b;
INC(i); INC(x, d); d := df.wtab[ORD(s[i])]
END
END;
RETURN i
END SCharIndex;
PROCEDURE (rd: Rider) SCharPos* (
x, index: INTEGER; IN s: ARRAY OF SHORTCHAR; font: Fonts.Font
): INTEGER;
VAR i, u, n, a, b, c, w: INTEGER; df: HostFonts.DevFont; ch: SHORTCHAR;
BEGIN
ASSERT(rd.port # NIL, 100); ASSERT(index <= LEN(s), 101);
WITH font: HostFonts.Font DO
u := rd.port.unit; df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
IF df = NIL THEN HostFonts.InsertDevFont(rd.port.dc, font, df, u) END;
a := 0; b := 0; n := LEN(s) - 1; i := 0; ch := s[0];
WHILE (i < n) & (ch # 0X) DO
INC(a, df.wtab[ORD(ch)]);
INC(b, font.wtab[ORD(ch)]);
INC(i); ch := s[i]
END;
n := i; c := b DIV u - a; i := 0; w := 0; a := 0;
INC(x, font.ftab[ORD(s[0])] DIV u);
WHILE (i < n) & (i < index) DO
INC(w, c); b := w DIV n; INC(x, b - a); a := b;
INC(x, df.wtab[ORD(s[i])]); INC(i)
END
END;
RETURN x
END SCharPos;
PROCEDURE (rd: Rider) DrawString* (
x, y: INTEGER; col: Ports.Color; IN s0: ARRAY OF CHAR; font: Fonts.Font
);
VAR res, i, a, b, c, n, w, u: INTEGER; p: Port; dc, old: GDI32.Handle; ch: SHORTCHAR;
s: ARRAY 1024 OF CHAR;
str: ARRAY 1024 OF SHORTCHAR;
df: HostFonts.DevFont; dx: ARRAY 1024 OF INTEGER; wt: ARRAY 1 OF INTEGER;
BEGIN
i21sysCharacters.ToUnicode(s0, s);
IF ~HostFonts.isUnicode THEN
ch := 1X;
res := KERNEL32.WideCharToMultiByte(0, {}, s, -1, str, LEN(str), ch, NIL);
str[res] := 0X;
rd.DrawSString(x, y, col, str, font);
RETURN
END;
ASSERT(rd.port # NIL, 100);
WITH font: HostFonts.Font DO
p := rd.port; dc := p.dc; u := p.unit;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF col = Ports.defaultColor THEN col := textCol END;
df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
IF (df # NIL) & (df.id = font.id) THEN (* native metric *)
n := LEN(s) - 1; i := 0;
WHILE (i < n) & (s[i] # 0X) DO INC(i) END;
res := GDI32.SelectObject(dc, df.id);
IF df.noGap THEN INC(x) END; (* caret pos optimization *)
res := GDI32.SetTextColor(dc, col);
res := GDI32.TextOutW(dc, x, y, s, i)
ELSE (* adapt to meta metric *)
old := GDI32.SelectObject(dc, font.id);
a := 0; b := 0; n := LEN(s) - 1; i := 0;
WHILE (i < n) & (s[i] # 0X) DO INC(b, font.wTab(dc, s[i])); INC(i) END;
INC(x, font.fTab(dc, s[0]) DIV u);
IF df = NIL THEN HostFonts.InsertDevFont(dc, font, df, u)
ELSE res := GDI32.SelectObject(dc, df.id)
END;
n := i; i := 0;
WHILE i < n DO
res := GDI32.GetCharWidth32W(dc, ORD(s[i]), ORD(s[i]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[i]), ORD(s[i]), wt) END;
IF res # 0 THEN c := wt[0] ELSE c := df.wtab[1] END;
INC(a, c); dx[i] := c; INC(i)
END;
c := b DIV u - a; i := 0; w := 0; a := 0;
WHILE i < n DO
INC(w, c); b := w DIV n; INC(dx[i], b - a); a := b; INC(i)
END;
res := GDI32.SetTextColor(dc, col);
IF df.noGap THEN INC(x) END; (* caret pos optimization *)
res := GDI32.ExtTextOutW(dc, x, y, {}, NIL, s, n, dx)
END
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
END DrawString;
PROCEDURE (rd: Rider) CharIndex* (x, pos: INTEGER; IN s: ARRAY OF CHAR; font: Fonts.Font): INTEGER;
VAR res, d, u, i, a, b, c, w, n: INTEGER; ch: SHORTCHAR; str: ARRAY 1024 OF SHORTCHAR;
df: HostFonts.DevFont; dc: USER32.Handle; wt: ARRAY 1 OF INTEGER;
BEGIN
IF ~HostFonts.isUnicode THEN
ch := 1X;
res := KERNEL32.WideCharToMultiByte(0, {}, s, -1, str, LEN(str), ch, NIL);
str[res] := 0X;
RETURN rd.SCharIndex(x, pos, str, font)
END;
ASSERT(rd.port # NIL, 100);
dc := rd.port.dc;
WITH font: HostFonts.Font DO
res := GDI32.SelectObject(dc, font.id);
u := rd.port.unit; df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
a := 0; b := 0; n := LEN(s) - 1; i := 0;
WHILE (i < n) & (s[i] # 0X) DO INC(b, font.wTab(dc, s[i])); INC(i) END;
INC(x, font.fTab(dc, s[0]) DIV u);
IF df = NIL THEN HostFonts.InsertDevFont(dc, font, df, u)
ELSE res := GDI32.SelectObject(dc, df.id)
END;
n := i; i := 0;
WHILE i < n DO
res := GDI32.GetCharWidth32W(dc, ORD(s[i]), ORD(s[i]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[i]), ORD(s[i]), wt) END;
IF res # 0 THEN c := wt[0] ELSE c := df.wtab[1] END;
INC(a, c); INC(i)
END;
c := b DIV u - a; i := 0; w := 0; a := 0;
res := GDI32.GetCharWidth32W(dc, ORD(s[0]), ORD(s[0]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[0]), ORD(s[0]), wt) END;
IF res # 0 THEN d := wt[0] ELSE d := df.wtab[1] END;
WHILE (i < n) & (pos > x + d DIV 2) DO
INC(w, c); b := w DIV n; INC(d, b - a); a := b;
INC(i); INC(x, d);
res := GDI32.GetCharWidth32W(dc, ORD(s[i]), ORD(s[i]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[i]), ORD(s[i]), wt) END;
IF res # 0 THEN d := wt[0] ELSE d := df.wtab[1] END;
END
END;
RETURN i
END CharIndex;
PROCEDURE (rd: Rider) CharPos* (x, index: INTEGER; IN s: ARRAY OF CHAR; font: Fonts.Font): INTEGER;
VAR res, i, u, a, b, c, w, d, n: INTEGER; ch: SHORTCHAR; str: ARRAY 1024 OF SHORTCHAR;
df: HostFonts.DevFont; dc: USER32.Handle; wt: ARRAY 1 OF INTEGER;
BEGIN
IF ~HostFonts.isUnicode THEN
ch := 1X;
res := KERNEL32.WideCharToMultiByte(0, {}, s, -1, str, LEN(str), ch, NIL);
str[res] := 0X;
RETURN rd.SCharPos(x, index, str, font)
END;
ASSERT(rd.port # NIL, 100); ASSERT(index <= LEN(s), 101);
dc := rd.port.dc;
WITH font: HostFonts.Font DO
res := GDI32.SelectObject(dc, font.id);
u := rd.port.unit; df := font.dev;
WHILE (df # NIL) & (df.unit # u) DO df := df.next END;
a := 0; b := 0; n := LEN(s) - 1; i := 0;
WHILE (i < n) & (s[i] # 0X) DO INC(b, font.wTab(dc, s[i])); INC(i) END;
INC(x, font.fTab(dc, s[0]) DIV u);
IF df = NIL THEN HostFonts.InsertDevFont(dc, font, df, u)
ELSE res := GDI32.SelectObject(dc, df.id)
END;
n := i; i := 0;
WHILE i < n DO
res := GDI32.GetCharWidth32W(dc, ORD(s[i]), ORD(s[i]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[i]), ORD(s[i]), wt) END;
IF res # 0 THEN c := wt[0] ELSE c := df.wtab[1] END;
INC(a, c); INC(i)
END;
c := b DIV u - a; i := 0; w := 0; a := 0;
WHILE (i < n) & (i < index) DO
INC(w, c); b := w DIV n; INC(x, b - a); a := b;
res := GDI32.GetCharWidth32W(dc, ORD(s[i]), ORD(s[i]), wt);
IF res = 0 THEN res := GDI32.GetCharWidthW(dc, ORD(s[i]), ORD(s[i]), wt) END;
IF res # 0 THEN d := wt[0] ELSE d := df.wtab[1] END;
INC(x, d); INC(i)
END
END;
RETURN x
END CharPos;
PROCEDURE (rd: Rider) SaveRect* (l, t, r, b: INTEGER; VAR res: INTEGER);
VAR rs: INTEGER; p: Port;
BEGIN
res := 1; p := rd.port;
ASSERT(p.dc # 0, 20);
IF l < 0 THEN l := 0 END;
IF t < 0 THEN t := 0 END;
IF r > p.w THEN r := p.w END;
IF b > p.h THEN b := p.h END;
IF (l < r) & (t < b) THEN
rd.sl := l; rd.st := t; rd.sr := r; rd.sb := b;
rd.dc := GDI32.CreateCompatibleDC(p.dc);
IF rd.dc # 0 THEN
rd.map := GDI32.CreateCompatibleBitmap(p.dc, r - l, b - t);
IF rd.map # 0 THEN
rs := GDI32.SelectObject(rd.dc, rd.map);
rs := GDI32.BitBlt(rd.dc, 0, 0, r - l, b - t, p.dc, l, t, copy);
res := 0
ELSE
rs := GDI32.DeleteDC(rd.dc); rd.dc := 0
END
END
END
END SaveRect;
PROCEDURE (rd: Rider) RestoreRect* (l, t, r, b: INTEGER; dispose: BOOLEAN);
VAR res: INTEGER; p: Port; dc: GDI32.Handle;
BEGIN
IF rd.dc # 0 THEN
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF l < rd.sl THEN l := rd.sl END;
IF t < rd.st THEN t := rd.st END;
IF r > rd.sr THEN r := rd.sr END;
IF b > rd.sb THEN b := rd.sb END;
res := GDI32.BitBlt(dc, l, t, r - l, b - t, rd.dc, l - rd.sl, t - rd.st, copy);
IF dispose THEN
res := GDI32.DeleteDC(rd.dc);
res := GDI32.DeleteObject(rd.map);
rd.dc := 0; rd.map := 0
END;
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
END
END RestoreRect;
PROCEDURE (rd: Rider) CopyFrom* (sdc: GDI32.Handle; x, y: INTEGER), NEW;
VAR res: INTEGER; p: Port; dc: GDI32.Handle;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port; dc := p.dc;
IF p.wnd = 0 THEN res := GDI32.SaveDC(dc)
ELSE res := GDI32.SelectClipRgn(dc, 0);
END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
res := GDI32.BitBlt(dc, rd.l, rd.t, rd.r - rd.l, rd.b - rd.t, sdc, x, y, copy);
IF p.wnd = 0 THEN res := GDI32.RestoreDC(dc, -1) END
END CopyFrom;
PROCEDURE (rd: Rider) DrawBitmap* (bmdc: GDI32.Handle; bw, bh, x, y, w, h: INTEGER), NEW;
VAR res, u: INTEGER; p: Port; dc: GDI32.Handle;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port;
dc := p.dc; u := p.unit;
res := GDI32.SaveDC(dc);
IF p.wnd # 0 THEN res := GDI32.SelectClipRgn(dc, 0) END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
IF (bw * u = w) & (bh * u = h) THEN
res := GDI32.BitBlt(dc, x DIV u, y DIV u, bw, bh, bmdc, 0, 0, copy)
ELSE
res := GDI32.StretchBlt(dc, x DIV u, y DIV u, w DIV u, h DIV u, bmdc, 0, 0, bw, bh, copy)
END;
res := GDI32.RestoreDC(dc, -1)
END DrawBitmap;
PROCEDURE (rd: Rider) DrawMetafile* (mf: GDI32.Handle; mode, x, y, w, h: INTEGER), NEW;
VAR res, oldMode, u: INTEGER; p: Port; dc: GDI32.Handle;
BEGIN
ASSERT(rd.port # NIL, 100);
p := rd.port;
p.CloseBuffer;
dc := p.dc; u := p.unit;
res := GDI32.SaveDC(dc);
IF p.wnd # 0 THEN res := GDI32.SelectClipRgn(dc, 0) END;
res := GDI32.IntersectClipRect(dc, rd.l, rd.t, rd.r, rd.b);
oldMode := GDI32.SetMapMode(dc, mode);
res := GDI32.SetViewportOrgEx(dc, x DIV u, y DIV u, NIL);
res := GDI32.SetViewportExtEx(dc, w DIV u, h DIV u, NIL);
res := GDI32.SetTextAlign(dc, 0);
res := GDI32.PlayMetaFile(dc, mf);
res := GDI32.SetViewportOrgEx(dc, 0, 0, NIL);
res := GDI32.SetMapMode(dc, oldMode);
res := GDI32.RestoreDC(dc, -1)
END DrawMetafile;
PROCEDURE (rd: Rider) FixOrigin*, NEW;
VAR p: Port; res: INTEGER; pt: GDI32.Point;
BEGIN
p := rd.port;
IF (Dialog.platform = 11) & (p.dc = p.homedc) & (p.wnd # 0) THEN (* win32s *)
pt.x := 0; pt.y := 0; res := USER32.ClientToScreen(p.wnd, pt);
res := GDI32.FixBrushOrgEx(p.dc, (rd.dx + pt.x) MOD 8, (rd.dy + pt.y) MOD 8, NIL)
ELSE
res := GDI32.SetBrushOrgEx(p.dc, (rd.dx - p.bx) MOD 8, (rd.dy - p.by) MOD 8, NIL)
END
END FixOrigin;
(** miscellaneous **)
PROCEDURE ResetColors*;
BEGIN
Ports.background := USER32.GetSysColor(5);
textCol := USER32.GetSysColor(8);
selBackground := USER32.GetSysColor(13);
selTextCol := USER32.GetSysColor(14);
Ports.dialogBackground := USER32.GetSysColor(15);
dialogTextCol := USER32.GetSysColor(18);
dialogShadowCol := USER32.GetSysColor(16);
dialogLightCol := USER32.GetSysColor(20);
END ResetColors;
PROCEDURE SetPrinterColors*;
BEGIN
Ports.background := Ports.white;
textCol := Ports.black;
selBackground := Ports.white;
selTextCol := Ports.black;
Ports.dialogBackground := Ports.white
END SetPrinterColors;
PROCEDURE ToggleDebug*;
BEGIN
debug := ~debug; noBuffer := debug
END ToggleDebug;
PROCEDURE ToggleBuffer*;
BEGIN
noBuffer := ~noBuffer
END ToggleBuffer;
PROCEDURE Init;
VAR i: INTEGER; instance, bm: KERNEL32.Handle; pat: ARRAY 12 OF SHORTINT;
BEGIN
instance := KERNEL32.GetModuleHandleA(NIL);
ResetColors;
grgn := GDI32.CreateRectRgn(0, 0, 0, 0);
nullBrush := GDI32.GetStockObject(GDI32.NullBrush);
nullPen := GDI32.GetStockObject(GDI32.NullPen);
cursors[Ports.arrowCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCArrow));
cursors[Ports.textCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCIBeam));
cursors[Ports.graphicsCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCCross));
cursors[Ports.bitmapCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCCross));
cursors[Ports.tableCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(7));
IF cursors[Ports.tableCursor] = 0 THEN cursors[Ports.tableCursor] := cursors[Ports.graphicsCursor] END;
cursors[Ports.refCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(6));
cursors[resizeHCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCSizeWE));
cursors[resizeVCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCSizeNS));
cursors[resizeLCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCSizeNWSE));
cursors[resizeRCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCSizeNESW));
cursors[resizeCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCSizeAll));
cursors[busyCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCWait));
cursors[stopCursor] := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCNo));
cursors[moveCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(1));
cursors[copyCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(2));
cursors[linkCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(3));
cursors[pickCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(4));
IF cursors[stopCursor] = 0 THEN
cursors[stopCursor] := USER32.LoadCursorA(instance, USER32.MakeIntRsrc(5))
END;
i := 0;
WHILE i < LEN(cursors) DO
IF cursors[i] = 0 THEN cursors[i] := cursors[Ports.arrowCursor] END;
INC(i)
END;
pat[0] := 0EEH; pat[1] := 0DDH; pat[2] := 0BBH; pat[3] := 077H;
pat[4] := 0EEH; pat[5] := 0DDH; pat[6] := 0BBH; pat[7] := 077H;
bm := GDI32.CreateBitmap(8, 8, 1, 1, SYSTEM.ADR(pat));
focusBrush := GDI32.CreatePatternBrush(bm);
pat[0] := 0EEH; pat[1] := 0BBH; pat[2] := 0DDH; pat[3] := 077H;
pat[4] := 0EEH; pat[5] := 0BBH; pat[6] := 0DDH; pat[7] := 077H;
bm := GDI32.CreateBitmap(8, 8, 1, 1, SYSTEM.ADR(pat));
dim25Brush := GDI32.CreatePatternBrush(bm);
pat[0] := 0AAH; pat[1] := 055H; pat[2] := 0AAH; pat[3] := 055H;
pat[4] := 0AAH; pat[5] := 055H; pat[6] := 0AAH; pat[7] := 055H;
bm := GDI32.CreateBitmap(8, 8, 1, 1, SYSTEM.ADR(pat));
dim50Brush := GDI32.CreatePatternBrush(bm);
pat[0] := 011H; pat[1] := 044H; pat[2] := 022H; pat[3] := 088H;
pat[4] := 011H; pat[5] := 044H; pat[6] := 022H; pat[7] := 088H;
bm := GDI32.CreateBitmap(8, 8, 1, 1, SYSTEM.ADR(pat));
dim75Brush := GDI32.CreatePatternBrush(bm);
invertBrush := GDI32.GetStockObject(GDI32.BlackBrush)
END Init;
BEGIN
Init
END HostPorts.
| Host/Mod/Ports.odc |
MODULE HostPrinters; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20080215, Fyodor Tkachov, reviewed
- 20051020, Ilya Ermakov, added external access way to printer parameters
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, KERNEL32, GDI32, USER32, COMDLG32,
Kernel, Files, Dialog, Ports, HostPorts, Stores, Models, Views, Controllers,
Properties, Printers, Printing, Documents, Windows, HostWindows;
CONST
eduMsgH = 30 * Ports.point;
dialogCommand = "StdCmds.OpenToolDialog('HostPrinters.printing', '#Host:Print')";
TYPE
Printer = POINTER TO RECORD (Printers.Printer)
w, h: INTEGER;
(* port: HostPorts.Port; (* port to which forwarding occurs *) *)
devNames, devMode: GDI32.Handle; (* printer description *)
clean: TrapCleaner;
cancel: Windows.Window (* cancel dialog *)
END;
(*
Rider = POINTER TO RECORD (HostPorts.Rider)
p: Printer
END;
*)
Directory = POINTER TO RECORD (Printers.Directory) END;
TrapCleaner = POINTER TO RECORD (Kernel.TrapCleaner)
p: Printer
END;
VAR
printing*: RECORD
pnum-: INTEGER;
Cancel*: PROCEDURE
END;
dir: Directory;
current: Printers.Printer;
aborted: BOOLEAN;
sa, sb, sc: ARRAY 64 OF CHAR;
err: INTEGER;
PROCEDURE PrinterDC (devNames, devMode: GDI32.Handle): GDI32.Handle;
VAR adr: INTEGER; i: SHORTINT; a, b, c: GDI32.StringPtr; dc: GDI32.Handle; dm: GDI32.DevModePtr;
BEGIN
adr := KERNEL32.GlobalLock(devNames);
dm := SYSTEM.VAL(GDI32.DevModePtr, KERNEL32.GlobalLock(devMode));
SYSTEM.GET(adr + 0, i); a := SYSTEM.VAL(GDI32.StringPtr, adr + i);
SYSTEM.GET(adr + 2, i); b := SYSTEM.VAL(GDI32.StringPtr, adr + i);
SYSTEM.GET(adr + 4, i); c := SYSTEM.VAL(GDI32.StringPtr, adr + i);
dc := GDI32.CreateDCA(a, b, c, dm^);
IF dc = 0 THEN dc := GDI32.CreateDCA(a, b, c, NIL) END;
adr := KERNEL32.GlobalUnlock(devMode);
adr := KERNEL32.GlobalUnlock(devNames);
RETURN dc
END PrinterDC;
(*
PROCEDURE GetPaperSize (id, orient: LONGINT; VAR w, h: LONGINT);
VAR x, y: LONGINT;
BEGIN
CASE id OF
| 1, 2, 18: x := 17 * Ports.inch DIV 2; y := 11 * Ports.inch
| 3, 4: x := 11 * Ports.inch; y := 17 * Ports.inch
| 5: x := 17 * Ports.inch DIV 2; y := 14 * Ports.inch
| 6: x := 11 * Ports.inch DIV 2; y := 17 * Ports.inch DIV 2
| 7: x := 29 * Ports.inch DIV 4; y := 21 * Ports.inch DIV 2
| 8: x := 297 * Ports.mm; y := 420 * Ports.mm
| 9, 10: x := 210 * Ports.mm; y := 297 * Ports.mm
| 11: x := 148 * Ports.mm; y := 210 * Ports.mm
| 12: x := 250 * Ports.mm; y := 354 * Ports.mm
| 13: x := 182 * Ports.mm; y := 257 * Ports.mm
| 14, 41: x := 17 * Ports.inch DIV 2; y := 13 * Ports.inch
| 15: x := 215 * Ports.mm; y := 275 * Ports.mm
| 16: x := 10 * Ports.inch; y := 14 * Ports.inch
| 17: x := 11 * Ports.inch; y := 17 * Ports.inch
| 19: x := 31 * Ports.inch DIV 8; y := 71 * Ports.inch DIV 8
| 20: x := 33 * Ports.inch DIV 8; y := 19 * Ports.inch DIV 2
| 21: x := 9 * Ports.inch DIV 2; y := 83 * Ports.inch DIV 8
| 22: x := 19 * Ports.inch DIV 4; y := 11 * Ports.inch
| 23: x := 5 * Ports.inch; y := 23 * Ports.inch DIV 2
| 24: x := 17 * Ports.inch; y := 22 * Ports.inch
| 25: x := 22 * Ports.inch; y := 34 * Ports.inch
| 26: x := 34 * Ports.inch; y := 44 * Ports.inch
| 27: x := 110 * Ports.mm; y := 220 * Ports.mm
| 28: x := 162 * Ports.mm; y := 229 * Ports.mm
| 29: x := 324 * Ports.mm; y := 458 * Ports.mm
| 30: x := 229 * Ports.mm; y := 324 * Ports.mm
| 31: x := 114 * Ports.mm; y := 162 * Ports.mm
| 32: x := 114 * Ports.mm; y := 229 * Ports.mm
| 33: x := 250 * Ports.mm; y := 353 * Ports.mm
| 34: x := 176 * Ports.mm; y := 250 * Ports.mm
| 35: x := 125 * Ports.mm; y := 176 * Ports.mm
| 36: x := 110 * Ports.mm; y := 230 * Ports.mm
| 37: x := 31 * Ports.inch DIV 8; y := 15 * Ports.inch DIV 2
| 38: x := 29 * Ports.inch DIV 8; y := 13 * Ports.inch DIV 2
| 39: x := 119 * Ports.inch DIV 8; y := 11 * Ports.inch
| 40: x := 17 * Ports.inch DIV 2; y := 12 * Ports.inch
ELSE orient := 0
END;
IF orient = 1 THEN w := x; h := y
ELSIF orient = 2 THEN w := y; h := x
END
END GetPaperSize;
*)
PROCEDURE NewPrinter* (devNames, devMode: GDI32.Handle): Printers.Printer;
VAR p: Printer; res, w, h, pw, ph, nx, ny, unit, ux, uy: INTEGER;
dc: GDI32.Handle; m: GDI32.DevModePtr; pt: GDI32.Point;
port: HostPorts.Port;
BEGIN
ASSERT(devNames # 0, 20);
dc := PrinterDC(devNames, devMode);
IF dc # 0 THEN
NEW(p);
p.devNames := devNames; p.devMode := devMode;
w := GDI32.GetDeviceCaps(dc, GDI32.HorzRes);
h := GDI32.GetDeviceCaps(dc, GDI32.VertRes);
nx := GDI32.GetDeviceCaps(dc, GDI32.LogPixelsX);
ny := GDI32.GetDeviceCaps(dc, GDI32.LogPixelsY);
ux := (Ports.inch + nx DIV 2) DIV nx;
uy := (Ports.inch + ny DIV 2) DIV ny;
unit := ux;
IF nx < ny THEN
(*
res := GDI32.SetMapMode(dc, 8); (* anisotropic *)
res := GDI32.SetWindowExtEx(dc, 1, nx, NIL); (* does not scale fonts correctly !!! *)
res := GDI32.SetViewportExtEx(dc, 1, ny, NIL);
*)
h := h * nx DIV ny
ELSIF nx > ny THEN
(*
res := GDI32.SetMapMode(dc, 8); (* anisotropic *)
res := GDI32.SetWindowExtEx(dc, ny, 1, NIL); (* does not scale fonts correctly !!! *)
res := GDI32.SetViewportExtEx(dc, nx, 1, NIL);
*)
w := w * ny DIV nx; unit := uy
END;
(*
m := SYSTEM.VAL(GDI32.DevModePtr, KERNEL32.GlobalLock(devMode));
wu := w * unit; hu := h * unit; pw := wu; ph := hu; (* port as default *)
GetPaperSize(m.paperSize, m.orientation, pw, ph);
res := KERNEL32.GlobalUnlock(devMode);
IF pw < wu THEN pw := wu END;
IF ph < hu THEN ph := hu END;
*)
pw := GDI32.GetDeviceCaps(dc, GDI32.PhysicalWidth);
ph := GDI32.GetDeviceCaps(dc, GDI32.PhysicalHeight);
IF (pw = 0) OR (ph = 0) THEN
res := GDI32.Escape(dc, 12, 0, NIL, pt);
ASSERT(res > 0, 100);
pw := pt.x; ph := pt.y
END;
pw := pw * ux; ph := ph * uy;
nx := GDI32.GetDeviceCaps(dc, GDI32.PhysicalOffsetX);
ny := GDI32.GetDeviceCaps(dc, GDI32.PhysicalOffsetY);
IF (nx = 0) OR (ny = 0) THEN
res := GDI32.Escape(dc, 13, 0, NIL, pt);
ASSERT(res > 0, 100);
nx := pt.x; ny := pt.y
END;
nx := nx * ux; ny := ny * uy;
(*
p.Init(unit);
p.SetSize(w, h);
*)
p.InitPrinter(-nx, -ny, pw - nx, ph - ny);
NEW(port); p.InitPort(port);
port.Init(unit, Ports.printer);
port.SetSize(w, h);
res := GDI32.DeleteDC(dc)
ELSE p := NIL
END;
RETURN p
END NewPrinter;
PROCEDURE SetCurrent* (devNames, devMode: GDI32.Handle); (* used in HostDialog *)
BEGIN
IF devNames # 0 THEN
current := NewPrinter(devNames, devMode)
END;
END SetCurrent;
PROCEDURE GetPage* (p: Printers.Printer; VAR w, h: INTEGER);
VAR l, t, r, b: INTEGER;
BEGIN
WITH p: Printer DO
p.GetRect(l, t, r, b);
w := r - l;
h := b - t
END
END GetPage;
PROCEDURE Error (res: INTEGER): INTEGER;
BEGIN
IF res = -1 THEN res := KERNEL32.GetLastError()
ELSIF aborted THEN res := 1
ELSE res := 0
END;
RETURN res
END Error;
PROCEDURE Cancel;
BEGIN
aborted := TRUE
END Cancel;
PROCEDURE [2] AbortHandler (dc: GDI32.Handle; error: INTEGER): INTEGER;
VAR res: INTEGER; msg: USER32.Message; s: ARRAY 32 OF CHAR;
BEGIN
WHILE USER32.PeekMessageA(msg, 0, 0, 0, 1) # 0 DO
res := USER32.TranslateMessage(msg);
(*
IF msg.message = USER32.WMPaint THEN
res := USER32.GetClassNameA(msg.wnd, s, LEN(s));
IF (s # "Oberon Doc") & (s # "Oberon Aux") THEN
res := USER32.DispatchMessageA(msg)
END
ELSE
res := USER32.DispatchMessageA(msg)
END
*)
res := USER32.DispatchMessageA(msg)
END;
IF aborted THEN RETURN 0 ELSE RETURN 1 END
END AbortHandler;
PROCEDURE (c: TrapCleaner) Cleanup;
VAR res: INTEGER; p: Printer;
BEGIN
p := c.p;
res := GDI32.AbortDoc(p.ThisPort()(HostPorts.Port).dc);
res := GDI32.DeleteDC(p.ThisPort()(HostPorts.Port).dc);
res := USER32.EnableWindow(HostWindows.main, 1);
HostPorts.ResetColors;
IF p.cancel # NIL THEN Windows.dir.Close(p.cancel); p.cancel := NIL END
END Cleanup;
(* Printer *)
(*
PROCEDURE (p: Printer) NewRider (): Rider;
VAR r: Rider;
BEGIN
ASSERT(p.port # NIL, 20); ASSERT(p.port.dc # 0, 21);
NEW(r); r.p := p; r.InitPort(p.port);
RETURN r
END NewRider;
*)
PROCEDURE (p: Printer) OpenJob (VAR copies: INTEGER; name: ARRAY OF CHAR);
VAR res: INTEGER; info: GDI32.DocInfo; s: Stores.Store; sn: ARRAY 256 OF SHORTCHAR;
port: HostPorts.Port;
BEGIN
aborted := FALSE; copies := 1;
port := p.ThisPort()(HostPorts.Port);
port.SetDC(PrinterDC(p.devNames, p.devMode), 0);
p.res := Error(GDI32.SetAbortProc(port.dc, AbortHandler));
IF p.res = 0 THEN
(* open cancel dialog *)
printing.pnum := 0;
HostWindows.dir.unmoveable := TRUE;
Dialog.Call(dialogCommand, " ", res);
HostWindows.dir.unmoveable := FALSE;
p.cancel := Windows.dir.First();
(* install trap cleaner *)
NEW(p.clean); p.clean.p := p;
Kernel.PushTrapCleaner(p.clean);
(* start printing *)
info.size := SIZE(GDI32.DocInfo);
sn := SHORT(name$);
info.docName := sn;
info.output := NIL;
p.res := Error(GDI32.StartDocA(port.dc, info));
HostPorts.SetPrinterColors;
res := USER32.EnableWindow(HostWindows.main, 0)
END;
port.SetDC(port.dc, 0) (* reinitialize dc *)
END OpenJob;
PROCEDURE (p: Printer) CloseJob;
VAR res: INTEGER; port: HostPorts.Port;
BEGIN
port := p.ThisPort()(HostPorts.Port);
IF aborted THEN p.res := Error(GDI32.AbortDoc(port.dc))
ELSE p.res := Error(GDI32.EndDoc(port.dc))
END;
res := GDI32.DeleteDC(port.dc);
res := USER32.EnableWindow(HostWindows.main, 1);
HostPorts.ResetColors;
IF p.cancel # NIL THEN Windows.dir.Close(p.cancel); p.cancel := NIL END;
Kernel.PopTrapCleaner(p.clean)
END CloseJob;
PROCEDURE (p: Printer) OpenPage;
VAR res: INTEGER; port: HostPorts.Port;
BEGIN
port := p.ThisPort()(HostPorts.Port);
IF ~aborted THEN p.res := Error(GDI32.StartPage(port.dc)) END;
printing.pnum := Printing.Current() (* Printing.par.page.current *) + 1;
Dialog.Update(printing);
res := USER32.UpdateWindow(p.cancel(HostWindows.Window).wnd);
port.SetDC(port.dc, 0) (* reinitialize dc *)
END OpenPage;
PROCEDURE (p: Printer) ClosePage;
BEGIN
IF ~aborted THEN p.res := Error(GDI32.EndPage(p.ThisPort()(HostPorts.Port).dc)) END
END ClosePage;
(*
PROCEDURE (p: Printer) SetSize (w, h: INTEGER);
BEGIN
p.w := w; p.h := h
END SetSize;
PROCEDURE (p: Printer) OpenBuffer (l, t, r, b: INTEGER);
END OpenBuffer;
PROCEDURE (p: Printer) CloseBuffer;
END CloseBuffer;
PROCEDURE (p: Printer) GetSize (OUT w, h: INTEGER);
BEGIN
w := p.w; h := p.h
END GetSize;
*)
(* Rider *)
(*
PROCEDURE (rd: Rider) Base (): Ports.Port;
BEGIN
RETURN rd.p
END Base;
*)
(* Directory *)
PROCEDURE (d: Directory) Default (): Printers.Printer;
VAR res: INTEGER; prt: COMDLG32.PrintDlgData;
BEGIN
prt.size := SIZE(COMDLG32.PrintDlgData);
prt.devMode := 0; prt.devNames := 0; prt.owner := 0;
prt.flags := {7, 10}; (* no warning, return default *)
res := COMDLG32.PrintDlgA(prt);
IF res # 0 THEN
RETURN NewPrinter(prt.devNames, prt.devMode)
ELSE
(*
res := COMDLG32.CommDlgExtendedError();
ASSERT(res = 1008H, 100); (* no default printer *)
*)
RETURN NIL
END
END Default;
PROCEDURE (d: Directory) Current (): Printers.Printer;
BEGIN
RETURN current
END Current;
PROCEDURE (d: Directory) Available (): BOOLEAN;
BEGIN
RETURN current # NIL
END Available;
PROCEDURE GetPrinterDev* (p: Printers.Printer; OUT devNames, devMode: GDI32.Handle);
BEGIN
WITH p: Printer DO
devNames := p.devNames;
devMode := p.devMode
ELSE
devNames := 0;
devMode := 0
END;
END GetPrinterDev;
PROCEDURE Init;
VAR prt: COMDLG32.PrintDlgData;
BEGIN
printing.Cancel := Cancel;
NEW(dir); Printers.SetDir(dir);
current := dir.Default()
END Init;
BEGIN
Init
END HostPrinters.
| Host/Mod/Printers.odc |
MODULE HostRegistry;
(** project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20100322, F.V.Tkachov, implemented local storage of registry data in order to make it unique for each project folder (BlackBox's server mode); the original text is appended herewith.
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT KERNEL32, ADVAPI32, HostFiles, Dialog, Strings, Files;
IMPORT Files, Dialog, Strings, HostRegistry0;
VAR localeId*: INTEGER;
CONST registryPath = ''; registryName = 'registry.ini'; tab = 9;
TYPE
Field = ARRAY 100 OF SHORTCHAR;
Record = POINTER TO RECORD
key, value: Field;
next: Record
END;
VAR registry: Record;
PROCEDURE WriteField ( wr: Files.Writer; s: Field );
VAR i: INTEGER;
BEGIN
i := 0;
WHILE s[ i ] # 0X DO
wr.WriteByte( SHORT( ORD( s[ i ] ) ) );
i := i + 1
END;
wr.WriteByte( tab );
END WriteField;
PROCEDURE WriteRecord ( wr: Files.Writer; rec: Record );
VAR
BEGIN
WriteField( wr, rec.key );
WriteField( wr, rec.value );
END WriteRecord;
PROCEDURE SaveRegistry;
VAR loc: Files.Locator; file: Files.File; wr: Files.Writer;
rec: Record; res: INTEGER;
BEGIN
loc := Files.dir.This( registryPath );
file := Files.dir.New( loc, Files.dontAsk );
wr := file.NewWriter( wr );
rec := registry;
WHILE rec # NIL DO
WriteRecord( wr, rec );
rec := rec.next
END;
file.Register( registryName, '', Files.dontAsk, res ); ASSERT( res = 0 );
END SaveRegistry;
PROCEDURE ReadField ( rd: Files.Reader; OUT s: Field );
VAR i: INTEGER; byte: BYTE;
BEGIN
i := 0;
rd.ReadByte( byte );
IF ~rd.eof THEN
WHILE byte # tab DO
s[ i ] := SHORT( CHR( byte ) );
i := i + 1;
rd.ReadByte( byte );
END;
END;
s[ i ] := 0X;
END ReadField;
PROCEDURE ReadRecord ( rd: Files.Reader; OUT rec: Record );
VAR key: Field;
BEGIN
ReadField( rd, key );
IF key # '' THEN
NEW( rec );
rec.key := key;
ReadField( rd, rec.value );
ELSE
rec := NIL
END;
END ReadRecord;
PROCEDURE ReadRegistry;
VAR loc: Files.Locator; file: Files.File; rd: Files.Reader;
rec: Record; res: INTEGER;
BEGIN
loc := Files.dir.This( registryPath );
file := Files.dir.Old( loc, registryName, Files.exclusive );
IF file # NIL THEN
rd := file.NewReader( rd );
rec := NIL;
ReadRecord( rd, rec );
WHILE rec # NIL DO
rec.next := registry; registry := rec;
ReadRecord( rd, rec )
END;
file.Close;
ELSE
file := Files.dir.New( loc, Files.dontAsk );
file.Register( registryName, '', Files.dontAsk, res ); ASSERT( res = 0 );
END;
END ReadRegistry;
PROCEDURE FindRecord ( key: Field ): Record;
VAR rec: Record;
BEGIN
rec := registry;
WHILE ( rec # NIL ) & ( rec.key$ # key$ ) DO
rec := rec.next
END;
RETURN rec
END FindRecord;
PROCEDURE AddRecord ( key, value: Field );
VAR rec: Record;
BEGIN
ASSERT( FindRecord( key ) = NIL, 100 );
NEW( rec ); rec.key := key; rec.value := value;
rec.next := registry; registry := rec;
END AddRecord;
PROCEDURE ReadPair (
key: ARRAY OF SHORTCHAR; OUT value: ARRAY OF SHORTCHAR; OUT res: INTEGER
);
VAR rec: Record;
BEGIN
rec := FindRecord( key$ );
IF rec = NIL THEN
res := 1;
value := ''
ELSE
res := 0;
value := rec.value$
END
END ReadPair;
PROCEDURE WritePair (
key: ARRAY OF SHORTCHAR; value: ARRAY OF SHORTCHAR
);
VAR rec: Record;
BEGIN
ASSERT( ( key # '' ) & ( value # '' ) );
rec := FindRecord( key$ );
IF rec = NIL THEN
AddRecord( key$, value$ );
ELSE
ASSERT( rec.key = key$ );
rec.value := value$
END;
END WritePair;
PROCEDURE ReadString* (
key: ARRAY OF SHORTCHAR; VAR str: ARRAY OF SHORTCHAR; VAR res: INTEGER
);
VAR r, len: INTEGER; sw, comp, appl, vers: ADVAPI32.Handle; an: ARRAY 32 OF SHORTCHAR;
BEGIN
ReadPair( key, str, res ); IF res = 0 THEN RETURN END;
res := ADVAPI32.RegOpenKeyA(ADVAPI32.KeyCurrentUser, "Software", sw);
IF res = 0 THEN
res := ADVAPI32.RegOpenKeyA(sw, "Oberon", comp);
IF res = 0 THEN
an := SHORT(Dialog.appName$);
res := ADVAPI32.RegOpenKeyA(comp, an, appl);
IF res = 0 THEN
res := ADVAPI32.RegOpenKeyA(appl, "CurrentVersion", vers);
IF res = 0 THEN
len := LEN(str);
res := ADVAPI32.RegQueryValueA(vers, key, str, len);
r := ADVAPI32.RegCloseKey(vers)
END;
r := ADVAPI32.RegCloseKey(appl)
END;
r := ADVAPI32.RegCloseKey(comp)
END;
r := ADVAPI32.RegCloseKey(sw)
END
END ReadString;
PROCEDURE ReadInt* (key: ARRAY OF SHORTCHAR; VAR x: INTEGER; VAR res: INTEGER);
VAR str: ARRAY 64 OF SHORTCHAR; s: ARRAY 64 OF CHAR;
BEGIN
ReadString(key, str, res); s := str$;
IF res = 0 THEN Strings.StringToInt(s, x, res) END;
END ReadInt;
PROCEDURE ReadBool* (key: ARRAY OF SHORTCHAR; VAR x: BOOLEAN; VAR res: INTEGER);
VAR str: ARRAY 4 OF SHORTCHAR;
BEGIN
ReadString(key, str, res);
IF res = 0 THEN x := str = "1" END
END ReadBool;
PROCEDURE ReadIntList* (key: ARRAY OF SHORTCHAR; VAR x: ARRAY OF INTEGER; VAR res: INTEGER);
VAR i, n, val, sig: INTEGER; str: ARRAY 256 OF SHORTCHAR;
BEGIN
ReadString(key, str, res);
IF res = 0 THEN
n := 0; i := 0;
WHILE str[i] # 0X DO
IF n >= LEN(x) THEN res := 2; RETURN END;
val := 0; sig := 1;
IF str[i] = "-" THEN sig := -1; INC(i) END;
WHILE (str[i] >= "0") & (str[i] <= "9") DO val := 10 * val + ORD(str[i]) - ORD("0"); INC(i) END;
x[n] := sig * val;
IF str[i] = "," THEN INC(i)
ELSIF str[i] # 0X THEN res := 1; RETURN
END;
INC(n)
END
END
END ReadIntList;
PROCEDURE WriteString* (key: ARRAY OF SHORTCHAR; str: ARRAY OF SHORTCHAR);
VAR res, n: INTEGER; sw, comp, appl, vers: ADVAPI32.Handle; an: ARRAY 32 OF SHORTCHAR;
BEGIN
WritePair( key, str ); RETURN;
res := ADVAPI32.RegCreateKeyA(ADVAPI32.KeyCurrentUser, "Software", sw);
IF res = 0 THEN
res := ADVAPI32.RegCreateKeyA(sw, "Oberon", comp);
IF res = 0 THEN
an := SHORT(Dialog.appName$);
res := ADVAPI32.RegCreateKeyA(comp, an, appl);
IF res = 0 THEN
res := ADVAPI32.RegCreateKeyA(appl, "CurrentVersion", vers);
IF res = 0 THEN
n := 0;
WHILE (n < LEN(str)) & (str[n] # 0X) DO INC(n) END;
res := ADVAPI32.RegSetValueA(vers, key, 1, str, n);
END;
res := ADVAPI32.RegCloseKey(appl)
END;
res := ADVAPI32.RegCloseKey(comp)
END;
res := ADVAPI32.RegCloseKey(sw)
END
END WriteString;
PROCEDURE WriteInt* (key: ARRAY OF SHORTCHAR; x: INTEGER);
VAR str: ARRAY 64 OF CHAR;
BEGIN
Strings.IntToString(x, str);
WriteString(key, SHORT(str))
END WriteInt;
PROCEDURE WriteBool* (key: ARRAY OF SHORTCHAR; x: BOOLEAN);
BEGIN
IF x THEN WriteString(key, "1") ELSE WriteString(key, "0") END
END WriteBool;
PROCEDURE WriteIntList* (key: ARRAY OF SHORTCHAR; VAR x: ARRAY OF INTEGER);
VAR i, j, n: INTEGER; str: ARRAY 256 OF SHORTCHAR; s: ARRAY 16 OF CHAR;
BEGIN
n := 0; i := 0;
WHILE n < LEN(x) DO
IF (n > 0) & (i < LEN(str)) THEN str[i] := ","; INC(i) END;
Strings.IntToString(x[n], s); j := 0;
WHILE (s[j] # 0X) & (i < LEN(str)) DO str[i] := SHORT(s[j]); INC(i); INC(j) END;
INC(n)
END;
IF i < LEN(str) THEN str[i] := 0X ELSE str[LEN(str) - 1] := 0X END;
WriteString(key, str)
END WriteIntList;
PROCEDURE ReadMeasure;
VAR res, len: INTEGER; cp, int: ADVAPI32.Handle; str: ARRAY 4 OF SHORTCHAR;
BEGIN
res := KERNEL32.GetProfileIntA("intl", "iMeasure", 1);
Dialog.metricSystem := res = 0
END ReadMeasure;
PROCEDURE Init;
VAR name, bname: Dialog.String; res, i, v: INTEGER;
BEGIN
v := KERNEL32.GetVersion();
localeId := 1024; (* user default *)
name := HostFiles.appName$;
bname := "BLACKBOX"; i := 0;
WHILE (i < 8) & (CAP(name[i]) = bname[i]) DO INC(i) END;
IF i = 8 THEN
name := "BlackBox"
ELSIF (v < 0) & (v MOD 256 < 4) THEN
i := 1;
WHILE name[i] # 0X DO
IF (name[i] >= "A") & (name[i] <= "Z") THEN name[i] := CHR(ORD(name[i]) + ORD("a") - ORD("A")) END;
INC(i)
END
END;
Dialog.appName := name$;
Dialog.version := 15;
Dialog.Call("Startup.Setup", "", res);
ReadMeasure
END Init;
BEGIN
ReadRegistry;
Init
CLOSE
SaveRegistry;
END HostRegistry.
(* the original version of HostRegistry *)
MODULE HostRegistry;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT KERNEL32, ADVAPI32, HostFiles, Dialog, Strings;
VAR localeId*: INTEGER;
PROCEDURE ReadString* (
key: ARRAY OF SHORTCHAR; VAR str: ARRAY OF SHORTCHAR; VAR res: INTEGER
);
VAR r, len: INTEGER; sw, comp, appl, vers: ADVAPI32.Handle; an: ARRAY 32 OF SHORTCHAR;
BEGIN
res := ADVAPI32.RegOpenKeyA(ADVAPI32.KeyCurrentUser, "Software", sw);
IF res = 0 THEN
res := ADVAPI32.RegOpenKeyA(sw, "Oberon", comp);
IF res = 0 THEN
an := SHORT(Dialog.appName$);
res := ADVAPI32.RegOpenKeyA(comp, an, appl);
IF res = 0 THEN
res := ADVAPI32.RegOpenKeyA(appl, "CurrentVersion", vers);
IF res = 0 THEN
len := LEN(str);
res := ADVAPI32.RegQueryValueA(vers, key, str, len);
r := ADVAPI32.RegCloseKey(vers)
END;
r := ADVAPI32.RegCloseKey(appl)
END;
r := ADVAPI32.RegCloseKey(comp)
END;
r := ADVAPI32.RegCloseKey(sw)
END
END ReadString;
PROCEDURE ReadInt* (key: ARRAY OF SHORTCHAR; VAR x: INTEGER; VAR res: INTEGER);
VAR str: ARRAY 64 OF SHORTCHAR; s: ARRAY 64 OF CHAR;
BEGIN
ReadString(key, str, res); s := str$;
IF res = 0 THEN Strings.StringToInt(s, x, res) END;
END ReadInt;
PROCEDURE ReadBool* (key: ARRAY OF SHORTCHAR; VAR x: BOOLEAN; VAR res: INTEGER);
VAR str: ARRAY 4 OF SHORTCHAR;
BEGIN
ReadString(key, str, res);
IF res = 0 THEN x := str = "1" END
END ReadBool;
PROCEDURE ReadIntList* (key: ARRAY OF SHORTCHAR; VAR x: ARRAY OF INTEGER; VAR res: INTEGER);
VAR i, n, val, sig: INTEGER; str: ARRAY 256 OF SHORTCHAR;
BEGIN
ReadString(key, str, res);
IF res = 0 THEN
n := 0; i := 0;
WHILE str[i] # 0X DO
IF n >= LEN(x) THEN res := 2; RETURN END;
val := 0; sig := 1;
IF str[i] = "-" THEN sig := -1; INC(i) END;
WHILE (str[i] >= "0") & (str[i] <= "9") DO val := 10 * val + ORD(str[i]) - ORD("0"); INC(i) END;
x[n] := sig * val;
IF str[i] = "," THEN INC(i)
ELSIF str[i] # 0X THEN res := 1; RETURN
END;
INC(n)
END
END
END ReadIntList;
PROCEDURE WriteString* (key: ARRAY OF SHORTCHAR; str: ARRAY OF SHORTCHAR);
VAR res, n: INTEGER; sw, comp, appl, vers: ADVAPI32.Handle; an: ARRAY 32 OF SHORTCHAR;
BEGIN
res := ADVAPI32.RegCreateKeyA(ADVAPI32.KeyCurrentUser, "Software", sw);
IF res = 0 THEN
res := ADVAPI32.RegCreateKeyA(sw, "Oberon", comp);
IF res = 0 THEN
an := SHORT(Dialog.appName$);
res := ADVAPI32.RegCreateKeyA(comp, an, appl);
IF res = 0 THEN
res := ADVAPI32.RegCreateKeyA(appl, "CurrentVersion", vers);
IF res = 0 THEN
n := 0;
WHILE (n < LEN(str)) & (str[n] # 0X) DO INC(n) END;
res := ADVAPI32.RegSetValueA(vers, key, 1, str, n);
END;
res := ADVAPI32.RegCloseKey(appl)
END;
res := ADVAPI32.RegCloseKey(comp)
END;
res := ADVAPI32.RegCloseKey(sw)
END
END WriteString;
PROCEDURE WriteInt* (key: ARRAY OF SHORTCHAR; x: INTEGER);
VAR str: ARRAY 64 OF CHAR;
BEGIN
Strings.IntToString(x, str);
WriteString(key, SHORT(str))
END WriteInt;
PROCEDURE WriteBool* (key: ARRAY OF SHORTCHAR; x: BOOLEAN);
BEGIN
IF x THEN WriteString(key, "1") ELSE WriteString(key, "0") END
END WriteBool;
PROCEDURE WriteIntList* (key: ARRAY OF SHORTCHAR; VAR x: ARRAY OF INTEGER);
VAR i,j, n: INTEGER; str: ARRAY 256 OF SHORTCHAR; s: ARRAY 16 OF CHAR;
BEGIN
n := 0; i := 0;
WHILE n < LEN(x) DO
IF (n > 0) & (i < LEN(str)) THEN str[i] := ","; INC(i) END;
Strings.IntToString(x[n], s); j := 0;
WHILE (s[j] # 0X) & (i < LEN(str)) DO str[i] := SHORT(s[j]); INC(i); INC(j) END;
INC(n)
END;
IF i < LEN(str) THEN str[i] := 0X ELSE str[LEN(str) - 1] := 0X END;
WriteString(key, str)
END WriteIntList;
PROCEDURE ReadMeasure;
VAR res, len: INTEGER; cp, int: ADVAPI32.Handle; str: ARRAY 4 OF SHORTCHAR;
BEGIN
res := KERNEL32.GetProfileIntA("intl", "iMeasure", 1);
Dialog.metricSystem := res = 0
END ReadMeasure;
PROCEDURE Init;
VAR name, bname: Dialog.String; res, i, v: INTEGER;
BEGIN
v := KERNEL32.GetVersion();
localeId := 1024; (* user default *)
name := HostFiles.appName$;
bname := "BLACKBOX";
i := 0;
WHILE (i < 8) & (CAP(name[i]) = bname[i]) DO INC(i) END;
IF i = 8 THEN
name := "BlackBox"
ELSIF (v < 0) & (v MOD 256 < 4) THEN
i := 1;
WHILE name[i] # 0X DO
IF (name[i] >= "A") & (name[i] <= "Z") THEN
name[i] := CHR(ORD(name[i]) + ORD("a") - ORD("A"))
END;
INC(i)
END
END;
Dialog.appName := name$;
Dialog.version := 15;
Dialog.Call("Startup.Setup", "", res);
ReadMeasure
END Init;
BEGIN
Init
END HostRegistry. | Host/Mod/Registry.odc |
MODULE HostTabFrames;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, Kernel, WinApi, WinCtl, Fonts, Ports, Views,
Controllers, Dialog, HostFonts, HostPorts, StdTabViews;
CONST
DEL = 07X;
dlgWindowExtra = 30;
TYPE
Info = RECORD
wnd, ctrl: WinApi.HANDLE;
x1, y1, w1, h1, x2, y2, w2, h2: INTEGER;
hasFocus: BOOLEAN
END;
Tab = POINTER TO RECORD (StdTabViews.Frame)
i: Info;
dispLeft, dispTop, dispWidth, dispHeight: INTEGER;
END;
Directory = POINTER TO RECORD (StdTabViews.FrameDirectory) END;
VAR
instance: WinApi.HANDLE;
SubclassCtl: PROCEDURE(wnd: WinApi.HANDLE);
(* auxiliary procedures *)
PROCEDURE GetSize (f: StdTabViews.Frame; VAR x, y, w, h: INTEGER);
VAR u, x0, y0: INTEGER;
BEGIN
u := f.unit; f.view.context.GetSize(w, h); x0 := f.gx; y0 := f.gy;
x := x0 DIV u; y := y0 DIV u;
w := (x0 + w) DIV u - x; h := (y0 + h) DIV u - y
END GetSize;
PROCEDURE Adapt (f: StdTabViews.Frame; VAR i: Info);
VAR res, x, y, w, h, cx, cy, cw, ch: INTEGER; r: HostPorts.Rider;
BEGIN
IF i.wnd # 0 THEN
r := f.rider(HostPorts.Rider);
IF r.port.wnd # 0 THEN (* port is a window *)
GetSize(f, x, y, w, h);
cx := r.l; cy := r.t; cw := r.r - r.l; ch := r.b - r.t;
IF (cx # i.x1) OR (cy # i.y1) OR (cw # i.w1) OR (ch # i.h1) THEN
i.x1 := cx; i.y1 := cy; i.w1 := cw; i.h1 := ch;
res := WinApi.MoveWindow(i.wnd, cx, cy, cw, ch, 0)
END;
DEC(x, cx); DEC(y, cy);
IF (x # i.x2) OR (y # i.y2) OR (w # i.w2) OR (h # i.h2) THEN
i.x2 := x; i.y2 := y; i.w2 := w; i.h2 := h;
res := WinApi.MoveWindow(i.ctrl, x, y, w, h, 0)
END
END
END
END Adapt;
PROCEDURE Open (f: StdTabViews.Frame; class, name: WinApi.PtrSTR; style, ex: SET; VAR i: Info);
VAR res, x, y, w, h, cx, cy, cw, ch: INTEGER; p: HostPorts.Port; s: SET; r: Ports.Rider;
BEGIN
f.noRedraw := TRUE;
r := f.rider; GetSize(f, x, y, w, h);
r.GetRect(cx, cy, cw, ch); cw := cw - cx; ch := ch - cy;
p := f.rider(HostPorts.Rider).port;
IF p.wnd # 0 THEN (* port is a window *)
s := {27, 30}; (* disabled, child *)
i.wnd := WinApi.CreateWindowExA({}, "Oberon Tab", "", s, cx, cy, cw, ch, p.wnd, 0, instance, 0);
IF i.wnd # 0 THEN
DEC(x, cx); DEC(y, cy);
res := WinApi.SetWindowLongA(i.wnd, dlgWindowExtra, SYSTEM.VAL(INTEGER, f));
i.ctrl := WinApi.CreateWindowExA(ex, class, name, style, x, y, w, h, i.wnd, 0, instance, 0);
IF i.ctrl # 0 THEN
IF (SubclassCtl # NIL) THEN SubclassCtl(i.ctrl) END;
IF f.font # NIL THEN
res := WinApi.SendMessageA(i.ctrl, WinApi.WM_SETFONT, f.font(HostFonts.Font).dev.id, 0)
END;
Adapt(f, i);
res := WinApi.ShowWindow(i.wnd, 1);
res := WinApi.ShowWindow(i.ctrl, 1);
ELSE res := WinApi.DestroyWindow(i.wnd); i.wnd := 0
END
ELSE i.ctrl := 0
END
ELSE (* port is a printer -> define temp windows *)
i.wnd := 0; i.ctrl := 0;
END
END Open;
PROCEDURE (f: Tab) Print (l, r, t, b: INTEGER), NEW;
VAR
w, h, sw, asc, dsc, fw, len, sel, i, dm, x, y, top: INTEGER;
font: Fonts.Font; tv: StdTabViews.View; s: Dialog.String; v: Views.View;
BEGIN
IF f.font # NIL THEN font := f.font ELSE font := HostFonts.dlgFont END;
font.GetBounds(asc, dsc, fw); y := asc + dsc; x := 0; dm := 0;(*y DIV 10;*) top := 0;
f.view.context.GetSize(w, h); f.DrawRect(0, 0, w, h, 1, Ports.black);
tv := f.view(StdTabViews.View); sel := tv.Index();
len := tv.NofTabs();
IF len > 0 THEN
i := 0;
tv.GetItem(i, s, v); Dialog.MapString(s, s);
WHILE (i < len) & (s # "") & (v # NIL) DO
tv.GetItem(i, s, v); Dialog.MapString(s, s);
sw := SHORT(ENTIER(font.StringWidth(s) * 1.20)) + 2*dsc;
IF (x + sw + 2*dm) > w THEN
f.DrawLine(0, y + 2*dm, w, y + 2*dm, 1, Ports.black);
x := 0; top := y + 2*dm; y := y + 2*dm + asc + dsc
END;
IF i = sel THEN
f.DrawRect(x, top, x + sw + 2*dm, y + 2*dm, Ports.fill, Ports.black);
f.DrawString(x + dm + dsc, y - dsc + dm, Ports.white, s, font)
ELSE
f.DrawRect(x, top, x + sw + 2*dm, y + 2*dm, 1, Ports.black);
f.DrawString(x + dm + dsc, y - dsc + dm, Ports.black, s, font)
END;
x := x + sw + 2*dm;
INC(i);
END;
f.DrawLine(0, y + 2*dm, w, y + 2*dm, 1, Ports.black);
f.dispLeft := f.unit; f.dispTop := y + 2*dm + f.unit;
f.dispWidth := w - 2*f.unit; f.dispHeight := h - (y + 2*dm + f.unit);
END;
(*
IF f.font # NIL THEN font := f.font ELSE font := HostFonts.dlgFont END;
font.GetBounds(asc, dsc, fw); y := asc + dsc; x := 0; dm := y DIV 10; top := 0;
f.view.context.GetSize(w, h); f.DrawRect(0, 0, w, h, 1, Ports.black);
tv := f.view(StdTabViews.View); sel := tv.Index();
len := tv.NofTabs();
IF len > 0 THEN
tv.GetItem(sel, lbl, v); Dialog.MapString(lbl, lbl);
s := " *" + lbl$ + "*"; sv := v;
i := 0;
WHILE (i < len) & (lbl # "") & (v # NIL) DO
IF i # sel THEN tv.GetItem(i, lbl, v); Dialog.MapString(lbl, lbl); s := s + " | " + lbl END;
INC(i);
END;
f.DrawString(dm, y + dm, Ports.black, s, font);
f.DrawLine(0, y + 2*dm, w, y + 2*dm, 1, Ports.black);
f.dispLeft := f.unit; f.dispTop := y + 2*dm + f.unit;
f.dispWidth := w - 2*f.unit; f.dispHeight := h - (y + 2*dm + f.unit);
END;
*)
END Print;
PROCEDURE SendKey (ch: SHORTCHAR; wnd: WinApi.HANDLE);
VAR res, code: INTEGER;
BEGIN
CASE ch OF
| 10X: code := 21H
| 11X: code := 22H
| 12X: code := 21H
| 13X: code := 22H
| 14X: code := 24H
| 15X: code := 23H
| 16X: code := 24H
| 17X: code := 23H
| 1CX: code := 25H
| 1DX: code := 27H
| 1EX: code := 26H
| 1FX: code := 28H
| DEL: code := 2EH
ELSE code := 0
END;
IF code # 0 THEN
res := WinApi.SendMessageA(wnd, WinApi.WM_KEYDOWN, code, 0);
res := WinApi.SendMessageA(wnd, WinApi.WM_KEYUP, code, 0)
ELSE
res := WinApi.SendMessageA(wnd, WinApi.WM_CHAR, ORD(ch), 0)
END
END SendKey;
PROCEDURE HandleMouse (wnd: WinApi.HANDLE; x, y: INTEGER; buttons: SET);
VAR res, b, hc, m: INTEGER; pt: WinApi.POINT; w: WinApi.HANDLE; msg: WinApi.MSG;
BEGIN
res := WinApi.ReleaseCapture(); b := 0;
IF HostPorts.left IN buttons THEN INC(b) END;
IF HostPorts.right IN buttons THEN INC(b, 2) END;
IF Controllers.extend IN buttons THEN INC(b, 4) END;
IF Controllers.modify IN buttons THEN INC(b, 8) END;
pt.x := x; pt.y := y;
REPEAT
w := wnd; wnd := WinApi.ChildWindowFromPoint(wnd, pt);
res := WinApi.ClientToScreen(w, pt);
hc := WinApi.SendMessageA(wnd, WinApi.WM_NCHITTEST, 0, pt.x + pt.y * 65536);
res := WinApi.ScreenToClient(wnd, pt)
UNTIL (hc # 1) OR (w = wnd);
IF hc > 1 THEN
res := WinApi.ClientToScreen(wnd, pt);
IF ODD(b) THEN m := WinApi.WM_NCLBUTTONDOWN
ELSE m := WinApi.WM_NCRBUTTONDOWN
END;
res := WinApi.SendMessageA(wnd, m, hc, pt.x + pt.y * 65536)
ELSE
res := WinApi.GetClassLongA(wnd, -26); (* classStyle *)
IF (Controllers.doubleClick IN buttons) & ODD(res DIV 8) THEN (* DblClks IN classStyle *)
IF ODD(b) THEN m := WinApi.WM_LBUTTONDBLCLK ELSE m := WinApi.WM_RBUTTONDBLCLK END
ELSE
IF ODD(b) THEN m := WinApi.WM_LBUTTONDOWN ELSE m := WinApi.WM_RBUTTONDOWN END
END;
res := WinApi.SendMessageA(wnd, m, b, pt.x + pt.y * 65536)
END;
REPEAT
res := WinApi.GetMessageA(msg, 0, 0, 0);
IF (msg.message >= WinApi.WM_MOUSEMOVE) & (msg.message <= WinApi.WM_MBUTTONDBLCLK)
THEN
b := msg.wParam
END;
res := WinApi.TranslateMessage(msg);
res := WinApi.DispatchMessageA(msg)
UNTIL b MOD 4 = 0
END HandleMouse;
PROCEDURE Mark (on, focus: BOOLEAN; VAR i: Info);
VAR res: INTEGER;
BEGIN
IF focus THEN
IF on THEN
IF ~i.hasFocus THEN
res := WinApi.SendMessageA(i.ctrl, WinApi.WM_SETFOCUS, 0, 0);
i.hasFocus := TRUE
END
ELSE
IF i.hasFocus THEN
res := WinApi.SendMessageA(i.ctrl, WinApi.WM_KILLFOCUS, 0, 0);
i.hasFocus := FALSE
END
END
END
END Mark;
(* Tab *)
PROCEDURE (f: Tab) SetOffset (x, y: INTEGER);
BEGIN
f.SetOffset^(x, y);
Adapt(f, f.i)
END SetOffset;
PROCEDURE (f: Tab) Close;
VAR res: INTEGER;
BEGIN
IF f.i.wnd # 0 THEN (* deallocate *)
ASSERT(f.rider # NIL, 100); ASSERT(f.rider.Base() # NIL, 101);
res := WinApi.DestroyWindow(f.i.wnd);
f.i.wnd := 0; f.i.ctrl := 0
END;
(*f.Close^*)
END Close;
PROCEDURE (f: Tab) Update;
VAR
res: INTEGER;
BEGIN
IF ~f.disabled THEN
IF WinApi.IsWindowEnabled(f.i.ctrl) = 0 THEN res := WinApi.EnableWindow(f.i.ctrl, 1) END
ELSE
IF WinApi.IsWindowEnabled(f.i.ctrl) # 0 THEN res := WinApi.EnableWindow(f.i.ctrl, 0) END
END;
res := WinApi.UpdateWindow(f.i.ctrl);
END Update;
PROCEDURE (f: Tab) UpdateList;
VAR
res, i, sel, len: INTEGER;
ti: WinCtl.TCITEMA;
s: Dialog.String; ss: ARRAY 256 OF SHORTCHAR;
rect: WinApi.RECT;
v: Views.View;
tv: StdTabViews.View;
hrgn, hrgn1: WinApi.HRGN;
BEGIN
tv := f.view(StdTabViews.View); sel := tv.Index();
res := WinApi.SendMessageA(f.i.ctrl, WinCtl.TCM_DELETEALLITEMS, 0, 0);
len := tv.NofTabs();
(* Add the tabs to the tabcontrol *)
IF len > 0 THEN
i := 0; tv.GetItem(i, s, v); Dialog.MapString(s, s); ss := SHORT(s$);
WHILE (i < len) & (ss # "") & (v # NIL) DO
ti.mask := WinCtl.TCIF_TEXT + WinCtl.TCIF_IMAGE;
ti.pszText := ss; ti.iImage := -1;
res := WinApi.SendMessage(f.i.ctrl, WinCtl.TCM_INSERTITEM, i, SYSTEM.ADR(ti));
INC(i); IF i < len THEN tv.GetItem(i, s, v); Dialog.MapString(s, s); ss := SHORT(s$) END
END
END;
(* Get the display area *)
rect.left := 0; rect.top := 0; rect.right := f.i.w2; rect.bottom := f.i.h2;
res := WinApi.SendMessageA(f.i.ctrl, WinCtl.TCM_ADJUSTRECT, WinApi.FALSE, SYSTEM.ADR(rect));
(* set the area which the control should redraw *)
hrgn := WinApi.CreateRectRgn(0, 0, f.i.w2, f.i.h2);
hrgn1 := WinApi.CreateRectRgn(rect.left, rect.top, rect.right, rect.bottom);
res := WinApi.CombineRgn(hrgn, hrgn, hrgn1, WinApi.RGN_DIFF);
res := WinApi.SetWindowRgn(f.i.ctrl, hrgn, WinApi.FALSE);
IF res = 0 THEN res := WinApi.DeleteObject(hrgn) END;
res := WinApi.DeleteObject(hrgn1);
(* set the area which the contained views should draw *)
f.dispLeft := rect.left * f.unit; f.dispTop := rect.top * f.unit;
f.dispWidth := (rect.right - rect.left) * f.unit; f.dispHeight := (rect.bottom - rect.top) * f.unit;
(* Set the size and the domain of the views *)
IF len > 0 THEN
i := 0; tv.GetItem(i, s, v); ss := SHORT(s$);
WHILE (i < len) & (ss # "") & (v # NIL) DO
v.context.SetSize(f.dispWidth, f.dispHeight);
INC(i); IF i < len THEN tv.GetItem(i, s, v); ss := SHORT(s$) END
END
END;
(* Reset selection *)
res := WinApi.SendMessageA(f.i.ctrl, WinCtl.TCM_SETCURSEL, sel, 0);
f.Update
END UpdateList;
PROCEDURE (f: Tab) Paint (il, it, ir, ib: INTEGER), NEW;
VAR res, l, t, r, b, w, h: INTEGER; ri: HostPorts.Rider; rect: WinApi.RECT;
BEGIN
res := WinApi.GetWindowRect(f.i.wnd, rect);
w := rect.right - rect.left; h := rect.bottom - rect.top;
ri := f.rider(HostPorts.Rider);
ri.port.CloseBuffer;
IF it < f.dispTop THEN (* Paint the top part *)
l := (il DIV f.unit) - 1; IF l < 0 THEN l := 0 END; r := (ir DIV f.unit) + 1; IF r > w THEN r := w END;
rect.left := l; rect.top := 0; rect.right := r; rect.bottom := f.dispTop DIV f.unit;
res := WinApi.InvalidateRect(f.i.wnd, rect, 0); res := WinApi.InvalidateRect(f.i.ctrl, rect, 0);
res := WinApi.UpdateWindow(f.i.wnd); res := WinApi.UpdateWindow(f.i.ctrl)
END;
IF il < f.dispLeft THEN (* Paint the left part *)
t := (it DIV f.unit) - 1; IF t < 0 THEN t := 0 END; b := (ib DIV f.unit) + 1; IF b > h THEN b := h END;
rect.left := 0; rect.top := t; rect.right := f.dispLeft DIV f.unit; rect.bottom := b;
res := WinApi.InvalidateRect(f.i.wnd, rect, 0); res := WinApi.InvalidateRect(f.i.ctrl, rect, 0);
res := WinApi.UpdateWindow(f.i.wnd); res := WinApi.UpdateWindow(f.i.ctrl)
END;
IF ib > f.dispTop + f.dispHeight THEN (* Paint the bottom part *)
l := (il DIV f.unit) - 1; IF l < 0 THEN l := 0 END; r := (ir DIV f.unit) + 1; IF r > w THEN r := w END;
rect.left := l; rect.top := (f.dispTop + f.dispHeight) DIV f.unit; rect.right := r; rect.bottom := h;
res := WinApi.InvalidateRect(f.i.wnd, rect, 0); res := WinApi.InvalidateRect(f.i.ctrl, rect, 0);
res := WinApi.UpdateWindow(f.i.wnd); res := WinApi.UpdateWindow(f.i.ctrl)
END;
IF ir > f.dispLeft + f.dispWidth THEN (* Paint the right part *)
t := (it DIV f.unit) - 1; IF t < 0 THEN t := 0 END; b := (ib DIV f.unit) + 1; IF b > h THEN b := h END;
rect.left := (f.dispLeft + f.dispWidth) DIV f.unit; rect.top := t; rect.right := w; rect.bottom := b;
res := WinApi.InvalidateRect(f.i.wnd, rect, 0); res := WinApi.InvalidateRect(f.i.ctrl, rect, 0);
res := WinApi.UpdateWindow(f.i.wnd); res := WinApi.UpdateWindow(f.i.ctrl)
END
END Paint;
PROCEDURE (f: Tab) Restore (l, t, r, b: INTEGER);
VAR
icex: WinCtl.INITCOMMONCONTROLSEX;
ok: WinApi.BOOL;
BEGIN
IF f.i.ctrl = 0 THEN (* lazy allocation *)
icex.dwSize := SIZE(WinCtl.INITCOMMONCONTROLSEX);
icex.dwICC := WinCtl.ICC_TAB_CLASSES;
ok := WinCtl.InitCommonControlsEx(icex);
Open(f, WinCtl.WC_TABCONTROL, "",
WinApi.WS_CLIPSIBLINGS + WinApi.WS_CHILD + WinApi.WS_VISIBLE + WinCtl.TCS_MULTILINE,
{}, f.i);
f.UpdateList;
END;
f.Update;
IF f.i.wnd # 0 THEN f.Paint(l, t, r, b) ELSE f.Print(l, t, r, b) END
END Restore;
PROCEDURE (f: Tab) KeyDown (ch: CHAR);
VAR res: INTEGER;
BEGIN
ASSERT(~f.disabled, 100);
IF ch = " " THEN
res := WinApi.SendMessageA(f.i.ctrl, WinApi.WM_KEYDOWN, ORD(ch), 0);
res := WinApi.SendMessageA(f.i.ctrl, WinApi.WM_KEYUP, ORD(ch), 0)
ELSE SendKey(SHORT(ch), f.i.ctrl)
END
END KeyDown;
PROCEDURE (f: Tab) MouseDown (x, y: INTEGER; buttons: SET);
BEGIN
ASSERT(~f.disabled, 100);
IF f.rider # NIL THEN
HandleMouse(f.i.wnd, x DIV f.unit, y DIV f.unit, buttons)
END
END MouseDown;
PROCEDURE (f: Tab) Mark (on, focus: BOOLEAN);
BEGIN
Mark(on, f.front, f.i)
END Mark;
PROCEDURE (f: Tab) InDispArea (x, y: INTEGER): BOOLEAN;
BEGIN
IF ((x >= f.dispLeft) & (x <= f.dispLeft + f.dispWidth) &
(y >= f.dispTop) & (y <= f.dispTop + f.dispHeight)) THEN
RETURN TRUE
ELSE
RETURN FALSE
END
END InDispArea;
PROCEDURE (f: Tab) GetDispSize (OUT x, y, w, h: INTEGER);
VAR
rect: WinApi.RECT;
res: INTEGER;
BEGIN
IF ~Views.IsPrinterFrame(f) THEN
rect.left := 0; rect.top := 0; rect.right := f.i.w2; rect.bottom := f.i.h2;
res := WinApi.SendMessageA(f.i.ctrl, WinCtl.TCM_ADJUSTRECT, WinApi.FALSE, SYSTEM.ADR(rect));
f.dispLeft := rect.left * f.unit; f.dispTop := rect.top * f.unit;
f.dispWidth := (rect.right - rect.left) * f.unit; f.dispHeight := (rect.bottom - rect.top) * f.unit
END;
x := f.dispLeft; y := f.dispTop; w := f.dispWidth; h := f.dispHeight
END GetDispSize;
(* Directory *)
PROCEDURE (d: Directory) GetTabSize (VAR w, h: INTEGER);
BEGIN
IF w = Views.undefined THEN w := 150 * Ports.point END;
IF h = Views.undefined THEN h := 100 * Ports.point END
END GetTabSize;
PROCEDURE (d: Directory) New (): StdTabViews.Frame;
VAR f: Tab;
BEGIN
NEW(f); RETURN f
END New;
(* control window class *)
(* Used for common controls, not standard controls *)
PROCEDURE HandleNotifyMsg (wnd: WinApi.HANDLE; wParam, lParam: INTEGER);
VAR c: StdTabViews.Frame; pnmhdr: WinApi.PtrNMHDR;
BEGIN
c := SYSTEM.VAL(StdTabViews.Frame, WinApi.GetWindowLongA(wnd, dlgWindowExtra));
pnmhdr := SYSTEM.VAL(WinApi.PtrNMHDR, lParam);
WITH c: Tab DO
IF c.i.ctrl #0 THEN
IF pnmhdr.code = WinCtl.TCN_SELCHANGE THEN;
c.SetIndex(WinApi.SendMessageA(c.i.ctrl, WinCtl.TCM_GETCURSEL, 0, 0))
END
END
END
END HandleNotifyMsg;
PROCEDURE [2] CtrlHandler (wnd: WinApi.HANDLE; message, wParam, lParam: INTEGER): INTEGER;
BEGIN
IF message = WinApi.WM_NOTIFY THEN
Kernel.Try(HandleNotifyMsg, wnd, wParam, lParam);
RETURN 0
END;
RETURN WinApi.DefWindowProcA(wnd, message, wParam, lParam)
END CtrlHandler;
PROCEDURE Install;
VAR dir: Directory;
BEGIN
NEW(dir); StdTabViews.SetFrameDir(dir)
END Install;
PROCEDURE InitClass;
VAR class: WinApi.WNDCLASS; res: INTEGER;
BEGIN
class.hCursor := WinApi.NULL;
class.hIcon := WinApi.NULL;
class.lpszMenuName := NIL;
class.lpszClassName := "Oberon Tab";
class.hbrBackground := 0; (* no background *)
class.style := {};
class.hInstance := instance;
class.lpfnWndProc := CtrlHandler;
class.cbClsExtra := 0;
class.cbWndExtra := dlgWindowExtra + 4;
res := WinApi.RegisterClassA(class)
END InitClass;
PROCEDURE Init*;
BEGIN
StdTabViews.setFocus := TRUE;
instance := WinApi.GetModuleHandleA(NIL);
InitClass;
Install;
END Init;
END HostTabFrames.
| Host/Mod/TabFrames.odc |
MODULE HostTextConv; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20111211, Fyodor Tkachov, switched from National to i21sysCharacters
- 20080523, Борис Рюмшин, коррекция русификации
- 20060407, Ilya Ermakov, russification
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT
SYSTEM, KERNEL32, GDI32, USER32, COM, WinApi, WinOle,
Files, Fonts, Ports, Stores, Views, Dialog, Converters, Properties,
HostFonts, HostWindows, HostClipboard, TextModels,
TextRulers, TextViews, TextMappers, i21sysCharacters;
CONST
CR = 0DX; LF = 0AX; FF = 0EX; TAB = 09X;
halfpoint = Ports.point DIV 2;
twips = Ports.point DIV 20;
TYPE
Context = POINTER TO RECORD
next: Context;
dest: INTEGER;
attr: TextModels.Attributes
END;
MemReader = POINTER TO RECORD (Files.Reader)
adr, pos: INTEGER
END;
VAR
debug*: BOOLEAN;
(* MemReader *)
PROCEDURE (r: MemReader) Base (): Files.File;
BEGIN
RETURN NIL
END Base;
PROCEDURE (r: MemReader) Pos (): INTEGER;
BEGIN
RETURN r.pos
END Pos;
PROCEDURE (r: MemReader) SetPos (pos: INTEGER);
BEGIN
r.pos := pos
END SetPos;
PROCEDURE (r: MemReader) ReadByte (OUT x: BYTE);
BEGIN
SYSTEM.GET(r.adr + r.pos, x); INC(r.pos)
END ReadByte;
PROCEDURE (r: MemReader) ReadBytes (VAR x: ARRAY OF BYTE; beg, len: INTEGER);
BEGIN
HALT(126)
END ReadBytes;
PROCEDURE GenGlobalMedium (hg: WinApi.HGLOBAL; unk: COM.IUnknown; VAR sm: WinOle.STGMEDIUM);
BEGIN
sm.tymed := WinOle.TYMED_HGLOBAL;
sm.u.hGlobal := hg;
sm.pUnkForRelease := unk
END GenGlobalMedium;
PROCEDURE MediumGlobal (VAR sm: WinOle.STGMEDIUM): WinApi.HGLOBAL;
BEGIN
ASSERT(sm.tymed = WinOle.TYMED_HGLOBAL, 20);
RETURN sm.u.hGlobal
END MediumGlobal;
PROCEDURE WriteWndChar (wr: TextModels.Writer; ch: SHORTCHAR);
BEGIN
CASE ch OF
| CR, TAB, " "..7EX, 0A0X..0FFX: wr.WriteChar(ch)
| LF:
| 80X: wr.WriteChar(20ACX) (* euro *)
| 82X: wr.WriteChar(201AX)
| 83X: wr.WriteChar(0192X)
| 84X: wr.WriteChar(201EX)
| 85X: wr.WriteChar(2026X)
| 86X: wr.WriteChar(2020X)
| 87X: wr.WriteChar(2021X)
| 88X: wr.WriteChar(02C6X)
| 89X: wr.WriteChar(2030X)
| 8AX: wr.WriteChar(0160X)
| 8BX: wr.WriteChar(2039X)
| 8CX: wr.WriteChar(0152X)
| 91X: wr.WriteChar(2018X)
| 92X: wr.WriteChar(2019X)
| 93X: wr.WriteChar(201CX)
| 94X: wr.WriteChar(201DX)
| 95X: wr.WriteChar(2022X)
| 96X: wr.WriteChar(2013X)
| 97X: wr.WriteChar(2014X)
| 98X: wr.WriteChar(02DCX)
| 99X: wr.WriteChar(2122X)
| 9AX: wr.WriteChar(0161X)
| 9BX: wr.WriteChar(203AX)
| 9CX: wr.WriteChar(0153X)
| 9FX: wr.WriteChar(0178X)
| 0X..8X, 0BX, 0CX, 0EX..1FX, 7FX, 81X, 8DX..90X, 9DX, 9EX:
wr.WriteChar(CHR(0EF00H + ORD(ch)))
END
END WriteWndChar;
PROCEDURE ThisWndChar (ch: CHAR): SHORTCHAR;
BEGIN
ch := i21sysCharacters.ExtendedAsciiOf(ch);
IF ch >= 100X THEN
IF (ch >= 0EF00X) & (ch <= 0EFFFX) THEN ch := CHR(ORD(ch) - 0EF00H)
ELSIF ch = 20ACX THEN ch := 80X (* euro *)
ELSIF ch = 201AX THEN ch := 82X
ELSIF ch = 0192X THEN ch := 83X
ELSIF ch = 201EX THEN ch := 84X
ELSIF ch = 2026X THEN ch := 85X
ELSIF ch = 2020X THEN ch := 86X
ELSIF ch = 2021X THEN ch := 87X
ELSIF ch = 02C6X THEN ch := 88X
ELSIF ch = 2030X THEN ch := 89X
ELSIF ch = 0160X THEN ch := 8AX
ELSIF ch = 2039X THEN ch := 8BX
ELSIF ch = 0152X THEN ch := 8CX
ELSIF ch = 2018X THEN ch := 91X
ELSIF ch = 2019X THEN ch := 92X
ELSIF ch = 201CX THEN ch := 93X
ELSIF ch = 201DX THEN ch := 94X
ELSIF ch = 2022X THEN ch := 95X
ELSIF ch = 2013X THEN ch := 96X
ELSIF ch = 2014X THEN ch := 97X
ELSIF ch = 02DCX THEN ch := 98X
ELSIF ch = 2122X THEN ch := 99X
ELSIF ch = 0161X THEN ch := 9AX
ELSIF ch = 203AX THEN ch := 9BX
ELSIF ch = 0153X THEN ch := 9CX
ELSIF ch = 0178X THEN ch := 9FX
ELSE ch := "?"
END
ELSIF ch = 08FX THEN ch := " " (* digit space *)
END;
RETURN SHORT(ch)
END ThisWndChar;
PROCEDURE ParseRichText (rd: Files.Reader; wr: TextModels.Writer; VAR defRuler: TextRulers.Ruler);
TYPE
FontInfo = POINTER TO RECORD id: INTEGER; f: Fonts.Typeface; next: FontInfo END;
ColorInfo = POINTER TO RECORD id: INTEGER; c: Ports.Color; next: ColorInfo END;
CONST text = 0; fonttab = 1; colortab = 2; skip = 3;
VAR ch: SHORTCHAR; fact, val, defFont, dest, idx, fnum, cnum, bpos, spos, paraPos, i: INTEGER;
fonts, font: FontInfo; colors: ColorInfo; hasNum, remPar: BOOLEAN;
f: Fonts.Font; comm: ARRAY 32 OF SHORTCHAR; c, con: Context; ruler: TextRulers.Ruler;
p0: Properties.Property; p: TextRulers.Prop; attr: TextRulers.Attributes; tabStyle: SET;
PROCEDURE Color(i: INTEGER): ColorInfo;
VAR c: ColorInfo;
BEGIN
ASSERT(colors # NIL, 20);
c := colors;
WHILE (c # NIL) & (c.id # i) DO c := c.next END;
ASSERT(c # NIL, 100);
RETURN c
END Color;
PROCEDURE SetColor(i: INTEGER; c: Ports.Color);
VAR ci: ColorInfo;
BEGIN
NEW(ci); ci.id := i; ci.c := c; ci.next := colors; colors := ci
END SetColor;
PROCEDURE Font(i: INTEGER): FontInfo;
VAR f: FontInfo;
BEGIN
ASSERT(fonts # NIL, 20);
f := fonts;
WHILE (f # NIL) & (f.id # i) DO f := f.next END;
ASSERT(f # NIL, 100);
RETURN f
END Font;
PROCEDURE SetFont(i: INTEGER; tf: Fonts.Typeface);
VAR f: FontInfo;
BEGIN
NEW(f); f.id := i; f.f := tf; f.next := fonts; fonts := f
END SetFont;
PROCEDURE Next (VAR ch: SHORTCHAR);
VAR b: BYTE;
BEGIN
rd.ReadByte(b); ch := SHORT(CHR(b MOD 256))
END Next;
PROCEDURE Write (ch: SHORTCHAR);
BEGIN
IF dest = text THEN WriteWndChar(wr, ch)
ELSIF dest = fonttab THEN
ASSERT(font # NIL, 20);
font.f[idx] := ch; INC(idx); font.f[idx] := 0X
END
END Write;
PROCEDURE NewPara;
BEGIN
IF dest = text THEN
wr.WriteChar(CR); paraPos := wr.Pos(); remPar := FALSE;
IF (ruler.style.attr.first # ruler.style.attr.left) OR (ruler.style.attr.lead > 0)
OR (TextRulers.pageBreak IN ruler.style.attr.opts) THEN wr.WriteChar(FF); remPar := TRUE
END
END
END NewPara;
PROCEDURE CheckPara;
VAR t: TextModels.Model; v: Views.View;
BEGIN
IF paraPos >= 0 THEN
t := wr.Base();
IF remPar THEN t.Delete(paraPos, paraPos + 1) END;
wr.SetPos(paraPos);
v := Views.CopyOf(ruler, Views.deep); ruler := v(TextRulers.Ruler);
wr.WriteView(ruler, Views.undefined, Views.undefined);
wr.SetPos(t.Length());
paraPos := -1
END
END CheckPara;
BEGIN
defFont := 0; fnum := 1; f := Fonts.dir.Default(); NEW(fonts); fonts.f := f.typeface;
cnum := 1; NEW(colors); SetColor(0, Ports.defaultColor);
dest := text; con := NIL; paraPos := 0; remPar := FALSE;
defRuler := TextRulers.dir.New(NIL); ruler := defRuler; tabStyle := {};
Next(ch);
WHILE ch # 0X DO
IF ch = "{" THEN
NEW(c); c.dest := dest; c.attr := wr.attr; c.next := con; con := c;
bpos := rd.Pos(); Next(ch)
ELSIF ch = "}" THEN
IF con # NIL THEN
dest := con.dest; wr.SetAttr(con.attr); con := con.next
END;
Next(ch)
ELSIF ch = "\" THEN
spos := rd.Pos() - 1; Next(ch); i := 0; val := 0;
IF (ch >= "a") & (ch <= "z") THEN
WHILE (ch >= "a") & (ch <= "z") DO comm[i] := ch; INC(i); Next(ch) END;
comm[i] := 0X; fact := 1; hasNum := FALSE;
IF ch = "-" THEN fact := -1; Next(ch) END;
WHILE (ch >= "0") & (ch <= "9") DO
val := 10 * val + ORD(ch) - ORD("0"); Next(ch); hasNum := TRUE
END;
val := val * fact;
IF ch = " " THEN Next(ch) END;
(* special characters *)
IF comm = "tab" THEN wr.WriteChar(TAB)
ELSIF comm = "line" THEN wr.WriteChar(CR)
ELSIF comm = "par" THEN NewPara
(*
ELSIF comm = "enspace" THEN wr.WriteChar(08FX) (* digit space *)
*)
ELSIF comm = "ldblquote" THEN wr.WriteChar(201CX) (* unicode: left double quote *)
ELSIF comm = "rdblquote" THEN wr.WriteChar(201DX) (* unicode: right double quote *)
ELSIF comm = "lquote" THEN wr.WriteChar(2018X) (* unicode: left single quote *)
ELSIF comm = "rquote" THEN wr.WriteChar(2019X) (* unicode: right single quote *)
ELSIF comm = "page" THEN
NewPara; CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {TextRulers.pageBreak}; p.opts.mask := p.opts.val;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
(* character attributes *)
ELSIF comm = "plain" THEN
wr.SetAttr(TextModels.NewWeight(wr.attr, Fonts.normal));
wr.SetAttr(TextModels.NewStyle(wr.attr, {}));
wr.SetAttr(TextModels.NewTypeface(wr.attr, Font(defFont).f));
wr.SetAttr(TextModels.NewSize(wr.attr, 24 * halfpoint));
wr.SetAttr(TextModels.NewColor(wr.attr, Ports.defaultColor));
wr.SetAttr(TextModels.NewOffset(wr.attr, 0))
ELSIF comm = "b" THEN
IF hasNum & (val = 0) THEN wr.SetAttr(TextModels.NewWeight(wr.attr, Fonts.normal))
ELSE wr.SetAttr(TextModels.NewWeight(wr.attr, Fonts.bold))
END
ELSIF comm = "i" THEN
IF hasNum & (val = 0) THEN
wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style - {Fonts.italic}))
ELSE wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style + {Fonts.italic}))
END
ELSIF comm = "ul" THEN
IF hasNum & (val = 0) THEN
wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style - {Fonts.underline}))
ELSE wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style + {Fonts.underline}))
END
ELSIF comm = "strike" THEN
IF hasNum & (val = 0) THEN
wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style - {Fonts.strikeout}))
ELSE wr.SetAttr(TextModels.NewStyle(wr.attr, wr.attr.font.style + {Fonts.strikeout}))
END
ELSIF comm = "f" THEN
IF ~hasNum THEN val := defFont END;
IF dest = fonttab THEN
fnum := val; idx := 0; NEW(font); font.id := val; font.next := fonts; fonts := font
ELSE
wr.SetAttr(TextModels.NewTypeface(wr.attr, Font(val).f))
END
ELSIF comm = "fs" THEN
IF ~hasNum THEN val := 24 END;
wr.SetAttr(TextModels.NewSize(wr.attr, val * halfpoint))
ELSIF comm = "cf" THEN
wr.SetAttr(TextModels.NewColor(wr.attr, Color(val).c))
ELSIF comm = "dn" THEN
IF ~hasNum THEN val := 6 END;
wr.SetAttr(TextModels.NewOffset(wr.attr, -(val * halfpoint)))
ELSIF comm = "up" THEN
IF ~hasNum THEN val := 6 END;
wr.SetAttr(TextModels.NewOffset(wr.attr, val * halfpoint))
(* paragraph attributes *)
ELSIF comm = "pard" THEN
IF (ruler.style.attr.first # 0) OR (ruler.style.attr.left # 0)
OR (ruler.style.attr.opts # {TextRulers.leftAdjust})
OR (ruler.style.attr.tabs.len # 0) THEN
CheckPara; NEW(p);
p.valid := {TextRulers.first, TextRulers.left, TextRulers.opts, TextRulers.tabs};
p.opts.mask := {TextRulers.leftAdjust, TextRulers.rightAdjust, TextRulers.pageBreak};
p.first := 0; p.left := 0; p.opts.val := {TextRulers.leftAdjust}; p.tabs.len := 0;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
END
ELSIF comm = "fi" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.first}; p.first := ruler.style.attr.left + val * twips;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "li" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.left, TextRulers.first};
p.left := val * twips; p.first := p.left + ruler.style.attr.first - ruler.style.attr.left;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "ql" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {TextRulers.leftAdjust};
p.opts.mask := {TextRulers.leftAdjust, TextRulers.rightAdjust};
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "qr" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {TextRulers.rightAdjust};
p.opts.mask := {TextRulers.leftAdjust, TextRulers.rightAdjust};
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "qc" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {};
p.opts.mask := {TextRulers.leftAdjust, TextRulers.rightAdjust};
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "qj" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {TextRulers.leftAdjust, TextRulers.rightAdjust};
p.opts.mask := {TextRulers.leftAdjust, TextRulers.rightAdjust};
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "sb" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.lead}; p.lead := val * twips;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "sl" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.grid}; p.grid := val * twips;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "tqc" THEN
tabStyle := {TextRulers.centerTab}
ELSIF (comm = "tqr") OR (comm="tqdec") THEN
tabStyle := {TextRulers.rightTab}
ELSIF comm = "tb" THEN
CheckPara; p0 := ruler.style.attr.Prop(); p := p0(TextRulers.Prop);
p.valid := {TextRulers.tabs};
p.tabs.tab[p.tabs.len].stop := val * twips;
p.tabs.tab[p.tabs.len].type := {TextRulers.barTab}; tabStyle := {};
INC(p.tabs.len);
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "tx" THEN
CheckPara; p0 := ruler.style.attr.Prop(); p := p0(TextRulers.Prop);
p.valid := {TextRulers.tabs};
p.tabs.tab[p.tabs.len].stop := val * twips;
p.tabs.tab[p.tabs.len].type := tabStyle; tabStyle := {};
INC(p.tabs.len);
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
ELSIF comm = "pagebb" THEN
CheckPara; NEW(p);
p.valid := {TextRulers.opts}; p.opts.val := {TextRulers.pageBreak}; p.opts.mask := p.opts.val;
attr := TextRulers.ModifiedAttr(ruler.style.attr, p); ruler.style.SetAttr(attr)
(* header *)
ELSIF comm = "deff" THEN
IF hasNum THEN defFont := val END
ELSIF comm = "fonttbl" THEN
IF dest # skip THEN dest := fonttab END
ELSIF comm = "colortbl" THEN
IF dest # skip THEN dest := colortab; cnum := 0; SetColor(0, 0) END
ELSIF comm = "red" THEN
IF dest = colortab THEN SetColor(cnum, Color(cnum).c + val MOD 256) END
ELSIF comm = "green" THEN
IF dest = colortab THEN SetColor(cnum, Color(cnum).c + val MOD 256 * 256) END
ELSIF comm = "blue" THEN
IF dest = colortab THEN SetColor(cnum, Color(cnum).c + val MOD 256 * 65536) END
ELSIF comm = "rtf" THEN
ELSIF comm = "ansi" THEN
ELSIF comm = "lang" THEN
(* misc *)
ELSIF comm = "bin" THEN rd.SetPos(rd.Pos() + val - 1); Next(ch)
ELSE (* unknown *)
IF (spos = bpos) & (con # NIL) & (con.next # NIL) THEN dest := skip END
END
ELSIF ch = "'" THEN
Next(ch);
IF ch <= "9" THEN val := ORD(ch) - ORD("0") ELSE val := ORD(CAP(ch)) - ORD("A") + 10 END;
Next(ch);
IF ch <= "9" THEN val := 16 * val + ORD(ch) - ORD("0")
ELSE val := 16 * val + ORD(CAP(ch)) - ORD("A") + 10
END;
Write(SHORT(CHR(val))); Next(ch)
ELSE
IF ch = "~" THEN wr.WriteChar(0A0X) (* non breaking space *)
ELSIF ch = "-" THEN wr.WriteChar(0ADX) (* soft hyphen *)
ELSIF ch = "_" THEN wr.WriteChar(2011X) (* non breaking hyphen *)
ELSIF ch = "*" THEN bpos := rd.Pos()
ELSIF (ch = LF) OR (ch = CR) THEN NewPara
ELSIF (ch = "{") OR (ch = "}") OR (ch = "\") THEN Write(ch)
END;
Next(ch)
END
ELSIF ch = ";" THEN
IF dest = fonttab THEN font := Font(fnum); font.f[idx] := 0X; INC(idx)
ELSIF dest = colortab THEN INC(cnum); SetColor(cnum, 0)
ELSIF dest = text THEN Write(";")
END;
Next(ch)
ELSIF ch >= " " THEN
Write(ch); Next(ch)
ELSE
Next(ch)
END
END
END ParseRichText;
PROCEDURE ConvertToRichText (in: TextViews.View; beg, end: INTEGER; VAR out: TextModels.Model);
VAR r: TextModels.Reader; w: TextMappers.Formatter; ch: CHAR; f: Fonts.Font;
attr, attr0: TextModels.Attributes; col: Ports.Color; tf, atf: Fonts.Typeface; p, size, asize, offs: INTEGER;
style, astyle: SET; weight, aweight: INTEGER; rattr, rattr0: TextRulers.Attributes; ruler: TextRulers.Ruler;
text: TextModels.Model; firstLine, firstLine0: BOOLEAN; fonts: ARRAY 256 OF Fonts.Typeface;
colors: ARRAY 256 OF Ports.Color; fnum, cnum, i: INTEGER;
BEGIN
out := TextModels.dir.New(); w.ConnectTo(out);
f := Fonts.dir.Default(); tf := f.typeface;
fnum := 1; fonts[0] := tf;
cnum := 1; colors[0] := Ports.defaultColor;
col := Ports.defaultColor; size := 12 * Ports.point;
offs := 0; style := {}; weight := Fonts.normal;
attr0 := NIL; rattr0 := NIL; firstLine := TRUE; firstLine0 := FALSE;
text := in.ThisModel(); r := text.NewReader(NIL);
ruler := TextViews.ThisRuler(in, beg); rattr := ruler.style.attr;
r.SetPos(beg); r.ReadChar(ch);
WHILE ~r.eot & (r.Pos() <= end) DO
attr := r.attr;
IF (r.view # NIL) & (r.view IS TextRulers.Ruler) THEN
ruler := r.view(TextRulers.Ruler); rattr := ruler.style.attr;
firstLine := TRUE
ELSIF ch = FF THEN firstLine := TRUE
END;
IF (rattr # rattr0) OR (firstLine # firstLine0) THEN
IF (rattr # rattr0) OR (rattr.first # rattr.left) OR (rattr.lead # 0) OR (TextRulers.pageBreak IN rattr.opts)
THEN
w.WriteSString("\pard");
IF rattr.left # 0 THEN
w.WriteSString("\li"); w.WriteInt(rattr.left DIV twips)
END;
IF firstLine & (rattr.first # rattr.left) THEN
w.WriteSString("\fi"); w.WriteInt((rattr.first - rattr.left) DIV twips)
END;
IF firstLine & (rattr.lead # 0) THEN
w.WriteSString("\sb"); w.WriteInt(rattr.lead DIV twips)
END;
IF rattr.grid > Ports.point THEN
w.WriteSString("\sl"); w.WriteInt(rattr.grid DIV twips); w.WriteSString("\slmult1")
END;
IF {TextRulers.leftAdjust, TextRulers.rightAdjust} - rattr.opts = {} THEN w.WriteSString("\qj")
ELSIF TextRulers.rightAdjust IN rattr.opts THEN w.WriteSString("\qr")
ELSIF ~(TextRulers.leftAdjust IN rattr.opts) THEN w.WriteSString("\qc")
END;
IF firstLine & (TextRulers.pageBreak IN rattr.opts) THEN
w.WriteSString("\pagebb")
END;
i := 0;
WHILE i < rattr.tabs.len DO
IF TextRulers.centerTab IN rattr.tabs.tab[i].type THEN w.WriteSString("\tqc") END;
IF TextRulers.rightTab IN rattr.tabs.tab[i].type THEN w.WriteSString("\tqr") END;
IF TextRulers.barTab IN rattr.tabs.tab[i].type THEN w.WriteSString("\tb") END;
w.WriteSString("\tx"); w.WriteInt(rattr.tabs.tab[i].stop DIV twips);
INC(i)
END;
w.WriteChar(" ")
END;
rattr0 := rattr; firstLine0 := firstLine
END;
IF attr # attr0 THEN
p := w.Pos();
IF attr.color # col THEN
i := 0; WHILE (i < cnum) & (colors[i] # attr.color) DO INC(i) END;
IF i = cnum THEN colors[i] := attr.color; INC(cnum) END;
w.WriteSString("\cf"); w.WriteInt(i);
col := attr.color
END;
atf := attr.font.typeface$; asize := attr.font.size; astyle := attr.font.style; aweight := attr.font.weight;
IF atf # tf THEN
i := 0; WHILE (i < fnum) & (fonts[i] # atf) DO INC(i) END;
IF i = fnum THEN fonts[i] := atf; INC(fnum) END;
w.WriteSString("\f"); w.WriteInt(i);
tf := atf
END;
IF asize # size THEN
w.WriteSString("\fs"); w.WriteInt(asize DIV halfpoint);
size := asize
END;
IF astyle # style THEN
IF (Fonts.italic IN astyle) & ~(Fonts.italic IN style) THEN w.WriteSString("\i")
ELSIF ~(Fonts.italic IN astyle) & (Fonts.italic IN style) THEN w.WriteSString("\i0")
END;
IF (Fonts.underline IN astyle) & ~(Fonts.underline IN style) THEN w.WriteSString("\ul")
ELSIF ~(Fonts.underline IN astyle) & (Fonts.underline IN style) THEN w.WriteSString("\ul0")
END;
IF (Fonts.strikeout IN astyle) & ~(Fonts.strikeout IN style) THEN w.WriteSString("\strike")
ELSIF ~(Fonts.strikeout IN astyle) & (Fonts.strikeout IN style) THEN w.WriteSString("\strike0")
END;
style := astyle
END;
IF aweight # weight THEN
IF (aweight > Fonts.normal) & (weight = Fonts.normal) THEN w.WriteSString("\b")
ELSIF (aweight = Fonts.normal) & (weight > Fonts.normal) THEN w.WriteSString("\b0")
END;
weight := aweight
END;
IF attr.offset # offs THEN
IF attr.offset > 0 THEN w.WriteSString("\up"); w.WriteInt(attr.offset DIV halfpoint)
ELSIF attr.offset < 0 THEN w.WriteSString("\dn"); w.WriteInt(-(attr.offset DIV halfpoint))
ELSIF offs > 0 THEN w.WriteSString("\up0")
ELSE w.WriteSString("\dn0")
END;
offs := attr.offset
END;
IF w.Pos() # p THEN w.WriteChar(" ") END;
attr0 := attr
END;
IF ch >= 100X THEN
IF r.char = 2007X THEN w.WriteSString("\enspace ")
ELSIF r.char = 2010X THEN w.WriteChar("-")
ELSIF r.char = 2011X THEN w.WriteSString("\_")
ELSIF r.char = 201CX THEN (* unicode: left double quote *) w.WriteSString("\ldblquote ")
ELSIF r.char = 201DX THEN (* unicode: right double quote *) w.WriteSString("\rdblquote ")
ELSIF r.char = 2018X THEN (* unicode: left single quote *) w.WriteSString("\lquote ")
ELSIF r.char = 2019X THEN (* unicode: right single quote *) w.WriteSString("\rquote ")
ELSE w.WriteSString("\'");
w.WriteIntForm(ORD(ThisWndChar(r.char)) MOD 256, TextMappers.hexadecimal, 2, "0", FALSE)
END
ELSE
CASE ch OF
| TAB: w.WriteSString("\tab ")
| CR: w.WriteSString("\par "); w.WriteLn; firstLine := FALSE
| " ".."[", "]".."z", "|", "~": w.WriteChar(ch)
| "\": w.WriteSString("\\")
| "{": w.WriteSString("\{")
| "}": w.WriteSString("\}")
| 8FX: (* digit space *) w.WriteChar(" ")
| 90X: (* hyphen *) w.WriteChar("-")
| 91X: (* non-breaking hyphen *) w.WriteSString("\_")
| 0A0X: (* non-breaking space *) w.WriteSString("\~")
| 0ADX: (* soft hyphen *) w.WriteSString("\-")
| 0A1X..0ACX, 0AEX..0FFX:
w.WriteSString("\'"); w.WriteIntForm(ORD(ch), TextMappers.hexadecimal, 2, "0", FALSE)
ELSE
END
END;
r.ReadChar(ch);
END;
w.WriteChar("}");
(* header *)
w.SetPos(0);
w.WriteSString("{\rtf1\ansi\deff0");
w.WriteSString("{\fonttbl"); i := 0;
WHILE i < fnum DO
IF fonts[i] = Fonts.default THEN fonts[i] := HostFonts.defFont.alias$ END;
w.WriteSString("{\f"); w.WriteInt(i); w.WriteSString("\fnil "); w.WriteString(fonts[i]); w.WriteSString(";}");
INC(i)
END;
w.WriteChar("}"); w.WriteLn;
w.WriteSString("{\colortbl;"); i := 1;
WHILE i < cnum DO
w.WriteSString("\red"); w.WriteInt(colors[i] MOD 256);
w.WriteSString("\green"); w.WriteInt(colors[i] DIV 256 MOD 256);
w.WriteSString("\blue"); w.WriteInt(colors[i] DIV 65536 MOD 256);
w.WriteChar(";"); INC(i)
END;
w.WriteChar("}"); w.WriteLn;
w.WriteSString("\deftab216 ");
w.WriteSString("\plain")
END ConvertToRichText;
PROCEDURE ImportDText* (VAR med: WinOle.STGMEDIUM; OUT v: Views.View;
OUT w, h: INTEGER; OUT isSingle: BOOLEAN);
VAR t: TextModels.Model; res, adr: INTEGER; wr: TextModels.Writer; ch: SHORTCHAR;
hnd: KERNEL32.Handle; attr: TextModels.Attributes; p: Properties.StdProp; pref: Properties.BoundsPref;
BEGIN
hnd := MediumGlobal(med);
ASSERT(hnd # 0, 20);
adr := KERNEL32.GlobalLock(hnd);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
IF HostClipboard.cloneAttributes THEN
Properties.CollectStdProp(p);
NEW(attr); attr.InitFromProp(p);
wr.SetAttr(attr)
END;
SYSTEM.GET(adr, ch);
WHILE ch # 0X DO
WriteWndChar(wr, ch);
INC(adr); SYSTEM.GET(adr, ch)
END;
res := KERNEL32.GlobalUnlock(hnd);
v := TextViews.dir.New(t);
pref.w := Views.undefined; pref.h := Views.undefined;
Views.HandlePropMsg(v, pref);
w := pref.w; h := pref.h; isSingle := FALSE
END ImportDText;
PROCEDURE ImportDRichText* (VAR med: WinOle.STGMEDIUM; OUT v: Views.View;
OUT w, h: INTEGER; OUT isSingle: BOOLEAN);
VAR t: TextModels.Model; res, adr: INTEGER; wr: TextModels.Writer; rd: MemReader;
hnd: KERNEL32.Handle; ruler: TextRulers.Ruler; pref: Properties.BoundsPref;
BEGIN
IF debug THEN
ImportDText(med, v, w, h, isSingle);
RETURN;
END;
hnd := MediumGlobal(med);
ASSERT(hnd # 0, 20);
adr := KERNEL32.GlobalLock(hnd);
NEW(rd); rd.adr := adr; rd.pos := 0;
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
ParseRichText(rd, wr, ruler);
res := KERNEL32.GlobalUnlock(hnd);
v := TextViews.dir.New(t);
v(TextViews.View).SetDefaults(ruler, TextModels.dir.attr);
pref.w := Views.undefined; pref.h := Views.undefined;
Views.HandlePropMsg(v, pref);
w := pref.w; h := pref.h; isSingle := FALSE
END ImportDRichText;
PROCEDURE ImportDUnicode* (VAR med: WinOle.STGMEDIUM; OUT v: Views.View;
OUT w, h: INTEGER; OUT isSingle: BOOLEAN);
VAR t: TextModels.Model; res, adr, len: INTEGER; wr: TextModels.Writer; uc: CHAR;
hnd: KERNEL32.Handle; attr: TextModels.Attributes; p: Properties.StdProp; pref: Properties.BoundsPref;
BEGIN
hnd := MediumGlobal(med);
ASSERT(hnd # 0, 20);
adr := KERNEL32.GlobalLock(hnd);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
IF HostClipboard.cloneAttributes THEN
Properties.CollectStdProp(p);
NEW(attr); attr.InitFromProp(p);
wr.SetAttr(attr)
END;
SYSTEM.GET(adr, uc);
WHILE uc # 0X DO
ASSERT(uc # 0FFFEX, 100);
IF uc < 100X THEN WriteWndChar(wr, SHORT(uc))
ELSIF uc # 0FEFFX THEN wr.WriteChar(uc)
END;
INC(adr, 2); SYSTEM.GET(adr, uc)
END;
res := KERNEL32.GlobalUnlock(hnd);
v := TextViews.dir.New(t);
pref.w := Views.undefined; pref.h := Views.undefined;
Views.HandlePropMsg(v, pref);
w := pref.w; h := pref.h; isSingle := FALSE
END ImportDUnicode;
PROCEDURE ExportDText* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
VAR t: TextModels.Model; r: TextModels.Reader; ch: CHAR; wch: SHORTCHAR;
res, len, adr: INTEGER; hnd: KERNEL32.Handle;
BEGIN
ASSERT(v # NIL, 20);
WITH v: TextViews.View DO
t := v.ThisModel(); (* Alexander Iljin: fixed trap upon copying empty text view *)
hnd := KERNEL32.GlobalAlloc({1, 13}, 2 * t.Length() + 1); (* movable, sharable *)
IF hnd # 0 THEN
adr := KERNEL32.GlobalLock(hnd); len := 0;
r := t.NewReader(NIL); r.ReadChar(ch);
WHILE ~r.eot DO
IF (ch # TextModels.viewcode) & (ch # TextModels.para) THEN
wch := ThisWndChar(ch);
SYSTEM.PUT(adr, wch); INC(adr); INC(len);
IF wch = CR THEN SYSTEM.PUT(adr, LF); INC(adr); INC(len) END;
END;
r.ReadChar(ch)
END;
SYSTEM.PUT(adr, 0X); INC(len);
res := KERNEL32.GlobalUnlock(hnd);
hnd := KERNEL32.GlobalReAlloc(hnd, len, {});
GenGlobalMedium(hnd, NIL, med)
END
ELSE
END
END ExportDText;
PROCEDURE ExportDRichText* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
VAR t: TextModels.Model; r: TextModels.Reader; ch: CHAR; res, adr: INTEGER; hnd: KERNEL32.Handle;
BEGIN
ASSERT(v # NIL, 20);
WITH v: TextViews.View DO
ConvertToRichText(v, 0, MAX(INTEGER), t);
hnd := KERNEL32.GlobalAlloc({1, 13}, t.Length() + 1); (* movable, sharable *)
IF hnd # 0 THEN
adr := KERNEL32.GlobalLock(hnd);
r := t.NewReader(NIL); r.ReadChar(ch);
WHILE ~r.eot DO
SYSTEM.PUT(adr, ch); INC(adr);
r.ReadChar(ch)
END;
SYSTEM.PUT(adr, 0X);
res := KERNEL32.GlobalUnlock(hnd);
GenGlobalMedium(hnd, NIL, med)
END
ELSE
END
END ExportDRichText;
PROCEDURE ExportDUnicode* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
VAR t: TextModels.Model; r: TextModels.Reader; ch: CHAR; res, len, adr: INTEGER; hnd: KERNEL32.Handle;
BEGIN
ASSERT(v # NIL, 20);
WITH v: TextViews.View DO
t := v.ThisModel(); (* Alexander Iljin: fixed trap upon copying empty text view *)
hnd := KERNEL32.GlobalAlloc({1, 13}, 4 * t.Length() + 2); (* movable, sharable *)
IF hnd # 0 THEN
adr := KERNEL32.GlobalLock(hnd); len := 0;
r := t.NewReader(NIL); r.ReadChar(ch);
WHILE ~r.eot DO
ch := i21sysCharacters.UnicodeOf(ch);
IF ch = CR THEN
SYSTEM.PUT(adr, LONG(CR)); INC(adr, 2); INC(len, 2);
SYSTEM.PUT(adr, LONG(LF)); INC(adr, 2); INC(len, 2)
ELSIF (ch >= " ") OR (ch = TAB) THEN
IF (ch >= 0EF00X) & (ch <= 0EFFFX) THEN ch := CHR(ORD(ch) - 0EF00H) END;
SYSTEM.PUT(adr, ch); INC(adr, 2); INC(len, 2)
END;
r.ReadChar(ch)
END;
SYSTEM.PUT(adr, LONG(0X)); INC(len, 2);
res := KERNEL32.GlobalUnlock(hnd);
hnd := KERNEL32.GlobalReAlloc(hnd, len, {});
GenGlobalMedium(hnd, NIL, med)
END
ELSE
END
END ExportDUnicode;
PROCEDURE ImportText* (f: Files.File; OUT s: Stores.Store);
VAR r: Stores.Reader; t: TextModels.Model; wr: TextModels.Writer; ch, nch: SHORTCHAR;
BEGIN
ASSERT(f # NIL, 20);
r.ConnectTo(f); r.SetPos(0);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
r.ReadSChar(ch);
WHILE ~r.rider.eof DO
r.ReadSChar(nch);
IF (ch = CR) & (nch = LF) THEN r.ReadSChar(nch)
ELSIF ch = LF THEN ch := CR
END;
WriteWndChar(wr, ch); ch := nch
END;
s := TextViews.dir.New(t)
END ImportText;
PROCEDURE ImportTabText* (f: Files.File; OUT s: Stores.Store);
VAR r: Stores.Reader; t: TextModels.Model; wr: TextModels.Writer; ch, nch: SHORTCHAR;
BEGIN
ASSERT(f # NIL, 20);
r.ConnectTo(f); r.SetPos(0);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
r.ReadSChar(ch);
WHILE ~r.rider.eof DO
r.ReadSChar(nch);
IF (ch = CR) & (nch = LF) THEN r.ReadSChar(nch)
ELSIF ch = LF THEN ch := CR
ELSIF (ch = " ") & (nch = " ") THEN ch := TAB; r.ReadSChar(nch)
END;
WriteWndChar(wr, ch); ch := nch
END;
s := TextViews.dir.New(t)
END ImportTabText;
PROCEDURE ImportRichText* (f: Files.File; OUT s: Stores.Store);
VAR t: TextModels.Model; wr: TextModels.Writer; rd: Files.Reader; ruler: TextRulers.Ruler;
BEGIN
rd := f.NewReader(NIL); rd.SetPos(0);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
ParseRichText(rd, wr, ruler);
s := TextViews.dir.New(t);
s(TextViews.View).SetDefaults(ruler, TextModels.dir.attr)
END ImportRichText;
PROCEDURE ImportUnicode* (f: Files.File; OUT s: Stores.Store);
VAR r: Stores.Reader; t: TextModels.Model; v: TextViews.View; w: TextModels.Writer;
ch0, ch1: SHORTCHAR; len, res: INTEGER; uc: CHAR;
rev: BOOLEAN; fh, dc: GDI32.Handle; name: Fonts.Typeface;
BEGIN
ASSERT(f # NIL, 20);
r.ConnectTo(f); r.SetPos(0);
len := f.Length(); rev := FALSE;
t := TextModels.dir.New(); w := t.NewWriter(NIL); w.SetPos(0);
WHILE len > 0 DO
r.ReadSChar(ch0); r.ReadSChar(ch1);
IF rev THEN uc := CHR(ORD(ch1) + 256 * ORD(ch0))
ELSE uc := CHR(ORD(ch0) + 256 * ORD(ch1))
END;
DEC(len, 2);
IF uc = 0FFFEX THEN rev := ~rev
ELSIF uc < 100X THEN WriteWndChar(w, SHORT(uc))
ELSIF uc # 0FEFFX THEN w.WriteChar(uc)
END
END;
v := TextViews.dir.New(t);
s := v
END ImportUnicode;
PROCEDURE ImportDosText* (f: Files.File; OUT s: Stores.Store);
VAR r: Stores.Reader; t: TextModels.Model; wr: TextModels.Writer; ch, nch: SHORTCHAR;
PROCEDURE ConvertChar (wr: TextModels.Writer; ch: SHORTCHAR);
(* PC Code Page Mappings M4 (Latin) to Unicode Encoding *)
(* Reference: The Unicode Standard, Version 1.0, Vol 1, Addison Wesley, p. 536 *)
BEGIN
CASE ch OF
| CR, TAB, " "..7EX: wr.WriteChar(ch)
| LF:
| 80X..0AFX:
wr.WriteChar(i21sysCharacters.UnicodeOf(CHR(ORD(ch) + 64)))
| 0E0X..0EFX:
wr.WriteChar(i21sysCharacters.UnicodeOf(CHR(ORD(ch) + 16)))
| 00F0X:
wr.WriteChar(i21sysCharacters.UnicodeOf(0A8X))
| 00F1X:
wr.WriteChar(i21sysCharacters.UnicodeOf(0B8X))
(* | 080X: wr.WriteChar(0C7X)
| 081X: wr.WriteChar(0FCX)
| 082X: wr.WriteChar(0E9X)
| 083X: wr.WriteChar(0E2X)
| 084X: wr.WriteChar(0E4X)
| 085X: wr.WriteChar(0E0X)
| 086X: wr.WriteChar(0E5X)
| 087X: wr.WriteChar(0E7X)
| 088X: wr.WriteChar(0EAX)
| 089X: wr.WriteChar(0EBX)
| 08AX: wr.WriteChar(0E8X)
| 08BX: wr.WriteChar(0EFX)
| 08CX: wr.WriteChar(0EEX)
| 08DX: wr.WriteChar(0ECX)
| 08EX: wr.WriteChar(0C4X)
| 08FX: wr.WriteChar(0C5X)
| 090X: wr.WriteChar(0C9X)
| 091X: wr.WriteChar(0E6X)
| 092X: wr.WriteChar(0C6X)
| 093X: wr.WriteChar(0F4X)
| 094X: wr.WriteChar(0F6X)
| 095X: wr.WriteChar(0F2X)
| 096X: wr.WriteChar(0FBX)
| 097X: wr.WriteChar(0F9X)
| 098X: wr.WriteChar(0FFX)
| 099X: wr.WriteChar(0D6X)
| 09AX: wr.WriteChar(0DCX)
| 09BX: wr.WriteChar(0F8X)
| 09CX: wr.WriteChar(0A3X)
| 09DX: wr.WriteChar(0D8X)
| 09EX: wr.WriteChar(0D7X)
| 09FX: wr.WriteChar(0192X)
| 0A0X: wr.WriteChar(0E1X)
| 0A1X: wr.WriteChar(0EDX)
| 0A2X: wr.WriteChar(0F3X)
| 0A3X: wr.WriteChar(0FAX)
| 0A4X: wr.WriteChar(0F1X)
| 0A5X: wr.WriteChar(0D1X)
| 0A6X: wr.WriteChar(0AAX)
| 0A7X: wr.WriteChar(0BAX)
| 0A8X: wr.WriteChar(0BFX)
| 0A9X: wr.WriteChar(0AEX)
| 0AAX: wr.WriteChar(0ACX)
| 0ABX: wr.WriteChar(0BDX)
| 0ACX: wr.WriteChar(0BCX)
| 0ADX: wr.WriteChar(0A1X)
| 0AEX: wr.WriteChar(0ABX)
| 0AFX: wr.WriteChar(0BBX) *)
| 0B5X: wr.WriteChar(0C1X)
| 0B6X: wr.WriteChar(0C2X)
| 0B7X: wr.WriteChar(0C0X)
| 0B8X: wr.WriteChar(0A9X)
| 0BDX: wr.WriteChar(0A2X)
| 0BEX: wr.WriteChar(0A5X)
| 0C6X: wr.WriteChar(0E3X)
| 0C7X: wr.WriteChar(0C3X)
| 0CFX: wr.WriteChar(0A4X)
| 0D0X: wr.WriteChar(0F0X)
| 0D1X: wr.WriteChar(0D0X)
| 0D2X: wr.WriteChar(0CAX)
| 0D3X: wr.WriteChar(0CBX)
| 0D4X: wr.WriteChar(0C8X)
| 0D5X: wr.WriteChar(0131X)
| 0D6X: wr.WriteChar(0CDX)
| 0D7X: wr.WriteChar(0CEX)
| 0D8X: wr.WriteChar(0CFX)
| 0DDX: wr.WriteChar(0A6X)
| 0DEX: wr.WriteChar(0CCX)
(* | 0E0X: wr.WriteChar(0D3X)
| 0E1X: wr.WriteChar(0DFX)
| 0E2X: wr.WriteChar(0D4X)
| 0E3X: wr.WriteChar(0D2X)
| 0E4X: wr.WriteChar(0F5X)
| 0E5X: wr.WriteChar(0D5X)
| 0E6X: wr.WriteChar(0B5X)
| 0E7X: wr.WriteChar(0FEX)
| 0E8X: wr.WriteChar(0DEX)
| 0E9X: wr.WriteChar(0DAX)
| 0EAX: wr.WriteChar(0DBX)
| 0EBX: wr.WriteChar(0D9X)
| 0ECX: wr.WriteChar(0FDX)
| 0EDX: wr.WriteChar(0DDX)
| 0EEX: wr.WriteChar(0AFX)
| 0EFX: wr.WriteChar(0B4X)
| 0F0X: wr.WriteChar(0ADX)
| 0F1X: wr.WriteChar(0B1X) *)
| 0F2X: wr.WriteChar(02017X)
| 0F3X: wr.WriteChar(0BEX)
| 0F4X: wr.WriteChar(0B6X)
| 0F5X: wr.WriteChar(0A7X)
| 0F6X: wr.WriteChar(0F7X)
| 0F7X: wr.WriteChar(0B8X)
| 0F8X: wr.WriteChar(0B0X)
| 0F9X: wr.WriteChar(0A8X)
| 0FAX: wr.WriteChar(0B7X)
| 0FBX: wr.WriteChar(0B9X)
| 0FCX: wr.WriteChar(0B3X)
| 0FDX: wr.WriteChar(0B2X)
| 0X..8X, 0BX, 0CX, 0EX..1FX, 7FX,
0B0X..0B4X, 0B9X..0BCX, 0BFX..0C5X, 0C8X..0CEX, 0D9X..0DCX, 0DFX, 0FEX, 0FFX:
wr.WriteChar(CHR(0EF00H + ORD(ch)))
END
END ConvertChar;
BEGIN
ASSERT(f # NIL, 20);
r.ConnectTo(f); r.SetPos(0);
t := TextModels.dir.New(); wr := t.NewWriter(NIL);
r.ReadSChar(ch);
WHILE ~r.rider.eof DO
r.ReadSChar(nch);
IF (ch = CR) & (nch = LF) THEN r.ReadSChar(nch)
ELSIF ch = LF THEN ch := CR
END;
ConvertChar(wr, ch); ch := nch
END;
s := TextViews.dir.New(t)
END ImportDosText;
PROCEDURE TextView(s: Stores.Store): Stores.Store;
BEGIN
IF s IS Views.View THEN RETURN Properties.ThisType(s(Views.View), "TextViews.View")
ELSE RETURN NIL
END
END TextView;
PROCEDURE ExportText* (s: Stores.Store; f: Files.File);
VAR w: Stores.Writer; t: TextModels.Model; r: TextModels.Reader; ch: CHAR; wch: SHORTCHAR;
BEGIN
ASSERT(s # NIL, 20); ASSERT(f # NIL, 21);
(* IF s IS TextViews.View THEN *)
s := TextView(s);
IF s # NIL THEN
w.ConnectTo(f); w.SetPos(0);
t := s(TextViews.View).ThisModel();
IF t # NIL THEN
r := t.NewReader(NIL);
r.ReadChar(ch);
WHILE ~r.eot DO
IF (ch # TextModels.viewcode) & (ch # TextModels.para) THEN
wch := ThisWndChar(ch);
w.WriteSChar(wch);
IF wch = CR THEN w.WriteSChar(LF) END
END;
r.ReadChar(ch)
END
END
END
END ExportText;
PROCEDURE ExportTabText* (s: Stores.Store; f: Files.File);
VAR w: Stores.Writer; t: TextModels.Model; r: TextModels.Reader; ch: CHAR; wch: SHORTCHAR;
BEGIN
ASSERT(s # NIL, 20); ASSERT(f # NIL, 21);
s := TextView(s);
IF s # NIL THEN
w.ConnectTo(f); w.SetPos(0);
t := s(TextViews.View).ThisModel();
IF t # NIL THEN
r := t.NewReader(NIL);
r.ReadChar(ch);
WHILE ~r.eot DO
IF (ch # TextModels.viewcode) & (ch # TextModels.para) THEN
wch := ThisWndChar(ch);
IF wch = CR THEN w.WriteSChar(CR); w.WriteSChar(LF)
ELSIF wch = TAB THEN w.WriteSChar(" "); w.WriteSChar(" ")
ELSE w.WriteSChar(wch)
END
END;
r.ReadChar(ch)
END
END
END
END ExportTabText;
PROCEDURE ExportRichText* (s: Stores.Store; f: Files.File);
VAR t: TextModels.Model; r: TextModels.Reader; ch: CHAR; w: Stores.Writer;
BEGIN
ASSERT(s # NIL, 20); ASSERT(f # NIL, 21);
WITH s: TextViews.View DO
ConvertToRichText(s, 0, MAX(INTEGER), t);
w.ConnectTo(f); w.SetPos(0);
r := t.NewReader(NIL); r.ReadChar(ch);
WHILE ~r.eot DO
w.WriteSChar(SHORT(ch)); r.ReadChar(ch)
END;
(*
w.WriteSChar(0X)
*)
ELSE
END
END ExportRichText;
PROCEDURE ExportUnicode* (s: Stores.Store; f: Files.File);
VAR w: Stores.Writer; t: TextModels.Model; r: TextModels.Reader; ch: CHAR; tab2sp: INTEGER;
BEGIN
ASSERT(s # NIL, 20); ASSERT(f # NIL, 21);
s := TextView(s);
IF s # NIL THEN
w.ConnectTo(f); w.SetPos(0);
w.WriteChar(0FEFFX); (* little endian *)
t := s(TextViews.View).ThisModel();
IF t # NIL THEN
r := t.NewReader(NIL);
r.ReadChar(ch);
WHILE ~r.eot DO
ch := i21sysCharacters.UnicodeOf(ch);
IF ch = CR THEN
w.WriteChar(CR); w.WriteChar(LF)
ELSIF (ch >= " ") OR (ch = TAB) THEN
IF (ch >= 0EF00X) & (ch <= 0EFFFX) THEN ch := CHR(ORD(ch) - 0EF00H) END;
w.WriteChar(ch)
END;
r.ReadChar(ch)
END
END
END
END ExportUnicode;
PROCEDURE ImportHex* (f: Files.File; OUT s: Stores.Store);
VAR r: Stores.Reader; t: TextModels.Model; w: TextMappers.Formatter; ch: SHORTCHAR; a: INTEGER;
i: INTEGER; str: ARRAY 17 OF CHAR;
BEGIN
ASSERT(f # NIL, 20);
r.ConnectTo(f); r.SetPos(0);
t := TextModels.dir.New();
w.ConnectTo(t); w.SetPos(0);
r.ReadSChar(ch); a := 0;
WHILE ~r.rider.eof DO
IF a MOD 16 = 0 THEN
w.WriteChar("[");
w.WriteIntForm(a, TextMappers.hexadecimal, 8, "0", FALSE);
w.WriteSString("]ЏЏЏ")
END;
w.WriteIntForm(ORD(ch), TextMappers.hexadecimal, 2, "0", FALSE);
IF ch > 20X THEN str[a MOD 16] := ch ELSE str[a MOD 16] := "Џ" END;
INC(a);
IF a MOD 16 = 0 THEN
str[16] := 0X; w.WriteString("ЏЏЏЏ"); w.WriteString(str);
w.WriteLn
ELSIF a MOD 4 = 0 THEN
w.WriteString("ЏЏ")
ELSE
w.WriteChar("Џ")
END;
r.ReadSChar(ch)
END;
IF a MOD 16 # 0 THEN
str[a MOD 16] := 0X;
i := (16 - a MOD 16) * 3 + (3 - a MOD 16 DIV 4) + 3;
WHILE i # 0 DO w.WriteChar("Џ"); DEC(i) END;
w.WriteString(str)
END;
s := TextViews.dir.New(t)
END ImportHex;
END HostTextConv. | Host/Mod/TextConv.odc |
MODULE HostWindows; (* SP410 *)
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = "
- 20080302 Fyodor Tkachov, edited: I.E.'s addition for full-screen support
- 20061208, Ilya Ermakov, full-screen mode support
- 20060531, Alexander Iljin, Updated GetThisWindow to allow parameter p = NIL
- 20060608, Alexander Iljin, Updated WMPaint processing to RETURN 0
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Log,
SYSTEM, KERNEL32, GDI32, USER32, Services,
Kernel, Meta, Files, HostFiles, Ports, HostRegistry, HostPorts, Properties,
Views, Controllers, Containers, Dialog, Converters, Documents, Windows, WinApi,
HostMechanisms (* don't remove *);
CONST
inPlace* = 31; (* flag for in place windows *)
untitledKey = "#System:untitled";
allocKey = "#Host:AllocatedMemory";
totalKey = "#Host:Total";
byteKey = "#Host:Bytes";
iClose = 100; (* known in HostMenus *)
scrollRange = 16384;
borderW = 5 * Ports.point;
guardCheck = 4;
useSeparators = TRUE; noSeparators = FALSE; (* parameters to be used with AppendInt *)
minimized = MAX(INTEGER);
ENTER = 0DX; ESC = 1BX;
TAB = 09X; LTAB = 0AX; RDEL = 07X; LDEL = 08X;
PL = 10X; PR = 11X; PU = 12X; PD = 13X;
DL = 14X; DR = 15X; DU = 16X; DD = 17X;
AL = 1CX; AR = 1DX; AU = 1EX; AD = 1FX;
debug = FALSE;
TYPE
Hook* = POINTER TO ABSTRACT RECORD END;
Window* = POINTER TO EXTENSIBLE RECORD (Windows.Window)
hook*: Hook;
wnd-: USER32.Handle;
child-: BOOLEAN; (* if window is a child of the application window *)
dlg: BOOLEAN; (* if window has a 3d dialog border *)
fix: BOOLEAN; (* window is opened with fix coordinates *)
next: Window; (* window ring, to prevent garbage collection of windows *)
trapped: BOOLEAN; (* if window caused trap, it won't get idle messages anymore *)
setup: BOOLEAN;
dirty: BOOLEAN; (* dirty mark shown *)
used: BOOLEAN; (* window received at least on message *)
dw, dh: INTEGER; (* window size correction for tools *)
mw, mh: INTEGER; (* max window size *)
destroyed: BOOLEAN;
wheelPos: SHORTINT;
title: Views.Title
END;
Directory* = POINTER TO EXTENSIBLE RECORD (Windows.Directory)
unit*: INTEGER;
invisible*: BOOLEAN;
unmoveable*: BOOLEAN;
background*: BOOLEAN
END;
ScrollInfo* = RECORD [1]
size*: INTEGER;
mask*: SET;
min*, max*, page*, pos*: INTEGER;
trackPos*: INTEGER
END;
VAR
visualScroll*: BOOLEAN;
memInStatus*: BOOLEAN;
noAppWin*: BOOLEAN; (* If true only tool windows are shown *)
noClientScroll*: BOOLEAN; (* If true the client window of the application window doesn't display scroll bars*)
fullSize*: BOOLEAN; (* If true the client window of the application window doesn't display scroll bars*)
fullScreen*: BOOLEAN; (* Fullscreen mode support *)
dir-: Directory;
main-, client-, status-: USER32.Handle; (* main windows *)
unit-: INTEGER; (* resolution of main window *)
ctl3d-: USER32.Handle;
scW-, scH-: INTEGER; (* screen width and height *)
mainW-, mainH-: INTEGER; (* main window client area size *)
mainHook*: Hook;
tWindow, fWindow: Window; (* target and front focus windows *)
aWindow: Window; (* activated child window *)
newNumber: INTEGER; (* number for next untitled document *)
winAnchor: Window; (* list of all windows, from top to bottom, first is dumy header *)
bgWindow: Window; (* current background window, if any *)
whiteBrush, nullPen: GDI32.Handle;
docIcon, dirtyIcon: USER32.Handle;
instance: USER32.Handle; (* application instance *)
cbViewer: Window; (* pseudo window for clipboard drawing *)
cbValid: BOOLEAN; (* clipboard contents is valid *)
mainActive: BOOLEAN; (* main is active window *)
activating: BOOLEAN; (* used for mouse window activation *)
actMod: Kernel.Module;
FramePaint*: PROCEDURE(
wnd: USER32.Handle; msg, wPar, lPar: INTEGER): INTEGER;
GetScrollInfo*: PROCEDURE(
wnd: USER32.Handle; bar: INTEGER; VAR info: ScrollInfo): INTEGER;
SetScrollInfo*: PROCEDURE(
wnd: USER32.Handle; bar: INTEGER; VAR info: ScrollInfo; redraw: INTEGER): INTEGER;
font, info: USER32.Handle;
statusH, alloc, total: INTEGER;
allocStr, totalStr, byteStr: ARRAY 256 OF CHAR;
idleTraped: BOOLEAN;
showState: INTEGER; (* show command for main window *)
lBorder, tBorder, rBorder, bBorder: INTEGER; (* space for tools in main window *)
PROCEDURE ScrollModPressed (): BOOLEAN;
BEGIN
RETURN USER32.GetAsyncKeyState(11H) < 0
END ScrollModPressed;
(* auxiliary portable prcedures *)
PROCEDURE GetSection (w: Window; focus, vertical: BOOLEAN;
VAR size, sect, pos: INTEGER; VAR valid: BOOLEAN);
VAR msg: Controllers.PollSectionMsg;
BEGIN (* portable *)
msg.focus := focus; msg.vertical := vertical;
msg.wholeSize := 1; msg.partSize := 0; msg.partPos := 0;
msg.valid := FALSE; msg.done := FALSE;
w.ForwardCtrlMsg(msg);
IF msg.done THEN
size := msg.wholeSize; sect := msg.partSize; pos := msg.partPos;
IF size < 0 THEN size := 0 END;
IF sect < 0 THEN sect := 0 ELSIF sect > size THEN sect := size END;
IF pos > size - sect THEN pos := size - sect END;
IF pos < 0 THEN pos := 0 END
ELSE size := 1; sect := 0; pos := 0
END;
valid := msg.valid
END GetSection;
PROCEDURE SetOrigin (w: Window; focus, vertical: BOOLEAN; pos: INTEGER);
(* set origin of window's view *)
VAR msg: Controllers.ScrollMsg;
BEGIN (* portable *)
msg.focus := focus; msg.vertical := vertical;
msg.op := Controllers.gotoPos; msg.pos := pos;
msg.done := FALSE;
w.ForwardCtrlMsg(msg)
END SetOrigin;
PROCEDURE Scroll (w: Window; focus, vertical: BOOLEAN; dir: INTEGER);
(* scroll relative, by line or page increment or decrement *)
VAR msg: Controllers.ScrollMsg; c: Containers.Controller; v: Views.View;
BEGIN (* portable *)
c := w.doc.ThisController(); v := c.ThisFocus();
IF (v # NIL) & (v IS Containers.View) THEN
Containers.FadeMarks(v(Containers.View).ThisController(), FALSE)
END;
msg.focus := focus; msg.vertical := vertical;
msg.op := dir;
msg.done := FALSE;
w.ForwardCtrlMsg(msg)
END Scroll;
(** miscellaneous procedures **)
PROCEDURE ActualWnd* (): USER32.Handle;
BEGIN
(*
IF (fWindow # NIL) & ~fWindow.child & fWindow.used THEN RETURN fWindow.wnd
ELSE RETURN main
END
*)
IF (fWindow # NIL) & ~fWindow.child & fWindow.used THEN RETURN fWindow.wnd
ELSIF USER32.IsWindowVisible(main) # 0 THEN RETURN main
ELSE RETURN 0
END
END ActualWnd;
PROCEDURE ThisWindow (wnd: USER32.Handle): Window;
(* determine window by its WindowPtr *)
BEGIN
IF wnd = cbViewer.wnd THEN RETURN cbViewer
ELSE RETURN SYSTEM.VAL(Window, USER32.GetWindowLongA(wnd, 0))
END
END ThisWindow;
PROCEDURE AppendInt (VAR s: ARRAY OF CHAR; n: INTEGER; useSeparators: BOOLEAN);
VAR len: INTEGER; i, j: INTEGER; d: ARRAY 32 OF CHAR;
BEGIN
ASSERT(n >= 0, 20);
i := 0; REPEAT
d[i] := CHR(30H + n MOD 10); INC(i); n := n DIV 10;
IF useSeparators & (i MOD 4 = 3) & (n # 0) THEN d[i] := "'"; INC(i) END
UNTIL n = 0;
len := LEN(s) - 1;
j := 0; WHILE s[j] # 0X DO INC(j) END;
IF j + i < len THEN
REPEAT DEC(i); s[j] := d[i]; INC(j) UNTIL i = 0;
s[j] := 0X
END
END AppendInt;
PROCEDURE Append (VAR s: ARRAY OF CHAR; t: ARRAY OF CHAR);
VAR len: INTEGER; i, j: INTEGER; ch: CHAR;
BEGIN
len := LEN(s);
i := 0; WHILE s[i] # 0X DO INC(i) END;
j := 0; REPEAT ch := t[j]; s[i] := ch; INC(j); INC(i) UNTIL (ch = 0X) OR (i = len);
s[len - 1] := 0X
END Append;
PROCEDURE StripTitle (VAR s: Views.Title);
VAR i: INTEGER;
BEGIN
IF s[0] = "<" THEN
i := 1; WHILE (s[i] # ">") & (s[i] # 0X) DO s[i - 1] := s[i]; INC(i) END;
DEC(i); s[i] := 0X
END
END StripTitle;
PROCEDURE GenTitle (w: Window; name: ARRAY OF CHAR; VAR title: ARRAY OF CHAR);
(* generate window title for a document *)
VAR newName: ARRAY 64 OF CHAR; i: INTEGER;
BEGIN
IF w.sub THEN title[0] := "<"; title[1] := 0X ELSE title[0] := 0X END;
IF name # "" THEN
i := 0;
WHILE name[i] # 0X DO INC(i) END;
IF (i > 4) & (name[i-4] = ".") & (CAP(name[i-3]) = "O") & (CAP(name[i-2]) = "D") & (CAP(name[i-1]) = "C")
THEN
name[i-4] := 0X
END;
Append(title, name)
ELSE
Dialog.MapString(untitledKey, newName);
Append(title, newName); AppendInt(title, newNumber, noSeparators);
INC(newNumber)
END;
IF w.sub THEN Append(title, ">") END
END GenTitle;
PROCEDURE GenPathTitle (w: Window; OUT title: ARRAY OF CHAR);
VAR loc: Files.Locator; ch: CHAR; s1, s2: HostFiles.FullName; i, j: INTEGER;
BEGIN
loc := w.loc; title := "";
WITH loc: HostFiles.Locator DO
i := 0; ch := loc.path[0]; j := 0; s2 := "";
WHILE ch # 0X DO
IF (ch = "\") OR (ch = "/") THEN
s1[j] := 0X; s2 := s1$; j := 0
ELSE
s1[j] := ch; INC(j)
END;
INC(i); ch := loc.path[i]
END;
s1[j] := 0X;
IF ((CAP(s1[0]) = "M") & (CAP(s1[1]) = "O") & (CAP(s1[2]) = "D") & (s1[3] = 0X) OR
(CAP(s1[0]) = "D") & (CAP(s1[1]) = "O") & (CAP(s1[2]) = "C") & (CAP(s1[3]) = "U") & (s1[4] = 0X) OR
(CAP(s1[0]) = "R") & (CAP(s1[1]) = "S") & (CAP(s1[2]) = "R") & (CAP(s1[3]) = "C") & (s1[4] = 0X))
& (s2 # "") THEN
title := "("; Append(title, s2); Append(title, ")")
END
ELSE
END;
Append(title, w.name)
END GenPathTitle;
PROCEDURE ThisStyle (base, flags: SET): SET;
BEGIN
IF ~(Windows.noHScroll IN flags) THEN INCL(base, 20) END; (* hor scrollbar *)
IF ~(Windows.noVScroll IN flags) THEN INCL(base, 21) END; (* ver scrollbar *)
IF ~(Windows.noResize IN flags) THEN INCL(base, 18) END; (* sizing border *)
RETURN base
END ThisStyle;
PROCEDURE^ (w: Window) UpdateScrollbars (focus: BOOLEAN), NEW;
(* Hook *)
PROCEDURE (hk: Hook) Activate* (on: BOOLEAN), NEW, ABSTRACT;
PROCEDURE (hk: Hook) Focus* (on: BOOLEAN), NEW, ABSTRACT;
PROCEDURE (hk: Hook) Resize* (w, h: INTEGER), NEW, ABSTRACT;
(* Window creation *)
PROCEDURE OpenDoc (w: Window; l, t, r, b: INTEGER; min, max: BOOLEAN);
(* first part of Open, called from directory.open *)
VAR dw, dh, res: INTEGER; wnd: GDI32.Handle; m: USER32.MDICreateStruct; c: Containers.Controller;
BEGIN
ASSERT(~(Windows.isTool IN w.flags), 20);
m.title := "";
IF Windows.isAux IN w.flags THEN m.class := "Oberon Aux"
ELSE m.class := "Oberon Doc"
END;
m.instance := instance;
m.x := USER32.CWUseDefault;
m.y := USER32.CWUseDefault;
m.w := USER32.CWUseDefault;
m.h := USER32.CWUseDefault;
IF (l >= 0) & (t >= 0) & ~((l = 0) & (t = 0) & (r = 0) & (b = 0)) THEN
m.x := l; m.y := t;
IF (r > l) & (b > t) THEN
m.w := r - l; m.h := b - t; w.fix := TRUE
END
END;
(*
IF (l < r) & (t < b) THEN
m.x := l; m.w := r - l; m.y := t; m.h := b - t; w.fix := TRUE
ELSE
m.x := USER32.CWUseDefault;
m.y := USER32.CWUseDefault;
m.w := USER32.CWUseDefault;
m.h := USER32.CWUseDefault
END;
*)
m.style := ThisStyle({}, w.flags);
IF ~(Windows.noResize IN w.flags) THEN
IF max THEN INCL(m.style, 24) END (* maximized *)
(*
IF min THEN INCL(m.style, 29) END (* minimized *)
*)
END;
m.lParam := SYSTEM.VAL(INTEGER, w);
w.child := TRUE;
c := w.doc.ThisController();
IF dir.background THEN
w.doc.PollRect(l, t, r, b);
dw := (r - l ) DIV w.frame.unit; dh := (b - t) DIV w.frame.unit; (* TODO: Correct this *)
IF Documents.winWidth IN c.opts THEN m.w := mainW ELSE m.w := dw END;
IF Documents.winHeight IN c.opts THEN m.h := mainH ELSE m.h := dh END;
m.x := 0; m.y := 0;
w.fix := TRUE;
m.style := {}
END;
wnd := USER32.SendMessageA(client, USER32.WMMDICreate, 0, SYSTEM.ADR(m));
IF dir.background THEN
res := WinApi.SetWindowPos(
wnd, 1 (* HWND_BOTTOM *), 0, 0, 0, 0, WinApi.SWP_NOSIZE + WinApi.SWP_NOMOVE)
END;
IF ~(Windows.noResize IN w.flags) THEN
(*
IF max THEN res := USER32.ShowWindow(wnd, 3) END; (* maximized *)
*)
IF min THEN res := USER32.ShowWindow(wnd, 6) END (* minimized *)
END;
c.SetFocus(w.doc.ThisView());
res := USER32.SetFocus(wnd);
res := USER32.UpdateWindow(wnd)
END OpenDoc;
PROCEDURE CreateDoc (wnd: USER32.Handle; wParam, lParam: INTEGER);
(* second part of Open, called from window handler *)
VAR res, cw, ch, u, dl, dt, dr, db: INTEGER; w: Window; style, f: SET; v: Views.View; col: Ports.Color;
dc: USER32.Handle; rect, crect: USER32.Rect; cs: USER32.PCreateStruct; c: Containers.Controller;
BEGIN
cs := SYSTEM.VAL(USER32.PCreateStruct, lParam);
w := SYSTEM.VAL(Window, cs.params.lParam);
res := USER32.SetWindowLongA(wnd, 0, SYSTEM.VAL(INTEGER, w));
w.wnd := wnd;
dc := USER32.GetDC(wnd);
w.port(HostPorts.Port).SetDC(dc, wnd);
IF ~(Windows.noHScroll IN w.flags) THEN
res := USER32.SetScrollRange(wnd, USER32.SBHorz, 0, scrollRange, 1)
END;
IF ~(Windows.noVScroll IN w.flags) THEN
res := USER32.SetScrollRange(wnd, USER32.SBVert, 0, scrollRange, 1)
END;
v := w.doc.ThisView(); f := {};
WITH v: Containers.View DO
c := v.ThisController();
IF c # NIL THEN f := c.opts END
ELSE
END;
col := Views.transparent; v.GetBackground(col);
w.dlg := ({Containers.noCaret, Containers.noSelection} - f = {}) (* mask mode *)
& (col = Ports.dialogBackground); (* dialog background *)
style := BITS(USER32.GetWindowLongA(wnd, -16));
style := ThisStyle(style - {20, 21, 18}, w.flags);
IF Windows.noResize IN w.flags THEN
style := style - (WinApi.WS_THICKFRAME + WinApi.WS_MAXIMIZEBOX) + WinApi.WS_BORDER
ELSE
style := style + WinApi.WS_THICKFRAME
END;
IF dir.background THEN
style := style - (WinApi.WS_THICKFRAME + WinApi.WS_MAXIMIZEBOX +
WinApi.WS_MINIMIZEBOX + WinApi.WS_BORDER + WinApi.WS_DLGFRAME);
res := WinApi.ShowScrollBar(wnd, WinApi.SB_BOTH, WinApi.FALSE)
END;
res := USER32.SetWindowLongA(wnd, -16, ORD(style));
style := BITS(USER32.GetWindowLongA(wnd, -20));
IF ~dir.background THEN INCL(style, 8) ELSE EXCL(style, 8) END; (* window edge *)
IF w.dlg THEN (* INCL(style, 0) *) ELSE INCL(style, 9) END; (* dialog modal frame, client edge *)
res := USER32.SetWindowLongA(wnd, -20, ORD(style));
res := USER32.SetWindowPos(w.wnd, 0, 0, 0, 0, 0, {0, 1, 2, 3, 5});
(* no size, no move, no z order, no redraw, frame changed *)
res := USER32.GetClientRect(wnd, rect);
u := w.frame.unit; cw := rect.right; ch := rect.bottom;
w.port.SetSize(0, 0);
w.doc.PollRect(dl, dt, dr, db);
IF w.fix THEN
IF dir.background THEN
w.doc.SetRect(0, 0, dr - dl , db - dt) (* TODO: Corrct this *)
ELSE
IF w.dlg THEN w.doc.SetRect(0, 0, cw * u, ch * u)
ELSE w.doc.SetRect(borderW, borderW, cw * u - borderW, ch * u - borderW)
END
END
ELSIF w.dlg THEN
cw := (dr - dl) DIV u;
ch := (db - dt) DIV u;
w.doc.SetRect(0, 0, dr - dl, db - dt)
ELSE
res := USER32.GetClientRect(client, crect);
cw := (dr - dl + 2 * borderW) DIV u + 1;
ch := (db - dt + 2 * borderW) DIV u + 1;
IF ~(Windows.noHScroll IN w.flags) & (cw > crect.right - 40) THEN cw := crect.right - 80 END;
IF ~(Windows.noVScroll IN w.flags) & (ch > crect.bottom - 40) THEN ch := crect.bottom - 80 END;
(*
IF cw > rect.right THEN cw := rect.right END;
IF ch > rect.bottom THEN ch := rect.bottom END;
*)
w.doc.SetRect(borderW, borderW, borderW + dr - dl, borderW + db - dt)
END;
IF cw < 0 THEN cw := 0 END;
IF ch < 0 THEN ch := 0 END;
w.SetSize(cw, ch);
w.Restore(0, 0, cw, ch);
w.Update;
w.UpdateScrollbars(FALSE);
IF ~w.fix THEN w.SetSize(cw, ch) END;
res := USER32.GetWindowRect(wnd, rect);
w.mw := rect.right - rect.left; w.mh := rect.bottom - rect.top;
HostMechanisms.InstallDropTarget(wnd, w);
w.setup := TRUE
END CreateDoc;
PROCEDURE OpenDlg (w: Window; l, t, r, b: INTEGER; min, max: BOOLEAN);
(* first part of Open, called from directory.open *)
VAR res, cx, cy, cw, ch: INTEGER; wnd: GDI32.Handle; style: SET;
rect: USER32.Rect; c: Containers.Controller;
BEGIN
ASSERT(Windows.isTool IN w.flags, 20);
style := ThisStyle({7, 19, 22, 23, (*25,*) 31}, w.flags); (* dialog, sysmenu, border, clipchildren, popup *)
w.child := FALSE; w.dlg := TRUE;
res := USER32.GetWindowRect(main, rect);
cw := (rect.right - rect.left) DIV 2;
cx := rect.left + cw DIV 2;
ch := (rect.bottom - rect.top) DIV 2;
cy := rect.top + ch DIV 2;
IF (l >= 0) & (t >= 0) & ~((l = 0) & (t = 0) & (r = 0) & (b = 0)) THEN
cx := l; cy := t;
IF (r > l) & (b > t) THEN
cw := r - l; ch := b - t; w.fix := TRUE
END
END;
(*
IF (l < r) & (t < b) THEN
cx := l; cw := r - l; cy := t; ch := b - t; w.fix := TRUE
ELSE
res := USER32.GetWindowRect(main, rect);
cw := (rect.right - rect.left) DIV 2;
cx := rect.left + cw DIV 2;
ch := (rect.bottom - rect.top) DIV 2;
cy := rect.top + ch DIV 2
END;
*)
IF noAppWin THEN
style := style + WinApi.WS_MINIMIZEBOX;
wnd := USER32.CreateWindowExA(WinApi.WS_EX_APPWINDOW + WinApi.WS_EX_DLGMODALFRAME,
"Oberon Dlg", "", style, cx, cy, cw, ch,
ActualWnd(), 0, instance, SYSTEM.VAL(INTEGER, w))
ELSE
wnd := USER32.CreateWindowExA({0}, "Oberon Dlg", "", style, cx, cy, cw, ch,
ActualWnd(), 0, instance, SYSTEM.VAL(INTEGER, w))
END;
res := USER32.ShowWindow(wnd, 1);
c := w.doc.ThisController();
c.SetFocus(w.doc.ThisView());
res := USER32.SetFocus(wnd);
res := USER32.UpdateWindow(wnd)
END OpenDlg;
PROCEDURE CreateDlg (wnd: USER32.Handle; wParam, lParam: INTEGER);
(* second part of Open, called from window handler *)
VAR res, cw, ch, dl, dt, dr, db: INTEGER; w: Window;
dc, menu: USER32.Handle; rect: USER32.Rect; cs: USER32.PCreateStruct;
BEGIN
cs := SYSTEM.VAL(USER32.PCreateStruct, lParam);
w := SYSTEM.VAL(Window, cs.params);
res := USER32.SetWindowLongA(wnd, 0, SYSTEM.VAL(INTEGER, w));
w.wnd := wnd; w.child := FALSE; w.dlg := TRUE;
IF ~(inPlace IN w.flags) THEN
menu := USER32.GetSystemMenu(wnd, 0);
res := USER32.RemoveMenu(menu, 0F000H, {}); (* SC_SIZE *)
IF ~noAppWin THEN res := USER32.RemoveMenu(menu, 0F020H, {}) END; (* SC_MINIMIZE *)
res := USER32.RemoveMenu(menu, 0F030H, {}); (* SC_MAXIMIZE *)
res := USER32.RemoveMenu(menu, 0F120H, {}); (* SC_RESTORE *)
IF dir.unmoveable THEN
res := USER32.RemoveMenu(menu, 0F010H, {}) (* SC_MOVE *)
END;
dc := USER32.GetDC(wnd);
w.port(HostPorts.Port).SetDC(dc, wnd);
IF ~(Windows.noHScroll IN w.flags) THEN
res := USER32.SetScrollRange(wnd, USER32.SBHorz, 0, scrollRange, 1)
END;
IF ~(Windows.noVScroll IN w.flags) THEN
res := USER32.SetScrollRange(wnd, USER32.SBVert, 0, scrollRange, 1)
END;
res := USER32.GetClientRect(wnd, rect);
IF w.fix THEN
cw := rect.right; ch := rect.bottom;
w.doc.SetRect(0, 0, cw * w.frame.unit, ch * w.frame.unit)
ELSE
w.doc.PollRect(dl, dt, dr, db);
cw := (dr - dl) DIV w.frame.unit;
ch := (db - dt) DIV w.frame.unit;
w.doc.SetRect(0, 0, dr - dl, db - dt)
END;
IF cw < 0 THEN cw := 0 END;
IF ch < 0 THEN ch := 0 END;
w.SetSize(cw, ch);
w.Restore(0, 0, cw, ch);
w.Update;
w.UpdateScrollbars(FALSE);
w.SetSize(cw, ch)
END;
HostMechanisms.InstallDropTarget(wnd, w);
w.setup := TRUE
END CreateDlg;
(** Window **)
PROCEDURE (w: Window) ForwardCtrlMsg* (VAR msg: Controllers.Message), EXTENSIBLE;
VAR d: BOOLEAN; res: INTEGER;
BEGIN
IF w.frame # NIL THEN
Views.SetRoot(w.frame, w.frame.view, w = fWindow, w.flags);
w.ForwardCtrlMsg^(msg);
WITH msg: Controllers.ScrollMsg DO
w.UpdateScrollbars(FALSE)
ELSE
END;
IF (w.flags * {Windows.isAux, Windows.isTool} = {}) & (w.seq # NIL) THEN
d := ~(Windows.neverDirty IN w.flags) & w.seq.Dirty();
IF (d # w.dirty) & (w = aWindow) THEN
res := USER32.SendMessageA(w.wnd, USER32.WMNCActivate, 1, 0);
IF USER32.IsZoomed(w.wnd) # 0 THEN res := USER32.DrawMenuBar(main) END
END
END
END
END ForwardCtrlMsg;
PROCEDURE (w: Window) SetSize* (width, height: INTEGER);
VAR res, x, y, dw, dh: INTEGER; cr, wr: USER32.Rect; p: USER32.Point;
BEGIN
IF w.port # NIL THEN
IF (width = 0) & (height = 0) THEN w.SetSize^(minimized, minimized)
ELSE
w.SetSize^(width, height);
res := USER32.GetClientRect(w.wnd, cr);
dw := width - cr.right; dh := height - cr.bottom;
IF ~(inPlace IN w.flags) & (w # cbViewer) & ((dw # 0) OR (dh # 0)) THEN
res := USER32.GetWindowRect(w.wnd, wr);
p.x := wr.left; p.y := wr.top;
IF ~(Windows.isTool IN w.flags) THEN res := USER32.ScreenToClient(client, p) END;
x := p.x; y := p.y;
IF Windows.isTool IN w.flags THEN DEC(x, dw DIV 2); DEC(y, dh DIV 2) END;
width := wr.right - wr.left + dw; height := wr.bottom - wr.top + dh;
IF w.child THEN
res := USER32.GetClientRect(client, cr);
dw := cr.right; dh := cr.bottom
ELSE
dw := scW; dh := scH
END;
IF x + width > dw THEN x := dw - width END;
IF y + height > dh THEN y := dh - height END;
IF x < 0 THEN x := 0 END;
IF y < 0 THEN y := 0 END;
(*
IF x + width > dw THEN width := dw - x END;
IF y + height > dh THEN height := dh - y END;
*)
res := USER32.SetWindowPos(w.wnd, 0, x, y, width, height,
WinApi.SWP_FRAMECHANGED + WinApi.SWP_NOZORDER + WinApi.SWP_NOACTIVATE)
END
END
END
END SetSize;
PROCEDURE (w: Window) SetTitle2* (title: Views.Title), NEW;
(* assign name of window, generate title out of name, and update window title bar *)
VAR res: INTEGER; h: Window; t: ARRAY 256 OF CHAR; st: ARRAY 256 OF SHORTCHAR;
BEGIN
ASSERT(w.wnd # 0, 20);
StripTitle(title);
h := w;
REPEAT
GenTitle(h, title, t); st := SHORT(t$);
res := USER32.SetWindowTextA(h.wnd, st);
h := h.link(Window)
UNTIL h = w
END SetTitle2;
PROCEDURE (w: Window) SetTitle* (title: Views.Title);
BEGIN
ASSERT(w.wnd # 0, 20);
w.title := title; Dialog.MapString(w.title, title);
w.SetTitle2(title)
END SetTitle;
PROCEDURE (w: Window) RefreshTitle* ;
VAR title: Views.Title;
BEGIN
ASSERT(w.wnd # 0, 20);
Dialog.MapString(w.title, title);
w.SetTitle2(title)
END RefreshTitle;
PROCEDURE (w: Window) GetTitle* (OUT title: Views.Title);
(* get name of window *)
VAR res: INTEGER; st: ARRAY 256 OF SHORTCHAR;
BEGIN
ASSERT(w.wnd # 0, 20);
title := w.title;
IF title = "" THEN
res := USER32.GetWindowTextA(w.wnd, st, LEN(title));
title := st$; StripTitle(title)
END
END GetTitle;
PROCEDURE (w: Window) SetSpec* (loc: Files.Locator; name: Files.Name; conv: Converters.Converter);
VAR title: Views.Title;
BEGIN
IF name # "" THEN Kernel.MakeFileName(name, "") END;
w.SetSpec^ (loc, name, conv);
IF (loc # NIL) & (w.wnd # 0) THEN GenPathTitle(w, title); w.SetTitle(title) END
END SetSpec;
PROCEDURE (w: Window) Mark (do, wk: BOOLEAN), NEW;
VAR mark: Controllers.MarkMsg;
BEGIN
mark.show := do;
mark.focus := ~wk;
w.ForwardCtrlMsg(mark);
Properties.IncEra
END Mark;
PROCEDURE (w: Window) MouseDown* (x, y, time: INTEGER; modifiers: SET);
(* handle a mouse down event in window *)
VAR pw, ph: INTEGER; track: Controllers.TrackMsg;
BEGIN
track.modifiers := modifiers;
w.port.GetSize(pw, ph); track.x := x * w.port.unit; track.y := y * w.port.unit;
w.ForwardCtrlMsg(track);
Properties.IncEra
END MouseDown;
PROCEDURE (w: Window) KeyDown* (ch: CHAR; buttons: SET);
BEGIN
w.KeyDown^(ch, buttons);
Properties.IncEra
END KeyDown;
PROCEDURE UpdateScrollbar (w: Window; vertical, focus: BOOLEAN);
VAR res, size, sect, pos, type, p, q, m: INTEGER; valid: BOOLEAN; i: ScrollInfo;
msg: Controllers.PollSectionMsg; f: Views.Frame;
BEGIN
IF w.frame = NIL THEN RETURN END;
IF vertical THEN type := USER32.SBVert ELSE type := USER32.SBHorz END;
GetSection(w, focus, vertical, size, sect, pos, valid);
IF valid THEN
res := USER32.ShowScrollBar(w.wnd, type, 1);
res := USER32.EnableScrollBar(w.wnd, type, USER32.ESBEnableBoth);
p := KERNEL32.MulDiv(pos, scrollRange, size - sect);
IF (Dialog.platform # 11) & (GetScrollInfo # NIL) THEN
i.size := SIZE(ScrollInfo); i.mask := {0, 1, 2}; (* range, page, pos *)
res := GetScrollInfo(w.wnd, type, i);
IF (res # 0) THEN
IF sect > 0 THEN q := KERNEL32.MulDiv(sect, scrollRange, size - sect); m := scrollRange + q
ELSE q := -1; m := scrollRange
END;
IF (i.pos # p) OR (i.page # q + 1) THEN
i.pos := p; i.page := q + 1; i.max := m;
res := SetScrollInfo(w.wnd, type, i, 1)
END
ELSIF p # USER32.GetScrollPos(w.wnd, type) THEN
res := USER32.SetScrollPos(w.wnd, type, p, 1)
END
ELSIF p # USER32.GetScrollPos(w.wnd, type) THEN
res := USER32.SetScrollPos(w.wnd, type, p, 1)
END
ELSIF ~focus THEN
msg.focus := FALSE; msg.vertical := vertical; msg.done := FALSE;
f := Views.ThisFrame(w.frame, w.doc.ThisView());
IF f # NIL THEN
Views.ForwardCtrlMsg(f, msg);
IF msg.done THEN
res := USER32.ShowScrollBar(w.wnd, type, 1);
res := USER32.EnableScrollBar(w.wnd, type, USER32.ESBDisableBoth)
ELSE res := USER32.ShowScrollBar(w.wnd, type, 0)
END
ELSE res := USER32.ShowScrollBar(w.wnd, type, 0)
END
END
END UpdateScrollbar;
PROCEDURE (w: Window) Scroll (code, p: INTEGER; focus, vertical: BOOLEAN), NEW;
VAR res, size, sect, pos, type: INTEGER; valid, noBuf: BOOLEAN;
BEGIN
GetSection(w, focus, vertical, size, sect, pos, valid);
IF valid THEN
noBuf := HostPorts.noBuffer; HostPorts.noBuffer := TRUE;
IF code = USER32.SBThumbPos THEN
SetOrigin(w, focus, vertical, KERNEL32.MulDiv(p, size - sect, scrollRange))
ELSIF visualScroll & (code = USER32.SBThumbTrack) THEN
SetOrigin(w, focus, vertical, KERNEL32.MulDiv(p, size - sect, scrollRange));
res := USER32.UpdateWindow(w.wnd);
dir.Update(w)
ELSIF code = USER32.SBLineUp THEN Scroll(w, focus, vertical, Controllers.decLine)
ELSIF code = USER32.SBLineDown THEN Scroll(w, focus, vertical, Controllers.incLine)
ELSIF code = USER32.SBPageUp THEN Scroll(w, focus, vertical, Controllers.decPage)
ELSIF code = USER32.SBPageDown THEN Scroll(w, focus, vertical, Controllers.incPage)
END;
(*
UpdateScrollbar(w, vertical, focus);
*)
GetSection(w, focus, vertical, size, sect, pos, valid);
IF vertical THEN type := USER32.SBVert ELSE type := USER32.SBHorz END;
res := USER32.SetScrollPos(w.wnd, type, KERNEL32.MulDiv(pos, scrollRange, size - sect), 1);
dir.Update(w);
HostPorts.noBuffer := noBuf
END
END Scroll;
PROCEDURE (w: Window) UpdateScrollbars (focus: BOOLEAN), NEW;
BEGIN
IF (USER32.GetAsyncKeyState(1) >= 0)
& (USER32.GetAsyncKeyState(4) >= 0)
& (USER32.GetAsyncKeyState(2) >= 0) THEN
IF ~(Windows.noHScroll IN w.flags) THEN UpdateScrollbar(w, FALSE, focus) END;
IF ~(Windows.noVScroll IN w.flags) THEN UpdateScrollbar(w, TRUE, focus) END
END
END UpdateScrollbars;
PROCEDURE (w: Window) UpdateCursor (x, y: INTEGER; modifiers: SET), NEW;
VAR pw, ph: INTEGER; msg: Controllers.PollCursorMsg; cur: INTEGER;
BEGIN
w.port.GetSize(pw, ph);
IF ((w = fWindow) OR (w = tWindow) OR ~w.child) & (x >= 0) & (x < pw) & (y >= 0) & (y < ph) THEN
msg.x := x * w.frame.unit; msg.y := y * w.frame.unit; msg.cursor := Ports.arrowCursor;
msg.modifiers := modifiers;
w.ForwardCtrlMsg(msg); cur := msg.cursor
ELSE cur := Ports.arrowCursor
END;
IF cur >= 0 THEN w.frame.SetCursor(cur) END
END UpdateCursor;
PROCEDURE (w: Window) PutOnTop, NEW;
VAR v: Window;
BEGIN
IF w # bgWindow THEN
v := winAnchor;
WHILE (v # NIL) & (v.next # w) DO v := v.next END;
IF v # NIL THEN
v.next := w.next; w.next := winAnchor.next; winAnchor.next := w
END
END
END PutOnTop;
PROCEDURE (w: Window) Close*, EXTENSIBLE;
VAR res: INTEGER; h: Window;
BEGIN
ASSERT(w.frame # NIL, 20);
IF bgWindow = w THEN bgWindow := NIL END;
IF fWindow = w THEN
w.Mark(FALSE, FALSE); fWindow := NIL;
IF tWindow = w THEN tWindow := NIL END
ELSIF tWindow = w THEN
w.Mark(FALSE, FALSE); tWindow := NIL
END;
(*
(* remove all shown marks in all windows *)
IF fWindow # NIL THEN
ASSERT(fWindow.frame # NIL, 125); ASSERT(fWindow.wnd # 0, 126);
mark.show := FALSE; fWindow.ForwardCtrlMsg(mark)
END;
tWindow := NIL; fWindow := NIL;
*)
(*
IF w = fWindow THEN fWindow := NIL END;
IF w = tWindow THEN tWindow := NIL END;
*)
h := winAnchor;
WHILE (h.next # NIL) & (h.next # w) DO h := h.next END;
ASSERT(h.next = w, 21);
h.next := w.next; w.next := NIL;
HostMechanisms.RemoveDropTarget(w.wnd);
w.Close^;
IF ~w.destroyed THEN
w.destroyed := TRUE;
IF w.child THEN
IF USER32.IsZoomed(w.wnd) # 0 THEN
res := USER32.SendMessageA(client, USER32.WMMDIRestore, w.wnd, 0)
END;
res := USER32.SendMessageA(client, USER32.WMMDIDestroy, w.wnd, 0)
ELSE
res := USER32.DestroyWindow(w.wnd)
END;
w.trapped := TRUE; w.wnd := 0
END;
ASSERT(w.frame = NIL, 60)
END Close;
PROCEDURE ShowMain*;
VAR res: INTEGER; menu: WinApi.HANDLE;
BEGIN
IF debug THEN Log.String("show main"); Log.Ln END;
IF fullSize THEN
menu := WinApi.GetSystemMenu(main, 0);
res := WinApi.RemoveMenu(menu, WinApi.SC_MOVE, {})
END;
res := USER32.ShowWindow(main, showState);
res := USER32.UpdateWindow(main);
showState := USER32.SWShow
END ShowMain;
(* Directory *)
PROCEDURE (d: Directory) Open* (
w: Windows.Window; doc: Documents.Document; flags: SET; name: Views.Title;
loc: Files.Locator; fname: Files.Name; conv: Converters.Converter
), EXTENSIBLE;
VAR res: INTEGER; v, bg: Window; p: HostPorts.Port;
BEGIN
WITH w: Window DO
(* if background then it has to be and AuxDialog *)
IF d.background
& ((Windows.isTool IN flags) OR ~(Windows.noHScroll IN flags) OR ~(Windows.noVScroll IN flags))
THEN
d.background := FALSE
END;
(* port allocation *)
NEW(p);
IF d.unit # 0 THEN p.Init(d.unit, Ports.screen) ELSE p.Init(unit, Ports.screen) END;
(* initialization *)
w.trapped := FALSE;
w.Init(p);
d.Open^(w, doc, flags, name, loc, fname, conv);
IF w # cbViewer THEN
IF ~d.background THEN
w.next := winAnchor.next; winAnchor.next := w (* new top window *)
ELSE
v := winAnchor;
WHILE v.next # NIL DO v := v.next END; v.next := w; w.next := NIL;
bg := bgWindow; bgWindow := w (* new background window *)
END;
IF ~(inPlace IN w.flags) THEN
(* window creation *)
IF Windows.isTool IN flags THEN
OpenDlg(w, d.l, d.t, d.r, d.b, d.minimized, d.maximized)
ELSE
IF ~d.invisible & (USER32.IsWindowVisible(main) = 0) THEN ShowMain END;
OpenDoc(w, d.l, d.t, d.r, d.b, d.minimized, d.maximized)
END;
IF (loc # NIL) & (name = fname) THEN GenPathTitle(w, name) END;
w.SetTitle(name);
IF Windows.isTool IN flags THEN
res := USER32.SendMessageA(w.wnd, USER32.WMNCActivate, 0, 0);
res := USER32.SendMessageA(w.wnd, USER32.WMNCActivate, 1, 0)
END;
ASSERT(w.frame # NIL, 60)
END
END;
d.l := -1; d.t := -1; d.r := -1; d.b := -1;
d.minimized := FALSE; d.maximized := FALSE;
d.unit := 0;
d.unmoveable := FALSE;
IF d.background THEN
IF bg # NIL THEN dir.Close(bg) END;
bgWindow := w;
d.background := FALSE
END
END
END Open;
PROCEDURE (d: Directory) First* (): Window;
BEGIN
RETURN winAnchor.next
END First;
PROCEDURE (d: Directory) Next* (w: Windows.Window): Window;
BEGIN
IF w # NIL THEN RETURN w(Window).next ELSE RETURN NIL END
END Next;
PROCEDURE (d: Directory) New* (): Window, EXTENSIBLE;
VAR w: Window;
BEGIN
NEW(w); RETURN w
END New;
PROCEDURE (d: Directory) Focus* (target: BOOLEAN): Window;
BEGIN
IF target THEN RETURN tWindow ELSE RETURN fWindow END
END Focus;
PROCEDURE (d: Directory) Select* (w: Windows.Window; lazy: BOOLEAN);
VAR res: INTEGER;
BEGIN
WITH w: Window DO
IF ~(inPlace IN w.flags) THEN
res := USER32.SetForegroundWindow(main);
IF res = 0 THEN res := USER32.SetActiveWindow(main) END; (* win32s *)
IF w.child THEN res := USER32.BringWindowToTop(main) END
END;
IF USER32.IsIconic(w.wnd) # 0 THEN
res := USER32.ShowWindow(w.wnd, 9); (* restore *)
res := USER32.InvalidateRect(w.wnd, NIL, 0)
END;
IF USER32.GetTopWindow(main) # w.wnd THEN
res := USER32.BringWindowToTop(w.wnd)
END;
(*
res := USER32.UpdateWindow(w.wnd);
*)
res := USER32.SetFocus(w.wnd)
END
END Select;
PROCEDURE (d: Directory) GetThisWindow* (p: Ports.Port; px, py: INTEGER;
OUT x, y: INTEGER; OUT w: Windows.Window);
VAR res: INTEGER; wnd: USER32.Handle; pt: USER32.Point; s: ARRAY 32 OF SHORTCHAR;
BEGIN
(* Alexander Iljin:
Original code was as follows:
wnd := p(HostPorts.Port).wnd;
pt.x := px; pt.y := py;
res := USER32.ClientToScreen(wnd, pt);
wnd := USER32.WindowFromPoint(pt);
I just made it possible to call GetThisWindow with p = NIL. If p = NIL then (px, py) specify screen coordinates, otherwise it is client coordinates within a port p, as usual.
*)
pt.x := px; pt.y := py;
IF p # NIL THEN
wnd := p(HostPorts.Port).wnd;
res := USER32.ClientToScreen(wnd, pt);
END;
wnd := USER32.WindowFromPoint(pt);
IF wnd # 0 THEN
res := USER32.GetClassNameA(wnd, s, LEN(s));
IF (s = "Oberon Doc") OR (s = "Oberon Aux") OR (s = "Oberon Dlg") THEN
res := USER32.ScreenToClient(wnd, pt);
x := pt.x; y := pt.y; w := ThisWindow(wnd)
ELSE
w := NIL
END
ELSE
w := NIL
END
END GetThisWindow;
PROCEDURE (d: Directory) Close* (w: Windows.Window);
VAR v, u: Windows.Window; h: Window;
BEGIN
h := winAnchor; WHILE (h.next # NIL) & (h.next # w) DO h := h.next END;
IF h.next = w THEN
IF ~w.sub THEN
v := w.link;
WHILE v # w DO u := v.link; v.Close; v := u END
END;
w.Close
END
END Close;
PROCEDURE (d: Directory) GetBounds* (OUT w, h: INTEGER);
VAR rect: USER32.Rect; res: INTEGER;
BEGIN
res := USER32.GetClientRect(client, rect);
w := rect.right; h := rect.bottom
END GetBounds;
(** window handlers **)
PROCEDURE CallHeapShow* (a: INTEGER);
TYPE P = PROCEDURE(a: INTEGER; t: ARRAY OF CHAR);
V = RECORD (Meta.Value) p: P END;
VAR i: Meta.Item; ok: BOOLEAN; v: V;
BEGIN
Meta.Lookup("DevDebug", i);
IF i.obj = Meta.modObj THEN i.Lookup("ShowHeapObject", i);
IF i.obj = Meta.procObj THEN i.GetVal(v, ok);
IF ok THEN v.p(a, "") END
END
END
END CallHeapShow;
PROCEDURE KeyModifiers (data: INTEGER): SET;
VAR b: SET;
BEGIN
b := {};
IF USER32.GetKeyState(10H) < 0 THEN INCL(b, Controllers.extend); INCL(b, HostPorts.shift) END;
IF USER32.GetKeyState(11H) < 0 THEN INCL(b, Controllers.modify); INCL(b, HostPorts.ctrl) END;
IF ODD(data DIV 20000000H) THEN INCL(b, HostPorts.alt) END;
RETURN b
END KeyModifiers;
PROCEDURE HandleKey (wnd: USER32.Handle; code, ext: INTEGER);
VAR b: SET; w: Window; pmsg: Controllers.PollFocusMsg; scroll: BOOLEAN; c: Containers.Controller;
BEGIN
w := ThisWindow(wnd); b := KeyModifiers(ext); w.used := TRUE;
scroll := ODD(USER32.GetKeyState(91H)) (* scroll lock *);
pmsg.focus := NIL; w.ForwardCtrlMsg(pmsg);
IF (pmsg.focus # NIL) & (pmsg.focus.view IS Containers.View) THEN
c := pmsg.focus.view(Containers.View).ThisController();
IF (c # NIL) & (Containers.noCaret IN c.opts) THEN scroll := TRUE END
END;
CASE code OF
| 2EH: w.KeyDown(RDEL, b) (* delete -> right delete *)
| 08H: w.KeyDown(LDEL, b) (* backspace -> left delete *)
| 09H: (* tab *)
IF Controllers.extend IN b THEN w.KeyDown(LTAB, b) (* left tab *)
ELSE w.KeyDown(TAB, b) (* right tab *)
END
| 0DH: w.KeyDown(ENTER, b) (* enter *)
| 1BH: w.KeyDown(ESC, b) (* escape *)
| 21H: (* page up *)
IF scroll THEN
w.Scroll(USER32.SBPageUp, 0, TRUE, ~(Controllers.modify IN b))
ELSIF Controllers.modify IN b THEN (* move caret left one page *)
w.KeyDown(PL, b - {Controllers.modify})
ELSE (* move caret up one page *)
w.KeyDown(PU, b)
END
| 22H: (* page down *)
IF scroll THEN
w.Scroll(USER32.SBPageDown, 0, TRUE, ~(Controllers.modify IN b))
ELSIF Controllers.modify IN b THEN (* move caret right one page *)
w.KeyDown(PR, b - {Controllers.modify})
ELSE (* move caret down one page *)
w.KeyDown(PD, b)
END
| 23H: (* end *)
IF scroll THEN
w.Scroll(USER32.SBThumbPos, scrollRange, TRUE, Controllers.modify IN b)
ELSIF Controllers.modify IN b THEN (* move caret to doc end *)
w.KeyDown(DD, b - {Controllers.modify})
ELSE (* move caret to line end *)
w.KeyDown(DR, b)
END
| 24H: (* home *)
IF scroll THEN
w.Scroll(USER32.SBThumbPos, 0, TRUE, Controllers.modify IN b)
ELSIF Controllers.modify IN b THEN (* move caret to doc start *)
w.KeyDown(DU, b - {Controllers.modify})
ELSE (* move caret to line start *)
w.KeyDown(DL, b)
END
| 25H: (* left *)
IF scroll THEN
w.Scroll(USER32.SBLineUp, 0, TRUE, FALSE)
ELSE
w.KeyDown(AL, b)
END
| 26H: (* up *)
IF scroll THEN
w.Scroll(USER32.SBLineUp, 0, TRUE, TRUE)
ELSE
w.KeyDown(AU, b)
END
| 27H: (* right *)
IF scroll THEN
w.Scroll(USER32.SBLineDown, 0, TRUE, FALSE)
ELSE
w.KeyDown(AR, b)
END
| 28H: (* down *)
IF scroll THEN
w.Scroll(USER32.SBLineDown, 0, TRUE, TRUE)
ELSE
w.KeyDown(AD, b)
END
ELSE
END;
Properties.IncEra
END HandleKey;
PROCEDURE HandleChar (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR w: Window; mod: SET; ch: CHAR;
BEGIN
IF (wParam >= 20H) & (wParam # 7FH) THEN
w := ThisWindow(wnd); mod := KeyModifiers(lParam); w.used := TRUE;
IF USER32.VkKeyScanA(SHORT(CHR(wParam))) >= 4 * 256 THEN EXCL(mod, HostPorts.alt) END;
CASE wParam OF
| 80H: ch := 20ACX (* euro *)
| 82H: ch := 201AX
| 83H: ch := 0192X
| 84H: ch := 201EX
| 85H: ch := 2026X
| 86H: ch := 2020X
| 87H: ch := 2021X
| 88H: ch := 02C6X
| 89H: ch := 2030X
| 8AH: ch := 0160X
| 8BH: ch := 2039X
| 8CH: ch := 0152X
| 91H: ch := 2018X
| 92H: ch := 2019X
| 93H: ch := 201CX
| 94H: ch := 201DX
| 95H: ch := 2022X
| 96H: ch := 2013X
| 97H: ch := 2014X
| 98H: ch := 02DCX
| 99H: ch := 2122X
| 9AH: ch := 0161X
| 9BH: ch := 203AX
| 9CH: ch := 0153X
| 9FH: ch := 0178X
ELSE ch := CHR(wParam)
END;
w.KeyDown(ch, mod)
END
END HandleChar;
PROCEDURE HandleMouse (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR w: Window; isDown: BOOLEAN; x, y: INTEGER; b: SET; f, g: Views.Frame;
BEGIN
w := ThisWindow(wnd); b := {}; w.used := TRUE;
IF ODD(wParam) THEN INCL(b, HostPorts.left) END;
IF ODD(wParam DIV 16) THEN INCL(b, HostPorts.middle) END;
IF ODD(wParam DIV 2) THEN INCL(b, HostPorts.right) END;
isDown := b # {};
IF ODD(wParam DIV 4) THEN INCL(b, HostPorts.shift); INCL(b, Controllers.extend) END;
IF ODD(wParam DIV 8) THEN INCL(b, HostPorts.ctrl); INCL(b, Controllers.modify) END;
IF USER32.GetAsyncKeyState(12H) < 0 THEN INCL(b, HostPorts.alt) END;
IF ODD(wParam DIV 128) THEN INCL(b, Controllers.doubleClick) END;
x := lParam MOD 65536;
y := lParam DIV 65536;
HostPorts.SetMouseState(x, y, b, isDown);
IF wParam DIV 256 = 1 THEN
IF {HostPorts.middle, HostPorts.shift, HostPorts.ctrl} - b = {} THEN
CallHeapShow(SYSTEM.VAL(INTEGER, w))
ELSIF {HostPorts.middle, HostPorts.shift, HostPorts.alt} - b = {} THEN
f := w.frame; x := x * f.unit; y := y * f.unit;
REPEAT g := f; f := Views.FrameAt(g, x - g.gx, y - g.gy) UNTIL f = NIL;
CallHeapShow(SYSTEM.VAL(INTEGER, g))
ELSIF ~activating THEN
w.MouseDown(x, y, 0, b)
END
ELSIF wParam DIV 256 = 2 THEN
w.UpdateCursor(x, y, b)
END;
IF ~isDown THEN activating := FALSE END;
Properties.IncEra
END HandleMouse;
PROCEDURE DeactivateWin (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR w: Window;
BEGIN
w := ThisWindow(wnd);
IF fWindow = w THEN
w.Mark(FALSE, TRUE); fWindow := NIL;
IF (inPlace IN w.flags) OR ~(Windows.isTool IN w.flags) THEN
w.Mark(TRUE, TRUE);
IF (w # aWindow) & ~(inPlace IN w.flags) THEN tWindow := NIL END
END
END
END DeactivateWin;
PROCEDURE ActivateWin (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR res: INTEGER; w: Window;
BEGIN
w := ThisWindow(wnd);
IF fWindow # w THEN
IF fWindow # NIL THEN
DeactivateWin(fWindow.wnd, 0, 0)
END;
w.PutOnTop;
res := USER32.UpdateWindow(wnd);
IF (inPlace IN w.flags) OR ~(Windows.isTool IN w.flags) THEN
w.Mark(FALSE, TRUE);
tWindow := w
END;
fWindow := w; w.Mark(TRUE, TRUE);
Properties.IncEra;
(*
Dialog.CheckGuards
*)
Dialog.Notify(0, 0, {guardCheck})
END
END ActivateWin;
PROCEDURE ActivateWindow* (w: Windows.Window; do: BOOLEAN);
BEGIN
IF debug THEN
IF do THEN Log.String("Activate ") ELSE Log.String("Deactivate ") END;
Log.IntForm(SYSTEM.VAL(INTEGER, w), 16, 8, "0", FALSE);
Log.Char(" ");
Log.IntForm(SYSTEM.VAL(INTEGER, fWindow), 16, 8, "0", FALSE);
IF inPlace IN w.flags THEN Log.String(" ip") END;
IF Windows.isTool IN w.flags THEN Log.String(" tool") END;
Log.Ln
END;
IF do THEN ActivateWin(w(Window).wnd, 0, 0)
ELSE DeactivateWin(w(Window).wnd, 0, 0)
END
END ActivateWindow;
PROCEDURE SizeWin (wnd: USER32.Handle; w, h: INTEGER);
VAR v: Window;
BEGIN
v := ThisWindow(wnd);
IF ~(inPlace IN v.flags) THEN
v.SetSize(w, h)
END;
IF v.hook # NIL THEN v.hook.Resize(w, h) END
END SizeWin;
PROCEDURE ScrollWin (wnd: USER32.Handle; wParam, vertical: INTEGER);
VAR w: Window;
BEGIN
w := ThisWindow(wnd);
IF ~activating THEN w.Scroll(wParam MOD 65536, wParam DIV 65536, ScrollModPressed(), vertical # 0)
END
END ScrollWin;
PROCEDURE WheelScroll (wnd: USER32.Handle; wParam, lParam: INTEGER);
VAR w: Window; res, lines, delta, keys: INTEGER; msg: Controllers.WheelMsg;
p: WinApi.POINT;
BEGIN
delta := wParam DIV 10000H; keys := wParam MOD 10000H;
w := ThisWindow(wnd);
lines := 3;
res := WinApi.SystemParametersInfo(104 (*SPI_GETWHEELSCROLLLINES*), 0, SYSTEM.ADR(lines), 0);
p.x := lParam MOD 65536; p.y := lParam DIV 65536;
res := WinApi.ScreenToClient(wnd, p);
msg.x := p.x * w.port.unit; msg.y := p.y * w.port.unit;
msg.nofLines := 0; msg.op := -1;
IF lines > 10 THEN (* scroll pages *)
INC(w.wheelPos, delta);
IF w.wheelPos >= 120 THEN
msg.op := Controllers.decPage;
DEC(w.wheelPos, 120)
ELSIF w.wheelPos <= -120 THEN
msg.op := Controllers.incPage;
INC(w.wheelPos, 120)
END
ELSIF lines > 0 THEN
INC(w.wheelPos, delta * lines);
WHILE w.wheelPos >= 120 DO
msg.op := Controllers.decLine;
INC(msg.nofLines);
DEC(w.wheelPos, 120)
END;
WHILE w.wheelPos <= -120 DO
msg.op := Controllers.incLine;
INC(msg.nofLines);
INC(w.wheelPos, 120)
END
END;
msg.done := FALSE;
IF msg.op >= 0 THEN w.ForwardCtrlMsg(msg) END;
IF ~msg.done THEN (* scroll document *)
CASE msg.op OF
| Controllers.decPage:
w.Scroll(USER32.SBPageUp, 0, ODD(keys DIV 8), ~ODD(keys DIV 4))
| Controllers.incPage:
w.Scroll(USER32.SBPageDown, 0, ODD(keys DIV 8), ~ODD(keys DIV 4))
| Controllers.decLine:
WHILE msg.nofLines > 0 DO
w.Scroll(USER32.SBLineUp, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
DEC(msg.nofLines)
END
| Controllers.incLine:
WHILE msg.nofLines > 0 DO
w.Scroll(USER32.SBLineDown, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
DEC(msg.nofLines)
END
ELSE
END
(*
IF lines > 10 THEN (* scroll pages *)
INC(w.wheelPos, delta);
IF w.wheelPos >= 120 THEN
w.Scroll(USER32.SBPageUp, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
DEC(w.wheelPos, 120)
ELSIF w.wheelPos <= -120 THEN
w.Scroll(USER32.SBPageDown, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
INC(w.wheelPos, 120)
END
ELSIF lines > 0 THEN
INC(w.wheelPos, delta * lines);
WHILE w.wheelPos >= 120 DO
w.Scroll(USER32.SBLineUp, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
DEC(w.wheelPos, 120)
END;
WHILE w.wheelPos <= -120 DO
w.Scroll(USER32.SBLineDown, 0, ODD(keys DIV 8), ~ODD(keys DIV 4));
INC(w.wheelPos, 120)
END
END
*)
END
END WheelScroll;
PROCEDURE InvalidateWin (wnd, dc: USER32.Handle; paint: INTEGER);
TYPE RectPtr = POINTER TO USER32.Rect;
VAR w: Window; rp: RectPtr;
BEGIN
w := ThisWindow(wnd);
w.port(HostPorts.Port).SetDC(dc, wnd);
rp := SYSTEM.VAL(RectPtr, paint);
w.Restore(rp.left, rp.top, rp.right, rp.bottom)
END InvalidateWin;
PROCEDURE PaintWin (wnd: USER32.Handle; a, b: INTEGER);
VAR w: Window;
BEGIN
w := ThisWindow(wnd);
w.Update
END PaintWin;
PROCEDURE [2] DocWinHandler (wnd: USER32.Handle; message, wParam, lParam: INTEGER): INTEGER;
VAR res, x, dx, dy: INTEGER; w: Window; ps: USER32.PaintStruct;
(* pm: USER32.PMinMaxInfo; *)
rec: USER32.Rect; style, st: SET; wp: WinApi.WINDOWPOS;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
CASE message OF
| USER32.WMCreate:
Kernel.Try(CreateDoc, wnd, wParam, lParam)
| USER32.WMClose:
res := USER32.SendMessageA(main, USER32.WMCommand, iClose, 0);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMDestroy:
w := ThisWindow(wnd);
IF ~w.destroyed THEN
w.destroyed := TRUE;
w.Close
END;
IF w = aWindow THEN aWindow := NIL END;
IF w = tWindow THEN tWindow := NIL END
| USER32.WMChildActivate:
w := ThisWindow(wnd);
w.PutOnTop; aWindow := w;
tWindow := w
| USER32.WMSetFocus:
w := ThisWindow(wnd);
IF debug THEN
Log.String("Doc: SetFocus ");
Log.IntForm(SYSTEM.VAL(INTEGER, w), 16, 8, "0", FALSE);
Log.Char(" ");
Log.IntForm(SYSTEM.VAL(INTEGER, fWindow), 16, 8, "0", FALSE);
IF inPlace IN w.flags THEN Log.String(" ip") END;
IF Windows.isTool IN w.flags THEN Log.String(" tool") END;
Log.Ln
END;
IF tWindow # w THEN activating := TRUE END;
IF w = bgWindow THEN
res := WinApi.SetWindowPos(wnd, 1 (* HWND_BOTTOM *), 0, 0, 0, 0,
WinApi.SWP_NOSIZE + WinApi.SWP_NOMOVE + WinApi.SWP_NOREDRAW)
END;
Kernel.Try(ActivateWin, wnd, wParam, lParam);
IF w.hook # NIL THEN w.hook.Focus(TRUE) END
| USER32.WMKillFocus:
w := ThisWindow(wnd);
IF debug THEN
Log.String("Doc: KillFocus ");
Log.IntForm(SYSTEM.VAL(INTEGER, w), 16, 8, "0", FALSE);
Log.Char(" ");
Log.IntForm(SYSTEM.VAL(INTEGER, fWindow), 16, 8, "0", FALSE);
IF inPlace IN w.flags THEN Log.String(" ip") END;
IF Windows.isTool IN w.flags THEN Log.String(" tool") END;
Log.Ln
END;
IF wParam # main THEN Kernel.Try(DeactivateWin, wnd, wParam, lParam) END;
IF w.hook # NIL THEN w.hook.Focus(FALSE) END
| USER32.WMSize:
w := ThisWindow(wnd);
IF (w = bgWindow) & ((wParam = WinApi.SIZE_MAXHIDE) OR (wParam = WinApi.SIZE_MAXSHOW)) THEN
Controllers.ResetCurrentPath();
RETURN 0
ELSE
Kernel.Try(SizeWin, wnd, lParam MOD 65536, lParam DIV 65536)
END
| USER32.WMHScroll:
Kernel.Try(ScrollWin, wnd, wParam, 0);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMVScroll:
Kernel.Try(ScrollWin, wnd, wParam, 1);
Controllers.ResetCurrentPath();
RETURN 0
| 020AH: (* WM_MOUSEWHEEL *)
Kernel.Try(WheelScroll, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMPaint:
w := ThisWindow(wnd);
w.GetSize(dx, dy);
IF (dx # minimized) & (dy # minimized) THEN
(* clip region must be reset to ensure correct ps.paint ! *)
res := GDI32.SelectClipRgn(w.port(HostPorts.Port).dc, 0);
x := USER32.BeginPaint(w.wnd, ps);
Kernel.Try(InvalidateWin, wnd, x, SYSTEM.ADR(ps.paint));
res := USER32.EndPaint(w.wnd, ps);
Kernel.Try(PaintWin, wnd, 0, 0);
(* Alexander Iljin: we MUST return 0 and, before that, reset path *)
Controllers.ResetCurrentPath();
RETURN 0
END
| USER32.WMLButtonDown, USER32.WMRButtonDown, USER32.WMMButtonDown:
IF wnd # USER32.GetFocus() THEN
res := USER32.SendMessageA(client, USER32.WMMDIActivate, wnd, 0);
res := USER32.SetFocus(wnd)
END;
res := USER32.SetCapture(wnd);
Kernel.Try(HandleMouse, wnd, wParam + 256, lParam);
IF USER32.GetCapture() = wnd THEN res := USER32.ReleaseCapture() END;
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMLButtonDblClk, USER32.WMRButtonDblClk, USER32.WMMButtonDblClk:
res := USER32.SetCapture(wnd);
Kernel.Try(HandleMouse, wnd, wParam + (128 + 256), lParam);
IF USER32.GetCapture() = wnd THEN res := USER32.ReleaseCapture() END;
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMLButtonUp, USER32.WMRButtonUp, USER32.WMMButtonUp:
Kernel.Try(HandleMouse, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMMouseMove:
Kernel.Try(HandleMouse, wnd, wParam + (2 * 256), lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMKeyDown:
Kernel.Try(HandleKey, wnd, wParam, lParam)
| USER32.WMChar:
Kernel.Try(HandleChar, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMNCLButtonDown:
IF activating & ((wParam = 6) OR (wParam = 7) OR (wParam = 20)) THEN (* in scrollbar, close *)
Controllers.ResetCurrentPath();
RETURN 0
END
| USER32.WMNCLButtonUp, USER32.WMNCRButtonUp:
activating := FALSE
| USER32.WMMDIActivate:
w := ThisWindow(wnd);
IF w.hook # NIL THEN w.hook.Activate(wnd = lParam) END
| USER32.WMNCActivate:
w := ThisWindow(wnd);
IF (w = bgWindow) OR ((bgWindow # NIL) & (wParam MOD 65536 = WinApi.FALSE)) THEN
res := WinApi.SetWindowPos(bgWindow.wnd, 1 (* HWND_BOTTOM *), 0, 0, 0, 0,
WinApi.SWP_NOSIZE + WinApi.SWP_NOMOVE + WinApi.SWP_NOACTIVATE)
END;
style := BITS(USER32.GetWindowLongA(wnd, -16));
IF wParam MOD 65536 # 0 THEN
IF ~mainActive & (w # tWindow) & (tWindow # NIL) THEN
st := BITS(USER32.GetWindowLongA(tWindow.wnd, -16));
st := st - {16, 17, 19}; (* minimize box, maximize box, sysmenu *)
res := USER32.SetWindowLongA(tWindow.wnd, -16, ORD(st));
res := USER32.GetWindowRect(tWindow.wnd, rec);
x := GDI32.CreateRectRgnIndirect(rec);
res := USER32.SendMessageA(tWindow.wnd, USER32.WMNCPaint, x, 0)
END;
IF (w.flags * {Windows.isAux, Windows.isTool} = {}) THEN
IF ~(Windows.neverDirty IN w.flags) & w.seq.Dirty() THEN
res := USER32.SetClassLongA(wnd, -14, dirtyIcon); w.dirty := TRUE
ELSE
res := USER32.SetClassLongA(wnd, -14, docIcon); w.dirty := FALSE
END
END;
style := style + WinApi.WS_MINIMIZEBOX + WinApi.WS_SYSMENU;
IF ~(Windows.noResize IN w.flags) THEN style := style + WinApi.WS_MAXIMIZEBOX END
ELSIF mainActive THEN
style := style - {16, 17, 19} (* minimize box, maximize box, sysmenu *)
END;
res := USER32.SetWindowLongA(wnd, -16, ORD(style))
| WinApi.WM_WINDOWPOSCHANGED:
w := ThisWindow(wnd);
wp := SYSTEM.VAL(WinApi.WINDOWPOS, lParam);
IF (w = bgWindow) & (wp.hwndInsertAfter # 1 (* HWND_BOTTOM *)) THEN
res := WinApi.SetWindowPos(wnd, 1 (* HWND_BOTTOM *), 0, 0, 0, 0,
WinApi.SWP_NOSIZE + WinApi.SWP_NOMOVE + WinApi.SWP_NOACTIVATE);
Controllers.ResetCurrentPath();
RETURN USER32.DefMDIChildProcA(wnd, message, wParam, lParam)
ELSE
Controllers.ResetCurrentPath();
RETURN USER32.DefMDIChildProcA(wnd, message, wParam, lParam)
END
(*
| USER32.WMGetMinMaxInfo:
w := ThisWindow(wnd);
IF (w # NIL) & (w.mw > 0) & (Windows.noResize IN w.flags) THEN
pm := SYSTEM.VAL(USER32.PMinMaxInfo, lParam);
pm.maxTrackSize.x := w.mw;
pm.maxTrackSize.y := w.mh;
Controllers.ResetCurrentPath();
RETURN 0
END
*)
ELSE
END;
Controllers.ResetCurrentPath();
RETURN USER32.DefMDIChildProcA(wnd, message, wParam, lParam)
END DocWinHandler;
PROCEDURE [2] DialogHandler (wnd: USER32.Handle; message, wParam, lParam: INTEGER): INTEGER;
VAR res, x, dx, dy: INTEGER; w: Window; ps: USER32.PaintStruct;
BEGIN
Controllers.SetCurrentPath(Controllers.targetPath);
CASE message OF
| USER32.WMCreate:
Kernel.Try(CreateDlg, wnd, wParam, lParam)
| USER32.WMClose:
res := USER32.SendMessageA(main, USER32.WMCommand, iClose, 0);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMDestroy:
w := ThisWindow(wnd);
IF ~w.destroyed THEN
w.destroyed := TRUE;
w.Close
END
| USER32.WMSetFocus:
w := ThisWindow(wnd);
IF debug THEN
Log.String("Dlg: SetFocus ");
Log.IntForm(SYSTEM.VAL(INTEGER, w), 16, 8, "0", FALSE);
Log.Char(" ");
Log.IntForm(SYSTEM.VAL(INTEGER, fWindow), 16, 8, "0", FALSE);
IF inPlace IN w.flags THEN Log.String(" ip") END;
IF Windows.isTool IN w.flags THEN Log.String(" tool") END;
Log.Ln
END;
Kernel.Try(ActivateWin, wnd, wParam, lParam);
IF w.hook # NIL THEN w.hook.Focus(TRUE) END
| USER32.WMKillFocus:
w := ThisWindow(wnd);
IF debug THEN
Log.String("Dlg: KillFocus ");
Log.IntForm(SYSTEM.VAL(INTEGER, w), 16, 8, "0", FALSE);
Log.Char(" ");
Log.IntForm(SYSTEM.VAL(INTEGER, fWindow), 16, 8, "0", FALSE);
IF inPlace IN w.flags THEN Log.String(" ip") END;
IF Windows.isTool IN w.flags THEN Log.String(" tool") END;
Log.Ln
END;
IF ~(inPlace IN w.flags) THEN Kernel.Try(DeactivateWin, wnd, wParam, lParam) END;
IF w.hook # NIL THEN w.hook.Focus(FALSE) END
| USER32.WMSize:
w := ThisWindow(wnd);
Kernel.Try(SizeWin, wnd, lParam MOD 65536 + w.dw, lParam DIV 65536 + w.dh)
| USER32.WMHScroll:
Kernel.Try(ScrollWin, wnd, wParam, 0);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMVScroll:
Kernel.Try(ScrollWin, wnd, wParam, 1);
Controllers.ResetCurrentPath();
RETURN 0
| 020AH: (* WM_MOUSEWHEEL *)
Kernel.Try(WheelScroll, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMPaint:
w := ThisWindow(wnd);
w.GetSize(dx, dy);
IF (dx # minimized) & (dy # minimized) THEN
(* clip region must be reset to ensure correct ps.paint ! *)
res := GDI32.SelectClipRgn(w.port(HostPorts.Port).dc, 0);
x := USER32.BeginPaint(w.wnd, ps);
Kernel.Try(InvalidateWin, wnd, x, SYSTEM.ADR(ps.paint));
res := USER32.EndPaint(w.wnd, ps);
Kernel.Try(PaintWin, wnd, 0, 0);
(* Alexander Iljin: we MUST return 0 and, before that, reset path *)
Controllers.ResetCurrentPath();
RETURN 0
END
| USER32.WMLButtonDown, USER32.WMRButtonDown, USER32.WMMButtonDown:
res := USER32.SetCapture(wnd);
Kernel.Try(HandleMouse, wnd, wParam + 256, lParam);
IF USER32.GetCapture() = wnd THEN res := USER32.ReleaseCapture() END;
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMLButtonDblClk, USER32.WMRButtonDblClk, USER32.WMMButtonDblClk:
res := USER32.SetCapture(wnd);
Kernel.Try(HandleMouse, wnd, wParam + (128 + 256), lParam);
IF USER32.GetCapture() = wnd THEN res := USER32.ReleaseCapture() END;
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMLButtonUp, USER32.WMRButtonUp, USER32.WMMButtonUp:
Kernel.Try(HandleMouse, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMMouseMove:
Kernel.Try(HandleMouse, wnd, wParam + (2 * 256), lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMKeyDown:
Kernel.Try(HandleKey, wnd, wParam, lParam)
| USER32.WMChar, USER32.WMSysChar:
Kernel.Try(HandleChar, wnd, wParam, lParam);
Controllers.ResetCurrentPath();
RETURN 0
| USER32.WMActivate:
w := ThisWindow(wnd);
IF w.hook # NIL THEN w.hook.Activate(wParam # 0) END
| USER32.WMNCPaint, USER32.WMNCActivate:
IF FramePaint # NIL THEN
Controllers.ResetCurrentPath();
RETURN FramePaint(wnd, message, wParam, lParam)
END
ELSE
END;
Controllers.ResetCurrentPath();
RETURN USER32.DefWindowProcA(wnd, message, wParam, lParam)
END DialogHandler;
(** clipboard handling **)
PROCEDURE OpenClipboard* (doc: Documents.Document);
BEGIN
NEW(cbViewer);
dir.Open(cbViewer, doc, {Windows.neverDirty}, "Clipboard", NIL, "", NIL)
END OpenClipboard;
(*
PROCEDURE SizeClipboard* (wnd: USER32.Handle; w, h: LONGINT);
VAR res: LONGINT; dc: USER32.Handle;
BEGIN
cbViewer.wnd := wnd;
dc := USER32.GetDC(wnd);
cbViewer.port(HostPorts.Port).SetDC(dc, wnd);
(*
res := USER32.ShowScrollBar(wnd, USER32.SBHorz, 1);
res := USER32.SetScrollRange(wnd, USER32.SBHorz, 0, scrollRange, 1);
res := USER32.ShowScrollBar(wnd, USER32.SBVert, 1);
res := USER32.SetScrollRange(wnd, USER32.SBVert, 0, scrollRange, 1);
*)
Kernel.Try(SizeWin, wnd, w, h);
(*
cbViewer.UpdateScrollbars(FALSE);
*)
res := USER32.ReleaseDC(wnd, dc);
END SizeClipboard;
PROCEDURE PaintClipboard* (wnd: USER32.Handle; VAR ps: USER32.PaintStruct);
VAR res: LONGINT; dc: USER32.Handle;
BEGIN
cbViewer.wnd := wnd;
res := GDI32.SelectClipRgn(ps.dc, 0);
Kernel.Try(InvalidateWin, wnd, ps.dc, ADR(ps.paint));
Kernel.Try(PaintWin, wnd, 0, 0)
END PaintClipboard;
PROCEDURE ScrollClipboard* (wnd: USER32.Handle; code, pos: LONGINT; vertical: BOOLEAN);
VAR res: LONGINT; dc: USER32.Handle;
BEGIN
cbViewer.wnd := wnd;
(*
dc := USER32.GetDC(wnd);
cbViewer.port(HostPorts.Port).SetDC(dc, wnd);
cbViewer.Scroll(code, pos, vertical);
cbViewer.SetSize(cbViewer.port.w, cbViewer.port.h);
cbViewer.UpdateScrollbars(FALSE);
res := USER32.ReleaseDC(wnd, dc)
*)
END ScrollClipboard;
*)
(** miscellaneous **)
PROCEDURE UpdateInfo;
VAR res: INTEGER; str: ARRAY 256 OF CHAR; sstr: ARRAY 256 OF SHORTCHAR;
BEGIN
IF memInStatus & ((alloc # Kernel.Allocated()) (* OR (total # Kernel.Used()) *) ) THEN
alloc := Kernel.Allocated(); total := Kernel.Used();
str := allocStr$; AppendInt(str, alloc, useSeparators); Append(str, byteStr);
(*
Append(str, totalStr); AppendInt(str, total, useSeparators); Append(str, byteStr);
*)
sstr := SHORT(str$);
res := USER32.SetWindowTextA(info, sstr)
END
END UpdateInfo;
(*
PROCEDURE Check;
VAR i: INTEGER; s: SET; obj: Kernel.Object;
BEGIN
IF Documents.dispMsgHeight = 0 THEN
IF actMod = NIL THEN actMod := Kernel.modList END;
IF actMod.refcnt >= 0 THEN
obj := Kernel.ThisObject(actMod, "~");
s := BITS(actMod.csize);
i := ORD(s / SYSTEM.ROT(s, 7) / SYSTEM.ROT(s, -8));
IF (obj = NIL) OR (obj.fprint # i) OR (obj.offs # ADR(obj^)) THEN
SYSTEM.PUT(ADR(Documents.dispMsgHeight), (* LONG( *)(* LONG( *)1)
END
END;
actMod := actMod.next
END
END Check;
*)
PROCEDURE SetVisualScroll* (do: BOOLEAN);
BEGIN
IF visualScroll # do THEN
visualScroll := do;
HostRegistry.WriteBool("VisualScroll", do)
END
END SetVisualScroll;
PROCEDURE Idle*;
VAR w: Window; tick: Controllers.TickMsg; focus: BOOLEAN;
BEGIN
w := dir.Focus(FALSE);
IF (w # NIL) & ~w.trapped THEN
w.trapped := TRUE;
IF w.frame # NIL THEN
tick.tick := KERNEL32.GetTickCount();
w.ForwardCtrlMsg(tick)
END;
w.trapped := FALSE
END;
focus := ScrollModPressed(); w := dir.First();
WHILE w # NIL DO
IF ~w.trapped THEN
w.trapped := TRUE;
w.UpdateScrollbars(focus & (w = fWindow));
w.trapped := FALSE
END;
w := dir.Next(w)
END;
IF ~idleTraped THEN
idleTraped := TRUE;
IF USER32.GetAsyncKeyState(1) >= 0 THEN activating := FALSE END;
IF USER32.GetAsyncKeyState(2) >= 0 THEN activating := FALSE END;
UpdateInfo;
(*
Check;
*)
idleTraped := FALSE
END;
Services.actionHook.Step
END Idle;
PROCEDURE ActivateMain* (do: BOOLEAN);
BEGIN
mainActive := do
END ActivateMain;
PROCEDURE ResizeMainWindow* (type, w, h: INTEGER);
VAR res, m: INTEGER;
BEGIN
m := w DIV 2;
mainW := w - lBorder - rBorder;
mainH := h - tBorder - bBorder;
IF Dialog.showsStatus THEN DEC(mainH, statusH) END;
(*
res := USER32.DefFrameProcA(main, client, USER32.WMSize, type, mainW + mainH * 65536);
*)
IF debug THEN Log.String("resize main window"); Log.Ln END;
res := USER32.MoveWindow(client, lBorder, tBorder, mainW, mainH, 1);
IF Dialog.showsStatus THEN
IF memInStatus THEN
res := USER32.MoveWindow(status, 0, h - statusH, m + 1, statusH, 1);
res := USER32.MoveWindow(info, m, h - statusH, w - m, statusH, 1);
res := USER32.ShowWindow(info, 1)
ELSE
res := USER32.MoveWindow(status, 0, h - statusH, w, statusH, 1);
res := USER32.ShowWindow(info, 0)
END;
res := USER32.ShowWindow(status, 1)
ELSE
res := USER32.ShowWindow(status, 0);
res := USER32.ShowWindow(info, 0)
END
END ResizeMainWindow;
PROCEDURE SetMainBorderWidth* (l, t, r, b: INTEGER);
VAR res: INTEGER; rect: USER32.Rect;
BEGIN
lBorder := l; tBorder := t; rBorder := r; bBorder := b;
res := USER32.GetClientRect(main, rect);
ResizeMainWindow(0, rect.right, rect.bottom)
END SetMainBorderWidth;
PROCEDURE GetMainBorder* (VAR l, t, r, b: INTEGER);
VAR res: INTEGER; rect: USER32.Rect;
BEGIN
res := USER32.GetClientRect(main, rect);
l := 0; t := 0; r := rect.right; b := rect.bottom;
IF Dialog.showsStatus THEN DEC(b, statusH) END
END GetMainBorder;
PROCEDURE SaveWindowState*;
VAR res: INTEGER; wp: USER32.WindowPlacement; list: ARRAY 10 OF INTEGER;
BEGIN
IF ~fullSize THEN
wp.len := SIZE(USER32.WindowPlacement);
res := USER32.GetWindowPlacement(main, wp);
IF res # 0 THEN
list[0] := wp.normPos.left;
list[1] := wp.normPos.top;
list[2] := wp.normPos.right;
list[3] := wp.normPos.bottom;
list[4] := wp.minPos.x;
list[5] := wp.minPos.y;
list[6] := wp.maxPos.x;
list[7] := wp.maxPos.y;
list[8] := wp.showCmd;
IF 1 IN wp.flags THEN list[9] := 1 ELSE list[9] := 0 END;
HostRegistry.WriteIntList("MainWindow", list)
ELSE
res := KERNEL32.GetLastError(); HALT(120)
END
END
END SaveWindowState;
PROCEDURE LoadWindowState ();
VAR res: INTEGER; wp: USER32.WindowPlacement; list: ARRAY 10 OF INTEGER;
si: KERNEL32.StartupInfo; rect: WinApi.RECT;
BEGIN
list[8] := 0; list[9] := 0;
IF fullSize THEN
wp.len := SIZE(USER32.WindowPlacement);
wp.flags := WinApi.WPF_SETMINPOSITION + WinApi.WPF_RESTORETOMAXIMIZED;
res := WinApi.SystemParametersInfo(WinApi.SPI_GETWORKAREA, 0, SYSTEM.ADR(rect), 0);
wp.normPos.left := rect.left;
wp.normPos.top := rect.top;
wp.normPos.right := rect.right;
wp.normPos.bottom := rect.bottom;
wp.minPos.x := rect.left;
wp.minPos.y := rect.top;
wp.maxPos.x := rect.left;
wp.maxPos.y := rect.top;
wp.showCmd := USER32.SWHide;
showState := WinApi.SW_SHOW;
res := USER32.SetWindowPlacement(main, wp)
ELSE
HostRegistry.ReadIntList("MainWindow", list, res);
IF res = 0 THEN
wp.len := SIZE(USER32.WindowPlacement);
wp.flags := {0}; (* set min pos *)
wp.normPos.left := list[0];
wp.normPos.top := list[1];
wp.normPos.right := list[2];
wp.normPos.bottom := list[3];
wp.minPos.x := list[4];
wp.minPos.y := list[5];
IF list[8] = 0 THEN (* v1.0..v1.1 *)
wp.showCmd := list[6];
wp.maxPos.x := -1;
wp.maxPos.y := -1
ELSE (* v1.11.. *)
wp.maxPos.x := list[6];
wp.maxPos.y := list[7];
wp.showCmd := list[8];
IF list[9] > 0 THEN INCL(wp.flags, 1) END (* restore maximized *)
END;
si.size := SIZE(KERNEL32.StartupInfo);
KERNEL32.GetStartupInfoA(si);
IF 0 IN si.flags THEN (* showWindow valid *)
IF si.showWindow > 1 THEN wp.showCmd := si.showWindow
ELSIF wp.showCmd = 2 THEN (* restore minimized *)
IF 1 IN wp.flags THEN wp.showCmd := 3 ELSE wp.showCmd := 9 END
END
END;
showState := wp.showCmd; wp.showCmd := USER32.SWHide;
res := USER32.SetWindowPlacement(main, wp)
END
END
END LoadWindowState;
PROCEDURE CreateMainWindows* (menuBar, winMenu: USER32.Handle; Handler: USER32.WndProc);
VAR res: INTEGER; class: USER32.WndClass; ccs: USER32.ClientCreateStruct;
dc: USER32.Handle; tm: GDI32.TextMetric; str: ARRAY 256 OF CHAR; ver: ARRAY 8 OF CHAR;
sstr: ARRAY 64 OF SHORTCHAR;
BEGIN
(* init window classes *)
class.cursor := USER32.LoadCursorA(0, USER32.MakeIntRsrc(USER32.IDCArrow));
class.icon := USER32.LoadIconA(instance, USER32.MakeIntRsrc(1));
IF (class.icon = 0) OR (class.icon = 1) THEN
class.icon := USER32.LoadIconA(0, USER32.MakeIntRsrc(USER32.IDIApplication))
END;
class.menuName := NIL;
class.className := "Oberon App";
class.backgnd := 0; (* 12 + 1; *) (* application workspace color *)
class.style := {3, 5}; (* doubleclicks, privat dc *)
class.instance := instance;
class.wndProc := Handler;
class.clsExtra := 0;
class.wndExtra := 4;
USER32.RegisterClassA(class);
class.cursor := 0; (* no class cursor *)
class.menuName := NIL;
class.backgnd := 0; (* no background *)
class.className := "Oberon Dlg";
class.wndProc := DialogHandler;
USER32.RegisterClassA(class);
class.className := "Oberon Aux";
class.wndProc := DocWinHandler;
USER32.RegisterClassA(class);
docIcon := USER32.LoadIconA(instance, USER32.MakeIntRsrc(2));
IF (docIcon = 0) OR (docIcon = 1) THEN
docIcon := USER32.LoadIconA(0, USER32.MakeIntRsrc(USER32.IDIApplication))
END;
dirtyIcon := USER32.LoadIconA(instance, USER32.MakeIntRsrc(5));
IF (dirtyIcon = 0) OR (dirtyIcon = 1) THEN dirtyIcon := docIcon END;
class.icon := docIcon;
class.className := "Oberon Doc";
class.wndProc := DocWinHandler;
USER32.RegisterClassA(class);
(* open main windows *)
sstr := SHORT(Dialog.appName$);
IF fullScreen THEN
main := USER32.CreateWindowExA({8, 9}, "Oberon App", sstr, WinApi.WS_SYSMENU + WinApi.WS_MINIMIZEBOX + WinApi.WS_POPUP,
0, 0, USER32.GetSystemMetrics(WinApi.SM_CXFULLSCREEN),
USER32.GetSystemMetrics(WinApi.SM_CYFULLSCREEN),
0, menuBar, instance, 0);
ELSIF ~fullSize THEN
main := USER32.CreateWindowExA({8, 9}, "Oberon App", sstr,
{16..19, 22, 23}, (* maxbox, minbox, frame, sysmenu, title, border *)
USER32.CWUseDefault, USER32.CWUseDefault,
USER32.CWUseDefault, USER32.CWUseDefault,
0, menuBar, instance, 0)
ELSE
main := USER32.CreateWindowExA({8, 9}, "Oberon App", sstr,
WinApi.WS_MINIMIZEBOX + WinApi.WS_SYSMENU + WinApi.WS_CAPTION,
USER32.CWUseDefault, USER32.CWUseDefault,
USER32.CWUseDefault, USER32.CWUseDefault,
0, menuBar, instance, 0)
END;
ccs.windowMenu := winMenu;
ccs.firstChild := 10000;
IF noClientScroll THEN
client := USER32.CreateWindowExA({}, "MDICLIENT", NIL,
{25, 30}, (* clipchildren, child *)
0, 0, 0, 0,
main, 32767, instance, SYSTEM.ADR(ccs))
ELSE
client := USER32.CreateWindowExA({}, "MDICLIENT", NIL,
{20, 21, 25, 30}, (* scroll, clipchildren, child *)
0, 0, 0, 0,
main, 32767, instance, SYSTEM.ADR(ccs))
END;
status := USER32.CreateWindowExA({}, "STATIC", NIL,
{7, 23, 30}, (* left, noprefix, border, child *)
0, 0, 0, 0,
main, 32766, instance, 0);
info := USER32.CreateWindowExA({}, "STATIC", NIL,
{7, 23, 30}, (* left, noprefix, border, child *)
0, 0, 0, 0,
main, 32765, instance, 0);
res := USER32.SendMessageA(status, USER32.WMSetFont, font, 1);
res := USER32.SendMessageA(info, USER32.WMSetFont, font, 1);
dc := USER32.GetDC(status);
res := GDI32.GetTextMetricsA(dc, tm);
res := USER32.ReleaseDC(status, dc);
statusH := tm.height;
showState := USER32.SWShow;
LoadWindowState();
res := USER32.ShowWindow(client, 1);
IF Dialog.showsStatus THEN
res := USER32.ShowWindow(status, 1);
IF memInStatus THEN
res := USER32.ShowWindow(info, 1)
END
END;
(* moved to HostMenus
res := USER32.ShowWindow(main, USER32.SWShow);
res := USER32.UpdateWindow(main);
*)
HostFiles.main := main;
dc := USER32.GetDC(main);
unit := Ports.inch DIV GDI32.GetDeviceCaps(dc, GDI32.LogPixelsY);
res := USER32.ReleaseDC(main, dc);
Dialog.MapString(allocKey, allocStr);
Dialog.MapString(totalKey, totalStr);
Dialog.MapString(byteKey, byteStr);
IF Dialog.appName = "BlackBox" THEN
str := Dialog.appName$;
ver := " x.y";
ver[1] := CHR(Dialog.version DIV 10 + ORD("0"));
ver[3] := CHR(Dialog.version MOD 10 + ORD("0"));
Append(str, ver);
Dialog.ShowStatus(str)
END;
HostMechanisms.InstallDropTarget(client, NIL)
END CreateMainWindows;
PROCEDURE Init;
VAR res, v: INTEGER; d: Directory; dc, user: USER32.Handle;
Register: PROCEDURE(i: USER32.Handle): INTEGER; p: KERNEL32.StringPtr;
BEGIN
instance := KERNEL32.GetModuleHandleA(NIL);
dc := USER32.GetDC(0);
unit := Ports.inch DIV GDI32.GetDeviceCaps(dc, GDI32.LogPixelsY);
res := USER32.ReleaseDC(0, dc);
scW := USER32.GetSystemMetrics(0); (* screen width *)
scH := USER32.GetSystemMetrics(1); (* screen height *)
NEW(d); d.l := -1; d.t := -1; d.r := -1; d.b := -1; dir := d; Windows.SetDir(d);
NEW(winAnchor); winAnchor.next := NIL; (* dummy header *)
tWindow := NIL; fWindow := NIL; aWindow := NIL; bgWindow := NIL;
noClientScroll := FALSE; fullSize := FALSE; noAppWin := FALSE;
whiteBrush := GDI32.GetStockObject(GDI32.WhiteBrush);
nullPen := GDI32.GetStockObject(GDI32.NullPen);
font := GDI32.GetStockObject(GDI32.AnsiVarFont);
cbValid := FALSE; newNumber := 1;
visualScroll := TRUE; HostRegistry.ReadBool("VisualScroll", visualScroll, res);
v := KERNEL32.GetVersion();
v := v MOD 256 * 100 + v DIV 256 MOD 256;
IF v < 400 THEN
res := KERNEL32.SearchPathA(NIL, "CTL3D32.DLL", NIL, 0, NIL, p);
IF res > 0 THEN (* CTL3D32 available, avoids error dialog in LoadLibrary on Win32s *)
ctl3d := KERNEL32.LoadLibraryA("CTL3D32");
IF ctl3d # 0 THEN
SYSTEM.PUT(SYSTEM.ADR(Register), KERNEL32.GetProcAddress(ctl3d, "Ctl3dRegister"));
IF Register # NIL THEN
res := Register(instance);
IF res # 0 THEN
SYSTEM.PUT(
SYSTEM.ADR(FramePaint), KERNEL32.GetProcAddress(ctl3d, "Ctl3dDlgFramePaint"))
ELSE ctl3d := 0
END
END
END
END
END;
user := KERNEL32.GetModuleHandleA("USER32");
SYSTEM.PUT(SYSTEM.ADR(GetScrollInfo), KERNEL32.GetProcAddress(user, "GetScrollInfo"));
SYSTEM.PUT(SYSTEM.ADR(SetScrollInfo), KERNEL32.GetProcAddress(user, "SetScrollInfo"))
END Init;
BEGIN
Init
END HostWindows.
| Host/Mod/Windows.odc |
Host/Rsrc/Imptype.odc |
|
Host/Rsrc/Prefs.odc |
|
Host/Rsrc/Printing.odc |
|
Host/Rsrc/Setup.odc |
|
STRINGS
Bottom: Нижнее:
Caret Курсор
Caret Period (in ms): Период курсора (в мсек):
D&efault font... Шрифт по умолчанию...
Di&alog font... Шрифт в диалогах...
&Double Двойная
Layout Вид
Left: Левое:
Margins Поля
&No Отсутствует
Printer... Принтер...
Printing Page: Печатается страница:
Read File As: Читать файл как:
Right: Правое:
&Simple Простая
Standard Header Стандартный заголовок
Status bar Строка состояния
&Thick Caret Толстый курсор
Top: Верхнее:
&Use true type metric Использовать метрику True Type
&Visual scrolling Видимая прокрутка
Shift Shift+
Ctrl Ctrl+
Space Пробел
Edit Правка
Open Открыть
MoveHere Переместить сюда
CopyHere Копировать сюда
LinkHere Создать ярлык сюда
Object Объект
MissingDirectory Каталог не найден
CreateDir Будет создан каталог ^0
FileError Файловая ошибка
ReplaceWriteProtected Не могу заменить ^0:^1защита от записи
ReplaceInUse Не могу заменить ^0:^1уже используется
ReplaceAccessDenied Не могу заменить ^0:^1доступ запрещен
AllocatedMemory Выделенная память:
Total Всего:
Bytes байт
Print Печать
OpenFile Открыть файл
ControlInspector Просмотр свойств
SaveChanges Файл ^0 был изменен.^1^2Вы хотите сохранить изменения?
Saving сохраняю
Saved сохранен
Failed ошибка
Document Документ
AllFiles Все файлы
NotUnderWindows3 Недоступно под Windows 3.11
HostTextConv.ImportText Простой текст
HostTextConv.ImportTabText Простой текст (два пробела в таб)
HostTextConv.ImportRichText Текст с форматированием
HostTextConv.ImportUnicode Текст юникод
HostTextConv.ImportHex Файл данных (hex)
HostTextConv.ImportDosText Текст (кодировка Dos)
HostBitmaps.ImportBitmap Картинка (Bitmap)
HostBitmaps.ExportBitmap Bitmap
HostTextConv.ExportText Простой текст
HostTextConv.ExportTabText Простой текст (таб в два пробела)
HostTextConv.ExportRichText Текст с форматированием
HostTextConv.ExportUnicode Текст юникод
HostBitmaps.ExportBitmap Bitmap
HostTextConv.ImportDRichText Текст с форматированием
HostTextConv.ImportDUnicode Текст юникод
HostTextConv.ImportDText Простой текст
HostPictures.ImportDPict Картинка (Metafile)
HostBitmaps.ImportDBitmap Картинка (Bitmap)
HostBitmaps.ImportDPictAsBitmap Картинка (Bitmap)
TextViews.StdView текст
HostPictures.StdView картинка
HostBitmaps.StdView картинка bitmap
Properties.StdProp HostDialog.FontDialog
Bitmaps.Evaluate.101 Недостаточно памяти для размещения bitmap
| Host/Rsrc/Strings.odc |
Справка для учителя
Знакомство
Меню,документы,Рабочийжурнал
Простейшаяпрограмма
Онеанглийскихключевыхсловах
ОтличияотстарогоПаскаля на примере задачи С4, ЕГЭ-2010
Официальные документы: СообщениеоязыкеКомпонентныйПаскаль
ОтличияКомпонентногоПаскаляотстарого
Каккомпиляторсообщаетобошибках
ТРАПы--аварийныеостановки
ПримерырешенийзадачЕГЭ
Справкапоучебномувводу-выводу (включает несколько примеров).
СправкапоЧерепашке
Каксоздатьихранитьпрограмму
Ключевыесловаизпрописныхбукв
Подробнее см. документы: ОбF5вшкольнойверсии
ОбиспользованииклавишиF5дляпечатиключевыхслов
Редактированиеиформатирование
*Оботступах
Орг. вопросы
*Организациякомпьютерногокласса
Организацияработыдома
Задачи и списки задач
Чтохранитсявпапкеi21edu/Заготовки
*Примерзадачи
Подготовказадач
Примерсписказадач
Использованиенеанглийскихключевыхслов
Настройкаменю (это легко и очень полезно: добавить в меню мини-среды, списки задач и т.п.)
Примеры модули из подсистемы i21прим:
*TPGraphics пример рисования в стиле Турбо Паскаля
Трап пример аварийной остановки
ПростыеЧисла несколько процедур на тему простых чисел.
Strings пример с литерными цепочками
Files запись и чтение простых файлов
Random использование генератора случайных чисел
Тетрис сложный пример: движущаяся картинка + взаимодействие с клавиатурой
i21eduТочкиЛинииПример пример с перспективой.
Ещё два старых примера ввода-вывода:
StdLog пример печати в Рабочий журнал.
In пример ввода данных из потока ввода.
Пошаговаяразработка подробное описание шагов (с картинками, указаниями, какие клавиши нажимать, и с проч. подробностями) написания программ на Блэкбоксе.
СозданиепростыхдиалоговвБлэкбоксе
ПримерыизкнигиН.ВиртаАлгоритмы...
Близкое знакомство
Модули и т.п.:
Загрузкаиперезагрузкамодулей технические сведения
Опроцедурахимодулях идеология
ПолезныесведенияоработевБлэкбоксе
КакорганизованадокументациявБлэкбоксе
Штатнаядокументация
Быстроевведениедляпрофессионалов
________________
[email protected]
последние изменения: 2010-10-23 | i21edu/Справка для учителя.odc |
i21eduRandom
DEFINITION i21eduRandom;
PROCEDURE InitSeed (seed: INTEGER);
PROCEDURE Int (n: INTEGER): INTEGER;
PROCEDURE Real (): REAL;
END i21eduRandom.
| i21edu/Docu/Random.odc |
i21eduFiles
DEFINITION i21eduFiles;
IMPORT Files;
CONST
noFileOpen = 0;
reading = 1;
writing = -1;
VAR
eof-: BOOLEAN;
filename-: ARRAY 256 OF CHAR;
mode-: INTEGER;
path-: ARRAY 2000 OF CHAR;
PROCEDURE Close;
PROCEDURE Delete (name: ARRAY OF CHAR);
PROCEDURE New (name: Files.Name);
PROCEDURE Open (name: Files.Name);
PROCEDURE ReadChar (OUT ch: CHAR);
PROCEDURE ReadInt (OUT n: INTEGER);
PROCEDURE ReadReal (OUT r: REAL);
PROCEDURE ReadSChar (OUT ch: SHORTCHAR);
PROCEDURE ReadString (OUT a: ARRAY OF CHAR);
PROCEDURE SetFolder (p: ARRAY OF CHAR);
PROCEDURE WriteChar (ch: CHAR);
PROCEDURE WriteInt (n: INTEGER);
PROCEDURE WriteReal (r: REAL);
PROCEDURE WriteSChar (ch: SHORTCHAR);
PROCEDURE WriteString (a: ARRAY OF CHAR);
END i21eduFiles.
Экспериментальный модуль для школьных курсов, предназначен в первую очередь для иллюстрации файлового ввода-вывода как такового.
Для ввода-вывода данных в других задачах гораздо удобнее делать ввод-вывод прямо из открытых текстовых документов. См. об этом Тексткакинтерфейс.
На данный момент модуль допускает только один открытый файл, причём чтение-запись идут чисто последовательно, то есть нельзя явно указать позицию, с которой нужно продолжать чтение или запись. Нельзя также и смешивать операции чтения и записи нельзя. Эти ограничения нетрудно ослабить, если опыт покажет, что это нужно.
Данные читаются-записываются в двоичном формате. Политерное чтение возможно, и на этой основе можно запрограммировать сканирование текстового файла на предмет распознавания чисел и т.п. неплохое упражнение для профильных курсов.
По умолчанию файлы помещаются в рабочую папку, если Блэкбокс вызван в рабочей папке в серверном режиме, или в основную папку ББ если ББ был запущен двойным кликом по BlackBox.exe. Процедура SetFolder позволяет изменить текущую папку, с которой в данный момент работает модуль.
Так как ввод-вывод здесь двоичный, то в процедурах этого модуля имена файлов всегда задаются полностью, с расширением. То есть от себя модуль расширения не добавляет (как это делается в командах Блэкбокса, предназначенных для работы с документами в формате Блэкбокса).
Пример использования средств модуля: i21eduFilesTest
CONST noFileOpen, reading, writing
Возможные значения переменной mode, соответствуют режимам: открытого файла нет; производится чтение файла; производится запись в файл.
VAR eof-: BOOLEAN
Эта логическая переменная сообщает, достигнут ли при попытке чтения конец файла (eof = end of file). Все операции чтения (Read***) устанавливают это значение.
VAR filename-: ARRAY 256 OF CHAR
Имя (с расширением), открытого в данный момент файла.
Значение равно пустой цепочке литер (''), если открытого файла нет.
VAR mode-: INTEGER
Режим работы с открытым файлом. Возможные значения константы noFileOpen, reading, writing.
VAR path-: ARRAY 2000 OF CHAR
Путь до текущей папки, с которой в данный момент работает модуль. Путь может быть относительным (относительно основной папки ББ или рабочей папки, если ББ запущен в серверном режиме) или абсолютным.
PROCEDURE Close
Закрывает открытый файл, если таковой имеется.
Только после явного закрытия файла можно открыть новый.
PROCEDURE Delete (name: ARRAY OF CHAR)
Удаляет файл с указанным именем из текущей папки, если таковой там есть.
PROCEDURE New (name: Files.Name)
Открывает для записи новый файл с указанным именем в текущей папке.
Если файл с таким именем там уже есть, то в рабочий журнал печатается сообщение и ничего больше не происходит.
Если файл создается в новой, еще пустой папке, то откроется диалог, требующий подтверждения создания новой папки.
PROCEDURE Open (name: Files.Name)
Открывается для чтения файл с указанным именем, существующий в текущей папке.
Если такого файла нет, то в Рабочий журнал печатается сообщение и ничего больше не происходит.
PROCEDURE ReadChar (OUT ch: CHAR)
Из открытого файла в литерную переменную ch читается очередная литера (Unicode).
PROCEDURE ReadInt (OUT n: INTEGER);
Из открытого файла в целую переменную n читается очередное целое (в файле 4 байта).
PROCEDURE ReadReal (OUT r: REAL)
Из открытого файла в вещественную переменную r читается очередное вещественное число (в файле 8 байтов).
PROCEDURE ReadSChar (OUT ch: SHORTCHAR)
Из открытого файла в короткую (однобайтную) литерную переменную ch читается очередная однобайтная литера.
PROCEDURE ReadString (OUT a: ARRAY OF CHAR);
Из открытого файла в массив литер a считывается очередная цепочка литер; конец цепочки указывается нулевой литерой, которая в Обероне/Компонентном Паскале обозначается как 0X.
Длину прочитанной цепочки (то есть количество литер до 0X) можно определить с помощью конструкции LEN(a$), где LEN встроенная в язык целочисленная функция, а вместо a может стоять имя любого литерного массива; без значка $ функция выдаст длину самого массива.
Если массив a недостаточно велик, чтобы поместилась цепочка вместе с терминальной литерой 0X, то случится аварийная остановка Трап.
PROCEDURE SetFolder (p: ARRAY OF CHAR)
Устанавливает новую текущую папку, в которой модуль будет производить операции с файлами.
Если папки по указанному адресу нет, она автоматически создастся при создании там файла; при этом появится диалог, требующий подтверждения создания новой папки.
PROCEDURE WriteChar (ch: CHAR);
В очередную позицию открытого файла пишется литера ch (два байта).
PROCEDURE WriteInt (n: INTEGER);
В очередную позицию открытого файла пишется целое n (4 байта).
PROCEDURE WriteReal (r: REAL);
В очередную позицию открытого файла пишется вещественное число r (8 байт).
PROCEDURE WriteSChar (ch: SHORTCHAR);
В очередную позицию открытого файла пишется однобайтная литера ch.
PROCEDURE WriteString (a: ARRAY OF CHAR);
В очередную позицию открытого файла пишется цепочка двухбайтных литер из массива a, заканчивающаяся терминальной литерой 0X.
_______________
[email protected]
2010-09-28 | i21edu/Docu/ru/Files.odc |