Example #1
0
 def toside(self):
     screen = QtGui.QDesktopWidget().screenGeometry()
     size = self.geometry()
     #        self.move((screen.width()-size.width()) , (screen.height()-size.height()))
     self.setGeometry((screen.width() - size.width()) + 320,
                      (screen.height() - size.height()) - 130, 200, 390)
Example #2
0
 def center(self):
     screen = QtGui.QDesktopWidget().screenGeometry()
     size = self.geometry()
     self.move((screen.width() - size.width()) / 2,
               (screen.height() - size.height()) / 2)
Example #3
0
    def __init__(self, parent, appName, argTemplate, account, server, ticket,
                 chatServer, language, runDir, wineProgram, wineDebug,
                 winePrefix, hiResEnabled, wineApp, osType, homeDir, icoFileIn,
                 rootDir):

        self.winMain = parent
        self.homeDir = homeDir
        self.winLog = QtGui.QDialog(parent)
        self.osType = osType

        uifile = None
        icofile = None

        try:
            from pkg_resources import resource_filename
            uifile = resource_filename(__name__, 'ui/winLog.ui')
            icofile = resource_filename(__name__, icoFileIn)
        except:
            uifile = os.path.join(rootDir, "ui", "winLog.ui")
            icofile = os.path.join(rootDir, icoFileIn)

        Ui_winLog, base_class = uic.loadUiType(uifile)
        self.uiLog = Ui_winLog()
        self.uiLog.setupUi(self.winLog)
        self.winLog.setWindowFlags(QtCore.Qt.Dialog)
        self.winLog.setWindowIcon(QtGui.QIcon(icofile))
        screen = QtGui.QDesktopWidget().screenGeometry()
        size = self.winLog.geometry()
        self.winLog.move((screen.width() - size.width()) / 2,
                         (screen.height() - size.height()) / 2)

        if self.osType.usingWindows:
            self.winLog.setWindowTitle("Output")
        else:
            if wineApp == "Wine":
                self.winLog.setWindowTitle("Launch Game - Wine output")
            else:
                self.winLog.setWindowTitle("Launch Game - Crossover output")

        #self.uiLog.btnStart.setVisible(False)
        self.uiLog.btnStart.setText("Launcher")
        self.uiLog.btnStart.setEnabled(False)
        self.uiLog.btnSave.setText("Save")
        self.uiLog.btnSave.setEnabled(False)
        self.uiLog.btnStop.setText("Exit")
        QtCore.QObject.connect(self.uiLog.btnStart, QtCore.SIGNAL("clicked()"),
                               self.btnStartClicked)
        QtCore.QObject.connect(self.uiLog.btnSave, QtCore.SIGNAL("clicked()"),
                               self.btnSaveClicked)
        QtCore.QObject.connect(self.uiLog.btnStop, QtCore.SIGNAL("clicked()"),
                               self.btnStopClicked)

        self.aborted = False
        self.finished = False
        self.command = ""
        self.arguments = []

        gameParams = argTemplate.replace("{SUBSCRIPTION}", account).replace(
            "{LOGIN}", server).replace("{GLS}", ticket).replace(
                "{CHAT}", chatServer).replace("{LANG}", language)

        if not hiResEnabled:
            gameParams = gameParams + " --HighResOutOfDate"

        if wineDebug != "":
            os.environ["WINEDEBUG"] = wineDebug

        if winePrefix != "" and wineApp == "Wine":
            os.environ["WINEPREFIX"] = winePrefix

        self.process = QtCore.QProcess()
        QtCore.QObject.connect(self.process,
                               QtCore.SIGNAL("readyReadStandardOutput()"),
                               self.readOutput)
        QtCore.QObject.connect(self.process,
                               QtCore.SIGNAL("readyReadStandardError()"),
                               self.readErrors)
        QtCore.QObject.connect(
            self.process, QtCore.SIGNAL("finished(int, QProcess::ExitStatus)"),
            self.resetButtons)

        if wineApp == "Native":
            self.command = appName
            self.process.setWorkingDirectory(runDir)

            os.chdir(runDir)

            for arg in gameParams.split(" "):
                self.arguments.append(arg)

        elif wineApp == "Wine":
            self.command = wineProgram
            self.process.setWorkingDirectory(runDir)

            self.arguments.append(appName)

            for arg in gameParams.split(" "):
                self.arguments.append(arg)

        elif wineApp == "CXGames":
            if not self.osType.startCXG():
                self.uiLog.txtLog.append(
                    "<b>Error: Couldn't start Crossover Games</b>")
                self.uiLog.btnSave.setEnabled(False)
                self.uiLog.btnStart.setEnabled(False)

            if self.osType.macPathCX == "":
                tempFile = "%s%s%s" % (self.osType.globalDir,
                                       self.osType.directoryCXG, wineProgram)

                if os.path.isfile(tempFile):
                    self.command = tempFile
                else:
                    tempFile = "%s%s%s" % (homeDir, self.osType.directoryCXG,
                                           wineProgram)

                    if os.path.isfile(tempFile):
                        self.command = tempFile
                    else:
                        self.command = wineProgram
            else:
                self.command = "%s%s" % (self.osType.macPathCX, wineProgram)

            self.process.setWorkingDirectory(runDir)

            tempArg = "--bottle %s --verbose -- %s %s" % (winePrefix, appName,
                                                          gameParams)
            for arg in tempArg.split(" "):
                self.arguments.append(arg)
        elif wineApp == "CXOffice":
            if not self.osType.startCXO():
                self.uiLog.txtLog.append(
                    "<b>Error: Couldn't start Crossover</b>")
                self.uiLog.btnSave.setEnabled(False)
                self.uiLog.btnStart.setEnabled(False)

            if self.osType.macPathCX == "":
                tempFile = "%s%s%s" % (self.osType.globalDir,
                                       self.osType.directoryCXO, wineProgram)

                if os.path.isfile(tempFile):
                    self.command = tempFile
                else:
                    tempFile = "%s%s%s" % (homeDir, self.osType.directoryCXO,
                                           wineProgram)

                    if os.path.isfile(tempFile):
                        self.command = tempFile
                    else:
                        self.command = wineProgram
            else:
                self.command = "%s%s" % (self.osType.macPathCX, wineProgram)

            self.process.setWorkingDirectory(runDir)

            tempArg = "--bottle %s --verbose -- %s %s" % (winePrefix, appName,
                                                          gameParams)
            for arg in tempArg.split(" "):
                self.arguments.append(arg)
Example #4
0
 def center(self):
   qr = self.frameGeometry()
   cp = QtGui.QDesktopWidget().availableGeometry().center()
   qr.moveCenter(cp)
   self.move(qr.topLeft())
 def position(self):
     screen = QtGui.QDesktopWidget().screenGeometry()
     x = (screen.width() - self.geometry().width()) / 2
     y = (screen.height() - self.geometry().height()) / 2
     self.move(x, y)
