Python PyQt4.QtGui 模块，QStandardItem() 实例源码

def createIcon(self, nodeType):
        '''Create Icons for `libraryModel`.

        :param nodeType: Type of icon to create.
        '''
        pixmap = QtGui.QPixmap(60, 60)
        pixmap.fill()
        painter = QtGui.QPainter(pixmap)
        if nodeType == "transition":
            painter.setBrush(QtCore.Qt.white)
            painter.drawRect(5, 10, 50, 30)
        elif nodeType == "place":           
            painter.setBrush(QtCore.Qt.white)
            painter.drawEllipse(5, 10, 50, 30) 
        elif nodeType == "token":           
            painter.setBrush(QtCore.Qt.green)
            painter.drawEllipse(15, 15, 30, 30) 

        painter.end()
        return QtGui.QStandardItem( QtGui.QIcon(pixmap), nodeType[0].upper() + nodeType[1:] )
    #------------------------------------------------------------------------------------------------

def __init__(self, parent):
        QtGui.QComboBox.__init__(self, parent)
        self.model = QtGui.QStandardItemModel()
        self.state_item = QtGui.QStandardItem('all')
        self.state_item.setEnabled(False)
        self.model.appendRow(self.state_item)
        all_item = QtGui.QStandardItem('select all')
        self.model.appendRow(all_item)
        none_item = QtGui.QStandardItem('select none')
        self.model.appendRow(none_item)
        self.bank_items = []
        for i in range(8):
            item = QtGui.QStandardItem(uppercase[i])
            item.setCheckable(True)
            item.setCheckState(2)
            item.setTristate(False)
            self.model.appendRow(item)
            self.bank_items.append(item)
        self.setModel(self.model)
        self.activated.connect(self.check)
        self.setCurrentIndex(0)
        self.installEventFilter(self)

def add_local_sysex(self, file_info):
        if file_info.size() != 26240:
            raise BaseException('Wavetable file "{}", doesn\'t match size.'.format(file_info.fileName()))
        try:
            with open(str(file_info.absoluteFilePath().toUtf8()), 'rb') as sf:
                data = list(ord(i) for i in sf.read(406))
            if data[:4] != [IDW, IDE] and data[4] != WTBD and data[7] != 0:
                raise BaseException('SysEx file "{}" is not a Wavetable'.format(file_info.fileName()))
        except Exception as e:
            raise BaseException('An error occurred while loading wavetable file {}:\n{}'.format(file_info.fileName(), e))
        wt_slot = data[5]
        wt_name = ''.join([str(unichr(l)) for l in data[392:406]])
        name_item = QtGui.QStandardItem(wt_name)
        slot_item = QtGui.QStandardItem(str(wt_slot))
        date_item = QtGui.QStandardItem(file_info.lastModified().toString(QtCore.Qt.SystemLocaleShortDate))
        file_item = QtGui.QStandardItem()
        file_item.setData(file_info)
        uid = str(uuid4())
        uid_item = QtGui.QStandardItem(uid)
        self.model.appendRow([name_item, slot_item, date_item, file_item, uid_item])
        self.wavetable_data[uid] = None

def __init__(self, main, *args, **kwargs):
        QtGui.QDialog.__init__(self, main, *args, **kwargs)
        load_ui(self, 'dialogs/wavetable_undo.ui')
        self.main = main
        self.undo = self.main.undo
        self.undo_model = QtGui.QStandardItemModel()
        self.undo_list.setModel(self.undo_model)

        original = QtGui.QStandardItem('Initial state')
        setBoldItalic(original, True, False)
        self.undo_model.appendRow(original)

        self.undo.updated.connect(self.update)
        self.undo.indexChanged.connect(self.indexChanged)
        self.undo_list.doubleClicked.connect(self.do_action)
        self.undo_btn.clicked.connect(lambda: self.undo.setIndex(0))
        self.redo_btn.clicked.connect(lambda: self.undo.setIndex(self.undo.count()))

def __init__(self, parent=None):
        QtGui.QComboBox.__init__(self, parent)
        self.setEditable(True)
        self.setInsertPolicy(QtGui.QComboBox.NoInsert)
        self.setMaximumWidth(100)
        self.p_model = QtGui.QStandardItemModel()
        self.name_model = QtGui.QStandardItemModel()
        self.setModel(self.p_model)

        metrics = QtGui.QFontMetrics(self.view().font())
        ctrl_width = []
        note_width = []
        for i in range(128):
            ctrl = Controllers[i]
            ctrl_str = '{} - {}'.format(i, ctrl)
            ctrl_item = QtGui.QStandardItem(ctrl_str)
            ctrl_item.setData(i, IdRole)
            ctrl_item.setData(ctrl, NameRole)
            ctrl_width.append(metrics.width(ctrl_str))
            ctrl_name_item = QtGui.QStandardItem(ctrl)
            ctrl_name_item.setData(i, IdRole)
            note = NoteNames[i].title()
            note_str = '{} - {}'.format(i, note)
            note_item = QtGui.QStandardItem(note_str)
            note_item.setData(i, IdRole)
            note_item.setData(note, NameRole)
            note_width.append(metrics.width(note_str))
            note_name_item = QtGui.QStandardItem(note)
            note_name_item.setData(i, IdRole)
            self.p_model.appendRow([ctrl_item, note_item])
            self.name_model.appendRow([ctrl_name_item, note_name_item])

        self.ctrl_width = max(ctrl_width)
        self.note_width = max(note_width)
        self.ref_size = self.width()

        self.activated.connect(lambda i: self.lineEdit().setCursorPosition(0))
        self.currentIndexChanged.connect(lambda i: self.lineEdit().setCursorPosition(0))

