QWidget * ExtcapArgumentFileSelection::createEditor(QWidget * parent)
{
QWidget * fileWidget = new QWidget(parent);
QHBoxLayout * editLayout = new QHBoxLayout();
QMargins margins = editLayout->contentsMargins();
editLayout->setContentsMargins(0, 0, 0, margins.bottom());
fileWidget->setContentsMargins(margins.left(), margins.right(), 0, margins.bottom());
QPushButton * button = new QPushButton(UTF8_HORIZONTAL_ELLIPSIS, fileWidget);
textBox = new QLineEdit(_default->toString(), parent);
textBox->setReadOnly(true);
if ( _argument->default_complex != NULL && _argument->arg_type == EXTCAP_ARG_STRING )
textBox->setText(QString().fromUtf8(extcap_complex_get_string(_argument->default_complex)));
if ( _argument->tooltip != NULL )
{
textBox->setToolTip(QString().fromUtf8(_argument->tooltip));
button->setToolTip(QString().fromUtf8(_argument->tooltip));
}
connect(button, SIGNAL(clicked()), (QObject *)this, SLOT(openFileDialog()));
editLayout->addWidget(textBox);
editLayout->addWidget(button);
fileWidget->setLayout(editLayout);
return fileWidget;
}
static QMargins maxMargins(const QMargins &a,
const QMargins &b)
{
return QMargins(qMax(a.left(), b.left()),
qMax(a.top(), b.top()),
qMax(a.right(), b.right()),
qMax(a.bottom(), b.bottom()));
}
void saveInSettings(QSettings& settingsObj, const QString &name, const QMargins &value)
{
settingsObj.setValue(name + "/left", value.left());
settingsObj.setValue(name + "/top", value.top());
settingsObj.setValue(name + "/right", value.right());
settingsObj.setValue(name + "/bottom", value.bottom());
}
QString LayoutDumper::getLayoutInfo(QLayout* layout)
{
if (!layout) {
return "null_layout";
}
QMargins margins = layout->contentsMargins();
QSize sizehint = layout->sizeHint();
QSize minsize = layout->minimumSize();
QString name = layout->metaObject()->className();
// usually unhelpful (blank): layout->objectName()
QString margin = QString("margin (l=%1,t=%2,r=%3,b=%4)")
.arg(margins.left())
.arg(margins.top())
.arg(margins.right())
.arg(margins.bottom());
QString constraint = QString("constraint %1")
.arg(toString(layout->sizeConstraint()));
QString sh = QString("sizeHint (%1 x %2)")
.arg(sizehint.width())
.arg(sizehint.height());
QString ms = QString("minimumSize (%7 x %8)")
.arg(minsize.width())
.arg(minsize.height());
QString hfw = layout->hasHeightForWidth() ? " [hasHeightForWidth]" : "";
return QString("%1, %2, %3, %4, %5%6")
.arg(name)
.arg(margin)
.arg(constraint)
.arg(sh)
.arg(ms)
.arg(hfw);
}
void BrushItem::updateBoundingRect()
{
prepareGeometryChange();
if (!mMapDocument) {
mBoundingRect = QRectF();
return;
}
const QRect bounds = mRegion.boundingRect();
mBoundingRect = mMapDocument->renderer()->boundingRect(bounds);
// Adjust for amount of pixels tiles extend at the top and to the right
if (mTileLayer) {
const Map *map = mMapDocument->map();
QMargins drawMargins = mTileLayer->drawMargins();
drawMargins.setTop(drawMargins.top() - map->tileHeight());
drawMargins.setRight(drawMargins.right() - map->tileWidth());
// Since we're also drawing a tile selection, we should not apply
// negative margins
mBoundingRect.adjust(qMin(0, -drawMargins.left()),
qMin(0, -drawMargins.top()),
qMax(0, drawMargins.right()),
qMax(0, drawMargins.bottom()));
}
}
void QWindowsGeometryHint::applyToMinMaxInfo(DWORD style, DWORD exStyle, MINMAXINFO *mmi) const
{
if (QWindowsContext::verboseWindows)
qDebug().nospace() << '>' << __FUNCTION__ << '<' << " min="
<< minimumSize.width() << ',' << minimumSize.height()
<< " max=" << maximumSize.width() << ',' << maximumSize.height()
<< " in " << *mmi;
const QMargins margins = QWindowsGeometryHint::frame(style, exStyle);
const int frameWidth = margins.left() + margins.right();
const int frameHeight = margins.top() + margins.bottom();
if (minimumSize.width() > 0)
mmi->ptMinTrackSize.x = minimumSize.width() + frameWidth;
if (minimumSize.height() > 0)
mmi->ptMinTrackSize.y = minimumSize.height() + frameHeight;
const int maximumWidth = qMax(maximumSize.width(), minimumSize.width());
const int maximumHeight = qMax(maximumSize.height(), minimumSize.height());
if (maximumWidth < QWINDOWSIZE_MAX)
mmi->ptMaxTrackSize.x = maximumWidth + frameWidth;
// windows with title bar have an implicit size limit of 112 pixels
if (maximumHeight < QWINDOWSIZE_MAX)
mmi->ptMaxTrackSize.y = qMax(maximumHeight + frameHeight, 112);
if (QWindowsContext::verboseWindows)
qDebug().nospace() << '<' << __FUNCTION__
<< " frame=" << margins << ' ' << frameWidth << ',' << frameHeight
<< " out " << *mmi;
}
void HGLayout::setMargins(const QMargins& m)
{
if (layout()) {
layout()->setContentsMargins(m.left(), m.top(), m.right(), m.bottom());
}
HLayout::setMargins(m);
}
void QWaylandWindow::handleMouseEventWithDecoration(QWaylandInputDevice *inputDevice, ulong timestamp, const QPointF &local, const QPointF &global, Qt::MouseButtons b, Qt::KeyboardModifiers mods)
{
if (mWindowDecoration->handleMouse(inputDevice,local,global,b,mods))
return;
QMargins marg = frameMargins();
QRect windowRect(0 + marg.left(),
0 + marg.top(),
geometry().size().width() - marg.right(),
geometry().size().height() - marg.bottom());
if (windowRect.contains(local.toPoint()) || mMousePressedInContentArea != Qt::NoButton) {
QPointF localTranslated = local;
QPointF globalTranslated = global;
localTranslated.setX(localTranslated.x() - marg.left());
localTranslated.setY(localTranslated.y() - marg.top());
globalTranslated.setX(globalTranslated.x() - marg.left());
globalTranslated.setY(globalTranslated.y() - marg.top());
if (!mMouseEventsInContentArea) {
restoreMouseCursor(inputDevice);
QWindowSystemInterface::handleEnterEvent(window());
}
QWindowSystemInterface::handleMouseEvent(window(), timestamp, localTranslated, globalTranslated, b, mods);
mMouseEventsInContentArea = true;
mMousePressedInContentArea = b;
} else {
if (mMouseEventsInContentArea) {
QWindowSystemInterface::handleLeaveEvent(window());
mMouseEventsInContentArea = false;
}
mWindowDecoration->handleMouse(inputDevice,local,global,b,mods);
}
}
void Map::adjustDrawMargins(const QMargins &margins) {
mDrawMargins = maxMargins(QMargins(margins.left(),
margins.top() - mTileHeight,
margins.right() - mTileWidth,
margins.bottom()),
mDrawMargins);
}
void KWidget::setMargins( const QMargins& m )
{
QGraphicsLayout *tmpLayout = layout();
if(tmpLayout == NULL)
return;
tmpLayout->setContentsMargins(m.left(), m.top(), m.right(), m.bottom());
}
void LineEdit::paintEvent(QPaintEvent * event)
{
QLineEdit::paintEvent(event);
QPainter p(this);
// draw the default text if needed
bool showDefaultText = text().isEmpty() && !infoText_.isEmpty();
if (showDefaultText) {
p.setPen(Qt::gray);
const QMargins margins = textMargins();
p.drawText(QRect(margins.left() + 8,
margins.top(),
width() - margins.left() - margins.right() - 8,
height() - margins.top() - margins.bottom()),
infoText_,
Qt::AlignLeft | Qt::AlignVCenter);
}
// draw left icon
if (!leftIcon_.isNull()) {
int offset = 1 + (height() - leftIcon_.height() ) / 2;
p.drawPixmap(offset, offset, leftIcon_);
}
// draw right icon
if (!showDefaultText && !rightIcon_.isNull()) {
p.drawPixmap(width() - rightIcon_.width() - 7, 1 + (height() - rightIcon_.height()) / 2, rightIcon_);
}
}
void UIScaleFactorEditor::prepare()
{
m_pMainLayout = new QGridLayout;
if (!m_pMainLayout)
return;
QMargins margins = m_pMainLayout->contentsMargins();
m_pMainLayout->setContentsMargins(0, margins.top(), 0, margins.bottom());
m_pMonitorComboBox = new QComboBox;
if (m_pMonitorComboBox)
{
m_pMainLayout->addWidget(m_pMonitorComboBox, 0, 0);
m_pMonitorComboBox->insertItem(0, "All Monitors");
connect(m_pMonitorComboBox ,static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &UIScaleFactorEditor::sltMonitorComboIndexChanged);
}
QGridLayout *pSliderLayout = new QGridLayout;
pSliderLayout->setSpacing(0);
m_pScaleSlider = new QIAdvancedSlider;
{
pSliderLayout->addWidget(m_pScaleSlider, 0, 0, 1, 3);
m_pScaleSlider->setMinimum(100);
m_pScaleSlider->setMaximum(200);
m_pScaleSlider->setPageStep(10);
m_pScaleSlider->setSingleStep(1);
m_pScaleSlider->setTickInterval(10);
m_pScaleSlider->setSnappingEnabled(true);
connect(m_pScaleSlider, static_cast<void(QIAdvancedSlider::*)(int)>(&QIAdvancedSlider::valueChanged),
this, &UIScaleFactorEditor::sltScaleSliderValueChanged);
}
m_pMinScaleLabel = new QLabel;
if (m_pMinScaleLabel)
pSliderLayout->addWidget(m_pMinScaleLabel, 1, 0);
QSpacerItem *pSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
if (pSpacer)
pSliderLayout->addItem(pSpacer, 1, 1);
m_pMaxScaleLabel = new QLabel;
if (m_pMaxScaleLabel)
pSliderLayout->addWidget(m_pMaxScaleLabel, 1, 2);
m_pMainLayout->addLayout(pSliderLayout, 0, 1, 2, 1);
m_pScaleSpinBox = new QSpinBox;
if (m_pScaleSpinBox)
{
m_pMainLayout->addWidget(m_pScaleSpinBox, 0, 3);
m_pScaleSpinBox->setSuffix("%");
m_pScaleSpinBox->setMinimum(100);
m_pScaleSpinBox->setMaximum(200);
connect(m_pScaleSpinBox ,static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
this, &UIScaleFactorEditor::sltScaleSpinBoxValueChanged);
}
configureScaleFactorMinMaxValues();
setLayout(m_pMainLayout);
retranslateUi();
}
QRect WWidgetGroup::layoutContentsMargins() const {
QLayout* pLayout = layout();
QMargins margins = pLayout ? pLayout->contentsMargins() :
contentsMargins();
return QRect(margins.left(), margins.top(),
margins.right(), margins.bottom());
}
QSize TrayIcon::sizeHint() const
{
QMargins margins = contentsMargins();
return QSize(margins.left() + mIconSize.width() + margins.right(),
margins.top() + mIconSize.height() + margins.bottom()
);
}
virtual void Put(ProgramOptions::Ptr po, const boost::any& value)
{
QMargins r = boost::any_cast<QMargins>(value);
po->PutInt("Left", r.left());
po->PutInt("Top", r.top());
po->PutInt("Right", r.right());
po->PutInt("Bottom", r.bottom());
}
QMargins
DpiScaler::scaled( const QMargins& margins ) const
{
return scaled( margins.left(),
margins.top(),
margins.right(),
margins.bottom() );
}
void QWidgetWindow::updateMargins()
{
const QMargins margins = frameMargins();
QTLWExtra *te = m_widget->d_func()->topData();
te->posIncludesFrame= false;
te->frameStrut.setCoords(margins.left(), margins.top(), margins.right(), margins.bottom());
m_widget->data->fstrut_dirty = false;
}
void Utils::WriteMargins(ProgramOptions::Ptr po, const std::string& name, const QMargins& rect)
{
ProgramOptions::Ptr node = po->StartNode(name);
node->PutInt("Left", rect.left());
node->PutInt("Top", rect.top());
node->PutInt("Right", rect.right());
node->PutInt("Bottom", rect.bottom());
}
int VtlWidget::margin() const
{
QMargins m = contentsMargins();
Q_ASSERT ( m.left() == m.top() && m.top() == m.right() && m.right() == m.bottom() );
return contentsMargins().left();
}
QWidget * ExtArgRadio::createEditor(QWidget * parent)
{
int count = 0;
bool anyChecked = false;
selectorGroup = new QButtonGroup(parent);
QWidget * radioButtons = new QWidget;
QVBoxLayout * vrLayout = new QVBoxLayout();
QMargins margins = vrLayout->contentsMargins();
vrLayout->setContentsMargins(0, 0, 0, margins.bottom());
if ( callStrings != 0 )
delete callStrings;
callStrings = new QList<QString>();
if ( values.length() > 0 )
{
ExtcapValueList::const_iterator iter = values.constBegin();
while ( iter != values.constEnd() )
{
QRadioButton * radio = new QRadioButton((*iter).value());
QString callString = (*iter).call();
callStrings->append(callString);
if ( _default != NULL && (*iter).isDefault() )
{
radio->setChecked(true);
anyChecked = true;
}
else if (_default != NULL)
{
if ( callString.compare(_default->toString()) == 0 )
{
radio->setChecked(true);
anyChecked = true;
}
}
connect(radio, SIGNAL(clicked(bool)), SLOT(onBoolChanged(bool)));
selectorGroup->addButton(radio, count);
vrLayout->addWidget(radio);
count++;
++iter;
}
}
/* No default was provided, and not saved value exists */
if ( anyChecked == false && count > 0 )
((QRadioButton*)(selectorGroup->button(0)))->setChecked(true);
radioButtons->setLayout(vrLayout);
return radioButtons;
}
void MarginsEditingWidget::setMargins(const QMargins &margins)
{
disconnectAll();
ui->leftMarginSpinBox->setValue(margins.left());
ui->topMarginSpinBox->setValue(margins.top());
ui->rightMarginSpinBox->setValue(margins.right());
ui->bottomMarginSpinBox->setValue(margins.bottom());
connectAll();
}
void ColorEditor::resizeEvent( QResizeEvent* event )
{
// Do the normal line-edit-with-button thing
LineEditWithButton::resizeEvent( event );
// Then add text padding on the left to make room for the color swatch
QMargins marge = textMargins();
setTextMargins( height(), marge.top(), marge.right(), marge.bottom() );
}
void QMapboxGL::setMargins(const QMargins &margins_)
{
d_ptr->margins = {
static_cast<double>(margins_.top()),
static_cast<double>(margins_.left()),
static_cast<double>(margins_.bottom()),
static_cast<double>(margins_.right())
};
}
void MapScene::updateSceneRect()
{
QRectF sceneRect = mMapDocument->renderer()->mapBoundingRect();
QMargins margins = mMapDocument->map()->computeLayerOffsetMargins();
sceneRect.adjust(-margins.left(),
-margins.top(),
margins.right(),
margins.bottom());
QMargins drawMargins = mMapDocument->map()->drawMargins();
sceneRect.adjust(qMin(0, -drawMargins.left()),
qMin(0, -drawMargins.top()),
qMax(0, drawMargins.right()),
qMax(0, drawMargins.bottom()));
setSceneRect(sceneRect);
}
QScriptValue NMarginsPrototype::toScriptValue(QScriptEngine *engine, const QMargins &m)
{
QScriptValue obj = engine->newObject();
obj.setProperty("bottom", m.bottom());
obj.setProperty("left", m.left());
obj.setProperty("right", m.right());
obj.setProperty("top", m.top());
return obj;
}
QSize
ComboBox::sizeForWidth(int w) const
{
if (minimumWidth() > 0) {
w = std::max( w, maximumWidth() );
}
QSize contentsMargin;
{
QMargins margins = contentsMargins();
contentsMargin.setWidth( margins.left() + margins.right() );
contentsMargin.setHeight( margins.bottom() + margins.top() );
}
QRect br;
//Using this constructor of QFontMetrics will respect the DPI of the screen, see http://doc.qt.io/qt-4.8/qfontmetrics.html#QFontMetrics-2
QFontMetrics fm(font(), 0);
Qt::Alignment align = QStyle::visualAlignment( Qt::LeftToRight, QFlag(_align) );
int hextra = DROP_DOWN_ICON_SIZE * 2, vextra = 0;
///Indent of 1 character
int indent = fm.width( QLatin1Char('x') );
if (indent > 0) {
if ( (align & Qt::AlignLeft) || (align & Qt::AlignRight) ) {
hextra += indent;
}
if ( (align & Qt::AlignTop) || (align & Qt::AlignBottom) ) {
vextra += indent;
}
}
// Turn off center alignment in order to avoid rounding errors for centering,
// since centering involves a division by 2. At the end, all we want is the size.
int flags = align & ~(Qt::AlignVCenter | Qt::AlignHCenter);
bool tryWidth = (w < 0) && (align & Qt::TextWordWrap);
if (tryWidth) {
w = std::min( fm.averageCharWidth() * 80, maximumSize().width() );
} else if (w < 0) {
w = 2000;
}
w -= ( hextra + contentsMargin.width() );
br = fm.boundingRect(0, 0, w, 2000, flags, _currentText);
if ( tryWidth && ( br.height() < 4 * fm.lineSpacing() ) && (br.width() > w / 2) ) {
br = fm.boundingRect(0, 0, w / 2, 2000, flags, _currentText);
}
if ( tryWidth && ( br.height() < 2 * fm.lineSpacing() ) && (br.width() > w / 4) ) {
br = fm.boundingRect(0, 0, w / 4, 2000, flags, _currentText);
}
const QSize contentsSize(br.width() + hextra, br.height() + vextra);
return (contentsSize + contentsMargin).expandedTo( minimumSize() );
} // ComboBox::sizeForWidth
QMargins
DpiScaler::scaled( const QPaintDevice* pd, const QMargins& margins )
{
return scaled( pd,
margins.left(),
margins.top(),
margins.right(),
margins.bottom() );
}
void
QueryLabel::setExtraContentsMargins( int left, int top, int right, int bottom )
{
QMargins margins = contentsMargins();
margins.setLeft( margins.left() + left );
margins.setTop( margins.top() + top );
margins.setRight( margins.right() + right );
margins.setBottom( margins.bottom() + bottom );
setContentsMargins( margins );
}
void PrinterTests::margins()
{
QPrinter printer(QPrinter::HighResolution);
printer.setPageMargins(10, 20, 30, 45, QPrinter::Millimeter);
QMargins margins = Printer::margins(&printer);
QCOMPARE(margins.left(), 100);
QCOMPARE(margins.top(), 200);
QCOMPARE(margins.right(), 300);
QCOMPARE(margins.bottom(), 450);
}
void DefaultGui::adjustFloatingControlSize() {
qDebug("DefaultGui::adjustFloatingControlSize");
//floating_control->adjustSize();
QWidget *iw = floating_control->internalWidget();
QSize iws = iw->size();
QMargins m = floating_control->contentsMargins();
int new_height = iws.height() + m.top() + m.bottom();
if (new_height < 32) new_height = 32;
floating_control->resize(floating_control->width(), new_height);
}
