include/wx/private/textmeasure.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/private/textmeasure.h
   3 // Purpose:     declaration of wxTextMeasure class
   4 // Author:      Manuel Martin
   5 // Created:     2012-10-05
   6 // RCS-ID:      $Id:
   7 // Copyright:   (c) 1997-2012 wxWidgets team
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef _WX_PRIVATE_TEXTMEASURE_H_
  12 #define _WX_PRIVATE_TEXTMEASURE_H_
  13
  14 class WXDLLIMPEXP_FWD_CORE wxDC;
  15 class WXDLLIMPEXP_FWD_CORE wxFont;
  16 class WXDLLIMPEXP_FWD_CORE wxWindow;
  17
  18 // ----------------------------------------------------------------------------
  19 // wxTextMeasure: class used to measure text extent.
  20 // ----------------------------------------------------------------------------
  21
  22 class wxTextMeasureBase
  23 {
  24 public:
  25     // The first ctor argument must be non-NULL, i.e. each object of this class
  26     // is associated with either a valid wxDC or a valid wxWindow.
  27     wxTextMeasureBase(const wxDC *dc, const wxFont *theFont);
  28     wxTextMeasureBase(const wxWindow *win, const wxFont *theFont);
  29
  30     // Even though this class is not supposed to be used polymorphically, give
  31     // it a virtual dtor to avoid compiler warnings.
  32     virtual ~wxTextMeasureBase() { }
  33
  34
  35     // Return the extent of a single line string.
  36     void GetTextExtent(const wxString& string,
  37                        wxCoord *width,
  38                        wxCoord *height,
  39                        wxCoord *descent = NULL,
  40                        wxCoord *externalLeading = NULL);
  41
  42     // The same for a multiline (with '\n') string.
  43     void GetMultiLineTextExtent(const wxString& text,
  44                                 wxCoord *width,
  45                                 wxCoord *height,
  46                                 wxCoord *heightOneLine = NULL);
  47
  48     // Find the dimensions of the largest string.
  49     wxSize GetLargestStringExtent(size_t n, const wxString* strings);
  50     wxSize GetLargestStringExtent(const wxArrayString& strings)
  51     {
  52         return GetLargestStringExtent(strings.size(), &strings[0]);
  53     }
  54
  55     // Fill the array with the widths for each "0..N" substrings for N from 1
  56     // to text.length().
  57     //
  58     // The scaleX argument is the horizontal scale used by wxDC and is only
  59     // used in the generic implementation.
  60     bool GetPartialTextExtents(const wxString& text,
  61                                wxArrayInt& widths,
  62                                double scaleX);
  63
  64
  65     // These functions are called by our public methods before and after each
  66     // call to DoGetTextExtent(). Derived classes may override them to prepare
  67     // for -- possibly several -- subsequent calls to DoGetTextExtent().
  68     //
  69     // As these calls must be always paired, they're never called directly but
  70     // only by our friend MeasuringGuard class.
  71     //
  72     // NB: They're public only to allow VC6 to compile this code, there doesn't
  73     //     seem to be any way to give MeasuringGuard access to them (FIXME-VC6)
  74     virtual void BeginMeasuring() { }
  75     virtual void EndMeasuring() { }
  76
  77 protected:
  78     // RAII wrapper for the two methods above.
  79     class MeasuringGuard
  80     {
  81     public:
  82         MeasuringGuard(wxTextMeasureBase& tm) : m_tm(tm)
  83         {
  84             m_tm.BeginMeasuring();
  85         }
  86
  87         ~MeasuringGuard()
  88         {
  89             m_tm.EndMeasuring();
  90         }
  91
  92     private:
  93         wxTextMeasureBase& m_tm;
  94     };
  95
  96
  97     // The main function of this class, to be implemented in platform-specific
  98     // way used by all our public methods.
  99     //
 100     // The width and height pointers here are never NULL and the input string
 101     // is not empty.
 102     virtual void DoGetTextExtent(const wxString& string,
 103                                  wxCoord *width,
 104                                  wxCoord *height,
 105                                  wxCoord *descent = NULL,
 106                                  wxCoord *externalLeading = NULL) = 0;
 107
 108     // The real implementation of GetPartialTextExtents().
 109     //
 110     // On input, widths array contains text.length() zero elements and the text
 111     // is guaranteed to be non-empty.
 112     virtual bool DoGetPartialTextExtents(const wxString& text,
 113                                          wxArrayInt& widths,
 114                                          double scaleX) = 0;
 115
 116     // Call either DoGetTextExtent() or wxDC::GetTextExtent() depending on the
 117     // value of m_useDCImpl.
 118     //
 119     // This must be always used instead of calling DoGetTextExtent() directly!
 120     void CallGetTextExtent(const wxString& string,
 121                            wxCoord *width,
 122                            wxCoord *height,
 123                            wxCoord *descent = NULL,
 124                            wxCoord *externalLeading = NULL);
 125
 126
 127     // Exactly one of m_dc and m_win is non-NULL for any given object of this
 128     // class.
 129     const wxDC* const m_dc;
 130     const wxWindow* const m_win;
 131
 132     // If this is true, simply forward to wxDC::GetTextExtent() from our
 133     // CallGetTextExtent() instead of calling our own DoGetTextExtent().
 134     //
 135     // We need this because our DoGetTextExtent() typically only works with
 136     // native DCs, i.e. those having an HDC under Windows or using Pango under
 137     // GTK+. However wxTextMeasure object can be constructed for any wxDC, not
 138     // necessarily a native one and in this case we must call back into the DC
 139     // implementation of text measuring itself.
 140     bool m_useDCImpl;
 141
 142     // This one can be NULL or not.
 143     const wxFont* const m_font;
 144
 145     wxDECLARE_NO_COPY_CLASS(wxTextMeasureBase);
 146 };
 147
 148 // Include the platform dependant class declaration, if any.
 149 #if defined(__WXGTK20__)
 150     #include "wx/gtk/private/textmeasure.h"
 151 #elif defined(__WXMSW__)
 152     #include "wx/msw/private/textmeasure.h"
 153 #else // no platform-specific implementation of wxTextMeasure yet
 154     #include "wx/generic/private/textmeasure.h"
 155
 156     #define wxUSE_GENERIC_TEXTMEASURE 1
 157 #endif
 158
 159 #ifndef wxUSE_GENERIC_TEXTMEASURE
 160     #define wxUSE_GENERIC_TEXTMEASURE 0
 161 #endif
 162
 163 #endif // _WX_PRIVATE_TEXTMEASURE_H_