Example #1
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # MOVE WINDOW
        def moveWindow(event):
            # RESTORE BEFORE MOVE
            if UIFunctions.returnStatus() == 1:
                UIFunctions.maximize_restore(self)

            # IF LEFT CLICK MOVE WINDOW
            if event.buttons() == Qt.LeftButton:
                self.move(self.pos() + event.globalPos() - self.dragPos)
                self.dragPos = event.globalPos()
                event.accept()

        # SET TITLE BAR
        self.ui.title_bar.mouseMoveEvent = moveWindow

        ## ==> SET UI DEFINITIONS
        UIFunctions.uiDefinitions(self)

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #2
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.selectAreaWidget = None

        self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
        self.screenshotWidget = None
        color = QColor(72, 41, 12).name(QColor.HexRgb)
        self.ui.hexColorLabel.setText(color)
        self.ui.bobberColorLabel.setStyleSheet("QLabel { background-color : " +
                                               color + "; }")

        self.fish = GetTheFish()
        self.fish.gui = True
        self.updateGui()
        self.thread = ThreadRunner(self.fish)

        # connects
        self.ui.colorButton.clicked.connect(self.openScreenshot)
        self.ui.startButton.clicked.connect(self.toggleFishing)
        self.ui.areaButton.clicked.connect(self.take_screenshot)
        self.ui.thresholdBobberSpinBox.valueChanged.connect(self.guiUpdated)
        self.ui.thresholdCatchSpinBox.valueChanged.connect(self.guiUpdated)
        self.ui.jumpToBobberCheck.stateChanged.connect(self.guiUpdated)
        self.ui.verboseCheck.stateChanged.connect(self.guiUpdated)
Example #3
0
    def __init__(self):
        QMainWindow.__init__(self)
        
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.setWindowFlag(QtCore.Qt.FramelessWindowHint)
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)

        self.ui.back2_btn2.clicked.connect(lambda: self.ui.stacked_wid.setCurrentIndex(0))
        self.ui.create_btn.clicked.connect(lambda: self.ui.stacked_wid.setCurrentIndex(1))
        self.ui.back_btn.clicked.connect(lambda: self.ui.stacked_wid.setCurrentIndex(0))
        self.ui.add_btn.clicked.connect(lambda: self.ui.stacked_wid.setCurrentIndex(3))
        self.ui.back_btn3.clicked.connect(lambda: self.ui.stacked_wid.setCurrentIndex(2))
        self.ui.proceed_btn.clicked.connect(lambda: self.validation(self.ui.massterpw_entry.text()))
        
        self.ui.choosepath_btn.clicked.connect(self.create_db)
        self.ui.createdb_btn_2.clicked.connect(self.finalize_db)
        self.ui.choosefile_btn.clicked.connect(self.choose_db)
        self.ui.submit_btn.clicked.connect(self.add)
        
        self.ui.massterpw_entry.returnPressed.connect(lambda: self.validation(self.ui.massterpw_entry.text()))
        self.ui.confirmmasterpw2_entry.returnPressed.connect(self.finalize_db)
        self.ui.url_entry.returnPressed.connect(self.add)

        self.ui.close_lbl.mousePressEvent = lambda e: self.close()
        self.ui.min_lbl.mousePressEvent   = lambda e: self.showMinimized()

        self.filepath = None
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.mode = 'OFF'
        self.sound = 1
        self.voice = 0

        self.soundplayerbtn = soundplayingbuttons()
        self.soundplayerstatus = soundplayingstatus()
        self.mouse = movemouse()
        self.openingfile = openfile()
        self.labviewfilehandling = labviewmode()
        self.modecheckbtn = modecheckbutton()
        self.modecheckbtn.signal.connect(self.modechange)
        self.modecheckbtn.start()

        def moveWindow(event):
            if UIFunctions.returnStatus() == 1:
                UIFunctions.maximize_restore(self)

            if event.buttons() == Qt.LeftButton:
                self.move(self.pos() + event.globalPos() - self.dragPos)
                self.dragPos = event.globalPos()
                event.accept()

        self.ui.titl_frame.mouseMoveEvent = moveWindow

        UIFunctions.uiDefinitions(self)

        self.show()
Example #5
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        ## TOGGLE SUB MENUS
        ########################################################################
        #self.ui.Btn_Toggle.clicked.connect(lambda: UIFunctions.toggleMenu(self, 200, True))
        self.ui.Btn_hpc.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_hpc, True))
        self.ui.Btn_spc.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_spc, True))
        self.ui.Btn_dpc.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_dpc, True))
        self.ui.Btn_ssc.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_ssc, True))
        self.ui.Btn_alc.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_alc, True))
        self.ui.Btn_cmt.clicked.connect(lambda: UIFunctions.openSubMenu(
            self, 240, self.ui.frame_cmt, True))

        ## NAVIGATING PAGES
        self.ui.Btn_spc_main.clicked.connect(
            lambda: UIFunctions.handleButton(self, 1))
        self.ui.Btn_hpc_main.clicked.connect(
            lambda: UIFunctions.handleButton(self, 0))
        self.ui.Btn_hpc_mat.clicked.connect(
            lambda: UIFunctions.handleButton(self, 2))

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #6
0
    def __init__(self, parent=None):
        self.main_win = QMainWindow()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self.main_win)

        self.ui.MakeMoneyButton.clicked.connect(self.on_MAKEMONEY_click)
        self.ui.lookupButton.clicked.connect(self.on_LOOKUP_click)
Example #7
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # MOVE WINDOW
        def moveWindow(event):
            # RESTORE BEFORE MOVE
            if UIFunctions.returnStatus() == 1:
                UIFunctions.maximize_restore(self)

            # IF LEFT CLICK MOVE WINDOW
            if event.buttons() == Qt.LeftButton:
                self.move(self.pos() + event.globalPos() - self.dragPos)
                self.dragPos = event.globalPos()
                event.accept()

        # SET TITLE BAR
        self.ui.title_bar.mouseMoveEvent = moveWindow

        ## ==> SET UI DEFINITIONS
        UIFunctions.uiDefinitions(self)

        ## QTIMER ==> START
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.systemInformation)

        # TIMER IN MILLISECONDS
        self.timer.start(1000)

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #8
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.DF = pd.DataFrame([])

        ## TOP
        ########################################################################

        self.ui.BtnLoadDf.clicked.connect(lambda: DataFunc.get_data(self))

        ## PAGES
        ########################################################################

        # PAGE 1
        self.ui_page1 = Ui_Page1(self)

        # PAGE 2
        self.ui.Btn_Menu_2.clicked.connect(
            lambda: self.ui.Pages_Widget.setCurrentWidget(self.ui.page_2))

        # PAGE 3
        self.ui.Btn_Menu_3.clicked.connect(
            lambda: self.ui.Pages_Widget.setCurrentWidget(self.ui.page_3))

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #9
0
class AppWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.setWindowFlag(QtCore.Qt.FramelessWindowHint)
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)

        def moveWindow(event):
            if UIFunctions.returnStatus(self) == 1:
                UIFunctions.maximize_restore(self)
            if event.buttons() == Qt.LeftButton:
                self.move(self.pos() + event.globalPos() - self.dragPos)
                self.dragPos = event.globalPos()
                event.accept()

        self.ui.frame_titleBar_title.mouseMoveEvent = moveWindow
        UIFunctions.uiDefinitions(self)
    
    # EVENT
    def mousePressEvent(self, event):
        self.dragPos = event.globalPos()

    def resizeEvent(self, event):
        return super(AppWindow, self).resizeEvent(event)
Example #10
0
class MainWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.setWindowTitle('Knowledge On The Go')

        self.ui.Btn_Toggle.clicked.connect(lambda: UIFunctions.toggle_menu(self, 250, True))

        # PAGE 1 - Dictionary
        self.ui.btn_page_1.clicked.connect(lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_1))

        # PAGE 2 - Wikipedia
        self.ui.btn_page_2.clicked.connect(lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_2))

        # PAGE 3 - Message-Server
        self.ui.btn_page_3.clicked.connect(lambda: self.server())

        # PAGE 4 - Message-Client
        self.ui.btn_page_4.clicked.connect(lambda: self.client())

    def server(self):
        print()
        print()
        import server

    def client(self):
        print()
        print()
        import client