def create_event_types(self):
        self.trigger_model = QtGui.QStandardItemModel()
        self.record_model = QtGui.QStandardItemModel()
        self.ignore_model = QtGui.QStandardItemModel()
        self.trigger_list.setModel(self.trigger_model)
        self.record_list.setModel(self.record_model)
        self.ignore_list.setModel(self.ignore_model)
        all_types = list(trigger_defaults)+list(record_defaults)
        view_dict = {TRIGGER: self.trigger_model, RECORD: self.record_model, IGNORE: self.ignore_model}
#        defaults = {ev_type:dest for dest, t in dict({trigger_defaults: self.trigger_model, record_defaults: self.record_model, ignore_defaults: self.ignore_model}.items()) for ev_type in t}
        for ev_type in all_types:
            item = QtGui.QStandardItem(str(ev_type))
            item.setData(ev_type, EventRole)
#            item.setData(defaults[ev_type], DefaultRole)
            item.setData(True if ev_type in trigger_allowed else False, TriggerRole)
            item.setData(True if ev_type in record_allowed else False, RecordRole)
            view_dict[self.event_filter[ev_type]].appendRow(item)

def create_stop_events(self, raw_list):
        for ev_type, data1, data2, chan in raw_list:
            ev_type = eval(ev_type)
            ev_item = event_model_dict[ev_type].clone()
            if ev_type == SYSEX:
                chan_item = QtGui.QStandardItem()
                chan_item.setData(0, IdRole)
                chan_item.setEnabled(False)
                data1_item = QtGui.QStandardItem(' '.join(['{:02X}'.format(v) for v in data1]))
                data1_item.setData(0, IdRole)
                data1_item.setData(data1, SysExRole)
                data2_item = QtGui.QStandardItem()
                data2_item.setData(0, IdRole)
                data2_item.setEnabled(False)
            else:
                chan_item = QtGui.QStandardItem('{}'.format(chan+1 if chan >= 0 else 'All'))
                chan_item.setData(chan, IdRole)
                data1_item = QtGui.QStandardItem('{} - {}'.format(data1, Controllers[data1] if ev_type==CTRL else NoteNames[data1].title()))
                data1_item.setData(data1, IdRole)
                data2_item = QtGui.QStandardItem(str(data2))
                data2_item.setData(data2, IdRole)
            chan_item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignCenter)
            data2_item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignCenter)
            self.stop_events_model.appendRow([ev_item, chan_item, data1_item, data2_item])

def row_append(self, src, dst, proto, info):
        self.model.appendRow((QtGui.QStandardItem(src),
                              QtGui.QStandardItem(dst),
                              QtGui.QStandardItem(proto),
                              QtGui.QStandardItem(info)))

def set_items(self, items):
        self._model.clear()
        for item in items:
            list_item = QStandardItem(item)
            self._model.appendRow(list_item)
        self.list_view.setModel(self._model)

def on_add_click(self):
        item, ok = utils.input_query(None, "Adding %s" % self.itemName.lower(), self.itemName + ":")
        if ok:
            list_item = QStandardItem(item)
            self._model.appendRow(list_item)
            self.list_view.setCurrentIndex(self._model.indexFromItem(list_item))
            self.event_add(item)

def update_files_list(self):

        self.tools = Tools()

        # initialize model for inserting to table
        model = QtGui.QStandardItemModel(1, 1)

        model.setHorizontalHeaderLabels(['File name', 'File size', 'Mimetype', 'File ID'])

        self.current_bucket_index = self.file_manager_ui.bucket_select_combo_box.currentIndex()
        self.current_selected_bucket_id = self.bucket_id_list[self.current_bucket_index]

        i = 0

        try:
            for self.file_details in self.storj_engine.storj_client.bucket_files(str(self.current_selected_bucket_id)):
                item = QtGui.QStandardItem(str(self.file_details['filename'].replace('[DECRYPTED]', "")))
                model.setItem(i, 0, item)  # row, column, item (StandardItem)

                file_size_str = self.tools.human_size(int(self.file_details["size"]))  # get human readable file size

                item = QtGui.QStandardItem(str(file_size_str))
                model.setItem(i, 1, item)  # row, column, item (QQtGui.StandardItem)

                item = QtGui.QStandardItem(str(self.file_details['mimetype']))
                model.setItem(i, 2, item)  # row, column, item (QStandardItem)

                item = QtGui.QStandardItem(str(self.file_details['id']))
                model.setItem(i, 3, item)  # row, column, item (QStandardItem)

                i = i + 1

                self.__logger.info(self.file_details)

        except sjexc.StorjBridgeApiError as e:
            self.__logger.error(e)

        self.file_manager_ui.files_list_tableview.clearFocus()
        self.file_manager_ui.files_list_tableview.setModel(model)
        self.file_manager_ui.files_list_tableview.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)

def initialize_buckets_table(self):
        self.storj_engine = StorjEngine()  # Init StorjEngine
        self.__logger.info('resolving buckets')
        # Initialize model for inserting to table
        model = QStandardItemModel(1, 1)

        model.setHorizontalHeaderLabels(['Name', 'Storage', 'Transfer', 'ID'])

        i = 0
        try:
            for bucket in self.storj_engine.storj_client.bucket_list():
                item = QStandardItem(bucket.name)
                model.setItem(i, 0, item)  # row, column, item (QStandardItem)

                item = QStandardItem(str(bucket.storage))
                model.setItem(i, 1, item)  # row, column, item (QStandardItem)

                item = QStandardItem(str(bucket.transfer))
                model.setItem(i, 2, item)  # row, column, item (QStandardItem)

                item = QStandardItem(bucket.id)
                model.setItem(i, 3, item)  # row, column, item (QStandardItem)

                i = i + 1

        except sjexc.StorjBridgeApiError as e:
            QtGui.QMessageBox.about(
                self,
                'Unhandled bucket resolving exception',
                'Exception: %s' % e)

        # Set label of user buckets number
        self.bucket_manager_ui.total_buckets_label.setText(str(i))
        self.bucket_manager_ui.bucket_list_tableview.setModel(model)
        self.bucket_manager_ui.bucket_list_tableview.horizontalHeader().\
            setResizeMode(QtGui.QHeaderView.Stretch)

