Usando QtDesigner com Pyqt e Python 2.6

Question

Eu sou novo no Python e estou começando a me ensinar a programação da GUI (espero) usando o PYQT4.7 e o Python 2.6

Acabei de baixar todo o pacote PYQT/QT4 (incluindo qtdesigner) no site do PYQT, no entanto, parece QtDesigner, que parece incrível de usar como um novato (já que você pode ver todos os atributos/propriedades/inadimplência etc.) de cada widget e visualmente visualmente Editar as propriedades é ótimo, mas o PYQT parece não definir o QtDesigner para integrar diretamente com os scripts de geração de código Pyqt e Pyqts Python:

IE: Acertar "Visualizar código", tenta executar o script designer-> C ++ chamado (UIC) em vez do script pyuic.py, etc.

Existe uma maneira de fazer com que o qtDesigner se integre estreitamente com o PYQT para geração de código em tempo real, como acontece com o C ++?

Caso contrário, isso significa que eu tenho que codificar toda a GUI QT dentro do meu Python IDE e procurar todo o código de documentação e caldeira para cada widget? (parece muito ineficiente e deselegante em comparação com apenas a integração QtDesigner+Python).

Qual é o fluxo habitual de produção de ferramentas // de uso de designer com pyqt? (Se nenhuma integração direta for possível - os usuários do Python+Pyqt simplesmente pulavam usando o QtDesigner todos juntos e escrevem manualmente todo o código QT GUI no Python?)

Quaisquer dicas/sugestões adicionais para um novato PYQT seriam apreciadas. Obrigado!

PS Eu sei que um monte de vocês provavelmente vai me dizer para sugar e codificar toda a interface do QT à mão, mas se eu usar o designer enquanto aprender como perguntado acima, forneça uma maneira de fazer isso para que eu possa aprender Mais facilmente, obrigado!

Answer 1

Comecei a escrever meu primeiro aplicativo PYQT (o PYQT é usado apenas para lidar com a GUI) e, ao que parece, que a boa cadeia de ferramentas é: QtDesigner para gerar .ui s e lidar com recursos e algum IDE, que podem definir o QtDesigner para editá -los. Eu uso o Eclipse, porque é altamente personalizável. Você pode compilar seu .qrc e .ui por demanda fazendo um pouco assim no início do aplicativo, na configuração ou em qualquer outro horário:

os.system("pyrcc4.exe -o ui/images_rc.py ui/images/images.qrc")
uic.compileUiDir(appDir + '/ui', True)

E depois usando as classes geradas da seguinte maneira:

class MyMainWindow(QtGui.QMainWindow):

    def __init__(self, owner):
        QtGui.QMainWindow.__init__(self)
        # 'Ui_MyMainWindow' is the class, that was generated by uic, 
        # naming convention is: 'Ui_' plus the name of root widget in designer
        self.ui = Ui_MyMainWindow()
        self.ui.setupUi(self)

ou você pode carregar .ui diretamente quando o contêiner inits:

    QtGui.QMainWindow.__init__(self)
    self.ui = None
    uic.loadUi('MyMainWindowUI.ui', self.ui)
    #now you have the instance of Ui_MyMainWindow in self.ui too, as above

Observe que eu adicionei o sufixo da interface do usuário ao nome do arquivo .UI, foi feito para evitar o nome do nome, causa o nome do arquivo .py, gerado pelo UIC, não é o nome da classe começando com 'ui_', mas apenas o widget root.

E outra nota: no final do arquivo gerado, 'importar %.qrc nome %_rc' (por padrão é a string Import Images_RC); portanto, você deve ciente disso ao usar o PYRCC4.

Toda a abordagem é flexível o suficiente, é preciso todo o trabalho de codificação da interface do usuário! Mas você ainda pode fazer um ajuste fino no atributo mymainwindow.ui, onde a instância de ui_mymainwindow se lança; E evita herança desnecessária. Pessoalmente, faço métodos _ConnectSlots e _initIntefrace no mymainwindow para fazer algum designer de trabalho não pode.

Ainda tenho que observar que a escrita do código da interface é uma boa abordagem, porque o código, gerado pela UIC, é feio. Eu prefiro carregar .ui em vigor por loadUi () por causa disso :) e se você tem muitos controles personalizados do PYQT, é tão booooring trazê -los para o qtdesigner ..

Answer 2

O que fiz foi fazer meu próprio executável da UIC que é um invólucro para o script pyuic.py.

Você precisará...

1. Para obter e instalar py2exe

2. Substitua Python_Path no código uic.py abaixo

3. Edite o arquivo qt.conf nos packages do site pyqt4 e defina binários = caminho para a pasta que contém o UIC EXE depois de fabricado.

4. Coloque uic.py e setup.py na mesma pasta

5. No prompt de comando, navegue até a pasta onde setup.py e uic.py são executados o seguinte comando "python setup.py py2exe".

//----iic.py

#uic.py
import subprocess
import sys

args = ""

for arg in sys.argv: 
    if sys.argv[0] != arg:
        args += arg + " "


# Start pyuic.py script
command = 'python %PYTHON_PATH%\\PyQt4\\uic\\pyuic.py '+ args
out = ''


child = subprocess.Popen(command, shell=True, stderr=subprocess.PIPE)
complete = False
while True:
    out = child.stderr.read(1)
    if out == '' and child.poll() != None:
        break
    if out != '':
        sys.stdout.write(out)
        sys.stdout.flush()

// ----- setup.py

#setup.py    
from distutils.core import setup
import py2exe

setup(windows=[{"script":"uic.py"}], options={"py2exe" : {"includes" : ["sip", "PyQt4.QtCore"]}})

Answer 3

Você pode correr pyuic (ou melhor pyuic4) da mão, em seu console. Você pode fazer sua GUI usando designer com Python, assim como faria com C ++.

A propósito: escrevi todas as coisas da GUI para o meu aplicativo (10k de código) manualmente. Eu realmente não gosto de designers da GUI e trabalhando com código gerado, quando você precisa ajustar alguma coisa.

Answer 4

QtDesigner usa uic.exe Para gerar no código Fly C ++. uic.exe é uma ferramenta de linha de comando, ele obtém nomes de arquivos como parâmetros de entrada. Para integração com Python, você pode escrever um programa Python que usa pyuic.py, combine com entradas com uic.exeEntrada (Order, Switchs etc.), converta -a em um executável (usando PY2EXE) e renomeie o executável para uic.exe. Em seguida, substitua -o por uic.exe no diretório de bin QT (uic.exe não existe no pyqt como eu sei). Você deve ter cuidado com os argumentos de entrada de uic.exe e sua macro escrita à mão (eles devem combinar).

Eu acho que seu programa precisará conhecer o caminho de Python (para usar o Pyuic). Se você estiver usando o Windows, poderá obter o caminho do registro.