Example #11
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.main_win = QMainWindow()
        self.ui = Ui_MainWindow()
        self.main_win.setWindowFlag(Qt.FramelessWindowHint)
        self.ui.setupUi(self.main_win)
        self.ui.stackedWidget.setCurrentWidget(self.ui.home_page)
        self.ui.actionBanking_Sector.triggered.connect(self.show_banking_form)
        self.ui.actionDesigning_Sector_3.triggered.connect(
            self.show_designing_form)
        self.ui.actionChange_Password.triggered.connect(self.change_password)
        self.ui.actionBanking_Sector_2.triggered.connect(self.bank_view_page)
        self.ui.actionDesigning_Sector_4.triggered.connect(
            self.design_view_page)
        self.ui.actionExit_2.triggered.connect(self.closemainwindow)
        self.ui.actionAll_2.triggered.connect(self.statement_form)
        self.ui.back_search_btn.clicked.connect(self.backtohomepage)
        self.ui.back_search_btn_2.clicked.connect(self.backtohomepage)
        self.ui.actionBanking.triggered.connect(self.show_popup)
        self.ui.actionBanking_Sector_5.triggered.connect(
            self.show_banking_tform)
        self.ui.actionDesigning_Sector_7.triggered.connect(
            self.show_designing_tform)
        self.ui.actionLadger.triggered.connect(self.show_ledger)
        self.ui.actionTab_View.triggered.connect(self.show_tabs)

        timer = QTimer(self)
        timer.timeout.connect(self.showtime)
        timer.start(1000)
Example #12
0
class BrowserWindow(QtGui.QWidget):
    """Das Hauptfenster des Browsers."""
    def __init__(self, *args):
        QtGui.QMainWindow.__init__(self, *args)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.createConnects()

    def createConnects(self):
        self.ui.editAddress.returnPressed.connect(self.loadPage)
        self.ui.webView.urlChanged.connect(self.updateUrl)
        self.ui.buttonBack.clicked.connect(self.ui.webView.back)
        self.ui.buttonForward.clicked.connect(self.ui.webView.forward)
        self.ui.buttonReload.clicked.connect(self.ui.webView.reload)

    @QtCore.pyqtSlot(QtCore.QUrl)
    def updateUrl(self, url):
        self.ui.editAddress.setText(url.toString())

    @QtCore.pyqtSlot()
    def loadPage(self):
        stringUrl = unicode(self.ui.editAddress.text())
        if not re.search(r"^http", stringUrl):
            stringUrl = "http://" + stringUrl
        url = QtCore.QUrl(stringUrl)
        self.ui.webView.load(url)
        self.ui.editAddress.clearFocus()
Example #13
0
class BrowserWindow(QtGui.QWidget):
    """Das Hauptfenster des Browsers."""

    def __init__(self, *args):
        QtGui.QMainWindow.__init__(self, *args)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.createConnects()

    def createConnects(self):
        self.ui.editAddress.returnPressed.connect(self.loadPage)
        self.ui.webView.urlChanged.connect(self.updateUrl)
        self.ui.buttonBack.clicked.connect(self.ui.webView.back)
        self.ui.buttonForward.clicked.connect(self.ui.webView.forward)
        self.ui.buttonReload.clicked.connect(self.ui.webView.reload)

    @QtCore.pyqtSlot(QtCore.QUrl)
    def updateUrl(self, url):
        self.ui.editAddress.setText(url.toString())

    @QtCore.pyqtSlot()
    def loadPage(self):
        stringUrl = unicode(self.ui.editAddress.text())
        if not re.search(r"^http", stringUrl):
            stringUrl = "http://" +stringUrl
        url = QtCore.QUrl(stringUrl)
        self.ui.webView.load(url)
        self.ui.editAddress.clearFocus()
Example #14
0
    def __init__(self):
        self.videolist = []  # save the list of unwatched videos
        self.watched = []  # Save the list of watched videos
        self.emotion = 0  # store the numerical value of emotion
        self.saved = 0  # Flag to check video anotation is saved or not before pressing next
        self.image = None
        self.cap = None
        self.timer = None

        self.main_win = QMainWindow()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self.main_win)
        self.ui.currentfolder = None
        self.ui.currentvideo = None
        self.ui.folderpath.setText("No Folder Selected")
        self.ui.emotion.setText("None")
        self.ui.Videoname.setText("None")
        self.ui.folder.clicked.connect(self.selectfolder)
        self.ui.save.clicked.connect(self.saveclicked)

        self.ui.replay.clicked.connect(self.replayclicked)
        self.ui.next.clicked.connect(self.nextclicked)

        self.ui.angry.clicked.connect(self.angryclicked)
        self.ui.happy.clicked.connect(self.happyclicked)
        self.ui.sad.clicked.connect(self.sadclicked)
        self.ui.surprise.clicked.connect(self.surpriseclicked)
        self.ui.disgust.clicked.connect(self.disgustclicked)
        self.ui.fear.clicked.connect(self.fearclicked)
        self.ui.noemotion.clicked.connect(self.noemotionclicked)
        self.ui.uncertain.clicked.connect(self.uncertainclicked)
Example #15
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        ## TOGGLE/BURGUER MENU
        ########################################################################
        self.ui.Btn_Toggle.clicked.connect(
            lambda: UIFunctions.toggleMenu(self, 250, True))

        ## PAGES
        ########################################################################

        # PAGE 1
        self.ui.btn_page_1.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_1))

        # PAGE 2
        self.ui.btn_page_2.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_2))

        # PAGE 3
        self.ui.btn_page_3.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_3))

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #16
0
class MainWindow:
    def __init__(self, parent=None):
        self.main_win = QMainWindow()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self.main_win)

        self.ui.MakeMoneyButton.clicked.connect(self.on_MAKEMONEY_click)
        self.ui.lookupButton.clicked.connect(self.on_LOOKUP_click)

    def show(self):
        self.main_win.show()

    def on_LOOKUP_click(self):
        userSymbol = self.ui.stockSymbol.text().upper()
        lookup_info = "Current price of " + userSymbol + ": " + str(
            get_current_stock_price(userSymbol))
        self.ui.OutputText.setText(lookup_info)

    def on_MAKEMONEY_click(self):
        if self.ui.stockSymbol.hasAcceptableInput() == False:
            self.ui.OutputText.setText("Please enter a valid stock symbol")
        if self.ui.desiredMargins.text().isdigit() == False:
            self.ui.OutputText.setText("Please enter a number greater than 0")
        userSymbol = self.ui.stockSymbol.text().upper()
        userMargins = float(self.ui.desiredMargins.text()) / 100
        self.ui.OutputText.setText(marginBot(userSymbol, userMargins))
Example #17
0
    def __init__(self):
        QMainWindow.__init__(self)

        # Set up the user interface from QtDesigner
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.ui.act_periph = []
        self.ui.menu_periph = []
        self.ui.lab_status = QLabel()
        self.ui.lab_status.setText("No connection")
        self.ui.statusBar.addPermanentWidget(self.ui.lab_status)

        self.about_dialog = QDialog(self)
        self.about_dialog.ui = Ui_AboutDialog()
        self.about_dialog.ui.setupUi(self.about_dialog)

        self.svd_dialog = QDialog(self)
        self.svd_dialog.ui = Ui_SVDDialog()
        self.svd_dialog.ui.setupUi(self.svd_dialog)
        self.svd_dialog.ui.tree_svd.itemDoubleClicked.connect(self.handle_svd_dialog_item_double_clicked)
        self.svd_dialog.ui.tree_svd.headerItem().setText(0, "List of packed SVD")

        # Add some vars
        self.svd_reader = SVDReader()
        self.openocd_tn = OpenOCDTelnet()
        self.openocd_rt = None
        self.opt_autoread = False
Example #18
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        ## PAGES
        ########################################################################

        # PAGE 1
        self.ui.btn_page_1.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_1))

        # PAGE 2
        self.ui.btn_page_2.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_2))

        # PAGE 3
        self.ui.btn_page_3.clicked.connect(
            lambda: self.ui.stackedWidget.setCurrentWidget(self.ui.page_3))

        ########################################################################
        app.aboutToQuit.connect(lambda: UIFunctions.closeEvent(self))

        self.ui.pushButton.clicked.connect(
            lambda: UIFunctions.clickedButton(self))

        #self.ui.pushButton.clicked.connect(lambda: UIFunctions.clickedButton(self))
        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #19
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.logger = logging.getLogger('MainWindow')
        self.ui = Ui_MainWindow()
        self.rootDir = Path(__file__).parent
        self.dbDir = os.path.join(self.rootDir, "db")
        self.configFile = os.path.join(self.rootDir, 'src', 'config',
                                       'config.yaml')
        self.config = self.load_yml()

        # UI Stuff
        self.ui.setupUi(self)
        self.ui_functions = ui_Functions(self, self.ui)
        self.ui_functions.setWindowTitle(self.config['app']['title'])
        self.setWindowIcon(QtGui.QIcon(os.path.join(self.rootDir, 'App.ico')))

        # Connectors
        self.ui.btn_close.clicked.connect(self.window_close)
        self.ui.btn_max.clicked.connect(self.ui_functions.maximize_restore)
        self.ui.btn_min.clicked.connect(self.showMinimized)

        # Database Setup --------------------------
        self.db = Database(self.dbDir)

        # Setup Tables ----------------------------
        table_user = Users(self, "users")
        table_user.setup()

        QtCore.QTimer.singleShot(500, lambda: self.test())
