class MasterAnnotationFilterWidget(CommonAnnotationFilterWidget):
    def __init__(self, parent, **params):
        super(MasterAnnotationFilterWidget, self).__init__(parent, **params)

    @property
    def action_button(self):
        return self.__action_button__

    def createActionButton(self):
        self.__action_button__ = PushButtonWidget(self, i18n_def='Apply',
                                clicked_handler=self.__annotation_handler__)
        self.__action_button__.setChecked(False)
        self.__action_button__.setEnabled(False)

    def __annotation_handler__(self):
        self.annotation_filter.excluded_annotations = self.excluded_annotations
        run_filter(self.parent(), self.annotation_filter, self.data_accessor,
                   filter_name='annotation')
        self.setDisabledAnnotations(self.excluded_annotations)
        self.disableIfAllChecked()
        self.__action_button__.setEnabled(False)
class TachogramPlotDatasourceListWidget(CommonWidget):
    def __init__(self, parent, model, **params):
        super(TachogramPlotDatasourceListWidget, self).__init__(parent,
                                                    add_widget_to_parent=True,
                                                    layout=QVBoxLayout())
        self.params = Params(**params)
        toolbars = ToolBarManager(self, CheckUncheckToolBarWidget,
                OperationalToolBarWidget,
                toolbar_close_handler=self.params.close_tachogram_plot_handler)
        self.layout().addWidget(toolbars)

        self.__showTachogramsButton__ = PushButtonWidget(self,
                    i18n="poincare.plot.show.tachograms.button",
                    i18n_def="Show tachograms",
                    enabled=False,
                    clicked_handler=self.__showTachogramsHandler__,
                    enabled_precheck_handler=self.__enabledPrecheckHandler__)

        self.__allowTachogramsDuplicationButton__ = CheckBoxWidget(self,
                    i18n="poincare.plot.allow.tachograms.duplications.button",
                    i18n_def="Allow tachograms duplication",
                    enabled=False,
                    enabled_precheck_handler=self.__enabledPrecheckHandler__)

        self.__closeAllTachogramsButton__ = PushButtonWidget(self,
                    i18n="poincare.plot.close.all.tachograms.button",
                    i18n_def="Close all tachograms",
                    enabled=False,
                    clicked_handler=self.__closeTachogramsHandler__)

        self.__datasourceList__ = \
            ListWidgetWidget(self,
                list_item_clicked_handler=self.__datasourceItemClickedHandler__, # @IgnorePep8
                list_item_double_clicked_handler=self.__datasourceDoubleItemClickedHandler__, # @IgnorePep8
                selectionMode=QAbstractItemView.MultiSelection,
                selectionBehavior=QAbstractItemView.SelectRows)
        if len(model) > 0:
            for row in range(len(model)):
                fileSpecification = model[row]
                ListWidgetItemWidget(self.__datasourceList__,
                                     text=fileSpecification.filename,
                                     data=fileSpecification)
        else:
            ListWidgetItemWidget(self.__datasourceList__,
                                 text='model not specified or incorrect type')

        self.__filesPreviewButton__ = PushButtonWidget(self,
                    i18n="poincare.plot.files.preview.button",
                    i18n_def="Files preview",
                    enabled=False,
                    clicked_handler=self.__filesPreviewHandler__,
                    enabled_precheck_handler=self.__enabledPrecheckHandler__)

    def __datasourceItemClickedHandler__(self, listItem):
        self.emit(ENABLEMEND_SIGNAL, listItem.isSelected())

    def __showTachogramsHandler__(self):
        self.__showTachograms__(self.__getFilesSpecifications__(selected=True))

    def __filesPreviewHandler__(self):
        showFilesPreviewDialog(self.__getFilesSpecifications__(selected=True))

    def __datasourceDoubleItemClickedHandler__(self, listItem):
        self.__showTachograms__(self.__getFilesSpecifications__([listItem]))

    def __showTachograms__(self, files_specifications):
        progressManager = ProgressDialogManager(self,
                                        label_text="Create tachograms",
                                        max_value=len(files_specifications))
        firstFocus = True
        checked = self.__allowTachogramsDuplicationButton__.isChecked()
        with progressManager as progress:
            for idx in range(progress.maximum()):
                if (progress.wasCanceled()):
                    break
                progress.increaseCounter()
                tachogram_plot = self.params.add_tachogram_plot_handler(
                                            files_specifications[idx],
                                            checked, firstFocus)
                if firstFocus and tachogram_plot:
                    firstFocus = False

        self.__datasourceList__.clearSelection()

    def __enabledPrecheckHandler__(self, widget):
        """
        only interested widgets return bool value others return none value
        """
        if widget in (self.__showTachogramsButton__,
                      self.__allowTachogramsDuplicationButton__,
                      self.__filesPreviewButton__):
            return len(self.__datasourceList__.selectedIndexes()) > 0

    def __closeTachogramsHandler__(self):
        if self.params.close_tachograms_handler:
            if self.params.close_tachograms_handler():
                self.__closeAllTachogramsButton__.setEnabled(False)
        self.toolbar_uncheck_handler()

    def toolbar_uncheck_handler(self):
        self.__datasourceList__.clearSelection()
        self.emit(ENABLEMEND_SIGNAL, False)

    def toolbar_check_handler(self):
        self.__datasourceList__.selectAll()
        self.emit(ENABLEMEND_SIGNAL, True)

    def toolbar_maximum_handler(self):
        maximize_widget(self)

    def toolbar_restore_handler(self):
        restore_widget(self)

    def enabledCloseAllTachogramsButton(self, enabled):
        self.__closeAllTachogramsButton__.setEnabled(enabled)

    def __getFilesSpecifications__(self, list_items=None, selected=False):
        if selected:  # get files specifications from selected items
            list_items = self.__datasourceList__.selectedItems()
        #acquired from data buffer of list items file specification objects
        return [list_item.getData() for list_item in list_items]

    def getSelectedFilesSpecifications(self):
        """
        method returns selected files specifications in tachogram plot
        list widget
        """
        return self.__getFilesSpecifications__(selected=True)
