mieki256's diary

1. 縦横比を4:3に設定して矩形で選択。
2. 切り抜き(トリミング)。
3. イメージサイズを640x480にリサイズ(再サンプリング)。

• 選択範囲作成後、境界をドラッグして微調整することができない。
• 4:3でトリミングした状態で、縦横比を維持にチェックを入れて640x480にリサイズしようとすると、片方に小数点の数値が入ってきて、1ドット足りなくなったりする。

u"""
QSliderとQSpinBoxを1つのWidgetにまとめて並べてみるサンプル.

RGB/HSLのQSlider + QSpinBoxを用意して値を連動させる。結果を色で表示する。

Windows10 x64 + Python 2.7.11 + PySide 1.2.4
"""


import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA


class LabelSliderSpinBox(QWidget):

    """Slider and SpinBox."""

    # Signalを用意
    valueChanged = Signal(int)

    def __init__(self, text, parent=None):
        """init."""
        super(LabelSliderSpinBox, self).__init__(parent)
        # self.setContentsMargins(0, 0, 0, 0)
        hl = QHBoxLayout()
        hl.setContentsMargins(0, 0, 0, 0)
        # hl.setSpacing(0)
        self.lbl = QLabel(text, self)
        self.sld = QSlider(Qt.Horizontal, self)
        self.spb = QSpinBox(self)
        hl.addWidget(self.lbl)
        hl.addWidget(self.sld)
        hl.addWidget(self.spb)
        self.setLayout(hl)
        self.sld.valueChanged[int].connect(self.changed_slider_value)
        self.spb.valueChanged[int].connect(self.changed_spinbox_value)

        # 用意したシグナルとスロットを関連付ける
        self.valueChanged[int].connect(self.changedValue)

    def setText(self, text):
        """set QLabel text."""
        self.lbl.setText(text)

    def setRange(self, start_v, end_v):
        """set range QSlider and QSpinBox."""
        self.sld.setRange(start_v, end_v)
        self.spb.setRange(start_v, end_v)

    def setValue(self, value):
        """set value to QSlider and QSpinBox."""
        self.sld.setValue(value)
        self.spb.setValue(value)

    def value(self):
        """get value."""
        return self.spb.value()

    def changed_slider_value(self, n):
        """changed slider value."""
        self.spb.setValue(n)

    def changed_spinbox_value(self, n):
        """changed spinbox value."""
        self.sld.setValue(n)
        self.valueChanged.emit(n)  # 値が変わったのでシグナルを発行

    # スロットを用意する
    @Slot(int)
    def changedValue(self, value):
        """changed slider or spinbox value."""
        pass
        # print("value = %d" % value)


class MyWidget(QWidget):

    """My Widget."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        self.setWindowTitle("Color Slider")

        self.event_ignore = False

        l = QVBoxLayout()

        # color display button
        btn = QPushButton()
        btn.setFixedSize(64, 64)

        # set button background-color
        btn.setStyleSheet("QWidget { background-color: %s }"
                          % QColor(128, 128, 128).name())

        l.addWidget(btn)
        btn.clicked.connect(self.show_color_dialog)
        self.btn = btn

        # sliders
        data = [
            ("R", 0, 255, 128), ("G", 0, 255, 128), ("B", 0, 255, 128),
            ("H", 0, 360, 180), ("S", 0, 255, 128), ("L", 0, 255, 128)]
        self.sliders = []
        for (i, d) in enumerate(data):
            text, start_v, end_v, init_v = d
            w = LabelSliderSpinBox(text, self)
            w.setRange(start_v, end_v)
            w.setValue(init_v)
            l.addWidget(w)
            self.sliders.append(w)
            if i < 3:
                w.valueChanged.connect(self.changed_rgb)
            else:
                w.valueChanged.connect(self.changed_hsl)

        self.setLayout(l)

    def update_rgb_disp(self, col):
        """update RGB disp button."""
        # set background-color
        self.btn.setStyleSheet("QWidget { background-color: %s }"
                               % col.name())

    def set_sliders_rgb(self, col):
        """set RGB slider value."""
        r, g, b = col.red(), col.green(), col.blue()
        self.set_sliders(0, (r, g, b))

    def set_sliders_hsl(self, col):
        """set HSL slider value."""
        h, s, l = col.hslHue(), col.hslSaturation(), col.lightness()
        self.set_sliders(3, (h, s, l))

    def set_sliders(self, idx, v):
        """set 3 slider value."""
        for i in range(3):
            if self.sliders[idx + i].value() != v[i]:
                self.sliders[idx + i].setValue(v[i])

    def get_sliders(self, idx):
        """get 3 slider value."""
        v = []
        for i in range(3):
            v.append(self.sliders[idx + i].value())
        return tuple(v)

    def changed_rgb(self, _):
        """changed RGB value."""
        if not self.event_ignore:
            self.event_ignore = True
            r, g, b = self.get_sliders(0)
            col = QColor(r, g, b)
            self.set_sliders_hsl(col)
            self.update_rgb_disp(col)
            self.event_ignore = False

    def changed_hsl(self, _):
        """changed HSL value."""
        if not self.event_ignore:
            self.event_ignore = True
            h, s, l = self.get_sliders(3)
            col = QColor()
            col.setHsl(h, s, l)
            self.set_sliders_rgb(col)
            self.update_rgb_disp(col)
            self.event_ignore = False

    def show_color_dialog(self):
        """open QColorDialog."""
        col = QColorDialog.getColor()
        if col.isValid():
            self.set_sliders_rgb(col)


def main():
    """Main."""
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

◎ RGBからHSLの変換について。 :

◎ ラベルとスライダーとスピンボックスをまとめた。 :

今回、管理をしやすくするために、QLabel(ラベル)と、QSlider(スライダー)と、QSpinBox(スピンボックス)をまとめたウィジェットを作って配置してみた。

QWidget に _QHBoxLayout(横に並べるレイアウト) を設定して、中に _QLabel 、 _QSlider 、 _QSpinBox を並べて管理、みたいな。

更に、「QSlider の値が変わったら QSpinBox も同じ値に変更」「QSpinBox の値が変わったら QSlider も同じ値に変更」という処理も入れた。これで、QSlider と QSpinBox が連動して動く。QSlider、QSpinBox には valueChanged というシグナル？が用意されていて、値が変わったらそのシグナルが発生することになっているので、ソレを利用した。

しかし、このままだと、QSlider もしくは QSpinBox の値が変わったことを親Widgetに伝える術が無くなるので(valueChanged シグナルを既に使っているので)、別途シグナルを設定して、QSlider もしくは QSpinBox の値が変わったらそのシグナルを発生するようにしてみたり。

class LabelSliderSpinBox(QWidget):

    # Signalを用意
    valueChanged = Signal(int)

    def __init__(self, text, parent=None):

        (中略)

        # 用意したシグナルとスロットを関連付ける
        self.valueChanged[int].connect(self.changedValue)

    (中略)

    def changed_spinbox_value(self, n):
        self.sld.setValue(n)
        self.valueChanged.emit(n)  # 値が変わったのでシグナルを発行

    # スロットを用意する
    @Slot(int)
    def changedValue(self, value):
        print("value = %d" % value)

親Widget側では、「子Widget の持ってる値が変化したら valueChanged というシグナルを子Widgetが出してくれるはずだから、そのシグナルが来た時はこの関数を呼ぶ」的な設定をしてやればいい。

    w.valueChanged.connect(self.changed_rgb)

◎ シグナルが出続ける問題にまた遭遇。 :

◎ ボタンの背景色を設定。 :

        btn.setStyleSheet("QWidget { background-color: %s }"
                          % QColor(128, 128, 128).name())

◎ アップデート終了。 :

◎ 休止状態から復帰するとロック画面が出てきてしまう。 :

◎ 既定のブラウザが設定できない。 :

◎ Cドライブの容量が少なくなってしまった。 :

◎ 休止状態から復帰するとロック画面が出てきてしまう問題。 :

◎ デフラグをかけた。 :

◎ SyncToyについて。 :

u"""
QSliderとQSpinBoxを1つのWidgetにまとめて並べてみるサンプル.

