KDChartPropertySet.h

Go to the documentation of this file.

/*
   KDChart - a multi-platform charting engine
   */
 
/****************************************************************************
 ** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB.  All rights reserved.
 **
 ** This file is part of the KDChart library.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid commercial KDChart licenses may use this file in
 ** accordance with the KDChart Commercial License Agreement provided with
 ** the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.klaralvdalens-datakonsult.se/?page=products for
 **   information about KDChart Commercial License Agreements.
 **
 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
 ** licensing are not clear to you.
 **
 **********************************************************************/
#ifndef __KDCHARTPROPERTYSET__
#define __KDCHARTPROPERTYSET__
 
 
#include <KDChartEnums.h>
#include <kdchart_export.h>
#include <tqdom.h>
#include <tqcolor.h>
#include <tqbrush.h>


class KDCHART_EXPORT KDChartPropertySet :public TQObject
{
    TQ_OBJECT
    
    TQ_ENUMS( SpecialDataPropertyID )
 
    // Required by TQSA
    TQ_ENUMS( PenStyle )
 
    friend class KDChartParams;
 
    public:
    enum SpecialDataPropertyID {
        UndefinedID = -2,
        OwnID = -1
    };

    KDChartPropertySet() :
        mOwnID( UndefinedID )
    { fullReset(""); }
 

    KDChartPropertySet( const TQString& name, int idParent=KDChartPropertySet::UndefinedID ) :
        mOwnID( UndefinedID )
    { fullReset( name, idParent ); }
 

    void deepCopy( const KDChartPropertySet* source );
 

    const KDChartPropertySet* clone() const;
 

    void quickReset( const TQString& name, int idParent=KDChartPropertySet::UndefinedID );
 

    void fullReset( const TQString& name, int idParent=KDChartPropertySet::UndefinedID );
 

    TQDomElement saveXML(TQDomDocument& doc) const;
 

    static bool loadXML( const TQDomElement& element, KDChartPropertySet& set );
 
public slots:
    int id() const { return mOwnID; }

    void setName( const TQString& name )
    {
        mName = name;
    }

    TQString name() const { return mName; }
 
 

    void setShowBar( int idShowBar, bool showBar )
    {
        mIdShowBar = idShowBar;
        mShowBar =   showBar;
    }

    bool hasOwnShowBar( int& idShowBar, bool& showBar )
    {
        idShowBar = mIdShowBar;
        if( OwnID == idShowBar ){
            showBar = mShowBar;
            return true;
        }
        return false;
    }

    void setBarColor( int idBarColor, const TQColor& barColor )
    {
        mIdBarColor = idBarColor;
        mBarColor = barColor;
    }

    bool hasOwnBarColor( int& idBarColor, TQColor& barColor )
    {
        idBarColor = mIdBarColor;
        if( OwnID == mIdBarColor ){
            barColor = mBarColor;
            return true;
        }
        return false;
    }
 

    void setLineWidth( int idLineWidth, int lineWidth )
    {
        mIdLineWidth = idLineWidth;
        mLineWidth =   lineWidth;
    }

    bool hasOwnLineWidth( int& idLineWidth, int& lineWidth )
    {
        idLineWidth = mIdLineWidth;
        if( OwnID == mIdLineWidth ){
            lineWidth = mLineWidth;
            return true;
        }
        return false;
    }

    void setLineColor( int idLineColor, const TQColor& lineColor )
    {
        mIdLineColor = idLineColor;
        mLineColor = lineColor;
    }

    bool hasOwnLineColor( int& idLineColor, TQColor& lineColor )
    {
        idLineColor = mIdLineColor;
        if( OwnID == mIdLineColor ){
            lineColor = mLineColor;
            return true;
        }
        return false;
    }

    void setLineStyle( int idLineStyle, const TQt::PenStyle& lineStyle )
    {
        mIdLineStyle = idLineStyle;
        mLineStyle =   lineStyle;
    }

    bool hasOwnLineStyle( int& idLineStyle, TQt::PenStyle& lineStyle )
    {
        idLineStyle = mIdLineStyle;
        if( OwnID == mIdLineStyle ){
            lineStyle = mLineStyle;
            return true;
        }
        return false;
    }
 
 

    void setAreaBrush( int idAreaBrush, const TQBrush& areaBrush )
    {
        mIdAreaBrush = idAreaBrush;
        mAreaBrush = areaBrush;
    }

    bool hasOwnAreaBrush( int& idAreaBrush, TQBrush& areaBrush )
    {
        idAreaBrush = mIdAreaBrush;
        if( OwnID == mIdAreaBrush ){
            areaBrush = mAreaBrush;
            return true;
        }
        return false;
    }
 
 
 
 

    void setShowMarker( int idShowMarker, bool showMarker )
    {
        mIdShowMarker = idShowMarker;
        mShowMarker =   showMarker;
    }