Example #6
0
    def __init__(self):

        QtGui.QMainWindow.__init__(self)

        #Dimensiones originales
        size_x_Original = 1080
        size_y_Original = 1920

        #Clicked button
        self.p = 1.15
        self.b = 0.95

        #Flags Vista 2
        self.IsChecked = [['Red', False], ['Pink', False], ['Blue', False],
                          ['Black', False], ['Yellow', False]]

        #Direcciones de Imágenes de fondo
        self.MAIN_VIEW = "src/img/ArtesPowerRangers/Pantalla 1/1.jpg"
        self.VIEW_2 = "src/img/ArtesPowerRangers/Pantalla 2/1 Back.jpg"
        self.VIEW_3 = "src/img/ArtesPowerRangers/Pantalla 3/1 Back.jpg"
        self.VIEW_5 = "src/img/ArtesPowerRangers/Pantalla 5/Back5.jpg"
        self.VIEW_6 = "src/img/ArtesPowerRangers/Pantalla 7/Back-7.jpg"

        #Direcciones Caras Vista 3
        self.URL_FACES = [
            "src/img/ArtesPowerRangers/Pantalla 3/3 Rengers/Red.jpg",
            "src/img/ArtesPowerRangers/Pantalla 3/3 Rengers/Pink.jpg",
            "src/img/ArtesPowerRangers/Pantalla 3/3 Rengers/Blue.jpg",
            "src/img/ArtesPowerRangers/Pantalla 3/3 Rengers/Black.jpg",
            "src/img/ArtesPowerRangers/Pantalla 3/3 Rengers/Yellow.jpg"
        ]

        self.RED = "src/img/ArtesPowerRangers/Pantalla 2/Red.jpg"
        self.RED_BLOCK = "src/img/ArtesPowerRangers/Pantalla 2/red_blocked.png"
        self.BLUE = "src/img/ArtesPowerRangers/Pantalla 2/Blue.jpg"
        self.BLUE_BLOCK = "src/img/ArtesPowerRangers/Pantalla 2/azul_blocked.png"
        self.BLACK = "src/img/ArtesPowerRangers/Pantalla 2/black.jpg"
        self.BLACK_BLOCK = "src/img/ArtesPowerRangers/Pantalla 2/black_blocked.png"
        self.PINK = "src/img/ArtesPowerRangers/Pantalla 2/pink.jpg"
        self.PINK_BLOCK = "src/img/ArtesPowerRangers/Pantalla 2/pink_blocked.png"
        self.YELLOW = "src/img/ArtesPowerRangers/Pantalla 2/yellow.jpg"
        self.YELLOW_BLOCK = "src/img/ArtesPowerRangers/Pantalla 2/yellow_blocked.png"

        self.GIF = "src/img/gif_red.gif"

        self.PASS_MAIL = "aradmagol"
        self.MAIL = "*****@*****.**"

        # Se monta la interfaz de usuario para la pantalla principal
        self.ui = uic.loadUi("views/main.ui")

        #Se bloquea el marco superior
        self.ui.setWindowFlags(self.ui.windowFlags()
                               | QtCore.Qt.CustomizeWindowHint)
        self.ui.setWindowFlags(self.ui.windowFlags()
                               & ~QtCore.Qt.WindowMaximizeButtonHint)

        #Full Screen
        self.ui.showFullScreen()
        screen = QtGui.QDesktopWidget().screenGeometry()

        #Dimensiones de la pantalla
        self.size_x = screen.width()
        self.size_y = screen.height()

        #Relación imagen/pantalla
        rel_x = float(self.size_x) / float(size_x_Original)
        rel_y = float(self.size_y) / float(size_y_Original)

        #----------Vista 1---------------
        #Se carga la imagen principal
        palette = QPalette()
        palette.setBrush(
            QPalette.Background,
            QBrush(QPixmap(self.MAIN_VIEW).scaled(self.size_x, self.size_y)))
        self.ui.setPalette(palette)
        #Vista de inicio
        self.ui.setCurrentWidget(self.ui.View1)

        #----------Bóton Inicio-----------
        nx = self.ui.inicio_btn.width() * rel_x
        ny = self.ui.inicio_btn.height() * rel_y

        self.ui.inicio_btn.resize(int(nx), int(ny))
        self.ui.inicio_btn.move(int(self.size_x / 2 - nx / 2),
                                int(7 * self.size_y / 8))
        self.ui.inicio_btn.mousePressEvent = self.pressStartV1
        self.ui.inicio_btn.mouseReleaseEvent = self.releaseStartV1
        #----------------------------------

        #-----------Vista 2----------------
        #-----------Título-----------------
        tx = self.ui.title_v2.width() * rel_x
        ty = self.ui.title_v2.height() * rel_y

        self.ui.title_v2.resize(int(tx), int(ty))
        self.ui.title_v2.move(int(self.size_x / 2 - tx / 2),
                              int(self.size_y / 10))

        #----------Bóton Ranger Azul-------
        y_init = 403 * rel_y

        brx = self.ui.blue_ranger.width() * rel_x
        bry = self.ui.blue_ranger.height() * rel_y

        self.ui.blue_ranger.resize(int(brx), int(bry))
        self.ui.blue_ranger.move(int(self.size_x / 2 - brx / 2), int(y_init))
        self.ui.blue_ranger.mousePressEvent = self.pressBlue

        #----------Bóton Ranger Rosa-----------
        self.ui.pink_ranger.resize(int(brx), int(bry))
        self.ui.pink_ranger.move(int(self.size_x / 2 - brx / 2),
                                 int(y_init + bry))
        self.ui.pink_ranger.mousePressEvent = self.pressPink

        #----------Bóton Ranger Rojo-----------
        self.ui.red_ranger.resize(int(brx), int(bry))
        self.ui.red_ranger.move(int(self.size_x / 2 - brx / 2),
                                int(y_init + 2 * bry))
        self.ui.red_ranger.mousePressEvent = self.pressRed

        #----------Bóton Ranger Amarillo-----------
        self.ui.yellow_ranger.resize(int(brx), int(bry))
        self.ui.yellow_ranger.move(int(self.size_x / 2 - brx / 2),
                                   int(y_init + 3 * bry))
        self.ui.yellow_ranger.mousePressEvent = self.pressYellow

        #----------Bóton Ranger Negro-----------
        self.ui.black_ranger.resize(int(brx), int(bry))
        self.ui.black_ranger.move(int(self.size_x / 2 - brx / 2),
                                  int(y_init + 4 * bry))
        self.ui.black_ranger.mousePressEvent = self.pressBlack

        #----------Botón Continuar-------------
        self.y_init_btn = 1700 * rel_y

        c2x = self.ui.continue_btn.width() * rel_x
        c2y = self.ui.continue_btn.height() * rel_y

        self.ui.continue_btn.resize(int(c2x), int(c2y))
        self.ui.continue_btn.move(int(self.size_x / 2 - c2x / 2),
                                  int(self.y_init_btn))
        self.ui.continue_btn.mousePressEvent = self.pressContinueV2
        self.ui.continue_btn.mouseReleaseEvent = self.releaseContinueV2

        #--------------------------------------
        #Se guarda el tamaño original del botón
        self.x_red = self.ui.red_ranger.width()
        self.y_red = self.ui.red_ranger.height()

        #Se guarda el tamaño original del botón
        self.x_black = self.ui.black_ranger.width()
        self.y_black = self.ui.black_ranger.height()

        #Se guarda el tamaño original del botón
        self.x_pink = self.ui.pink_ranger.width()
        self.y_pink = self.ui.pink_ranger.height()

        #Se guarda el tamaño original del botón
        self.x_blue = self.ui.blue_ranger.width()
        self.y_blue = self.ui.blue_ranger.height()

        #Se guarda el tamaño original del botón
        self.x_yellow = self.ui.yellow_ranger.width()
        self.y_yellow = self.ui.yellow_ranger.height()

        #------------Vista 3--------------
        #-----------Título-----------------
        self.t3x = self.ui.title_v3.width() * rel_x
        t3y = self.ui.title_v3.height() * rel_y

        self.ui.title_v3.resize(int(self.t3x), int(t3y))
        self.ui.title_v3.move(int(self.size_x / 2 - self.t3x / 2),
                              int(self.size_y / 9))

        self.fx = self.ui.photo_ranger.width() * rel_x
        fy = self.ui.photo_ranger.height() * rel_y

        self.ui.photo_ranger.resize(int(self.fx), int(fy))
        self.ui.photo_ranger.move(int(self.size_x / 2 - self.fx / 2),
                                  int(self.size_y / 6))

        self.name_x = self.ui.name_v3.width() * rel_x
        self.name_y = self.ui.name_v3.height() * rel_y

        self.ui.name_v3.resize(int(self.name_x), int(self.name_y))
        self.ui.name_v3.move(int(self.size_x / 2 - self.name_x / 2),
                             int(self.size_y / 2 + 2 * self.name_y))

        #--------------Keyboard-----------
        self.promptTex = ""
        self.ui.keyboard.move(
            int(self.size_x / 2 - self.ui.keyboard.width() / 2),
            int(self.size_y / 2))
        self.ui.key_a.mouseReleaseEvent = self.key_a
        self.ui.key_b.mouseReleaseEvent = self.key_b
        self.ui.key_c.mouseReleaseEvent = self.key_c
        self.ui.key_d.mouseReleaseEvent = self.key_d
        self.ui.key_e.mouseReleaseEvent = self.key_e
        self.ui.key_f.mouseReleaseEvent = self.key_f
        self.ui.key_g.mouseReleaseEvent = self.key_g
        self.ui.key_h.mouseReleaseEvent = self.key_h
        self.ui.key_i.mouseReleaseEvent = self.key_i
        self.ui.key_j.mouseReleaseEvent = self.key_j
        self.ui.key_k.mouseReleaseEvent = self.key_k
        self.ui.key_l.mouseReleaseEvent = self.key_l
        self.ui.key_m.mouseReleaseEvent = self.key_m
        self.ui.key_n.mouseReleaseEvent = self.key_n
        self.ui.key_o.mouseReleaseEvent = self.key_o
        self.ui.key_p.mouseReleaseEvent = self.key_p
        self.ui.key_q.mouseReleaseEvent = self.key_q
        self.ui.key_r.mouseReleaseEvent = self.key_r
        self.ui.key_s.mouseReleaseEvent = self.key_s
        self.ui.key_t.mouseReleaseEvent = self.key_t
        self.ui.key_u.mouseReleaseEvent = self.key_u
        self.ui.key_v.mouseReleaseEvent = self.key_v
        self.ui.key_w.mouseReleaseEvent = self.key_w
        self.ui.key_x.mouseReleaseEvent = self.key_x
        self.ui.key_y.mouseReleaseEvent = self.key_y
        self.ui.key_z.mouseReleaseEvent = self.key_z

        self.ui.key_1.mouseReleaseEvent = self.key_1
        self.ui.key_2.mouseReleaseEvent = self.key_2
        self.ui.key_3.mouseReleaseEvent = self.key_3
        self.ui.key_4.mouseReleaseEvent = self.key_4
        self.ui.key_5.mouseReleaseEvent = self.key_5
        self.ui.key_6.mouseReleaseEvent = self.key_6
        self.ui.key_7.mouseReleaseEvent = self.key_7
        self.ui.key_8.mouseReleaseEvent = self.key_8
        self.ui.key_9.mouseReleaseEvent = self.key_9
        self.ui.key_0.mouseReleaseEvent = self.key_0

        self.ui.key_punto.mouseReleaseEvent = self.key_punto
        self.ui.key_puntocoma.mouseReleaseEvent = self.key_puntocoma
        self.ui.key_coma.mouseReleaseEvent = self.key_coma
        self.ui.key_space.mouseReleaseEvent = self.key_space
        self.ui.key_money.mouseReleaseEvent = self.key_money
        self.ui.key_cs.mouseReleaseEvent = self.key_cs
        self.ui.key_cc.mouseReleaseEvent = self.key_cc
        self.ui.key_guionbajo.mouseReleaseEvent = self.key_guion_bajo
        self.ui.key_guion.mouseReleaseEvent = self.key_guion_alto
        self.ui.key_admirar.mouseReleaseEvent = self.key_admiracion
        self.ui.key_porcentage.mouseReleaseEvent = self.key_porcentaje
        self.ui.key_arroba.mouseReleaseEvent = self.key_arroba
        self.ui.key_number.mouseReleaseEvent = self.key_number

        self.ui.key_delete.mouseReleaseEvent = self.key_delete

        #-------------Continuar-----------
        self.c3x = self.ui.continue_btn_V3.width() * rel_x
        c3y = self.ui.continue_btn_V3.height() * rel_y

        self.ui.continue_btn_V3.resize(int(self.c3x), int(c3y))
        self.ui.continue_btn_V3.move(int(self.size_x / 2 - self.c3x / 2),
                                     int(self.y_init_btn))
        self.ui.continue_btn_V3.mousePressEvent = self.pressContinueV3
        self.ui.continue_btn_V3.mouseReleaseEvent = self.releaseContinueV3

        #--------------Atrás--------------
        self.ax = self.ui.cancelar.width() * rel_x
        ay = self.ui.cancelar.height() * rel_y

        self.ui.cancelar.resize(int(self.ax), int(ay))
        self.ui.cancelar.move(int(self.size_x / 25), int(self.y_init_btn))
        self.ui.cancelar.mousePressEvent = self.pressCancelar
        self.ui.cancelar.mouseReleaseEvent = self.releaseCancelar

        self.firstTime = False

        #--------------Vista 5---------------
        #------------Muestra GIF-------------
        altura_gif = 350 * rel_y
        gif_x = self.ui.the_gif.width() * rel_x
        gif_y = self.ui.the_gif.height() * rel_y

        self.ui.the_gif.resize(int(gif_x), int(gif_y))
        self.ui.the_gif.move(int(self.size_x / 2 - gif_x / 2), int(altura_gif))
        #--------------Marco-----------------
        altura_mark = 1250 * rel_y
        mark_x = self.ui.cuadro.width() * rel_x
        mark_y = self.ui.cuadro.height() * rel_y

        self.ui.cuadro.resize(int(mark_x), int(mark_y))
        self.ui.cuadro.move(int(self.size_x / 2 - mark_x / 2),
                            int(altura_mark))
        #-----------Atrás botón--------------
        altura_atras = 1350 * rel_y
        base_atras = 130 * rel_x

        atras_x = self.ui.atras.width() * rel_x
        atras_y = self.ui.atras.height() * rel_y

        self.ui.atras.resize(int(atras_x), int(atras_y))
        self.ui.atras.move(int(base_atras), int(altura_atras))
        self.ui.atras.mousePressEvent = self.pressAtrasV5
        self.ui.atras.mouseReleaseEvent = self.releaseAtrasV5
        #-----------Continuar botón--------------
        base_con = 575 * rel_x

        con_x = self.ui.continuar_V5.width() * rel_x
        con_y = self.ui.continuar_V5.height() * rel_y

        self.ui.continuar_V5.resize(int(con_x), int(con_y))
        self.ui.continuar_V5.move(int(base_con), int(altura_atras))
        self.ui.continuar_V5.mousePressEvent = self.pressContinueV5
        self.ui.continuar_V5.mouseReleaseEvent = self.releaseContinueV5

        #Posiciones de los botones
        self.positionV2 = self.ui.continue_btn.pos()
        self.positionV3 = self.ui.continue_btn_V3.pos()
        self.positionV5 = self.ui.continuar_V5.pos()
        self.positionAtras = self.ui.atras.pos()
        self.positionCancelar = self.ui.cancelar.pos()

        #------------Vista 6---------------
        #------------Muestra GIF-------------
        self.altura_gif2 = 170 * rel_y
        self.gif2_x = self.ui.the_gif_validate.width() * rel_x
        gif2_y = self.ui.the_gif_validate.height() * rel_y

        self.ui.the_gif_validate.resize(int(self.gif2_x), int(gif2_y))
        self.ui.the_gif_validate.move(int(self.size_x / 2 - self.gif2_x / 2),
                                      int(self.altura_gif2))
        #----------Escribe Correo-------------
        self.altura_mail = 990 * rel_y
        self.mail_x = self.ui.title_V6.width() * rel_x
        mail_y = self.ui.title_V6.height() * rel_y

        self.ui.title_V6.resize(int(self.mail_x), int(mail_y))
        self.ui.title_V6.move(int(self.size_x / 2 - self.mail_x / 2),
                              int(self.altura_mail))

        #----------Acepto?-------------
        self.altura_acepto = 1650 * rel_y
        self.acepto_x = self.ui.acepto.width() * rel_x
        acepto_y = self.ui.acepto.height() * rel_y

        self.ui.acepto.resize(int(self.acepto_x), int(acepto_y))
        self.ui.acepto.move(int(self.size_x / 2 - self.acepto_x / 2),
                            int(self.altura_acepto))

        #Bandera para el uso del teclado :)
        self.flag_Key = 3  #La vista 3 es la original

        #Botón pantalla completa
        self.ui.next_btn.resize(self.size_x, self.size_y)
        self.ui.next_btn.move(0, 0)
        self.ui.next_btn.mousePressEvent = self.restart

        #Nombre
        self.name = ""
        #Correo
        self.email = ""

        self.ui.show()
Example #7
0
    def __initUI(self):
        """
		Initialize the GUI
		"""
        # Layout
        layout = QtGui.QVBoxLayout()
        self.__mainWidget = QtGui.QWidget()
        self.__mainWidget.setLayout(layout)
        self.setCentralWidget(self.__mainWidget)

        # Browse images button
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Image :")
        self.__imageLabel = QtGui.QLabel("aucune")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__imageLabel)
        layout.addLayout(hLayout)
        self.__imageButton = QtGui.QPushButton(u"Choisir une image")
        layout.addWidget(self.__imageButton)

        # Surface width input
        self.__widthInput = QtGui.QDoubleSpinBox()
        self.__widthInput.setDecimals(0)
        self.__widthInput.setMinimum(50)
        self.__widthInput.setMaximum(1000)
        self.__widthInput.setValue(PROFILE_AREA_WIDTH)
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Largeur de la forme (px) :")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__widthInput)
        layout.addLayout(hLayout)

        # Threshold input
        self.__thresholdInput = QtGui.QDoubleSpinBox()
        self.__widthInput.setDecimals(0)
        self.__thresholdInput.setMinimum(0)
        self.__thresholdInput.setMaximum(300)
        self.__thresholdInput.setValue(COLOR_THRESHOLD)
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Tolérance de détection des couleurs :")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__thresholdInput)
        layout.addLayout(hLayout)

        # Preview image
        self.__previewImage = QtGui.QLabel()
        self.__previewImage.setPixmap(
            QtGui.QPixmap(PROFILE_AREA_WIDTH, PROFILE_AREA_WIDTH))
        label = QtGui.QLabel(u"Forme détectée :")
        hLayout = QtGui.QHBoxLayout()
        layout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__previewImage)
        hLayout.addStretch(1)
        layout.addLayout(hLayout)

        # Refresh button
        self.__refreshButton = QtGui.QPushButton(u"Calculer la forme")
        layout.addWidget(self.__refreshButton)

        # Surface width input
        self.__unitInput = QtGui.QDoubleSpinBox()
        self.__unitInput.setDecimals(3)
        self.__unitInput.setMinimum(0.001)
        self.__unitInput.setMaximum(10)
        self.__unitInput.setValue(SHAPE_UNIT)
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Taille d'un pixel (mm) :")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__unitInput)
        layout.addLayout(hLayout)

        # Surface width input
        self.__baseZInput = QtGui.QDoubleSpinBox()
        self.__baseZInput.setDecimals(0)
        self.__baseZInput.setMinimum(1)
        self.__baseZInput.setMaximum(100)
        self.__baseZInput.setValue(BASE_Z)
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Hauteur de la base :")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__baseZInput)
        layout.addLayout(hLayout)

        # Surface width input
        self.__shapeZInput = QtGui.QDoubleSpinBox()
        self.__shapeZInput.setDecimals(0)
        self.__shapeZInput.setMinimum(1)
        self.__shapeZInput.setMaximum(100)
        self.__shapeZInput.setValue(SHAPE_Z)
        hLayout = QtGui.QHBoxLayout()
        label = QtGui.QLabel(u"Hauteur de la forme :")
        hLayout.addWidget(label)
        hLayout.addStretch(1)
        hLayout.addWidget(self.__shapeZInput)
        layout.addLayout(hLayout)

        # Export button
        self.__exportButton = QtGui.QPushButton(u"Exporter en STL")
        layout.addWidget(self.__exportButton)

        # Center the window
        geo = self.frameGeometry()
        geo.moveCenter(QtGui.QDesktopWidget().availableGeometry().center())
        self.move(geo.topLeft())
        # Title
        self.setWindowTitle("Profil 3D")
Example #8
0
    def _setupUI(self):
        self.setWindowTitle(self.NAME)

        self._addMenu()
        self._addToolbar()

        self._tabs = QtGui.QTabWidget()
        self._tabs.setTabsClosable(True)
        self.connect(self._tabs, QtCore.SIGNAL("currentChanged(int)"),
                     self._roomTabFocused)
        self.connect(self._tabs, QtCore.SIGNAL("tabCloseRequested(int)"),
                     self._roomTabClose)

        self._editor = SpellTextEditor(lang=self.getSetting(
            "program", "spell_language"),
                                       mainFrame=self)

        speakButton = QtGui.QPushButton(self._("&Send"))
        self.connect(speakButton, QtCore.SIGNAL('clicked()'), self.speak)

        grid = QtGui.QGridLayout()
        grid.setRowStretch(0, 1)
        grid.addWidget(self._tabs, 0, 0, 1, -1)
        grid.addWidget(self._editor, 2, 0)
        grid.addWidget(speakButton, 2, 1)

        widget = QtGui.QWidget()
        widget.setLayout(grid)
        self.setCentralWidget(widget)

        tabWidgetFocusEventFilter = TabWidgetFocusEventFilter(self)
        self.connect(tabWidgetFocusEventFilter, QtCore.SIGNAL("tabFocused()"),
                     self._roomTabFocused)
        widget.installEventFilter(tabWidgetFocusEventFilter)

        self.centralWidget().hide()

        size = self.getSetting("window", "size")

        if not size:
            size = QtCore.QSize(640, 480)

        self.resize(size)

        position = self.getSetting("window", "position")
        if not position:
            screen = QtGui.QDesktopWidget().screenGeometry()
            position = QtCore.QPoint((screen.width() - size.width()) / 2,
                                     (screen.height() - size.height()) / 2)

        self.move(position)

        self._updateLayout()

        menu = QtGui.QMenu(self)
        menu.addAction(self._menus["file"]["connect"])
        menu.addAction(self._menus["file"]["disconnect"])
        menu.addSeparator()
        menu.addAction(self._menus["file"]["exit"])

        self._trayIcon = Systray(self._trayIconIcon, self)
        self._trayIcon.setContextMenu(menu)
        self._trayIcon.setToolTip(self.DESCRIPTION)
