VRS - The Virtual Rendering System

version 3.3

abstracttext.h

Go to the documentation of this file.

 /**********************************************************************
 VRS - The Virtual Rendering System
 Copyright (C) 2001 Computer Graphics Systems Group at the 
 Hasso-Plattner-Institute, Potsdam, Germany.
 This library is free software; you can redistribute it and/or 
 modify it under the terms of the GNU Lesser General Public 
 License as published by the Free Software Foundation; either 
 version 2.1 of the License, or (at your option) any later version.
 This library is distributed in the hope that it will be useful, but 
 WITHOUT ANY WARRANTY; without even the implied warranty of 
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
 See the GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser+ General Public
 License along with this library; if not, write to the FreeSoftware 
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA, 02111-1307, USA.
 **********************************************************************/


#ifndef __ABSTRACTTEXT_H__
#define __ABSTRACTTEXT_H__

#include <vrs/shape.h>
#include <string>
#include <set>
#include <list>

#include <vrs/text/vrs_textprerequisites.h>
#include <vrs/text/fontdefinition.h>

namespace VRS
{
namespace TEXT
{
        
        class VRS_CORE_API AbstractText : public Shape
        {
                public: 
            enum HorizontalAlignment { LEFT, RIGHT, CENTER };
            VRS_SERIALIZABLE_CLASS_ENUM(HorizontalAlignment);
                enum VerticalAlignment { TOP, BOTTOM, MIDDLE };
            VRS_SERIALIZABLE_CLASS_ENUM(VerticalAlignment);
                enum Direction { HORIZONTAL, VERTICAL };
            VRS_SERIALIZABLE_CLASS_ENUM(Direction);
                enum HorizontalDirection { LEFTTORIGHT, RIGHTTOLEFT };
            VRS_SERIALIZABLE_CLASS_ENUM(HorizontalDirection);
                enum VerticalDirection { TOPTOBOTTOM, BOTTOMTOTOP };
            VRS_SERIALIZABLE_CLASS_ENUM(VerticalDirection);

                enum TextPlane { TP_XY_z, TP_XY_Z, TP_XZ_y, TP_XZ_Y, TP_YZ_x, TP_YZ_X };


                        virtual ~AbstractText() {};

//------- The text-contents

#ifdef VRS_HAS_WSTRING     // Has Unicode support

                        virtual const std::wstring& getText() const = 0;
                        virtual void setText(const std::wstring& str) = 0;
#else                      // Has no Unicode support

                        virtual const std::string& getText() const = 0;
#endif
                        virtual void setText(const std::string& str) = 0;


//------- FontDefinition

                        virtual SO<FontDefinition> getFontDefinition( ) const = 0;
                        virtual void setFontDefinition( SO<FontDefinition> ) = 0;

//------- Alignment and AbstractText::Direction

                        virtual HorizontalAlignment getHorizontalAlignment() const = 0;
            virtual void setHorizontalAlignment(HorizontalAlignment tva) = 0;
                        virtual VerticalAlignment getVerticalAlignment() const = 0;
                        virtual void setVerticalAlignment(VerticalAlignment tva) = 0;
            virtual HorizontalDirection getHorizontalDirection() const = 0;
                virtual void setHorizontalDirection(HorizontalDirection thd) = 0;
            virtual VerticalDirection getVerticalDirection() const = 0;
                virtual void setVerticalDirection(VerticalDirection thd) = 0;
            virtual AbstractText::Direction getDirection() const = 0;
                virtual void setDirection(AbstractText::Direction td) = 0;

                        virtual void setAlignmentBounds( float rightBorder, float bottomBorder ) = 0;
                        virtual void setRightAlignmentBound(float rightBorder) = 0;
                        virtual void setBottomAlignmentBound(float bottomBorder) = 0;
            virtual float getRightAlignmentBound() const = 0;
            virtual float getBottomAlignmentBound() const = 0;


//------- Line Spacing

                        virtual float getLineSpacing() const = 0;
                        virtual void setLineSpacing(float LineSpacing) = 0;
                

//------- Text Color

                        virtual void setColor( const Color& color, bool use = true ) = 0;
                        virtual Color getColor() const = 0;
            virtual bool useColor() const = 0;

//------- Text Offset, Scaling and Axis

                        virtual Matrix getMatrix() const = 0;
                        virtual void setMatrix( const Matrix& m ) = 0;
            virtual void setMatrix( AbstractText::TextPlane tp, 
                                const Vector& offset=Vector(0,0,0), const Vector& scale=Vector(1,1,1) )
                        {
                                setMatrix( AbstractText::buildMatrix(tp,offset,scale) );
                        };
                        static Matrix buildMatrix( TextPlane tp, const Vector& offset=Vector(0,0,0), const Vector& scale=Vector(1,1,1) )
                        {       
                                Matrix ret;

                // the rotation
                                switch( tp )
                                {
                                default:
                                case TP_XY_z:
                                        ret = Matrix::identity;
                                        break;          
                                case TP_XY_Z:
                                        ret = Matrix::rotation(Vector(0,1,0),Vector(0,0,0),180);
                                        break;
                                case TP_XZ_y:
                                        ret = Matrix::rotation(Vector(1,0,0),Vector(0,0,0),90);
                                        break;
                                case TP_XZ_Y:
                                        ret = Matrix::rotation(Vector(0,0,1),Vector(0,0,0),180)*Matrix::rotation(Vector(1,0,0),Vector(0,0,0),90);
                                        break;
                                case TP_YZ_x:
                                        ret = Matrix::rotation(Vector(1,0,0),Vector(0,0,0),90)*Matrix::rotation(Vector(0,1,0),Vector(0,0,0),90);
                                        break;
                                case TP_YZ_X:
                                        ret = Matrix::rotation(Vector(1,0,0),Vector(0,0,0),90)*Matrix::rotation(Vector(0,1,0),Vector(0,0,0),-90);
                                        break;
                                }

                // offset
                                if( offset != Vector(0,0,0) )
                                        ret = ret * Matrix::translation(offset);
                // scaling
                                if( scale != Vector(1,1,1) )
                                        ret = ret * Matrix::scaling(scale);

                                return ret;
                        };
 

//------- Shape rendering

                        virtual Bounds boundingBox() const = 0;
            virtual Bounds getLocalBounds() const = 0;

                        VRS_TYPEINFO(AbstractText, Shape);
        };
}
}

#endif

---

Generated on Wed May 22 06:00:16 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact