Cpper
C/C++高级工程师 Android高级软件工程师 IT集成工程师 音频工程师 熟悉c,c++,java,c#,py,js,asp等多种语言 程序猿
QCustomPlot和QWt各有千秋
前者偏轻,但是功能有点弱了,可以修改QCustomPlot增加Qwt的一些模块和类

如下 代码为QComstomPlot使用QwtText的例子
class QwtText : public  QCPLayerable
{
public:

    
/*!
      \brief Text format

      The text format defines the QwtTextEngine, that is used to render
      the text.

      \sa QwtTextEngine, setTextEngine()
    
*/

    
enum TextFormat
    {
        
/*!
          The text format is determined using QwtTextEngine::mightRender() for
          all available text engines in increasing order > PlainText.
          If none of the text engines can render the text is rendered
          like QwtText::PlainText.
         
*/
        AutoText 
= 0,

        
//! Draw the text as it is, using a QwtPlainTextEngine.
        PlainText,

        
//! Use the Scribe framework (Qt Rich Text) to render the text.
        RichText,

        
/*!
          Use a MathML (
http://en.wikipedia.org/wiki/MathML) render engine
          to display the text. The Qwt MathML extension offers such an engine
          based on the MathML renderer of the Qt solutions package. 
          To enable MathML support the following code needs to be added to the
          application:
\verbatim QwtText::setTextEngine(QwtText::MathMLText, new QwtMathMLTextEngine()); \endverbatim
         
*/
        MathMLText,

        
/*!
          Use a TeX (
http://en.wikipedia.org/wiki/TeX) render engine
          to display the text ( not implemented yet ).
         
*/
        TeXText,

        
/*!
          The number of text formats can be extended using setTextEngine.
          Formats >= QwtText::OtherFormat are not used by Qwt.
         
*/
        OtherFormat 
= 100
    };

    
/*!
      \brief Paint Attributes

      Font and color and background are optional attributes of a QwtText.
      The paint attributes hold the information, if they are set.
    
*/
    
enum PaintAttribute
    {
        
//! The text has an individual font.
        PaintUsingTextFont = 0x01,

        
//! The text has an individual color.
        PaintUsingTextColor = 0x02,

        
//! The text has an individual background.
        PaintBackground = 0x04
    };

    
//! Paint attributes
    typedef QFlags<PaintAttribute> PaintAttributes;

    
/*!
      \brief Layout Attributes
      The layout attributes affects some aspects of the layout of the text.
    
*/
    
enum LayoutAttribute
    {
        
/*!
          Layout the text without its margins. This mode is useful if a
          text needs to be aligned accurately, like the tick labels of a scale.
          If QwtTextEngine::textMargins is not implemented for the format
          of the text, MinimumLayout has no effect.
         
*/
        MinimumLayout 
= 0x01
    };

    
//! Layout attributes
    typedef QFlags<LayoutAttribute> LayoutAttributes;

    QwtText(QCustomPlot 
*plot,const QString & = QString::null,
             TextFormat textFormat 
= AutoText );

    
~QwtText();

    
void setText( const QString &,
        QwtText::TextFormat textFormat 
= AutoText );
    QString text() 
const;

    
bool isNull() const;
    
bool isEmpty() const;

    
void setFont( const QFont & );
    QFont font() 
const;

    QFont usedFont( 
const QFont & ) const;

    
void setRenderFlags( int flags );
    
int renderFlags() const;

    
void setColor( const QColor & );
    QColor color() 
const;

    QColor usedColor( 
const QColor & ) const;

    
void setBorderRadius( double );
    
double borderRadius() const;

    
void setBorderPen( const QPen & );
    QPen borderPen() 
const;

    
void setBackgroundBrush( const QBrush & );
    QBrush backgroundBrush() 
const;

    
void setPaintAttribute( PaintAttribute, bool on = true );
    
bool testPaintAttribute( PaintAttribute ) const;

    
void setLayoutAttribute( LayoutAttribute, bool on = true );
    
bool testLayoutAttribute( LayoutAttribute ) const;

    
double heightForWidth( double width, const QFont & = QFont() ) const;
    QSizeF textSize( 
const QFont & = QFont() ) const;

    
//void draw( QPainter *painter, const QRectF &rect ) const;
    virtual void applyDefaultAntialiasingHint(QCPPainter* painter)const;
    
virtual void draw(QCPPainter* painter);

    
static const QwtTextEngine *textEngine( 
        
const QString &text, QwtText::TextFormat = AutoText );

    
static const QwtTextEngine *textEngine( QwtText::TextFormat );
    
static void setTextEngine( QwtText::TextFormat, QwtTextEngine * );

private:
    
class PrivateData;
    PrivateData 
*d_data;

    
class LayoutCache;
    LayoutCache 
*d_layoutCache;
};

//! \return text().isNull()
inline bool QwtText::isNull() const
{
    
return text().isNull();
}

//! \return text().isEmpty()
inline bool QwtText::isEmpty() const
{
    
return text().isEmpty();
}

Q_DECLARE_OPERATORS_FOR_FLAGS( QwtText::PaintAttributes )
Q_DECLARE_OPERATORS_FOR_FLAGS( QwtText::LayoutAttributes )

class QwtTextEngineDict
{
public:
    
static QwtTextEngineDict &dict();

    
void setTextEngine( QwtText::TextFormat, QwtTextEngine * );

    
const QwtTextEngine *textEngine( QwtText::TextFormat ) const;
    
const QwtTextEngine *textEngine( const QString &,
        QwtText::TextFormat ) 
const;

private:
    QwtTextEngineDict();
    
~QwtTextEngineDict();

    typedef QMap
<int, QwtTextEngine *> EngineMap;

    inline 
const QwtTextEngine *engine( EngineMap::const_iterator &it ) const
    {
        
return it.value();
    }

    EngineMap d_map;
};

QwtTextEngineDict 
&QwtTextEngineDict::dict()
{
    
static QwtTextEngineDict engineDict;
    
return engineDict;
}

QwtTextEngineDict::QwtTextEngineDict()
{
    d_map.insert( QwtText::PlainText, 
new QwtPlainTextEngine() );
#ifndef QT_NO_RICHTEXT
    d_map.insert( QwtText::RichText, 
new QwtRichTextEngine() );
#endif
}

QwtTextEngineDict::
~QwtTextEngineDict()
{
    
for ( EngineMap::const_iterator it = d_map.begin();
        it 
!= d_map.end(); ++it )
    {
        
const QwtTextEngine *textEngine = engine( it );
        delete textEngine;
    }
}

const QwtTextEngine *QwtTextEngineDict::textEngine( const QString& text,
    QwtText::TextFormat format ) 
const
{
    
if ( format == QwtText::AutoText )
    {
        
for ( EngineMap::const_iterator it = d_map.begin();
            it 
!= d_map.end(); ++it )
        {
            
if ( it.key() != QwtText::PlainText )
            {
                
const QwtTextEngine *= engine( it );
                
if ( e && e->mightRender( text ) )
                    
return e;
            }
        }
    }

    EngineMap::const_iterator it 
= d_map.find( format );
    
if ( it != d_map.end() )
    {
        
const QwtTextEngine *= engine( it );
        
if ( e )
            
return e;
    }

    it 
= d_map.find( QwtText::PlainText );
    
return engine( it );
}

void QwtTextEngineDict::setTextEngine( QwtText::TextFormat format,
    QwtTextEngine 
*engine )
{
    
if ( format == QwtText::AutoText )
        
return;

    
if ( format == QwtText::PlainText && engine == NULL )
        
return;

    EngineMap::const_iterator it 
= d_map.find( format );
    
if ( it != d_map.end() )
    {
        
const QwtTextEngine *= this->engine( it );
        
if ( e )
            delete e;

        d_map.remove( format );
    }

    
if ( engine != NULL )
        d_map.insert( format, engine );
}

const QwtTextEngine *QwtTextEngineDict::textEngine(
    QwtText::TextFormat format ) 
const
{
    
const QwtTextEngine *= NULL;

    EngineMap::const_iterator it 
= d_map.find( format );
    
if ( it != d_map.end() )
        e 
= engine( it );

    
return e;
}

class QwtText::PrivateData
{
public:
    PrivateData():
        renderFlags( Qt::AlignCenter ),
        borderRadius( 
0 ),
        borderPen( Qt::NoPen ),
        backgroundBrush( Qt::NoBrush ),
        paintAttributes( 
0 ),
        layoutAttributes( 
0 ),
        textEngine( NULL )
    {
    }

    
int renderFlags;
    QString text;
    QFont font;
    QColor color;
    
double borderRadius;
    QPen borderPen;
    QBrush backgroundBrush;

    QwtText::PaintAttributes paintAttributes;
    QwtText::LayoutAttributes layoutAttributes;

    
const QwtTextEngine *textEngine;
};

class QwtText::LayoutCache
{
public:
    
void invalidate()
    {
        textSize 
= QSizeF();
    }

    QFont font;
    QSizeF textSize;
};

/*!
   Constructor

   \param text Text content
   \param textFormat Text format
*/
QwtText::QwtText(QCustomPlot
* plot, const QString &text, QwtText::TextFormat textFormat ):
QCPLayerable(plot)
{
    d_data 
= new PrivateData;
    d_data
->text = text;
    d_data
->textEngine = textEngine( text, textFormat );

    d_layoutCache 
= new LayoutCache;
}

//! Destructor
QwtText::~QwtText()
{
    delete d_data;
    delete d_layoutCache;
}

/*!
   Assign a new text content

   \param text Text content
   \param textFormat Text format

   \sa text()
*/
void QwtText::setText( const QString &text,
    QwtText::TextFormat textFormat )
{
    d_data
->text = text;
    d_data
->textEngine = textEngine( text, textFormat );
    d_layoutCache
->invalidate();
}

/*!
   \return Text as QString.
   \sa setText()
*/
QString QwtText::text() 
const
{
    
return d_data->text;
}

/*!
   \brief Change the render flags

   The default setting is Qt::AlignCenter

   \param renderFlags Bitwise OR of the flags used like in QPainter::drawText()

   \sa renderFlags(), QwtTextEngine::draw()
   \note Some renderFlags might have no effect, depending on the text format.
*/
void QwtText::setRenderFlags( int renderFlags )
{
    
if ( renderFlags != d_data->renderFlags )
    {
        d_data
->renderFlags = renderFlags;
        d_layoutCache
->invalidate();
    }
}

/*!
   \return Render flags
   \sa setRenderFlags()
*/
int QwtText::renderFlags() const
{
    
return d_data->renderFlags;
}

/*!
   Set the font.

   \param font Font
   \note Setting the font might have no effect, when
         the text contains control sequences for setting fonts.
*/
void QwtText::setFont( const QFont &font )
{
    d_data
->font = font;
    setPaintAttribute( PaintUsingTextFont );
}

//! Return the font.
QFont QwtText::font() const
{
    
return d_data->font;
}

/*!
   Return the font of the text, if it has one.
   Otherwise return defaultFont.

   \param defaultFont Default font
   \return Font used for drawing the text

   \sa setFont(), font(), PaintAttributes
*/
QFont QwtText::usedFont( 
const QFont &defaultFont ) const
{
    
if ( d_data->paintAttributes & PaintUsingTextFont )
        
return d_data->font;

    
return defaultFont;
}

/*!
   Set the pen color used for drawing the text.

   \param color Color
   \note Setting the color might have no effect, when
         the text contains control sequences for setting colors.
*/
void QwtText::setColor( const QColor &color )
{
    d_data
->color = color;
    setPaintAttribute( PaintUsingTextColor );
}

//! Return the pen color, used for painting the text
QColor QwtText::color() const
{
    
return d_data->color;
}

/*!
  Return the color of the text, if it has one.
  Otherwise return defaultColor.

  \param defaultColor Default color
  \return Color used for drawing the text

  \sa setColor(), color(), PaintAttributes
*/
QColor QwtText::usedColor( 
const QColor &defaultColor ) const
{
    
if ( d_data->paintAttributes & PaintUsingTextColor )
        
return d_data->color;

    
return defaultColor;
}

/*!
  Set the radius for the corners of the border frame

  \param radius Radius of a rounded corner
  \sa borderRadius(), setBorderPen(), setBackgroundBrush()
*/
void QwtText::setBorderRadius( double radius )
{
    d_data
->borderRadius = qMax( 0.0, radius );
}

