Pythonando

Dialogs em PySide ( Parte 2 )

2011-09-25T05:43:00.000-07:00

QtGui.QColorDialog

O QtGui.QColorDialog fornece um widget de dialog para selecionar cores.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we select a color value
from the QtGui.QColorDialog and change the background
color of a QtGui.QFrame widget. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):      

        col = QtGui.QColor(0, 0, 0) 

        self.btn = QtGui.QPushButton('Dialog', self)
        self.btn.move(20, 20)

        self.btn.clicked.connect(self.showDialog)

        self.frm = QtGui.QFrame(self)
        self.frm.setStyleSheet("QWidget { background-color: %s }" 
            % col.name())
        self.frm.setGeometry(130, 22, 100, 100)            
        
        self.setGeometry(300, 300, 250, 180)
        self.setWindowTitle('Color dialog')
        self.show()
        
    def showDialog(self):
      
        col = QtGui.QColorDialog.getColor()

        if col.isValid():
            self.frm.setStyleSheet("QWidget { background-color: %s }"
                % col.name())
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

O exemplo de aplicação mostra um botão e um QtGui.QFrame . O fundo widget está definido para a cor preta. Usando o QtGui.QColorDialog , podemos mudar seu fundo.

col = QtGui.QColor(0, 0, 0)

Esta é uma cor inicial do fundo QtGui.QFrame .

col = QtGui.QColorDialog.getColor()

Esta linha irá aparecer o QtGui.QColorDialog .

if col.isValid():
    self.frm.setStyleSheet("QWidget { background-color: %s }"
        % col.name())

Vamos verificar se a cor é válida. Se clicarmos no botão de cancelar, não obteremos cor válida. Se a cor é válida, mudamos a cor de fundo usando a paleta de cores.

Dialogs em PySide ( Parte 1 )

2011-09-25T05:36:00.000-07:00

Janelas de diálogo ou caixas de diálogo são comuns em aplicações GUI moderna. Um diálogo é definido como uma conversa entre duas ou mais pessoas. Em uma aplicação de computador uma caixa de diálogo é uma janela que é utilizada para "conversar" com a aplicação.

Uma caixa de diálogo é usado para entrada de dados, alterar dados, altere as configurações do aplicativo Dialogs etc, são meios importantes de comunicação entre um usuário e um programa de computador.

QtGui.QInputDialog

O QtGui.QInputDialog fornece um diálogo de simples conveniência para obter um valor único de um usuário. O valor de entrada pode ser uma string, um número ou um item de uma lista.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we receive data from
a QtGui.QInputDialog dialog. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):      

        self.btn = QtGui.QPushButton('Dialog', self)
        self.btn.move(20, 20)
        self.btn.clicked.connect(self.showDialog)
        
        self.le = QtGui.QLineEdit(self)
        self.le.move(130, 22)
        
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Input dialog')
        self.show()
        
    def showDialog(self):
        text, ok = QtGui.QInputDialog.getText(self, 'Input Dialog', 
            'Enter your name:')
        
        if ok:
            self.le.setText(str(text))
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

O exemplo tem um botão e uma linha widget de edição. O botão mostra o dialog de entrada para obter valores de texto. O texto digitado será exibido no widget linha de edição.

text, ok = QtGui.QInputDialog.getText(self, 'Input Dialog', 
    'Enter your name:')

Esta linha apresenta o dialog de entrada. A primeira string é o título do dialog, a segunda é uma mensagem na caixa do dialog. A caixa do dialog retorna o texto digitado e um valor booleano. Se clicar no botão ok, o valor booleano seria verdadeiro, falso caso contrário.

if ok:
    self.le.setText(str(text))

O texto que recebemos na caixa de diálogo é definido para o widget linha de edição.

Eventos e Sinais no PySide ( Parte 4 )

2011-09-25T05:25:00.000-07:00

Emitindo Sinais

Objetos criados a partir QtCore.QObject pode emitir sinais. Se clicarmos no botão, um sinal clicked é gerado. No exemplo a seguir veremos, como nós podemos emitir um sinal qualquer.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we show how to emit a
signal. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Communicate(QtCore.QObject):
    
    closeApp = QtCore.Signal()

class Example(QtGui.QMainWindow):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):      

        self.c = Communicate()
        self.c.closeApp.connect(self.close)       
        
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Emit signal')
        self.show()
        
    def mousePressEvent(self, event):
        
        self.c.closeApp.emit()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Criamos um novo sinal chamado closeApp . Este sinal é emitido, quando o mouse é pressionado. O sinal é conectado ao close() slot do QtGui.QMainWindow .

class Communicate(QtCore.QObject):
    
    closeApp = QtCore.Signal()

Nós criamos uma classe com base em uma QtCore.QObject . Ele cria um sinal closeApp quando instanciado.

self.c = Communicate()
self.c.closeApp.connect(self.close)

Nós conectar um close() slot do QtGui.QMainWindow ao sinal closeApp.

def mousePressEvent(self, event):
    
    self.c.closeApp.emit()

Quando clicamos na janela com o mouse, o closeApp sinal é emitido.

Eventos e Sinais no PySide ( Parte 3 )

2011-09-25T05:20:00.000-07:00

Remetente evento

Às vezes é conveniente saber, que widget é o remetente de um sinal. Para isso, o PySide tem um método sender().

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we determine the event sender
object.

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QMainWindow):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):      

        btn1 = QtGui.QPushButton("Button 1", self)
        btn1.move(30, 50)

        btn2 = QtGui.QPushButton("Button 2", self)
        btn2.move(150, 50)
      
        btn1.clicked.connect(self.buttonClicked)            
        btn2.clicked.connect(self.buttonClicked)
        
        self.statusBar()
        
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Event sender')
        self.show()
        
    def buttonClicked(self):
      
        sender = self.sender()
        self.statusBar().showMessage(sender.text() + ' was pressed')
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Nós temos dois botões em nosso exemplo. No método buttonClicked() nós determinamos que nós temos um botão clicado chamando método sender().

btn1.clicked.connect (self.buttonClicked)            
 btn2.clicked.connect (self.buttonClicked)

