user/wxLayout/wxllist.h

   1 /*-*- c++ -*-********************************************************
   2  * wxLayoutList.h - a formatted text rendering engine for wxWindows *
   3  *                                                                  *
   4  * (C) 1998 by Karsten Ballüder (Ballueder@usa.net)                 *
   5  *                                                                  *
   6  * $Id$
   7  *******************************************************************/
   8 #ifndef WXLLIST_H
   9 #define WXLLIST_H
  10
  11 #ifdef __GNUG__
  12 #   pragma interface "wxllist.h"
  13 #endif
  14
  15 #include   "kbList.h"
  16
  17 #include   "wx/wx.h"
  18 #include   "wx/print.h"
  19 #include   "wx/printdlg.h"
  20 #include   "wx/generic/printps.h"
  21 #include   "wx/generic/prntdlgg.h"
  22
  23 // skip the following defines if embedded in M application
  24 #ifdef   M_BASEDIR
  25 #   ifdef   DEBUG
  26 //#      define   WXLAYOUT_DEBUG
  27 #   endif
  28 #else
  29     // for testing only:
  30 #   define WXLAYOUT_DEBUG
  31     // The wxLayout classes can be compiled with std::string instead of wxString
  32     //#   define USE_STD_STRING
  33 #   define WXMENU_LAYOUT_LCLICK     1111
  34 #   define WXMENU_LAYOUT_RCLICK    1112
  35 #   define WXMENU_LAYOUT_DBLCLICK   1113
  36 #endif
  37
  38 #ifdef USE_STD_STRING
  39 #   include   <string>
  40     typedef   std::string String;
  41 #   define    Str(str)(str.c_str())
  42 #else
  43     typedef   wxString String;
  44 #   define    Str(str) str
  45 #endif
  46
  47 #define   WXLO_DEFAULTFONTSIZE 12
  48
  49 /// Types of currently supported layout objects.
  50 enum wxLayoutObjectType
  51 { WXLO_TYPE_INVALID = 0, WXLO_TYPE_TEXT, WXLO_TYPE_CMD, WXLO_TYPE_ICON, WXLO_TYPE_LINEBREAK };
  52
  53 /// Type used for coordinates in drawing.
  54 typedef long CoordType;
  55
  56 class wxLayoutList;
  57 class wxLayoutObjectBase;
  58
  59 class wxDC;
  60 class wxColour;
  61 class wxFont;
  62
  63 /** The base class defining the interface to each object which can be
  64     part of the layout. Each object needs to draw itself and calculate
  65     its size.
  66 */
  67 class wxLayoutObjectBase
  68 {
  69 public:
  70    struct UserData
  71    {
  72       virtual ~UserData() { }
  73    };
  74
  75    /// return the type of this object
  76    virtual wxLayoutObjectType GetType(void) const { return WXLO_TYPE_INVALID; } ;
  77    /** Calculates the position etc of an object.
  78        @param dc the wxDC to draw on
  79        @param position where to draw the top left corner
  80        @param baseLine the baseline for alignment, from top of box
  81    */
  82    virtual void Layout(wxDC & dc,
  83                        wxPoint position,
  84                        CoordType baseLine) {}
  85
  86    /** Draws an object.
  87        @param dc the wxDC to draw on
  88        @param translation to be added to coordinates
  89    */
  90    virtual void Draw(wxDC & dc, wxPoint const &translate) {}
  91
  92    /** Calculates and returns the size of the object.
  93        @param baseLine pointer where to store the baseline position of
  94        this object (i.e. the height from the top of the box to the
  95        baseline)
  96        @return the size of the object's box in pixels
  97    */
  98    virtual wxPoint GetSize(CoordType * baseLine = NULL) const
  99       { return wxPoint(0,0); }
 100
 101    /** Calculates and returns the position of the object.
 102        @return the size of the object's box in pixels
 103    */
 104    virtual wxPoint GetPosition(void) const { return m_Position; }
 105
 106    /// returns the number of cursor positions occupied by this object
 107    virtual CoordType CountPositions(void) const { return 1; }
 108
 109    /// constructor
 110    wxLayoutObjectBase() { m_UserData = NULL; }
 111    /// delete the user data
 112    virtual ~wxLayoutObjectBase() { delete m_UserData; }
 113
 114 #ifdef WXLAYOUT_DEBUG
 115    virtual void Debug(void);
 116 #endif
 117
 118    /// query whether coordinates have changed since last drawing
 119    virtual bool IsDirty(void) const { return true; }
 120
 121    /** Tells the object about some user data. This data is associated
 122        with the object and will be deleted at destruction time.
 123    */
 124    void   SetUserData(UserData *data) { m_UserData = data; }
 125    /** Return the user data. */
 126    void * GetUserData(void) const { return m_UserData; }
 127
 128 private:
 129    /// optional data for application's use
 130    UserData *m_UserData;
 131 protected:
 132    wxPoint m_Position;
 133 };
 134
 135 /// Define a list type of wxLayoutObjectBase pointers.
 136 KBLIST_DEFINE(wxLayoutObjectList, wxLayoutObjectBase);
 137
 138
 139 /// object for text block
 140 class wxLayoutObjectText : public wxLayoutObjectBase
 141 {
 142 public:
 143    wxLayoutObjectText(const String &txt);
 144
 145    virtual wxLayoutObjectType GetType(void) const { return WXLO_TYPE_TEXT; }
 146    virtual void Layout(wxDC &dc, wxPoint position, CoordType
 147                        baseLine);
 148
 149    virtual void Draw(wxDC &dc, wxPoint const &translate);
 150    /** This returns the height and in baseLine the position of the
 151        text's baseline within it's box. This is needed to properly
 152        align text objects.
 153    */
 154    virtual wxPoint GetSize(CoordType *baseLine = NULL) const;
 155
 156 #ifdef WXLAYOUT_DEBUG
 157    virtual void Debug(void);
 158 #endif
 159
 160    virtual CoordType CountPositions(void) const { return strlen(m_Text.c_str()); }
 161    virtual bool IsDirty(void) const { return m_IsDirty; }
 162
 163    // for editing:
 164    String & GetText(void) { return m_Text; }
 165    void SetText(String const &text) { m_Text = text; }
 166
 167 private:
 168    String m_Text;
 169    /// size of the box containing text
 170    long   m_Width, m_Height;
 171    /// the position of the baseline counted from the top of the box
 172    long   m_BaseLine;
 173    /// coordinates have changed
 174    bool m_IsDirty;
 175 };
 176
 177 /// icon/pictures:
 178 class wxLayoutObjectIcon : public wxLayoutObjectBase
 179 {
 180 public:
 181    wxLayoutObjectIcon(wxIcon *icon);
 182    wxLayoutObjectIcon(wxIcon const &icon);
 183
 184    ~wxLayoutObjectIcon() { delete m_Icon; }
 185
 186    virtual wxLayoutObjectType GetType(void) const { return WXLO_TYPE_ICON; }
 187    virtual void Layout(wxDC &dc, wxPoint position, CoordType baseLine);
 188    virtual void Draw(wxDC &dc, wxPoint const &translate);
 189
 190    virtual wxPoint GetSize(CoordType *baseLine = NULL) const;
 191    virtual bool IsDirty(void) const { return m_IsDirty; }
 192
 193 private:
 194    wxIcon *m_Icon;
 195    /// coordinates have changed
 196    bool m_IsDirty;
 197 };
 198
 199 /// for export to html:
 200 struct wxLayoutStyleInfo
 201 {
 202    int  size, family, style, weight;
 203    bool underline;
 204    unsigned fg_red, fg_green, fg_blue;
 205    unsigned bg_red, bg_green, bg_blue;
 206 };
 207
 208 /// pseudo-object executing a formatting command in Draw()
 209 class wxLayoutObjectCmd : public wxLayoutObjectBase
 210 {
 211 public:
 212    virtual wxLayoutObjectType GetType(void) const { return WXLO_TYPE_CMD; }
 213    virtual void Draw(wxDC &dc, wxPoint const &translate);
 214    virtual void Layout(wxDC &dc, wxPoint position, CoordType baseLine);
 215    wxLayoutObjectCmd(int size, int family, int style, int weight,
 216                 bool underline,
 217                 wxColour const *fg, wxColour const *bg);
 218    ~wxLayoutObjectCmd();
 219    /// caller must free pointer:
 220    wxLayoutStyleInfo *GetStyle(void) const ;
 221    /// return the background colour for setting colour of window
 222    wxColour const *GetBGColour(void) const { return m_ColourBG; }
 223 private:
 224    /// the font to use
 225    wxFont *m_font;
 226    /// foreground colour
 227    wxColour const *m_ColourFG;
 228    /// background colour
 229    wxColour const *m_ColourBG;
 230 };
 231
 232 /// this object doesn't do anything at all
 233 class wxLayoutObjectLineBreak : public wxLayoutObjectBase
 234 {
 235 public:
 236    virtual wxLayoutObjectType GetType(void) const { return WXLO_TYPE_LINEBREAK; }
 237 };
 238
 239
 240 class wxLayoutPrintout;
 241
 242 class wxLayoutMargins
 243 {
 244 public:
 245    wxLayoutMargins() { top = left = 0; bottom = right = -1; }
 246    int top;
 247    int left;
 248    int bottom;
 249    int right;
 250 };
 251
 252 /**
 253    This class provides a high level abstraction to the wxFText
 254    classes.
 255    It handles most of the character events with its own callback
 256    functions, providing an editing ability. All events which cannot be
 257    handled get passed to the parent window's handlers.
 258 */
 259 class wxLayoutList : public wxLayoutObjectList
 260 {
 261 public:
 262    wxLayoutList();
 263
 264    /// Destructor.
 265    ~wxLayoutList();
 266
 267    /// adds an object:
 268    void AddObject(wxLayoutObjectBase *obj);
 269    /// adds a text object
 270    void AddText(String const &txt);
 271    /// adds a line break
 272    void LineBreak(void);
 273    /// sets font parameters
 274    void SetFont(int family, int size, int style,
 275                 int weight, int underline,
 276                 wxColour const *fg,
 277                 wxColour const *bg);
 278    /// sets font parameters, colours by name
 279    void SetFont(int family=-1, int size = -1, int style=-1,
 280                 int weight=-1, int underline = -1,
 281                 char const *fg = NULL,
 282                 char const *bg = NULL);
 283    /// set font family
 284    inline void SetFontFamily(int family) { SetFont(family); }
 285    /// set font size
 286    inline void SetFontSize(int size) { SetFont(-1,size); }
 287    /// set font style
 288    inline void SetFontStyle(int style) { SetFont(-1,-1,style); }
 289    /// set font weight
 290    inline void SetFontWeight(int weight) { SetFont(-1,-1,-1,weight); }
 291    /// toggle underline flag
 292    inline void SetFontUnderline(bool ul) { SetFont(-1,-1,-1,-1,(int)ul); }
 293    /// set font colours by name
 294    inline void SetFontColour(char const *fg, char const *bg = NULL) { SetFont(-1,-1,-1,-1,-1,fg,bg); }
 295
 296
 297    /** Re-layouts the list on a DC.
 298        @param dc the dc to layout for
 299        @param margins if not NULL, use these top and left margins
 300    */
 301    void Layout(wxDC &dc, wxLayoutMargins *margins = NULL);
 302
 303   /** Draw the list on a given DC.
 304       @param dc the dc to layout for
 305       @param fromLine the first graphics line from where to draw
 306       @param toLine the last line at which to draw
 307       @param start if != iterator(NULL) start drawing from here
 308    */
 309    void Draw(wxDC &dc,
 310              CoordType fromLine = -1,
 311              CoordType toLine = -1,
 312              iterator start = iterator(NULL),
 313              wxPoint const &translate = wxPoint(0,0));
 314
 315    /** Deletes at least to the end of line and redraws */
 316    void EraseAndDraw(wxDC &dc, iterator start = iterator(NULL));
 317
 318    /** Finds the object occupying a certain screen position.
 319        @return pointer to wxLayoutObjectBase or NULL if not found
 320    */
 321    wxLayoutObjectBase *Find(wxPoint coords) const;
 322
 323 #ifdef WXLAYOUT_DEBUG
 324    void Debug(void);
 325    void ShowCurrentObject();
 326 #endif
 327
 328    /// dirty?
 329    bool IsDirty() const { return m_bModified; }
 330    bool CursorMoved(void) const { return m_CursorMoved; }
 331
 332    /// called after the contents is saved, for example
 333    void ResetDirty() { m_bModified = FALSE; }
 334
 335    /// for access by wxLayoutWindow:
 336    void GetSize(CoordType *max_x, CoordType *max_y,
 337                 CoordType *lineHeight);
 338
 339
 340    /**@name Functionality for editing */
 341    //@{
 342    /// set list editable or read only
 343    void SetEditable(bool editable = true) { m_Editable = editable; }
 344    /// return true if list is editable
 345    bool IsEditable(void) const { return m_Editable; }
 346    /// move cursor, returns true if it could move to the desired position
 347    bool MoveCursor(int dx = 0, int dy = 0);
 348    void SetCursor(wxPoint const &p) { m_CursorPosition = p; }
 349    void DrawCursor(wxDC &dc, bool erase = false);
 350
 351    /// Get current cursor position cursor coords
 352    wxPoint GetCursor(void) const { return m_CursorPosition; }
 353    /// Gets graphical coordinates of cursor
 354    wxPoint GetCursorCoords(void) const { return m_CursorCoords; }
 355
 356    /// delete one or more cursor positions
 357    void Delete(CoordType count = 1);
 358    void Insert(String const &text);
 359    void Insert(wxLayoutObjectBase *obj);
 360    void Clear(int family = wxROMAN, int size=WXLO_DEFAULTFONTSIZE, int style=wxNORMAL, int weight=wxNORMAL,
 361                     int underline=0, char const *fg="black", char const *bg="white");
 362
 363    /// return a pointer to the default settings (dangerous, why?) FIXME:
 364    wxLayoutObjectCmd const *GetDefaults(void) const { return m_DefaultSetting ; }
 365
 366    wxLayoutObjectList::iterator FindCurrentObject(CoordType *offset = NULL);
 367    // get the length of the line with the object pointed to by i, offs
 368    // only used to decide whether we are before or after linebreak
 369    CoordType GetLineLength(wxLayoutObjectList::iterator i,
 370                            CoordType offs = 0);
 371    wxLayoutPrintout *MakePrintout(wxString const &name);
 372
 373    /// Return maximum X,Y coordinates
 374    wxPoint GetSize(void) const { return wxPoint(m_MaxX, m_MaxY); }
 375 //@}
 376 protected:
 377    /// font parameters:
 378    int m_FontFamily, m_FontStyle, m_FontWeight;
 379    int m_FontPtSize;
 380    bool m_FontUnderline;
 381    /// colours:
 382    wxColour const * m_ColourFG;
 383    wxColour const * m_ColourBG;
 384    /// the default setting:
 385    wxLayoutObjectCmd *m_DefaultSetting;
 386
 387    /// needs recalculation?
 388    bool m_dirty;
 389    /// cursor moved
 390    bool m_CursorMoved;
 391
 392    /// needs saving (i.e., was modified?)
 393    bool m_bModified;
 394
 395    // the currently updated line:
 396    /// where do we draw next:
 397    wxPoint   m_Position;
 398    /// the height of the current line:
 399    CoordType m_LineHeight;
 400    /// maximum drawn x position so far
 401    CoordType m_MaxX;
 402    /// maximum drawn y position:
 403    CoordType m_MaxY;
 404
 405    //---- this is needed for editing:
 406    /// where is the text cursor (column,line):
 407    wxPoint   m_CursorPosition;
 408    /// where to draw the cursor
 409    wxPoint   m_CursorCoords;
 410    /// how large to draw it
 411    wxPoint   m_CursorSize;
 412
 413    /// to store content overwritten by cursor
 414    wxMemoryDC m_CursorMemDC;
 415
 416    /// which is the last line
 417    CoordType m_MaxLine;
 418    /// can we edit it?
 419    bool      m_Editable;
 420    /// find the object to the cursor position and returns the offset
 421    /// in there
 422    wxLayoutObjectList::iterator FindObjectCursor(wxPoint *cpos, CoordType *offset = NULL);
 423 private:
 424    /// Resets the font settings etc to default values
 425    void ResetSettings(wxDC &dc);
 426    /// calculates current cursor coordinates, called in Layout()
 427    void CalculateCursor(wxDC &dc);
 428    /// remembers the last cursor position for which FindObjectCursor was called
 429    wxPoint m_FoundCursor;
 430    /// remembers the iterator to the object related to m_FoundCursor
 431    wxLayoutObjectList::iterator m_FoundIterator;
 432 };
 433
 434 class wxLayoutPrintout: public wxPrintout
 435 {
 436  public:
 437    wxLayoutPrintout(wxLayoutList &llist, wxString const & title =
 438                     "wxLayout Printout")
 439       :wxPrintout(title)
 440       { m_llist = &llist; m_title = title;}
 441    bool OnPrintPage(int page);
 442    bool HasPage(int page);
 443    bool OnBeginDocument(int startPage, int endPage);
 444    void GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int
 445                     *selPageTo);
 446    void OnPreparePrinting(void);
 447 protected:
 448    virtual void DrawHeader(wxDC &dc, wxPoint topleft, wxPoint bottomright, int pageno);
 449
 450 private:
 451    wxLayoutList *m_llist;
 452    wxString      m_title;
 453    int           m_PageHeight, m_PageWidth;
 454    // how much we actually print per page
 455    int           m_PrintoutHeight;
 456    wxLayoutMargins m_Margins;
 457    int           m_NumOfPages;
 458 };
 459
 460 #endif // WXLLIST_H