RGB/HSLのQSlider + QSpinBoxを用意して値を連動させる。
かつ、ビットマップ画像をGIMPの「着色」風に変更してみる。

Windows10 x64 + Python 2.7.11 + PySide 1.2.4
"""


import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA

IMG_FILE = "temp.png"


class LabelSliderSpinBox(QWidget):

    """Slider and SpinBox."""

    # Signalを用意
    valueChanged = Signal(int)

    def __init__(self, text, parent=None):
        """init."""
        super(LabelSliderSpinBox, self).__init__(parent)
        # self.setContentsMargins(0, 0, 0, 0)
        hl = QHBoxLayout()
        hl.setContentsMargins(0, 0, 0, 0)
        # hl.setSpacing(0)
        self.lbl = QLabel(text, self)
        self.sld = QSlider(Qt.Horizontal, self)
        self.spb = QSpinBox(self)
        hl.addWidget(self.lbl)
        hl.addWidget(self.sld)
        hl.addWidget(self.spb)
        self.setLayout(hl)
        self.sld.valueChanged[int].connect(self.changed_slider_value)
        self.spb.valueChanged[int].connect(self.changed_spinbox_value)

        # 用意したシグナルとスロットを関連付ける
        self.valueChanged[int].connect(self.changedValue)

    def setText(self, text):
        """set QLabel text."""
        self.lbl.setText(text)

    def setRange(self, start_v, end_v):
        """set range QSlider and QSpinBox."""
        self.sld.setRange(start_v, end_v)
        self.spb.setRange(start_v, end_v)

    def setValue(self, value):
        """set value to QSlider and QSpinBox."""
        self.sld.setValue(value)
        self.spb.setValue(value)

    def value(self):
        """get value."""
        return self.spb.value()

    def changed_slider_value(self, n):
        """changed slider value."""
        self.spb.setValue(n)

    def changed_spinbox_value(self, n):
        """changed spinbox value."""
        self.sld.setValue(n)
        self.valueChanged.emit(n)  # 値が変わったのでシグナルを発行

    # スロットを用意する
    @Slot(int)
    def changedValue(self, value):
        """changed slider or spinbox value."""
        pass
        # print("value = %d" % value)


class MyWidget(QWidget):

    """My Widget."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        self.setWindowTitle("Color Slider")

        self.event_ignore = False

        l = QVBoxLayout()

        # bitmap display label
        im = QImage(IMG_FILE)
        lbl = QLabel("", self)
        lbl.setPixmap(QPixmap.fromImage(im))
        l.addWidget(lbl)
        self.im = im
        self.lbl = lbl
        self.lum_im = self.make_lum_image(im)

        # color display button
        btn = QPushButton()
        btn.setFixedSize(32, 32)

        # set button background-color
        btn.setStyleSheet("QWidget { background-color: %s }"
                          % QColor(128, 128, 128).name())

        l.addWidget(btn)
        btn.clicked.connect(self.show_color_dialog)
        self.btn = btn

        # sliders
        data = [
            ("R", 0, 255, 128), ("G", 0, 255, 128), ("B", 0, 255, 128),
            ("H", 0, 360, 180), ("S", 0, 255, 128), ("L", 0, 255, 128)]
        self.sliders = []
        for (i, d) in enumerate(data):
            text, start_v, end_v, init_v = d
            w = LabelSliderSpinBox(text, self)
            w.setRange(start_v, end_v)
            w.setValue(init_v)
            l.addWidget(w)
            self.sliders.append(w)
            if i < 3:
                w.valueChanged.connect(self.changed_rgb)
            else:
                w.valueChanged.connect(self.changed_hsl)

        self.setLayout(l)

    def update_rgb_disp(self, col):
        """update RGB disp button."""
        # set background-color
        self.btn.setStyleSheet("QWidget { background-color: %s }"
                               % col.name())

    def set_sliders_rgb(self, col):
        """set RGB slider value."""
        r, g, b = col.red(), col.green(), col.blue()
        self.set_sliders(0, (r, g, b))

    def set_sliders_hsl(self, col):
        """set HSL slider value."""
        h, s, l = col.hslHue(), col.hslSaturation(), col.lightness()
        self.set_sliders(3, (h, s, l))

    def set_sliders(self, idx, v):
        """set 3 slider value."""
        for i in range(3):
            if self.sliders[idx + i].value() != v[i]:
                self.sliders[idx + i].setValue(v[i])

    def get_sliders(self, idx):
        """get 3 slider value."""
        v = []
        for i in range(3):
            v.append(self.sliders[idx + i].value())
        return tuple(v)

    def changed_rgb(self, _):
        """changed RGB value."""
        if not self.event_ignore:
            self.event_ignore = True
            r, g, b = self.get_sliders(0)
            col = QColor(r, g, b)
            self.set_sliders_hsl(col)
            self.update_rgb_disp(col)
            self.change_pixmap_color(self.lum_im)
            self.event_ignore = False

    def changed_hsl(self, _):
        """changed HSL value."""
        if not self.event_ignore:
            self.event_ignore = True
            h, s, l = self.get_sliders(3)
            col = QColor()
            col.setHsl(h, s, l)
            self.set_sliders_rgb(col)
            self.update_rgb_disp(col)
            self.change_pixmap_color(self.lum_im)
            self.event_ignore = False

    def show_color_dialog(self):
        """open QColorDialog."""
        col = QColorDialog.getColor()
        if col.isValid():
            self.set_sliders_rgb(col)

    def make_lum_image(self, im):
        """make luminance image."""
        w, h = im.size().width(), im.size().height()
        dst = []
        for y in range(h):
            d = []
            for x in range(w):
                c = im.pixel(x, y)
                r, g, b = qRed(c), qGreen(c), qBlue(c)
                # get luminance
                l = int(0.2126 * r + 0.7152 * g + 0.0722 * b)
                l = max(0, min(l, 255))
                d.append((l, qAlpha(c)))
            dst.append(d)
        return dst

    def change_pixmap_color(self, src):
        """change QPixmap color."""
        b_h, b_s, b_l = self.get_sliders(3)
        w, h = len(src), len(src[0])
        dst = QImage(w, h, QImage.Format_ARGB32)
        c2 = QColor()
        for y in range(h):
            for x in range(w):
                l, a = src[y][x]
                if b_l > 128:
                    l *= (255.0 - b_l) / 127.0
                    l += (255.0 - ((255 - b_l) * 255.0 / 127.0))
                elif b_l < 128:
                    l *= b_l / 128.0
                l = int(l)
                if l < 0:
                    l = 0
                if l > 255:
                    l = 255
                c2.setHsl(b_h, b_s, l, a)
                dst.setPixel(x, y, c2.rgba())
        self.lbl.setPixmap(QPixmap.fromImage(dst))


def main():
    """Main."""
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

◎ PySide のアレコレをメモ。 :

◎ GIMPのソースの該当する部分。 :

      while (w--)
        {
          lum = (colorize->lum_red_lookup[s[RED]] +
                 colorize->lum_green_lookup[s[GREEN]] +
                 colorize->lum_blue_lookup[s[BLUE]]); /* luminosity */

          if (colorize->lightness > 0)
            {
              lum = (gdouble) lum * (100.0 - colorize->lightness) / 100.0;

              lum += 255 - (100.0 - colorize->lightness) * 255.0 / 100.0;
            }
          else if (colorize->lightness < 0)
            {
              lum = (gdouble) lum * (colorize->lightness + 100.0) / 100.0;
            }

          d[RED]   = colorize->final_red_lookup[lum];
          d[GREEN] = colorize->final_green_lookup[lum];
          d[BLUE]  = colorize->final_blue_lookup[lum];

          if (alpha)
            d[ALPHA] = s[ALPHA];

          s += srcPR->bytes;
          d += destPR->bytes;
        }

