def __lt__(self, other):
# make sure we're comparing apples to apples
if not isinstance(other, QtGui.QTreeWidgetItem):
return 0
tree = self.treeWidget()
if not tree:
return 0
col = tree.sortColumn()
# compare sorting data
mdata = unwrapVariant(self.data(col, self.SortRole))
odata = unwrapVariant(other.data(col, self.SortRole))
# compare editing data
if mdata is None or odata is None:
mdata = unwrapVariant(self.data(col, QtCore.Qt.EditRole))
odata = unwrapVariant(other.data(col, QtCore.Qt.EditRole))
if type(mdata) == type(odata) and not type(mdata) in (str, unicode):
return mdata < odata
# compare display data by natural sorting mechanisms on a string
mdata = nativestring(self.text(col))
odata = nativestring(other.text(col))
return projex.sorting.natural(mdata, odata) == -1
def setEditorData( self, editor, value ):
"""
Sets the value for the given editor to the inputed value.
:param editor | <QWidget>
value | <variant>
"""
# set the data for a multitagedit
if ( isinstance(editor, XMultiTagEdit) ):
if ( not isinstance(value, list) ):
value = [nativestring(value)]
else:
value = map(nativestring, value)
editor.setTags(value)
editor.setCurrentItem(editor.createItem())
# set the data for a combobox
elif ( isinstance(editor, QComboBox) ):
i = editor.findText(nativestring(value))
editor.setCurrentIndex(i)
editor.lineEdit().selectAll()
# set the data for a line edit
elif ( isinstance(editor, QLineEdit) ):
editor.setText(nativestring(value))
editor.selectAll()
def exportTree(self, tree, filename):
"""
Exports the inputed tree object to the given excel file.
:param tree | <QTreeWidget>
filename | <str>
:return <bool>
"""
book = xlwt.Workbook()
# determine the title for the sheet to export
title = nativestring(tree.windowTitle())
if not title:
title = nativestring(tree.objectName())
if not title:
title = 'Sheet 1'
sheet = book.add_sheet(title)
# determine visible columns to export
cols = [c for c in range(tree.columnCount()) \
if not tree.isColumnHidden(c)]
# export the column headers
hitem = tree.headerItem()
for c, col in enumerate(cols):
sheet.write(0, c, nativestring(hitem.text(col)))
self._currrow = 1
for i in range(tree.topLevelItemCount()):
self.exportTreeItem(sheet, cols, tree.topLevelItem(i))
book.save(filename)
return True
def push(self, url, title=''):
"""
Pushes the url into the history stack at the current index.
:param url | <str>
:return <bool> | changed
"""
# ignore refreshes of the top level
if self.currentUrl() == url or self._blockStack:
return False
self._blockStack = True
self._stack = self._stack[:self._index+1]
self._stack.append((nativestring(url), nativestring(title)))
over = len(self._stack) - self.maximum()
if over > 0:
self._stack = self._stack[over:]
self._index = len(self._stack) - 1
self.canGoBackChanged.emit(self.canGoBack())
self.canGoForwardChanged.emit(self.canGoForward())
self._blockStack = False
return True
def recordSet( self ):
"""
Returns the record set that is associated with this widget.
:return <orb.RecordSet> || None
"""
if ( not self.table() ):
return None
recordSet = RecordSet(self.table())
recordSet.setQuery(self.query())
# set the grouping options
grouping = nativestring(self.uiGroupingTXT.text()).split(',')
while ( '' in grouping ):
grouping.remove('')
recordSet.setGroupBy( grouping )
# set the sorting options
sorting = nativestring(self.uiSortingTXT.text()).split(',')
while ( '' in sorting ):
sorting.remove('')
recordSet.setOrder([i.split('|') for i in sorting])
# set the paged options
recordSet.setPaged(self.uiPagedCHK.isChecked())
recordSet.setPageSize(self.uiPagedSPN.value())
return recordSet
def titleForFilepath( url ):
"""
Returns a gui title for this url.
:return <str>
"""
url = nativestring(url)
if url in XdkEntryItem.TITLE_MAP:
return XdkEntryItem.TITLE_MAP.get(url)
url = nativestring(url).replace('\\', '/')
basename = os.path.basename(url)
title = os.path.splitext(basename)[0]
if title == 'index':
title = url.split('/')[-2]
if title.endswith('-allmembers'):
title = 'List of All Members for %s' % title.split('-')[-2]
elif title.endswith('-source'):
title = 'Source Code for %s' % title.split('-')[-2]
elif len(nativestring(url).split('/')) <= 2 and title in TITLE_MAP:
title = TITLE_MAP[title]
elif not 'api/' in url:
title = projex.text.pretty(title)
return title
def importProfile(self, filename=''):
"""
Exports the current profile to a file.
:param filename | <str>
"""
if not (filename and isinstance(filename, basestring)):
filename = QtGui.QFileDialog.getOpenFileName(self,
'Import Layout from...',
QtCore.QDir.currentPath(),
'XView (*.xview)')
if type(filename) == tuple:
filename = nativestring(filename[0])
filename = nativestring(filename)
if not filename:
return
if not filename.endswith('.xview'):
filename += '.xview'
profile = XViewProfile.load(filename)
if not profile:
return
profile.restore(self)
def calculateRange(self, values):
"""
Calculates the range of values for this axis based on the dataset
value amount.
:param values | [<variant>, ..]
"""
vals = filter(lambda x: x is not None, values)
try:
min_val = min(min(vals), 0)
except ValueError:
min_val = 0
try:
max_val = max(max(vals), 0)
except ValueError:
max_val = 10
ndigits = max(len(nativestring(abs(int(min_val)))), len(nativestring(abs(int(max_val)))))
rounding = 10 ** (ndigits - 1)
self.setRoundTo(rounding)
self.setMinimum(self.rounded(min_val, rounding))
self.setMaximum(self.rounded(max_val, rounding))
self.reset()
def setFilterData(self, key, value):
"""
Sets the filtering information for the given key to the inputed value.
:param key | <str>
value | <str>
"""
self._filterData[nativestring(key)] = nativestring(value)
def keyColor( self, key ):
"""
Returns a color for the inputed key (used in pie charts).
:param key | <str>
:return <QColor>
"""
self._keyColors.setdefault(nativestring(key), self.color())
return self._keyColors[nativestring(key)]
def save(self):
"""
Saves the state for this item to the scaffold.
"""
enabled = self.checkState(0) == QtCore.Qt.Checked
self._element.set('name', nativestring(self.text(0)))
self._element.set('enabled', nativestring(enabled))
for child in self.children():
child.save()
def storeValue(self, xelem, value):
"""
Stores the value for the inptued instance to the given xml element.
:param xelem | <xml.etree.Element>
value | <variant>
"""
typ = type(value)
if typ == QtGui.QColor:
xelem.set('type', 'color')
xelem.text = nativestring(value.name())
elif typ == QtCore.QPoint:
xelem.set('type', 'point')
xelem.text = '{0},{1}'.format(value.x(), value.y())
elif typ == QtCore.QPointF:
xelem.set('type', 'pointf')
xelem.text = '{0},{1}'.format(value.x(), value.y())
elif typ == QtCore.QRect:
xelem.set('type', 'rect')
xelem.text = '{0},{1},{2},{3}'.format(value.x(),
value.y(),
value.width(),
value.height())
elif typ == QtCore.QRectF:
xelem.set('type', 'rectf')
xelem.text = '{0},{1},{2},{3}'.format(value.x(),
value.y(),
value.width(),
value.height())
elif typ == QtCore.QByteArray:
xelem.set('type', 'bytea')
xelem.text = cPickle.dumps(nativestring(value))
elif typ == ElementTree.Element:
xelem.set('type', 'xml')
xelem.append(value)
elif typ in (list, tuple, dict):
xelem.set('type', 'pickle')
xelem.text = cPickle.dumps(value)
else:
if not typ in (str, unicode):
value_text = nativestring(value)
else:
value_text = value
xelem.set('type', typ.__name__)
xelem.text = value_text
def __init__(self, xdk_filename):
# create the new XdkItem
super(XdkItem, self).__init__(None, xdk_filename)
# creates the new XdkItem
basename = os.path.basename(nativestring(xdk_filename))
name = os.path.splitext(basename)[0]
temppath = nativestring(QDir.tempPath())
temp_path = os.path.join(temppath, 'xdk/%s' % name)
# define custom properties
self._tempFilepath = temp_path
self._searchurls = {}
# set the options
self.setChildIndicatorPolicy(self.ShowIndicator)
self.setIcon(0, QIcon(projexui.resources.find('img/sdk.png')))
toc_file = os.path.join(temp_path, 'toc.xml')
toc_xml = None
if toc_file:
try:
toc_xml = ElementTree.parse(toc_file).getroot()[0]
except:
pass
if toc_xml is not None:
self._url = 'file:///%s/index.html' % temp_path.strip('/')
self.setText(0, toc_xml.get('title', self.text(0)))
self.loadFromXml(toc_xml, temp_path)
else:
# load the url information for this entry
for name in sorted(os.listdir(temp_path)):
# ignore 'hidden' folders
if name.startswith('_') and not name.startswith('__'):
continue
# ignore special cases (only want modules for this)
if '-' in name or name == 'toc.xml':
continue
# use the index or __init__ information
if name == '__init__.html':
self._url = 'file:///%s/%s' % (temp_path, name)
continue
elif name == 'index.html':
self._url = 'file:///%s/%s' % (temp_path, name)
# otherwise, load a childitem
filepath = os.path.join(temp_path, name)
folder = os.path.isdir(filepath)
XdkEntryItem(self, filepath, folder=folder)
def setHint(self, hint):
"""
Sets the hint for this filepath.
:param hint | <str>
"""
if self.normalizePath():
filepath = os.path.normpath(nativestring(hint))
else:
filepath = os.path.normpath(nativestring(hint)).replace('\\', '/')
self._filepathEdit.setHint(hint)
def dictionary(self):
"""
Returns a dictionary of the key/value pairing for the items in
this widget.
:return {<str> key: <str> value, ..}
"""
output = {}
for i in range(self.topLevelItemCount() - 1):
item = self.topLevelItem(i)
output[nativestring(item.text(1))] = nativestring(item.text(2))
return output
def setDragData(self, format, value):
"""
Sets the drag information that is associated with this tree
widget item for the given format.
:param format | <str>
value | <variant>
"""
if value is None:
self._dragData.pop(nativestring(format), None)
else:
self._dragData[nativestring(format)] = value
def edit( parent, template, actions = None ):
"""
Prompts the user to edit the menu template with the given actions. \
If no actions are supplied, then the actions from the parent will \
be used.
:param parent | <QWidget>
template | <str>
actions | {<str> name: <QAction>, .. } || None
:return (<str> template, <bool> accepted)
"""
# collect the potential actions from the widget
if ( actions is None ):
actions = {}
for action in parent.actions():
key = nativestring(action.objectName())
if ( not key ):
key = nativestring(action.text()).replace('&', '')
if ( key ):
actions[key] = action
if ( not actions ):
return ('', False)
dlg = QDialog(parent)
dlg.setWindowTitle('Edit Menu')
widget = XMenuTemplateWidget(dlg)
widget.setActions(actions)
widget.setMenuTemplate(template)
widget.layout().setContentsMargins(0, 0, 0, 0)
opts = QDialogButtonBox.Save | QDialogButtonBox.Cancel
btns = QDialogButtonBox(opts, Qt.Horizontal, dlg)
btns.accepted.connect( dlg.accept )
btns.rejected.connect( dlg.reject )
layout = QVBoxLayout()
layout.addWidget(widget)
layout.addWidget(btns)
dlg.setLayout(layout)
dlg.adjustSize()
dlg.resize(650, 400)
if ( dlg.exec_() ):
return (widget.menuTemplate(), True)
return ('', False)
def showWizards( self ):
"""
Show the wizards widget for the currently selected plugin.
"""
self.uiWizardTABLE.clear()
item = self.uiPluginTREE.currentItem()
if ( not (item and item.parent()) ):
plugins = []
else:
wlang = nativestring(item.parent().text(0))
wgrp = nativestring(item.text(0))
plugins = self.plugins(wlang, wgrp)
if ( not plugins ):
self.uiWizardTABLE.setEnabled(False)
self.uiDescriptionTXT.setEnabled(False)
return
self.uiWizardTABLE.setEnabled(True)
self.uiDescriptionTXT.setEnabled(True)
# determine the number of columns
colcount = len(plugins) / 2
if ( len(plugins) % 2 ):
colcount += 1
self.uiWizardTABLE.setRowCount(2)
self.uiWizardTABLE.setColumnCount( colcount )
header = self.uiWizardTABLE.verticalHeader()
header.setResizeMode(0, header.Stretch)
header.setResizeMode(1, header.Stretch)
header.setMinimumSectionSize(64)
header.hide()
header = self.uiWizardTABLE.horizontalHeader()
header.setMinimumSectionSize(64)
header.hide()
col = -1
row = 1
for plugin in plugins:
if ( row ):
col += 1
row = int(not row)
widget = PluginWidget(self, plugin)
self.uiWizardTABLE.setItem(row, col, QTableWidgetItem())
self.uiWizardTABLE.setCellWidget(row, col, widget)
def handleButtonClick( self, button ):
"""
Handle the event when a user clicks on one of the part buttons.
:param button | <QToolButton>
"""
path = button.property('path')
is_completer = button.property('is_completer')
# popup a completion menu
if ( unwrapVariant(is_completer) ):
model = self.navigationModel()
if ( not model ):
return
sep = self.separator()
path = nativestring(unwrapVariant(path))
item = model.itemByPath(path, includeRoot = True)
if ( not item ):
return
curr_path = nativestring(self.text()).strip(self.separator())
curr_path = curr_path.replace(path, '').strip(self.separator())
child_name = ''
if ( curr_path ):
child_name = curr_path.split(self.separator())[0]
index = model.indexFromItem(item)
self._completerTree.move(QCursor.pos())
self._completerTree.setRootIndex(index)
self._completerTree.verticalScrollBar().setValue(0)
if ( child_name ):
child_item = None
for i in range(item.rowCount()):
child = item.child(i)
if ( child.text() == child_name ):
child_item = child
break
if ( child_item ):
child_index = model.indexFromItem(child_item)
self._completerTree.setCurrentIndex(child_index)
self._completerTree.scrollTo(child_index)
self._completerTree.show()
self._completerTree.setUpdatesEnabled(True)
else:
self.setText(unwrapVariant(path))
def columns( self ):
"""
Returns the list of column names for this table widget's columns.
:return [<str>, ..]
"""
output = []
for c in range(self.columnCount()):
hitem = self.horizontalHeaderItem(c)
text = nativestring(hitem.text())
if ( not text ):
text = nativestring(hitem.toolTip())
output.append(text)
return output
def dispatch(location='Central'):
"""
Returns the instance of the global view dispatching system. All views \
will route their signals through the central hub so no single view \
necessarily depends on another.
:return <XViewDispatch>
"""
dispatch = XView._dispatch.get(nativestring(location))
if not dispatch:
dispatch = XViewDispatch(QApplication.instance())
XView._dispatch[nativestring(location)] = dispatch
return dispatch
def filterItems(self,
terms,
caseSensitive=False):
"""
Filters the items in this tree based on the inputed text.
:param terms | <str> || {<str> datatype: [<str> opt, ..]}
caseSensitive | <bool>
"""
# create a dictionary of options
if type(terms) != dict:
terms = {'*': nativestring(terms)}
# validate the "all search"
if '*' in terms and type(terms['*']) != list:
sterms = nativestring(terms['*'])
if not sterms.strip():
terms.pop('*')
else:
dtype_matches = DATATYPE_FILTER_EXPR.findall(sterms)
# generate the filter for each data type
for match, dtype, values in dtype_matches:
sterms = sterms.replace(match, '')
terms.setdefault(dtype, [])
terms[dtype] += values.split(',')
keywords = sterms.replace(',', '').split()
while '' in keywords:
keywords.remove('')
terms['*'] = keywords
# filter out any data types that are not being searched
filtered_dtypes = self.filteredDataTypes()
filter_terms = {}
for dtype, keywords in terms.items():
if dtype != '*' and not dtype in filtered_dtypes:
continue
if not caseSensitive:
keywords = [nativestring(keyword).lower() for keyword in keywords]
else:
keywords = map(nativestring, keywords)
filter_terms[dtype] = keywords
self.__filterItems(filter_terms, caseSensitive)
def pickAttachment(self):
"""
Prompts the user to select an attachment to add to this edit.
"""
filename = QFileDialog.getOpenFileName(self.window(),
'Select Attachment',
'',
'All Files (*.*)')
if type(filename) == tuple:
filename = nativestring(filename[0])
filename = nativestring(filename)
if filename:
self.addAttachment(os.path.basename(filename), filename)
def value( self ):
"""
Returns the current value of the current pair's value.
:return <str>
"""
return nativestring(self._valueEdit.text())
def title( self ):
"""
Returns the title for this rollout.
:return <str>
"""
return nativestring(self._titleLabel.text())
def drawDisplay(self, painter, option, rect, text):
"""
Overloads the drawDisplay method to render HTML if the rich text \
information is set to true.
:param painter | <QtGui.QPainter>
option | <QtGui.QStyleOptionItem>
rect | <QtCore.QRect>
text | <str>
"""
if self.showRichText():
# create the document
doc = QtGui.QTextDocument()
doc.setTextWidth(float(rect.width()))
doc.setHtml(text)
# draw the contents
painter.translate(rect.x(), rect.y())
doc.drawContents(painter, QtCore.QRectF(0,
0,
float(rect.width()),
float(rect.height())))
painter.translate(-rect.x(), -rect.y())
else:
if type(text).__name__ not in ('str', 'unicode', 'QString'):
text = nativestring(text)
metrics = QtGui.QFontMetrics(option.font)
text = metrics.elidedText(text,
QtCore.Qt.TextElideMode(option.textElideMode),
rect.width())
painter.setFont(option.font)
painter.drawText(rect, int(option.displayAlignment), text)
def setDateFormat(self, format):
"""
Sets the date format for this delegate.
:param format | <str>
"""
self._dateFormat = nativestring(format)
def key( self ):
"""
Returns the current value of the current pair's key.
:return <str>
"""
return nativestring(self._keyEdit.text())
def addEntry(self, key='', value=''):
"""
Creates a new entry item for this widget.
:param key | <str>
value | <variant>
"""
img = resources.find('img/close.png')
new_item = XTreeWidgetItem()
new_item.setText(1, nativestring(key))
new_item.setText(2, nativestring(value))
new_item.setIcon(0, QtGui.QIcon(img))
new_item.setFixedHeight(22)
self.insertTopLevelItem(self.topLevelItemCount() - 1, new_item)
return new_item
def setValue( self, value ):
# ignore password values since they are encrypted and we don't want
# to encrypt them multiple times
if ( value ):
value = IGNORED
self.setText(nativestring(value))
def setDragData(self, key, value):
"""
Sets the drag data associated with this data set. This will be
used when the user attempts to drag & drop a data set from the
chart somewhere. If no key is supplied, then the full data dictionary
is returned. The drag data key will be joined as:
application/x-[key]
:param key | <str> || None
value | <variant>
"""
self._dragData[nativestring(key)] = value
def itemPath(self, item):
"""
Returns the path for the inputed item based on its hierarchy.
:return <str>
"""
path = []
while (item):
path.insert(0, nativestring(item.text()))
item = item.parent()
sep = self.separator()
return sep + sep.join(path)
def filterData(self, key):
"""
Returns the filter data for the given key.
:param key | <str>
:return <str>
"""
if key == 'text':
default = nativestring(self.text())
else:
default = ''
return self._filterData.get(key, default)
def setText(self, text):
"""
Sets the text for this button. If it is set to show rich text, then
it will update the label text, leaving the root button text blank,
otherwise it will update the button.
:param text | <str>
"""
self._text = nativestring(text)
if self.showRichText():
self.richTextLabel().setText(text)
else:
super(XPushButton, self).setText(text)
def setFilepathModeText( self, text ):
"""
Sets the filepath mode for this widget based on the inputed text.
:param text | <str>
:return <bool> | success
"""
try:
self.setFilepathMode(XFilepathEdit.Mode[nativestring(text)])
return True
except KeyError:
return False
def formatValue(self, value):
"""
Formats the inputed value based on the formatting system for this ruler.
:param value | <variant>
"""
formatter = self.formatter()
if (formatter is not None):
return formatter(value)
elif (self.format()):
rtype = self.rulerType()
if (rtype in (XChartRuler.Type.Date, XChartRuler.Type.Datetime,
XChartRuler.Type.Time)):
return value.toString(self.format())
else:
try:
return self.format() % value
except TypeError:
return nativestring(value)
return nativestring(value)
def pickFilepath( self ):
"""
Picks the image file to use for this icon path.
"""
filepath = QFileDialog.getOpenFileName( self,
'Select Image File',
QDir.currentPath(),
self.fileTypes())
if type(filepath) == tuple:
filepath = nativestring(filepath[0])
if ( filepath ):
self.setFilepath(filepath)
def currentSchemaPath(self):
"""
Returns the column path for the current item. This will be a '.'
joined path based on the root schema to the given column.
:return <str>
"""
item = self.currentItem()
path = []
while item:
path.append(nativestring(item.text(0)))
item = item.parent()
return '.'.join(reversed(path))
def buildData(self, key=None, default=None):
"""
Returns the build information for this item for the given key,
or all build information if the supplied key is None.
:param key | <str> || None
default | <variant>
:return <variant>
"""
if key is None:
return self._buildData
return self._buildData.get(nativestring(key), default)
def removeAttachment(self, title):
"""
Removes the attachment from the given title.
:param title | <str>
:return <variant> | attachment
"""
attachment = self._attachments.pop(nativestring(title), None)
if attachment:
self.resizeToContents()
return attachment
def removeAxis(self, axis):
"""
Removes an axis from this chart either by direct reference or by
name.
:param axis | <projexui.widgets.XChartAxis> || <str>
"""
if not isinstance(axis, XChartAxis):
axis = self.axis(nativestring(axis))
try:
self._axes.remove(axis)
except ValueError:
pass
def isValid( self ):
"""
Returns whether or not the filepath exists on the system. \
In the case of a SaveFile, only the base folder \
needs to exist on the system, in other modes the actual filepath must \
exist.
:return <bool>
"""
check = nativestring(self._filepathEdit.text()).split(os.path.pathsep)[0]
if ( self.filepathMode() == XFilepathEdit.Mode.SaveFile ):
check = os.path.dirname(check)
return os.path.exists(check)
def record(viewWidget):
"""
Records the state for the inputed view widget into data.
:param viewWidget | <XViewWidget>
"""
profile = XViewProfile()
xprofile = ElementTree.Element('profile')
xprofile.set('locked', nativestring(viewWidget.isLocked()))
XViewProfile.recordWidget(xprofile, viewWidget.widget())
profile.setXmlElement(xprofile)
return profile
def fileName(self):
"""
Returns the filename.
:return <str>
"""
if self._filename:
return self._filename
filename = nativestring(super(XSettings, self).fileName())
if self._customFormat:
filename, ext = os.path.splitext(filename)
filename += '.' + self._customFormat.extension()
return filename
def setText(self, text):
"""
Sets the text for this serial edit to the inputed text.
:param text | <str>
"""
texts = nativestring(text).split(' ')
for i, text in enumerate(texts):
editor = self.editorAt(i)
if not editor:
break
editor.setText(text)
def generateResourceFile(srcpath, outpath='', buildpath='', build=True):
"""
Generates a Qt resource file based on the given source path. This will
take all the files and folders within the source and generate a new XML
representation of that path. An optional outpath can be provided as the
generated resource path, by default it will be called the name of the
source path.
:param srcpath | <str>
outpath | <str>
"""
if not outpath:
outpath = os.path.join(os.path.dirname(srcpath),
os.path.basename(srcpath) + '.qrc')
relpath = './%s' % os.path.basename(srcpath)
else:
relpath = os.path.relpath(srcpath, os.path.dirname(outpath))
xml = ElementTree.Element('RCC')
xml.set('header', 'projexui.resources')
srcpath = nativestring(srcpath)
srcpath = os.path.normpath(srcpath)
root_prefix = os.path.basename(srcpath) + '/'
count = len(srcpath)
for root, folders, files in os.walk(srcpath):
if not files:
continue
relpath = os.path.relpath(root, os.path.dirname(outpath))
prefix = (root_prefix + root[count + 1:].replace('\\', '/')).strip('/')
xresource = ElementTree.SubElement(xml, 'qresource')
xresource.set('prefix', prefix)
for file in files:
xfile = ElementTree.SubElement(xresource, 'file')
xfile.set('alias', file)
xfile.text = os.path.join(relpath, file).replace('\\', '/')
projex.text.xmlindent(xml)
xml_str = ElementTree.tostring(xml)
# save the exported information
with open(outpath, 'w') as f:
f.write(xml_str)
if build:
buildResourceFile(outpath, buildpath)
def dragMoveEvent(self, event):
"""
Handles the drag move event.
:param event | <QDragEvent>
"""
tags = nativestring(event.mimeData().text())
if (event.source() == self):
event.acceptProposedAction()
elif (tags):
event.acceptProposedAction()
else:
super(XMultiTagEdit, self).dragMoveEvent(event)
def setHint(self, text):
"""
Sets the hint to the inputed text. The same hint will be used for
all editors in this widget.
:param text | <str>
"""
texts = nativestring(text).split(' ')
for i, text in enumerate(texts):
editor = self.editorAt(i)
if not editor:
break
editor.setHint(text)
def plugins( self, typ = None, group = None ):
"""
Returns the plugins used for this dialog.
:param typ | <str> || None
group | <str> || None
:return [<XWizardPlugin>, ..]
"""
if ( typ is None ):
output = []
for wlang in self._plugins.values():
for wgrp in wlang.values():
output += wgrp
return output
elif ( group is None ):
output = []
for wgrp in self._plugins.get(nativestring(typ), {}).values():
output += wgrp
return output
else:
return self._plugins.get(nativestring(typ), {}).get(nativestring(group), [])
def setColumnTypeText( self, columnTypeText ):
"""
Sets the column type for this widget based on the inputed text.
:param columnTypeText | <str>
"""
if ( not ColumnType ):
return False
try:
columnType = ColumnType[nativestring(columnTypeText)]
except KeyError:
return False
return self.setColumnType(columnType)
def setColor(self, key, value):
"""
Sets the color value for the inputed color.
:param key | <unicode>
value | <QtGui.QColor>
"""
key = nativestring(key).capitalize()
self._colorSet.setColor(key, value)
# update the palette information
if (key == 'Background'):
palette = self.palette()
palette.setColor(palette.Base, value)
self.setPalette(palette)
def currentRecord(self):
"""
Returns the current record based on the active index from the model.
:return <orb.Table> || None
"""
completion = nativestring(self._pywidget.text())
options = map(str, self.model().stringList())
try:
index = options.index(completion)
except ValueError:
return None
return self._records[index]
def saveValues(self):
"""
Generates a dictionary of values from the widgets in this editor that
will be used to save the values on its record.
:return {<str> columnName: <variant> value, ..}
"""
output = {}
for widget in self.findChildren(QWidget):
prop = widget.property('columnName')
if not prop:
continue
columnName = nativestring(unwrapVariant(prop, ''))
if ( not columnName ):
continue
value, success = projexui.widgetValue(widget)
if ( not success ):
continue
# convert from values to standard python values
if ( isinstance(value, QDateTime) ):
value = value.toPyDateTime()
elif ( isinstance(value, QDate) ):
value = value.toPyDate()
elif ( isinstance(value, QTime) ):
value = value.toPyTime()
elif ( type(value).__name__ == 'QString' ):
value = nativestring(value)
output[columnName] = value
return output
def mimeData(self, items):
"""
Creates the mime data for the different items.
:param items | [<QListWidgetItem>, ..]
:return <QMimeData>
"""
text = []
for item in items:
text.append(nativestring(item.text()))
data = QMimeData()
data.setText(','.join(text))
return data
def splitPath(self, path):
"""
Splits the path into its components.
:param path | <str>
:return [<str>, ..]
"""
sep = self.model().separator()
splt = nativestring(path).lstrip(sep).split(sep)
if (splt and not splt[-1]):
self.model().itemByPath(path)
return splt
def pathFromIndex(self, index):
"""
Returns the joined path from the given model index. This will
join together the full path with periods.
:param index | <QModelIndex>
:return <str>
"""
out = []
while index and index.isValid():
out.append(nativestring(unwrapVariant(index.data())))
index = self._model.parent(index)
return self.joiner().join(reversed(out))
def editorValue(self, editor):
"""
Returns the value for this plugin from the inputed editor.
:param editor | <QtGui.QWidget>
:return <variant>
"""
if isinstance(editor, QLineEdit):
try:
return eval(nativestring(editor.text()))
except:
return 0
else:
return super(NumericPlugin, self).editorValue(editor)
def load(self, filename, lineno=0):
"""
Loads the inputed filename as the current document for this edit.
:param filename | <str>
lineno | <int>
:return <bool> | success
"""
filename = nativestring(filename)
if (not (filename and os.path.exists(filename))):
return False
# load the file
docfile = QFile(filename)
if (not docfile.open(QFile.ReadOnly)):
return False
success = self.read(docfile)
docfile.close()
if (not success):
return False
self._filename = nativestring(filename)
ext = os.path.splitext(filename)[1]
self.setCurrentLine(lineno)
lang = XLanguage.byFileType(ext)
if (lang != self.language()):
self.setLanguage(lang)
self.setModified(False)
return True
def findUiActions(widget):
"""
Looks up actions for the inputed widget based on naming convention.
:param widget | <QWidget>
:return [<QAction>, ..]
"""
import_qt(globals())
output = []
for action in widget.findChildren(QtGui.QAction):
name = nativestring(action.objectName()).lower()
if (name.startswith('ui') and name.endswith('act')):
output.append(action)
return output
def validatePage(self):
"""
Finishes up the structure information for this wizard by building
the scaffold.
"""
path = self.uiOutputPATH.filepath()
for item in self.uiStructureTREE.topLevelItems():
item.save()
try:
self.scaffold().build(path, self._structure)
except Exception, err:
QtGui.QMessageBox.critical(None, 'Error Occurred',
nativestring(err))
return False
