# -*- coding: utf-8 -*-
#
# Licensed under the terms of the Qwt License
# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
# (see LICENSE file for more details)

"""
QwtPlot
-------

.. autoclass:: QwtPlot
   :members:

QwtPlotItem
-----------

.. autoclass:: QwtPlotItem
   :members:
"""

from qwt.qt.QtGui import (QWidget, QFont, QSizePolicy, QFrame, QApplication,
                          QRegion, QPainter, QPalette)
from qwt.qt.QtCore import Qt, Signal, QEvent, QSize, QRectF

from qwt.text import QwtText, QwtTextLabel
from qwt.scale_widget import QwtScaleWidget
from qwt.scale_draw import QwtScaleDraw
from qwt.scale_engine import QwtLinearScaleEngine
from qwt.plot_canvas import QwtPlotCanvas
from qwt.scale_div import QwtScaleDiv
from qwt.scale_map import QwtScaleMap
from qwt.graphic import QwtGraphic
from qwt.legend import QwtLegendData
from qwt.interval import QwtInterval

import numpy as np


def qwtEnableLegendItems(plot, on):
    if on:
        plot.legendDataChanged.connect(plot.updateLegendItems)
    else:
        plot.legendDataChanged.disconnect(plot.updateLegendItems)

def qwtSetTabOrder(first, second, with_children):
    tab_chain = [first, second]
    if with_children:
        children = second.findChildren(QWidget)
        w = second.nextInFocusChain()
        while w in children:
            while w in children:
                children.remove(w)
            tab_chain += [w]
            w = w.nextInFocusChain()
    for idx in range(len(tab_chain)-1):
        w_from = tab_chain[idx]
        w_to = tab_chain[idx+1]
        policy1, policy2 = w_from.focusPolicy(), w_to.focusPolicy()
        proxy1, proxy2 = w_from.focusProxy(), w_to.focusProxy()
        for w in (w_from, w_to):
            w.setFocusPolicy(Qt.TabFocus)
            w.setFocusProxy(None)
        QWidget.setTabOrder(w_from, w_to)
        for w, pl, px in ((w_from, policy1, proxy1), (w_to, policy2, proxy2)):
            w.setFocusPolicy(pl)
            w.setFocusProxy(px)


class ItemList(list):
    def sortItems(self):
        self.sort(key=lambda item: item.z())

    def insertItem(self, obj):
        self.append(obj)
        self.sortItems()
        
    def removeItem(self, obj):
        self.remove(obj)
        self.sortItems()


class QwtPlotDict_PrivateData(object):
    def __init__(self):
        self.itemList = ItemList()
        self.autoDelete = True


class QwtPlotDict(object):
    """
    A dictionary for plot items
    
    `QwtPlotDict` organizes plot items in increasing z-order.
    If `autoDelete()` is enabled, all attached items will be deleted
    in the destructor of the dictionary.
    `QwtPlotDict` can be used to get access to all `QwtPlotItem` items - or 
    all items of a specific type -  that are currently on the plot.
    
    .. seealso::
    
        :py:meth:`QwtPlotItem.attach()`, :py:meth:`QwtPlotItem.detach()`, 
        :py:meth:`QwtPlotItem.z()`
    """
    def __init__(self):
        self.__data = QwtPlotDict_PrivateData()
    
    def setAutoDelete(self, autoDelete):
        """
        En/Disable Auto deletion

        If Auto deletion is on all attached plot items will be deleted
        in the destructor of `QwtPlotDict`. The default value is on.
        
        :param bool autoDelete: enable/disable

        .. seealso::
        
            :py:meth:`autoDelete()`, :py:meth:`insertItem()`
        """
        self.__data.autoDelete = autoDelete
    
    def autoDelete(self):
        """
        :return: true if auto deletion is enabled

        .. seealso::
        
            :py:meth:`setAutoDelete()`, :py:meth:`insertItem()`
        """
        return self.__data.autoDelete
    
    def insertItem(self, item):
        """
        Insert a plot item
        
        :param qwt.plot.QwtPlotItem item: PlotItem

        .. seealso::
        
            :py:meth:`removeItem()`
        """
        self.__data.itemList.insertItem(item)
    
    def removeItem(self, item):
        """
        Remove a plot item
        
        :param qwt.plot.QwtPlotItem item: PlotItem

        .. seealso::
        
            :py:meth:`insertItem()`
        """
        self.__data.itemList.removeItem(item)

    def detachItems(self, rtti, autoDelete):
        """
        Detach items from the dictionary
        
        :param int rtti: In case of `QwtPlotItem.Rtti_PlotItem` detach all items otherwise only those items of the type rtti.
        :param bool autoDelete: If true, delete all detached items
        """
        for item in self.__data.itemList[:]:
            if rtti == QwtPlotItem.Rtti_PlotItem and item.rtti() == rtti:
                item.attach(None)
                if self.autoDelete:
                    self.__data.itemList.remove(item)

    def itemList(self, rtti=None):
        """
        A list of attached plot items.

        Use caution when iterating these lists, as removing/detaching an 
        item will invalidate the iterator. Instead you can place pointers 
        to objects to be removed in a removal list, and traverse that list 
        later.
        
        :param int rtti: In case of `QwtPlotItem.Rtti_PlotItem` detach all items otherwise only those items of the type rtti.
        :return: List of all attached plot items of a specific type. If rtti is None, return a list of all attached plot items.
        """
        if rtti is None or rtti == QwtPlotItem.Rtti_PlotItem:
            return self.__data.itemList
        return [item for item in self.__data.itemList if item.rtti() == rtti]


class QwtPlot_PrivateData(QwtPlotDict_PrivateData):
    def __init__(self):
        super(QwtPlot_PrivateData, self).__init__()
        self.titleLabel = None
        self.footerLabel = None
        self.canvas = None
        self.legend = None
        self.layout = None
        self.autoReplot = None


class AxisData(object):
    def __init__(self):
        self.isEnabled = None
        self.doAutoScale = None
        self.minValue = None
        self.maxValue = None
        self.stepSize = None
        self.maxMajor = None
        self.maxMinor = None
        self.isValid = None
        self.scaleDiv = None # QwtScaleDiv
        self.scaleEngine = None # QwtScaleEngine
        self.scaleWidget = None # QwtScaleWidget


class QwtPlot(QFrame, QwtPlotDict):
    """
    A 2-D plotting widget

    QwtPlot is a widget for plotting two-dimensional graphs.
    An unlimited number of plot items can be displayed on its canvas. 
    Plot items might be curves (:py:class:`qwt.plot_curve.QwtPlotCurve`), 
    markers (:py:class:`qwt.plot_marker.QwtPlotMarker`), 
    the grid (:py:class:`qwt.plot_grid.QwtPlotGrid`), or anything else 
    derived from :py:class:`QwtPlotItem`.
    
    A plot can have up to four axes, with each plot item attached to an x- and
    a y axis. The scales at the axes can be explicitly set (`QwtScaleDiv`), or
    are calculated from the plot items, using algorithms (`QwtScaleEngine`) 
    which can be configured separately for each axis.
    
    The following example is a good starting point to see how to set up a 
    plot widget::
    
        from qwt.qt.QtGui import QApplication
        from qwt import QwtPlot, QwtPlotCurve
        import numpy as np

        app = QApplication([])

        x = np.linspace(-10, 10, 500)
        y1, y2 = np.cos(x), np.sin(x)

        my_plot = QwtPlot("Two curves")
        curve1, curve2 = QwtPlotCurve("Curve 1"), QwtPlotCurve("Curve 2")
        curve1.setData(x, y1)
        curve2.setData(x, y2)
        curve1.attach(my_plot)
        curve2.attach(my_plot)
        my_plot.resize(600, 300)
        my_plot.replot()
        my_plot.show()

        app.exec_()
        
    .. image:: /images/QwtPlot_example.png
        
    .. py:class:: QwtPlot([title=""], [parent=None])
    
        :param str title: Title text
        :param QWidget parent: Parent widget
        
    .. py:data:: itemAttached
    
        A signal indicating, that an item has been attached/detached
        
        :param plotItem: Plot item
        :param on: Attached/Detached

    .. py:data:: legendDataChanged
    
        A signal with the attributes how to update 
        the legend entries for a plot item.

        :param itemInfo: Info about a plot item, build from itemToInfo()
        :param data: Attributes of the entries (usually <= 1) for the plot item.

    """
    
    itemAttached = Signal("PyQt_PyObject", bool)
    legendDataChanged = Signal("PyQt_PyObject", "PyQt_PyObject")

    # enum Axis
    validAxes = yLeft, yRight, xBottom, xTop = list(range(4))
    axisCnt = len(validAxes)
    
    # enum LegendPosition
    LeftLegend, RightLegend, BottomLegend, TopLegend = list(range(4))
    
    def __init__(self, *args):
        if len(args) == 0:
            title, parent = "", None
        elif len(args) == 1:
            if isinstance(args[0], QWidget) or args[0] is None:
                title = ""
                parent, = args
            else:
                title, = args
                parent = None
        elif len(args) == 2:
            title, parent = args
        else:
            raise TypeError("%s() takes 0, 1 or 2 argument(s) (%s given)"\
                            % (self.__class__.__name__, len(args)))
        QwtPlotDict.__init__(self)
        QFrame.__init__(self, parent)
        
        self.__layout_state = None
        
        self.__data = QwtPlot_PrivateData()
        from qwt.plot_layout import QwtPlotLayout
        self.__data.layout = QwtPlotLayout()
        self.__data.autoReplot = False
                
        self.setAutoReplot(True)