Example #9
0
 def center(self):  #主窗口居中显示函数
     screen = QtGui.QDesktopWidget().screenGeometry()
     size = self.geometry()
     self.move((screen.width() - size.width()) / 2 - 15,
               (screen.height() - size.height()) / 2 - 60)
Example #10
0
 def __centerOnScreen(self):
     '''Centers the window on the screen.'''
     resolution = QtGui.QDesktopWidget().screenGeometry()
     self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
               (resolution.height() / 2) - (self.frameSize().height() / 2))
    def initUI(self):

        if (len(sys.argv) == 1):
            self.config_file = "protocol_configuration.ini"
        else:
            if (string.find(sys.argv[1], '.ini') == -1):
                self.config_file = str(sys.argv[1]) + ".ini"
            else:
                self.config_file = str(sys.argv[1])

        print "Using configuration file: ", self.config_file

        config = ConfigParser.RawConfigParser(allow_no_value=True)
        config.read("./" + self.config_file)

        self.connect_to_loop = 1

        if (self.connect_to_loop):
            self.bci = BCI.BciInterface()
            self.bci.id_msg_bus.SetEvent(400)
            self.bci.iDsock_bus.sendall(self.bci.id_serializer_bus.Serialize())

        # Globals
        self.ACTION_UP = config.getint("constants", "ACTION_UP")
        self.ACTION_DOWN = config.getint("constants", "ACTION_DOWN")
        self.ACTION_LEFT = config.getint("constants", "ACTION_LEFT")
        self.ACTION_RIGHT = config.getint("constants", "ACTION_RIGHT")
        self.ACTION_END_EFFECTOR = config.getint("constants",
                                                 "ACTION_END_EFFECTOR")
        self.ACTION_UP_LEFT = config.getint("constants", "ACTION_UP_LEFT")
        self.ACTION_UP_RIGHT = config.getint("constants", "ACTION_UP_RIGHT")
        self.ACTION_DOWN_LEFT = config.getint("constants", "ACTION_DOWN_LEFT")
        self.ACTION_DOWN_RIGHT = config.getint("constants",
                                               "ACTION_DOWN_RIGHT")

        self.TID_ACTION = config.getint("constants", "TID_ACTION")
        self.TID_TARGET = config.getint("constants", "TID_TARGET")
        self.TID_STATE = config.getint("constants", "TID_STATE")
        self.TID_PHASE = config.getint("constants", "TID_PHASE")
        self.TID_LETTER = config.getint("constants", "TID_LETTER")
        self.TID_EXIT = config.getint("constants", "TID_EXIT")
        self.TID_TARGET_AND_STATE_MULTIPLIER = config.getint(
            "constants", "TID_TARGET_AND_STATE_MULTIPLIER")
        self.TID_TARGET_AND_STATE_AND_LETTER_MULTIPLIER = config.getint(
            "constants", "TID_TARGET_AND_STATE_AND_LETTER_MULTIPLIER")
        self.REST_PHASE = config.getint("constants", "REST_PHASE")
        self.full_screen = config.getint("window", "full_screen")
        self.execution_mode = config.getint("protocol", "execution_mode")
        self.first_move = 0

        self.OFFLINE_RUN = config.getint("constants", "OFFLINE_RUN")
        self.OFFLINE_CS_RUN = config.getint("constants", "OFFLINE_CS_RUN")
        self.ONLINE_RUN = config.getint("constants", "ONLINE_RUN")
        self.ONLINE_FREE_RUN = config.getint("constants", "ONLINE_FREE_RUN")
        self.ONLINE_SIMULATED = config.getint("constants", "ONLINE_SIMULATED")

        self.connect_eye = config.getint("protocol", "use_eye_tracker")

        now = datetime.datetime.now()

        self.format = config.get("protocol", "xdf_format")
        self.subject_id = config.get("protocol", "subject_id")
        self.name_experiment = config.get("protocol", "name_experiment")

        self.filename = self.subject_id + '_' + self.name_experiment + '_' + str(
            now.year) + str(now.month) + str(now.day) + '_' + str(
                now.hour) + str(now.minute) + str(
                    now.second) + '.' + self.format

        # Parameters
        if (self.full_screen):
            self.screen_width = QtGui.QDesktopWidget().screenGeometry().width()
            self.screen_height = QtGui.QDesktopWidget().screenGeometry(
            ).height()
            print "screen ", self.screen_width, ", ", self.screen_height
        else:
            self.screen_width = config.getint("window", "screen_width")
            self.screen_height = config.getint("window", "screen_height")

        self.num_tiles_x = config.getint("interface", "num_tiles_column")
        self.num_tiles_y = config.getint("interface", "num_tiles_row")
        self.grid_thickness = config.getint("interface", "grid_thickness")
        self.gap_x = config.getint("interface", "gap_x")
        self.gap_y = config.getint("interface", "gap_y")
        self.tile_width = config.getint("interface", "tile_width")
        self.tile_height = config.getint("interface", "tile_height")
        self.device_diameter = config.getint("interface", "device_diameter")

        self.color_grid = QtGui.QColor(
            float(config.get("colors", "color_grid").split(',')[0]),
            float(config.get("colors", "color_grid").split(',')[1]),
            float(config.get("colors", "color_grid").split(',')[2]))
        self.color_text = QtGui.QColor(
            float(config.get("colors", "color_text").split(',')[0]),
            float(config.get("colors", "color_text").split(',')[1]),
            float(config.get("colors", "color_text").split(',')[2]))
        self.color_background = QtGui.QColor(
            float(config.get("colors", "color_background").split(',')[0]),
            float(config.get("colors", "color_background").split(',')[1]),
            float(config.get("colors", "color_background").split(',')[2]))
        self.color_target = QtGui.QColor(
            float(config.get("colors", "color_target").split(',')[0]),
            float(config.get("colors", "color_target").split(',')[1]),
            float(config.get("colors", "color_target").split(',')[2]))
        self.color_target_ONLINE_FREEMODE = QtGui.QColor(
            float(config.get("colors", "color_target2").split(',')[0]),
            float(config.get("colors", "color_target2").split(',')[1]),
            float(config.get("colors", "color_target2").split(',')[2]))
        self.color_device = QtGui.QColor(
            float(config.get("colors", "color_device").split(',')[0]),
            float(config.get("colors", "color_device").split(',')[1]),
            float(config.get("colors", "color_device").split(',')[2]))

        self.color_end_effector = QtGui.QColor(0, 0, 250)

        self.font = QtGui.QFont()
        self.font_size = config.getint("interface", "font_size")
        self.font.setPixelSize(self.font_size)
        self.fm = QtGui.QFontMetrics(self.font)
        self.characters = config.get("interface", "characters")

        self.position_target_y = 2
        self.position_target_x = 2

        self.position_device_y = 1
        self.position_device_x = 2

        self.tt = time()

        self.init_position_x = (self.screen_width -
                                ((self.num_tiles_x * self.tile_width) +
                                 ((self.num_tiles_x - 1) * self.gap_x))) / 2
        self.init_position_y = (self.screen_height -
                                ((self.num_tiles_y * self.tile_height) +
                                 ((self.num_tiles_y - 1) * self.gap_y))) / 2
        self.setGeometry(0, 0, self.screen_width, self.screen_height)
        self.setWindowTitle('RASER')
        self.setFocusPolicy(QtCore.Qt.WheelFocus)
        self.setFocus()

        # Connect to eye-tracker
        if (self.connect_eye):
            self.eyetracker = EyeLink.tracker(self.screen_width,
                                              self.screen_height)
        else:
            print "[RaSER GUI] Eye-tracker not used"

        self.show()

        if (self.full_screen):
            self.showFullScreen()

        QtCore.QCoreApplication.processEvents()
        QtCore.QCoreApplication.flush()
        timer = QtCore.QTimer(self)
        timer.timeout.connect(self.update_loop)
        timer.start(config.getfloat("interface", "paint_cycle_time"))

        self.tt = time()
        self.end_effector_shrink_factor = config.getfloat(
            "interface", "end_effector_shrink_factor")
        self.increase_saliency_end_effector = config.getint(
            "interface", "increase_saliency_end_effector")
        self.action_end_effector = 0
        self.counter_end_effector = 0
        self.action_end_effector_time = round(
            config.getfloat("interface", "end_effector_action_time") /
            config.getfloat("interface", "paint_cycle_time"))

        self.paint_underscore = 0
        self.counter_underscore = 0
        self.underscore_blinking_time = round(
            config.getfloat("interface", "underscore_blinking_time") /
            config.getfloat("interface", "paint_cycle_time"))
        self.written_text = ""
        self.color = 1

        self.action_executed = 0
        self.draw_photodiode = config.getint("interface", "draw_photodiode")

        # Rest phase variables
        self.rest_phase_duration = (
            float(config.get("protocol", "rest_phase_duration").split(' ')[0])
            - 1) * 1000 / config.getfloat("interface", "paint_cycle_time")
        self.counter_rest_phase = 0
        self.rest_phase_bar_length = 0.6 * self.screen_width
        self.show_rest_phase = 0
        self.color_rect = QtGui.QColor(255, 100, 0)
        self.color_text = QtGui.QColor(0, 128, 128)

        #######################################################################
        # LPT Trigger initialization
        #######################################################################
        # self.use_hwtrigger = config.getint("protocol", "use_hardware_trigger")
        self.lpt_type = config.getint("protocol", "use_hardware_trigger")
        self.use_hwtrigger = self.lpt_type > 0

        # Parallel port
        if (self.lpt_type == 1):
            self.lpt = pylpttrigger
            self.lpt.open(0, 100, 0)
        # Arduino
        elif (self.lpt_type == 2):
            SERIAL_PORT = 'Arduino Micro'
            BAUD_RATE = 115200
            self.lpt = SerialWriter.SerialWriter(SERIAL_PORT, BAUD_RATE)
        else:
            print "Unknown LPT Trigger!! Exiting..."
            exit()

        self.send_trigger = 0
        self.counter_lpt = 0
    def __init__(self):
        #Create Window
        super(MyWindow, self).__init__()
        uic.loadUi('ThreePhase.ui', self)
        self.show()
        qr = self.frameGeometry()
        cp = QtGui.QDesktopWidget().availableGeometry().center()
        qr.moveCenter(cp)
        self.move(qr.topLeft())

        #Create Vars to hold output values
        self.freq = 3  #hz
        self.freqStep = 1
        self.globalGain = 0.8003
        self.globalOffset = 0
        self.op_code = 1  #idle
        self.channel_1_offset_value = 0
        self.channel_2_offset_value = 0
        self.channel_3_offset_value = 0
        self.channel_1_gain_value = 1.0
        self.channel_2_gain_value = 1.0
        self.channel_3_gain_value = 1.0

        #Create necessary local vars
        self.update_freq = 1000  #time in msec for timer experation
        self.msg_data = []
        self.dataHasChanged = False

        #Connect GUI features to functionality
        #connect frequency input
        self.Increase_Freq_Btn.clicked.connect(self.increaseFreq)
        self.Decrease_Freq_Btn.clicked.connect(self.decreaseFreq)
        self.connect(self.FreqDial, QtCore.SIGNAL('valueChanged(int)'),
                     self.updateFreq)
        #connect gain input
        self.OffsetInput.valueChanged.connect(self.updateOffset)
        #connect offset input
        self.GainInput.valueChanged.connect(self.updateGain)
        #connect start button
        self.Startbtn.clicked.connect(self.startBtnPress)
        #connect stop button
        self.Stopbtn.clicked.connect(self.stopBtnPress)
        self.Stopbtn.setEnabled(False)
        #connect channel offset
        self.Channel1_offset.valueChanged.connect(self.channelOffsetUpdate)
        self.Channel2_offset.valueChanged.connect(self.channelOffsetUpdate)
        self.Channel3_offset.valueChanged.connect(self.channelOffsetUpdate)
        #connect channel multipliers
        self.Channel1_gain.valueChanged.connect(self.channelGainUpdate)
        self.Channel2_gain.valueChanged.connect(self.channelGainUpdate)
        self.Channel3_gain.valueChanged.connect(self.channelGainUpdate)
        #connect reset button
        self.ResetBtn.clicked.connect(self.resetGenData)

        #Create I2C comm
        self.DEVICE_BUS = 1
        self.DEVICE_ADDR = 0x08
        try:
            self.bus = smbus.SMBus(self.DEVICE_BUS)
            self.updateSysStatus("Connected")
        except:
            self.updateSysStatus(
                "I2C Connection Error Please Check Connections and Restart")

        #Create update timer
        self.timer = QtCore.QTimer()
        self.timer.setInterval(self.update_freq)
        self.timer.timeout.connect(self.timerExperation)
        self.timer.start()
    def __init__(self):

        QtGui.QWidget.__init__(self)
        screen = QtGui.QDesktopWidget().screenGeometry()
        self.setWindowTitle('Annotation & Augmentation Tool')
        self.setGeometry(0, 0, screen.width(), screen.height())
        self.image_path = None
        iconsize = 0.047 * ((screen.width() + screen.height()) / 2)
        self.buttonopenFolder = QtGui.QToolButton()
        self.buttonopenFolder.setText('   Open Folder   ')
        self.buttonopenFolder.setIcon(QtGui.QIcon('./res/image.png'))
        self.buttonopenFolder.setIconSize(
            QtCore.QSize(int(iconsize), int(iconsize)))
        self.buttonopenFolder.setCheckable(True)
        self.buttonopenFolder.setFixedSize(int(1.8 * iconsize),
                                           int(1.4 * iconsize))
        self.buttonopenFolder.setToolButtonStyle(
            QtCore.Qt.ToolButtonTextUnderIcon)
        self.buttonopenFolder.clicked.connect(self.openFloder)

        self.nextImageButton = QtGui.QToolButton()
        self.nextImageButton.setText('Previous \nImage')
        self.nextImageButton.setIcon(QtGui.QIcon('./res/left.png'))
        self.nextImageButton.setIconSize(
            QtCore.QSize(int(0.5 * iconsize), int(0.5 * iconsize)))
        self.nextImageButton.setFixedSize(int(0.85 * iconsize),
                                          int(1.4 * iconsize))
        self.nextImageButton.setCheckable(True)
        self.nextImageButton.setToolButtonStyle(
            QtCore.Qt.ToolButtonTextUnderIcon)
        self.nextImageButton.clicked.connect(self.fetchPreviousImage)

        self.previousImageButton = QtGui.QToolButton()
        self.previousImageButton.setText('Next \nImage')
        self.previousImageButton.setIcon(QtGui.QIcon('./res/rightF.png'))
        self.previousImageButton.setIconSize(
            QtCore.QSize(int(0.5 * iconsize), int(0.5 * iconsize)))
        self.previousImageButton.setFixedSize(int(0.85 * iconsize),
                                              int(1.4 * iconsize))
        self.previousImageButton.setCheckable(True)
        self.previousImageButton.setToolButtonStyle(
            QtCore.Qt.ToolButtonTextUnderIcon)
        self.previousImageButton.clicked.connect(self.fetchNextImage)

        self.saveYoloFormat = QtGui.QToolButton()
        self.saveYoloFormat.setText('   Save Annot    ')
        self.saveYoloFormat.setIcon(QtGui.QIcon('./res/save.png'))
        self.saveYoloFormat.setIconSize(
            QtCore.QSize(int(iconsize), int(iconsize)))
        self.saveYoloFormat.setCheckable(True)
        self.saveYoloFormat.setFixedSize(int(1.8 * iconsize),
                                         int(1.4 * iconsize))
        self.saveYoloFormat.setToolButtonStyle(
            QtCore.Qt.ToolButtonTextUnderIcon)
        self.saveYoloFormat.clicked.connect(self.saveAnnotation)
        classlabel = QtGui.QLabel("Classes")
        self.classList = [line.rstrip('\n') for line in open('./classes.txt')]
        self.classIndx = 0
        self.CBclass = QtGui.QComboBox()
        self.CBclass.addItems(self.classList)
        self.CBclass.currentIndexChanged.connect(self.selectionchange)

        l1 = QtGui.QLabel()
        l1.setText("Data Augmentation")

        self.rotateImage = QtGui.QToolButton()
        self.rotateImage.setText(' Roation ')
        self.rotateImage.setIcon(QtGui.QIcon('./res/rotate.png'))
        self.rotateImage.setIconSize(QtCore.QSize(int(iconsize),
                                                  int(iconsize)))
        self.rotateImage.setCheckable(True)
        self.rotateImage.setFixedSize(int(1.8 * iconsize), int(1.4 * iconsize))
        self.rotateImage.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.rotateImage.clicked.connect(self.rotate3Image)

        self.flipping = QtGui.QToolButton()
        self.flipping.setText('  Flipping ')
        self.flipping.setIcon(QtGui.QIcon('./res/FLIP_F.png'))
        self.flipping.setIconSize(QtCore.QSize(int(iconsize), int(iconsize)))
        self.flipping.setCheckable(True)
        self.flipping.setFixedSize(int(1.8 * iconsize), int(1.4 * iconsize))
        self.flipping.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.flipping.clicked.connect(self.flippingImage)

        self.addnoise = QtGui.QToolButton()
        self.addnoise.setText('   Salt & Papper Noise   ')
        self.addnoise.setIcon(QtGui.QIcon('./res/noise.png'))
        self.addnoise.setIconSize(QtCore.QSize(int(iconsize), int(iconsize)))
        self.addnoise.setCheckable(True)
        self.addnoise.setFixedSize(int(1.8 * iconsize), int(1.4 * iconsize))
        self.addnoise.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.addnoise.clicked.connect(self.addnoiseImage)

        self.addBright = QtGui.QToolButton()
        self.addBright.setText('   Brightness   ')
        self.addBright.setIcon(QtGui.QIcon('./res/bright.png'))
        self.addBright.setIconSize(QtCore.QSize(int(iconsize), int(iconsize)))
        self.addBright.setCheckable(True)
        self.addBright.setFixedSize(int(1.8 * iconsize), int(1.4 * iconsize))
        self.addBright.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.addBright.clicked.connect(self.addBrightImage)

        utemlogo = QtGui.QLabel()
        pixmap = QtGui.QPixmap('./res/utem.png')
        utemlogo.setPixmap(
            pixmap.scaled(int(2 * iconsize), int(1.5 * iconsize),
                          QtCore.Qt.KeepAspectRatio))
        fkekklogo = QtGui.QLabel()
        pixmap = QtGui.QPixmap('./res/fkekk.png')
        fkekklogo.setPixmap(
            pixmap.scaled(int(2 * iconsize), int(1.5 * iconsize),
                          QtCore.Qt.KeepAspectRatio))

        ButtonLayout = QtGui.QVBoxLayout()
        ButtonLayout.setAlignment(QtCore.Qt.AlignCenter)
        ButtonLayout.addWidget(self.buttonopenFolder)
        hboxRL = QtGui.QHBoxLayout()
        hboxRL.addWidget(self.nextImageButton)
        hboxRL.addWidget(self.previousImageButton)
        ButtonLayout.addLayout(hboxRL)
        ButtonLayout.addWidget(self.saveYoloFormat)
        ButtonLayout.addWidget(classlabel)
        ButtonLayout.addWidget(self.CBclass)
        ButtonLayout.addStretch()
        ButtonLayout.addWidget(l1)
        ButtonLayout.addWidget(self.rotateImage)
        ButtonLayout.addWidget(self.flipping)
        ButtonLayout.addWidget(self.addnoise)
        ButtonLayout.addWidget(self.addBright)
        ButtonLayout.addStretch()
        ButtonLayout.addWidget(fkekklogo)
        ButtonLayout.addWidget(utemlogo)

        self.label_image = MouseLabel(self)
        self.scroll = QtGui.QScrollArea(self)
        self.scroll.setWidget(self.label_image)
        hbox = QtGui.QHBoxLayout(self)
        hbox.addWidget(self.scroll)
        hbox.addLayout(ButtonLayout)

        self.connect(self.label_image,
                     QtCore.SIGNAL('clicked(int, int, int, int, int)'),
                     self.point_selected)
	def __init__(self, parent=None, flags=QtCore.Qt.Widget):
		super(MainWindow, self).__init__(parent, flags)

		splitter_widget = QtGui.QSplitter(QtCore.Qt.Horizontal)

		self.code_object_view = QtGui.QTreeView(splitter_widget)
		self.code_object_view.setHeaderHidden(True)
		self.code_object_view.setModel(QtGui.QStandardItemModel())
		self.code_object_view.selectionModel().currentChanged.connect(self.on_code_object_view_current_changed)

		tab_widget = QtGui.QTabWidget(splitter_widget)

		self.summary_view = QtWebKit.QWebView()
		self.summary_view.page().setLinkDelegationPolicy(QtWebKit.QWebPage.DelegateAllLinks)
		self.summary_view.linkClicked.connect(self.on_summary_view_link_clicked)

		self.disassembly_view = QtWebKit.QWebView()
		self.disassembly_view.page().setLinkDelegationPolicy(QtWebKit.QWebPage.DelegateAllLinks)
		self.disassembly_view.linkClicked.connect(self.on_disassembly_view_link_clicked)

		self.hex_edit = hexedit.HexEdit()

		tab_widget.addTab(self.summary_view, 'Summary')
		tab_widget.addTab(self.disassembly_view, 'Disassembly')
		tab_widget.addTab(self.hex_edit, 'Hex Dump')

		menu = self.menuBar().addMenu('&File')
		menu.addAction('&Open...').triggered.connect(self.on_menu_bar_open_triggered)
		menu.addAction('&Close').triggered.connect(self.on_menu_bar_close_triggered)
		menu.addAction('&Reload').triggered.connect(self.on_menu_bar_reload_triggered)
		menu.addSeparator()
		menu.addAction('E&xit').triggered.connect(Qt.qApp.quit)
		menu = self.menuBar().addMenu('&Help')
		menu.addAction('About...').triggered.connect(self.on_menu_bar_about_triggered)
		menu.addSeparator()
		menu.addAction('About Qt...').triggered.connect(Qt.qApp.aboutQt)

		splitter_widget.setStretchFactor(0, 0)
		splitter_widget.setStretchFactor(1, 1)
		splitter_widget.setSizes([200, splitter_widget.width()-200])

		self.setCentralWidget(splitter_widget)
		self.setWindowTitle('Chrysanthemum')
		self.setWindowIcon(QtGui.QIcon(':/images/icon.png'))
		self.setAcceptDrops(True)
		self.resize(1024, 768)
		
		self.setGeometry(QtGui.QStyle.alignedRect(QtCore.Qt.LeftToRight, QtCore.Qt.AlignCenter, self.size(), QtGui.QDesktopWidget().availableGeometry()))

		self.close()