◎ PySideのQImageについてメモ。 :

    def get_hflip_image(self, img):
        u"""水平反転したQImageを返す."""
        nimg = img.mirrored(True, False)
        return nimg
    
    def get_vflip_image(self, img):
        u"""垂直反転したQImageを返す."""
        nimg = img.mirrored(False, True)
        return nimg

    def get_rot_image(self, img, id):
        u"""回転したQImageを返す."""
        deg = id * 90
        rot = QTransform()
        rot = rot.rotate(deg)
        nimg = img.transformed(rot)
        return nimg

        pm = QPixmap.fromImage(qimg)

    def save_undo(self):
        u"""キャンバスをUndoバッファに記憶."""
        if len(self.undo_buf) > UNDO_MAX:
            del(self.undo_buf[0])
        self.undo_buf.append(self.canvas_pixmap.copy())

    def undo(self):
        u"""キャンバスをUndo."""
        if len(self.undo_buf) > 0:
            pm = self.undo_buf.pop()
            self.canvas_pixmap = pm.copy()
            self.canvas_item.setPixmap(self.canvas_pixmap)
            return True
        return False

• キャンバス上でマウスクリックされたタイミングで、Undo用のデータを記録する。ブラシ描画する前にキャンバス相当の QPixmap をリストに格納。
• リストの要素数が一定数を超えていたら、最初の要素を削除してから、最後に QPixmap の copy を追加。
• Undo時は、リストの最後から copy してきて、リストの最後の要素を削除。
• buf.append(pixmap)ではポインタ(?)しか記録されないだろうから、ディープコピーをする QPixmap.copy() を呼んでる。つもりなのだけど、これで合ってるのかどうか…。

◎ ウチの近所も色々とアレだったり。 :

u"""押したままの状態になるボタンを並べてツールパネル相当を作るテスト."""


import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA


class ToolPanel(QWidget):

    u"""ツールパネル用Widget."""

    button_clicked = Signal(int)  # シグナルを用意

    def __init__(self, *argv, **keywords):
        u"""初期化."""
        super(ToolPanel, self).__init__(*argv, **keywords)
        self.grp = QButtonGroup()
        gb = QGridLayout()
        dt = [
            (0, 0, 0, "Brush"),
            (1, 0, 1, "Erase"),
            (0, 1, 2, "Box"),
            (1, 1, 3, "Box Fill"),
            (0, 2, 4, "Select"),
            (1, 2, 5, "Fill"),
        ]
        for x, y, id, s in dt:
            btn = QPushButton(s, self)
            btn.setCheckable(True)  # トグルボタンにする
            self.grp.addButton(btn, id)  # グループ登録してラジオボタン風に使う
            gb.addWidget(btn, y, x)
        self.setLayout(gb)
        self.grp.setExclusive(True)  # 排他的なボタン処理にする
        self.grp.button(0).setChecked(True)  # 最初のボタンを押しておく
        self.grp.buttonClicked.connect(self.changed_button)

    def changed_button(self):
        u"""ボタンが押された時に呼ばれる処理."""
        self.button_clicked.emit(self.grp.checkedId())  # シグナルを発生

    def get_id(self):
        u"""選択状態(ID)を返す."""
        return self.grp.checkedId()


class MyMainWidget(QWidget):

    u"""メインウインドウ."""

    def __init__(self, *argv, **keywords):
        u"""初期化."""
        super(MyMainWidget, self).__init__(*argv, **keywords)
        self.tb = ToolPanel(self)
        self.tb.button_clicked.connect(self.changed_toolbox)
        self.lbl = QLabel("----", self)
        self.lbl.setText("ID=%d" % self.tb.get_id())
        l = QVBoxLayout()
        l.addWidget(self.tb)
        l.addWidget(self.lbl)
        self.setLayout(l)

    def changed_toolbox(self, id):
        u"""ツールの選択状態が切り替わった時に呼ばれる処理."""
        self.lbl.setText("ID=%d" % id)


def main():
    u"""メイン処理."""
    app = QApplication(sys.argv)
    w = MyMainWidget()
    w.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

◎ アイコン画像を表示してみた。 :

各ボタンにテキストが表示されてる状態ではツールパネルっぽくないので、試しにアイコン画像を表示してみたり。

_button_test_with_icon.py.txt

u"""
押したままの状態になるボタンを並べてツールパネル相当を作るテスト.

アイコン画像をボタン上に表示してみる版。
"""


import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA


class ToolPanel(QWidget):

    u"""ツールパネル用Widget."""

    button_clicked = Signal(int)  # シグナルを用意

    def __init__(self, *argv, **keywords):
        u"""初期化."""
        super(ToolPanel, self).__init__(*argv, **keywords)

        # 画像を読み込んで分割
        im = QImage("./toolbar_32x32x8.png")
        h = im.size().height()
        imgs = []
        for i in range(8):
            imgs.append(im.copy(i * h, 0, h, h))

        self.grp = QButtonGroup()

        gb = QGridLayout()
        gb.setHorizontalSpacing(0)  # GridLayoutの水平余白を設定
        gb.setVerticalSpacing(0)    # GridLayoutの垂直余白を設定
        dt = [
            (0, 0, 0, "Brush"),
            (1, 0, 1, "Erase"),
            (2, 0, 2, "Line"),
            (3, 0, 3, "Box Line"),
            (4, 0, 4, "Box Fill"),
            (0, 1, 5, "Fill"),
            (1, 1, 6, "Text"),
            (2, 1, 7, "Select"),
        ]
        for x, y, id, s in dt:
            icon = QIcon(QPixmap.fromImage(imgs[id]))  # アイコン画像を生成
            btn = QPushButton(icon, "", self)

            # アイコンサイズを画像の元サイズにする
            btn.setIconSize(imgs[id].size())

            btn.setToolTip(s)  # ツールチップを指定

            btn.setCheckable(True)  # トグルボタンにする
            self.grp.addButton(btn, id)  # グループ登録してラジオボタン風に使う
            gb.addWidget(btn, y, x)
        self.setLayout(gb)
        self.grp.setExclusive(True)  # 排他的なボタン処理にする
        self.grp.button(0).setChecked(True)  # 最初のボタンを押しておく
        self.grp.buttonClicked.connect(self.changed_button)

    def changed_button(self):
        u"""ボタンが押された時に呼ばれる処理."""
        self.button_clicked.emit(self.grp.checkedId())  # シグナルを発生

    def get_id(self):
        u"""選択状態(ID)を返す."""
        return self.grp.checkedId()


class MyMainWidget(QWidget):

    u"""メインウインドウ."""

    def __init__(self, *argv, **keywords):
        u"""初期化."""
        super(MyMainWidget, self).__init__(*argv, **keywords)
        self.tb = ToolPanel(self)
        self.tb.button_clicked.connect(self.changed_toolbox)
        self.lbl = QLabel("----", self)
        self.lbl.setText("ID=%d" % self.tb.get_id())
        l = QVBoxLayout()
        l.addWidget(self.tb)
        l.addWidget(self.lbl)
        self.setLayout(l)

    def changed_toolbox(self, id):
        u"""ツールの選択状態が切り替わった時に呼ばれる処理."""
        self.lbl.setText("ID=%d" % id)


def main():
    u"""メイン処理."""
    app = QApplication(sys.argv)
    app.setStyle(QStyleFactory.create("cleanlooks"))
    # app.setStyle(QStyleFactory.create("plastique"))
    # app.setStyle(QStyleFactory.create("windows"))
    # app.setStyle(QStyleFactory.create("windowsvista"))
    w = MyMainWidget()
    w.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