def reset(self,newAvailableTexts,newSelectedTexts):
        # precheck
        for txt in newAvailableTexts:
            assert type(txt) == unicode
        for txt in newSelectedTexts:
            assert txt in newAvailableTexts

        # empty old info
        self.availableFields.clear()
        self.selectedFields.clear()

        # fill model
        for txt in newAvailableTexts:
            # note that we will emit fieldChoiceChanged afterwards, for the list view
            item = QtGui.QStandardItem(txt)
            item.setEditable(False)
            # CAUTION!
            if txt in newSelectedTexts:
                #  Bad for order
                # self.selectedFields.appendRow(item)
                pass
            else:
                self.availableFields.appendRow(item)

        for txt in newSelectedTexts:
            item = QtGui.QStandardItem(txt)
            item.setEditable(False)
            self.selectedFields.appendRow(item)

        # update widgets
        if self.availableFields.hasIndex(0,0):
            self.availableFieldsDisplay.setCurrentIndex(self.availableFields.indexFromItem(self.availableFields.item(0)))

        if self.selectedFields.hasIndex(0,0):
            self.selectedFieldsDisplay.setCurrentIndex(self.selectedFields.indexFromItem(self.selectedFields.item(0)))

        self.updateButtonStatus()

        self.fieldChoiceChanged.emit(self.getCurrentSelectedFields())

    # returns a list of currently selected fields (i.e. what we actually care about)

def slotAddButtonClicked(self):
        # take current selection from availableFieldsDisplay 
        theIndex = self.availableFieldsDisplay.currentIndex()
        assert theIndex.isValid()
        theItem = self.availableFields.itemFromIndex(theIndex)
        theText = theItem.text()

        # remove that from availableFields
        self.availableFields.removeRow(theIndex.row())
        if self.availableFields.rowCount() > theIndex.row():
            self.availableFieldsDisplay.setCurrentIndex(self.availableFields.indexFromItem(self.availableFields.item(theIndex.row())))
        elif self.availableFields.rowCount() > theIndex.row() - 1:
            # at the end
            self.availableFieldsDisplay.setCurrentIndex(self.availableFields.indexFromItem(self.availableFields.item(theIndex.row() - 1)))
        # otherwise, that's empty

        # add it to selectedFields, before the current selection
        selIndex = self.selectedFieldsDisplay.currentIndex()
        if selIndex.isValid():
           currentSelectedFieldsPosition = selIndex.row()
        else:
           currentSelectedFieldsPosition = 0
        newItem = QtGui.QStandardItem(theText)
        newItem.setEditable(False)
        self.selectedFields.insertRow(currentSelectedFieldsPosition,newItem)

        # make sure we have a selection
        selIndex = self.selectedFieldsDisplay.currentIndex()
        if not selIndex.isValid():
            self.selectedFieldsDisplay.setCurrentIndex(self.selectedFields.indexFromItem(self.selectedFields.item(0)))

        self.updateButtonStatus()
        self.fieldChoiceChanged.emit(self.getCurrentSelectedFields())

def slotRemoveButtonClicked(self):
        # take current selection from selectedFieldsDisplay 
        theIndex = self.selectedFieldsDisplay.currentIndex()
        assert theIndex.isValid()
        theItem = self.selectedFields.itemFromIndex(theIndex)
        theText = theItem.text()

        # remove that from selectedFields
        self.selectedFields.removeRow(theIndex.row())
        if self.selectedFields.rowCount() > theIndex.row():
            self.selectedFieldsDisplay.setCurrentIndex(self.selectedFields.indexFromItem(self.selectedFields.item(theIndex.row())))
        elif self.selectedFields.rowCount() > theIndex.row() - 1:
            # at the end
            self.selectedFieldsDisplay.setCurrentIndex(self.selectedFields.indexFromItem(self.selectedFields.item(theIndex.row() - 1)))
        # otherwise, that's empty

        # add it to availableFields
        currentAvFieldsPosition = 0
        newItem = QtGui.QStandardItem(theText)
        newItem.setEditable(False)
        self.availableFields.insertRow(currentAvFieldsPosition,newItem)

        # make sure we have a selection
        avIndex = self.availableFieldsDisplay.currentIndex()
        if not avIndex.isValid():
            self.availableFieldsDisplay.setCurrentIndex(self.availableFields.indexFromItem(self.availableFields.item(0)))

        self.updateButtonStatus()
        self.fieldChoiceChanged.emit(self.getCurrentSelectedFields())
        pass

def createEditor(self, parent, option, index):
        self.proxy = index.model()
        self.index = self.proxy.mapToSource(index)
        combo = QtGui.QComboBox(parent)
        model = QtGui.QStandardItemModel()
        [model.appendRow(QtGui.QStandardItem(cat)) for cat in categories]
        combo.setModel(model)
        combo.setCurrentIndex(index.data(CatRole).toPyObject())
        combo.activated.connect(lambda i: parent.setFocus())
        return combo

def __init__(self, *args, **kwargs):
        QtGui.QStandardItem.__init__(self, *args, **kwargs)
        self.setFlags(self.flags() ^ QtCore.Qt.ItemIsEditable)

