Subversion Repositories Scribus

Compare Revisions

Regard whitespace Rev 2040 → Rev 2039

/branches/Version13x/Scribus/scribus/scribus.cpp
493,7 → 493,6
Prefs.toolSettings.scaleType = true;
Prefs.toolSettings.aspectRatio = true;
Prefs.toolSettings.lowResType = 1;
Prefs.toolSettings.useEmbeddedPath = false;
Prefs.MinWordLen = 3;
Prefs.HyCount = 2;
Prefs.Language = "";
3021,7 → 3020,6
doc->toolSettings.scaleY = static_cast<double>(dia->tabTools->scalingVertical->value()) / 100.0;
doc->toolSettings.scaleType = dia->tabTools->buttonGroup3->isChecked();
doc->toolSettings.aspectRatio = dia->tabTools->checkRatioImage->isChecked();
doc->toolSettings.useEmbeddedPath = dia->tabTools->embeddedPath->isChecked();
int haRes = 0;
if (dia->tabTools->checkFullRes->isChecked())
haRes = 0;
7804,7 → 7802,6
Prefs.toolSettings.scaleY = static_cast<double>(dia->tabTools->scalingVertical->value()) / 100.0;
Prefs.toolSettings.scaleType = dia->tabTools->buttonGroup3->isChecked();
Prefs.toolSettings.aspectRatio = dia->tabTools->checkRatioImage->isChecked();
Prefs.toolSettings.useEmbeddedPath = dia->tabTools->embeddedPath->isChecked();
int haRes = 0;
if (dia->tabTools->checkFullRes->isChecked())
haRes = 0;
/branches/Version13x/Scribus/scribus/scribusview.cpp
3002,14 → 3002,6
{
if (currItem->itemType() == PageItem::ImageFrame)
{
if (currItem->imageClip.size() != 0)
{
currItem->imageClip = currItem->pixm.imgInfo.PDSpathData[currItem->pixm.imgInfo.usedPath].copy();
QWMatrix cl;
cl.translate(currItem->LocalX*currItem->LocalScX, currItem->LocalY*currItem->LocalScY);
cl.scale(currItem->LocalScX, currItem->LocalScY);
currItem->imageClip.map(cl);
}
MoveItemI((newX-Mxp)/currItem->LocalScX, (newY-Myp)/currItem->LocalScY, currItem->ItemNr);
Mxp = newX;
Myp = newY;
6178,8 → 6170,6
FPoint tp2 = getMinClipF(&Clip);
SizeItem(currItem->Width - tp2.x(), currItem->Height - tp2.y(), currItem->ItemNr, true, false, false);
Clip.translate(-tp2.x(), -tp2.y());
// if (currItem->imageClip.size() != 0)
// currItem->imageClip.translate(-tp2.x(), -tp2.y());
if (currItem->Rot != 0)
{
FPoint npv = FPoint(tp2.x(), tp2.y());
8124,7 → 8114,7
ScApp->fileWatcher->removeFile(currItem->Pfile);
currItem->Pfile = "";
currItem->PicAvail = false;
currItem->pixm = ScImage();
currItem->pixm = QImage();
if (currItem->itemType() == PageItem::ImageFrame)
{
currItem->LocalScX = 1;
8142,7 → 8132,6
currItem->setFillTransparency(0.0);
currItem->setLineTransparency(0.0);
currItem->InvPict = false;
currItem->imageClip.resize(0);
/* emit UpdtObj(Doc->currentPage->PageNr, currItem->ItemNr); */
}
updateContents();
8950,11 → 8939,11
if ((it->itemType() == PageItem::ImageFrame) && (it->PicAvail))
{
if (Pr->contains(it->IProfile))
LoadPict(it->Pfile, i, true);
LoadPict(it->Pfile, i);
else
{
it->IProfile = Doc->CMSSettings.DefaultInputProfile;
LoadPict(it->Pfile, i, true);
LoadPict(it->Pfile, i);
}
}
counter++;
9727,14 → 9716,6
currItem = SelItem.at(a);
currItem->LocalX = x;
currItem->LocalY = y;
if (currItem->imageClip.size() != 0)
{
currItem->imageClip = currItem->pixm.imgInfo.PDSpathData[currItem->pixm.imgInfo.usedPath].copy();
QWMatrix cl;
cl.translate(currItem->LocalX*currItem->LocalScX, currItem->LocalY*currItem->LocalScY);
cl.scale(currItem->LocalScX, currItem->LocalScY);
currItem->imageClip.map(cl);
}
RefreshItem(currItem);
}
}
9750,14 → 9731,6
currItem = SelItem.at(a);
currItem->LocalScX = x;
currItem->LocalScY = y;
if (currItem->imageClip.size() != 0)
{
currItem->imageClip = currItem->pixm.imgInfo.PDSpathData[currItem->pixm.imgInfo.usedPath].copy();
QWMatrix cl;
cl.translate(currItem->LocalX*currItem->LocalScX, currItem->LocalY*currItem->LocalScY);
cl.scale(currItem->LocalScX, currItem->LocalScY);
currItem->imageClip.map(cl);
}
RefreshItem(currItem);
}
}
10443,13 → 10416,10
bool dummy;
QFileInfo fi = QFileInfo(fn);
PageItem *Item = pageItem;
QString clPath = Item->pixm.imgInfo.usedPath;
Item->pixm.imgInfo.valid = false;
Item->pixm.imgInfo.clipPath = "";
Item->pixm.imgInfo.PDSpathData.clear();
Item->pixm.imgInfo.layerInfo.clear();
Item->pixm.imgInfo.usedPath = "";
Item->imageClip.resize(0);
if (!reload)
{
if ((ScApp->fileWatcher->files().contains(Item->Pfile) != 0) && (Item->PicAvail))
10480,38 → 10450,10
{
Item->LocalScX = 72.0 / xres;
Item->LocalScY = 72.0 / yres;
Item->LocalX = 0;
Item->LocalY = 0;
if ((Doc->toolSettings.useEmbeddedPath) && (Item->pixm.imgInfo.clipPath != ""))
{
Item->pixm.imgInfo.usedPath = Item->pixm.imgInfo.clipPath;
clPath = Item->pixm.imgInfo.clipPath;
if (Item->pixm.imgInfo.PDSpathData.contains(clPath))
{
Item->imageClip = Item->pixm.imgInfo.PDSpathData[clPath].copy();
Item->pixm.imgInfo.usedPath = clPath;
QWMatrix cl;
cl.translate(Item->LocalX*Item->LocalScX, Item->LocalY*Item->LocalScY);
cl.scale(Item->LocalScX, Item->LocalScY);
Item->imageClip.map(cl);
}
}
}
Item->Pfile = fi.absFilePath();
if (!reload)
ScApp->fileWatcher->addFile(Item->Pfile);
else
{
if (Item->pixm.imgInfo.PDSpathData.contains(clPath))
{
Item->imageClip = Item->pixm.imgInfo.PDSpathData[clPath].copy();
Item->pixm.imgInfo.usedPath = clPath;
QWMatrix cl;
cl.translate(Item->LocalX*Item->LocalScX, Item->LocalY*Item->LocalScY);
cl.scale(Item->LocalScX, Item->LocalScY);
Item->imageClip.map(cl);
}
}
Item->BBoxH = Item->pixm.height();
Item->OrigW = Item->pixm.width();
Item->OrigH = Item->pixm.height();
/branches/Version13x/Scribus/scribus/plugins/svgexplugin/svgexplugin.cpp
463,9 → 463,6
ob.setAttribute("clipPathUnits", "userSpaceOnUse");
ob.setAttribute("clip-rule", "evenodd");
QDomElement cl = docu->createElement("path");
if (Item->imageClip.size() != 0)
cl.setAttribute("d", SetClipPathImage(Item)+"Z");
else
cl.setAttribute("d", SetClipPath(Item)+"Z");
ob.appendChild(cl);
gr.appendChild(ob);
665,38 → 662,6
return tmp;
}
 
