graphics.txt

书名:C语言科学与艺术,以前交钱下载的

Similarly, it is also usually a simple matter to create a new window on
the screen to use for drawing.  Existing graphics libraries usually have
high-level tools for window creation, so the InitGraphics implementation
need only perform the appropriate set of function calls to create and
position a new window.

The hard part is implementing the conceptual model used by graphics.h,
which is fundamentally different from that used in existing graphics
libraries.  In the typical graphics library supplied with a compiler or
operating system, applications are coded using what is generally called
the event loop strategy.  Each application establishes an initial state
and then enters a loop with the following paradigmatic form:

          void EventLoop(void)
          {
              EventT event;

              while (event = WaitForNextEvent()) {
                  RespondToEvent(event);
              }
          }

Calls to WaitForNextEvent block until a system event occurs, at which
point the operating system delivers the event to the application, which
then initiates some appropriate response.  These events include, for
example, requests to update the window, mouse clicks, and keyboard
activity.

While the event-loop paradigm is appropriate for experienced
programmers, it makes little sense to students in an introductory
course.  Those students are used to writing a function called main that
executes sequentially, one statement at a time.  In the first few weeks
of a CS1 course, it is unwise to introduce a different paradigm.  Thus,
students should be able to code graphical applications that start at the
beginning of main and execute sequentially.  For example, to draw a
one-inch square centered at the point (1, 1), introductory students
expect the program to look like this:

          main()
          {
              InitGraphics();
              MovePen(0.5, 0.5);
              DrawLine(0, 1);
              DrawLine(1, 0);
              DrawLine(0, -1);
              DrawLine(-1, 0);
          }

This code contains no event loop and has no place for one.  Thus, the
challenge of implementing the graphics library is to find a way to hide
the complexity of the event loop processing inside the library
implementation.

Fortunately, this problem is not usually as hard as it appears because
most C programming environments already include a solution as part of
the standard I/O library implementation.  Like the graphics model
assumed by the graphics.h interface, the I/O model assumed by stdio.h is
not directly compatible with the event-loop paradigm.  For an
application that uses stdio.h to work, there must be an event loop
somewhere that intercepts the keyboard events as they occur.  From the
perspective of a client of stdio.h, however, the event loop is
invisible; the program simply calls an input function, such as getchar
or scanf, which eventually returns with the desired input characters.

To preserve the structural simplicity offered by stdio.h,
microcomputer-based implementations of C typically implement the
standard I/O library so that the required event-loop processing is
embedded in the console input routines.[1]  Whenever the program waits
for input from the standard input device, the library implementation
simply enters an event loop, during which it responds to any system
events that occur.  Keyboard input is queued until a complete line can
be returned to the application, but the event loop also processes update
requests, so that the program behaves correctly if windows are
repositioned on the screen.

The fact that the system must already perform the required event-loop
processing makes it easier to implement the graphics library.  In most
cases, all that is needed is to make the existing event loop used for
console I/O also respond to update events for the graphics window.  This
effect can be achieved in a variety of ways, as illustrated by the
following examples:

   o  In the Borland C environment for Microsoft Windows, making the
      graphics window a child of the console window was sufficient
      to solve the problem, because the parent window automatically
      delivers events to its children.

   o  In the THINK C environment on the Macintosh, it was necessary
      to make a dynamic patch to the console event loop so that it
      also called the appropriate update procedures in the graphics
      library.

   o  The X Windows implementation for Unix required a different
      approach.  In this implementation, the function InitGraphics
      calls fork to create two parallel threads, connected by a
      communication pipe.  One of those threads returns to execute
      the application code.  The other enters an event loop waiting
      either for X events that require a response or for commands
      from the application program sent over the communication pipe.

In addition to these platform-specific implementations, the public
distribution site on aw.com also includes a fully standard version that
does not actually display a graphical image but instead writes a
PostScript file suitable for printing.  The existence of this
implementation ensures that it is always possible to use the simple
graphics.h interface even on platforms for which no specialized
implementation exists.

5.  CONCLUSIONS

Our experience over the last two years at Stanford suggests that using a
graphics library in an introductory course enhances student interest and
helps reinforce several essential programming concepts.  We have also
demonstrated that it is possible to design a graphics library that can
be implemented in a relatively portable way.