Ambos os botões estão ligados ao mesmo slot.

def buttonClicked(self):
  
    sender = self.sender()
    self.statusBar().showMessage(sender.text() + ' was pressed')

Nós determinamos a fonte do sinal chamando o método sender(). Na barra de status do pedido, vamos mostrar o Label do botão sendo pressionado.

Eventos e Sinais no PySide ( Parte 2 )

2011-09-25T05:15:00.000-07:00

Reimplementar manipulador de eventos

Eventos em PySide são processados, muitas vezes por reimplementação de manipuladores de eventos.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we reimplement an 
event handler. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):      
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Event handler')
        self.show()
        
    def keyPressEvent(self, e):
        
        if e.key() == QtCore.Qt.Key_Escape:
            self.close()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Em nosso exemplo, vamos reimplementar o keyPressEvent() manipulador de eventos.

def keyPressEvent(self, e):
    
    if e.key() == QtCore.Qt.Key_Escape:
        self.close()

Se clicarmos no botão de escape, o aplicativo é encerrado.

Eventos e Sinais no PySide ( Parte 1 )

2011-09-25T05:08:00.000-07:00

Nesta parte do tutorial de programação PySide, vamos explorar os eventos e sinais que ocorrem em aplicações.

Eventos

Os eventos são uma parte importante em qualquer programa GUI. Eventos são gerados por usuários ou pelo sistema. Quando chamamos a aplicação com o método exec_(), a aplicação entra no loop principal. O loop principal obtém eventos e os envia para os objetos. PySide tem um sinal único e mecanismo de slot.

Todas as aplicações GUI são event-driven. Uma aplicação reage a diferentes tipos de eventos que são gerados durante a sua vida. Eventos são gerados principalmente pelo usuário de um aplicativo. Mas eles podem ser gerados por outros meios também. por exemplo, ligação à Internet, gerenciador de janelas, timer. No modelo de evento, há três participantes:

fonte de evento
objeto de evento
destino do evento

A origem do evento é o objeto cujo estado muda. Ele gera eventos. O objeto de evento (Event) encapsula as mudanças de estado na origem do evento. O destino do evento é o objeto que quer ser notificado.

Sinais e slots são usados para comunicação entre objetos. Um sinal é emitido quando um determinado evento ocorre. Um slot pode ser qualquer callable Python. Um slot é chamado quando um sinal conectado a ele é emitido.

Sinais e Slots

Este é um exemplo simples, demonstrando sinais e slots em PySide.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we connect a signal
of a QtGui.QSlider to a slot 
of a QtGui.QLCDNumber. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        lcd = QtGui.QLCDNumber(self)
        sld = QtGui.QSlider(QtCore.Qt.Horizontal, self)

        vbox = QtGui.QVBoxLayout()
        vbox.addWidget(lcd)
        vbox.addWidget(sld)

        self.setLayout(vbox)
        sld.valueChanged.connect(lcd.display)
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Signal & slot')
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

No nosso exemplo, vamos mostrar uma QtGui.QLCDNumber e um QtGui.QSlider .Nós mudamos o número lcd com o slider .

sld.valueChanged.connect (lcd.display)

Aqui nós ligar um valueChanged sinal do controle do slider para a display do slot do número lcd.

O remetente é um objeto que emite um sinal. O receptor é o objeto, que recebe o sinal. O slot é o método, que reage ao sinal.

Gerenciamento de layout em PySide ( Parte 4 )

2011-09-24T12:46:00.000-07:00

Exemplo de revisão

Widgets podem abranger várias colunas ou linhas em uma grade. O exemplo a seguir, ilustra melhor isso.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we create a bit
more complicated window layout using
the QGridLayout manager. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        title = QtGui.QLabel('Title')
        author = QtGui.QLabel('Author')
        review = QtGui.QLabel('Review')

        titleEdit = QtGui.QLineEdit()
        authorEdit = QtGui.QLineEdit()
        reviewEdit = QtGui.QTextEdit()

        grid = QtGui.QGridLayout()
        grid.setSpacing(10)

        grid.addWidget(title, 1, 0)
        grid.addWidget(titleEdit, 1, 1)

        grid.addWidget(author, 2, 0)
        grid.addWidget(authorEdit, 2, 1)

        grid.addWidget(review, 3, 0)
        grid.addWidget(reviewEdit, 3, 1, 5, 1)
        
        self.setLayout(grid) 
        
        self.setGeometry(300, 300, 350, 300)
        self.setWindowTitle('Review')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Aqui nós criamos uma janela na qual temos três Labels, duas linhas de texto edições e um widget de edição. O layout é feito com o QtGui.QGridLayout .

grid = QtGui.QGridLayout()
grid.setSpacing(10)

Nós criamos um grid layout e set spacing between entre os widgets.

grid.addWidget(reviewEdit, 3, 1, 5, 1)

Se adicionar um widget a uma grade, podemos oferecer extensão de linha e extensão de coluna do widget. No nosso caso, fazemos o widget reviewEdit abrangendo cinco linhas.

Gerenciamento de layout em PySide ( Parte 3 )

2011-09-24T12:26:00.000-07:00

Grid layout

A classe de layout mais universal em PySide é o grid layout. Este layout divide o espaço em linhas e colunas. Para criar um grid layout, usamos o a classe QtGui.QGridLayout.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we create a skeleton
of a calculator using a QGridLayout.

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        names = ['Cls', 'Bck', '', 'Close', '7', '8', '9', '/',
                '4', '5', '6', '*', '1', '2', '3', '-',
                '0', '.', '=', '+']

        grid = QtGui.QGridLayout()

        j = 0
        pos = [(0, 0), (0, 1), (0, 2), (0, 3),
                (1, 0), (1, 1), (1, 2), (1, 3),
                (2, 0), (2, 1), (2, 2), (2, 3),
                (3, 0), (3, 1), (3, 2), (3, 3 ),
                (4, 0), (4, 1), (4, 2), (4, 3)]

        for i in names:
            button = QtGui.QPushButton(i)
            if j == 2:
                grid.addWidget(QtGui.QLabel(''), 0, 2)
            else: grid.addWidget(button, pos[j][0], pos[j][1])
            j = j + 1

        self.setLayout(grid)   
        
        self.move(300, 150)
        self.setWindowTitle('Calculator')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

