The Stanford cslib package

gobjects.h

    family-style-size 

Type detail

typedef struct GObjectCDT *GObject;

typedef GObject GRect;

   main() {
      GWindow gw = newGWindow(500, 300);
      printf("This program draws a red rectangle at (0, 0).\n")
      GRect rect = newGRect(0, 0, 200, 100);
      setFilled(rect, true);
      setColor(rect, "RED");
      add(gw, rect);
   }

color = getFillColor(gobj);

typedef GRect GRoundRect;

rect = newGRect(x, y, width, height);

typedef GRect G3DRect;

GRoundRect rect = newGRoundRect(x, y, width, height, corner);

typedef GObject GOval;

   main() {
      GWindow gw = newGWindow(500, 300);
      printf("This program draws a green oval filling the window.\n");
      GOval oval = newGOval(getWidth(gw), getHeight(gw));
      setFilled(oval, true);
      setColor(oval, "GREEN");
      add(gw, oval);
   }

if (isRaised(rect)) ...

typedef GObject GLine;

   main() {
      GWindow gw = newGWindow(500, 300);
      printf("This program draws the diagonals on the window.\n");
      add(gw, newGLine(0, 0, getWidth(gw), getHeight(gw)));
      add(gw, newGLine(0, getHeight(gw), getWidth(gw), 0));
   }

oval = newGOval(x, y, width, height);

typedef GObject GArc;

This type represents an elliptical arc. The arc is specified by the following parameters:

• The coordinates of the bounding rectangle (x, y, width, height)
• The angle at which the arc starts (start)
• The number of degrees that the arc covers (sweep)

All angles in a GArc description are measured in degrees moving counterclockwise from the +x axis. Negative values for either start or sweep indicate motion in a clockwise direction.

The following diagram illustrates the interpretation of these parameters for the arc shown in red:

Usage:

pt = getEndPoint(gobj);

typedef GObject GLabel;

This subtype represents a text string. For example, the following code adds a GLabel containing "hello, world" to the center of the window:

   main() {
      GWindow gw;
      GLabel label;
      double x, y;

      printf("This program draws the 'hello, world' message.\n");
      gw = newGWindow(600, 400);
      label = newGLabel("hello, world");
      setFont(label, "SansSerif-18");
      x = (getWidth(gw) - getWidth(label)) / 2;
      y = (getHeight(gw) + getFontAscent(label)) / 2;
      setLocation(label, x, y);
      add(gw, label);
   }

Controlling the appearance and positioning of a GLabel depends on understanding the following terms:

• The baseline is the horizontal line on which the characters rest.
• The origin is the point on the baseline at which the label begins.
• The height is the distance that separate two successive lines.
• The ascent is the maximum distance a character in this font extends above the baseline.
• The descent is the maximum distance a character in this font extends below the baseline.

The following diagram illustrates the interpretation of these terms:

Usage:

rect = getFrameRectangle(arc);

typedef GObject GImage;

   main() {
      printf("This program draws the Stanford tree.\n");
      GWindow gw = newGWindow(600, 400);
      GImage tree = newGImage("StanfordTree.png");
      double x = (getWidth(gw) - getWidth(tree)) / 2;
      double y = (getHeight(gw) - getHeight(tree)) / 2;
      add(gw, tree, x, y);
   }

descent = getFontDescent(label);

typedef GObject GPolygon;

This subtype represents a polygon bounded by line segments. The newGPolygon function creates an empty polygon. To complete the figure, you need to add vertices to the polygon using the functions addVertex, addEdge, and addPolarEdge. As an example, the following code adds a filled red octagon to the center of the window:

   main() {
      GWindow gw;
      GPolygon stopSign;
      double edge;
      int i;

      printf("This program draws a red octagon.\n");
      gw = newGWindow(600, 400);
      edge = 75;
      stopSign = newGPolygon();
      addVertex(stopSign, -edge / 2, edge / 2 + edge / sqrt(2.0));
      for (i = 0; i < 8; i++) {
         addPolarEdge(stopSign, edge, 45 * i);
      }
      setFilled(stopSign, true);
      setColor(stopSign, "RED");
      add(gw, stopSign, getWidth(gw) / 2, getHeight(gw) / 2);
   }

The program results in the following picture:

Usage:

GImage image = newGImage(filename);

typedef GObject GCompound;

vec = getVertices(poly);

Function detail

void freeGObject(GObject gobj);

freeGObject(gobj);

double getX(GObject gobj);

x = getX(gobj);

double getY(GObject gobj);

y = getY(gobj);

GPoint getLocation(GObject gobj);

pt = getLocation(gobj);

void setLocation(GObject gobj, double x, double y);

setLocation(gobj, x, y);

void move(GObject gobj, double dx, double dy);

