void ShareUserGroupWidget::slotSharesFetched(const QList<QSharedPointer<Share>> &shares)
{
    QScrollArea *scrollArea = _ui->scrollArea;


    auto newViewPort = new QWidget(scrollArea);
    auto layout = new QVBoxLayout(newViewPort);

    QSize minimumSize = newViewPort->sizeHint();
    int x = 0;

    foreach(const auto &share, shares) {
        // We don't handle link shares
        if (share->getShareType() == Share::TypeLink) {
            continue;
        }

        ShareWidget *s = new ShareWidget(share, _isFile, _ui->scrollArea);
        connect(s, SIGNAL(resizeRequested()), this, SLOT(slotAdjustScrollWidgetSize()));
        layout->addWidget(s);

        x++;
        if (x <= 3) {
            minimumSize = newViewPort->sizeHint();
        } else {
            minimumSize.rwidth() = qMax(newViewPort->sizeHint().width(), minimumSize.width());
        }
    }

    minimumSize.rwidth() += layout->spacing();
    minimumSize.rheight() += layout->spacing();
    scrollArea->setMinimumSize(minimumSize);
    scrollArea->setVisible(!shares.isEmpty());
    scrollArea->setWidget(newViewPort);
}
Example #2
0
QSize TrackViewDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    QSize res = QStyledItemDelegate::sizeHint(option, index);

    if (!index.parent().isValid())
    {

        if (!mDiskHeightHint)
        {
            int h = 8;
            QPainter painter(mTrackView);
            QFont titleFont = this->titleFont(&painter);
            QFont filesFont = this->filesFont(&painter);
            h += QFontMetrics(titleFont).height();
            h += QFontMetrics(filesFont).height() * 2;
            mDiskHeightHint = qMax(IMG_HEIGHT, h) + 2 * MARGIN + BOTTOM_PADDING; //For Line
        }


        res.rheight() = mDiskHeightHint;
        if (index.row())
            res.rheight() += TOP_PADDING;
        if (index.column() == 0)
            res.rwidth() = 600;
        else
            res.rwidth() = 0;
    }
    else
    {
        res.rheight() = res.height() + 8;
    }

    return res;
}
void MultiLayer::wheelEvent(QWheelEvent *e) {
  QApplication::setOverrideCursor(Qt::waitCursor);

  bool resize = false;
  QPoint aux;
  QSize intSize;
  Graph *resize_graph = 0;
  // Get the position of the mouse
  int xMouse = e->x();
  int yMouse = e->y();
  for (int i = 0; i < (int)graphsList.count(); i++) {
    Graph *gr = (Graph *)graphsList.at(i);
    intSize = gr->plotWidget()->size();
    aux = gr->pos();
    if (xMouse > aux.x() && xMouse < (aux.x() + intSize.width())) {
      if (yMouse > aux.y() && yMouse < (aux.y() + intSize.height())) {
        resize_graph = gr;
        resize = TRUE;
      }
    }
  }
  if (resize &&
      (e->state() == Qt::AltButton || e->state() == Qt::ControlButton ||
       e->state() == Qt::ShiftButton)) {
    intSize = resize_graph->plotWidget()->size();
    // If alt is pressed then change the width
    if (e->state() == Qt::AltButton) {
      if (e->delta() > 0) {
        intSize.rwidth() += 5;
      } else if (e->delta() < 0) {
        intSize.rwidth() -= 5;
      }
    }
    // If crt is pressed then changed the height
    else if (e->state() == Qt::ControlButton) {
      if (e->delta() > 0) {
        intSize.rheight() += 5;
      } else if (e->delta() < 0) {
        intSize.rheight() -= 5;
      }
    }
    // If shift is pressed then resize
    else if (e->state() == Qt::ShiftButton) {
      if (e->delta() > 0) {
        intSize.rwidth() += 5;
        intSize.rheight() += 5;
      } else if (e->delta() < 0) {
        intSize.rwidth() -= 5;
        intSize.rheight() -= 5;
      }
    }

    aux = resize_graph->pos();
    resize_graph->setGeometry(QRect(QPoint(aux.x(), aux.y()), intSize));
    resize_graph->plotWidget()->resize(intSize);

    emit modifiedPlot();
  }
  QApplication::restoreOverrideCursor();
}
QSize FilterHorizontalHeaderView::sectionSizeFromContents(int logicalIndex) const
{
	QVariant variant = model()->headerData(logicalIndex, Qt::Horizontal, Qt::SizeHintRole);
	if (variant.isValid())
		return qvariant_cast<QSize>(variant);
	// otherwise use the contents
	QStyleOptionHeader opt;
	initStyleOption(&opt);
	opt.section = logicalIndex;
	QVariant var = model()->headerData(logicalIndex, Qt::Horizontal,
					   Qt::FontRole);
	QFont fnt;
	if (var.isValid() && var.canConvert<QFont>())
		fnt = qvariant_cast<QFont>(var);
	else
		fnt = font();
	fnt.setBold(true);
	opt.fontMetrics = QFontMetrics(fnt);
	opt.text = model()->headerData(logicalIndex, Qt::Horizontal,
				       Qt::DisplayRole).toString();
	variant = model()->headerData(logicalIndex, Qt::Horizontal, Qt::DecorationRole);
	opt.icon = qvariant_cast<QIcon>(variant);
	if (opt.icon.isNull())
		opt.icon = qvariant_cast<QPixmap>(variant);
	QSize size = style()->sizeFromContents(QStyle::CT_HeaderSection, &opt, QSize(), this);
	/*if (isSortIndicatorShown() && sortIndicatorSection() == logicalIndex) {
    int margin = style()->pixelMetric(QStyle::PM_HeaderMargin, &opt, this);
    if (Qt::Horizontal == Qt::Horizontal)
	size.rwidth() += size.height() + margin;
    else
	size.rheight() += size.width() + margin;
    }*/
	size.rwidth()=std::max(size.rwidth(),40);
	return size;
}
Example #5
0
QSize SearchItemDelegate::sizeHint(const QStyleOptionViewItem &option,
                                   const QModelIndex &index) const
{
    QStyleOptionViewItem opt(option);

    QStyle *style = opt.widget->style();

    QSize size = QStyledItemDelegate::sizeHint(opt, index);
    size.setWidth(0);

    const int margin = style->pixelMetric(QStyle::PM_FocusFrameHMargin, &opt, opt.widget) + 1;

    // Find decoration roles with data present.
    QList<int> roles;
    for (int role : m_decorationRoles) {
        if (!index.data(role).isNull())
            roles.append(role);
    }

    if (!roles.isEmpty()) {
        const QIcon icon = index.data(roles.first()).value<QIcon>();
        const QSize actualSize = icon.actualSize(opt.decorationSize);
        const int decorationWidth = std::min(opt.decorationSize.width(), actualSize.width());
        size.rwidth() = (decorationWidth + margin) * roles.size() + margin;
    }

    size.rwidth() += opt.fontMetrics.width(index.data().toString()) + margin * 2;
    return size;
}
void QConsolePrivate::updateConsoleSize (bool sync)
{
  QFontMetrics fm (m_consoleView->font());
  QSize winSize = m_consoleView->size ();

  m_charSize.rwidth () = fm.averageCharWidth();
  m_charSize.rheight () = fm.lineSpacing ();

  m_consoleRect.setWidth (int(double(winSize.width ()) / double(fm.averageCharWidth())));
  m_consoleRect.setHeight (int(double(winSize.height ()) / double(fm.lineSpacing ())));

  m_bufferSize.rwidth () = m_consoleRect.width ();
  m_bufferSize.rheight () = qMax (m_bufferSize.height (),
                                  m_consoleRect.height ());

  m_consoleRect.moveLeft (0);
  if (m_consoleRect.bottom () >= m_bufferSize.height ())
    m_consoleRect.moveTop (m_bufferSize.height () - m_consoleRect.height ());

  log ("Console resized:\n");
  log ("  widget size: %d x %d\n", winSize.width (), winSize.height ());
  log ("  buffer size: %d x %d\n", m_bufferSize.width (),
       m_bufferSize.height ());
  log ("  window: (%d, %d) -> (%d, %d) [%d x %d]\n",
       m_consoleRect.left (), m_consoleRect.top (),
       m_consoleRect.right (), m_consoleRect.bottom (),
       m_consoleRect.width (), m_consoleRect.height ());

  if (sync)
    syncConsoleParameters ();

  updateScrollBar ();
}
//=============================================================================
int sstQt01PathPaintWidgetCls::updateButtonGeometry(QToolButton *button, int x, int y)
{
    QSize size = button->sizeHint();
    button->setGeometry(x - size.rwidth(), y - size.rheight(),
                        size.rwidth(), size.rheight());

    return y - size.rheight()
           - style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
}
Example #8
0
static QSize segmentSizeFromContents(const QStyleOption *option, const QSize &contentSize)
{
    QSize ret = contentSize;
    if (const QtStyleOptionSegmentControlSegment *segment
            = static_cast<const QtStyleOptionSegmentControlSegment *>(option)) {
        ret.rwidth() += 20;
        ret.rheight() += 10;
        if (!segment->icon.isNull())
            ret.rwidth() += 5;
    }
    return ret;
}
QSize QIrParabolicEffectManager::sizeHint() const
{
	QIR_P(const QIrParabolicEffectManager);
	QIrDockView * view = p->view;
	QList< QIrDockletBundle * > list = view->bundles();
	QIrDock * dock = view->dock();
	QRectF bounding;
	QRectF geom;
	int sepCount = 0, count = list.count();
	QIrDockStyle * style = dock->dockStyle();
	int spacing = p->view->dockletSpacing();

	if ( !style )
		return QSize();

	bounding = contentRect();
	for (int i = 0; i < count; i++) {
		if ( list[i]->docklet()->isSeparator() )
			sepCount++;
	}
	QSize s = bounding.size().toSize();
	
	if ( !dock->isExtended() ) {
		QSize mindockletSize = sizeForIconSize(style,spacing,dock->effectiveMinimumIconSize(),dock->minimumIconSize(),dock->maximumIconSize(),false,dock->orientation());
		QSize minSepSize = sizeForIconSize(style,spacing,dock->effectiveMinimumIconSize(),dock->minimumIconSize(),
			dock->maximumIconSize(),true,dock->orientation());

		if ( dock->orientation() == Qt::Horizontal ) {
			s.rwidth() = (count - sepCount) * (mindockletSize.width() + 1) + sepCount * (minSepSize.width() + 1) - 1;
		} else {
			s.rheight() = (count - sepCount) * (mindockletSize.height() + 1) + sepCount * (minSepSize.height() + 1) - 1;
		}
	}	
	return s;
}
Example #10
0
void WelcomeScreen::update()
{
    // find dimensions
    int max_x = 0;
    int max_y = 0;
    for (Buttons::const_iterator i = m_buttons.constBegin();
         i != m_buttons.constEnd();
         ++i) {
        if (i.key().x > max_x) {
            max_x = i.key().x;
        }
        if (i.key().y > max_y) {
            max_y = i.key().y;
        }    
    }
    max_x++;
    max_y++;
    
    // place buttons
    QSize size = m_size;
    size.rwidth() /= max_x;
    size.rheight() /= max_y;
    
    for (Buttons::const_iterator i = m_buttons.constBegin();
         i != m_buttons.constEnd();
         ++i) {
        QPoint pos(size.width() * i.key().x,
                   size.height() * i.key().y);
        QPoint delta((size.width() - i.value()->size().width()) / 2,
                     (size.height() - i.value()->size().height()) / 2);
        i.value()->moveTo(pos + delta);
        i.value()->repaint();
    }
}
 /* Search for the maximum available size-hint */
 foreach (QIWizardPage *pPage, pages)
 {
     maxOfSizeHints.rwidth() = pPage->sizeHint().width() > maxOfSizeHints.width() ?
                               pPage->sizeHint().width() : maxOfSizeHints.width();
     maxOfSizeHints.rheight() = pPage->sizeHint().height() > maxOfSizeHints.height() ?
                                pPage->sizeHint().height() : maxOfSizeHints.height();
 }
