pyqt5 Qlabel关于图片的展示

ReCombination

已于 2024-09-30 15:36:12 修改

阅读量8k

点赞数 24

文章标签： pyqt qt

于 2023-07-08 14:09:13 首次发布

本文链接：https://blog.csdn.net/qq_36500197/article/details/131611022

版权

在使用Qlabel展示图片时，有时图片尺寸过大，且没有指定Label大小时，就会把窗口撑得很大，如果指定Label大小，如设置了max尺寸或者fixed直接固定死，那么这时候图片可以正常放在Label里面，但是会有拉伸的问题

简单的例子:

不指定Label尺寸

class TestWin(QMainWindow):
    def __init__(self, parent=None):
        super(TestWin, self).__init__(parent)
        self.resize(1000,400)
        label = QLabel()
        pixmap = QPixmap("E:\我的坚果云\Mapixel\lyric_background.jpg")
        label.setPixmap(pixmap)
        self.setCentralWidget(label)

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

效果:-> 整个屏幕都放不下

指定Label尺寸：

class TestWin(QMainWindow):
    def __init__(self, parent=None):
        super(TestWin, self).__init__(parent)
        self.resize(1000,400)
        label = QLabel()
        label.setFixedSize(1000, 400)
        pixmap = QPixmap("E:\我的坚果云\Mapixel\lyric_background.jpg")
        label.setPixmap(pixmap)
        self.setCentralWidget(label)

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

效果:-> 窗口不撑的很大了，但是图片展示不全

指定尺寸，并且增加自适应：

class TestWin(QMainWindow):
    def __init__(self, parent=None):
        super(TestWin, self).__init__(parent)
        self.resize(1000,400)
        label = QLabel()
        label.setFixedSize(1000, 400)
        pixmap = QPixmap("E:\我的坚果云\Mapixel\lyric_background.jpg")
        label.setScaledContents(True)
        label.setPixmap(pixmap)
        self.setCentralWidget(label)

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

效果:->显示完全了，但是图片被拉伸

Label需要展示不同尺寸的图片，这样显然很迟钝，那我们去掉尺寸限制和自适应，自己给它个比例，图片是什么样的就按什么样的来展示就行了

class TestWin(QMainWindow):
    def __init__(self, parent=None):
        super(TestWin, self).__init__(parent)
        self.resize(1000,400)
        label = QLabel()
        # label.setFixedSize(1000, 400)
        pixmap = QPixmap("E:\我的坚果云\Mapixel\lyric_background.jpg")
        proportion = pixmap.height() / self.height()
        pixmap.setDevicePixelRatio(proportion)
        # label.setScaledContents(True)
        label.setPixmap(pixmap)
        self.setCentralWidget(label)

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

效果: 既不会撑大窗口，也不会丢失比例，因为比例的分母最大就是self.height()，当然令写一个数字大于当前窗口高就另外一个效果，也可以使用其他值，比如300(当前窗口高400)

比例分母300：依旧维持原比例展示

如果想要图片随窗口变化而变化的话就要自定义一个窗口了

如：

class CustomizeWin(QMainWindow):
    ResizeEvent = pyqtSignal(QSize)

    def __init__(self):
        super().__init__()

    def resizeEvent(self, a0: QResizeEvent) -> None:
        super().resizeEvent(a0)
        self.ResizeEvent.emit(a0.size())
class TestWin(CustomizeWin):
    def __init__(self):
        super(TestWin, self).__init__()
        self.init_size = QSize(1000,400)
        self.resize(self.init_size)
        self.label_height = 300
        self.label = QLabel()
        self.ResizeEvent.connect(self.pixmap_extend)
        pixmap = QPixmap("E:\我的坚果云\Mapixel\lyric_background.jpg")
        proportion = pixmap.height() / self.label_height
        pixmap.setDevicePixelRatio(proportion)
        self.label.setPixmap(pixmap)
        self.setCentralWidget(self.label)

    def pixmap_extend(self, size:QSize):
        pixmap = self.label.pixmap()
        proportion = pixmap.height() / ((size.height() / self.init_size.height()) * self.label_height)
        pixmap.setDevicePixelRatio(proportion)
        self.label.setPixmap(pixmap)

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

效果:

以下是我个人自定义的QLabel组件:

Python代码：

参数:

object_name:  对象名称，当多次实例化该组件时，内部数据需要对象名称作为区分标识，否则会造成混淆
sync_text:       要显示的文本字符串
sync_enable: Union[bool] = False   自定义模式进入标识，默认为False
integrating_enable: Union[bool] = False  图像嵌套标识，默认为False
integrating_pixmap: Union[str, QPixmap] = False  需要嵌套的图像，默认没有
sync_pixel: Union[str, QPixmap] = False    自定义模式开启情况下，需要显示的图像，
sync_pixel_pos: Union[list, tuple[int, int]] = (0, 0)  自定义模式开启情况下，图像的起始坐标位置
sync_font_option: Union[list[list[MouseAction, QFont]]] = ((MouseAction.Normal, QFont(Font.YouYuan, 16)),)   自定义模式开启情况下，可以设置的文本颜色，包括鼠标按压-释放-进入-离开的颜色设置
sync_color_option: Union[list[list[MouseAction, QColor]]] = ((MouseAction.Normal, QColor(qRgb(155, 186, 200))), )  自定义模式开启情况下，可以设置的文本字体，与颜色同理
sync_text_pos: Union[list, tuple[int, int]] = (0, 0)  自定义模式开启情况下，文本的起始坐标位置
sync_draw_type: Union[DrawType] = DrawType.DrawRect): 自定义模式开启情况下，图像显示模式，可选择四边形或者圆形

from collections import defaultdict
from typing import Union
from PyQt5.QtCore import QPoint, Qt, pyqtSignal, QRect
from PyQt5.QtGui import (QFont, QMouseEvent, QPixmap, QColor, QPaintEvent, QPainter, QPen, qRgb, QIcon, QResizeEvent, QFontMetrics,
                         QBrush)
from PyQt5.QtWidgets import QLabel, QMenu, QAction
from PublicSourceSection.PublicEnum.PublicEnumClass import *
from PublicSourceSection.PublicSheetStyle.Sheetstyle_Initialize import *
class MouseAction(Enum):
    Normal = 'Normal'
    MousePressedEvent = 'MousePressedEvent'
    MouseReleaseEvent = 'MouseReleaseEvent'
    MouseRnterEvent = 'MouseRnterEvent'
    MouseLeaveEvent = 'MouseLeaveEvent'

class DrawType(Enum):
    DrawRound = 'DrawRound'
    DrawRect = 'DrawRect'
