gls_ctl_text_box.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsCTLTextBox class.
 
  \par Copyright Information
 
  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
 
#ifndef INCLUDED_GLS_CTL_TEXT_BOX_H
#define INCLUDED_GLS_CTL_TEXT_BOX_H
 
// CTL Text box does not work for WebGL due to issues with the Pango library and its dependencies
// CTL Text boxes will fall back to stock GlsTextBoxes, and any CTL functions will do nothing.
// GLS-5903: Remove Pango from CTL Text Box
#if defined( EMSCRIPTEN )
#    define GLS_CTL_FALLBACK_ENABLED
#    ifndef GLES
#        error "GLES should always be enabled when using the CTL fallback code"
#    endif
#endif
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSCTLTEXTBOX ) || defined( GLSGEN_IMPORT_GLSCTLTEXTBOX ) || defined( GLSGEN_GLSCTLTEXTBOX_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSCTLTEXTBOX ) || defined( GLSGEN_GLSCTLTEXTBOX_EXPORT_GENERATED )
#        define GLSGEN_GLSCTLTEXTBOX_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSCTLTEXTBOX_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSCTLTEXTBOX_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
#include "gls_cpp_lang_support.h"
#include "gls_gl.h"
#include "scoped_ptr.h"
#include "unhide_globals.h"
#include <string>
 
#ifndef GLS_CTL_FALLBACK_ENABLED
#    include "gls_text.h"
/// Base class to use for GlsCTLTextBox, used to support platforms that don't support CTL.
#    define CTL_BASE_CLASS GlsText
#else
#    include "gls_text_box.h"
#    define CTL_BASE_CLASS GlsTextBox
#endif
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_ctl_text_box"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
// Force inclusion of the pango libraries
#ifdef WIN32
#    if !defined( NO_GLS_AUTOLIB ) && !defined( GLS_IMPORT_LIBRARY )
#        ifdef _WIN64
#            define PANGO_SUFFIX "_64"
#        else
#            define PANGO_SUFFIX ""
#        endif
#        pragma message( "Will automatically link with libfontconfig" PANGO_SUFFIX "-1.0.lib" )
#        pragma message( "Will automatically link with libpango" PANGO_SUFFIX "-1.0.lib" )
#        pragma message( "Will automatically link with libpangoft2" PANGO_SUFFIX "-1.0.lib" )
#        pragma message( "Will automatically link with libgobject" PANGO_SUFFIX "-2.0.lib" )
#        pragma comment( lib, "libfontconfig" PANGO_SUFFIX "-1.0.lib" )
#        pragma comment( lib, "libpango" PANGO_SUFFIX "-1.0.lib" )
#        pragma comment( lib, "libpangoft2" PANGO_SUFFIX "-1.0.lib" )
#        pragma comment( lib, "libgobject" PANGO_SUFFIX "-2.0.lib" )
#    endif
#endif
 
namespace disti
{
// Forward Declarations
#ifndef GLS_CTL_FALLBACK_ENABLED
class GlsPangoWrapper;
struct PangoRect;
#else
class GlsTextBoxFontRenderer;
#endif // GLS_CTL_FALLBACK_ENABLED
 
#ifdef GLES
class GlsGloFileAttribute;
class GlsStateManager;
class GlsQuadListVCT_2D;
#endif // GLES
 
//===========================================================================
/** \brief The Gls CTL (Complex Text Layout) Text Box.
  * 
  * On certain platforms, the text layout library is unavailable, and complex text rendering in the runtime will be missing.
  * 
  * To account for this, the GlsCTLTextBox will 'Fallback' to being treated as a GlsTextBox.  In those cases, certain 
  * GlsCTLTextBox functions will not have no effect.
  */
class GlsCTLTextBox : public CTL_BASE_CLASS
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef CTL_BASE_CLASS _BaseClass; ///< Deprecated typedef for the base class.
    typedef CTL_BASE_CLASS BaseClass;  ///< Typedef for the base class.
 
    /** The internal border between the layout edges and the glyph edges.
      * This will keep the glyph edges from appearing cut-off when linear texture filtering is applied. 
      */
    static const unsigned int INTERNAL_BORDER = 1;
 
