void PageItem_PathText::layout()
{
QImage pgPix(10, 10, QImage::Format_ARGB32_Premultiplied);
QRectF rd; // = QRect(0,0,9,9);
ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
DrawObj(painter, rd);
painter->end();
delete painter;
updatePolyClip();
}
QPixmap SampleItem::getSample(int width, int height)
{
// if it's false => the used font will be removed from used fonts
// after sample creating
bool previouslyUsedFont = false;
if (tmpStyle.charStyle().font().isNone())
return QPixmap();
UndoManager::instance()->setUndoEnabled(false); // disable undo
PageItem_TextFrame *previewItem = new PageItem_TextFrame(m_Doc, 0, 0, width, height, 0, "__whiteforpreviewbg__", "__whiteforpreview__");
QImage pm(width, height, QImage::Format_ARGB32);
ScPainter *painter = new ScPainter(&pm, width, height, 1.0, 0);
painter->setZoomFactor(PrefsManager::instance()->appPrefs.displayPrefs.displayScale);
if (m_Doc->UsedFonts.contains(tmpStyle.charStyle().font().scName()))
previouslyUsedFont = true;
m_Doc->AddFont(tmpStyle.charStyle().font().scName(), qRound(m_Doc->itemToolPrefs().textSize / 10.0));
previewItem->FrameType = PageItem::TextFrame;
previewItem->itemText.clear();
// previewItem->setFont(tmpStyle.charStyle().font()->scName());
previewItem->Cols = 1;
text.replace(QChar(10),QChar(13)).replace(QChar(5),QChar(13));
previewItem->itemText.insertChars(0, text);
previewItem->itemText.setDefaultStyle(tmpStyle);
previewItem->setFillColor("__whiteforpreviewbg__");
previewItem->setFillShade(bgShade);
previewItem->SetRectFrame();
previewItem->Frame = false;
previewItem->DrawObj(painter, QRect());
painter->end();
delete(painter);
delete previewItem;
// cleanups and resets
if (!previouslyUsedFont)
{
QString fontName = tmpStyle.charStyle().font().scName();
(*m_Doc->AllFonts)[fontName].decreaseUsage(); // was increased by AddFont()
m_Doc->UsedFonts.remove(fontName);
}
// m_Doc->docParagraphStyles.remove(tmpIndex);
UndoManager::instance()->setUndoEnabled(true);
return QPixmap::fromImage(pm);
}
void ScPattern::createPreview()
{
double sc = 500.0 / qMax(width, height);
bool savedFlag = doc->guidesPrefs().framesShown;
bool savedDoDrawing = doc->DoDrawing;
doc->guidesPrefs().framesShown = false;
doc->DoDrawing = true;
pattern = QImage(qRound(width * sc), qRound(height * sc), QImage::Format_ARGB32_Premultiplied);
pattern.fill( qRgba(0, 0, 0, 0) );
ScPainter *painter = new ScPainter(&pattern, pattern.width(), pattern.height(), 1, 0);
painter->setZoomFactor(sc);
for (int i = 0; i < items.count(); ++i)
{
PageItem* embedded = items.at(i);
painter->save();
painter->translate(embedded->gXpos, embedded->gYpos);
embedded->isEmbedded = true;
embedded->invalid = true;
embedded->DrawObj(painter, QRectF());
embedded->isEmbedded = false;
painter->restore();
}
painter->end();
delete painter;
doc->DoDrawing = savedDoDrawing;
doc->guidesPrefs().framesShown = savedFlag;
}
void ShapeView::updateShapeList()
{
clear();
setWordWrap(true);
for (QHash<QString, shapeData>::Iterator it = m_Shapes.begin(); it != m_Shapes.end(); ++it)
{
int w = it.value().width + 4;
int h = it.value().height + 4;
QImage Ico(w, h, QImage::Format_ARGB32_Premultiplied);
Ico.fill(0);
ScPainter *painter = new ScPainter(&Ico, w, h);
painter->setBrush(qRgb(0, 0, 0));
painter->setPen(qRgb(0, 0, 0), 1.0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
painter->setFillMode(ScPainter::Solid);
painter->setStrokeMode(ScPainter::Solid);
painter->translate(2.0, 2.0);
painter->setupPolygon(&it.value().path);
painter->drawPolygon();
painter->end();
delete painter;
QPixmap pm;
if (w >= h)
pm = QPixmap::fromImage(Ico.scaledToWidth(48, Qt::SmoothTransformation));
else
pm = QPixmap::fromImage(Ico.scaledToHeight(48, Qt::SmoothTransformation));
QPixmap pm2(48, 48);
pm2.fill(palette().color(QPalette::Base));
QPainter p;
p.begin(&pm2);
p.drawPixmap(24 - pm.width() / 2, 24 - pm.height() / 2, pm);
p.end();
QListWidgetItem *item = new QListWidgetItem(pm2, it.value().name, this);
item->setData(Qt::UserRole, it.key());
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
}
}
void GradientPreview::paintEvent(QPaintEvent *e)
{
QList<VColorStop*> cstops = fill_gradient.colorStops();
StopM.clear();
for (uint a = 0; a < fill_gradient.Stops(); ++a)
{
int center = qRound(cstops.at(a)->rampPoint * (width()-20))+10;
StopM.append(center);
}
QImage pixm(width()-20, 37, QImage::Format_ARGB32_Premultiplied);
QPainter pb;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pb.begin(&pixm);
pb.fillRect(0, 0, pixm.width(), pixm.height(), b);
pb.end();
ScPainter *p = new ScPainter(&pixm, width()-20, 37);
// p->clear(Qt::white);
p->setPen(Qt::black);
p->setLineWidth(1);
p->setFillMode(2);
p->fill_gradient = fill_gradient;
p->setGradient(VGradient::linear, FPoint(0,20), FPoint(width()-20,20), FPoint(0, 0), 1.0, 0.0);
p->drawRect(0, 0, width()-20, 37);
p->end();
delete p;
QPainter pw;
pw.begin(this);
pw.drawImage(10, 5, pixm);
if (isEditable)
{
for (uint a = 0; a < fill_gradient.Stops(); ++a)
{
int center = qRound(cstops.at(a)->rampPoint * (width()-20))+10;
pw.setPen(QPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
if (StopM[qMax(ActStop,0)] == center)
pw.setBrush(Qt::red);
else
pw.setBrush(Qt::blue);
QPolygon cr;
cr.setPoints(3, qRound(center), 43, qRound(center-4), 56, qRound(center+4), 56);
pw.drawPolygon(cr);
}
}
pw.end();
QFrame::paintEvent(e);
}
: QDialog( parent, Qt::FramelessWindowHint)
#endif
{
int base = 48;
int size = base + qRound(-face.descent() * base) + 3;
int sizex = size + 2, sizey = size + 20;
resize(sizex, sizey);
setMinimumSize(sizex, sizey);
setMaximumSize(sizex, sizey);
pixm = QPixmap(size, size);
QImage pix(size, size, QImage::Format_ARGB32_Premultiplied);
ScPainter *p = new ScPainter(&pix, size, size);
p->clear();
pixm.fill(Qt::white);
QTransform chma;
chma.scale(4.8, 4.8);
uint gl = face.char2CMap(currentChar);
FPointArray gly = face.glyphOutline(gl);
double ww = size - face.glyphWidth(gl, base);
if (gly.size() > 4)
{
gly.map(chma);
p->translate(ww / 2, 1);
p->setBrush(Qt::black);
p->setFillMode(1);
p->setupPolygon(&gly);
p->fillPath();
p->end();
}
delete p;
pixm=QPixmap::fromImage(pix);
QString tmp;
tmp.sprintf("%04X", currentChar);
valu = "0x"+tmp;
}
void gradientManagerDialog::updateGradientList()
{
gradientsList->clear();
for (QMap<QString, VGradient>::Iterator it = dialogGradients.begin(); it != dialogGradients.end(); ++it)
{
QImage pixm(48, 12, QImage::Format_ARGB32);
QPainter pb;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pb.begin(&pixm);
pb.fillRect(0, 0, 48, 12, b);
pb.end();
ScPainter *p = new ScPainter(&pixm, 48, 12);
p->setPen(Qt::black);
p->setLineWidth(1);
p->setFillMode(2);
p->fill_gradient = it.value();
p->setGradient(VGradient::linear, FPoint(0,6), FPoint(48, 6), FPoint(0, 0), 1.0, 0.0);
p->drawRect(0, 0, 48, 12);
p->end();
delete p;
QPixmap pm;
pm = QPixmap::fromImage(pixm);
QListWidgetItem *item = new QListWidgetItem(pm, it.key(), gradientsList);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
}
if (dialogGradients.count() == 0)
{
buttonRemoveAll->setEnabled(false);
buttonSave->setEnabled(false);
}
else
{
buttonRemoveAll->setEnabled(true);
buttonSave->setEnabled(true);
}
}
QVariant CharTableModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || m_doc == 0)
return QVariant();
int ix = index.row() * m_cols + index.column();
uint currentChar;
QString currentFont = m_fontInUse;
if (ix < m_characters.count())
{
currentChar = m_characters[ix];
currentFont = m_fonts[ix];
}
else
return QVariant();
// for mimeData()
if (role == CharTableModel::CharTextRole)
return QString("%1").arg(QChar(currentChar));
if (role == CharTableModel::CharTextAndFontRole)
return QString("%1#%2").arg(currentChar).arg(currentFont);
// tooltip
if (role == Qt::ToolTipRole)
return QString("Unicode:\n0x%1").arg(currentChar, 4, 16, QChar('0'));
// status tip
if ( role == Qt::StatusTipRole )
{
QString tmp = QString("%1").arg(currentChar, 4, 16, QChar('0')).toUpper();
QStringList lst;
lst << tmp << currentFont;
return lst;
}
// pixmap
if (role == Qt::DecorationRole)
{
// m_cols should not become 0. Never.
int baseSize = m_viewWidth / m_cols;
QTransform chma;
chma.scale(baseSize/10, baseSize/10);
ScFace face = (*m_doc->AllFonts)[currentFont];
uint gl = face.char2CMap(currentChar);
int size = baseSize + qRound(-face.descent() * baseSize) + 1;
double ww = baseSize - face.glyphWidth(gl, baseSize);
QImage pix(baseSize, size, QImage::Format_ARGB32_Premultiplied);
ScPainter *p = new ScPainter(&pix, baseSize, size);
p->clear();
FPointArray gly = face.glyphOutline(gl, 1);
if (gly.size() > 4)
{
gly.map(chma);
p->translate(ww / 2, 1);
p->setBrush(Qt::black);
p->setFillMode(1);
p->setupPolygon(&gly);
p->fillPath();
p->end();
}
delete p;
return QVariant(QPixmap::fromImage(pix));
}
// trash
return QVariant();
}
void ArrowChooser::rebuildList(QList<ArrowDesc> *arrowStyles)
{
clear();
FPointArray Path;
Path.resize(0);
addItem(CommonStrings::tr_None);
for (int a = 0; a < arrowStyles->count(); ++a)
{
QImage image(22, 22, QImage::Format_ARGB32);
ScPainter *painter = new ScPainter(&image, 22, 22);
painter->clear();
painter->setBrush(qRgb(0, 0, 0));
painter->setPen(qRgb(0, 0, 0));
painter->setFillMode(1);
painter->translate(3.0, 3.0);
Path.resize(0);
Path = arrowStyles->at(a).points.copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
QMatrix mm;
QMatrix mm2;
if (arrowDirection)
{
mm2.scale(-1, 1);
mm2.translate(-max.x(), 0);
}
mm.scale(16.0 / qMax(max.x(), max.y()), 16.0 / qMax(max.x(), max.y()));
Path.map(mm2 * mm);
painter->setupPolygon(&Path);
painter->setLineWidth(1.0);
painter->drawPolygon();
painter->drawPolyLine();
painter->end();
delete painter;
int wi = image.width();
int hi = image.height();
for( int yi=0; yi < hi; ++yi )
{
QRgb *s = (QRgb*)(image.scanLine( yi ));
for(int xi=0; xi < wi; ++xi )
{
if((*s) == 0xffffffff)
(*s) &= 0x00ffffff;
s++;
}
}
QPixmap Ico;
Ico=QPixmap::fromImage(image);
addItem(Ico, arrowStyles->at(a).name);
}
}
QString ScriXmlDoc::WriteElem(ScribusDoc *doc, Selection* selection)
{
if (selection->count()==0)
return "";
double xp, yp, wp, hp;
PageItem *item;
QString documentStr = "";
item = selection->itemAt(0);
QList<PageItem*> emG;
QMap<int, PageItem*> emMap;
emG.clear();
for (int cor = 0; cor < selection->count(); ++cor)
{
emMap.insert(doc->Items->indexOf(selection->itemAt(cor)), selection->itemAt(cor));
}
emG = emMap.values();
double selectionWidth = 0;
double selectionHeight = 0;
if (selection->isMultipleSelection())
{
double gx, gy, gw, gh;
selection->getGroupRect(&gx, &gy, &gw, &gh);
xp = gx;
yp = gy;
wp = gw;
hp = gh;
selection->getVisualGroupRect(&gx, &gy, &selectionWidth, &selectionHeight);
}
else
{
double minx = std::numeric_limits<double>::max();
double miny = std::numeric_limits<double>::max();
double maxx = -std::numeric_limits<double>::max();
double maxy = -std::numeric_limits<double>::max();
double x1, x2, y1, y2;
item->getVisualBoundingRect(&x1, &y1, &x2, &y2);
xp = qMin(minx, x1);
yp = qMin(miny, y1);
selectionWidth = wp = qMax(maxx, x2) - xp;
selectionHeight = hp = qMax(maxy, y2) - yp;
}
double scaleI = 50.0 / qMax(selectionWidth, selectionHeight);
QImage retImg = QImage(50, 50, QImage::Format_ARGB32_Premultiplied);
retImg.fill( qRgba(0, 0, 0, 0) );
ScPainter *painter = new ScPainter(&retImg, retImg.width(), retImg.height(), 1, 0);
painter->setZoomFactor(scaleI);
for (int em = 0; em < emG.count(); ++em)
{
PageItem* embedded = emG.at(em);
painter->save();
painter->translate(-xp, -yp);
embedded->invalid = true;
embedded->DrawObj(painter, QRectF());
painter->restore();
}
int pg = doc->OnPage(xp + wp / 2.0, yp + hp / 2.0);
if (pg > -1)
{
xp = xp - doc->getXOffsetForPage(pg);
yp = yp - doc->getYOffsetForPage(pg);
}
delete painter;
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
retImg.save(&buffer, "PNG");
QByteArray ba = buffer.buffer().toBase64();
buffer.close();
const FileFormat *fmt = LoadSavePlugin::getFormatById(FORMATID_SLA150EXPORT);
if (fmt)
{
fmt->setupTargets(doc, 0, doc->scMW(), 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
documentStr = fmt->saveElements(xp, yp, wp, hp, selection, ba);
}
return documentStr;
}
ExtImageProps::ExtImageProps( QWidget* parent, ImageInfoRecord *info, PageItem *item, ScribusView *view )
: QDialog( parent )
{
setModal(true);
setWindowTitle( tr( "Extended Image Properties" ) );
setWindowIcon(QIcon(loadIcon ( "AppIcon.png" )));
ExtImagePropsLayout = new QVBoxLayout( this );
ExtImagePropsLayout->setMargin(6);
ExtImagePropsLayout->setSpacing(6);
viewWidget = view;
currentItem = item;
currentLayer = 0;
originalInfo = *info;
originalImageClip = item->imageClip.copy();
blendModes.clear();
blendModes.insert("norm", tr("Normal"));
blendModes.insert("dark", tr("Darken"));
blendModes.insert("lite", tr("Lighten"));
blendModes.insert("hue ", tr("Hue"));
blendModes.insert("sat ", tr("Saturation"));
blendModes.insert("colr", tr("Color"));
blendModes.insert("lum ", tr("Luminosity"));
blendModes.insert("mul ", tr("Multiply"));
blendModes.insert("scrn", tr("Screen"));
blendModes.insert("diss", tr("Dissolve"));
blendModes.insert("over", tr("Overlay"));
blendModes.insert("hLit", tr("Hard Light"));
blendModes.insert("sLit", tr("Soft Light"));
blendModes.insert("diff", tr("Difference"));
blendModes.insert("smud", tr("Exclusion"));
blendModes.insert("div ", tr("Color Dodge"));
blendModes.insert("idiv", tr("Color Burn"));
blendModesRev.clear();
blendModesRev.insert( tr("Normal"), "norm");
blendModesRev.insert( tr("Darken"), "dark");
blendModesRev.insert( tr("Lighten"), "lite");
blendModesRev.insert( tr("Hue"), "hue ");
blendModesRev.insert( tr("Saturation"), "sat ");
blendModesRev.insert( tr("Color"), "colr");
blendModesRev.insert( tr("Luminosity"), "lum ");
blendModesRev.insert( tr("Multiply"), "mul ");
blendModesRev.insert( tr("Screen"), "scrn");
blendModesRev.insert( tr("Dissolve"), "diss");
blendModesRev.insert( tr("Overlay"), "over");
blendModesRev.insert( tr("Hard Light"), "hLit");
blendModesRev.insert( tr("Soft Light"), "sLit");
blendModesRev.insert( tr("Difference"), "diff");
blendModesRev.insert( tr("Exclusion"), "smud");
blendModesRev.insert( tr("Color Dodge"), "div ");
blendModesRev.insert( tr("Color Burn"), "idiv");
propsTab = new QTabWidget( this );
QPalette palette;
palette.setColor(backgroundRole(), Qt::white);
if (info->layerInfo.count() != 0)
{
tab = new QWidget( propsTab );
tabLayout = new QVBoxLayout( tab );
tabLayout->setMargin(6);
tabLayout->setSpacing(6);
layout1 = new QHBoxLayout;
layout1->setMargin(0);
layout1->setSpacing(6);
textLabel1 = new QLabel( tab );
textLabel1->setText( tr( "Blend Mode:" ) );
layout1->addWidget( textLabel1 );
blendMode = new ScComboBox( tab );
blendMode->clear();
blendMode->addItem( tr("Normal"));
blendMode->addItem( tr("Darken"));
blendMode->addItem( tr("Lighten"));
blendMode->addItem( tr("Hue"));
blendMode->addItem( tr("Saturation"));
blendMode->addItem( tr("Color"));
blendMode->addItem( tr("Luminosity"));
blendMode->addItem( tr("Multiply"));
blendMode->addItem( tr("Screen"));
blendMode->addItem( tr("Dissolve"));
blendMode->addItem( tr("Overlay"));
blendMode->addItem( tr("Hard Light"));
blendMode->addItem( tr("Soft Light"));
blendMode->addItem( tr("Difference"));
blendMode->addItem( tr("Exclusion"));
blendMode->addItem( tr("Color Dodge"));
blendMode->addItem( tr("Color Burn"));
layout1->addWidget( blendMode );
textLabel2 = new QLabel( tab );
textLabel2->setText( tr( "Opacity:" ) );
layout1->addWidget( textLabel2 );
opacitySpinBox = new QSpinBox( tab );
opacitySpinBox->setMinimum(0);
opacitySpinBox->setMaximum(100);
opacitySpinBox->setSingleStep(10);
opacitySpinBox->setSuffix( tr(" %"));
layout1->addWidget( opacitySpinBox );
tabLayout->addLayout( layout1 );
layerTable = new QTableWidget(info->layerInfo.count(), 3, tab );
layerTable->setHorizontalHeaderItem(0, new QTableWidgetItem(QIcon(loadIcon("16/show-object.png")), ""));
layerTable->setHorizontalHeaderItem(1, new QTableWidgetItem(""));
layerTable->setHorizontalHeaderItem(2, new QTableWidgetItem( tr("Name")));
QHeaderView* headerH = layerTable->horizontalHeader();
headerH->setStretchLastSection(true);
headerH->setMovable(false);
headerH->setClickable(false);
if (info->layerInfo.count() == 1)
{
layerTable->setColumnWidth(1, 40);
layerTable->setColumnWidth(0, 24);
}
layerTable->setSortingEnabled(false);
layerTable->setSelectionBehavior( QAbstractItemView::SelectRows );
QHeaderView *Header = layerTable->verticalHeader();
Header->setMovable(false);
Header->setResizeMode(QHeaderView::Fixed);
Header->hide();
FlagsSicht.clear();
int col2Width = 0;
int col1Width = 0;
if (info->layerInfo.count() != 0)
{
if ((info->isRequest) && (info->RequestProps.contains(0)))
{
opacitySpinBox->setValue(qRound(info->RequestProps[0].opacity / 255.0 * 100));
setCurrentComboItem(blendMode, blendModes[info->RequestProps[0].blend]);
}
else
{
opacitySpinBox->setValue(qRound(info->layerInfo[0].opacity / 255.0 * 100));
setCurrentComboItem(blendMode, blendModes[info->layerInfo[0].blend]);
}
opacitySpinBox->setEnabled(true);
blendMode->setEnabled(true);
QString tmp;
QList<PSDLayer>::iterator it2;
uint counter = 0;
for (it2 = info->layerInfo.begin(); it2 != info->layerInfo.end(); ++it2)
{
QCheckBox *cp = new QCheckBox((*it2).layerName, this);
cp->setPalette(palette);
QPixmap pm;
pm=QPixmap::fromImage((*it2).thumb);
col1Width = qMax(col1Width, pm.width());
cp->setIcon(pm);
FlagsSicht.append(cp);
connect(cp, SIGNAL(clicked()), this, SLOT(changedLayer()));
layerTable->setCellWidget(info->layerInfo.count()-counter-1, 0, cp);
if ((info->isRequest) && (info->RequestProps.contains(counter)))
cp->setChecked(info->RequestProps[counter].visible);
else
cp->setChecked(!((*it2).flags & 2));
if (!(*it2).thumb_mask.isNull())
{
QCheckBox *cp2 = new QCheckBox((*it2).layerName, this);
cp2->setPalette(palette);
QPixmap pm2;
pm2=QPixmap::fromImage((*it2).thumb_mask);
col2Width = qMax(col2Width, pm2.width());
cp2->setIcon(pm2);
connect(cp2, SIGNAL(clicked()), this, SLOT(changedLayer()));
layerTable->setCellWidget(info->layerInfo.count()-counter-1, 1, cp2);
if ((info->isRequest) && (info->RequestProps.contains(counter)))
cp2->setChecked(info->RequestProps[counter].useMask);
else
cp2->setChecked(true);
FlagsMask.append(cp2);
}
else
FlagsMask.append(0);
QTableWidgetItem *tW = new QTableWidgetItem((*it2).layerName);
tW->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
layerTable->setItem(info->layerInfo.count()-counter-1, 2, tW);
layerTable->setRowHeight(info->layerInfo.count()-counter-1, 40);
counter++;
}
}
tabLayout->addWidget( layerTable );
layerTable->setColumnWidth(1, 24 + col2Width);
layerTable->setColumnWidth(0, 24 + col1Width);
blendMode->setCurrentIndex(0);
// headerH->setResizeMode(QHeaderView::Fixed);
propsTab->addTab( tab, tr( "Layers" ) );
}
tab_2 = new QWidget( propsTab );
tabLayout_2 = new QVBoxLayout( tab_2 );
tabLayout_2->setMargin(6);
tabLayout_2->setSpacing(6);
pathList = new QListWidget( tab_2 );
pathList->clear();
pathList->setIconSize(QSize(40, 40));
QMap<QString, FPointArray>::Iterator it;
if (info->PDSpathData.count() != 0)
{
for (it = info->PDSpathData.begin(); it != info->PDSpathData.end(); ++it)
{
QImage pixm(40, 40, QImage::Format_ARGB32);
ScPainter *p = new ScPainter(&pixm, 40, 40);
p->clear();
p->translate(3.0, 3.0);
if (it.key() == info->clipPath)
{
pixm.fill(Qt::green);
p->clear(Qt::green);
}
else
pixm.fill(Qt::white);
FPointArray Path;
Path.resize(0);
Path = info->PDSpathData[it.key()].copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
QMatrix mm;
mm.scale(34.0 / qMax(max.x(), max.y()), 34.0 / qMax(max.x(), max.y()));
Path.map(mm);
p->setupPolygon(&Path);
p->setPen(Qt::black);
p->setBrush(Qt::white);
p->setFillMode(0);
p->setLineWidth(1.0);
p->strokePath();
p->end();
delete p;
QPixmap pm;
pm=QPixmap::fromImage(pixm);
new QListWidgetItem(QIcon(pm), it.key(), pathList);
if (it.key() == info->usedPath)
{
pathList->setCurrentRow(pathList->count()-1);
pathList->currentItem()->setSelected(true);
}
}
}
tabLayout_2->addWidget( pathList );
resetPath = new QPushButton( tr("Don't use any Path"), tab_2);
tabLayout_2->addWidget( resetPath );
propsTab->addTab( tab_2, tr( "Paths" ) );
ExtImagePropsLayout->addWidget( propsTab );
layoutBottom = new QHBoxLayout;
layoutBottom->setMargin(0);
layoutBottom->setSpacing(6);
livePreview = new QCheckBox( this );
livePreview->setText( tr( "Live Preview" ) );
livePreview->setChecked(true);
doPreview = true;
layoutBottom->addWidget( livePreview );
QSpacerItem* spacer = new QSpacerItem( 2, 2, QSizePolicy::Expanding, QSizePolicy::Minimum );
layoutBottom->addItem( spacer );
okButton = new QPushButton( CommonStrings::tr_OK, this );
layoutBottom->addWidget( okButton );
cancelButton = new QPushButton( CommonStrings::tr_Cancel, this );
cancelButton->setDefault( true );
layoutBottom->addWidget( cancelButton );
ExtImagePropsLayout->addLayout( layoutBottom );
resize(330, 320);
connect(pathList, SIGNAL( itemClicked(QListWidgetItem*) ), this, SLOT( selPath(QListWidgetItem*) ) );
connect(resetPath, SIGNAL(clicked()), this, SLOT(noPath()));
connect(livePreview, SIGNAL(clicked()), this, SLOT(changePreview()));
connect(okButton, SIGNAL(clicked()), this, SLOT(leaveOK()));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(leaveCancel()));
if (info->layerInfo.count() != 0)
{
connect(layerTable, SIGNAL(cellClicked(int, int)), this, SLOT(selLayer(int)));
connect(opacitySpinBox, SIGNAL(valueChanged(int)), this, SLOT(changedLayer()));
connect(blendMode, SIGNAL(activated(int)), this, SLOT(changedLayer()));
}
