SD>круг и квадрат это одна фигура эээ не совсем корректно

class TFigure
{
public:

   // ...

protected:

   std::vector<TPoint> m_Points;
};

class TObject
{
public:

   virtual void DrawOnWindow(TWindow & rWindow) const = 0;
   virtual void DrawOnConsole(TConsole & rConsole) const = 0;
};

class TDrawDevice
{
public:

   virtual void DrawRect(const TRect & rRect);
   virtual void DrawText(const int x, const int y, const std::string & rText);
   // И т.д.
};

class TWindowDevice : public TDrawDevice
{
public:

   virtual void DrawRect(const TRect & rRect);
   virtual void DrawText(const int x, const int y, const std::string & rText);
   // И т.д.

private:

   TWindow & m_rWindow;
};

class TConsoleDevice : public TDrawDevice
{
public:

   virtual void DrawRect(const TRect & rRect);
   virtual void DrawText(const int x, const int y, const std::string & rText);
   // И т.д.

private:

   TConsole & m_rConsole;
};

class TObject
{
public:

   virtual void Draw(TDrawDevice & rDevice) const = 0;
};

// Базовый класс для сегмента пути.
class TPathSegment {...};

// Класс для отрезка.
class TLineSegment : public TPathSegment {...};

// Класс для кривой Безье.
class TCurveSegment : public TPathSegment {...};

// Путь - контур фигуры.
class TPath
{
public:

   // ...
private:

   std::vector<TPathSegment *> m_Segments;
};

// Фигура.
class TFigure
{
public:

   // ...
private:

   TPath m_Path;
};

// Глиф, базовый класс.
class TGlyph {...};

// Буква A.
class TGlyphA : public TGlyph {...};

// Буква B.
class TGlyphB : public TGlyph {...};

// Буква C.
class TGlyphC : public TGlyph {...};

// И т.д.

class TGlyph
{
public:

   // ...
private:

   wchar_t m_Code;
   TPath m_Outline;
};

class TFont
{
public:

   // ...
private:

   std::map<wchar_t, TGlyph> m_Glyphs;
};

TReader Reader;
THttp Http;

while (!Reader.Understand())
{
   std::string page1 = Http.GetPage("http://www.rsdn.ru/Forum/Message.aspx?mid=1699457&only=1");
   Reader.Read(page1);

   std::string page2 = Http.GetPage("http://www.rsdn.ru/Forum/Message.aspx?mid=1699208&only=1");
   Reader.Read(page2);

   Reader.Think();
}

class Shape    //базовый
{
virtual void Move(double dt) = 0;
virtual void Draw(HDC dc) const = 0;
virtual ~Shape();
// другие методы
};

class SomeShape : public Shape
{
    void Move(double dt) { /*...*/ }
    void Draw(HDC dc) { /*...*/ }
};
class OtherShape : public Shape
{
    void Move(double dt) { /*...*/ }
    void Draw(HDC dc) { /*...*/ }
};

// Базовый класс фигуры.
class TFigure {...};

// Круг.
class TCircle : public TFigure {...};

// Квадрат.
class TQuadrate : public TFigure {...};

ДЧ>class Shape    //базовый
ДЧ>{
ДЧ>virtual void Move(double dt) = 0;
ДЧ>virtual void Draw(HDC dc) const = 0;
ДЧ>virtual ~Shape();
ДЧ>// другие методы
ДЧ>};

ДЧ>class SomeShape : public Shape
ДЧ>{
ДЧ>    void Move(double dt) { /*...*/ }
ДЧ>    void Draw(HDC dc) { /*...*/ }
ДЧ>};
ДЧ>class OtherShape : public Shape
ДЧ>{
ДЧ>    void Move(double dt) { /*...*/ }
ДЧ>    void Draw(HDC dc) { /*...*/ }
ДЧ>};
ДЧ>

class SomeShape : public Shape
{
    void Move(double dt) { /*...*/ }
    void Draw(HDC dc) { /*...*/ }
    
   GeneralCanvas::Instance->Draw(Direct ....);
   или
   GeneralCanvas::Instance->Draw(HDC ....);

   или получать контекст
   GeneralCanvas::Instance->getCurrent....

};