def createEditor(self, parent, option, index):
        self.index = index
        combo = QtGui.QComboBox(parent)
        combo.addItems(['Unchanged'] + index.data(ValuesRole).toPyObject())
#        model = QtGui.QStandardItemModel()
#        [model.appendRow(QtGui.QStandardItem(value)) for value in index.data(ValuesRole).toPyObject()]
#        combo.setModel(model)
        combo.setCurrentIndex(index.data(EditedRole).toPyObject() + 1)
        combo.activated.connect(lambda i: parent.setFocus())
        return combo

def add_item(self, item):
        self.model.appendRow(QtGui.QStandardItem(item))
        self.adjust_size()

def update(self):
        self.undo_model.clear()
        index = self.undo.index()
        original = QtGui.QStandardItem('Initial state')
        setBoldItalic(original, True, False)
        self.undo_model.appendRow(original)
        for u in xrange(self.undo.count()):
            cmd = self.undo.command(u)
            item = QtGui.QStandardItem(cmd.text())
#            item.setData(cmd, undoRole)
            if u > index:
                setBoldItalic(item, False, True)
            else:
                setBoldItalic(item, True, False)
            self.undo_model.appendRow(item)

def build_graph(self):
        for c, ports in self.graph.port_id_dict.items():
            rows = []
            for p, port in ports.items():
                if port.is_output and not port.hidden:
                    port_item = QtGui.QStandardItem(port.name)
                    port_name = '{}:{}'.format(port.client.name, port.name)
                    port_item.setData(port_name, NameRole)
                    port_item.setData(True, PortRole)
                    full_port_item = QtGui.QStandardItem(port_name)
                    setBold(port_item)
                    port_id = QtGui.QStandardItem('{}:{}'.format(port.client.id, port.id))
                    port_id.setData('{}:{}'.format(port.client.id, port.id), NameRole)
                    setBold(port_id)
                    rows.append([port_item, port_id, full_port_item])
            if rows:
               client_item = QtGui.QStandardItem(' {}'.format(port.client.name))
               client_item.setData('{}:.*'.format(port.client.name), NameRole)
               client_item.setData(QtGui.QBrush(QtCore.Qt.gray), QtCore.Qt.ForegroundRole)
               client_id = QtGui.QStandardItem(str(port.client.id))
               client_id.setData('{}:.*'.format(port.client.id), NameRole)
               client_id.setData(QtGui.QBrush(QtCore.Qt.gray), QtCore.Qt.ForegroundRole)
               self.graph_model.appendRow([client_item, client_id])
               for r in rows:
                   self.graph_model.appendRow(r)
        self.input_table.resizeColumnsToContents()
        self.input_table.resizeRowsToContents()

def blacklist_add(self):
        dialog = PortFilterDialog(self)
        res = dialog.exec_()
        if res:
            item = QtGui.QStandardItem(res)
            self.blacklist_model.appendRow(item)

def fb_add(self, table):
        if table.model().rowCount() > 8:
            QtGui.QMessageBox.question(self, 'Too many events', 'Too many events to send, are you crazy???')
            return
        ev_type = event_model[0].clone()
        chan_item = QtGui.QStandardItem('1')
        chan_item.setData(0, IdRole)
        chan_item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignCenter)
        param = QtGui.QStandardItem('{} - {}'.format(0, Controllers[0]))
        param.setData(0, IdRole)
        data2_item = QtGui.QStandardItem('0')
        data2_item.setData(0, IdRole)
        data2_item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignCenter)
        table.model().appendRow([ev_type, chan_item, param, data2_item])

def client_id_dialog(cls, main):
        def get_id(event):
            item = self.model.item(self.listview.indexAt(event.pos()).row())
            sel_id = item.data(IdRole).toString()
            if self.setter_edit.text() == sel_id:
                self.accept()
            self.setter_edit.setText(sel_id)
        def highlight(text):
            for item in [self.model.item(row) for row in range(self.model.rowCount())]:
                setItalic(item, True if item.data(IdRole).toString()==text else False)
        self = cls(main)
        self.description_lbl.setText(
                                     'Insert a client ID or select it from the list of the existing clients.\n\n'+
                                     'Remember, Client IDs can change during runtime. If you use ALSA, you '+
                                     'should use this only for system clients (highlighted in the list).\n'+
                                     'Using this filter for JACK is useless, use name filtering instead.'
                                     )
        self.setter_lbl.setText('Client ID:')
        self.setter_edit.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('[0-9]{1,12}')))
        self.listview.mouseDoubleClickEvent = get_id
        graph = main.main.graph
        for client_id in sorted(graph.client_id_dict.keys()):
            if not self.client_has_outputs(graph, client_id): continue
            client = graph.client_id_dict[client_id]
            item = QtGui.QStandardItem('{} ({})'.format(client.name, client.id))
            if client.type == alsaseq.SEQ_KERNEL_CLIENT:
                setBold(item)
            item.setData(client.id, IdRole)
            self.model.appendRow(item)
        self.setter_edit.textChanged.connect(highlight)
        if self.exec_() and self.setter_edit.text():
            return self.setter_edit.text()
        else:
            return None

