int QPrinter::metric( int m ) const
{
int val;
PageSize s = pageSize();
#if defined(CHECK_RANGE)
ASSERT( (uint)s < (uint)NPageSize );
#endif
static int widths[] = { 595, 516, 612, 612, 541,
2384, 1684, 1191, 842, 420, 297, 210, 148, 105,
2920, 2064, 91, 1460, 1032, 729, 516, 363, 258,
181, 127, 461, 297, 312, 595, 1224, 792 };
static int heights[] = { 842, 729, 792, 1009, 720,
3370, 2384, 1684, 1191, 595, 420, 297, 210, 148,
4127, 2920, 127, 2064, 1460, 1032, 729, 516, 363,
258, 181, 648, 684, 624, 935, 792, 1224 };
switch ( m ) {
case QPaintDeviceMetrics::PdmWidth:
val = orient == Portrait ? widths[ s ] : heights[ s ];
if ( !fullPage() )
val -= 2*margins().width();
break;
case QPaintDeviceMetrics::PdmHeight:
val = orient == Portrait ? heights[ s ] : widths[ s ];
if ( !fullPage() )
val -= 2*margins().height();
break;
case QPaintDeviceMetrics::PdmDpiX:
val = 72;
break;
case QPaintDeviceMetrics::PdmDpiY:
val = 72;
break;
case QPaintDeviceMetrics::PdmWidthMM:
val = metric( QPaintDeviceMetrics::PdmWidth );
val = (val * 254 + 360) / 720; // +360 to get the right rounding
break;
case QPaintDeviceMetrics::PdmHeightMM:
val = metric( QPaintDeviceMetrics::PdmHeight );
val = (val * 254 + 360) / 720;
break;
case QPaintDeviceMetrics::PdmNumColors:
val = 16777216;
break;
case QPaintDeviceMetrics::PdmDepth:
val = 24;
break;
default:
val = 0;
#if defined(CHECK_RANGE)
qWarning( "QPixmap::metric: Invalid metric command" );
#endif
}
return val;
}
void stack_layout::layout_items(const point& aPosition, const size& aSize)
{
if (!enabled())
return;
owner()->layout_items_started();
next_layout_id();
for (auto& item : items())
{
if (!item.visible())
continue;
item.layout(aPosition + margins().top_left(), aSize - margins().size());
}
owner()->layout_items_completed();
}
void IntervalProgressDisplay::EllipticalPaintStrategy::paint(QPainter &p, const PaintContext &context, const PaintColors &colors)
{
qreal margin = context.elementsSize + 4;
QRectF rect = createContextRect(context, margin);
if (context.beatsPerInterval <= 32) {
drawCircles(p, rect, context, colors, context.beatsPerInterval, 0, true);// draw a ellipse
} else {
int elementsInOuterEllipse = context.beatsPerInterval / 2;
int elementsInNestedEllipse = context.beatsPerInterval - elementsInOuterEllipse;
//draw the internal circles first, so external circles will appear in top
qreal margin = context.elementsSize * 1.8;
QMarginsF margins(margin, margin, margin, margin);
bool drawPath = context.currentBeat >= elementsInOuterEllipse;
drawCircles(p, rect.marginsRemoved(margins), context, colors, elementsInNestedEllipse, elementsInOuterEllipse, drawPath);
//draw external circles
if (context.currentBeat < elementsInOuterEllipse){ //only draw the external circles when playing the first part of interval
drawCircles(p, rect, context, colors, elementsInOuterEllipse, 0, true);
}
}
drawCurrentBeatValue(p, rect, context, colors);
}
MainPanel::MainPanel(QWidget *parent) : QWidget(parent)
{
QVBoxLayout* layout = new QVBoxLayout;
layout->addWidget(m_two = new TwoPanel(this));
layout->addWidget(m_line = new CommandLine(this, this));
layout->addWidget(m_buttons = new CommandButtons(this));
// Setup sizePolicy
m_two->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
m_line->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
m_two->selectPanel(TwoPanel::PANEL_LEFT);
//
QMargins margins(0, 0, 0, 0);
m_two->setContentsMargins(margins);
m_line->setContentsMargins(margins);
m_buttons->setContentsMargins(margins);
layout->setMargin(0);
setLayout(layout);
connect(m_buttons, SIGNAL(pushButtonSignal(int)), this, SLOT(pressButtonSlot(int)));
}
bool QWaylandMaterialDecoration::handleTouch(QWaylandInputDevice *inputDevice, const QPointF &local,
const QPointF &global, Qt::TouchPointState state,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(inputDevice);
Q_UNUSED(global);
Q_UNUSED(mods);
bool handled = state == Qt::TouchPointPressed;
if (handled) {
if (closeButtonRect().contains(local))
QWindowSystemInterface::handleCloseEvent(window());
else if (maximizeButtonRect().contains(local))
window()->setWindowState(waylandWindow()->isMaximized() ? Qt::WindowNoState
: Qt::WindowMaximized);
else if (minimizeButtonRect().contains(local))
window()->setWindowState(Qt::WindowMinimized);
else if (local.y() <= margins().top())
waylandWindow()->shellSurface()->move(inputDevice);
else
handled = false;
}
return handled;
}
QPoint SubMenu::popupPosition(QQuickItem* item, const QSize& size)
{
if (!item || !item->window()) {
return QPoint(0, 0);
}
QPointF pos = item->mapToScene(QPointF(0, 0));
pos = item->window()->mapToGlobal(pos.toPoint());
pos.setX(pos.x() + m_offset + item->width());
QRect avail = availableScreenRectForItem(item);
if (pos.x() + size.width() > avail.right()) {
pos.setX(pos.x() - m_offset - item->width() - size.width());
m_facingLeft = true;
emit facingLeftChanged();
}
pos.setY(pos.y() - margins()->property("top").toInt());
if (pos.y() + size.height() > avail.bottom()) {
int overshoot = std::ceil(((avail.bottom() - (pos.y() + size.height())) * -1) / item->height()) * item->height();
pos.setY(pos.y() - overshoot);
}
return pos.toPoint();
}
rSize ruiLinearLayout::LayoutVertical(rRect& rect, bool setPosition){
rSize layoutSize(0, 0);
rSize currentItemSize(0, 0);
ruiWidget* widget = nullptr;
rPoint contentOffset = ContentOffset();
rPoint layoutPos(rect.x + contentOffset.x, rect.y + contentOffset.y);
rIntArray margins(4);
for (size_t i = 0; i < m_layoutItems.size(); i++){
widget = m_layoutItems[i];
DetermineMargins(widget, margins);
rPoint finalPosition = layoutPos;
finalPosition.x += margins[ruiMARGIN_LEFT];
finalPosition.y += margins[ruiMARGIN_TOP];
if (setPosition)
widget->SetPosition(finalPosition);
currentItemSize = widget->Size();
layoutSize.x = std::max(layoutSize.x, currentItemSize.x + margins[ruiMARGIN_LEFT] + margins[ruiMARGIN_RIGHT]);
layoutSize.y += currentItemSize.y + margins[ruiMARGIN_TOP] + margins[ruiMARGIN_BOTTOM];
layoutPos.y += currentItemSize.y + margins[ruiMARGIN_TOP] + margins[ruiMARGIN_BOTTOM];
}
return layoutSize;
}
void QSGDefaultGlyphNode::update()
{
QRawFont font = m_glyphs.rawFont();
QMargins margins(0, 0, 0, 0);
if (m_style == QQuickText::Normal) {
m_material = new QSGTextMaskMaterial(font);
} else if (m_style == QQuickText::Outline) {
QSGOutlinedTextMaterial *material = new QSGOutlinedTextMaterial(font);
material->setStyleColor(m_styleColor);
m_material = material;
margins = QMargins(1, 1, 1, 1);
} else {
QSGStyledTextMaterial *material = new QSGStyledTextMaterial(font);
if (m_style == QQuickText::Sunken) {
material->setStyleShift(QVector2D(0, -1));
margins.setTop(1);
} else if (m_style == QQuickText::Raised) {
material->setStyleShift(QVector2D(0, 1));
margins.setBottom(1);
}
material->setStyleColor(m_styleColor);
m_material = material;
}
m_material->setColor(m_color);
QRectF boundingRect;
m_material->populate(m_position, m_glyphs.glyphIndexes(), m_glyphs.positions(), geometry(),
&boundingRect, &m_baseLine, margins);
setBoundingRect(boundingRect);
setMaterial(m_material);
markDirty(DirtyGeometry);
}
size stack_layout::minimum_size(const optional_size& aAvailableSpace) const
{
if (items_visible() == 0)
return size{};
size result;
for (const auto& item : items())
{
result.cx = std::max(result.cx, item.minimum_size(aAvailableSpace).cx);
result.cy = std::max(result.cy, item.minimum_size(aAvailableSpace).cy);
}
result.cx += (margins().left + margins().right);
result.cy += (margins().top + margins().bottom);
result.cx = std::max(result.cx, layout::minimum_size(aAvailableSpace).cx);
result.cy = std::max(result.cy, layout::minimum_size(aAvailableSpace).cy);
return result;
}
void MultilineTextEdit::adjustHeight() {
qreal textHeight =
glm::clamp(static_cast<int>(document()->size().height()), minLineCount_, maxLineCount_) *
lineHeight_;
QMargins margins(contentsMargins());
setFixedHeight(static_cast<int>(textHeight + margins.top() + margins.bottom()));
}
glm::uvec2 Indigo::NinePatch::min_size() const
{
glm::uvec2 margins(m_margins.x + m_margins.z,m_margins.y + m_margins.w);
glm::uvec2 borders(m_info->m_borders.x + m_info->m_borders.z,m_info->m_borders.y + m_info->m_borders.w);
return glm::max(margins,borders);
}
QMargins MarginsEditingWidget::margins() const
{
QMargins margins(ui->leftMarginSpinBox->value(),
ui->topMarginSpinBox->value(),
ui->rightMarginSpinBox->value(),
ui->bottomMarginSpinBox->value());
return margins;
}
bool ORPrintRender::render(ORODocument * pDocument)
{
if(pDocument == 0 || _printer == 0)
return false;
_printer->setFullPage(true);
bool deleteWhenComplete = false;
bool endWhenComplete = false;
QPainter localPainter;
if(_painter == 0)
{
deleteWhenComplete = true;
_painter = &localPainter;
}
if(!_painter->isActive())
{
endWhenComplete = true;
if(!_painter->begin(_printer))
return false;
}
qreal xDpi = _printer->logicalDpiX();
qreal yDpi = _printer->logicalDpiY();
int fromPage = _printer->fromPage();
if(fromPage > 0)
fromPage -= 1;
int toPage = _printer->toPage();
if(toPage == 0 || toPage > pDocument->pages())
toPage = pDocument->pages();
for(int copy = 0; copy < _printer->numCopies(); copy++)
{
for(int page = fromPage; page < toPage; page++)
{
if(page > 0)
_printer->newPage();
int pageToPrint = page;
if(_printer->pageOrder() == QPrinter::LastPageFirst)
pageToPrint = toPage - 1 - page;
QSize margins(_printer->paperRect().left() - _printer->pageRect().left(), _printer->paperRect().top() - _printer->pageRect().top());
renderPage(pDocument, pageToPrint, _painter, xDpi, yDpi, margins, _printer->resolution());
}
}
if(endWhenComplete)
_painter->end();
if(deleteWhenComplete)
_painter = 0;
return true;
}
void Margins::set(double lr, double tpr, double btr, double rr)
{
MarginStruct margins(tpr, lr, btr, rr);
ScCore->primaryMainWindow()->doc->resetPage(ScCore->primaryMainWindow()->doc->pagePositioning(), &margins);
ScCore->primaryMainWindow()->view->reformPages();
ScCore->primaryMainWindow()->doc->setModified(true);
ScCore->primaryMainWindow()->view->GotoPage(ScCore->primaryMainWindow()->doc->currentPageNumber());
ScCore->primaryMainWindow()->view->DrawNew();
}
size stack_layout::maximum_size(const optional_size& aAvailableSpace) const
{
size result{ std::numeric_limits<size::dimension_type>::max(), std::numeric_limits<size::dimension_type>::max() };
for (const auto& item : items())
{
result.cx = std::min(result.cx, item.maximum_size(aAvailableSpace).cx);
result.cy = std::min(result.cy, item.maximum_size(aAvailableSpace).cy);
}
if (result.cx != std::numeric_limits<size::dimension_type>::max())
result.cx += (margins().left + margins().right);
if (result.cy != std::numeric_limits<size::dimension_type>::max())
result.cy += (margins().top + margins().bottom);
if (result.cx != std::numeric_limits<size::dimension_type>::max())
result.cx = std::min(result.cx, layout::maximum_size(aAvailableSpace).cx);
if (result.cy != std::numeric_limits<size::dimension_type>::max())
result.cy = std::min(result.cy, layout::maximum_size(aAvailableSpace).cy);
return result;
}
void
TagDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
{
QPen p( Qt::NoPen );
QBrush b( Qt::NoBrush );
int alpha = 255;
float tagRelevance = index.data( PlaydarTagCloudModel::RelevanceRole ).value<float>() * 0.8;
QColor bc(54,115,213);
QColor borderColor = bc;
bc.setAlphaF( tagRelevance * 0.5 );
borderColor.setAlphaF( tagRelevance );
b = QBrush( bc );
p = QPen( borderColor );
QColor const dark = option.palette.color( QPalette::Highlight ).darker();
if( option.state & (QStyle::State_Selected | QStyle::State_Active) )
{
b = option.state & QStyle::State_Enabled
? option.palette.highlight()
: QColor(0x64, 0x64, 0x64, alpha );
}
if( option.state & QStyle::State_MouseOver )
p = option.palette.color( QPalette::Highlight );
if( option.state & QStyle::State_Active )
p = dark;
p.setWidth( 3 );
painter->setPen( p );
painter->setBrush( b );
painter->setRenderHint( QPainter::Antialiasing, true );
painter->drawRoundedRect( option.rect.adjusted( 2, 2, -2, -2 ), 5.0f, 5.0f );
const float weight = index.data( PlaydarTagCloudModel::LinearWeightRole ).value<float>();
painter->setFont( font( option.font, weight ) );
painter->setRenderHint( QPainter::Antialiasing, false );
QColor textColor = option.state & (QStyle::State_Selected|QStyle::State_Active)
? option.palette.color( QPalette::HighlightedText )
: option.palette.color( QPalette::Text );
textColor.setAlpha( alpha );
painter->setPen( textColor );
QString const text = index.data().toString();
QFontMetrics const metrics = painter->fontMetrics();
QPoint pt;
pt.setX( option.rect.x() + (option.rect.width() - metrics.width( text ))/2 );
pt.setY( option.rect.y() + margins( weight ).height()/2 + metrics.ascent() );
painter->drawText( pt, text );
}
void QWaylandMaterialDecoration::processMouseBottom(QWaylandInputDevice *inputDevice,
const QPointF &local, Qt::MouseButtons b,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(mods);
if (local.x() <= margins().left()) {
// bottom left bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SizeBDiagCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT, b);
} else if (local.x() > window()->width() - margins().right()) {
// bottom right bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SizeFDiagCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT, b);
} else {
// bottom bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SplitVCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_BOTTOM, b);
}
}
QSize
TagDelegate::sizeHint( const QStyleOptionViewItem& option, const QModelIndex& index ) const
{
const float weight = index.data( PlaydarTagCloudModel::LinearWeightRole ).value<float>();
QFontMetrics fm( font( option.font, weight ) );
const QSize margin = margins( weight );
gBaseline = margin.height()/2 + fm.ascent();
gLeftMargin = margin.width()/2;
return fm.size( Qt::TextSingleLine, index.data().toString() ) + margin;
}
QSize QPrinter::margins() const
{
uint t, l, r, b;
// If the printer is not active, we need to flip the values for the landscape case.
margins(&t, &l, &r, &b);
if (state == PST_ACTIVE || orientation() == Portrait)
return QSize(t, l);
else
return QSize(r, t);
}
bool QWaylandMaterialDecoration::handleMouse(QWaylandInputDevice *inputDevice, const QPointF &local,
const QPointF &global, Qt::MouseButtons b,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(global);
// Figure out what area mouse is in
if (closeButtonRect().contains(local)) {
if (clickButton(b, Close))
QWindowSystemInterface::handleCloseEvent(window());
} else if (maximizeButtonRect().contains(local)) {
if (clickButton(b, Maximize))
window()->setWindowState(waylandWindow()->isMaximized() ? Qt::WindowNoState
: Qt::WindowMaximized);
} else if (minimizeButtonRect().contains(local)) {
if (clickButton(b, Minimize))
window()->setWindowState(Qt::WindowMinimized);
} else if (local.y() <= margins().top()) {
processMouseTop(inputDevice, local, b, mods);
} else if (local.y() > window()->height() - margins().bottom() + margins().top()) {
processMouseBottom(inputDevice, local, b, mods);
} else if (local.x() <= margins().left()) {
processMouseLeft(inputDevice, local, b, mods);
} else if (local.x() > window()->width() - margins().right() + margins().left()) {
processMouseRight(inputDevice, local, b, mods);
} else {
waylandWindow()->restoreMouseCursor(inputDevice);
setMouseButtons(b);
return false;
}
setMouseButtons(b);
return true;
}
void PartResizerWidget::updatePositions()
{
QMargins margins(contentsMargins());
partWidget().move(partWidgetStart() + margins.left(), margins.top());
partWidget().resize(partWidgetWidth() - margins.left() - margins.right(), height() - margins.top() - margins.bottom());
leftHandle().move(partWidgetStart() - leftHandle().width(), 0);
rightHandle().move(partWidgetStart() + partWidgetWidth(), 0);
partWidget().update();
}
void KatePrinter::writeSettings(QPrinter& printer)
{
KSharedConfigPtr config = KGlobal::config();
KConfigGroup group(config, "Kate Print Settings");
KConfigGroup margins(&group, "Margins");
qreal left, right, top, bottom;
printer.getPageMargins(&left, &top, &right, &bottom, QPrinter::Millimeter);
margins.writeEntry( "left", left);
margins.writeEntry( "top", top);
margins.writeEntry( "right", right);
margins.writeEntry( "bottom", bottom);
}
void GameLoader::initializeObject(const QDomElement& element, AnimatedObject* object)
{
QSize size(element.attribute("width").toUInt(), element.attribute("height").toUInt());
double velocity = element.attribute("velocity").toDouble();
object->setSize(size);
object->setVelocity(velocity);
QDomElement marginsElement = element.firstChildElement("margins");
QMargins margins(marginsElement.attribute("left").toInt(), marginsElement.attribute("top").toInt(), marginsElement.attribute("right").toInt(), marginsElement.attribute("bottom").toInt());
object->setMargins(margins);
initializeAnimation(element.firstChildElement("animation"), object->animation());
}
Float log_exp_corpus_stats(corpus_type *c, const Float w[], Float dL_dw[],
Float *sum_g, Float *sum_p, Float *sum_w)
{
size_type n = c->nloserparses;
Float *m = MALLOC(n*sizeof(Float));
Float L, Lm = 0, min_m;
int i, j, k, mi;
assert(m != NULL);
for (k = 0; k < c->nfeatures; ++k) /* zero dL_dw[] */
dL_dw[k] = 0;
min_m = margins(c, w, m, sum_g, sum_p, sum_w);
for (mi = 0; mi < n; ++mi)
Lm += exp(min_m - m[mi]);
L = log(Lm) - min_m;
/* compute dL/dw */
mi = 0;
for (i = 0; i < c->nsentences; ++i) {
sentence_type *s = &c->sentence[i];
if (s->Px > 0) {
Float c_sum = 0;
for (j = 0; j < s->nparses; ++j)
if (j != s->correct_index) {
Float c = exp(min_m - m[mi++])/Lm;
c_sum += c;
for (k = 0; k < s->parse[j].nf; ++k) /* 1 count features */
dL_dw[s->parse[j].f[k]] += c;
for (k = 0; k < s->parse[j].nfc; ++k) /* arbitrary count features */
dL_dw[s->parse[j].fc[k].f] += c * s->parse[j].fc[k].c;
}
for (k = 0; k < s->parse[s->correct_index].nf; ++k)
dL_dw[s->parse[s->correct_index].f[k]] -= c_sum;
for (k = 0; k < s->parse[s->correct_index].nfc; ++k)
dL_dw[s->parse[s->correct_index].fc[k].f]
-= c_sum * s->parse[s->correct_index].fc[k].c;
}
}
assert(mi == n);
FREE(m);
return L;
} /* log_exp_corpus_stats() */
void QWaylandMaterialDecoration::processMouseTop(QWaylandInputDevice *inputDevice,
const QPointF &local, Qt::MouseButtons b,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(mods);
if (local.y() <= margins().bottom()) {
if (local.x() <= margins().left()) {
// top left bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SizeFDiagCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_TOP_LEFT, b);
} else if (local.x() > window()->width() - margins().right()) {
// top right bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SizeBDiagCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_TOP_RIGHT, b);
} else {
// top reszie bit
waylandWindow()->setMouseCursor(inputDevice, Qt::SplitVCursor);
startResize(inputDevice, WL_SHELL_SURFACE_RESIZE_TOP, b);
}
} else {
waylandWindow()->restoreMouseCursor(inputDevice);
startMove(inputDevice, b);
}
}
PyObject *scribus_setmargins(PyObject* /* self */, PyObject* args)
{
double lr, tpr, btr, rr;
if (!PyArg_ParseTuple(args, "dddd", &lr, &rr, &tpr, &btr))
return NULL;
if(!checkHaveDocument())
return NULL;
MarginStruct margins(ValueToPoint(tpr), ValueToPoint(lr), ValueToPoint(btr), ValueToPoint(rr));
ScCore->primaryMainWindow()->doc->resetPage(margins, ScCore->primaryMainWindow()->doc->currentPageLayout);
ScCore->primaryMainWindow()->view->reformPages();
ScCore->primaryMainWindow()->doc->setModified(true);
ScCore->primaryMainWindow()->view->GotoPage(ScCore->primaryMainWindow()->doc->currentPageNumber());
ScCore->primaryMainWindow()->view->DrawNew();
// Py_INCREF(Py_None);
// return Py_None;
Py_RETURN_NONE;
}
QRectF
ConnectionGeometry::
boundingRect() const
{
auto points = pointsC1C2();
QRectF basicRect(_out, _in);
QRectF c1c2Rect(points.first, points.second);
QMargins margins(_pointDiameter,
_pointDiameter,
_pointDiameter,
_pointDiameter);
return basicRect.united(c1c2Rect).marginsAdded(margins);
}
void QDeclarativeBorderImage::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
{
Q_D(QDeclarativeBorderImage);
if (d->pix.isNull() || d->width() <= 0.0 || d->height() <= 0.0)
return;
bool oldAA = p->testRenderHint(QPainter::Antialiasing);
bool oldSmooth = p->testRenderHint(QPainter::SmoothPixmapTransform);
QTransform oldTransform;
if (d->smooth)
p->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, d->smooth);
if (d->mirror) {
oldTransform = p->transform();
QTransform mirror;
mirror.translate(d->width(), 0).scale(-1, 1.0);
p->setWorldTransform(mirror * oldTransform);
}
const QDeclarativeScaleGrid *border = d->getScaleGrid();
int left = border->left();
int right = border->right();
qreal borderWidth = left + right;
if (borderWidth > 0.0 && d->width() < borderWidth) {
qreal diff = borderWidth - d->width() - 1;
left -= qRound(diff * qreal(left) / borderWidth);
right -= qRound(diff * qreal(right) / borderWidth);
}
int top = border->top();
int bottom = border->bottom();
qreal borderHeight = top + bottom;
if (borderHeight > 0.0 && d->height() < borderHeight) {
qreal diff = borderHeight - d->height() - 1;
top -= qRound(diff * qreal(top) / borderHeight);
bottom -= qRound(diff * qreal(bottom) / borderHeight);
}
QMargins margins(left, top, right, bottom);
QTileRules rules((Qt::TileRule)d->horizontalTileMode, (Qt::TileRule)d->verticalTileMode);
qDrawBorderPixmap(p, QRect(0, 0, (int)d->width(), (int)d->height()), margins, d->pix, d->pix.rect(), margins, rules);
if (d->smooth) {
p->setRenderHint(QPainter::Antialiasing, oldAA);
p->setRenderHint(QPainter::SmoothPixmapTransform, oldSmooth);
}
if (d->mirror)
p->setWorldTransform(oldTransform);
}
void FancyLineEdit::updateMargins() {
bool leftToRight = (layoutDirection() == Qt::LeftToRight);
Side realLeft = (leftToRight ? Left : Right);
Side realRight = (leftToRight ? Right : Left);
int leftMargin = d->m_iconbutton[realLeft]->pixmap().width() + 8;
int rightMargin = d->m_iconbutton[realRight]->pixmap().width() + 8;
// Note KDE does not reserve space for the highlight color
if (style()->inherits("OxygenStyle")) {
leftMargin = qMax(24, leftMargin);
rightMargin = qMax(24, rightMargin);
}
QMargins margins((d->m_iconEnabled[realLeft] ? leftMargin : 0), 0,
(d->m_iconEnabled[realRight] ? rightMargin : 0), 0);
setTextMargins(margins);
}
PyObject *scribus_setmargins(PyObject* /* self */, PyObject* args)
{
double lr, tpr, btr, rr;
if (!PyArg_ParseTuple(args, "dddd", &lr, &rr, &tpr, &btr))
return nullptr;
if (!checkHaveDocument())
return nullptr;
MarginStruct margins(ValueToPoint(tpr), ValueToPoint(lr), ValueToPoint(btr), ValueToPoint(rr));
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
ScribusView* currentView = ScCore->primaryMainWindow()->view;
currentDoc->resetPage(currentDoc->pagePositioning(), &margins);
currentView->reformPages();
currentDoc->setModified(true);
currentView->GotoPage(currentDoc->currentPageNumber());
currentView->DrawNew();
Py_RETURN_NONE;
}