Example #15
0
 def center_on_screen(self):
     resolution = QtGui.QDesktopWidget().screenGeometry()
     self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
               (resolution.height() / 2) - (self.frameSize().height() / 2))
Example #16
0
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)

        self.setWindowIcon(QtGui.QIcon(os.path.join("Resources", "images", "Icon")))
        self.setWindowTitle("Pcode - Loading...")

        screen = QtGui.QDesktopWidget().screenGeometry()
        self.resize(screen.width() - 200, screen.height() - 200)
        size = self.geometry()
        self.move((screen.width() - size.width()) / 2, (
            screen.height() - size.height()) / 2)
        self.lastWindowGeometry = self.geometry()

        mainLayout = QtGui.QVBoxLayout()
        mainLayout.setSpacing(0)
        mainLayout.setMargin(0)
        self.setLayout(mainLayout)

        self.useData = UseData()

        logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',
                            filename=self.useData.appPathDict["logfile"], level=logging.DEBUG)
        if sys.version_info.major < 3:
            logging.error("This application requires Python 3")
            sys.exit(1)

        self.library = Library(self.useData)
        self.busyWidget = BusyWidget(app, self.useData, self)

        if self.useData.SETTINGS["UI"] == "Custom":
            app.setStyleSheet(StyleSheet.globalStyle)

        self.projectWindowStack = QtGui.QStackedWidget()

        self.projectTitleBox = QtGui.QComboBox()
        self.projectTitleBox.setMinimumWidth(180)
        self.projectTitleBox.setStyleSheet(StyleSheet.projectTitleBoxStyle)
        self.projectTitleBox.setItemDelegate(QtGui.QStyledItemDelegate())
        self.projectTitleBox.currentIndexChanged.connect(self.projectChanged)
        self.projectTitleBox.activated.connect(self.projectChanged)

        self.settingsWidget = SettingsWidget(self.useData, app,
                                             self.projectWindowStack, self.library.codeViewer, self)
        self.settingsWidget.colorScheme.styleEditor(self.library.codeViewer)

        startWindow = Start(self.useData, self)
        self.addProject(startWindow, "Start",
                        "Start", os.path.join("Resources", "images", "flag-green"))

        self.projects = Projects(self.useData, self.busyWidget,
                                 self.library, self.settingsWidget, app,
                                 self.projectWindowStack, self.projectTitleBox, self)

        self.createActions()

        hbox = QtGui.QHBoxLayout()
        hbox.setContentsMargins(5, 3, 5, 3)
        mainLayout.addLayout(hbox)

        hbox.addStretch(1)

        self.pagesStack = QtGui.QStackedWidget()
        mainLayout.addWidget(self.pagesStack)

        self.projectSwitcher = StackSwitcher(self.pagesStack)
        self.projectSwitcher.setStyleSheet(StyleSheet.mainMenuStyle)
        hbox.addWidget(self.projectSwitcher)

        self.pagesStack.addWidget(self.projectWindowStack)
#        self.addPage(self.projectWindowStack, "EDITOR", QtGui.QIcon(
#            os.path.join("Resources", "images", "hire-me")))
#
#        self.addPage(self.library, "LIBRARY", QtGui.QIcon(
#            os.path.join("Resources", "images", "library")))
#        self.projectSwitcher.setDefault()

        hbox.addWidget(self.projectTitleBox)
        hbox.setSpacing(5)

        self.settingsButton = QtGui.QToolButton()
        self.settingsButton.setAutoRaise(True)
        self.settingsButton.setDefaultAction(self.settingsAct)
        hbox.addWidget(self.settingsButton)

        self.fullScreenButton = QtGui.QToolButton()
        self.fullScreenButton.setAutoRaise(True)
        self.fullScreenButton.setDefaultAction(self.showFullScreenAct)
        hbox.addWidget(self.fullScreenButton)

        self.aboutButton = QtGui.QToolButton()
        self.aboutButton.setAutoRaise(True)
        self.aboutButton.setDefaultAction(self.aboutAct)
        hbox.addWidget(self.aboutButton)

        self.setShortcuts()

        if self.useData.settings["firstRun"] == 'True':
            self.showMaximized()
        else:
            self.restoreUiState()

        self.useData.settings["running"] = 'True'
        self.useData.settings["firstRun"] = 'False'
        self.useData.saveSettings()
