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());
}
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;
}
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);
}
QSize TrayIcon::sizeHint() const
{
QMargins margins = contentsMargins();
return QSize(margins.left() + mIconSize.width() + margins.right(),
margins.top() + mIconSize.height() + margins.bottom()
);
}
void LineEdit::paintEvent(QPaintEvent* event)
{
QLineEdit::paintEvent(event);
if(hasIcon()) {
QPainter painter(this);
painter.drawPixmap(3, 2, icon_);
}
QPainter painter(this);
QFontMetrics fm(font());
QMargins margins = textMargins();
if(!prefix_.isEmpty()) {
int x = margins.left() - fm.width(prefix_) + 4;
int y = margins.top() + fm.height();
painter.setPen(prefixColor_);
painter.drawText(x, y, prefix_);
}
if(!suffix_.isEmpty()) {
int x = width() - margins.right();
int y = margins.top() + fm.height();
painter.setPen(suffixColor_);
painter.drawText(x, y, suffix_);
}
}
void LineEdit::setRightIcon(const QPixmap & icon)
{
rightIcon_ = icon;
QMargins margins = textMargins();
margins.setRight(icon.width() + 6);
setTextMargins(margins);
}
void Map::adjustDrawMargins(const QMargins &margins) {
mDrawMargins = maxMargins(QMargins(margins.left(),
margins.top() - mTileHeight,
margins.right() - mTileWidth,
margins.bottom()),
mDrawMargins);
}
void LineEdit::setLeftIcon(const QPixmap & icon)
{
leftIcon_ = icon;
QMargins margins = textMargins();
margins.setLeft(icon.width() + 2);
setTextMargins(margins);
}
BaseToolBar::BaseToolBar(const QString& title, QWidget* parent) : QToolBar(title, parent) {
// Update right margin of filter textbox.
QMargins margins = contentsMargins();
margins.setRight(margins.right() + FILTER_RIGHT_MARGIN);
setContentsMargins(margins);
}
void KWidget::setMargins( const QMargins& m )
{
QGraphicsLayout *tmpLayout = layout();
if(tmpLayout == NULL)
return;
tmpLayout->setContentsMargins(m.left(), m.top(), m.right(), m.bottom());
}
void HGLayout::setMargins(const QMargins& m)
{
if (layout()) {
layout()->setContentsMargins(m.left(), m.top(), m.right(), m.bottom());
}
HLayout::setMargins(m);
}
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;
}
QRect WWidgetGroup::layoutContentsMargins() const {
QLayout* pLayout = layout();
QMargins margins = pLayout ? pLayout->contentsMargins() :
contentsMargins();
return QRect(margins.left(), margins.top(),
margins.right(), margins.bottom());
}
void DragTool::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton) {
const QMargins margins = contentsMargins();
const QRect iconRect((width() - d->iconSize.width()) / 2, margins.top(),
d->iconSize.width(), d->iconSize.height());
if (iconRect.contains(event->pos())) {
auto drag = new QDrag(this);
auto mimeData = new QMimeData;
QByteArray data;
QDataStream dataStream(&data, QIODevice::WriteOnly);
dataStream << d->newElementId << d->title << d->stereotype;
mimeData->setData(QLatin1String(qmt::MIME_TYPE_NEW_MODEL_ELEMENTS), data);
drag->setMimeData(mimeData);
QPixmap pixmap = d->icon.pixmap(d->iconSize, QIcon::Normal, QIcon::Off);
QPainter painter(&pixmap);
painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
painter.fillRect(pixmap.rect(), QColor(0, 0, 0, 96));
drag->setPixmap(pixmap);
drag->setHotSpot(QPoint(drag->pixmap().width() / 2, drag->pixmap().height() / 2));
d->disableFrame = true;
update();
Qt::DropAction dropAction = drag->exec();
Q_UNUSED(dropAction);
d->disableFrame = false;
update();
}
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent)
{
setupUi(this);
// add the settings slide out panel
controlPanel = new ControlPanel(this->centralWidget());
QMargins mainMargins = m_verticalLayout->contentsMargins();
controlPanel->setLeftMargin(mainMargins.left());
//show the controlPanel
controlPanel->show();
// slide this panel to the top
controlPanel->collapse();
// make sure there is enough room for the controls
int minWidth = controlPanel->frameGeometry().width();
if( minWidth > m_mainSplitter->minimumWidth())
m_mainSplitter->setMinimumWidth(minWidth);
// make sure there is enough space for the collapsed panel
// above all other widgets
int hHeight = controlPanel->hiddenHeight();
qDebug() << Q_FUNC_INFO << "calculated height: " << hHeight;
mainMargins.setTop(hHeight);
m_verticalLayout->setContentsMargins(mainMargins);
m_mainSplitter->installEventFilter(this);
}
void NMarginsPrototype::fromScriptValue(const QScriptValue &obj, QMargins &m)
{
m.setBottom(obj.property("bottom").toInt32());
m.setLeft(obj.property("left").toInt32());
m.setRight(obj.property("right").toInt32());
m.setTop(obj.property("top").toInt32());
}
void DragTool::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QMargins margins = contentsMargins();
QPixmap pixmap = d->icon.pixmap(d->iconSize, isEnabled() ? QIcon::Normal : QIcon::Disabled, QIcon::Off);
QPainter painter(this);
QRect targetRect((width() - pixmap.width()) / 2,
margins.top() + (d->iconSize.height() - pixmap.height()) / 2,
pixmap.width(),
pixmap.height());
QRect sourceRect(0, 0, pixmap.width(), pixmap.height());
painter.drawPixmap(targetRect, pixmap, sourceRect);
QRect textRect = painter.boundingRect(QRect(), Qt::AlignLeft | Qt::TextSingleLine, d->title);
QRect boundingRect(0, d->iconSize.height(), width(), textRect.height());
painter.drawText(boundingRect, Qt::AlignHCenter | Qt::TextSingleLine, d->title);
// draw a weak frame if mouse is inside widget
if (!d->disableFrame && rect().contains(QWidget::mapFromGlobal(QCursor::pos()))) {
QRect rect(0, 0, width() - 1, height() - 1);
QPen pen = painter.pen();
pen.setStyle(Qt::DotLine);
painter.setPen(pen);
painter.drawRect(rect);
d->framePainted = true;
} else {
d->framePainted = false;
}
}
void BackgroundWidget::expandMainWidget()
{
mMainLayout.setContentsMargins(0, 0, 0, 0);
QMargins margins = mDefaultMargins;
margins.setBottom(0);
mStatusBarLayout.setContentsMargins(margins);
}
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();
}
void FancyLineEdit::setSide(Side side)
{
m_d->m_side = side;
Side iconpos = side;
if (layoutDirection() == Qt::RightToLeft)
iconpos = (side == Left ? Right : Left);
// Make room for icon
// Let the style determine minimum height for our widget
QSize size(ICONBUTTON_SIZE + 6, ICONBUTTON_SIZE + 2);
// Note KDE does not reserve space for the highlight color
if (style()->inherits("OxygenStyle")) {
size = size.expandedTo(QSize(24, 0));
}
QMargins margins;
if (iconpos == Right)
margins.setRight(size.width());
else
margins.setLeft(size.width());
setTextMargins(margins);
}
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());
}
void ClipboardBrowser::updateEditorGeometry()
{
if ( editing() ) {
const QRect contents = viewport()->contentsRect();
const QMargins margins = contentsMargins();
m_editor->setGeometry( contents.translated(margins.left(), margins.top()) );
}
}
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());
}
QMargins
DpiScaler::scaled( const QMargins& margins ) const
{
return scaled( margins.left(),
margins.top(),
margins.right(),
margins.bottom() );
}
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 QWindowsBackingStore::flushDp(QWindow *window, const QRect &br, const QPoint &offset)
{
Q_ASSERT(window);
if (QWindowsContext::verbose > 1)
qCDebug(lcQpaBackingStore) << __FUNCTION__ << this << window << offset << br;
QWindowsWindow *rw = QWindowsWindow::baseWindowOf(window);
#ifndef Q_OS_WINCE
const bool hasAlpha = rw->format().hasAlpha();
const Qt::WindowFlags flags = window->flags();
if ((flags & Qt::FramelessWindowHint) && QWindowsWindow::setWindowLayered(rw->handle(), flags, hasAlpha, rw->opacity()) && hasAlpha) {
// Windows with alpha: Use blend function to update.
const QMargins marginsDP = rw->frameMarginsDp();
const QRect r = rw->geometryDp() + marginsDP;
const QPoint frameOffset(marginsDP.left(), marginsDP.top());
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (BYTE)(255.0 * rw->opacity()), AC_SRC_ALPHA};
if (QWindowsContext::user32dll.updateLayeredWindowIndirect) {
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, m_image->hdc(), &ptSrc, 0, &blend, ULW_ALPHA, &dirty};
QWindowsContext::user32dll.updateLayeredWindowIndirect(rw->handle(), &info);
} else {
QWindowsContext::user32dll.updateLayeredWindow(rw->handle(), NULL, &ptDst, &size, m_image->hdc(), &ptSrc, 0, &blend, ULW_ALPHA);
}
} else {
#endif
const HDC dc = rw->getDC();
if (!dc) {
qErrnoWarning("%s: GetDC failed", __FUNCTION__);
return;
}
if (!BitBlt(dc, br.x(), br.y(), br.width(), br.height(),
m_image->hdc(), br.x() + offset.x(), br.y() + offset.y(), SRCCOPY)) {
const DWORD lastError = GetLastError(); // QTBUG-35926, QTBUG-29716: may fail after lock screen.
if (lastError != ERROR_SUCCESS && lastError != ERROR_INVALID_HANDLE)
qErrnoWarning(lastError, "%s: BitBlt failed", __FUNCTION__);
}
rw->releaseDC();
#ifndef Q_OS_WINCE
}
#endif
// Write image for debug purposes.
if (QWindowsContext::verbose > 2 && lcQpaBackingStore().isDebugEnabled()) {
static int n = 0;
const QString fileName = QString::fromLatin1("win%1_%2.png").
arg(rw->winId()).arg(n++);
m_image->image().save(fileName);
qCDebug(lcQpaBackingStore) << "Wrote " << m_image->image().size() << fileName;
}
}
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;
}
void QWaylandShellSurface::setNormal()
{
if (m_fullscreen || m_maximized) {
m_fullscreen = m_maximized = false;
setTopLevel();
QMargins m = m_window->frameMargins();
m_window->configure(0, m_size.width() + m.left() + m.right(), m_size.height() + m.top() + m.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())
};
}