    friend class GlsCTLTextBoxEditor;
 
#ifndef GLS_CTL_FALLBACK_ENABLED
    /** The vertical alignment types. */
    enum VerticalAlignment_t{
        ALIGN_CENTER,
        ALIGN_TOP,
        ALIGN_BOTTOM
    };
#else
    typedef Align_t VerticalAlignment_t;
#endif // GLS_CTL_FALLBACK_ENABLED
 
    /** Deprecated */
    enum VerticalAlignmentCTL_t
    {
        VERTICAL_ALIGNMENT_CENTER = ALIGN_CENTER,
        VERTICAL_ALIGNMENT_TOP    = ALIGN_TOP,
        VERTICAL_ALIGNMENT_BOTTOM = ALIGN_BOTTOM
    };
 
    /** The ellipsize mode types. */
    enum EllipsizeMode_t
    {
        ELLIPSIZE_MODE_NONE,
        ELLIPSIZE_MODE_START,
        ELLIPSIZE_MODE_MIDDLE,
        ELLIPSIZE_MODE_END
    };
 
    /**
     * The text direction types.
     * TEXT_DIRECTION_LTR          - Use Left to Right as the base direction for rendering text.
     * TEXT_DIRECTION_RTL          - Use Right to Left as the base direction for rendering text.
     * TEXT_DIRECTION_AUTOMATIC    - Determine the base direction for rendering text from the first strongly directioned character.
     * TEXT_DIRECTION_AUTO_BY_LINE - Determine the base direction for rendering text for each individual EOL-seperated line in the text string.
     */
    enum TextDirection_t
    {
        TEXT_DIRECTION_LTR,
        TEXT_DIRECTION_RTL,
        TEXT_DIRECTION_AUTOMATIC,
        TEXT_DIRECTION_AUTO_BY_LINE
    };
 
#ifndef GLS_CTL_FALLBACK_ENABLED
    /// The resize behavior types.
    enum ResizeMode_t{
        RESIZE_MODE_FIXED,
        RESIZE_MODE_AUTO_WIDTH,
        RESIZE_MODE_AUTO_HEIGHT
    };
#endif
 
    /** The structure returned to the caller when getting the glyph metrics.
      * These are in logical units, relative to the bottom-left corner of the text box.
      */
    struct GlyphMetrics
    {
        float minX; ///< Minimum X in logical units.
        float minY; ///< Minimum Y in logical units.
        float maxX; ///< Maximum X in logical units.
        float maxY; ///< Maximum Y in logical units.
 
        GlyphMetrics()
            : minX( 0.0f )
            , minY( 0.0f )
            , maxX( 0.0f )
            , maxY( 0.0f )
        {}
    };
 
    /** Default constructor. */
    GLSGEN_GLSCTLTEXTBOX_EXPORT GlsCTLTextBox();
 
    /** The copy constructor for GlsCTLTextBox
     * 
     * \param that          The GlsCTLTextBox object that is being copied
     * \param generateNames Whether or not to generate a new instance name
     */
    GLSGEN_GLSCTLTEXTBOX_EXPORT GlsCTLTextBox( const GlsCTLTextBox& that, const bool generateNames );
 
    /** Destructor.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT ~GlsCTLTextBox();
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLS_CTL_FALLBACK_ENABLED
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
 
    /** Print a string into this text object.
      * Replaces the entire string.
      * \param format  printf style varargs formatting string.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void VaString( const char* format, ... );
 
    /// Set the vertical alignment for this text object.
    /// \param verticalAlignment The vertical alignment type.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void VerticalAlignment( VerticalAlignment_t verticalAlignment );
 
    /// Set the vertical alignment for this text object.
    /// \param verticalAlignment The vertical alignment type.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void VerticalAlignment( VerticalAlignmentCTL_t verticalAlignment ) { VerticalAlignment( static_cast<VerticalAlignment_t>( verticalAlignment ) ); }
#else
 
    /** Set the vertical alignment for this text object
      * \param[in] verticalAlignment The vertical alignment type.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void VerticalAlignment( VerticalAlignment_t verticalAlignment ) { BaseClass::VerticalAlignment( verticalAlignment ); }
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void VerticalAlignment( VerticalAlignmentCTL_t verticalAlignment );
 
#endif // GLS_CTL_FALLBACK_ENABLED
 
    /** Get the vertical alignment for this text object
      * \return The vertical alignment type.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT VerticalAlignment_t VerticalAlignment();
 
#ifndef GLES
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
 
#endif // GLES
 
    /** Rebuilds this text box layout.  This may be an expensive call, so it should only be called when a property changes.   */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void Rebuild();
 
