Editing QuickDraw GX (section)

==Description==
===Graphics===
QuickDraw GX is based on an [[object oriented]] model in which graphics objects are aware of and responsible for their own state. Unlike QuickDraw, there is no universal "state", every drawing command can re-construct the state from data stored within it, or various "parent" objects. For instance, a programmer could build a <code>redBox</code> object that first sets the color to red, and then draws a square. From that point on the program no longer has to explicitly set the color before drawing, the GX system itself will always correctly set the drawing color when asked to draw a <code>redBox</code>, and reset it when finished. Since this state was private, and sent to GX if and when needed, GX theoretically allowed the Mac OS to support protected memory, as state was no longer shared directly between the programs and graphics system.

This contrasts strongly with the original QuickDraw, where the programmer was responsible for all state changes. For instance, if one were to draw a redBox and then a series of lines, the lines would also appear in red unless the programmer explicitly changed the color first. The advantage to this approach is that it minimizes the number of commands needed to set state; the programmer can organize drawing to draw groups of similarly styled objects at the same time and thereby save time. The disadvantage of this approach is that it is easy to "forget" to change state and end up causing problems, so easy that programmers often saved and restored the complete state before every drawing command, thereby potentially ''lowering'' performance.

The drawing state under GX was hierarchical. A default drawing mode was created with every window, as it was under QD, and drawing objects with no other state changes would use these defaults. The programmer could then change state in the objects themselves, as in our <code>redBox</code> example, or alternately change the state of all drawing by setting the state in the window object. GX objects could be easily collected into groups, themselves objects, allowing the state to be set for an entire complex object.

One part of the overall drawing state was the <code>gxMapping</code>. This was a 3-by-3 [[matrix (mathematics)|matrix]] which could express arbitrary [[linear transformation]]s in two dimensions, including [[perspective (graphical)|perspective]] distortions. All GX objects had an associated mapping as part of its drawing state, which allowed for things like rotations and translations. Although all of this state was held in the <code>gxMapping</code> for that object, GX also provided "wrapper" commands like "rotate" to make the [[API]] simpler to use.

Unlike QuickDraw, QuickDraw GX allowed for fractional coordinates. However, these were [[fixed point arithmetic|fixed-point]] values, rather than [[floating point|floating-point]]. At the time GX was being developed (late 1980s to early 1990s), there was still a significant performance penalty in using floating-point arithmetic.

The GX graphics architecture was built around a number of types of objects which were premade, though a full set of [[API]] calls was available for examining and manipulating them:
* a '''gxShape''' defined the basic geometry of a shape (for example, coordinates of control points for a curve, or the text content of a text object).
* a '''gxStyle''' defined elaborations of the basic shape geometry, such as line thickness, cap and join styles, fill pattern and text font.
* a '''gxInk''' specified how pixel values were to be computed when rendering the shape: besides specifying a basic color for the shape, this also included an elaborate ''transfer mode'' structure that could define a wide variety of functions of the initial and final destination pixel value.
* a '''gxFont''' represented a font, either one installed for systemwide use, or one installed on-the-fly by the current application for its own use. API calls allowed the interrogation of the properties of a font, including the determination of what encodings (Unicode, language-specific etc.) it might support.
* a '''gxProfile''' was a representation of a ColorSync color profile, used as part of the specification of a color for drawing. GX integrated full support for color matching at all stages of the drawing process, as well as support for non-RGB color specifications (such as [[HSV color space|HSV]], [[YUV]] and [[International Commission on Illumination|CIE]] XYZ).
* a '''gxTransform''' determined the relationship between the shape and the display device. Besides the [[Clipping path]] and the gxMapping that transformed the shape before displaying on the output device, this object also specified [[hit-testing]] information that controlled responses to user clicks within the area of the shape.
* a '''gxViewDevice''' represented a block of pixel memory into which drawing would be rendered. This could be an actual on-screen display, or an offscreen block of memory. GX supported all the [[QuickDraw]] pixel layouts; this allowed both a GX view device and a QuickDraw GrafPort to point to the same pixels, thereby allowing applications to mix both sets of drawing calls.
* a '''gxViewPort''' was a logical destination for drawing. A gxTransform could specify a list of more than one of these; the shape would be drawn into all of them in a single <code>GXDrawShape</code> call.
* a '''gxViewGroup''' represented the connection between view devices and view ports. Each view port had a gxMapping specifying its relationship to the global coordinate system of the view group; and each view device had a gxMapping that specified its location and the size of its pixels with regard to view group coordinates. There was a single predefined view group which contained all on-screen view devices (and whose view ports effectively corresponded to on-screen windows); applications were free to create their own view groups for off-screen view devices and view ports.
* a '''gxTag''' allowed the attachment of arbitrary application-defined information to most of the above object types. Each tag had an [[OSType]] type code, but there could be multiple tags of the same type attached to the same object.

