def _init_toolbar(self):
     selectAction = self.addAction(QIcon(":/plugins/spatialplot/action.png"), 'Select Features', self.select_mode)
     selectAction.setToolTip('Click and drag the plot to select features in the QGIS interface.')
     selectAction.setCheckable(True)
     self._actions['select'] = selectAction
     
     NavigationToolbar2QTAgg._init_toolbar(self)

 def __init__(self, canvas, parent, browser):
     NavigationToolbar2QTAgg.__init__(self,canvas,parent)
     for c in self.findChildren(QtGui.QToolButton):
         #print str(c.text())
         if str(c.text()) in ('Subplots','Customize','Back','Forward','Home'):
             c.defaultAction().setVisible(False)
     self.parent = parent
     self.browser = browser

	def __init__(self, *args, **kwargs):
		NavigationToolbar2QTAgg.__init__(self, *args, **kwargs)

		self.init_buttons()
		self.panAction.setCheckable(True)
		self.zoomAction.setCheckable(True)

		# remove the subplots action
		self.removeAction( self.subplotsAction )

class MplCanvas(FigureCanvas):
    def __init__(self, parent=None, width=5, height=4, dpi=100):
        matplotlib.rcParams['font.size'] = 8
        self.figure = Figure(figsize=(width, height), dpi=dpi)
        self.axes = self.figure.add_subplot(111)

        FigureCanvas.__init__(self, self.figure)
        self.setParent(parent)
        
        self.toolbar = NavigationToolbar(self, parent)
        self.toolbar.setIconSize(QSize(16, 16))

        FigureCanvas.setSizePolicy(self,
                                   QSizePolicy.Expanding,
                                   QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(self)
        
    def getToolbar(self):
        return self.toolbar

    def clear(self):
        self.figure.clear()
        self.axes = self.figure.add_subplot(111)
        
    def test(self):
        self.axes.plot([1,2,3,4])
        
    def saveAs(self, fname):
        self.figure.savefig(fname)

class plotwidget(FigureCanvas):
    def __init__(self, parent, width=12, height=6, dpi=72, projection3d=False):

        #plotdata can be 2d array for image plot or list of 2 1d arrays for x-y plot or 2d array for image plot or list of lists of 2 1D arrays

        self.fig=Figure(figsize=(width, height), dpi=dpi)
        if projection3d:
            self.axes=self.fig.add_subplot(111, navigate=True, projection='3d')
        else:
            self.axes=self.fig.add_subplot(111, navigate=True)

        self.axes.hold(True)
        FigureCanvas.__init__(self, self.fig)
        self.setParent(parent)
        #self.parent=parent
        FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(self)
        #NavigationToolbar(self, parent)
        
        self.toolbar=NavigationToolbar(self.figure.canvas, self)
        self.toolbar.setMovable(True)#DOESNT DO ANYTHING
        self.mpl_connect('button_press_event', self.myclick)
        self.clicklist=[]

    def myclick(self, event):
        if not (event.xdata is None or event.ydata is None):
            arrayxy=[event.xdata, event.ydata]
            print 'clicked on image: array indeces ', arrayxy, ' using button', event.button
            self.clicklist+=[arrayxy]
            self.emit(SIGNAL("genericclickonplot"), [event.xdata, event.ydata, event.button])

 def __init__(self, widgimage, parent=None):
     #print 'ImgSpeNavToolBar.__init__'
     self.widgimage  = widgimage
     self.canvas     = self.widgimage.getCanvas()
     fig = self.canvas.figure
     fig.ntbZoomIsOn = False
     NavigationToolbar.__init__( self, self.canvas, parent )

class MatplotlibPlot:
    """ Class encapsulating a matplotlib plot"""

    def __init__(self, parent = None, dpi = 100, size = (5,5)):
        """ Class initialiser """

        self.dpi = dpi
        self.figure = Figure(size, dpi = self.dpi)
        self.canvas = FigureCanvas(self.figure)
        self.canvas.setParent(parent)

        # Create the navigation toolbar, tied to the canvas
        self.toolbar = NavigationToolbar(self.canvas, parent)
        self.canvas.show()
        self.toolbar.show()

        # Reset the plot landscape
        self.figure.clear()

    def plotMultiPixel(self, info, data):
        """ Generate multi-pixel plot """

        # Tabula Rasa
        self.figure.clear()
        rows = math.ceil(math.sqrt(info['nbeams']))

	    # Display a subplot per beam (randomly for now)
        for i in range(info['nbeams']):
            ax = self.figure.add_subplot(rows, rows, i)
            ax.plot(data[:,512,i])
            
        

    def updatePlot(self):
        self.canvas.draw()

 def home(self, *args) :
     print 'Home is clicked'
     fig = self.canvas.figure
     fig.myXmin = None
     fig.myXmax = None
     fig.myYmin = None
     fig.myYmax = None
     NavigationToolbar.home(self)

 def __init__(self,canvas,parent):
     #NavigationToolbar.__init__(self,parent,canevas)
     #self.layout = QVBoxLayout( self )
     self.canvas = canvas
     #QtGui.QWidget.__init__(self, parent)
     #self.layout.setMargin( 2 )
     #self.layout.setSpacing( 0 )
     NavigationToolbar.__init__(self, canvas, canvas)

    def __init__(self, parent, canvas):
        """ Initialization
        """
        NavigationToolbar2.__init__(self, canvas, canvas)

        self._myParent = parent
        self._navigationMode = MyNavigationToolbar.NAVIGATION_MODE_NONE

        return

class MplWidgetT(QtGui.QWidget):
    def __init__(self, parent = None):
        QtGui.QWidget.__init__(self, parent)
        self.canvas = MplCanvas()
        self.ntb = NavigationToolbar(self.canvas, self)
        self.ntb.setIconSize(QtCore.QSize(16, 16))
        self.vbl = QtGui.QVBoxLayout()
        self.vbl.addWidget(self.canvas)
        self.vbl.addWidget(self.ntb)
        self.setLayout(self.vbl)

    def _update_view(self):
        """
        view update called by home(), back() and forward()
        :return:
        """
        NavigationToolbar2._update_view(self)

        self._myParent.evt_view_updated()

        return

    def draw(self):
        """
        Canvas is drawn called by pan(), zoom()
        :return:
        """
        NavigationToolbar2.draw(self)

        self._myParent.evt_view_updated()

        return

 def NewFigure_proc(self):
     widget = QtGui.QWidget(self.MainFigTabWidget)
     vlay = QtGui.QVBoxLayout(widget)
     self.Figures.append(MplWidget(widget))
     ntb = NavToolbar(self.Figures[-1], parent = widget)
     ntb.setIconSize(QtCore.QSize(15,15))
     vlay.setSpacing(0)
     vlay.setMargin(0)
     vlay.addWidget(self.Figures[-1])
     vlay.addWidget(ntb)
     widget.setLayout(vlay)
     self.MainFigTabWidget.addTab(widget, 'Figure '+str(len(self.Figures)))
     widget.setObjectName(str(self.MainFigTabWidget.count()))
     self.Figures[-1].setObjectName(str(self.MainFigTabWidget.count()))

  def __init__(self, plugin, parent=None):
    QWidget.__init__(self, parent)
    self.setupUi(self)

    self.plugin = plugin
    self.inputs = plugin.inputs
    self.settings = QSettings("NextGIS", "MOLUSCE")

    # init plot for learning curve
    self.figure = Figure()
    self.axes = self.figure.add_subplot(111)
    self.figure.suptitle(self.tr("Neural Network learning curve"))
    self.canvas = FigureCanvas(self.figure)
    self.mpltoolbar = NavigationToolbar(self.canvas, None)
    lstActions = self.mpltoolbar.actions()
    self.mpltoolbar.removeAction(lstActions[7])
    self.layoutPlot.addWidget(self.canvas)
    self.layoutPlot.addWidget(self.mpltoolbar)

    # and configure matplotlib params
    rcParams['font.serif'] = "Verdana, Arial, Liberation Serif"
    rcParams['font.sans-serif'] = "Tahoma, Arial, Liberation Sans"
    rcParams['font.cursive'] = "Courier New, Arial, Liberation Sans"
    rcParams['font.fantasy'] = "Comic Sans MS, Arial, Liberation Sans"
    rcParams['font.monospace'] = "Courier New, Liberation Mono"

    self.btnTrainNetwork.clicked.connect(self.trainNetwork)

    self.manageGui()

 def _createPlotWidget(self):
     self._plotWidget = QtGui.QWidget()
     self._plotFigure = Figure()
     self._plotCanvas = FigureCanvas(self._plotFigure)
     self._plotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
     self._plotCanvas.updateGeometry()
     self._plotCanvas.setParent(self._plotWidget)
     self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
     self._plotFigure.set_canvas(self._plotCanvas)
     # Vm and command voltage go in the same subplot
     self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential')
     self._vm_axes.set_ylim(-20.0, 120.0)
     # Channel conductances go to the same subplot
     self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance')
     self._g_axes.set_ylim(0.0, 0.5)
     # Injection current for Vclamp/Iclamp go to the same subplot
     self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current')
     self._im_axes.set_ylim(-0.5, 0.5)
     # Channel currents go to the same subplot
     self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current')
     self._i_axes.set_ylim(-10, 10)
     for axis in self._plotFigure.axes:
         axis.set_autoscale_on(False)
     layout = QtGui.QVBoxLayout()
     layout.addWidget(self._plotCanvas)
     self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget)
     layout.addWidget(self._plotNavigator)
     self._plotWidget.setLayout(layout)

   def __init__(self, parent, corrmatrix):
     QFrame.__init__(self)
    
     self.setWindowTitle("Correlation Matrix")
     
     self.corrmatrix=[[]]
     self.rank=None
     self.rim=0.05
  
     self.parent=parent            # parent object/class
     self.fig=None
  
     # Create canvas for plotting
     self.fig = Figure((7, 7), dpi=100)
     self.canvas = FigureCanvas(self.fig)
     self.canvas.setParent(self)
     self.fig.subplots_adjust(left=self.rim, right=1.0-self.rim, top=1.0-self.rim, bottom=self.rim)  # set a small rim
     self.ax=self.fig.add_subplot(111)

     self.mpl_toolbar = NavigationToolbar(self.canvas, self)
     self.mpl_toolbar.show()
  
     self.setMinimumWidth(700)
     self.setMinimumHeight(700)
     self.corrmatrix=corrmatrix

     self.xLabel="Parameter index"
     self.yLabel="Parameter index"

     self.createWidgets()
     self.createLayouts()
     self.connectSignals()
     self.plot(self.corrmatrix)

 def buildUi(self):
     self.verticalLayout = QVBoxLayout(self)
     self.figure = Figure()
     self.canvas = Canvas(self.figure)	                # <-- figure required
     self.navigationToolbar = NavigationToolbar(self.canvas, self)
     self.verticalLayout.addWidget(self.canvas)
     self.verticalLayout.addWidget(self.navigationToolbar)

 def __init__(self, h5file = None):
     QtGui.QWidget.__init__(self)        
     # define a right side control panel
     gLay = QtGui.QGridLayout()
     row = 0
     
     if isinstance(h5file, tables.file.File):
         self.h5file = h5file
         
     elif isinstance(h5file, str):
         self.h5file = str(QtGui.QFileDialog.getOpenFileName(caption='select an h5 file',
                                                             filter='*.h5'))
         if self.h5file:
             self.h5file = tables.openFile(self.h5file, 'r')
     
     elif not h5file:
         self.loadH5FileBtn = QtGui.QPushButton('Load H5File')
         self.loadH5FileBtn.clicked.connect(self.loadH5FileProc)
         gLay.addWidget(self.loadH5FileBtn, row, 0, 1, 2)
         row += 1
         self.setWindowTitle('Spike Sorting Quality Explorer')
             
     self.FirstUnitCombo = QtGui.QComboBox()
     gLay.addWidget(self.FirstUnitCombo, row, 0, 1, 2)
     row += 1
     
     self.selectBtn = QtGui.QPushButton('Select None')
     self.selectBtn.clicked.connect(self.selectProc)
     self.selectBtn.setCheckable(True)
     gLay.addWidget(self.selectBtn, row, 0)
     
     self.plotXCorrBtn = QtGui.QPushButton('Plot xCorr')
     self.plotXCorrBtn.clicked.connect(self.plotXCorr)
     gLay.addWidget(self.plotXCorrBtn, row, 1)
     row += 1
     
     self.UnitsSelector = QtGui.QTableWidget(0, 1)
     self.UnitsSelector.verticalHeader().setVisible(False)
     self.UnitsSelector.horizontalHeader().setVisible(False)
     self.UnitsSelector.setColumnWidth(0, 200)
     gLay.addWidget(self.UnitsSelector, row, 0, 1, 2)
     row += 1
     
     mainLay = QtGui.QHBoxLayout(self)
     mainLay.addLayout(gLay)
     
     # define a left side figure
     vLay = QtGui.QVBoxLayout()
     self.mainFig = MplWidget(self)
     self.mainFig.figure.set_facecolor('k')
     self.ntb = NavToolbar(self.mainFig, self)
     self.ntb.setIconSize(QtCore.QSize(15, 15))
     vLay.addWidget(self.mainFig)
     vLay.addWidget(self.ntb)
 
     mainLay.addLayout(vLay)        
     
     self.show()
     
     self.UnitChecks = []

    def __init__(self, parent=None):
        super(Window, self).__init__(parent)
 
        self.figure = plt.figure()
        self.canvas = FigureCanvas(self.figure)
 
         
        self.toolbar = NavigationToolbar(self.canvas, self)
        self.toolbar.hide()
 
        # Just some button 
        self.button = QtGui.QPushButton('Plot')
        self.button.clicked.connect(self.plot)
 
        self.button1 = QtGui.QPushButton('Zoom')
        self.button1.clicked.connect(self.zoom)
         
        self.button2 = QtGui.QPushButton('Pan')
        self.button2.clicked.connect(self.pan)
         
        self.button3 = QtGui.QPushButton('Home')
        self.button3.clicked.connect(self.home)
 
 
        # set the layout
        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.toolbar)
        layout.addWidget(self.canvas)
        layout.addWidget(self.button)
        layout.addWidget(self.button1)
        layout.addWidget(self.button2)
        layout.addWidget(self.button3)
        self.setLayout(layout)