    // NO CTL-only functions should be disabled when using the GlsTextBox fallback.
    // They should be available to every runtime, even if they do nothing.
 
    /** Gets the type of automatic ellipsize if the text does not fit in the boundary.
      * \return The type of automatic ellipsize if the text does not fit in the boundary.
      * \note In CTL Fallback mode, returns ELLIPSIZE_MODE_NONE.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT EllipsizeMode_t EllipsizeMode();
 
    /** Sets the type of automatic ellipsize if the text does not fit in the boundary.
      * \param[in] ellipsizeMode The type of automatic ellipsize if the text does not fit in the boundary.
      * \note In CTL Fallback mode, has no effect.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void EllipsizeMode( const EllipsizeMode_t ellipsizeMode );
 
    /** Gets the number of lines in the layout.
      * \return The number of lines in the layout.
      * \note In CTL Fallback mode, returns 0.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT unsigned int GetLineCount();
 
    /** Gets the number of glyphs in the layout.
      * \return The number of glyphs in the layout.
      * \note In CTL Fallback mode, returns 0.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT unsigned int GetGlyphCount();
 
    /** Gets the glyph metrics for the given glyph index.
      * \param[in] glyphIndex The index of the glyph in the layout line to get the glyph metrics for.
      * \return The glyph metrics for the given glyph index.
      * \note In CTL Fallback mode, returns a default GlyphMetrics struct.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT GlyphMetrics GetGlyphMetrics( const unsigned int glyphIndex );
 
    /// Set the Pango Layout auto dir, exposes pango_layout_set_auto_dir ()
    /// see: https://developer.gnome.org/pango/stable/pango-Layout-Objects.html#pango-layout-set-auto-dir
    /// \param[in] autoDir Whether or not the layout should automatically determine base direction based on content
    /// \note In CTL Fallback mode, has no effect.
    /// \deprecated
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetLayoutAutoDir( bool autoDir ){};
 
    /// Set width used to render the text.  If the width of the vertices is smaller than this width, the text will be truncated.  If the
    /// value is 0.0, the text will be rendered to the full width of the vertices
    /// \note In CTL Fallback mode, has no effect.
    /// \param width The new width to set.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetAltWidth( float width );
 
    /// Set height used to render the text.  If the height of the vertices is smaller than this height, the text will be truncated.  If the
    /// value is 0.0, the text will be rendered to the full height of the vertices
    /// \note In CTL Fallback mode, has no effect.
    /// \param height The new height to set.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetAltHeight( float height );
 
    /** Scales the text horizontally by the given value.  Text is still clamped by the bounds of the text box 
      * \param value the horizontal scale
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void TextHorizontalScale( float value );
 
    /// \return The current horizontal scale.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT float TextHorizontalScale();
 
    /** Scales the text vertically by the given value.  Text is still clamped by the bounds of the text box 
      * \param value the vertical scale
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void TextVerticalScale( float value );
 
    /// \return The current vertical scale.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT float TextVerticalScale();
 
    /** Gets the base direction used in applying the Unicode bidirectional algorithm.
      * \return the text direction
      * \note In CTL Fallback mode, returns TEXT_DIRECTION_AUTOMATIC.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT TextDirection_t TextDirection();
 
    /** Sets the base direction used in applying the Unicode bidirectional algorithm.
      * \param[in] textDirection The text direction.
      * \note In CTL Fallback mode, has no effect.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void TextDirection( const TextDirection_t textDirection );
 
    bool RequiresFontFile() const DISTI_METHOD_OVERRIDE
    {
        return true;
    }
 
#ifndef GLS_CTL_FALLBACK_ENABLED
    /// Set the resize behavior for this object.
    /// \param value The new resize behavior.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void ResizeMode( ResizeMode_t value );
 
    /// \return The current resize behavior for this object.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT ResizeMode_t ResizeMode();
 
    /// Set the maximum resize width for this object in logical units.
    /// \param value The new maximum width.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void MaxWidth( float value );
 
    /// \return The current maximum resize width for this object in logical units.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT float MaxWidth();
 
    /// Set the maximum resize height for this object in logical units.
    /// \param value The new maximum height.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void MaxHeight( float value );
 
    /// \return The current maximum resize height for this object in logical units.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT float MaxHeight();
#endif
 
#ifdef GLES20
    /** Re-enables automatic pixel alignment behavior that was always active by default prior to 7.0
      * This flag should be enabled at the start of the program if your design relied on this behavior in a previous version of GL Studio.
      * \param enabled the new state for the alignment behavior flag 
      */
    GLSGEN_GLSCTLTEXTBOX_EXPORT static void SetAutomaticPixelAlignmentEnabled( const bool enabled );
#endif
 
protected:
#ifndef GLS_CTL_FALLBACK_ENABLED
    /** Width used to render the text */
    float _altWidth;
    /** Height used to render the text */
    float _altHeight;
 