Example #17
0
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)

        self.setWindowIcon(
            QtGui.QIcon(os.path.join("Resources", "images", "Icon")))
        self.setWindowTitle("Pcode - Loading...")

        screen = QtGui.QDesktopWidget().screenGeometry()
        self.resize(screen.width() - 200, screen.height() - 200)
        size = self.geometry()
        self.move((screen.width() - size.width()) / 2,
                  (screen.height() - size.height()) / 2)
        self.lastWindowGeometry = self.geometry()

        self.setBaseColor()

        mainLayout = QtGui.QVBoxLayout()
        mainLayout.setSpacing(0)
        mainLayout.setMargin(0)
        self.setLayout(mainLayout)

        self.useData = UseData()
        self.library = Library(self.useData)
        self.busyWidget = BusyWidget(app, self.useData, self)

        self.projectWindowStack = QtGui.QStackedWidget()

        self.projectTitleBox = QtGui.QComboBox()
        self.projectTitleBox.setMinimumWidth(180)
        self.projectTitleBox.setStyleSheet(StyleSheet.projectTitleBoxStyle)
        self.projectTitleBox.setItemDelegate(QtGui.QStyledItemDelegate())
        self.projectTitleBox.currentIndexChanged.connect(self.projectChanged)
        self.projectTitleBox.activated.connect(self.projectChanged)

        self.settingsWidget = SettingsWidget(self.useData,
                                             self.projectWindowStack,
                                             self.library.codeViewer, self)
        self.settingsWidget.colorScheme.styleEditor(self.library.codeViewer)

        startWindow = Start(self.useData, self)
        self.addProject(startWindow, "Start", "Start",
                        os.path.join("Resources", "images", "flag-green"))

        self.projects = Projects(self.useData, self.busyWidget, self.library,
                                 self.settingsWidget, app,
                                 self.projectWindowStack, self.projectTitleBox,
                                 self)

        self.createActions()

        hbox = QtGui.QHBoxLayout()
        hbox.setContentsMargins(5, 3, 5, 3)
        mainLayout.addLayout(hbox)

        hbox.addStretch(1)

        self.pagesStack = QtGui.QStackedWidget()
        mainLayout.addWidget(self.pagesStack)

        self.projectSwitcher = StackSwitcher(self.pagesStack)
        self.projectSwitcher.setStyleSheet(StyleSheet.mainMenuStyle)
        hbox.addWidget(self.projectSwitcher)

        self.addPage(
            self.projectWindowStack, "EDITOR",
            QtGui.QIcon(os.path.join("Resources", "images", "hire-me")))

        self.addPage(
            self.library, "LIBRARY",
            QtGui.QIcon(os.path.join("Resources", "images", "library")))
        self.projectSwitcher.setDefault()

        hbox.addWidget(self.projectTitleBox)
        hbox.setSpacing(5)

        self.settingsButton = QtGui.QToolButton()
        self.settingsButton.setAutoRaise(True)
        self.settingsButton.setDefaultAction(self.settingsAct)
        hbox.addWidget(self.settingsButton)

        self.fullScreenButton = QtGui.QToolButton()
        self.fullScreenButton.setAutoRaise(True)
        self.fullScreenButton.setDefaultAction(self.showFullScreenAct)
        hbox.addWidget(self.fullScreenButton)

        self.aboutButton = QtGui.QToolButton()
        self.aboutButton.setAutoRaise(True)
        self.aboutButton.setDefaultAction(self.aboutAct)
        hbox.addWidget(self.aboutButton)

        self.install_shortcuts()

        if self.useData.settings["firstRun"] == 'True':
            self.showMaximized()
        else:
            self.restoreUiState()

        self.useData.settings["running"] = 'True'
        self.useData.settings["firstRun"] = 'False'
        self.useData.saveSettings()
Example #18
0
 def initSize(self):
     screen = QtGui.QDesktopWidget().screenGeometry()
     self.setGeometry(screen.width() / 8,
                      screen.height() / 8, 3 * screen.width() / 4,
                      3 * screen.height() / 4)
Example #19
0
    def __init__(self, parent, roach_config, network_config, filesys_config,
                 hardware_config, logging_config):
        super(configWindow, self).__init__(parent)

        # Load of main window GUI
        # The GUI was developed in QT Designer
        self.ui = uic.loadUi("./src/gui/config.ui")

        # Screen dimensions
        screen = QtGui.QDesktopWidget().screenGeometry()

        self.size_x = screen.width()
        self.size_y = screen.height()

        self.ui.setWindowFlags(self.ui.windowFlags()
                               | QtCore.Qt.CustomizeWindowHint)
        self.ui.setWindowFlags(self.ui.windowFlags()
                               & ~QtCore.Qt.WindowMaximizeButtonHint)

        self.ui.move(self.size_x / 2 - self.ui.width() / 2,
                     self.size_y / 2 - self.ui.height() / 2)

        self.hdw_cfg = hardware_config
        self.fsy_cfg = filesys_config
        self.lgg_cfg = logging_config
        self.net_cfg = network_config
        self.rch_cfg = roach_config

        # ROACH
        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        roach_list = self.rch_cfg.keys()
        network_list = self.net_cfg.keys()
        synth_list = self.hdw_cfg["synth_config"].keys()
        atten_list = self.hdw_cfg["atten_config"].keys()

        self.ui.nameRoachBox.clear()
        self.ui.netNameRoach.clear()
        self.ui.nameRoachBox.addItems(roach_list)
        self.ui.netNameRoach.addItems(roach_list)

        self.fillSynthesizer(synth_list)
        self.fillAttenuator(atten_list)

        # Roach settings
        self.updateRoach(roach_list[0])

        # Network settings
        self.updateNetwork(roach_list[0])

        # Hardware settings
        # Synthesizer
        self.ui.synthNameEdit.clear()
        self.ui.synthNameEdit.addItems(synth_list)
        self.updateSynth(synth_list[0])
        # Attenuator
        self.ui.attenNameEdit.clear()
        self.ui.attenNameEdit.addItems(atten_list)
        self.updateAtt(atten_list[0])

        # Directories
        self.updateDirectories()

        # Logging
        self.updateLogging()

        # Buttons
        # Roach
        self.ui.firmFileBtn.mousePressEvent = self.chooseFirmFilePath
        self.ui.tonesFileBtn.mousePressEvent = self.chooseTonesFilePath

        self.ui.nameRoachBox.currentIndexChanged.connect(self.changeRoach)

        self.ui.addRoachBtn.mousePressEvent = self.addNewRoach
        self.ui.removeRoachBtn.mousePressEvent = self.rmRoach

        self.ui.roachBtn.mousePressEvent = self.saveRoach
        self.ui.roachWriteBtn.mousePressEvent = self.writeRoach

        # Network
        self.ui.netNameRoach.currentIndexChanged.connect(
            self.changeRoachNetwork)

        self.ui.netBtn.mousePressEvent = self.saveNet
        self.ui.netWriteBtn.mousePressEvent = self.writeNet

        # Hardware
        self.ui.synthNameEdit.currentIndexChanged.connect(self.changeSynth)
        self.ui.attenNameEdit.currentIndexChanged.connect(self.changeAtten)

        self.ui.activeSynthBtn.mousePressEvent = self.toggleActiveSynth
        self.ui.activeAttenBtn.mousePressEvent = self.toggleActiveAtten

        self.ui.addSynthBtn.mousePressEvent = self.addNewSynth
        self.ui.removeSynthBtn.mousePressEvent = self.rmSynth

        self.ui.addAttenBtn.mousePressEvent = self.addNewAtten
        self.ui.removeAttenBtn.mousePressEvent = self.rmAtten

        self.ui.hdwBtn.mousePressEvent = self.saveHardware
        self.ui.hdwWriteBtn.mousePressEvent = self.writeHardware

        # Directories
        self.ui.diryFirmwareEdit.mousePressEvent = self.chooseFirmPath
        self.ui.rootDiryBtn.mousePressEvent = self.chooseRootPath
        self.ui.logDiryBtn.mousePressEvent = self.chooseLogPath
        self.ui.pidBtn.mousePressEvent = self.choosePIDPath
        self.ui.toneDiryBtn.mousePressEvent = self.chooseTonesPath
        self.ui.RAMDiryBtn.mousePressEvent = self.chooseRAMPath

        self.ui.theDiryBtn.mousePressEvent = self.saveDiry
        self.ui.theDiryWriteBtn.mousePressEvent = self.writeDiry
Example #20
0
 def center(self):
     geometry = self.frameGeometry()
     center = QtGui.QDesktopWidget().availableGeometry().center()
     geometry.moveCenter(center)
     self.move(geometry.topLeft())
Example #21
0
 def center(self):
     qr = self.frameGeometry()                                   # Getting current window frame of my desktop
     cp = QtGui.QDesktopWidget().availableGeometry().center()    # Getting center point of my Desktop wiondow
     qr.moveCenter(cp)                                           # moving the center of the window to the cp
     self.move(qr.topLeft())
Example #22
0
 def centrar(self):  # Centra el Frame
     screen = QtGui.QDesktopWidget().screenGeometry(
     )  # obtiene resolucion del usuario
     size = self.geometry()
     self.move((screen.width() - size.width()) / 2,
               (screen.height() - size.height()) / 2)
        file.write(str(l))
        file.close()

        label_nilaiprima = self.label_nilaip
        label_nilaiprima.setText("p = " + str(num)[0:3] + "..")
        file2 = open('output/nilaip.txt', 'w')
        file2.write(str(num))
        file2.close()

        # print(lower)
        # print(upper)

        return num

    def next(self):
        self.hide()
        ketiga = FungsiKetiga.MyQtApp(self)
        ketiga.position()
        ketiga.show()


if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    qt_app = MyQtApp()
    screen = QtGui.QDesktopWidget().screenGeometry()
    x = (screen.width() - qt_app.geometry().width()) / 2
    y = (screen.height() - qt_app.geometry().height()) / 2
    qt_app.move(x, y)
    qt_app.show()
    app.exec()
Example #24
0
 def center(self):
     frameGm = self.frameGeometry()
     centerPoint = QtGui.QDesktopWidget().availableGeometry().center()
     frameGm.moveCenter(centerPoint)
     self.move(frameGm.topLeft())
Example #25
0
def main():

    # Create the object that handles the communication with the FPGA board:
    sl = SuperLaserLand_JD_RP()

    # Specify the mapping between the MAC addresses (which are used as a form of serial numbers) and the box data
    devices_data = {}
    devices_data['002632f016dc'] = {
        'color': '#1CC981',
        'name': 'Red Pitaya 0',
        'shorthand': 'RP 0',
        'config file': 'system_parameters_RP_1.xml',
        #'port': 60002
    }

    devices_data['002632f03cc2'] = {
        'color': '#1CC981',
        'name': 'RP Comb 1',
        'shorthand': 'RPC 1',
        'config file': 'system_parameters_RP_C1.xml',
        #'port': 60002
    }

    devices_data['002632f03d5b'] = {
        'color': '#1CC981',
        'name': 'RP Comb 2',
        'shorthand': 'RPC 2',
        'config file': 'system_parameters_RP_C3.xml',
        #'port': 60002
    }

    #    serial_to_color_mapping = {}
    #    serial_to_color_mapping['000000054R'] = '#1CC981'
    #    serial_to_color_mapping['000000054S'] = '#811CC9'
    #    # serial_to_color_mapping['124300046U'] = 'blue'
    #    serial_to_color_mapping['12320003SX'] = 'orange'
    #    serial_to_color_mapping['000000054E'] = '#E37405'   # orange high-bandwidth (dark orange)
    #    serial_to_color_mapping['000000054J'] = '#70E7FF'  # blue high-bandwidth (light blue)
    #    serial_to_color_mapping['124300046R'] = '#B572E8'  # purple high-bandwidth (purple)
    #    serial_to_color_mapping['124300046V'] = '#FF0000'
    #    serial_to_color_mapping['124300046S'] = '#0033CC'

    # this opens the connection to the fpga (hard-coded IP address for now)
    #    strList = sl.getDeviceList()

    ###########################################################################
    # Update the FPGA bitfile and the Zynq monitor-tcp C program

    # send new bitfile version
    try:
        #        sl.dev.write_file_on_remote(strFilenameLocal=r'D:\Projects\RedPitaya\fpga\project\redpitaya.runs\impl_1\red_pitaya_top.bit', strFilenameRemote='/opt/red_pitaya_top.bit')
        #        sl.dev.write_file_on_remote(strFilenameLocal=r'D:\Projets_Xilinx\RedPitaya\fpga\project\redpitaya.runs\impl_1\red_pitaya_top.bit', strFilenameRemote='/opt/red_pitaya_top.bit')
        pass
    except:
        print "warning, could not update fpga bitfile"
        pass
    # program FPGA with new bitfile:
#    sl.dev.send_shell_command('cat /opt/red_pitaya_top.bit > /dev/xdevcfg')

#    time.sleep(3)

#
#    # send new monitor-tcp version
#    sl.dev.write_file_on_remote(strFilenameLocal=u'D:\\Université\\Dropbox\\22_H2015\\Red Pitaya\\monitor-tcp\\monitor-tcp', strFilenameRemote='/opt/monitor-tcp-new')
#
#    # set executable permissions
#    sl.dev.send_shell_command('chmod +x /opt/monitor-tcp-new')
#    # copy over old file
#    sl.dev.send_shell_command('mv /opt/monitor-tcp-new /opt/monitor-tcp')
#
#    # send reboot command
#    sl.dev.send_reboot_command()
#    sl.dev.sock.shutdown(socket.SHUT_RDWR)
#    sl.dev.sock.close()
#
#    time.sleep(1) # give some time for tcp server to come back up
##    return
#    sl.getDeviceList() # reconnect
#
#    #sl.dev.OpenTCPConnection(sl.dev.HOST, sl.dev.PORT) # hack to get things working quickly
##    sl.dev.sock.connect((sl.dev.HOST, sl.dev.PORT))
#
##    return  # for quick debug tests