QString SVGExPlug::SetClipPathImage(PageItem *ite)
{
QString tmp = "";
FPoint np, np1, np2;
bool nPath = true;
if (ite->imageClip.size() > 3)
{
for (uint poi=0; poi<ite->imageClip.size()-3; poi += 4)
{
if (ite->imageClip.point(poi).x() > 900000)
{
tmp += "Z ";
nPath = true;
continue;
}
if (nPath)
{
np = ite->imageClip.point(poi);
tmp += "M"+FToStr(np.x())+" "+FToStr(np.y())+" ";
nPath = false;
}
np = ite->imageClip.point(poi+1);
tmp += "C"+FToStr(np.x())+" "+FToStr(np.y())+" ";
np1 = ite->imageClip.point(poi+3);
tmp += FToStr(np1.x())+" "+FToStr(np1.y())+" ";
np2 = ite->imageClip.point(poi+2);
tmp += FToStr(np2.x())+" "+FToStr(np2.y())+" ";
}
}
return tmp;
}
 
/*!
\fn QString SVGExPlug::FToStr(double c)
\author Franz Schmid
/branches/Version13x/Scribus/scribus/plugins/svgexplugin/svgexplugin.h
39,7 → 39,6
 
private:
void ProcessPage(ScribusApp *plug, Page *Seite, QDomDocument *docu, QDomElement *elem);
QString SetClipPathImage(PageItem *ite);
QString SetClipPath(PageItem *ite);
QString FToStr(double c);
QString IToStr(int c);
/branches/Version13x/Scribus/scribus/pageitem.cpp
162,7 → 162,6
}
PoLine.resize(0);
ContourLine.resize(0);
imageClip.resize(0);
Segments.clear();
PoShow = false;
BaseOffs = 0;
520,9 → 519,6
}
else
{
if (imageClip.size() != 0)
p->setupPolygon(&imageClip);
else
p->setupPolygon(&PoLine);
p->setClipPath();
p->save();
536,8 → 532,8
p->translate(0, Height * sc);
p->scale(1, -1);
}
p->scale(LocalScX, LocalScY);
p->translate(LocalX*LocalScX*sc, LocalY*LocalScY*sc);
p->scale(LocalScX, LocalScY);
if (pixm.imgInfo.lowResType != 0)
p->scale(pixm.imgInfo.lowResScale, pixm.imgInfo.lowResScale);
if (InvPict)
/branches/Version13x/Scribus/scribus/fileloader.cpp
453,7 → 453,6
doc->toolSettings.scaleType = static_cast<bool>(QStoInt(dc.attribute("PSCALE", "1")));
doc->toolSettings.aspectRatio = static_cast<bool>(QStoInt(dc.attribute("PASPECT", "0")));
doc->toolSettings.lowResType = QStoInt(dc.attribute("HalfRes", "1"));
doc->toolSettings.useEmbeddedPath = static_cast<bool>(QStoInt(dc.attribute("EmbeddedPath", "0")));
if (dc.hasAttribute("PEN"))
doc->toolSettings.dPen = dc.attribute("PEN");
if (dc.hasAttribute("BRUSH"))
1204,7 → 1203,6
QString tmp;
int xi;
double xf, yf;
QString clPath;
switch (pt)
{
// OBSOLETE CR 2005-02-06
1229,16 → 1227,6
view->LoadPict(currItem->Pfile, z);
currItem->LocalScX = scx;
currItem->LocalScY = scy;
clPath = obj->attribute("ImageClip", "");
if (currItem->pixm.imgInfo.PDSpathData.contains(clPath))
{
currItem->imageClip = currItem->pixm.imgInfo.PDSpathData[clPath].copy();
currItem->pixm.imgInfo.usedPath = clPath;
QWMatrix cl;
cl.translate(currItem->LocalX*currItem->LocalScX, currItem->LocalY*currItem->LocalScY);
cl.scale(currItem->LocalScX, currItem->LocalScY);
currItem->imageClip.map(cl);
}
currItem->PicArt = QStoInt(obj->attribute("PICART"));
currItem->BBoxX = QStodouble(obj->attribute("BBOXX"));
currItem->BBoxH = QStodouble(obj->attribute("BBOXH"));
/branches/Version13x/Scribus/scribus/scimage.h
118,6 → 118,8
bool progressive;
int lowResType; /* 0 = full Resolution, 1 = 72 dpi, 2 = 36 dpi */
double lowResScale;
double pathXoffset;
double pathYoffset;
QMap<QString, FPointArray> PDSpathData;
QMap<int, LoadRequest> RequestProps;
QString clipPath;
/branches/Version13x/Scribus/scribus/tabtools.h
87,7 → 87,6
LinkButton* chainButton;
QButtonGroup* buttonGroup5;
QCheckBox* checkRatioImage;
QCheckBox* embeddedPath;
QButtonGroup* buttonGroupRes;
QRadioButton* checkFullRes;
QRadioButton* checkNormalRes;
/branches/Version13x/Scribus/scribus/scribusdoc.cpp
100,7 → 100,6
toolSettings.scaleY = prefsData->toolSettings.scaleY;
toolSettings.scaleType = prefsData->toolSettings.scaleType;
toolSettings.aspectRatio = prefsData->toolSettings.aspectRatio;
toolSettings.useEmbeddedPath = prefsData->toolSettings.useEmbeddedPath;
toolSettings.lowResType = prefsData->toolSettings.lowResType;
toolSettings.dCols = prefsData->toolSettings.dCols;
toolSettings.dGap = prefsData->toolSettings.dGap;
/branches/Version13x/Scribus/scribus/scribusXml.cpp
2452,7 → 2452,6
}
SetItemProps(&ob, item, true);
ob.setAttribute("OnMasterPage", item->OnMasterPage);
ob.setAttribute("ImageClip", item->pixm.imgInfo.usedPath);
if (item->GrType != 0)
{
QPtrVector<VColorStop> cstops = item->fill_gradient.colorStops();
2715,7 → 2714,6
dc.setAttribute("PICTSCY",doc->toolSettings.scaleY);
dc.setAttribute("PSCALE", static_cast<int>(doc->toolSettings.scaleType));
dc.setAttribute("PASPECT", static_cast<int>(doc->toolSettings.aspectRatio));
dc.setAttribute("EmbeddedPath", static_cast<int>(doc->toolSettings.useEmbeddedPath));
dc.setAttribute("HalfRes", doc->toolSettings.lowResType);
dc.setAttribute("MINORC",doc->guidesSettings.minorColor.name());
dc.setAttribute("MAJORC",doc->guidesSettings.majorColor.name());
3096,7 → 3094,6
dc9.setAttribute("POLYS", static_cast<int>(Vor->toolSettings.polyS));
dc9.setAttribute("PSCALE", static_cast<int>(Vor->toolSettings.scaleType));
dc9.setAttribute("PASPECT", static_cast<int>(Vor->toolSettings.aspectRatio));
dc9.setAttribute("EmbeddedPath", static_cast<int>(Vor->toolSettings.useEmbeddedPath));
dc9.setAttribute("HalfRes", Vor->toolSettings.lowResType);
dc9.setAttribute("StartArrow", Vor->toolSettings.dStartArrow);
dc9.setAttribute("EndArrow", Vor->toolSettings.dEndArrow);
3436,7 → 3433,6
Vorein->toolSettings.scaleY = QStodouble(dc.attribute("PICTSCY","1"));
Vorein->toolSettings.scaleType = static_cast<bool>(QStoInt(dc.attribute("PSCALE", "1")));
Vorein->toolSettings.aspectRatio = static_cast<bool>(QStoInt(dc.attribute("PASPECT", "0")));
Vorein->toolSettings.useEmbeddedPath = static_cast<bool>(QStoInt(dc.attribute("EmbeddedPath", "0")));
Vorein->toolSettings.lowResType = QStoInt(dc.attribute("HalfRes", "1"));
Vorein->toolSettings.polyC = QStoInt(dc.attribute("POLYC", "4"));
Vorein->toolSettings.polyF = QStodouble(dc.attribute("POLYF", "0.5"));
/branches/Version13x/Scribus/scribus/tabtools.cpp
463,10 → 463,6
subTabImageLayout->addWidget( shadingFillImage, 3, 1, Qt::AlignLeft );
textLabel20b = new QLabel(shadingFillImage, tr( "S&hading:" ), subTabImage, "textLabel20b" );
subTabImageLayout->addWidget( textLabel20b, 3, 0 );
embeddedPath = new QCheckBox( subTabImage, "embeddedPath" );
embeddedPath->setText( tr( "Use embedded Clipping Path" ) );
embeddedPath->setChecked(prefsData->useEmbeddedPath);
subTabImageLayout->addMultiCellWidget( embeddedPath, 4, 4, 0, 1 );
buttonGroupRes = new QButtonGroup( subTabImage, "buttonGroup3" );
buttonGroupRes->setColumnLayout(0, Qt::Vertical );
buttonGroupRes->layout()->setSpacing( 6 );
496,7 → 492,7
checkHalfRes->setChecked(true);
break;
}
subTabImageLayout->addMultiCellWidget( buttonGroupRes, 5, 5, 0, 1 );
subTabImageLayout->addMultiCellWidget( buttonGroupRes, 4, 4, 0, 1 );
subStackTools->addWidget( subTabImage, 3 );
 