Example #20
0
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.timer = QTimer()
        self.timer.setInterval(2)
        self.timer.timeout.connect(self.maim_task)
        self.timer.start()
Example #21
0
 def __init__(self):
     super(MyApp, self).__init__()
     QtWidgets.QMainWindow.__init__(self)
     Ui_MainWindow.__init__(self)
     # Configure l'interface utilisateur.
     self.setupUi(self)
     self.Liste_Employes.triggered.connect(self.toListe_emp)
     self.Competences.triggered.connect(self.toComp)
     self.Details_Operation.triggered.connect(self.toOp)
Example #22
0
    def __init__(self, lst):
        QMainWindow.__init__(self)

        self.ui = Ui_MainWindow()
        self.Boxes = []
        self.newlist = []
        self.today_news_list = lst

        self.Refresh()

        self.show()
Example #23
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # MAIN WINDOW LABEL
        QtCore.QTimer.singleShot(
            1500, lambda: self.ui.label.setText(
                "<strong>THANKS</strong> FOR WATCHING"))
        QtCore.QTimer.singleShot(
            1500,
            lambda: self.setStyleSheet("background-color: #222; color: #FFF"))
class Main(QtGui.QMainWindow):
    """
    Módulo principal del sistema
    """
    def __init__(self):
        super(Main, self).__init__()
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        # Cargamos las acciones al presionar el menú
        self.menu_actions()
        self.show()
        self.activar()

    def menu_actions(self):
        self.ui.actionModulo_Clientes.triggered.connect(self.load_mod1)
        self.ui.actionMarcas.triggered.connect(self.load_mod2)
        self.ui.actionModelosAutos.triggered.connect(self.load_mod3)
        self.ui.actionLogin.triggered.connect(self.load_mod4)
        
    def load_mod1(self):
        """carga modulo clientes"""
        widget = Mod1(self)
        self.setCentralWidget(widget)

    def load_mod2(self):
        """
        carga modulo marcas
        """
        widget = Mod2(self)
        self.setCentralWidget(widget)

    def load_mod3(self):
        """
        carga modulo modelos
        """
        widget = Mod3(self)
        self.setCentralWidget(widget)

    def load_mod4(self):
        """
        carga modulo del login
        """
        widget = Mod4(self)
        self.setCentralWidget(widget)

    def activar(self):
        """
        Este metodo lo llamara el login para activar las
        opciones princupales [originalmente estan desasctivadas]
        """
        self.ui.actionModulo_Clientes.setEnabled(True)
        self.ui.actionMarcas.setEnabled(True)
        self.ui.actionModelosAutos.setEnabled(True)
Example #25
0
 def __init__(self):
     QMainWindow.__init__(self)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     #self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMinimizeButtonHint)
     self.setFixedSize(self.width(), self.height())
     self.statusBar().setSizeGripEnabled(False)
     self.ui.lineEdit_email.setReadOnly(True)
     self.ui.lineEdit_name.setReadOnly(True)
     self.ui.lineEdit_password.setReadOnly(True)
     ## SHOW ==> MAIN WINDOW
     ########################################################################
     self.show()
Example #26
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        ## TOGGLE/BURGUER MENU
        ########################################################################
        self.ui.Btn_Toggle.clicked.connect(lambda: UIFunctions.toggleMenu(self, 250, True))


        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #27
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        ## DROP SHADOW EFFECT

        self.setAttribute(Qt.WA_TranslucentBackground)
        self.shadow = QGraphicsDropShadowEffect(self)
        self.shadow.setBlurRadius(20)
        self.shadow.setXOffset(0)
        self.shadow.setYOffset(0)
        self.shadow.setColor(QColor(0, 0, 0, 60))
        self.ui.frame.setGraphicsEffect(self.shadow)
Example #28
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.ui.Canvas_box.removeWidget(self.ui.Canvas_label)
        self.ui.Canvas_label = Canvas()
        self.ui.Canvas_label.initialize()
        # We need to enable mouse tracking to follow the mouse without the button pressed.
        # self.ui.Canvas_label.setMouseTracking(True)
        # Enable focus to capture key inputs.
        #self.ui.Canvas_label.setFocusPolicy(Qt.StrongFocus)

        self.ui.Canvas_box.addWidget(self.ui.Canvas_label)

        self.ui.stackedWidget.setCurrentWidget(self.ui.Drawing_page)

        # For the Drawing page
        self.ui.Drawing.clicked.connect(self.Drawing_page)

        # For the Home Page
        self.ui.Home.clicked.connect(self.Home_page)

        # For the Video
        self.ui.Video.clicked.connect(self.Camera_feed)

        #This is for the subition on the Canvas
        self.ui.sub.clicked.connect(self.sub_btn)

        # MOVE WINDOW
        def moveWindow(event):
            # RESTORE BEFORE MOVE
            if UIFunctions.returnStatus() == 1:
                UIFunctions.maximize_restore(self)

            # IF LEFT CLICK MOVE WINDOW
            if event.buttons() == Qt.RightButton:
                self.move(self.pos() + event.globalPos() - self.dragPos)
                self.dragPos = event.globalPos()
                event.accept()

        # SET TITLE BAR
        self.ui.title_bar.mouseMoveEvent = moveWindow

        ## ==> SET UI DEFINITIONS
        UIFunctions.uiDefinitions(self)

        ## SHOW ==> MAIN WINDOW
        ########################################################################
        self.show()
Example #29
0
class MainWindow(QMainWindow):
    def __init__(self, client):
        super(MainWindow, self).__init__()
        self.client = client

        # Set up the user interface from Designer.
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.ui.info_group_box.setTitle("User: "******"%0.2f" % (balance / 100.0))
        pattern = "Pay %0.2f to %s" if balance < 0 else "Receive %0.2f from %s"

        self.ui.transactions_list.clear()
        for user, value in transactions.items():
            self.ui.transactions_list.addItem(pattern % (value / 100.0, user))

    def pending(self):
        if not self._pending_dialog:
            self._pending_dialog = PendingWidget(self.client)
        self._pending_dialog.refresh()
        self._pending_dialog.show()
class MainWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # SET VALUE TO 0
        self.ui.progressBar.setValue(0)

        # EXPAND BTN
        self.ui.btnExpand.clicked.connect(self.expand)

        # RETRACT BTN
        self.ui.btnRetract.clicked.connect(self.retract)

        # RESIZE MAIN WINDOW
        self.ui.btnResizeWindow.clicked.connect(
            lambda: self.resizeMainWindow(1200, 500))

        # SHOW WINDOW
        self.show()

    # FUNCTION TO EXPAND PROGRESS BAR OR ANOTHER WIDGET
    def expand(self):
        # CREATE ANIMATION
        self.animation = QPropertyAnimation(self.ui.progressBar, b"value")
        self.animation.setDuration(2000)
        self.animation.setStartValue(0)
        self.animation.setEndValue(100)
        self.animation.setEasingCurve(QtCore.QEasingCurve.Linear)
        self.animation.start()

    def retract(self):
        # CREATE ANIMATION
        self.animation = QPropertyAnimation(self.ui.progressBar, b"value")
        self.animation.setDuration(2000)
        self.animation.setStartValue(100)
        self.animation.setEndValue(0)
        self.animation.setEasingCurve(QtCore.QEasingCurve.Linear)
        self.animation.start()

    def resizeMainWindow(self, width, height):
        # CREATE ANIMATION
        self.animation = QPropertyAnimation(self, b"size")
        self.animation.setDuration(1000)
        self.animation.setEndValue(QtCore.QSize(width, height))
        self.animation.setEasingCurve(QtCore.QEasingCurve.InOutQuad)
        self.animation.start()