class NLabel(QLabel, ICmeiaPlayStyle):
    MousePressEvent = pyqtSignal(QMouseEvent)
    MouseReleaseEvent = pyqtSignal(QMouseEvent)
    MouseEnterEvent = pyqtSignal(list)
    MenuCheckEvent = pyqtSignal(str)
    MouseMoveEvent = pyqtSignal(list)
    active_dict = defaultdict(str)
    integer_dict = defaultdict(int)
    nest_dict = defaultdict(dict)

    def __init__(self, object_name: Union[str],
                 sync_text: Union[str] = '',
                 sync_enable: Union[bool] = False,
                 integrating_enable: Union[bool] = False,
                 integrating_pixmap: Union[str, QPixmap] = False,
                 sync_pixel: Union[str, QPixmap] = False,
                 sync_pixel_pos: Union[list, tuple[int, int]] = (0, 0, 0, 0),
                 sync_font_option: Union[list[list[MouseAction, QFont]]] = ((MouseAction.Normal, QFont(Font.YouYuan, 16)),),
                 sync_color_option: Union[list[list[MouseAction, QColor]]] = ((MouseAction.Normal, QColor(qRgb(155, 186, 200))), ),
                 sync_text_pos: Union[list, tuple[int, int]] = (0, 0, 0, 0),
                 sync_draw_type: Union[DrawType] = DrawType.DrawRect):
        super().__init__()

        self.setMouseTracking(True)
        self.setAlignment(Qt.AlignCenter)
        self.sync_enable = sync_enable
        self.integrating_enable = integrating_enable
        self.setObjectName(object_name)
        self.setText(sync_text)
        self.setFont(sync_font_option)
        self.setColor(sync_color_option)
        self.setDrawType(sync_draw_type)
        if isinstance(sync_pixel, str):
            self.setPixmap(QPixmap(sync_pixel))
        elif isinstance(sync_pixel, QPixmap):
            self.setPixmap(sync_pixel)
        if isinstance(integrating_pixmap, str):
            self.setIntegratingPixmap(QPixmap(integrating_pixmap))
        elif isinstance(integrating_pixmap, QPixmap):
            self.setIntegratingPixmap(integrating_pixmap)
        else:
            self.setIntegratingPixmap(None)
        self.sync_pixel_left = sync_pixel_pos[0]
        self.sync_pixel_top = sync_pixel_pos[1]
        self.sync_text_left = sync_text_pos[0]
        self.sync_text_top = sync_text_pos[1]

        self.item_addmenu = QMenu()
        self.item_addmenu_register = ['Left_SourceAddLabel']
        self.item_addmenu.setStyleSheet(self.Botton_PlayModeMenu_Stl)
        self.item_addmenu.addAction(QAction(QIcon(':/private.png'), 'Add-Private', self.item_addmenu))
        self.item_addmenu.addAction(QAction(QIcon(':/file-addition.png'), 'Add-File', self.item_addmenu))
        self.item_addmenu.addAction(QAction(QIcon(':/folder-addition.png'), 'Add-Folder', self.item_addmenu))
        self.item_addmenu.setMinimumWidth(QFontMetrics(QFont('SimSun', 13)).width('Add-Private'))

        self.item_takemenu = QMenu()
        self.item_takemenu.adjustSize()
        self.item_takemenu_register = ['Left_SourceDeleteLabel']
        self.item_takemenu.setStyleSheet(self.Botton_PlayModeMenu_Stl)
        self.item_takemenu.addAction(QAction(QIcon(':/private_take.png'), 'Take-PrivateItem', self.item_takemenu))
        self.item_takemenu.addAction(QAction(QIcon(':/table_take.png'), 'Take-TableItem', self.item_takemenu))
        self.item_takemenu.setMinimumWidth(QFontMetrics(QFont('SimSun', 13)).width('Take-PrivateItem'))


    def setObjectName(self, name: str) -> None:
        super().setObjectName(name)
        self.replace_object = self.nest_dict[self.objectName()]
        self.replace_object['WindowHeight'] = self.height()
        self.replace_object['SyncEnable'] = self.sync_enable
        self.replace_object['Font'] = defaultdict(dict)
        self.replace_object['Color'] = defaultdict(dict)
        self.replace_object['SyncPixelImage'] = False

    def setText(self, a0: str) -> None:
        self.replace_object['SyncText'] = a0

    def setColor(self, color: list):
        for config_color in color:
            key = ''
            value = ''
            if len(config_color) >= 2:
                for color_item in config_color:
                    if isinstance(color_item, MouseAction):
                        key = color_item.value
                    elif isinstance(color_item, QColor):
                        value = color_item
            else:
                continue
            self.replace_object['Color'].update({key: value})
        normal_color = self.replace_object['Color'][MouseAction.Normal.value]
        for dict_key in list(MouseAction):
            if dict_key.value in self.replace_object['Color'].keys():
                continue
            else:
                self.replace_object['Color'][dict_key.value] = normal_color
        self.replace_object['SyncTextColor'] = normal_color

    def setFont(self, font: list) -> None:
        if isinstance(font, QFont):
            self.replace_object['Font'].update({MouseAction.Normal: QFont})
        else:
            for config_font in font:
                key = ''
                value = ''
                if len(config_font) >= 2:
                    for font_item in config_font:
                        if isinstance(font_item, MouseAction):
                            key = font_item.value
                        elif isinstance(font_item, QFont):
                            value = font_item
                    self.replace_object['Font'].update({key: value})
                else:
                    continue
        normal_font = self.replace_object['Font'][MouseAction.Normal.value]
        for dict_key in list(MouseAction):
            if dict_key.value in self.replace_object['Font'].keys():
                continue
            else:
                self.replace_object['Font'][dict_key.value] = normal_font
        self.replace_object['SyncTextFont'] = normal_font

    def setDrawType(self, drawtype: DrawType):
        self.replace_object['DrawType'] = drawtype

    def mousePressEvent(self, event: QMouseEvent) -> None:
        if event.button() == Qt.LeftButton:
            self.MousePressEvent.emit(event)
            self.replace_object['SyncTextFont'] = self.replace_object['Font'][MouseAction.MousePressedEvent.value]
            self.replace_object['SyncTextColor'] = self.replace_object['Color'][MouseAction.MousePressedEvent.value]
            self.update()

    def mouseReleaseEvent(self, event: QMouseEvent) -> None:
        if event.button() == Qt.LeftButton:
            self.MouseReleaseEvent.emit(event)
            if self.objectName() in self.item_addmenu_register:
                self.item_addmenu.popup(self.mapToGlobal(QPoint(self.replace_object['Width'] // 2, 0)))
            if self.objectName() in self.item_takemenu_register:
                self.item_takemenu.popup(self.mapToGlobal(QPoint(self.replace_object['Width'] // 2, 0)))

            self.replace_object['SyncTextFont'] = self.replace_object['Font'][MouseAction.MouseReleaseEvent.value]
            self.replace_object['SyncTextColor'] = self.replace_object['Color'][MouseAction.MouseReleaseEvent.value]
            self.update()

    def enterEvent(self, event) -> None:
        self.MouseEnterEvent.emit([True, self.objectName()])
        self.replace_object['SyncTextFont'] = self.replace_object['Font'][MouseAction.MouseRnterEvent.value]
        self.replace_object['SyncTextColor'] = self.replace_object['Color'][MouseAction.MouseRnterEvent.value]
        self.update()

    def leaveEvent(self, event) -> None:
        self.MouseEnterEvent.emit([False, self.objectName()])
        self.replace_object['SyncTextFont'] = self.replace_object['Font'][MouseAction.MouseLeaveEvent.value]
        self.replace_object['SyncTextColor'] = self.replace_object['Color'][MouseAction.MouseLeaveEvent.value]
        self.update()

    def mouseMoveEvent(self, event) -> None:
        self.MouseMoveEvent.emit([True, self.objectName()])

    def setPixmap(self, a0: QPixmap) -> None:
        if self.replace_object['SyncEnable'] and isinstance(a0, QPixmap):
            self.replace_object['SyncPixelImage'] = a0
        else:
            super().setPixmap(a0)
        self.update()

    def setIntegratingPixmap(self, pixmap: Union[QPixmap, None]):
        if self.integrating_enable and isinstance(pixmap, QPixmap):
            self.replace_object['IntegratingPixmap'] = pixmap
        else:
            if 'IntegratingPixmap' in self.replace_object.keys():
                self.replace_object['IntegratingPixmap'] = QPixmap()

    def paintEvent(self, a0: QPaintEvent) -> None:
        painter = QPainter(self)
        painter.setRenderHints(QPainter.LosslessImageRendering)
        painter.setRenderHints(QPainter.SmoothPixmapTransform)
        painter.setRenderHints(QPainter.TextAntialiasing)
        painter.setRenderHints(QPainter.Antialiasing)
        synctext_width = QFontMetrics(self.replace_object['SyncTextFont']).width(self.replace_object['SyncText'])
        if 'Width_Proportion' in self.replace_object.keys():
            width_proportion = self.replace_object['Width_Proportion']
        else:
            width_proportion = 1
        if 'Height_Proportion' in self.replace_object.keys():
            height_proportion = self.replace_object['Height_Proportion']
        else:
            height_proportion = 1

        if self.replace_object['SyncEnable']:
            expected_pixmap_proportion = (self.replace_object['SyncPixelImage'].height() / self.replace_object['Height']
            if isinstance(self.replace_object['SyncPixelImage'], QPixmap) else 1)
            expected_pixmap_width = (round(self.replace_object['SyncPixelImage'].width() // expected_pixmap_proportion)
            if isinstance(self.replace_object['SyncPixelImage'], QPixmap) else 0)
            _centra_pixelpos = (self.replace_object['Width'] - expected_pixmap_width) // 2
            _centra_textpos = (self.replace_object['Width'] - synctext_width) // 2
            if self.replace_object['SyncPixelImage'] and self.replace_object['SyncText']:
                painter.setPen(Qt.NoPen)
                self.replace_object['SyncPixelImage'].setDevicePixelRatio(expected_pixmap_proportion)
                if self.integrating_enable:
                    pixel_start_x = self.sync_pixel_left * width_proportion + _centra_pixelpos
                else:
                    pixel_start_x = self.sync_pixel_left * width_proportion
                pixel_start_y = self.sync_pixel_top * height_proportion
                pixel_start_w = expected_pixmap_width
                pixel_start_h = self.replace_object['Height']
                if self.replace_object['DrawType'] == DrawType.DrawRect:
                    image_rect = QRect(pixel_start_x, pixel_start_y, pixel_start_w, pixel_start_h)
                    painter.drawPixmap(image_rect, self.replace_object['SyncPixelImage'])
                else:
                    image_rect = QRect(pixel_start_x, pixel_start_y, self.replace_object['Height'], self.replace_object['Height'])
                    radius = self.replace_object['SyncPixelImage'].height() // 2
                    pixel = self.replace_object['SyncPixelImage'].scaled(self.replace_object['SyncPixelImage'].size(),
                                                                         Qt.IgnoreAspectRatio,
                                                                         Qt.SmoothTransformation)
                    round_brush = QBrush(pixel)
                    painter.setBrush(round_brush)
                    painter.drawRoundedRect(image_rect, radius, radius, Qt.SizeMode.AbsoluteSize)
                painter.setPen(QPen(self.replace_object['SyncTextColor']))
                painter.setFont(self.replace_object['SyncTextFont'])
                if self.integrating_enable:
                    text_start_x = self.sync_text_left * width_proportion + _centra_textpos
                else:
                    text_start_x = pixel_start_x + expected_pixmap_width + self.sync_text_left * width_proportion
                text_start_y = self.sync_text_top * height_proportion
                text_start_w = self.replace_object['Width'] - expected_pixmap_width
                text_start_h = self.replace_object['Height']
                text_rect = QRect(text_start_x, text_start_y, text_start_w, text_start_h)
                painter.drawText(text_rect, Qt.AlignJustify | Qt.AlignVCenter, self.replace_object['SyncText'])
                setFixedWidth(text_start_x + synctext_width);

            elif not self.replace_object['SyncPixelImage'] and self.replace_object['SyncText']:
                painter.setFont(self.replace_object['SyncTextFont'])
                painter.setPen(QPen(self.replace_object['SyncTextColor']))
                text_start_x = self.sync_text_left * width_proportion
                text_start_y = self.sync_text_top * height_proportion
                text_start_w = self.replace_object['Width']
                text_start_h = self.replace_object['Height']
                text_rect = QRect(text_start_x, text_start_y, text_start_w, text_start_h)
                painter.drawText(text_rect, Qt.AlignJustify | Qt.AlignVCenter, self.replace_object['SyncText'])

            elif self.replace_object['SyncPixelImage'] and not self.replace_object['SyncText']:
                painter.setPen(Qt.NoPen)
                self.replace_object['SyncPixelImage'].setDevicePixelRatio(expected_pixmap_proportion)
                pixel_start_x = self.sync_pixel_left * width_proportion
                pixel_start_y = self.sync_pixel_top * height_proportion
                pixel_start_w = self.replace_object['Width']
                pixel_start_h = self.replace_object['Height']
                if self.replace_object['DrawType'] == DrawType.DrawRect:
                    image_rect = QRect(pixel_start_x, pixel_start_y, pixel_start_w, pixel_start_h)
                    painter.drawPixmap(image_rect, self.replace_object['SyncPixelImage'])
                else:
                    image_rect = QRect(pixel_start_x, pixel_start_y, self.replace_object['Height'], self.replace_object['Height'])
                    radius = self.replace_object['SyncPixelImage'].height() // 2
                    pixel = self.replace_object['SyncPixelImage'].scaled(self.replace_object['SyncPixelImage'].size(), Qt.IgnoreAspectRatio,Qt.SmoothTransformation)
                    round_brush = QBrush(pixel)
                    painter.setBrush(round_brush)
                    painter.drawRoundedRect(image_rect, radius, radius, Qt.SizeMode.AbsoluteSize)

            if 'IntegratingPixmap' in self.replace_object.keys() and self.replace_object['IntegratingPixmap'].width():
                pixel_start_w = self.replace_object['Width']
                pixel_start_h = self.replace_object['Height']
                integrating_pixmap = self.replace_object['IntegratingPixmap']
                expected_pixmap_proportion = integrating_pixmap.height() / 20
                expected_pixmap_width = integrating_pixmap.width() // expected_pixmap_proportion
                integrating_pixmap.setDevicePixelRatio(expected_pixmap_proportion)
                _centra_pixelposx = (pixel_start_w - expected_pixmap_width) // 2
                _centra_pixelposy = (pixel_start_h - 20) // 2
                painter.drawPixmap(round(_centra_pixelposx), round(_centra_pixelposy), integrating_pixmap)

        else:
            super().paintEvent(a0)

    def resizeEvent(self, a0: QResizeEvent) -> None:
        super().resizeEvent(a0)
        width = a0.size().width()
        height = a0.size().height()
        if 'Width' in self.replace_object.keys() and width != self.replace_object['Width']:
            proportion = width // self.replace_object['Width']
            if proportion <1:
                self.replace_object['Width_Proportion'] = 1
            else:
                self.replace_object['Width_Proportion'] = proportion
        if 'Height' in self.replace_object.keys() and height != self.replace_object['Height']:
            proportion = width // self.replace_object['Height']
            if proportion <1:
                self.replace_object['Height_Proportion'] = 1
            else:
                self.replace_object['Height_Proportion'] = proportion
        self.replace_object['Width'] = width
        self.replace_object['Height'] = height
        self.update()

定义了鼠标进入离开，点击释放、移动的信号，直接初始化用就行了

Qlabel显示效果：

图片圆形展示图片文字标签定义文字大小变化嵌入图片

使用实例:

public_font_option = [[MouseAction.Normal, QFont(Font.YouYuan, 12)],
                              [MouseAction.MouseRnterEvent, QFont(Font.YouYuan, 13)],
                              [MouseAction.MouseLeaveEvent, QFont(Font.YouYuan, 12)],
                              [MouseAction.MousePressedEvent, QFont(Font.YouYuan, 13)],
                              [MouseAction.MouseReleaseEvent, QFont(Font.YouYuan, 12)]]

public_color_option = [[MouseAction.Normal, QColor(qRgb(151, 187, 212))],
                       [MouseAction.MouseRnterEvent, QColor(qRgb(151, 187, 212))],
                       [MouseAction.MouseLeaveEvent, QColor(qRgb(151, 187, 212))],
                       [MouseAction.MousePressedEvent, QColor(qRgb(135, 206, 250))],
                       [MouseAction.MouseReleaseEvent, QColor(qRgb(151, 187, 212))]]

DoorLabel = NLabel(object_name='DoorLabel',
                   sync_text='Music',
                   sync_enable=True,
                   sync_pixel=':/musicdoor.png',
                   sync_pixel_pos=[0, 0],
                   sync_font_option=public_font_option,
                   sync_color_option=public_color_option,
                   sync_text_pos=[8, 0])

C++代码最新版的以QT代码为准

枚举和使用到的字段

    typedef enum{
    DRAWTYPE_ROUND,
    DRAWTYPE_RECT,
    } CST_BRIGHT_SPOT;

    typedef enum {
    PIXLOAD_TILEWIN,
    PIXLOAD_KEEPRATIO,
    PIXLOAD_IGNORERATIO
    } WIN_ATTRIBUTE;


struct MOUSE_ATTRIBUTE{
    static constexpr const char* WIN_CURRENT = "MSEV-TYPE-01";
    static constexpr const char* WIN_NORMAL = "MSEV-TYPE-02";
    static constexpr const char* WIN_ENTER = "MSEV-TYPE-03";
    static constexpr const char* WIN_LEAVE = "MSEV-TYPE-04";
    static constexpr const char* WIN_PRESS = "MSEV-TYPE-05";
    static constexpr const char* WIN_RELEASE = "MSEV-TYPE-06";
};

头文件

#ifndef NINSIPIDVIEW_H
#define NINSIPIDVIEW_H
#include "tools/Npyscript.h"
#include <QtWidgets>

typedef  QString MSEVKEY_STRUCT;

class NinsipidView : public QWidget{

    Q_OBJECT

public:
    enum colorType{
        BACK,
        FORE,
        BORDER
    };

    QStringList msevkeys = {MSEVKEY.WIN_NORMAL,
                            MSEVKEY.WIN_LEAVE,
                            MSEVKEY.WIN_ENTER,
                            MSEVKEY.WIN_PRESS,
                            MSEVKEY.WIN_RELEASE};

    NinsipidView(QWidget *parent = nullptr);

    NinsipidView(QString text, QWidget *parent = nullptr);

    void _init_();

    QString text();

    void doconfigur_text(QString text);

    void doconfigur_format(QString format);

    void doconfigur_formattext(QString text);

    void doconfigur_color(const QColor &color);

    void doconfigur_autoswitch_pixpre(QString pre, QString swt, bool enable=true);

    void doconfigur_autoswitch_pixswap(bool signals_enable=true);

    void doconfigur_pixmap(QString curtainint);

    void doconfigur_pixmap(QPixmap pixmap);

    void doconfigur_textsetting(int align=Qt::AlignLeft | Qt::AlignVCenter, QFont font=QFont("KaiTi_GB2312",13), QPoint excursion=QPoint(0,0));

    void doconfigur_textsetting(QFont font=QFont("KaiTi_GB2312",13), QPoint excursion=QPoint(0,0));

    void doconfigur_textsetting(QPoint excursion=QPoint(0,0));

    void doconfigur_imgsetting(NT::CST_BRIGHT_SPOT drawtype, NT::WIN_ATTRIBUTE imgratio=NT::PIXLOAD_KEEPRATIO, int margins=0, QPoint excursion=QPoint(0,0), bool hi_q=false);

    void doconfigur_imgsetting(NT::WIN_ATTRIBUTE imgratio=NT::PIXLOAD_KEEPRATIO, int margins=0, QPoint excursion=QPoint(0,0), bool hi_q=false);

    void doconfigur_imgsetting(int margins=0, QPoint excursion=QPoint(0,0), bool hi_q=false);

    void doconfigur_imgsetting(QPoint excursion=QPoint(0,0), bool hi_q=false);

    void doconfigur_imgsetting(bool hi_q=false);

    void doconfigur_fontgroup(QMap<MSEVKEY_STRUCT , QFont> group_font);

    void doconfigur_colorgroup(QMap<MSEVKEY_STRUCT , QColor> group_color);

    void doconfigur_backcolorgroup(QMap<MSEVKEY_STRUCT , QColor> group_bkcolor);

    void doconfigur_bordercolorgroup(QMap<MSEVKEY_STRUCT, QColor> group_border);

    void doconfigur_pixmapgroup(QMap<MSEVKEY_STRUCT, QString> group_pixmap);

    void doconfigur_pixmapgroupE(QMap<MSEVKEY_STRUCT, QPixmap> group_pixmap);

    void doconfigur_adjustedwidth(bool enable);

    void doconfigur_brighttype(NT::CST_BRIGHT_SPOT drawtype, uint radius = 4, uint border = 1);

    void doconfigur_lock();

    void doconfigur_unlock();

    QMenu* contentMenu();

    void doconfigur_popueway(Qt::MouseButton button);

    QMap<MSEVKEY_STRUCT, QColor> &color(colorType type){
        switch (type) {
            case BACK:
                return impact_backgroup;
            case FORE:
                return impact_foregroup;
            case BORDER:
                return impact_bordgroup;
        }
    }

protected:
    virtual void paintEvent(QPaintEvent *event);
    virtual void mousePressEvent(QMouseEvent *event);
    virtual void mouseReleaseEvent(QMouseEvent *event);
    virtual void enterEvent(QEvent *event);
    virtual void leaveEvent(QEvent *event);
    virtual void showEvent(QShowEvent *event);

    void pixmap_ratio(NT::WIN_ATTRIBUTE imgratio, QPixmap &pixmap, int w, int h, bool hi_q);

signals:
    void msnm_pre(QString);
    void msev_pre(QMouseEvent *);
    void msev_rls(QMouseEvent *);
    void msev_rpre();
    void msev_rrls();
    void msev_etr(bool);
    void msev_mv();
    void msnm_rls(QString);
    void msev_db();
    void msev_swtc_pre(bool);

private:
    bool polygonTouch();
    QMap<MSEVKEY_STRUCT, QFont> impact_fontgroup;
    QMap<MSEVKEY_STRUCT, QColor> impact_foregroup;
    QMap<MSEVKEY_STRUCT, QColor> impact_backgroup;
    QMap<MSEVKEY_STRUCT, QColor> impact_bordgroup;
    QMap<MSEVKEY_STRUCT, QPixmap> impact_imaggroup;
    QMap<MSEVKEY_STRUCT, int> impact_imagstat;
    KEY_ATTRIBUTE RPLKEY;
    MOUSE_ATTRIBUTE MSEVKEY;
    QMenu *popuMenu = new QMenu(this);

    void pixmapChange();

};
#endif

QString text // 当前文本
void doconfigur_text // 设置文本
void doconfigur_format // 设置格式，如 Load%1...,后续设置格式文本时，文本将替换掉%1
void doconfigur_formattext // 设置格式文本，优先级高于 doconfigur_text
void doconfigur_color // 设置文本颜色
void doconfigur_autoswitch_pixpre // 设置两个需要点击才能切换的图片，优先级高于 doconfigur_pixmapgroup
void doconfigur_autoswitch_pixswap // 手动触发 doconfigur_autoswitch_pixpre 的图片切换
void doconfigur_pixmap // 设置图片，参数为字符串类型
void doconfigur_pixmap // 设置图片，参数为 Qpixmap 类型
void doconfigur_textsetting // 文本属性设置
void doconfigur_textsetting // 重载
void doconfigur_textsetting // 重载
void doconfigur_imgsetting // 图片属性设置
void doconfigur_imgsetting // 重载
void doconfigur_imgsetting // 重载
void doconfigur_imgsetting // 重载
void doconfigur_imgsetting // 重载
void doconfigur_fontgroup // 字体组设置
void doconfigur_colorgroup // 文本颜色组设置
void doconfigur_backcolorgroup // 背景颜色组设置
void doconfigur_bordercolorgroup // 边框颜色组设置
void doconfigur_pixmapgroup // 背景图片组设置，字典为 QString - QString 数据格式
void doconfigur_pixmapgroupE // 字体组设置，字典为 QString - QPixmap 数据格式
void doconfigur_adjustedwidth // 自适应组件宽
void doconfigur_brighttype // 组件背景图案设置，可选矩形和圆形
void doconfigur_lock // 锁定背景为点击颜色
void doconfigur_unlock // 解除锁定背景色
QMenu* contentMenu // 返回组件菜单对象，可插入选项，然后组件外连接信号
void doconfigur_popueway // 唤出菜单的方式，自定义按钮
QMap<MSEVKEY_STRUCT, QColor> &color // 返回背景/边框/文本颜色组字典，在组件外修改
void pixmap_ratio // 图片属性设置，私有函数
信号:
void msnm_pre(QString); // 点击信号，传值为对象名称
void msev_pre(QMouseEvent *); // 左键点击信号
void msev_rls(QMouseEvent *); // 左键释放信号
void msev_rpre(); // 右键点击信号
void msev_rrls(); // 右键释放信号
void msev_etr(bool); // 鼠标进入组件信号，true为进入，false为离开
void msev_mv(); // 鼠标移动信号
void msnm_rls(QString); // 鼠标释放信号，传值为对象名称
void msev_db(); // 鼠标双击信号
void msev_swtc_pre(bool); // doconfigur_autoswitch_pixpre 的图片切换信号

CPP文件

#include "solar/trunk/NinsipidView.h"
#include <qmetatype.h>

NinsipidView::NinsipidView(QWidget *parent) : QWidget(parent){
    _init_();
}

NinsipidView::NinsipidView(QString text, QWidget *parent):QWidget(parent){
    _init_();
    doconfigur_text(text);
}

void NinsipidView::_init_(){
    setProperty("lock", false);
    setProperty("win-autowidth", false);
    setProperty("pixmap-margins", 0);
    setProperty("pixmap-drawtype", NT::DRAWTYPE_RECT);
    setProperty("pixmap-imgratio", NT::PIXLOAD_KEEPRATIO);
    setProperty("pixmap-excursion", QPoint(0,0));
    setProperty("bright-drawtype", NT::DRAWTYPE_RECT);
    setProperty("text-align", Qt::AlignVCenter);
    setProperty("text-excursion", QPoint(0,0));
    setProperty("text-font", QFont("KaiTi_GB2312", 11));
    setProperty("text-font-weight", 1);

    setProperty("pixmap-switch-enable", false);
    doconfigur_fontgroup({{MSEVKEY.WIN_NORMAL, QFont("KaiTi_GB2312",13)}});
}

void NinsipidView::doconfigur_adjustedwidth(bool enable){
    setProperty("win-autowidth", enable);
}

void NinsipidView::doconfigur_text(QString text){
    setProperty("view-text", text);
    if (isVisible()) update();
}

void NinsipidView::doconfigur_format(QString format){
    setProperty("view-format", format);
    if (isVisible()) update();
}

void NinsipidView::doconfigur_formattext(QString text){
    setProperty("view-format-text", text);
    if (isVisible()) update();
}

QString NinsipidView::text(){
    return property("view-text").toString();
}

void NinsipidView::doconfigur_textsetting(int align, QFont font, QPoint excursion){
    doconfigur_fontgroup(QMap<QString, QFont>{{MSEVKEY.WIN_CURRENT, font}});
    setProperty("text-excursion", excursion);
    setProperty("text-align", align);
    doconfigur_fontgroup({{MSEVKEY.WIN_NORMAL, font}});
    if (isVisible()) update();
}

void NinsipidView::doconfigur_textsetting(QFont font, QPoint excursion){
    doconfigur_textsetting(property("text-align").toInt(), font, excursion);
}

void NinsipidView::doconfigur_textsetting(QPoint excursion){
    QFont font = property("text-font").value<QFont>();
    doconfigur_textsetting(property("text-align").toInt(), font, excursion);
}

void NinsipidView::doconfigur_color(const QColor &color){
    doconfigur_colorgroup(QMap<QString, QColor>{{MSEVKEY.WIN_CURRENT, color}});
}

void NinsipidView::doconfigur_autoswitch_pixpre(QString pre, QString swt, bool enable){
    QPixmap maskpixmappre;
    PPScriptExec::pyScript_PixmapVariant(QSize(), maskpixmappre, QSize(), true, pre);
    setProperty("pixmap-switch-pre", maskpixmappre);
    QPixmap maskpixmapswt;
    PPScriptExec::pyScript_PixmapVariant(QSize(), maskpixmapswt, QSize(), true, swt);
    setProperty("pixmap-switch-swt", maskpixmapswt);
    setProperty("pixmap-switch-enable", enable);
    setProperty("pixmap-switch-state", true);
    if (isVisible()) pixmapChange(); // disperse to lead
}

void NinsipidView::doconfigur_pixmap(QVariant curtain){
    doconfigur_pixmapgroup({{MSEVKEY.WIN_NORMAL, curtain}});
}

void NinsipidView::doconfigur_fontgroup(QMap<MSEVKEY_STRUCT, QFont> group_font){
    for (int indexof = 0; indexof < msevkeys.length();indexof++){
        QStringList keyList = group_font.keys();
        QString key = msevkeys[indexof];
        if (keyList.contains(key))
        {
            impact_fontgroup[key] = group_font[key];
        } else {
            impact_fontgroup[key] = impact_fontgroup[MSEVKEY.WIN_NORMAL];;
        }
    }
    impact_fontgroup[MSEVKEY.WIN_CURRENT] = impact_fontgroup[MSEVKEY.WIN_NORMAL];
    if (impact_fontgroup[MSEVKEY.WIN_CURRENT] != font()) update();
}

void NinsipidView::doconfigur_colorgroup(QMap<MSEVKEY_STRUCT, QColor> group_color){
    impact_foregroup[MSEVKEY.WIN_NORMAL] = QColor(120,120,120);
    for (int indexof = 0; indexof < msevkeys.length();indexof++)
    {
        QString key = msevkeys[indexof];
        if (group_color[key].isValid())
        {
            impact_foregroup[key] = group_color[key];
        } else {
            impact_foregroup[key] = impact_foregroup[MSEVKEY.WIN_NORMAL];
        }
    }
    impact_foregroup[MSEVKEY.WIN_CURRENT] = impact_foregroup[MSEVKEY.WIN_NORMAL];
}

void NinsipidView::doconfigur_backcolorgroup(QMap<MSEVKEY_STRUCT, QColor> group_bkcolor){
    impact_backgroup[MSEVKEY.WIN_NORMAL] = QColor(Qt::transparent);
    for (int indexof = 0; indexof < msevkeys.length();indexof++)
    {
        QString key = msevkeys[indexof];
        if (group_bkcolor[key].isValid())
        {
            impact_backgroup[key] = group_bkcolor[key];
        } else {
            impact_backgroup[key] = impact_backgroup[MSEVKEY.WIN_NORMAL];
        }
    }
    impact_backgroup[MSEVKEY.WIN_CURRENT] = impact_backgroup[MSEVKEY.WIN_NORMAL];
}

void NinsipidView::doconfigur_bordercolorgroup(QMap<MSEVKEY_STRUCT, QColor> group_border){
    impact_bordgroup[MSEVKEY.WIN_NORMAL] = QColor(Qt::transparent);
    for (int indexof = 0; indexof < msevkeys.length();indexof++)
    {
        QString key = msevkeys[indexof];
        if (group_border[key].isValid())
        {
            impact_bordgroup[key] = group_border[key];
        } else {
            impact_bordgroup[key] = impact_bordgroup[MSEVKEY.WIN_NORMAL];
        }
    }
    impact_bordgroup[MSEVKEY.WIN_CURRENT] = impact_bordgroup[MSEVKEY.WIN_NORMAL];
}

void NinsipidView::doconfigur_pixmapgroup(QMap<MSEVKEY_STRUCT, QVariant> group_pixmap){
    QPixmap maskpixmap;
    maskpixmap.fill(Qt::transparent);
    impact_imaggroup[MSEVKEY.WIN_NORMAL] = maskpixmap;
    for (int indexof = 0; indexof < msevkeys.length();indexof++)
    {
        QString key = msevkeys[indexof];
        QVariant curtain = group_pixmap[key];
        QPixmap advancePixmap;
        if (!curtain.isNull())
        {
            if (curtain.type() == QVariant::ByteArray)
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(), advancePixmap, QSize(), true, curtain.toByteArray());
            }
            if (curtain.type() == QVariant::String)
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(), advancePixmap, QSize(), true, curtain.toString());
            }
            else if (curtain.type() == QVariant::Pixmap)
            {
                advancePixmap = curtain.value<QPixmap>();

            }
        }
        if (advancePixmap.isNull())
        {
            impact_imaggroup[key] = impact_imaggroup[MSEVKEY.WIN_NORMAL];
        }
        else
        {
            impact_imaggroup[key] = advancePixmap;
        }

    }
    setMinimumWidth(23);
    if (isVisible()) pixmapChange(); // disperse to lead
}

void NinsipidView::doconfigur_imgsetting(NT::CST_BRIGHT_SPOT drawtype, NT::WIN_ATTRIBUTE imgratio, int margins, QPoint excursion, bool hi_q){
//*** pixmap error,because keys list not equalily msevkeys and win_current key where not in msevkeys
    QStringList keys = impact_imaggroup.keys();
    int bestw = width() - margins * 2;
    int besth = height() - margins * 2;
    foreach(QString key, keys)
    {
        QPixmap advancePixmap = impact_imaggroup[key];
        //****不再限制执行条件(auld width != now width:exec)，否则将有可能会漏掉个别图像没有设置尺寸
        if (!advancePixmap.size().isNull())
        {
            pixmap_ratio(imgratio, advancePixmap, bestw, besth, hi_q);
            impact_imaggroup[key] = advancePixmap;
        }
    }
    QVariant prevar = property("pixmap-switch-pre");
    QVariant swtvar = property("pixmap-switch-swt");
    QPixmap prepix = prevar.value<QPixmap>();
    QPixmap swtpix = swtvar.value<QPixmap>();
    if (prevar.isValid() && swtvar.isValid() && !prevar.value<QPixmap>().isNull() && !swtvar.value<QPixmap>().isNull())
    {
            pixmap_ratio(imgratio, prepix, bestw, besth, hi_q);
            pixmap_ratio(imgratio, swtpix, bestw, besth, hi_q);
            setProperty("pixmap-switch-pre", prepix);
            setProperty("pixmap-switch-swt", swtpix);
    }
    if (property("pixmap-switch-enable").toBool() && !prepix.isNull() && !swtpix.isNull())
    {
        impact_imaggroup[MSEVKEY.WIN_CURRENT] = prepix;
    }
    else
    {
        impact_imaggroup[MSEVKEY.WIN_CURRENT] = impact_imaggroup[MSEVKEY.WIN_NORMAL];
    }
    setProperty("pixmap-drawtype", drawtype);
    setProperty("pixmap-imgratio", imgratio);
    setProperty("pixmap-margins", margins);
    setProperty("pixmap-excursion", excursion);
    setProperty("pixmap-hiq", hi_q);
}

void NinsipidView::doconfigur_imgsetting(NT::WIN_ATTRIBUTE imgratio, int margins, QPoint excursion, bool hi_q){
    NT::CST_BRIGHT_SPOT drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
    doconfigur_imgsetting(drawtype, imgratio, margins, excursion, hi_q);
}

void NinsipidView::doconfigur_imgsetting(int margins, QPoint excursion, bool hi_q){
    NT::CST_BRIGHT_SPOT drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
    NT::WIN_ATTRIBUTE ratio = static_cast<NT::WIN_ATTRIBUTE>(property("pixmap-imgratio").toInt());
    doconfigur_imgsetting(drawtype, ratio, margins, excursion, hi_q);
}

void NinsipidView::doconfigur_imgsetting(QPoint excursion, bool hi_q){
    NT::CST_BRIGHT_SPOT drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
    NT::WIN_ATTRIBUTE ratio = static_cast<NT::WIN_ATTRIBUTE>(property("pixmap-imgratio").toInt());
    int margin = property("pixmap-margins").toInt();
    doconfigur_imgsetting(drawtype, ratio, margin, excursion, hi_q);
}

void NinsipidView::doconfigur_imgsetting(bool hi_q){
    NT::CST_BRIGHT_SPOT drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
    NT::WIN_ATTRIBUTE ratio = static_cast<NT::WIN_ATTRIBUTE>(property("pixmap-imgratio").toInt());
    int margin = property("pixmap-margins").toInt();
    QPoint excursion = property("pixmap-excursion").toPoint();
    doconfigur_imgsetting(drawtype, ratio, margin, excursion, hi_q);
}

void NinsipidView::doconfigur_brighttype(NT::CST_BRIGHT_SPOT drawtype, uint radius, uint border){
    setProperty("bright-drawtype", drawtype);
    setProperty("bright-radius", radius);
    setProperty("bright-border-width", border);
}

void NinsipidView::doconfigur_lock(){
    setProperty("lock", true);
    if (isVisible()) update();
}

void NinsipidView::doconfigur_unlock(){
    setProperty("lock", false);
    if (isVisible()) update();
}

void NinsipidView::mousePressEvent(QMouseEvent *event){
    if (event->button() == Qt::LeftButton)
    {
        emit msev_pre(event);
        emit msnm_pre(objectName());
        setFont(impact_fontgroup[MSEVKEY.WIN_PRESS]);
        impact_foregroup[MSEVKEY.WIN_CURRENT] = impact_foregroup[MSEVKEY.WIN_PRESS];
        impact_backgroup[MSEVKEY.WIN_CURRENT] = impact_backgroup[MSEVKEY.WIN_PRESS];
        impact_bordgroup[MSEVKEY.WIN_CURRENT] = impact_bordgroup[MSEVKEY.WIN_PRESS];
        if (!property("pixmap-switch-enable").toBool()) impact_imaggroup[MSEVKEY.WIN_CURRENT] = impact_imaggroup[MSEVKEY.WIN_PRESS];
    }
    if (event->button() == static_cast<Qt::MouseButton>(property("menu-popue-buttom").toInt()) && !popuMenu->isEmpty())
    {
        popuMenu->popup(mapToGlobal(QPoint(0, height())));
    }
    if (event->button() == Qt::RightButton)
    {
        emit msev_rpre();
    }
    doconfigur_autoswitch_pixswap();
    if (isVisible())update();
    QWidget::mousePressEvent(event);
}

void NinsipidView::doconfigur_autoswitch_pixswap(bool signals_enable){
    QPixmap prepix = property("pixmap-switch-pre").value<QPixmap>();
    QPixmap swtpix = property("pixmap-switch-swt").value<QPixmap>();
    if (property("pixmap-switch-enable").toBool())
    {
        if (property("pixmap-switch-state").toBool())
        {
            impact_imaggroup[MSEVKEY.WIN_CURRENT] = swtpix;
            setProperty("pixmap-switch-state", false);
            if (signals_enable) emit msev_swtc_pre(true);
        }
        else
        {
            impact_imaggroup[MSEVKEY.WIN_CURRENT] = prepix;
            setProperty("pixmap-switch-state", true);
            if (signals_enable) emit msev_swtc_pre(false);
        }
    }
}

void NinsipidView::mouseReleaseEvent(QMouseEvent *event){
    if (event->button() == Qt::LeftButton)
    {
        emit msev_rls(event);
        emit msnm_rls(objectName());
        setFont(impact_fontgroup[MSEVKEY.WIN_RELEASE]);
        impact_foregroup[MSEVKEY.WIN_CURRENT] = impact_foregroup[MSEVKEY.WIN_RELEASE];
        impact_backgroup[MSEVKEY.WIN_CURRENT] = impact_backgroup[MSEVKEY.WIN_RELEASE];
        impact_bordgroup[MSEVKEY.WIN_CURRENT] = impact_bordgroup[MSEVKEY.WIN_RELEASE];
        if (!property("pixmap-switch-enable").toBool()) impact_imaggroup[MSEVKEY.WIN_CURRENT] = impact_imaggroup[MSEVKEY.WIN_RELEASE];
        if (isVisible())update();
    }
    if (event->button() == Qt::RightButton)
    {
        emit msev_rrls();
    }
    QWidget::mouseReleaseEvent(event);
}

void NinsipidView::enterEvent(QEvent *event){
    emit msev_etr(true);
    setFont(impact_fontgroup[MSEVKEY.WIN_ENTER]);
    impact_foregroup[MSEVKEY.WIN_CURRENT] = impact_foregroup[MSEVKEY.WIN_ENTER];
    impact_backgroup[MSEVKEY.WIN_CURRENT] = impact_backgroup[MSEVKEY.WIN_ENTER];
    impact_bordgroup[MSEVKEY.WIN_CURRENT] = impact_bordgroup[MSEVKEY.WIN_ENTER];;
    if (!property("pixmap-switch-enable").toBool()) impact_imaggroup[MSEVKEY.WIN_CURRENT] = impact_imaggroup[MSEVKEY.WIN_ENTER];
    if (isVisible())update();
    QWidget::enterEvent(event);
}

void NinsipidView::leaveEvent(QEvent *event){
    emit msev_etr(false);
    setFont(impact_fontgroup[MSEVKEY.WIN_LEAVE]);
    impact_foregroup[MSEVKEY.WIN_CURRENT] = impact_foregroup[MSEVKEY.WIN_LEAVE];
    impact_backgroup[MSEVKEY.WIN_CURRENT] = impact_backgroup[MSEVKEY.WIN_LEAVE];
    impact_bordgroup[MSEVKEY.WIN_CURRENT] = impact_bordgroup[MSEVKEY.WIN_LEAVE];
    if (!property("pixmap-switch-enable").toBool()) impact_imaggroup[MSEVKEY.WIN_CURRENT] = impact_imaggroup[MSEVKEY.WIN_LEAVE];
    if (isVisible())update();
    QWidget::leaveEvent(event);
}

void NinsipidView::showEvent(QShowEvent *event){
    pixmapChange();
    setFont(impact_fontgroup[MSEVKEY.WIN_CURRENT]);
    if (!width()) setMinimumWidth(23);
    QWidget::showEvent(event);
}

void NinsipidView::pixmapChange(){
    if (!impact_imaggroup.isEmpty())
    {
        int margin = property("pixmap-margins").toInt();
        NT::CST_BRIGHT_SPOT drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
        NT::WIN_ATTRIBUTE ratio = static_cast<NT::WIN_ATTRIBUTE>(property("pixmap-imgratio").toInt());
        QPoint excursion = property("pixmap-excursion").toPoint();
        doconfigur_imgsetting(drawtype, ratio, margin, excursion);
        update();
    }
}

void NinsipidView::paintEvent(QPaintEvent *event){
    QPainter Impact(this);
    Impact.setRenderHints(QPainter::SmoothPixmapTransform|
                                QPainter::TextAntialiasing|
                                QPainter::Antialiasing);
    QColor advanceForeColor;
    QColor advanceBackColor;
    QColor advanceBorderColor;
    QPixmap advancePixmap;
    if (property("lock").toBool())
    {
        advanceForeColor =  impact_foregroup[MSEVKEY.WIN_PRESS];
        advanceBackColor =  impact_backgroup[MSEVKEY.WIN_PRESS];
        advanceBorderColor =  impact_bordgroup[MSEVKEY.WIN_PRESS];
        advancePixmap = impact_imaggroup[MSEVKEY.WIN_PRESS];
    }
    else
    {
        advanceForeColor =  impact_foregroup[MSEVKEY.WIN_CURRENT];
        advanceBackColor =  impact_backgroup[MSEVKEY.WIN_CURRENT];
        advanceBorderColor =  impact_bordgroup[MSEVKEY.WIN_CURRENT];
        advancePixmap = impact_imaggroup[MSEVKEY.WIN_CURRENT];
    }

    QString view_text = property("view-text").toString();
    QString view_formatt = property("view-format").toString();
    QString view_format_text = property("view-format-text").toString();
    QString advanceText;
    if (!view_formatt.isEmpty())
    {
        if (view_format_text.isEmpty())
        {
            advanceText = view_formatt.remove(QRegularExpression("%\\d{1}"));
        }
        else
        {
            advanceText = view_formatt.arg(view_format_text);
        }
    }
    else
    {
        advanceText = view_text;
    }
    QFontMetrics Metrics(font());
    int size_w = width();
    int size_h = height();
    int character = Metrics.horizontalAdvance(advanceText);
    int text_Left = property("text-excursion").toPoint().x();
    int text_Roof = property("text-excursion").toPoint().y();
    int pix_Left = property("pixmap-excursion").toPoint().x();
    int pix_Roof = property("pixmap-excursion").toPoint().y();
    int borderWidth = property("bright-border-width").toInt();
    int pixmap_width = advancePixmap.width();
    int pixmap_height = advancePixmap.height();
    int pixmap_Start_X;
    int pixmap_Start_Y;
    int pixmap_Start_W;
    int pixmap_Start_H;
    int text_Start_X;
    int text_Start_Y;
    int text_Start_W;
    int text_Start_H;
    NT::CST_BRIGHT_SPOT bright_drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("bright-drawtype").toInt());
    NT::CST_BRIGHT_SPOT pixmap_drawtype = static_cast<NT::CST_BRIGHT_SPOT>(property("pixmap-drawtype").toInt());
    QRect standarRect(0, 0, size_w, size_h);
    advanceBorderColor.isValid() ? Impact.setPen(QPen(advanceBorderColor, borderWidth)) :
                                   Impact.setPen(QPen(Qt::transparent, borderWidth));
    advanceBackColor.isValid() ? Impact.setBrush(advanceBackColor) :
                                 Impact.setBrush(Qt::transparent);
    if (bright_drawtype == NT::DRAWTYPE_RECT)
    {
        Impact.drawRoundedRect(standarRect,
                               property("bright-radius").toInt(),
                               property("bright-radius").toInt());
    }
    else
    {
        standarRect.setWidth(size_h);
        uint radius = size_h / 2;
        Impact.drawRoundedRect(standarRect, radius, radius);
    }
    if (!advanceText.isEmpty() &&
        !advancePixmap.isNull())
    {
        QRect drawTypeRect;
        pixmap_Start_X = pix_Left + (size_h - pixmap_height) / 2;
        pixmap_Start_Y = pix_Roof + (size_h - pixmap_height) / 2;
        pixmap_Start_W = advancePixmap.width();
        pixmap_Start_H = advancePixmap.height();
        if (pixmap_drawtype == NT::DRAWTYPE_RECT)
        {
            drawTypeRect.setRect(pixmap_Start_X,
                                 pixmap_Start_Y,
                                 pixmap_Start_W,
                                 pixmap_Start_H);
            Impact.drawPixmap(drawTypeRect, advancePixmap);
        }
        else
        {
            if (!advancePixmap.isNull())
            {
                drawTypeRect.setRect(pixmap_Start_X,
                                     pixmap_Start_Y,
                                     advancePixmap.width(), size_h);
                int RadiusX = size_w / 2;
                int RadiusY = size_h / 2;
                Impact.setBrush(advancePixmap);
                Impact.drawRoundedRect(drawTypeRect,
                                       RadiusX,
                                       RadiusY,
                                       Qt::SizeMode::AbsoluteSize);
            }
        }
        Impact.setPen(QPen(advanceForeColor));
        Impact.setFont(font());
        text_Start_X = drawTypeRect.x() + drawTypeRect.width() + text_Left;
        text_Start_Y = text_Roof;
        text_Start_W = size_w - advancePixmap.width();
        text_Start_H = size_h;
        QRect Text_Rect(text_Start_X,
                        text_Start_Y,
                        text_Start_W,
                        text_Start_H);

        Impact.drawText(Text_Rect,
                        static_cast<Qt::Alignment>(property("text-align").toInt()),
                        advanceText);
        if (property("win-autowidth").toBool()) setFixedWidth(text_Start_X + character + property("pixmap-margins").toInt() * 2);
    }

    else if (!advanceText.isEmpty() &&
             advancePixmap.isNull())
    {
        Impact.setFont(font());
        Impact.setPen(QPen(advanceForeColor));
        text_Start_X = text_Left;
        text_Start_Y = text_Roof;
        text_Start_W = size_w;
        text_Start_H = size_h;
        QRect Text_Rect(text_Start_X,
                        text_Start_Y,
                        text_Start_W,
                        text_Start_H);

        Impact.drawText(Text_Rect,
                        static_cast<Qt::Alignment>(property("text-align").toInt()),
                        advanceText);
        if (property("win-autowidth").toBool()) setFixedWidth(text_Start_X + character);
    }

    else if (advanceText.isEmpty() &&
            !advancePixmap.isNull())
    {
        pixmap_Start_X =(standarRect.width() - pixmap_width) / 2;
        pixmap_Start_Y = (standarRect.height() - pixmap_height) / 2 ;
        pixmap_Start_W = pixmap_width;
        pixmap_Start_H = pixmap_height;
        QRect pixmapRect(pixmap_Start_X,
                         pixmap_Start_Y,
                         pixmap_Start_W,
                         pixmap_Start_H);
        if (pixmap_drawtype == NT::DRAWTYPE_RECT)
        {
            Impact.drawTiledPixmap(pixmapRect, advancePixmap);
        }
        else
        {
            QPainterPath path;
            path.addRoundedRect(pixmapRect,
                                pixmapRect.width() / 2,
                                pixmapRect.height() / 2);
            Impact.setClipPath(path);
            Impact.drawPixmap(pixmapRect, advancePixmap);
        }
        if (property("win-autowidth").toBool()) setFixedWidth(pixmap_Start_W + property("pixmap-margins").toInt() * 2);
    }
    QWidget::paintEvent(event);
}

QMenu* NinsipidView::contentMenu(){
    return popuMenu;
}

void NinsipidView::doconfigur_popueway(Qt::MouseButton buttom){
    setProperty("menu-popue-buttom", buttom);
}

void NinsipidView::pixmap_ratio(NT::WIN_ATTRIBUTE imgratio, QPixmap &pixmap, int w, int h, bool hi_q){
    switch (imgratio)
    {
        case NT::PIXLOAD_TILEWIN:
            PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(0,0), hi_q);
            break;
        case NT::PIXLOAD_KEEPRATIO:
            PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(-1, h), hi_q);
            break;
        case NT::PIXLOAD_IGNORERATIO_LOWER:
            if (w > h)
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(h,h), hi_q);
            }
            else
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(w, h), hi_q);
            }
            break;
        case NT::PIXLOAD_IGNORERATIO_CAPITAL:
            if (w < h)
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(h,h), hi_q);
            }
            else
            {
                PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(w, w), hi_q);
            }
            break;
        default:
            PPScriptExec::pyScript_PixmapVariant(QSize(w, h), pixmap, QSize(0,0), hi_q);
            break;
    }
}