subTabPolygon = new QWidget( subStackTools, "subTabPolygon" );
/branches/Version13x/Scribus/scribus/scribusstructs.h
378,7 → 378,6
bool scaleType;
bool aspectRatio;
int lowResType;
bool useEmbeddedPath;
/* Magnifier Tool */
int magMin;
int magMax;
/branches/Version13x/Scribus/scribus/extimageprops.cpp
209,7 → 209,7
pixm.fill(white);
FPointArray Path;
Path.resize(0);
Path = info->PDSpathData[it.key()].copy();
Path = currentItem->pixm.imgInfo.PDSpathData[it.key()].copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
225,13 → 225,9
p->end();
delete p;
pathList->insertItem(pixm, it.key());
if (it.key() == info->usedPath)
pathList->setSelected(pathList->count()-1, true);
}
}
tabLayout_2->addWidget( pathList );
resetPath = new QPushButton( tr("Don't use any Path"), tab_2, "reset");
tabLayout_2->addWidget( resetPath );
propsTab->insertTab( tab_2, tr( "Paths" ) );
ExtImagePropsLayout->addWidget( propsTab );
resize(330, 320);
240,8 → 236,6
connect(layerTable, SIGNAL(currentChanged(int, int)), this, SLOT(selLayer(int)));
connect(opacitySpinBox, SIGNAL(valueChanged(int)), this, SLOT(changedLayer()));
connect(blendMode, SIGNAL(activated(int)), this, SLOT(changedLayer()));
connect(resetPath, SIGNAL(clicked()), this, SLOT(noPath()));
}
 
