364 lines
12 KiB
Python
364 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
from ..Qt import QtCore, QtGui
|
|
|
|
from .DockDrop import *
|
|
from ..widgets.VerticalLabel import VerticalLabel
|
|
from ..python2_3 import asUnicode
|
|
|
|
|
|
class Dock(QtGui.QWidget, DockDrop):
|
|
|
|
sigStretchChanged = QtCore.Signal()
|
|
sigClosed = QtCore.Signal(object)
|
|
|
|
def __init__(self, name, area=None, size=(10, 10), widget=None, hideTitle=False, autoOrientation=True, closable=False, fontSize="12px"):
|
|
QtGui.QWidget.__init__(self)
|
|
DockDrop.__init__(self)
|
|
self._container = None
|
|
self._name = name
|
|
self.area = area
|
|
self.label = DockLabel(name, self, closable, fontSize)
|
|
if closable:
|
|
self.label.sigCloseClicked.connect(self.close)
|
|
self.labelHidden = False
|
|
self.moveLabel = True ## If false, the dock is no longer allowed to move the label.
|
|
self.autoOrient = autoOrientation
|
|
self.orientation = 'horizontal'
|
|
#self.label.setAlignment(QtCore.Qt.AlignHCenter)
|
|
self.topLayout = QtGui.QGridLayout()
|
|
self.topLayout.setContentsMargins(0, 0, 0, 0)
|
|
self.topLayout.setSpacing(0)
|
|
self.setLayout(self.topLayout)
|
|
self.topLayout.addWidget(self.label, 0, 1)
|
|
self.widgetArea = QtGui.QWidget()
|
|
self.topLayout.addWidget(self.widgetArea, 1, 1)
|
|
self.layout = QtGui.QGridLayout()
|
|
self.layout.setContentsMargins(0, 0, 0, 0)
|
|
self.layout.setSpacing(0)
|
|
self.widgetArea.setLayout(self.layout)
|
|
self.widgetArea.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
|
|
self.widgets = []
|
|
self._container = None
|
|
self.currentRow = 0
|
|
#self.titlePos = 'top'
|
|
self.raiseOverlay()
|
|
self.hStyle = """
|
|
Dock > QWidget {
|
|
border: 1px solid #000;
|
|
border-radius: 5px;
|
|
border-top-left-radius: 0px;
|
|
border-top-right-radius: 0px;
|
|
border-top-width: 0px;
|
|
}"""
|
|
self.vStyle = """
|
|
Dock > QWidget {
|
|
border: 1px solid #000;
|
|
border-radius: 5px;
|
|
border-top-left-radius: 0px;
|
|
border-bottom-left-radius: 0px;
|
|
border-left-width: 0px;
|
|
}"""
|
|
self.nStyle = """
|
|
Dock > QWidget {
|
|
border: 1px solid #000;
|
|
border-radius: 5px;
|
|
}"""
|
|
self.dragStyle = """
|
|
Dock > QWidget {
|
|
border: 4px solid #00F;
|
|
border-radius: 5px;
|
|
}"""
|
|
self.setAutoFillBackground(False)
|
|
self.widgetArea.setStyleSheet(self.hStyle)
|
|
|
|
self.setStretch(*size)
|
|
|
|
if widget is not None:
|
|
self.addWidget(widget)
|
|
|
|
if hideTitle:
|
|
self.hideTitleBar()
|
|
|
|
def implements(self, name=None):
|
|
if name is None:
|
|
return ['dock']
|
|
else:
|
|
return name == 'dock'
|
|
|
|
def setStretch(self, x=None, y=None):
|
|
"""
|
|
Set the 'target' size for this Dock.
|
|
The actual size will be determined by comparing this Dock's
|
|
stretch value to the rest of the docks it shares space with.
|
|
"""
|
|
if x is None:
|
|
x = 0
|
|
if y is None:
|
|
y = 0
|
|
self._stretch = (x, y)
|
|
self.sigStretchChanged.emit()
|
|
|
|
def stretch(self):
|
|
return self._stretch
|
|
|
|
def hideTitleBar(self):
|
|
"""
|
|
Hide the title bar for this Dock.
|
|
This will prevent the Dock being moved by the user.
|
|
"""
|
|
self.label.hide()
|
|
self.labelHidden = True
|
|
if 'center' in self.allowedAreas:
|
|
self.allowedAreas.remove('center')
|
|
self.updateStyle()
|
|
|
|
def showTitleBar(self):
|
|
"""
|
|
Show the title bar for this Dock.
|
|
"""
|
|
self.label.show()
|
|
self.labelHidden = False
|
|
self.allowedAreas.add('center')
|
|
self.updateStyle()
|
|
|
|
def title(self):
|
|
"""
|
|
Gets the text displayed in the title bar for this dock.
|
|
"""
|
|
return asUnicode(self.label.text())
|
|
|
|
def setTitle(self, text):
|
|
"""
|
|
Sets the text displayed in title bar for this Dock.
|
|
"""
|
|
self.label.setText(text)
|
|
|
|
def setOrientation(self, o='auto', force=False):
|
|
"""
|
|
Sets the orientation of the title bar for this Dock.
|
|
Must be one of 'auto', 'horizontal', or 'vertical'.
|
|
By default ('auto'), the orientation is determined
|
|
based on the aspect ratio of the Dock.
|
|
"""
|
|
# setOrientation may be called before the container is set in some cases
|
|
# (via resizeEvent), so there's no need to do anything here until called
|
|
# again by containerChanged
|
|
if self.container() is None:
|
|
return
|
|
|
|
if o == 'auto' and self.autoOrient:
|
|
if self.container().type() == 'tab':
|
|
o = 'horizontal'
|
|
elif self.width() > self.height()*1.5:
|
|
o = 'vertical'
|
|
else:
|
|
o = 'horizontal'
|
|
if force or self.orientation != o:
|
|
self.orientation = o
|
|
self.label.setOrientation(o)
|
|
self.updateStyle()
|
|
|
|
def updateStyle(self):
|
|
## updates orientation and appearance of title bar
|
|
if self.labelHidden:
|
|
self.widgetArea.setStyleSheet(self.nStyle)
|
|
elif self.orientation == 'vertical':
|
|
self.label.setOrientation('vertical')
|
|
if self.moveLabel:
|
|
self.topLayout.addWidget(self.label, 1, 0)
|
|
self.widgetArea.setStyleSheet(self.vStyle)
|
|
else:
|
|
self.label.setOrientation('horizontal')
|
|
if self.moveLabel:
|
|
self.topLayout.addWidget(self.label, 0, 1)
|
|
self.widgetArea.setStyleSheet(self.hStyle)
|
|
|
|
def resizeEvent(self, ev):
|
|
self.setOrientation()
|
|
self.resizeOverlay(self.size())
|
|
|
|
def name(self):
|
|
return self._name
|
|
|
|
def addWidget(self, widget, row=None, col=0, rowspan=1, colspan=1):
|
|
"""
|
|
Add a new widget to the interior of this Dock.
|
|
Each Dock uses a QGridLayout to arrange widgets within.
|
|
"""
|
|
if row is None:
|
|
row = self.currentRow
|
|
self.currentRow = max(row+1, self.currentRow)
|
|
self.widgets.append(widget)
|
|
self.layout.addWidget(widget, row, col, rowspan, colspan)
|
|
self.raiseOverlay()
|
|
|
|
def startDrag(self):
|
|
self.drag = QtGui.QDrag(self)
|
|
mime = QtCore.QMimeData()
|
|
self.drag.setMimeData(mime)
|
|
self.widgetArea.setStyleSheet(self.dragStyle)
|
|
self.update()
|
|
action = self.drag.exec_()
|
|
self.updateStyle()
|
|
|
|
def float(self):
|
|
self.area.floatDock(self)
|
|
|
|
def container(self):
|
|
return self._container
|
|
|
|
def containerChanged(self, c):
|
|
if self._container is not None:
|
|
# ask old container to close itself if it is no longer needed
|
|
self._container.apoptose()
|
|
self._container = c
|
|
if c is None:
|
|
self.area = None
|
|
else:
|
|
self.area = c.area
|
|
if c.type() != 'tab':
|
|
self.moveLabel = True
|
|
self.label.setDim(False)
|
|
else:
|
|
self.moveLabel = False
|
|
|
|
self.setOrientation(force=True)
|
|
|
|
def raiseDock(self):
|
|
"""If this Dock is stacked underneath others, raise it to the top."""
|
|
self.container().raiseDock(self)
|
|
|
|
def close(self):
|
|
"""Remove this dock from the DockArea it lives inside."""
|
|
self.setParent(None)
|
|
QtGui.QLabel.close(self.label)
|
|
self.label.setParent(None)
|
|
self._container.apoptose()
|
|
self._container = None
|
|
self.sigClosed.emit(self)
|
|
|
|
def __repr__(self):
|
|
return "<Dock %s %s>" % (self.name(), self.stretch())
|
|
|
|
## PySide bug: We need to explicitly redefine these methods
|
|
## or else drag/drop events will not be delivered.
|
|
def dragEnterEvent(self, *args):
|
|
DockDrop.dragEnterEvent(self, *args)
|
|
|
|
def dragMoveEvent(self, *args):
|
|
DockDrop.dragMoveEvent(self, *args)
|
|
|
|
def dragLeaveEvent(self, *args):
|
|
DockDrop.dragLeaveEvent(self, *args)
|
|
|
|
def dropEvent(self, *args):
|
|
DockDrop.dropEvent(self, *args)
|
|
|
|
|
|
class DockLabel(VerticalLabel):
|
|
|
|
sigClicked = QtCore.Signal(object, object)
|
|
sigCloseClicked = QtCore.Signal()
|
|
|
|
def __init__(self, text, dock, showCloseButton, fontSize):
|
|
self.dim = False
|
|
self.fixedWidth = False
|
|
self.fontSize = fontSize
|
|
VerticalLabel.__init__(self, text, orientation='horizontal', forceWidth=False)
|
|
self.setAlignment(QtCore.Qt.AlignTop|QtCore.Qt.AlignHCenter)
|
|
self.dock = dock
|
|
self.updateStyle()
|
|
self.setAutoFillBackground(False)
|
|
self.mouseMoved = False
|
|
|
|
self.closeButton = None
|
|
if showCloseButton:
|
|
self.closeButton = QtGui.QToolButton(self)
|
|
self.closeButton.clicked.connect(self.sigCloseClicked)
|
|
self.closeButton.setIcon(QtGui.QApplication.style().standardIcon(QtGui.QStyle.SP_TitleBarCloseButton))
|
|
|
|
def updateStyle(self):
|
|
r = '3px'
|
|
if self.dim:
|
|
fg = '#aaa'
|
|
bg = '#44a'
|
|
border = '#339'
|
|
else:
|
|
fg = '#fff'
|
|
bg = '#66c'
|
|
border = '#55B'
|
|
|
|
if self.orientation == 'vertical':
|
|
self.vStyle = """DockLabel {
|
|
background-color : %s;
|
|
color : %s;
|
|
border-top-right-radius: 0px;
|
|
border-top-left-radius: %s;
|
|
border-bottom-right-radius: 0px;
|
|
border-bottom-left-radius: %s;
|
|
border-width: 0px;
|
|
border-right: 2px solid %s;
|
|
padding-top: 3px;
|
|
padding-bottom: 3px;
|
|
font-size: %s;
|
|
}""" % (bg, fg, r, r, border, self.fontSize)
|
|
self.setStyleSheet(self.vStyle)
|
|
else:
|
|
self.hStyle = """DockLabel {
|
|
background-color : %s;
|
|
color : %s;
|
|
border-top-right-radius: %s;
|
|
border-top-left-radius: %s;
|
|
border-bottom-right-radius: 0px;
|
|
border-bottom-left-radius: 0px;
|
|
border-width: 0px;
|
|
border-bottom: 2px solid %s;
|
|
padding-left: 3px;
|
|
padding-right: 3px;
|
|
font-size: %s;
|
|
}""" % (bg, fg, r, r, border, self.fontSize)
|
|
self.setStyleSheet(self.hStyle)
|
|
|
|
def setDim(self, d):
|
|
if self.dim != d:
|
|
self.dim = d
|
|
self.updateStyle()
|
|
|
|
def setOrientation(self, o):
|
|
VerticalLabel.setOrientation(self, o)
|
|
self.updateStyle()
|
|
|
|
def mousePressEvent(self, ev):
|
|
self.pressPos = ev.localPos()
|
|
self.mouseMoved = False
|
|
ev.accept()
|
|
|
|
def mouseMoveEvent(self, ev):
|
|
if not self.mouseMoved:
|
|
self.mouseMoved = (ev.localPos() - self.pressPos).manhattanLength() > QtGui.QApplication.startDragDistance()
|
|
|
|
if self.mouseMoved and ev.buttons() == QtCore.Qt.LeftButton:
|
|
self.dock.startDrag()
|
|
ev.accept()
|
|
|
|
def mouseReleaseEvent(self, ev):
|
|
ev.accept()
|
|
if not self.mouseMoved:
|
|
self.sigClicked.emit(self, ev)
|
|
|
|
def mouseDoubleClickEvent(self, ev):
|
|
if ev.button() == QtCore.Qt.LeftButton:
|
|
self.dock.float()
|
|
|
|
def resizeEvent (self, ev):
|
|
if self.closeButton:
|
|
if self.orientation == 'vertical':
|
|
size = ev.size().width()
|
|
pos = QtCore.QPoint(0, 0)
|
|
else:
|
|
size = ev.size().height()
|
|
pos = QtCore.QPoint(ev.size().width() - size, 0)
|
|
self.closeButton.setFixedSize(QtCore.QSize(size, size))
|
|
self.closeButton.move(pos)
|
|
super(DockLabel,self).resizeEvent(ev)
|