QPixmap MLocalThemeDaemonClient::requestPixmap(const QString &id, const QSize &requestedSize)
{
    QPixmap pixmap;

    QSize size = requestedSize;
    if (size.width() < 1) {
        size.rwidth() = 0;
    }
    if (size.height() < 1) {
        size.rheight() = 0;
    }

    const PixmapIdentifier pixmapId(id, size);
    pixmap = m_pixmapCache.value(pixmapId);
    if (pixmap.isNull()) {
        // The pixmap is not cached yet. Decode the image and
        // store it into the cache as pixmap.
        const QImage image = readImage(id);
        if (!image.isNull()) {
            pixmap = QPixmap::fromImage(image);
            if (requestedSize.isValid() && (pixmap.size() != requestedSize)) {
                pixmap = pixmap.scaled(requestedSize);
            }

            m_pixmapCache.insert(pixmapId, pixmap);
        }
    }
    return pixmap;
}
Example #13
0
QSize XKPPlacementLayout::calculateSize(SizeType sizeType) const
{
#ifdef DEBUG_XKPPLACEMENT
    qDebug() << "calculateSize()";
#endif
    QSize totalSize;

    for(int i = 0; i < list.size(); ++i) {
        ItemWrapper *wrapper = list.at(i);
        Placement position = wrapper->position;
        QSize itemSize;

        if(sizeType == MinimumSize)
            itemSize = wrapper->item->minimumSize();
        else if(sizeType == SizeHint)
            itemSize = wrapper->item->sizeHint();
        else if(sizeType == PlacementSize && wrapper->widget) {
            if(wrapper->widget->property(placementSizeName).toSize() == QSize(-1, -1)) {
                wrapper->widget->setProperty(placementSizeName, wrapper->widget->size());
                itemSize = wrapper->widget->size();
            } else {
                itemSize = wrapper->widget->property(placementSizeName).toSize();
            }
        }

        if(position == Top || position == Bottom || position == Center)
            totalSize.rheight() += itemSize.height();

        if(position == Left || position == Right || position == Center)
            totalSize.rwidth() += itemSize.width();
    }

    return totalSize;
}
Example #14
0
QSize MainWindow::sizeHint() const
{
    QSize size = printer->paperSize(QPrinter::Point).toSize() * 1.2;
    size.rwidth() += brushWidget->sizeHint().width();
    return size.boundedTo(
               QApplication::desktop()->availableGeometry().size());
}
Example #15
0
 QSize BorderLayout::calculateSize(SizeType sizeType) const
 {
     QSize totalSize;

     for (int i = 0; i < list.size(); ++i) {
         ItemWrapper *wrapper = list.at(i);
         Position position = wrapper->position;
         QSize itemSize;

         if (sizeType == MinimumSize)
             itemSize = wrapper->item->minimumSize();
         else // (sizeType == SizeHint)
             itemSize = wrapper->item->sizeHint();

         if (position == North || position == South || position == Center)
             totalSize.rheight() += itemSize.height();

         if (position == West || position == East || position == Center)
             totalSize.rwidth() += itemSize.width();
     }
     if (totalSize.height() < 0)
       totalSize.setHeight(0);
     if (totalSize.width() < 0)
       totalSize.setWidth(0);
     return totalSize;
 }
