QTableView::item:selected {background: " + QString(COLOR_STANDARD_TABLE_CURSOR) + "; color: " + QString(COLOR_BLACK) + "}

QTableView {selection-background-color: rgba(255, 0, 0, 50)}

QTableView {selection-background-color: rgba(255, 0, 0, 50);border: 3px solid black}

void GraphicsView::wheelEvent(QWheelEvent *e)
{
    if (e->modifiers() & Qt::ControlModifier) {
        if (e->angleDelta().y() > 0)
            view->zoomIn();
        else
            view->zoomOut();
        e->accept();
    } else {
        QGraphicsView::wheelEvent(e);
    }
}

// -----------------------------------------------------------

class View : public QFrame
{
    Q_OBJECT
public:
    explicit View(const QString &, QWidget *parent = nullptr);

    QGraphicsView *view() const;
....
}

void View::setupMatrix()
{
    qreal scale = qPow(qreal(2), (zoomValue - 250) / qreal(50));
    QTransform matrix;
    matrix.scale(scale, scale);
    matrix.rotate(0);
    graphicsView->setTransform(matrix);
    setResetButtonEnabled();
}

void View::zoomIn()
{
    if (zoomValue + ZOOMDELTAVALUE <= ZOOMMAX)
    {
        zoomValue += 6;
        setupMatrix();
    }
}

void View::zoomOut()
{
    if (zoomValue - ZOOMDELTAVALUE >= ZOOMMIN)
    {
        zoomValue -= 6;
        setupMatrix();
    }
}

// -----------------------------------------

    scene =  new QGraphicsScene(this);
    View *view = new View("", this);
    view->view()->setScene(scene);
    scene->addPixmap(QPixmap(":/icons/images/russia.png"));

class CheckBoxListDelegate;

class CheckBoxList: public QComboBox
{
    Q_OBJECT
 public:
    CheckBoxList(QString text, QWidget *widget = 0);
    virtual ~CheckBoxList();
    virtual void paintEvent(QPaintEvent *);
public slots:
    void SetDisplayText(QString strr);
    QString GetDisplayText() const;
private:
    CheckBoxListDelegate * delegate;
    QString m_DisplayText;
private slots:
    void act ();
};
CheckBoxList::CheckBoxList(QString text, QWidget *widget )
:QComboBox(widget),m_DisplayText(text)
{
    delegate = new CheckBoxListDelegate(this);
    view()->setItemDelegate(delegate);
    view()->setEditTriggers(QAbstractItemView::CurrentChanged);
    connect(delegate,SIGNAL(dataChanged()),this,SLOT(act()));
}


CheckBoxList::~CheckBoxList()
{
}


void CheckBoxList::act()
{
    emit activated(0);
}

void CheckBoxList::paintEvent(QPaintEvent *)
{
    QStylePainter painter(this);
    painter.setPen(palette().color(QPalette::Text));

    // draw the combobox frame, focusrect and selected etc.
    QStyleOptionComboBox opt;
    initStyleOption(&opt);

    // if no display text been set , use "..." as default
    if(m_DisplayText.isNull())
        opt.currentText = "...";
    else
        opt.currentText = m_DisplayText;
    painter.drawComplexControl(QStyle::CC_ComboBox, opt);

    // draw the icon and text
    painter.drawControl(QStyle::CE_ComboBoxLabel, opt);
}


void CheckBoxList::SetDisplayText(QString strr)
{
    m_DisplayText = strr;
}

QString CheckBoxList::GetDisplayText() const
{
    return m_DisplayText;
}

class CheckBoxListDelegate : public QItemDelegate
{
    Q_OBJECT
signals:
    void dataChanged () const;
public slots:
    void dCH ()
    {
        emit dataChanged();
    }
public:
    CheckBoxListDelegate(QObject *parent)
         : QItemDelegate(parent)
    {
    }

    void paint(QPainter *painter, const QStyleOptionViewItem &option,
                          const QModelIndex &index) const
    {
        //Get item data
        bool value = index.data(Qt::UserRole).toBool();
        QString text = index.data(Qt::DisplayRole).toString();

        // fill style options with item data
        const QStyle *style = QApplication::style();
        QStyleOptionButton opt;
        opt.state |= value ? QStyle::State_On : QStyle::State_Off;
        opt.state |= QStyle::State_Enabled;
        opt.text = text;
        opt.rect = option.rect;

        // draw item data as CheckBox
                style->drawControl(QStyle::CE_CheckBox,&opt,painter);
    }

    QWidget *createEditor(QWidget *parent,
         const QStyleOptionViewItem &,
         const QModelIndex &) const
    {
        // create check box as our editor
         QCheckBox *editor = new QCheckBox(parent);
         return editor;
    }

     void setEditorData(QWidget *editor,
                                         const QModelIndex &index) const
     {
         //set editor data
         QCheckBox *myEditor = static_cast<QCheckBox*>(editor);
         myEditor->setText(index.data(Qt::DisplayRole).toString());
         myEditor->setChecked(index.data(Qt::UserRole).toBool());

     }

     void setModelData(QWidget *editor, QAbstractItemModel *model,
                                        const QModelIndex &index) const
     {
         //get the value from the editor (CheckBox)
         QCheckBox *myEditor = static_cast<QCheckBox*>(editor);
         bool value = myEditor->isChecked();

         //set model data
         QMap<int,QVariant> data;
         data.insert(Qt::DisplayRole,myEditor->text());
         data.insert(Qt::UserRole,value);
         model->setItemData(index,data);
        emit dataChanged();
     }
 };

    QHBoxLayout * labLay = new QHBoxLayout (ui->gbLabel);
    cblLabel = new CheckBoxList (QString::fromLocal8Bit("Выберите метку ..."), ui->gbLabel);
    labLay->addWidget(cblLabel);
    connect(cblLabel,SIGNAL(activated(int)),this,SLOT(changedLabelSettings()));

cblLabel->setModel(metkaModel);

void SqlQueryExecutor::slotGet618Data(uint turplesCount)
{
    if (!QSqlDatabase::database().isOpen())
    {
        emit dbDbErrorAppears(QSqlError::ConnectionError, tr("Ошибка подключения к БД."), "");
        return;
    }
    QSqlQuery * query618 = new QSqlQuery ();
    QString sty;
    if (turplesCount == 0)
        sty = QString ("%1 %2 ORDER BY id DESC ").arg(strQueryA618, strWhereA618);
    else
        sty = QString ("%1 %2 ORDER BY id DESC %3 %4").arg(strQueryA618, strWhereA618, "LIMIT").arg(turplesCount);
    query618->exec(sty);
    if (query618->lastError().isValid())
    {
        emit dbDbErrorAppears(query618->lastError().type(), query618->lastError().text(), "");
        return;
    }
    emit set618Data(query618);
}

void SqlQueryExecutor::slotOpenDbConnection(QString address, QString serverName, QString login, QString password)
{
    if (QSqlDatabase::database().isOpen())
    {
        QString connectionName = QSqlDatabase::database().connectionName();
        QSqlDatabase::database(connectionName).close();
        QSqlDatabase::removeDatabase(connectionName);
    }
    QSqlDatabase db = QSqlDatabase::addDatabase("QPSQL");
    db.setHostName(address);
    db.setDatabaseName(dbName);
    db.setUserName(login);
    db.setPassword(password);
    if (!db.open())
    {
        if (db.lastError().isValid())
            emit dbDbErrorAppears(db.lastError().type(), db.lastError().text(), serverName);
        return;
    }
    emit dbConnected(serverName);
}