    bool hasOwnShowMarker( int& idShowMarker, bool& showMarker )
    {
        idShowMarker = mIdShowMarker;
        if( OwnID == idShowMarker ){
            showMarker = mShowMarker;
            return true;
        }
        return false;
    }

    void setMarkerAlign( int idMarkerAlign, uint markerAlign )
    {
        mIdMarkerAlign = idMarkerAlign;
        mMarkerAlign =   markerAlign;
    }
    bool hasOwnMarkerAlign( int& idMarkerAlign, uint& markerAlign )
    {
        idMarkerAlign = mIdMarkerAlign;
        if( OwnID == idMarkerAlign ){
            markerAlign = mMarkerAlign;
            return true;
        }
        return false;
    }
    void setMarkerSize( int idMarkerSize, const TQSize& markerSize )
    {
        mIdMarkerSize = idMarkerSize;
        mMarkerSize =   markerSize;
    }
    bool hasOwnMarkerSize( int& idMarkerSize, TQSize& markerSize )
    {
        idMarkerSize = mIdMarkerSize;
        if( OwnID == idMarkerSize ){
            markerSize = mMarkerSize;
            return true;
        }
        return false;
    }
    void setMarkerColor( int idMarkerColor, const TQColor& markerColor )
    {
        mIdMarkerColor = idMarkerColor;
        mMarkerColor =   markerColor;
    }
    bool hasOwnMarkerColor( int& idMarkerColor, TQColor& markerColor )
    {
        idMarkerColor = mIdMarkerColor;
        if( OwnID == idMarkerColor ){
            markerColor = mMarkerColor;
            return true;
        }
        return false;
    }
    void setMarkerStyle( int idMarkerStyle, int markerStyle )
    {
        mIdMarkerStyle = idMarkerStyle;
        mMarkerStyle =   markerStyle;
    }
    bool hasOwnMarkerStyle( int& idMarkerStyle, int& markerStyle )
    {
        idMarkerStyle = mIdMarkerStyle;
        if( OwnID == idMarkerStyle ){
            markerStyle = mMarkerStyle;
            return true;
        }
        return false;
    }
 
 
 
 
 
 
    void setExtraLinesAlign( int idExtraLinesAlign, uint extraLinesAlign )
    {
        mIdExtraLinesAlign = idExtraLinesAlign;
        mExtraLinesAlign =   extraLinesAlign;
    }
    bool hasOwnExtraLinesAlign( int& idExtraLinesAlign, uint& extraLinesAlign )
    {
        idExtraLinesAlign = mIdExtraLinesAlign;
        if( OwnID == idExtraLinesAlign ){
            extraLinesAlign = mExtraLinesAlign;
            return true;
        }
        return false;
    }
    void setExtraLinesInFront( int idExtraLinesInFront, bool extraLinesInFront )
    {
        mIdExtraLinesInFront = idExtraLinesInFront;
        mExtraLinesInFront   = extraLinesInFront;
    }
    bool hasOwnExtraLinesInFront( int& idExtraLinesInFront, bool& extraLinesInFront )
    {
        idExtraLinesInFront = mIdExtraLinesInFront;
        if( OwnID == idExtraLinesInFront ){
            extraLinesInFront = mExtraLinesInFront;
            return true;
        }
        return false;
    }
    void setExtraLinesLength( int idExtraLinesLength, int extraLinesLength )
    {
        mIdExtraLinesLength = idExtraLinesLength;
        mExtraLinesLength =   extraLinesLength;
    }
    bool hasOwnExtraLinesLength( int& idExtraLinesLength, int& extraLinesLength )
    {
        idExtraLinesLength = mIdExtraLinesLength;
        if( OwnID == idExtraLinesLength ){
            extraLinesLength = mExtraLinesLength;
            return true;
        }
        return false;
    }
    void setExtraLinesWidth( int idExtraLinesWidth, int extraLinesWidth )
    {
        mIdExtraLinesWidth = idExtraLinesWidth;
        mExtraLinesWidth =   extraLinesWidth;
    }
    bool hasOwnExtraLinesWidth( int& idExtraLinesWidth, int& extraLinesWidth )
    {
        idExtraLinesWidth = mIdExtraLinesWidth;
        if( OwnID == idExtraLinesWidth ){
            extraLinesWidth = mExtraLinesWidth;
            return true;
        }
        return false;
    }
    void setExtraLinesColor( int idExtraLinesColor, const TQColor& extraLinesColor )
    {
        mIdExtraLinesColor = idExtraLinesColor;
        mExtraLinesColor =   extraLinesColor;
    }
    bool hasOwnExtraLinesColor( int& idExtraLinesColor, TQColor& extraLinesColor )
    {
        idExtraLinesColor = mIdExtraLinesColor;
        if( OwnID == idExtraLinesColor ){
            extraLinesColor = mExtraLinesColor;
            return true;
        }
        return false;
    }
    void setExtraLinesStyle( int idExtraLinesStyle, const TQt::PenStyle extraLinesStyle )
    {
        mIdExtraLinesStyle = idExtraLinesStyle;
        mExtraLinesStyle =   extraLinesStyle;
    }
    bool hasOwnExtraLinesStyle( int& idExtraLinesStyle, TQt::PenStyle& extraLinesStyle )
    {
        idExtraLinesStyle = mIdExtraLinesStyle;
        if( OwnID == idExtraLinesStyle ){
            extraLinesStyle = mExtraLinesStyle;
            return true;
        }
        return false;
    }
 