No nosso exemplo, criamos uma grade de botões. Para preencher uma lacuna, e também adicionamos um QtGui.QLabel widget.

grid = QtGui.QGridLayout()

Aqui nós criamos um grid layout.

if j == 2:
    grid.addWidget(QtGui.QLabel(''), 0, 2)
else: grid.addWidget(button, pos[j][0], pos[j][1])

Para adicionar um widget a uma grade, chamamos de método addWidget(). Os argumentos são o widget, a linha e o número da coluna.

Gerenciamento de layout em PySide ( Parte 2 )

2011-09-24T12:19:00.000-07:00

Box Layout

Já por sua vez, o gerenciamento de layout com as classes layout é muito mais flexível e prático. É a maneira preferida para colocar widgets em uma janela. As classes básicas de layout são QtGui.QHBoxLayout e QtGui.QVBoxLayout . Eles alinham os widgets horizontalmente e verticalmente.

Imagine que queria colocar dois botões no canto inferior direito. Para criar esse layout , vamos usar uma caixa horizontal e um vertical. Para criar o espaço necessário, iremos adicionar um stretch factor.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

In this example, we position two push
buttons in the bottom-right corner 
of the window. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        okButton = QtGui.QPushButton("OK")
        cancelButton = QtGui.QPushButton("Cancel")

        hbox = QtGui.QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(okButton)
        hbox.addWidget(cancelButton)

        vbox = QtGui.QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(hbox)
        
        self.setLayout(vbox)    
        
        self.setGeometry(300, 300, 300, 150)
        self.setWindowTitle('Absolute')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

O exemplo coloca dois botões no canto inferior direito da janela. Neste caso, nós usamos as QtGui.HBoxLayout e QtGui.QVBoxLayout .

okButton = QtGui.QPushButton("OK")
cancelButton = QtGui.QPushButton("Cancel")

Aqui iremos criar dois push buttons..

hbox = QtGui.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(okButton)
hbox.addWidget(cancelButton)

Nós criamos um horizontal box layout. Adicionamos um stretch factor e dois botões. O trecho adiciona um stretchable spacer antes de os dois botões. Isto irá empurrá-los para a direita da janela.

vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)

Para criar o layout necessário, nós colocamos um layout horizontal para uma vertical. O stretch factor na caixa vertical vai empurrar a caixa horizontal com os botões na parte inferior da janela.

self.setLayout(vbox)

E finalmente, vamos definir o layout de base da janela.

Gerenciamento de layout em PySide ( Parte 1 )

2011-09-24T12:07:00.000-07:00

Uma coisa importante em programação GUI é o gerenciamento de layout. Gerenciamento de layout é a maneira como colocamos os widgets na janela. A gestão pode ser feito de duas maneiras. Podemos usar o posicionamento absoluto ou classes layout.

Posicionamento absoluto

O programador especifica a posição eo tamanho de cada elemento em pixels. Quando você usa o posicionamento absoluto, você tem que entender várias coisas.

o tamanho e a posição de um widget não mudam se você redimensionar uma janela
aplicativos podem parecer diferentes em várias plataformas
mudar fontes em seu aplicativo pode estragar o layout
se você decidir mudar seu layout, você deve refazer completamente o seu layout, e será tedioso e demorado

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This example shows three labels on a window
using absolute positioning. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        label1 = QtGui.QLabel('Zetcode', self)
        label1.move(15, 10)

        label2 = QtGui.QLabel('tutorials', self)
        label2.move(35, 40)
        
        label3 = QtGui.QLabel('for programmers', self)
        label3.move(55, 70)        
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Absolute')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Nós simplesmente chamar o move() método para posicionar nossos widgets. No nosso caso estes elementos são rótulos. Nós posicioná-los, fornecendo as coordenadas x e y. O início do sistema de coordenadas está no canto superior esquerdo. Os valores de x cresce da esquerda para a direita. Os valores de y crescem de cima para baixo.

Menus e barras de ferramentas no PySide ( Parte 4 )

2011-09-24T09:02:00.000-07:00

Colocando em conjunto

No último exemplo desta seção, vamos criar uma barra de menu barra de ferramentas, e uma barra de status. Vamos também criar um widget central.

#!/usr/bin/python
 # -*- coding: utf-8 -*-

 """
 ZetCode PySide tutorial 

 This program creates a skeleton of
 a classic GUI application with a menubar,
 toolbar, statusbar and a central widget. 

 author: Jan Bodnar
 website: zetcode.com 
 last edited: August 2011
 """

 import sys
 from PySide import QtGui

 class Example(QtGui.QMainWindow):
    
     def __init__(self):
         super(Example, self).__init__()
        
         self.initUI()
        
     def initUI(self):               
        
         textEdit = QtGui.QTextEdit()
         self.setCentralWidget(textEdit)

         exitAction = QtGui.QAction('Exit', self)
         exitAction.setShortcut('Ctrl+Q')
         exitAction.setStatusTip('Exit application')
         exitAction.triggered.connect(self.close)

         self.statusBar()

         menubar = self.menuBar()
         fileMenu = menubar.addMenu('&File')
         fileMenu.addAction(exitAction)

         toolbar = self.addToolBar('Exit')
         toolbar.addAction(exitAction)
        
         self.setGeometry(300, 300, 350, 250)
         self.setWindowTitle('Main window')    
         self.show()
        
        
 def main():
    
     app = QtGui.QApplication(sys.argv)
     ex = Example()
     sys.exit(app.exec_())


 if __name__ == '__main__':
     main()

Este exemplo de código cria um esqueleto de uma aplicação GUI clássica com uma barra de ferramentas menubar, e uma barra de status.

TextEdit QtGui.QTextEdit = ()
 self.setCentralWidget (TextEdit)

Aqui nós criamos um texto widget de edição. Nós configuramos para ser o widget central do QtGui.QMainWindow . O Widget central ocupará todo o espaço vazio que é deixado.