move(gobj, dx, dy);

double getWidth(GObject gobj);

width = getWidth(gobj);

double getHeight(GObject gobj);

height = getHeight(gobj);

GDimension getSize(GObject gobj);

size = getSize(gobj);

GRectangle getBounds(GObject gobj);

rect = getBounds(gobj);

void setColor(GObject gobj, string color);

setColor(gobj, color);

string getColorGObject(GObject gobj);

color = getColorGObject(gobj);

void setVisible(GObject gobj, bool flag);

setVisible(gobj, flag);

bool isVisible(GObject gobj);

if (isVisible(gobj)) . . .

void sendForward(GObject gobj);

sendForward(gobj);

void sendToFront(GObject gobj);

sendToFront(gobj);

void sendBackward(GObject gobj);

sendBackward(gobj);

void sendToBack(GObject gobj);

sendToBack(gobj);

bool contains(GObject gobj, double x, double y);

if (contains(gobj, x, y)) . . .

string getType(GObject gobj);

type = getType(gobj);

GObject getParent(GObject gobj);

parent = getParent(gobj);

void setSize(GObject gobj, double width, double height);

setSize(gobj, width, height);

void setBounds(GObject gobj, double x, double y, double width, double height);

setBounds(gobj, x, y, width, height);

void setFilled(GObject gobj, bool flag);

setFilled(gobj, flag);

bool isFilled(GObject gobj);

if (isFilled(gobj)) . . .

void setFillColor(GObject gobj, string color);

setFillColor(gobj, color);

string getFillColor(GObject gobj);

color = getFillColor(gobj);

GRect newGRect(double x, double y, double width, double height);

rect = newGRect(x, y, width, height);

GRoundRect newGRoundRect(double x, double y, double width, double height, double corner);

GRoundRect rect = newGRoundRect(x, y, width, height, corner);

G3DRect newG3DRect(double x, double y, double width, double height, bool raised);

G3DRect rect = newG3DRect(x, y, width, height, raised);

void setRaised(G3DRect rect, bool raised);

setRaised(rect, raised);

bool isRaised(G3DRect rect);

if (isRaised(rect)) ...

GObject newGOval(double x, double y, double width, double height);

oval = newGOval(x, y, width, height);

GObject newGLine(double x0, double y0, double x1, double y1);

line = newGLine(x0, y0, x1, y1);

void setStartPoint(GLine line, double x, double y);

setStartPoint(gline, x, y);

void setEndPoint(GLine line, double x, double y);

setEndPoint(line, x, y);

GPoint getStartPoint(GObject gobj);

pt = getStartPoint(gobj);

GPoint getEndPoint(GObject gobj);

pt = getEndPoint(gobj);

GArc newGArc(double x, double y, double width, double height, double start, double sweep);

Creates a new GArc consisting of an elliptical arc.

The following screenshots show several examples of how the GArc constructor interprets the start and sweep parameters:

In the code fragments underneath each of these diagrams, r is the radius of the circular arc, and cx and cy are the coordinates of the center or the window.

Usage:

arc = newGArc(x, y, width, height, start, sweep);

void setStartAngle(GArc arc, double start);

setStartAngle(arc, start);

double getStartAngle(GArc arc);

angle = getStartAngle(arc);

void setSweepAngle(GArc arc, double start);

setSweepAngle(arc, start);

double getSweepAngle(GArc arc);

angle = getSweepAngle(arc);

void setFrameRectangle(GArc garc, double x, double y, double width, double height);

setFrameRectangle(arc, x, y, width, height);

GRectangle getFrameRectangle(GArc arc);

rect = getFrameRectangle(arc);

GLabel newGLabel(string str);

label = newGLabel(str);

void setFont(GLabel label, string font);

   family-style-size

setFont(label, font);

string getFont(GLabel label);

font = getFont(label);

void setLabel(GLabel label, string str);

setLabel(label, str);

string getLabel(GLabel label);

str = getLabel(label);

double getFontAscent(GLabel label);

ascent = getFontAscent(label);

double getFontDescent(GLabel label);

descent = getFontDescent(label);

GImage newGImage(string filename);

GImage image = newGImage(filename);

GPolygon newGPolygon(void);

poly = newGPolygon();

void addVertex(GPolygon poly, double x, double y);

addVertex(poly, x, y);

void addEdge(GPolygon poly, double dx, double dy);

addEdge(poly, dx, dy);

void addPolarEdge(GPolygon poly, double r, double theta);

addPolarEdge(poly, r, theta);

Vector getVertices(GPolygon poly);

vec = getVertices(poly);

GObject newGCompound(void);

comp = newGCompound();

void add(GCompound compound, GObject gobj);

add(compound, gobj);

void add(GCompound compound, GObject gobj);

add(compound, gobj);