    /** the horizontal scale */
    float _textHorizontalScale;
    /** the vertical scale */
    float _textVerticalScale;
 
    /** Pointer to the internal data needed for Pango. */
    ScopedPtr<GlsPangoWrapper> _glsPangoWrapper;
 
    /** makes adjustment to the image verts and texture coords for the alt width / height and text scaling properties
      * \param[inout] verts the image verts
      * \param[inout] texCoords the image texture coords
      */
    void AdjustImageVertsAndCoords( PangoRect& verts, PangoRect& texCoords );
 
    /// Used internally to apply scale when rendering text.
    /// \note Not normally called by users.
    /// \param textBoxWidth The width of the box in logical units.
    /// \param textBoxHeight The height of the box in logical units.
    /// \param verts The returned bounding rectangle.
    void ApplyTextScale( float textBoxWidth, float textBoxHeight, PangoRect& verts );
 
    /// Used internally to clamp when rendering text.
    /// \note Not normally called by users.
    /// \param textBoxWidth The width of the box in logical units.
    /// \param textBoxHeight The height of the box in logical units.
    /// \param verts The returned bounding rectangle.
    /// \param texCoords The returned texture coordinate rectangle.
    void ClampToTextBoxSize( float textBoxWidth, float textBoxHeight, PangoRect& verts, PangoRect& texCoords );
 
    /// Used internally to apply vertical alignment when rendering text.
    /// \note Not normally called by users.
    /// \param textBoxHeight The height of the box in logical units.
    /// \param verts The returned bounding rectangle.
    void ApplyVerticalAlignment( float textBoxHeight, PangoRect& verts );
 
#    ifdef GLES20
    /** State of automatic pixel alignment behavior flag */
    static bool s_isAutomaticPixelAlignmentEnabled;
#    endif
 
    TextDirection_t _textDirection; ///< Text direction behavior for this object.
 
#    ifndef GLS_CTL_FALLBACK_ENABLED
    ResizeMode_t _resizeMode;      ///< Resize behavior for this object.
    float        _resizeMaxWidth;  ///< Maximum resize width in logical units.
    float        _resizeMaxHeight; ///< Maximum resize height in logical units.
#    endif
 
#endif // GLS_CTL_FALLBACK_ENABLED
 
#ifdef GLES
 
    // See DisplayObject
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
 
#    ifndef GLS_CTL_FALLBACK_ENABLED
    /** The list of quads to draw for the shadows. */
    ScopedPtr<GlsQuadListVCT_2D> _shadows;
    /** The list of quads to draw for the characters. */
    ScopedPtr<GlsQuadListVCT_2D> _characters;
 
    /** True if _geometryRefresh was true in PreDraw.  This is just so we can rebuild the quads in Draw(). */
    bool _geometryRefreshDraw;
 
    /** Populate the quad storage
      * \param stateManager  
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void PopulateQuadStorage( IGlsStateManager* stateManager );
 
    /** Draws the polygons that make up the characters.
      * \param stateManager  
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void DrawText( IGlsStateManager* stateManager );
#    endif // GLS_CTL_FALLBACK_ENABLED
 
#else
    /** Draws the polygons that make up the characters.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void DrawText();
#endif // GLES
#ifndef GLS_CTL_FALLBACK_ENABLED
    /** Rebuilds the vertices of the text box.
      */
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void RecalcVertices();
 
    /// Set the size of the CTL text box to the incoming Pango rectangle's size.
    /// \param verts The new size to set to.
    /// \param keepWidth Whether or not to ignore changes to the object's width.
    virtual GLSGEN_GLSCTLTEXTBOX_EXPORT void SetVerticesToImageSize( const PangoRect& verts, bool keepWidth );
#endif // GLS_CTL_FALLBACK_ENABLED
 
private:
    void OnCellDimensionChanged() DISTI_METHOD_OVERRIDE
    {
        // Prevent changing cell dimensions for CTL Textbox
        _cellHeight = 0;
        _cellWidth  = 0;
        ControlCellSize( false );
    }
 
