def __init__(self, runner=None):
_OptionsModelMixin.__init__(self)
QAbstractTableModel.__init__(self)
self._runner = runner
def _column0(runner, options):
return str(options)
def _column1(runner, options):
STATE_ICONS = \
{LocalRunner.STATE_QUEUED: getIcon('media-playback-pause'),
LocalRunner.STATE_RUNNING: getIcon('media-playback-start'),
LocalRunner.STATE_SIMULATED: getIcon('face-smile'),
LocalRunner.STATE_ERROR: getIcon('face-sad')}
try:
return STATE_ICONS.get(runner.options_state(options))
except KeyError:
return None
def _column2(runner, options):
try:
progress = runner.options_progress(options) * 100
except KeyError:
progress = 0.0
return '{0:n}%'.format(progress)
def _column3(runner, options):
try:
return runner.options_status(options)
except KeyError:
return ''
self._data_getter = {0: _column0, 1: _column1, 2: _column2, 3: _column3}
def __init__(self, results, headerdata, parent=None, *args):
""" datain: a list of lists
headerdata: a list of strings
"""
QAbstractTableModel.__init__(self, parent, *args)
#self.arraydata = datain
self.headerdata = headerdata
self.results = results
def __init__(self, results, headerdata, parent=None, *args):
""" datain: a list of lists
headerdata: a list of strings
"""
QAbstractTableModel.__init__(self, parent, *args)
#self.arraydata = datain
self.headerdata = headerdata
self.results = results
def flags(self, index):
if not index.isValid():
return Qt.ItemIsEnabled
# If the column is the vary parameter then we want the user to be able to check/uncheck the box
if index.column() == 1:
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def __init__(self, dataset = Dataset(), parent = None):
'''Construtor de DatasetModel.
Parâmetros:
dataset : objeto Dataset para ser atribuído a *_dataset*
'''
QAbstractTableModel.__init__(self, parent)
self._dataset = dataset
def __init__(self, obsLightManager, projectName):
QAbstractTableModel.__init__(self)
self.__obsLightManager = obsLightManager
self.__project = projectName
self.__pkgList = None
self.__getPackageList()
if self.colors is None:
self.__loadColors()
def __init__(self, dataset=Dataset(), parent=None):
'''Construtor de DatasetModel.
Parâmetros:
dataset : objeto Dataset para ser atribuído a *_dataset*
'''
QAbstractTableModel.__init__(self, parent)
self._dataset = dataset
def __init__(self):
""" Build the Transactions Table """
QAbstractTableModel.__init__(self)
self.columns = self.getColumns()
self.roleResponses = {Qt.DisplayRole:self.getData,
Qt.EditRole:self.getData,
Qt.ToolTipRole:self.getTip,
Qt.StatusTipRole:self.getTip,
Qt.TextAlignmentRole:self.getTextAlignment}
def __init__ ( self, editor, parent ):
""" Initialise the object.
"""
QAbstractTableModel.__init__( self, parent )
self.setSupportedDragActions( Qt.CopyAction | Qt.MoveAction )
self._editor = editor
self._row = editor.data_row_for
self._font = set()
def __init__(self, dados = [], parent = None):
'''Construtor de DatasetModel.
Parâmetros:
dados : objeto Dataset para ser atribuído a *_dataset*
'''
QAbstractTableModel.__init__(self, parent)
self._dados = dados
self._estatistica = dados.describe()
def __init__(self,
table_data,
headers=[],
check_row=[],
executed_row=[],
parent=None):
QAbstractTableModel.__init__(self, parent)
self.check_row = check_row
self.table_data = table_data
self.headers = headers
self.executed_row = executed_row
def __init__(self, tabList=None, parent=None):
QAbstractTableModel.__init__(self, parent)
self.__headers = [
'Char', 'Freq', 'ASCII', 'Huff', u'Ĉ ASCII', u'Ĉ Huff']
if tabList is None:
tabList = [['' for x in range(len(self.__headers))]]
for x in range(len(tabList)):
missingCols = len(self.__headers) - len(tabList[x])
for x in range(missingCols):
tabList[x].append('/')
self.__tabList = tabList
self.hlRow = []
def flags(self, index):
""" Define editable cells
:param index:
"""
if not index.isValid():
return Qt.ItemIsEnabled
if index.column() in [NODE_NAME, NODE_FILE]:
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
return Qt.ItemFlags(QAbstractTableModel.flags(self, index))
def flags(self, index):
""" Define editable cells
:param index:
"""
if not index.isValid():
return Qt.ItemIsEnabled
if index.column() in [NODE_NAME, NODE_FILE]:
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
return Qt.ItemFlags(QAbstractTableModel.flags(self, index))
def mimeTypes ( self ):
""" Returns the set of mime types that drag data can be encoded in.
"""
result = QAbstractTableModel.mimeTypes( self )
result.append( PythonMimeType )
return result
def flagsEvent(self, index):
row = index.row()
if (index.column() == COLUMN.VALUE and
(row == EVENT_ROW.NAME or row == EVENT_ROW.TARGET or row == EVENT_ROW.EXPRESSION or row == EVENT_ROW.TRIGGEREXPRESSION)):
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
else:
return None
def flagsGeneral(self, index):
row = index.row()
if index.column() == COLUMN.VALUE and row == 1: # 1 is hardcoded; "Name" always has to be at 2nd position
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
else:
#return Qt.ItemFlags(QAbstractTableModel.flags(self, index))
return None
def flagsRule(self, index):
row = index.row()
if (index.column() == COLUMN.VALUE and
(row == RULE_ROW.NAME or row == RULE_ROW.VARIABLE or row == RULE_ROW.MATH)):
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
else:
return None
def flags(self, index):
""" Set the item flags at the given index. Seems like we're
implementing this function just to see how it's done, as we
manually adjust each tableView to have NoEditTriggers.
"""
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def __init__(self):
QAbstractTableModel.__init__(self)
self.__state_current_data = None
self.__state_cond = {} # now sql condition
self.__state_data = list() # data
self.__state_check = [] # checked list
self.__state_fields_name = [] # fields CN name
self.__state_fields_id = [] # data table field name
self.__state_edit_fields = []
self.__state_select = {}
self._state_editable = False
self.__service = None
def flags(self, index):
""" Set the item flags at the given index. Seems like we're
implementing this function just to see how it's done, as we
manually adjust each tableView to have NoEditTriggers.
"""
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def flagsGeneral(self, index):
row = index.row()
if index.column(
) == COLUMN.VALUE and row == 1: # 1 is hardcoded; "Name" always has to be at 2nd position
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
else:
#return Qt.ItemFlags(QAbstractTableModel.flags(self, index))
return None
def setData ( self, index, value, role ):
""" Reimplemented to allow setting data.
"""
if role == Qt.EditRole:
# This works because a Facets Editor will have already set the value
# on the object, and so we don't need to do anything here:
return True
return QAbstractTableModel.setData( self, index, value, role )
def __init__(self, result):
QAbstractTableModel.__init__(self)
self._result = result
self._transitions = sorted(result.iter_transitions())
self._header_sections = ["Transition", "PG", "PE", "CG", "CE", "BG", "BE", "TG", "TE"]
self._data_funcs = [
lambda r, t: r.intensity(t, False, False),
lambda r, t: r.intensity(t, True, False),
lambda r, t: r.characteristic_fluorescence(t, False),
lambda r, t: r.characteristic_fluorescence(t, True),
lambda r, t: r.bremsstrahlung_fluorescence(t, False),
lambda r, t: r.bremsstrahlung_fluorescence(t, True),
lambda r, t: r.intensity(t, False, True),
lambda r, t: r.intensity(t, True, True),
]
self._show_uncertainty = True
self._factor = 1.0
def __init__(self, watcher=None):
""" Init model """
QAbstractTableModel.__init__(self)
self.table_view = None
self.watcher = watcher
self.watcher.fileChanged.connect(self.file_watch_file_change)
self.watcher.directoryChanged.connect(self.file_watch_directory_change)
self.is_reloading_file = False
self.suspend_force_sort = False
self.supported_format_dict = dict(
[(n_type, nodeAttr) for n_type, nice, nodeAttr in MTTSettings.SUPPORTED_TYPE])
self.db = None
# create database table
try:
self._database_create_table()
except sqlite3.Error, e:
mtt_log('Error init DB :\n\t>> %s <<\n' % e, msg_type='error',
verbose=False)
sys.exit(1)
def __init__(self,
obsLightManager,
projectName,
getDataDictListFunc,
sortOnKey=None):
"""
Initialize the model.
obsLightManager: an instance of `ObsLightManager`
projectName: the name of the MIC project this model will retrieve data from
getDataDictListFunc: a function taking a project name as parameter and
returning a list of data dictionaries
"""
QAbstractTableModel.__init__(self)
self.__modified = False
self.__dataDictList = None
self.__manager = obsLightManager
self.__project = projectName
self.__getDataDictListFunc = getDataDictListFunc
self.sortOnKey = sortOnKey
self.refresh()
def __init__(self, obsLightManager, projectName, packageName):
"""
Initialize the OscWorkingCopyModel.
`obsLightManager`: a reference to the ObsLightManager.
`projectName`: the name of the OBS project in which we are working.
`packageName`: the name of the package we are managing the working copy of.
"""
QAbstractTableModel.__init__(self)
self.__obsLightManager = obsLightManager
self.__project = projectName
self.__package = packageName
self.__columnList = list()
self.__fileList = list()
self.__fileInfos = dict()
self.sortKey = None
self.sortOrder = Qt.SortOrder.AscendingOrder
# dict<unicode, dict<object, QColor>>
self.colors = dict()
self._loadColors()
self.refresh()
def __init__(self, watcher=None):
""" Init model """
QAbstractTableModel.__init__(self)
self.table_view = None
self.watcher = watcher
self.watcher.fileChanged.connect(self.file_watch_file_change)
self.watcher.directoryChanged.connect(self.file_watch_directory_change)
self.is_reloading_file = False
self.suspend_force_sort = False
self.supported_format_dict = dict([
(n_type, nodeAttr)
for n_type, nice, nodeAttr in MTTSettings.SUPPORTED_TYPE
])
self.db = None
# create database table
try:
self._database_create_table()
except sqlite3.Error, e:
mtt_log('Error init DB :\n\t>> %s <<\n' % e,
msg_type='error',
verbose=False)
sys.exit(1)
def flags(self,index):
if ( not index.isValid() ):
return super(VoxelGridModel,self).flags(index)
# creating some shortcuts for the GridPlane and the Column
grid_plane = self._data[index.row()]
column = GridManagerColumns.Columns[index.column()]
# The default planes cannot have some of its values changed (Name, Plane, Offset), so we protect them here.
if( grid_plane.name in VoxelGrid.ReservedNames.values() ):
if( column in [ GridManagerColumns.Visible, GridManagerColumns.Collision ] ):
return super(VoxelGridModel,self).flags(index) | Qt.ItemIsEditable
else:
return super(VoxelGridModel,self).flags(index)
# If it's not one of the protected planes, the everything is valid >.< (user can edit)
if( column != GridManagerColumns.Color ):
return super(VoxelGridModel,self).flags(index) | Qt.ItemIsEditable
return QAbstractTableModel.flags(self,index)
def mimeData ( self, indices ):
""" Returns the serialized MIME data for the specified list of model
indices.
"""
result = QAbstractTableModel.mimeData( self, indices )
get_drag = self._editor.grid_adapter.get_drag
rows = set()
items = []
for index in indices:
row = self._row( index.row() )
column = index.column()
if row not in rows:
rows.add( row )
item = get_drag( row, column )
if item is not None:
items.append( item )
result.setData( PythonMimeType, dumps( items, -1 ) )
self._editor.drag_rows( list( rows ) )
return result
def dropMimeData ( self, mime_data, drop_action, row, column, parent ):
""" Handles the data supplied by a drag and drop operation that ended
with the given action. Returns True if the data and action can be
handled by the model; otherwise returns False.
"""
# Save whether the associated editor is in the dragging state (we'd let
# the editor figure it out, but the state seems to change by the time
# the editor method below is called):
dragging = (self._editor.control.state() ==
QAbstractItemView.DraggingState)
if mime_data.hasFormat( PythonMimeType ):
try:
data = loads( str( mime_data.data( PythonMimeType ) ) )
self._editor.data_dropped_on( self._row( parent.row() ),
parent.column(), data, dragging )
return True
except:
pass
return QAbstractTableModel.dropMimeData( self, mime_data, drop_action,
row, column, parent )
def __init__(self, parent, infoDict, header, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.infoDict = infoDict
self.header_labels = header
def __init__(self):
QAbstractTableModel.__init__(self)
self._layers = []
def __init__(self, parent, mylist, header, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.mylist = mylist
self.header = header
def reset(self):
self.beginResetModel()
self.states = self.turing.states
self.alphabet = self.turing.alphabet
self.endResetModel()
QAbstractTableModel.reset(self)
def __init__(self, parent, list, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.list = list
self.header = []
self.generate_headers()
def __init__(self, addons, latestVersions, parent=None):
QAbstractTableModel.__init__(self, parent)
self.addons = addons
self.latestVersions = latestVersions
self.parent = parent
def __init__(self, table, parent=None):
QAbstractTableModel.__init__(self, parent)
self.table = table
def flags(self, index):
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(QAbstractTableModel.flags(self, index) |
Qt.ItemIsEditable)
def __init__(self, table, parent=None):
QAbstractTableModel.__init__(self, parent)
self.table = table
def __init__(self, parent, datalist, header, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.header = []
self.list = []
self.set_list(datalist, header)
def __init__(self, QObject_parent=None, turing=None):
QAbstractTableModel.__init__(self, QObject_parent)
self.set_machine(turing)
def __init__(self, repoTuple):
QAbstractTableModel.__init__(self)
self._repoTuple = repoTuple
def __init__(self, parent, header, data_list, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.data_list = data_list
self.header = header
def flags(self, index):
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def __init__(self):
QAbstractTableModel.__init__(self)
self._forcings = []
def headerData(self, section, orientation, role=Qt.DisplayRole):
if role == Qt.DisplayRole and orientation == Qt.Horizontal:
return self.header_labels[section]
return QAbstractTableModel.headerData(self, section, orientation, role)
def __init__(self, parent, datalist, header, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.header = []
self.list = []
self.set_list(datalist, header)
def headerData(self, section, orientation, role=Qt.DisplayRole):
if role == Qt.DisplayRole and orientation == Qt.Horizontal:
return self.header_labels[section]
return QAbstractTableModel.headerData(self, section, orientation, role)
def __init__(self):
QAbstractTableModel.__init__(self)
self._limits = []
def reset(self):
self.beginResetModel()
self.states = self.turing.states
self.alphabet = self.turing.alphabet
self.endResetModel()
QAbstractTableModel.reset(self)
def __init__(self, courses):
QAbstractTableModel.__init__(self)
# my object is a mapping, while table model uses an index (so it's
# more similar to a list
self.courses = list(courses)
def __init__(self, QObject_parent=None, turing=None):
QAbstractTableModel.__init__(self, QObject_parent)
self.set_machine(turing)