/*!
  \return Radius for the corners of the border frame
  \sa setBorderRadius(), borderPen(), backgroundBrush()
*/
double QwtText::borderRadius() const
{
    
return d_data->borderRadius;
}

/*!
   Set the background pen

   \param pen Background pen
   \sa borderPen(), setBackgroundBrush()
*/
void QwtText::setBorderPen( const QPen &pen )
{
    d_data
->borderPen = pen;
    setPaintAttribute( PaintBackground );
}

/*!
   \return Background pen
   \sa setBorderPen(), backgroundBrush()
*/
QPen QwtText::borderPen() 
const
{
    
return d_data->borderPen;
}

/*!
   Set the background brush

   \param brush Background brush
   \sa backgroundBrush(), setBorderPen()
*/
void QwtText::setBackgroundBrush( const QBrush &brush )
{
    d_data
->backgroundBrush = brush;
    setPaintAttribute( PaintBackground );
}

/*!
   \return Background brush
   \sa setBackgroundBrush(), borderPen()
*/
QBrush QwtText::backgroundBrush() 
const
{
    
return d_data->backgroundBrush;
}

/*!
   Change a paint attribute

   \param attribute Paint attribute
   \param on On/Off

   \note Used by setFont(), setColor(),
         setBorderPen() and setBackgroundBrush()
   \sa testPaintAttribute()
*/
void QwtText::setPaintAttribute( PaintAttribute attribute, bool on )
{
    
if ( on )
        d_data
->paintAttributes |= attribute;
    
else
        d_data
->paintAttributes &= ~attribute;
}

/*!
   Test a paint attribute

   \param attribute Paint attribute
   \return true, if attribute is enabled

   \sa setPaintAttribute()
*/
bool QwtText::testPaintAttribute( PaintAttribute attribute ) const
{
    
return d_data->paintAttributes & attribute;
}

/*!
   Change a layout attribute

   \param attribute Layout attribute
   \param on On/Off
   \sa testLayoutAttribute()
*/
void QwtText::setLayoutAttribute( LayoutAttribute attribute, bool on )
{
    
if ( on )
        d_data
->layoutAttributes |= attribute;
    
else
        d_data
->layoutAttributes &= ~attribute;
}

/*!
   Test a layout attribute

   \param attribute Layout attribute
   \return true, if attribute is enabled

   \sa setLayoutAttribute()
*/
bool QwtText::testLayoutAttribute( LayoutAttribute attribute ) const
{
    
return d_data->layoutAttributes | attribute;
}

/*!
   Find the height for a given width

   \param defaultFont Font, used for the calculation if the text has no font
   \param width Width

   \return Calculated height
*/
double QwtText::heightForWidth( double width, const QFont &defaultFont ) const
{
    
// We want to calculate in screen metrics. So
    
// we need a font that uses screen metrics

    
const QFont font( usedFont( defaultFont ), QApplication::desktop() );

    
double h = 0;

    
if ( d_data->layoutAttributes & MinimumLayout )
    {
        
double left, right, top, bottom;
        d_data
->textEngine->textMargins( font, d_data->text,
            left, right, top, bottom );

        h 
= d_data->textEngine->heightForWidth(
            font, d_data
->renderFlags, d_data->text,
            width 
+ left + right );

        h 
-= top + bottom;
    }
    
else
    {
        h 
= d_data->textEngine->heightForWidth(
            font, d_data
->renderFlags, d_data->text, width );
    }

    
return h;
}

/*!
   Find the height for a given width

   \param defaultFont Font, used for the calculation if the text has no font

   \return Calculated height
*/