def port_id_dialog(cls, main):
        def get_id(event):
            item = self.model.item(self.listview.indexAt(event.pos()).row())
            if not item.isEnabled(): return
            sel_id = item.data(IdRole).toString()
            if self.setter_edit.text() == sel_id:
                self.accept()
            self.setter_edit.setText(sel_id)
        def highlight(text):
            for item in [self.model.item(row) for row in range(self.model.rowCount())]:
                setItalic(item, True if item.data(IdRole).toString()==text else False)
        self = cls(main)
        self.description_lbl.setText(
                                     'Insert a port ID (in "client:port" format) or select it from the list of the existing ports.\n\n'+
                                     'Remember, port IDs can change during runtime. If you use ALSA, you '+
                                     'should use this only for system ports (highlighted in the list).\n'+
                                     'Using this filter for JACK is useless, use name filtering instead.'
                                     )
        self.setter_lbl.setText('Port ID:')
        self.setter_edit.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('[0-9]{1,12}:[0-9]{1,12}')))
        self.listview.mouseDoubleClickEvent = get_id
        graph = main.main.graph
        for client_id in sorted(graph.client_id_dict.keys()):
            if not self.client_has_outputs(graph, client_id): continue
            client = graph.client_id_dict[client_id]
            item = QtGui.QStandardItem('{} ({})'.format(client.name, client.id))
            item.setEnabled(False)
            self.model.appendRow(item)
            for port_id in sorted(graph.port_id_dict[client_id].keys()):
                port = graph.port_id_dict[client_id][port_id]
                if not port.is_output: continue
                item = QtGui.QStandardItem(' {} ({})'.format(port.name, port.id))
                if client.type == alsaseq.SEQ_KERNEL_CLIENT:
                    setBold(item)
                item.setData('{}:{}'.format(client.id, port.id), IdRole)
                self.model.appendRow(item)
        self.setter_edit.textChanged.connect(highlight)
        if self.exec_() and self.setter_edit.text():
            return self.setter_edit.text()
        else:
            return None

def stop_events_add(self):
        param_item = QtGui.QStandardItem('{} - {}'.format(1, Controllers[1]))
        param_item.setData(1, UserRole)
        value_item = QtGui.QStandardItem('0')
        value_item.setData(0, UserRole)
        value_item.setData(QtCore.Qt.AlignHCenter, QtCore.Qt.TextAlignmentRole)
        self.stop_events_model.appendRow([param_item, value_item])
        self.stop_events_list.resizeRowsToContents()

def defaults(self):
        res = QtGui.QMessageBox.question(self, 'Restore defaults?', 'Restore <b>all</b> values to default?', 
                                         QtGui.QMessageBox.Ok|QtGui.QMessageBox.Cancel)
        if not res: return
        self.max_rec_spin.setValue(defaults['max_rec'])
        self.autosave_chk.setChecked(False)
        self.autosave_path_edit.setText('')
        self.minimum_time_spin.setValue(defaults['minimum_time'])
        self.last_event_limit_spin.setValue(defaults['last_event_limit'])
        self.tick_res_spin.setValue(defaults['tick_res'])

        for row in range(self.stop_events_model.rowCount()-1, -1, -1):
            self.stop_events_model.takeRow(row)
        for param, value in defaults['stop_events']:
            param_item = QtGui.QStandardItem('{} - {}'.format(param, Controllers[param]))
            param_item.setData(param, UserRole)
            value_item = QtGui.QStandardItem(str(value))
            value_item.setData(value, UserRole)
            value_item.setData(QtCore.Qt.AlignHCenter, QtCore.Qt.TextAlignmentRole)
            self.stop_events_model.appendRow([param_item, value_item])
        self.stop_events_list.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Stretch)
        self.stop_events_list.resizeColumnToContents(1)
        self.stop_events_list.resizeRowsToContents()

        for btn in self.event_btn_group.buttons():
            btn.setChecked(False)
        for row in range(self.client_id_model.rowCount()):
            item = self.client_id_model.takeRow(row)[0]
            del item
        for row in range(self.port_id_model.rowCount()):
            item = self.port_id_model.takeRow(row)[0]
            del item
        for row in range(self.port_name_model.rowCount()):
            item = self.port_name_model.takeRow(row)[0]
            del item

def filter_dialog(self, ref):
        ref = self.reference[ref]
        res = ref.dialog(self)
        if res is not None:
            if ref.model.findItems(res): return
            item = QtGui.QStandardItem(str(res))
            ref.model.appendRow(item)
            ref.list.setCurrentIndex(ref.model.index(ref.model.rowCount()-1, 0))

def populatePhotos(self, index=0):
        self.model.clear()

        QApplication.setOverrideCursor(Qt.WaitCursor)

        # photos is a list of tuples (id, title, imagepath)
        photos = self._photosOfLandmark()
        for i in photos:

            tp=os.path.join(self.thumbpath, str(i[0])) +'.png'

            img=self.thumbnailPhoto(i[2],tp)

            icon = QIcon(img)

            title = i[1] if i[1] else '<unnamed photo> %s' % i[0]

            item = QStandardItem(title)
            item.setIcon(icon)
            item.setData(i[0], Qt.UserRole)
            item.setToolTip(title)
            self.model.appendRow(item)
            lastIdx = self.model.indexFromItem(item)

        idx = self.model.createIndex(0, 0)
        if self.model.rowCount() > 0:
            if index == -1:
                idx = lastIdx
            elif index > 0:
                idx = self.model.createIndex(index, 0)
            self.lstPhotos.selectionModel().select(idx, QItemSelectionModel.Select)
        else:
            self._clearForm()

        QApplication.restoreOverrideCursor()