###########################################################################
# Start the User Interface
    allowSetForegroundWindow.allowSetForegroundWindow()

    # Start Qt:
    app = QtGui.QApplication(sys.argv)

    strBroadcastAddress = '192.168.0.255'
    strFPGAFirmware = r'red_pitaya_top.bit'
    strCPUFirmware = u'monitor-tcp'
    initial_config = initialConfiguration(sl.dev, devices_data,
                                          strBroadcastAddress, strFPGAFirmware,
                                          strCPUFirmware)

    #    def __init__(self, dev, devices_data={}, strBroadcastAddress="192.168.2.255", strFPGAFirmware='', strCPUFirmware=''):

    #    # this will remove minimized status
    #    # and restore window with keeping maximized/normal state
    #    allowSetForegroundWindow.allowSetForegroundWindow()
    ##    initial_config.setWindowState(initial_config.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
    #    # this will activate the window
    ##    initial_config.activateWindow()
    ##    initial_config.show()
    #  #  initial_config.raise_()
    #  #  initial_config.show()
    #
    #    SetWindowPos(initial_config.winId(),
    #                    win32con.HWND_TOPMOST, # = always on top. only reliable way to bring it to the front on windows
    #                    0, 0, 0, 0,
    #                    win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW)
    #    SetWindowPos(initial_config.winId(),
    #                    win32con.HWND_NOTOPMOST, # disable the always on top, but leave window at its top position
    #                    0, 0, 0, 0,
    #                    win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW)
    #    initial_config.raise_()
    #    initial_config.show()
    #    initial_config.activateWindow()

    #initial_config.setWindowState(initial_config.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
    # Run the event loop for this window
    app.exec_()

    if initial_config.bOk == False:
        # User clicked cancel. simply close the program:
        return

    # Start the init process (this sets the PLL gain/settings registers and the residuals streaming)
    sl.initSubModules(initial_config.bSendDefaultValues)

    ###########################################################################
    # Create the object which handles the configuration parameters (DAC offsets, DAC gains, beat frequency modulation range, etc):
    sp = SLLSystemParameters()
    #    # Send the values to the FPGA only if we have just re-programmed it. Otherwise we use whatever value is already in so we don't disturb the operation
    #    bTriggerEvents = False
    #    if initial_config.bSendFirmware:
    #
    #        bTriggerEvents = True
    bTriggerEvents = True

    # Lookup filename and load if file is there:
    try:
        custom_config_file = devices_data[
            initial_config.strSelectedSerial]['config file']
        sp.loadFromFile(custom_config_file)
        print('Loaded configuration from %s' % custom_config_file)
    except KeyError:
        custom_config_file = ''
        print 'Warning: Could not find config file "%s" for FPGA serial: %s, loading default values' % (
            custom_config_file, initial_config.strSelectedSerial)
        sp.loadDefaults()

    sp.loadDefaults()
    # sp.saveToFile('system_parameters_current.xml')

    bSendToFPGA = bTriggerEvents
    sp.sendToFPGA(sl, bSendToFPGA)

    #    config_window = SLLConfigurationWindow()
    #    config_window.loadParameters(sp)
    #    config_window.hide()

    ###########################################################################
    # Load all our windows:

    # Style sheet which includes the color scheme for each specific box:
    try:
        custom_style_sheet = (
            '#MainWindow {color: white; background-color: %s;}' %
            devices_data[initial_config.strSelectedSerial]['color'])
    except KeyError:
        custom_style_sheet = ''

    # The shorthand name which gets added to the window names:
    try:
        custom_shorthand = devices_data[
            initial_config.strSelectedSerial]['shorthand']
    except KeyError:
        custom_shorthand = ''

    # Have to be careful with the modulus setting (double-check with a scope to make sure the output frequency is right)
    # I think the output frequency for the square wave mode is given by:
    # 200 MHz/(2*(modulus+1))
    # While for the pulsed mode (bPulses = 1), the frequency is:
    # 200 MHz/(modulus+1)


#    sl.set_clk_divider_settings(bOn=1, bPulses=0, modulus=67e3-1)
#    sl.set_clk_divider_settings(bOn=1, bPulses=0, modulus=67e3+1-1)
    divider_settings_window = DisplayDividerAndResidualsStreamingSettingsWindow(
        sl,
        clk_divider_modulus=67e3,
        bDividerOn=0,
        bPulses=0,
        custom_style_sheet=custom_style_sheet,
        custom_shorthand=custom_shorthand,
        bUpdateFPGA=bSendToFPGA)

    # Optical lock window
    xem_gui_mainwindow2 = XEM_GUI_MainWindow(
        sl, custom_shorthand + ': Optical lock', 1, (False, True, False), sp,
        custom_style_sheet, initial_config.strSelectedSerial)
    xem_gui_mainwindow2.initSL(bTriggerEvents)

    # CEO Lock window
    xem_gui_mainwindow = XEM_GUI_MainWindow(sl,
                                            custom_shorthand + ': CEO lock', 0,
                                            (True, False, False), sp,
                                            custom_style_sheet,
                                            initial_config.strSelectedSerial)
    xem_gui_mainwindow.initSL(bTriggerEvents)

    #    ###########################################################################
    #    # For testing the Red Pitaya with the built-in DDS:
    #
    #    addr_vco = 2
    #    addr_vco_amplitude = 0x0000
    #    addr_vco_freq_msb  = 0x0004
    #    addr_vco_freq_lsb  = 0x0008
    #
    #    vco_amplitude = round(0.01*(2**15-1))
    ##   vco_freq_word = np.array([round((15e6/100e6+1./600.)*2.**48)]).astype(np.int64)
    ##   # break vco word into msbs and lsbs:
    ##   vco_freq_word_msbs = vco_freq_word >> 32
    ##   vco_freq_word_lsbs = np.bitwise_and(vco_freq_word, (1<<32)-1)
    #
    #   # write amplitude
    #    address_uint32 = (addr_vco << 20) + addr_vco_amplitude
    #    data_uint32 = vco_amplitude
    #    sl.dev.write_Zynq_register_uint32(address_uint32, data_uint32)

    #########################################################
    # The two frequency counter:
    strOfTime = time.strftime("%m_%d_%Y_%H_%M_%S_")

    try:
        temp_control_port = devices_data[
            initial_config.strSelectedSerial]['port']
    except:
        temp_control_port = 0

    strNameTemplate = 'data_logging\%s' % strOfTime
    strNameTemplate = '%s_%s_' % (strNameTemplate,
                                  initial_config.strSelectedSerial)
    freq_error_window1 = FreqErrorWindowWithTempControlV2(
        sl, 'CEO beat in-loop counter', 0, strNameTemplate, custom_style_sheet,
        0, xem_gui_mainwindow)
    freq_error_window2 = FreqErrorWindowWithTempControlV2(
        sl, 'Optical beat in-loop counter', 1, strNameTemplate,
        custom_style_sheet, temp_control_port, None)

    counters_window = Qt.QWidget()
    counters_window.setObjectName('MainWindow')
    counters_window.setStyleSheet(custom_style_sheet)
    vbox = Qt.QVBoxLayout()
    vbox.addWidget(freq_error_window1)
    vbox.addWidget(freq_error_window2)
    counters_window.setLayout(vbox)
    counters_window.setWindowTitle(custom_shorthand + ': Frequency counters')
    #counters_window.setGeometry(993, 40, 800, 1010)
    #counters_window.setGeometry(0, 0, 750, 1000)
    #    counters_window.resize(600, 1080-100+30)
    counters_window.move(QtGui.QDesktopWidget().availableGeometry().topLeft() +
                         Qt.QPoint(985, 10))
    counters_window.show()

    # Dither windows, this code could be moved to another class/file to help with clutter:
    dither_widget0 = DisplayDitherSettingsWindow(
        sl,
        0,
        modulation_frequency_in_hz='1e3',
        output_amplitude='1e-3',
        integration_time_in_seconds='0.1',
        bEnableDither=True,
        custom_style_sheet=custom_style_sheet)
    dither_widget1 = DisplayDitherSettingsWindow(
        sl,
        1,
        modulation_frequency_in_hz='5e3',
        output_amplitude='1e-3',
        integration_time_in_seconds='0.1',
        bEnableDither=True,
        custom_style_sheet=custom_style_sheet)
    dither_widget2 = DisplayDitherSettingsWindow(
        sl,
        2,
        modulation_frequency_in_hz='110',
        output_amplitude='1e-4',
        integration_time_in_seconds='0.1',
        bEnableDither=True,
        custom_style_sheet=custom_style_sheet)

    settings_window = Qt.QWidget()
    settings_window.setObjectName('MainWindow')
    settings_window.setStyleSheet(custom_style_sheet)
    vbox = Qt.QVBoxLayout()
    vbox.addWidget(dither_widget0)
    vbox.addWidget(dither_widget1)
    vbox.addWidget(dither_widget2)
    vbox.addStretch(1)
    hbox = Qt.QHBoxLayout()
    hbox.addLayout(vbox)
    hbox.addWidget(divider_settings_window)
    hbox.addStretch(1)
    settings_window.setLayout(hbox)
    settings_window.setWindowTitle(custom_shorthand + ': Dither controls')
    settings_window.show()

    #    ###########################################################################
    #    # For testing out the transfer function window:
    #    frequency_axis = np.logspace(np.log10(10e3), np.log10(2e6), 10e3)
    #    transfer_function = 1/(1 + 1j*frequency_axis/100e3)
    #    window_number = 1
    #    vertical_units = 'V/V'
    #    tf_window1 = DisplayTransferFunctionWindow(frequency_axis, transfer_function, window_number, vertical_units)
    #

    #    # Regroup the two windows into a single one:
    main_windows = Qt.QWidget()
    main_windows.setObjectName('MainWindow')
    main_windows.setStyleSheet(custom_style_sheet)

    #    ###########################################################################
    #    # Select clock source
    #    # clock_source = 0: Internal clock at 100 MHz
    #    # clock_source = 1: External clock at 200 MHz on DIN[0]/CLKIN, divided by 2 internally for a system clock still at 100 MHz
    #    if initial_config.bSendFirmware:
    #        if initial_config.bExternalClock == True:
    #            clock_source = 1
    #            print('External clock mode')
    #        else:
    #            clock_source = 0
    #            print('Internal clock mode')
    #        sl.selectClockSource(clock_source)
    #        # Now we just need to reset the frontend to make sure we start everything in a nice state
    #        sl.resetFrontend()

    sl.resetFrontend()

    tabs = QtGui.QTabWidget()
    # xem_gui_mainwindow2.resize(600, 700)

    # xem_gui_mainwindow.setContentsMargins(0, 0, 0, 0)
    # xem_gui_mainwindow.layout().setContentsMargins(0, 0, 0, 0)
    # xem_gui_mainwindow2.setContentsMargins(0, 0, 0, 0)
    # xem_gui_mainwindow2.layout().setContentsMargins(0, 0, 0, 0)
    # counters_window.setContentsMargins(0, 0, 0, 0)
    # counters_window.layout().setContentsMargins(0, 0, 0, 0)
    # dither_window.setContentsMargins(0, 0, 0, 0)
    # dither_window.layout().setContentsMargins(0, 0, 0, 0)
    # dfr_timing_gui.setContentsMargins(0, 0, 0, 0)
    # dfr_timing_gui.layout().setContentsMargins(0, 0, 0, 0)
    # divider_settings_window.setContentsMargins(0, 0, 0, 0)
    # divider_settings_window.layout().setContentsMargins(0, 0, 0, 0)

    tabs.setMaximumSize(1920, 1080 - 100 + 30)
    # main_windows.setMaximumSize(600,600)
    # xem_gui_mainwindow.setMaximumSize(600,600)
    # xem_gui_mainwindow2.setMaximumSize(600,600)
    # counters_window.setMaximumSize(600,600)
    # dither_window.setMaximumSize(600,600)
    # dfr_timing_gui.setMaximumSize(600,600)
    # divider_settings_window.setMaximumSize(600,600)
    tabs.addTab(xem_gui_mainwindow, "CEO Lock")
    tabs.addTab(xem_gui_mainwindow2, "Optical Lock")
    tabs.addTab(counters_window, "Counters")
    tabs.addTab(settings_window, "Settings")
    #FEATURE
    #tabs.addTab(dfr_timing_gui, "DFr trigger generator")
    #    tabs.addTab(divider_settings_window, "Filter settings")
    # tabs.setGeometry(0, 0, 750, 1000)

    box = QtGui.QHBoxLayout()
    box.addWidget(tabs)
    main_windows.setLayout(box)
    main_windows.setWindowTitle(custom_shorthand)
    main_windows.move(QtGui.QDesktopWidget().availableGeometry().topLeft() +
                      Qt.QPoint(945 - 300, 0))

    main_windows.show()

    # Enter main event loop
    app.exec_()
Example #26
0
    def __init__(self, *args):
        QtGui.QWidget.__init__(self, None)
        self.ui = Ui_wallpaperWidget()
        self.ui.setupUi(self)
        # Get system locale
        self.catLang = KGlobal.locale().language()

        isWide = lambda x: float(x[0]) / float(x[1]) >= 1.6
        isSquare = lambda x: float(x[0]) / float(x[1]) < 1.6

        # Get screen resolution
        rect = QtGui.QDesktopWidget().screenGeometry()

        # Get metadata.desktop files from shared wallpaper directory
        lst = KStandardDirs().findAllResources("wallpaper",
                                               "*metadata.desktop",
                                               KStandardDirs.Recursive)

        for desktopFiles in lst:
            parser = DesktopParser()
            parser.read(str(desktopFiles))

            try:
                wallpaperTitle = parser.get_locale('Desktop Entry',
                                                   'Name[%s]' % self.catLang,
                                                   '')
            except:
                wallpaperTitle = parser.get_locale('Desktop Entry', 'Name', '')

            try:
                wallpaperDesc = parser.get_locale('Desktop Entry',
                                                  'X-KDE-PluginInfo-Author',
                                                  '')
            except:
                wallpaperDesc = "Unknown"

            # Get all files in the wallpaper's directory
            l = os.listdir(
                os.path.join(
                    os.path.split(str(desktopFiles))[0], "contents/images"))

            wallpaperFile = os.path.split(str(desktopFiles))[0]
            wallpaperThumb = os.path.join(
                os.path.split(str(desktopFiles))[0], "contents/screenshot.png")

            # Insert wallpapers to listWidget.
            item = QtGui.QListWidgetItem(self.ui.listWallpaper)
            # Each wallpaper item is a widget. Look at widgets.py for more information.
            widget = WallpaperItemWidget(unicode(wallpaperTitle),
                                         unicode(wallpaperDesc),
                                         wallpaperThumb, self.ui.listWallpaper)
            item.setSizeHint(QSize(38, 110))
            self.ui.listWallpaper.setItemWidget(item, widget)
            # Add a hidden value to each item for detecting selected wallpaper's path.
            item.setStatusTip(wallpaperFile)

        self.ui.listWallpaper.connect(self.ui.listWallpaper,
                                      SIGNAL("itemSelectionChanged()"),
                                      self.setWallpaper)
        self.ui.checkBox.connect(self.ui.checkBox, SIGNAL("stateChanged(int)"),
                                 self.disableWidgets)
        self.ui.buttonChooseWp.connect(self.ui.buttonChooseWp,
                                       SIGNAL("clicked()"),
                                       self.selectWallpaper)
