Gomme et QImage

**electrolover49** · 12/06/2012, 16h16

Envoyé par ashren

Je comprend mieux ce que tu as en tête, pense simplement que les évènements souris/clavier devront être gérés par la QGraphicsScene et non l'ImageView.

Tant mieux si tu comprends ce que je voulais dire.
Pour la gestion des événements, j'y ai déjà pensé effectivement, je suis en train de voir comment implémenter la freehandline, je continue ma spécification et puis après je m'attaquerais au découpage de mon application ^^.

Je tiens encore une fois à te remercier pour ton aide, je travaille en "autoditacte" et parfois ce n'est pas si facile.

**electrolover49** · 13/06/2012, 12h39

Dans un soucis de portabilité, je souhaite découper le code pour cela, j'ai exporté l'Image view et le menu dans des packages.
Cependant, pour imageView, ça marche parfaitement mais j'ai du mal à mettre le menu à part.

Je pense que cela est utile pour découper l'application et avoir un main le plus simple possible .

MainWindow.py

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 
from ImageView.ImageView import ImageView
from Menu.UiMenu import UiMenu
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.image = ImageView(QImage())
        self.resize(500, 300)
        self.setWindowTitle("Image loader")
 
 
 
        """
        Add of scroll bars to see properly the images
        """
        self.area = QScrollArea(self)
        self.area.setWidget(self.image)
        self.area.setWidgetResizable(True)
        self.setCentralWidget(self.area)
 
        #Check Box rub
 
        statusbar = QStatusBar(self)
        self.setStatusBar(statusbar)
        self._ckbox = QCheckBox("Rubber On")
        statusbar.addWidget(self._ckbox)
        if self._ckbox.isChecked():
            self._mode = "rub"
        else :
            self._mode = "select"
        #Init of the boolean to know whether we select or rub
        self.image.mode = self._mode
        self._ckbox.stateChanged.connect(self.__rubberBoxChanged)
    def initMenu(self):
        self.ui = UiMenu()
        self.ui.setupUI(self)
    def __rubberBoxChanged(self, state):
        if self._ckbox.isChecked():
            self._mode = 'rub'
        else:
            self._mode = 'select'
        self.image.mode = self._mode
 
  if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

UiMenu.py

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
# -*- coding: utf-8 -*-
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence,QColor,QCheckBox,QStatusBar,QIcon,\
                         QMessageBox,QImage, QRubberBand, QMainWindow, QAction,\
                         QMenuBar, QFileDialog, QScrollArea,QColorDialog,QPalette,QBrush
from PySide.QtCore import QSize, QRect,QRectF,Qt
 