class TachogramPlotDatasourceListWidget(CommonWidget):
    def __init__(self, parent, model, **params):
        super(TachogramPlotDatasourceListWidget,
              self).__init__(parent,
                             add_widget_to_parent=True,
                             layout=QVBoxLayout())
        self.params = Params(**params)
        toolbars = ToolBarManager(
            self,
            CheckUncheckToolBarWidget,
            OperationalToolBarWidget,
            toolbar_close_handler=self.params.close_tachogram_plot_handler)
        self.layout().addWidget(toolbars)

        self.__showTachogramsButton__ = PushButtonWidget(
            self,
            i18n="poincare.plot.show.tachograms.button",
            i18n_def="Show tachograms",
            enabled=False,
            clicked_handler=self.__showTachogramsHandler__,
            enabled_precheck_handler=self.__enabledPrecheckHandler__)

        self.__allowTachogramsDuplicationButton__ = CheckBoxWidget(
            self,
            i18n="poincare.plot.allow.tachograms.duplications.button",
            i18n_def="Allow tachograms duplication",
            enabled=False,
            enabled_precheck_handler=self.__enabledPrecheckHandler__)

        self.__closeAllTachogramsButton__ = PushButtonWidget(
            self,
            i18n="poincare.plot.close.all.tachograms.button",
            i18n_def="Close all tachograms",
            enabled=False,
            clicked_handler=self.__closeTachogramsHandler__)

        self.__datasourceList__ = \
            ListWidgetWidget(self,
                list_item_clicked_handler=self.__datasourceItemClickedHandler__, # @IgnorePep8
                list_item_double_clicked_handler=self.__datasourceDoubleItemClickedHandler__, # @IgnorePep8
                selectionMode=QAbstractItemView.MultiSelection,
                selectionBehavior=QAbstractItemView.SelectRows)
        if len(model) > 0:
            for row in range(len(model)):
                fileSpecification = model[row]
                ListWidgetItemWidget(self.__datasourceList__,
                                     text=fileSpecification.filename,
                                     data=fileSpecification)
        else:
            ListWidgetItemWidget(self.__datasourceList__,
                                 text='model not specified or incorrect type')

        self.__filesPreviewButton__ = PushButtonWidget(
            self,
            i18n="poincare.plot.files.preview.button",
            i18n_def="Files preview",
            enabled=False,
            clicked_handler=self.__filesPreviewHandler__,
            enabled_precheck_handler=self.__enabledPrecheckHandler__)

    def __datasourceItemClickedHandler__(self, listItem):
        self.emit(ENABLEMEND_SIGNAL, listItem.isSelected())

    def __showTachogramsHandler__(self):
        self.__showTachograms__(self.__getFilesSpecifications__(selected=True))

    def __filesPreviewHandler__(self):
        showFilesPreviewDialog(self.__getFilesSpecifications__(selected=True))

    def __datasourceDoubleItemClickedHandler__(self, listItem):
        self.__showTachograms__(self.__getFilesSpecifications__([listItem]))

    def __showTachograms__(self, files_specifications):
        progressManager = ProgressDialogManager(
            self,
            label_text="Create tachograms",
            max_value=len(files_specifications))
        firstFocus = True
        checked = self.__allowTachogramsDuplicationButton__.isChecked()
        with progressManager as progress:
            for idx in range(progress.maximum()):
                if (progress.wasCanceled()):
                    break
                progress.increaseCounter()
                tachogram_plot = self.params.add_tachogram_plot_handler(
                    files_specifications[idx], checked, firstFocus)
                if firstFocus and tachogram_plot:
                    firstFocus = False

        self.__datasourceList__.clearSelection()

    def __enabledPrecheckHandler__(self, widget):
        """
        only interested widgets return bool value others return none value
        """
        if widget in (self.__showTachogramsButton__,
                      self.__allowTachogramsDuplicationButton__,
                      self.__filesPreviewButton__):
            return len(self.__datasourceList__.selectedIndexes()) > 0

    def __closeTachogramsHandler__(self):
        if self.params.close_tachograms_handler:
            if self.params.close_tachograms_handler():
                self.__closeAllTachogramsButton__.setEnabled(False)
        self.toolbar_uncheck_handler()

    def toolbar_uncheck_handler(self):
        self.__datasourceList__.clearSelection()
        self.emit(ENABLEMEND_SIGNAL, False)

    def toolbar_check_handler(self):
        self.__datasourceList__.selectAll()
        self.emit(ENABLEMEND_SIGNAL, True)

    def toolbar_maximum_handler(self):
        maximize_widget(self)

    def toolbar_restore_handler(self):
        restore_widget(self)

    def enabledCloseAllTachogramsButton(self, enabled):
        self.__closeAllTachogramsButton__.setEnabled(enabled)

    def __getFilesSpecifications__(self, list_items=None, selected=False):
        if selected:  # get files specifications from selected items
            list_items = self.__datasourceList__.selectedItems()
        #acquired from data buffer of list items file specification objects
        return [list_item.getData() for list_item in list_items]

    def getSelectedFilesSpecifications(self):
        """
        method returns selected files specifications in tachogram plot
        list widget
        """
        return self.__getFilesSpecifications__(selected=True)
Exemple #4
0
class FiltersWidget(CompositeWidget):
    """
    a composite widget to choose a filtering method based on
    subclasses of Filter class
    """
    @temporarySettingsDecorator()
    def __init__(self, parent, **params):
        get_or_put(params, 'layout', QVBoxLayout())
        super(FiltersWidget, self).__init__(parent, **params)
        self.params = Params(**params)
        self.data_accessor = self.params.data_accessor  # alias
        #if self.params.use_apply_button == True:
        if 1 == 1:
            self.data_accessor.addListener(self,
                                __FilterActivatedDataVectorListener__(self))

        filtersGroup = GroupBoxWidget(self, layout=QVBoxLayout(),
                                      i18n_def=params.get('title', 'Filters'))
        annotation_widget_class = params.get('annotation_widget_class', False)
        if annotation_widget_class:
            self.__annotation_filter__ = annotation_widget_class(
                                filtersGroup, data_accessor=self.data_accessor)
        else:
            self.__annotation_filter__ = CommonAnnotationFilterWidget(
                                filtersGroup, data_accessor=self.data_accessor)

        self.__square_filter__ = SquareFilterWidget(filtersGroup,
                                data_accessor=self.data_accessor,
                                use_apply_button=self.params.use_apply_button)

        if params.get('restore_button', False):
            self.__restore_button__ = PushButtonWidget(filtersGroup,
                                     i18n_def='Back to unfiltered data',
                                     clicked_handler=self.__restore_handler__,
                                     enabled=False)

    def __restore_handler__(self):
        self.data_accessor.restore(remove_filter_names=True)
        self.__annotation_filter__.reset()
        self.__square_filter__.reset()
        if hasattr(self, '__restore_button__'):
            self.__restore_button__.setEnabled(False)

    def enableRestoreButton(self):
        if hasattr(self, '__restore_button__'):
            self.__restore_button__.setEnabled(True)

    def getSquareFilterParams(self):
        return self.__square_filter__.getSquareFilterParams()

    @temporarySetterDecorator(name='square_filter_params',
                              _conv=QVariant.toPyObject,
                              _getter_handler=getSquareFilterParams)
    def setSquareFilterParams(self, square_filter_params):
        self.__square_filter__.setSquareFilterParams(square_filter_params)

    def getAnnotationFilterParams(self):
        return self.__annotation_filter__.getAnnotationFilterParams()

    @temporarySetterDecorator(name='annotation_filter_params',
                              _conv=QVariant.toPyObject,
                              _getter_handler=getAnnotationFilterParams)
    def setAnnotationFilterParams(self, annotation_filter_params):
        self.__annotation_filter__.setAnnotationFilterParams(
                                                annotation_filter_params)
