Logo Search packages:      
Sourcecode: scidavis version File versions  Download package

Graph.h

/***************************************************************************
    File                 : Graph.h
    Project              : SciDAVis
    --------------------------------------------------------------------
    Copyright            : (C) 2006 by Ion Vasilief, Tilman Benkert
    Email (use @ for *)  : ion_vasilief*yahoo.fr, thzs*gmx.net
    Description          : Graph widget

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *  This program is free software; you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation; either version 2 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  This program 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 General Public License for more details.                           *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
 *   Boston, MA  02110-1301  USA                                           *
 *                                                                         *
 ***************************************************************************/
#ifndef GRAPH_H
#define GRAPH_H

#include <QList>
#include <QPointer>
#include <QPrinter>
#include <QVector>
#include <QEvent>
#include <QMap>

#include <qwt_plot.h>
#include <qwt_plot_marker.h>
#include <qwt_plot_curve.h>

#include "Plot.h"
#include "Table.h"
#include "AxesDialog.h"
#include "PlotToolInterface.h"
#include "core/column/Column.h"

class QwtPlotCurve;
class QwtPlotZoomer;
class QwtPieCurve;
class Table;
class Legend;
class ArrowMarker;
class ImageMarker;
class TitlePicker;
class ScalePicker;
class CanvasPicker;
class ApplicationWindow;
class Matrix;
class SelectionMoveResizer;
class RangeSelectorTool;
class DataCurve;
class PlotCurve;
class QwtErrorPlotCurve;

//! Structure containing curve layout parameters
00068 typedef struct{
00069   int lCol;        //!< line color
00070   int lWidth;      //!< line width
00071   int lStyle;      //!< line style
00072   int filledArea;  //!< flag: toggles area filling under curve
00073   int aCol;        //!< curve area color
00074   int aStyle;      //!< area filling style
00075   int symCol;      //!< symbol outline color
00076   int fillCol;     //!< symbol fill color
00077   int penWidth;    //!< symbol outline width
00078   int sSize;       //!< symbol size
00079   int sType;       //!< symbol type (shape)
00080   int connectType; //!< symbol connection type
}  CurveLayout;

/**
 * \brief A 2D-plotting widget.
 *
 * Graphs are managed by a MultiLayer, where they are sometimes referred to as "graphs" and sometimes as "layers".
 * Other parts of the code also call them "plots", regardless of the fact that there's also a class Plot.
 * Within the user interface, they are quite consistently called "layers".
 *
 * Each graph owns a Plot called #d_plot, which handles parts of the curve, axis and marker management (similarly to QwtPlot),
 * as well as the pickers #d_zoomer (a QwtPlotZoomer), #titlePicker (a TitlePicker), #scalePicker (a ScalePicker) and #cp (a CanvasPicker),
 * which handle various parts of the user interaction.
 *
 * Graph contains support for various curve types (see #CurveType),
 * some of them relying on SciDAVis-specific QwtPlotCurve subclasses for parts of the functionality.
 *
 * %Note that some of Graph's methods are implemented in analysis.cpp.
 *
 * \section future_plans Future Plans
 * Merge with Plot and CanvasPicker.
 * Think about merging in TitlePicker and ScalePicker.
 * On the other hand, things like range selection, peak selection or (re)moving data points could be split out into tool classes
 * like QwtPlotZoomer or SelectionMoveResizer.
 *
 * What definitely should be split out are plot types like histograms and pie charts (TODO: which others?).
 * We need a generic framework for this in any case so that new plot types can be implemented in plugins,
 * and Graph could do with a little diet. Especially after merging in Plot and CanvasPicker.
 * [ Framework needs to support plug-ins; assigned to knut ]
 *
 * Add support for floating-point line widths of curves and axes (request 2300).
 * [ assigned to thzs ]
 */