Menus e barras de ferramentas no PySide ( Parte 3 )

2011-09-23T23:24:00.000-07:00

Toolbar - Barra de ferramentas

Grupo de menus que todo aplicativo usa praticamente. Barras de ferramentas fornecem acesso rápido aos comandos mais utilizados.

#!/usr/bin/python
 # -*- coding: utf-8 -*-

 """
 ZetCode PySide tutorial 

 This program creates a toolbar.

 author: Jan Bodnar
 website: zetcode.com 
 last edited: August 2011
 """

 import sys
 from PySide import QtGui

 class Example(QtGui.QMainWindow):
    
     def __init__(self):
         super(Example, self).__init__()
        
         self.initUI()
        
     def initUI(self):               
        
         exitAction = QtGui.QAction(QtGui.QIcon('exit24.png'), 'Exit', self)
         exitAction.setShortcut('Ctrl+Q')
         exitAction.triggered.connect(self.close)
        
         self.toolbar = self.addToolBar('Exit')
         self.toolbar.addAction(exitAction)
        
         self.setGeometry(300, 300, 350, 250)
         self.setWindowTitle('Toolbar')    
         self.show()
        
        
 def main():
    
     app = QtGui.QApplication(sys.argv)
     ex = Example()
     sys.exit(app.exec_())


 if __name__ == '__main__':
     main()

No exemplo acima, criamos uma barra de ferramentas simples.

exitAction = QtGui.QAction (QtGui.QIcon ('exit24.png'), 'Exit', self)
exitAction.setShortcut ('Ctrl + Q')
exitAction.triggered.connect (self.close)

Semelhante ao exemplo menubar acima, criamos um objeto da ação. O objeto tem um Label ( nome ) que indica ícone ( icon ), e um shorcut. Um método de encerramento da QtGui.QMainWindow está ligado ao sinal exitAction.

self.toolbar self.addToolBar = ('Exit')
 self.toolbar.addAction (exitAction)

E como resultado, teremos isto:

Menus e barras de ferramentas no PySide ( Parte 2 )

2011-09-23T23:13:00.000-07:00

Menubar

A barra de menu é uma parte comum de uma aplicação GUI. É um grupo de comandos localizados em vários menus.