void ExtImageProps::changedLayer()
293,24 → 287,30
connect(blendMode, SIGNAL(activated(int)), this, SLOT(changedLayer()));
}
 
void ExtImageProps::noPath()
{
disconnect(pathList, SIGNAL( highlighted(QListBoxItem*) ), this, SLOT( selPath(QListBoxItem*) ) );
currentItem->imageClip.resize(0);
currentItem->pixm.imgInfo.usedPath = "";
pathList->clearSelection();
viewWidget->updateContents();
connect(pathList, SIGNAL( highlighted(QListBoxItem*) ), this, SLOT( selPath(QListBoxItem*) ) );
}
 
void ExtImageProps::selPath(QListBoxItem *c)
{
currentItem->imageClip = currentItem->pixm.imgInfo.PDSpathData[c->text()].copy();
currentItem->PoLine = currentItem->pixm.imgInfo.PDSpathData[c->text()].copy();
currentItem->pixm.imgInfo.usedPath = c->text();
viewWidget->MoveItem(currentItem->pixm.imgInfo.pathXoffset, currentItem->pixm.imgInfo.pathYoffset, currentItem, false);
QWMatrix cl;
cl.translate(currentItem->LocalX*currentItem->LocalScX, currentItem->LocalY*currentItem->LocalScY);
cl.scale(currentItem->LocalScX, currentItem->LocalScY);
currentItem->imageClip.map(cl);
cl.scale(72.0 / currentItem->pixm.imgInfo.xres, 72.0 / currentItem->pixm.imgInfo.yres);
currentItem->PoLine.map(cl);
currentItem->Clip = FlattenPath(currentItem->PoLine, currentItem->Segments);
currentItem->ClipEdited = true;
double lx = currentItem->Xpos;
double ly = currentItem->Ypos;
int oldFT = currentItem->FrameType;
currentItem->FrameType = 3;
currentItem->LocalX = 0;
currentItem->LocalY = 0;
viewWidget->AdjustItemSize(currentItem);
/* if (oldFT == 3)
{
viewWidget->MoveItem(lx- currentItem->Xpos, ly - currentItem->Ypos, currentItem, false);
} */
currentItem->pixm.imgInfo.pathXoffset = lx- currentItem->Xpos;
currentItem->pixm.imgInfo.pathYoffset = ly - currentItem->Ypos;
viewWidget->setRedrawBounding(currentItem);
viewWidget->updateContents();
}
 