Example #31
0
class MainWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # MAIN WINDOW LABEL
        QtCore.QTimer.singleShot(
            3000, lambda: self.ui.label.setText(
                "<strong>Thank You</strong> for using Mudra"))
        QtCore.QTimer.singleShot(
            1500,
            lambda: self.setStyleSheet("background-color: #222; color: #FFF"))

        window = tk.Tk()
        window.title("Mudra Camera Interface")
        window.iconphoto(False, tk.PhotoImage(file='mn.png'))
        window.geometry('500x500')
        window.configure(bg='#383A59')

        frame1 = tk.Frame(window)
        btn5 = tk.Button(frame1,
                         text='Upload File',
                         height=90,
                         width=230,
                         fg='black',
                         compound='left')

        btn4_image = Image.open('./main.png')
        btn4_image = btn4_image.resize((50, 50), Image.ANTIALIAS)
        btn4_image = ImageTk.PhotoImage(btn4_image)

        # --------------- Button -------------------#
        btn_font = font.Font(size=25)

        btn4 = tk.Button(frame1,
                         text='Launch',
                         height=90,
                         width=230,
                         fg='black',
                         command=record,
                         image=btn4_image,
                         compound='left')
        btn4['font'] = btn_font
        btn4.grid(row=5, pady=(20, 20), column=5)

        frame1.pack()
        window.mainloop()
Example #32
0
    def __init__(self, *args):
        super(Main, self).__init__(*args)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        icon = QtGui.QIcon("favicon.ico")
        self.setWindowIcon(icon)
        self.download_windows = File_Manager()

        self.date = datetime.fromisoformat('2011-11-04T00:00:00')
        self.state = True
        self.ui.time.setText(self.date.strftime('%H:%M:%S'))

        self.ui.dialog.clicked.connect(self.show_dialog)
        self.ui.video.clicked.connect(self.on_video)
        self.ui.file.clicked.connect(self.file_browser)
        self.ui.set_ip.clicked.connect(self.set_ip)
        self.ui.file_2.clicked.connect(self.show_files)

        self.record_state = QTimer()
        self.record_state.setInterval(1000)
        self.record_state.timeout.connect(self.onTimerOut)
        self.runing_state = QTimer()
        self.runing_state.setInterval(1000)
        self.stopEvent = threading.Event()
        self.stopEvent.clear()
Example #33
0
    def __init__(self, parent=None):

        QtGui.QMainWindow.__init__(self, parent)
        self.ui = Ui_MainWindow()

        self.ui.setupUi(self)

        self.server_pointers = []
        self.config_file = "config"

        self.server_list_layout = QtGui.QVBoxLayout()
        self.ui.server_list_container.setLayout(self.server_list_layout)

        self.ui.tab.content_set = "server_list"

        self.connect(self.ui.add_server_button, 
            QtCore.SIGNAL('pressed()'),self.add_server_to_list)

        self.connect(self.ui.tabWidget,
            QtCore.SIGNAL("currentChanged(int)"),self.tab_changed)

        ### menu triggers
        ### wonder if i can connect this ways buttons, etc...
        ### lazy to read manual for it :P
        self.ui.actionExit.triggered.connect(QtGui.qApp.quit)
        ### :'-(((can not connect to a function)))-':
        #self.ui.actionOpen.triggered.connect(self.open_config_file())
        self.connect(self.ui.actionOpen,
            QtCore.SIGNAL("triggered()"),self.open_config_file)

        self.get_servers_from_config()
 def __init__(self):
     super(Main, self).__init__()
     self.ui = Ui_Main()
     self.ui.setupUi(self)
     # Cargamos las acciones al presionar el menú
     self.menu_actions()
     self.show()
     self.activar()
Example #35
0
 def __init__(self, parent=None):
     #http://pythonadventures.wordpress.com/2013/01/10/launch-just-one-instance-of-a-qt-application/
     wid = self.get_pid()
     if_focus = os.popen('xdotool getactivewindow').readlines()
     #hide if the window have focues when executed again
     if if_focus[0] == wid:
         os.system('xdotool windowunmap "' + wid + '"')
         sys.exit()
     #Software already opened
     if wid:
         #Show
         os.system('xdotool windowmap ' + wid)
         #get focus
         os.system('xdotool windowactivate ' + wid)
         move_under_cursor()
         sys.exit()
     else:
         #Load the ui
         QMainWindow.__init__(self, parent)
         self.ui = Ui_MainWindow()
         self.ui.setupUi(self)
         #Set the MainWindow Title
         self.setWindowTitle(self.appname)
         #Connect the function with the signal
         self.ui.pushSettings.clicked.connect(self.openKeyDialog)
         self.ui.pushRefresh.clicked.connect(self.loadAsana)
         self.ui.pushAddTask.clicked.connect(self.addTask)
         self.ui.pushUpdate.clicked.connect(self.comboProjectChanged)
         self.ui.lineTask.returnPressed.connect(self.addTask)
         self.ui.comboWorkspace.currentIndexChanged.connect(self.comboWorkspaceChanged)
         self.ui.comboProject.currentIndexChanged.connect(self.comboProjectChanged)
         #When the software are closed on console the software are closed
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         #Add hide parameter
         parser = argparse.ArgumentParser()
         parser.add_argument("--hide", help="hide the window at startup", action="store_true")
         args = parser.parse_args()
         #Show the form
         QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
         self.show()
         if not args.hide:
             move_under_cursor()
         else:
             wid = self.get_pid()
             os.popen('xdotool windowunmap "' + wid + '"')
         self.loadAsana()
Example #36
0
    def __init__(self, parent=None):
        super(Window, self).__init__(parent)

        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.setupSignalsSlots()
        self.switchToMain()

        self.current_id = None

        self.led_model = LedModel()

        db = QSqlDatabase.addDatabase('QSQLITE')
        db.setDatabaseName('led-tool.db')
        db.open()

        self.manufacturers_model = QSqlTableModel()
        self.manufacturers_model.setTable("manufacturers")
        self.manufacturers_model.select()

        self.ui.brightness_group_table_view.setModel(self.led_model)

        self.ui.manufacturer_combo.setModel(self.manufacturers_model)
        self.ui.manufacturer_combo.setModelColumn(1)

        self.mapper = QDataWidgetMapper()
        self.mapper.setModel(self.led_model)
        self.mapper.addMapping(self.ui.name_edit, 1)
        self.mapper.addMapping(self.ui.typical_voltage_spin, 6)
        self.mapper.addMapping(self.ui.typical_current_spin, 7)
        self.mapper.addMapping(self.ui.thermal_resistance_spin, 4)
        self.mapper.addMapping(self.ui.reference_temperature_spin, 5)
        self.mapper.addMapping(self.ui.manufacturer_combo, 3)
        self.mapper.toFirst()

        self.ui.led_filter.installEventFilter(self)

        self.ui.main_stacked_widget.setCurrentIndex(1)
        self.ui.editor_stacked_widget.setCurrentIndex(0)
    def __init__(self):
        QMainWindow.__init__(self)
        self.toggleHistory = False
        self.context = Ui_MainWindow()
        self.context.setupUi(self)

        # Define's a media player that play's music and connects the seeker bar to it's seek position.
        self.player = QMediaPlayer()
        self.player.positionChanged.connect(self.updateSeeker)

        # Connects callback functions to the buttons in the GUI.
        self.context.btnPlay.clicked.connect(self.playMusic)
        self.context.btnPause.clicked.connect(self.pauseMusic)
        self.context.btnStop.clicked.connect(self.stopMusic)
        self.context.btnShuffle.clicked.connect(self.shuffleMusic)
        self.context.btnHistory.clicked.connect(self.switchHistory)
        self.context.btnClearHistory.clicked.connect(self.clearHistory)
        self.context.btnFund.clicked.connect(self.fundAccount)
        self.context.btnRefreshStore.clicked.connect(self.refreshStore)
        self.context.btnBuy.clicked.connect(self.buyMusic)
        self.context.btnCheckout.clicked.connect(self.checkout)
        self.context.btnPurchaseHistory.clicked.connect(self.showPurchases)
        self.context.seekSlider.sliderMoved.connect(self.setPosition)
        self.context.btnProfile.clicked.connect(self.showProfile)
        self.context.btnManager.clicked.connect(self.showManagerPanel)
        self.context.btnLogout.clicked.connect(self.logout)

        # Connects the history list to the media player.
        self.historyCount = 0
        self.context.btnClearHistory.setVisible(False)
        self.context.historyList.setVisible(False)
        self.context.historyList.setColumnWidth(0, 250)
        self.context.historyList.setColumnWidth(1, 60)
        self.context.historyList.setColumnWidth(2 , 150)
        self.context.historyList.verticalHeader().setVisible(False)
        self.context.historyList.cellDoubleClicked.connect(self.selectHistory)

        # Update's the GUI according to the current user's account info.
        self.updateAccountInfo()