    GlsCTLTextBox& operator=( const GlsCTLTextBox& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsCTLTextBox( const GlsCTLTextBox& ) DISTI_SPECIAL_MEM_FUN_DELETE;
};
 
#ifndef GLS_CTL_FALLBACK_ENABLED
 
/// In stream operator for VerticalAlignment_t enumeration.
/// \param instr The stream to read from.
/// \param verticalAlignment The returned alignment to be read from stream.
/// \return The stream in its current state.
inline std::istream& operator>>( std::istream& instr, disti::GlsCTLTextBox::VerticalAlignment_t& verticalAlignment )
{
    std::string str;
    instr >> str;
 
    if( str == "ALIGN_TOP" || str == "VERTICAL_ALIGNMENT_TOP" )
    {
        verticalAlignment = disti::GlsCTLTextBox::ALIGN_TOP;
    }
    else if( str == "ALIGN_CENTER" || str == "VERTICAL_ALIGNMENT_CENTER" )
    {
        verticalAlignment = disti::GlsCTLTextBox::ALIGN_CENTER;
    }
    else if( str == "ALIGN_BOTTOM" || str == "VERTICAL_ALIGNMENT_BOTTOM" )
    {
        verticalAlignment = disti::GlsCTLTextBox::ALIGN_BOTTOM;
    }
    return instr;
}
 
/// Out stream operator for VerticalAlignment_t enumeration.
/// \param outstr The stream to write to.
/// \param verticalAlignment The alignment to write to the stream.
/// \return The stream in its current state.
inline std::ostream& operator<<( std::ostream& outstr, disti::GlsCTLTextBox::VerticalAlignment_t verticalAlignment )
{
    switch( verticalAlignment )
    {
    case disti::GlsCTLTextBox::ALIGN_TOP:
        outstr << "ALIGN_TOP";
        break;
    case disti::GlsCTLTextBox::ALIGN_CENTER:
        outstr << "ALIGN_CENTER";
        break;
    case disti::GlsCTLTextBox::ALIGN_BOTTOM:
        outstr << "ALIGN_BOTTOM";
        break;
    }
    return outstr;
}
#endif // GLS_CTL_FALLBACK_ENABLED
 
/// In stream operator for EllipsizeMode_t enumeration.
/// \param instr The stream to read from.
/// \param ellipsizeMode The returned mode to be read from stream.
/// \return The stream in its current state.
inline std::istream& operator>>( std::istream& instr, disti::GlsCTLTextBox::EllipsizeMode_t& ellipsizeMode )
{
    std::string str;
    instr >> str;
 
    if( str == "ELLIPSIZE_MODE_NONE" )
    {
        ellipsizeMode = disti::GlsCTLTextBox::ELLIPSIZE_MODE_NONE;
    }
    else if( str == "ELLIPSIZE_MODE_START" )
    {
        ellipsizeMode = disti::GlsCTLTextBox::ELLIPSIZE_MODE_START;
    }
    else if( str == "ELLIPSIZE_MODE_MIDDLE" )
    {
        ellipsizeMode = disti::GlsCTLTextBox::ELLIPSIZE_MODE_MIDDLE;
    }
    else if( str == "ELLIPSIZE_MODE_END" )
    {
        ellipsizeMode = disti::GlsCTLTextBox::ELLIPSIZE_MODE_END;
    }
    return instr;
}
 
/// Out stream operator for EllipsizeMode_t enumeration.
/// \param outstr The stream to write to.
/// \param ellipsizeMode The mode to write to the stream.
/// \return The stream in its current state.
inline std::ostream& operator<<( std::ostream& outstr, disti::GlsCTLTextBox::EllipsizeMode_t ellipsizeMode )
{
    switch( ellipsizeMode )
    {
    case disti::GlsCTLTextBox::ELLIPSIZE_MODE_NONE:
        outstr << "ELLIPSIZE_MODE_NONE";
        break;
    case disti::GlsCTLTextBox::ELLIPSIZE_MODE_START:
        outstr << "ELLIPSIZE_MODE_START";
        break;
    case disti::GlsCTLTextBox::ELLIPSIZE_MODE_MIDDLE:
        outstr << "ELLIPSIZE_MODE_MIDDLE";
        break;
    case disti::GlsCTLTextBox::ELLIPSIZE_MODE_END:
        outstr << "ELLIPSIZE_MODE_END";
        break;
    }
    return outstr;
}
 
/// In stream operator for TextDirection_t enumeration.
/// \param instr The stream to read from.
/// \param direction The returned direction to be read from stream.
/// \return The stream in its current state.
inline std::istream& operator>>( std::istream& instr, disti::GlsCTLTextBox::TextDirection_t& direction )
{
    std::string str;
    instr >> str;
 
    if( str == "TEXT_DIRECTION_LTR" )
    {
        direction = disti::GlsCTLTextBox::TEXT_DIRECTION_LTR;
    }
    else if( str == "TEXT_DIRECTION_RTL" )
    {
        direction = disti::GlsCTLTextBox::TEXT_DIRECTION_RTL;
    }
    else if( str == "TEXT_DIRECTION_AUTOMATIC" )
    {
        direction = disti::GlsCTLTextBox::TEXT_DIRECTION_AUTOMATIC;
    }
    else if( str == "TEXT_DIRECTION_AUTO_BY_LINE" )
    {
        direction = disti::GlsCTLTextBox::TEXT_DIRECTION_AUTO_BY_LINE;
    }
    return instr;
}
 
/// Out stream operator for TextDirection_t enumeration.
/// \param outstr The stream to write to.
/// \param direction The direction to write to the stream.
/// \return The stream in its current state.
inline std::ostream& operator<<( std::ostream& outstr, disti::GlsCTLTextBox::TextDirection_t direction )
{
    switch( direction )
    {
    case disti::GlsCTLTextBox::TEXT_DIRECTION_LTR:
        outstr << "TEXT_DIRECTION_LTR";
        break;
    case disti::GlsCTLTextBox::TEXT_DIRECTION_RTL:
        outstr << "TEXT_DIRECTION_RTL";
        break;
    case disti::GlsCTLTextBox::TEXT_DIRECTION_AUTOMATIC:
        outstr << "TEXT_DIRECTION_AUTOMATIC";
        break;
    case disti::GlsCTLTextBox::TEXT_DIRECTION_AUTO_BY_LINE:
        outstr << "TEXT_DIRECTION_AUTO_BY_LINE";
        break;
    }
    return outstr;
}
 
#ifndef GLS_CTL_FALLBACK_ENABLED
/// In stream operator for ResizeMode_t enumeration.
/// \param instr The stream to read from.
/// \param resizeMode The returned mode to be read from stream.
/// \return The stream in its current state.
inline std::istream& operator>>( std::istream& instr, disti::GlsCTLTextBox::ResizeMode_t& resizeMode )
{
    std::string str;
    instr >> str;
 
    if( str == "RESIZE_MODE_FIXED" )
    {
        resizeMode = disti::GlsCTLTextBox::RESIZE_MODE_FIXED;
    }
    else if( str == "RESIZE_MODE_AUTO_WIDTH" )
    {
        resizeMode = disti::GlsCTLTextBox::RESIZE_MODE_AUTO_WIDTH;
    }
    else if( str == "RESIZE_MODE_AUTO_HEIGHT" )
    {
        resizeMode = disti::GlsCTLTextBox::RESIZE_MODE_AUTO_HEIGHT;
    }
    return instr;
}
 
/// Out stream operator for ResizeMode_t enumeration.
/// \param outstr The stream to write to.
/// \param resizeMode The mode to write to the stream.
/// \return The stream in its current state.
inline std::ostream& operator<<( std::ostream& outstr, disti::GlsCTLTextBox::ResizeMode_t resizeMode )
{
    switch( resizeMode )
    {
    case disti::GlsCTLTextBox::RESIZE_MODE_FIXED:
        outstr << "RESIZE_MODE_FIXED";
        break;
    case disti::GlsCTLTextBox::RESIZE_MODE_AUTO_WIDTH:
        outstr << "RESIZE_MODE_AUTO_WIDTH";
        break;
    case disti::GlsCTLTextBox::RESIZE_MODE_AUTO_HEIGHT:
        outstr << "RESIZE_MODE_AUTO_HEIGHT";
        break;
    }
    return outstr;
}
#endif
 
} // namespace disti
 
#endif // INCLUDED_GLS_CTL_TEXT_BOX_H