====Shape types====
GX shapes could be of various types:
* a straight line defined by its end points.
* a rectangle defined by its left, right, upper and lower bounds.
* a polygon defined by a sequence of vertex coordinates.
* a ''curve'' shape was a single quadratic [[Bézier curve]] defined by three control points.
* a ''path'' shape which was a sequence of quadratic [[Bézier curve]]s. Each control point had an associated flag indicating whether it was "on-curve" or "off-curve". An on-curve point was a Bézier endpoint, while an off-curve point was a Bézier midpoint. If two successive off-curve points were encountered, then an implicit on-curve point was assumed to lie halfway between them. Two successive on-curve points defined a straight-line segment.
* a ''bitmap'' shape contained raster data in any of the supported pixel formats.
* a ''picture'' shape was a grouping of other shapes (possibly including recursive picture shapes), with the option of specifying additional transformations applying to the whole group.
* the various types of ''typographic'' shapes are described in the GX Typography section below.
* additional types which were perhaps not directly useful for drawing, but could be combined with other shapes in geometry calculations: the ''empty'' shape (drawing of which did nothing); the ''point'' shape consisting of a single point; and the ''full'' shape (of infinite extent).

===Typography===
{{see also|Apple Advanced Typography}}
The typography features of GX were integrated in the form of 3 types of gxShape:
* ''Text shapes'' were the simplest: these contained a single run of text rendered in a single font style.
* ''Glyph shapes'' were a way to use character shapes ("[[glyphs]]") as pure geometry, for instance as [[Clipping path]]s.
* ''Layout shapes'' were the most elaborate. These could be divided into multiple runs with different font styles, even different language encodings and text directions. Thus, it was possible to embed a sequence of Arabic text, rendered right-to-left, within an outer sequence of left-to-right Roman text. Layout shapes unleashed the full power of contextual substitutions, kerning, variations and all the other capabilities of TrueType GX fonts. Their main restriction was that they were confined to a single line of text.

The GX API also provided hit-testing functions, so that for example if the user clicked on a layout shape in the middle of a [[ligature (typography)|ligature]], or in the region between a change of text direction, GX itself would provide the smarts to determine which character position in the original text corresponded to the click.

=== TrueType GX ===
An important distinction in GX was drawn between a '''character''' and a '''glyph''', a distinction also found in the Unicode Standard. A ''character'' was an abstract symbol from the character set of a writing system, such as the letter "f" in the writing systems of the Latin script. Whereas a ''glyph'' was a specific graphic shape from a particular font, whether the shape represented a single character or a set of characters. Thus, for example, the Hoefler Text font had glyphs to represent the letters "f" and "l". It also had another glyph to represent the ligature {{not a typo|"ﬂ"}}, which could be automatically composed (instead of the individual glyphs) wherever the two abstract characters "f" and "l" occurred in sequence in the source text.

This distinction was important in that such contextual substitutions occurred at rendering time, without any changes to the source character string. Thus they had no impact on editing or searching of the text. PostScript Type 1 font files have one to one mapping only, and as ligatures are many to one mappings, they can not be inserted into the composition without changing the source character string, for instance, the ligature ffi is placed at the position of capital Y in Adobe font products, and "Adobe Offices" is composed by typing "Adobe O" <change font> "Y" <change font> "ces". In the layout the character string is broken, and in PDF made from streamed PostScript the characters f+f+i can only be reconstructed, if the name of the glyph follows a glyph naming list.

Contextual substitutions can be controlled by enabling or disabling the composition options of a TrueType GX font in WorldText on the Mac OS 9 CD or in TextEdit in Mac OS X. Fonts commonly have features called "common ligatures" (such as the "fl" example), "rare ligatures" (such as inscriptional ME and MD ligatures), "archaic non-terminal s" (for automatically substituting the letter "s" with the [[long s|archaic form]] that looked more like an "f", except at the ends of words), and even choices between entirely separate sets of glyph designs, such as more and less ornate forms.

The rules for performing contextual substitutions are implemented as [[state machine]]s built into the font, and interpreted by the LLM Line Layout Manager, the counterpart of the CMM Color Management Module for ColorSync services. Text management in the operating system allowed QuickDraw GX to accept character strings with any mix of writing systems and scripts, and compose the strings automatically, whether the encoding was Unicode 1.0 or 8&nbsp;bit and 8/16&nbsp;bit encodings.

Another interesting feature was font "variations," which were the GX equivalent of Adobe's "[[multiple master fonts|multiple master]]" fonts. Whereas Adobe's fonts required the user explicitly create an "instance" of the font by specifying values for the variation axes before they could use it, GX allowed the user to specify the font directly for a layout style, and then dynamically vary the axis values and immediately observe the effect on the layout of the text.

This technology became the core of what Microsoft and Adobe would adopt in 2016, with its development of [[OpenType variable fonts|OpenType Variable Fonts]].