pyScript_PixmapVariant 代码:

void PPScriptExec::pyScript_PixmapVariant(QSize expsize, QPixmap &pixmap, QSize fsize, bool hiq, QVariant curtain){
    if (pixmap.isNull() && !curtain.isNull())
    {
        pyScript_PixmapVariant(pixmap, curtain);
    }
    else if (!pixmap.isNull())
    {
        int fw = fsize.width();
        int fh = fsize.height();
        if (fsize.isNull() || fsize == QSize())
        {
            if (hiq)
            {
                pyScript_PilrsizeforPixmap("outer_script", "pixmapresize",pixmap, {expsize.width(), expsize.height()});
            }
            else
            {
                pixmap = pixmap.scaled(expsize,
                                       Qt::IgnoreAspectRatio,
                                       Qt::SmoothTransformation);
            }
        }
        else
        {
            int bastwidth = expsize.width();
            int bestheight = expsize.height();
            double pixw = pixmap.width();
            double pixh = pixmap.height();
            if (fw < 0 && fh >= 0)
            {
                double proportion = pixh / bestheight;
                bastwidth = pixw / proportion;
                if (hiq)
                {
                    pyScript_PilrsizeforPixmap("outer_script", "pixmapresize", pixmap, {bastwidth, bestheight});
                }
                else
                {
                    pixmap = pixmap.scaled(bastwidth, bestheight,
                                           Qt::KeepAspectRatioByExpanding,
                                           Qt::SmoothTransformation);
                }
            }
            else if (fw >= 0 && fh < 0)
            {
                double proportion = pixw / fw;
                bestheight = pixh / proportion;
                if (hiq)
                {
                    pyScript_PilrsizeforPixmap("outer_script", "pixmapresize", pixmap, {bastwidth, bestheight});
                }
                else
                {
                    pixmap = pixmap.scaled(bastwidth, bestheight,
                                           Qt::KeepAspectRatioByExpanding,
                                           Qt::SmoothTransformation);
                }
            }
            else if (fw && fh)
            {
                if (hiq)
                {
                    pyScript_PilrsizeforPixmap("outer_script", "pixmapresize", pixmap, {fsize.width(), fsize.height()});
                }
                else
                {
                    pixmap = pixmap.scaled(fsize,
                                           Qt::IgnoreAspectRatio,
                                           Qt::SmoothTransformation);
                }
            }
        }
    }
}