Example #38
0
class MainForm(QtGui.QMainWindow):
    def __init__(self, parent=None):

        QtGui.QMainWindow.__init__(self, parent)
        self.ui = Ui_MainWindow()

        self.ui.setupUi(self)

        self.server_pointers = []
        self.config_file = "config"

        self.server_list_layout = QtGui.QVBoxLayout()
        self.ui.server_list_container.setLayout(self.server_list_layout)

        self.ui.tab.content_set = "server_list"

        self.connect(self.ui.add_server_button, 
            QtCore.SIGNAL('pressed()'),self.add_server_to_list)

        self.connect(self.ui.tabWidget,
            QtCore.SIGNAL("currentChanged(int)"),self.tab_changed)

        ### menu triggers
        ### wonder if i can connect this ways buttons, etc...
        ### lazy to read manual for it :P
        self.ui.actionExit.triggered.connect(QtGui.qApp.quit)
        ### :'-(((can not connect to a function)))-':
        #self.ui.actionOpen.triggered.connect(self.open_config_file())
        self.connect(self.ui.actionOpen,
            QtCore.SIGNAL("triggered()"),self.open_config_file)

        self.get_servers_from_config()

        

    def open_config_file(self):
        open_dialog = QtGui.QFileDialog()
        # open_dialog.exec_()

        # print open_dialog

        self.config_file = open_dialog.getOpenFileName()
        self.rebuild_config_gui(self.config_file)

    def rebuild_config_gui(self, config_file):
        print self.server_pointers
        for server in self.server_pointers:
            server.remove_server()
            print self.server_pointers

        self.get_servers_from_config(config_file)


    def add_server_to_list(self,name="",ip="",user="",passwd="",port="22"):
        
        server = ServerGUI_Node(self,name,ip,user,passwd,port)
        if self.server_pointers != None:
            self.server_pointers.append(server)
        else:
            self.server_pointers = []
            self.server_pointers.append(server)

        self.server_list_layout.addWidget(server.group_box)
        

        # self.ui.server_list_layout.addWidget(group_box)

    def get_servers_from_config(self, config_file=None):
        server_list = server_connect.get_config(config_file)
        print server_list.server_list
        for server in server_list.server_list:

            self.add_server_to_list(server.name,server.ip,
                server.user,server.passwd,server.port)

    def set_edit_conf_menu_active(self):
        self.ui.menuConfiguration.setDisabled(False)

    def tab_changed(self, i):
        if self.ui.tabWidget.currentWidget().content_set == "conf":
            self.set_edit_conf_menu_active()
        elif self.ui.tabWidget.currentWidget().content_set == "server_list":
            self.ui.menuConfiguration.setDisabled(True)
Example #39
0
class MainWindow(QMainWindow, Ui_MainWindow):
    #Create settings for the software
    settings = QSettings('Mte90', 'QAsana')
    settings.setFallbacksEnabled(False)
    version = '2.0'
    appname = 'QAsana - ' + version + ' by Mte90'
    workspaces_id = {}
    workspace_id = ''
    projects_id = {}
    project_id = ''
    proj_tasks_id = {}
    asana_api = None

    def __init__(self, parent=None):
        #http://pythonadventures.wordpress.com/2013/01/10/launch-just-one-instance-of-a-qt-application/
        wid = self.get_pid()
        if_focus = os.popen('xdotool getactivewindow').readlines()
        #hide if the window have focues when executed again
        if if_focus[0] == wid:
            os.system('xdotool windowunmap "' + wid + '"')
            sys.exit()
        #Software already opened
        if wid:
            #Show
            os.system('xdotool windowmap ' + wid)
            #get focus
            os.system('xdotool windowactivate ' + wid)
            move_under_cursor()
            sys.exit()
        else:
            #Load the ui
            QMainWindow.__init__(self, parent)
            self.ui = Ui_MainWindow()
            self.ui.setupUi(self)
            #Set the MainWindow Title
            self.setWindowTitle(self.appname)
            #Connect the function with the signal
            self.ui.pushSettings.clicked.connect(self.openKeyDialog)
            self.ui.pushRefresh.clicked.connect(self.loadAsana)
            self.ui.pushAddTask.clicked.connect(self.addTask)
            self.ui.pushUpdate.clicked.connect(self.comboProjectChanged)
            self.ui.lineTask.returnPressed.connect(self.addTask)
            self.ui.comboWorkspace.currentIndexChanged.connect(self.comboWorkspaceChanged)
            self.ui.comboProject.currentIndexChanged.connect(self.comboProjectChanged)
            #When the software are closed on console the software are closed
            signal.signal(signal.SIGINT, signal.SIG_DFL)
            #Add hide parameter
            parser = argparse.ArgumentParser()
            parser.add_argument("--hide", help="hide the window at startup", action="store_true")
            args = parser.parse_args()
            #Show the form
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
            self.show()
            if not args.hide:
                move_under_cursor()
            else:
                wid = self.get_pid()
                os.popen('xdotool windowunmap "' + wid + '"')
            self.loadAsana()

    def openKeyDialog(self):
        key, ok = QInputDialog.getText(self, 'Authorization Key', 'Insert the key:', QLineEdit.Normal, self.settings.value('Key'))
        if not self.settings.value('Key'):
            self.settings.setValue('Key', key)

    def loadAsana(self):
        if self.settings.value('Key') != -1:
            if self.settings.value('Key'):
                self.ui.comboWorkspace.currentIndexChanged.disconnect(self.comboWorkspaceChanged)
                QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
                self.asana_api = asana.Client.access_token(self.settings.value('Key'))
                #get workspace
                workspace = self.asana_api.users.me()
                workspace = workspace['workspaces']
                self.ui.comboWorkspace.clear()
                for workspace in self.asana_api.workspaces.find_all():
                    self.workspaces_id[workspace['name']] = workspace['id']
                    #populate the combobox
                    self.ui.comboWorkspace.addItem(workspace['name'])
                self.ui.comboWorkspace.currentIndexChanged.connect(self.comboWorkspaceChanged)
                self.comboWorkspaceChanged()
            else:
                QMessageBox.critical(self.window(), "Key not configured", "Set the key for access to Asana!")
        else:
            QMessageBox.critical(self.window(), "Key not configured", "Set the key for access to Asana!")

    def comboWorkspaceChanged(self):
        self.ui.comboProject.currentIndexChanged.disconnect(self.comboProjectChanged)
        self.workspace_id = self.workspaces_id[self.ui.comboWorkspace.currentText()]
        #get projects
        self.ui.comboProject.clear()
        for projects in self.asana_api.projects.find_all({'workspace': self.workspace_id, 'archived': 'false'}):
            self.projects_id[projects['name']] = projects['id']
            #populate the combobox
            self.ui.comboProject.addItem(projects['name'])
        self.ui.comboProject.currentIndexChanged.connect(self.comboProjectChanged)
        self.comboProjectChanged()

    def comboProjectChanged(self):
        if len(self.ui.comboProject.currentText()) > 0:
            self.project_id = self.projects_id[self.ui.comboProject.currentText()]
            #get project tasks
            qsubtasks = QStandardItemModel()
            for proj_tasks in self.asana_api.tasks.find_by_project(self.project_id, { 'completed_since': 'now'}):
                item = QStandardItem(proj_tasks['name'])
                item.setEditable(True)
                item.setToolTip('Double click to edit')
                if not proj_tasks['name'].endswith(':'):
                    check = Qt.Unchecked
                    item.setCheckState(check)
                    item.setCheckable(True)
                    self.projects_id[proj_tasks['name']] = proj_tasks['id']
                    item.setStatusTip(str(proj_tasks['id']))
                else:
                    font = QFont()
                    font.setWeight(QFont.Bold)
                    item.setFont(font)
                #populate the listview
                qsubtasks.appendRow(item)
            self.ui.listTasks.setModel(qsubtasks)
            QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))
            qsubtasks.itemChanged.connect(self.checkTasks)

    def checkTasks(self, item):
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        if item.checkState():
            self.asana_api.tasks.delete(self.projects_id[item.text()])
            self.ui.listTasks.model().removeRow(item.row())
        else:
            self.asana_api.tasks.update(item.statusTip(), {'id': item.statusTip(), 'name': item.text()})
        QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))

    def addTask(self):
        task = self.ui.lineTask.text()
        self.ui.lineTask.setText('')
        self.asana_api.tasks.create_in_workspace(self.workspace_id, {'name': task, 'projects': [self.project_id]})
        self.comboProjectChanged()

    def get_pid(self):
        wid = os.popen('xdotool search --name "' + self.appname + '"').readlines()
        #Check if multiple rows output
        if len(wid) > 0:
            wid = wid[0]
        return wid