#        self.setPlotLayout(self.__data.layout)
        
        # title
        self.__data.titleLabel = QwtTextLabel(self)
        self.__data.titleLabel.setObjectName("QwtPlotTitle")
        self.__data.titleLabel.setFont(QFont(self.fontInfo().family(), 14,
                                             QFont.Bold))
        text = QwtText(title)
        text.setRenderFlags(Qt.AlignCenter|Qt.TextWordWrap)
        self.__data.titleLabel.setText(text)
        
        # footer
        self.__data.footerLabel = QwtTextLabel(self)
        self.__data.footerLabel.setObjectName("QwtPlotFooter")
        footer = QwtText()
        footer.setRenderFlags(Qt.AlignCenter|Qt.TextWordWrap)
        self.__data.footerLabel.setText(footer)
        
        # legend
        self.__data.legend = None
        
        # axis
        self.__axisData = []
        self.initAxesData()
        
        # canvas
        self.__data.canvas = QwtPlotCanvas(self)
        self.__data.canvas.setObjectName("QwtPlotCanvas")
        self.__data.canvas.installEventFilter(self)
        
        self.setSizePolicy(QSizePolicy.MinimumExpanding,
                           QSizePolicy.MinimumExpanding)
        
        self.resize(200, 200)
        
        focusChain = [self, self.__data.titleLabel, self.axisWidget(self.xTop),
                      self.axisWidget(self.yLeft), self.__data.canvas,
                      self.axisWidget(self.yRight),
                      self.axisWidget(self.xBottom), self.__data.footerLabel]
        
        for idx in range(len(focusChain)-1):
            qwtSetTabOrder(focusChain[idx], focusChain[idx+1], False)
        
        qwtEnableLegendItems(self, True)

    def __del__(self):
        #XXX Is is really necessary in Python? (pure transcription of C++)
        self.setAutoReplot(False)
        self.detachItems(QwtPlotItem.Rtti_PlotItem, self.autoDelete())
        self.__data.layout = None
        self.deleteAxesData()
        self.__data = None
        
    def initAxesData(self):
        """Initialize axes"""
        self.__axisData = [AxisData() for axisId in self.validAxes]
        
        self.__axisData[self.yLeft].scaleWidget = \
            QwtScaleWidget(QwtScaleDraw.LeftScale, self)
        self.__axisData[self.yRight].scaleWidget = \
            QwtScaleWidget(QwtScaleDraw.RightScale, self)
        self.__axisData[self.xTop].scaleWidget = \
            QwtScaleWidget(QwtScaleDraw.TopScale, self)
        self.__axisData[self.xBottom].scaleWidget = \
            QwtScaleWidget(QwtScaleDraw.BottomScale, self)

        self.__axisData[self.yLeft
                        ].scaleWidget.setObjectName("QwtPlotAxisYLeft")
        self.__axisData[self.yRight
                        ].scaleWidget.setObjectName("QwtPlotAxisYRight")
        self.__axisData[self.xTop
                        ].scaleWidget.setObjectName("QwtPlotAxisXTop")
        self.__axisData[self.xBottom
                        ].scaleWidget.setObjectName("QwtPlotAxisXBottom")

        fscl = QFont(self.fontInfo().family(), 10)
        fttl = QFont(self.fontInfo().family(), 12, QFont.Bold)
        
        for axisId in self.validAxes:
            d = self.__axisData[axisId]

            d.scaleEngine = QwtLinearScaleEngine()

            d.scaleWidget.setTransformation(d.scaleEngine.transformation())
            d.scaleWidget.setFont(fscl)
            d.scaleWidget.setMargin(2)

            text = d.scaleWidget.title()
            text.setFont(fttl)
            d.scaleWidget.setTitle(text)
            
            d.doAutoScale = True
            d.minValue = 0.0
            d.maxValue = 1000.0
            d.stepSize = 0.0            
            d.maxMinor = 5
            d.maxMajor = 8
            d.isValid = False
            
        self.__axisData[self.yLeft].isEnabled = True
        self.__axisData[self.yRight].isEnabled = False
        self.__axisData[self.xBottom].isEnabled = True
        self.__axisData[self.xTop].isEnabled = False

    def deleteAxesData(self):
        #XXX Is is really necessary in Python? (pure transcription of C++)
        for axisId in self.validAxes:
            self.__axisData[axisId].scaleEngine = None
            self.__axisData[axisId] = None

    def axisWidget(self, axisId):
        """
        :param int axisId: Axis index
        :return: Scale widget of the specified axis, or None if axisId is invalid.
        """
        if self.axisValid(axisId):
            return self.__axisData[axisId].scaleWidget
    
    def setAxisScaleEngine(self, axisId, scaleEngine):
        """
        Change the scale engine for an axis
        
        :param int axisId: Axis index
        :param qwt.scale_engine.QwtScaleEngine scaleEngine: Scale engine

        .. seealso::
        
            :py:meth:`axisScaleEngine()`
        """
        if self.axisValid(axisId) and scaleEngine is not None:
            d = self.__axisData[axisId]
            d.scaleEngine = scaleEngine
            self.__axisData[axisId].scaleWidget.setTransformation(
                                                scaleEngine.transformation())
            d.isValid = False
            self.autoRefresh()
    
    def axisScaleEngine(self, axisId):
        """
        :param int axisId: Axis index
        :return: Scale engine for a specific axis

        .. seealso::
        
            :py:meth:`setAxisScaleEngine()`
        """
        if self.axisValid(axisId):
            return self.__axisData[axisId].scaleEngine

    def axisAutoScale(self, axisId):
        """
        :param int axisId: Axis index
        :return: True, if autoscaling is enabled
        """
        if self.axisValid(axisId):
            return self.__axisData[axisId].doAutoScale
    
    def axisEnabled(self, axisId):
        """
        :param int axisId: Axis index
        :return: True, if a specified axis is enabled
        """
        if self.axisValid(axisId):
            return self.__axisData[axisId].isEnabled
    
    def axisFont(self, axisId):
        """
        :param int axisId: Axis index
        :return: The font of the scale labels for a specified axis
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).font()
        else:
            return QFont()
    
    def axisMaxMajor(self, axisId):
        """
        :param int axisId: Axis index
        :return: The maximum number of major ticks for a specified axis

        .. seealso::
        
            :py:meth:`setAxisMaxMajor()`, 
            :py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).maxMajor
        else:
            return 0

    def axisMaxMinor(self, axisId):
        """
        :param int axisId: Axis index
        :return: The maximum number of minor ticks for a specified axis

        .. seealso::
        
            :py:meth:`setAxisMaxMinor()`, 
            :py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).maxMinor
        else:
            return 0
    
    def axisScaleDiv(self, axisId):
        """
        :param int axisId: Axis index
        :return: The scale division of a specified axis

        axisScaleDiv(axisId).lowerBound(), axisScaleDiv(axisId).upperBound()
        are the current limits of the axis scale.

        .. seealso::
        
            :py:class:`qwt.scale_div.QwtScaleDiv`, 
            :py:meth:`setAxisScaleDiv()`, 
            :py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`
        """
        return self.__axisData[axisId].scaleDiv
    
    def axisScaleDraw(self, axisId):
        """
        :param int axisId: Axis index
        :return: Specified scaleDraw for axis, or NULL if axis is invalid.
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).scaleDraw()

    def axisStepSize(self, axisId):
        """
        :param int axisId: Axis index
        :return: step size parameter value
        
        This doesn't need to be the step size of the current scale.

        .. seealso::
        
            :py:meth:`setAxisScale()`, 
            :py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).stepSize
        else:
            return 0
    
    def axisInterval(self, axisId):
        """
        :param int axisId: Axis index
        :return: The current interval of the specified axis

        This is only a convenience function for axisScaleDiv(axisId).interval()

        .. seealso::
        
            :py:class:`qwt.scale_div.QwtScaleDiv`, 
            :py:meth:`axisScaleDiv()`
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).scaleDiv.interval()
        else:
            return QwtInterval()

    def axisTitle(self, axisId):
        """
        :param int axisId: Axis index
        :return: Title of a specified axis
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).title()
        else:
            return QwtText()
    
    def enableAxis(self, axisId, tf=True):
        """
        Enable or disable a specified axis

        When an axis is disabled, this only means that it is not
        visible on the screen. Curves, markers and can be attached
        to disabled axes, and transformation of screen coordinates
        into values works as normal.
        
        Only xBottom and yLeft are enabled by default.
  
        :param int axisId: Axis index
        :param bool tf: True (enabled) or False (disabled)
        """
        if self.axisValid(axisId) and tf != self.__axisData[axisId].isEnabled:
            self.__axisData[axisId].isEnabled = tf
            self.updateLayout()
            
    def invTransform(self, axisId, pos):
        """
        Transform the x or y coordinate of a position in the
        drawing region into a value.
  
        :param int axisId: Axis index
        :param int pos: position
        
        .. warning::
        
            The position can be an x or a y coordinate,
            depending on the specified axis.
        """
        if self.axisValid(axisId):
            return self.canvasMap(axisId).invTransform(pos)
        else:
            return 0.
            
    def transform(self, axisId, value):
        """
        Transform a value into a coordinate in the plotting region
  
        :param int axisId: Axis index
        :param fload value: Value
        :return: X or Y coordinate in the plotting region corresponding to the value.
        """
        if self.axisValid(axisId):
            return self.canvasMap(axisId).transform(value)
        else:
            return 0.

    def setAxisFont(self, axisId, font):
        """
        Change the font of an axis
  
        :param int axisId: Axis index
        :param QFont font: Font
        
        .. warning::
        
            This function changes the font of the tick labels,
            not of the axis title.
        """
        if self.axisValid(axisId):
            return self.axisWidget(axisId).setFont(font)
    
    def setAxisAutoScale(self, axisId, on=True):
        """
        Enable autoscaling for a specified axis

        This member function is used to switch back to autoscaling mode
        after a fixed scale has been set. Autoscaling is enabled by default.
  
        :param int axisId: Axis index
        :param bool on: On/Off

        .. seealso::
        
            :py:meth:`setAxisScale()`, :py:meth:`setAxisScaleDiv()`, 
            :py:meth:`updateAxes()`
        
        .. note::
        
            The autoscaling flag has no effect until updateAxes() is executed
            ( called by replot() ).
        """
        if self.axisValid(axisId) and self.__axisData[axisId].doAutoScale != on:
            self.__axisData[axisId].doAutoScale = on
            self.autoRefresh()
    
    def setAxisScale(self, axisId, min_, max_, stepSize=0):
        """
        Disable autoscaling and specify a fixed scale for a selected axis.

        In updateAxes() the scale engine calculates a scale division from the 
        specified parameters, that will be assigned to the scale widget. So 
        updates of the scale widget usually happen delayed with the next replot.
  
        :param int axisId: Axis index
        :param float min_: Minimum of the scale
        :param float max_: Maximum of the scale
        :param float stepSize: Major step size. If <code>step == 0</code>, the step size is calculated automatically using the maxMajor setting.

        .. seealso::
        
            :py:meth:`setAxisMaxMajor()`, :py:meth:`setAxisAutoScale()`, 
            :py:meth:`axisStepSize()`, 
            :py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`
        """
        if self.axisValid(axisId):
            d = self.__axisData[axisId]
            d.doAutoScale = False
            d.isValid = False
            d.minValue = min_
            d.maxValue = max_
            d.stepSize = stepSize
            self.autoRefresh()
    
    def setAxisScaleDiv(self, axisId, scaleDiv):
        """
        Disable autoscaling and specify a fixed scale for a selected axis.

        The scale division will be stored locally only until the next call
        of updateAxes(). So updates of the scale widget usually happen delayed with 
        the next replot.
  
        :param int axisId: Axis index
        :param qwt.scale_div.QwtScaleDiv scaleDiv: Scale division

        .. seealso::
        
            :py:meth:`setAxisScale()`, :py:meth:`setAxisAutoScale()`
        """
        if self.axisValid(axisId):
            d = self.__axisData[axisId]
            d.doAutoScale = False
            d.scaleDiv = scaleDiv
            d.isValid = True
            self.autoRefresh()
        
    def setAxisScaleDraw(self, axisId, scaleDraw):
        """
        Set a scale draw
  
        :param int axisId: Axis index
        :param qwt.scale_draw.QwtScaleDraw scaleDraw: Object responsible for drawing scales.

        By passing scaleDraw it is possible to extend QwtScaleDraw
        functionality and let it take place in QwtPlot. Please note
        that scaleDraw has to be created with new and will be deleted
        by the corresponding QwtScale member ( like a child object ).
  
        .. seealso::
        
            :py:class:`qwt.scale_draw.QwtScaleDraw`, 
            :py:class:`qwt.scale_widget.QwtScaleWigdet`
        
        .. warning::
        
            The attributes of scaleDraw will be overwritten by those of the
            previous QwtScaleDraw.
        """
        if self.axisValid(axisId):
            self.axisWidget(axisId).setScaleDraw(scaleDraw)
            self.autoRefresh()
    
    def setAxisLabelAlignment(self, axisId, alignment):
        """
        Change the alignment of the tick labels
  
        :param int axisId: Axis index
        :param Qt.Alignment alignment: Or'd Qt.AlignmentFlags
  
        .. seealso::
        
            :py:meth:`qwt.scale_draw.QwtScaleDraw.setLabelAlignment()`
        """
        if self.axisValid(axisId):
            self.axisWidget(axisId).setLabelAlignment(alignment)
            
    def setAxisLabelRotation(self, axisId, rotation):
        """
        Rotate all tick labels
  
        :param int axisId: Axis index
        :param float rotation: Angle in degrees. When changing the label rotation, the label alignment might be adjusted too.
  
        .. seealso::
        
            :py:meth:`setLabelRotation()`, :py:meth:`setAxisLabelAlignment()`
        """
        if self.axisValid(axisId):
            self.axisWidget(axisId).setLabelRotation(rotation)
            
    def setAxisLabelAutoSize(self, axisId, state):
        """
        Set tick labels automatic size option (default: on)
  
        :param int axisId: Axis index
        :param bool state: On/off 
        
        .. seealso::
        
            :py:meth:`qwt.scale_draw.QwtScaleDraw.setLabelAutoSize()`
        """
        if self.axisValid(axisId):
            self.axisWidget(axisId).setLabelAutoSize(state)
            
    def setAxisMaxMinor(self, axisId, maxMinor):
        """
        Set the maximum number of minor scale intervals for a specified axis
  
        :param int axisId: Axis index
        :param int maxMinor: Maximum number of minor steps
  
        .. seealso::
        
            :py:meth:`axisMaxMinor()`
        """
        if self.axisValid(axisId):
            maxMinor = max([0, min([maxMinor, 100])])
            d = self.__axisData[axisId]
            if maxMinor != d.maxMinor:
                d.maxMinor = maxMinor
                d.isValid = False
                self.autoRefresh()

    def setAxisMaxMajor(self, axisId, maxMajor):
        """
        Set the maximum number of major scale intervals for a specified axis
  
        :param int axisId: Axis index
        :param int maxMajor: Maximum number of major steps
  
        .. seealso::
        
            :py:meth:`axisMaxMajor()`
        """
        if self.axisValid(axisId):
            maxMajor = max([1, min([maxMajor, 10000])])
            d = self.__axisData[axisId]
            if maxMajor != d.maxMajor:
                d.maxMajor = maxMajor
                d.isValid = False
                self.autoRefresh()

    def setAxisTitle(self, axisId, title):
        """
        Change the title of a specified axis
  
        :param int axisId: Axis index
        :param title: axis title
        :type title: qwt.text.QwtText or str
        """
        if self.axisValid(axisId):
            self.axisWidget(axisId).setTitle(title)
            self.updateLayout()

    def updateAxes(self):
        """
        Rebuild the axes scales

        In case of autoscaling the boundaries of a scale are calculated 
        from the bounding rectangles of all plot items, having the 
        `QwtPlotItem.AutoScale` flag enabled (`QwtScaleEngine.autoScale()`). 
        Then a scale division is calculated (`QwtScaleEngine.didvideScale()`) 
        and assigned to scale widget.
        
        When the scale boundaries have been assigned with `setAxisScale()` a 
        scale division is calculated (`QwtScaleEngine.didvideScale()`)
        for this interval and assigned to the scale widget.
        
        When the scale has been set explicitly by `setAxisScaleDiv()` the 
        locally stored scale division gets assigned to the scale widget.
        
        The scale widget indicates modifications by emitting a 
        `QwtScaleWidget.scaleDivChanged()` signal.
        
        `updateAxes()` is usually called by `replot()`. 
  
        .. seealso::
        
            :py:meth:`setAxisAutoScale()`, :py:meth:`setAxisScale()`,
            :py:meth:`setAxisScaleDiv()`, :py:meth:`replot()`,
            :py:meth:`QwtPlotItem.boundingRect()`
        """
        intv = [QwtInterval() for _i in self.validAxes]
        itmList = self.itemList()
        for item in itmList:
            if not item.testItemAttribute(QwtPlotItem.AutoScale):
                continue
            if not item.isVisible():
                continue
            if self.axisAutoScale(item.xAxis()) or self.axisAutoScale(item.yAxis()):
                rect = item.boundingRect()
                if rect.width() >= 0.:
                    intv[item.xAxis()] |= QwtInterval(rect.left(), rect.right())
                if rect.height() >= 0.:
                    intv[item.yAxis()] |= QwtInterval(rect.top(), rect.bottom())
        for axisId in self.validAxes:
            d = self.__axisData[axisId]
            minValue = d.minValue
            maxValue = d.maxValue
            stepSize = d.stepSize
            if d.doAutoScale and intv[axisId].isValid():
                d.isValid = False
                minValue = intv[axisId].minValue()
                maxValue = intv[axisId].maxValue()
                d.scaleEngine.autoScale(d.maxMajor, minValue, maxValue, stepSize)
            if not d.isValid:
                d.scaleDiv = d.scaleEngine.divideScale(minValue, maxValue,
                                           d.maxMajor, d.maxMinor, stepSize)
                d.isValid = True
            scaleWidget = self.axisWidget(axisId)
            scaleWidget.setScaleDiv(d.scaleDiv)

            # It is *really* necessary to update border dist!
            # Otherwise, when tick labels are large enough, the ticks 
            # may not be aligned with canvas grid.
            # See the following issues for more details:
            # https://github.com/PierreRaybaut/guiqwt/issues/57
            # https://github.com/PierreRaybaut/PythonQwt/issues/30
            startDist, endDist = scaleWidget.getBorderDistHint()
            scaleWidget.setBorderDist(startDist, endDist)

        for item in itmList:
            if item.testItemInterest(QwtPlotItem.ScaleInterest):
                item.updateScaleDiv(self.axisScaleDiv(item.xAxis()),
                                    self.axisScaleDiv(item.yAxis()))
    
    def setCanvas(self, canvas):
        """
        Set the drawing canvas of the plot widget.
        
        The default canvas is a `QwtPlotCanvas`.
        
        :param QWidget canvas: Canvas Widget

        .. seealso::
        
            :py:meth:`canvas()`
        """
        if canvas == self.__data.canvas:
            return
        self.__data.canvas = canvas
        if canvas is not None:
            canvas.setParent(self)
            canvas.installEventFilter(self)
            if self.isVisible():
                canvas.show()
    
    def event(self, event):
        ok = QFrame.event(self, event)
        if event.type() == QEvent.LayoutRequest:
            self.updateLayout()
        elif event.type() == QEvent.PolishRequest:
            self.replot()
        return ok

    def eventFilter(self, obj, event):
        if obj is self.__data.canvas:
            if event.type() == QEvent.Resize:
                self.updateCanvasMargins()
            elif event.type() == 178:#QEvent.ContentsRectChange:
                self.updateLayout()
        return QFrame.eventFilter(self, obj, event)
    
    def autoRefresh(self):
        """Replots the plot if :py:meth:`autoReplot()` is True."""
        if self.__data.autoReplot:
            self.replot()
    
    def setAutoReplot(self, tf=True):
        """
        Set or reset the autoReplot option

        If the autoReplot option is set, the plot will be
        updated implicitly by manipulating member functions.
        Since this may be time-consuming, it is recommended
        to leave this option switched off and call :py:meth:`replot()`
        explicitly if necessary.
        
        The autoReplot option is set to false by default, which
        means that the user has to call :py:meth:`replot()` in order 
        to make changes visible.
        
        :param bool tf: True or False. Defaults to True.

        .. seealso::
        
            :py:meth:`canvas()`
        """
        self.__data.autoReplot = tf
    
    def autoReplot(self):
        """
        :return: True if the autoReplot option is set.

        .. seealso::
        
            :py:meth:`setAutoReplot()`
        """
        return self.__data.autoReplot
    
    def setTitle(self, title):
        """
        Change the plot's title
        
        :param title: New title
        :type title: str or qwt.text.QwtText

        .. seealso::
        
            :py:meth:`title()`
        """
        current_title = self.__data.titleLabel.text()
        if isinstance(title, QwtText) and current_title == title:
            return
        elif not isinstance(title, QwtText) and current_title.text() == title:
            return
        self.__data.titleLabel.setText(title)
        self.updateLayout()
    
    def title(self):
        """
        :return: Title of the plot

        .. seealso::
        
            :py:meth:`setTitle()`
        """
        return self.__data.titleLabel.text()
    
    def titleLabel(self):
        """
        :return: Title label widget.
        """
        return self.__data.titleLabel
    
    def setFooter(self, text):
        """
        Change the text the footer
        
        :param text: New text of the footer
        :type text: str or qwt.text.QwtText

        .. seealso::
        
            :py:meth:`footer()`
        """
        current_footer = self.__data.footerLabel.text()
        if isinstance(text, QwtText) and current_footer == text:
            return
        elif not isinstance(text, QwtText) and current_footer.text() == text:
            return
        self.__data.footerLabel.setText(text)
        self.updateLayout()
    
    def footer(self):
        """
        :return: Text of the footer

        .. seealso::
        
            :py:meth:`setFooter()`
        """
        return self.__data.footerLabel.text()
    
    def footerLabel(self):
        """
        :return: Footer label widget.
        """
        return self.__data.footerLabel

    def setPlotLayout(self, layout):
        """
        Assign a new plot layout
        
        :param layout: Layout
        :type layout: qwt.plot_layout.QwtPlotLayout

        .. seealso::
        
            :py:meth:`plotLayout()`
        """
        if layout != self.__data.layout:
            self.__data.layout = layout
            self.updateLayout()
    
    def plotLayout(self):
        """
        :return: the plot's layout

        .. seealso::
        
            :py:meth:`setPlotLayout()`
        """
        return self.__data.layout
    
    def legend(self):
        """
        :return: the plot's legend

        .. seealso::
        
            :py:meth:`insertLegend()`
        """
        return self.__data.legend
    
    def canvas(self):
        """
        :return: the plot's canvas
        """
        return self.__data.canvas
    
    def sizeHint(self):
        """
        :return: Size hint for the plot widget

        .. seealso::
        
            :py:meth:`minimumSizeHint()`
        """
        dw = dh = 0
        for axisId in self.validAxes:
            if self.axisEnabled(axisId):
                niceDist = 40
                scaleWidget = self.axisWidget(axisId)
                scaleDiv = scaleWidget.scaleDraw().scaleDiv()
                majCnt = len(scaleDiv.ticks(QwtScaleDiv.MajorTick))
                if axisId in (self.yLeft, self.yRight):
                    hDiff = (majCnt-1)*niceDist-scaleWidget.minimumSizeHint().height()
                    if hDiff > dh:
                        dh = hDiff
                else:
                    wDiff = (majCnt-1)*niceDist-scaleWidget.minimumSizeHint().width()
                    if wDiff > dw:
                        dw = wDiff
        return self.minimumSizeHint() + QSize(dw, dh)
    
    def minimumSizeHint(self):
        """
        :return: Return a minimum size hint
        """
        hint = self.__data.layout.minimumSizeHint(self)
        hint += QSize(2*self.frameWidth(), 2*self.frameWidth())
        return hint
    
    def resizeEvent(self, e):
        QFrame.resizeEvent(self, e)
        self.updateLayout()
    
    def replot(self):
        """
        Redraw the plot

        If the `autoReplot` option is not set (which is the default)
        or if any curves are attached to raw data, the plot has to
        be refreshed explicitly in order to make changes visible.

        .. seealso::
        
            :py:meth:`updateAxes()`, :py:meth:`setAutoReplot()`
        """
        doAutoReplot = self.autoReplot()
        self.setAutoReplot(False)
        self.updateAxes()
        
        #  Maybe the layout needs to be updated, because of changed
        #  axes labels. We need to process them here before painting
        #  to avoid that scales and canvas get out of sync.
        QApplication.sendPostedEvents(self, QEvent.LayoutRequest)
        
        if self.__data.canvas:
            try:
                self.__data.canvas.replot()
            except (AttributeError, TypeError):
                self.__data.canvas.update(self.__data.canvas.contentsRect())
        
        self.setAutoReplot(doAutoReplot)

    def get_layout_state(self):
        return (self.contentsRect(),
                self.__data.titleLabel.text(), self.__data.footerLabel.text(),
                [(self.axisEnabled(axisId), self.axisTitle(axisId).text())
                 for axisId in self.validAxes],
                self.__data.legend)
    
    def updateLayout(self):
        """
        Adjust plot content to its current size.

        .. seealso::
        
            :py:meth:`resizeEvent()`
        """
#        state = self.get_layout_state()
#        if self.__layout_state is not None and\
#           state == self.__layout_state:
#            return
#        self.__layout_state = state

        self.__data.layout.activate(self, self.contentsRect())
        
        titleRect = self.__data.layout.titleRect().toRect()
        footerRect = self.__data.layout.footerRect().toRect()
        scaleRect = [self.__data.layout.scaleRect(axisId).toRect()
                     for axisId in self.validAxes]
        legendRect = self.__data.layout.legendRect().toRect()
        canvasRect = self.__data.layout.canvasRect().toRect()
        
        if self.__data.titleLabel.text():
            self.__data.titleLabel.setGeometry(titleRect)
            if not self.__data.titleLabel.isVisibleTo(self):
                self.__data.titleLabel.show()
        else:
            self.__data.titleLabel.hide()

        if self.__data.footerLabel.text():
            self.__data.footerLabel.setGeometry(footerRect)
            if not self.__data.footerLabel.isVisibleTo(self):
                self.__data.footerLabel.show()
        else:
            self.__data.footerLabel.hide()
        
        for axisId in self.validAxes:
            if self.axisEnabled(axisId):
                self.axisWidget(axisId).setGeometry(scaleRect[axisId])
                
                if axisId in (self.xBottom, self.xTop):
                    r = QRegion(scaleRect[axisId])
                    if self.axisEnabled(self.yLeft):
                        r = r.subtracted(QRegion(scaleRect[self.yLeft]))
                    if self.axisEnabled(self.yRight):
                        r = r.subtracted(QRegion(scaleRect[self.yRight]))
                    r.translate(-scaleRect[axisId].x(), -scaleRect[axisId].y())
                    
                    self.axisWidget(axisId).setMask(r)
                    
                if not self.axisWidget(axisId).isVisibleTo(self):
                    self.axisWidget(axisId).show()
                
            else:
                self.axisWidget(axisId).hide()
            
        if self.__data.legend:
            if self.__data.legend.isEmpty():
                self.__data.legend.hide()
            else:
                self.__data.legend.setGeometry(legendRect)
                self.__data.legend.show()
        
        self.__data.canvas.setGeometry(canvasRect)
    
    def getCanvasMarginsHint(self, maps, canvasRect):
        """
        Calculate the canvas margins
        
        :param list maps: `QwtPlot.axisCnt` maps, mapping between plot and paint device coordinates
        :param QRectF canvasRect: Bounding rectangle where to paint

        Plot items might indicate, that they need some extra space
        at the borders of the canvas by the `QwtPlotItem.Margins` flag.

        .. seealso::
        
            :py:meth:`updateCanvasMargins()`, :py:meth:`getCanvasMarginHint()`
        """
        left = top = right = bottom = -1.

        for item in self.itemList():
            if item.testItemAttribute(QwtPlotItem.Margins):
                m = item.getCanvasMarginHint(maps[item.xAxis()],
                                             maps[item.yAxis()], canvasRect)
                left = max([left, m[self.yLeft]])
                top = max([top, m[self.xTop]])
                right = max([right, m[self.yRight]])
                bottom = max([bottom, m[self.xBottom]])

        return left, top, right, bottom
    
    def updateCanvasMargins(self):
        """
        Update the canvas margins

        Plot items might indicate, that they need some extra space
        at the borders of the canvas by the `QwtPlotItem.Margins` flag.

        .. seealso::
        
            :py:meth:`getCanvasMarginsHint()`, 
            :py:meth:`QwtPlotItem.getCanvasMarginHint()`
        """
        maps = [self.canvasMap(axisId) for axisId in self.validAxes]
        margins = self.getCanvasMarginsHint(maps, self.canvas().contentsRect())
        
        doUpdate = False
        
        for axisId in self.validAxes:
            if margins[axisId] >= 0.:
                m = np.ceil(margins[axisId])
                self.plotLayout().setCanvasMargin(m, axisId)
                doUpdate = True
        
        if doUpdate:
            self.updateLayout()
    
    def drawCanvas(self, painter):
        """
        Redraw the canvas.
        
        :param QPainter painter: Painter used for drawing

        .. warning::
        
            drawCanvas calls drawItems what is also used
            for printing. Applications that like to add individual
            plot items better overload drawItems()

        .. seealso::
        
            :py:meth:`getCanvasMarginsHint()`, 
            :py:meth:`QwtPlotItem.getCanvasMarginHint()`
        """
        maps = [self.canvasMap(axisId) for axisId in self.validAxes]
        self.drawItems(painter, self.__data.canvas.contentsRect(), maps)
    
    def drawItems(self, painter, canvasRect, maps):
        """
        Redraw the canvas.
        
        :param QPainter painter: Painter used for drawing
        :param QRectF canvasRect: Bounding rectangle where to paint
        :param list maps: `QwtPlot.axisCnt` maps, mapping between plot and paint device coordinates

        .. note::
        
            Usually canvasRect is `contentsRect()` of the plot canvas.
            Due to a bug in Qt this rectangle might be wrong for certain 
            frame styles ( f.e `QFrame.Box` ) and it might be necessary to 
            fix the margins manually using `QWidget.setContentsMargins()`
        """
        for item in self.itemList():
            if item and item.isVisible():
                painter.save()
                painter.setRenderHint(QPainter.Antialiasing,
                          item.testRenderHint(QwtPlotItem.RenderAntialiased))
                painter.setRenderHint(QPainter.HighQualityAntialiasing,
                          item.testRenderHint(QwtPlotItem.RenderAntialiased))
                item.draw(painter, maps[item.xAxis()], maps[item.yAxis()],
                          canvasRect)
                painter.restore()

    def canvasMap(self, axisId):
        """
        :param int axisId: Axis
        :return: Map for the axis on the canvas. With this map pixel coordinates can translated to plot coordinates and vice versa.

        .. seealso::
        
            :py:class:`qwt.scale_map.QwtScaleMap`, 
            :py:meth:`transform()`, :py:meth:`invTransform()`
        """
        map_ = QwtScaleMap()
        if not self.__data.canvas:
            return map_
        
        map_.setTransformation(self.axisScaleEngine(axisId).transformation())
        sd = self.axisScaleDiv(axisId)
        map_.setScaleInterval(sd.lowerBound(), sd.upperBound())
        
        if self.axisEnabled(axisId):
            s = self.axisWidget(axisId)
            if axisId in (self.yLeft, self.yRight):
                y = s.y() + s.startBorderDist() - self.__data.canvas.y()
                h = s.height() - s.startBorderDist() - s.endBorderDist()
                map_.setPaintInterval(y+h, y)
            else:
                x = s.x() + s.startBorderDist() - self.__data.canvas.x()
                w = s.width() - s.startBorderDist() - s.endBorderDist()
                map_.setPaintInterval(x, x+w)
        else:
            canvasRect = self.__data.canvas.contentsRect()
            if axisId in (self.yLeft, self.yRight):
                top = 0
                if not self.plotLayout().alignCanvasToScale(self.xTop):
                    top = self.plotLayout().canvasMargin(self.xTop)
                bottom = 0
                if not self.plotLayout().alignCanvasToScale(self.xBottom):
                    bottom = self.plotLayout().canvasMargin(self.xBottom)
                map_.setPaintInterval(canvasRect.bottom()-bottom,
                                      canvasRect.top()+top)
            else:
                left = 0
                if not self.plotLayout().alignCanvasToScale(self.yLeft):
                    left = self.plotLayout().canvasMargin(self.yLeft)
                right = 0
                if not self.plotLayout().alignCanvasToScale(self.yRight):
                    right = self.plotLayout().canvasMargin(self.yRight)
                map_.setPaintInterval(canvasRect.left()+left,
                                      canvasRect.right()-right)
        return map_
    
    def setCanvasBackground(self, brush):
        """
        Change the background of the plotting area

        Sets brush to `QPalette.Window` of all color groups of
        the palette of the canvas. Using `canvas().setPalette()`
        is a more powerful way to set these colors.

        :param QBrush brush: New background brush

        .. seealso::
        
            :py:meth:`canvasBackground()`
        """
        pal = self.__data.canvas.palette()
        pal.setBrush(QPalette.Window, brush)
        self.canvas().setPalette(pal)
    
    def canvasBackground(self):
        """
        :return: Background brush of the plotting area.

        .. seealso::
        
            :py:meth:`setCanvasBackground()`
        """
        return self.canvas().palette().brush(QPalette.Normal, QPalette.Window)
    
    def axisValid(self, axisId):
        """
        :param int axisId: Axis
        :return: True if the specified axis exists, otherwise False
        """
        return axisId in QwtPlot.validAxes
    
    def insertLegend(self, legend, pos=None, ratio=-1):
        """
        Insert a legend

        If the position legend is `QwtPlot.LeftLegend` or `QwtPlot.RightLegend`
        the legend will be organized in one column from top to down.
        Otherwise the legend items will be placed in a table
        with a best fit number of columns from left to right.
        
        insertLegend() will set the plot widget as parent for the legend.
        The legend will be deleted in the destructor of the plot or when 
        another legend is inserted.
        
        Legends, that are not inserted into the layout of the plot widget
        need to connect to the legendDataChanged() signal. Calling updateLegend()
        initiates this signal for an initial update. When the application code
        wants to implement its own layout this also needs to be done for
        rendering plots to a document ( see QwtPlotRenderer ).

        :param qwt.legend.QwtAbstractLegend legend: Legend
        :param QwtPlot.LegendPosition pos: The legend's position. 
        :param float ratio: Ratio between legend and the bounding rectangle of title, canvas and axes

        .. note::

            For top/left position the number of columns will be limited to 1, 
            otherwise it will be set to unlimited.

        .. note::

            The legend will be shrunk if it would need more space than the 
            given ratio. The ratio is limited to ]0.0 .. 1.0]. 
            In case of <= 0.0 it will be reset to the default ratio. 
            The default vertical/horizontal ratio is 0.33/0.5.

        .. seealso::
        
            :py:meth:`legend()`, 
            :py:meth:`qwt.plot_layout.QwtPlotLayout.legendPosition()`,
            :py:meth:`qwt.plot_layout.QwtPlotLayout.setLegendPosition()`
        """
        if pos is None:
            pos = self.RightLegend
        self.__data.layout.setLegendPosition(pos, ratio)
        if legend != self.__data.legend:
            if self.__data.legend and self.__data.legend.parent() is self:
                del self.__data.legend
            self.__data.legend = legend
            if self.__data.legend:
                self.legendDataChanged.connect(self.__data.legend.updateLegend)
                if self.__data.legend.parent() is not self:
                    self.__data.legend.setParent(self)
                
                qwtEnableLegendItems(self, False)
                self.updateLegend()
                qwtEnableLegendItems(self, True)
                
                lpos = self.__data.layout.legendPosition()

                if legend is not None:
                    if lpos in (self.LeftLegend, self.RightLegend):
                        if legend.maxColumns() == 0:
                            legend.setMaxColumns(1)
                    elif lpos in (self.TopLegend, self.BottomLegend):
                        legend.setMaxColumns(0)
                
                previousInChain = None
                if lpos == self.LeftLegend:
                    previousInChain = self.axisWidget(QwtPlot.xTop)
                elif lpos == self.TopLegend:
                    previousInChain = self
                elif lpos == self.RightLegend:
                    previousInChain = self.axisWidget(QwtPlot.yRight)
                elif lpos == self.BottomLegend:
                    previousInChain = self.footerLabel()
                
            if previousInChain:
                qwtSetTabOrder(previousInChain, legend, True)
        
        self.updateLayout()
    
    def updateLegend(self, plotItem=None):
        """
        If plotItem is None, emit QwtPlot.legendDataChanged for all 
        plot item. Otherwise, emit the signal for passed plot item.
    
        :param qwt.plot.QwtPlotItem plotItem: Plot item

        .. seealso::
        
            :py:meth:`QwtPlotItem.legendData()`, :py:data:`QwtPlot.legendDataChanged`
        """
        if plotItem is None:
            items = list(self.itemList())
        else:
            items = [plotItem]
        for plotItem in items:
            if plotItem is None:
                continue
            legendData = []
            if plotItem.testItemAttribute(QwtPlotItem.Legend):
                legendData = plotItem.legendData()
            self.legendDataChanged.emit(plotItem, legendData)

    def updateLegendItems(self, plotItem, legendData):
        """
        Update all plot items interested in legend attributes

        Call `QwtPlotItem.updateLegend()`, when the 
        `QwtPlotItem.LegendInterest` flag is set.
    
        :param qwt.plot.QwtPlotItem plotItem: Plot item
        :param list legendData: Entries to be displayed for the plot item ( usually 1 )

        .. seealso::
        
            :py:meth:`QwtPlotItem.LegendInterest()`, 
            :py:meth:`QwtPlotItem.updateLegend`
        """
        if plotItem is not None:
            for item in self.itemList():
                if item.testItemInterest(QwtPlotItem.LegendInterest):
                    item.updateLegend(plotItem, legendData)
    
    def attachItem(self, plotItem, on):
        """
        Attach/Detach a plot item
    
        :param qwt.plot.QwtPlotItem plotItem: Plot item
        :param bool on: When true attach the item, otherwise detach it
        """
        if plotItem.testItemInterest(QwtPlotItem.LegendInterest):
            for item in self.itemList():
                legendData = []
                if on and item.testItemAttribute(QwtPlotItem.Legend):
                    legendData = item.legendData()
                    plotItem.updateLegend(item, legendData)
    
        if on:
            self.insertItem(plotItem)
        else:
            self.removeItem(plotItem)
        
        self.itemAttached.emit(plotItem, on)
        
        if plotItem.testItemAttribute(QwtPlotItem.Legend):
            if on:
                self.updateLegend(plotItem)
            else:
                self.legendDataChanged.emit(plotItem, [])
        
        self.autoRefresh()
    
    def print_(self, printer):
        """
        Print plot to printer
    
        :param printer: Printer
        :type printer: QPaintDevice or QPrinter or QSvgGenerator
        """
        from qwt.plot_renderer import QwtPlotRenderer
        renderer = QwtPlotRenderer(self)
        renderer.renderTo(self, printer)
    
    def exportTo(self, filename, size=(800, 600), size_mm=None,
                 resolution=72., format_=None):
        """
        Export plot to PDF or image file (SVG, PNG, ...)
    
        :param str filename: Filename
        :param tuple size: (width, height) size in pixels
        :param tuple size_mm: (width, height) size in millimeters
        :param float resolution: Image resolution
        :param str format_: File format (PDF, SVG, PNG, ...)
        """
        if size_mm is None:
            size_mm = tuple(25.4*np.array(size)/resolution)
        from qwt.plot_renderer import QwtPlotRenderer
        renderer = QwtPlotRenderer(self)
        renderer.renderDocument(self, filename, size_mm, resolution, format_)


class QwtPlotItem_PrivateData(object):
    def __init__(self):
        self.plot = None
        self.isVisible = True
        self.attributes = 0
        self.interests = 0
        self.renderHints = 0
        self.z = 0.
        self.xAxis = QwtPlot.xBottom
        self.yAxis = QwtPlot.yLeft
        self.legendIconSize = QSize(8, 8)
        self.title = None # QwtText


class QwtPlotItem(object):
    """
    Base class for items on the plot canvas
    
    A plot item is "something", that can be painted on the plot canvas,
    or only affects the scales of the plot widget. They can be categorized as:
    
    - Representator

      A "Representator" is an item that represents some sort of data
      on the plot canvas. The different representator classes are organized
      according to the characteristics of the data:

          - :py:class:`qwt.plot_marker.QwtPlotMarker`: Represents a point or a 
            horizontal/vertical coordinate
          - :py:class:`qwt.plot_curve.QwtPlotCurve`: Represents a series of 
            points
    
    - Decorators

      A "Decorator" is an item, that displays additional information, that
      is not related to any data:

          - :py:class:`qwt.plot_grid.QwtPlotGrid`
    
    Depending on the `QwtPlotItem.ItemAttribute` flags, an item is included
    into autoscaling or has an entry on the legend.
    
    Before misusing the existing item classes it might be better to
    implement a new type of plot item
    ( don't implement a watermark as spectrogram ).
    Deriving a new type of `QwtPlotItem` primarily means to implement
    the `YourPlotItem.draw()` method.

    .. seealso::

        The cpuplot example shows the implementation of additional plot items.

    .. py:class:: QwtPlotItem([title=None])
    
        Constructor
        
        :param title: Title of the item
        :type title: qwt.text.QwtText or str
    """
    
    # enum RttiValues
    (Rtti_PlotItem, Rtti_PlotGrid, Rtti_PlotScale, Rtti_PlotLegend,
     Rtti_PlotMarker, Rtti_PlotCurve, Rtti_PlotSpectroCurve,
     Rtti_PlotIntervalCurve, Rtti_PlotHistogram, Rtti_PlotSpectrogram,
     Rtti_PlotSVG, Rtti_PlotTradingCurve, Rtti_PlotBarChart,
     Rtti_PlotMultiBarChart, Rtti_PlotShape, Rtti_PlotTextLabel,
     Rtti_PlotZone) = list(range(17))
    Rtti_PlotUserItem = 1000
    
    # enum ItemAttribute
    Legend = 0x01
    AutoScale = 0x02
    Margins = 0x04
    
    # enum ItemInterest
    ScaleInterest = 0x01
    LegendInterest = 0x02
    
    # enum RenderHint
    RenderAntialiased = 0x1
    
    def __init__(self, title=None):
        """title: QwtText"""
        if title is None:
            title = QwtText("")
        if hasattr(title, 'capitalize'):  # avoids dealing with Py3K compat.
            title = QwtText(title)
        assert isinstance(title, QwtText)
        self.__data = QwtPlotItem_PrivateData()
        self.__data.title = title

    def attach(self, plot):
        """
        Attach the item to a plot.

        This method will attach a `QwtPlotItem` to the `QwtPlot` argument. 
        It will first detach the `QwtPlotItem` from any plot from a previous 
        call to attach (if necessary). If a None argument is passed, it will 
        detach from any `QwtPlot` it was attached to.
        
        :param qwt.plot.QwtPlot plot: Plot widget

        .. seealso::
        
            :py:meth:`detach()`
        """
        if plot is self.__data.plot:
            return
        
        if self.__data.plot:
            self.__data.plot.attachItem(self, False)
        
        self.__data.plot = plot
        
        if self.__data.plot:
            self.__data.plot.attachItem(self, True)
    
    def detach(self):
        """
        Detach the item from a plot.

        This method detaches a `QwtPlotItem` from any `QwtPlot` it has been 
        associated with.

        .. seealso::
        
            :py:meth:`attach()`
        """
        self.attach(None)
    
    def rtti(self):
        """
        Return rtti for the specific class represented. `QwtPlotItem` is 
        simply a virtual interface class, and base classes will implement 
        this method with specific rtti values so a user can differentiate 
        them.
        
        :return: rtti value
        """
        return self.Rtti_PlotItem
    
    def plot(self):
        """
        :return: attached plot
        """
        return self.__data.plot
        
    def z(self):
        """
        Plot items are painted in increasing z-order.
        
        :return: item z order

        .. seealso::
        
            :py:meth:`setZ()`, :py:meth:`QwtPlotDict.itemList()`
        """
        return self.__data.z
        
    def setZ(self, z):
        """
        Set the z value
        
        Plot items are painted in increasing z-order.
        
        :param float z: Z-value

        .. seealso::
        
            :py:meth:`z()`, :py:meth:`QwtPlotDict.itemList()`
        """
        if self.__data.z != z:
            if self.__data.plot:
                self.__data.plot.attachItem(self, False)
            self.__data.z = z
            if self.__data.plot:
                self.__data.plot.attachItem(self, True)
            self.itemChanged()
    
    def setTitle(self, title):
        """
        Set a new title
        
        :param title: Title
        :type title: qwt.text.QwtText or str

        .. seealso::
        
            :py:meth:`title()`
        """
        if not isinstance(title, QwtText):
            title = QwtText(title)
        if self.__data.title != title:
            self.__data.title = title
        self.legendChanged()
    
    def title(self):
        """
        :return: Title of the item

        .. seealso::
        
            :py:meth:`setTitle()`
        """
        return self.__data.title
    
    def setItemAttribute(self, attribute, on=True):
        """
        Toggle an item attribute
        
        :param int attribute: Attribute type
        :param bool on: True/False

        .. seealso::
        
            :py:meth:`testItemAttribute()`
        """
        if bool(self.__data.attributes & attribute) != on:
            if on:
                self.__data.attributes |= attribute
            else:
                self.__data.attributes &= ~attribute
            if attribute == QwtPlotItem.Legend:
                self.legendChanged()
            self.itemChanged()
    
    def testItemAttribute(self, attribute):
        """
        Test an item attribute
        
        :param int attribute: Attribute type
        :return: True/False

        .. seealso::
        
            :py:meth:`setItemAttribute()`
        """
        return bool(self.__data.attributes & attribute)
    
    def setItemInterest(self, interest, on=True):
        """
        Toggle an item interest
        
        :param int attribute: Interest type
        :param bool on: True/False

        .. seealso::
        
            :py:meth:`testItemInterest()`
        """
        if bool(self.__data.interests & interest) != on:
            if on:
                self.__data.interests |= interest
            else:
                self.__data.interests &= ~interest
            self.itemChanged()
    
    def testItemInterest(self, interest):
        """
        Test an item interest
        
        :param int attribute: Interest type
        :return: True/False

        .. seealso::
        
            :py:meth:`setItemInterest()`
        """
        return bool(self.__data.interests & interest)
    
    def setRenderHint(self, hint, on=True):
        """
        Toggle a render hint
        
        :param int hint: Render hint
        :param bool on: True/False

        .. seealso::
        
            :py:meth:`testRenderHint()`
        """
        if bool(self.__data.renderHints & hint) != on:
            if on:
                self.__data.renderHints |= hint
            else:
                self.__data.renderHints &= ~hint
            self.itemChanged()
    
    def testRenderHint(self, hint):
        """
        Test a render hint
        
        :param int attribute: Render hint
        :return: True/False

        .. seealso::
        
            :py:meth:`setRenderHint()`
        """
        return bool(self.__data.renderHints & hint)
    
    def setLegendIconSize(self, size):
        """
        Set the size of the legend icon

        The default setting is 8x8 pixels
        
        :param QSize size: Size

        .. seealso::
        
            :py:meth:`legendIconSize()`, :py:meth:`legendIcon()`
        """
        if self.__data.legendIconSize != size:
            self.__data.legendIconSize = size
            self.legendChanged()
    
    def legendIconSize(self):
        """
        :return: Legend icon size

        .. seealso::
        
            :py:meth:`setLegendIconSize()`, :py:meth:`legendIcon()`
        """
        return self.__data.legendIconSize
    
    def legendIcon(self, index, size):
        """
        :param int index: Index of the legend entry (usually there is only one)
        :param QSizeF size: Icon size
        :return: Icon representing the item on the legend
        
        The default implementation returns an invalid icon

        .. seealso::
        
            :py:meth:`setLegendIconSize()`, :py:meth:`legendData()`
        """
        return QwtGraphic()
    
    def defaultIcon(self, brush, size):
        """
        Return a default icon from a brush

        The default icon is a filled rectangle used
        in several derived classes as legendIcon().
   
        :param QBrush brush: Fill brush
        :param QSizeF size: Icon size
        :return: A filled rectangle
        """
        icon = QwtGraphic()
        if not size.isEmpty():
            icon.setDefaultSize(size)
            r = QRectF(0, 0, size.width(), size.height())
            painter = QPainter(icon)
            painter.fillRect(r, brush)
        return icon
    
    def show(self):
        """Show the item"""
        self.setVisible(True)
    
    def hide(self):
        """Hide the item"""
        self.setVisible(False)
    
    def setVisible(self, on):
        """
        Show/Hide the item
        
        :param bool on: Show if True, otherwise hide

        .. seealso::
        
            :py:meth:`isVisible()`, :py:meth:`show()`, :py:meth:`hide()`
        """
        if on != self.__data.isVisible:
            self.__data.isVisible = on
            self.itemChanged()
    
    def isVisible(self):
        """
        :return: True if visible

        .. seealso::
        
            :py:meth:`setVisible()`, :py:meth:`show()`, :py:meth:`hide()`
        """
        return self.__data.isVisible
    
    def itemChanged(self):
        """
        Update the legend and call `QwtPlot.autoRefresh()` for the
        parent plot.

        .. seealso::
        
            :py:meth:`QwtPlot.legendChanged()`, :py:meth:`QwtPlot.autoRefresh()`
        """
        if self.__data.plot:
            self.__data.plot.autoRefresh()
    
    def legendChanged(self):
        """
        Update the legend of the parent plot.
        
        .. seealso::
        
            :py:meth:`QwtPlot.updateLegend()`, :py:meth:`itemChanged()`
        """
        if self.testItemAttribute(QwtPlotItem.Legend) and self.__data.plot:
            self.__data.plot.updateLegend(self)
    
    def setAxes(self, xAxis, yAxis):
        """
        Set X and Y axis

        The item will painted according to the coordinates of its Axes.
        
        :param int xAxis: X Axis (`QwtPlot.xBottom` or `QwtPlot.xTop`)
        :param int yAxis: Y Axis (`QwtPlot.yLeft` or `QwtPlot.yRight`)
        
        .. seealso::
        
            :py:meth:`setXAxis()`, :py:meth:`setYAxis()`,
            :py:meth:`xAxis()`, :py:meth:`yAxis()`
        """
        if xAxis == QwtPlot.xBottom or xAxis == QwtPlot.xTop:
            self.__data.xAxis = xAxis
        if yAxis == QwtPlot.yLeft or yAxis == QwtPlot.yRight:
            self.__data.yAxis = yAxis
        self.itemChanged()

    def setAxis(self, xAxis, yAxis):
        """
        Set X and Y axis

        .. warning::
        
            `setAxis` has been removed in Qwt6: please use 
            :py:meth:`setAxes()` instead
        """
        import warnings
        warnings.warn("`setAxis` has been removed in Qwt6: "\
                      "please use `setAxes` instead", RuntimeWarning)
        self.setAxes(xAxis, yAxis)
    
    def setXAxis(self, axis):
        """
        Set the X axis

        The item will painted according to the coordinates its Axes.
        
        :param int axis: X Axis (`QwtPlot.xBottom` or `QwtPlot.xTop`)
        
        .. seealso::
        
            :py:meth:`setAxes()`, :py:meth:`setYAxis()`,
            :py:meth:`xAxis()`, :py:meth:`yAxis()`
        """
        if axis in (QwtPlot.xBottom, QwtPlot.xTop):
            self.__data.xAxis = axis
            self.itemChanged()
    
    def setYAxis(self, axis):
        """
        Set the Y axis

        The item will painted according to the coordinates its Axes.
        
        :param int axis: Y Axis (`QwtPlot.yLeft` or `QwtPlot.yRight`)
        
        .. seealso::
        
            :py:meth:`setAxes()`, :py:meth:`setXAxis()`,
            :py:meth:`xAxis()`, :py:meth:`yAxis()`
        """
        if axis in (QwtPlot.yLeft, QwtPlot.yRight):
            self.__data.yAxis = axis
            self.itemChanged()

    def xAxis(self):
        """
        :return: xAxis
        """
        return self.__data.xAxis
    
    def yAxis(self):
        """
        :return: yAxis
        """
        return self.__data.yAxis
    
    def boundingRect(self):
        """
        :return: An invalid bounding rect: QRectF(1.0, 1.0, -2.0, -2.0)
        
        .. note::
        
            A width or height < 0.0 is ignored by the autoscaler
        """
        return QRectF(1.0, 1.0, -2.0, -2.0)
    
    def getCanvasMarginHint(self, xMap, yMap, canvasRect):
        """
        Calculate a hint for the canvas margin

        When the QwtPlotItem::Margins flag is enabled the plot item
        indicates, that it needs some margins at the borders of the canvas.
        This is f.e. used by bar charts to reserve space for displaying
        the bars.
        
        The margins are in target device coordinates ( pixels on screen )
        
        :param qwt.scale_map.QwtScaleMap xMap: Maps x-values into pixel coordinates.
        :param qwt.scale_map.QwtScaleMap yMap: Maps y-values into pixel coordinates.
        :param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
        
        .. seealso::
        
            :py:meth:`QwtPlot.getCanvasMarginsHint()`, 
            :py:meth:`QwtPlot.updateCanvasMargins()`,
        """
        left = top = right = bottom = 0.
        return left, top, right, bottom
    
    def legendData(self):
        """
        Return all information, that is needed to represent
        the item on the legend
        
        `QwtLegendData` is basically a list of QVariants that makes it
        possible to overload and reimplement legendData() to 
        return almost any type of information, that is understood
        by the receiver that acts as the legend.
        
        The default implementation returns one entry with 
        the title() of the item and the legendIcon().
        
        :return: Data, that is needed to represent the item on the legend
        
        .. seealso::
        
            :py:meth:`title()`, :py:meth:`legendIcon()`, 
            :py:class:`qwt.legend.QwtLegend`
        """
        data = QwtLegendData()
        label = self.title()
        label.setRenderFlags(label.renderFlags() & Qt.AlignLeft)
        data.setValue(QwtLegendData.TitleRole, label)
        graphic = self.legendIcon(0, self.legendIconSize())
        if not graphic.isNull():
            data.setValue(QwtLegendData.IconRole, graphic)
        return [data]
    
    def updateLegend(self, item, data):
        """
        Update the item to changes of the legend info

        Plot items that want to display a legend ( not those, that want to
        be displayed on a legend ! ) will have to implement updateLegend().
        
        updateLegend() is only called when the LegendInterest interest
        is enabled. The default implementation does nothing.
        
        :param qwt.plot.QwtPlotItem item: Plot item to be displayed on a legend
        :param list data: Attributes how to display item on the legend
        
        .. note::
        
            Plot items, that want to be displayed on a legend
            need to enable the `QwtPlotItem.Legend` flag and to implement
            legendData() and legendIcon()
        """
        pass

    def scaleRect(self, xMap, yMap):
        """
        Calculate the bounding scale rectangle of 2 maps
        
        :param qwt.scale_map.QwtScaleMap xMap: Maps x-values into pixel coordinates.
        :param qwt.scale_map.QwtScaleMap yMap: Maps y-values into pixel coordinates.
        :return: Bounding scale rect of the scale maps, not normalized
        """
        return QRectF(xMap.s1(), yMap.s1(), xMap.sDist(), yMap.sDist())
    
    def paintRect(self, xMap, yMap):
        """
        Calculate the bounding paint rectangle of 2 maps
        
        :param qwt.scale_map.QwtScaleMap xMap: Maps x-values into pixel coordinates.
        :param qwt.scale_map.QwtScaleMap yMap: Maps y-values into pixel coordinates.
        :return: Bounding paint rectangle of the scale maps, not normalized
        """
        return QRectF(xMap.p1(), yMap.p1(), xMap.pDist(), yMap.pDist())