def apply_data_to_file_table(self, files_data):

        model = TableModel(1, 1)
        file_list_header_labels = ['File name', 'File size', 'File ID']

        if DISPLAY_FILE_CREATION_DATE_IN_MAIN:
            file_list_header_labels.append('Creation date')

        model.setHorizontalHeaderLabels(file_list_header_labels)

        i = 0

        for self.file_details in files_data:
            item = QtGui.QStandardItem(
                str(self.file_details['filename'].replace('[DECRYPTED]', '')).decode('utf8'))
            model.setItem(i, 0, item)  # row, column, item (StandardItem)

            file_size_str = self.tools.human_size(int(self.file_details['size']))  # get human readable file size

            item = QtGui.QStandardItem(str(file_size_str))
            model.setItem(i, 1, item)  # row, column, item (QQtGui.StandardItem)

            # item = QtGui.QStandardItem(str(self.file_details['mimetype']))
            # model.setItem(i, 2, item)  # row, column, item (QStandardItem)

            item = QtGui.QStandardItem(str(self.file_details['id']))
            model.setItem(i, 2, item)  # row, column, item (QStandardItem)

            # print_(self.file_details)

            if DISPLAY_FILE_CREATION_DATE_IN_MAIN:
                item = QtGui.QStandardItem(str(self.file_details['created']).replace('Z', '').replace('T', ' '))
                model.setItem(i, 3, item)  # row, column, item (QStandardItem)

            i = i + 1

            # self.__logger.info(self.file_details)
            self.__logger.debug(self.file_details['filename'].replace('[DECRYPTED]', '').decode('utf8'))



        self.file_manager_ui.files_list_tableview.clearFocus()
        self.file_manager_ui.files_list_tableview.setModel(model)
        self.file_manager_ui.files_list_tableview.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
        if FILE_LIST_SORTING_MAIN_ENABLED:
            self.file_manager_ui.files_list_tableview.setSortingEnabled(True)
            self.file_manager_ui.files_list_tableview.horizontalHeader().sortIndicatorChanged.connect(
                self.handleSortIndicatorChanged)
            self.file_manager_ui.files_list_tableview.sortByColumn(0, QtCore.Qt.AscendingOrder)
        self.emit(QtCore.SIGNAL('changeLoadingGif'), False)
        return True

def fillTagModel(model,dcm,regex=None):
    '''Fill a QStandardItemModel object `model' with a tree derived from tags in `dcm', filtering by pattern `regex'.'''
    try:
        regex=re.compile(str(regex),re.DOTALL)
    except:
        regex='' # no regex or bad pattern

    def _datasetToItem(parent,d):
        '''Add every element in `d' to the QStandardItem object `parent', this will be recursive for list elements.'''
        for elem in d:
            value=_elemToValue(elem)
            tag='(%04x, %04x)'%(elem.tag.group,elem.tag.elem)
            parent1 = QtGui.QStandardItem(str(elem.name))
            tagitem = QtGui.QStandardItem(tag)

            if isinstance(value,str):
                try:
                    value=value.decode('ascii')
                    if '\n' in value or '\r' in value: # multiline text data should be shown as repr
                        value=repr(value)
                except:
                    value=repr(value)

                if not regex or re.search(regex,str(elem.name)+tag+value) is not None:
                    parent.appendRow([parent1,tagitem,QtGui.QStandardItem(value)])

            elif value is not None and len(value)>0:
                parent.appendRow([parent1,tagitem])
                for v in value:
                    parent1.appendRow(v)

    def _elemToValue(elem):
        '''Return the value in `elem', which will be a string or a list of QStandardItem objects if elem.VR=='SQ'.'''
        value=None
        if elem.VR=='SQ':
            value=[]
            for i,item in enumerate(elem):
                parent1 = QtGui.QStandardItem('%s %i'%(elem.name,i))
                _datasetToItem(parent1,item)
                if not regex or parent1.hasChildren(): # discard sequences whose children have been filtered out
                    value.append(parent1)
        elif elem.name!='Pixel Data':
            value=str(elem.value)

        return value        

    _datasetToItem(model,dcm)

def build(self, sound_list):
        invalid = []
        for sound_id, sound in enumerate(sound_list):
            res = sound.checkout()
            if res is not None:
                invalid.append((sound_id, res))
        if invalid:
            sound_list = ParamFixDialog(sound_list, invalid, self).exec_()
            if not sound_list:
                return False
        if self.sound_list:
            self.sounds_table.setRowCount(0)
        self.sound_list = sound_list
        self.export_list = []
        self.sounds_table.setRowCount(len(self.sound_list))
        for row, sound in enumerate(self.sound_list):
            export_item = QtGui.QStandardItem()
            export_item.setCheckable(True)
            check = SmallCheck()
            check.toggled.connect(lambda state, index=row: self.export_set(index, state))
            self.export_list.append(True)
            self.sounds_table.setCellWidget(row, 0, check)
            bank_item = QtGui.QTableWidgetItem(uppercase[sound.bank] if sound.bank < len(uppercase) else uppercase[-1])
            bank_item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            prog_item = QtGui.QTableWidgetItem('{:03}'.format(sound.prog+1))
            name_item = QtGui.QTableWidgetItem(QtCore.QString.fromUtf8(sound.name))
            cat_item = QtGui.QTableWidgetItem(categories[sound.cat] if sound.cat < len(categories) else categories[-1])
            self.sounds_table.setItem(row, 1, bank_item)
            self.sounds_table.setItem(row, 2, prog_item)
            self.sounds_table.setItem(row, 3, name_item)
            self.sounds_table.setItem(row, 4, cat_item)
            sound.nameChanged.connect(name_item.setText)
            sound.bankChanged.connect(lambda bank, item=bank_item: item.setText(uppercase[bank]))
        if len(self.sound_list) <= 128:
            allow_remap = True
        else:
            allow_remap = False
        self.bankmap_btn.setEnabled(allow_remap)
        self.bankmap_combo.setEnabled(allow_remap)
        self.bankmap_lbl.setEnabled(allow_remap)
        self.export_state = True
        return True

def _addSound(self, sound):
        bank = sound.bank
        prog = sound.prog
        self.data[bank][prog] = sound