#! / Usr / bin / python
 # -*- Coding: utf-8 -*-

 "" "
 ZetCode PySide tutorial 

 Este programa cria um menu.

 autor: Jan Bodnar
 Web site: zetcode.com 
 Ultima edição: agosto 2011
 "" "

 import sys
 from PySide import QtGui

 Exemplo de classe (QtGui.QMainWindow):
    
     def __init__ (self):
         super (auto Exemplo). __init__ ()
        
         self.initUI ()
        
     def initUI (self):               
        
         exitAction = QtGui.QAction (QtGui.QIcon ('exit.png'), '& Exit ", self)
         exitAction.setShortcut ('Ctrl + Q')
         exitAction.setStatusTip ('Exit pedido »)
         exitAction.triggered.connect (self.close)

         self.statusBar ()

         menubar = self.menuBar ()
         fileMenu menubar.addMenu = ('& File')
         fileMenu.addAction (exitAction)
        
         self.setGeometry (300, 300, 250, 150)
         self.setWindowTitle ('Menu')    
         self.show ()
        
        
 def main ():
    
     app QtGui.QApplication = (sys.argv)
     Exemplo ex = ()
     sys.exit (app.exec_ ())


 if __name__ == '__main__':
     main ()

No exemplo acima, criamos um menubar com um menu. Este menu vai conter uma ação que irá encerrar o aplicativo se selecionado. A barra de status é criada também. A ação será acessível com o atalho Ctrl + Q.

exitAction = QtGui.QAction (QtGui.QIcon ('exit.png'), '& Exit ", self)
exitAction.setShortcut ('Ctrl + Q')
exitAction.setStatusTip ('Exit pedido »)

O PySide QtGui.QAction é uma abstração para as ações realizadas com uma barra de ferramentas menubar, ou com uma tecla atalho personalizada. Na primeira linha, criamos uma ação, com um ícone específico e um Label 'Exit'.

Além disso, um atalho é definido para esta ação. A terceira linha cria um status tip, que é mostrado na barra de status, quando houver o ponteiro do mouse sobre o item de menu.

exitAction.triggered.connect (self.close)

Quando selecionar esta ação em particular, um sinal será acionado. O sinal é conectado ao método close() do QtGui.QMainWindow widget. Isso encerra a aplicação.

menubar = self.menuBar ()

Uma barra de menu é criada.

fileMenu menubar.addMenu = ('& File')
 fileMenu.addAction (exitAction)

Nós criamos menu &File com o método addMenu() do objeto menubar. Nós adicionamos a ação criada anteriormente para o File.

Menus e barras de ferramentas no PySide ( Parte 1 )

2011-09-23T23:02:00.000-07:00

Nesta parte do tutorial sobre o PySide, vamos criar menus e barras de ferramentas. Um menu é um grupo de comandos localizados em um menubar. A barra de ferramentas tem botões com os comandos comuns na aplicação.

MainWindow - Janela Principal

O QtGui.QMainWindow é uma classe fornece uma janela principal do aplicativo. Isto permite que possamos criar o esqueleto da aplicação clássica com uma barra de status da barra de ferramentas e uma barra de menu.

Statusbar

A barra de status é um widget que é usado para exibir informações de status.

#! / Usr / bin / python
 # -*- Coding: utf-8 -*-

 "" "
 ZetCode PySide tutorial 

 Este programa cria uma barra de status.

 autor: Jan Bodnar
 Web site: zetcode.com 
 Ultima edição: agosto 2011
 "" "

 import sys
 from PySide import QtGui

 Exemplo de classe (QtGui.QMainWindow):
    
     def __init__ (self):
         super (auto Exemplo). __init__ ()
        
         self.initUI ()
        
     def initUI (self):               
        
         self.statusBar (). ShowMessage ('Ready')
        
         self.setGeometry (300, 300, 250, 150)
         self.setWindowTitle ('Statusbar')    
         self.show ()
        
        
 def main ():
    
     app QtGui.QApplication = (sys.argv)
     Exemplo ex = ()
     sys.exit (app.exec_ ())


 if __name__ == '__main__':
     main ()

A barra de status é criado com a ajuda do QtGui.QMainWindow widget.

self.statusBar (). ShowMessage ('Ready')

Para obter a barra de status, chamamos o método statusBar() do da classe QtGui.QMainWindow. A primeira chamada do método cria uma barra de status. Chamadas subseqüentes retornam o objeto do status. O showMessage() exibe uma mensagem na statusbar.

PySide - Exemplo Simples ( Parte 6 )

2011-09-18T15:51:00.000-07:00

O script a seguir mostra, como podemos por no centro do desktop uma janela.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This program centers a window 
on the screen. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):               
        
        self.resize(250, 150)
        self.center()
        
        self.setWindowTitle('Center')    
        self.show()
        
    def center(self):
        
        qr = self.frameGeometry()
        cp = QtGui.QDesktopWidget().availableGeometry().center()
        qr.moveCenter(cp)
        self.move(qr.topLeft())
        
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Centralizar uma janela na tela.

self.center()

O código que irá centrar a janela é colocado com o método center().

qr = self.frameGeometry()

Obtemos um retângulo especificando a geometria da janela principal. Isto inclui qualquer moldura da janela.

cp = QtGui.QDesktopWidget().availableGeometry().center()

Nós descobrimos a resolução da tela do nosso monitor. E da presente resolução, obtemos o ponto central.

qr.moveCenter(cp)

Agora vamos definir o centro do retângulo ao centro da tela. Tamanho do retângulo é alterado.

self.move(qr.topLeft())

Movemos o ponto superior esquerdo da janela do aplicativo para o ponto superior esquerdo do retângulo qr, assim, centralizamos a janela na nossa tela.

PySide - Exemplo Simples ( Parte 5 )

2011-09-18T14:57:00.000-07:00

Por padrão, se clicar sobre o botão x na barra de título, o QtGui.QWidget será fechado. Às vezes queremos modificar esse comportamento padrão. Por exemplo, se temos um arquivo aberto em um editor para o qual precisaremos fazer algumas mudanças. É sensato ter um sistema para mostrar uma caixa de mensagem para confirmar a ação.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This program shows a confirmation 
message box when we click on the close
button of the application window. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):               
        
        self.setGeometry(300, 300, 250, 150)        
        self.setWindowTitle('Message box')    
        self.show()
        
    def closeEvent(self, event):
        
        reply = QtGui.QMessageBox.question(self, 'Message',
            "Are you sure to quit?", QtGui.QMessageBox.Yes | 
            QtGui.QMessageBox.No, QtGui.QMessageBox.No)

        if reply == QtGui.QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()        
        
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Se fechar o QtGui.QWidget, o QCloseEvent é gerado. Para modificar o comportamento widget precisamos reimplementar o manipulador de eventos closeEvent().

reply = QtGui.QMessageBox.question(self, 'Message',
    "Are you sure to quit?", QtGui.QMessageBox.Yes | 
    QtGui.QMessageBox.No, QtGui.QMessageBox.No)

Vamos mostrar uma caixa de mensagem com dois botões. Sim e Não. A primeira seqüência aparece na barra de título. A segunda string é o texto da mensagem exibida pelo diálogo. O terceiro argumento especifica a combinação de botões que aparecem na caixa de diálogo. O último parâmetro é o botão padrão. É o botão, que, inicialmente, o foco do teclado. O valor de retorno é armazenado na variável de resposta.

if reply == QtGui.QMessageBox.Yes:
    event.accept()
else:
    event.ignore()

Aqui nós testamos o valor de retorno. Se clicarmos no botão Sim, aceitamos o evento que leva ao encerramento do widget e para o término da aplicação. Caso contrário, ignorar o evento close.

PySide - Exemplo Simples ( Parte 4 )

2011-09-18T14:25:00.000-07:00

A maneira óbvia como fechar uma janela é clicar sobre a marca x na barra de título. No próximo exemplo, vamos mostrar, como podemos fechar nossos programas de forma diferente. Faremos um breve resumo sobre slots e sinais.

O seguinte é o construtor de um QtGui.QPushButton, que vamos usar em nosso exemplo.

class PySide.QtGui.QPushButton(text[, parent=None])

O parâmetro de texto é um texto que será exibido no botão. O pai é o widget, no qual colocamos a nossa botão. No nosso caso será um QtGui.QWidget.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This program creates a quit
button. When we press the button,
the application terminates. 

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui, QtCore

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):               
        
        qbtn = QtGui.QPushButton('Quit', self)
        qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)
        qbtn.resize(qbtn.sizeHint())
        qbtn.move(50, 50)       
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Quit button')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Neste exemplo, criamos um botão de quit. Ao clicar na janela, o aplicativo é encerrado.

qbtn = QtGui.QPushButton('Quit', self)

Nós criamos um botão. O botão é uma instância da classe QtGui.QPushButton. O primeiro parâmetro do construtor é o rótulo do botão. O segundo parâmetro é o widget pai. O widget é o widget pai do Exemple, que é um QtGui.QWidget por herança.

qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)

O sistema de processamento de eventos em PySide é construído com o sinal e mecanismo de slot. Se clicarmos no botão, um sinal é emitido por ter clicado. O slot pode ser um slot Qt ou qualquer. O QtCore.QCoreApplication contém o ciclo de eventos principais. Ele processa e despacha todos os eventos. O método instance() nos dá a instância atual.

Note-se que QtCore.QCoreApplication é criado com o QtGui.QApplication. O sinal clicado está ligado ao método quit(), que encerra o aplicativo. A comunicação é feita entre dois objetos. O emissor e o receptor. O remetente é o botão, o receptor é o objeto de aplicativo.

PySide - Exemplo Simples ( Parte 3 )

2011-09-18T14:00:00.000-07:00

