C++ QRadialGradient::radius方法代码示例

KoStopGradient * KoStopGradient::fromQGradient(QGradient * gradient)
{
    if (! gradient)
        return 0;

    KoStopGradient * newGradient = new KoStopGradient("");
    newGradient->setType(gradient->type());
    newGradient->setSpread(gradient->spread());

    switch (gradient->type()) {
    case QGradient::LinearGradient: {
        QLinearGradient * g = static_cast<QLinearGradient*>(gradient);
        newGradient->m_start = g->start();
        newGradient->m_stop = g->finalStop();
        newGradient->m_focalPoint = g->start();
        break;
    }
    case QGradient::RadialGradient: {
        QRadialGradient * g = static_cast<QRadialGradient*>(gradient);
        newGradient->m_start = g->center();
        newGradient->m_stop = g->center() + QPointF(g->radius(), 0);
        newGradient->m_focalPoint = g->focalPoint();
        break;
    }
    case QGradient::ConicalGradient: {
        QConicalGradient * g = static_cast<QConicalGradient*>(gradient);
        qreal radian = g->angle() * M_PI / 180.0;
        newGradient->m_start = g->center();
        newGradient->m_stop = QPointF(100.0 * cos(radian), 100.0 * sin(radian));
        newGradient->m_focalPoint = g->center();
        break;
    }
    default:
        delete newGradient;
        return 0;
    }

    Q_FOREACH (const QGradientStop & stop, gradient->stops()) {
        KoColor color(newGradient->colorSpace());
        color.fromQColor(stop.second);
        newGradient->m_stops.append(KoGradientStop(stop.first, color));
    }

    return newGradient;
}

void RadialVolumeWidgetPrivate::paintBackground() // QGradient is soooo sloooow
{
  QPainter p(&bg);
  p.setRenderHint(QPainter::Antialiasing, true);

  int r = spectrum.radius();
  QPoint c = spectrum.center().toPoint();

  p.setBrush(spectrum);
  p.setPen(QPen(Qt::NoPen));
  p.drawEllipse(c.x()-r, c.y()-r, 2*r, 2*r); // Gradient background

  p.setBrush(QBrush()); // Do not fill
  //p.setPen(QPen(QColor(255, 255, 255, 160), 0, Qt::DashLine));
  for (int i=0; i<n_levels; i++)
  {
    int l_r = r*levels[i];
    p.setPen(QPen(QColor(255, 255, 255, 255-(180*(i+1))/n_levels), 1, Qt::DashLine));
    p.drawEllipse(c.x()-l_r, c.y()-l_r, 2*l_r, 2*l_r);
  }
}

void Mask::mask_slot(){
    int countSel = gsri->countSelected();
    GObjectInterface *iObj, *endObj=gsri->selected(gsri->countSelected()-1);//создаём контейнер с выделенными рамкой объектами
    qreal k_h, k_w, width_iObj, width_endObj = endObj->boundingRect().width(),
    height_iObj, height_endObj = endObj->boundingRect().height();
    QBrush endObjBrush = endObj->brush();
    if(endObjBrush.style() == Qt::RadialGradientPattern
            || endObjBrush.style() == Qt::ConicalGradientPattern
                || endObjBrush.style() == Qt::LinearGradientPattern){
        for (int i=0; i<countSel-1; i++){
            iObj = gsri->selected(i);
            QBrush inters = iObj->brush();
            qreal iObjAlpha = inters.color().alphaF();
            QGradient qg = *endObjBrush.gradient();
            height_iObj = iObj->boundingRect().height();
            width_iObj = iObj->boundingRect().width();
            k_h = height_endObj/height_iObj;//считаем коэффициенты пропорциональности фигур для умножения-->
            k_w = width_endObj/width_iObj;//-->на точки градиента(чтобы градиенты не зависели от размеров фигур).

            int d_x = iObj->boundingRect().x() - endObj->boundingRect().x();//вычисляем расстояния между левыми краями фигур
            int d_y = iObj->boundingRect().y() - endObj->boundingRect().y();
            qreal k_shift_x = ( d_x / width_endObj) * k_w,//вычисляем коэффициенты сдвига градиента по ширине-->
                    k_shift_y = (d_y / height_endObj) * k_h;//--> и по высотке

            QGradientStops grStops(qg.stops());//копируем точки/цвета задаваемого градиента.

            QColor BrushColor = inters.gradient()->stops()[0].second;

            for(int j=0; j<grStops.count(); j++){
                grStops[j].second.setRgbF( BrushColor.redF(), BrushColor.greenF(), BrushColor.blueF(),
                                           grStops[j].second.alphaF()*iObjAlpha);
            }

            if(qg.type() == QGradient::LinearGradient){
                QLinearGradient qlg = *static_cast<const QLinearGradient *>(endObjBrush.gradient());
                QLinearGradient qlgLinear(qlg.start().x() * k_w - k_shift_x, qlg.start().y() * k_h - k_shift_y,
                                         qlg.finalStop().x() * k_w - k_shift_x, qlg.finalStop().y() * k_h - k_shift_y);
                qlgLinear.setStops(grStops);
                iObj->setBrush(qlgLinear);
            }

            if(qg.type() == QGradient::RadialGradient){
                for(int j=0; j<grStops.count(); j++)
                    grStops[j].first *= k_w;
                QRadialGradient qlg = *static_cast<const QRadialGradient *>(endObjBrush.gradient());
                QRadialGradient qlgRadial(QPointF(qlg.center().x()*k_w - k_shift_x, qlg.center().y()*k_h - k_shift_y),
                     qlg.radius(), QPointF(qlg.focalPoint().x()*k_w - k_shift_x, qlg.focalPoint().y()*k_h - k_shift_y),
                     qlg.focalRadius());
                qlgRadial.setStops(grStops);
                iObj->setBrush(qlgRadial);
            }

            if(qg.type() == QGradient::ConicalGradient){
                QConicalGradient qlg = *static_cast<const QConicalGradient *>(endObjBrush.gradient());
                QConicalGradient qlgConical(QPointF(qlg.center().x()*k_w - k_shift_x, qlg.center().y()*k_h - k_shift_y),
                                          qlg.angle());
                qlgConical.setStops(grStops);
                iObj->setBrush(qlgConical);
            }
        }
        endObj->setVisible(false);
    }
    else{
        QMessageBox m;
        m.setText(tr("upper figure does not contain a gradient"));
        m.exec();
    }
    gsri->reset();

}