/branches/Version13x/Scribus/scribus/scimage.cpp
80,6 → 80,8
imgInfo.clipPath = "";
imgInfo.usedPath = "";
imgInfo.layerInfo.clear();
imgInfo.pathXoffset = 0.0;
imgInfo.pathYoffset = 0.0;
}
 
void ScImage::swapRGBA()
/branches/Version13x/Scribus/scribus/libpostscript/pslib.cpp
1097,9 → 1097,6
}
else
PS_setcmykcolor_dummy();
if (ite->imageClip.size() != 0)
SetClipPath(&ite->imageClip);
else
SetClipPath(&ite->PoLine);
PS_closepath();
PS_clip(false);
1583,9 → 1580,6
PS_newpath();
}
PS_save();
if (c->imageClip.size() != 0)
SetClipPath(&c->imageClip);
else
SetClipPath(&c->PoLine);
PS_closepath();
PS_clip(true);
/branches/Version13x/Scribus/scribus/libpdf/pdflib.cpp
1079,9 → 1079,6
}
}
PutPage("q\n");
if (ite->imageClip.size() != 0)
PutPage(SetClipPathImage(ite));
else
PutPage(SetClipPath(ite));
PutPage("h\nW*\nn\n");
if (ite->imageFlippedH())
1592,6 → 1589,46
PutPage(name+" Do\n");
else
{
/* uint OldOwn = ite->OwnPage;
double OldX = ite->Xpos;
double OldY = ite->Ypos;
double OldBX = ite->BoundingX;
double OldBY = ite->BoundingY;
ite->OwnPage = pag->PageNr;
if (!ite->ChangedMasterItem)
{
ite->Xpos = OldX - mPage->Xoffset;
ite->Ypos = OldY - mPage->Yoffset;
ite->BoundingX = OldBX - mPage->Xoffset;
ite->BoundingY = OldBY - mPage->Yoffset;
}
double savScale = view->Scale;
view->Scale = 1.0;
doc->RePos = true;
QPixmap pgPix(10, 10);
QRect rd = QRect(0,0,9,9);
ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
if (painter!=NULL)
{
doc->Pages = doc->MasterPages;
doc->MasterP = true;
doc->Items = doc->MasterItems;
ite->DrawObj(painter, rd);
doc->Pages = doc->DocPages;
doc->MasterP = false;
doc->Items = doc->DocItems;
doc->RePos = false;
view->Scale = savScale;
delete painter;
}
ite->OwnPage = OldOwn;
if (!ite->ChangedMasterItem)
{
ite->Xpos = OldX;
ite->Ypos = OldY;
ite->BoundingX = OldBX;
ite->BoundingY = OldBY;
} */
PutPage("q\n");
if (((ite->fillTransparency() != 0) || (ite->lineTransparency() != 0)) && (Options->Version >= 14))
PDF_Transparenz(ite);
1960,9 → 1997,6
}
}
PutPage("q\n");
if (ite->imageClip.size() != 0)
PutPage(SetClipPathImage(ite));
else
PutPage(SetClipPath(ite));
PutPage("h\nW*\nn\n");
if (ite->imageFlippedH())
2892,38 → 2926,6
return tmp;
}
 