bool PPScriptExec::pyScript_PixmapVariant(QPixmap &pixmap, QVariant curtain){
    bool byte_pass = false;
    while (true)
    {
        if ((pixmap.isNull() && !curtain.isNull()))
        {
            if (curtain.type() == QVariant::ByteArray || byte_pass)
            {
                if (pixmap.loadFromData(QByteArray::fromBase64(curtain.toByteArray())))
                {
                    return true;
                }
                else
                {
                    if (pixmap.loadFromData(curtain.toByteArray()))
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else if (curtain.type() == QVariant::String)
            {
                bool load = pixmap.load(curtain.toString());
                if (load)
                {
                    return true;
                }
                else
                {
                    QByteArray imgbyte = Reader::g_reader(curtain.toString());
                    if (imgbyte.isEmpty())
                    {
                        byte_pass = true;
                    }
                    else
                    {
                        curtain.setValue(imgbyte);
                    }
                }
            }
            else if (curtain.type() == QVariant::Pixmap)
            {
                QPixmap varpixmap = curtain.value<QPixmap>();
                pixmap.swap(varpixmap);
                return true;
            }
        }
    }
}

效果:

很多小组件都可以由 NinsipidView 来完成

初始化实例，列举几个动图中用到的组件初始化代码

音乐按钮是一个图片+文字内容的按钮，代码是这样的

    RTP_musicLabel->doconfigur_text("音乐");
    RTP_musicLabel->doconfigur_textsetting(QPoint(7, 0));
    RTP_musicLabel->doconfigur_brighttype(NT::DRAWTYPE_RECT);
    RTP_musicLabel->doconfigur_adjustedwidth(true);
    RTP_musicLabel->doconfigur_imgsetting(NT::DRAWTYPE_RECT, NT::PIXLOAD_KEEPRATIO, 3, QPoint(4, 0));
    RTP_musicLabel->doconfigur_pixmapgroup({{MSEVKEY.WIN_NORMAL, ":/PIXMAP/bench/music-guide-dark.png"},
                                            {MSEVKEY.WIN_ENTER,  ":/PIXMAP/bench/music-guide-shallow.png"}});
    RTP_musicLabel->doconfigur_fontgroup({{MSEVKEY.WIN_NORMAL, QFont("KaiTi_GB2312", 10)}});
    RTP_musicLabel->doconfigur_colorgroup({{MSEVKEY.WIN_NORMAL, QColor(116,124,141)},
                                           {MSEVKEY.WIN_ENTER, QColor(234,237,241)}});
    RTP_musicLabel->doconfigur_backcolorgroup({{MSEVKEY.WIN_NORMAL, QColor(234,237,241)},
                                               {MSEVKEY.WIN_ENTER, QColor(116,124,141)}});
    RTP_musicLabel->doconfigur_bordercolorgroup({{MSEVKEY.WIN_NORMAL, QColor(222,225,232)},
                                                 {MSEVKEY.WIN_ENTER, QColor(191,196,210)}});

本地媒体按钮：

    LF_localMeidaLabel->doconfigur_text("本地媒体");
    LF_localMeidaLabel->doconfigur_textsetting(QPoint(5, 0));
    LF_localMeidaLabel->doconfigur_brighttype(NT::DRAWTYPE_RECT);
    LF_localMeidaLabel->doconfigur_imgsetting(NT::DRAWTYPE_RECT, NT::PIXLOAD_IGNORERATIO_LOWER, 5, QPoint(4, 0));
    LF_localMeidaLabel->doconfigur_fontgroup(VariableOptionFont);
    LF_localMeidaLabel->doconfigur_colorgroup(foreColorMap);
    LF_localMeidaLabel->doconfigur_backcolorgroup(backColorMap);
    LF_localMeidaLabel->doconfigur_pixmapgroup({{MSEVKEY.WIN_NORMAL, ":/PIXMAP/bench/view-local-nor.png"},
                                                {MSEVKEY.WIN_PRESS, ":/PIXMAP/bench/view-local-hvr.png"}});

再用个函数辅助设置一下，将按钮的点击事件与函数绑定，例如

然后就有动图中的点击效果了

而像这类需要点击才会切换图片的也比较简单，它的优先级比较高，直接设置就好了

    favora_rename->setFixedHeight(23);
    favora_rename->doconfigur_adjustedwidth(true);
    favora_rename->doconfigur_brighttype(NT::DRAWTYPE_ROUND);
    favora_rename->doconfigur_imgsetting(NT::DRAWTYPE_RECT, NT::PIXLOAD_IGNORERATIO_LOWER, 3);
    favora_rename->doconfigur_backcolorgroup({{MSEVKEY.WIN_ENTER, QColor(230,230,230,180)}});
    favora_rename->doconfigur_autoswitch_pixpre(":/PIXMAP/bench/private-edit.png", ":/PIXMAP/bench/private-edit-finish.png");

本人业余代码爱好者，没事玩玩，写的可能不咋好，觉得有参考价值就参考下吧