Example #1
0
void View::setXPos(int x)
      {
      int delta  = xpos - x;         // -  -> shift left
      xpos  = x;
      
      #ifdef VIEW_USE_DOUBLE_BUFFERING
      if (pm.isNull())
            return;
      if (!pmValid) {
            //printf("View::setXPos !pmValid x:%d width:%d delta:%d\n", x, width(), delta);
            redraw();
            return;
            }
            
      int w = width();
      int h = height();

      QRect r;
      if (delta >= w || delta <= -w)
            r = QRect(0, 0, w, h);
      else if (delta < 0) {   // shift left
            //bitBlt(&pm,  0, 0, &pm,  -delta, 0, w + delta, h, CopyROP, true);
            QPainter p(&pm);
            p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing, false);
            //printf("View::setXPos x:%d w:%d delta:%d r.x:%d r.w:%d\n", 
            //  x, w, delta, r.x(), r.width());                    
            p.drawPixmap(0, 0, pm, -delta, 0, w + delta, h);
            r = QRect(w + delta, 0, -delta, h);
            }
      else {                  // shift right
            //bitBlt(&pm,  delta, 0, &pm,     0, 0, w-delta, h, CopyROP, true);
            QPainter p(&pm);
            p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing, false);
            //printf("View::setXPos x:%d w:%d delta:%d r.x:%d r.w:%d\n", 
            //  x, w, delta, r.x(), r.width());                    
            p.drawPixmap(delta, 0, pm,     0, 0, w-delta, h);
            r = QRect(0, 0, delta, h);
            }
      QRect olr = overlayRect();
      QRect olr1(olr);
      olr1.translate(delta, 0);

      r |= olr;
      r |= olr1;
      
      //printf("View::setXPos x:%d w:%d delta:%d r.x:%d r.w:%d\n", x, w, delta, r.x(), r.width());
      //printf("View::setXPos paint delta:%d r.x:%d r.y:%d r.w:%d r.h:%d\n", delta, r.x(), r.y(), r.width(), r.height());  
      
      paint(r);
      update();
      
      #else
      scroll(delta, 0);
      QRect olr = overlayRect();
      // Is there an overlay?
      if(!olr.isNull())
      {
        // Are we shifting right (moving left)?
        if(delta >= 0)
        {
          // Translate not good - need to set x to delta.
          //olr.translate(delta, 0);
          olr.setX(delta);
          olr.setWidth(olr.x() + olr.width() + delta);
        }
        else
        // We are shifting left (moving right).
        {
          // Translate not good - need to limit x to 0.
          //olr.translate(delta, 0);
          olr.setX(olr.x() + delta);
        }
        
        if(olr.x() < 0)
          olr.setX(0);
        if(olr.right() > width())
          olr.setRight(width());
        
        if(olr.y() < 0)
          olr.setY(0);
        if(olr.bottom() > height())
          olr.setBottom(height());
        
        //printf("scroll X update: x:%d y:%d w:%d h:%d\n", olr.x(), olr.y(), olr.width(), olr.height()); 
        update(olr);
      }  
      #endif
      }