アイコン画像として、以下を自作した。スクリプトソースも含めて、CC0 / Public Domain ってことで。

_toolbar_32x32x8.png

こんな見た目になった。

• アイコンの指定には、QIcon を使う。QPixmap を渡すと作れるっぽいので、元画像が QImage なら、QIcon(QPixmap.fromImage(qimg)) てな記述になる。
• QIcon は、自動で画像を縮小して適切なサイズにしてしまうので、元画像サイズで表示したい場合は setIconSize() を呼んで元画像サイズを指定してやる。
• QGridLayout の水平余白、垂直余白は、setHorizontalSpacing()、setVerticalSpacing() で指定できる。
• ボタン上にマウスカーソルを合わせた際にピョコッと表示されるツールチップは、setToolTip() で指定できる。
• 各Widgetの全体的な見た目は、QApplication.setStyle() で変更できる。QStyleFactory.create("cleanlooks") や QStyleFactory.create("plastique") を渡してやると見た目が変わる。指定できる文字列としては、windows、motif、cde、plastique、cleanlooks があるらしい。

_QIcon - PySide v1.0.7 documentation
_QGridLayout - PySide v1.0.7 documentation
_QWidget - PySide v1.0.7 documentation
_QApplication - PySide v1.0.7 documentation
_QStyleFactory - PySide v1.0.7 documentation

    zoomactual_action = view_menu.addAction("Zoom &1:1")
    zoomactual_action.setShortcut("Ctrl+1")
    zoomactual_action.triggered.connect(self.zoom_actual_pixels)

    open_action = QAction("&Open", self)
    open_action.setShortcut(QKeySequence(QKeySequence.Open))
    open_action.setStatusTip("Open Image File")
    open_action.triggered.connect(self.show_open_dialog)
    file_menu.addAction(open_action)

    ...

    zoomin_action = view_menu.addAction("Zoom &In")
    zoomin_action.setShortcut(QKeySequence(QKeySequence.ZoomIn))
    zoomin_action.triggered.connect(self.zoom_in)

    zoomout_action = view_menu.addAction("Zoom &Out")
    zoomout_action.setShortcut(QKeySequence(QKeySequence.ZoomOut))
    zoomout_action.triggered.connect(self.zoom_out)

    save_as_action = QAction("Save &As...", self)
    save_as_action.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_S))
    save_as_action.setStatusTip("Save Canvas Image")
    save_as_action.triggered.connect(self.show_save_dialog)
    file_menu.addAction(save_as_action)

◎ これほどCGツールが溢れているのに。 :

◎ 一般的なアプリなら Tango Icon Library がヨサゲ。 :

◎ インストール時のアレコレ。 :

◎ 起動時間。 :

◎ メモリの使い方について。 :

◎ キャンバスの拡大表示について。 :

◎ ブラシがボケる。 :

◎ カスタムツールエリアは便利。 :

◎ パレットの表示個数が少ない。 :

◎ Photoshopプラグインが使えなかった。 :

◎ 2016/11/11追記。 :

◎ 2016/11/11追記。 :

◎ GIMPの起動時間がヤバイ。 :

◎ 細かいファイルをまとめることはできないのかな。 :

◎ 圧縮フォルダってあったような。 :

◎ Windows版GIMPは起動が遅いという話も。 :

◎ Script-fuよりPython-fuのほうがいいのかな。 :

◎ 経緯。 :

◎ 問題点。 :

◎ Cortanaをもう少し改善してほしい。 :

◎ Microsoftは愚かな農夫、なのだろうか。 :

◎ 関連情報をメモ。 :

    def erase_brush_pixmap(self):
        u"""ブラシ画像(QPixmap)を消しゴムとして使う."""
        qp = QPainter()
        qp.begin(self.canvas)
        qp.setCompositionMode(QPainter.CompositionMode_DestinationOut)
        x, y = self.brush.width() + 16, 0
        qp.drawPixmap(x, y, self.brush)
        qp.end()
        del qp
        self.canvas_item.setPixmap(self.canvas)

◎ 不具合メモ。 :

◎ アイコンバグを修正。 :

◎ メニューフォントを変更。 :

style "my-font"
{
  font_name="Tahoma 9"
}
widget "*" style "my-font"

◎ Susieプラグインを使う手もアリ。 :

_Bay-side で、SVG形式Susieプラグインが公開されてる。ありがたや。

_ViX +SVG形式Susieプラグインで表示してみた。

ここで表示しているsvg群は、それぞれ48x48ドットのページサイズで作られているけど、そのサイズが反映された状態で表示された。見た目も綺麗。

◎ ArtLibreSetの入手先。 :

◎ svgからpngに変換する方法で悩む。 :

◎ Windows版のrsvg-convertがあった。 :

◎ XnViewもrsvg-convertに対応してるらしいのだが。 :

◎ QActionの書き方。 :

    eraser_action = QAction("Eraser", self)
    eraser_icon = QIcon(self.icons[2])
    eraser_action.setIcon(eraser_icon)
    eraser_action.setCheckable(True)
    eraser_action.setShortcut("E")
    eraser_action.setStatusTip("Eraser tool")
    eraser_action.triggered.connect(self.eraser_tool)

    line_action = QAction(QIcon(self.icons[3]), "Line", self,
                          checkable=True, shortcut="L",
                          statusTip="Line tool",
                          triggered=self.line_tool)

◎ Qtが持っているアイコン画像を使う書き方。 :

    new_action = QAction("&New", self)
    new_icon = QIcon(QPixmap("document-new.png"))
    new_action.setIcon(new_icon)

    new_action = QAction("&New", self)
    new_icon = self.style().standardIcon(QStyle.SP_FileIcon)
    new_action.setIcon(new_icon)

◎ QToolBar上のアイコンサイズ。 :

    self.view_tb = QToolBar("View")
    self.view_tb.setIconSize(QSize(32, 32))
    self.addToolBar(self.view_tb)

◎ アクションのグループ化。 :

    # ツール群。checkableをTrueにしてることに注意
    pen_action = QAction("Pen", self)
    pen_action.setIcon(QIcon(self.icons[0]))
    pen_action.setCheckable(True)
    pen_action.setShortcut("P")
    pen_action.triggered.connect(self.pen_tool)

    eraser_action = QAction("Eraser", self)
    eraser_action.setIcon(QIcon(self.icons[2]))
    eraser_action.setCheckable(True)
    eraser_action.setShortcut("E")
    eraser_action.triggered.connect(self.eraser_tool)

    # ツール群はグループ化する。どれか一つだけが選ばれる状態になる。
    self.tools_grp = QActionGroup(self)
    self.tools_grp.addAction(pen_action)
    self.tools_grp.addAction(eraser_action)
    pen_action.setChecked(True)

◎ Markdownの売り。 :

◎ 余談。 :

◎ ツールバー用アイコン画像も置いときます。 :

自作したツールバー用のアイコン画像 ( svg + png (48x48, 32x32, 22x22, 16x16) ) もzipにして置いときます。ライセンスは CC0 / Public Domain のフリー素材ってことで。

_artlibreset_substitute_20161118.zip (104KB)

中に mkpng.rb てのが入ってますが…。これは _Windows版のrsvg-convert.exe を使って、scalable\*.svg を png に変換するバッチファイル代わりのRubyスクリプト、なので気にしないでください。

ちなみに、svg 作成には、 _Inkscape を使いました、とメモ。

◎ QMainWindowは最初からメニューバー等を持ってるらしい。 :

    new_action = QAction("&New", self)
    new_icon = QIcon("./document-new.svg")
    new_action.setIcon(new_icon)
    new_action.setShortcut(QKeySequence(QKeySequence.New))
    new_action.setToolTip("New Canvas")
    new_action.triggered.connect(self.new_canvas)

