def __init__(self, items, tooltip):
items.insert(1, '')
QTreeWidgetItem.__init__(self, items)
self.__intColumn = 0
self.__tooltip = tooltip
self.__fileModified = False
self.setIcon(1, getIcon('findtooltip.png'))
def __init__(self, logInfo):
self.logInfo = logInfo
message = ""
if logInfo.message:
message = str(logInfo.message)
authorTooltip = ""
author = ""
if logInfo.author:
authorTooltip = str(logInfo.author)
author = authorTooltip.split("@", 1)[0]
revision = ""
if logInfo.revision:
if logInfo.revision.number:
revision = str(logInfo.revision.number)
date = ""
if logInfo.date:
date = timestampToString(logInfo.date)
QTreeWidgetItem.__init__(self,
["", "", revision, date, author, message])
self.setCheckState(SELECT_COL, Qt.Unchecked)
self.setToolTip(REVISION_COL, revision)
self.setToolTip(DATE_COL, date)
self.setToolTip(AUTHOR_COL, authorTooltip)
self.setToolTip(MESSAGE_COL, message)
def __init__(self, pluginManager, cdmPlugin, active, category):
self.plugin = cdmPlugin
self.active = active
self.category = category
name = self.plugin.getName()
ver = self.plugin.getVersion()
QTreeWidgetItem.__init__(self, ["", "", "", name, ver])
if not self.plugin.conflictType in [
pluginManager.NO_CONFLICT, pluginManager.USER_DISABLED
]:
self.setIcon(CONFLICT_COL, getIcon('pluginconflict.png'))
self.setToolTip(CONFLICT_COL, self.plugin.conflictMessage)
self.setToolTip(STATE_COL, "Enable / disable")
self.setToolTip(CONFLICT_COL, "Conflict")
if self.plugin.isUser():
self.setIcon(TYPE_COL, getIcon('pluginuser.png'))
self.setToolTip(TYPE_COL, "User plugin")
else:
self.setIcon(TYPE_COL, getIcon('pluginsystem.png'))
self.setToolTip(TYPE_COL, "System wide plugin")
self.setFlags(self.flags() | Qt.ItemIsUserCheckable)
if active:
self.setCheckState(STATE_COL, Qt.Checked)
else:
self.setCheckState(STATE_COL, Qt.Unchecked)
def __init__(self, items, isOutside, funcIDs):
QTreeWidgetItem.__init__(self, items)
self.__isOutside = isOutside
self.__funcIDs = funcIDs
# Set the first column icon
if isOutside:
self.setIcon(OUTSIDE_COL_INDEX, getIcon('nonprojectentry.png'))
self.setToolTip(OUTSIDE_COL_INDEX, 'Record of an outside function')
else:
self.setIcon(OUTSIDE_COL_INDEX, getIcon('empty.png'))
self.setToolTip(OUTSIDE_COL_INDEX, '')
# Set the function name tooltip
fileName = self.getFileName()
lineNumber = self.getLineNumber()
if fileName != "" and lineNumber != 0:
self.setToolTip(
NAME_COL_INDEX,
GlobalData().getFileLineDocstring(fileName, lineNumber))
# Sets the location/name columns
self.updateLocation(False)
self.setText(NAME_COL_INDEX, self.getFunctionName())
for column in [
CALLS_COL_INDEX, TOTALPERCALL_COL_INDEX, CUM_COL_INDEX,
CUMPERCALL_COL_INDEX, CALLERS_COL_INDEX, CALLEES_COL_INDEX
]:
self.setTextAlignment(column, Qt.AlignRight)
self.setTextAlignment(TOTAL_COL_INDEX, Qt.AlignLeft)
def __init__(self, parent, isGlobal, displayName, displayValue,
displayType):
self.__isGlobal = isGlobal
self.__value = displayValue
self.__type = displayType
self.__name, self.__varID = VariableItem.extractId(displayName)
# Decide about the display value
displayValue = getDisplayValue(displayValue)
# Decide about the tooltip
self.__tooltip = "Name: " + self.__name + "\n" + \
"Type: " + displayType + "\n" + \
"Value: "
tooltipDisplayValue = getTooltipValue(self.__value)
if '\r' in tooltipDisplayValue or '\n' in tooltipDisplayValue:
self.__tooltip += "\n" + tooltipDisplayValue
else:
self.__tooltip += tooltipDisplayValue
QTreeWidgetItem.__init__(self, parent,
[self.__name, displayValue, displayType])
self.populated = True
def __init__(self, parentItem, exceptionType, exceptionMessage,
stackTrace):
QTreeWidgetItem.__init__(self, parentItem)
self.__count = 1
self.__exceptionType = exceptionType
self.__exceptionMessage = exceptionMessage
if not exceptionMessage:
self.setText(0, str(exceptionType))
self.setToolTip(0, "Type: " + str(exceptionType))
else:
self.setText(0, str(exceptionType) + ", " +
getDisplayValue(exceptionMessage))
tooltip = "Type: " + str(exceptionType) + "\n" + "Message: "
tooltipMessage = getTooltipValue(exceptionMessage)
if '\r' in tooltipMessage or '\n' in tooltipMessage:
tooltip += "\n" + tooltipMessage
else:
tooltip += tooltipMessage
self.setToolTip(0, tooltip)
if stackTrace:
for entry in stackTrace:
fileName = entry[0]
lineNumber = entry[1]
funcName = entry[2]
funcArguments = entry[3]
StackFrameItem(self, fileName, lineNumber,
funcName, funcArguments)
def __init__(self, parentItem, fileName, lineNumber, funcName, funcArgs):
QTreeWidgetItem.__init__(self, parentItem)
self.__fileName = fileName
self.__lineNumber = lineNumber
self.__funcName = funcName
self.__funcArgs = funcArgs
self.setText(0, os.path.basename(fileName) + ":" + str(lineNumber))
self.setToolTip(0, fileName + ":" + str(lineNumber))
self.setText(1, funcName)
self.setToolTip(1, funcName)
self.setText(2, funcArgs)
self.setToolTip(2, funcArgs)
def __init__(self, fileName, lineNumber, funcName, funcArgs, frameNumber):
shortened = os.path.basename(fileName) + ":" + str(lineNumber)
self.__lineNumber = lineNumber
QTreeWidgetItem.__init__(self,
["", shortened, funcName, funcArgs, fileName])
self.__isCurrent = False
self.__frameNumber = frameNumber
tooltip = ['Location: ' + fileName + ':' + str(lineNumber)]
if funcName:
tooltip += ['Function: ' + funcName, 'Arguments: ' + funcArgs]
self.setToolTip(0, '\n'.join(tooltip))
def __createLayout(self, paths, ignoredPaths):
"""Creates the dialog layout"""
self.resize(640, 420)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Paths to commit part
vboxLayout.addWidget(QLabel("Paths (total: " +
str(len(paths)) + ")"))
self.__pathView = QTreeWidget()
self.__pathView.setAlternatingRowColors(True)
self.__pathView.setRootIsDecorated(False)
self.__pathView.setItemsExpandable(False)
self.__pathView.setSortingEnabled(True)
self.__pathView.setItemDelegate(NoOutlineHeightDelegate(4))
self.__pathView.setUniformRowHeights(True)
self.__pathHeader = QTreeWidgetItem(["", "Path", "Status", "Message"])
self.__pathView.setHeaderItem(self.__pathHeader)
self.__pathView.header().setSortIndicator(1, Qt.AscendingOrder)
vboxLayout.addWidget(self.__pathView)
# Paths to ignore part
vboxLayout.addWidget(QLabel("Ignored paths (total: " +
str(len(ignoredPaths)) + ")"))
self.__ignoredPathView = QTreeWidget()
self.__ignoredPathView.setAlternatingRowColors(True)
self.__ignoredPathView.setRootIsDecorated(False)
self.__ignoredPathView.setItemsExpandable(False)
self.__ignoredPathView.setSortingEnabled(True)
self.__ignoredPathView.setItemDelegate(NoOutlineHeightDelegate(4))
self.__ignoredPathView.setUniformRowHeights(True)
pathToIgnoreHeader = QTreeWidgetItem(["Path", "Status"])
self.__ignoredPathView.setHeaderItem(pathToIgnoreHeader)
self.__ignoredPathView.header().setSortIndicator(0, Qt.AscendingOrder)
vboxLayout.addWidget(self.__ignoredPathView)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok)
buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
buttonBox.accepted.connect(self.accept)
vboxLayout.addWidget(buttonBox)
def __createLayout(self, pathsToAdd):
"""Creates the dialog layout"""
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Paths to add part
vboxLayout.addWidget(
QLabel("Paths to add (total: " + str(len(pathsToAdd)) + ")"))
self.__pathToAddView = QTreeWidget()
self.__configTable(self.__pathToAddView)
self.__pathToAddHeader = QTreeWidgetItem(["", "Path"])
self.__pathToAddView.setHeaderItem(self.__pathToAddHeader)
self.__pathToAddView.header().setSortIndicator(PATH_COL,
Qt.AscendingOrder)
self.__pathToAddView.itemChanged.connect(self.__onAddPathChanged)
vboxLayout.addWidget(self.__pathToAddView)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setText("Add")
buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
buttonBox.accepted.connect(self.userAccept)
buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(buttonBox)
def __populate(self):
"""Populate the properties list"""
# Get the currently selected name
selectedName = None
selected = list(self.__propsView.selectedItems())
if selected:
selectedName = str(selected[0].text(0))
self.__propsView.clear()
properties = readProperties(self.__client, self.__path)
if properties:
for itemPath, itemProps in properties:
if self.__path == itemPath or \
self.__path == itemPath + os.path.sep:
for name, value in itemProps.iteritems():
name = str(name).strip()
value = str(value).strip()
newItem = QTreeWidgetItem([name, value])
self.__propsView.addTopLevelItem(newItem)
self.__resizePropsView()
self.__sortPropsView()
if selectedName:
index = 0
for index in range(0, self.__propsView.topLevelItemCount()):
item = self.__propsView.topLevelItem(index)
if selectedName == item.text(0):
item.setSelected(True)
def __onProjectChanged(self, what):
"""Triggered when a project is changed"""
if what != CodimensionProject.CompleteProject:
return
self.clear()
project = GlobalData().project
if project.isLoaded():
self.__ignored = list(project.exceptionFilters)
else:
self.__ignored = Settings()['ignoredExceptions']
for exceptionType in self.__ignored:
item = QTreeWidgetItem(self.exceptionsList)
item.setText(0, exceptionType)
self.__updateTitle()
def addExceptionFilter(self, excType):
"""Adds a new item into the ignored exceptions list"""
if excType == "":
return
if " " in excType:
return
if excType in self.__ignored:
return
item = QTreeWidgetItem(self.exceptionsList)
item.setText(0, excType)
project = GlobalData().project
if project.isLoaded():
project.addExceptionFilter(excType)
else:
Settings().addExceptionFilter(excType)
self.__ignored.append(excType)
self.__updateTitle()
def __updateDetails(self, item):
"""Updates the content of the details and the error boxes"""
self.__details.clear()
self.__errorsText.setText("")
if item is None:
return
self.__details.addTopLevelItem(
QTreeWidgetItem(["Author", item.plugin.getAuthor()]))
self.__details.addTopLevelItem(
QTreeWidgetItem(["Path",
os.path.normpath(item.plugin.getPath())]))
self.__details.addTopLevelItem(
QTreeWidgetItem(["Description",
item.plugin.getDescription()]))
self.__details.addTopLevelItem(
QTreeWidgetItem(["Web site", item.plugin.getWebsite()]))
copyright = item.plugin.getCopyright()
if copyright is not None:
if copyright.lower() != "unknown":
self.__details.addTopLevelItem(
QTreeWidgetItem(["Copyright", copyright]))
for name in item.plugin.getDetails():
value = item.plugin.getDetails()[name]
self.__details.addTopLevelItem(QTreeWidgetItem([name, value]))
self.__errorsText.setText(item.plugin.conflictMessage)
def data(self, column, role):
"""Provides the data for the requested role"""
if role == Qt.ToolTipRole:
return self.__tooltip
if role == Qt.DecorationRole:
if column == 0:
if not self.parent():
if self.__isGlobal:
fileName = 'globvar.png'
else:
fileName = 'locvar.png'
return getIcon(fileName)
return QTreeWidgetItem.data(self, column, role)
def addCallTrace(self, isCall, fromFile, fromLine, fromFunction, toFile,
toLine, toFunction):
"""Adds a record to the list"""
tooltip = 'Return\n'
icon = self.__retIcon
if isCall:
tooltip = 'Call\n'
icon = self.__callIcon
if self.projectLoaded:
project = GlobalData().project
fromFile = project.getRelativePath(fromFile)
toFile = project.getRelativePath(toFile)
parentItem = self
if self.__callStack:
parentItem = self.__callStack[-1]
fromItem = self.__entryFormat.format(fromFile, fromLine, fromFunction)
toItem = self.__entryFormat.format(toFile, toLine, toFunction)
item = QTreeWidgetItem(parentItem, ['', fromItem, toItem])
item.setIcon(0, icon)
item.setData(0, Qt.UserRole, isCall)
item.setExpanded(True)
tooltip += 'From: ' + fromItem + '\nTo: ' + toItem
item.setToolTip(1, tooltip)
item.setToolTip(2, tooltip)
if isCall:
self.__callStack.append(item)
else:
if self.__callStack:
self.__callStack.pop(-1)
self.count += 1
def __init__(self, navBar, parent):
QTreeWidget.__init__(self, parent)
self.__navBar = navBar
self.setAlternatingRowColors(True)
self.setRootIsDecorated(True)
self.setItemsExpandable(True)
self.setSortingEnabled(False)
self.setItemDelegate(NoOutlineHeightDelegate(4))
self.setUniformRowHeights(True)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setExpandsOnDoubleClick(False)
self.__headerItem = QTreeWidgetItem(['Node', 'Position / items'])
self.setHeaderItem(self.__headerItem)
self.itemSelectionChanged.connect(self.__selectionChanged)
self.itemActivated.connect(self.__activated)
def __init__(self, pathsToAdd, parent=None):
QDialog.__init__(self, parent)
self.addPaths = []
self.__createLayout(pathsToAdd)
self.setWindowTitle("SVN add")
# Fill the lists
for item in pathsToAdd:
newItem = QTreeWidgetItem(["", item])
newItem.setCheckState(CHECK_COL, Qt.Checked)
newItem.setToolTip(PATH_COL, item[0])
self.__pathToAddView.addTopLevelItem(newItem)
self.__resizeAddPaths()
self.__sortAddPaths()
self.__updateOKStatus()
def __createLayout(self):
"""Creates the dialog layout"""
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
hLayout = QHBoxLayout()
self.__propsView = QTreeWidget()
self.__propsView.setAlternatingRowColors(True)
self.__propsView.setRootIsDecorated(False)
self.__propsView.setItemsExpandable(False)
self.__propsView.setSortingEnabled(True)
self.__propsView.setItemDelegate(NoOutlineHeightDelegate(4))
self.__propsView.itemSelectionChanged.connect(
self.__propsSelectionChanged)
propsViewHeader = QTreeWidgetItem(["Property Name", "Property Value"])
self.__propsView.setHeaderItem(propsViewHeader)
self.__propsView.header().setSortIndicator(0, Qt.DescendingOrder)
hLayout.addWidget(self.__propsView)
self.__delButton = QToolButton()
self.__delButton.setText("Delete")
self.__delButton.setFocusPolicy(Qt.NoFocus)
self.__delButton.setEnabled(False)
self.__delButton.clicked.connect(self.__onDel)
hLayout.addWidget(self.__delButton, 0, Qt.AlignBottom)
vboxLayout.addLayout(hLayout)
# Set property part
setGroupbox = QGroupBox(self)
setGroupbox.setTitle("Set Property")
setLayout = QGridLayout(setGroupbox)
setLayout.addWidget(QLabel("Name"), 0, 0, Qt.AlignTop | Qt.AlignRight)
setLayout.addWidget(QLabel("Value"), 1, 0, Qt.AlignTop | Qt.AlignRight)
self.__nameEdit = QLineEdit()
self.__nameEdit.textChanged.connect(self.__nameChanged)
setLayout.addWidget(self.__nameEdit, 0, 1)
self.__valueEdit = QTextEdit()
self.__valueEdit.setAcceptRichText(False)
self.__valueEdit.textChanged.connect(self.__valueChanged)
metrics = QFontMetrics(self.__valueEdit.font())
rect = metrics.boundingRect("X")
self.__valueEdit.setFixedHeight(rect.height() * 4 + 5)
setLayout.addWidget(self.__valueEdit, 1, 1)
self.__setButton = QToolButton()
self.__setButton.setText("Set")
self.__setButton.setFocusPolicy(Qt.NoFocus)
self.__setButton.setEnabled(False)
self.__setButton.clicked.connect(self.__onSet)
setLayout.addWidget(self.__setButton, 1, 2,
Qt.AlignBottom | Qt.AlignHCenter)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
setGroupbox.sizePolicy().hasHeightForWidth())
setGroupbox.setSizePolicy(sizePolicy)
vboxLayout.addWidget(setGroupbox)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok)
buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
buttonBox.accepted.connect(self.close)
vboxLayout.addWidget(buttonBox)
def attachDummy(self):
"""Attach a dummy sub item to allow for lazy population"""
QTreeWidgetItem(self, ["DUMMY"])
def addNodeRecursive(self, node, prefix=None):
nodeName = node.__class__.__name__
if prefix is not None:
nodeName = prefix + nodeName
treeNode = QTreeWidgetItem([nodeName, self.__getNodePosition(node)])
if self.__parentStack[-1] is None:
self.addTopLevelItem(treeNode)
else:
self.__parentStack[-1].addChild(treeNode)
for fieldName in node._fields:
fieldValue = getattr(node, fieldName)
if isinstance(fieldValue, ast.AST):
if fieldValue._fields:
self.__parentStack.append(treeNode)
self.addNodeRecursive(fieldValue, fieldName + ': ')
self.__parentStack.pop(-1)
else:
treeNode.addChild(
QTreeWidgetItem(
[fieldName + ': ' + fieldValue.__class__.__name__,
self.__getNodePosition(fieldValue)]))
elif self.__isScalar(fieldValue):
treeNode.addChild(
QTreeWidgetItem([fieldName + ': ' + repr(fieldValue), '']))
elif isinstance(fieldValue, list):
listLength = len(fieldValue)
txt = str(listLength) + ' item'
if listLength != 1:
txt += 's'
listNode = QTreeWidgetItem([fieldName + ': [...]', txt])
treeNode.addChild(listNode)
self.expandItem(listNode)
self.__parentStack.append(listNode)
for index, listItem in enumerate(fieldValue):
prefix = '[' + str(index) + ']: '
if self.__isScalar(listItem):
treeNode.addChild(
QTreeWidgetItem([prefix + repr(listItem), '']))
else:
self.addNodeRecursive(listItem, prefix)
self.__parentStack.pop(-1)
else:
logging.error('AST node is not recognized. Skipping...')
self.expandItem(treeNode)
def __createLayout(self):
"""Creates the dialog layout"""
self.resize(640, 480)
self.setSizeGripEnabled(True)
layout = QVBoxLayout()
# Plugins list
self.__pluginsView = QTreeWidget()
self.__pluginsView.setAlternatingRowColors(True)
self.__pluginsView.setRootIsDecorated(False)
self.__pluginsView.setItemsExpandable(False)
self.__pluginsView.setSortingEnabled(True)
self.__pluginsView.setItemDelegate(NoOutlineHeightDelegate(4))
self.__pluginsView.setUniformRowHeights(True)
# Alert | system/user | Enable | Name | Version
self.__pluginsHeader = QTreeWidgetItem(
["", "", "", "Name", "Version", ""])
self.__pluginsView.setHeaderItem(self.__pluginsHeader)
self.__pluginsView.header().setSortIndicator(NAME_COL,
Qt.AscendingOrder)
self.__pluginsView.itemSelectionChanged.connect(
self.__pluginSelectionChanged)
self.__pluginsView.itemChanged.connect(self.__onItemChanged)
layout.addWidget(self.__pluginsView)
# Detailed information
detailsLabel = QLabel("Detailed information")
layout.addWidget(detailsLabel)
self.__details = QTreeWidget()
self.__details.setAlternatingRowColors(False)
self.__details.setRootIsDecorated(False)
self.__details.setItemsExpandable(False)
self.__details.setSortingEnabled(False)
self.__details.setItemDelegate(NoOutlineHeightDelegate(4))
self.__details.setUniformRowHeights(True)
detailsHeader = QTreeWidgetItem(["", ""])
self.__details.setHeaderItem(detailsHeader)
self.__details.setHeaderHidden(True)
metrics = QFontMetrics(self.__details.font())
rect = metrics.boundingRect("X")
self.__details.setFixedHeight(rect.height() * 6 + 5)
layout.addWidget(self.__details)
# Errors/warnings
errorsLabel = QLabel("Errors / warnings")
layout.addWidget(errorsLabel)
self.__errorsText = QTextEdit()
self.__errorsText.setReadOnly(True)
self.__errorsText.setAcceptRichText(False)
metrics = QFontMetrics(self.__errorsText.font())
rect = metrics.boundingRect("X")
self.__errorsText.setFixedHeight(rect.height() * 4 + 5)
layout.addWidget(self.__errorsText)
# Buttons box
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setDefault(True)
buttonBox.accepted.connect(self.close)
buttonBox.rejected.connect(self.close)
layout.addWidget(buttonBox)
self.setLayout(layout)
def __init__(self, tid, name, state):
QTreeWidgetItem.__init__(self, ["", name, state, str(tid)])
self.__isCurrent = False
self.__setTooltip()
def __init__(self, items, uuid):
QTreeWidgetItem.__init__(self, items)
self.uuid = uuid
def __createLayout(self):
"""Creates the dialog layout"""
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Revisions to compare
compareGroupbox = QGroupBox(self)
compareGroupbox.setTitle("Revisions to compare")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
compareGroupbox.sizePolicy().hasHeightForWidth())
compareGroupbox.setSizePolicy(sizePolicy)
revisionLayout = QHBoxLayout(compareGroupbox)
self.__lhsRevisionLabel = QLabel()
self.__lhsRevisionLabel.setFrameStyle(QFrame.StyledPanel)
self.__lhsResetButton = QToolButton()
self.__lhsResetButton.setIcon(
getIcon(pluginHomeDir + 'svnclearrev.png'))
self.__lhsResetButton.setFocusPolicy(Qt.NoFocus)
self.__lhsResetButton.setEnabled(False)
self.__lhsResetButton.setToolTip("Reset revision to compare")
self.__lhsResetButton.clicked.connect(self.__onLHSReset)
self.__rhsRevisionLabel = QLabel()
self.__rhsRevisionLabel.setFrameStyle(QFrame.StyledPanel)
self.__rhsResetButton = QToolButton()
self.__rhsResetButton.setIcon(
getIcon(pluginHomeDir + 'svnclearrev.png'))
self.__rhsResetButton.setFocusPolicy(Qt.NoFocus)
self.__rhsResetButton.setEnabled(False)
self.__rhsResetButton.setToolTip("Reset revision to compare")
self.__rhsResetButton.clicked.connect(self.__onRHSReset)
lhsLayout = QHBoxLayout()
lhsLayout.addWidget(self.__lhsRevisionLabel)
lhsLayout.addWidget(self.__lhsResetButton)
rhsLayout = QHBoxLayout()
rhsLayout.addWidget(self.__rhsRevisionLabel)
rhsLayout.addWidget(self.__rhsResetButton)
bothLayout = QVBoxLayout()
bothLayout.addLayout(lhsLayout)
bothLayout.addLayout(rhsLayout)
revisionLayout.addLayout(bothLayout)
self.__diffButton = QToolButton()
self.__diffButton.setText("Diff")
self.__diffButton.setFocusPolicy(Qt.NoFocus)
self.__diffButton.setEnabled(False)
self.__diffButton.clicked.connect(self.__onDiff)
revisionLayout.addWidget(self.__diffButton)
vboxLayout.addWidget(compareGroupbox)
# Log table
logHeaderFrame = QFrame()
logHeaderFrame.setFrameStyle(QFrame.StyledPanel)
logHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(logHeaderFrame)
logHeaderFrame.setFixedHeight(24)
logHeaderLayout = QHBoxLayout()
logHeaderLayout.setContentsMargins(3, 0, 0, 0)
logHeaderLayout.addWidget(QLabel("Subversion log of " + self.__path))
logHeaderFrame.setLayout(logHeaderLayout)
vboxLayout.addWidget(logHeaderFrame)
self.__logView = QTreeWidget()
self.__logView.setAlternatingRowColors(True)
self.__logView.setRootIsDecorated(False)
self.__logView.setItemsExpandable(False)
self.__logView.setSortingEnabled(True)
self.__logView.setItemDelegate(NoOutlineHeightDelegate(4))
self.__logViewHeader = QTreeWidgetItem(
["", "", "Revision", "Date", "Author", "Message"])
self.__logView.setHeaderItem(self.__logViewHeader)
self.__logView.header().setSortIndicator(REVISION_COL,
Qt.AscendingOrder)
self.__logView.itemChanged.connect(self.__onLogViewChanged)
vboxLayout.addWidget(self.__logView)
# Diff part
diffHeaderFrame = QFrame()
diffHeaderFrame.setFrameStyle(QFrame.StyledPanel)
diffHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(diffHeaderFrame)
diffHeaderFrame.setFixedHeight(24)
diffLabel = QLabel("Diff")
diffExpandingSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__showHideDiffButton = QToolButton()
self.__showHideDiffButton.setAutoRaise(True)
self.__showHideDiffButton.setIcon(getIcon('less.png'))
self.__showHideDiffButton.setFixedSize(20, 20)
self.__showHideDiffButton.setToolTip("Show diff")
self.__showHideDiffButton.setFocusPolicy(Qt.NoFocus)
self.__showHideDiffButton.clicked.connect(self.__onShowHideDiff)
diffLayout = QHBoxLayout()
diffLayout.setContentsMargins(3, 0, 0, 0)
diffLayout.addWidget(diffLabel)
diffLayout.addSpacerItem(diffExpandingSpacer)
diffLayout.addWidget(self.__showHideDiffButton)
diffHeaderFrame.setLayout(diffLayout)
self.__diffViewer = DiffTabWidget()
self.__diffViewer.setHTML(self.NODIFF)
self.__diffViewer.setVisible(False)
vboxLayout.addWidget(diffHeaderFrame)
vboxLayout.addWidget(self.__diffViewer)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok)
buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
buttonBox.accepted.connect(self.close)
vboxLayout.addWidget(buttonBox)
def __createLayout(self, action, title, files):
"""Creates the dialog layout"""
self.resize(400, 300)
self.setSizeGripEnabled(True)
# Top level layout
layout = QVBoxLayout(self)
# Pixmap and the message
topLayout = QHBoxLayout()
pixmap = QLabel()
pixmap.setPixmap(getPixmap('warning.png'))
topLayout.addWidget(pixmap)
hSpacer = QWidget()
hSpacer.setFixedSize(15, 15)
topLayout.addWidget(hSpacer)
message = QLabel("All the project files must be "
"saved before start debugging")
message.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
message.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
message.setWordWrap(True)
topLayout.addWidget(message)
layout.addLayout(topLayout)
vSpacer = QWidget()
vSpacer.setFixedSize(15, 15)
layout.addWidget(vSpacer)
layout.addWidget(QLabel(title + ":"))
filesList = QTreeWidget()
filesList.setRootIsDecorated(False)
filesList.setAlternatingRowColors(True)
filesList.setUniformRowHeights(True)
filesList.setItemsExpandable(False)
filesList.setItemDelegate(NoOutlineHeightDelegate(4))
filesList.setSelectionMode(QAbstractItemView.NoSelection)
filesList.setHeaderHidden(True)
for item in files:
fileName = item[0]
fileItem = QTreeWidgetItem([fileName])
fileType, icon, _ = getFileProperties(fileName)
fileItem.setIcon(0, icon)
if isPythonMime(fileType):
info = GlobalData().briefModinfoCache.get(fileName)
fileItem.setToolTip(
0, info.docstring.text if info.docstring else '')
filesList.addTopLevelItem(fileItem)
layout.addWidget(filesList)
# Buttons at the bottom
buttonBox = QDialogButtonBox()
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
continueButton = buttonBox.addButton(action,
QDialogButtonBox.ActionRole)
continueButton.setDefault(True)
layout.addWidget(buttonBox)
continueButton.clicked.connect(self.accept)
buttonBox.rejected.connect(self.close)
continueButton.setFocus()
def __createLayout(self, pathsToCommit, pathsToIgnore):
"""Creates the dialog layout"""
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Paths to commit part
commitHeaderFrame = QFrame()
commitHeaderFrame.setFrameStyle(QFrame.StyledPanel)
commitHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(commitHeaderFrame)
commitHeaderFrame.setFixedHeight(24)
expandingCommitSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__selectAllButton = QToolButton()
self.__selectAllButton.setAutoRaise(True)
self.__selectAllButton.setIcon(
getIcon(pluginHomeDir + 'svnselectall.png'))
self.__selectAllButton.setFixedSize(20, 20)
self.__selectAllButton.setToolTip("Select all")
self.__selectAllButton.setFocusPolicy(Qt.NoFocus)
self.__selectAllButton.clicked.connect(self.__onSelectAll)
commitHeaderLayout = QHBoxLayout()
commitHeaderLayout.setContentsMargins(3, 0, 0, 0)
commitHeaderLayout.addWidget(
QLabel("Paths to commit (total: " + str(len(pathsToCommit)) + ")"))
commitHeaderLayout.addSpacerItem(expandingCommitSpacer)
commitHeaderLayout.addWidget(self.__selectAllButton)
commitHeaderFrame.setLayout(commitHeaderLayout)
vboxLayout.addWidget(commitHeaderFrame)
self.__pathToCommitView = QTreeWidget()
self.__configTable(self.__pathToCommitView)
self.__pathToCommitHeader = QTreeWidgetItem(["", "Path", "Status", ""])
self.__pathToCommitView.setHeaderItem(self.__pathToCommitHeader)
self.__pathToCommitView.header().setSortIndicator(
PATH_COL, Qt.AscendingOrder)
self.__pathToCommitView.itemChanged.connect(self.__onCommitPathChanged)
vboxLayout.addWidget(self.__pathToCommitView)
# Paths to ignore part
headerFrame = QFrame()
headerFrame.setFrameStyle(QFrame.StyledPanel)
headerFrame.setAutoFillBackground(True)
self.__setLightPalette(headerFrame)
headerFrame.setFixedHeight(24)
ignoreLabel = QLabel("Ignored paths (total: " +
str(len(pathsToIgnore)) + ")")
expandingSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__showHideIgnoredButton = QToolButton()
self.__showHideIgnoredButton.setAutoRaise(True)
self.__showHideIgnoredButton.setIcon(getIcon('less.png'))
self.__showHideIgnoredButton.setFixedSize(20, 20)
self.__showHideIgnoredButton.setToolTip("Show ignored path list")
self.__showHideIgnoredButton.setFocusPolicy(Qt.NoFocus)
self.__showHideIgnoredButton.clicked.connect(self.__onShowHideIgnored)
ignoredHeaderLayout = QHBoxLayout()
ignoredHeaderLayout.setContentsMargins(3, 0, 0, 0)
ignoredHeaderLayout.addWidget(ignoreLabel)
ignoredHeaderLayout.addSpacerItem(expandingSpacer)
ignoredHeaderLayout.addWidget(self.__showHideIgnoredButton)
headerFrame.setLayout(ignoredHeaderLayout)
vboxLayout.addWidget(headerFrame)
self.__pathToIgnoreView = QTreeWidget()
self.__configTable(self.__pathToIgnoreView)
self.__pathToIgnoreView.setVisible(False)
pathToIgnoreHeader = QTreeWidgetItem(["Path", "Status"])
self.__pathToIgnoreView.setHeaderItem(pathToIgnoreHeader)
self.__pathToIgnoreView.header().setSortIndicator(0, Qt.AscendingOrder)
vboxLayout.addWidget(self.__pathToIgnoreView)
# Message part
vboxLayout.addWidget(QLabel("Message"))
self.__message = QTextEdit()
self.__message.setAcceptRichText(False)
metrics = QFontMetrics(self.__message.font())
rect = metrics.boundingRect("X")
self.__message.setFixedHeight(rect.height() * 4 + 5)
vboxLayout.addWidget(self.__message)
# Diff part
diffHeaderFrame = QFrame()
diffHeaderFrame.setFrameStyle(QFrame.StyledPanel)
diffHeaderFrame.setAutoFillBackground(True)
self.__setLightPalette(diffHeaderFrame)
diffHeaderFrame.setFixedHeight(24)
diffLabel = QLabel("Diff")
diffExpandingSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding)
self.__showHideDiffButton = QToolButton()
self.__showHideDiffButton.setAutoRaise(True)
self.__showHideDiffButton.setIcon(getIcon('less.png'))
self.__showHideDiffButton.setFixedSize(20, 20)
self.__showHideDiffButton.setToolTip("Show diff")
self.__showHideDiffButton.setFocusPolicy(Qt.NoFocus)
self.__showHideDiffButton.clicked.connect(self.__onShowHideDiff)
diffLayout = QHBoxLayout()
diffLayout.setContentsMargins(3, 0, 0, 0)
diffLayout.addWidget(diffLabel)
diffLayout.addSpacerItem(diffExpandingSpacer)
diffLayout.addWidget(self.__showHideDiffButton)
diffHeaderFrame.setLayout(diffLayout)
self.__diffViewer = DiffTabWidget()
self.__diffViewer.setHTML(self.NODIFF)
self.__diffViewer.setVisible(False)
vboxLayout.addWidget(diffHeaderFrame)
vboxLayout.addWidget(self.__diffViewer)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setText("Commit")
buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
buttonBox.accepted.connect(self.userAccept)
buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(buttonBox)
def __init__(self, plugin, pathsToCommit, pathsToIgnore, parent=None):
QDialog.__init__(self, parent)
self.__plugin = plugin
self.__createLayout(pathsToCommit, pathsToIgnore)
self.setWindowTitle("SVN commit")
# Fill the lists
for item in pathsToCommit:
newItem = QTreeWidgetItem(["", item[0], STATUS[item[1]]])
newItem.setCheckState(CHECK_COL, Qt.Checked)
newItem.setToolTip(PATH_COL, item[0])
newItem.setToolTip(STATUS_COL, STATUS[item[1]])
self.__pathToCommitView.addTopLevelItem(newItem)
diffButton = self.__createDiffButton()
diffButton.path = item[0]
diffButton.status = item[1]
if os.path.isdir(item[0]) or item[1] in [IND_REPLACED] \
or not isFileSearchable(item[0]):
diffButton.setEnabled(False)
diffButton.setToolTip("Diff is not available")
else:
diffButton.setEnabled(True)
diffButton.setToolTip("Click to see diff")
self.__pathToCommitView.setItemWidget(newItem, DIFF_COL,
diffButton)
self.__resizeCommitPaths()
self.__sortCommitPaths()
for item in pathsToIgnore:
newItem = QTreeWidgetItem([item[0], STATUS[item[1]]])
newItem.setToolTip(0, item[0])
newItem.setToolTip(1, STATUS[item[1]])
self.__pathToIgnoreView.addTopLevelItem(newItem)
self.__pathToIgnoreView.header().resizeSections(
QHeaderView.ResizeToContents)
self.__updateSelectAllStatus()
self.__updateOKStatus()
self.__message.setFocus()
def __populate(self, disassembly):
"""Populates disassembly"""
currentTopLevel = None
emptyCount = 0
for line in disassembly.splitlines():
if line.lower().startswith('disassembly of'):
line = line.strip()
emptyCount = 0
# Two options:
# Disassembly of <code object optToString at 0x7f63b7bf9920, file "...", line 45>:
# Disassembly of optToString:
if line.endswith(':'):
line = line[:-1]
if '<' in line and '>' in line:
# First option
begin = line.find('code object ') + len('code object ')
end = line.find(' at 0x')
name = line[begin:end]
begin = line.find(', line ') + len(', line ')
lineNo = line[begin:-1]
currentTopLevel = QTreeWidgetItem(
[name + ' (' + lineNo + ')'])
else:
# Second option
currentTopLevel = QTreeWidgetItem([line.split()[-1]])
self.__table.addTopLevelItem(currentTopLevel)
continue
if currentTopLevel is None:
continue
if not line.strip():
emptyCount += 1
continue
# Here: not an empty line and there is a parent
# so parse and add as a child
while emptyCount > 0:
currentTopLevel.addChild(QTreeWidgetItem([]))
emptyCount -= 1
# Line numbers may occupy more than 3 positions so the first
# part is taken with a good margin
parts = line.split()
if '>>' in parts:
jump = '>>'
parts.remove('>>')
else:
jump = ''
if '-->' in parts:
parts.remove('-->')
if parts[0].isdigit() and parts[1].isdigit():
# Line number and address
lineNo = parts.pop(0)
else:
# Only adderess
lineNo = ''
address = parts.pop(0)
instruction = parts.pop(0)
if parts:
argument = parts.pop(0)
else:
argument = ''
if parts:
interpretation = ' '.join(parts)
else:
interpretation = ''
currentTopLevel.addChild(
QTreeWidgetItem([
lineNo, jump, address, instruction, argument,
interpretation
]))
self.__table.expandItem(currentTopLevel)
def __init__(self, statusList, parent=None):
QDialog.__init__(self, parent)
# Split statuses
paths = []
ignoredPaths = []
for status in statusList:
if status[1] == IND_IGNORED:
ignoredPaths.append(status)
else:
paths.append(status)
self.__createLayout(paths, ignoredPaths)
self.setWindowTitle("SVN status")
# Fill the lists
for item in paths:
message = ""
if item[2]:
message = item[2]
newItem = QTreeWidgetItem(["", item[0],
STATUS[item[1]], message])
pixmap = getIndicatorPixmap(item[1])
if pixmap:
newItem.setIcon(0, QIcon(pixmap))
newItem.setToolTip(1, item[0])
newItem.setToolTip(2, STATUS[item[1]])
if message:
newItem.setToolTip(3, message)
self.__pathView.addTopLevelItem(newItem)
self.__pathView.header().resizeSections(QHeaderView.ResizeToContents)
self.__pathView.header().resizeSection(0, 20)
self.__pathView.header().setResizeMode(QHeaderView.Fixed)
for item in ignoredPaths:
newItem = QTreeWidgetItem([item[0], STATUS[item[1]]])
newItem.setToolTip(0, item[0])
newItem.setToolTip(1, STATUS[item[1]])
self.__ignoredPathView.addTopLevelItem(newItem)
self.__ignoredPathView.header().resizeSections(QHeaderView.ResizeToContents)