#        self.sound_index[sound] = bank, prog

        index_item = QtGui.QStandardItem('{}{:03}'.format(uppercase[bank], prog+1))
        index_item.setData(bank*128+prog, IndexRole)
        index_item.setEditable(False)
        bank_item = QtGui.QStandardItem(uppercase[bank])
#        bank_item.setData(bank, UserRole)
        bank_item.setData(bank, BankRole)
        bank_item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignCenter)
        bank_item.setEditable(False)
        prog_item = QtGui.QStandardItem('{:03}'.format(prog+1))
#        prog_item.setData(prog, UserRole)
        prog_item.setData(prog, ProgRole)
        prog_item.setEditable(False)
        name_item = QtGui.QStandardItem(sound.name)
#        name_item.setData(sound.Osc_1_Shape, QtCore.Qt.ToolTipRole)
#        name_item.setData(sound.name, QtCore.Qt.ToolTipRole)
        cat_item = QtGui.QStandardItem(categories[sound.cat])
#        cat_item.setData(sound.cat, UserRole)
        cat_item.setData(sound.cat, CatRole)
#        status_item = QtGui.QStandardItem('Dumped' if sound.state == DUMPED else 'Stored')
        status_item = QtGui.QStandardItem(status_dict[sound.state])
        status_item.setData(sound.state, EditedRole)
        status_item.setEditable(False)
        sound_item = QtGui.QStandardItem()
        sound_item.setData(sound, SoundRole)
        sound.bankChanged.connect(lambda bank, item=bank_item: item.setData(bank, BankRole))
        sound.progChanged.connect(lambda prog, item=prog_item: item.setData(prog, ProgRole))
        sound.indexChanged.connect(lambda index, item=index_item: item.setData(index, IndexRole))
        sound.nameChanged.connect(lambda name, item=name_item: item.setText(name))
        sound.catChanged.connect(lambda cat, bank=bank, item=cat_item: self.soundSetCategory(item, bank, cat))
        sound.edited.connect(lambda state, item=status_item: item.setData(state, EditedRole))

        found = self.model.findItems('{}{:03}'.format(uppercase[bank], prog+1), QtCore.Qt.MatchFixedString, 0)
        if found:
            self.model.takeRow(found[0].row())

        self.model.appendRow([index_item, bank_item, prog_item, name_item, cat_item, status_item, sound_item])

def port_name_dialog(cls, main):
        def get_name(event):
            item = self.model.item(self.listview.indexAt(event.pos()).row())
            sel_name = str(item.data(NameRole).toString()).replace('(', '\(').replace(')', '\)')
            if self.setter_edit.text() == sel_name:
                self.accept()
            self.setter_edit.setText(sel_name)
        def highlight(text):
            print 'searching: {}'.format(text)
            try:
                regex = re.compile('{}'.format(str(text)))
            except:
                [setItalic(item, False) for item in [self.model.item(row) for row in range(self.model.rowCount())]]
                self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(False)
                return
            self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(True)
            for item in [self.model.item(row) for row in range(self.model.rowCount())]:
                print 'pattern: {}\tstring: {}'.format(regex.pattern, item.data(NameRole).toString())
                rm = regex.match(item.data(NameRole).toString())
                if rm: print rm.string
                setItalic(item, True if regex.match(item.data(NameRole).toString()) is not None else False)
        self = cls(main)
        self.description_lbl.setText(
                                     'Insert a client name or select it from the list of the existing clients.\n\n'+
                                     'Remember, with ALSA multiple client can share the same name, and this filter'+
                                     'will behave in the same way. On the other hand, JACK uses unique names, so'+
                                     'starting multiple instances of the same program will result in clients named'+
                                     '"client_01", "client_02", etc. In that case, you can use a regex, eg:'+
                                     '"client_name.*" will match every client name starting with "client_name"'
                                     )
        self.setter_lbl.setText('Client name')
        self.listview.mouseDoubleClickEvent = get_name
        graph = main.main.graph
        for client_id in sorted(graph.client_id_dict.keys()):
            if not self.client_has_outputs(graph, client_id): continue
            client = graph.client_id_dict[client_id]
            item = QtGui.QStandardItem('{} ({})'.format(client.name, client.id))
            item.setData('{}:.*'.format(client.name), NameRole)
            item.setEnabled(False)
            self.model.appendRow(item)
            for port_id in sorted(graph.port_id_dict[client_id].keys()):
                port = graph.port_id_dict[client_id][port_id]
                if not port.is_output: continue
                item = QtGui.QStandardItem(' {} ({})'.format(port.name, port.id))
                if client.type == alsaseq.SEQ_KERNEL_CLIENT:
                    setBold(item)
                item.setData('{}:{}'.format(client.name, port.name), NameRole)
                self.model.appendRow(item)
        self.setter_edit.textChanged.disconnect()
        self.setter_edit.textChanged.connect(highlight)
        if self.exec_() and self.setter_edit.text():
            return self.setter_edit.text()
        else:
            return None