◎ importの書き方で使えたり使えなかったりするらしい。 :

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA
from PySide import QtSvg, QtXml  # NOQA

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *  # NOQA

◎ サポートしてる画像フォーマットを確認。 :

        for s in QImageReader.supportedImageFormats():
            print(s)

bmp
gif
ico
jpeg
jpg
mng
pbm
pgm
png
ppm
svg
svgz
tga
tif
tiff
xbm
xpm

bmp
gif
ico
jpeg
jpg
mng
pbm
pgm
png
ppm
tga
tif
tiff
xbm
xpm

◎ QIconについてメモ。 :

◎ QKeySequence についてメモ。 :

u"""
PySide + QDialogのテスト.

カスタムダイアログを表示して入力値を取得する例.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""
import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class CanvasSizeInputDialog(QDialog):

    u"""キャンバスサイズ入力ダイアログ."""

    DEF_W = 256
    DEF_H = 256

    def __init__(self, *argv, **keywords):
        """init."""
        super(CanvasSizeInputDialog, self).__init__(*argv, **keywords)
        self.setWindowTitle("Input new canvas size")

        # スピンボックスを用意
        self.input_w = QSpinBox(self)
        self.input_h = QSpinBox(self)
        self.input_w.setRange(1, 8192)  # 値の範囲
        self.input_h.setRange(1, 8192)
        self.input_w.setFixedWidth(80)  # 表示する横幅を指定
        self.input_h.setFixedWidth(80)
        self.input_w.setValue(CanvasSizeInputDialog.DEF_W)  # 初期値を設定
        self.input_h.setValue(CanvasSizeInputDialog.DEF_H)

        # ダイアログのOK/キャンセルボタンを用意
        btns = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
            Qt.Horizontal, self)
        btns.accepted.connect(self.accept)
        btns.rejected.connect(self.reject)

        # 各ウィジェットをレイアウト
        gl = QGridLayout()
        gl.addWidget(QLabel("Input new canvas size", self), 0, 0, 1, 4)
        gl.addWidget(self.input_w, 1, 0)
        gl.addWidget(QLabel("x", self), 1, 1)
        gl.addWidget(self.input_h, 1, 2)
        gl.addWidget(btns, 2, 3)
        self.setLayout(gl)

    def canvas_size(self):
        u"""キャンバスサイズを取得。(w, h)で返す."""
        w = int(self.input_w.value())
        h = int(self.input_h.value())
        return (w, h)

    @staticmethod
    def get_canvas_size(parent=None):
        u"""ダイアログを開いてキャンバスサイズとOKキャンセルを返す."""
        dialog = CanvasSizeInputDialog(parent)
        result = dialog.exec_()  # ダイアログを開く
        w, h = dialog.canvas_size()  # キャンバスサイズを取得
        return (w, h, result == QDialog.Accepted)


class MyWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        self.btn = QPushButton("Open Dialog", self)
        self.lbl = QLabel("Ready", self)

        # レイアウト
        l = QVBoxLayout()
        l.addWidget(self.btn)
        l.addWidget(self.lbl)
        self.setLayout(l)

        # ボタンを押したらキャンバスサイズ入力ダイアログを開く
        self.btn.clicked.connect(self.open_input_dialog)

    def open_input_dialog(self):
        u"""キャンバスサイズ入力ダイアログを開いて値を取得."""
        w, h, result = CanvasSizeInputDialog.get_canvas_size(self)
        if result:
            self.lbl.setText("Ok. %d x %d" % (w, h))
        else:
            self.lbl.setText("Cancel.")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

        # ダイアログのOK/キャンセルボタンを用意
        btns = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
            Qt.Horizontal, self)
        btns.accepted.connect(self.accept)
        btns.rejected.connect(self.reject)

        dialog = CanvasSizeInputDialog(parent)
        result = dialog.exec_()  # ダイアログを開く

u"""
GIMPのgplファイルを読み込んでパレットを表示してみるテスト.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4