class UiMenu(QMenuBar):  
    def setupUI(self,QMainWindow):
 
        """
        Adding of actions for the tool bar
        """
        iconToolBar = self.addToolBar("iconBar")
 
        #About 
        _actionAbout = QAction(self)
        _actionAbout.triggered.connect(self.__actionAbout)
 
        _actionAbout.setIcon(QIcon("Pics\info-icon.jpg"))
        _actionAbout.setStatusTip("Pop up the About dialog.")
        iconToolBar.addAction(_actionAbout)
        #Rubber
        _actionRubber = QAction(self)
 
        _actionRubber.setIcon(QIcon("Pics\eraser2.png"))
        _actionRubber.setStatusTip("Enable or Disable eraser tool")
        iconToolBar.addAction(_actionRubber)
 
        #Palette
        _actionPalette = QAction(self)
        _actionPalette.triggered.connect(self.__actionPalette)
        _actionPalette.setIcon(QIcon("Pics\eraser2.png"))
        _actionPalette.setStatusTip("Enable or Disable eraser tool")
        iconToolBar.addAction(_actionPalette)
 
        """
            Add of the Menu which contains all the features like of Open/Save/..
            and the edit options
        """
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        _edit = menu.addMenu("Edit")
        # Menu Open
        _action = QAction('Open', _file,shortcut=QKeySequence.Open)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu Save
        _action = QAction('Save', _file,shortcut=QKeySequence.Save)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu Close
        _action = QAction('Close', _file,shortcut=QKeySequence.Close)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
        #Menu Edit
    def __actionOpen(self):
        _file = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if _file:
            self.image.setWorkingImage(QImage(_file[0]))
        else:
            print "Invalid Image"
 
    def __actionSave(self):
        _file = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        _result = self.image.workingImage().save(_file[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def __actionClose(self):
        self.close()
 
    def __actionPalette(self):
        self._color = QColorDialog.getColor()
        self.palette = QPalette()
        self.palette.setColor(QPalette().NoRole,self._color)
    def getColor(self):
        return self._color
    def setColor(self,colour):
        self._color=colour
        self.update()
    def __actionAbout(self):
        '''Popup a box with about message.'''
        QMessageBox.about(self, "About PySide, Platform and the like",
        """<b> About this program </b> 
                <p>Copyright  2012 Maugin Guillaume. 
                All rights reserved in accordance with
                GPL v2 or later 
                <p>This application can be used for
                displaying OS and platform details.
                <p>Python %s - PySide version %s - Qt version %s on %s""" )
    #Init of the property for mode
    color = property(getColor, setColor)

EDIT : Malgré tout , je n'ai pas l'impression que mon menu s'initialise la fenêtre reste simple sans menu :s

**ashren** · 13/06/2012, 13h05

Bonjour,

pourquoi ne pas faire hériter UiMenu de QMenuBar directement ?

**electrolover49** · 13/06/2012, 13h47

oui, effectivement je vais faire comme cela.
Je pensais qu'hériter de la QMain win serait la meilleure solution finalement non peut-être.
EDIT : Cf.Réponse précédente avec code, si j'ai bien compris.

**ashren** · 13/06/2012, 14h01

Non, ce que je voulais dire c'est hériter de QMenuBar, remplir les action dans le __init__ de cette classe et la traiter comme une QMenuBar normale (qui se remplit toute seule).

Après, ce n'est peut-être pas la meilleure solution de tout séparer.

Il faut aussi penser au moyen que tu va utiliser pour connecter les actions de ton menu aux méthodes de la MainWindow (trouves-tu cela plus simple de garder le code du menu dans ta MainWindow comme avant, ou préfères-tu séparer et exposer les actions à travers ta classe UiMenu afin que ta MainWindow se connecte sur celles-ci ?).

**electrolover49** · 13/06/2012, 14h29

Finalement, je ne suis plus sûr lol, je me demande si cela est vraiment utile car toute les actions seront donc déconnectées de la fenêtre principale mais plutôt dans le menu ce qui n'est pas forcément judicieux, je pense.

Donc je vais remettre le menu dans le MainWindow et je vais continuer ma spécification et mon boulot sur la gomme.

**electrolover49** · 14/06/2012, 09h13

J'ai rajouté une palette pour choisir la couleur de la gomme en faite le but final est de sélectionner la couleur que l'on veut pour gommer efficacement.
(voir rendre cela automatique si possible lol)

MainWindow.py

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def __actionPalette(self):
        self._color = QColorDialog.getColor()
        self.palette = QPalette()
        self.palette.setColor(QPalette().NoRole,self._color)
    def getPaletteColor(self):
        return self._color
    def setPaletteColor(self,colour):
        self._color=colour
        self.update()
    #Init of the property for mode
    color = property(getPaletteColor, setPaletteColor)

Enfin, j'aimerais savoir si il était possible d'afficher la couleur choisie à la manière de paint.
cf. PJ

**ashren** · 14/06/2012, 09h20

Pour la manière automatique du choix de couleur, je suppose qu'implémenter un 'color picker' serait un début.

Après, pour la sélection de couleur à la manière de paint, un QPushButton avec une QIcon crée dynamiquement et affichant une boite de dialogue avec des sliders de 0 à 255 pour les composantes RGB devrait faire l'affaire.

**electrolover49** · 14/06/2012, 09h27

Extrait main
Pour le color selecter, cela est déjà fait j'ai une icône palette lorsqu'on clique dessus cela sélectionne la couleur voulue.
Par contre, le color picker , je le connais en java mais en C++ , je n'ai pas trouvé de module qui afficher vraiment la couleur à la manière de paint :s

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 #Palette
        _actionPalette = QAction(self)
        _actionPalette.triggered.connect(self.__actionPalette)
        _actionPalette.setIcon(QIcon("Pics\Palette.png"))
        _actionPalette.setStatusTip("Choose your color")
        iconToolBar.addAction(_actionPalette)

**ashren** · 14/06/2012, 10h00

Tu entends quoi exactement par 'à la manière de paint' ?

**electrolover49** · 14/06/2012, 10h07

Comme j'avais mis en pièce jointe, i.e on doit voir la couleur choisie après sélection sur la QPalette ou bien (plus tard) après appuie grâce une pipette par exemple.

**ashren** · 14/06/2012, 10h16

Je réitère donc ma solution: un QPushButton avec une QIcon générée automatiquement par la validation de la QColorDialog, i.e On créé une QImage et on utilise un QPainter dessus pour faire fillRect avec la couleur voulue.

**electrolover49** · 14/06/2012, 10h27

Ah d'accord je comprends mieux maintenant, cela me parait bien.
Je vais essayer cette solution, merci ^^.

**electrolover49** · 14/06/2012, 11h12

Alors j'ai essayé plusieurs solutions et ce n'est pas si simple que cela enfin pour moi.
Solutions :

Rectangle
J'ai essayé d'avoir un rectangle comme tu m'avais conseillé avec la couleur choisie sauf que j'ai du mal à l’insérer avec ma QImage et ce sera encore plus difficile avec la pixmap
Pixmap
Finalement, cette solution me parait la meilleure même si elle ne fonctionne pas là en effet on peut remplir la pixmap avec la couleur souhaitée.

Enfin, ce qui me bloque aussi, c'est comme "updater" le color picker :s

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
# -*- coding: utf-8 -*-
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence,QColor,QCheckBox,QStatusBar,QIcon,\
                         QMessageBox,QImage, QRubberBand, QMainWindow, QAction,\
                         QMenuBar, QFileDialog, QScrollArea,QColorDialog,QPalette,QBrush,QPixmap
from PySide.QtCore import QSize, QRect,QRectF,Qt
from ImageView.ImageView import ImageView
 
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setWindowTitle("Rub your Image")
        self._color = QColor()
        self._colorPicker = QImage()
        self._pix = QPixmap()
        self._rectColorPicker = QRectF(10,10,10,10)
        self.image = ImageView(QImage(),self._color)
        self.resize(500, 300)
 
        #Init of the Menu with the menubar and the icon
        self._initMenu()
        #Init of the Scrollarea 
        self._initScrollArea()
        #Init of the checkbox with the rubber on box
        self._initCkBox()
 
    def _initMenu(self):
        """
        Adding of actions for the tool bar
        """
        iconToolBar = self.addToolBar("iconBar")
 
        #About 
        _actionAbout = QAction(self)
        _actionAbout.triggered.connect(self.__actionAbout)
 
        _actionAbout.setIcon(QIcon("Pics\info-icon.jpg"))
        _actionAbout.setStatusTip("Pop up the About dialog.")
        iconToolBar.addAction(_actionAbout)
        #Rubber
        _actionRubber = QAction(self)
        _actionRubber.triggered.connect(self.__actionRubber)
        _actionRubber.setIcon(QIcon("Pics\eraser2.png"))
        _actionRubber.setStatusTip("Enable or Disable eraser tool")
        iconToolBar.addAction(_actionRubber)
 
        #Palette
        _actionPalette = QAction(self)
        _actionPalette.triggered.connect(self.__actionPalette)
        _actionPalette.setIcon(QIcon("Pics\Palette.png"))
        _actionPalette.setStatusTip("Choose your color")
        iconToolBar.addAction(_actionPalette)
 
        #ColorPicker
        _actionColorPicker = QAction(self)
        _actionColorPicker.triggered.connect(self.__actionColorPicker)
        _actionColorPicker.setIcon(QIcon(self._pix))
        _actionColorPicker.setStatusTip("Chosen color")
        iconToolBar.addAction(_actionColorPicker)
 
        """
            Add of the Menu which contains all the features like of Open/Save/..
            and the edit options
        """
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        _edit = menu.addMenu("Edit")
        # Menu Open
        _action = QAction('Open', _file,shortcut=QKeySequence.Open)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu Save
        _action = QAction('Save image As', _file,shortcut=QKeySequence.Save)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu Close
        _action = QAction('Close', _file,shortcut=QKeySequence.Close)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
        #Menu Edit
    def _initScrollArea(self):
        """
        Add of scroll bars to see properly the images
        """
        self.area = QScrollArea(self)
        self.area.setWidget(self.image)
        self.area.setWidgetResizable(True)
        self.setCentralWidget(self.area)
 
    def _initCkBox(self):
    #Check Box rub
        statusbar = QStatusBar(self)
        self.setStatusBar(statusbar)
        self._ckbox = QCheckBox("Rubber On/Off")
        statusbar.addWidget(self._ckbox)
        if self._ckbox.isChecked():
            self._mode = "rub"
        else :
            self._mode = "select"
        #Init of the boolean to know whether we select or rub
        self.image.mode = self._mode
        self._ckbox.stateChanged.connect(self.__rubberBoxChanged)
    def __actionOpen(self):
        _file = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if _file:
            self.image.setWorkingImage(QImage(_file[0]))
        else:
            print "Invalid Image"
 
    def __actionSave(self):
        _file = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        _result = self.image.workingImage().save(_file[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def __actionClose(self):
        self.close()
    def __actionRubber(self):
 
        if self._ckbox.isChecked():
            print"uncheck"
            self._ckbox.setChecked(False)
        else :
            print "Set check"
            self._ckbox.setChecked(self._ckbox.isCheckable())
    def __actionPalette(self):
        self._color = QColorDialog.getColor()
        self.palette = QPalette()
        self.palette.setColor(QPalette().NoRole,self._color)
        #We give the imageView the color of the pen/rub
        self.image.setPenColor(self._color)
    def __actionColorPicker(self):
#        self.painter = QPainter()
#        self.painter.fillRect(self._rectColorPicker,self.getPaletteColor())
        #self.painter.fillRect(self._colorPicker,self.getPaletteColor())
        self._pix.fill(self.getPaletteColor())
    def getPaletteColor(self):
        return self._color
    def setPaletteColor(self,colour):
        self._color=colour
        self.update()
    #Init of the property for mode
    color = property(getPaletteColor, setPaletteColor)
 
    def __actionAbout(self):
        '''Popup a box with about message.'''
        QMessageBox.about(self, "About PySide, Platform and the like",
        """<b> About this program </b> 
                <p>Copyright  2012 Maugin Guillaume. 
                All rights reserved in accordance with
                GPL v2 or later 
                <p>This application can be used for
                displaying OS and platform details.
                <p>Python %s - PySide version %s - Qt version %s on %s""" )
 
    def __rubberBoxChanged(self, state):
        if self._ckbox.isChecked():
            self._mode = 'rub'
        else:
            self._mode = 'select'
        self.image.mode = self._mode
 
 
 
 
if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

**ashren** · 14/06/2012, 17h25

Un exemple bateau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
from PySide.QtGui import QApplication, QPushButton, QColorDialog, QIcon, QPainter, QPixmap, QBrush, QColor
 
class ColorButton(QPushButton):
    def __init__(self, parent=None):
        super(ColorButton, self).__init__(parent=parent)
        self.clicked.connect(self.__onClicked)
        self.setText("Couleur 1")
        self.__setColor(QColor(255, 255, 255))
 
    def __onClicked(self):
        dlg = QColorDialog(self)
        if dlg.exec_():
            self.__setColor(dlg.selectedColor())
 
    def __setColor(self, color):
        _img = QPixmap(16, 16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(color))
        _p.end()
        self.setIcon(QIcon(_img))
 
if __name__ == '__main__':
    app = QApplication([])
    win = ColorButton()
    win.show()
    app.exec_()

**electrolover49** · 14/06/2012, 18h29

Je vais voir l'exemple et le mettre en pratique ^^.
Bonne soirée.

**electrolover49** · 15/06/2012, 13h09

Grâce à ton exemple, j'ai réussi à mettre en oeuvre le color picker ^^.
Malgré tout, il y a deux points ennuyeux :

Couleur non transmise à ImageView
C'est à dire qu'avant j'arrivais à passer la couleur choisie à la vue pour pouvoir afficher le cercle avec la couleur choisie et dorénavant, cela bloque.
Widget Color Picker moche
Je voulais garder la toolBar donc j'ai ajouter le widget color picker et cela n'est pas très beau avec le cadre , je ne sais pas si on peut faire mieux au pire il faudra que je revoie surement la conception avec un layout, etc...

Merci de ton aide .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
# -*- coding: utf-8 -*-
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence,QColor,QCheckBox,QStatusBar,QIcon,\
                         QMessageBox,QImage, QRubberBand, QMainWindow, QAction,\
                         QMenuBar, QFileDialog, QScrollArea,QColorDialog,QPalette,QBrush,QPixmap,\
                         QPushButton
from PySide.QtCore import QSize, QRect,QRectF,Qt
from ImageView import ImageView
 
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setWindowTitle("Rub your Image")
        self._color = QColor()
 
        self._buttonColorPicker = QPushButton()
        self.__setColor(QColor(255,255,255))
 
        #ColorPicker
 
        self._buttonColorPicker.clicked.connect(self.__actionColorPicker)
        self._buttonColorPicker.setText("Color Picker")
        self._buttonColorPicker.setToolTip("Choose your color")
 
        self.image = ImageView(QImage(),self._color)
        self.resize(500, 300)
 
        #Init of the Menu with the menubar and the icon
        self._initMenu()
        #Init of the Scrollarea 
        self._initScrollArea()
        #Init of the checkbox with the rubber on box
        self._initCkBox()
 
    def _initMenu(self):
        """
        Adding of actions for the tool bar
        """
        self.iconToolBar = self.addToolBar("iconBar")
 
        #About 
        _actionAbout = QAction(self)
        _actionAbout.triggered.connect(self.__actionAbout)
 
        _actionAbout.setIcon(QIcon("Pics\info-icon.jpg"))
        _actionAbout.setStatusTip("Pop up the About dialog.")
        self.iconToolBar.addAction(_actionAbout)
        #Rubber
        _actionRubber = QAction(self)
        _actionRubber.triggered.connect(self.__actionRubber)
        _actionRubber.setIcon(QIcon("Pics\eraser2.png"))
        _actionRubber.setStatusTip("Enable or Disable eraser tool")
        self.iconToolBar.addAction(_actionRubber)
 
        self.iconToolBar.addWidget(self._buttonColorPicker)
 
 
        """
            Add of the Menu which contains all the features like of Open/Save/..
            and the edit options
        """
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        _edit = menu.addMenu("Edit")
        # Menu Open
        _action = QAction('Open', _file,shortcut=QKeySequence.Open)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu Save
        _action = QAction('Save image As', _file,shortcut=QKeySequence.Save)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu Close
        _action = QAction('Close', _file,shortcut=QKeySequence.Close)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
        #Menu Edit
    def _initScrollArea(self):
        """
        Add of scroll bars to see properly the images
        """
        self.area = QScrollArea(self)
        self.area.setWidget(self.image)
        self.area.setWidgetResizable(True)
        self.setCentralWidget(self.area)
 
    def _initCkBox(self):
    #Check Box rub
        statusbar = QStatusBar(self)
        self.setStatusBar(statusbar)
        self._ckbox = QCheckBox("Rubber On/Off")
        statusbar.addWidget(self._ckbox)
        if self._ckbox.isChecked():
            self._mode = "rub"
        else :
            self._mode = "select"
        #Init of the boolean to know whether we select or rub
        self.image.mode = self._mode
        self._ckbox.stateChanged.connect(self.__rubberBoxChanged)
    def __actionOpen(self):
        _file = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if _file:
            self.image.setWorkingImage(QImage(_file[0]))
        else:
            print "Invalid Image"
 
    def __actionSave(self):
        _file = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        _result = self.image.workingImage().save(_file[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def __actionClose(self):
        self.close()
    def __actionRubber(self):
 
        if self._ckbox.isChecked():
            print"uncheck"
            self._ckbox.setChecked(False)
        else :
            print "Set check"
            self._ckbox.setChecked(self._ckbox.isCheckable())
 
    def __actionAbout(self):
        '''Popup a box with about message.'''
        QMessageBox.about(self, "About PySide, Platform and the like",
        """<b> About this program </b> 
                <p>Copyright  2012 Maugin Guillaume. 
                All rights reserved in accordance with
                GPL v2 or later 
                <p>This application can be used for
                displaying OS and platform details.
                <p>Python %s - PySide version %s - Qt version %s on %s""" )
    def __actionColorPicker(self):
        dlg = QColorDialog(self)
        if dlg.exec_():
            self.__setColor(dlg.selectedColor())
 
    def __setColor(self, color):
        _img = QPixmap(16, 16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(color))
        _p.end()
        #Mise à jour de la couleur
        self._color = color
        self._buttonColorPicker.setIcon(QIcon(_img))
    def __getColor(self):
        return self._color
    def __rubberBoxChanged(self, state):
        if self._ckbox.isChecked():
            self._mode = 'rub'
        else:
            self._mode = 'select'
        self.image.mode = self._mode
 
 
 
 
if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

**ashren** · 15/06/2012, 16h48

Bonjour,

tu peux aussi regarder du côté des stylesheets, par contre rendre un programme 'beau' ce n'est plus vraiment mon domaine.

PS: si ton widget est dans une toolbar, essaie de changer la classe de base QPushButton par QToolButton (vu que c'est dédié à ça).

**electrolover49** · 15/06/2012, 18h56

Je vois pour les stylesheets, je me débrouillerai ^^ .
Enfin pour passer la couleur à la vue, j'ai toujours le même problème, sur ma version antérieure avec la QPalette, j'envoyais bien la couleur à la vue et maintenant, la couleur reste noire :s.

**ashren** · 15/06/2012, 19h44

Tu ne met pas à jour la couleur dans l'ImageView il me semble (après le dlg.exec_).

Gomme et QImage [QtGui]

PyQt Python

Discussions similaires

Partager

Partager