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