"""

import os
import re
import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class PalettePreview(QGraphicsView):

    u"""パレットプレビュー用QGraphicsView."""

    valueGetted = Signal(QColor)

    def __init__(self, *argv, **keywords):
        """init."""
        super(PalettePreview, self).__init__(*argv, **keywords)
        self.rgb_data = []
        self.w = 256
        self.h = 128
        self.columns = 16
        self.rows = 8
        self.cw = self.w / self.columns
        self.ch = self.h / self.rows
        self.select_color = QColor(Qt.black)

        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setFixedSize(self.w, self.h)
        self.setBackgroundBrush(QBrush(self.get_bg_chip_image()))

        self.setScene(QGraphicsScene(self))
        pm = QPixmap(self.w, self.h)
        pm.fill(Qt.black)
        self.pal_canvas_item = QGraphicsPixmapItem(pm)
        self.scene().addItem(self.pal_canvas_item)
        self.pal_canvas_item.setOffset(0, 0)

    def make_palette_preview(self, columns, rgb_data):
        u"""パレットプレビュー画像を生成."""
        self.rgb_data = rgb_data
        self.columns = columns
        n = len(rgb_data)
        self.rows = n / columns
        if n % columns != 0 or n < columns:
            self.rows += 1
        self.cw = self.w / self.columns
        self.ch = self.h / self.rows

        # QPixmapに描画
        pm = QPixmap(self.w, self. h)
        pm.fill(QColor(0, 0, 0, 0))
        x, y = 0, 0
        for d in self.rgb_data:
            r, g, b, _ = d
            self.draw_one_palette(pm, x, y, self.cw, self.ch, (r, g, b))
            x += self.cw
            if x >= self.w or x + self.cw > self.w:
                x = 0
                y += self.ch

        self.pal_canvas_item.setPixmap(pm)
        self.scene().setSceneRect(QRectF(0, 0, self.w, self.h))

    def draw_one_palette(self, pm, x, y, w, h, rgb):
        r, g, b = rgb
        brush = QPixmap(w, h)
        brush.fill(QColor(r, g, b, 255))
        qp = QPainter()
        qp.begin(pm)
        qp.drawPixmap(x, y, brush)
        qp.end()
        del qp
        del brush

    def get_bg_chip_image(self):
        u"""背景塗りつぶし用のパターンを作成して返す."""
        c0, c1 = 128, 80
        im = QImage(16, 16, QImage.Format_ARGB32)
        qp = QPainter()
        qp.begin(im)
        qp.fillRect(0, 0, 16, 16, QColor(c0, c0, c0, 255))
        qp.fillRect(0, 0, 8, 8, QColor(c1, c1, c1, 255))
        qp.fillRect(8, 8, 8, 8, QColor(c1, c1, c1, 255))
        qp.end()
        del qp
        return im

    def mousePressEvent(self, event):
        u"""マウスボタンが押された時の処理."""
        if event.button() == Qt.LeftButton:
            scene_pos = self.mapToScene(event.pos())
            x = int(scene_pos.x())
            y = int(scene_pos.y())
            if x < 0 or x >= self.w or y < 0 or y >= self.h:
                return
            idx = (y / self.ch) * self.columns + (x / self.cw)
            if idx < len(self.rgb_data):
                r, g, b, _ = self.rgb_data[idx]
                self.select_color.setRgb(r, g, b, 255)
                self.valueGetted.emit(self.select_color)

    @Slot(QColor)
    def changedValue(self, value):
        """get color."""
        pass


class PaletteSelect(QWidget):

    u"""パレット選択ウィジェット."""

    PAL_DIR = "./palettes"
    DEF_PAL_NAME = "pet2015"

    valueGetted = Signal(QColor)

    def __init__(self, *argv, **keywords):
        """init."""
        super(PaletteSelect, self).__init__(*argv, **keywords)
        self.gpl_data = self.get_gpl_data()

        self.gview = PalettePreview(self)

        idx = 0
        self.combo = QComboBox(self)
        lst = sorted(self.gpl_data.keys())
        for (i, key) in enumerate(lst):
            self.combo.addItem(key)
            if key == PaletteSelect.DEF_PAL_NAME:
                idx = i

        vl = QVBoxLayout()
        vl.addWidget(self.combo)
        vl.addWidget(self.gview)
        self.setLayout(vl)

        self.combo.activated[str].connect(self.change_combo)
        self.gview.valueGetted[QColor].connect(self.clicked_palette_view)

        self.combo.setCurrentIndex(idx)
        self.update_preview(PaletteSelect.DEF_PAL_NAME)

    def change_combo(self, str):
        u"""comboboxが変更された時に呼ばれる処理."""
        self.update_preview(str)

    def clicked_palette_view(self, col):
        u"""パレットプレビューがクリックされた時に呼ばれる処理."""
        self.valueGetted.emit(col)

    def update_preview(self, pal_name):
        u"""パレットプレビューを更新."""
        _, columns, rgb_data = self.gpl_data[pal_name]
        self.gview.make_palette_preview(columns, rgb_data)

    def get_gpl_data(self):
        u"""パレットファイル(.gpl)を読み込み."""
        dir = PaletteSelect.PAL_DIR
        dt = {}
        for fname in os.listdir(dir):
            path, ext = os.path.splitext(fname)
            if ext.lower() == ".gpl":
                d = self.read_gpl_file(dir, fname)
                if d is not None:
                    fname, name, columns, rgb_data = d
                    name = name.lower()
                    dt[name] = (fname, columns, rgb_data)
        return dt

    def read_gpl_file(self, dir, fname):
        u"""gplファイルを1つ読み込んで内容をタブルで返す."""
        name = fname
        columns = 16
        rgb_data = []
        fpath = os.path.join(dir, fname).replace(os.path.sep, '/')

        r1 = re.compile(r"Name:\s+(.+)$")
        r2 = re.compile(r"Columns:\s+(\d+)$")
        r4 = re.compile(r"^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.+)$")
        r5 = re.compile(r"^\s*$")

        f = open(fpath, 'r')
        for (i, s) in enumerate(f):
            s = s.rstrip()
            if i == 0:
                if s != "GIMP Palette":
                    return None
            elif i == 1:
                m = r1.match(s)
                if m:
                    name = m.group(1)
                else:
                    print("Error : %s" & s)
                    return None
            elif i == 2:
                m = r2.match(s)
                if m:
                    columns = int(m.group(1))
                else:
                    print("Error : %s" & s)
                    return None
            elif s.find("#") == 0:
                continue
            elif r5.match(s):
                continue
            else:
                m = r4.match(s)
                if m:
                    r, g, b, colname = m.groups()
                    rgb_data.append([int(r), int(g), int(b), colname])
                else:
                    print("Error : %s" & s)
                    return None
        f.close()
        return (fname, name, columns, rgb_data)


class MyWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        self.palview = PaletteSelect(self)
        self.lbl = QLabel("Ready.")
        l = QVBoxLayout()
        l.addWidget(self.palview)
        l.addWidget(self.lbl)
        self.setLayout(l)

        self.palview.valueGetted[QColor].connect(self.clicked_palette)

    def clicked_palette(self, col):
        u"""パレットプレビューがクリックされた時の処理."""
        r, g, b = col.red(), col.green(), col.blue()
        self.lbl.setText("RGB=(%d, %d, %d)" % (r, g, b))


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

◎ 余談。 :

u"""
PySide + QToolBox の動作確認.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class Dummy(QWidget):

    u"""仮表示用ウィジェット."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(Dummy, self).__init__(*argv, **keywords)
        l = QVBoxLayout(self)
        l.addWidget(QPushButton("Dummy", self))
        l.addWidget(QPushButton("Dummy", self))
        l.addWidget(QPushButton("Dummy", self))
        self.setLayout(l)


class MyWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)

        page1 = Dummy(self)
        page2 = Dummy(self)
        page3 = Dummy(self)

        qtb = QToolBox(self)
        qtb.addItem(page1, "page 1")
        qtb.addItem(page2, "page 2")
        qtb.addItem(page3, "page 3")

        l = QVBoxLayout(self)
        l.addWidget(qtb)
        self.setLayout(l)


def main():
    """main."""
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

◎ QTabWidgetを使った例。 :

ちなみに、QTabWidget を使った例は以下。

_qtabwidget_test.py

u"""
QTabWidgetのテスト.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class Dummy1(QWidget):

    u"""仮表示用ウィジェット1."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(Dummy1, self).__init__(*argv, **keywords)
        l = QVBoxLayout(self)
        l.addWidget(QPushButton("Dummy1", self))
        self.setLayout(l)


class Dummy2(QWidget):

    u"""仮表示用ウィジェット2."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(Dummy2, self).__init__(*argv, **keywords)
        l = QVBoxLayout(self)
        l.addWidget(QPushButton("Dummy2", self))
        self.setLayout(l)


class TestQTabWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(TestQTabWidget, self).__init__(*argv, **keywords)

        tab1 = Dummy1(self)
        tab2 = Dummy2(self)

        qtab = QTabWidget()
        qtab.addTab(tab1, "Tab 1")
        qtab.addTab(tab2, "Tab 2")

        l = QVBoxLayout()
        l.addWidget(qtab)
        self.setLayout(l)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = TestQTabWidget()
    w.show()
    sys.exit(app.exec_())

これもまた、選んだウィジェットは表示されるけど、ソレ以外のウィジェットが非表示になる、という点は変わらないわけで。

◎ ちと考えてること。 :

u"""
Widgetの表示・非表示ができるかどうかのテスト.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class AccordionWidget(QWidget):

    u"""アコーディオンモドキのカスタムウィジェット."""

    layout_changed = Signal()

    def __init__(self, title, parent=None):
        """init."""
        super(AccordionWidget, self).__init__(parent)
        self.title = title
        self.open_flag = True

        self.open_btn = QPushButton("", self)
        self.open_btn.setStyleSheet("text-align: left;")
        self.update_button_text()

        self.mainw = QLabel(self)
        self.mainw.setPixmap("./tmp_bg.png")

        l = QVBoxLayout(self)
        l.addWidget(self.open_btn)
        l.addWidget(self.mainw)
        self.setLayout(l)

        self.open_btn.clicked.connect(self.open_close_main_widget)

    def open_close_main_widget(self):
        u"""メインウィジェットを開いたり閉じたりする処理."""
        if self.open_flag:
            self.mainw.hide()
            self.open_flag = False
        else:
            self.mainw.show()
            self.open_flag = True
        self.update_button_text()
        # self.layout().update()
        self.updateGeometry()
        # self.update()
        self.layout_changed.emit()

    def update_button_text(self):
        u"""開閉ボタンのテキストを設定."""
        if self.open_flag:
            self.open_btn.setText(self.title)
        else:
            self.open_btn.setText(u"> " + self.title)


class TestQTabWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(TestQTabWidget, self).__init__(*argv, **keywords)

        page1 = AccordionWidget("page 1", self)
        page2 = AccordionWidget("page 2", self)
        page3 = AccordionWidget("page 3", self)

        l = QVBoxLayout()
        l.addWidget(page1)
        l.addWidget(page2)
        l.addWidget(page3)
        self.setLayout(l)

        page1.layout_changed.connect(self.changed_layout)
        page2.layout_changed.connect(self.changed_layout)
        page3.layout_changed.connect(self.changed_layout)

    def changed_layout(self):
        u"""レイアウトが変更された時に呼ばれる処理."""
        # レイアウトを再計算させるときは以下のように書くらしい
        self.layout().activate()
        self.resize(self.sizeHint())


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = TestQTabWidget()
    w.show()
    sys.exit(app.exec_())

layout.activate()
self.resize(self.sizeHint())

self.open_btn.setStyleSheet("text-align: left;")

◎ ボタンに記号を表示したいのだけど。 :

◎ 症状をメモ。 :

◎ 電源部分についてるスイッチについて。 :

◎ 関連ページをメモ。 :

u"""
Pillow(PIL)のImageQtについて動作確認.