class TFigure
{
public:

    // ...

protected:

    std::vector<TPoint> m_Points;
    bool usesCurves;
    std::vector<TCurve> m_Curves;
};

class TFigure
{
public:

    // ...

protected:

    std::vector<TPoint> m_Points;
    bool usesCurves;
    std::vector<TCurve> m_Curves;
    bool usesEllipses;
    std::vector<TEllipse> m_Ellipses;
};

enum IPointFlag
{
   PF_MOVE,
   PF_LINE,
   PF_CURVE
};

class TFigure
{
public:

   // ...

private:

   std::vector<IPointFlag> m_Flags;
   std::vector<TPoint> m_Points;
};

size_t i = 0;

while (i < m_Points.size())
{
   switch (m_Flags[i])
   {
      case PF_MOVE:
         dc.MoveTo(m_Points[i]);
         i++;
         break;
      case PF_LINE:
         dc.LineTo(m_Points[i]);
         i++;
         break;
      case PF_CURVE:
         ASSERT((i + 2) < m_Points.size());
         dc.CurveTo(m_Points[i], m_Points[i + 1], m_Points[i + 2]);
         i += 3;
         break;
   }
}

class Element{
virtual void Draw()=0;
}

class Polygon:public Draw{
...
}
class Figure{
...
std::vector<Element*> elements;
}

  // Общие классы
template <class T> class IClonable abstract
{
public:
  virtual T * Clone() = 0;
}

template <class T> class Array : virtual public IClonable<Array<T>>
{
  T ** hItems;
};

  // Параметры фигуры
class Parameter abstract : virtual public IClonable<Parameter>
{
  Text * hParamName;
};
class Real : public Parameter {};
class Text : public Parameter {};
class Point : public Parameter {};
// ...

  // на данном этапе один класс "типа фигуры" с неск. экземплярами (типами)
class FigureType sealed
{
  Text typeName;
  Array<Parameter> params;
  Array<CreateTool> createTools; // see 3ds max script: Create Tools; Tool Create;
  
  Figure * CreateFigure()
  {
    return new Figure(this);
  }
};

  // тоже самое, но не для "типа", а для "фигуры"
class Figure sealed
{
  FigureType * hType;
  Array<Parameter> * hParams;
public:
  Figure(FigureType * ht) : hType(ht), hParams(ht->params.Clone()) { }
};

  // Документ
class Document
{
  Array<Figure> figures;
  Array<View> views;

  bool Serialize(/* ... */);
};

  // Вид
class View
{
  Renderer * hRenderer;
  Document * hDoc;

  bool Draw()
  {
    return hRenderer->Render(this, hDoc);
  }
};

  // Движок (редактора или чего-то-там)
class Engine
{
  //Array<FigureType> figureTypes;
  Map<Text, FigureType> figureTypes;
  Array<Document> docs;
  Renderer * hDefaultRenderer;
private:
  Engine();
public:
  static Engine & GetSingle() // синглтон
  {
    static Engine instance;
    return instance;
  }
};

  // графические рисовальщики (дивайсы):
class Renderer abstract
{
  virtual public bool Render(View *, Document *) = 0;
};

class GDIRenderer : public Renderer {};
class OGLRenderer : public Renderer {};
// ...

shape{
  name="rectangle with text",
  
  -- Control points
  controls { 
    text_position = control { 
                             -- Might be also initialized externally inside shape.on_init
                             on_init = function() 
                                               self.x = shape.width/2
                                               self.y = shape.height/2
                                       end 
                            },
  },

  -- Graphical elements
  elements {
    lines = group{ line{}, line{}, line{}, line{} },
    text  = text{},
  },

  -- Modifiable properties
  properties {
     text = string_param{ on_change = function(new_text) self.elements.text.set_text( new_text ) end }
  },

  -- Behaviour
  on_init = function()
     resize(100,100)
  end,

  on_resize = function()
     self.elements.text.x = self.controls.text_position.x
     self.elements.text.y = self.controls.text_position.y
     self.elements.lines[0].x = 0
     self.elements.lines[0].y = 0
     self.elements.lines[1].x = shape.width
     self.elements.lines[1].y = 0
     -- etc
  end
}