Step 9: Changing pens

	There is a new protected data member, Color (a TColor object). Color and PenSize make up the attributes necessary to construct a TPen object.
	The constructor signature has changed from TLine(int penSize = 1); to TLine(const TColor &color = (TColor) 0, int penSize = 1); The constructor itself changes to set PenSize to the constructor's second parameter and to create a new TColor object and assign it to Color. If no parameters are specified and the first parameter takes on its default value, TColor::Black is used as the pen color.
	The two QueryPen functions are abandoned in favor of two new functions: QueryPenSize, which returns the pen size as an int and QueryColor, which returns the pen color as a TColor.
	Instead of using the query functions to set the pen attributes, there are two new functions called SetPen. One takes a single int parameter and the other takes a TColor & and an int. The pen query and set functions are discussed in the next section.
	A Draw function is added so that the TLine class dictates how it is drawn. This function is virtual so that it can be easily overridden in a derived class.

class TLine : public TPoints {
  public:
    // Constructor to allow construction from a color and a pen size.
    // Also serves as default constructor.
    TLine(const TColor &color = TColor(0), int penSize = 1)
      : TPoints(10, 0, 10), PenSize(penSize), Color(color) {}
    // Functions to modify and query pen attributes.
    int QueryPenSize() { return PenSize; }
    TColor& QueryColor() { return Color; }
    void SetPen(TColor &newColor, int penSize = 0);
    void SetPen(int penSize);

    // TLine draws itself. Returns true if everything went OK.
    virtual bool Draw(TDC &) const;

    // The == operator must be defined for the container class,
    // even if unused
    bool operator ==(const TLine& other) const
      { return &other == this; }
    friend ostream& operator <<(ostream& os, const TLine& line);
    friend istream& operator >>(istream& is, TLine& line);
  protected:
    int PenSize;
    TColor Color;
};
       

void
TLine::SetPen(int penSize)
{
  if (penSize < 1)
    PenSize = 1;
  else
    PenSize = penSize;
}

void
TLine::SetPen(TColor &newColor, int penSize)
{
  // If penSize isn't the default (0), set PenSize to the new size.
  if (penSize)
    PenSize = penSize;

  Color = newColor;
}
       

bool
TLine::Draw(TDC &dc) const
{
  // Set pen for the dc to the values for this line
  TPen pen(Color, PenSize);
  dc.SelectObject(pen);

  // Iterates through the points in the line i.
  TPointsIterator j(*this);
  bool first = true;

  while (j) {
    TPoint p = j++;

    if (!first)
      dc.LineTo(p);
    else {
      dc.MoveTo(p);
      first = false;
    }
  }
  dc.RestorePen();
  return true;
}
       

void
TDrawWindow::Paint(TDC& dc, bool, TRect&)
{
  // Iterates through the array of line objects.
  TLinesIterator i(*Lines);

  while (i)
    i++.Draw(dc);
}
       

	The insertion operator is modified to write out the PenSize and Color member. It then writes out the points just as it did before.
	The extraction operator reads in the data and uses the PenSize and Color data in the SetPen function. Each point is read in from the file and added to the object.

	The Pen data member is constructed from the size and color of the current line.
	The SetPenSize function is removed. The function GetPenSize opens a TInputDialog for the user to enter a new pen size in. GetPenSize then calls the function Line->SetPen to actually set the pen size.
	The CmPenColor function is added to handle the CM_PENCOLOR event. This event is sent from the new Tools menu choice Pen Color.

void
TDrawWindow::CmPenColor()
{
  TChooseColorDialog::TData colors;
  static TColor custColors[16] =
  {
    0x010101L, 0x101010L, 0x202020L, 0x303030L,
    0x404040L, 0x505050L, 0x606060L, 0x707070L,
    0x808080L, 0x909090L, 0xA0A0A0L, 0xB0B0B0L,
    0xC0C0C0L, 0xD0D0D0L, 0xE0E0E0L, 0xF0F0F0L
  };

  colors.Flags = CC_RGBINIT;
  colors.Color = TColor(Line->QueryColor());
  colors.CustColors = custColors;
  if (TChooseColorDialog(this, colors).Execute() == IDOK)
    Line->SetPen(colors.Color);
}
       

	The TPen and TColor classes are discussed in "Graphics objects" in the ObjectWindows Programmer's Guide.
	Dialog boxes, including the TChooseColorDialog class, are discussed in "Dialog box objects" in the ObjectWindows Programmer's Guide.