動作確認 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""

from PySide import QtGui
import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA
sys.modules['PyQt4.QtGui'] = QtGui   # PyQt4を使わないようにしている
from PIL import Image
from PIL import ImageQt


class MyWidget(QWidget):

    """main window."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        img = Image.open("./tmp_00_default.png")
        img = img.convert("RGBA")
        qimg = ImageQt.ImageQt(img)
        pm = QPixmap.fromImage(QImage(qimg))

        lbl = QLabel(self)
        lbl.setPixmap(pm)
        self.setLayout(QVBoxLayout())
        self.layout().addWidget(lbl)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

◎ QGraphicsSceneで表示してるアレコレの透明度。 :

◎ ウィジェットの隙間を少なくしたい。 :

>>> from PIL import Image, ImageDraw
>>> help(ImageDraw.floodfill)
Help on function floodfill in module PIL.ImageDraw:

floodfill(image, xy, value, border=None)
    (experimental) Fills a bounded region with a given color.
    
    :param image: Target image.
    :param xy: Seed position (a 2-item coordinate tuple).
    :param value: Fill color.
    :param border: Optional border value.  If given, the region consists of
        pixels with a color different from the border color.  If not given,
        the region consists of pixels having the same color as the seed
        pixel.

u"""
PIL(Pillow)のfloodfillを試す.

PIL(Pillow)には、文書化されていないが floodfill という関数があって、
塗りつぶし処理ができるらしい。

動作確認環境 : Windows10 x64 + Python 2.7.12 + Pillow 3.4.2
"""

from PIL import Image
from PIL import ImageDraw
import time

im = Image.open("./tmp_image.png")

start = time.time()
ImageDraw.floodfill(im, (64, 64), (255, 0, 0, 255), border=None)
ImageDraw.floodfill(im, (200, 240), (0, 255, 0, 255), border=None)
ImageDraw.floodfill(im, (480, 400), (0, 0, 255, 255), border=None)
etime = time.time() - start
print("%f" % etime)

im.save("./tmp_image_result.png")

◎ QImageからPIL Imageへの変換。 :

u"""
Pillow(PIL)のImageQtについて動作確認.

動作確認 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4 + Pillow 3.4.2
"""

use_pyside = True

import sys

if use_pyside:
    # use PySide

    # import PySide
    # sys.modules['PyQt4'] = PySide

    # ここでPyQt4を使わないようにしているはず…なのだが…
    from PySide import QtGui
    from PySide import QtCore
    sys.modules['PyQt4.QtGui'] = QtGui
    sys.modules['PyQt4.QtCore'] = QtCore

    from PySide.QtCore import *  # NOQA
    from PySide.QtGui import *   # NOQA
else:
    # use PyQt4
    from PyQt4.QtCore import *  # NOQA
    from PyQt4.QtGui import *   # NOQA

from PIL import Image
from PIL import ImageQt


class MyWidget(QWidget):

    def __init__(self, *argv, **keywords):
        super(MyWidget, self).__init__(*argv, **keywords)

        layout = QGridLayout()

        lst = [
            "./tmp_grayscale.png",
            "./tmp_indexed.png",
            "./tmp_rgb.png",
            "./tmp_rgba.png"
        ]

        for i, fpath in enumerate(lst):
            im = Image.open(fpath)
            old_im_mode = im.mode

            if im.mode != "RGBA":
                im = im.convert("RGBA")
            print("im.mode %s -> %s" % (old_im_mode, im.mode))

            qim1 = ImageQt.ImageQt(im)

            qim2 = QImage(qim1)
            pm = QPixmap.fromImage(qim2)
            lbl = QLabel(old_im_mode, self)
            lbl.setPixmap(pm)
            layout.addWidget(lbl, i / 2, i % 2)

        self.setLayout(layout)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

• グレースケール、インデックスカラー、RGB、RGBA、の4つ画像を、PIL の Image.open() で読み込んで、
• PIL の ImageQt を使って PySide の QImage に変換してから、
• 得られた QImage を QPixmap に変換して、ラベルウィジェットを使って表示。

>>> from PIL import Image
>>> im = Image.open("hoge.png")
>>> im.mode

• "1" : 1bit画像。白黒のみの画像。
• "L" : グレースケール画像。256色のパレットを持っていて、パレットは0(黒)〜255(白)が割り当てられてる。
• "P" : インデックスカラー画像。256色以下のパレットを持っている。
• "RGB" : RGB画像。アルファチャンネルは持ってない。
• "RGBA" : RGBA画像。アルファチャンネルを持っている。

u"""
QImageを使って画像フォーマットを確認する.

L(グレースケール)、P(インデックスカラー)、RGB、RGBAを判断する。

動作確認 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4 + Pillow 3.4.2
"""

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class MyWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)

        l = QVBoxLayout()
        tb = QTextEdit(self)
        l.addWidget(tb)
        self.setLayout(l)

        lst = [
            "./tmp_1bit.png",
            "./tmp_grayscale.png",
            "./tmp_indexed.png",
            "./tmp_rgb.png",
            "./tmp_rgba.png"
        ]

        for i, fpath in enumerate(lst):
            qim = QImage(fpath)
            ret = self.get_image_mode(qim)
            tb.append("%s is %s" % (fpath, ret))

    def get_image_mode(self, qim):
        u"""画像モードを調べて返す.

        PIL Image.mode と同様、1,L,P,RGB,RGBAで返す。
        """
        ret = ""
        fmt = qim.format()
        if fmt == QImage.Format_Mono:
            ret = "1"
        elif fmt == QImage.Format_MonoLSB:
            ret = "1"
        elif fmt == QImage.Format_Indexed8:
            ret = "L" if qim.allGray() else "P"
        elif fmt == QImage.Format_RGB32:
            ret = "RGB"
        elif fmt == QImage.Format_ARGB32:
            ret = "RGBA"
        else:
            ret = "UNKNOWN"
            print(f)
        del qim
        return ret

if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

u"""
QPixmap → QImage → PIL Image に変換して塗り潰しの処理をしてみる.