Example #2
0
void Image3DOverlay::render(RenderArgs* args) {
    if (!_isLoaded) {
        _isLoaded = true;
        _texture = DependencyManager::get<TextureCache>()->getTexture(_url);
    }

    if (!_visible || !getParentVisible() || !_texture || !_texture->isLoaded()) {
        return;
    }

    Q_ASSERT(args->_batch);
    gpu::Batch* batch = args->_batch;

    float imageWidth = _texture->getWidth();
    float imageHeight = _texture->getHeight();

    QRect fromImage;
    if (_fromImage.isNull()) {
        fromImage.setX(0);
        fromImage.setY(0);
        fromImage.setWidth(imageWidth);
        fromImage.setHeight(imageHeight);
    } else {
        float scaleX = imageWidth / _texture->getOriginalWidth();
        float scaleY = imageHeight / _texture->getOriginalHeight();

        fromImage.setX(scaleX * _fromImage.x());
        fromImage.setY(scaleY * _fromImage.y());
        fromImage.setWidth(scaleX * _fromImage.width());
        fromImage.setHeight(scaleY * _fromImage.height());
    }

    float maxSize = glm::max(fromImage.width(), fromImage.height());
    float x = fromImage.width() / (2.0f * maxSize);
    float y = -fromImage.height() / (2.0f * maxSize);

    glm::vec2 topLeft(-x, -y);
    glm::vec2 bottomRight(x, y);
    glm::vec2 texCoordTopLeft(fromImage.x() / imageWidth, fromImage.y() / imageHeight);
    glm::vec2 texCoordBottomRight((fromImage.x() + fromImage.width()) / imageWidth,
                                  (fromImage.y() + fromImage.height()) / imageHeight);

    const float MAX_COLOR = 255.0f;
    xColor color = getColor();
    float alpha = getAlpha();

    applyTransformTo(_transform, true);
    Transform transform = _transform;
    transform.postScale(glm::vec3(getDimensions(), 1.0f));

    batch->setModelTransform(transform);
    batch->setResourceTexture(0, _texture->getGPUTexture());

    DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(*batch, true, false, _emissive, true);
    DependencyManager::get<GeometryCache>()->renderQuad(
        *batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
        glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha)
    );

    batch->setResourceTexture(0, args->_whiteTexture); // restore default white color after me
}
void FSTaskDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{

    QString title         = index.data(FSAbstractTaskModel::TitleRole).toString();
    QString subTitle      = index.data(FSAbstractTaskModel::SubTitleRole).toString();
    int progress          = index.data(FSAbstractTaskModel::ProgressRole).toInt();
    QString mimeIconPath  = index.data(FSAbstractTaskModel::MimeIconRole).toString();
//    QString actionIconPath= index.data(FSAbstractTaskModel::TitleRole).toString();


    if (option.state & QStyle::State_Selected)
    {
        painter->setPen(Qt::NoPen);
        painter->setBrush(QBrush(QColor("#316AC5")));
        painter->drawRect(option.rect);
    }

    painter->setPen(QPen(Qt::black));


    QPixmap icon (mimeIconPath);

    painter->drawPixmap(5, option.rect.center().y()-icon.height()/2, icon);

    QRect progressRect = option.rect;
    progressRect.setX(40);
    progressRect.setY(option.rect.center().y() - 7);
    progressRect.setRight(option.rect.right() - 30);

    progressRect.setHeight(progress < 100 ? 14 : 1);

    if (progress <100) {
    QStyleOptionProgressBar progressBarOption;
    progressBarOption.rect = progressRect;

    progressBarOption.minimum = 0;
    progressBarOption.maximum = 100;
    progressBarOption.progress = progress;
    progressBarOption.text = QString::number(progress) + "%";
    progressBarOption.textVisible = true;
    progressBarOption.textAlignment = Qt::AlignCenter;

    qApp->style()->drawControl(QStyle::CE_ProgressBar,
                               &progressBarOption, painter);


    QFontMetrics metrics(painter->font());

    if ((option.state & QStyle::State_Selected))
        painter->setPen(QPen(Qt::white));
    else
        painter->setPen(QPen(Qt::black));

    painter->setFont(QFont(painter->font().family(),10));
    painter->drawText(progressRect.topLeft()-QPoint(-5,5),title);
    painter->setFont(QFont(painter->font().family(),8));
    painter->drawText(progressRect.bottomLeft()+QPoint(5,5+metrics.height()),
                      subTitle);
    }

    else
    {
        QFontMetrics metrics(painter->font());

        painter->setFont(QFont(painter->font().family(),10));
        painter->drawText(progressRect.topLeft(),title);
        painter->setFont(QFont(painter->font().family(),8));
        painter->drawText(progressRect.topLeft()+QPoint(0,metrics.height()),subTitle);

    }



//   QPixmap rightPixmap(actionIconPath);
//    if (mClicked.contains(index))
//        painter->setOpacity(0.4);
//    else
//        painter->setOpacity(1);


//    painter->drawPixmap(option.rect.right() -20,  option.rect.center().y()-8,
//                        rightPixmap);


}
Example #4
0
void ArthurStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                QPainter *painter, const QWidget *widget) const
{

    Q_ASSERT(option);
    switch (element) {
    case PE_FrameFocusRect:
        break;

    case PE_IndicatorRadioButton:
        if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
            bool hover = (button->state & State_Enabled) && (button->state & State_MouseOver);
            painter->save();
            QPixmap radio;
            if (hover)
                drawHoverRect(painter, widget->rect());

            if (button->state & State_Sunken)
                radio = cached(":res/images/radiobutton-on.png");
            else if (button->state & State_On)
                radio = cached(":res/images/radiobutton_on.png");
            else
                radio = cached(":res/images/radiobutton_off.png");
            painter->drawPixmap(button->rect.topLeft(), radio);

            painter->restore();
        }
        break;

    case PE_PanelButtonCommand:
        if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
            bool hover = (button->state & State_Enabled) && (button->state & State_MouseOver);

            painter->save();
            const QPushButton *pushButton = qobject_cast<const QPushButton *>(widget);
            Q_ASSERT(pushButton);
            QWidget *parent = pushButton->parentWidget();
            if (parent && qobject_cast<QGroupBox *>(parent)) {
                QLinearGradient lg(0, 0, 0, parent->height());
                lg.setColorAt(0, QColor(224,224,224));
                lg.setColorAt(1, QColor(255,255,255));
                painter->setPen(Qt::NoPen);
                painter->setBrush(lg);
                painter->setBrushOrigin(-widget->mapToParent(QPoint(0,0)));
                painter->drawRect(button->rect);
                painter->setBrushOrigin(0,0);
            }

            bool down = (button->state & State_Sunken) || (button->state & State_On);

            QPixmap left, right, mid;
            if (down) {
                left = cached(":res/images/button_pressed_cap_left.png");
                right = cached(":res/images/button_pressed_cap_right.png");
                mid = cached(":res/images/button_pressed_stretch.png");
            } else {
                left = cached(":res/images/button_normal_cap_left.png");
                right = cached(":res/images/button_normal_cap_right.png");
                mid = cached(":res/images/button_normal_stretch.png");
            }
            painter->drawPixmap(button->rect.topLeft(), left);
            painter->drawTiledPixmap(QRect(button->rect.x() + left.width(),
                                           button->rect.y(),
                                           button->rect.width() - left.width() - right.width(),
                                           left.height()),
                                     mid);
            painter->drawPixmap(button->rect.x() + button->rect.width() - right.width(),
                                button->rect.y(),
                                right);
            if (hover)
                painter->fillRect(widget->rect().adjusted(3,5,-3,-5), QColor(31,127,31,63));
            painter->restore();
        }
        break;

    case PE_FrameGroupBox:
        if (const QStyleOptionFrameV2 *group
                = qstyleoption_cast<const QStyleOptionFrameV2 *>(option)) {
            const QRect &r = group->rect;

            painter->save();
            int radius = 14;
            int radius2 = radius*2;
            QPainterPath clipPath;
            clipPath.moveTo(radius, 0);
            clipPath.arcTo(r.right() - radius2, 0, radius2, radius2, 90, -90);
            clipPath.arcTo(r.right() - radius2, r.bottom() - radius2, radius2, radius2, 0, -90);
            clipPath.arcTo(r.left(), r.bottom() - radius2, radius2, radius2, 270, -90);
            clipPath.arcTo(r.left(), r.top(), radius2, radius2, 180, -90);
            painter->setClipPath(clipPath);
            QPixmap titleStretch = cached(":res/images/title_stretch.png");
            QPixmap topLeft = cached(":res/images/groupframe_topleft.png");
            QPixmap topRight = cached(":res/images/groupframe_topright.png");
            QPixmap bottomLeft = cached(":res/images/groupframe_bottom_left.png");
            QPixmap bottomRight = cached(":res/images/groupframe_bottom_right.png");
            QPixmap leftStretch = cached(":res/images/groupframe_left_stretch.png");
            QPixmap topStretch = cached(":res/images/groupframe_top_stretch.png");
            QPixmap rightStretch = cached(":res/images/groupframe_right_stretch.png");
            QPixmap bottomStretch = cached(":res/images/groupframe_bottom_stretch.png");
            QLinearGradient lg(0, 0, 0, r.height());
            lg.setColorAt(0, QColor(224,224,224));
            lg.setColorAt(1, QColor(255,255,255));
            painter->setPen(Qt::NoPen);
            painter->setBrush(lg);
            painter->drawRect(r.adjusted(0, titleStretch.height()/2, 0, 0));
            painter->setClipping(false);

            int topFrameOffset = titleStretch.height()/2 - 2;
            painter->drawPixmap(r.topLeft() + QPoint(0, topFrameOffset), topLeft);
            painter->drawPixmap(r.topRight() - QPoint(topRight.width()-1, 0)
                                + QPoint(0, topFrameOffset), topRight);
            painter->drawPixmap(r.bottomLeft() - QPoint(0, bottomLeft.height()-1), bottomLeft);
            painter->drawPixmap(r.bottomRight() - QPoint(bottomRight.width()-1,
                                bottomRight.height()-1), bottomRight);

            QRect left = r;
            left.setY(r.y() + topLeft.height() + topFrameOffset);
            left.setWidth(leftStretch.width());
            left.setHeight(r.height() - topLeft.height() - bottomLeft.height() - topFrameOffset);
            painter->drawTiledPixmap(left, leftStretch);

            QRect top = r;
            top.setX(r.x() + topLeft.width());
            top.setY(r.y() + topFrameOffset);
            top.setWidth(r.width() - topLeft.width() - topRight.width());
            top.setHeight(topLeft.height());
            painter->drawTiledPixmap(top, topStretch);

            QRect right = r;
            right.setX(r.right() - rightStretch.width()+1);
            right.setY(r.y() + topRight.height() + topFrameOffset);
            right.setWidth(rightStretch.width());
            right.setHeight(r.height() - topRight.height()
                            - bottomRight.height() - topFrameOffset);
            painter->drawTiledPixmap(right, rightStretch);

            QRect bottom = r;
            bottom.setX(r.x() + bottomLeft.width());
            bottom.setY(r.bottom() - bottomStretch.height()+1);
            bottom.setWidth(r.width() - bottomLeft.width() - bottomRight.width());
            bottom.setHeight(bottomLeft.height());
            painter->drawTiledPixmap(bottom, bottomStretch);
            painter->restore();
        }
        break;

    default:
        QWindowsStyle::drawPrimitive(element, option, painter, widget);
        break;
    }
    return;
}
void QSGPropertyAnimator::updateProperty(QObject *target, const QString& p)
{
    QSGAnimatedProperty *ap = m_controller->registeredProperty(p, target);
    if (ap && m_duration > 0) {
        if (m_elapsed > m_startTime && ((m_elapsed < m_startTime + m_loops * m_duration) || (m_loops < 0))) {

            QVariant value = ap->value();
            qreal tx = int(m_elapsed - m_startTime) % int(m_duration);

            switch (value.type()) {
            case QMetaType::Double:
                value = QVariant(m_from.toReal() + (m_to.toReal() - m_from.toReal()) * m_easing.valueForProgress(tx / m_duration));
                break;
            case QMetaType::QColor:
                {
                QColor from = qvariant_cast<QColor>(m_from);
                QColor to = qvariant_cast<QColor>(m_to);
                QColor result = qvariant_cast<QColor>(value);
                result.setRed(from.red() + (to.red() - from.red()) * m_easing.valueForProgress(tx / m_duration));
                result.setGreen(from.green() + (to.green() - from.green()) * m_easing.valueForProgress(tx / m_duration));
                result.setBlue(from.blue() + (to.blue() - from.blue()) * m_easing.valueForProgress(tx / m_duration));
                result.setAlpha(from.alpha() + (to.alpha() - from.alpha()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::Int:
                value = QVariant(m_from.toInt() + (m_to.toInt() - m_from.toInt()) * m_easing.valueForProgress(tx / m_duration));
                break;
            case QMetaType::QSize:
                {
                QSize from = m_from.toSize();
                QSize to = m_to.toSize();
                QSize result = value.toSize();
                result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
                result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QSizeF:
                {
                QSizeF from = m_from.toSize();
                QSizeF to = m_to.toSize();
                QSizeF result = value.toSize();
                result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
                result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QPoint:
                {
                QPoint from = m_from.toPoint();
                QPoint to = m_to.toPoint();
                QPoint result = value.toPoint();
                result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
                result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QPointF:
                {
                QPointF from = m_from.toPointF();
                QPointF to = m_to.toPointF();
                QPointF result = value.toPointF();
                result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
                result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QRect:
                {
                QRect from = m_from.toRect();
                QRect to = m_to.toRect();
                QRect result = value.toRect();
                result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
                result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
                result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
                result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QRectF:
                {
                QRectF from = m_from.toRectF();
                QRectF to = m_to.toRectF();
                QRectF result = value.toRectF();
                result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
                result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
                result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
                result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            case QMetaType::QVector3D:
                {
                QVector3D from = qvariant_cast<QVector3D>(m_from);
                QVector3D to = qvariant_cast<QVector3D>(m_to);
                QVector3D result = qvariant_cast<QVector3D>(value);
                result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
                result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
                result.setZ(from.z() + (to.z() - from.z()) * m_easing.valueForProgress(tx / m_duration));
                value = result;
                break;
                }
            default:
                break;
            }
            ap->setValue(value);
        }
    }
}
Example #6
0
void ImageOverlay::render(RenderArgs* args) {
    if (!_isLoaded && _renderImage) {
        _isLoaded = true;
        _texture = DependencyManager::get<TextureCache>()->getTexture(_imageURL);
    }
    // If we are not visible or loaded, return.  If we are trying to render an
    // image but the texture hasn't loaded, return.
    if (!_visible || !_isLoaded || (_renderImage && !_texture->isLoaded())) {
        return;
    }

    auto geometryCache = DependencyManager::get<GeometryCache>();
    gpu::Batch& batch = *args->_batch;
    geometryCache->useSimpleDrawPipeline(batch);
    if (_renderImage) {
        batch.setResourceTexture(0, _texture->getGPUTexture());
    } else {
        batch.setResourceTexture(0, args->_whiteTexture);
    }

    const float MAX_COLOR = 255.0f;
    xColor color = getColor();
    float alpha = getAlpha();
    glm::vec4 quadColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);

    int left = _bounds.left();
    int right = _bounds.right() + 1;
    int top = _bounds.top();
    int bottom = _bounds.bottom() + 1;

    glm::vec2 topLeft(left, top);
    glm::vec2 bottomRight(right, bottom);

    batch.setModelTransform(Transform());

    // if for some reason our image is not over 0 width or height, don't attempt to render the image
    if (_renderImage) {
        float imageWidth = _texture->getWidth();
        float imageHeight = _texture->getHeight();
        if (imageWidth > 0 && imageHeight > 0) {
            QRect fromImage;
            if (_wantClipFromImage) {
                float scaleX = imageWidth / _texture->getOriginalWidth();
                float scaleY = imageHeight / _texture->getOriginalHeight();

                fromImage.setX(scaleX * _fromImage.x());
                fromImage.setY(scaleY * _fromImage.y());
                fromImage.setWidth(scaleX * _fromImage.width());
                fromImage.setHeight(scaleY * _fromImage.height());
            }
            else {
                fromImage.setX(0);
                fromImage.setY(0);
                fromImage.setWidth(imageWidth);
                fromImage.setHeight(imageHeight);
            }

            float x = fromImage.x() / imageWidth;
            float y = fromImage.y() / imageHeight;
            float w = fromImage.width() / imageWidth; // ?? is this what we want? not sure
            float h = fromImage.height() / imageHeight;

            glm::vec2 texCoordTopLeft(x, y);
            glm::vec2 texCoordBottomRight(x + w, y + h);
            glm::vec4 texcoordRect(texCoordTopLeft, w, h);

            DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor);
        } else {
            DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, quadColor);
        }
    } else {
        DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, quadColor);
    }
}
Example #7
0
Window::Window(void) {
    setWindowTitle(APP_NAME);
    is_full_screen = false;

//	setWindowOpacity(0.9);
//	setAttribute(Qt::WA_MacSmallSize, true);
//	setAttribute(Qt::WA_MacMiniSize, true);
//	setAttribute(Qt::WA_MacBrushedMetal, true);
    setUnifiedTitleAndToolBarOnMac(true);

    browser = new Browser();
    process = new Process();
    connect(process, SIGNAL(signal_OOM_notification(void *)), this, SLOT(slot_OOM_notification(void *)));

    edit = new Edit(process, browser);
    QWidget *view_container = edit->get_views_widget(this);
    edit_history = new EditHistory(edit, this);
    edit->set_edit_history(edit_history);

    batch = new Batch(this, process, edit, browser);

    // load or reset photo - from browser to edit
    connect(browser, SIGNAL(signal_load_photo(Photo_ID, QString, QImage)), edit, SLOT(slot_load_photo(Photo_ID, QString, QImage)));

    // update processed thumbnail in browser
    connect(edit, SIGNAL(signal_update_thumbnail(Photo_ID, QImage)), browser, SLOT(slot_update_thumbnail(Photo_ID, QImage)));

    // 'center' browser on already open photo
    connect(edit, SIGNAL(signal_browse_to_photo(Photo_ID)), browser, SLOT(slot_browse_to_photo(Photo_ID)));

    // reset photos selection
    connect(batch, SIGNAL(signal_batch_accepted(void)), browser, SLOT(slot_selection_clear(void)));
    // context menu 'save as'
    connect(browser, SIGNAL(signal_export(void)), batch, SLOT(slot_export(void)));

    create_side_tabs();

    sp_thumbs_left = new Main_Splitter(Qt::Horizontal, this);
    sp_thumbs_left_w = new QWidget();
    sp_thumbs_left->addWidget(sp_thumbs_left_w);
    sp_thumbs_left->addWidget(view_container);
    sp_thumbs_left_w->setVisible(false);
//	sp_thumbs_left->insertWidget(1, view_container);
    sp_thumbs_left->setStretchFactor(0, 0);
    sp_thumbs_left->setStretchFactor(1, 1);
    sp_thumbs_left->setCollapsible(0, false);
    sp_thumbs_left->setCollapsible(1, false);
    sp_thumbs_left->setOpaqueResize(false);

    sp_thumbs_right = new Main_Splitter(Qt::Horizontal, this);
    sp_thumbs_right->addWidget(sp_thumbs_left);
    sp_thumbs_right->setStretchFactor(0, 1);
    sp_thumbs_right->setStretchFactor(1, 0);
    sp_thumbs_right->setCollapsible(0, false);
//	sp_thumbs_right->setCollapsible(1, false);
    sp_thumbs_right->setOpaqueResize(false);

    QSplitter *sp_left = new Main_Splitter(Qt::Horizontal, this);
    sp_left->addWidget(widget_side);
    sp_left->addWidget(sp_thumbs_right);
//	sp_left->addWidget(view_container);
    sp_left->setStretchFactor(0, 0);
    sp_left->setStretchFactor(1, 1);
    sp_left->setCollapsible(0, false);
    sp_left->setCollapsible(1, false);
    sp_left->setOpaqueResize(false);

    sp_thumbs_top = new Main_Splitter(Qt::Vertical, this);
    sp_thumbs_top->addWidget(browser->get_list());	// 0
    sp_thumbs_top->addWidget(sp_left);				// 1
    sp_thumbs_top->setStretchFactor(0, 0);
    sp_thumbs_top->setStretchFactor(1, 1);
    sp_thumbs_top->setCollapsible(0, false);
    sp_thumbs_top->setCollapsible(1, false);
    sp_thumbs_top->setOpaqueResize(false);

    sp_thumbs_bottom = new Main_Splitter(Qt::Vertical, this);
    sp_thumbs_bottom->addWidget(sp_thumbs_top);	// 0
    sp_thumbs_bottom->setStretchFactor(0, 1);
    sp_thumbs_bottom->setStretchFactor(1, 0);
    sp_thumbs_bottom->setCollapsible(0, false);
    sp_thumbs_bottom->setOpaqueResize(false);

    QVBoxLayout *controls_layout = new QVBoxLayout();
    QWidget *controls = edit->get_controls_widget();
    controls_layout->setContentsMargins(0, 0, 0, 0);
    controls_layout->addWidget(controls, 1);
    controls_layout->addWidget(batch->controls());

    QHBoxLayout *main_layout = new QHBoxLayout;
    main_layout->setSpacing(0);
    main_layout->setContentsMargins(0, 0, 0, 0);
    main_layout->addWidget(sp_thumbs_bottom, 1);
    main_layout->addLayout(controls_layout, 0);

    QWidget *main_widget = new QWidget(this);
    main_widget->setContentsMargins(0, 0, 0, 0);
    main_widget->setLayout(main_layout);
    setCentralWidget(main_widget);

    create_menu();
    // place window at the desktop
    // TODO: save and restore geometry after first run
    QRect dr = qApp->desktop()->screenGeometry(this);
    int w = 1000;
    int h = 560;
    dr.setX((dr.width() - w) / 2);
    dr.setY((dr.height() - h) / 3);
    dr.setWidth(w);
    dr.setHeight(h);
    this->setGeometry(dr);

    // reconfigure if necessary
    thumbnails_position = Browser::thumbnails_top;
    string str;
    if(Config::instance()->get(CONFIG_SECTION_LAYOUT, "thumbnails_position", str))
        thumbnails_position = Browser::thumbnails_position_from_string(str);
    change_thumbnails_position(thumbnails_position);

    /*
    	QSet<QString> styles_blacklist;
    	styles_blacklist.insert("motif");
    	styles_blacklist.insert("windows");
    //	styles_blacklist.insert("cde");
    	QStringList l = QStyleFactory::keys();
    	for(int i = 0; i < l.size(); ++i) {
    		QString entry = l[i].toLower();
    		if(!styles_blacklist.contains(entry))
    			cerr << "Style: \"" << l[i].toLocal8Bit().constData() << "\"" << endl;
    	}
    */
//	System::instance()->qt_style_default = new QStyle();
//	QApplication::setStyle(QStyleFactory::create("plastique"));
//	QApplication::setPalette(QApplication::style()->standardPalette());
}
Example #8
0
void CircuitsWidget::mouseReleaseEvent(QMouseEvent *event) {
	setFocus();
	if(connectingComponent){
		// resetting cursor
		QCursor c;
		c.setShape(Qt::ArrowCursor);
		setCursor(c);
		// checking click on components
		QPoint click = event->pos();
		for(int it = 0; it < componentList.size(); it++){
			QRect r = componentList[it]->rect();
			r.setX(componentList[it]->x());
			r.setY(componentList[it]->y());
			r.setWidth(componentList[it]->width());
			r.setHeight(componentList[it]->height());
			bool c1 = r.contains(click); // the mouserelease is on a component
			bool c2 = !(componentOnConnection == componentList[it]); // not the same component
			bool c3 = (componentOnConnection->outComponentList.indexOf(componentList[it])==-1); // not already connected
			bool c4 = componentOnConnection->getComponentType() != 2; // the left component is not a collector
			bool c5 = componentList[it]->getComponentType() != 3; // the right component is not a variable
            // if the right component is a collector it must be unconnected
            bool c6;
            if(componentList[it]->getComponentType() == 2)
                c6 = componentList[it]->inComponentList.isEmpty();
            else
                c6 = true;  
            // if the right component is a NOT port it must be unconnected
            bool c7;
            if(componentList[it]->getComponentType() == 6)
                c7 = componentList[it]->inComponentList.isEmpty();
            else
                c7 = true;
            // if the right component is a divider, it must be unconnected
            bool c8;
            if(componentList[it]->getComponentType() == 7)
                c8 = componentList[it]->inComponentList.isEmpty();
            else
                c8 = true;
			if(c1 && c2 && c3 && c4 && c5 && c6 && c7 && c8){
				// creating and set new wire
				Wire *w = new Wire(componentOnConnection, componentList[it]);
				wireList.append(w);
				// setting connections
				componentOnConnection->outComponentList.append(componentList[it]);
				componentList[it]->inComponentList.append(componentOnConnection);
				// value injection
				int ctype = componentList[it]->getComponentType();
				switch(ctype){
                    case(8):{
                        // muler
                        int tmp = componentList[it]->getValue();
                        componentList[it]->setValue(tmp * componentOnConnection->getValue());
                        break;
                    }
                    case(7):{
                        // diver
                        Diver* d = (Diver*) componentList[it].data(); // pay attenction
                        int r = componentOnConnection->getValue() / d->getDivider();
                        componentList[it]->setValue(r);
                        break;
                    }
                    case(6):{
                        //noter
                        if(componentOnConnection->getValue() != 0)
                            componentList[it]->setValue(0);
                        else
                            componentList[it]->setValue(1);
                        break;
                    }
                    case(5):{
                        //orer
                        bool tmp = componentList[it]->getValue();
                        componentList[it]->setValue(tmp || componentOnConnection->getValue());
                        break;
                    }
                    case(4):{
                        //ander
                        bool tmp = componentList[it]->getValue();
                        componentList[it]->setValue(tmp && componentOnConnection->getValue());
                        break;
                    }
					case(3):{
						//variabile
						printf("WARNING: This component shouldn't have any incoming component\n");
						break;
					}
					case(2):{
						// collector
						componentList[it]->setValue(componentOnConnection->getValue());
						break;
					}
					case(1):{
						//adder
						int tmp = componentList[it]->getValue();
						componentList[it]->setValue(tmp + componentOnConnection->getValue());
						break;
					}
					default:{
						printf("FATAL ERROR: invalid component type\n");
						exit(1);
					}
				}
				repaint();
			}
		}
		connectingComponent = false;
		componentOnConnection = NULL;
	}
}
/** Overloads default QWidget::paintEvent. Draws the actual 
 * bandwidth graph. */
void RSPermissionMatrixWidget::paintEvent(QPaintEvent *)
{
    //std::cerr << "In paint event!" << std::endl;

  /* Set current graph dimensions */
  _rec = this->frameRect();
  
  /* Start the painter */
  _painter->begin(this);
  
  /* We want antialiased lines and text */
  _painter->setRenderHint(QPainter::Antialiasing);
  _painter->setRenderHint(QPainter::TextAntialiasing);
  
  /* Fill in the background */
  _painter->fillRect(_rec, QBrush(BACK_COLOR));
  _painter->drawRect(_rec);

  // draw one line per friend.
  std::list<RsPeerId> ssllist ;
  rsPeers->getFriendList(ssllist) ;

  // sort list
  {
      // RSPermissionMatrixWidgets parent is ServicePermissionsPage which holds the checkbox
      ServicePermissionsPage *spp = dynamic_cast<ServicePermissionsPage*>(parentWidget());
      if(spp != NULL) {
          // sort out offline peers
          if(spp->isHideOfflineChecked()) {
              RsPeerDetails peerDetails;
              for(std::list<RsPeerId>::iterator it = ssllist.begin(); it != ssllist.end();) {
                  rsPeers->getPeerDetails(*it, peerDetails);

                  switch (peerDetails.connectState) {
                  case RS_PEER_CONNECTSTATE_OFFLINE:
                  case RS_PEER_CONNECTSTATE_TRYING_TCP:
                  case RS_PEER_CONNECTSTATE_TRYING_UDP:
                      it = ssllist.erase(it);
                      break;
                  default:
                      it++;
                      break;
                  }
              }
          }
      }

      // sort by name
      ssllist.sort(sortRsPeerIdByNameLocation);
  }

  RsPeerServiceInfo ownServices;
  rsServiceControl->getOwnServices(ownServices);

  // Display friend names at the beginning of each column

  const QFont& font(_painter->font()) ;
  QFontMetrics fm(font);
  int peer_name_size = 0 ;
  float line_height = 2 + fm.height() ;

  std::vector<QString> names ;

  for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it)
  {
      RsPeerDetails details ;
      rsPeers->getPeerDetails(*it,details) ;

      QString name = QString::fromUtf8(details.name.c_str()) + " (" + QString::fromUtf8(details.location.c_str()) + ")";
      if(name.length() > 20)
          name = name.left(20)+"..." ;

      peer_name_size = std::max(peer_name_size, fm.width(name)) ;
      names.push_back(name) ;
  }

  QPen pen ;
  pen.setWidth(2) ;
  pen.setBrush(Qt::black) ;

  _painter->setPen(pen) ;
  int i=0;
  int x=5 ;
  int y=MATRIX_START_Y ;

  for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it,++i)
  {
      float X = MATRIX_START_X + peer_name_size - fm.width(names[i]) ;
      float Y = MATRIX_START_Y + (i+0.5)*ROW_SIZE + line_height/2.0f-2 ;

      _painter->drawText(QPointF(X,Y),names[i]) ;

      if(*it == _current_peer_id)
          _painter->drawLine(QPointF(X,Y+3),QPointF(X+fm.width(names[i]),Y+3)) ;

      y += line_height ;
  }

  matrix_start_x = 5 + MATRIX_START_X + peer_name_size ;

  // now draw the service names

  i=0 ;
  std::vector<int> last_width(10,0) ;

  for(std::map<uint32_t, RsServiceInfo>::const_iterator it(ownServices.mServiceList.begin());it!=ownServices.mServiceList.end();++it,++i)
  {
      QString name = QString::fromUtf8(it->second.mServiceName.c_str()) ;
      int text_width = fm.width(name) ;

      int X = matrix_start_x + COL_SIZE/2 - 2 + i*COL_SIZE - text_width/2;

      int height_index = 0 ;
      while(last_width[height_index] > X-5 && height_index < last_width.size()-1)
          ++height_index ;

      int Y = MATRIX_START_Y - ICON_SIZE_Y - 2 - line_height * height_index;

      last_width[height_index] = X + text_width ;
       // draw a half-transparent rectangle

      QBrush brush ;
      brush.setColor(QColor::fromHsvF(0.0f,0.0f,1.0f,0.8f));
      brush.setStyle(Qt::SolidPattern) ;

      QPen pen ;
      pen.setWidth(2) ;

      if(_current_service_id == it->second.mServiceType)
          pen.setBrush(Qt::black) ;
      else
          pen.setBrush(Qt::gray) ;

      _painter->setPen(pen) ;

      QRect info_pos( X-5,Y-line_height-2, text_width + 10, line_height + 5) ;

      //_painter->fillRect(info_pos,brush) ;
      //_painter->drawRect(info_pos) ;

      _painter->drawLine(QPointF(X,Y+3),QPointF(X+text_width,Y+3)) ;
      _painter->drawLine(QPointF(X+text_width/2, Y+3), QPointF(X+text_width/2,MATRIX_START_Y+peer_ids.size()*ROW_SIZE - ROW_SIZE+5)) ;

      pen.setBrush(Qt::black) ;
      _painter->setPen(pen) ;

      _painter->drawText(QPointF(X,Y),name);
  }

  // Now draw the global switches.

  peer_ids.clear() ;
  for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it)
      peer_ids.push_back(*it) ;
  service_ids.clear() ;
  for(std::map<uint32_t, RsServiceInfo>::const_iterator sit(ownServices.mServiceList.begin());sit!=ownServices.mServiceList.end();++sit)
      service_ids.push_back(sit->first) ;

  static const std::string global_switch[2] = { ":/images/global_switch_off.png",
                                                ":/images/global_switch_on.png" } ;

  for(int i=0;i<service_ids.size();++i)
  {
      RsServicePermissions serv_perm ;
      rsServiceControl->getServicePermissions(service_ids[i],serv_perm) ;

      QPixmap pix(global_switch[serv_perm.mDefaultAllowed].c_str()) ;
      QRect position = computeNodePosition(0,i,false) ;

      position.setY(position.y() - ICON_SIZE_Y + 8) ;
      position.setX(position.x() + 3) ;
      position.setHeight(30) ;
      position.setWidth(30) ;

      _painter->drawPixmap(position,pix,QRect(0,0,30,30)) ;
  }

  // We draw for each service.

  static const std::string pixmap_names[4] = { ":/images/switch00.png",
                                               ":/images/switch01.png",
                                               ":/images/switch10.png",
                                               ":/images/switch11.png" } ;

  int n_col = 0 ;
  int n_col_selected = -1 ;
  int n_row_selected = -1 ;

  for(std::map<uint32_t, RsServiceInfo>::const_iterator sit(ownServices.mServiceList.begin());sit!=ownServices.mServiceList.end();++sit,++n_col)
  {
      RsServicePermissions service_perms ;

      rsServiceControl->getServicePermissions(sit->first,service_perms) ;

      // draw the default switch.


      // draw one switch per friend.

      int n_row = 0 ;

      for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it,++n_row)
      {
          RsPeerServiceInfo local_service_perms ;
          RsPeerServiceInfo remote_service_perms ;

          rsServiceControl->getServicesAllowed (*it, local_service_perms) ;
          rsServiceControl->getServicesProvided(*it,remote_service_perms) ;

          bool  local_allowed =  local_service_perms.mServiceList.find(sit->first) !=  local_service_perms.mServiceList.end() ;
          bool remote_allowed = remote_service_perms.mServiceList.find(sit->first) != remote_service_perms.mServiceList.end() ;

      QPixmap pix(pixmap_names[(local_allowed << 1) + remote_allowed].c_str()) ;

      bool selected = (sit->first == _current_service_id && *it == _current_peer_id) ;
      QRect position = computeNodePosition(n_row,n_col,selected) ;

      if(selected)
      {
          n_row_selected = n_row ;
          n_col_selected = n_col ;
      }
          _painter->drawPixmap(position,pix,QRect(0,0,ICON_SIZE_X,ICON_SIZE_Y)) ;
      }
  }

  // now display some info about current node.

  if(n_row_selected < peer_ids.size() && n_col_selected < service_ids.size())
  {
      QRect position = computeNodePosition(n_row_selected,n_col_selected,false) ;

      // draw text info

      RsServicePermissions service_perms ;

      rsServiceControl->getServicePermissions(service_ids[n_col_selected],service_perms) ;

      QString service_name    = tr("Service name:")+" "+QString::fromUtf8(service_perms.mServiceName.c_str()) ;
      QString service_default = service_perms.mDefaultAllowed?tr("Allowed by default"):tr("Denied by default");
      QString peer_name = tr("Peer name:")+" " + names[n_row_selected] ;
      QString peer_id = tr("Peer Id:")+" "+QString::fromStdString(_current_peer_id.toStdString()) ;

      RsPeerServiceInfo pserv_info ;
      rsServiceControl->getServicesAllowed(_current_peer_id,pserv_info) ;

      bool locally_allowed = pserv_info.mServiceList.find(_current_service_id) != pserv_info.mServiceList.end();
      bool remotely_allowed = false ; // default, if the peer is offline

      if(rsServiceControl->getServicesProvided(_current_peer_id,pserv_info))
          remotely_allowed = pserv_info.mServiceList.find(_current_service_id) != pserv_info.mServiceList.end();

      QString local_status  = locally_allowed ?tr("Enabled for this peer") :tr("Disabled for this peer") ;
      QString remote_status = remotely_allowed?tr("Enabled by remote peer"):tr("Disabled by remote peer") ;

      if(!service_perms.mDefaultAllowed)
          local_status = tr("Switched Off") ;

      const QFont& font(_painter->font()) ;
      QFontMetrics fm(font);

      int text_size_x = 0 ;
      text_size_x = std::max(text_size_x,fm.width(service_name));
      text_size_x = std::max(text_size_x,fm.width(peer_name));
      text_size_x = std::max(text_size_x,fm.width(peer_id));
      text_size_x = std::max(text_size_x,fm.width(local_status));
      text_size_x = std::max(text_size_x,fm.width(remote_status));

       // draw a half-transparent rectangle

      QBrush brush ;
      brush.setColor(QColor::fromHsvF(0.0f,0.0f,1.0f,0.8f));
      brush.setStyle(Qt::SolidPattern) ;

      QPen pen ;
      pen.setWidth(2) ;
      pen.setBrush(Qt::black) ;

      _painter->setPen(pen) ;

      QRect info_pos( position.x() + 50, position.y() - 10, text_size_x + 10, line_height * 5 + 5) ;

      _painter->fillRect(info_pos,brush) ;
      _painter->drawRect(info_pos) ;

      // draw the text

      float x = info_pos.x() + 5 ;
      float y = info_pos.y() + line_height + 1 ;

      _painter->drawText(QPointF(x,y), service_name)  ; y += line_height ;
      _painter->drawText(QPointF(x,y), peer_name)     ; y += line_height ;
      _painter->drawText(QPointF(x,y), peer_id)       ; y += line_height ;
      _painter->drawText(QPointF(x,y), remote_status) ; y += line_height ;
      _painter->drawText(QPointF(x,y), local_status)  ; y += line_height ;
  }

  _max_height = MATRIX_START_Y + (peer_ids.size()+3) * ROW_SIZE ;
  _max_width  = matrix_start_x + (service_ids.size()+3) * COL_SIZE ;

  /* Stop the painter */
  _painter->end();
}
Example #10
0
void UBRubberBand::mouseMoveEvent(QMouseEvent *event)
{
    determineResizingMode(event->pos());

    if (mMouseIsPressed)
    {
        UBBoardView *view = UBApplication::boardController->controlView();
        QRect currentGeometry = geometry();

        QPoint pressPoint(event->pos());
        QPoint pressPointGlobal(view->mapToGlobal(pressPoint));
        QPoint prevPressPointGlobal(view->mapToGlobal(mLastPressedPoint));
        QPoint movePointGlogal = (view->mapToGlobal(mLastMousePos));

        QPoint topLeftResizeVector(pressPointGlobal - prevPressPointGlobal);
        QPoint rightBottomResizeVector(pressPointGlobal - movePointGlogal);

        bool bGeometryChange = true;

        switch(mResizingMode)
        {
        case None:
            {
                QPointF itemsMoveVector(view->mapToScene(pressPointGlobal) - view->mapToScene(prevPressPointGlobal));

                move(pos()+pressPointGlobal - prevPressPointGlobal);
                view->moveRubberedItems(itemsMoveVector);

                bGeometryChange = false;
                break;
            }

        case Top:
            {
                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());
            }break;

        case Bottom:
            {
                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());
            }break;

        case Left:
            {
                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());
            }break;
        case Right:
            {
                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());
            }break;

        case TopLeft:
            {
                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());  
                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());
            }break;

        case TopRight:
            {
                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());  
                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());                
            }
            break;

        case BottomLeft:
            {
                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());
                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());  
            }break;

        case BottomRight:
            {
                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());
                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());        
            }break;
        
        }
        if(bGeometryChange)
        {   
            setGeometry(currentGeometry);
        }

        mLastMousePos = event->pos();
    }

    QRubberBand::mouseMoveEvent(event);
} 
void Data_analysis_gui::save_as_image( const QString& filename, 
                                       const QString& format,
                                       bool show_stats, bool show_grid ) {
  // get a file name and the name of the filter to use to save the image.
  // 3 filters are available: PNG, BMP, and Postscript. Postscript is not
  // available on Windows (Qt limitation).


  // Create a blank image of the correct dimensions
  int extra_width = 15;
  int min_height = 0;
  if( show_stats ) {
    extra_width = 200;
    min_height = 250;
  }
  QSize total_size( plot_->size().width() + extra_width, 
                    std::max( min_height, plot_->size().height()+10 ) );
  QPixmap pix( total_size );
  pix.fill();
  QPainter painter( &pix );
  

  // draw the content of the plot

  QwtPlotPrintFilter filter;
  if( show_grid )
    filter.setOptions( QwtPlotPrintFilter::PrintTitle | QwtPlotPrintFilter::PrintGrid );
  else
    filter.setOptions( QwtPlotPrintFilter::PrintTitle );

  QRect rect = plot_->rect();
  rect.setY( rect.y() + 10 );
  plot_->print( &painter, rect, filter );


  // Add the summary statistics to the image if requested

  if( show_stats ) {
    QFont font = plot_->axisFont( QwtPlot::xBottom );
    painter.setFont( font );
    int text_y_start = std::max( 40, total_size.height()/2 - 100 );
    painter.translate( plot_->size().width()+15 , text_y_start );
    paint_stats( painter );
  }


  // Finally, save the pixmap in the required format

  if( format == "Postscript" || format == "PS" ) {
    /*
#if defined(WIN32) || defined(_WIN32)
    if (show_stats)
		build_stats();
    SimplePs ps(filename,plot_, _stats,show_stats);
	if (!ps.isopen()){
		QMessageBox::warning(this,"Unable to save file",
		"Failed to save ps file",QMessageBox::Ok,
		Qt::NoButton);
		return;
	}
	savePostScript(ps);

#else
    */
    QPrinter printer;
    
    printer.setOutputFormat(QPrinter::PostScriptFormat);
    printer.setOutputFileName( filename );
    printer.setPageSize( QPrinter::A6 );
    printer.setFullPage( true );
    printer.setOrientation( QPrinter::Landscape );
    plot_->print(printer, filter);

    QPainter P(&printer);
    //P.begin(&printer);
    //paint_stats(P);
    P.drawPixmap(QPoint(0,0),pix);

    //#endif
  }
  else {
    QByteArray tmp = format.toLatin1();
    pix.save( filename, tmp.constData() );
  }

}
Example #12
0
// --------------------------------------------------
void ctkSearchBox::paintEvent(QPaintEvent * event)
{
  Q_D(ctkSearchBox);

  // Draw the line edit with text.
  // Text has already been shifted to the right (in resizeEvent()) to leave
  // space for the search icon.
  this->Superclass::paintEvent(event);

  QPainter p(this);

  QRect cRect = d->clearRect();
  QRect sRect = d->showSearchIcon ? d->searchRect() : QRect();

#if QT_VERSION >= 0x040700
  QRect r = rect();
  QPalette pal = palette();

  QStyleOptionFrameV2 panel;
  initStyleOption(&panel);
  r = this->style()->subElementRect(QStyle::SE_LineEditContents, &panel, this);
  r.setX(r.x() + this->textMargins().left());
  r.setY(r.y() + this->textMargins().top());
  r.setRight(r.right() - this->textMargins().right());
  r.setBottom(r.bottom() - this->textMargins().bottom());
  p.setClipRect(r);

  QFontMetrics fm = fontMetrics();
  Qt::Alignment va = QStyle::visualAlignment(this->layoutDirection(),
                                             QFlag(this->alignment()));
  int vscroll = 0;
  const int verticalMargin = 1;
  const int horizontalMargin = 2;
  switch (va & Qt::AlignVertical_Mask) {
   case Qt::AlignBottom:
       vscroll = r.y() + r.height() - fm.height() - verticalMargin;
       break;
   case Qt::AlignTop:
       vscroll = r.y() + verticalMargin;
       break;
   default:
       //center
       vscroll = r.y() + (r.height() - fm.height() + 1) / 2;
       break;
  }
  QRect lineRect(r.x() + horizontalMargin, vscroll,
                 r.width() - 2*horizontalMargin, fm.height());

  int minLB = qMax(0, -fm.minLeftBearing());

  if (this->text().isEmpty())
    {
    if (!this->hasFocus() && !this->placeholderText().isEmpty())
      {
      QColor col = pal.text().color();
      col.setAlpha(128);
      QPen oldpen = p.pen();
      p.setPen(col);
      lineRect.adjust(minLB, 0, 0, 0);
      QString elidedText = fm.elidedText(this->placeholderText(), Qt::ElideRight, lineRect.width());
      p.drawText(lineRect, va, elidedText);
      p.setPen(oldpen);
      }
    }
  p.setClipRect(this->rect());
#endif

  // Draw clearIcon
  if (!d->hideClearIcon)
    {
    QPixmap closePixmap = d->clearIcon.pixmap(cRect.size(),this->isEnabled() ? QIcon::Normal : QIcon::Disabled);
    this->style()->drawItemPixmap(&p, cRect, Qt::AlignCenter, closePixmap);
    }

  // Draw searchIcon
  if (d->showSearchIcon)
    {
    QPixmap searchPixmap = d->searchIcon.pixmap(sRect.size(), this->isEnabled() ? QIcon::Normal : QIcon::Disabled);
    this->style()->drawItemPixmap(&p, sRect, Qt::AlignCenter, searchPixmap);
    }
}
Example #13
0
void DrawZone::drawContents(QPainter* p,int clipx,int clipy,int clipw,int cliph)
{

// Erase background without flicker
	QRect updateRect(clipx,clipy,clipw,cliph);

	// Pixmap for double-buffering
  QPixmap doubleBuffer(updateRect.size());
  if (doubleBuffer.isNull())
  	return;

  QPainter p2(&doubleBuffer);
	p2.drawPixmap(0,0,zoomedImage,clipx,clipy,clipw,cliph);
	p2.setBackgroundColor(p->backgroundColor());

	if (zoomedImage.width() < (clipw+clipx) ) {
		int eraseWidth = clipw+clipx - zoomedImage.width();
		p2.eraseRect( QRect(clipw-eraseWidth,0,eraseWidth,cliph) );
	}

	if (zoomedImage.height() < (cliph+clipy) ) {
		int eraseHeight = cliph+clipy - zoomedImage.height();
		p2.eraseRect( QRect(0,cliph-eraseHeight,clipw,eraseHeight) );
	}

	p2.translate(-clipx, -clipy);
	p2.scale(_zoom,_zoom);

	QRect areaUpdateRect;
	areaUpdateRect.setX(myround(clipx/_zoom)-1);
	areaUpdateRect.setY(myround(clipy/_zoom)-1);
	areaUpdateRect.setWidth(myround(clipw/_zoom)+2);
	areaUpdateRect.setHeight(myround(cliph/_zoom)+2);

	AreaListIterator it=imageMapEditor->areaList();
	for ( it.toLast();it.current() != 0L; --it)
	{
     if (it.current()->rect().intersects(areaUpdateRect))
       it.current()->draw(p2);
	}

	// Draw the current drawing Area
	if (currentAction != MoveArea &&
			currentAction != MoveSelectionPoint &&
			currentAction != None &&
			currentAction != DoSelect)
	{
		currentArea->draw(p2);
	}

	if (currentAction == DoSelect )
  {
		QPen pen = QPen(QColor("white"),1);
		p2.setRasterOp(Qt::XorROP);
		pen.setStyle(Qt::DotLine);
		p2.setPen(pen);

		QRect r( drawStart.x(),drawStart.y(),drawCurrent.x()-drawStart.x(),drawCurrent.y()-drawStart.y());
		r = r.normalize();
		p2.drawRect(r);
	}



  p2.end();

  // Copy the double buffer into the widget
  p->drawPixmap(clipx,clipy,doubleBuffer);


}
Example #14
0
void View::setYPos(int y)
      {
      int delta  = ypos - y;         // -  -> shift up
      ypos  = y;
      
      #ifdef VIEW_USE_DOUBLE_BUFFERING
      if (pm.isNull())
            return;
      if (!pmValid) {
            //printf("View::setYPos !pmValid y:%d height:%d delta:%d\n", y, height(), delta);
            
            redraw();
            return;
            }
      
      int w = width();
      int h = height();
      
      QRect r;
      if (delta >= h || delta <= -h)
            r = QRect(0, 0, w, h);
      else if (delta < 0) {   // shift up
            //bitBlt(&pm,  0, 0, &pm, 0, -delta, w, h + delta, CopyROP, true);
            QPainter p(&pm);
            p.drawPixmap(0, 0, pm, 0, -delta, w, h + delta);
            r = QRect(0, h + delta, w, -delta);
            }
      else {                  // shift down
            //bitBlt(&pm,  0, delta, &pm, 0, 0, w, h-delta, CopyROP, true);
            QPainter p(&pm);
            p.drawPixmap(0, delta, pm, 0, 0, w, h-delta);
            r = QRect(0, 0, w, delta);
            }
      QRect olr = overlayRect();
      QRect olr1(olr);
      olr1.translate(0, delta);

      r |= olr;
      r |= olr1;

      //printf("View::setYPos paint delta:%d r.x:%d r.y:%d r.w:%d r.h:%d\n", delta, r.x(), r.y(), r.width(), r.height());  
      
      paint(r);
      update();
      
      #else
      scroll(0, delta);
      QRect olr = overlayRect();
      // Is there an overlay?
      if(!olr.isNull())
      {
        // Are we shifting down (moving up)?
        if(delta >= 0)
        {
          // Translate not good - need to set y to delta.
          //olr.translate(0, delta);
          olr.setY(delta);
          olr.setHeight(olr.y() + olr.height() + delta);
        }
        else
        // We are shifting up (moving down).
        {
          // Translate not good - need to limit y to 0.
          //olr.translate(0, delta);
          olr.setY(olr.y() + delta);
        }
        
        if(olr.x() < 0)
          olr.setX(0);
        if(olr.right() > width())
          olr.setRight(width());
        
        if(olr.y() < 0)
          olr.setY(0);
        if(olr.bottom() > height())
          olr.setBottom(height());
        
        //printf("scroll Y update: x:%d y:%d w:%d h:%d\n", olr.x(), olr.y(), olr.width(), olr.height()); 
        update(olr);
      }  
      #endif
      }
