Index: src/UIElements/Views/Qt4/Plotting/Makefile.am
===================================================================
--- src/UIElements/Views/Qt4/Plotting/Makefile.am	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/Makefile.am	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,75 @@
+# Below is all for the User Interface
+
+if CONDQWT
+QWTSOURCE = \
+	UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.cpp \
+	UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.cpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.cpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.cpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.cpp \
+	UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisData.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisPageRegistry.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlot.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlotCurve.cpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlotPage.cpp
+
+QWTMOC_HEADER = \
+	UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.hpp \
+	UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.hpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.hpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp \
+	UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.hpp \
+	UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisData.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlot.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp \
+	UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp
+
+QWT_HEADER = \
+	$(QWTMOC_HEADER)
+
+if CONDQTGUI
+lib_LTLIBRARIES += libMolecuilderQwtUI.la
+
+libMolecuilderQwtUI_la_includedir = $(includedir)/MoleCuilder/
+libMolecuilderQwtUI_la_CPPFLAGS = ${QT_CFLAGS} ${GLU_CXXFLAGS} ${BOOST_CPPFLAGS} ${CodePatterns_CFLAGS}  ${JobMarket_CFLAGS} $(mol_ac_qwt_cxxflags)
+libMolecuilderQwtUI_la_LDFLAGS = $(AM_LDFLAGS) $(BOOST_FILESYSTEM_LDFLAGS) $(BOOST_PROGRAM_OPTIONS_LDFLAGS) $(BOOST_RANDOM_LDFLAGS) $(BOOST_SYSTEM_LDFLAGS) $(BOOST_THREAD_LDFLAGS) $(mol_ac_qwt_ldflags)
+
+libMolecuilderQwtUI_la_LIBADD = \
+	$(mol_ac_qwt_libs)
+
+nobase_libMolecuilderQwtUI_la_include_HEADERS = ${QWTHEADER}
+libMolecuilderQwtUI_la_SOURCES = ${QWTSOURCE}
+nodist_libMolecuilderQwtUI_la_SOURCES =
+libMolecuilderQwtUI_la_LDFLAGS += -version-info $(MOLECUILDER_SO_VERSION)
+#libMolecuilderQwtUI_libincludedir = $(libdir)/MoleCuilder/include
+#nodist_libMolecuilderQwtUI_libinclude_HEADERS = $(top_builddir)/libmolecuilder_config.h
+
+
+nodist_libMolecuilderQwtUI_la_SOURCES += allqwtmocs.moc.cpp
+
+#Rules needed for Qt4
+# UI-Files are scattered throughout several subdirectories
+# Therfore `%'-rules do not seem to work
+#Quick fix to get it done otherwise
+allqwtmocs.moc.cpp: ${QWTMOC_HEADER}
+	echo "" > allqwtmocs.moc.cpp;\
+	list='${QWTMOC_HEADER}'; for header in $$list; do \
+	echo "Making mocfile for $$header"; \
+	target=`basename $$header | sed "s/\(.*\)\..*/\1.moc.cpp/"`;\
+	$(QT_MOC) $(srcdir)/$$header -o $$target \
+	|| eval $$failcom; \
+	echo "#include \"$$target\"" >> allqwtmocs.moc.cpp; \
+	done;
+
+MOSTLYCLEANFILES += \
+	*.moc.cpp \
+	moc_*.cpp \
+	ui_*.h
+
+endif
+endif
Index: src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,27 @@
+/*
+ * QListWidgetCurveItem.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "QListWidgetCurveItem.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+
+QListWidgetCurveItem::QListWidgetCurveItem()
+{
+
+}
+
+QListWidgetCurveItem::~QListWidgetCurveItem()
+{
+
+}
Index: src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,41 @@
+/*
+ * QListWidgetCurveItem.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QLISTWIDGETCURVEITEM_HPP
+#define QLISTWIDGETCURVEITEM_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtGui/QListWidgetItem>
+
+/**
+ * \class QListWidgetCurveItem
+ *
+ * The class only adds the curveName
+ * property (as std::string) to the
+ * QListWidgetItem class.
+ * The curveName property should contain
+ * the name by which the curve can be
+ * retrieved from the registry.
+ **/
+
+class QListWidgetCurveItem : public QListWidgetItem
+{
+public:
+    QListWidgetCurveItem();
+    ~QListWidgetCurveItem();
+    std::string curveName;
+
+signals:
+
+public slots:
+};
+
+#endif // QLISTWIDGETCURVEITEM_HPP
Index: src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,200 @@
+/*
+ * QSeisScrollbar.cpp
+ *
+ *  taken from "realtime"-example
+ *
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qstyle.h>
+#if QT_VERSION >= 0x040000
+#include <qstyleoption.h>
+#endif
+#include "ScrollBar.hpp"
+
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+ScrollBar::ScrollBar(QWidget * parent):
+    QScrollBar(parent)
+{
+    init();
+}
+
+ScrollBar::ScrollBar(Qt::Orientation o, 
+        QWidget *parent):
+    QScrollBar(o, parent)
+{
+    init();
+}
+
+ScrollBar::ScrollBar(double minBase, double maxBase, 
+        Qt::Orientation o, QWidget *parent):
+    QScrollBar(o, parent)
+{
+    init();
+    setBase(minBase, maxBase);
+    moveSlider(minBase, maxBase);
+}
+
+void ScrollBar::init()
+{
+    d_inverted = orientation() == Qt::Vertical;
+    d_baseTicks = 1000000;
+    d_minBase = 0.0;
+    d_maxBase = 1.0;
+    moveSlider(d_minBase, d_maxBase);
+
+    connect(this, SIGNAL(sliderMoved(int)), SLOT(catchSliderMoved(int)));
+    connect(this, SIGNAL(valueChanged(int)), SLOT(catchValueChanged(int)));
+}
+
+void ScrollBar::setInverted(bool inverted)
+{
+    if ( d_inverted != inverted )
+    {
+        d_inverted = inverted;
+        moveSlider(minSliderValue(), maxSliderValue());
+    }
+}
+
+bool ScrollBar::isInverted() const
+{
+    return d_inverted;
+}
+
+void ScrollBar::setBase(double min, double max)
+{
+    if ( min != d_minBase || max != d_maxBase )
+    {
+        d_minBase = min;
+        d_maxBase = max;
+
+        moveSlider(minSliderValue(), maxSliderValue());
+    }
+}
+
+void ScrollBar::moveSlider(double min, double max)
+{
+    const int sliderTicks = qRound((max - min) / 
+        (d_maxBase - d_minBase) * d_baseTicks);
+
+    // setRange initiates a valueChanged of the scrollbars
+    // in some situations. So we block
+    // and unblock the signals.
+
+    blockSignals(true);
+
+    setRange(sliderTicks / 2, d_baseTicks - sliderTicks / 2);
+    int steps = sliderTicks / 200;
+    if ( steps <= 0 )
+        steps = 1;
+
+#if QT_VERSION < 0x040000
+    setSteps(steps, sliderTicks);
+#else
+    setSingleStep(steps);
+    setPageStep(sliderTicks);
+#endif
+
+    int tick = mapToTick(min + (max - min) / 2);
+    if ( isInverted() )
+        tick = d_baseTicks - tick;
+
+#if QT_VERSION < 0x040000
+    directSetValue(tick);
+    rangeChange();
+#else
+    setSliderPosition(tick);
+#endif
+    blockSignals(false);
+}
+
+double ScrollBar::minBaseValue() const
+{
+    return d_minBase;
+}
+
+double ScrollBar::maxBaseValue() const
+{
+    return d_maxBase;
+}
+
+void ScrollBar::sliderRange(int value, double &min, double &max) const
+{
+    if ( isInverted() )
+        value = d_baseTicks - value;
+
+    const int visibleTicks = pageStep();
+
+    min = mapFromTick(value - visibleTicks / 2);
+    max = mapFromTick(value + visibleTicks / 2);
+}
+
+double ScrollBar::minSliderValue() const
+{
+    double min, dummy;
+    sliderRange(value(), min, dummy);
+
+    return min;
+}
+
+double ScrollBar::maxSliderValue() const
+{
+    double max, dummy;
+    sliderRange(value(), dummy, max);
+
+    return max;
+}
+
+int ScrollBar::mapToTick(double v) const
+{   
+    return (int) ( ( v - d_minBase) / (d_maxBase - d_minBase ) * d_baseTicks );
+}
+
+double ScrollBar::mapFromTick(int tick) const
+{   
+    return d_minBase + ( d_maxBase - d_minBase ) * tick / d_baseTicks;
+}
+
+void ScrollBar::catchValueChanged(int value)
+{
+    double min, max;
+    sliderRange(value, min, max);
+    emit valueChanged(orientation(), min, max);
+}
+
+void ScrollBar::catchSliderMoved(int value)
+{
+    double min, max;
+    sliderRange(value, min, max);
+    emit sliderMoved(orientation(), min, max);
+}
+
+int ScrollBar::extent() const
+{
+#if QT_VERSION < 0x040000
+    return style().pixelMetric(QStyle::PM_ScrollBarExtent, this);
+#else
+    QStyleOptionSlider opt;
+    opt.init(this);
+    opt.subControls = QStyle::SC_None;
+    opt.activeSubControls = QStyle::SC_None;
+    opt.orientation = orientation();
+    opt.minimum = minimum();
+    opt.maximum = maximum();
+    opt.sliderPosition = sliderPosition();
+    opt.sliderValue = value();
+    opt.singleStep = singleStep();
+    opt.pageStep = pageStep();
+    opt.upsideDown = invertedAppearance();
+    if (orientation() == Qt::Horizontal)
+        opt.state |= QStyle::State_Horizontal;
+    return style()->pixelMetric(QStyle::PM_ScrollBarExtent, &opt, this);
+#endif
+}
Index: src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,65 @@
+/*
+ * QSeisScrollbar.cpp
+ *
+ *  taken from "realtime"-example
+ *
+ */
+
+#ifndef _SCROLLBAR_HPP
+#define _SCROLLBAR_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qscrollbar.h>
+
+class ScrollBar: public QScrollBar
+{
+    Q_OBJECT
+
+public:
+    ScrollBar(QWidget *parent = NULL);
+    ScrollBar(Qt::Orientation, QWidget *parent = NULL);
+    ScrollBar(double minBase, double maxBase,       
+        Qt::Orientation o, QWidget *parent = NULL);
+
+    void setInverted(bool);
+    bool isInverted() const;
+
+    double minBaseValue() const;
+    double maxBaseValue() const;
+
+    double minSliderValue() const;
+    double maxSliderValue() const;
+
+    int extent() const;
+
+signals:
+    void sliderMoved(Qt::Orientation, double, double);
+    void valueChanged(Qt::Orientation, double, double);
+
+public slots:
+    virtual void setBase(double min, double max);
+    virtual void moveSlider(double min, double max);
+
+protected:
+    void sliderRange(int value, double &min, double &max) const;
+    int mapToTick(double) const;
+    double mapFromTick(int) const;
+
+private slots:
+    void catchValueChanged(int value);
+    void catchSliderMoved(int value);
+
+private:
+    void init();
+
+    bool d_inverted;
+    double d_minBase;
+    double d_maxBase;
+    int d_baseTicks;
+};
+
+#endif // _SCROLLBAR_HPP
Index: src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,537 @@
+/*
+ * QSeisScrollzoomer.cpp
+ *
+ *  taken from "realtime"-example
+ *
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qevent.h>
+#include <qwt_plot_canvas.h>
+#include <qwt_plot_layout.h>
+#include <qwt_scale_engine.h>
+#include <qwt_scale_widget.h>
+#include "ScrollZoomer.hpp"
+
+#include "UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollBar.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+class ScrollData
+{
+public:
+    ScrollData():
+        scrollBar(NULL),
+        position(ScrollZoomer::OppositeToScale),
+#if QT_VERSION < 0x040000
+        mode(QScrollView::Auto)
+#else
+        mode(Qt::ScrollBarAsNeeded)
+#endif
+    {
+    }
+
+    ~ScrollData()
+    {
+        delete scrollBar;
+    }
+
+    ScrollBar *scrollBar;
+    ScrollZoomer::ScrollBarPosition position;
+#if QT_VERSION < 0x040000
+    QScrollView::ScrollBarMode mode;
+#else
+    Qt::ScrollBarPolicy mode;
+#endif
+};
+
+ScrollZoomer::ScrollZoomer(QwtPlotCanvas *canvas):
+    QwtPlotZoomer(canvas),
+    d_cornerWidget(NULL),
+    d_hScrollData(NULL),
+    d_vScrollData(NULL),
+    d_inZoom(false),
+    d_alignCanvasToScales(false)
+{
+    if ( !canvas )
+        return;
+
+    d_hScrollData = new ScrollData;
+    d_vScrollData = new ScrollData;
+
+    //disable zoom reset on middle mouse button
+    setMousePattern(QwtEventPattern::MouseSelect3, Qt::NoButton);
+}
+
+ScrollZoomer::~ScrollZoomer()
+{
+    delete d_cornerWidget;
+    delete d_vScrollData;
+    delete d_hScrollData;
+}
+
+void ScrollZoomer::rescale()
+{
+    QwtScaleWidget *xScale = plot()->axisWidget(xAxis());
+    QwtScaleWidget *yScale = plot()->axisWidget(yAxis());
+
+    if ( zoomRectIndex() <= 0 )
+    {
+        if ( d_inZoom )
+        {
+            xScale->setMinBorderDist(0, 0);
+            yScale->setMinBorderDist(0, 0);
+
+            QwtPlotLayout *layout = plot()->plotLayout();
+            layout->setAlignCanvasToScales(d_alignCanvasToScales);
+
+            d_inZoom = false;
+        }
+    }
+    else
+    {
+        if ( !d_inZoom )
+        {
+            /*
+             We set a minimum border distance. 
+             Otherwise the canvas size changes when scrolling, 
+             between situations where the major ticks are at
+             the canvas borders (requiring extra space for the label)
+             and situations where all labels can be painted below/top
+             or left/right of the canvas.
+             */
+            int start, end;
+
+            xScale->getBorderDistHint(start, end);
+            xScale->setMinBorderDist(start, end);
+
+            yScale->getBorderDistHint(start, end);
+            yScale->setMinBorderDist(start, end);
+
+            QwtPlotLayout *layout = plot()->plotLayout();
+            d_alignCanvasToScales = layout->alignCanvasToScales();
+            layout->setAlignCanvasToScales(false);
+
+            d_inZoom = true;
+        }
+    }
+
+    QwtPlotZoomer::rescale();
+    updateScrollBars();
+}
+
+ScrollBar *ScrollZoomer::scrollBar(Qt::Orientation o)
+{
+    ScrollBar *&sb = (o == Qt::Vertical) 
+        ? d_vScrollData->scrollBar : d_hScrollData->scrollBar;
+
+    if ( sb == NULL )
+    {
+        sb = new ScrollBar(o, canvas());
+        sb->hide();
+        connect(sb,
+            SIGNAL(valueChanged(Qt::Orientation, double, double)),
+            SLOT(scrollBarMoved(Qt::Orientation, double, double)));
+    }
+    return sb;
+}
+
+ScrollBar *ScrollZoomer::horizontalScrollBar() const
+{
+    return d_hScrollData->scrollBar;
+}
+
+ScrollBar *ScrollZoomer::verticalScrollBar() const
+{
+    return d_vScrollData->scrollBar;
+}
+    
+#if QT_VERSION < 0x040000
+void ScrollZoomer::setHScrollBarMode(QScrollView::ScrollBarMode mode)
+#else
+void ScrollZoomer::setHScrollBarMode(Qt::ScrollBarPolicy mode)
+#endif
+{
+    if ( hScrollBarMode() != mode )
+    {
+        d_hScrollData->mode = mode;
+        updateScrollBars();
+    }
+}
+
+#if QT_VERSION < 0x040000
+void ScrollZoomer::setVScrollBarMode(QScrollView::ScrollBarMode mode)
+#else
+void ScrollZoomer::setVScrollBarMode(Qt::ScrollBarPolicy mode)
+#endif
+{
+    if ( vScrollBarMode() != mode )
+    {
+        d_vScrollData->mode = mode;
+        updateScrollBars();
+    }
+}
+
+#if QT_VERSION < 0x040000
+QScrollView::ScrollBarMode ScrollZoomer::hScrollBarMode() const
+#else
+Qt::ScrollBarPolicy ScrollZoomer::hScrollBarMode() const
+#endif
+{
+    return d_hScrollData->mode;
+}
+
+#if QT_VERSION < 0x040000
+QScrollView::ScrollBarMode ScrollZoomer::vScrollBarMode() const
+#else
+Qt::ScrollBarPolicy ScrollZoomer::vScrollBarMode() const
+#endif
+{
+    return d_vScrollData->mode;
+}
+
+void ScrollZoomer::setHScrollBarPosition(ScrollBarPosition pos)
+{
+    if ( d_hScrollData->position != pos )
+    {
+        d_hScrollData->position = pos;
+        updateScrollBars();
+    }
+}
+
+void ScrollZoomer::setVScrollBarPosition(ScrollBarPosition pos)
+{
+    if ( d_vScrollData->position != pos )
+    {
+        d_vScrollData->position = pos;
+        updateScrollBars();
+    }
+}
+
+ScrollZoomer::ScrollBarPosition ScrollZoomer::hScrollBarPosition() const
+{
+    return d_hScrollData->position;
+}
+
+ScrollZoomer::ScrollBarPosition ScrollZoomer::vScrollBarPosition() const
+{
+    return d_vScrollData->position;
+}
+
+void ScrollZoomer::setCornerWidget(QWidget *w)
+{
+    if ( w != d_cornerWidget )
+    {
+        if ( canvas() )
+        {
+            delete d_cornerWidget;
+            d_cornerWidget = w;
+            if ( d_cornerWidget->parent() != canvas() )
+            {
+#if QT_VERSION < 0x040000
+                d_cornerWidget->reparent(canvas(), QPoint(0, 0));
+#else
+                d_cornerWidget->setParent(canvas());
+#endif
+            }
+
+            updateScrollBars();
+        }
+    }
+}
+
+QWidget *ScrollZoomer::cornerWidget() const
+{
+    return d_cornerWidget;
+}
+
+bool ScrollZoomer::eventFilter(QObject *o, QEvent *e)
+{
+    if (  o == canvas() )
+    {
+        switch(e->type())
+        {
+            case QEvent::Resize:
+            {
+                const int fw = ((QwtPlotCanvas *)canvas())->frameWidth();
+
+                QRect rect;
+                rect.setSize(((QResizeEvent *)e)->size());
+                rect.setRect(rect.x() + fw, rect.y() + fw,
+                    rect.width() - 2 * fw, rect.height() - 2 * fw);
+
+                layoutScrollBars(rect);
+                break;
+            }
+            case QEvent::ChildRemoved:
+            {
+                const QObject *child = ((QChildEvent *)e)->child();
+                if ( child == d_cornerWidget )
+                    d_cornerWidget = NULL;
+                else if ( child == d_hScrollData->scrollBar )
+                    d_hScrollData->scrollBar = NULL;
+                else if ( child == d_vScrollData->scrollBar )
+                    d_vScrollData->scrollBar = NULL;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return QwtPlotZoomer::eventFilter(o, e);
+}
+
+bool ScrollZoomer::needScrollBar(Qt::Orientation o) const
+{
+#if QT_VERSION < 0x040000
+    QScrollView::ScrollBarMode mode;
+#else
+    Qt::ScrollBarPolicy mode;
+#endif
+    double zoomMin, zoomMax, baseMin, baseMax;
+
+    if ( o == Qt::Horizontal )
+    {
+        mode = d_hScrollData->mode;
+        baseMin = zoomBase().left();
+        baseMax = zoomBase().right();
+        zoomMin = zoomRect().left();
+        zoomMax = zoomRect().right();
+    }
+    else
+    {
+        mode = d_vScrollData->mode;
+        baseMin = zoomBase().top();
+        baseMax = zoomBase().bottom();
+        zoomMin = zoomRect().top();
+        zoomMax = zoomRect().bottom();
+    }
+
+    bool needed = false;
+    switch(mode)
+    {
+#if QT_VERSION < 0x040000
+        case QScrollView::AlwaysOn:
+#else
+        case Qt::ScrollBarAlwaysOn:
+#endif
+            needed = true;
+            break;
+#if QT_VERSION < 0x040000
+        case QScrollView::AlwaysOff:    
+#else
+        case Qt::ScrollBarAlwaysOff:
+#endif
+            needed = false;
+            break;
+        default:
+        {
+            if ( baseMin < zoomMin || baseMax > zoomMax )
+                needed = true;
+            break;
+        }
+    }
+    return needed;
+}
+
+void ScrollZoomer::updateScrollBars()
+{
+    if ( !canvas() )
+        return;
+
+    const int xAxis = QwtPlotZoomer::xAxis();
+    const int yAxis = QwtPlotZoomer::yAxis();
+
+    int xScrollBarAxis = xAxis;
+    if ( hScrollBarPosition() == OppositeToScale )
+        xScrollBarAxis = oppositeAxis(xScrollBarAxis);
+
+    int yScrollBarAxis = yAxis;
+    if ( vScrollBarPosition() == OppositeToScale ) 
+        yScrollBarAxis = oppositeAxis(yScrollBarAxis); 
+
+
+    QwtPlotLayout *layout = plot()->plotLayout();
+
+    bool showHScrollBar = needScrollBar(Qt::Horizontal);
+    if ( showHScrollBar )
+    {
+        ScrollBar *sb = scrollBar(Qt::Horizontal);
+
+        sb->setPalette(plot()->palette());
+
+        const QwtScaleDiv *sd = plot()->axisScaleDiv(xAxis);
+        sb->setInverted(sd->lowerBound() > sd->upperBound() );
+
+        sb->setBase(zoomBase().left(), zoomBase().right());
+        sb->moveSlider(zoomRect().left(), zoomRect().right());
+
+        if ( !sb->isVisibleTo(canvas()) )
+        {
+            sb->show();
+            layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis) 
+                + sb->extent(), xScrollBarAxis);
+        }
+    }
+    else
+    {
+        if ( horizontalScrollBar() )
+        {
+            horizontalScrollBar()->hide();
+            layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis) 
+                - horizontalScrollBar()->extent(), xScrollBarAxis);
+        }
+    }
+
+    bool showVScrollBar = needScrollBar(Qt::Vertical);
+    if ( showVScrollBar )
+    {
+        ScrollBar *sb = scrollBar(Qt::Vertical);
+
+        sb->setPalette(plot()->palette());
+
+        const QwtScaleDiv *sd = plot()->axisScaleDiv(yAxis);
+        sb->setInverted(sd->lowerBound() < sd->upperBound() );
+
+        sb->setBase(zoomBase().top(), zoomBase().bottom());
+        sb->moveSlider(zoomRect().top(), zoomRect().bottom());
+
+        if ( !sb->isVisibleTo(canvas()) )
+        {
+            sb->show();
+            layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis) 
+                + sb->extent(), yScrollBarAxis);
+        }
+    }
+    else
+    {
+        if ( verticalScrollBar() )
+        {
+            verticalScrollBar()->hide();
+            layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis) 
+                - verticalScrollBar()->extent(), yScrollBarAxis);
+        }
+    }
+
+    if ( showHScrollBar && showVScrollBar )
+    {
+        if ( d_cornerWidget == NULL )
+        {
+            d_cornerWidget = new QWidget(canvas());
+#if QT_VERSION >= 0x040100
+            d_cornerWidget->setAutoFillBackground(true);
+#endif
+            d_cornerWidget->setPalette(plot()->palette());
+        }
+        d_cornerWidget->show();
+    }
+    else
+    {
+        if ( d_cornerWidget )
+            d_cornerWidget->hide();
+    }
+
+    layoutScrollBars(((QwtPlotCanvas *)canvas())->contentsRect());
+    plot()->updateLayout();
+}
+
+void ScrollZoomer::layoutScrollBars(const QRect &rect)
+{
+    int hPos = xAxis();
+    if ( hScrollBarPosition() == OppositeToScale )
+        hPos = oppositeAxis(hPos);
+
+    int vPos = yAxis();
+    if ( vScrollBarPosition() == OppositeToScale )
+        vPos = oppositeAxis(vPos);
+
+    ScrollBar *hScrollBar = horizontalScrollBar();
+    ScrollBar *vScrollBar = verticalScrollBar();
+
+    const int hdim = hScrollBar ? hScrollBar->extent() : 0;
+    const int vdim = vScrollBar ? vScrollBar->extent() : 0;
+    
+    if ( hScrollBar && hScrollBar->isVisible() )
+    {
+        int x = rect.x();
+        int y = (hPos == QwtPlot::xTop) 
+            ? rect.top() : rect.bottom() - hdim + 1;
+        int w = rect.width();
+
+        if ( vScrollBar && vScrollBar->isVisible() )
+        {
+            if ( vPos == QwtPlot::yLeft )
+                x += vdim;
+            w -= vdim;
+        }
+
+        hScrollBar->setGeometry(x, y, w, hdim);
+    }
+    if ( vScrollBar && vScrollBar->isVisible() )
+    {
+        int pos = yAxis();
+        if ( vScrollBarPosition() == OppositeToScale )
+            pos = oppositeAxis(pos);
+
+        int x = (vPos == QwtPlot::yLeft)
+            ? rect.left() : rect.right() - vdim + 1;
+        int y = rect.y();
+
+        int h = rect.height();
+
+        if ( hScrollBar && hScrollBar->isVisible() )
+        {
+            if ( hPos == QwtPlot::xTop )
+                y += hdim;
+                
+            h -= hdim;
+        }
+
+        vScrollBar->setGeometry(x, y, vdim, h);
+    }
+    if ( hScrollBar && hScrollBar->isVisible() &&
+        vScrollBar && vScrollBar->isVisible() )
+    {
+        if ( d_cornerWidget )
+        {
+            QRect cornerRect(
+                vScrollBar->pos().x(), hScrollBar->pos().y(),
+                vdim, hdim);
+            d_cornerWidget->setGeometry(cornerRect);
+        }
+    }
+}
+
+void ScrollZoomer::scrollBarMoved(Qt::Orientation o, double min, double)
+{
+    if ( o == Qt::Horizontal )
+        move(min, zoomRect().top());
+    else
+        move(zoomRect().left(), min);
+
+    emit zoomed(zoomRect());
+}
+
+int ScrollZoomer::oppositeAxis(int axis) const
+{
+    switch(axis)
+    {
+        case QwtPlot::xBottom:
+            return QwtPlot::xTop;
+        case QwtPlot::xTop:
+            return QwtPlot::xBottom;
+        case QwtPlot::yLeft:
+            return QwtPlot::yRight;
+        case QwtPlot::yRight:
+            return QwtPlot::yLeft;
+        default:
+            break;
+    }
+
+    return axis;
+}
Index: src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,89 @@
+/*
+ * QSeisScrollzoomer.h
+ *
+ *  taken from "realtime"-example
+ *
+ */
+
+#ifndef _SCROLLZOOMER_HPP
+#define _SCROLLZOOMER_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qglobal.h>
+#if QT_VERSION < 0x040000
+#include <qscrollview.h>
+#endif
+#include <qwt_plot_zoomer.h>
+
+class ScrollData;
+class ScrollBar;
+
+class ScrollZoomer: public QwtPlotZoomer
+{
+    Q_OBJECT
+public:
+    enum ScrollBarPosition
+    {
+        AttachedToScale,
+        OppositeToScale
+    };
+
+    ScrollZoomer(QwtPlotCanvas *);
+    virtual ~ScrollZoomer();
+
+    ScrollBar *horizontalScrollBar() const;
+    ScrollBar *verticalScrollBar() const;
+
+#if QT_VERSION < 0x040000
+    void setHScrollBarMode(QScrollView::ScrollBarMode);
+    void setVScrollBarMode(QScrollView::ScrollBarMode);
+
+    QScrollView::ScrollBarMode vScrollBarMode () const;
+    QScrollView::ScrollBarMode hScrollBarMode () const;
+#else
+    void setHScrollBarMode(Qt::ScrollBarPolicy);
+    void setVScrollBarMode(Qt::ScrollBarPolicy);
+
+    Qt::ScrollBarPolicy vScrollBarMode () const;
+    Qt::ScrollBarPolicy hScrollBarMode () const;
+#endif
+
+    void setHScrollBarPosition(ScrollBarPosition);
+    void setVScrollBarPosition(ScrollBarPosition);
+
+    ScrollBarPosition hScrollBarPosition() const;
+    ScrollBarPosition vScrollBarPosition() const;
+
+    QWidget* cornerWidget() const;
+    virtual void setCornerWidget(QWidget *); 
+    
+    virtual bool eventFilter(QObject *, QEvent *);
+
+    virtual void rescale();
+
+protected:
+    virtual ScrollBar *scrollBar(Qt::Orientation);
+    virtual void updateScrollBars();
+    virtual void layoutScrollBars(const QRect &);
+
+private slots:
+    void scrollBarMoved(Qt::Orientation o, double min, double max);
+
+private:
+    bool needScrollBar(Qt::Orientation) const;
+    int oppositeAxis(int) const;
+
+    QWidget *d_cornerWidget;
+
+    ScrollData *d_hScrollData;
+    ScrollData *d_vScrollData;
+
+    bool d_inZoom;
+    bool d_alignCanvasToScales;
+};
+            
+#endif // _SCROLLZOOMER_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,52 @@
+/*
+ * QSeisCurveRegistry.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include "CodePatterns/Registry_impl.hpp"
+#include "CodePatterns/Singleton_impl.hpp"
+
+#include <iostream>
+
+QSeisCurveRegistry::QSeisCurveRegistry()
+{
+}
+
+QSeisCurveRegistry::~QSeisCurveRegistry()
+{}
+
+void QSeisCurveRegistry::registerInstance(QSeisPlotCurve *instance)
+{
+    Registry<QSeisPlotCurve>::registerInstance(instance);
+    emit curveAdded(instance->getName(), instance->type);
+}
+
+void QSeisCurveRegistry::unregisterInstance(QSeisPlotCurve *instance)
+{
+    Registry<QSeisPlotCurve>::unregisterInstance(instance);
+    emit curveRemoved(instance->getName(), instance->type);
+}
+
+void QSeisCurveRegistry::resetRegistry()
+{
+	for (std::map<const std::string,QSeisPlotCurve*>::iterator iter = getBeginIter(); iter != getEndIter(); ++iter)
+		emit curveRemoved(iter->first, iter->second->type);
+		Registry<QSeisPlotCurve>::cleanup();
+}
+
+
+CONSTRUCT_SINGLETON(QSeisCurveRegistry)
+CONSTRUCT_REGISTRY(QSeisPlotCurve)
Index: src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,63 @@
+/*
+ * QSeisCurveRegistry.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QSEISCURVEREGISTRY_HPP
+#define QSEISCURVEREGISTRY_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtCore/QObject>
+#include "CodePatterns/Registry.hpp"
+#include "CodePatterns/Singleton.hpp"
+
+/**
+ * \class QSeisCurveRegistry
+ *
+ * This class acts as a registry for all
+ * currently available QSeisPlotCurves.
+ *
+ * The (un)registerInstance functions where
+ * reimplemented to include the curveAdded/
+ * Changed/Removed signals.
+ * The QSeisPageRegistry relays on this
+ * signals to maintain the existing list of
+ * available curves.
+ *
+ * The resetRegistry() function is basically
+ * the normal Registry::cleanup() function,
+ * it only emits additionally the curveRemoved()
+ * signal for every curve to keep the
+ * PageRegistry on track.
+ **/
+
+class QSeisPlotCurve;
+
+class QSeisCurveRegistry : public QObject, public Registry<QSeisPlotCurve>, public Singleton<QSeisCurveRegistry>
+{
+    Q_OBJECT
+
+    friend class Singleton<QSeisCurveRegistry>;
+
+public:
+    void registerInstance(QSeisPlotCurve *instance);
+    void unregisterInstance(QSeisPlotCurve *instance);
+    void resetRegistry();
+
+private:
+    QSeisCurveRegistry();
+    ~QSeisCurveRegistry();
+
+signals:
+    void curveAdded(std::string name, QString type);
+    void curveChanged(std::string name, QString type);
+    void curveRemoved(std::string name, QString type);
+};
+
+#endif // QSEISCURVEREGISTRY_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisData.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisData.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisData.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,153 @@
+/*
+ * QSeisData.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "QSeisData.hpp"
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+/** Constructor for QSeisData.
+ *
+ *  We create the QSeisPlotCurve instance here by calling createCurve().
+ *
+ * @param name file name data is associated with
+ * @param columnNo column number in the file this instance represents
+ */
+QSeisData::QSeisData(QString name, quint32 columnNo) :
+         intName(name), columnNumber(columnNo)
+{
+    createCurve();
+}
+
+/** Constructor for QSeisData.
+ *
+ * Note that we do not spawn any QSeisCurve instance here.
+ *
+ * @param xValues predefined set of x values
+ * @param yValues predefined set of y values
+ * @param name file for this data set
+ */
+QSeisData::QSeisData(std::vector<double> xValues, std::vector<double> yValues, QString name) :
+        intName(name), xData(xValues), yData(yValues)
+{
+
+}
+
+/** Destructor for QSeisData.
+ *
+ */
+QSeisData::~QSeisData()
+{
+}
+
+/** Create QSeisCurve instance for this data set if not yet present.
+ *
+ * We check in QSeisCurveRegistry whether a curve associated with \a intName is
+ * already present. If so, we associated with it, overwriting any association
+ * which another QSeisData has (probably from an old file that was deleted but
+ * whose data has been preserved so far). If not, we create a new instance and
+ * register it.
+ *
+ * \note We make this instance child of the curve such that it is destroyed when
+ *       then curve is destroyed.
+ *
+ */
+void QSeisData::createCurve()
+{
+    QSeisPlotCurve *new_curve = NULL;
+    // if curve is already present, replace binding to this one
+    if (QSeisCurveRegistry::getInstance().isPresentByName(intName.toStdString())) {
+        new_curve = QSeisCurveRegistry::getInstance().getByName(intName.toStdString());
+    } else {
+//	QString type = QSeisXMLParser::getInstance().getTypeOfName(intName);
+//        new_curve = new QSeisPlotCurve(intName, type);
+    }
+    connect(this, SIGNAL(dataChanged(QwtData*)), new_curve, SLOT(updateCurve(QwtData*)));
+    connect(this, SIGNAL(dataOutOfDate()), new_curve, SLOT(markAsOutOfDate()));
+    connect(new_curve, SIGNAL(dataRequested()), this, SIGNAL(dataRequested()));
+    setParent(new_curve);
+
+    // if replacing present curve, notify
+    if (QSeisCurveRegistry::getInstance().isPresentByName(intName.toStdString())) {
+        emit dataChanged(this);
+    } else {
+        QSeisCurveRegistry::getInstance().registerInstance(new_curve);
+    }
+}
+
+/** Slot for updating of the data contents.
+ *
+ *  We get here all data because then QSeisParser (who gives the signal) can
+ *  bind to all QSeisData instances' slots at once.
+ *
+ * @param newData new data to store
+ */
+void QSeisData::updateData(const std::vector<std::vector<double> > &newData)
+{
+    xData.clear();
+    yData.clear();
+    if (newData.size() > columnNumber)
+    {
+        xData = newData[0];
+        yData = newData[columnNumber];
+    }
+    emit dataChanged((QwtData *)this);
+}
+
+/** Copy function.
+ *
+ * This is defined in QwtData, hence we need to implement it.
+ *
+ * @return copy of this instance
+ */
+QSeisData* QSeisData::copy() const
+{
+    return new QSeisData(xData, yData, intName);
+}
+
+/** Getter for size of the data set, i.e. number of tupels.
+ *
+ * @return number of data tupels.
+ */
+size_t QSeisData::size() const
+{
+    return xData.size();
+}
+
+/** Getter for specific x value
+ *
+ * @param i index of value
+ * @return \a xData[i] or 0. if not present
+ */
+double QSeisData::x(size_t i) const
+{
+    if (i < xData.size())
+        return xData.at(i);
+    else
+        return 0.0f;
+}
+
+/** Getter for specific y value
+ *
+ * @param i index of value
+ * @return \a yData[i] or 0. if not present
+ */
+double QSeisData::y(size_t i) const
+{
+    if (i < yData.size())
+        return yData.at(i);
+    else
+        return 0.0f;
+}
Index: src/UIElements/Views/Qt4/Plotting/QSeisData.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisData.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisData.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,72 @@
+/*
+ * QSeisData.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QSEISDATA_HPP
+#define QSEISDATA_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qwt_global.h>
+#include <qwt_data.h>
+#include <QtCore/QObject>
+#include <vector>
+
+/**
+ * \class QSeisData
+ *
+ * This class gets its data from the QSeisParser
+ * class through the updateData() slot.
+ * The class itself emits a signal if its data
+ * changes which should call the corresponding update
+ * slots of the child QSeisPlotCurve objects.
+ *
+ * This class passes the request to fully parse a
+ * only through from its child QSeisPlotCurve class
+ * to its Corresponding QSeisParser class.
+ *
+ * This objects gets destroyed together with its parent
+ * object (QSeisPlotCurve).
+ *
+ * <the right place to implement display
+ *  around average etc.>
+ **/
+
+class QSeisParser;
+
+class QSeisData : public QObject, public QwtData
+{
+    Q_OBJECT
+
+public:
+    QSeisData(QString name, quint32 columnNo);
+    QSeisData(std::vector<double> xValues, std::vector<double> yValues, QString name);
+    ~QSeisData();
+    double x(size_t i) const;
+    double y(size_t i) const;
+    QSeisData *copy() const;
+    size_t size() const;
+
+private:
+    QString intName;
+    std::vector<double> xData;
+    std::vector<double> yData;
+    quint32 columnNumber;
+    void createCurve();
+
+public slots:
+    void updateData(const std::vector< std::vector<double> > &newData);
+
+signals:
+    void dataChanged(QwtData *newData);
+    void dataRequested();
+    void dataOutOfDate();
+};
+
+#endif // QSEISDATA_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,99 @@
+/*
+ * QSeisPageRegistry.cpp
+ *
+ *  Created on: Mar 14, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include "CodePatterns/Registry_impl.hpp"
+#include "CodePatterns/Singleton_impl.hpp"
+
+
+QSeisPageRegistry::QSeisPageRegistry()
+{
+
+}
+
+QSeisPageRegistry::~QSeisPageRegistry()
+{
+
+}
+
+void QSeisPageRegistry::cleanup()
+{
+    for (std::map<const std::string,QSeisPlotPage*>::iterator iter = getBeginIter(); iter != getEndIter(); ++iter)
+        emit pageDeleted(QString::fromStdString(iter->first));
+    Registry<QSeisPlotPage>::cleanup();
+}
+
+QSeisPlotPage* QSeisPageRegistry::getByName(const std::string name)
+{
+    if (!isPresentByName(name))
+    {
+        //create new plot tab
+        QSeisPlotPage *new_page = new QSeisPlotPage(QString::fromStdString(name));
+        registerInstance(new_page);
+        emit pageCreated((QWidget *)new_page, QString::fromStdString(name));
+    }
+    return Registry<QSeisPlotPage>::getByName(name);
+}
+
+void QSeisPageRegistry::deleteByName(const std::string name)
+{
+    if (!isPresentByName(name))
+        return;
+
+    QSeisPlotPage *page = Registry<QSeisPlotPage>::getByName(name);
+    unregisterInstance(page);
+    QString delName = page->plotType;
+    delete page;
+    emit pageDeleted(delName);
+}
+
+void QSeisPageRegistry::registerInstance(QSeisPlotPage *instance)
+{
+    Registry<QSeisPlotPage>::registerInstance(instance);
+}
+
+void QSeisPageRegistry::unregisterInstance(QSeisPlotPage *instance)
+{
+    Registry<QSeisPlotPage>::unregisterInstance(instance);
+}
+
+void QSeisPageRegistry::addCurve(std::string name, QString dataType)
+{
+    QSeisPlotPage *page = getByName(dataType.toStdString());
+    page->addCurve(name);
+}
+
+void QSeisPageRegistry::removeCurve(std::string name, QString dataType)
+{
+    QSeisPlotPage *page = getByName(dataType.toStdString());
+    page->removeCurve(name);
+}
+
+void QSeisPageRegistry::updateCurve(std::string name, QString dataType)
+{
+    QSeisPlotPage *page = getByName(dataType.toStdString());
+    page->updateCurve(name);
+}
+
+void QSeisPageRegistry::resetPlotView(QString dataType)
+{
+    QSeisPlotPage *page = getByName(dataType.toStdString());
+    page->resetPlot();
+}
+
+CONSTRUCT_SINGLETON(QSeisPageRegistry)
+CONSTRUCT_REGISTRY(QSeisPlotPage)
Index: src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,68 @@
+/*
+ * QSeisPageRegistry.hpp
+ *
+ *  Created on: Mar 14, 2011
+ *      Author: landvogt
+ */
+
+
+#ifndef QSEISPAGEREGISTRY_HPP
+#define QSEISPAGEREGISTRY_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtCore/QObject>
+
+#include "CodePatterns/Registry.hpp"
+#include "CodePatterns/Singleton.hpp"
+
+/**
+ * \class QSeisPageRegistry
+ *
+ * This class acts as a registry for all QSeisPlotPage
+ * objects. This registry does not allow to (un)register
+ * instances. Instead it creates a new instance if
+ * getByName() with a non-existing name is called.
+ *
+ * The registry also passes the add/update/remove signals
+ * to the PlotPage with the correct dataType string.
+ *
+ * On creating and destroying of an instance the
+ * pageCreated/pageDeleted signal is emitted to keep the GUI
+ * updated.
+ **/
+
+class QSeisPlotPage;
+
+class QSeisPageRegistry : public QObject, public Registry<QSeisPlotPage>, public Singleton<QSeisPageRegistry>
+{
+    Q_OBJECT
+
+friend class Singleton<QSeisPageRegistry>;
+
+public:
+    QSeisPlotPage *getByName(const std::string name);
+    void deleteByName(const std::string name);
+    void cleanup();
+
+public slots:
+    void addCurve(std::string name, QString dataType);
+    void removeCurve(std::string name, QString dataType);
+    void updateCurve(std::string name, QString dataType);
+    void resetPlotView(QString dataType);
+
+private:
+    QSeisPageRegistry();
+    ~QSeisPageRegistry();
+    void registerInstance(QSeisPlotPage *instance);
+    void unregisterInstance(QSeisPlotPage *instance);
+
+signals:
+    void pageCreated(QWidget *page, QString name);
+    void pageDeleted(QString name);
+};
+
+#endif // QSEISPAGEREGISTRY_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlot.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlot.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlot.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,173 @@
+/*
+ * QSeisPlot.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPlot.hpp"
+#include "UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.hpp"
+#include "UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp"
+
+#include <iostream>
+#include <qwt_plot_marker.h>
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+QSeisPlot::QSeisPlot(QWidget *parent,QString type) : QwtPlot(parent)
+{
+    //no title as there are already the different tabs
+    setTitle("");
+    //display legend on the right hand side
+    //no legend displayed - list names are colored instead
+    //insertLegend(new QwtLegend(), QwtPlot::RightLegend);
+
+    plottype* tmp = QSeisXMLParser::getInstance().return_plottype_by_name(type.toStdString());
+    ASSERT(tmp != NULL,
+        "QSeisPlot::QSeisPlot() - could not find desired plottype by name "+type.toStdString()+".");
+    std::cout << "Type is " << type.toStdString() << ", " << tmp << std::endl;
+
+    //label axes
+    const std::string xlabel = tmp->get_label(plottype::X);
+    const std::string ylabel = tmp->get_label(plottype::Y);
+    const std::string xunits = tmp->get_units(plottype::X);
+    const std::string yunits = tmp->get_units(plottype::Y);
+    setAxisTitle(xBottom, (xlabel+std::string(" [")+xunits+std::string("]")).c_str());
+    setAxisTitle(yLeft, (ylabel+std::string(" [")+yunits+std::string("]")).c_str());
+
+    //add zero line
+    QwtPlotMarker *zeroLine = new QwtPlotMarker();
+    zeroLine->setLineStyle(QwtPlotMarker::HLine);
+    zeroLine->setYValue(0.0);
+    zeroLine->attach(this);
+
+    zoomer = new ScrollZoomer(canvas());
+
+#ifdef QWTPANNER
+    panner = new QwtPlotPanner(canvas());
+    panner->setMouseButton(Qt::MidButton);
+#else
+    panning = false;
+    startPan = QPointF(0.0f, 0.0f);
+#endif
+
+    //init colors
+    availableColors.append(QColor(Qt::darkYellow));
+    availableColors.append(QColor(Qt::darkMagenta));
+    availableColors.append(QColor(Qt::darkCyan));
+    availableColors.append(QColor(Qt::darkGreen));
+    availableColors.append(QColor(Qt::darkRed));
+    availableColors.append(QColor(Qt::yellow));
+    availableColors.append(QColor(Qt::magenta));
+    availableColors.append(QColor(Qt::cyan));
+    availableColors.append(QColor(Qt::green));
+    availableColors.append(QColor(Qt::red));
+    availableColors.append(QColor(Qt::blue));
+    availableColors.append(QColor(Qt::black));
+
+    color_map.insert(std::make_pair("black",QColor(Qt::black)));
+    color_map.insert(std::make_pair("red",QColor(Qt::red)));
+    color_map.insert(std::make_pair("blue",QColor(Qt::blue)));
+    color_map.insert(std::make_pair("green",QColor(Qt::green)));
+    color_map.insert(std::make_pair("cyan",QColor(Qt::cyan)));
+    color_map.insert(std::make_pair("yellow",QColor(Qt::yellow)));
+    color_map.insert(std::make_pair("magenta",QColor(Qt::magenta)));
+    color_map.insert(std::make_pair("darkYellow",QColor(Qt::darkYellow)));
+    color_map.insert(std::make_pair("darkMagenta",QColor(Qt::darkMagenta)));
+    color_map.insert(std::make_pair("darkCyan",QColor(Qt::darkCyan)));
+    color_map.insert(std::make_pair("darkGreen",QColor(Qt::darkGreen)));
+    color_map.insert(std::make_pair("darkRed",QColor(Qt::darkRed)));
+}
+
+QSeisPlot::~QSeisPlot()
+{
+
+}
+
+void QSeisPlot::loadSettingsFromXML(QString fileName)
+{
+    //load settings from XML file sometime in the future
+    qDebug("loadSettingsFromXML %s", fileName.toAscii().constData());
+}
+
+void QSeisPlot::resetZoomer()
+{
+    if (axisAutoScale(xBottom) && axisAutoScale(yLeft))
+        zoomer->setZoomBase(0);
+}
+
+#ifndef QWTPANNER
+void QSeisPlot::mouseMoveEvent(QMouseEvent *event)
+{
+    if ((event->buttons() == Qt::MidButton) && (panning))
+    {
+        double xPos = invTransform(xBottom, event->pos().x() - canvas()->pos().x());
+        double yPos = invTransform(yLeft, event->pos().y() - canvas()->pos().y());
+        zoomer->moveBy(xPos-startPan.x(), yPos-startPan.y());
+        startPan = QPointF(xPos, yPos);
+    }
+}
+
+void QSeisPlot::mousePressEvent(QMouseEvent *event)
+{
+    //start panning only above the plot canvas
+    if ((event->button() == Qt::MidButton)
+        && (event->pos().x() >= canvas()->pos().x())
+        && (event->pos().x() <= (canvas()->pos().x() + canvas()->width()))
+        && (event->pos().y() >= canvas()->pos().y())
+        && (event->pos().y() <= (canvas()->pos().y() + canvas()->height())))
+    {
+        panning = true;
+        startPan = QPointF(invTransform(xBottom, event->pos().x() - canvas()->pos().x()),
+                           invTransform(yLeft, event->pos().y() - canvas()->pos().y()));
+    }
+}
+
+void QSeisPlot::mouseReleaseEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::MidButton)
+    {
+        panning = false;
+        startPan = QPointF(0.0f, 0.0f);
+    }
+}
+#endif
+
+QColor QSeisPlot::getCurveColor(std::string curve_color)
+{
+	if(color_map.count(curve_color)!=0) {
+		if(availableColors.count(color_map[curve_color])!=0) {
+			return color_map[curve_color];
+		}
+	}
+	QColor retColor = QColor(Qt::black);
+	if (!availableColors.isEmpty())
+	{
+	     retColor = availableColors.last();
+		 availableColors.removeLast();
+		 }
+
+	return retColor;
+}
+
+void QSeisPlot::freeCurveColor(QColor color)
+{
+    if (color != QColor(Qt::black) && (!availableColors.contains(color)))
+    {
+        availableColors.append(color);
+    }
+}
+
+void QSeisPlot::resetPlot()
+{
+    setAxisAutoScale(QwtPlot::xBottom);
+    setAxisAutoScale(QwtPlot::yLeft);
+    replot();
+    zoomer->setZoomBase(0);
+}
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlot.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlot.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlot.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,89 @@
+/*
+ * QSeisPlot.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QSEISPLOT_HPP
+#define QSEISPLOT_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+//uncomment the define below to use the QwtPlotPanner instead
+//of my manual implementation
+//#define QWTPANNER
+
+#include <qwt_global.h>
+#include <qwt_plot.h>
+#ifdef QWTPANNER
+#include <qwt_plot_panner.h>
+#endif
+#include "UIElements/Views/Qt4/Plotting/QScrollZoomer/ScrollZoomer.hpp"
+#include <QtGui/QMouseEvent>
+#include <QtCore/QList>
+#include <map>
+#include <string>
+
+/**
+ * \class QSeisPlot
+ *
+ * This class is derived from QwtPlot.
+ * It implements the ScrollZoomer class
+ * from the Qwt Realtime example.
+ * The zoomer implementation has some flaws
+ * because the zoomer class needs to know
+ * what QRectF is the "unzoomed" view.
+ * Not all actions where this rect is changed
+ * are correctly handled at the moment!
+ *
+ * It is possible to pan around the plot canvas
+ * using the middle mouse button.
+ * The original QwtPanner implementation (available
+ * by defining "QWTPANNER") is less CPU intensive
+ * but does not pan while dragging around.
+ *
+ * This class also holds a QList of available
+ * curve colours. The list is initialised in the
+ * constructor. The QSeisPlotCurve class is
+ * implemented to fetch a colour from plot it is
+ * about to get attached to and "free the colour"
+ * if it gets detached.
+ **/
+
+class QSeisPlot : public QwtPlot
+{
+    Q_OBJECT
+
+public:
+    QSeisPlot(QWidget *parent,QString type);
+    ~QSeisPlot();
+    void loadSettingsFromXML(QString fileName);
+    QColor getCurveColor(std::string);
+    void freeCurveColor(QColor color);
+
+private:
+    QList<QColor> availableColors;
+    ScrollZoomer *zoomer;
+    std::map<std::string,QColor> color_map;
+#ifdef QWTPANNER
+    QwtPlotPanner *panner;
+#else
+    QPointF startPan;
+    bool panning;
+    void mouseMoveEvent(QMouseEvent *event);
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+#endif
+
+signals:
+
+public slots:
+    void resetPlot();
+    void resetZoomer();
+};
+
+#endif // QSEISPLOT_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,71 @@
+/*
+ * QSeisPlotCurve.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlot.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include "CodePatterns/Assert.hpp"
+
+
+QSeisPlotCurve::QSeisPlotCurve(QString name, QString dataType, bool preparsed) :
+        type(dataType), intName(name), onlyPreparsed(preparsed), upToDate(true)
+{}
+
+QSeisPlotCurve::~QSeisPlotCurve()
+{
+    detach();
+}
+
+std::string QSeisPlotCurve::getName()
+{
+    return intName.toStdString();
+}
+
+void QSeisPlotCurve::updateCurve(QwtData *newData)
+{
+    setTitle(intName.right(intName.length() - intName.lastIndexOf('/') - 1));
+    setData(*newData);
+    upToDate = true;
+    if (plot() != NULL)
+        plot()->replot();
+}
+
+void QSeisPlotCurve::attach(QSeisPlot *plot)
+{
+    //check if already all data is present or if we have to request it
+    if (onlyPreparsed || !upToDate)
+    {
+        onlyPreparsed = false;
+        emit dataRequested();
+    }
+    setPen(QPen(plot->getCurveColor(color)));
+    QwtPlotCurve::attach((QwtPlot *)plot);
+}
+
+void QSeisPlotCurve::detach()
+{
+    if (plot() == NULL)
+        return;
+
+    ((QSeisPlot *)plot())->freeCurveColor(pen().color());
+    QwtPlotCurve::detach();
+}
+
+void QSeisPlotCurve::markAsOutOfDate()
+{
+    upToDate = false;
+    if (plot() != NULL)
+        emit dataRequested();
+}
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,69 @@
+/*
+ * QSeisPlotCurve.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QSEISPLOTCURVE_HPP
+#define QSEISPLOTCURVE_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qwt_global.h>
+#include <qwt_plot_curve.h>
+#include <QtCore/QObject>
+#include <string>
+
+/**
+ * \class QSeisPlotCurve
+ *
+ * This class is notified of changes by
+ * its corresponding QSeisData object.
+ *
+ * It fetches automatically a free curve colour
+ * for the plot is attached to (and "frees" the
+ * colour on detach).
+ *
+ * When the curve is attached and only the column
+ * number without data is available (due to preparse only),
+ * the class emits the dataRequested() signal to fetch the
+ * full data set. The "empty" curve is still directly
+ * attached to the plot, but gets autotically updated
+ * when the data has been completely processed.
+ * (This way the user interface does not get blocked.)
+ **/
+
+class QSeisPlot;
+
+class QSeisPlotCurve : public QObject, public QwtPlotCurve
+{
+    Q_OBJECT
+
+public:
+    QSeisPlotCurve(QString name, QString dataType, bool preparsed = true);
+    ~QSeisPlotCurve();
+    std::string getName();
+    QString type;
+    void attach(QSeisPlot *plot);
+    void detach();
+    QString getDisplayName() { return QString::fromStdString(getName()); }
+    std::string color;
+
+public slots:
+    void updateCurve(QwtData *newData);
+    void markAsOutOfDate();
+
+private:
+    QString intName;
+    bool onlyPreparsed;
+    bool upToDate;
+
+signals:
+    void dataRequested();
+};
+
+#endif // QSEISPLOTCURVE_HPP
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,127 @@
+/*
+ * QSeisPlotPage.cpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtGui/QHBoxLayout>
+#include <QtGui/QListView>
+#include <QtGui/QListWidgetItem>
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlot.hpp"
+#include "UIElements/Views/Qt4/Plotting/QListWidgetCurveItem.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotCurve.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisCurveRegistry.hpp"
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+QSeisPlotPage::QSeisPlotPage(QString type, QWidget *parent) :
+        QWidget(parent), plotType(type)
+{
+    //create GUI elements
+    QHBoxLayout *layout = new QHBoxLayout(this);
+    curveList = new QListWidget(this);
+    curveList->setMaximumWidth(250);
+    plot = new QSeisPlot(this,type);
+    layout->addWidget(curveList);
+    layout->addWidget(plot);
+    setLayout(layout);
+
+    connect(curveList, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(listItemChanged(QListWidgetItem*)));
+}
+
+QSeisPlotPage::~QSeisPlotPage()
+{
+
+}
+
+std::string QSeisPlotPage::getName()
+{
+    return plotType.toStdString();
+}
+
+void QSeisPlotPage::resetPlot()
+{
+    plot->resetPlot();
+}
+
+void QSeisPlotPage::addCurve(std::string name)
+{
+    QSeisPlotCurve *curve;
+    QListWidgetCurveItem *item;
+    curve = QSeisCurveRegistry::getInstance().getByName(name);
+
+    item = new QListWidgetCurveItem();
+    item->curveName = curve->getName();
+    item->setText(curve->getDisplayName());
+
+    if (curve->plot() != NULL)
+        item->setCheckState(Qt::Checked);
+    else
+        item->setCheckState(Qt::Unchecked);
+
+    curveList->addItem((QListWidgetItem *)item);
+}
+
+void QSeisPlotPage::updateCurve(std::string name)
+{
+    QSeisPlotCurve *curve;
+    curve = QSeisCurveRegistry::getInstance().getByName(name);
+    if (curve->plot() != NULL)
+        curve->plot()->replot();
+}
+
+void QSeisPlotPage::removeCurve(std::string name)
+{
+    QSeisPlotCurve *curve;
+    QListWidgetCurveItem *item;
+    curve = QSeisCurveRegistry::getInstance().getByName(name);
+
+    for (int i = 0; i < curveList->count(); i++)
+    {
+        item = (QListWidgetCurveItem *)curveList->item(i);
+        if (item->curveName == name)
+        {
+            curveList->takeItem(i);
+            delete item;
+            return;
+        }
+    }
+}
+
+void QSeisPlotPage::listItemChanged(QListWidgetItem *item)
+{
+    QListWidgetCurveItem *curveItem = (QListWidgetCurveItem *)item;
+    QSeisPlotCurve *curve;
+    curve = QSeisCurveRegistry::getInstance().getByName(curveItem->curveName);
+
+    if (curveItem->checkState() == Qt::Unchecked)
+    {
+        if (curve->plot() != NULL)
+        {
+            curve->detach();
+            //be carefull - changing the text color triggers this slot!
+            curveItem->setTextColor(QColor(Qt::black));
+        }
+    }
+    else if (curveItem->checkState() == Qt::Checked)
+    {
+        if (curve->plot() == NULL)
+        {
+            curve->attach(plot);
+            //be carefull - changing the text color triggers this slot!
+            curveItem->setTextColor(curve->pen().color());
+        }
+    }
+
+    plot->replot();
+    plot->resetZoomer();
+}
Index: src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,52 @@
+/*
+ * QSeisPlotPage.hpp
+ *
+ *  Created on: Jan 30, 2011
+ *      Author: landvogt
+ */
+
+#ifndef QSEISPLOTPAGE_HPP
+#define QSEISPLOTPAGE_HPP
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtGui/QWidget>
+
+class QSeisPlot;
+class QListWidgetItem;
+class QListWidget;
+
+/**
+ * \class QSeisPlotPage
+ *
+ * This class is derived from QWidget and provides
+ * the GUI elements for a single plot tab.
+ **/
+class QSeisPlotPage : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit QSeisPlotPage(QString type, QWidget *parent = 0);
+    ~QSeisPlotPage();
+    QString plotType;
+    QListWidget *curveList;
+    QSeisPlot *plot;
+    std::string getName();
+    void resetPlot();
+
+private slots:
+    void listItemChanged(QListWidgetItem *item);
+
+signals:
+
+public slots:
+    void addCurve(std::string name);
+    void removeCurve(std::string name);
+    void updateCurve(std::string name);
+
+};
+
+#endif // QSEISPLOTPAGE_HPP
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,215 @@
+/*
+ * QSeisXMLParser.cpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtCore/QDir>
+#include <QtCore/QList>
+
+#include "UIElements/Views/Qt4/Plotting/QSeisPageRegistry.hpp"
+#include "UIElements/Views/Qt4/Plotting/QSeisPlotPage.hpp"
+
+#include "QSeisXMLParser.hpp"
+
+// property tree uses alignment new
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include <boost/foreach.hpp>
+#include <string>
+#include <set>
+#include <exception>
+#include <iostream>
+#include <sstream>
+
+#include "CodePatterns/Assert.hpp"
+
+#include "CodePatterns/Singleton_impl.hpp"
+
+/** Constructor for QSeisXMLParser.
+ *
+ */
+QSeisXMLParser::QSeisXMLParser()
+{
+	unitmap["mass"] = "mass";
+	unitmap["length"] = "length";
+	unitmap["time"] = "time";
+	unitmap["current"] = "current";
+	unitmap["temperature"] = "temperature";
+	unitnames.push_back("mass");
+	unitnames.push_back("length");
+	unitnames.push_back("time");
+	unitnames.push_back("current");
+	unitnames.push_back("temperature");
+}
+
+/** Destructor for QSeisXMLParser.
+ *
+ */
+QSeisXMLParser::~QSeisXMLParser()
+{
+  // remove all types
+  for(std::vector<plottype*>::iterator it=types.begin();it!=types.end();++it) {
+    delete *it;
+  }
+  types.clear();
+  // remove all curves
+  for(std::vector<plotcurve*>::iterator it=curves.begin();it!=curves.end();++it) {
+		delete *it;
+	}
+	curves.clear();
+}
+
+/** Returns list of desired files.
+ *
+ * Desired files are all listed in the parsed .xml file, with prefix full
+ * file names are constructed and returned.
+ *
+ * @param prefix prefix of filenames
+ * @return list of all desired files
+ */
+QStringList QSeisXMLParser::getFiles(QString prefix) {
+	    QStringList file_names;
+	    qDebug("List of desired curves:");
+	    for(size_t i=0;i<(curves.size());i++) {
+	      QString name = prefix+QString(".")+QString((*curves[i]).get_suffix().c_str());
+	      qDebug("\t%s", name.toAscii().constData());
+	    	file_names.append(name);
+	    }
+	    return file_names;
+}
+
+/** Loads an .xml file.
+ *
+ *  Loads the XML file, then parses types and curves contained.
+ *
+ * @param file file name
+ */
+void QSeisXMLParser::load(std::istream& file) {
+	curves_by_suffix.clear();
+	using boost::property_tree::ptree;
+	ptree pt;
+	qDebug("Parsing XML file ... ");
+	read_xml(file,pt);
+	qDebug("Parsing types ... ");
+	BOOST_FOREACH(ptree::value_type &i,pt.get_child("seismolo.plottypes")) {
+		std::string name=i.second.get<std::string>("name");
+		std::string style=i.second.get<std::string>("style");
+		std::string xlabel=i.second.get<std::string>("xlabel");
+		std::string ylabel=i.second.get<std::string>("ylabel");
+		std::vector<int> xunits;
+		xunits.push_back(i.second.get<int>("xunits.mass"));
+		xunits.push_back(i.second.get<int>("xunits.length"));
+		xunits.push_back(i.second.get<int>("xunits.time"));
+		xunits.push_back(i.second.get<int>("xunits.current"));
+		xunits.push_back(i.second.get<int>("xunits.temperature"));
+		std::vector<int> yunits;
+		yunits.push_back(i.second.get<int>("yunits.mass"));
+		yunits.push_back(i.second.get<int>("yunits.length"));
+		yunits.push_back(i.second.get<int>("yunits.time"));
+		yunits.push_back(i.second.get<int>("yunits.current"));
+		yunits.push_back(i.second.get<int>("yunits.temperature"));
+		plottype * tmp = new plottype(name,xlabel,ylabel,style,xunits,yunits, unitnames,unitmap);
+		types.push_back(tmp);
+		qDebug("\ttype: %s, %p", name.c_str(), types.back());
+		types_by_name.insert(std::make_pair(types.back()->get_name(),types.back()));
+	}
+	qDebug("Parsing curves ... ");
+	BOOST_FOREACH(ptree::value_type &i,pt.get_child("seismolo.plotcurves")) {
+		std::string name=i.second.get<std::string>("name");
+		std::string type=i.second.get<std::string>("type");
+		std::string suffix=i.second.get<std::string>("suffix");
+		std::string color=i.second.get<std::string>("color");
+		int column=i.second.get<int>("column");
+		// check that type exists
+		ASSERT(types_by_name.count(type),
+				"QSeisXMLParser::load() - type "+type+" for curve "+name+" not found.");
+
+		std::stringstream tmp;
+		tmp<<column;
+		if (suffix[0] == '.') // erase leading dot if present
+		  suffix.erase(suffix.begin());
+		plotcurve* curv=new plotcurve(name,type,suffix,color,column);
+		curves.push_back(curv);
+    qDebug("\tcurve: %s", curves.back()->get_name().c_str());
+		curves_suff.insert(std::make_pair(suffix+tmp.str(),curv));
+		curves_by_suffix.insert(std::make_pair(suffix+tmp.str(),type));
+		ASSERT(curves_by_suffix.size()!=0,"curves by suffix is empty!");
+	}
+}
+
+/** Creates plot page for each \a types.
+ *
+ */
+void QSeisXMLParser::createPlotPages() {
+	for(size_t i=0;i<types.size();i++) {
+		const std::string name=types[i]->get_name();
+		QSeisPageRegistry::getInstance().getByName(name);
+	}
+}
+
+/** Associates each curve in \a curves with its plot page.
+ *
+ */
+void QSeisXMLParser::associateCurves() {
+	for(quint32 i=0;i<(curves.size());i++) {
+		std::string temp=(*curves[i]).get_type();
+		int u=(*curves[i]).get_column();
+		std::stringstream ostrs;
+		QString watchPath; //=QSeisFileRegistry::getInstance().getWatchPath();
+		ostrs << prefix.toStdString() << (*curves[i]).get_suffix() << u;
+		QSeisPlotPage *instance = QSeisPageRegistry::getInstance().getByName(temp);
+		instance->addCurve(ostrs.str());
+	}
+}
+
+/** Getter for type for a given curve.
+ *
+ * @param name name of curve
+ * @return type of curve, i.e. the plot page
+ */
+QString QSeisXMLParser::getTypeOfName(const QString &name) {
+	std::string suffix(name.toStdString());
+	int found=suffix.find(".");
+	ASSERT(found!=-1,"Name of curve " + suffix + " is invalid.");
+	suffix=suffix.substr(found+1,suffix.size()-(found+1));
+
+//	Debugausgabe
+	std::map<std::string,std::string>::iterator m;
+	for(m=curves_by_suffix.begin();m!=curves_by_suffix.end();++m) {
+		std::cerr << m->first << "----" << m->second << std::endl;
+	}
+	if (curves_by_suffix.count(suffix))
+		return QString(curves_by_suffix[suffix].c_str());
+	else
+		return QString();
+}
+
+std::string QSeisXMLParser::getCurveColor(std::string suff_col) {
+	if(curves_suff.count(suff_col)!=0) {
+		return curves_suff[suff_col]->get_color();
+	}
+	else return std::string();
+}
+
+plottype* QSeisXMLParser::return_plottype_by_name(std::string name) {
+	if(types_by_name.count(name)!=0) {
+		return types_by_name[name];
+	} else return NULL;
+}
+
+void QSeisXMLParser::set_units(const std::vector<std::string>& unitnames_xml,const std::map<std::string,std::string>& unitmap_xml) {
+	unitmap=unitmap_xml;unitnames=unitnames_xml;
+}
+
+CONSTRUCT_SINGLETON(QSeisXMLParser)
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,60 @@
+/*
+ * QSeisXMLParser.hpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+#ifndef QSEISXMLPARSER_HPP_
+#define QSEISXMLPARSER_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <QtCore/QStringList>
+#include <QtCore/QString>
+#include <QtCore/QFileInfo>
+
+#include "UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp"
+#include "UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.hpp"
+
+#include <vector>
+#include <map>
+#include <iosfwd>
+#include <utility>
+
+#include "CodePatterns/Singleton.hpp"
+
+class QSeisXMLParser : public Singleton<QSeisXMLParser> {
+	friend class Singleton<QSeisXMLParser>;
+	friend class plotcurve;
+	friend class XMLParserTest;
+
+	public:
+	QStringList getFiles(QString);
+	void load(std::istream&);
+	void createPlotPages();
+	void associateCurves();
+	QString getTypeOfName(const QString &name);
+	std::string getCurveColor(std::string);
+	plottype* return_plottype_by_name(std::string name);
+	void set_units(const std::vector<std::string>&,const std::map<std::string,std::string>&);
+
+	protected:
+	QSeisXMLParser();
+	~QSeisXMLParser();
+
+	private:
+	QString prefix;
+	std::map<std::string, std::string> unitmap;
+	std::vector<std::string> unitnames;
+	std::vector<plottype*> types;
+	std::map<std::string,plottype*> types_by_name;
+	std::vector<plotcurve*> curves;
+	std::map<std::string,plotcurve*> curves_suff;
+	std::map<std::string,std::string> curves_by_suffix;
+};
+
+#endif /* QSEISXMLPARSER_HPP_ */
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,62 @@
+/*
+ * QSeisXMLParser_plotcurve.cpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include <iostream>
+#include "QSeisXMLParser_plotcurve.hpp"
+
+plotcurve::plotcurve(std::string name_pc,std::string type_pc,std::string suffix_pc,std::string color_pc,int column_pc) :
+	name(name_pc),type(type_pc),suffix(suffix_pc),color(color_pc),column(column_pc)
+	{}
+
+/** Explicit copy constructor for class plotcurve.
+ *
+ * \note is made private to prevent accidental copying of the instance.
+ *
+ * @param ref instance to copy
+ */
+plotcurve::plotcurve(const plotcurve &ref) :
+	name(ref.name),type(ref.type),suffix(ref.suffix),color(ref.color),column(ref.column)
+{
+  std::cout << "plotcurve " << &ref << " has been copied." << std::endl;
+	std::cout << ref.name << " --- " << ref.type << " --- " << ref.suffix << std::flush;
+	std::cout << " --- " << ref.color << " --- " << ref.column <<  std::endl;
+}
+
+plotcurve::~plotcurve()
+{}
+
+void plotcurve::set_values(std::string name_pc,std::string type_pc,std::string suffix_pc,int column_pc) {
+	name=name_pc;type=type_pc;suffix=suffix_pc;column=column_pc;
+}
+
+std::string plotcurve::get_name() {
+	return name;
+}
+
+std::string plotcurve::get_type() {
+	return type;
+}
+
+std::string plotcurve::get_suffix() {
+	return suffix;
+}
+
+std::string plotcurve::get_color() {
+	return color;
+}
+
+int plotcurve::get_column() {
+	return column;
+}
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plotcurve.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,42 @@
+/*
+ * QSeisXMLParser_plotcurve.hpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+#ifndef QSEISXMLPARSER_PLOTCURVE_HPP_
+#define QSEISXMLPARSER_PLOTCURVE_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+class plottype;
+
+class plotcurve{
+public:
+	plotcurve(std::string name_pc,std::string type_pc,std::string suffix_pc,std::string color_pc,int column_pc);
+	~plotcurve();
+	void set_values(std::string,std::string,std::string,int);
+	std::string get_name();
+	std::string get_type();
+	std::string get_suffix();
+	std::string get_color();
+	int get_column();
+
+private:
+	//?> name of the plot
+	std::string name;
+	std::string type;
+	std::string suffix;
+	std::string color;
+	int column;
+
+  plotcurve(const plotcurve &ref);
+};
+
+#endif /* QSEISXMLPARSER_PLOTCURVE_HPP_ */
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.cpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.cpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,187 @@
+/*
+ * QSeisXMLParser_plottype.cpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+// have this after(!) all Qt includes
+#include "CodePatterns/MemDebug.hpp"
+
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/toString.hpp"
+
+#include "QSeisXMLParser_plottype.hpp"
+
+
+/** Constructor for class plottype.
+ *
+ * @param name_pt name
+ * @param xlabel_pt label for X axis
+ * @param ylabel_pt label for Y axis
+ * @param style_pt style of plot
+ * @param xunits_pt unit vector for x axis
+ * @param yunits_pt unit vector for y axis
+ * @param unitnames_pt (unit) names for each unit vector coefficient
+ * @param unitmap_pt mapping to internal unit names
+ */
+plottype::plottype(
+    std::string name_pt,
+    std::string xlabel_pt,
+    std::string ylabel_pt,
+    std::string style_pt,
+    const UnitsVector &xunits_pt,
+    const UnitsVector &yunits_pt,
+    const std::vector<std::string> &unitnames_pt,
+    const std::map<std::string,std::string> &unitmap_pt) :
+  name(name_pt),
+  style(style_pt),
+  unitnames(unitnames_pt),
+  unitmap(unitmap_pt)
+{
+  labels.insert(make_pair(X, xlabel_pt));
+  labels.insert(make_pair(Y, ylabel_pt));
+  units.insert(make_pair(X, xunits_pt));
+  units.insert(make_pair(Y, yunits_pt));
+//  std::cout << "Labels: " << labels << std::endl;
+//  std::cout << "Units: " << units << std::endl;
+}
+
+/** Explicit copy constructor for class plottype.
+ *
+ * \note is made private to prevent accidental copying of the instance.
+ *
+ * @param ref instance to copy values from
+ */
+plottype::plottype(const plottype &ref) :
+    name(ref.name),
+    style(ref.style),
+    units(ref.units),
+    labels(ref.labels),
+    unitnames(ref.unitnames),
+    unitmap(ref.unitmap)
+{
+  std::cout << "plottype " << &ref << " has been copied." << std::endl;
+}
+
+/** Destructor for plottype.
+ *
+ */
+plottype::~plottype()
+{
+  labels.clear();
+  units.clear();
+  unitnames.clear();
+  unitmap.clear();
+}
+
+/** (Re)-set all values for this plottype instance.
+ *
+ * @param name_pt name
+ * @param xlabel_pt label for X axis
+ * @param ylabel_pt label for Y axis
+ * @param style_pt style of plot
+ * @param xunits_pt unit vector for x axis
+ * @param yunits_pt unit vector for y axis
+ * @param unitnames_pt (unit) names for each unit vector coefficient
+ * @param unitmap_pt mapping to internal unit names
+ */
+void plottype::set_values(
+		std::string name_pt,
+		std::string xlabel_pt,
+		std::string ylabel_pt,
+		std::string style_pt,
+		const std::vector<int> &xunits_pt,
+		const std::vector<int> &yunits_pt,
+		const std::vector<std::string> &unitnames_pt,
+		const std::map<std::string, std::string> &unitmap_pt)
+{
+  name = name_pt;
+  style = style_pt;
+  unitnames = unitnames_pt;
+  unitmap = unitmap_pt;
+  labels[X] = xlabel_pt;
+  labels[Y] = ylabel_pt;
+  units[X] = xunits_pt;
+  units[Y] = yunits_pt;
+}
+
+/** Comparison operator for two plottype's.
+ *
+ * We just compare the name against the given one.
+ *
+ * @param type name to compare against.
+ * @return true - name equals \a type, false - not
+ */
+bool plottype::operator==(std::string type)
+{
+ if(type==name) return true;
+ else return false;
+}
+
+/** Getter for name.
+ *
+ * @return \a name
+ */
+std::string plottype::get_name() const
+{
+	return name;
+}
+
+/** Getter for label.
+ *
+ * @param _axis label for which axis
+ * @return label description for the desired \a _axis
+ */
+std::string plottype::get_label(const enum axis _axis) const
+{
+  LabelPerAxis::const_iterator it = labels.find(_axis);
+  ASSERT(it != labels.end(),
+      "plottype::get_label() - unknown axis type "+toString(_axis)+".");
+	return it->second;
+}
+
+/** Getter for style string.
+ *
+ * @return \a style
+ */
+std::string plottype::get_style() const
+{
+	return style;
+}
+
+/** Returns a string with the unit for the given \a _axis.
+ *
+ * \note Because it is declared as a const member function we cannot use
+ *       operator[] on the maps, as this function is not const (it inserts
+ *       if the key is missing in the map). Hence, we have to operator with
+ *       find and const_iterator's.
+ *
+ * @param _axis
+ * @return string containing the full unit
+ */
+std::string plottype::get_units(const enum axis _axis) const
+{
+	std::string result;
+	UnitPerAxis::const_iterator UnitsArray = units.find(_axis);
+	ASSERT(UnitsArray != units.end(),
+	    "plottype::get_units() - unknown axis type "+toString(_axis)+".");
+	bool firstflag = true;
+	for (size_t it = 0; it < (UnitsArray->second).size(); ++it) {
+	  UnitNamesMap::const_iterator unitname = unitmap.find(unitnames[it]);
+	  ASSERT(unitname != unitmap.end(),
+	      "plottype::get_units() - unknown unit name "+unitnames[it]+".");
+		if(!(UnitsArray->second).at(it))
+		  continue;
+		result += ((!firstflag) ? std::string(" ") : std::string("")) + (unitname->second);
+		if ((UnitsArray->second)[it] != 1)
+		  result += std::string("^") + toString((UnitsArray->second)[it]);
+		firstflag = false;
+	}
+	return result;
+}
Index: src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp
===================================================================
--- src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
+++ src/UIElements/Views/Qt4/Plotting/XMLParser/QSeisXMLParser_plottype.hpp	(revision 35302b57b5c489d9535c30527e3c33675ec2acb6)
@@ -0,0 +1,57 @@
+/*
+ * QSeisXMLParser_plottype.hpp
+ *
+ *  Created on: Apr 5, 2011
+ *      Author: bierbach
+ */
+
+#ifndef QSEISXMLPARSER_PLOTTYPE_HPP_
+#define QSEISXMLPARSER_PLOTTYPE_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+#include <vector>
+#include <map>
+#include <sstream>
+
+
+class plottype{
+	public:
+  enum axis
+  {
+    X,
+    Y
+  };
+
+  plottype(std::string name_pt,std::string xlabel_pt,std::string ylabel_pt,std::string style_pt,const std::vector<int> &xunits_pt,const std::vector<int> &yunits_pt, const std::vector<std::string> &unitnames_pt,const std::map<std::string,std::string> &unitmap_pt);
+  ~plottype();
+
+	void set_values(std::string,std::string,std::string,std::string,const std::vector<int>&,const std::vector<int>&,const std::vector<std::string>&,const std::map<std::string,std::string>&);
+	bool operator==(std::string);
+	std::string get_name() const;
+	std::string get_label(const enum axis _axis) const;
+	std::string get_style() const;
+	std::string get_units(const enum axis _axis) const;
+
+	private:
+  typedef std::vector<int> UnitsVector;
+	typedef std::map<enum axis, std::string > LabelPerAxis;
+	typedef std::map<enum axis, UnitsVector > UnitPerAxis;
+	typedef std::map<std::string,std::string> UnitNamesMap;
+	typedef std::vector<std::string> UnitNamesVector;
+
+	std::string name,style;
+	UnitPerAxis units;
+	LabelPerAxis labels;
+	UnitNamesVector unitnames;
+	UnitNamesMap unitmap;
+
+	private:
+	plottype(const plottype& ref);
+};
+
+#endif /* QSEISXMLPARSER_PLOTTYPE_HPP_ */