ImageQtに相当するクラスをスクリプト内に置いてみた版。
Pillow のバージョンが上がれば、このクラスは不要になるかもしれない。

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4 + Pillow 3.4.2
"""

import cStringIO
import sys

# ここでPyQt4を使わないようにしているはず…なのだが…
from PySide import QtGui
from PySide import QtCore
sys.modules['PyQt4.QtGui'] = QtGui
sys.modules['PyQt4.QtCore'] = QtCore

from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA

from PIL import Image
from PIL import ImageDraw
# from PIL import ImageQt


class ImageQtPoor(QImage):

    u"""ImageQt substitute. Supports only RGBA image."""

    def __init__(self, im):
        """convert PIL Image to PySide QImage."""
        self.org_mode = im.mode
        if im.mode != "RGBA":
            im = im.convert("RGBA")
        w, h = im.size
        fmt = QImage.Format_ARGB32
        self.__data = im.tobytes("raw", "BGRA")
        super(ImageQtPoor, self).__init__(self.__data, w, h, fmt)

    @staticmethod
    def fromqimage(qim):
        """convert PySide QImage ro PIL Image."""
        buf = QBuffer()
        buf.open(QIODevice.ReadWrite)
        qim.save(buf, "PNG")
        fp = cStringIO.StringIO()
        fp.write(buf.data())
        buf.close()
        fp.seek(0)
        return Image.open(fp)

    @staticmethod
    def toqimage(pim):
        """convert PIL Image to PySide QImage."""
        fp = cStringIO.StringIO()
        pim.save(fp, "PNG")
        qim = QImage()
        qim.loadFromData(fp.getvalue(), "PNG")
        return qim


class GView(QGraphicsView):

    u"""画像アイテム表示用."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(GView, self).__init__(*argv, **keywords)
        self.setBackgroundBrush(Qt.gray)
        scene = QGraphicsScene(self)
        self.setScene(scene)

        pm = QPixmap("./tmp_rgba.png")
        self.pm_item = QGraphicsPixmapItem(pm)
        scene.addItem(self.pm_item)

    def mousePressEvent(self, event):
        u"""マウスクリックした際に呼ばれる処理."""
        p = self.mapToScene(event.pos())
        x, y = int(p.x()), int(p.y())

        pm = self.pm_item.pixmap()         # QPixmapを取得
        qim = pm.toImage()                 # QImageに変換
        pim = ImageQtPoor.fromqimage(qim)  # PIL Imageに変換
        if pim.mode != "RGBA":
            pim = pim.convert("RGBA")

        # 塗り潰し(Flood Fill)をする
        ImageDraw.floodfill(pim, (x, y), (128, 0, 64, 255))

        qim2 = ImageQtPoor(pim)            # PIL Image → QImageに変換
        # qim2 = ImageQtPoor.toqimage(pim)

        pm2 = QPixmap.fromImage(qim2)      # QPixmapに変換
        self.pm_item.setPixmap(pm2)


class MyWidget(QWidget):

    u"""メインウインドウ相当."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        gv = GView(self)
        l = QVBoxLayout()
        l.addWidget(gv)
        self.setLayout(l)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

Qt.NoOpaqueDetection

イメージに不透明でないピクセルが含まれているかどうかを確認しないでください。 画像が半透明で、不透明でないピクセルが見つかるまで画像のピクセルをチェックするオーバーヘッドを避けたい場合や、その他の理由でピックスマップにアルファチャンネルを保持させたい場合は、これを使用します。 画像にアルファチャンネルがない場合、このフラグは効果がありません。

u"""
QCursorのテスト。マウスカーソルを変更する.

動作確認環境 : Windows10 x64 + Python 2.7.12 + PySide 1.2.4
"""

import sys
from PySide.QtCore import *  # NOQA
from PySide.QtGui import *   # NOQA


class GView(QGraphicsView):

    """GraphicsView."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(GView, self).__init__(*argv, **keywords)

        scene = QGraphicsScene(self)
        self.setScene(scene)

        pm = QPixmap(320, 240)
        pm.fill(QColor(192, 192, 192, 255))
        pitem = QGraphicsPixmapItem(pm)
        scene.addItem(pitem)

        lst = [
            ("pen", "./mouse_cursor_pen.png", 0, 0),
            ("eraser", "./mouse_cursor_eraser.png", 0, 0),
            ("picker", "./mouse_cursor_picker.png", 9, 22),
            ("fill", "./mouse_cursor_fill.png", 9, 22),
        ]
        self.curs = []
        for d in lst:
            name, filepath, hx, hy = d
            cur_pm = QPixmap(filepath)
            cur = QCursor(cur_pm, hotX=hx, hotY=hy)
            self.curs.append(cur)

        self.cur_idx = 0
        self.setCursor(self.curs[self.cur_idx])

    def mousePressEvent(self, event):
        u"""マウスボタンが押された時の処理."""
        # 左もしくは右ボタンを押したらマウスカーソルを変更
        if event.button() == Qt.LeftButton:
            self.cur_idx = (self.cur_idx + 1) % len(self.curs)
        elif event.button() == Qt.RightButton:
            self.cur_idx = (self.cur_idx - 1 + len(self.curs)) % len(self.curs)
        else:
            return

        self.setCursor(self.curs[self.cur_idx])  # マウスカーソルを設定

    def mouseReleaseEvent(self, event):
        u"""マウスボタンが離された時の処理."""
        pass
        # self.unsetCursor()


class MyWidget(QWidget):

    """Main Window."""

    def __init__(self, *argv, **keywords):
        """init."""
        super(MyWidget, self).__init__(*argv, **keywords)
        l = QVBoxLayout()
        l.addWidget(QLabel("Dummy", self))
        l.addWidget(QLabel("Dummy", self))
        l.addWidget(GView(self))
        l.addWidget(QLabel("Dummy", self))
        l.addWidget(QLabel("Dummy", self))
        self.setLayout(l)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MyWidget()
    w.show()
    sys.exit(app.exec_())

• cx_Freeze を使う。
• py2exe を使う。
• Pyinstaller を使う。

◎ py2exeのインストール。 :

◎ 設定ファイル setup.cy を書く。 :

# -*- coding: utf-8 -*-
"""py2exe config."""

import sys
import os

if sys.platform == "win32":
    # Windows
    import py2exe
    from distutils.core import setup

    IMAGELIB_DIR = r"D:\Python\Python27\Lib\site-packages\PySide\plugins\imageformats"
    imgfiles = [os.path.join(IMAGELIB_DIR, i) for i in [
        "qgif4.dll",
        "qgifd4.dll",
        "qico4.dll",
        "qicod4.dll",
        "qjpeg4.dll",
        "qjpegd4.dll",
        "qmng4.dll",
        "qmngd4.dll",
        "qsvg4.dll",
        "qsvgd4.dll",
        "qtga4.dll",
        "qtgad4.dll",
        "qtiff4.dll",
        "qtiffd4.dll",
    ]]

    data_files = [("imageformats", imgfiles)]

    py2exe_options = {
        "compressed": 1,
        "optimize": 2,
        "bundle_files": 3
    }

    setup(
        data_files=data_files,
        options={"py2exe": py2exe_options},
        # console = [
        windows=[
            {"script": "stampixelart.py"}
        ],
        zipfile="lib/libs.zip"
    )

if sys.platform == 'darwin':
    # OS X
    pass

if sys.platform == 'linux2':
    # Linux
    pass

◎ exe化を実行。 :

*** binary dependencies ***
Your executable(s) also depend on these dlls which are not included,
you may or may not need to distribute them.

Make sure you have the license if you distribute any of them, and
make sure you don't distribute files belonging to the operating system.

   OLEAUT32.dll - C:\WINDOWS\system32\OLEAUT32.dll
   USER32.dll - C:\WINDOWS\system32\USER32.dll
   IMM32.dll - C:\WINDOWS\system32\IMM32.dll
   SHELL32.dll - C:\WINDOWS\system32\SHELL32.dll
   ole32.dll - C:\WINDOWS\system32\ole32.dll
   MSVCP90.dll - C:\Program Files (x86)\Intel\OpenCL SDK\2.0\bin\x86\MSVCP90.dll
   WINMM.dll - C:\WINDOWS\system32\WINMM.dll
   COMDLG32.dll - C:\WINDOWS\system32\COMDLG32.dll
   ADVAPI32.dll - C:\WINDOWS\system32\ADVAPI32.dll
   WS2_32.dll - C:\WINDOWS\system32\WS2_32.dll
   WINSPOOL.DRV - C:\WINDOWS\system32\WINSPOOL.DRV
   GDI32.dll - C:\WINDOWS\system32\GDI32.dll
   VERSION.dll - C:\WINDOWS\system32\VERSION.dll
   KERNEL32.dll - C:\WINDOWS\system32\KERNEL32.dll

sudo apt-get install python-pyside

sudo pip install Pillow

◎ ビルドしてみた。 :

$ python
Python 2.7.12 (default, Nov 19 2016, 06:48:10) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import PySide
>>> PySide.__version__
'1.2.4'

◎ 簡単にインストールできるスクリプトもあるっぽい。 :