Example #16
0
QSize ThumbDelegate::sizeHint(const QStyleOptionViewItem & /*option*/, const QModelIndex & /*index*/) const
{
    QSize hint = BachMainWindow::tnSize();
		hint.rheight() += 4;
		hint.rwidth() += 4;
		return hint;
}
Example #17
0
QSize Button::sizeHint() const
{
    QSize size = QToolButton::sizeHint();
    size.rheight() += 15;
    size.rwidth() = qMax(size.height(), size.width());
    return size;
}
Example #18
0
void QDirectFBPixmapData::fill(const QColor &color)
{
    if (!serialNumber())
        return;

    Q_ASSERT(dfbSurface);

    alpha |= (color.alpha() < 255);

    if (alpha && isOpaqueFormat(imageFormat)) {
        QSize size;
        dfbSurface->GetSize(dfbSurface, &size.rwidth(), &size.rheight());
        screen->releaseDFBSurface(dfbSurface);
        imageFormat = screen->alphaPixmapFormat();
        d = QDirectFBScreen::depth(imageFormat);
        dfbSurface = screen->createDFBSurface(size, screen->alphaPixmapFormat(), QDirectFBScreen::TrackSurface);
        setSerialNumber(++global_ser_no);
        if (!dfbSurface) {
            qWarning("QDirectFBPixmapData::fill()");
            invalidate();
            return;
        }
    }

    dfbSurface->Clear(dfbSurface, color.red(), color.green(), color.blue(), color.alpha());
}
Example #19
0
QSize TextBrowserDialog::sizeHint() const
{
	QSize size = text_browser->document()->size().toSize();
	if (text_browser->verticalScrollBar())
		size.rwidth() += text_browser->verticalScrollBar()->width();
	return size;
}
Example #20
0
/*!
    \reimp
*/
QSize Q3WidgetStack::minimumSizeHint() const
{
    constPolish();

    QSize size(0, 0);

    Q3IntDictIterator<QWidget> it(*dict);
    QWidget *w;

    while ((w = it.current()) != 0) {
        ++it;
        QSize sh = w->minimumSizeHint();
        if (w->sizePolicy().horData() == QSizePolicy::Ignored)
            sh.rwidth() = 0;
        if (w->sizePolicy().verData() == QSizePolicy::Ignored)
            sh.rheight() = 0;
#ifndef QT_NO_LAYOUT
        size = size.expandedTo(sh).expandedTo(w->minimumSize());
#endif
    }
    if (size.isNull())
        size = QSize(64, 32);
    size += QSize(2*frameWidth(), 2*frameWidth());
    return size;
}
Example #21
0
QRegion WidgetArea::getRegionWithWidgets()
{
    QPoint p;
    QSize s = size();
    for(w_map::iterator itr = m_widgets.begin(); itr != m_widgets.end(); ++itr)
    {
        DataWidget *w = *itr;
        p.rx() = std::min(w->x(), p.x());
        p.ry() = std::min(w->y(), p.y());

        s.rwidth() = std::max(s.width(), w->x() + w->width());
        s.rheight() = std::max(s.height(), w->y() + w->height());
    }
    s.rwidth() += abs(p.x());
    s.rheight() += abs(p.y());
    return QRegion(QRect(p, s));
}
Example #22
0
/*!
    \reimp
 */