Nós podemos fornecer um balão de ajuda para qualquer um dos nossos widgets.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This example shows a tooltip on 
a window and a button

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
        
        self.setToolTip('This is a <b>QWidget</b> widget')
        
        btn = QtGui.QPushButton('Button', self)
        btn.setToolTip('This is a <b>QPushButton</b> widget')
        btn.resize(btn.sizeHint())
        btn.move(50, 50)       
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Tooltips')    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Neste exemplo, vamos mostrar uma dica para um dois widgets PySide.

QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))

Esse método estático define uma fonte usada para processar as dicas. Usamos uma fonte SansSerif 10px.

self.setToolTip('This is a <b>QWidget</b> widget')

Para criar um tooltip, chamamos o método setTooltip(). Podemos usar também, a formatação rich text.

btn = QtGui.QPushButton('Button', self)
btn.setToolTip('This is a <b>QPushButton</b> widget')

Nós criamos um widget botão e definimos suas propriedades.

btn.resize(btn.sizeHint())
btn.move(50, 50)

O botão está sendo redimensionado e movido sobre a janela. O método sizeHint() dá o tamanho recomendado para o botão.

PySide - Exemplo Simples ( Parte 2 )

2011-09-18T13:38:00.000-07:00

O ícone é uma pequena imagem, que normalmente é exibido no canto superior esquerdo da barra de título. É também visível na barra de tarefas. No exemplo a seguir vamos mostrar, como o fazemos em PySide. Vamos também apresentar alguns novos métodos.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PySide tutorial 

This example shows an icon
in the titlebar of the window.

author: Jan Bodnar
website: zetcode.com 
last edited: August 2011
"""

import sys
from PySide import QtGui

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):
        
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Icon')
        self.setWindowIcon(QtGui.QIcon('web.png'))        
    
        self.show()
        
def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

O exemplo anterior foi codificado em um estilo processual. Linguagem de programação Python suporta tanto processuais e estilos de programação orientada a objeto. Programação em PySide significa programação em OOP.

class Example(QtGui.QWidget):
    
    def __init__(self):
        super(Example, self).__init__()

As três coisas mais importantes da programação orientada a objetos são classes, dados e métodos. Aqui nós criamos uma nova classe chamada Exemple. Exemple é uma classe que herda a classe QtGui.QWidget. Isto significa que devemos chamar dois construtores. O primeiro para a classe Exemple e o segundo para a classe herdada no caso, o QtGui.QWidget. O segundo é chamado com o método super().

self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Icon')
self.setWindowIcon(QtGui.QIcon('web.png'))

Todos os três métodos foram herdados da classe QtGui.QWidget. O setGeometry() faz duas coisas. Ele localiza a posição da janela na tela e define o tamanho da janela. Os dois primeiros parâmetros são as posições x e y da janela. A terceira é a largura e o quarto é a altura da janela.

O último método define o ícone do aplicativo. Para fazer isso, criamos um objeto QtGui.QIcon. O QtGui.QIcon recebe o caminho para o nosso ícone será exibido.

def main():
    
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

Vamos colocar o código de inicialização dentro do método main(). Este é um código de linguagem Python.

PySide - Exemplo Simples ( Parte 1 )

2011-09-18T13:17:00.000-07:00

PySide é um kit de ferramentas de alto nível. Se quisermos código em um kit de ferramentas de nível inferior, o seguinte exemplo de código poderia facilmente ter dezenas de linhas mas evitamos isso importando módulos do PySide:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# simple.py

import sys
from PySide import QtGui

app = QtGui.QApplication(sys.argv)

wid = QtGui.QWidget()
wid.resize(250, 150)
wid.setWindowTitle('Simple')
wid.show()

sys.exit(app.exec_())

O código acima mostra uma pequena janela na tela.

import sys
from PySide import QtGui

Aqui nós fornecemos as importações necessárias. Os widgets básicos GUI estão localizadas no módulo QtGui.

app = QtGui.QApplication(sys.argv)

O objeto de aplicativo está localizado no módulo QtGui. O parâmetro sys.argv é uma lista de argumentos da linha de comando.

wid = QtGui.QWidget()

O Widget de QWidget é a classe base de todos os objetos de interface do usuário PySide. Nós fornecemos o construtor padrão para QWidget. O construtor padrão não tem pai. Um widget com nenhum pai é chamado de janela.

wid.resize(250, 150)

O resize () método redimensiona o widget. É de largura e 150px 250px.

wid.setWindowTitle('Simple')

Aqui vamos definir o título para a nossa janela. O título é mostrado na barra de título.

wid.show()

O método show () exibe o widget na tela.

sys.exit(app.exec_())

Finalmente, entramos no mainloop da aplicação. A manipulação de eventos começa a partir deste ponto. O mainloop recebe eventos do sistema de janelas e despacha-los para o mini-aplicações. O mainloop termina, se nós chamamos o método exit(). O sys.exit() método que garante uma saída limpa. O ambiente será informado, como o aplicativo terminou.

Você quer saber porque o método exec_() tem um sublinhado? Tudo tem um significado. Isto se deve ao fato de que exec é uma palavra reservada do python. E assim, exec_() foi utilizado.

PySide - Introdução

2011-09-18T12:56:00.000-07:00

PySide é uma biblioteca Python multi-plataforma para criar interfaces gráficas. É uma ligação Python ao framework Qt. A biblioteca é uma das bibliotecas mais poderosas GUI ( Guide User Interface ). O site oficial do projeto PySide é pyside.org. E é desenvolvido pela Nokia.

PySide é implementado como um conjunto de módulos Python. Atualmente ele tem 15 módulos. Estes módulos fornecem ferramentas poderosas para trabalhar com GUI, multimídia, documentos XML, de rede ou bancos de dados. Em nosso tutorial, vamos trabalhar com dois desses módulos. O QtGui e os módulos QtCore.

O módulo QtCore contém a funcionalidade não-gui core. Este módulo é utilizado para trabalhar com o tempo, arquivos e diretórios, vários tipos de dados, fluxos, urls, fios ou processos. O módulo QtGui contém os componentes gráficos e classes relacionadas. Estas incluem, por exemplo botões, janelas, barras de status, barras de ferramentas, sliders, bitmaps, cores, fontes, etc...

PySide foi desenvolvido pela Nokia uma vez que o dono do toolkit Qt (PyQt), não conseguiram chegar a um acordo com a Computing Riverbank para incluir a LGPL como licença alternativa. PySide tem uma alta compatibilidade com a API do PyQt4, de modo a migração para o PySide não é difícil. Além do mais, sua documentação é mais elaborada e de fácil entendimento.

Você pode acessar sua documentação no site: http://www.pyside.org/docs/pyside/contents.html

No Linux para instalar, basta digitar no Terminal:

Sudo apt-add-repositório ppa: pyside
Sudo apt-get update
Sudo apt-get install python-pyside

PyQt4 - Drag and Drop ( Parte 2 )

2011-09-15T23:56:00.000-07:00

No exemplo a seguir, vamos demonstrar, como arrastar e soltar um widget botão.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PyQt4 tutorial

In this program, we can press
on a button with a left mouse
click or drag and drop the button 
with  the right mouse click. 

author: Jan Bodnar
website: zetcode.com
last edited: December 2010
"""