class ChooseColumnsDataPage(QWizardPage):

    def __init__(self, _parent, datasource_page_id):
        QWizardPage.__init__(self, parent=_parent)
        self.datasource_page_id = datasource_page_id
        self.pageLayout = None
        self.headersTablePreview = None

        self.__dataFilesHeaders__ = {}
        self.__signalColumnIndexes__ = {}  # includes selected signal column indexes @IgnorePep8
        self.__annotationColumnIndexes__ = {}  # includes selected annotation column indexes @IgnorePep8
        self.__timeColumnIndexes__ = {}  # includes selected [optional] time column indexes @IgnorePep8

        self.__globalSeparator__ = None
        self.__globalCheckBox__ = None
        self.__globalIndex__ = GlobalIndex(None, None, None)

        self.__headerWidgets__ = []
        self.__widgetsHorizontalHeader__ = None

        self.__signal_header_element__ = HeaderElement('signal', 'signal', self.__signalWidgetHandler__) # @IgnorePep8
        self.__annotation_header_element__ = HeaderElement('annotation', 'annotation', self.__annotationWidgetHandler__) # @IgnorePep8
        self.__time_header_element__ = HeaderElement('time', 'time', self.__timeWidgetHandler__) # @IgnorePep8

    def initializePage(self):
        self.setTitle('Choose column data')
        #self.setSubTitle('Choose column specific data')

        if self.pageLayout == None:
            self.pageLayout = QVBoxLayout()
            self.setLayout(self.pageLayout)
            self.__createTableView__(self.pageLayout)
        #select the first row
        self.filesTableView.selectRow(0)
        self.separatorWidget.setGlobalSeparatorAsDefault()

    def __createTableView__(self, pageLayout):
        self.tableViewComposite = CompositeWidget(self, layout=QVBoxLayout())

        datasource_page = self.wizard().page(self.datasource_page_id)
        model = CheckStateProxySortFilterModel(self)
        model.setSourceModel(datasource_page.getDatasourceModel())
        model.setDynamicSortFilter(True)

        self.filesTableView = FilesTableView(self.tableViewComposite,
                                        model=model,
                                        onClickedAction=self.onClickedAction,
                                        wizardButtons=(QWizard.NextButton,),
                                        wizard_handler=self.wizard,
                                        sorting=True)
        self.filesTableView.setColumnHidden(0, True)

        self.filePreviewButton = PushButtonWidget(self.tableViewComposite,
                            i18n="datasource.file.preview.button",
                            i18n_def="File preview",
                            enabled=False,
                            clicked_handler=self.filePreviewAction)

        self.separatorWidget = GlobalSeparatorWidget(self.tableViewComposite,
                                separatorHandler=self.__separatorHandler__,
                                globalHandler=self.__globalSeparatorHandler__,
                                enabled=False)

        self.__createHeaderPreviewGroup__()

        self.__activity__ = ActivityWidget(self)

        self.__timeUnitsGroup__ = self.__createTimeUnitsGroup__()

    def __createTimeUnitsGroup__(self):
        return TimeUnitsWidget(self.tableViewComposite,
                               i18n_def='Signal time unit')

    def onClickedAction(self, idx):
        self.filePreviewButton.setEnabled(True)
        self.filesTableView.onClickedAction(
                                self.filesTableView.model().mapToSource(idx))
        #global separator could be None
        self.__createFileHeadersPreview__(self.__globalSeparator__)
        if self.__globalSeparator__:
            self.separatorWidget.setSeparator(self.__globalSeparator__)
        else:
            self.separatorWidget.setSeparator(self.__getSelectedSeparator__())
        self.separatorWidget.setEnabled(True)

    def filePreviewAction(self):
        showFilesPreviewDialog(
                        self.filesTableView.getSelectedPathAndFilename())

    def __separatorHandler__(self, _separator):
        self.__createFileHeadersPreview__(_separator)

    def __globalSeparatorHandler__(self, _checked, _separator=None):
        self.__globalSeparator__ = _separator

    def __createFileHeadersPreview__(self, _separator=None):

        dataFileHeader = self.__getDataFileHeader__(_separator)
        if dataFileHeader == None:
            return

        self.__createHeadersTablePreview__()

        colCount = dataFileHeader.getHeadersCount()
        model = self.__createHeadersTablePreviewModel__(colCount)

        self.__widgetsHorizontalHeader__ = WidgetsHorizontalHeader(
                                                    self.headersTablePreview)

        # create header line
        pathFile = self.filesTableView.getSelectedPathAndFilename()
        self.__headerWidgets__ = []
        for headerLine in dataFileHeader.getHeadersLines(1):
            for num, header in enumerate(headerLine):
                widget = HeaderWidget(self.__widgetsHorizontalHeader__,
                                      header,
                                      [self.__signal_header_element__,
                                       self.__annotation_header_element__,
                                       self.__time_header_element__])
                self.__headerWidgets__.append(widget)
                # some value of global indicator have to be not None
                if not nvl(*self.__globalIndex__) == None:
                    widget.enabledAll(False)
                    if self.__globalIndex__.signal == num:  # signal index
                        widget.check(self.__signal_header_element__.name)
                    elif self.__globalIndex__.annotation == num:  # annotation index @IgnorePep8
                        widget.check(self.__annotation_header_element__.name)
                    if self.__globalIndex__.time == num:  # time index
                        widget.check(self.__time_header_element__.name)
                elif self.__signalColumnIndexes__.get(pathFile) == num:
                    widget.check(self.__signal_header_element__.name)
                elif self.__annotationColumnIndexes__.get(pathFile) == num:
                    widget.check(self.__annotation_header_element__.name)
                elif self.__timeColumnIndexes__.get(pathFile) == num:
                    widget.check(self.__time_header_element__.name)
        self.__widgetsHorizontalHeader__.setWidgets(self.__headerWidgets__)

        # create data lines
        for rowData in dataFileHeader.getDataLines():
            modelData = list()
            for idx in range(colCount):
                modelData.append(QStandardItem(rowData[idx]
                                        if colCount <= len(rowData) else ""))
            model.appendRow(modelData)

        self.fileHeaderPreviewGroup.setEnabled(True)
        self.fileHeaderPreviewGroup.show()

    def __getDataFileHeader__(self, _separator=None):
        pathFile = self.filesTableView.getSelectedPathAndFilename()
        if pathFile == None:
            ErrorWindow(message="The file must be selected !")
        else:
            return self.__createDataFileHeader__(pathFile, _separator)

    def __createHeadersTablePreviewModel__(self, colNumber):
        model = PreviewDataViewModel(self.headersTablePreview)
        labels = QStringList(create_list("", colNumber))
        model.setHorizontalHeaderLabels(labels)
        self.headersTablePreview.setModel(model)
        return model

    def __createHeadersTablePreview__(self):

        self.__createHeaderPreviewGroup__()

        self.headersTablePreview = TableViewWidget(self.fileHeaderPreviewGroup,
                            selectionBehavior=QAbstractItemView.SelectRows,
                            selectionMode=QAbstractItemView.SingleSelection)

        self.__globalCheckBox__ = CheckBoxWidget(
                                    self.fileHeaderPreviewGroup,
                                    i18n="global.data.column.index",
                                    i18n_def="Global columns indexes",
                                    clicked_handler=self.__globalClicked__)
        if self.__globalIndex__.signal:
            self.__globalCheckBox__.setChecked(True)

    def __createDataFileHeader__(self, pathFile, _separator):
        dataFileHeader = self.__dataFilesHeaders__.get(pathFile, None)
        if dataFileHeader == None:
            dataFileHeader = DataFileHeader(pathFile)
            self.__dataFilesHeaders__[pathFile] = dataFileHeader

        if _separator == None:
            _separator = dataFileHeader.getSeparator()

        if _separator == None:
            #try to discover a separator based on file data
            _separator = dataFileHeader.getSeparator(generate=True)

        dataFileHeader.setSeparator(_separator)
        return dataFileHeader

    def __getSelectedSeparator__(self):
        pathFile = self.filesTableView.getSelectedPathAndFilename()
        if pathFile:
            dataFileHeader = self.__dataFilesHeaders__.get(pathFile)
            if dataFileHeader:
                return dataFileHeader.getSeparator()

    # for future use
    def __setSeparatorForAll__(self, _separator=None):
        model = self.filesTableView.model()
        for row in range(model.rowCount()):
            #it's necessity to alter model index of QSortFilterProxyModel type
            #into source model index of QStandardItemModel type
            idx = model.mapToSource(model.index(row, 0))
            pathFile = self.filesTableView.getPathAndFilename(idx)
            if pathFile:
                self.__createDataFileHeader__(pathFile, _separator)

    def __signalWidgetHandler__(self, _widget):
        self.__widgetHandler__(_widget, self.__signal_header_element__.name)

    def __annotationWidgetHandler__(self, _widget):
        self.__widgetHandler__(_widget, self.__annotation_header_element__.name)  # @IgnorePep8

    def __timeWidgetHandler__(self, _widget):
        self.__widgetHandler__(_widget, self.__time_header_element__.name)

    def __widgetHandler__(self, _widget, _type):
        checked = _widget.isChecked(_type)
        pathFile = self.filesTableView.getSelectedPathAndFilename()
        if checked:
            for num, widget in enumerate(self.__headerWidgets__):
                if widget == _widget:
                    if _type == self.__signal_header_element__.name:
                        _widget.uncheck(self.__annotation_header_element__.name) # @IgnorePep8
                        self.__signalColumnIndexes__[pathFile] = num
                    elif _type == self.__annotation_header_element__.name:
                        _widget.uncheck(self.__signal_header_element__.name)
                        _widget.uncheck(self.__time_header_element__.name)
                        self.__annotationColumnIndexes__[pathFile] = num
                    elif _type == self.__time_header_element__.name:
                        _widget.uncheck(self.__annotation_header_element__.name) # @IgnorePep8
                        self.__timeColumnIndexes__[pathFile] = num
                else:
                    if _type == self.__signal_header_element__.name:
                        widget.uncheck(self.__signal_header_element__.name)
                    elif _type == self.__annotation_header_element__.name:
                        widget.uncheck(self.__annotation_header_element__.name)
                    elif _type == self.__time_header_element__.name:
                        widget.uncheck(self.__time_header_element__.name)

            self.__globalCheckBox__.setEnabled(True)
        else:
            if _type == self.__signal_header_element__.name:
                self.__signalColumnIndexes__[pathFile] = None
            elif _type == self.__annotation_header_element__.name:
                self.__annotationColumnIndexes__[pathFile] = None
            elif _type == self.__time_header_element__.name:
                self.__timeColumnIndexes__[pathFile] = None

    def __globalClicked__(self):

        _signal = None
        _annotation = None
        _time = None
        if self.__globalCheckBox__.isChecked():
            for num, widget in enumerate(self.__headerWidgets__):
                if widget.isChecked(self.__signal_header_element__.name):
                    _signal = num
                if widget.isChecked(self.__annotation_header_element__.name):
                    _annotation = num
                if widget.isChecked(self.__time_header_element__.name):
                    _time = num
            index = GlobalIndex(_signal, _annotation, _time)
            if index.signal == None:
                self.__globalCheckBox__.setChecked(False)
                InformationWindow(None,
                        message='At least signal column has to be selected !')
                return
            else:
                for num, widget in enumerate(self.__headerWidgets__):
                    widget.enabledAll(False)
                self.__globalIndex__ = index
                self.__setGlobalIndexForAll__(self.__globalIndex__)
        else:
            for widget in self.__headerWidgets__:
                widget.enabledAll(True)
            self.__globalIndex__ = GlobalIndex(None, None, None)

    def __setGlobalIndexForAll__(self, _globalIndex):
        model = self.filesTableView.model()
        for row in range(model.rowCount()):
            #it's necessity to alter model index of QSortFilterProxyModel type
            #into source model index of QStandardItemModel type
            idx = model.mapToSource(model.index(row, 0))
            pathFile = self.filesTableView.getPathAndFilename(idx)
            if pathFile:
                self.__signalColumnIndexes__[pathFile] = _globalIndex.signal

                if _globalIndex.annotation:  # annontation global index
                    self.__annotationColumnIndexes__[pathFile] = \
                                                    _globalIndex.annotation
                if _globalIndex.time:  # time global index
                    self.__timeColumnIndexes__[pathFile] = \
                                                    _globalIndex.time

    def __createHeaderPreviewGroup__(self):
        if hasattr(self, 'fileHeaderPreviewGroup'):
            self.fileHeaderPreviewGroup.deleteLater()
        self.fileHeaderPreviewGroup = GroupBoxWidget(self.tableViewComposite,
                                    i18n="datasource.file.header.preview",
                                    i18n_def="Header preview",
                                    layout=QVBoxLayout(),
                                    hidden=True,
                                    enabled=False)

    def validatePage(self):
        filesSpecificationModel = DatasourceFilesSpecificationModel()
        for (_path, _filename, _signalIndex, _annotationIndex, _timeIndex,
             _separator) in \
            self.__getFilesSpec__(indexes=True, separators=True):
                if _signalIndex == None:
                    ErrorWindow(message=("No signal column for the file %s !"
                                         % (_filename)))
                    return False
                if _separator == None:
                    ErrorWindow(message=("No separator for file %s !"
                                         % (_filename)))
                    return False
                filesSpecificationModel.appendRow(_path, _filename,
                    _signalIndex, _annotationIndex, _timeIndex, _separator,
                    self.__timeUnitsGroup__.getUnit())

        PluginsManager.invokePlugin(PluginsNames.TACHOGRAM_PLOT_PLUGIN_NAME,
                    inspect.stack(),
                    model=filesSpecificationModel.getAsFilesSpecifications(),
                    activity_description=self.__activity__.description(),
                    activity_params=['model'])
        return True

    def __getFilesSpec__(self, _pathfile=True,
                         indexes=False, use_global_index=True,
                         separators=False, use_global_separator=True):
        filesSpec = []
        model = self.filesTableView.model()
        for row in range(model.rowCount()):
            #it's necessity to alter model index of QSortFilterProxyModel type
            #into source model index of QStandardItemModel type
            idx = model.mapToSource(model.index(row, 0))
            pathFile = self.filesTableView.getPathAndFilename(idx)

            if pathFile:
                fileSpec = []
                if _pathfile == True:
                    fileSpec.extend(pathFile)

                if indexes == True:
                    signalIndex = self.__signalColumnIndexes__.get(pathFile)
                    if signalIndex == None and use_global_index == True and \
                        not self.__globalIndex__.signal == None:
                        signalIndex = self.__globalIndex__.signal
                    fileSpec.append(signalIndex)

                    annotationIndex = self.__annotationColumnIndexes__.get(
                                                                   pathFile)
                    if annotationIndex == None and use_global_index == True \
                        and not self.__globalIndex__.annotation == None:
                        annotationIndex = self.__globalIndex__.annotation
                    fileSpec.append(annotationIndex)

                    timeIndex = self.__timeColumnIndexes__.get(pathFile)
                    if timeIndex == None and use_global_index == True \
                        and not self.__globalIndex__.time == None:
                        timeIndex = self.__globalIndex__.time
                    fileSpec.append(timeIndex)

                if separators == True:
                    separator = None
                    dataFileHeader = self.__dataFilesHeaders__.get(pathFile)
                    if not dataFileHeader == None:
                        separator = dataFileHeader.getSeparator()
                    if separator == None and use_global_separator == True:
                        separator = self.__globalSeparator__
                    fileSpec.append(separator)
                filesSpec.append(tuple(fileSpec))
        return filesSpec