QString PDFlib::SetClipPathImage(PageItem *ite)
{
bool nPath = true;
QString tmp = "";
FPoint np;
if (ite->imageClip.size() > 3)
{
for (uint poi=0; poi<ite->imageClip.size()-3; poi += 4)
{
if (ite->imageClip.point(poi).x() > 900000)
{
tmp += "h\n";
nPath = true;
continue;
}
if (nPath)
{
np = ite->imageClip.point(poi);
tmp += FToStr(np.x())+" "+FToStr(-np.y())+" m\n";
nPath = false;
}
np = ite->imageClip.point(poi+1);
tmp += FToStr(np.x())+" "+FToStr(-np.y())+" ";
np = ite->imageClip.point(poi+3);
tmp += FToStr(np.x())+" "+FToStr(-np.y())+" ";
np = ite->imageClip.point(poi+2);
tmp += FToStr(np.x())+" "+FToStr(-np.y())+" c\n";
}
}
return tmp;
}
 
QString PDFlib::SetClipPath(PageItem *ite, bool poly)
{
bool nPath = true;
/branches/Version13x/Scribus/scribus/libpdf/pdflib.h
65,7 → 65,6
QString IToStr(int c);
QString setStrokeMulti(struct SingleLine *sl);
QString SetClipPathArray(FPointArray *ite, bool poly = true);
QString SetClipPathImage(PageItem *ite);
QString SetClipPath(PageItem *ite, bool poly = true);
QString SetFarbe(QString farbe, int Shade);
QString putColor(QString color, int Shade, bool fill);
/branches/Version13x/Scribus/scribus/about.cpp
51,7 → 51,7
tabLayout1->addWidget( pixmapLabel1 );
buildID = new QLabel( tab, "BB" );
buildID->setAlignment(Qt::AlignCenter);
QString bu = tr("%1 %2 %3 ").arg("27").arg("April").arg("2005");
QString bu = tr("%1 %2 %3 ").arg("26").arg("April").arg("2005");
#ifdef HAVE_CMS
bu += "C";
#else
/branches/Version13x/Scribus/scribus/mpalette.cpp
1761,17 → 1761,15
return;
bool tmp = HaveItem;
HaveItem = false;
LXpos->setValue(x * Umrech);
LYpos->setValue(y * Umrech);
if (tmp)
{
LXpos->setValue(x * Umrech * CurItem->LocalScX);
LYpos->setValue(y * Umrech * CurItem->LocalScY);
ScaleX->setValue(scx * 100 / 72.0 * CurItem->pixm.imgInfo.xres);
ScaleY->setValue(scy * 100 / 72.0 * CurItem->pixm.imgInfo.yres);
}
else
{
LXpos->setValue(x * Umrech);
LYpos->setValue(y * Umrech);
ScaleX->setValue(scx * 100);
ScaleY->setValue(scy * 100);
}
2342,7 → 2340,7
return;
if ((HaveDoc) && (HaveItem))
{
ScApp->view->ChLocalXY(LXpos->value() / Umrech / CurItem->LocalScX, LYpos->value() / Umrech / CurItem->LocalScY);
ScApp->view->ChLocalXY(LXpos->value() / Umrech, LYpos->value() / Umrech);
emit DocChanged();
}
}
2354,7 → 2352,6
if ((HaveDoc) && (HaveItem))
{
ScApp->view->ChLocalSc(ScaleX->value() / 100.0 / CurItem->pixm.imgInfo.xres * 72.0, ScaleY->value() / 100.0 / CurItem->pixm.imgInfo.yres * 72.0);
ScApp->view->ChLocalXY(LXpos->value() / Umrech / CurItem->LocalScX, LYpos->value() / Umrech / CurItem->LocalScY);
emit DocChanged();
}
}
3009,7 → 3006,7
/* PFJ - 29.02.04 - re-arranged the initialisation of EmbedP */
bool EmbedP = prn.startsWith("Embedded") ? true : false;
CurItem->UseEmbedded = EmbedP;
ScApp->view->LoadPict(CurItem->Pfile, CurItem->ItemNr, true);
ScApp->view->LoadPict(CurItem->Pfile, CurItem->ItemNr);
ScApp->view->RefreshItem(CurItem);
}
}
3021,7 → 3018,7
if ((HaveDoc) && (HaveItem))
{
CurItem->IRender = MonitorI->currentItem();
ScApp->view->LoadPict(CurItem->Pfile, CurItem->ItemNr, true);
ScApp->view->LoadPict(CurItem->Pfile, CurItem->ItemNr);
ScApp->view->RefreshItem(CurItem);
}
}
/branches/Version13x/Scribus/scribus/extimageprops.h
15,7 → 15,6
class QListBox;
class QListBoxItem;
class QCheckBox;
class QPushButton;
#include "scribus.h"
#include "scimage.h"
 
36,7 → 35,6
QTable* layerTable;
QWidget* tab_2;
QListBox* pathList;
QPushButton* resetPath;
QPtrList<QCheckBox> FlagsSicht;
ScribusView *viewWidget;
PageItem *currentItem;
48,7 → 46,6
void changedLayer();
void selLayer(int layer);
void selPath(QListBoxItem *c);
void noPath();
 
protected:
QVBoxLayout* ExtImagePropsLayout;
/branches/Version13x/Scribus/scribus/pageitem.h
207,7 → 207,6
QPointArray Clip;
FPointArray PoLine;
FPointArray ContourLine;
FPointArray imageClip;
QValueList<uint> Segments;
bool PoShow;
double BaseOffs;