import sys
from PyQt4 import QtGui
from PyQt4 import QtCore


class Button(QtGui.QPushButton):
  
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)

    def mouseMoveEvent(self, e):

        if e.buttons() != QtCore.Qt.RightButton:
            return

        mimeData = QtCore.QMimeData()

        drag = QtGui.QDrag(self)
        drag.setMimeData(mimeData)
        drag.setHotSpot(e.pos() - self.rect().topLeft())

        dropAction = drag.start(QtCore.Qt.MoveAction)


    def mousePressEvent(self, e):
      
        QtGui.QPushButton.mousePressEvent(self, e)
        if e.button() == QtCore.Qt.LeftButton:
            print 'press'


class Example(QtGui.QWidget):
  
    def __init__(self):
        super(Example, self).__init__()

        self.initUI()
        
    def initUI(self):

        self.setAcceptDrops(True)

        self.button = Button('Button', self)
        self.button.move(100, 65)

        self.setWindowTitle('Click or Move')
        self.setGeometry(300, 300, 280, 150)

    def dragEnterEvent(self, e):
      
        e.accept()

    def dropEvent(self, e):

        position = e.pos()
        self.button.move(position)

        e.setDropAction(QtCore.Qt.MoveAction)
        e.accept()

def main():
  
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    ex.show()
    app.exec_()  


if __name__ == '__main__':
    main()

No nosso exemplo de código, temos um QPushButton na janela. Se clicarmos no botão com um botão esquerdo do mouse, imprimirá 'pressione' o console. Com o botão direito mover o botão, nós realizaremos assim uma operação de arrastar e soltar sobre o widget botão.

class Button(QtGui.QPushButton):
  
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)

Criamos uma classe Button, que deriva do QPushButton. Nós vamos entao reimplementar também dois métodos do QPushButton. mouseMoveEvent() e mousePressEvent(). O mouseMoveEvent() é o lugar, onde a operação de arrastar e soltar começa.

if event.buttons() != QtCore.Qt.RightButton:
    return

Aqui decidimos, que podemos realizar drag & drop apenas com um botão direito do mouse. O botão esquerdo do mouse é reservado para clicar no botão.

mimeData = QtCore.QMimeData()

drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - self.rect().topLeft())

Aqui criamos um objeto QDrag.

dropAction = drag.start(QtCore.Qt.MoveAction)

O método start() do objeto arrastar começa a arrastar e soltar.

def mousePressEvent(self, e):
  
    QtGui.QPushButton.mousePressEvent(self, e)
    if e.button() == QtCore.Qt.LeftButton:
        print 'press'

Repare que nós chamamos de método mousePressEvent() sobre o pai também. Caso contrário, não veríamos o botão sendo pressionado.

position = e.pos()

self.button.move(position)

O método dropEvent() é o que acontece depois que soltar o botão do mouse e concluir a operação de drop. Nós descobrimos então a posição atual do ponteiro do mouse.

e.setDropAction(QtCore.Qt.MoveAction)
e.accept()

Nós especificamos o tipo da ação de soltar. No nosso caso, é uma ação de movimento.

PyQt4 - Drag and Drop ( Parte 1 )

2011-09-15T20:04:00.000-07:00

Nesta parte do tutorial PyQt4, vamos falar sobre as operações de drag & drop.

Em interfaces de computador gráfica do usuário, drag-and-drop é a ação (ou suporte para a ação de) clicando em um objeto virtual e arrastando-o para um local diferente ou em outro objeto virtual. Em geral, ele pode ser usado para invocar diversos tipos de ações, ou criar vários tipos de associações entre dois objetos abstratos. (Wikipedia)

Arrastar e soltar funcionalidade é um dos aspectos mais visíveis da interface gráfica do usuário. Operação arrastar e soltar permite aos usuários fazer coisas complexas de forma intuitiva.

Normalmente, podemos arrastar e soltar duas coisas. Dados ou alguns objetos gráficos. Se arrastar uma imagem de uma aplicação para outra, arraste e solte dados binários. Se arrastar uma aba no Firefox e movê-lo para outro lugar, temos de arrastar e soltar um componente gráfica.

Simples arrastar e soltar

No primeiro exemplo, teremos uma QLineEdit e um QPushButton. Vamos arrastar texto normal a partir da linha de edição widget e solte-o widget botão.

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
ZetCode PyQt4 tutorial

This is a simple drag and
drop example. 