REFERENCES

[Hilburn93] Thomas B. Hilburn, "A top-down approach to teaching an
introductory computer science course," SIGCSE Bulletin, March 1993.

[House94] Donald House and David Levine, "The art and science of
computer graphics:  a very depth-first approach to the non-majors
course," SIGCSE Bulletin, March 1994.

[Papert80] Seymour Papert, Mindstorms, New York: Basic Books, 1980.

[Roberge92] James Roberge, "Creating programming projects with visual
impact," SIGCSE Bulletin, March 1992.

[Roberts93]  Eric S. Roberts, "Using C in CS1: Evaluating the Stanford
experience," SIGCSE Bulletin, March 1993.

[Roberts95]  Eric S. Roberts, The Art and Science of C: A Library-Based
Approach, Reading, MA: Addison-Wesley, 1995.

FOOTNOTES

[1] In THINK C, for example, this operation is performed as part of the
implementation of the console I/O package console.c.  In the Borland
C/C++ system, the same functionality is provided by the EasyWin package.

Figure 1.  Functions in graphics.h

InitGraphics();              This procedure initializes the package and
                             creates the graphics window on the screen.
                             The call to the InitGraphics function is
                             typically the first statement in main.

MovePen(x, y);               This procedure moves the current point to
                             the position (x, y) without drawing a line.

DrawLine(dx, dy);            This procedure draws a line extending from
                             the current point by moving the pen dx and
                             dy inches along the respective coordinate
                             axes.

DrawArc(r, start, sweep);    This procedure draws a circular arc, which
                             always begins at the current point.  The
                             arc itself has radius r, and starts at the
                             angle specified by the parameter start,
                             relative to the center of the circle.  This
                             angle is measured in degrees
                             counterclockwise from the 3 o'clock
                             position along the x-axis, as in
                             traditional mathematics.  The fraction of
                             the circle drawn is specified by the
                             parameter sweep, which is also measured in
                             degrees.  If the value of sweep is
                             positive, the arc is drawn counterclockwise
                             from the current point; if sweep is
                             negative, the arc is drawn clockwise.  The
                             current point at the end of the DrawArc
                             operation is the final position of the pen
                             along the arc.

width = GetWindowWidth();    These functions return the width and
height = GetWindowHeight();  height, in inches, of the drawing area of
                             the graphics window.

cx = GetCurrentX();          These functions return the current x- and
cy = GetCurrentY();          y-coordinates of the pen.  Like all
                             coordinates in the graphics package, these
                             values are measured in inches relative to
                             the origin.

Figure 2.  Selected functions in extgraph.h

DrawEllipticalArc            This procedure is similar to DrawArc in the
  (rx, ry, start, sweep);    basic graphics library, but draws an
                             elliptical rather than a circular arc.

StartFilledRegion(density);  These procedures are used to draw a filled
EndFilledRegion();           region.  The boundaries of the region are
                             defined by a set of calls to the line and
                             arc drawing functions that represent the
                             boundary path.  The parameter density is a
                             floating-point value that represents the
                             pixel density to be used for the fill
                             color.

DrawTextString(s);           This procedure draws the text string s at
                             the current pen position.  The pen position
                             is moved so that it follows the final
                             character in the string.  The interface
                             also contains functions to set the font,
                             size, and style of the text.

SetPenColor(color);
DefineColor(name, r, g, b, );
                             The SetPenColor function sets the graphics
                             package to draw in some color other than
                             the default black.  Colors are identified
                             by name, which makes it easier to save and
                             restore the current color.  By default,
                             only a small set of standard colors are
                             defined, but DefineColor allows clients to
                             define new ones by specifying their RGB
                             values.

x = GetMouseX();             These functions make it possible for the
y = GetMouseY();             client to use the mouse to design graphical
flag = MouseButtonIsDown();  user interfaces.  Given these primitives,
                             it is easy to design interfaces that
                             provide portable implementations of
                             buttons, menus, and other standard
                             interactors.

Pause(seconds);              The Pause function forces the system to
                             redraw the screen and then waits for the
                             specified number of seconds.  This function
                             can be used to animate the displays.