Example #27
0
    def initUI(self, parent, adjust, name, point, marker, marker_size):

        QtGui.QMainWindow.__init__(self)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.setWindowTitle(name)
        self.resize(1000, 1000)
        screen = QtGui.QDesktopWidget().screenGeometry()
        self.move(random.randint(0, screen.height()),
                  random.randint(0, screen.width()))
        self.open = QtGui.QAction('&Open', self)
        self.open.setShortcut('Ctrl+O')
        self.open.setStatusTip('import graphics')
        self.connect(self.open, QtCore.SIGNAL('triggered()'), self.openGraph)

        self.close = QtGui.QAction('&Exit', self)
        self.close.setShortcut('Ctrl+Q')
        self.close.setStatusTip('Exit application')
        self.connect(self.close, QtCore.SIGNAL('triggered()'),
                     QtCore.SLOT('close()'))

        self.printG = QtGui.QAction('&Print', self)
        self.printG.setShortcut('Ctrl+P')
        self.printG.setStatusTip('Print graphics')
        self.connect(self.printG, QtCore.SIGNAL('triggered()'),
                     self.printGraph)

        self.save = QtGui.QAction('&Save', self)
        self.save.setShortcut('Ctrl+S')
        self.save.setStatusTip('Save Graphic')
        self.connect(self.save, QtCore.SIGNAL('triggered()'), self.showDialog)

        self.setStatusBar(QtGui.QStatusBar())
        self.menubar = self.menuBar()
        self.fileMenu1 = self.menubar.addMenu('&File')
        #self.fileMenu1.addAction(self.open)
        self.fileMenu1.addAction(self.save)
        self.fileMenu1.addAction(self.printG)
        self.fileMenu1.addAction(self.close)

        self.main_widget = QtGui.QWidget(self)
        self.main_lay = QtGui.QHBoxLayout(self.main_widget)

        #Creation of the graphics widged
        self.graph_widget = QtGui.QWidget(self)
        self.graph_lay = QtGui.QVBoxLayout(self.graph_widget)

        self.G = Canvas.CanvasQT(self.main_widget, width=6, height=4, dpi=100,\
                                    x=self.x,y=self.y,pxlbl=self.xlabel,pylbl=self.ylabel\
                                     ,point=point,marker=marker,marker_size=marker_size)
        self.navigation_toolbar = NavigationToolbar2(self.G, self)

        #creation of the option widget
        self.test = QtGui.QWidget()
        self.test.hide()
        self.option_layout = QtGui.QGridLayout(self.test)

        self.lbl2 = QtGui.QLabel("select file :", self)
        self.lbl2.setFixedSize(70, 36)
        self.tefile = QtGui.QTextEdit()
        self.tefile.setReadOnly(True)
        self.tefile.setFixedSize(100, 36)

        self.browse = QtGui.QPushButton('&Browse', self)
        self.browse.setFixedSize(100, 36)
        #        self.connect(self.browse ,QtCore.SIGNAL("clicked()"),self.openFile)

        self.tbro = QtGui.QTextBrowser()
        self.tbro.setFixedHeight(500)
        self.tbro.setFixedWidth(200)
        self.tbro.setLineWrapMode(QtGui.QTextEdit.NoWrap)

        self.lbl3 = QtGui.QLabel("x :", self)
        self.lbl3.setFixedSize(15, 36)

        self.CBox1 = QtGui.QComboBox()
        self.CBox1.addItem("")
        self.CBox1.setFixedSize(65, 36)
        #        self.connect(self.CBox1,QtCore.SIGNAL('currentIndexChanged(const QString&)'),self.changeData)

        self.lbl4 = QtGui.QLabel("y :", self)
        self.lbl4.setFixedSize(15, 36)

        self.CBox2 = QtGui.QComboBox()
        self.CBox2.addItem("")
        self.CBox2.setFixedSize(65, 36)
        #        self.connect(self.CBox2,QtCore.SIGNAL('currentIndexChanged(const QString&)'),self.changeData)

        self.imp = QtGui.QPushButton('&import', self)
        self.imp.setFixedSize(100, 36)
        #       self.connect(self.imp ,QtCore.SIGNAL("clicked()"),self.close)

        self.option_layout.addWidget(self.lbl2, 0, 0, 1, 1,
                                     QtCore.Qt.AlignCenter)
        self.option_layout.addWidget(self.tefile, 0, 1, 1, 4,
                                     QtCore.Qt.AlignLeft)
        self.option_layout.addWidget(self.browse, 0, 5, 1, 1,
                                     QtCore.Qt.AlignCenter)
        self.option_layout.addWidget(self.tbro, 1, 0, 10, 6,
                                     QtCore.Qt.AlignCenter)
        self.option_layout.addWidget(self.lbl3, 12, 0, 1, 1,
                                     QtCore.Qt.AlignRight)
        self.option_layout.addWidget(self.CBox1, 12, 1, 1, 1,
                                     QtCore.Qt.AlignLeft)
        self.option_layout.addWidget(self.lbl4, 12, 2, 1, 1,
                                     QtCore.Qt.AlignRight)
        self.option_layout.addWidget(self.CBox2, 12, 3, 1, 1,
                                     QtCore.Qt.AlignLeft)
        self.option_layout.addWidget(self.imp, 12, 5, 1, 1,
                                     QtCore.Qt.AlignLeft)

        self.graph_lay.addWidget(self.G)
        self.graph_lay.addWidget(self.navigation_toolbar, 0)
        self.main_lay.addWidget(self.graph_widget)
        self.main_lay.addWidget(self.test)

        if self.average:
            self.checkbox_average = QtGui.QCheckBox("Show average Value")
            self.connect(self.checkbox_average, QtCore.SIGNAL('clicked()'),
                         self.addAverage)
            self.lbl1 = QtGui.QLabel()
            self.lbl1.setFixedWidth(250)
            average = self.averageValue()
            display = self.displayData(
                average, self.getStandardDeviation(self.y, average))
            self.lbl1.setText('Average : ' + display)
            self.navigation_toolbar.addWidget(self.lbl1)
            self.navigation_toolbar.addWidget(self.checkbox_average)

        if adjust:
            self.G.adjust_x_lim(self.x, self.y)

        self.main_widget.setFocus()
        self.setCentralWidget(self.main_widget)
    def __init__(self, parent=None):
        super(QtGui.QWidget, self).__init__(parent)

        self.do_output = False
        self.data_dir = ''
        self.has_selected_data_dir = False
        self.has_selected_output_dir = True

        self.setWindowTitle("Enter settings for Experiment YAML File")
        self.title_label = QtGui.QLabel("Enter Settings to Save as YAML File")
        self.main_vbox = QtGui.QVBoxLayout()
        self.title_hbox = QtGui.QHBoxLayout()
        self.title_hbox.addStretch()
        self.title_hbox.addWidget(self.title_label)
        self.title_hbox.addStretch()
        self.main_vbox.addLayout(self.title_hbox)
        # self.main_vbox.addStretch()

        # file name
        # self.file_name_hbox = QtGui.QHBoxLayout()
        self.file_name_field = QtGui.QLineEdit()
        # regexp = QtCore.QRegExp('(.+?)(\.[^.]*$|$')
        # validator = QtGui.QRegExpValidator(regexp)
        # self.file_name_field.setValidator(validator)
        self.file_name_label = QtGui.QLabel("Enter filename without extension")
        # self.file_name_hbox.addWidget(self.file_name_field)
        # self.file_name_hbox.addWidget(self.file_name_label)
        # self.main_vbox.addLayout(self.file_name_hbox)

        # data directory
        # self.data_dir_hbox = QtGui.QHBoxLayout()
        self.data_button = QtGui.QPushButton("Select Data Dir", self)
        self.data_button.clicked.connect(self.select_data)
        self.data_label = QtGui.QLabel(
            "Click to select a valid data directory")
        # self.data_dir_hbox.addWidget(self.data_button)
        # self.data_dir_hbox.addWidget(self.data_label)
        # self.main_vbox.addLayout(self.data_dir_hbox)

        # output directory
        self.output_dir_button = QtGui.QPushButton("Select Output Location",
                                                   self)
        self.output_dir_button.clicked.connect(self.select_output_location)
        self.output_label = QtGui.QLabel(
            "Click to select directory to store Experiment YAML file")

        # Exp type
        # self.exp_type_hbox = QtGui.QHBoxLayout()
        self.exp_type_menu = QtGui.QComboBox(self)
        self.exp_type_menu.addItem("LEED")
        self.exp_type_menu.addItem("LEEM")
        self.exp_type_label = QtGui.QLabel("Select Experiment Type")
        # self.exp_type_hbox.addWidget(self.exp_type_menu)
        # self.exp_type_hbox.addWidget(self.exp_type_label)
        # self.main_vbox.addLayout(self.exp_type_hbox)

        # Data type
        # self.data_type_hbox = QtGui.QHBoxLayout()
        self.data_type_menu = QtGui.QComboBox(self)
        self.data_type_menu.addItem("Image")
        self.data_type_menu.addItem("Raw")
        self.data_type_label = QtGui.QLabel("Select Data Type")
        # self.data_type_hbox.addWidget(self.data_type_menu)
        # self.data_type_hbox.addWidget(self.data_type_label)
        # self.main_vbox.addLayout(self.data_type_hbox)
        self.data_type_menu.currentIndexChanged.connect(
            self.toggle_image_type_active)

        # Image type
        # self.image_type_hbox = QtGui.QHBoxLayout()
        self.image_type_menu = QtGui.QComboBox(self)
        self.image_type_menu.addItem("TIFF")
        self.image_type_menu.addItem("PNG")
        self.image_type_label = QtGui.QLabel("Select Image Type")
        # self.image_type_hbox.addWidget(self.image_type_menu)
        # self.image_type_hbox.addWidget(self.image_type_label)
        # self.main_vbox.addLayout(self.image_type_hbox)

        grid = QtGui.QGridLayout()
        grid.addWidget(self.file_name_field, 1, 0)
        grid.addWidget(self.file_name_label, 1, 1)
        grid.addWidget(self.data_button, 2, 0)
        grid.addWidget(self.data_label, 2, 1)
        grid.addWidget(self.output_dir_button, 3, 0)
        grid.addWidget(self.output_label, 3, 1)
        grid.addWidget(self.exp_type_menu, 4, 0)
        grid.addWidget(self.exp_type_label, 4, 1)
        grid.addWidget(self.data_type_menu, 5, 0)
        grid.addWidget(self.data_type_label, 5, 1)
        grid.addWidget(self.image_type_menu, 6, 0)
        grid.addWidget(self.image_type_label, 6, 1)
        grid.setHorizontalSpacing(100)
        grid.setVerticalSpacing(15)

        self.main_vbox.addLayout(grid)

        # Data Params
        self.data_params_hbox = QtGui.QHBoxLayout()
        self.data_params_hbox.addStretch()
        self.data_params_label = QtGui.QLabel("--Data Parameters--")
        self.data_params_hbox.addWidget(self.data_params_label)
        self.data_params_hbox.addStretch()
        self.main_vbox.addStretch()
        self.main_vbox.addLayout(self.data_params_hbox)

        self.im_hbox = QtGui.QHBoxLayout()
        self.im_width_field = QtGui.QLineEdit()
        self.im_width_field.setValidator(QtGui.QIntValidator(bottom=0))
        self.im_width_label = QtGui.QLabel("Enter Image Width > 0")
        self.im_hbox.addWidget(self.im_width_field)
        self.im_hbox.addWidget(self.im_width_label)

        self.im_height_field = QtGui.QLineEdit()
        self.im_height_field.setValidator(QtGui.QIntValidator(bottom=0))
        self.im_height_label = QtGui.QLabel("Enter Image Height > 0")
        self.im_hbox.addWidget(self.im_height_field)
        self.im_hbox.addWidget(self.im_height_label)

        self.im_bits_menu = QtGui.QComboBox()
        self.im_bits_menu.addItem("8")
        self.im_bits_menu.addItem("16")
        self.im_bits_label = QtGui.QLabel(
            "Select Image Bit Depth\n(only for Raw Data)")
        self.im_hbox.addWidget(self.im_bits_menu)
        self.im_hbox.addWidget(self.im_bits_label)

        self.im_byte_order_menu = QtGui.QComboBox()
        self.im_byte_order_menu.addItem("Little-Endian (Intel)")
        self.im_byte_order_menu.addItem("Big-Endian (Motorola)")
        self.im_byte_order_label = QtGui.QLabel(
            "Select Byte-Order for raw data")
        self.im_hbox.addWidget(self.im_byte_order_menu)
        self.im_hbox.addWidget(self.im_byte_order_label)

        self.main_vbox.addLayout(self.im_hbox)

        # Energy Params
        self.energy_params_label_hbox = QtGui.QHBoxLayout()
        self.energy_params_label_hbox.addStretch()
        self.energy_params_label = QtGui.QLabel("--Energy Parameters--")
        self.energy_params_label_hbox.addWidget(self.energy_params_label)
        self.energy_params_label_hbox.addStretch()
        self.main_vbox.addStretch()
        self.main_vbox.addLayout(self.energy_params_label_hbox)

        self.energy_params_hbox = QtGui.QHBoxLayout()
        self.min_energy_field = QtGui.QLineEdit()
        self.min_energy_field.setValidator(QtGui.QDoubleValidator())
        self.min_energy_label = QtGui.QLabel("Enter Starting Energy in eV")
        self.max_energy_field = QtGui.QLineEdit()
        self.max_energy_field.setValidator(QtGui.QDoubleValidator())
        self.max_energy_label = QtGui.QLabel("Enter Final Energy in eV")
        self.step_energy_field = QtGui.QLineEdit()
        self.step_energy_field.setValidator(QtGui.QDoubleValidator())
        self.step_energy_label = QtGui.QLabel("Enter Step Energy in eV")

        self.energy_params_hbox.addWidget(self.min_energy_field)
        self.energy_params_hbox.addWidget(self.min_energy_label)
        self.energy_params_hbox.addStretch()
        self.energy_params_hbox.addWidget(self.max_energy_field)
        self.energy_params_hbox.addWidget(self.max_energy_label)
        self.energy_params_hbox.addStretch()
        self.energy_params_hbox.addWidget(self.step_energy_field)
        self.energy_params_hbox.addWidget(self.step_energy_label)
        self.main_vbox.addLayout(self.energy_params_hbox)

        self.main_vbox.addStretch()
        self.end_button_hbox = QtGui.QHBoxLayout()
        self.cancel_button = QtGui.QPushButton("Cancel", self)
        self.cancel_button.clicked.connect(lambda: self.close())
        self.ok_button = QtGui.QPushButton("Ok", self)
        self.ok_button.clicked.connect(self.validate)
        self.end_button_hbox.addStretch()
        self.end_button_hbox.addWidget(self.cancel_button)
        self.end_button_hbox.addWidget(self.ok_button)
        self.main_vbox.addLayout(self.end_button_hbox)

        self.setLayout(self.main_vbox)

        # Center on Screen
        resolution = QtGui.QDesktopWidget().screenGeometry()
        self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
                  (resolution.height() / 2) - (self.frameSize().height() / 2))
        self.show()
    def __init__(self, parent=None):
        super(AttendanceGraph, self).__init__(parent)
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap(_fromUtf8("icons/favicon.png")),
                       QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.setWindowIcon(icon)
        self.setWindowTitle(
            'Employees\' Presence and Absence Average Count Comparison')

        fg = self.frameGeometry()
        cp = QtGui.QDesktopWidget().availableGeometry().center()
        fg.moveCenter(cp)
        self.move(fg.topLeft())
        self.setMinimumSize(800, 500)

        logs = self.get_attendance_stat()
        if logs is not None:

            self.figure = Figure(figsize=(100, 600), facecolor='gray')
            self.canvas = FigureCanvas(self.figure)

            self.toolbar = Tb(self.canvas, self)

            graph = self.figure.add_subplot(111)

            graph.set_xlabel('Period', color='yellow')
            graph.set_ylabel('Count', color='yellow')

            x = np.array(logs['key'])
            y_presences = np.array(logs['attendance_ave'])
            y_absences = np.array(logs['absence_ave'])

            x_smooth = np.linspace(x.min(), x.max(), 300)
            y_presences_smooth = spline(x, y_presences, x_smooth)
            y_absences_smooth = spline(x, y_absences, x_smooth)

            # graph.plot(x, y_presences, linestyle=' ', marker='o', color='blue')
            # graph.plot(x_smooth, y_presences_smooth, label='average presence count', color='blue')

            # graph.plot(x, y_absences, linestyle=' ', marker='o', color='orange')
            # graph.plot(x_smooth, y_absences_smooth, label='average absence count', color='orange')

            graph.plot(x, y_presences, linestyle=' ', marker='o', color='blue')
            graph.plot(logs['key'],
                       logs['attendance_ave'],
                       label='average presence count',
                       color='blue')

            graph.plot(x,
                       y_absences,
                       linestyle=' ',
                       marker='o',
                       color='orange')
            graph.plot(logs['key'],
                       logs['absence_ave'],
                       label='average absence count',
                       color='orange')

            graph.grid(linestyle='-')
            graph.legend(loc='upper left')
            graph.ticklabel_format(useOffset=False)

            layout = QtGui.QVBoxLayout()
            layout.addWidget(self.toolbar)
            layout.addWidget(self.canvas)
            self.setLayout(layout)

            self.setWindowModality(QtCore.Qt.ApplicationModal)