Example #40
0
import sys
import gevent
import gevent.monkey
gevent.monkey.patch_all()

from PyQt5.QtWidgets import QApplication, QMainWindow
from ui_main import Ui_MainWindow
from PyQt5.Qt import Qt, QTimer, QFont

import sys
import telnetlib

app = QApplication(sys.argv)
window = QMainWindow()
ui = Ui_MainWindow()


def a(QKeyEvent):
    if QKeyEvent.key() == Qt.Key_Up:
        print 'up'
    if QKeyEvent.key() == Qt.Key_Down:
        print 'down'
    b(QKeyEvent)


def send():
    text = u"<span style='color:red'>{}</span>".format(ui.lineEdit.text())
    ui.plainTextEdit.appendHtml(text)
    data = ui.lineEdit.text()
    t = u"{}\n".format(data).encode('cp1251')
Example #41
0
class MainWindow(QtGui.QMainWindow):

    def __init__(self):
        super(MainWindow, self).__init__()
        self.np_img = None
        self.image_actions = []
        self._init_ui()

        self.view = self.ui.imageLabel
        self.image_opener = ImageOpener(self)
        self.image_saver = ImageSaver(self)
        self.image_editor = ImageEditor()
        self.image_history = History()
        self.user_settings_dump_n_loader = UserSettingsDumpNLoader()
        self.diff_images_dir = self.user_settings_dump_n_loader.get_diff_images_dir()
        self.golden_images_dir = self.user_settings_dump_n_loader.get_golden_images_dir()

        self._init_file_actions()
        self._init_M2_actions()
        self._init_M3_actions()
        self._init_M4_actions()
        self._init_M5_actions()
        self._init_M6_actions()
        self._enable_menu_items(False)

    def _init_ui(self):
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.ui.imageLabel.setAlignment(QtCore.Qt.AlignCenter)
        self.setCentralWidget(self.ui.imageLabel)

    def _init_file_actions(self):
        self.ui.actionExit.triggered.connect(QtGui.qApp.quit)
        self.ui.actionOpen.triggered.connect(self._open_file)
        self.ui.actionSave.triggered.connect(self._save_file)
        self.ui.actionSave_As.triggered.connect(self.image_saver.save_as_file)
        self.ui.actionUndo.triggered.connect(self._undo)
        self.ui.actionRedo.triggered.connect(self._redo)

        self.image_actions.append(self.ui.actionSave)
        self.ui.actionSave_As.setEnabled(False)
        self._enable_undo_redo()

    def _init_M2_actions(self):
        self.ui.actionErosion.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.erosion))
        self.ui.actionDilatation.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.dilatation))
        self.ui.actionInversion.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.inversion))
        self.image_actions.extend([self.ui.actionErosion, self.ui.actionDilatation, self.ui.actionInversion])

    def _init_M3_actions(self):
        self.ui.actionIntegrating_filter.triggered.connect(
            lambda: self._image_editor_wrapper(self.image_editor.linear_filter, ImageEditor.integration_filter_matrix,
                                               ImageEditor.integration_filter_divisor)
        )
        self.ui.actionBlur.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
                                             ImageEditor.blur_matrix, ImageEditor.blur_divisor))
        self.ui.actionSharpen.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
                                                ImageEditor.sharpen_matrix, ImageEditor.sharpen_divisor))
        self.ui.actionMake_new_custom_filter.triggered.connect(self._make_new_custom_filter)
        for filter_name, (matrix, divisor) in self.user_settings_dump_n_loader.get_filters().iteritems():
            action = QtGui.QAction(self)
            action.setText(filter_name)
            action.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
                                     matrix, divisor))
            self.ui.menuCustom_filters.addAction(action)
        self.image_actions.extend([self.ui.actionIntegrating_filter, self.ui.actionBlur,
                                   self.ui.actionSharpen, self.ui.actionMake_new_custom_filter])

    def _init_M4_actions(self):
        self.ui.actionWhite_noise.triggered.connect(lambda: self._get_two_params_and_edit("Probability (%)", "Range",
                                                                                          self.image_editor.white_noise))
        self.ui.actionDust.triggered.connect(lambda: self._get_two_params_and_edit("Probability (%)", "Min value",
                                                                                   self.image_editor.dust))
        self.ui.actionGrid.triggered.connect(lambda: self._get_two_params_and_edit("Width", "Height",
                                                                                   self.image_editor.grid))
        self.image_actions.extend([self.ui.actionWhite_noise, self.ui.actionDust, self.ui.actionGrid])

    def _init_M5_actions(self):
        self.ui.actionDifference.triggered.connect(lambda: self._diff_images())
        self.ui.actionSet_diff_images_path.triggered.connect(lambda: self._set_diff_images_dir(self._choose_directory()))
        self.ui.actionSet_golden_images_path.triggered.connect(lambda: self._set_golden_images_dir(self._choose_directory()))
        self.image_actions.extend([self.ui.actionDifference,
                                   self.ui.actionSet_diff_images_path, self.ui.actionSet_golden_images_path])

    def _init_M6_actions(self):
        self.ui.actionMedian_filter_r_1.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 1))
        self.ui.actionMedian_filter_r_2.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 2))
        self.ui.actionMedian_filter_r_3.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 3))
        self.image_actions.extend([self.ui.actionMedian_filter_r_1, self.ui.actionMedian_filter_r_2,
                                   self.ui.actionMedian_filter_r_3])

    def _enable_menu_items(self, mode):
        for action in self.image_actions:
            action.setEnabled(mode)

    def _image_editor_wrapper(self, editor_func, *args):
        self.image_history.add_new_state(self.np_img)
        self.image_editor.update_image(self.np_img)
        self.np_img = editor_func(*args)
        self._show_np_image()
        self._enable_undo_redo()
        self._enable_menu_items(True)

    def _make_new_custom_filter(self):
        dialog = MakeNewCustomLinearFilterDialog(self.user_settings_dump_n_loader.get_filters().keys())
        if dialog.exec_():
            matrix, divisor, name = dialog.get_values()
            self._image_editor_wrapper(self.image_editor.linear_filter, matrix, divisor)
            self.user_settings_dump_n_loader.save_filter(matrix, divisor, name)
            action = QtGui.QAction(self)
            action.setText(name)
            self.ui.menuCustom_filters.addAction(action)
            action.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
                                     matrix, divisor))

    def _get_two_params_and_edit(self, param1, param2, editor_func):
        dialog = BaseTwoParamsDialog(param1, param2)
        if dialog.exec_():
            param1_value, param2_value = dialog.get_values()
            self._image_editor_wrapper(editor_func, param1_value, param2_value)

    @staticmethod
    def _choose_directory():
        return str(QtGui.QFileDialog.getExistingDirectory(None, 'Choose directory', '.', QtGui.QFileDialog.ShowDirsOnly))

    def _set_golden_images_dir(self, dirname):
        if dirname:
            self.golden_images_dir = dirname
            self.user_settings_dump_n_loader.set_golden_images_dir(dirname)

    def _set_diff_images_dir(self, dirname):
        if dirname:
            self.golden_images_dir = dirname
            self.user_settings_dump_n_loader.set_diff_images_dir(dirname)

    def _diff_images(self):
        self.image_editor.update_image(self.np_img)
        basename = os.path.basename(str(self.image_saver.filename))
        try:
            golden_np_img = scipy.misc.imread(os.path.join(str(self.golden_images_dir), basename))
            is_ok, diff_img, percentage = self.image_editor.diff_images(golden_np_img)
            if not is_ok:
                QtGui.QMessageBox.about(self, 'Error', 'Images have different size.s')
            else:
                QtGui.QMessageBox.about(self, 'Diff percentage', 'diff: %.1f %%' % percentage)
                diff_filename = os.path.join(str(self.diff_images_dir), basename)
                if percentage:
                    self.image_saver.save_any(diff_img, diff_filename)
        except IOError:
            QtGui.QMessageBox.about(self, 'Error', 'There is no golden image with corresponding name.')

    def _open_file(self):
        self.np_img = self.image_opener.open_file()
        self.image_history.reset()
        self.image_history.add_new_state(self.np_img)
        self.image_saver.filename = self.image_opener.filename

        # in case of png files swap channels
        if self.np_img.shape[2] == 4:
            self.np_img = utils.bgra2rgba(self.np_img)
        self._show_np_image()

        self._enable_menu_items(True)
        self._enable_undo_redo()
        self.ui.actionSave_As.setEnabled(True)

    def _save_file(self):
        self.image_saver.np_img = self.np_img
        self.image_saver.save_file()
        self.ui.actionSave.setEnabled(False)

    def _undo(self):
        if self.image_history.can_undo():
            self.np_img = self.image_history.undo()
            self._show_np_image()
            self._enable_undo_redo()

    def _redo(self):
        if self.image_history.can_redo():
            self.np_img = self.image_history.redo()
            self._show_np_image()
            self._enable_undo_redo()

    def _enable_undo_redo(self):
        undo_state, redo_state = True, True
        if not self.image_history.can_redo():
            redo_state = False
        if not self.image_history.can_undo():
            undo_state = False
        self.ui.actionRedo.setEnabled(redo_state)
        self.ui.actionUndo.setEnabled(undo_state)

    def _show_np_image(self):
        img = utils.np_to_qimage(self.np_img)
        self._show_image(img)

    def _show_image(self, img):
        pixmap = QtGui.QPixmap.fromImage(img)
        pixmap = self.scale_pixmap(pixmap)
        self.view.setPixmap(pixmap)

    def scale_pixmap(self, pixmap):
        dest_height, dest_width = self.view.size().height(), self.view.size().width()
        if dest_height < pixmap.size().height():
            pixmap = pixmap.scaledToHeight(self.view.size().height())
        elif dest_width < pixmap.size().width():
            pixmap = pixmap.scaledToWidth(self.view.size().width())
        return pixmap

    def show_window(self):
        self.show()            