Example #15
0
AddonManagementDialog::AddonManagementDialog(QWidget * p)
: QWidget(p)
{
	setWindowTitle(__tr2qs_ctx("Manage Addons - KVIrc","addon"));
	setObjectName("Addon manager");
	setWindowIcon(*(g_pIconManager->getSmallIcon(KviIconManager::Addons)));

#ifdef COMPILE_WEBKIT_SUPPORT
	m_pWebInterfaceDialog = NULL;
#endif //COMPILE_WEBKIT_SUPPORT

	m_pInstance = this;
	QGridLayout * g = new QGridLayout(this);

	KviTalHBox *hb = new KviTalHBox(this);
	hb->setMargin(1);
	hb->setSpacing(1);
	g->addWidget(hb,0,0);

	QToolButton * tb;
	QFrame * sep;

	m_pConfigureButton = new QToolButton(hb);
	m_pConfigureButton->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_ADDONS)));
	m_pConfigureButton->setIconSize(QSize(32,32));
	KviTalToolTip::add(m_pConfigureButton,__tr2qs_ctx("Configure addon...","addon"));
	connect(m_pConfigureButton,SIGNAL(clicked()),this,SLOT(configureScript()));

	m_pHelpButton = new QToolButton(hb);
	m_pHelpButton->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_HELP)));
	m_pHelpButton->setIconSize(QSize(32,32));
	KviTalToolTip::add(m_pHelpButton,__tr2qs_ctx("Show help","addon"));
	connect(m_pHelpButton,SIGNAL(clicked()),this,SLOT(showScriptHelp()));

	m_pUninstallButton = new QToolButton(hb);
	m_pUninstallButton->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_REMOVE)));
	m_pUninstallButton->setIconSize(QSize(32,32));
	KviTalToolTip::add(m_pUninstallButton,__tr2qs_ctx("Delete selected addon","addon"));
	connect(m_pUninstallButton,SIGNAL(clicked()),this,SLOT(uninstallScript()));

	sep = new QFrame(hb);
	sep->setFrameStyle(QFrame::VLine | QFrame::Sunken);
	sep->setMinimumWidth(12);

	m_pPackButton = new QToolButton(hb);
	m_pPackButton->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_PACK)));
	m_pPackButton->setIconSize(QSize(32,32));
	KviTalToolTip::add(m_pPackButton,__tr2qs_ctx("Create an addon as a distributable package","addon"));
	connect(m_pPackButton,SIGNAL(clicked()),this,SLOT(packScript()));

	sep = new QFrame(hb);
	sep->setFrameStyle(QFrame::VLine | QFrame::Sunken);
	sep->setMinimumWidth(12);

	tb = new QToolButton(hb);
	tb->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_OPEN)));
	tb->setIconSize(QSize(32,32));
	KviTalToolTip::add(tb,__tr2qs_ctx("Install addon package from disk","addon"));
	connect(tb,SIGNAL(clicked()),this,SLOT(installScript()));

	tb = new QToolButton(hb);
	tb->setIcon(*(g_pIconManager->getBigIcon(KVI_BIGICON_WWW)));
	tb->setIconSize(QSize(32,32));
	KviTalToolTip::add(tb,__tr2qs_ctx("Get more addons...","addon"));
	connect(tb,SIGNAL(clicked()),this,SLOT(getMoreScripts()));

	QWidget *w= new QWidget(hb);
	w->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);

	m_pListWidget = new KviTalListWidget(this);
	KviTalIconAndRichTextItemDelegate *itemDelegate=new KviTalIconAndRichTextItemDelegate(m_pListWidget);

	m_pListWidget->setItemDelegate(itemDelegate);
	m_pListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	m_pListWidget->setSortingEnabled(true);
	m_pListWidget->setMinimumHeight(400);
	m_pListWidget->setMinimumWidth(380);
	g->addWidget(m_pListWidget,1,0);

	fillListView();

	currentChanged(0,0);
	connect(m_pListWidget,SIGNAL(currentItemChanged(QListWidgetItem *,QListWidgetItem *)),this,SLOT(currentChanged(QListWidgetItem *,QListWidgetItem *)));
	m_pListWidget->setCurrentItem(m_pListWidget->item(0));

	QPushButton * pCloseBtn = new QPushButton(__tr2qs_ctx("Close","addon"),this);
	pCloseBtn->setMaximumSize(pCloseBtn->sizeHint().width(),pCloseBtn->sizeHint().height());
	connect(pCloseBtn,SIGNAL(clicked()),this,SLOT(closeClicked()));
	g->addWidget(pCloseBtn,2,0);

	g->setMargin(5);
	g->setSpacing(5);
	g->setAlignment(pCloseBtn,Qt::AlignRight);

	if(g_rectManagementDialogGeometry.y() < 5)
	{
		g_rectManagementDialogGeometry.setY(5);
	}
	resize(g_rectManagementDialogGeometry.width(),
		g_rectManagementDialogGeometry.height());

	QRect rect = g_pApp->desktop()->screenGeometry(g_pMainWindow);
	move(rect.x() + ((rect.width() - g_rectManagementDialogGeometry.width())/2),rect.y() + ((rect.height() - g_rectManagementDialogGeometry.height())/2));

	new QShortcut(Qt::Key_Escape, this, SLOT(closeClicked()));
}
CustomizeToolBarsDialog::CustomizeToolBarsDialog(QWidget * p)
: QWidget(p)
{
	setObjectName("Toolbar_editor");
	setWindowTitle(__tr2qs_ctx("Customize Toolbars","editor"));
	setWindowIcon(*(g_pIconManager->getSmallIcon(KviIconManager::ToolBar)));

	m_pInstance = this;

	QGridLayout * g = new QGridLayout(this);
	m_pDrawer = new KviActionDrawer(this);
	g->addWidget(m_pDrawer,0,0,7,1);

	QPushButton * b = new QPushButton(__tr2qs_ctx("New ToolBar","editor"),this);
	connect(b,SIGNAL(clicked()),this,SLOT(newToolBar()));
	g->addWidget(b,0,1);

	m_pDeleteToolBarButton = new QPushButton(__tr2qs_ctx("Delete ToolBar","editor"),this);
	connect(m_pDeleteToolBarButton,SIGNAL(clicked()),this,SLOT(deleteToolBar()));
	g->addWidget(m_pDeleteToolBarButton,1,1);

	m_pRenameToolBarButton = new QPushButton(__tr2qs_ctx("Edit ToolBar","editor"),this);
	connect(m_pRenameToolBarButton,SIGNAL(clicked()),this,SLOT(renameToolBar()));
	g->addWidget(m_pRenameToolBarButton,2,1);

	QFrame * f = new QFrame(this);
	f->setFrameStyle(QFrame::HLine | QFrame::Sunken);
	g->addWidget(f,3,1);

	m_pExportToolBarButton = new QPushButton(__tr2qs_ctx("Export ToolBar","editor"),this);
	connect(m_pExportToolBarButton,SIGNAL(clicked()),this,SLOT(exportToolBar()));
	g->addWidget(m_pExportToolBarButton,4,1);

	TrashcanLabel * t = new TrashcanLabel(this);
	g->addWidget(t,6,1);

	b = new QPushButton(__tr2qs_ctx("Close","editor"),this);
	connect(b,SIGNAL(clicked()),this,SLOT(closeClicked()));
	g->addWidget(b,7,1);

	g->setRowStretch(5,1);
	g->setColumnStretch(0,1);

	m_pDrawer->fill();

	connect(KviActionManager::instance(),SIGNAL(currentToolBarChanged()),this,SLOT(currentToolBarChanged()));
	KviActionManager::instance()->customizeToolBarsDialogCreated();

	currentToolBarChanged();

	if(g_rectToolBarEditorDialogGeometry.y() < 5)
	{
		g_rectToolBarEditorDialogGeometry.setY(5);
	}
	//setGeometry(KVI_OPTION_RECT(KviOption_rectRegisteredUsersDialogGeometry));
	resize(g_rectToolBarEditorDialogGeometry.width(),
		g_rectToolBarEditorDialogGeometry.height());
	move(g_rectToolBarEditorDialogGeometry.x(),
		g_rectToolBarEditorDialogGeometry.y());

	new QShortcut(Qt::Key_Escape, this, SLOT(closeClicked()));
}
Example #17
0
ChannelsJoinDialog::ChannelsJoinDialog(const char * name)
: QDialog(g_pMainWindow)
{
	setObjectName(name);
	setWindowTitle(__tr2qs("Join Channels"));
	setWindowIcon(*(g_pIconManager->getSmallIcon(KviIconManager::Channel)));

	m_pConsole = 0;

	QGridLayout * g = new QGridLayout(this);

	m_pTreeWidget = new ChannelsJoinDialogTreeWidget(this);
	m_pTreeWidget->setHeaderLabel(__tr2qs("Channel"));
	m_pTreeWidget->setRootIsDecorated(true);
	m_pTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	g->addWidget(m_pTreeWidget,0,0,1,2);
	//connect(m_pTreeWidget,SIGNAL(itemDoubleClicked(QTreeWidgetItem *,int)),this,SLOT(itemDoubleClicked(QTreeWidgetItem *,int)));


	m_pGroupBox = new KviTalGroupBox(Qt::Horizontal,__tr2qs("Channel" ),this);
	QString szMsg = __tr2qs("Name");
	szMsg.append(":");

	new QLabel(szMsg,m_pGroupBox);

	m_pChannelEdit = new QLineEdit(m_pGroupBox);
	connect(m_pChannelEdit,SIGNAL(returnPressed()), this, SLOT(editReturnPressed()));
	connect(m_pChannelEdit,SIGNAL(textChanged(const QString &)),this,SLOT(editTextChanged(const QString &)));

	szMsg = __tr2qs("Password");
	szMsg.append(":");
	QLabel(szMsg,m_pGroupBox);

	m_pPass = new QLineEdit(m_pGroupBox);
	m_pPass->setEchoMode(QLineEdit::Password);

	g->addWidget(m_pGroupBox,1,0,1,2);

	KviTalHBox * hb = new KviTalHBox(this);
	hb->setSpacing(4);

	g->addWidget(hb,2,0,1,2,Qt::AlignHCenter);

	m_pJoinButton = new QPushButton(__tr2qs("&Join"),hb);
	// Join on return pressed
	m_pJoinButton->setDefault(true);
	connect(m_pJoinButton,SIGNAL(clicked()),this,SLOT(joinClicked()));

	m_pRegButton = new QPushButton(__tr2qs("&Register"),hb);
	// Join on return pressed
	connect(m_pRegButton,SIGNAL(clicked()),this,SLOT(regClicked()));

	m_pClearButton = new QPushButton(__tr2qs("Clear Recent"),hb);
	connect(m_pClearButton,SIGNAL(clicked()),this,SLOT(clearClicked()));

	m_pShowAtStartupCheck = new QCheckBox(__tr2qs("Show this window after connecting"),this);
	m_pShowAtStartupCheck->setChecked(KVI_OPTION_BOOL(KviOption_boolShowChannelsJoinOnIrc));
	g->addWidget(m_pShowAtStartupCheck,3,0);


	QPushButton * cancelButton = new QPushButton(__tr2qs("Close"),this);
	connect(cancelButton,SIGNAL(clicked()),this,SLOT(cancelClicked()));

	g->addWidget(cancelButton,3,1);

/*
	KviTalHBox * hb = new KviTalHBox(this);
	hb->setSpacing(4);

	QPushButton * namesButton = new QPushButton("/names", hb);
	connect(namesButton,SIGNAL(clicked()),this,SLOT(namesClicked()));
	QPushButton * whoButton = new QPushButton("/who", hb);
	connect(whoButton,SIGNAL(clicked()),this,SLOT(whoClicked()));

	g->addWidget(hb,2,0);
*/

	g->setRowStretch(0,1);
	g->setColumnStretch(0,1);

	fillListView();

	if(g_rectChannelsJoinGeometry.y() < 5)
		g_rectChannelsJoinGeometry.setY(5);

	resize(g_rectChannelsJoinGeometry.width(),g_rectChannelsJoinGeometry.height());
	//move(g_rectChannelsJoinGeometry.x(),g_rectChannelsJoinGeometry.y());

	QRect rect = g_pApp->desktop()->screenGeometry(g_pMainWindow);
	move(rect.x() + ((rect.width() - g_rectChannelsJoinGeometry.width())/2),rect.y() + ((rect.height() - g_rectChannelsJoinGeometry.height())/2));

	enableJoin();
}
Example #18
0
void BillboardOverlay::render(RenderArgs* args) {
    if (!_isLoaded) {
        _isLoaded = true;
        _texture = DependencyManager::get<TextureCache>()->getTexture(_url);
    }

    if (!_visible || !_texture->isLoaded()) {
        return;
    }

    glm::quat rotation;
    if (_isFacingAvatar) {
        // rotate about vertical to face the camera
        rotation = args->_viewFrustum->getOrientation();
        rotation *= glm::angleAxis(glm::pi<float>(), IDENTITY_UP);
        rotation *= getRotation();
    } else {
        rotation = getRotation();
    }

    float imageWidth = _texture->getWidth();
    float imageHeight = _texture->getHeight();

    QRect fromImage;
    if (_fromImage.isNull()) {
        fromImage.setX(0);
        fromImage.setY(0);
        fromImage.setWidth(imageWidth);
        fromImage.setHeight(imageHeight);
    } else {
        float scaleX = imageWidth / _texture->getOriginalWidth();
        float scaleY = imageHeight / _texture->getOriginalHeight();

        fromImage.setX(scaleX * _fromImage.x());
        fromImage.setY(scaleY * _fromImage.y());
        fromImage.setWidth(scaleX * _fromImage.width());
        fromImage.setHeight(scaleY * _fromImage.height());
    }

    float maxSize = glm::max(fromImage.width(), fromImage.height());
    float x = fromImage.width() / (2.0f * maxSize);
    float y = -fromImage.height() / (2.0f * maxSize);

    glm::vec2 topLeft(-x, -y);
    glm::vec2 bottomRight(x, y);
    glm::vec2 texCoordTopLeft(fromImage.x() / imageWidth, fromImage.y() / imageHeight);
    glm::vec2 texCoordBottomRight((fromImage.x() + fromImage.width()) / imageWidth,
                                  (fromImage.y() + fromImage.height()) / imageHeight);

    const float MAX_COLOR = 255.0f;
    xColor color = getColor();
    float alpha = getAlpha();

    auto batch = args->_batch;

    if (batch) {
        Transform transform = _transform;
        transform.postScale(glm::vec3(getDimensions(), 1.0f));
        
        batch->setModelTransform(transform);
        batch->setUniformTexture(0, _texture->getGPUTexture());
        
        DependencyManager::get<GeometryCache>()->renderQuad(*batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
                                                            glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha));
    
        batch->setUniformTexture(0, args->_whiteTexture); // restore default white color after me
    } else {
        glEnable(GL_ALPHA_TEST);
        glAlphaFunc(GL_GREATER, 0.5f);

        glEnable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);

        glBindTexture(GL_TEXTURE_2D, _texture->getID());

        glPushMatrix(); {
            glTranslatef(getPosition().x, getPosition().y, getPosition().z);
            glm::vec3 axis = glm::axis(rotation);
            glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
            glScalef(_dimensions.x, _dimensions.y, 1.0f);

            DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
                                                                glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha));

        } glPopMatrix();

        glDisable(GL_TEXTURE_2D);
        glEnable(GL_LIGHTING);
        glDisable(GL_ALPHA_TEST);

        glBindTexture(GL_TEXTURE_2D, 0);
    }
}
void SchemaEditorDialog::buildMessageView()
{

    QVBoxLayout *vbox = new QVBoxLayout(centerW);
    centerW->setLayout(vbox);

    //messageView = new QWidget(centerW);
    //messageView->setLayout(vbox);
    // target window at top of main widget
    targetArea = new QWidget(centerW);
    QHBoxLayout *tarBox = new QHBoxLayout(targetArea);
    tarBox->setMargin(0);
    targetArea->setLayout(tarBox);
    QFont fnt = targetArea->font();
    fnt.setBold(true);
    targetArea->setFont(fnt);

    windowL = new QLabel("Window:",targetArea);
    windowL->setFont(fnt);
    windowV = new QLabel("",targetArea);
    windowV->setAlignment(Qt::AlignLeft);
    //fnt.setPointSize(fnt.pointSize()+2);
    fnt.setItalic(true);
    windowV->setFont(fnt);
    QFontMetrics fm1(fnt);
    windowV->setMinimumWidth(fm1.maxWidth()*8);
    tarBox->addWidget(windowL,0,Qt::AlignLeft);
    tarBox->addWidget(windowV,1);

    QHBoxLayout *topBox = new QHBoxLayout();
    topBox->addWidget(targetArea,2);
    topBox->setMargin(0);
    statusArea = new QWidget(targetArea);
    QHBoxLayout *sbox = new QHBoxLayout(statusArea);
    statusArea->setLayout(sbox);
    sbox->setMargin(0);
    statusI = new QLabel(targetArea);
    statusL = new QLabel(targetArea);
    statusL->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
    statusL->setFont(fnt);
    statusL->setText("");
    sbox->addWidget(statusI);
    sbox->addWidget(statusL);
    topBox->addWidget(statusArea,1,Qt::AlignRight);

    splitter = new QSplitter(Qt::Horizontal,this);
    buildSchemaArea();
    messageView = new QWidget(splitter);
    QGridLayout *wgrid = new QGridLayout(messageView);
    messageView->setLayout(wgrid);
    splitter->insertWidget(0,schemaArea);
    splitter->insertWidget(1,messageView);
    splitter->setChildrenCollapsible(true);

    workAreaStack = new QStackedWidget(this);

    /***************** start message area *************/

    messageWorkArea = new QWidget(this);

    QGridLayout *mwaGrid = new QGridLayout(messageWorkArea);
    messageWorkArea->setLayout(mwaGrid);
    mwaGrid->setMargin(0);
    messageListL  = new QLabel("Messages");
    messageListL->setToolTip("All possible FIX messages");
    availableListL = new QLabel("Available Fields");
    availableListL->setToolTip("All fields associated with selected message");
    selectedListL = new QLabel("Selected Fields");
    selectedListL->setToolTip("Fields that define table(s) headers");
    selectedListL->setAlignment(Qt::AlignHCenter);
    messageListL->setAlignment(Qt::AlignHCenter);
    availableListL->setAlignment(Qt::AlignHCenter);
    selectedListL->setAlignment(Qt::AlignHCenter);
    QWidget *messageArea = new QWidget(this);
    QVBoxLayout *mbox = new QVBoxLayout(messageArea);
    messageArea->setLayout(mbox);
    mbox->setMargin(0);
    QString ss1;
    ss1.append("QTreeView::item:hover { color: #ffffff; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,stop: 0 #1a3994, stop: 1 #061a33);}");

    messageListTreeView = new QTreeView(this);
    messageListTreeView->setStyleSheet(ss1);
    messageListTreeView->setMouseTracking(true);
    messageSpacerItem = new QSpacerItem(22,32);
    mbox->addWidget(messageListTreeView,1);
    mbox->addSpacerItem(messageSpacerItem);

    messageModel = new QStandardItemModel(messageListTreeView);
    messageListTreeView->setModel(messageModel);
    messageDelegate = new MessageItemDelegate(messageListTreeView);
    messageListTreeView->setItemDelegateForColumn(0,messageDelegate);
    QStringList messageListHeaders;
    messageListHeaders << "Name";
    messageModel->setHorizontalHeaderLabels(messageListHeaders);
    messageListTreeView->setSortingEnabled(true);
    messageListTreeView->setUniformRowHeights(true);
    connect(messageListTreeView,SIGNAL(clicked(QModelIndex)),
            this,SLOT(messageListClickedSlot(QModelIndex)));
    QWidget *availableArea = new QWidget(this);
    QVBoxLayout *avbox = new QVBoxLayout(availableArea);
    avbox->setMargin(0);
    availableArea->setLayout(avbox);

    availableFieldsTreeView = new QTreeView(this);
    availableFieldsTreeView->setStyleSheet(ss1);
    availableFieldsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    QWidget *availableButtonArea = new QWidget(availableArea);
    QHBoxLayout *abox = new QHBoxLayout(availableButtonArea);
    availableButtonArea->setLayout(abox);
    abox->setMargin(0);
    expandBG = new QButtonGroup(this);
    QIcon expandIcon;
    expandIcon.addPixmap(QPixmap(":/images/svg/buttonOn.svg"),
                         QIcon::Normal,
                         QIcon::On);
    expandIcon.addPixmap(QPixmap(":/images/svg/empty.svg"),
                         QIcon::Normal,
                         QIcon::Off);
    expandBG->setExclusive(false);
    expandPB = new QPushButton("Expand",availableButtonArea);
    QRect rect;
    rect.setX(0);
    rect.setY(0);
    rect.setWidth(10);
    rect.setHeight(expandPB->height());
    messageSpacerItem->setGeometry(rect);
    collapsePB = new QPushButton("Collapse",availableButtonArea);
    expandPB->setIcon(expandIcon);
    collapsePB->setIcon(expandIcon);
    expandPB->setCheckable(true);
    collapsePB->setCheckable(true);
    expandPB->setToolTip("Expand All Tree Items");
    collapsePB->setToolTip("Collapse All Tree Items");
    expandBG->addButton(expandPB);
    expandBG->addButton(collapsePB);
    connect(expandPB,SIGNAL(toggled(bool)),this,SLOT(expandAllSlot(bool)));
    connect(collapsePB,SIGNAL(toggled(bool)),this,SLOT(collapseAllSlot(bool)));

    abox->addWidget(expandPB,0);
    abox->addWidget(collapsePB,0);
    avbox->addWidget(availableFieldsTreeView,1);
    avbox->addWidget(availableButtonArea,0,Qt::AlignLeft);
    //connect(availableFieldsTreeView,SIGNAL(clicked(QModelIndex)),
    //        this,SLOT(availableFieldsTreeViewClickedSlot(QModelIndex)));

    availableFieldModel = new QStandardItemModel(availableFieldsTreeView);
    connect(availableFieldModel,SIGNAL(itemChanged(QStandardItem*)),
            this,SLOT(availableTreeItemChangedSlot(QStandardItem*)));
    availableFieldModel->setColumnCount(1);
    availableFieldHeaderItem = new QStandardItem("Fields");
    availableFieldModel->setHorizontalHeaderItem(0,availableFieldHeaderItem);
    availableFieldsTreeView->setSortingEnabled(true);
    availableFieldsTreeView->setModel(availableFieldModel);
    /********************** end message area ***************/


    QWidget *selectArea = new QWidget(this);
    QVBoxLayout *selectBox = new QVBoxLayout(selectArea);
    selectBox->setMargin(0);
    selectArea->setLayout(selectBox);

    selectedFieldsTreeView = new SelectedFieldsTreeView(selectArea);
    connect(selectedFieldsTreeView,SIGNAL(clicked(QModelIndex)),this,SLOT(selectedListClickedSlot(QModelIndex)));
    selectedFieldsTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    selectedFieldModel = new QStandardItemModel(selectedFieldsTreeView);
    selectedFieldModel->setColumnCount(1);
    selectedHeaderItem = new QStandardItem("");
    selectedFieldModel->setHorizontalHeaderItem(0,selectedHeaderItem);
    selectedFieldsTreeView->setSortingEnabled(true);
    selectedFieldsTreeView->setStyleSheet(ss1);
    selectedFieldsTreeView->setModel(selectedFieldModel);

    clearPB = new QPushButton("Clear",this);
    connect(clearPB,SIGNAL(clicked()),this,SLOT(clearSelectedSlot()));
    clearAllPB  = new QPushButton("Clear All",this);
    connect(clearAllPB,SIGNAL(clicked()),this,SLOT(clearAllSlot()));
    defaultPB = new QPushButton("Default",this);
    connect(defaultPB,SIGNAL(clicked()),this,SLOT(defaultSlot()));
    defaultPB->setToolTip("Add Default Fields");
    QWidget *selectButonArea = new QWidget(this);
    QHBoxLayout *selectBBox = new QHBoxLayout(selectButonArea);
    selectBBox->setMargin(0);
    selectButonArea->setLayout(selectBBox);
    selectBBox->addWidget(clearPB,0,Qt::AlignLeft);
    selectBBox->addWidget(clearAllPB,0,Qt::AlignLeft);
    selectBBox->addStretch(1);
    selectBBox->addWidget(defaultPB,0);
    selectBox->addWidget(selectedFieldsTreeView,1);
    selectBox->addWidget(selectButonArea,0);

    mwaGrid->addWidget(messageListL,0,0,Qt::AlignHCenter|Qt::AlignBottom);
    mwaGrid->addWidget(availableListL,0,1,Qt::AlignHCenter|Qt::AlignBottom);
    mwaGrid->addWidget(messageArea,1,0);
    mwaGrid->addWidget(availableArea,1,1);
    mwaGrid->setRowStretch(0,0);
    mwaGrid->setRowStretch(1,1);
    mwaGrid->setColumnStretch(0,1);
    mwaGrid->setColumnStretch(1,1);

    workAreaStack->insertWidget(MessageView, messageWorkArea);

    fieldsWorkArea = new QWidget(this);
    QVBoxLayout *fwaBox = new QVBoxLayout();
    fwaBox->setMargin(0);
    fieldsWorkArea->setLayout(fwaBox);

    fieldListL  = new QLabel("Available Fields");
    fieldListL->setAlignment(Qt::AlignHCenter);
    fnt = fieldListL->font();
    fnt.setBold(true);
    fieldListL->setFont(fnt);
    fieldListL->setToolTip("All possible FIX Fields");
    fieldListView = new QListView(this);
    QString ss;
    ss.append("QListView::item:hover { color: #ffffff; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,stop: 0 #1a3994, stop: 1 #061a33);}");
    fieldListView->setStyleSheet(ss);
    fnt = fieldListView->font();
    fnt.setBold(true);
    fnt.setPointSize(fnt.pointSize()+1);
    fieldListView->setFont(fnt);
    fieldListView->setWrapping(true);
    fieldsModel = new QStandardItemModel(fieldListView);
    fieldListView->setModel(fieldsModel);
    fieldListView->setFlow(QListView::LeftToRight);
    fieldListView->setGridSize(QSize(180,36));
    fieldListView->setResizeMode(QListView::Adjust);
    QItemSelectionModel *selectionModel =fieldListView->selectionModel();
    connect(fieldsModel,SIGNAL(itemChanged(QStandardItem*)),
            this,SLOT(fieldCheckedSlot(QStandardItem *)));
    fwaBox->addWidget(fieldListL,0,Qt::AlignCenter);
    fwaBox->addWidget(fieldListView,1);

    workAreaStack->insertWidget(MessageView, messageWorkArea);
    workAreaStack->insertWidget(FieldView, fieldsWorkArea);
    wgrid->addWidget(workAreaStack,0,0,2,2);
    wgrid->addWidget(selectedListL,0,2,Qt::AlignHCenter|Qt::AlignBottom);
    wgrid->addWidget(selectArea,1,2);

    wgrid->setMargin(3);
    wgrid->setSpacing(4);
    wgrid->setRowStretch(0,0);
    wgrid->setRowStretch(1,1);
    wgrid->setColumnStretch(0,0);
    wgrid->setColumnStretch(1,2);
    wgrid->setColumnStretch(2,1);

    messageL = new QLabel(this);
    messageL->setAlignment(Qt::AlignCenter);
    fnt = messageL->font();
    fnt.setPointSize(fnt.pointSize()+2);
    fnt.setBold(true);
    messageL->setFont(fnt);
    QPalette pal = messageL->palette();
    regMesssgeColor = pal.color(QPalette::WindowText);
    errorMessageColor = Qt::red;
    vbox->addLayout(topBox,0);
    vbox->addSpacing(10);
    vbox->addWidget(splitter,1);
    vbox->addSpacing(12);
    vbox->addWidget(messageL,0);
}
Example #20
0
QRect ctkDicomHostInterfaceImpl::getAvailableScreen(const QRect& preferredScreen)
{
  http.setAction("GetAvailableScreen");

  QtSoapMessage request;
  request.setMethod("GetAvailableScreen");

  QtSoapStruct* preferredScreenType = new QtSoapStruct(QtSoapQName("preferredScreen"));
  preferredScreenType->insert(new QtSoapSimpleType(QtSoapQName("Height"), preferredScreen.height()));
  preferredScreenType->insert(new QtSoapSimpleType(QtSoapQName("Width"), preferredScreen.width()));
  preferredScreenType->insert(new QtSoapSimpleType(QtSoapQName("RefPointX"), preferredScreen.x()));
  preferredScreenType->insert(new QtSoapSimpleType(QtSoapQName("RefPointY"), preferredScreen.y()));

  request.addMethodArgument(preferredScreenType);

  http.submitRequest(request, "/IHostService");

  qDebug() << "Submitted request GetAvailableScreen";

  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

  blockingLoop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);

  QApplication::restoreOverrideCursor();

  //qDebug() << "Reply error: " << reply->errorString();
  //qDebug() << reply->readAll();
  const QtSoapMessage& response = http.getResponse();

  if (response.isFault())
  {
    throw std::runtime_error("server error");
  }

  qDebug() << "Response: " << response.toXmlString();

  const QtSoapType &meth = response.method();

  if (!meth.isValid() || meth.type() != QtSoapType::Struct)
    qDebug() << "SOAP returning NIL: invalid or type != Struct";

  const QtSoapStruct &m = dynamic_cast<const QtSoapStruct &>(meth);
  if (m.count() == 0)
    qDebug() << "SOAP returning NIL: count == 0";


  const QtSoapType& screenResult = response.returnValue();
  if (!screenResult.isValid())
  {
    //throw std::runtime_error("invalid return value");
    qDebug() << response.errorString() << response.faultString().toString();
    qDebug() << response.toXmlString();
    return QRect();
  }

  qDebug() << screenResult.count() << screenResult["Height"].typeName();
  QRect resultRect;
  resultRect.setHeight(screenResult["Height"].toInt());
  resultRect.setWidth(screenResult["Width"].toInt());
  resultRect.setX(screenResult["RefPointX"].toInt());
  resultRect.setY(screenResult["RefPointY"].toInt());

  qDebug() << "x:" << resultRect.x() << " y:" << resultRect.y();

  return resultRect;
}
Example #21
0
void
GridItemDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
{
    PlayableItem* item = m_model->sourceModel()->itemFromIndex( m_model->mapToSource( index ) );
    if ( !item || !index.isValid() )
        return;

    QStyleOptionViewItemV4 opt = option;
    initStyleOption( &opt, QModelIndex() );
//    qApp->style()->drawControl( QStyle::CE_ItemViewItem, &opt, painter );

    QRect r = option.rect;
    r.setHeight( r.width() );

    QString top, bottom;
    if ( !item->album().isNull() )
    {
        top = item->album()->name();

        if ( !item->album()->artist().isNull() )
            bottom = item->album()->artist()->name();
    }
    else if ( !item->artist().isNull() )
    {
        top = item->artist()->name();
    }
    else if ( !item->query().isNull() )
    {
        top = item->query()->track()->track();
        bottom = item->query()->track()->artist();
    }
    else
    {
        return;
    }

    painter->save();
    painter->setRenderHint( QPainter::TextAntialiasing );

    if ( !m_covers.contains( index ) )
    {
        if ( !item->album().isNull() )
        {
            m_covers.insert( index, QSharedPointer< Tomahawk::PixmapDelegateFader >( new Tomahawk::PixmapDelegateFader( item->album(), r.size(), TomahawkUtils::Original, false ) ) );
        }
        else if ( !item->artist().isNull() )
        {
            m_covers.insert( index, QSharedPointer< Tomahawk::PixmapDelegateFader >( new Tomahawk::PixmapDelegateFader( item->artist(), r.size(), TomahawkUtils::Original, false ) ) );
        }
        else
        {
            m_covers.insert( index, QSharedPointer< Tomahawk::PixmapDelegateFader >( new Tomahawk::PixmapDelegateFader( item->query(), r.size(), TomahawkUtils::Original, false ) ) );
        }

        NewClosure( m_covers[ index ], SIGNAL( repaintRequest() ),
                    const_cast<GridItemDelegate*>(this), SLOT( doUpdateIndex( QPersistentModelIndex ) ), QPersistentModelIndex( index ) )->setAutoDelete( false );
    }

    QSharedPointer< Tomahawk::PixmapDelegateFader > fader = m_covers[ index ];
    if ( fader->size() != r.size() )
        fader->setSize( r.size() );
    const QPixmap cover = fader->currentPixmap();

    qreal opacity = -1.0;
    qreal pct = -1.0;
    if ( m_hoverFaders.contains( index ) )
    {
        pct = ( m_hoverFaders[ index ]->currentFrame() / 100.0 );
        opacity = 1.0 - pct * 0.70;
    }
    else if ( m_hoverIndex == index )
    {
        opacity = 0.3;
        pct = 1.0;
    }
    if ( opacity > -1.0 )
    {
        painter->save();

        const int cropIn = pct * ( (qreal)cover.width() * 0.10 );
        const QRect crop = cover.rect().adjusted( cropIn, cropIn, -cropIn, -cropIn );

        painter->drawPixmap( r, cover.copy( crop ).scaled( r.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation ) );

        painter->setOpacity( 1.0 - opacity );
        painter->setPen( Qt::transparent );
        painter->setBrush( Qt::black );
        painter->drawRect( r );

        painter->restore();
    }
    else
    {
        painter->drawPixmap( r, cover );
    }

    QTextOption to;
    to.setWrapMode( QTextOption::NoWrap );

    QString text;
    QRect textRect = option.rect.adjusted( 0, r.height() + m_margin / 4, 0, -m_margin / 2 + m_margin / 8 );
    bool oneLiner = false;
    if ( bottom.isEmpty() )
        oneLiner = true;

    painter->setPen( TomahawkStyle::SELECTION_FOREGROUND );
    painter->setFont( m_font );
    painter->setPen( Qt::black );
    painter->setOpacity( 0.8 );

    if ( m_showPosition )
    {
        painter->save();

        if ( !oneLiner )
        {
            QFont figFont = m_font;
            figFont.setPixelSize( textRect.height() - m_margin / 8 );
            painter->setFont( figFont );
        }

        const QString fig = QString::number( index.row() + 1 );
        painter->drawText( textRect, fig, QTextOption( Qt::AlignLeft | Qt::AlignVCenter ) );

        textRect.adjust( painter->fontMetrics().boundingRect( textRect, Qt::AlignLeft | Qt::AlignVCenter, fig ).width() + m_margin / 4, 0, 0, 0 );
        painter->restore();
    }

    if ( oneLiner )
    {
        // If the user is hovering over an artist rect, draw a background so they knows it's clickable
        if ( m_hoveringOverArtist == index )
        {
            QFont f = painter->font();
            f.setUnderline( true );
            painter->setFont( f );
        }

        to.setAlignment( Qt::AlignLeft | Qt::AlignTop );
        text = painter->fontMetrics().elidedText( top, Qt::ElideRight, textRect.width() - m_margin / 4 );
        painter->drawText( textRect, text, to );

        // Calculate rect of artist on-hover button click area
        m_artistNameRects[ index ] = painter->fontMetrics().boundingRect( textRect, Qt::AlignLeft | Qt::AlignTop, text );
    }
    else
    {
        painter->save();
        // If the user is hovering over an album rect, underline the album name
        if ( m_hoveringOverAlbum == index )
        {
            QFont f = painter->font();
            f.setUnderline( true );
            painter->setFont( f );
        }

        if ( m_showBuyButtons && !item->query().isNull() )
        {
            textRect.adjust( 0, 0, 0, -40 );
        }

        to.setAlignment( Qt::AlignLeft | Qt::AlignTop );
        text = painter->fontMetrics().elidedText( top, Qt::ElideRight, textRect.width() - m_margin / 4 );
        painter->drawText( textRect, text, to );

        if ( item->album() )
        {
            // Calculate rect of album on-hover button click area
            m_albumNameRects[ index ] = painter->fontMetrics().boundingRect( textRect, Qt::AlignLeft | Qt::AlignTop, text );
        }
        painter->restore();

        painter->save();
        painter->setOpacity( 0.6 );
        painter->setFont( m_smallFont );

        // If the user is hovering over an artist rect, underline the artist name
        if ( m_hoveringOverArtist == index )
        {
            QFont f = painter->font();
            f.setUnderline( true );
            painter->setFont( f );
        }

        textRect.adjust( 0, painter->fontMetrics().height() + m_margin / 16, 0, 0 );
        to.setAlignment( Qt::AlignLeft | Qt::AlignBottom );
        text = painter->fontMetrics().elidedText( bottom, Qt::ElideRight, textRect.width() - m_margin / 4 );
        painter->drawText( textRect, text, to );

        // Calculate rect of artist on-hover button click area
        m_artistNameRects[ index ] = painter->fontMetrics().boundingRect( textRect, Qt::AlignLeft | Qt::AlignBottom, text );
        painter->restore();

        if ( m_showBuyButtons && !item->query().isNull() )
        {
            QRect r = textRect;
            r.setY( textRect.y() + textRect.height() + 8 );
            r.setHeight( 32 );
            m_buyButtonRects[ index ] = r;

            QString text;
            bool itemsAvailable = false;
            if ( item->result() &&
               ( ( !item->result()->downloadFormats().isEmpty() && !DownloadManager::instance()->localFileForDownload( item->result()->downloadFormats().first().url.toString() ).isEmpty() ) ||
                 ( item->result()->downloadJob() && item->result()->downloadJob()->state() == DownloadJob::Finished ) ) )
            {
                text = tr( "View in Finder" );
            }
            else if ( item->query() && item->query()->numResults( true ) && !item->query()->results().first()->downloadFormats().isEmpty() )
            {
                text = tr( "Download %1" ).arg( item->query()->results().first()->downloadFormats().first().extension.toUpper() );
                itemsAvailable = true;
            }
            else if ( item->query()->numResults( true ) && !item->query()->results().first()->purchaseUrl().isEmpty() )
            {
                text = tr( "Buy" );
            }

            if ( !item->result() || !item->result()->downloadJob() || item->result()->downloadJob()->state() == DownloadJob::Finished )
            {
                if ( !text.isEmpty() )
                    DropDownButton::drawPrimitive( painter, r, text, m_hoveringOverBuyButton == index, itemsAvailable );
                else
                    m_buyButtonRects.remove( index );
            }
            else
            {
                painter->setPen( TomahawkStyle::PLAYLIST_PROGRESS_FOREGROUND.darker() );
                painter->setBrush( TomahawkStyle::PLAYLIST_PROGRESS_BACKGROUND );
                painter->drawRect( r.adjusted( 2, 2, -2, -2 ) );
                painter->setPen( TomahawkStyle::PLAYLIST_PROGRESS_FOREGROUND );
                painter->setBrush( TomahawkStyle::PLAYLIST_PROGRESS_FOREGROUND );
                QRect fillp = r.adjusted( 3, 3, -3, -3 );
                fillp.setWidth( float(fillp.width()) * ( float(item->result()->downloadJob()->progressPercentage()) / 100.0 ) );
                painter->drawRect( fillp );
            }
        }
    }

    painter->restore();
}
Example #22
0
void
QueryLabel::mouseMoveEvent( QMouseEvent* event )
{
    QFrame::mouseMoveEvent( event );
    int x = event->x();

    if ( event->buttons() & Qt::LeftButton &&
       ( m_dragPos - event->pos() ).manhattanLength() >= QApplication::startDragDistance() )
    {
        startDrag();
        leaveEvent( 0 );
        return;
    }

    if ( m_query.isNull() && m_result.isNull() )
    {
        m_hoverArea = QRect();
        m_hoverType = None;
        return;
    }

    QFontMetrics fm = fontMetrics();
    if ( m_useCustomFont )
        fm = QFontMetrics( m_font );

    int dashX = fm.width( DASH );
    int artistX = m_type & Artist ? fm.width( artist() ) : 0;
    int albumX = m_type & Album ? fm.width( album() ) : 0;
    int trackX = m_type & Track ? fm.width( track() ) : 0;

    if ( m_type & Track )
    {
        trackX += contentsMargins().left();
    }
    if ( m_type & Album )
    {
        trackX += albumX + dashX;
        albumX += contentsMargins().left();
    }
    if ( m_type & Artist )
    {
        albumX += artistX + dashX;
        trackX += artistX + dashX;
        artistX += contentsMargins().left();
    }

    QRect hoverArea;
    m_hoverType = None;

    if ( m_align & Qt::AlignLeft )
    {
        if ( m_type & Artist && x < artistX )
        {
            m_hoverType = Artist;
            hoverArea.setLeft( 0 );
            hoverArea.setRight( artistX + contentsMargins().left() - 1 );
        }
        else if ( m_type & Album && x < albumX && x > artistX )
        {
            m_hoverType = Album;
            int spacing = ( m_type & Artist ) ? dashX : 0;
            hoverArea.setLeft( artistX + spacing );
            hoverArea.setRight( albumX + spacing + contentsMargins().left() - 1 );
        }
        else if ( m_type & Track && x < trackX && x > albumX )
        {
            m_hoverType = Track;
            int spacing = ( m_type & Album ) ? dashX : 0;
            hoverArea.setLeft( albumX + spacing );
            hoverArea.setRight( trackX + contentsMargins().left() - 1 );
        }
        else if ( m_jumpLinkVisible && x < trackX + 6 + m_jumpPixmap.width() && x > trackX + 6 )
        {
            m_hoverType = Complete;
        }
    }
    else
    {
        hoverArea.setLeft( 0 );
        hoverArea.setRight( width() - 1 );
        
        if ( m_type & Artist )
            m_hoverType = Artist;
        else if ( m_type & Album )
            m_hoverType = Album;
        else if ( m_type & Track )
            m_hoverType = Track;
    }

    if ( hoverArea.width() )
    {
        hoverArea.setY( 1 );
        hoverArea.setHeight( height() - 2 );
    }
    
    if ( m_hoverType != None )
        setCursor( Qt::PointingHandCursor );
    else
        setCursor( Qt::ArrowCursor );

    if ( hoverArea != m_hoverArea )
    {
        m_hoverArea = hoverArea;
        repaint();
    }
}
Example #23
0
void SegmentPencil::mousePressEvent(QMouseEvent *e)
{
    // Let the baseclass have a go.
    SegmentTool::mousePressEvent(e);

    // We only care about the left and middle mouse buttons.
    // SegmentSelector might send us a middle press.
    if (e->button() != Qt::LeftButton  &&
        e->button() != Qt::MidButton)
        return;

    // No need to propagate.
    e->accept();

    // is user holding Ctrl+Alt? (ugly, but we are running short on available
    // modifiers; Alt is grabbed by the window manager, and right clicking, my
    // (dmm) original idea, is grabbed by the context menu, so let's see how
    // this goes over
    // ??? Why not just set this to true?  The use case is starting a
    //     pencil click/drag on top of an existing segment.  If the
    //     user wants to draw a segment on top of a segment, just let
    //     them.  Maybe this was an issue when segments could overlap?
    bool pencilAnyway = ((e->modifiers() & Qt::AltModifier) != 0  &&
                         (e->modifiers() & Qt::ControlModifier) != 0);

    m_newRect = false;

    QPoint pos = m_canvas->viewportToContents(e->pos());

    // Check if mouse click was on a rect
    //
    ChangingSegmentPtr item = m_canvas->getModel()->getSegmentAt(pos);

    // If user clicked a rect, and pencilAnyway is false, then there's nothing
    // left to do here
    if (item) {
        if (!pencilAnyway) return ;
    }

    // make new item

    SnapGrid &snapGrid = m_canvas->grid();
    
    setSnapTime(e, SnapGrid::SnapToBar);

    int trackPosition = snapGrid.getYBin(pos.y());

    // Don't do anything if the user clicked beyond the track buttons
    //
    if (trackPosition >= (int)m_doc->getComposition().getNbTracks())
        return ;

    Track *t = m_doc->getComposition().getTrackByPosition(trackPosition);
    if (!t)
        return ;

    TrackId trackId = t->getId();

    // Save the mouse X as the original Press point
    m_pressX = pos.x();

    m_startTime = snapGrid.snapX(m_pressX, SnapGrid::SnapLeft);
    m_endTime = snapGrid.snapX(m_pressX, SnapGrid::SnapRight);

    // Don't allow a length smaller than the smallest note
    if (m_endTime - m_startTime < Note(Note::Shortest).getDuration())
        m_endTime = m_startTime + Note(Note::Shortest).getDuration();

    int multiple = 
        m_doc->getComposition().getMaxContemporaneousSegmentsOnTrack(trackId);
    if (multiple < 1)
        multiple = 1;

    QRect tmpRect;
    tmpRect.setLeft(lround(snapGrid.getRulerScale()->
                               getXForTime(m_startTime)));
    tmpRect.setRight(lround(snapGrid.getRulerScale()->
                                getXForTime(m_endTime)));
    tmpRect.setY(snapGrid.getYBinCoordinate(trackPosition) + 1);
    tmpRect.setHeight(snapGrid.getYSnap() * multiple - 2);

    m_canvas->setNewSegmentColor(GUIPalette::convertColour(
            m_doc->getComposition().getSegmentColourMap().
            getColourByIndex(t->getColor())));
    m_canvas->drawNewSegment(tmpRect);

    m_newRect = true;

	m_canvas->update(tmpRect);
}
Example #24
0
void
QueryLabel::mouseMoveEvent( QMouseEvent* event )
{
    QFrame::mouseMoveEvent( event );
    int x = event->x();

    if ( event->buttons() & Qt::LeftButton &&
       ( m_dragPos - event->pos() ).manhattanLength() >= QApplication::startDragDistance() )
    {
        startDrag();
        leaveEvent( 0 );
        return;
    }

    if ( m_query.isNull() && m_result.isNull() )
    {
        m_hoverArea = QRect();
        m_hoverType = None;
        return;
    }

    const QFontMetrics& fm = fontMetrics();
    int dashX = fm.width( DASH );
    int artistX = m_type & Artist ? fm.width( artist() ) : 0;
    int albumX = m_type & Album ? fm.width( album() ) : 0;
    int trackX = m_type & Track ? fm.width( track() ) : 0;

    if ( m_type & Track )
    {
        trackX += contentsMargins().left();
    }
    if ( m_type & Album )
    {
        trackX += albumX + dashX;
        albumX += contentsMargins().left();
    }
    if ( m_type & Artist )
    {
        albumX += artistX + dashX;
        trackX += artistX + dashX;
        artistX += contentsMargins().left();
    }

    QRect hoverArea;
    m_hoverType = None;
    if ( m_type & Artist && x < artistX )
    {
        m_hoverType = Artist;
        hoverArea.setLeft( 0 );
        hoverArea.setRight( artistX + contentsMargins().left() - 1 );
    }
    else if ( m_type & Album && x < albumX && x > artistX )
    {
        m_hoverType = Album;
        int spacing = ( m_type & Artist ) ? dashX : 0;
        hoverArea.setLeft( artistX + spacing );
        hoverArea.setRight( albumX + spacing + contentsMargins().left() - 1 );
    }
    else if ( m_type & Track && x < trackX && x > albumX )
    {
        m_hoverType = Track;
        int spacing = ( m_type & Album ) ? dashX : 0;
        hoverArea.setLeft( albumX + spacing );
        hoverArea.setRight( trackX + contentsMargins().left() - 1 );
    }

    if ( hoverArea.width() )
    {
        hoverArea.setY( 1 );
        hoverArea.setHeight( height() - 2 );
    }
    if ( hoverArea != m_hoverArea )
    {
        m_hoverArea = hoverArea;
        repaint();
    }
}
Example #25
0
void Executor::timerEvent(QTimerEvent *)
{
   TimerKiller killer(this, timer_id_, interval_);
   //ищем топовое окно заданного класса
   static const QString psClass = "TfrmTable";
   static const int minFoldHue = 15;
   static const int maxFoldHue = 30;
   static const int minCallHue = 60;
   static const int maxCallHue = 70;
   static const int minCheckHue = 42;
   static const int maxCheckHue = 58;

   //смотрим топовое окно
   WId FgWnd = GetForegroundWindow();
   char clName[MAX_WND_TEXT];
   GetClassNameA(FgWnd, clName, MAX_WND_TEXT);
   QString sClass(clName);
   if (!sClass.contains(psClass))
   {
      return;
   }

   //область кнопок
   QRect checkRect;
   QRect foldRect;
   bool hasCheck = false;
   bool hasFold  = false;
   bool hasCall  = false;

   int btnHeight = 110;
   int btnWidth = 0;
   WId BtnWnd = FindWindowEx(FgWnd, NULL, L"TAniLayer", NULL); 
   if (BtnWnd)
   {
      RECT btnRect;
      //GetClientRect(BtnWnd, &btnRect);
      GetWindowRect(BtnWnd, &btnRect);
      btnHeight = btnRect.bottom - btnRect.top;
      btnWidth = btnRect.right - btnRect.left;
      btnWidth = btnWidth >> 1;
      HwndToTop(FgWnd);

      //делаем скрин области кнопок
      QPixmap pixBtn = QPixmap::grabWindow(BtnWnd, btnWidth, 0, btnWidth, btnHeight);
      QImage imgBtn  = pixBtn.toImage();
      //imgBtn.save("btn.bmp");
      
      QPoint ptFold, ptCall, ptCheck;
      //здесь нужна обработка нашего хода
      static const int rectMin = 10;
      //Начинаем поиск с кнопки Чек
      //если она есть то однозначно наш ход
      hasCheck = Proc770::checkHueButton(imgBtn, minCheckHue, maxCheckHue, 
         rectMin, checkRect);
      if (!hasCheck)
      {
         //ищем кнопку Fold и Call
         hasFold = Proc770::checkHueButton(imgBtn, minFoldHue, maxFoldHue, 
            rectMin, foldRect);
         hasCall = Proc770::checkHueButton(imgBtn, minCallHue, maxCallHue, rectMin);

         if (hasFold && hasCall)
         {
            //qDebug() << "FOLD is avail";
         }
         else
         {
            return;
         }
      }
      else
      {
         //qDebug() << "CHECK is avail";
      }
   }

   //здесь наш ход
   QPixmap pixRoom = QPixmap::grabWindow(FgWnd);
   QRect rectRoom = pixRoom.rect();
   rectRoom.setHeight(rectRoom.height() - btnHeight);
   QImage imgRoom = pixRoom.copy(rectRoom).toImage();
   
   // устанавливаем изображение для обработки
   cardProc_->setImage(imgRoom);
   // если стадия префлопа 
   if (cardProc_->isPreflop())
   {
      //qDebug() << "Preflop!";
      // получить карманные карты
      bool ok = false;
      QPair<QRect, QRect> holeCards = cardProc_->getHoleCards(&ok);
      if (!ok)
         return;

      /// Debugging {
      //uint num = 0;
      //num = QDateTime::currentDateTime().toTime_t();
      //imgRoom.save(QString("test/table_%1.bmp").arg(num));
      //imgBtn.save(QString("test/btns_%1.bmp").arg(num));
      //imgRoom.copy(holeCards.first).save(QString("test/first_%1.bmp").arg(num));
      //imgRoom.copy(holeCards.second).save(QString("test/second_%1.bmp").arg(num));
      /// } Debugging

      if (holeCards.first.isEmpty() || holeCards.second.isEmpty() ||
          holeCards.first.isNull() || holeCards.second.isNull())
          return;

      QImage firstImg  = imgRoom.copy(holeCards.first);
      QImage secondImg = imgRoom.copy(holeCards.second);

      QString card1 = cardFromImage(firstImg);
      QString card2 = cardFromImage(secondImg);

      if (card1.length() != 2 || card2.length() != 2)
         return;

      //qDebug() << card1 << card2;
      
      //сохранить карты в кэш
      QString joined = card1 + card2;
      if (joined == cache_ && !lastIsFold_)
      {
         //хорошие карты - человек думает, не мешать
         return;
      } 
      else
      {
         cache_ = joined;
      }
      
      QString range = cardRangeFromHoles(card1, card2);
      //qDebug() << range;
      if (playingCard_.contains(range))
      {
         //panic!
         lastIsFold_ = false;
         if (data_.visualAlert)
         {
            alarm_->highlight(joined, FgWnd);
         }
         if (data_.turnBeep)
         {
            QString appExe = qApp->applicationDirPath();
            QSound::play(appExe + "/sounds/turn.wav");
         }
      }
      else
      {
         if (data_.advisorMode)
         {
            QString advice = tr("Fold/Check this hand: %1")
               .arg(card1 + " " + card2);
            cbFun(advice.toStdString().c_str());
            return;
         }
         
         //foldOrCheck(FgWnd);
         //qDebug() << "Check Rect" << checkRect;
         int w = checkRect.width();
         int h = checkRect.height();
         checkRect.setX(btnWidth + checkRect.x());
         checkRect.setY(imgRoom.height() + checkRect.y());
         checkRect.setWidth(w);
         checkRect.setHeight(h);
         //qDebug() << "New Check Rect" << checkRect;

         //qDebug() << "Fold Rect" << foldRect;
         w = foldRect.width();
         h = foldRect.height();
         foldRect.setX(btnWidth + foldRect.x());
         foldRect.setY(imgRoom.height() + foldRect.y());
         foldRect.setWidth(w);
         foldRect.setHeight(h);
         //qDebug() << "New Fold Rect" << foldRect;
         if (hasCheck)
         {
            if (data_.checkBeep)
            {
               QString appExe = qApp->applicationDirPath();
               QSound::play(appExe + "/sounds/check.wav");
            }
            
            clickTo(FgWnd, checkRect);
            
            if (data_.showFolded)
            {
               QString sAction = tr("This hand has been checked: ");
               cbFun(QString(sAction + card1 + " " + card2).toStdString().c_str());
            }

            //обнулить кэш
            cache_.clear();
            lastIsFold_ = false;
         }
         else if (hasFold)
         {
            lastIsFold_ = true;
            if (data_.foldBeep)
            {
               QString appExe = qApp->applicationDirPath();
               QSound::play(appExe + "/sounds/fold.wav");
            }

            clickTo(FgWnd, foldRect);
            
            if (data_.showFolded)
            {
               QString sAction = tr("This hand has been folded: ");
               cbFun(QString(sAction + card1 + " " + card2).toStdString().c_str());
            }
         }
      }
   }
//код для набивки базы карт
/*
   qDebug() << "Check Rect" << checkRect;
   int w = checkRect.width();
   int h = checkRect.height();
   checkRect.setX(btnWidth + checkRect.x());
   checkRect.setY(imgRoom.height() + checkRect.y());
   checkRect.setWidth(w);
   checkRect.setHeight(h);
   qDebug() << "New Check Rect" << checkRect;

   qDebug() << "Fold Rect" << foldRect;
   w = foldRect.width();
   h = foldRect.height();
   foldRect.setX(btnWidth + foldRect.x());
   foldRect.setY(imgRoom.height() + foldRect.y());
   foldRect.setWidth(w);
   foldRect.setHeight(h);
   qDebug() << "New Fold Rect" << foldRect;

   if (cardProc_->isPreflop())
   {
      if (hasCheck)
      {
         clickTo(FgWnd, checkRect);
      }
      else if (hasFold && hasCall)
      {
         clickTo(FgWnd, foldRect);
      }
   }
   else
   {
      clickTo(FgWnd, foldRect);
      clickTo(FgWnd, checkRect);

      qDebug() << "Flop at least!";
      return;
   }
*/
}
Example #26
0
void Image3DOverlay::render(RenderArgs* args) {
    if (!_renderVisible || !getParentVisible() || !_texture || !_texture->isLoaded()) {
        return;
    }

    // Once the texture has loaded, check if we need to update the render item because of transparency
    if (!_textureIsLoaded && _texture && _texture->getGPUTexture()) {
        _textureIsLoaded = true;
        bool prevAlphaTexture = _alphaTexture;
        _alphaTexture = _texture->getGPUTexture()->getUsage().isAlpha();
        if (_alphaTexture != prevAlphaTexture) {
            auto itemID = getRenderItemID();
            if (render::Item::isValidID(itemID)) {
                render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
                render::Transaction transaction;
                transaction.updateItem(itemID);
                scene->enqueueTransaction(transaction);
            }
        }
    }

    Q_ASSERT(args->_batch);
    gpu::Batch* batch = args->_batch;

    float imageWidth = _texture->getWidth();
    float imageHeight = _texture->getHeight();

    QRect fromImage;
    if (_fromImage.isNull()) {
        fromImage.setX(0);
        fromImage.setY(0);
        fromImage.setWidth(imageWidth);
        fromImage.setHeight(imageHeight);
    } else {
        float scaleX = imageWidth / _texture->getOriginalWidth();
        float scaleY = imageHeight / _texture->getOriginalHeight();

        fromImage.setX(scaleX * _fromImage.x());
        fromImage.setY(scaleY * _fromImage.y());
        fromImage.setWidth(scaleX * _fromImage.width());
        fromImage.setHeight(scaleY * _fromImage.height());
    }

    float maxSize = glm::max(fromImage.width(), fromImage.height());
    float x = _keepAspectRatio ? fromImage.width() / (2.0f * maxSize) : 0.5f;
    float y = _keepAspectRatio ? -fromImage.height() / (2.0f * maxSize) : -0.5f;

    glm::vec2 topLeft(-x, -y);
    glm::vec2 bottomRight(x, y);
    glm::vec2 texCoordTopLeft((fromImage.x() + 0.5f) / imageWidth, (fromImage.y() + 0.5f) / imageHeight);
    glm::vec2 texCoordBottomRight((fromImage.x() + fromImage.width() - 0.5f) / imageWidth,
                                  (fromImage.y() + fromImage.height() - 0.5f) / imageHeight);

    float alpha = getAlpha();
    glm::u8vec3 color = getColor();
    glm::vec4 imageColor(toGlm(color), alpha);

    batch->setModelTransform(getRenderTransform());
    batch->setResourceTexture(0, _texture->getGPUTexture());

    DependencyManager::get<GeometryCache>()->renderQuad(
        *batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
        imageColor, _geometryId
    );

    batch->setResourceTexture(0, nullptr); // restore default white color after me
}
Example #27
0
void p_wid::paintEvent(QPaintEvent *event)
{
//    Struct_poz s = this->getSelectionBoundings();


    QPainter pain( this );

    //drawing the bg-MUSTER
    for ( unsigned int i = 0; i < this->current_tilesets_height; i ++)
        pain.drawPixmap( 0, 32*i, 256, 32, QPixmap( ":/resources/img/p_wid_background_rib.png" ) );

    QPixmap tmp_pixmap = this->tilesets.at( this->current_tileset );
    pain.drawPixmap(0, 0, 256, tmp_pixmap.height(), tmp_pixmap );

    //*** now the advanced stuff

    //drawing the grid

    QImage template1 = QImage( 32,32, QImage::Format_ARGB32 );
    template1.fill( 0 );
    QPainter tP( &template1 );
    tP.setPen( QColor( 100, 100, 100, 100 ) );
    tP.drawLine( 0,0,  31,0 );
    tP.drawLine( 0,0,  0,31 );
    tP.drawLine( 0,31, 31,31 );
    tP.drawLine( 31,0, 31,31 );
    if ( this->right_click_menu->actions()[ 0 ]->isChecked() )
    {
        for ( int hz = 0; hz < this->tilesets[ this->current_tileset ].height(); hz += 32 )
        {
            for ( int w = 0; w < 8; w++ )
            {
                pain.drawImage( QPoint(w*32, hz), template1);
            }
        }
    }
    //drawing the dim

    //framing the selection
    Struct_poz rec;
    rec.first_tile  = 0;
    rec = this->getSelectionBoundings();

    // mid white rect
    QRect frame;
    frame.setY( (       rec.first_tile / 8 ) * 32 );
    frame.setX( (       rec.first_tile % 8 ) * 32 );
    frame.setWidth(     rec.width * 32 );
    frame.setHeight(    rec.height * 32 );
    pain.setPen( Qt::white );
    pain.drawRect( frame );

    // outa black frame
    frame.setY( (       rec.first_tile / 8 ) * 32   -1);
    frame.setX( (       rec.first_tile % 8 ) * 32   -1);
    frame.setWidth(     rec.width * 32   +2);
    frame.setHeight(    rec.height * 32  +2);
    pain.setPen( Qt::black );
    pain.drawRect( frame );

    //inna black frame
    frame.setY( (       rec.first_tile / 8 ) * 32   +1);
    frame.setX( (       rec.first_tile % 8 ) * 32   +1);
    frame.setWidth(     rec.width * 32    -2);
    frame.setHeight(    rec.height * 32   -2);
    pain.setPen( Qt::black );
    pain.drawRect( frame );


    pain.end();
    event->accept();
}
void QColorTabWidget::drawTabs( QPainter& p, QRect rc )
{
#define TAB_INTERVAL	(3)
#define TAB_MARGIN		(10)
    QRect rectTab;

    switch (m_eTabDirection)
    {
    case TabDirectionHorzLeftTop:
        rectTab.setY(rc.top());
        rectTab.setX(rc.left() + m_nBarOffset);
        break;
    case TabDirectionHorzRightTop:
        rectTab.setY(rc.top());
        rectTab.setX(rc.right() - m_nBarOffset + TAB_INTERVAL);
        break;
    case TabDirectionVertLeftTop:
        rectTab.setX(rc.left());
        rectTab.setY(rc.top() + m_nBarOffset);
        break;
    case TabDirectionVertLeftBottom:
        rectTab.setX(rc.left());
        rectTab.setY(rc.bottom() - m_nBarOffset + TAB_INTERVAL);
        break;
    }

    QSize szTab = calcTabSize( p, m_aryTabInfo.at(0) );
    if (isHorzTab())
    {
        m_sizeTabHeader.setWidth(szTab.width());
        rectTab.setHeight(m_sizeTabHeader.height());
    }
    else
    {
        m_sizeTabHeader.setHeight(szTab.height());
        rectTab.setWidth(m_sizeTabHeader.width());
    }

    int nMaxTabBarSize = rc.width() - m_nBarOffset * 2;
    nMaxTabBarSize -= m_pExtraWidget != NULL ? (isHorzTab() ? m_pExtraWidget->width() : m_pExtraWidget->height()) + TAB_MARGIN*2 : 0;
    int nTabBarSize = 0;

    m_nVisibleCount = 0;
    for (int nI = m_nMoveCount; nI < m_aryTabInfo.size() ; nI ++)
    {
        TabInfo& ti = m_aryTabInfo[nI];
        szTab = calcTabSize( p, ti );

        if (m_eTabDirection == TabDirectionHorzRightTop)
        {
            rectTab.setX( rectTab.x() - (szTab.width() + TAB_INTERVAL + TAB_MARGIN) );
        }
        else if (m_eTabDirection == TabDirectionVertLeftBottom)
        {
            rectTab.setY( rectTab.y() - (szTab.height() + TAB_INTERVAL + TAB_MARGIN) );
        }

        if (isHorzTab())
        {
            rectTab.setWidth(szTab.width() + TAB_MARGIN);   // margin x: 5px
            nTabBarSize += rectTab.width();
        }
        else
        {
            rectTab.setHeight(szTab.height() + TAB_MARGIN);
            nTabBarSize += rectTab.height();
        }

        if( nTabBarSize <= nMaxTabBarSize )
        {
            drawTab( p, rectTab, ti,
                m_nHoverTabIndex == nI ? true : false,
                m_nActiveTabIndex == nI ? true : false, isNotifyTab(nI) < 0 ? false : true );

            m_nVisibleCount++;
        }

        ti.rcArea = rectTab;

        if (m_eTabDirection == TabDirectionHorzLeftTop)
        {
            rectTab.setX( rectTab.x() + (rectTab.width() + TAB_INTERVAL) );
        }
        else if (m_eTabDirection == TabDirectionVertLeftTop)
        {
            rectTab.setY( rectTab.y() + (rectTab.height() + TAB_INTERVAL) );
        }
    }

    if( m_nVisibleCount < m_aryTabInfo.size() )
    {
        if( !m_btnLeftTab.isVisible() )
        {
            m_btnLeftTab.setVisible( true );
            m_btnRightTab.setVisible( true );
        }
    }
    else
    {
        if( m_btnLeftTab.isVisible() )
        {
            m_btnLeftTab.setVisible( false );
            m_btnRightTab.setVisible( false );
        }
    }

    QPen bodyPen( QColor(160, 160, 160), 1.f);
    QPen bodyShadowPen( QColor(160, 160, 160, 150), 2.f);

    p.setPen(bodyShadowPen);
    if (isHorzTab())
    {
        int nTop = rectTab.bottom();
        if (m_nActiveTabIndex >= 0 && (m_nActiveTabIndex >= m_nMoveCount && m_nActiveTabIndex < (m_nMoveCount+m_nVisibleCount)))
        {
            const TabInfo& ti = m_aryTabInfo.at(m_nActiveTabIndex);
            p.drawLine( rc.left(), nTop, ti.rcArea.left(), nTop );
            p.drawLine( ti.rcArea.right(), nTop, rc.right(), nTop );
        }
        else
        {
            p.drawLine( rc.left(), nTop, rc.right(), nTop );
        }

        if (m_nActiveTabIndex >= 0)
            p.fillRect( rc.left(), nTop, rc.width(), rc.bottom()-nTop, Qt::white );

        p.drawLine( rc.right(), nTop, rc.right(), rc.bottom() );
        p.drawLine( rc.right(), rc.bottom(), rc.left(), rc.bottom() );
        p.drawLine( rc.left(), rc.bottom(), rc.left(), nTop );
    }
    else
    {
        int nLeft = rectTab.right();
        if (m_nActiveTabIndex >= 0 && (m_nActiveTabIndex >= m_nMoveCount && m_nActiveTabIndex < (m_nMoveCount+m_nVisibleCount)))
        {
            const TabInfo& ti = m_aryTabInfo.at(m_nActiveTabIndex);
            p.drawLine( nLeft, rc.top(), nLeft, ti.rcArea.top() );
            p.drawLine( nLeft, ti.rcArea.bottom(), nLeft, rc.bottom() );
        }
        else
        {
            p.drawLine( nLeft, rc.top(), nLeft, rc.bottom() );
        }

        if (m_nActiveTabIndex >= 0)
            p.fillRect( nLeft, rc.top(), rc.right()-nLeft, rc.height(), Qt::white );

        p.drawLine( nLeft, rc.bottom(), rc.right(), rc.bottom() );
        p.drawLine( rc.right(), rc.bottom(), rc.right(), rc.top() );
        p.drawLine( rc.right(), rc.top(), nLeft, rc.top() );
    }

    p.setPen( bodyPen );

    if (isHorzTab())
    {
        int nTop = rectTab.bottom();
        if (m_nActiveTabIndex >= 0 && (m_nActiveTabIndex >= m_nMoveCount && m_nActiveTabIndex < (m_nMoveCount+m_nVisibleCount)))
        {
            const TabInfo& ti = m_aryTabInfo.at(m_nActiveTabIndex);
            p.drawLine( rc.left(), nTop, ti.rcArea.left(), nTop );
            p.drawLine( ti.rcArea.right(), nTop, rc.right(), nTop );
        }
        else
        {
            p.drawLine( rc.left(), nTop, rc.right(), nTop );
        }

        p.drawLine( rc.right(), nTop, rc.right(), rc.bottom() );
        p.drawLine( rc.right(), rc.bottom(), rc.left(), rc.bottom() );
        p.drawLine( rc.left(), rc.bottom(), rc.left(), nTop );
    }
    else
    {
        int nLeft = rectTab.right();
        if (m_nActiveTabIndex >= 0 && (m_nActiveTabIndex >= m_nMoveCount && m_nActiveTabIndex < (m_nMoveCount+m_nVisibleCount)))
        {
            const TabInfo& ti = m_aryTabInfo.at(m_nActiveTabIndex);
            p.drawLine( nLeft, rc.top(), nLeft, ti.rcArea.top() );
            p.drawLine( nLeft, ti.rcArea.bottom(), nLeft, rc.bottom() );
        }
        else
        {
            p.drawLine( nLeft, rc.top(), nLeft, rc.bottom() );
        }

        p.drawLine( nLeft, rc.bottom(), rc.right(), rc.bottom() );
        p.drawLine( rc.right(), rc.bottom(), rc.right(), rc.top() );
        p.drawLine( rc.right(), rc.top(), nLeft, rc.top() );
    }
}
Example #29
0
void qRectFromScriptValue(const QScriptValue &object, QRect& rect) {
    rect.setX(object.property("x").toVariant().toInt());
    rect.setY(object.property("y").toVariant().toInt());
    rect.setWidth(object.property("width").toVariant().toInt());
    rect.setHeight(object.property("height").toVariant().toInt());
}
Example #30
0
/*!
  \brief Draw the marker
  \param p Painter
  \param x X position
  \param y Y position
  \param r Bounding rectangle
*/
void QwtMarker::draw(QPainter *p, int x, int y, const QRect &r)
{
    // draw lines
    if (d_style != NoLine)
    {
        p->setPen(d_pen);
        if ((d_style == HLine) || (d_style == Cross))
            p->drawLine(r.left(), y, r.right(), y);
        if ((d_style == VLine)||(d_style == Cross))
            p->drawLine(x, r.top(), x, r.bottom());
    }

    // draw symbol
    QSize sSym;
    if (d_sym.style() != QwtSymbol::None)
    {
        sSym = d_sym.size();
        d_sym.draw(p, x - (sSym.width() - 1) / 2 ,y - (sSym.width() - 1) / 2);
    }
    else
    {
        sSym.setWidth(0);
        sSym.setHeight(0);
    }
    

    // draw label
    if (!d_label.isEmpty())
    {
        p->setPen(d_tPen);
        p->setFont(d_font);

        const int th = p->fontMetrics().height();
        const int tw = p->fontMetrics().width(d_label);
        int lw = qwtMax(int(d_pen.width()), 1);
        int lw1;

        if ((d_style == VLine) || (d_style == HLine))
        {
            lw1 = (lw + 1) / 2 + LabelDist;
            lw = lw / 2 + LabelDist;
        }
        else 
        {
            lw1 = qwtMax((lw + 1) / 2, (sSym.width() + 1) / 2) + LabelDist;
            lw = qwtMax(lw / 2, (sSym.width() + 1) / 2) + LabelDist;
        }

        
        QRect tr;
        if (d_style == VLine)
        {
            if (d_align & (int) Qt::AlignTop)
               tr.setY(r.top() + LabelDist);
            else if (d_align & (int) Qt::AlignBottom)
               tr.setY(r.bottom() - LabelDist - th);
            else
               tr.setY(r.top() + (r.bottom() - r.top()) / 2);
        }
        else 
        {
            if (d_align & (int) Qt::AlignTop)
               tr.setY(y - lw - th);
            else if (d_align & (int) Qt::AlignBottom)
               tr.setY(y + lw1);
            else
               tr.setY(y - th/2);
        }


        if (d_style == HLine)
        {
            if (d_align & (int) Qt::AlignLeft)
               tr.setX(r.left() + LabelDist);
            else if (d_align & (int) Qt::AlignRight)
               tr.setX(r.right() - tw - LabelDist);
            else
               tr.setX(r.left() + (r.right() - r.left()) / 2);
        }
        else
        {
            if (d_align & (int) Qt::AlignLeft)
               tr.setX(x - tw - lw);
            else if (d_align & (int) Qt::AlignRight)
               tr.setX(x + lw1);
            else
               tr.setX(x - tw/ 2);
        }

        tr.setHeight(th);
        tr.setWidth(tw);    

        p->drawText(tr, Qt::AlignTop|Qt::AlignHCenter, d_label); 
    }
}