Power-Programmierung/CD1.mdf/pascal/library/dos/tvision/newed/colors.asc

Text File | 1993-10-31 | 13.2 KB | 300 lines

Turbo Vision Palettes

Objects in Turbo Vision can be grouped into two broad classes: those which are
descendants of TView (such as TWindow or TButton), and those which are not
(such as TCollection). The difference, of course, is that objects which are
descended from TView (also called "views" or "view objects") are intended to
be displayed on the computer's screen at some point in their lifetimes. Every
descendant of TView contains a Draw method, which is executed whenever the
view needs to redraw itself. Although every view's Draw method is different,
they all share one characteristic: they call GetColor to determine what
on-screen colors to use when drawing the various parts of the view.

GetColor in turn calls GetPalette, which returns a pointer to the view's
palette. What is a palette? In Turbo Vision, a palette acts as a translation
table. In much the same way that the ASCII code maps byte values onto
characters, a view's palette maps the set of colors used by the view onto the
palette of the view's owner.

Let's look at the palette of the TLabel view as an example. (It's shown at the
end of the description of TLabel in the Turbo Vision Guide.) We see that the
palette has four entries, numbered 1 through 4. TLabel's Draw method knows
that when it wants to draw normal text, it should use color number 1. But it
doesn't know what color number 1 really is, and it doesn't care. It simply
calls GetColor (1) and uses the color that GetColor returns.

GetColor calls GetPalette, which returns a pointer to TLabel's palette. From
the values contained in the palette, GetColor determines that for TLabel,
color number 1 is equivalent to TLabel's owner's color number 7. GetColor then
calls Owner^.GetColor (7); the owner view then goes through the same
procedure, using its own palette to perform another level of translation, and
so on, until the ultimate owner is reached, which in most Turbo Vision
programs is a TApplication object (or descendant). The TApplication object is
the final color arbiter, and provides all of the views with the actual video
attributes to use.

Let's trace through the TLabel color hierarchy: We've already determined that
TLabel color number 1 maps onto its owner's color number 7. The description of
TLabel's palette in the TV Guide states that TLabel's palette maps onto the
standard dialog palette. This tells us that TLabel objects are intended to be
owned by (i.e., inserted into) TDialog objects. If we now turn to TDialog's
palette description, we see that color number 7 (called "Label Normal") is
mapped onto TDialog's owner's color number 38. Well, dialog boxes are usually
inserted into the desktop, so let's look at TDeskTop's palette. When we do
that, we see that TDeskTop doesn't have a palette; this means that TDeskTop
doesn't do any color translation--TDialog's color number 38 "falls through" to
TDeskTop's owner's palette. Well, the desktop is owned by the application, so
we've reached the end of the chain. When TLabel's Draw method wants to use
color number 1, it eventually gets told to use the application's color number
38.

TApplication's palettes are not shown in the TV Guide, but we can find them in
the file APP.PAS in the TVISION directory. TApplication actually uses one of
three different palettes, depending on whether the program is being run on a
color, black and white, or monochrome monitor. For the purposes of this
example, we'll assume that we're using a color monitor. If we locate the 38th
entry in TApplication's palette, we find that it is equal to $70. The upper
nybble of the byte gives the background color, and the lower nybble the
foreground color, according to the following table:

  0 - black         4 - red           8 - dark gray     C - light red
  1 - blue          5 - magenta       9 - light blue    D - light magenta
  2 - green         6 - brown         A - light green   E - yellow
  3 - cyan          7 - light gray    B - light cyan    F - white

So, we see that a normal label has black text on a light gray background. All
of the other colors may be tracked down in a similar manner.

What happens if rather than inserting a TLabel into a TDialog, we insert it
into a TWindow? Well, let's follow the mapping, again using the "Normal Text"
color: TLabel color number 1 -> TWindow color number 7 -> TApplication color
number 14, 22, or 30, depending on whether the window is a blue, cyan, or gray
window, respectively. These entries correspond to blue text on gray, blue text
on green, or white text on light gray. Obviously, none of these are the same
as the black text on light gray of a TLabel inserted into a TDialog. This
points out a universal truth of Turbo Vision palettes: If a view is designed
to be inserted into a particular type of owner view, inserting it into a
different type of owner will almost always result in a change in color.