Example #42
0
 def _init_ui(self):
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     self.ui.imageLabel.setAlignment(QtCore.Qt.AlignCenter)
     self.setCentralWidget(self.ui.imageLabel)
Example #43
0
class Window(QMainWindow):
    def __init__(self, parent=None):
        super(Window, self).__init__(parent)

        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.setupSignalsSlots()
        self.switchToMain()

        self.current_id = None

        self.led_model = LedModel()

        db = QSqlDatabase.addDatabase('QSQLITE')
        db.setDatabaseName('led-tool.db')
        db.open()

        self.manufacturers_model = QSqlTableModel()
        self.manufacturers_model.setTable("manufacturers")
        self.manufacturers_model.select()

        self.ui.brightness_group_table_view.setModel(self.led_model)

        self.ui.manufacturer_combo.setModel(self.manufacturers_model)
        self.ui.manufacturer_combo.setModelColumn(1)

        self.mapper = QDataWidgetMapper()
        self.mapper.setModel(self.led_model)
        self.mapper.addMapping(self.ui.name_edit, 1)
        self.mapper.addMapping(self.ui.typical_voltage_spin, 6)
        self.mapper.addMapping(self.ui.typical_current_spin, 7)
        self.mapper.addMapping(self.ui.thermal_resistance_spin, 4)
        self.mapper.addMapping(self.ui.reference_temperature_spin, 5)
        self.mapper.addMapping(self.ui.manufacturer_combo, 3)
        self.mapper.toFirst()

        self.ui.led_filter.installEventFilter(self)

        self.ui.main_stacked_widget.setCurrentIndex(1)
        self.ui.editor_stacked_widget.setCurrentIndex(0)

    def setupSignalsSlots(self):
        self.ui.edit_led_button.clicked.connect(self.switchToEditor)
        self.ui.buttonBox.clicked.connect(self.switchToMain)

    def switchToEditor(self):
        self.ui.main_stacked_widget.setCurrentIndex(1)

    def switchToMain(self):
        self.ui.main_stacked_widget.setCurrentIndex(0)

    def eventFilter(self, source, event):
        if source is self.ui.led_filter:
            if event.type() == QEvent.KeyPress:
                if event.key() == Qt.Key_Escape:
                    self.ui.led_filter.clear()
        return QWidget.eventFilter(self, source, event)

    def keyPressEvent(self, event):

        default = True

        if event.key() == Qt.Key_Escape:
            self.switchToMain()
            default = False
#        if (event.modifiers() & Qt.ControlModifier):
#            if event.key() == Qt.Key_C: #copy
#                self.copyTableToClipboard()
#                default = False
#
#            if event.key() == Qt.Key_V: #paste
#                self.pasteClipboardToTable()
#                default = False

        if default:
            super(Window, self).keyPressEvent(event)