00114 class Graph: public QWidget
{
      Q_OBJECT

      public:
            Graph (QWidget* parent=0, const char* name=0, Qt::WFlags f=0);
            ~Graph();

            enum AxisType{Numeric = 0, Txt = 1, Day = 2, Month = 3, Time = 4, Date = 5, ColHeader = 6, DateTime = 22};
            enum MarkerType{None = -1, Text = 0, Arrow = 1, Image = 2};
            enum CurveType{Line, Scatter, LineSymbols, VerticalBars, Area, Pie, VerticalDropLines,
                  Spline, HorizontalSteps, Histogram, HorizontalBars, VectXYXY, ErrorBars,
                  Box, VectXYAM, VerticalSteps, ColorMap, GrayMap, ContourMap, Function};

            Plot *d_plot;
            QwtPlotZoomer *d_zoomer[2];
            TitlePicker *titlePicker;
            ScalePicker *scalePicker;
            CanvasPicker* cp;

            static int mapToQwtAxis(int axis);

            //! Returns the name of the parent MultiLayer object.
            QString parentPlotName();

            //! Change the active tool, deleting the old one if it exists.
            void setActiveTool(PlotToolInterface *tool);
            //! Return the active tool, or NULL if none is active.
00142             PlotToolInterface* activeTool() const { return d_active_tool; }

            Grid *grid(){return d_plot->grid();};

      public slots:
            //! Accessor method for #d_plot.
00148             Plot* plotWidget(){return d_plot;};
            void copy(ApplicationWindow *parent, Graph* g);

            //! \name Pie Curves
            //@{
            //! Returns true if this Graph is a pie plot, false otherwise.
00154             bool isPiePlot(){return (c_type.count() == 1 && c_type[0] == Pie);};
            void plotPie(Table* w,const QString& name, int startRow = 0, int endRow = -1);
            //! Used when restoring a pie plot from a project file
            void plotPie(Table* w,const QString& name, const QPen& pen, int brush, int size, int firstColor, int startRow = 0, int endRow = -1, bool visible = true);
            void removePie();
            QString pieLegendText();
            QString savePieCurveLayout();
            //@}

            bool insertCurvesList(Table* w, const QStringList& names, int style, int lWidth, int sSize, int startRow = 0, int endRow = -1);
            bool insertCurve(Table* w, const QString& name, int style, int startRow = 0, int endRow = -1);
            bool insertCurve(Table* w, int xcol, const QString& name, int style);
            bool insertCurve(Table* w, const QString& xColName, const QString& yColName, int style, int startRow = 0, int endRow = -1);
            void insertPlotItem(QwtPlotItem *i, int type);

            //! Shows/Hides a curve defined by its index.
            void showCurve(int index, bool visible = true);
            int visibleCurves();

            //! Removes a curve defined by its index.
            void removeCurve(int index);
            /**
             * \brief Removes a curve defined by its title string s.
             */
            void removeCurve(const QString& s);
            /**
             * \brief Removes all curves defined by the title/plot association string s.
             */
            void removeCurves(const QString& s);

            void updateCurvesData(Table* w, const QString& yColName);

            int curves(){return n_curves;};
            bool validCurvesDataSize();
            double selectedXStartValue();
            double selectedXEndValue();

        long curveKey(int curve){return c_keys[curve];}
            int curveIndex(long key){return c_keys.indexOf(key);};
            //! Map curve pointer to index.
            int curveIndex(QwtPlotCurve *c) const;
            //! map curve title to index
00196           int curveIndex(const QString &title){return plotItemsList().indexOf(title);}
          //! get curve by index
          QwtPlotCurve* curve(int index);
          //! get curve by name
00200           QwtPlotCurve* curve(const QString &title){return curve(curveIndex(title));}

            //! Returns the names of all the curves suitable for data analysis, as a string list. The list excludes error bars and spectrograms.
            QStringList analysableCurvesList();
            //! Returns the names of all the QwtPlotCurve items on the plot, as a string list
            QStringList curvesList();
          //! Returns the names of all plot items, including spectrograms, as a string list
            QStringList plotItemsList();
             //! get plotted item by index
          QwtPlotItem* plotItem(int index);
          //! get plot item by index
          int plotItemIndex(QwtPlotItem *it) const;

        void updateCurveNames(const QString& oldName, const QString& newName, bool updateTableName = true);

            int curveType(int curveIndex);
            //! Test whether curve can be converted to type using setCurveType().
            static bool canConvertTo(QwtPlotCurve *curve, CurveType type);
            //! Change the type of the given curve.
            /**
             * The option to disable updating is provided so as not to break the project opening code
             * (ApplicationWindow::openGraph()).
             */
            void setCurveType(int curve, CurveType type, bool update=true);
            void setCurveFullRange(int curveIndex);

            //! \name Output: Copy/Export/Print
            //@{
            void print();
            void setScaleOnPrint(bool on){d_scale_on_print = on;};
            void printCropmarks(bool on){d_print_cropmarks = on;};

            void copyImage();
            QPixmap graphPixmap();
            //! Provided for convenience in scripts
            void exportToFile(const QString& fileName);
            void exportSVG(const QString& fname);
            void exportVector(const QString& fileName, int res = 0, bool color = true,
                        bool keepAspect = true, QPrinter::PageSize pageSize = QPrinter::Custom, 
                                    QPrinter::Orientation orientation = QPrinter::Portrait);
            void exportImage(const QString& fileName, int quality = 100, bool transparent = false);
            //@}

            void replot(){d_plot->replot();};
            void updatePlot();

            //! \name Error Bars
            //@{
            bool addErrorBars(const QString& xColName, const QString& yColName, Table *errTable,
                        const QString& errColName, int type = 1, int width = 1, int cap = 8, const QColor& color = QColor(Qt::black),
                        bool through = true, bool minus = true, bool plus = true);

            bool addErrorBars(const QString& yColName, Table *errTable, const QString& errColName,
                        int type = 1, int width = 1, int cap = 8, const QColor& color = QColor(Qt::black),
                        bool through = true, bool minus = true, bool plus = true);

            void updateErrorBars(QwtErrorPlotCurve *er, bool xErr,int width, int cap, const QColor& c, bool plus, bool minus, bool through);

            //! Returns a valid master curve for the error bars curve.
            DataCurve* masterCurve(QwtErrorPlotCurve *er);
            //! Returns a valid master curve for a plot association.
            DataCurve* masterCurve(const QString& xColName, const QString& yColName);
            //@}

            //! \name Event Handlers
            //@{
            void contextMenuEvent(QContextMenuEvent *);
            void closeEvent(QCloseEvent *e);
            bool focusNextPrevChild ( bool next );
            //@}

            //! Set axis scale
            void setScale(int axis, double start, double end, double step = 0.0,
                        int majorTicks = 5, int minorTicks = 5, int type = 0, bool inverted = false);
            double axisStep(int axis){return d_user_step[axis];};

            //! \name Curves Layout
            //@{
            CurveLayout initCurveLayout(int style, int curves = 0);
            static CurveLayout initCurveLayout();
            //! Set layout parameters of the curve given by index.
            void updateCurveLayout(int index,const CurveLayout *cL);
            //! Tries to guess not already used curve color and symbol style
            void guessUniqueCurveLayout(int& colorIndex, int& symbolIndex);
            //@}

            //! \name Zoom
            //@{
            void zoomed (const QwtDoubleRect &);
            void zoom(bool on);
            void zoomOut();
            bool zoomOn();
            //@}

            void setAutoScale();
            void updateScale();

            //! \name Saving to File
            //@{
            QString saveToString(bool saveAsTemplate = false);
            QString saveScale();
            QString saveScaleTitles();
            QString saveFonts();
            QString saveMarkers();
            QString saveCurveLayout(int index);
            QString saveAxesTitleColors();
            QString saveAxesColors();
            QString saveEnabledAxes();
            QString saveCanvas();
            QString saveTitle();
            QString saveAxesTitleAlignement();
            QString saveEnabledTickLabels();
            QString saveTicksType();
            QString saveCurves();
            QString saveLabelsFormat();
            QString saveLabelsRotation();
            QString saveAxesLabelsType();
            QString saveAxesBaseline();
            QString saveAxesFormulas();
            //@}

            //! \name Text Markers
            //@{
            void drawText(bool on);
            bool drawTextActive(){return drawTextOn;};
            long insertTextMarker(Legend* mrk);

            //! Used when opening a project file
            long insertTextMarker(const QStringList& list, int fileVersion);
            void updateTextMarker(const QString& text,int angle, int bkg,const QFont& fnt,
                        const QColor& textColor, const QColor& backgroundColor);

            QFont defaultTextMarkerFont(){return defaultMarkerFont;};
            QColor textMarkerDefaultColor(){return defaultTextMarkerColor;};
            QColor textMarkerDefaultBackground(){return defaultTextMarkerBackground;};
            int textMarkerDefaultFrame(){return defaultMarkerFrame;};
            void setTextMarkerDefaults(int f, const QFont &font, const QColor& textCol, const QColor& backgroundCol);

            void setCopiedMarkerType(Graph::MarkerType type){selectedMarkerType=type;};
            void setCopiedMarkerEnds(const QPoint& start, const QPoint& end);
            void setCopiedTextOptions(int bkg, const QString& text, const QFont& font,
                        const QColor& color, const QColor& bkgColor);
            void setCopiedArrowOptions(int width, Qt::PenStyle style, const QColor& color,
                        bool start, bool end, int headLength, int headAngle, bool filledHead);
            void setCopiedImageName(const QString& fn){auxMrkFileName=fn;};
            QRect copiedMarkerRect(){return QRect(auxMrkStart, auxMrkEnd);};
            QVector<int> textMarkerKeys(){return d_texts;};
            Legend* textMarker(long id);

            void addTimeStamp();

            void removeLegend();
            void removeLegendItem(int index);
            void addLegendItem(const QString& colName);
            void insertLegend(const QStringList& lst, int fileVersion);
            Legend *legend();
            Legend *newLegend();
            Legend *newLegend(const QString& text);
            bool hasLegend(){return legendMarkerID >= 0;};

            //! Creates a new legend text using the curves titles
            QString legendText();
            //@}

            //! \name Line Markers
            //@{
            ArrowMarker* arrow(long id);
            void addArrow(ArrowMarker* mrk);

            //! Used when opening a project file
            void addArrow(QStringList list, int fileVersion);
            QVector<int> lineMarkerKeys(){return d_lines;};

            //!Draws a line/arrow depending on the value of "arrow"
            void drawLine(bool on, bool arrow = FALSE);
            bool drawArrow(){return drawArrowOn;};
            bool drawLineActive(){return drawLineOn;};

            Qt::PenStyle arrowLineDefaultStyle(){return defaultArrowLineStyle;};
            bool arrowHeadDefaultFill(){return defaultArrowHeadFill;};
            int arrowDefaultWidth(){return defaultArrowLineWidth;};
            int arrowHeadDefaultLength(){return defaultArrowHeadLength;};
            int arrowHeadDefaultAngle(){return defaultArrowHeadAngle;};
            QColor arrowDefaultColor(){return defaultArrowColor;};

            void setArrowDefaults(int lineWidth,  const QColor& c, Qt::PenStyle style,
                        int headLength, int headAngle, bool fillHead);
        bool arrowMarkerSelected();
            //@}

            //! \name Image Markers
            //@{
            ImageMarker* imageMarker(long id);
            QVector<int> imageMarkerKeys(){return d_images;};
            ImageMarker* addImage(ImageMarker* mrk);
            ImageMarker* addImage(const QString& fileName);

            void insertImageMarker(const QStringList& lst, int fileVersion);
            bool imageMarkerSelected();
            void updateImageMarker(int x, int y, int width, int height);
            //@}

            //! \name Common to all Markers
            //@{
            void removeMarker();
            void cutMarker();
            void copyMarker();
            void pasteMarker();
            //! Keep the markers on screen each time the scales are modified by adding/removing curves
            void updateMarkersBoundingRect();

            long selectedMarkerKey();
            /*!\brief Set the selected marker.
             * \param mrk key of the marker to be selected.
             * \param add whether the marker is to be added to an existing selection.
             * If <i>add</i> is false (the default) or there is no existing selection, a new SelectionMoveResizer is
             * created and stored in #d_markers_selector.
             */
            void setSelectedMarker(long mrk, bool add=false);
            QwtPlotMarker* selectedMarkerPtr();
            bool markerSelected();
            //! Reset any selection states on markers.
            void deselectMarker();
            MarkerType copiedMarkerType(){return selectedMarkerType;};
            //@}
      
            //! \name Axes
            //@{
            QList<int> axesType();

            QStringList scalesTitles();
            void setXAxisTitle(const QString& text);
            void setYAxisTitle(const QString& text);
            void setRightAxisTitle(const QString& text);
            void setTopAxisTitle(const QString& text);
            void setAxisTitle(int axis, const QString& text);
            QString axisTitle(int axis) { return d_plot->axisTitle(axis).text(); }

            QFont axisTitleFont(int axis);
            void setXAxisTitleFont(const QFont &fnt);
            void setYAxisTitleFont(const QFont &fnt);
            void setRightAxisTitleFont(const QFont &fnt);
            void setTopAxisTitleFont(const QFont &fnt);
            void setAxisTitleFont(int axis,const QFont &fnt);

            void setAxisFont(int axis,const QFont &fnt);
            QFont axisFont(int axis);
            void initFonts(const QFont &scaleTitleFnt,const QFont &numbersFnt);

            QColor axisTitleColor(int axis);
            void setXAxisTitleColor(const QColor& c);
            void setYAxisTitleColor(const QColor& c);
            void setRightAxisTitleColor(const QColor& c);
            void setTopAxisTitleColor(const QColor& c);
            void setAxesTitleColor(QStringList l);

            int axisTitleAlignment (int axis);
            void setXAxisTitleAlignment(int align);
            void setYAxisTitleAlignment(int align);
            void setTopAxisTitleAlignment(int align);
            void setRightAxisTitleAlignment(int align);
            void setAxesTitlesAlignment(const QStringList& align);

        QColor axisColor(int axis);
            QStringList axesColors();
            void setAxesColors(const QStringList& colors);

        QColor axisNumbersColor(int axis);
          QStringList axesNumColors();
          void setAxesNumColors(const QStringList& colors);

            void showAxis(int axis, int type, const QString& formatInfo, Table *table, bool axisOn,
                        int majTicksType, int minTicksType, bool labelsOn, const QColor& c, int format,
                int prec, int rotation, int baselineDist, const QString& formula, const QColor& labelsColor);

            void enableAxis(int axis, bool on = true);
            QVector<bool> enabledAxes();
            void enableAxes(QVector<bool> axesOn);
            void enableAxes(const QStringList& list);

            int labelsRotation(int axis);
            void setAxisLabelRotation(int axis, int rotation);

            QStringList enabledTickLabels();
            void setEnabledTickLabels(const QStringList& list);

            void setAxesLinewidth(int width);
            //! used when opening a project file
            void loadAxesLinewidth(int width);

            void drawAxesBackbones(bool yes);
            bool axesBackbones(){return drawAxesBackbone;};
            //! used when opening a project file
            void loadAxesOptions(const QString& s);

            QList<int> axesBaseline();
            void setAxesBaseline(const QList<int> &lst);
            void setAxesBaseline(QStringList &lst);

            void setMajorTicksType(const QList<int>& lst);
            void setMajorTicksType(const QStringList& lst);

            void setMinorTicksType(const QList<int>& lst);
            void setMinorTicksType(const QStringList& lst);

            int minorTickLength();
            int majorTickLength();
            void setAxisTicksLength(int axis, int majTicksType, int minTicksType,
                        int minLength, int majLength);
            void setTicksLength(int minLength, int majLength);
            void changeTicksLength(int minLength, int majLength);

            void setLabelsNumericFormat(const QStringList& l);
            void setLabelsNumericFormat(int axis, const QStringList& l);
            void setLabelsNumericFormat(int axis, int format, int prec = 6, const QString& formula = QString());
            void setLabelsDateTimeFormat(int axis, int type, const QString& formatInfo);
            void setLabelsDayFormat(int axis, int format);
            void setLabelsMonthFormat(int axis, int format);

            QString axisFormatInfo(int axis);
            QStringList axesLabelsFormatInfo(){return axesFormatInfo;};

            void setLabelsTextFormat(int axis, const Column *column, int startRow, int endRow);
            void setLabelsTextFormat(int axis, Table *table, const QString& columnName);
            void setLabelsColHeaderFormat(int axis, Table *table);

            QStringList getAxesFormulas(){return axesFormulas;};
            void setAxesFormulas(const QStringList& l){axesFormulas = l;};
            void setAxisFormula(int pos, const QString &f){axesFormulas[pos] = f;};
            //@}

            //! \name Canvas Frame
            //@{
            void drawCanvasFrame(bool frameOn, int width);
            void drawCanvasFrame(const QStringList& frame);
            void drawCanvasFrame(bool frameOn, int width, const QColor& color);
            QColor canvasFrameColor();
            int canvasFrameWidth();
            bool framed();
            //@}

            //! \name Plot Title
            //@{
            void setTitle(const QString& t);
            void setTitleFont(const QFont &fnt);
            void setTitleColor(const QColor &c);
            void setTitleAlignment(int align);

            bool titleSelected();
            void selectTitle();

            void removeTitle();
            void initTitle( bool on, const QFont& fnt);
            //@}

            //! \name Modifing insertCurve Data
            //@{
            int selectedCurveID();
            int selectedCurveIndex() { return curveIndex(selectedCurveID()); }
            QString selectedCurveTitle();
            //@}

            void disableTools();

            /*! Enables the data range selector tool.
             *
             * This one is a bit special, because other tools can depend upon an existing selection.
             * Therefore, range selection (like zooming) has to be provided in addition to the generic
             * tool interface.
             */
            bool enableRangeSelectors(const QObject *status_target=NULL, const char *status_slot="");

            //! \name Border and Margin
            //@{
            void setMargin (int d);
            void setFrame(int width = 1, const QColor& color = QColor(Qt::black));
            void setBackgroundColor(const QColor& color);
            void setCanvasBackground(const QColor& color);
            //@}

            void addFitCurve(QwtPlotCurve *c);
            void deleteFitCurves();
            QList<QwtPlotCurve *> fitCurvesList(){return d_fit_curves;};
            /*! Set start and end to selected X range of curve index or, if there's no selection, to the curve's total range.
             *
             * \return the number of selected or total points
             */
            int range(int index, double *start, double *end);

            //!  Used for VerticalBars, HorizontalBars and Histograms
            void setBarsGap(int curve, int gapPercent, int offset);

            //! \name Image Analysis Tools
            //@{
            void showIntensityTable();
            //@}

            //! \name User-defined Functions
            //@{
            bool modifyFunctionCurve(ApplicationWindow * parent, int curve, int type, const QStringList &formulas, const QString &var,QList<double> &ranges, int points);
            bool addFunctionCurve(ApplicationWindow *parent, int type, const QStringList &formulas, const QString& var,
                        QList<double> &ranges, int points, const QString& title = QString::null);
            //! Used when reading from a project file.
            bool insertFunctionCurve(ApplicationWindow * parent, const QStringList& func_spec, int points, int fileVersion);
            //! Returns an unique function name
        QString generateFunctionName(const QString& name = tr("F"));
            //@}

        //! Provided for convenience in scripts.
            void createTable(const QString& curveName);
        void createTable(const QwtPlotCurve* curve);
            void activateGraph();

            //! \name Vector Curves
            //@{
            void plotVectorCurve(Table* w, const QStringList& colList, int style, int startRow = 0, int endRow = -1);
            void updateVectorsLayout(int curve, const QColor& color, int width, int arrowLength, int arrowAngle, bool filled, int position,
                        const QString& xEndColName = QString(), const QString& yEndColName = QString());
            //@}

            //! \name Box Plots
            //@{
            void openBoxDiagram(Table *w, const QStringList& l, int fileVersion);
            void plotBoxDiagram(Table *w, const QStringList& names, int startRow = 0, int endRow = -1);
            //@}

            void setCurveSymbol(int index, const QwtSymbol& s);
            void setCurvePen(int index, const QPen& p);
            void setCurveBrush(int index, const QBrush& b);
            void setCurveStyle(int index, int s);

            //! \name Resizing
            //@{
            bool ignoresResizeEvents(){return ignoreResize;};
            void setIgnoreResizeEvents(bool ok){ignoreResize=ok;};
            void resizeEvent(QResizeEvent *e);
            void scaleFonts(double factor);
            //@}

            void notifyChanges();

            void updateSecondaryAxis(int axis);
            void enableAutoscaling(bool yes){m_autoscale = yes;};

            bool autoscaleFonts(){return autoScaleFonts;};
            void setAutoscaleFonts(bool yes){autoScaleFonts = yes;};

            static int obsoleteSymbolStyle(int type);
            static QString penStyleName(Qt::PenStyle style);
            static Qt::PenStyle getPenStyle(const QString& s);
            static Qt::PenStyle getPenStyle(int style);
            static Qt::BrushStyle getBrushStyle(int style);
            static void showPlotErrorMessage(QWidget *parent, const QStringList& emptyColumns);
            static QPrinter::PageSize minPageSize(const QPrinter& printer, const QRect& r);

            void showTitleContextMenu();
            void copyTitle();
            void cutTitle();

            void removeAxisTitle();
            void cutAxisTitle();
            void copyAxisTitle();
            void showAxisTitleMenu(int axis);
            void showAxisContextMenu(int axis);
            void hideSelectedAxis();
            void showGrids();

            //! Convenience function enabling the grid for QwtScaleDraw::Left and Bottom Scales
            void showGrid();
            //! Convenience function enabling the grid for a user defined axis
            void showGrid(int axis);

            void showAxisDialog();
            void showScaleDialog();

            //! Add a spectrogram to the graph
            void plotSpectrogram(Matrix *m, CurveType type);
            //! Restores a spectrogram. Used when opening a project file.
            void restoreSpectrogram(ApplicationWindow *app, const QStringList& lst);

            bool antialiasing(){return d_antialiasing;};
            //! Enables/Disables antialiasing of plot items.
            void setAntialiasing(bool on = true, bool update = true);

            void deselect();
            void print(QPainter *, const QRect &rect, const QwtPlotPrintFilter & = QwtPlotPrintFilter());
            void printCanvas(QPainter *painter, const QRect &canvasRect,
                   const QwtScaleMap map[QwtPlot::axisCnt], const QwtPlotPrintFilter &pfilter) const;

signals:
            void selectedGraph (Graph*);
            void closedGraph();
            void drawTextOff();
            void drawLineEnded(bool);
            void cursorInfo(const QString&);
            void showPlotDialog(int);
            void createTable(const QString&,const QString&,QList<Column*>);

            void viewImageDialog();
            void viewTextDialog();
            void viewLineDialog();
            void viewTitleDialog();
            void modifiedGraph();
            void hiddenPlot(QWidget*);

            void showLayerButtonContextMenu();
            void showContextMenu();
            void showCurveContextMenu(int);
            void showMarkerPopupMenu();

            void showAxisDialog(int);
            void axisDblClicked(int);
            void xAxisTitleDblClicked();
            void yAxisTitleDblClicked();
            void rightAxisTitleDblClicked();
            void topAxisTitleDblClicked();

            void createIntensityTable(const QString&);
            void dataRangeChanged();
            void showFitResults(const QString&);

      private:
            //! List storing pointers to the curves resulting after a fit session, in case the user wants to delete them later on.
00723             QList<QwtPlotCurve *>d_fit_curves;
            //! Render hint for plot items.
00725             bool d_antialiasing;
            bool autoScaleFonts;
            bool d_scale_on_print, d_print_cropmarks;
            int selectedAxis;
            QStringList axesFormulas;
            //! Stores columns used for axes with text labels or time/date format info
00731             QStringList axesFormatInfo;
            QList <int> axisType;
            MarkerType selectedMarkerType;
            QwtPlotMarker::LineStyle mrklStyle;

            //! Stores the step the user specified for the four scale. If step = 0.0, the step will be calculated automatically by the Qwt scale engine.
00737             QVector<double> d_user_step;
            //! Curve types
00739             QVector<int> c_type;
            //! Curves on plot keys
00741             QVector<int> c_keys;
            //! Arrows/lines on plot keys
00743             QVector<int> d_lines;
            //! Images on plot keys
00745             QVector<int> d_images;
            //! Stores the identifiers (keys) of the text objects on the plot
00747             QVector<int> d_texts;

            QPen mrkLinePen;
            QFont auxMrkFont, defaultMarkerFont;
            QColor auxMrkColor, auxMrkBkgColor;
            QPoint auxMrkStart, auxMrkEnd;
            Qt::PenStyle auxMrkStyle;
            QString auxMrkFileName, auxMrkText;

            int n_curves;
            int widthLine, defaultMarkerFrame;
            QColor defaultTextMarkerColor, defaultTextMarkerBackground;
            int auxMrkAngle,auxMrkBkg,auxMrkWidth;
            int auxArrowHeadLength, auxArrowHeadAngle;
            long selectedMarker,legendMarkerID;
            bool startArrowOn, endArrowOn, drawTextOn, drawLineOn, drawArrowOn;

            bool auxFilledArrowHead, ignoreResize;
            bool drawAxesBackbone, m_autoscale;

            QColor defaultArrowColor;
            int defaultArrowLineWidth, defaultArrowHeadLength, defaultArrowHeadAngle;
            bool defaultArrowHeadFill;
            Qt::PenStyle defaultArrowLineStyle;

            //! The markers selected for move/resize operations or NULL if none are selected.
00773             QPointer<SelectionMoveResizer> d_markers_selector;
            //! The current curve selection, or NULL if none is active.
00775             QPointer<RangeSelectorTool> d_range_selector;
            //! The currently active tool, or NULL for default (pointer).
00777             PlotToolInterface *d_active_tool;
};
#endif // GRAPH_H

Generated by  Doxygen 1.6.0   Back to index