class StatisticsWidget(GroupBoxWidget):
    """
    widget adds an action of statistics calculations into statistics widget
    """
    def __init__(self, parent, **params):
        get_or_put(params, 'layout', QVBoxLayout())
        get_or_put(params, 'i18n_def', 'Statistics')
        super(StatisticsWidget, self).__init__(parent, **params)
        self.params = Params(**params)

        self.data_accessors = []
        self.main_data_accessor = None
        if not self.params.data_vectors_accessor_group == None:
            self.data_accessors = self.params.data_vectors_accessor_group.data_vectors_accessors # @IgnorePep8
            self.main_data_accessor = self.params.data_vectors_accessor_group.group_data_vector_accessor # @IgnorePep8
        elif not self.params.data_accessor == None:
            self.main_data_accessor = self.params.data_accessor
            self.data_accessors = [self.main_data_accessor]

        for data_accessor in self.data_accessors:
            data_accessor.addListener(self, __StatisticsVectorListener__(self))

        self.__createButtons__()
        self.__statistics_widget__ = StatisticsSelectionWidget(self,
                    layout=QVBoxLayout(), i18n_def='',
                    check_handler=self.__change_statistics_handler__)

        self.__summary_statistics_widget__ = SummaryStatisticsSelectionWidget(
                    self, layout=QVBoxLayout(), i18n_def='Summary statistics',
                    check_handler=self.__change_statistics_handler__)

    def __createButtons__(self):
        buttons_composite = CompositeWidget(self, layout=QHBoxLayout())
        self.__calculate_button__ = PushButtonWidget(buttons_composite,
                                            i18n_def="Calculate statistics",
                    clicked_handler=self.__calculate_statistics_handler__)
        self.__enabled_calculation_button__(False)

        self.__save_outcomes_button__ = CheckBoxWidget(buttons_composite,
                                    i18n_def="Save outcomes", enabled=False)

        #if parameter save_outcomes_fixed_state is not None
        #then it's equal to checked state of save outcomes button
        #and this state couldn't be change later by a user
        if self.params.save_outcomes_fixed_state:
            self.__save_outcomes_button__.setChecked(
                                        self.params.save_outcomes_fixed_state)

    def __calculate_statistics_handler__(self):
        if len(self.data_accessors) == 0:
            return

        self.main_data_accessor.prepareParametersContainer()
        #processing many data accessors objects:
        #self.data_accessors object contains many data_accessor objects which
        #have to be treated in the same way as self.main_data_accessor object,
        #that means they must have the same parameters
        for data_accessor in self.data_accessors:
            data_accessor.parameters_container = self.main_data_accessor.parameters_container # @IgnorePep8

        formatted_summary_statistics = []
        save_csv = self.__save_outcomes_button__.isChecked()
        check_level = CoreParameters.MEDIUM_CHECK_LEVEL if save_csv else CoreParameters.LOW_CHECK_LEVEL # @IgnorePep8

        pp_generator_progress_bar = PoincarePlotGeneratorProgressBar(self,
                self.data_accessors, label_text='Statistics calculation',
                check_level=check_level, save_csv=save_csv,
                formatted_summary_statistics=formatted_summary_statistics,
                output_file_listener=self.params.output_file_listener)
        pp_generator_progress_bar.start()
        if pp_generator_progress_bar.interrupted() == False and \
            len(formatted_summary_statistics) == 1:
            #summary statistics values are updated only in the case
            #of one data accessor object
            self.__summary_statistics_widget__.setStatisticsValues(
                                        formatted_summary_statistics[0])

    def __change_statistics_handler__(self, _statistic, _checked):
        """
        handler invoked when number of selected rows is changing
        """
        if not _checked:
            if len(self.getSelectedStatisticsClasses()) > 0 or \
                len(self.getSelectedSummaryStatisticsClasses()) > 0:
                _checked = True
        self.__enabled_calculation_button__(_checked)

        #only if this parameter is None save outcomes button's check state
        #could be changed
        if self.params.save_outcomes_fixed_state == None:
            self.__save_outcomes_button__.setEnabled(_checked)

    def getSelectedStatisticsClasses(self):
        return self.__statistics_widget__.getSelectedStatisticsClasses()

    def getSelectedSummaryStatisticsClasses(self):
        return self.__summary_statistics_widget__.getSelectedStatisticsClasses() # @IgnorePep8

    def __enabled_calculation_button__(self, _enabled):
        """
        method sets background color of 'Calculate statistics' button to red
        if the button is disabled foreground color is set up to brown
        otherwise to black
        """
        if _enabled == False:
            self.__calculate_button__.setStyleSheet("background-color: red; color: brown") # @IgnorePep8
        else:
            self.__calculate_button__.setStyleSheet("background-color: red; color: black") # @IgnorePep8
        self.__calculate_button__.setEnabled(_enabled)