class MainWindow(QMainWindow):
    # Constructor which set's up the Main Window's GUI context.
    def __init__(self):
        QMainWindow.__init__(self)
        self.toggleHistory = False
        self.context = Ui_MainWindow()
        self.context.setupUi(self)

        # Define's a media player that play's music and connects the seeker bar to it's seek position.
        self.player = QMediaPlayer()
        self.player.positionChanged.connect(self.updateSeeker)

        # Connects callback functions to the buttons in the GUI.
        self.context.btnPlay.clicked.connect(self.playMusic)
        self.context.btnPause.clicked.connect(self.pauseMusic)
        self.context.btnStop.clicked.connect(self.stopMusic)
        self.context.btnShuffle.clicked.connect(self.shuffleMusic)
        self.context.btnHistory.clicked.connect(self.switchHistory)
        self.context.btnClearHistory.clicked.connect(self.clearHistory)
        self.context.btnFund.clicked.connect(self.fundAccount)
        self.context.btnRefreshStore.clicked.connect(self.refreshStore)
        self.context.btnBuy.clicked.connect(self.buyMusic)
        self.context.btnCheckout.clicked.connect(self.checkout)
        self.context.btnPurchaseHistory.clicked.connect(self.showPurchases)
        self.context.seekSlider.sliderMoved.connect(self.setPosition)
        self.context.btnProfile.clicked.connect(self.showProfile)
        self.context.btnManager.clicked.connect(self.showManagerPanel)
        self.context.btnLogout.clicked.connect(self.logout)

        # Connects the history list to the media player.
        self.historyCount = 0
        self.context.btnClearHistory.setVisible(False)
        self.context.historyList.setVisible(False)
        self.context.historyList.setColumnWidth(0, 250)
        self.context.historyList.setColumnWidth(1, 60)
        self.context.historyList.setColumnWidth(2 , 150)
        self.context.historyList.verticalHeader().setVisible(False)
        self.context.historyList.cellDoubleClicked.connect(self.selectHistory)

        # Update's the GUI according to the current user's account info.
        self.updateAccountInfo()

    # Log's the user out of the system and saves the store's database.
    # Also pauses the music in order to prevent any interference when logging
    # into a different account from the previous login.
    def logout(self):
        global currentAccount
        currentAccount = Account()
        saveDatabase()

        loginForm.show()
        self.stopMusic()
        self.hide()

    # Updates and shows the manager panel if it is not already visible.
    def showManagerPanel(self):
        if (not managerPanel.isVisible()):
            managerPanel.updateSetList()
            managerPanel.exec_()

    # Updates and shows the profile dialog if it is not already visible.
    def showProfile(self):
        if (not profileDialog.isVisible()):
            profileDialog.updateDialog()
            profileDialog.exec_()

    # Updates and shows the purchase dialog if it is not already visible.
    def showPurchases(self):
        if (not purchaseHistory.isVisible()):
            purchaseHistory.updateHistory()
            purchaseHistory.exec_()

    # Updates and shows the checkout dialog if it is not already visible.
    def checkout(self):
        if (not checkoutForm.isVisible()):
            checkoutForm.updateCheckout()
            checkoutForm.exec_()

    # Returns the present song selected within the store's list. Return's null if no selection is made.
    def getCurrentSong(self):
        selectSong = None
        for index, song in songs.enum():
            if (song.title == self.context.storeList.item(self.context.storeList.currentRow(), 0).text()):
                selectSong = song
        return selectSong

    # Add's a track to the user's cart according to their selection.
    def buyMusic(self):
        currentSong = self.getCurrentSong()

        # Determines if the user already has the track in their cart or purchases.
        if (not currentAccount.hasTrack(currentSong)):
            # Determines if there are more than 10 tracks in their cart.
            if (len(currentAccount.orders) == 9):
                QMessageBox.information(self, "Buy Track", "You can only purchase 10 tracks at a time.")
            else:
                # Display a confirmation message stating whether or not the user wants to buy the song.
                reply = QMessageBox.question(self, "Buy Track",
                     "Are you sure you would like to add\n%s\nto your cart for $%s?" % (currentSong.title, str(currentSong.cost)), QMessageBox.Yes, QMessageBox.No)
                if (reply == QMessageBox.Yes):
                    currentAccount.orders.append(currentSong)
                    checkoutForm.updateCheckout()
        else:
            QMessageBox.information(self, "Buy Track", "This track is already in your cart, or you have already bought the track.")

    # Re-populates the store's inventory list.
    def refreshStore(self):
        loadMusic(False)

    # Funds the user's balance with an inputted amount of money.
    def fundAccount(self):
        try:
            currentAccount.fund(float(QInputDialog.getText(self, "Fund Account", "Amount:", QLineEdit.Normal, "0")[0]))
            QMessageBox.information(self, "Fund Account", "Your account has been successfully funded.")
        except ValueError:
            QMessageBox.information(self, "Fund Account", "The amount you wished to fund is invalid.")

    # Clear's the history list.
    def clearHistory(self):
        self.context.historyList.clearContents()
        self.context.historyList.setRowCount(0)
        self.historyCount = 0

    # Toggles between the history list and store inventory list.
    def switchHistory(self):
        self.toggleHistory = not self.toggleHistory
        self.context.historyList.setVisible(self.toggleHistory)
        self.context.btnClearHistory.setVisible(self.toggleHistory)
        self.context.storeList.setVisible(not self.toggleHistory)
        self.context.btnRefreshStore.setVisible(not self.toggleHistory)
        if (self.toggleHistory):
            self.context.btnHistory.setText("Browse Store")
        else:
            self.context.btnHistory.setText("Play History")

    # Updates the GUI according to the current user's info.
    def updateAccountInfo(self):
        global currentAccount
        self.context.cashLabel.setText("$%.2f" % (currentAccount.balance))

        # Set's the Manager Panel button visible if the user is a manager.
        self.context.btnManager.setVisible(currentAccount.status == MANAGER_ACCOUNT)

    # Re-populates the store inventory list.
    def fillMusicList(self):
        # Nullifies the present content in the store's inventory list.
        self.context.storeList.clearContents()

        # Re-populates the store list.
        self.context.storeList.setRowCount(songs.size())
        self.context.storeList.setSortingEnabled(False)
        for index, song in songs.enum():
            titleObj = QTableWidgetItem(song.title)
            durationObj = QTableWidgetItem(msToHms(int(song.duration)))
            artistObj = QTableWidgetItem(song.artist)
            priceObj = QTableWidgetItem(str(song.cost))

            # Set's each widget on the store list as read-only.
            titleObj.setFlags(Qt.ItemIsEnabled)
            durationObj.setFlags(Qt.ItemIsEnabled)
            artistObj.setFlags(Qt.ItemIsEnabled)
            priceObj.setFlags(Qt.ItemIsEnabled)

            self.context.storeList.setItem(index, 0, titleObj)
            self.context.storeList.setItem(index, 1, durationObj)
            self.context.storeList.setItem(index, 2, artistObj)
            self.context.storeList.setItem(index, 3, priceObj)

        # Defines the store column widths.
        self.context.storeList.setColumnWidth(0, 250)
        self.context.storeList.setColumnWidth(1, 60)
        self.context.storeList.setColumnWidth(2 , 150)
        self.context.storeList.setSortingEnabled(True)
        self.context.storeList.verticalHeader().setVisible(False)
        self.context.storeList.cellDoubleClicked.connect(self.selectSong)

        # Shows the user how many track's are in stock.
        self.context.trackCount.setText("There are currently %s tracks in stock." % (str(songs.size())))

    # A callback function that handles whenever a song is double clicked within the store inventory list.
    def selectSong(self, row, column):
        selectSong = self.getCurrentSong()
        if (selectSong != None): # Determine if a selection is present.
            self.context.seekSlider.setMaximum(int(selectSong.duration))
            self.context.songName.setText(selectSong.title)

            # Play's the song.
            self.setMusic(selectSong.streamUrl, True)

            # Shows the user the song's thumbnail if the song has a thumbnail. Otherwise shows a blank canvas.
            if (selectSong.imageUrl != None):
                try:
                    image = QPixmap()
                    image.loadFromData(urllib.request.urlopen(selectSong.imageUrl).read())
                    image = image.scaled(QSize(225, 225), Qt.KeepAspectRatio, Qt.SmoothTransformation);
                    scene = QGraphicsScene(self.context.songImage)
                    scene.addPixmap(image)
                    self.context.songImage.setScene(scene)
                except ValueError:
                    image = QPixmap()
                    scene = QGraphicsScene(self.context.songImage)
                    scene.addPixmap(image)

                    self.context.songImage.setScene(scene)

                # Add's the song to the history.
                self.addHistory(selectSong)

    # Add's an entry to the history list.
    def addHistory(self, song):
        tObj = QTableWidgetItem(song.title)
        dObj = QTableWidgetItem(msToHms(int(song.duration)))
        aObj = QTableWidgetItem(song.artist)
        pObj = QTableWidgetItem(str(song.cost))

        # Set the widget for the history column to be read-only.
        tObj.setFlags(Qt.ItemIsEnabled)
        dObj.setFlags(Qt.ItemIsEnabled)
        aObj.setFlags(Qt.ItemIsEnabled)
        pObj.setFlags(Qt.ItemIsEnabled)

        self.context.historyList.setRowCount(self.historyCount + 1)
        self.context.historyList.setItem(self.historyCount, 0, tObj)
        self.context.historyList.setItem(self.historyCount, 1, dObj)
        self.context.historyList.setItem(self.historyCount, 2, aObj)
        self.context.historyList.setItem(self.historyCount, 3, pObj)
        self.historyCount += 1

    # A callback function that handles whenever a song is double clicked within the history list.
    def selectHistory(self, row, column):
        selectSong = self.getCurrentSong()
        if (selectSong != None): # Determines if a selection is present.
            self.context.seekSlider.setMaximum(int(selectSong.duration))
            self.context.songName.setText(selectSong.title)

            # Play's the song.
            self.setMusic(selectSong.streamUrl, True)

            # Shows the user the song's thumbnail if the song has a thumbnail. Otherwise shows a blank canvas.
            if (selectSong.imageUrl != None):
                try:
                    image = QPixmap()
                    image.loadFromData(urllib.request.urlopen(selectSong.imageUrl).read())
                    image = image.scaled(QSize(225, 225), Qt.KeepAspectRatio, Qt.SmoothTransformation);
                    scene = QGraphicsScene(self.context.songImage)
                    scene.addPixmap(image)
                    self.context.songImage.setScene(scene)
                except ValueError:
                    image = QPixmap()
                    scene = QGraphicsScene(self.context.songImage)
                    scene.addPixmap(image)
                    self.context.songImage.setScene(scene)

    # Play's or sets a song on the media player according to a given stream URL.
    def setMusic(self, streamUrl, play=False):
        global soundcloud_api_key
        self.player.setMedia(QMediaContent(QUrl(streamUrl + "?client_id=" + soundcloud_api_key)))
        if (play):
            self.playMusic()

    # A callback function that binds the media player's seek position to the seek slider's position.
    def setPosition(self):
        self.player.setPosition(self.context.seekSlider.sliderPosition())

    # Update's the seek slider's position as the media player streams a song.
    # Also update's the audio position label to the media player.
    def updateSeeker(self, position):
        self.context.seekSlider.setSliderPosition(position)
        self.context.audioPosition.setText(msToHms(position))

    # Randomly play's a song in the store's inventory list.
    def shuffleMusic(self):
        randomRow = random.randint(0, self.context.storeList.rowCount())
        self.context.storeList.setCurrentCell(randomRow, 0)
        self.selectSong(randomRow, 0)

    # Tell's the media player to play.
    def playMusic(self):
        self.player.play()

    # Tell's the media player to pause itself.
    def pauseMusic(self):
        self.player.pause()

    # Tell's the media player to pause itself and seek the current media towards it's
    # initial point.
    def stopMusic(self):
        self.player.stop()
Example #45
0
 def __init__(self, *args):
     QtGui.QMainWindow.__init__(self, *args)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     self.createConnects()