Anyone who has played around much with Turbo Vision has encountered the
situation where a view is displayed in flashing white text on a red
background. This happens when a call to GetColor is made with a color number
that exceeds the size of the view's palette. For example, let's see what
happens when we insert a TListBox into a TWindow, rather than a TDialog.
(Note: The TV Guide says that TListBox's palette maps onto the application
palette. This is incorrect; it actually maps onto TDialog's palette.) TListBox
has a five-entry palette which maps onto entries 26 through 29 in its owner's
palette. Well, lo and behold, a TWindow has only eight entries in its
palette--obtaining the 26th entry is impossible. In this situation, GetColor
returns the flashing white on red color to signal the error.

Here is a list of all of the entries in TApplication's palette, along with the
objects that use them:

 1 Background (DeskTop)
 2 Text Normal (Menu)
 3 Text Disabled (Menu)
 4 Text Shortcut (Menu)
 5 Selected Normal (Menu)
 6 Selected Disabled (Menu)
 7 Selected Shortcut (Menu)
 8 Frame Passive (Blue Window)
 9 Frame Active (Blue Window)
10 Frame Icon (Blue Window)
11 ScrollBar Page (Blue Window)
12 ScrollBar Reserved (Blue Window)
13 Scroller Normal Text (Blue Window)
14 Scroller Selected Text (Blue Window)
15 Reserved (Blue Window)
16 Frame Passive (Cyan Window)
17 Frame Active (Cyan Window)
18 Frame Icon (Cyan Window)
19 ScrollBar Page (Cyan Window)
20 ScrollBar Reserved (Cyan Window)
21 Scroller Normal Text (Cyan Window)
22 Scroller Selected Text (Cyan Window)
23 Reserved (Cyan Window)
24 Frame Passive (Gray Window)
25 Frame Active (Gray Window)
26 Frame Icon (Gray Window)
27 ScrollBar Page (Gray Window)
28 ScrollBar Reserved (Gray Window)
29 Scroller Normal Text (Gray Window)
30 Scroller Selected Text (Gray Window)
31 Reserved (Gray Window)
32 Frame Passive (Dialog)
33 Frame Active (Dialog)
34 Frame Icon (Dialog)
35 ScrollBar Page (Dialog)
36 ScrollBar Controls (Dialog)
37 StaticText (Dialog)
38 Label Normal (Dialog)
39 Label Highlight(Dialog)
40 Label Shortcut (Dialog)
41 Button Normal (Dialog)
42 Button Default (Dialog)
43 Button Selected (Dialog)
44 Button Disabled (Dialog)
45 Button Shortcut (Dialog)
46 Button Shadow (Dialog)
47 Cluster Normal (Dialog)
48 Cluster Selected (Dialog)
49 Cluster Shortcut (Dialog)
50 InputLine Normal (Dialog)
51 InputLine Selected (Dialog)
52 InputLine Arrows (Dialog)
53 History Arrow (Dialog)
54 History Sides (Dialog)
55 HistoryWindow ScrollBar page (Dialog)
56 HistoryWindow ScrollBar controls (Dialog)
57 ListViewer Normal (Dialog)
58 ListViewer Focused (Dialog)
59 ListViewer Selected (Dialog)
60 ListViewer Divider (Dialog)
61 InfoPane (Dialog)
62 Reserved (Dialog)
63 Reserved (Dialog)

What about changing colors in Turbo Vision? If all you want to do is change
the color of all instances of an object, say, by making all of your TButtons
cyan instead of green, you've got it easy. You just change the appropriate
entries in TApplication's palette (41 through 46), and you're set.

That was easy. Now, what about creating a new, unique view which is unlike any
predefined Turbo Vision objects? How will we color it? Let's say we want to
insert our new view (call it a TNewView) into a TDialog, and we want to use
two different colors, one for normal text and one for highlighted text. First,
we add two entries to TApplication's palette (numbers 64 and 65) that will
correspond to the two colors used by our new view. For the purposes of this
example, we'll say we want blue on light gray ($71) for normal text and light
green on light gray ($7A) for highlighted text (assuming a color monitor). Our
TApplication palette will now look like this:

  CColor =
        #$71#$70#$78#$74#$20#$28#$24#$17#$1F#$1A#$31#$31#$1E#$71#$00 +
    #$37#$3F#$3A#$13#$13#$3E#$21#$00#$70#$7F#$7A#$13#$13#$70#$7F#$00 +
    #$70#$7F#$7A#$13#$13#$70#$70#$7F#$7E#$20#$2B#$2F#$78#$2E#$70#$30 +
    #$3F#$3E#$1F#$2F#$1A#$20#$72#$31#$31#$30#$2F#$3E#$31#$13#$00#$00 +
    #$71#$7A;  { <- these last two are the new entries }

We must make similar changes in the black & white and monochrome palettes, of
course. Next, since we will be inserting TNewView into a TDialog, we need to
override TDialog's GetPalette method so that it will supply GetColor with the
proper palette:

  const
    CNewDialog = CDialog + #64#65;

  type
    TNewDialog = object (TDialog)
      function GetPalette: PPalette; virtual;
     end;
   .
   .
   .
  function TNewDialog.GetPalette: PPalette;

  const
    P: String[Length (CNewDialog)] = CNewDialog;

  begin
  GetPalette := @P;
  end;

Since we added our two new colors to the end of the standard TDialog palette,
which contains 32 entries, they will be the 33rd and 34th entries in
TNewDialog's palette. Now we have to define our TNewView so that it maps onto
the 33rd and 34th entry of its owner's palette:

  const
    CNewView = #33#34;

  type
    TNewView = object (TView)
      function GetPalette: PPalette; virtual;
       .
      .
      .
      end;

  function TNewView.GetPalette: PPalette;

  const
    P: String[Length (CNewView)] = CNewView;

  begin
  GetPalette := @P;
  end;

There. That wasn't so bad, was it? When TNewView's Draw method asks for color
number 1, it will get color number 64 from TApplication's palette; similarly,
color number 2 leads to TApplication's color number 65. If we ever want to
change the colors of our TNewView object, we simply change the entries in
TApplication's palette.

Okay, let's try something a bit trickier. Let's say we want to insert a view
into an owner which is not of the "correct" type. We already know that unless
we modify the palettes and associated methods, the colors will come out wrong.
The most general solution to the problem is to define a new object type, as in
the previous example. Thus, if we wanted to insert a TButton into a TWindow,
we would define a descendant of TButton (called TWindowButton, perhaps) and
follow the same steps we performed above to give it a set of colors to use.

In some cases, we don't need to add to TApplication's palette. In the previous
example, if all we want to do is put a button in a window, and we want the
button to look just like an ordinary TButton inserted into a TDialog, we can
use the same TApplication palette entries (41 through 46):

  const
    CNewWindow = CGrayWindow + #41#42#43#44#45#46;
    CWindowButton = #9#10#11#12#13#13#13#14;

  type
    TNewWindow = object (TWindow)
      function GetPalette: PPalette; virtual;
     end;

    TWindowButton = object (TButton)
      function GetPalette: PPalette; virtual;
      end;

The GetPalette method code is analogous to that of the previous example. Now,
when TWindowButton.Draw asks for color number 2, it is mapped to TNewWindow's
color number 10, which is mapped to TApplication's color number 42, just as if
it had been a TButton inserted into a TDialog. Note that I used CGrayWindow as
the basis for CNewWindow's palette. Since a TButton is normally inserted into
a TDialog, two of its colors (44 and 46) use a gray background. If you wanted
to put buttons into cyan or blue windows, you would need to use the more
general method of adding to TApplication's palette, as in the previous
example.

Last but not least, what about objects which can be instantiated with one of
several palettes? TWindow is a good example of this type of object; you can
have windows with blue, gray, or cyan color schemes. One of TWindow's fields
(Palette) is used to indicate which color scheme GetPalette should return.
TWindow.GetPalette might look something like this:

  function TWindow.GetPalette: PPalette;

  const
    PGray: string[Length (CGrayWindow)] = CGrayWindow;
    PCyan: string[Length (CCyanWindow)] = CCyanWindow;
    PBlue: string[Length (CBlueWindow)] = CBlueWindow;

  begin
  case Palette of
    wpGrayWindow: GetPalette = @PGray;
    wpCyanWindow: GetPalette = @PCyan;
    wpBlueWindow: GetPalette = @PBlue;
    end;
  end;

You can use the same technique with any objects of your own devising.

Well, that's about it for Turbo Vision palettes. Are you thoroughly confused
yet? Just remember: figuring out what color a view is going to be drawn with
is as simple as tracing the color mapping up the ownership hierarchy, until
you reach the TApplication object.

Please direct comments or suggestions to Steve Schafer [71121,1771].