class ChooseDatasourcePage(QWizardPage):
    def __init__(self, _parent):
        QWizardPage.__init__(self, parent=_parent)

    def initializePage(self):
        title_I18N(self, "datasource.page.title", "Datasource chooser")
        #self.setSubTitle('Setup frame specific data')
        pageLayout = QVBoxLayout()
        self.setLayout(pageLayout)
        self.__createFilesGroupBox(pageLayout)

        #to force call of isComplete(self) method by the Wizard framework
        #which causes state next button to be updated
        self.emit(WIZARD_COMPLETE_CHANGED_SIGNAL)
        self.rootDir = None

    def __createFilesGroupBox(self, pageLayout):
        self.filesGroupBox = GroupBoxWidget(
            self,
            i18n="datasource.files.group.title",
            i18n_def="Files",
            layout=QVBoxLayout())

        self.__createFileConstraintsComposite__(self.filesGroupBox)

        self.__createReloadButton__(self.filesGroupBox)

        self.__createTableView__(self.filesGroupBox)

        self.__createFilesOperationsComposite__(self.filesGroupBox)

        self.changeEnablemend(False)
        self.chooseRootDirButton.setEnabled(True)

    def __createFileConstraintsComposite__(self, parent):
        fileConstraintsComposite = CompositeWidget(parent,
                                                   layout=QHBoxLayout())

        self.chooseRootDirButton = PushButtonWidget(
            fileConstraintsComposite,
            i18n="datasource.datasource.choose.root.dir.button",
            i18n_def="Choose root dir",
            clicked_handler=self.chooseRootDirAction)

        LabelWidget(fileConstraintsComposite,
                    i18n="datasource.root.dir.label",
                    i18n_def="Root dir:")
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        self.rootDirLabel = LabelWidget(fileConstraintsComposite,
                                        i18n="datasource.root.dir.label",
                                        i18n_def="[Not set]",
                                        sizePolicy=sizePolicy,
                                        stretch_after_widget=1)

        LabelWidget(fileConstraintsComposite,
                    i18n="datasource.file.name.filter.label",
                    i18n_def="Files name filter")

        self.filesExtension = LineEditWidget(
            fileConstraintsComposite,
            maxLength=15,
            width=get_width_of_n_letters(14),
            text="*",
            enabled_precheck_handler=self.enabledPrecheckHandler)

        self.recursively = CheckBoxWidget(
            fileConstraintsComposite,
            i18n="datasource.search.files.recursively.label",
            i18n_def="Search files recursively",
            clicked_handler=self.reload,
            enabled_precheck_handler=self.enabledPrecheckHandler)

        self.onlyKnownTypes = CheckBoxWidget(
            fileConstraintsComposite,
            i18n="datasource.only.known.types.checkbox",
            i18n_def="Only known types",
            checked=True,
            clicked_handler=self.reload,
            enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createReloadButton__(self, parent):
        self.reloadButton = PushButtonWidget(
            parent,
            i18n="datasource.reload.button",
            i18n_def="Reload",
            clicked_handler=self.reload,
            alignment=Qt.AlignRight,
            enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createTableView__(self, parent):
        self.filesTableView = FilesTableView(
            parent,
            model=QStandardItemModel(self),
            onClickedAction=self.onClickedAction,
            wizardButtons=(QWizard.NextButton, ),
            wizard_handler=self.wizard,
            sorting=True,
            enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createFilesOperationsComposite__(self, parent):
        filesOperations = CompositeWidget(parent, layout=QHBoxLayout())

        self.filePreviewButton = PushButtonWidget(
            filesOperations,
            i18n="datasource.file.preview.button",
            i18n_def="File preview",
            stretch_after_widget=1,
            clicked_handler=self.filePreviewAction,
            enabled_precheck_handler=self.enabledPrecheckHandler)

        self.selectAllButton = PushButtonWidget(
            filesOperations,
            i18n="datasource.accept.select.all.button",
            i18n_def="Select all",
            enabled=False,
            clicked_handler=self.__select_all_handler__,
            enabled_precheck_handler=self.enabledPrecheckHandler)

        self.unselectAllButton = PushButtonWidget(
            filesOperations,
            i18n="datasource.accept.unselect.all.button",
            i18n_def="Unselect all",
            enabled=False,
            clicked_handler=self.__unselect_all_handler__,
            enabled_precheck_handler=self.enabledPrecheckHandler)

    def chooseRootDirAction(self):
        SettingsFactory.loadSettings(self, Setter(rootDir=None))

        rootDir = QFileDialog.getExistingDirectory(
            self,
            caption=self.chooseRootDirButton.text(),
            directory=self.rootDir)
        if rootDir:
            self.rootDir = rootDir + os.path.sep
            SettingsFactory.saveSettings(self, Setter(rootDir=self.rootDir))
            self.rootDirLabel.setText(self.rootDir)
            self.reload()

    def __select_all_handler__(self):
        self.__change_selection__(True)

    def __unselect_all_handler__(self):
        self.__change_selection__(False)

    def __change_selection__(self, _select):
        self.changeEnablemend(False)
        count = self.filesTableView.getRowCount()
        progressManager = ProgressDialogManager(
            self,
            label_text=("Selecting..." if _select else "Unselecting..."),
            max_value=count)
        with progressManager as progress:
            for idx in range(count):
                if (progress.wasCanceled()):
                    break
                progress.increaseCounter()
                if _select:
                    self.filesTableView.setCheckedRowState(idx, Qt.Checked)
                else:
                    self.filesTableView.setCheckedRowState(idx, Qt.Unchecked)
        self.filesTableView.changeCompleteState()
        self.changeEnablemend(True)

    def filePreviewAction(self):
        showFilesPreviewDialog(
            self.filesTableView.getSelectedPathAndFilename())

    def reload(self):
        self.changeEnablemend(True)
        if self.rootDirLabel.text():

            self.filesTableView.clear()
            self.changeEnablemend(False)

            iteratorFlag = QDirIterator.Subdirectories \
                            if self.recursively.isChecked() \
                            else QDirIterator.NoIteratorFlags
            nameFilters = QStringList(
                    self.filesExtension.text()) \
                    if len(self.filesExtension.text()) > 0 \
                            and not self.filesExtension.text() \
                                in ("*", "*.*", "", None) \
                    else QStringList()
            self.iterator = QDirIterator(self.rootDirLabel.text(), nameFilters,
                                         QDir.Filters(QDir.Files),
                                         iteratorFlag)

            with ProgressDialogManager(self) as progress:
                while (self.iterator.next()):
                    if (progress.wasCanceled()):
                        break
                    fileInfo = self.iterator.fileInfo()
                    if fileInfo.size() == 0 or fileInfo.isFile() == False:
                        continue
                    if self.filesExtension.text() in ("*", "*.*", "", None):
                        if (sys.platform == 'win32' \
                            and fileInfo.isExecutable() == True) \
                            or is_text_file(fileInfo.filePath(),
                                    self.onlyKnownTypes.checkState()) == False:
                            continue
                    progress.increaseCounter()

                    checkable = QStandardItem("")
                    checkable.setCheckable(True)
                    filename = QStandardItem(fileInfo.fileName())
                    progress.setLabelText(fileInfo.fileName())
                    size = QStandardItem(str(fileInfo.size()))
                    path = QStandardItem(fileInfo.path())
                    self.filesTableView.addRow(
                        (checkable, filename, size, path))  # @IgnorePep8

            self.filesTableView.resizeColumnsToContents()
            self.filesExtension.setFocus()
            self.changeEnablemend(True)

    def onClickedAction(self, idx):
        self.filePreviewButton.setEnabled(True)
        self.filesTableView.onClickedAction(idx)

    def isComplete(self):
        """
        method used by QWizard to check if next/previous buttons have to
        be disabled/enabled (when False/True is returned)
        """
        return self.filesTableView.isCompletedCount()

    def changeEnablemend(self, enabled):
        self.emit(SIGNAL(ENABLED_SIGNAL_NAME), enabled)
        self.chooseRootDirButton.setEnabled(enabled)

    def enabledPrecheckHandler(self, widget):
        """
        only interested widgets return bool value others none value
        """
        if widget in (self.selectAllButton, self.unselectAllButton):
            return self.filesTableView.count() > 0
        elif widget == self.filePreviewButton:
            return self.filesTableView.getSelectedRowCount() > 0

    def getDatasourceModel(self):
        return self.filesTableView.getModel()
Exemple #8
0
class FilesTrackerWidget(CompositeWidget):
    """
    widget which tracks created files
    """
    def __init__(self, parent, **params):
        get_or_put(params, 'layout', QVBoxLayout())
        get_or_put(params, 'i18n_def', 'Files')
        super(FilesTrackerWidget, self).__init__(parent, **params)

        self.params = Params(**params)

        self.__create_oper_buttons__()
        self.__createTable__()
        self.__createModel__()
        self.__create_misc_buttons__()

    def __createTable__(self):
        self.__table__ = TableViewWidget(self,
                change_check_count_handler=self.__change_check_count_handler__,
                rows_inserted_handler=self.__rows_inserted_handler__)
        self.__table__.setSelectionMode(QAbstractItemView.MultiSelection)
        self.__table__.setSelectionBehavior(QAbstractItemView.SelectRows)

    def __createModel__(self):
        self.__table__.setModel(__FilesTrackerModel__(self))

    def __create_oper_buttons__(self):
        buttons_composite = CompositeWidget(self, layout=QHBoxLayout())
        self.__select_all__ = PushButtonWidget(buttons_composite,
                    i18n_def="Select all",
                    clicked_handler=self.__select_all_handler__,
                    enabled=False)

        self.__unselect_all__ = PushButtonWidget(buttons_composite,
                    i18n_def="Unselect all",
                    clicked_handler=self.__unselect_all_handler__,
                    enabled=False)

        self.__clear__ = PushButtonWidget(buttons_composite, i18n_def="Clear",
                    clicked_handler=self.__clear_handler__,
                    enabled=False)

    def __select_all_handler__(self):
        self.__table__.changeCheckStatForAll(True)

    def __unselect_all_handler__(self):
        self.__table__.changeCheckStatForAll(False)

    def __clear_handler__(self):
        self.__table__.clearRows()
        self.__select_all__.setEnabled(False)
        self.__unselect_all__.setEnabled(False)
        self.__clear__.setEnabled(False)
        self.__plain_view__.setEnabled(False)

    def appendFile(self, _filename):
        self.__table__.model().appendFile(_filename)

    def __create_misc_buttons__(self):
        buttons_composite = CompositeWidget(self, layout=QHBoxLayout())
        self.__plain_view__ = PushButtonWidget(buttons_composite,
                    i18n_def="Plain view",
                    clicked_handler=self.__plain_view_handler__,
                    enabled=False)

    def __plain_view_handler__(self):
        filesnames = self.__table__.model().getSelectedFiles()
        dialog = FilesPreviewDialog(normalize_filenames(filesnames), self)
        dialog.exec_()

    def __change_check_count_handler__(self, count):
        self.__plain_view__.setEnabled(count > 0)

    def __rows_inserted_handler__(self, model_index, start_row, end_row):
        self.__select_all__.setEnabled(True)
        self.__unselect_all__.setEnabled(True)
        self.__clear__.setEnabled(True)
class StatisticsWidget(GroupBoxWidget):
    """
    widget adds an action of statistics calculations into statistics widget
    """
    def __init__(self, parent, **params):
        get_or_put(params, 'layout', QVBoxLayout())
        get_or_put(params, 'i18n_def', 'Statistics')
        super(StatisticsWidget, self).__init__(parent, **params)
        self.params = Params(**params)

        self.data_accessors = []
        self.main_data_accessor = None
        if not self.params.data_vectors_accessor_group == None:
            self.data_accessors = self.params.data_vectors_accessor_group.data_vectors_accessors  # @IgnorePep8
            self.main_data_accessor = self.params.data_vectors_accessor_group.group_data_vector_accessor  # @IgnorePep8
        elif not self.params.data_accessor == None:
            self.main_data_accessor = self.params.data_accessor
            self.data_accessors = [self.main_data_accessor]

        for data_accessor in self.data_accessors:
            data_accessor.addListener(self, __StatisticsVectorListener__(self))

        self.__createButtons__()
        self.__statistics_widget__ = StatisticsSelectionWidget(
            self,
            layout=QVBoxLayout(),
            i18n_def='',
            check_handler=self.__change_statistics_handler__)

        self.__summary_statistics_widget__ = SummaryStatisticsSelectionWidget(
            self,
            layout=QVBoxLayout(),
            i18n_def='Summary statistics',
            check_handler=self.__change_statistics_handler__)

    def __createButtons__(self):
        buttons_composite = CompositeWidget(self, layout=QHBoxLayout())
        self.__calculate_button__ = PushButtonWidget(
            buttons_composite,
            i18n_def="Calculate statistics",
            clicked_handler=self.__calculate_statistics_handler__)
        self.__enabled_calculation_button__(False)

        self.__save_outcomes_button__ = CheckBoxWidget(
            buttons_composite, i18n_def="Save outcomes", enabled=False)

        #if parameter save_outcomes_fixed_state is not None
        #then it's equal to checked state of save outcomes button
        #and this state couldn't be change later by a user
        if self.params.save_outcomes_fixed_state:
            self.__save_outcomes_button__.setChecked(
                self.params.save_outcomes_fixed_state)

    def __calculate_statistics_handler__(self):
        if len(self.data_accessors) == 0:
            return

        self.main_data_accessor.prepareParametersContainer()
        #processing many data accessors objects:
        #self.data_accessors object contains many data_accessor objects which
        #have to be treated in the same way as self.main_data_accessor object,
        #that means they must have the same parameters
        for data_accessor in self.data_accessors:
            data_accessor.parameters_container = self.main_data_accessor.parameters_container  # @IgnorePep8

        formatted_summary_statistics = []
        save_csv = self.__save_outcomes_button__.isChecked()
        check_level = CoreParameters.MEDIUM_CHECK_LEVEL if save_csv else CoreParameters.LOW_CHECK_LEVEL  # @IgnorePep8

        pp_generator_progress_bar = PoincarePlotGeneratorProgressBar(
            self,
            self.data_accessors,
            label_text='Statistics calculation',
            check_level=check_level,
            save_csv=save_csv,
            formatted_summary_statistics=formatted_summary_statistics,
            output_file_listener=self.params.output_file_listener)
        pp_generator_progress_bar.start()
        if pp_generator_progress_bar.interrupted() == False and \
            len(formatted_summary_statistics) == 1:
            #summary statistics values are updated only in the case
            #of one data accessor object
            self.__summary_statistics_widget__.setStatisticsValues(
                formatted_summary_statistics[0])

    def __change_statistics_handler__(self, _statistic, _checked):
        """
        handler invoked when number of selected rows is changing
        """
        if not _checked:
            if len(self.getSelectedStatisticsClasses()) > 0 or \
                len(self.getSelectedSummaryStatisticsClasses()) > 0:
                _checked = True
        self.__enabled_calculation_button__(_checked)

        #only if this parameter is None save outcomes button's check state
        #could be changed
        if self.params.save_outcomes_fixed_state == None:
            self.__save_outcomes_button__.setEnabled(_checked)

    def getSelectedStatisticsClasses(self):
        return self.__statistics_widget__.getSelectedStatisticsClasses()

    def getSelectedSummaryStatisticsClasses(self):
        return self.__summary_statistics_widget__.getSelectedStatisticsClasses(
        )  # @IgnorePep8

    def __enabled_calculation_button__(self, _enabled):
        """
        method sets background color of 'Calculate statistics' button to red
        if the button is disabled foreground color is set up to brown
        otherwise to black
        """
        if _enabled == False:
            self.__calculate_button__.setStyleSheet(
                "background-color: red; color: brown")  # @IgnorePep8
        else:
            self.__calculate_button__.setStyleSheet(
                "background-color: red; color: black")  # @IgnorePep8
        self.__calculate_button__.setEnabled(_enabled)
class ChooseDatasourcePage(QWizardPage):

    def __init__(self, _parent):
        QWizardPage.__init__(self, parent=_parent)

    def initializePage(self):
        title_I18N(self, "datasource.page.title", "Datasource chooser")
        #self.setSubTitle('Setup frame specific data')
        pageLayout = QVBoxLayout()
        self.setLayout(pageLayout)
        self.__createFilesGroupBox(pageLayout)

        #to force call of isComplete(self) method by the Wizard framework
        #which causes state next button to be updated
        self.emit(WIZARD_COMPLETE_CHANGED_SIGNAL)
        self.rootDir = None

    def __createFilesGroupBox(self, pageLayout):
        self.filesGroupBox = GroupBoxWidget(self,
                                    i18n="datasource.files.group.title",
                                    i18n_def="Files",
                                    layout=QVBoxLayout())

        self.__createFileConstraintsComposite__(self.filesGroupBox)

        self.__createReloadButton__(self.filesGroupBox)

        self.__createTableView__(self.filesGroupBox)

        self.__createFilesOperationsComposite__(self.filesGroupBox)

        self.changeEnablemend(False)
        self.chooseRootDirButton.setEnabled(True)

    def __createFileConstraintsComposite__(self, parent):
        fileConstraintsComposite = CompositeWidget(parent,
                                                   layout=QHBoxLayout())

        self.chooseRootDirButton = PushButtonWidget(fileConstraintsComposite,
                        i18n="datasource.datasource.choose.root.dir.button",
                        i18n_def="Choose root dir",
                        clicked_handler=self.chooseRootDirAction)

        LabelWidget(fileConstraintsComposite,
                     i18n="datasource.root.dir.label",
                     i18n_def="Root dir:")
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        self.rootDirLabel = LabelWidget(fileConstraintsComposite,
                                        i18n="datasource.root.dir.label",
                                        i18n_def="[Not set]",
                                        sizePolicy=sizePolicy,
                                        stretch_after_widget=1)

        LabelWidget(fileConstraintsComposite,
                    i18n="datasource.file.name.filter.label",
                    i18n_def="Files name filter")

        self.filesExtension = LineEditWidget(fileConstraintsComposite,
                        maxLength=15,
                        width=get_width_of_n_letters(14),
                        text="*",
                        enabled_precheck_handler=self.enabledPrecheckHandler)

        self.recursively = CheckBoxWidget(fileConstraintsComposite,
                        i18n="datasource.search.files.recursively.label",
                        i18n_def="Search files recursively",
                        clicked_handler=self.reload,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

        self.onlyKnownTypes = CheckBoxWidget(fileConstraintsComposite,
                        i18n="datasource.only.known.types.checkbox",
                        i18n_def="Only known types",
                        checked=True,
                        clicked_handler=self.reload,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createReloadButton__(self, parent):
        self.reloadButton = PushButtonWidget(parent,
                        i18n="datasource.reload.button",
                        i18n_def="Reload",
                        clicked_handler=self.reload,
                        alignment=Qt.AlignRight,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createTableView__(self, parent):
        self.filesTableView = FilesTableView(parent,
                        model=QStandardItemModel(self),
                        onClickedAction=self.onClickedAction,
                        wizardButtons=(QWizard.NextButton,),
                        wizard_handler=self.wizard,
                        sorting=True,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

    def __createFilesOperationsComposite__(self, parent):
        filesOperations = CompositeWidget(parent,
                                            layout=QHBoxLayout())

        self.filePreviewButton = PushButtonWidget(filesOperations,
                        i18n="datasource.file.preview.button",
                        i18n_def="File preview",
                        stretch_after_widget=1,
                        clicked_handler=self.filePreviewAction,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

        self.selectAllButton = PushButtonWidget(filesOperations,
                        i18n="datasource.accept.select.all.button",
                        i18n_def="Select all",
                        enabled=False,
                        clicked_handler=self.__select_all_handler__,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

        self.unselectAllButton = PushButtonWidget(filesOperations,
                        i18n="datasource.accept.unselect.all.button",
                        i18n_def="Unselect all",
                        enabled=False,
                        clicked_handler=self.__unselect_all_handler__,
                        enabled_precheck_handler=self.enabledPrecheckHandler)

    def chooseRootDirAction(self):
        SettingsFactory.loadSettings(self, Setter(rootDir=None))

        rootDir = QFileDialog.getExistingDirectory(self,
                                    caption=self.chooseRootDirButton.text(),
                                    directory=self.rootDir)
        if rootDir:
            self.rootDir = rootDir + os.path.sep
            SettingsFactory.saveSettings(self, Setter(rootDir=self.rootDir))
            self.rootDirLabel.setText(self.rootDir)
            self.reload()

    def __select_all_handler__(self):
        self.__change_selection__(True)

    def __unselect_all_handler__(self):
        self.__change_selection__(False)

    def __change_selection__(self, _select):
        self.changeEnablemend(False)
        count = self.filesTableView.getRowCount()
        progressManager = ProgressDialogManager(self,
                label_text=("Selecting..." if _select else "Unselecting..."),
                max_value=count)
        with progressManager as progress:
            for idx in range(count):
                if (progress.wasCanceled()):
                    break
                progress.increaseCounter()
                if _select:
                    self.filesTableView.setCheckedRowState(idx, Qt.Checked)
                else:
                    self.filesTableView.setCheckedRowState(idx, Qt.Unchecked)
        self.filesTableView.changeCompleteState()
        self.changeEnablemend(True)

    def filePreviewAction(self):
        showFilesPreviewDialog(
                    self.filesTableView.getSelectedPathAndFilename())

    def reload(self):
        self.changeEnablemend(True)
        if self.rootDirLabel.text():

            self.filesTableView.clear()
            self.changeEnablemend(False)

            iteratorFlag = QDirIterator.Subdirectories \
                            if self.recursively.isChecked() \
                            else QDirIterator.NoIteratorFlags
            nameFilters = QStringList(
                    self.filesExtension.text()) \
                    if len(self.filesExtension.text()) > 0 \
                            and not self.filesExtension.text() \
                                in ("*", "*.*", "", None) \
                    else QStringList()
            self.iterator = QDirIterator(
                                self.rootDirLabel.text(),
                                nameFilters,
                                QDir.Filters(QDir.Files),
                                iteratorFlag)

            with ProgressDialogManager(self) as progress:
                while(self.iterator.next()):
                    if (progress.wasCanceled()):
                        break
                    fileInfo = self.iterator.fileInfo()
                    if fileInfo.size() == 0 or fileInfo.isFile() == False:
                        continue
                    if self.filesExtension.text() in ("*", "*.*", "", None):
                        if (sys.platform == 'win32' \
                            and fileInfo.isExecutable() == True) \
                            or is_text_file(fileInfo.filePath(),
                                    self.onlyKnownTypes.checkState()) == False:
                            continue
                    progress.increaseCounter()

                    checkable = QStandardItem("")
                    checkable.setCheckable(True)
                    filename = QStandardItem(fileInfo.fileName())
                    progress.setLabelText(fileInfo.fileName())
                    size = QStandardItem(str(fileInfo.size()))
                    path = QStandardItem(fileInfo.path())
                    self.filesTableView.addRow((checkable, filename, size, path)) # @IgnorePep8

            self.filesTableView.resizeColumnsToContents()
            self.filesExtension.setFocus()
            self.changeEnablemend(True)

    def onClickedAction(self, idx):
        self.filePreviewButton.setEnabled(True)
        self.filesTableView.onClickedAction(idx)

    def isComplete(self):
        """
        method used by QWizard to check if next/previous buttons have to
        be disabled/enabled (when False/True is returned)
        """
        return self.filesTableView.isCompletedCount()

    def changeEnablemend(self, enabled):
        self.emit(SIGNAL(ENABLED_SIGNAL_NAME), enabled)
        self.chooseRootDirButton.setEnabled(enabled)

    def enabledPrecheckHandler(self, widget):
        """
        only interested widgets return bool value others none value
        """
        if widget in (self.selectAllButton, self.unselectAllButton):
            return self.filesTableView.count() > 0
        elif widget == self.filePreviewButton:
            return self.filesTableView.getSelectedRowCount() > 0

    def getDatasourceModel(self):
        return self.filesTableView.getModel()