Example #1
0
 def _setup_table(self, prechecked_elements, state_list, state_list_enables,
                  partly_disabled, disable_fancy, auto_depresso):
     self.signalMapper = QtCore.QSignalMapper(self)
     self.signalMapper.mapped[QWidget].connect(self.previewToggler)
     self.signalMapper2 = QtCore.QSignalMapper(self)
     self.signalMapper2.mapped[QWidget].connect(self.elementToggler)
     self.signalMapper3 = QtCore.QSignalMapper(self)
     self.signalMapper3.mapped[QWidget].connect(self.emit_right_clicked)
     self.signalMapper4 = QtCore.QSignalMapper(self)
     self.signalMapper4.mapped[QWidget].connect(self.focus_on_toggler)
     self.signalMapper5 = QtCore.QSignalMapper(self)
     self.signalMapper5.mapped[QWidget].connect(self.focus_off_toggler)
     self.signalMapper6 = QtCore.QSignalMapper(self)
     self.signalMapper6.mapped[QWidget].connect(self.emit_triggered)
     is_checkable = not auto_depresso
     for i in pt_indexes:
         pt_button = HoverableButton(i,
                                     partly_disabled=partly_disabled,
                                     disable_fancy=disable_fancy,
                                     is_checkable=is_checkable)
         pt_button.setMinimumSize(16, 16)
         pt_button.setMaximumSize(512, 512)
         if i in prechecked_elements:
             pt_button.setChecked(True)
         self.layout().addWidget(pt_button, pt_indexes[i][0],
                                 pt_indexes[i][1])
         # pt_button.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
         pt_button.hoverChanged.connect(self.signalMapper.map)
         pt_button.toggled.connect(self.signalMapper2.map)
         pt_button.rightClicked.connect(self.signalMapper3.map)
         pt_button.gainedFocus.connect(self.signalMapper4.map)
         pt_button.lostFocus.connect(self.signalMapper5.map)
         pt_button.pressed.connect(self.signalMapper6.map)
         self.signalMapper.setMapping(pt_button, pt_button)
         self.signalMapper2.setMapping(pt_button, pt_button)
         self.signalMapper3.setMapping(pt_button, pt_button)
         self.signalMapper4.setMapping(pt_button, pt_button)
         self.signalMapper5.setMapping(pt_button, pt_button)
         self.signalMapper6.setMapping(pt_button, pt_button)
     line = QFrame()
     line.setFrameShape(QFrame.HLine)
     line.setFrameShadow(QFrame.Sunken)
     line.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
     self.layout().addWidget(line, 6, 3, 1, 15)
     # dissable elements/buttons for provided list:
     if state_list_enables:
         disabled_elements = set(pt_indexes).difference(state_list)
     else:
         disabled_elements = state_list
     for i in disabled_elements:
         self.getButton(pt_indexes[i]).setEnabled(False)
     lant_text = QLabel('Lan')
     act_text = QLabel('Act')
     lant_text.setAlignment(QtCore.Qt.AlignCenter)
     act_text.setAlignment(QtCore.Qt.AlignCenter)
     self.layout().addWidget(lant_text, 5, 2)
     self.layout().addWidget(act_text, 6, 2)
     lant_text.setEnabled(False)
     act_text.setEnabled(False)
    def __createToolbarsAndConnect(self):

        actionGroup = QActionGroup(self)
        actionGroup.addAction(self.actionImport)
        actionGroup.addAction(self.actionVyhledavani)
        actionGroup.addAction(self.actionZpracujZmeny)

        # QSignalMapper
        self.signalMapper = QtCore.QSignalMapper(self)

        self.actionImport.triggered.connect(self.signalMapper.map)
        self.actionVyhledavani.triggered.connect(self.signalMapper.map)
        self.actionZpracujZmeny.triggered.connect(self.signalMapper.map)

        # setMapping on each button to the QStackedWidget index we'd like to
        # switch to
        self.signalMapper.setMapping(self.actionImport, 0)
        self.signalMapper.setMapping(self.actionVyhledavani, 2)
        self.signalMapper.setMapping(self.actionZpracujZmeny, 1)

        # connect mapper to stackedWidget
        self.signalMapper.mapped.connect(self.stackedWidget.setCurrentIndex)

        self.vfkBrowser.switchToPanelImport.connect(self.switchToImport)
        self.vfkBrowser.switchToPanelSearch.connect(self.switchToSearch)
        self.vfkBrowser.switchToPanelChanges.connect(self.switchToChanges)

        # Browser toolbar
        # ---------------
        self.__mBrowserToolbar = QToolBar(self)
        self.actionBack.triggered.connect(self.vfkBrowser.goBack)
        self.actionForward.triggered.connect(self.vfkBrowser.goForth)

        self.actionSelectBudInMap.triggered.connect(self.selectBudInMap)
        self.actionSelectParInMap.triggered.connect(self.selectParInMap)
        self.actionCuzkPage.triggered.connect(self.showOnCuzk)

        self.actionExportLatex.triggered.connect(self.latexExport)
        self.actionExportHtml.triggered.connect(self.htmlExport)

        self.actionShowInfoaboutSelection.toggled.connect(
            self.setSelectionChangedConnected)
        self.actionShowHelpPage.triggered.connect(self.vfkBrowser.showHelpPage)

        self.loadVfkButton.clicked.connect(self.loadVfkButton_clicked)

        self.__browseButtons['browseButton_1'] = self.browseButton
        self.__browseButtons['browseButton_1'].clicked.connect(
            lambda: self.browseButton_clicked(
                int('{}'.format(len(self.__vfkLineEdits)))))

        self.__vfkLineEdits['vfkLineEdit_1'] = self.vfkFileLineEdit

        bt = QToolButton(self.__mBrowserToolbar)
        bt.setPopupMode(QToolButton.InstantPopup)
        bt.setText("Export ")

        menu = QMenu(bt)
        menu.addAction(self.actionExportLatex)
        menu.addAction(self.actionExportHtml)
        bt.setMenu(menu)

        # add actions to toolbar icons
        self.__mBrowserToolbar.addAction(self.actionImport)
        self.__mBrowserToolbar.addAction(self.actionVyhledavani)
        self.__mBrowserToolbar.addAction(self.actionZpracujZmeny)
        self.__mBrowserToolbar.addSeparator()
        self.__mBrowserToolbar.addAction(self.actionBack)
        self.__mBrowserToolbar.addAction(self.actionForward)
        self.__mBrowserToolbar.addAction(self.actionSelectParInMap)
        self.__mBrowserToolbar.addAction(self.actionSelectBudInMap)
        self.__mBrowserToolbar.addAction(self.actionCuzkPage)
        self.__mBrowserToolbar.addSeparator()
        self.__mBrowserToolbar.addAction(self.actionShowInfoaboutSelection)
        self.__mBrowserToolbar.addSeparator()
        self.__mBrowserToolbar.addWidget(bt)
        self.__mBrowserToolbar.addSeparator()
        self.__mBrowserToolbar.addAction(self.actionShowHelpPage)

        self.rightWidgetLayout.insertWidget(0, self.__mBrowserToolbar)

        # connect signals from vfkbrowser when changing history
        self.vfkBrowser.currentParIdsChanged.connect(
            self.actionSelectParInMap.setEnabled)
        self.vfkBrowser.currentBudIdsChanged.connect(
            self.actionSelectBudInMap.setEnabled)
        self.vfkBrowser.historyBefore.connect(self.actionBack.setEnabled)
        self.vfkBrowser.historyAfter.connect(self.actionForward.setEnabled)
        self.vfkBrowser.definitionPointAvailable.connect(
            self.actionCuzkPage.setEnabled)

        # add toolTips
        self.pb_nextFile.setToolTip(u'Přidej další soubor VFK')
        self.parCheckBox.setToolTip(u'Načti vrstvu parcel')
        self.budCheckBox.setToolTip(u'Načti vrstvu budov')

        # add new VFK file
        self.pb_nextFile.clicked.connect(self.__addRowToGridLayout)

        # widget apply changes
        self.pb_mainDb.clicked.connect(lambda: self.browseDb_clicked('mainDb'))
        self.pb_amendmentDb.clicked.connect(
            lambda: self.browseDb_clicked('amendmentDb'))
        self.pb_exportDb.clicked.connect(
            lambda: self.browseDb_clicked('exportDb'))

        self.pb_applyChanges.clicked.connect(self.applyChanges)
        self.pb_applyChanges.setEnabled(False)

        self.changes_instance.maxRangeProgressBar.connect(
            self.__setRangeProgressBarChanges)
        self.changes_instance.updateStatus.connect(
            self.__updateProgressBarChanges)
        self.changes_instance.finishedStatus.connect(self.__changesApplied)
        self.changes_instance.preprocessingDatabase.connect(
            self.__changesPreprocessingDatabase)

        # connect radio boxes
        self.rb_file.clicked.connect(self.radioButtonValue)
        self.rb_directory.clicked.connect(self.radioButtonValue)