QSize QxtStars::minimumSizeHint() const
{
    QSize size = qxt_d().getStarSize();
    size.rwidth() *= maximum() - minimum();
    if (orientation() == Qt::Vertical)
        size.transpose();
    return size;
}
Example #23
0
//! [1]
QSize Button::sizeHint() const
//! [1] //! [2]
{
    QSize size = QToolButton::sizeHint();
    size.rheight() += 20;
    size.rwidth() = qMax(size.width(), size.height());
    return size;
}
Example #24
0
QSize TickSlider::sizeHint() const
{
    QSize size = QSlider::sizeHint();
    bool using_labels = tickLabelPosition() != NoTicks;
    QSize label = using_labels ? biggestLabel() : QSize();
    bool using_ticks = tickPosition() != NoTicks;
    int n_potential_labels = (maximum() - minimum()) / tickInterval();
    if (orientation() == Qt::Horizontal) {
        // Horizontal
        if (using_labels) {
            size.rheight() += 2 * label.height();
            size = size.expandedTo(QSize(
                                       n_potential_labels * label.width() +
                                       (n_potential_labels - 1) * m_min_interlabel_gap,
                                       0));
        }
        if (using_ticks) {
            size.rheight() += 2 * m_tick_length;
        }
        if (using_labels && using_ticks) {
            size.rheight() += 2 * m_tick_label_gap;
        }
        if (using_labels || using_ticks) {
            size.rheight() += 2 * m_gap_to_slider;
        }
    } else {
        // Vertical
        if (using_labels) {
            size.rwidth() += 2 * label.width();
            size = size.expandedTo(QSize(
                                       0,
                                       n_potential_labels * label.height() +
                                       (n_potential_labels - 1) * m_min_interlabel_gap));
        }
        if (using_ticks) {
            size.rwidth() += 2 * m_tick_length;
        }
        if (using_labels && using_ticks) {
            size.rwidth() += 2 * m_tick_label_gap;
        }
        if (using_labels || using_ticks) {
            size.rwidth() += 2 * m_gap_to_slider;
        }
    }
    return size;
}
Example #25
0
void PopupMenuEditor::resizeToContents()
{
    QSize s = contentsSize();
    dropLine->resize( s.width(), 2 );
    s.rwidth() += borderSize * 2;
    s.rheight() += borderSize * 2;
    resize( s );
}
Example #26
0
    QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const {
      QSize sh = QStyledItemDelegate::sizeHint(option, index);
      if (!index.parent().isValid()) {
        sh.rheight() += 2 * m_categoryDrawer.leftMargin();
      } else {
        sh.rheight() += m_categoryDrawer.leftMargin();
      }
      if (index.column() == 0) {
        sh.rwidth() += m_categoryDrawer.leftMargin();
      } else if (index.column() == 1) {
        sh.rwidth() = 150;
      } else {
        sh.rwidth() += m_categoryDrawer.leftMargin();
      }

      return sh;
    }