    void setExtraMarkersAlign( int idExtraMarkersAlign, uint extraMarkersAlign )
    {
        mIdExtraMarkersAlign = idExtraMarkersAlign;
        mExtraMarkersAlign =   extraMarkersAlign;
    }
    bool hasOwnExtraMarkersAlign( int& idExtraMarkersAlign, uint& extraMarkersAlign )
    {
        idExtraMarkersAlign = mIdExtraMarkersAlign;
        if( OwnID == idExtraMarkersAlign ){
            extraMarkersAlign = mExtraMarkersAlign;
            return true;
        }
        return false;
    }
    void setExtraMarkersSize( int idExtraMarkersSize, const TQSize& extraMarkersSize )
    {
        mIdExtraMarkersSize = idExtraMarkersSize;
        mExtraMarkersSize =   extraMarkersSize;
    }
    bool hasOwnExtraMarkersSize( int& idExtraMarkersSize, TQSize& extraMarkersSize )
    {
        idExtraMarkersSize = mIdExtraMarkersSize;
        if( OwnID == idExtraMarkersSize ){
            extraMarkersSize = mExtraMarkersSize;
            return true;
        }
        return false;
    }
    void setExtraMarkersColor( int idExtraMarkersColor, const TQColor& extraMarkersColor )
    {
        mIdExtraMarkersColor = idExtraMarkersColor;
        mExtraMarkersColor =   extraMarkersColor;
    }
    bool hasOwnExtraMarkersColor( int& idExtraMarkersColor, TQColor& extraMarkersColor )
    {
        idExtraMarkersColor = mIdExtraMarkersColor;
        if( OwnID == idExtraMarkersColor ){
            extraMarkersColor = mExtraMarkersColor;
            return true;
        }
        return false;
    }
    void setExtraMarkersStyle( int idExtraMarkersStyle, int extraMarkersStyle )
    {
        mIdExtraMarkersStyle = idExtraMarkersStyle;
        mExtraMarkersStyle =   extraMarkersStyle;
    }
    bool hasOwnExtraMarkersStyle( int& idExtraMarkersStyle, int& extraMarkersStyle )
    {
        idExtraMarkersStyle = mIdExtraMarkersStyle;
        if( OwnID == idExtraMarkersStyle ){
            extraMarkersStyle = mExtraMarkersStyle;
            return true;
        }
        return false;
    }
 
protected:
    // the following member only to be set internally by KDChartParams::registerProperties
    // and by KDChartParams::setProperties
    int mOwnID;
 
private:
    KDChartPropertySet( const KDChartPropertySet& ) : TQObject(0) {}
 
    TQString mName;
    // IDs:                     values used if ID == OwnID:
    int mIdLineWidth;         int          mLineWidth;
    int mIdLineColor;         TQColor       mLineColor;
    int mIdLineStyle;         TQt::PenStyle mLineStyle;
    int mIdShowMarker;        bool         mShowMarker;
    int mIdMarkerSize;        TQSize        mMarkerSize;
    int mIdMarkerColor;       TQColor       mMarkerColor;
    int mIdMarkerStyle;       int          mMarkerStyle;
    int mIdMarkerAlign;       uint         mMarkerAlign;
    int mIdExtraLinesAlign;   uint         mExtraLinesAlign;
    int mIdExtraLinesInFront; bool         mExtraLinesInFront;
    int mIdExtraLinesLength;  int          mExtraLinesLength;
    int mIdExtraLinesWidth;   int          mExtraLinesWidth;
    int mIdExtraLinesColor;   TQColor       mExtraLinesColor;
    int mIdExtraLinesStyle;   TQt::PenStyle mExtraLinesStyle;
    int mIdExtraMarkersAlign; uint         mExtraMarkersAlign;
    int mIdExtraMarkersSize;  TQSize        mExtraMarkersSize;
    int mIdExtraMarkersColor; TQColor       mExtraMarkersColor;
    int mIdExtraMarkersStyle; int          mExtraMarkersStyle;
    int mIdShowBar;           bool         mShowBar;
    int mIdBarColor;          TQColor       mBarColor;
    int mIdAreaBrush;         TQBrush       mAreaBrush;
    void fillValueMembersWithDummyValues();
};
 
#endif