Example #30
0
    def __init__(self):
        """
        Class constructor

        >>> 1 + 1
        2
        >>>
        """
        super(DySMainWindow, self).__init__()
        # self.setAttribute(QtCore.Qt.WA_TranslucentBackground, 90)
        #    minimum size
        self.setMinimumSize(500, 500)

        #   computer information
        self._hostname = socket.gethostname()
        print "self._hostname =", self._hostname
        #    style
        # self.setStyle("windows")
        #     plastique
        #     cde
        #     motif
        #     sgi
        #     windows
        #     cleanlooks
        #     mac
        
        #    icon
        self.setWindowIcon(QtGui.QIcon(":/application.png"))
        QtGui.QSystemTrayIcon(QtGui.QIcon(":/application.png"))
        
        #    location of window on self.screen_geometry
        self.window_offset_x = 250
        self.window_offset_y = 50

        #    language settings
        self.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))

        #    window name
        self.setWindowTitle("DyS")

        #   font
        self.font = QtGui.QFont("Consolas", 10)
        
        #    mouse tracking
        self.setMouseTracking(True)
        
        #    context menu
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        
        #    main window flags
        self.flags = QtCore.Qt.Window

        __main_dir = current_working_directory
        self._working_directory = QtCore.QString(os.path.abspath(__main_dir).replace("/", "\\"))

        #   get screen geometry size
        self.screen_geometry = QtGui.QDesktopWidget().screenGeometry()
        #    move
        # self.move(self.window_offset_x, self.window_offset_y)
        dy = .05*self.screen_geometry.height()

        #   size of application
        #   position main widget on self.screen_geometry
        self.setGeometry(.25*self.screen_geometry.width(), dy, .5*self.screen_geometry.width(), .5*self.screen_geometry.width())

        #    MBD system
        MBD_folder_name_ = None
        self.MBD_file_abs_path = None

        # self.MBD_filename = "0_0_0_double_pendulum.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_0_0_double_pendulum"

        # self.MBD_filename = "dys_0_.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_"

        # self.MBD_filename = "dys_0_2_1.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_2_1"

        # self.MBD_filename = "dys_0_3_prismatic_joint.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_3_prismatic_joint"

        # self.MBD_filename = "dys_0_4.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_4"

        # self.MBD_filename = "dys_0_5.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_5"

        # self.MBD_filename = "dys_0_6_1.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_6_1"

        # self.MBD_filename = "dys_0_6_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_6_2"

        # self.MBD_filename = "dys_0_7_0_1.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_0_1"

        # self.MBD_filename = "dys_0_7_0_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_0_2"

        # self.MBD_filename = "0_7_3_3_kinematic_analysis_1arm.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_kinematic_analysis_1arm"

        # self.MBD_filename = "0_7_3_3_kinematic_analysis_2arm.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_kinematic_analysis_2arm"

        # self.MBD_filename = "0_7_3_3_kinematic_analysis_slider_crank.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_kinematic_analysis_slider_crank"

        # self.MBD_filename = "0_7_3_3_kinematic_analysis_4bar.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_kinematic_analysis_4bar"

        # self.MBD_filename = "0_7_3_3_kinematic_analysis_efi.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_kinematic_analysis_efi"

        # self.MBD_filename = "0_7_3_3_dynamic_analysis_efi.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_dynamic_analysis_efi"
    
        # self.MBD_filename = "0_7_3_3_dynamic_analysis_efi_V2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_3_dynamic_analysis_efi_V2"

        # self.MBD_filename = "dys_0_7_3_0.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_0"
        
        # self.MBD_filename = "0_7_3_0_plane_sphere.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_0_plane_sphere"

        # self.MBD_filename = "dys_0_7_2_revolute_clearence_joint.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_2_revolute_clearence_joint"

        # self.MBD_filename = "0_7_2_revolute_clearance_joint_1.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_2_revolute_clearance_joint_1"

        # self.MBD_filename = "0_7_3_0_contact_models.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_0_contact_models"

        self.MBD_filename = "0_7_3_0_contact_models_cylinder.dprj"
        MBD_folder_name_ = "dynamic_systems\\0_7_3_0_contact_models_cylinder"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint_2"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint_paper.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint_paper"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint_paper_1.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint_paper_1"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint_paper_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint_paper_2"

        # self.MBD_filename = "0_7_1_0_spring_translational.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_1_0_spring_translational"

        # self.MBD_filename = "0_8_0_surface_roughness.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_8_0_surface_roughness"

        # self.MBD_filename = "0_9_0_brush_slip-ring.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_0_brush_slip-ring"

        # self.MBD_filename = "0_9_1_brush_slip-ring.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_1_brush_slip-ring"

        # self.MBD_filename = "0_9_2_multiple_contacts.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_2_multiple_contacts"

        # self.MBD_filename = "0_9_3_brush_slip-ring.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_3_brush_slip-ring"

        # self.MBD_filename = "0_9_4_brush_slip-ring.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_4_brush_slip-ring"

        # self.MBD_filename = "0_9_5_brush_energy.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_5_brush_energy"

        # self.MBD_filename = "0_9_6_brush_slip-ring.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_9_6_brush_slip-ring"

        # self.MBD_filename = "1_0_0_ancf-beam.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-beam"

        # self.MBD_filename = "1_0_0_ancf-cantilever_1element.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_1element"

        # self.MBD_filename = "1_0_0_ancf-cantilever_2elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_2elements"

        # self.MBD_filename = "1_0_0_ancf-cantilever_2elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_2elements"
        #
        # self.MBD_filename = "1_0_0_ancf-cantilever_4elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_4elements"
        #
        # self.MBD_filename = "1_0_0_ancf-cantilever_8elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_8elements"
        #
        # self.MBD_filename = "1_0_0_ancf-cantilever_16elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_16elements"
        #
        # self.MBD_filename = "1_0_0_ancf-cantilever_32elements.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_32elements"

        # self.MBD_filename = "1_0_0_ancf-free_falling_flexible_pendulum.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-free_falling_flexible_pendulum"

        # self.MBD_filename = "1_0_0_ancf-cantilever_M.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-cantilever_M"

        # self.MBD_filename = "1_0_0_ancf-beam_contact.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_0_ancf-beam_contact"

        # self.MBD_filename = "1_0_1_ancf_frame.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_ancf_frame"

        # self.MBD_filename = "1_0_1_geometry_test.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_geometry_test"

        # self.MBD_filename = "1_0_1_external_force.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_external_force"

        # self.MBD_filename = "1_0_1_paper_2_eigenfrequencies.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_eigenfrequencies"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_point_mass.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_point_mass"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_sub.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_sub"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2_y_spring=-1mm.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2_y_spring=-1mm"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2_y_spring=+1mm.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2_y_spring=+1mm"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2_prestress_2x.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2_prestress_2x"

        #self.MBD_filename = "1_0_1_paper_2_dynamic_system_2_prestress_params_2x.dprj"
        #MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2_prestress_params_2x"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_2_prestress_0.5x.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_2_prestress_0.5x"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_rigid.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_rigid"

        # self.MBD_filename = "1_0_1_paper_2_dynamic_system_rigid_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_dynamic_system_rigid_2"

        # self.MBD_filename = "0_7_3_2_pin_slot_clearance_joint_testing.dprj"
        # MBD_folder_name_ = "dynamic_systems\\0_7_3_2_pin_slot_clearance_joint_testing"

        # self.MBD_filename = "1_0_1_paper_2_rigid_joint_rigid_flexible.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_rigid_joint_rigid_flexible"

        # self.MBD_filename = "1_0_1_paper_2_revolute_joint_flexible_flexible.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_revolute_joint_flexible_flexible"

        # self.MBD_filename = "1_0_1_paper_2_revolute_joint_rigid_flexible.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_revolute_joint_rigid_flexible"

        # self.MBD_filename = "1_0_1_paper_2_rigid_joint_point_mass_flexible.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_rigid_joint_point_mass_flexible"

        # self.MBD_filename = "1_0_1_paper_2_rigid_joint_point_mass_flexible_offset.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_rigid_joint_point_mass_flexible_offset"

        # self.MBD_filename = "1_0_1_paper_2_rigid_joint_rigid_flexible.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_rigid_joint_rigid_flexible"

        # self.MBD_filename = "1_0_1_paper_2_rigid_joint_rigid_flexible_2.dprj"
        # MBD_folder_name_ = "dynamic_systems\\1_0_1_paper_2_rigid_joint_rigid_flexible_2"

        #   predefine attributes
        self.simulation_control_widget = None
        self._visualization_widget = "vtk"

        #   file is not defined
        if MBD_folder_name_ is None:
            self.MBD_folder_abs_path = os.getcwd()
            self.MBD_filename = project_filename = "Model_1"
            print "File is not defined"

        #   file is defined
        else:
            self._working_directory = os.path.join(os.getcwd(), "..")
            self.MBD_file_abs_path = os.path.abspath(os.path.join(self._working_directory, MBD_folder_name_, self.MBD_filename))

            self.MBD_folder_abs_path = os.path.join(self._working_directory, MBD_folder_name_)
            project_filename = os.path.basename(self.MBD_folder_abs_path)

        self._file_types = "Dynamic System Project File (*.dprj);;Multibody System File (*.mbd)"
        self.project = MBD_system_items.MBDsystemItem("MBDProject", parent=None)
        self.project.dys = self

        # print "self.MBD_folder_abs_path =", self.MBD_folder_abs_path
        self.MBD_system = MBDsystem(MBD_file_abs_path=self.MBD_file_abs_path,
                                    MBD_folder_abs_path=self.MBD_folder_abs_path,
                                    MBD_filename=project_filename,
                                    dys=self,
                                    parent=self.project)

        #   tree view widget
        self.tree_view_widget = TreeViewWidget(self.project, self.MBD_system, parent=self)
        self.tree_view_widget.setWindowFlags(self.flags)
        # self.tree_view_widget.show()
        #    move
        self.tree_view_widget.move(.18*self.screen_geometry.width() - self.tree_view_widget.frameGeometry().width(), dy)#self.frameGeometry().width(), self.frameGeometry().height())
        self.tree_view_widget.resize(.20*self.screen_geometry.width(), 0.8 * self.screen_geometry.height())

        #    simulation control widget
        self.simulation_control_widget = SimulationControlWidget(MBD_system=self.MBD_system, parent=self)
        self.simulation_control_widget.setWindowFlags(self.flags)
        # self.simulation_control_widget.show()

        #    move
        self.simulation_control_widget.move(.25*self.screen_geometry.width() + self.geometry().width(), dy)

        #   preferences widget
        self.preferences_widget = PreferencesWidget(self.simulation_control_widget, parent=None)

        #   graph widget - test
        for measure in self.MBD_system.measures:
            measure.graph_widget.setWindowFlags(self.flags)
            measure.graph_widget.show()

        #   set central widget
        self.setCentralWidget(self.simulation_control_widget.vtkWidget)

            # self.simulation_control_widget.vtkWidget.displayText()
            # print "2 =", self.simulation_control_widget.vtkWidget.vtkWidget.GetSize()
        # if self.simulation_control_widget.opengl_widget is not None:
        #     self.setCentralWidget(self.simulation_control_widget.opengl_widget)
        #    init graph widget - test
#         graph_widget = GraphWidget(parent=self)
#         graph_widget.setWindowFlags(self.flags)
#         graph_widget.show()
        #    output widget
        #    maybe put in new thread? if output will be large
#         self.OutputWidget = OutputWidget(parent=self)
#         self.OutputWidget.setWindowFlags(self.flags)
#         self.OutputWidget.show()

        #    job list widget
        self.JobListWidget = JobListWidget(job_list_=["job1", "job2", "job3"], parent=self)
        self.JobListWidget.setWindowFlags(self.flags)
        
        #    python console
        self.python_console = None#PythonConsole()

        #    resize
        # self.resize(self.simulation_control_widget.opengl_widget.initial_window_width, self.simulation_control_widget.opengl_widget.initial_window_height)
        
        #    create actions
        self.create_actions()
        
        #    create menus
        self.create_menus()
        
        #    create status bar
        self.create_status_bar()

        #    signals and connections
        self.connect_signals()