author: Jan Bodnar
website: zetcode.com
last edited: December 2010
"""

import sys
from PyQt4 import QtGui

class Button(QtGui.QPushButton):
  
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)
        
        self.setAcceptDrops(True)

    def dragEnterEvent(self, e):
      
        if e.mimeData().hasFormat('text/plain'):
            e.accept()
        else:
            e.ignore() 

    def dropEvent(self, e):
        self.setText(e.mimeData().text()) 


class Example(QtGui.QWidget):
  
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):

        edit = QtGui.QLineEdit('', self)
        edit.setDragEnabled(True)
        edit.move(30, 65)

        button = Button("Button", self)
        button.move(190, 65)
        
        self.setWindowTitle('Simple Drag & Drop')
        self.setGeometry(300, 300, 300, 150)


def main():
  
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    ex.show()
    app.exec_()  
  

if __name__ == '__main__':
    main()

Simples arrastar e soltar.

class Button(QtGui.QPushButton):
  
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)

A fim de soltar o texto no widget QPushButton, devemos reimplementar alguns métodos. Então, criamos a nossa própria classe Button, que vai herdar da classe QPushButton.

self.setAcceptDrops(True)

Nós permitimos evento drop para o widget.

def dragEnterEvent(self, e):
  
    if e.mimeData().hasFormat('text/plain'):
        e.accept()
    else:
        e.ignore()

Primeiro vamos reimplementar o método dragEnterEvent(). Informamos sobre o tipo de dados, vamos aceitar. No nosso caso, é texto puro.

def dropEvent(self, e):
    self.setText(e.mimeData().text())

Ao reimplementar o método dropEvent(), vamos definir o que vamos fazer sobre o evento drop. Aqui nós mudar o texto do widget botão.

edit = QtGui.QLineEdit('', self)
edit.setDragEnabled(True)

O Widget QLineEdit tem um suporte embutido para operações de arrastar. Tudo o que precisamos fazer é chamar o método setDragEnabled() para ativá-lo.

PyQt4 - Widgets ( Parte 9 )

2011-09-15T18:32:00.000-07:00

O QComboBox é um widget que permite ao usuário escolher entre uma lista de opções.

#!/usr/bin/python
# -*- coding: utf-8 -*-

# ZetCode PyQt4 tutorial
#
# In this example, we show how to 
# use the QComboBox widget.
# 
# author: Jan Bodnar
# website: zetcode.com
# last edited: December 2010


from PyQt4 import QtGui, QtCore


class Example(QtGui.QWidget):
  
    def __init__(self):
        super(Example, self).__init__()

        self.initUI()


    def initUI(self):

        self.label = QtGui.QLabel("Ubuntu", self)

        combo = QtGui.QComboBox(self)
        combo.addItem("Ubuntu")
        combo.addItem("Mandriva")
        combo.addItem("Fedora")
        combo.addItem("Red Hat")
        combo.addItem("Gentoo")

        combo.move(50, 50)
        self.label.move(50, 150)

        self.connect(combo, QtCore.SIGNAL('activated(QString)'), 
            self.onActivated)

        self.setGeometry(250, 200, 350, 250)
        self.setWindowTitle('QComboBox')

    def onActivated(self, text):
      
        self.label.setText(text)
        self.label.adjustSize()


def main():
  
    app = QtGui.QApplication([])
    ex = Example()
    ex.show()
    app.exec_()    


if __name__ == '__main__':
    main()

O exemplo mostra um QComboBox e um QLabel. A caixa de combinação tem uma lista de seis opções. Estes são os nomes das distros Linux. O Widget de etiqueta mostra a opção selecionada na caixa de combinação.

combo = QtGui.QComboBox(self)
combo.addItem("Ubuntu")
combo.addItem("Mandriva")
combo.addItem("Fedora")
combo.addItem("Red Hat")
combo.addItem("Gentoo")

Nós criamos um widget QComboBox e adicionar cinco opções para ele.

self.connect(combo, QtCore.SIGNAL('activated(QString)'), 
    self.onActivated)

Após uma seleção de itens, chamamos o método onActivated().

def onActivated(self, text):

    self.label.setText(text)
    self.label.adjustSize()

Dentro do método, vamos definir o texto do item escolhido para o widget do rótulo. Nós ajustar o tamanho da etiqueta.

PyQt4 - Widgets ( Parte 8 )

2011-09-15T18:26:00.000-07:00

QSplitter permite ao usuário controlar o tamanho dos widgets filhos, arrastando o limite da hierarquia entre seus filhos. No nosso exemplo, vamos mostrar três widgets QFrame organizados com dois divisores.

#!/usr/bin/python
# -*- coding: utf-8 -*-

# ZetCode PyQt4 tutorial
#
# This example shows
# how to use QSplitter widget.
# 
# author: Jan Bodnar
# website: zetcode.com
# last edited: December 2010


from PyQt4 import QtGui, QtCore


class Example(QtGui.QWidget):
  
    def __init__(self):
        super(Example, self).__init__()

        self.initUI()


    def initUI(self):

        hbox = QtGui.QHBoxLayout(self)

        topleft = QtGui.QFrame(self)
        topleft.setFrameShape(QtGui.QFrame.StyledPanel)
 
        topright = QtGui.QFrame(self)
        topright.setFrameShape(QtGui.QFrame.StyledPanel)

        bottom = QtGui.QFrame(self)
        bottom.setFrameShape(QtGui.QFrame.StyledPanel)

        splitter1 = QtGui.QSplitter(QtCore.Qt.Horizontal)
        splitter1.addWidget(topleft)
        splitter1.addWidget(topright)

        splitter2 = QtGui.QSplitter(QtCore.Qt.Vertical)
        splitter2.addWidget(splitter1)
        splitter2.addWidget(bottom)

        hbox.addWidget(splitter2)
        self.setLayout(hbox)

        self.setWindowTitle('QSplitter')
        QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))
        self.setGeometry(250, 200, 350, 250)
        

def main():

    app = QtGui.QApplication([])
    ex = Example()
    ex.show()
    app.exec_()


if __name__ == '__main__':
    main()

No nosso exemplo temos três widgets frame e dois splitters.

topleft = QtGui.QFrame(self)
topleft.setFrameShape(QtGui.QFrame.StyledPanel)

Usamos uma moldura estilo, a fim de ver os limites entre os widgets QFrame.

splitter1 = QtGui.QSplitter(QtCore.Qt.Horizontal)
splitter1.addWidget(topleft)
splitter1.addWidget(topright)

Nós criamos um widget QSplitter e adicionar dois frames dentro dela.

splitter2 = QtGui.QSplitter(QtCore.Qt.Vertical)
splitter2.addWidget(splitter1)

Podemos também adicionar divisor para outro widget splitter.

QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))

Nós usamos um estilo Cleanlooks. Em alguns estilos os frames não são visíveis.