def __init__(self, main):
        QtGui.QDialog.__init__(self, parent=None)
        _load_ui(self, 'settings.ui')
        self.main = main
        self.settings = self.main.settings

        #load filter settings will go here
        self.event_type_filter = self.settings.gFilters.get_event_type(set(), False)
        self.client_id_filter = self.settings.gFilters.get_client_id(set(), False)
        self.port_id_filter = self.settings.gFilters.get_port_id(set(), False)
        self.port_name_filter = self.settings.gFilters.get_port_name(set(), False)

        self.stop_events = self.settings.gGeneral.get_stop_events(defaults['stop_events'], False)
        self.stop_events_model = QtGui.QStandardItemModel()
        self.stop_events_list.setModel(self.stop_events_model)
        self.stop_events_list.setItemDelegate(self.StopDelegate(self))
        self.stop_events_model.setHorizontalHeaderLabels(['CTRL parameter', 'Value'])
        for param, value in self.stop_events:
            param_item = QtGui.QStandardItem('{} - {}'.format(param, Controllers[param]))
            param_item.setData(param, UserRole)
            value_item = QtGui.QStandardItem(str(value))
            value_item.setData(value, UserRole)
            value_item.setData(QtCore.Qt.AlignHCenter, QtCore.Qt.TextAlignmentRole)
            self.stop_events_model.appendRow([param_item, value_item])
        self.stop_events_list.resizeRowsToContents()
        self.stop_events_list.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Stretch)
        self.stop_events_list.resizeColumnToContents(1)
        self.stop_events_list.selectionChanged = self.stop_events_select
        self.stop_events_add_btn.clicked.connect(self.stop_events_add)
        self.stop_events_del_btn.clicked.connect(self.stop_events_del)

        self.max_rec_spin.setValue(self.settings.gGeneral.max_rec)
        self.minimum_time_spin.setValue(self.settings.gGeneral.minimum_time)
        self.last_event_limit_spin.setValue(self.settings.gGeneral.last_event_limit)
        self.autosave_chk.setChecked(self.settings.gGeneral.autosave)
        self.autosave_path_edit.setText(self.settings.gGeneral.get_autosave_path(''))
        self.tick_res_spin.setValue(self.settings.gGeneral.tick_res)

        self.autosave_chk.toggled.connect(self.autosave_set)
        self.autosave_path_btn.clicked.connect(self.autosave_path)

        self.allnotes_chk.clicked.connect(self.allnotes_click)
        self.noteon_chk.toggled.connect(self.note_toggled)
        self.noteon_chk.toggled.connect(lambda state: self.filter_event_set(NOTEON, state))
        self.noteoff_chk.toggled.connect(self.note_toggled)
        self.noteoff_chk.toggled.connect(lambda state: self.filter_event_set(NOTEOFF, state))
        self.ctrl_chk.toggled.connect(lambda state: self.filter_event_set(CTRL, state))
        self.pitchbend_chk.toggled.connect(lambda state: self.filter_event_set(PITCHBEND, state))
        self.aftertouch_chk.toggled.connect(lambda state: self.filter_event_set(AFTERTOUCH, state))
        self.polyaftertouch_chk.toggled.connect(lambda state: self.filter_event_set(POLY_AFTERTOUCH, state))
        self.program_chk.toggled.connect(lambda state: self.filter_event_set(PROGRAM, state))
        self.sysex_chk.toggled.connect(lambda state: self.filter_event_set(SYSEX, state))

        self.build_models()

        self.buttonBox.button(QtGui.QDialogButtonBox.RestoreDefaults).clicked.connect(self.defaults)
        self.buttonBox.button(QtGui.QDialogButtonBox.Apply).clicked.connect(self.check_changes)
        self.accepted.connect(self.check_changes)

def populate(self):
        self.event_buffer = self.main.event_buffer
        self.port_dict = {}
        client_dict = {}
        ev_set = set()
        for event, time, source, enabled in self.event_buffer:
            if event.type == NOTEON and event.data2 == 0:
                ev_set.add(NOTEOFF)
            else:
                ev_set.add(event.type)
            client_name, port_name, (client_id, port_id) = source
            if not client_id in client_dict:
                client_dict[client_id] = {
                                          'name': client_name, 
                                          'ports': {port_id: port_name}, 
                                          }
            else:
                client_dict[client_id]['ports'][port_id] = port_name
        for t, widget in self.event_widgets.items():
            widget.setEnabled(True if t in ev_set else False)
        self.allnotes_chk.setEnabled(True if set([NOTEON, NOTEOFF]).issubset(ev_set) else False)
        self.track_items = {}
        dest_list_index = 0
        for client_id in sorted(client_dict.keys()):
            client_name = client_dict[client_id]['name']
            client_item = QtGui.QStandardItem('{} ({})'.format(client_name, client_id))
            client_item.setForeground(QtGui.QBrush(QtCore.Qt.gray))
            client_item.export = True if not client_name in self.main.filter_list[COL_SRC_CLIENT] else False
            client_item.name = client_name
            client_item.is_client = True
            client_item.ports = {}
            self.src_model.appendRow(client_item)
            for port_id, port_name in [(p, client_dict[client_id]['ports'][p]) for p in sorted(client_dict[client_id]['ports'].keys())]:
                port_item = QtGui.QStandardItem(' {} ({})'.format(port_name, port_id))
                addr = '{}:{}'.format(client_id, port_id)
                if client_item.export and not (addr in self.main.filter_list[COL_SRC_ADDR] or port_name in self.main.filter_list[COL_SRC_PORT]):
                    export = True
                else:
                    export = False
                port_item.export = export
                port_item.name = port_name
                port_item.is_client = False
                client_item.ports[port_id] = port_item
                setBold(port_item, export)
                self.src_model.appendRow(port_item)
                self.port_dict[(client_id, port_id)] = port_item

                name = '{} ({})'.format(port_name, port_id)
                dest_item = QtGui.QStandardItem(name)
                dest_item.setFlags(dest_item.flags() ^ QtCore.Qt.ItemIsDropEnabled)
                dest_item.setData(name, NameRole)
                dest_item.setData(dest_list_index, OrdRole)
                dest_item.setData((client_id, port_id), DestRole)
                dest_item.setData(export, EnabledRole)
                dest_item.setEnabled(export)
                dest_list_index += 1
                self.dest_model.appendRow(dest_item)
                self.track_items[(client_id, port_id)] = dest_item
                port_item.setData(dest_item, DestRole)
        self.filled = True