void StylePainterMobile::drawProgress(const QRect& rect, double progress, bool leftToRight, bool animated, bool vertical) const
{
    const int horizontalBorder = (vertical ? rect.width() / 4 : 0);
    const int verticalBorder = (vertical ? 0 : rect.height() / 4);
    const QRect targetRect = rect.adjusted(horizontalBorder, verticalBorder, -horizontalBorder, -verticalBorder);

    QPixmap result;
    QSize imageSize = sizeForPainterScale(targetRect);
    if (vertical)
        qSwap(imageSize.rheight(), imageSize.rwidth());
    KeyIdentifier id;
    id.type = KeyIdentifier::Progress;
    id.width = imageSize.width();
    id.height = imageSize.height();
    id.trait1 = animated;
    id.trait2 = (!animated && !leftToRight);
    id.trait3 = progress * 100;
    if (!findCachedControl(id, &result)) {
        if (imageSize.isNull())
            return;
        result = QPixmap(imageSize);
        result.fill(Qt::transparent);
        QPainter painter(&result);
        painter.setRenderHint(QPainter::Antialiasing);
        QRect progressRect(QPoint(0, 0), imageSize);
        qreal radius = radiusFactor * progressRect.height();
        painter.setBrush(Qt::NoBrush);
        painter.setPen(borderPen());
        progressRect.adjust(1, 1, -1, -1);
        painter.drawRoundedRect(progressRect, radius, radius);
        progressRect.adjust(1, 1, -1, -1);
        if (animated) {
            const int right = progressRect.right();
            const int startPos = right * (1 - progressBarChunkPercentage) * 2 * fabs(progress - 0.5);
            progressRect.setWidth(progressBarChunkPercentage * right);
            progressRect.moveLeft(startPos);
        } else {
            progressRect.setWidth(progress * progressRect.width());
            if (!leftToRight)
                progressRect.moveRight(imageSize.width() - 2);
        }
        if (progressRect.width() > 0) {
            QLinearGradient gradient;
            gradient.setStart(progressRect.bottomLeft());
            gradient.setFinalStop(progressRect.topLeft());
            gradient.setColorAt(0.0, highlightColor);
            gradient.setColorAt(1.0, highlightColor.lighter());
            painter.setBrush(gradient);
            painter.setPen(Qt::NoPen);
            radius = radiusFactor * progressRect.height();
            painter.drawRoundedRect(progressRect, radius, radius);
        }
        insertIntoCache(id, result);
    }
    QTransform transform;
    transform.rotate(-90);
    painter->drawPixmap(targetRect, vertical ? result.transformed(transform) : result);
}
Example #28
0
QSize KxMenuItemWidget::sizeHint() const
{
    // Do not give invisible menu items any space
    if(!fMenuItem->isVisible()) return QSize(0,0);

    QSize sz;

    QWidget *q = parentWidget();
    QStyleOptionMenuItem opt = getStyleOption();
    KxMenuItem *action = fMenuItem;

    const int hmargin = q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q),
        iconWidth = q->style()->pixelMetric(QStyle::PM_SmallIconSize, 0, q);

    QFontMetrics fm(action->font().resolve(q->font()));
    if (action->isSeparator()) {
        sz = QSize(2, 2);
    } else {
        // Text
        QString s = action->text();
        int w = fm.width(s);
        QKeySequence shortcutSeq = fMenuItem->shortcut();
        sz.setWidth(w);
        sz.setHeight(fm.height());
        // Keyboard shortcut
        if(!shortcutSeq.isEmpty()) {
            QString shortcut = shortcutSeq.toString(QKeySequence::NativeText);
            w = fm.width(shortcut);
            sz.rwidth() += w + kShortcutRightMargin;
        }
        // Checkbox
        if(action->isCheckable()) {
            sz.rwidth() += iconWidth;
        }
        // option boxes
        sz.rwidth() += iconWidth;
        // Margins
        sz.rwidth() += 2 * hmargin;
    }

    opt.rect = q->rect();
    sz = q->style()->sizeFromContents(QStyle::CT_MenuItem, &opt, sz, q);

    return sz;
}
Example #29
0
void QZBar::resizeEvent (QResizeEvent *event)
{
    QSize size = event->size();
    try {
        if(thread)
            thread->window.resize(size.rwidth(), size.rheight());
    }
    catch(Exception) { /* ignore */ }
}
Example #30
0
QSize EvButton::sizeHint() const
{
    ensurePolished();
    QSize s = fontMetrics().size(Qt::TextSingleLine, text());
    s *= 1.1;

    s.rheight() += 4;
    s.rwidth() += s.height();
    return s.expandedTo(QApplication::globalStrut());
}