/*!
   Returns the size, that is needed to render text

   \param defaultFont Font of the text
   \return Caluclated size
*/
QSizeF QwtText::textSize( 
const QFont &defaultFont ) const
{
    
// We want to calculate in screen metrics. So
    
// we need a font that uses screen metrics

    
const QFont font( usedFont( defaultFont ), QApplication::desktop() );

    
if ( !d_layoutCache->textSize.isValid()
        
|| d_layoutCache->font != font )
    {
        d_layoutCache
->textSize = d_data->textEngine->textSize(
            font, d_data
->renderFlags, d_data->text );
        d_layoutCache
->font = font;
    }

    QSizeF sz 
= d_layoutCache->textSize;

    
if ( d_data->layoutAttributes & MinimumLayout )
    {
        
double left, right, top, bottom;
        d_data
->textEngine->textMargins( font, d_data->text,
            left, right, top, bottom );
        sz 
-= QSizeF( left + right, top + bottom );
    }

    
return sz;
}

void QwtText::applyDefaultAntialiasingHint(QCPPainter* painter)const
{
}

void QwtText::draw(QCPPainter* painter)
{
    QRectF rect 
= mParentPlot->rect();
    
if ( d_data->paintAttributes & PaintBackground )
    {
        
if ( d_data->borderPen != Qt::NoPen ||
            d_data
->backgroundBrush != Qt::NoBrush )
        {
            painter
->save();

            painter
->setPen( d_data->borderPen );
            painter
->setBrush( d_data->backgroundBrush );

            
if ( d_data->borderRadius == 0 )
            {
                QwtPainter::drawRect( painter, rect );
            }
            
else
            {
                painter
->setRenderHint( QPainter::Antialiasing, true );
                painter
->drawRoundedRect( rect,
                    d_data
->borderRadius, d_data->borderRadius );
            }

            painter
->restore();
        }
    }

    painter
->save();

    
if ( d_data->paintAttributes & PaintUsingTextFont )
    {
        painter
->setFont( d_data->font );
    }

    
if ( d_data->paintAttributes & PaintUsingTextColor )
    {
        
if ( d_data->color.isValid() )
            painter
->setPen( d_data->color );
    }

    QRectF expandedRect 
= rect;
    
if ( d_data->layoutAttributes & MinimumLayout )
    {
        
// We want to calculate in screen metrics. So
        
// we need a font that uses screen metrics

        
const QFont font( painter->font(), QApplication::desktop() );

        
double left, right, top, bottom;
        d_data
->textEngine->textMargins(
            font, d_data
->text, left, right, top, bottom );

        expandedRect.setTop( rect.top() 
- top );
        expandedRect.setBottom( rect.bottom() 
+ bottom );
        expandedRect.setLeft( rect.left() 
- left );
        expandedRect.setRight( rect.right() 
+ right );
    }

    d_data
->textEngine->draw( painter, expandedRect,
        d_data
->renderFlags, d_data->text );

    painter
->restore();
}

/*!
   Find the text engine for a text format

   In case of QwtText::AutoText the first text engine
   (beside QwtPlainTextEngine) is returned, where QwtTextEngine::mightRender
   returns true. If there is none QwtPlainTextEngine is returned.

   If no text engine is registered for the format QwtPlainTextEngine
   is returnd.

   \param text Text, needed in case of AutoText
   \param format Text format

   \return Corresponding text engine
*/
const QwtTextEngine *QwtText::textEngine( const QString &text,
    QwtText::TextFormat format )
{
    
return QwtTextEngineDict::dict().textEngine( text, format );
}

/*!
   Assign/Replace a text engine for a text format

   With setTextEngine it is possible to extend Qwt with
   other types of text formats.

   For QwtText::PlainText it is not allowed to assign a engine == NULL.

   \param format Text format
   \param engine Text engine

   \sa QwtMathMLTextEngine
   \warning Using QwtText::AutoText does nothing.
*/
void QwtText::setTextEngine( QwtText::TextFormat format,
    QwtTextEngine 
*engine )
{
    QwtTextEngineDict::dict().setTextEngine( format, engine );
}

/*!
   \brief Find the text engine for a text format

   textEngine can be used to find out if a text format is supported.

   \param format Text format
   \return The text engine, or NULL if no engine is available.
*/
const QwtTextEngine *QwtText::textEngine( QwtText::TextFormat format )
{
    
return  QwtTextEngineDict::dict().textEngine( format );
}
主要是修改了draw函数和去掉了几个构造函数
posted on 2017-05-15 13:16 ccsdu2009 阅读(850) 评论(0)  编辑 收藏 引用 所属分类: QT编程

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理