void ConnectorTool::continueRubberBanding( QMouseEvent *e )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage* pPage = view()->activePage();
bool hit = false;
KoPoint endPoint = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
endPoint = canvas->snapToGridAndGuides(endPoint);
}
m_pDragData->x = endPoint.x();
m_pDragData->y = endPoint.y();
if(m_type == StraightConnector) {
KivioStraightConnector* connector = static_cast<KivioStraightConnector*>(m_pStencil);
connector->setEndPoint(endPoint.x(), endPoint.y());
m_pDragData->id = kctCustom + 2;
} else {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
m_pDragData->id = kctCustom + connector->pointCount();
}
m_pStencil->customDrag(m_pDragData);
m_pStencil->updateGeometry();
canvas->repaint();
}
/**
* Handles what happens when a left-button double click occurs.
*
* If there are no stencils selected, this function returns. Otherwise
* it launches the text tool on the selected stencils and switches back
* to this tool when it's done.
*/
void SelectTool::leftDoubleClick(const QPoint& pos)
{
if( view()->activePage()->selectedStencils()->count() <= 0 )
return;
KoPoint pagePoint = view()->canvasWidget()->mapFromScreen(pos);
// Figure out how big 4 pixels is in terms of points
double threshold = view()->zoomHandler()->unzoomItY(4);
int colType;
KivioPage *page = view()->activePage();
KivioStencil* stencil = page->checkForStencil( &pagePoint, &colType, threshold, false);
if(stencil) {
// Locate the text tool. If not found, bail with an error
Kivio::Plugin *p = view()->pluginManager()->findPlugin("Text Mouse Tool");
if( !p )
{
kdDebug(43000) << "SelectTool::leftDoubleClick() - unable to locate Text Tool" << endl;
return;
}
static_cast<Kivio::MouseTool*>(p)->applyToolAction(stencil, pagePoint);
}
}
KivioPage* KivioMap::findPage( const QString& name )
{
KivioPage *t;
for ( t = m_lstPages.first(); t; t = m_lstPages.next() ) {
if ( name == t->pageName() )
return t;
}
return 0L;
}
bool SelectTool::startCustomDragging(const QPoint &pos, bool selectedOnly )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage *pPage = canvas->activePage();
KivioStencil *pStencil;
int colType;
KoPoint pagePoint = canvas->mapFromScreen( pos );
// Figure out how big 4 pixels is in terms of points
double threshold = view()->zoomHandler()->unzoomItY(4);
pStencil = pPage->checkForStencil( &pagePoint, &colType, threshold, selectedOnly );
if( !pStencil || colType < kctCustom ) {
return false;
}
if(pStencil->isSelected()) {
// If we are clicking an already selected stencil, and the control
// key down, then unselect this stencil
if(m_controlKey) {
pPage->unselectStencil(pStencil);
}
} else {
// Clicking a new stencil, and the control key is not down
if(!m_controlKey) {
pPage->unselectAllStencils();
}
pPage->selectStencil( pStencil );
}
m_pCustomDraggingStencil = pStencil;
// Set the mode
m_mode = stmCustomDragging;
m_customDragID = colType;
m_customDragOrigPoint = pStencil->customIDPoint(m_customDragID);
view()->canvasWidget()->setShowConnectorTargets(true);
view()->canvasWidget()->repaint();
// Create a new painter object
canvas->beginUnclippedSpawnerPainter();
m_firstTime = true;
return true;
}
QStringList KivioMap::hiddenPages() const
{
QStringList pages;
QPtrListIterator<KivioPage> it( m_lstPages );
for( ; it.current(); ++it )
{
KivioPage* page = it.current();
if( page->isHidden() )
pages.append( page->pageName() );
}
return pages;
}
/**
* Tests if we should start rubber banding (always returns true).
*/
bool SMLConnector::startRubberBanding( QMouseEvent *e )
{
KivioDoc* doc = view()->doc();
KivioPage* pPage = view()->activePage();
KivioCanvas* canvas = view()->canvasWidget();
startPoint = canvas->snapToGrid(canvas->mapFromScreen( e->pos() ));
// Create the stencil
KivioStencilSpawner* ss = doc->findInternalStencilSpawner("SML Connector");
if (!ss) {
kdDebug(43000) << "SMLTool: Failed to find StencilSpawner!" << endl;
return false;
}
startPoint = canvas->snapToGrid(canvas->mapFromScreen( e->pos() ));
// Create the stencil
m_pStencil = (KivioSMLConnector*)ss->newStencil("basic_line");
m_pStencil->setTextFont(doc->defaultFont());
// Unselect everything, add the stencil to the page, and select it
pPage->unselectAllStencils();
pPage->addStencil(m_pStencil);
pPage->selectStencil(m_pStencil);
// Get drag info ready
m_pDragData = new KivioCustomDragData();
m_pDragData->page = pPage;
m_pDragData->x = startPoint.x();
m_pDragData->y = startPoint.y();
m_pDragData->id = kctCustom + 2;
m_pStencil->setStartPoint(startPoint.x() + 10.0f, startPoint.y() + 10.0f);
m_pStencil->setEndPoint(startPoint.x(), startPoint.y());
m_pStencil->customDrag(m_pDragData);
canvas->repaint();
canvas->setCursor(*m_pConnectorCursor2);
return true;
}
void ConnectorTool::mousePress( QMouseEvent *e )
{
if(e->button() == LeftButton) {
bool ok = true;
if(!m_pStencil || (m_type == StraightConnector)) {
ok = startRubberBanding(e);
} else {
if(m_pStencil) {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
KivioCanvas* canvas = view()->canvasWidget();
KivioPage* pPage = canvas->activePage();
bool hit = false;
KoPoint point = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
point = canvas->snapToGrid(startPoint);
}
if((m_mode == stmDrawRubber) && hit) {
endRubberBanding(e);
} else {
connector->addPoint(point);
}
}
}
if(ok) {
m_mode = stmDrawRubber;
} else {
m_mode = stmNone;
}
} else if(e->button() == RightButton) {
if(m_type == PolyLineConnector) {
if(m_mode == stmDrawRubber) {
endRubberBanding(e);
}
view()->canvasWidget()->setCursor(*m_pConnectorCursor1);
m_mode = stmNone;
}
}
}
bool KivioMap::loadXML( const QDomElement& mymap )
{
m_lstPages.clear();
m_lstDeletedPages.clear();
// FIXME: make this load the real page units and whatever
// else
QDomNode n = mymap.firstChild();
while( !n.isNull() ) {
QDomElement e = n.toElement();
if ( !e.isNull() && e.tagName() == "KivioPage" ) {
KivioPage *t = m_pDoc->createPage();
m_pDoc->addPage( t );
if ( !t->loadXML( e ) )
return false;
}
n = n.nextSibling();
}
return true;
}
void SMLConnector::connector(QRect)
{
if (!m_pStencil)
return;
delete m_pDragData;
m_pDragData = 0;
KivioDoc* doc = view()->doc();
KivioPage* page = view()->activePage();
if (m_pStencil->w() < 3.0 && m_pStencil->h() < 3.0) {
page->unselectAllStencils();
page->selectStencil(m_pStencil);
page->deleteSelectedStencils();
m_pStencil = 0;
doc->updateView(page);
return;
}
m_pStencil->searchForConnections(page, view()->zoomHandler()->unzoomItY(4));
doc->updateView(page);
}
/**
* Tests if we should start rubber banding (always returns true).
*/
bool ConnectorTool::startRubberBanding( QMouseEvent *e )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioDoc* doc = view()->doc();
KivioPage* pPage = canvas->activePage();
QString spawnerId;
if(m_type == StraightConnector) {
spawnerId = "Dave Marotti - Straight Connector";
} else {
spawnerId = "Internal - PolyLine Connector";
}
KivioStencilSpawner* ss = doc->findInternalStencilSpawner(spawnerId);
if(!ss) {
kdDebug(43000) << "ConnectorTool: Failed to find StencilSpawner!" << endl;
return false;
}
// Create the stencil
m_pStencil = static_cast<Kivio1DStencil*>(ss->newStencil());
bool hit = false;
startPoint = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
startPoint = canvas->snapToGrid(startPoint);
}
if(!m_pStencil) {
return false;
}
m_pStencil->setTextFont(doc->defaultFont());
// Unselect everything, add the stencil to the page, and select it
pPage->unselectAllStencils();
pPage->addStencil(m_pStencil);
pPage->selectStencil(m_pStencil);
// Get drag info ready
m_pDragData = new KivioCustomDragData();
m_pDragData->page = pPage;
m_pDragData->x = startPoint.x();
m_pDragData->y = startPoint.y();
if(m_type == StraightConnector) {
KivioStraightConnector* connector = static_cast<KivioStraightConnector*>(m_pStencil);
m_pDragData->id = kctCustom + 2;
connector->setStartPoint(startPoint.x(), startPoint.y());
connector->setEndPoint(startPoint.x() + 10.0, startPoint.y() + 10.0);
} else {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
m_pDragData->id = kctCustom + 1;
connector->addPoint(startPoint);
connector->addPoint(startPoint);
}
m_pStencil->customDrag(m_pDragData);
canvas->repaint();
canvas->setCursor(*m_pConnectorCursor2);
return true;
}
KoFilter::ConversionStatus ImageExport::convert(const QByteArray& from, const QByteArray& to)
{
if(from != "application/x-kivio") {
return KoFilter::BadMimeType;
}
QString format;
if(to == "image/png") {
format = "PNG";
} else if(to == "image/jpeg") {
format = "JPEG";
} else if(to == "image/bmp") {
format = "BMP";
} else if(to == "image/x-eps") {
format = "EPS";
} else if(to == "image/x-portable-bitmap") {
format = "PBM";
} else if(to == "image/x-pcx") {
format = "PCX";
} else if(to == "image/x-portable-pixmap") {
format = "PPM";
} else if(to == "image/x-rgb") {
format = "RGB";
} else if(to == "image/x-xpixmap") {
format = "XPM";
} else if(to == "image/jpeg2000") {
format = "JP2";
} else {
return KoFilter::BadMimeType;
}
KoStoreDevice* storeIn = m_chain->storageFile("root", KoStore::Read);
if (!storeIn) {
KMessageBox::error(0, i18n("Failed to read data."), i18n( "Export Error" ));
return KoFilter::FileNotFound;
}
// Get the XML tree.
QDomDocument domIn;
domIn.setContent(storeIn);
KivioDoc doc;
if(!doc.loadXML(0, domIn)) {
KMessageBox::error(0, i18n("Malformed XML data."), i18n("Export Error"));
return KoFilter::WrongFormat;
}
ImageExportDialog dlg;
QStringList pageNames;
Q3PtrList<KivioPage> pageList = doc.map()->pageList();
Q3PtrListIterator<KivioPage> it(pageList);
for(; it.current() != 0; ++it) {
pageNames.append(it.current()->pageName());
}
KoZoomHandler zoom;
dlg.setPageList(pageNames);
KivioPage* page = doc.map()->firstPage();
QSize size = QSize(zoom.zoomItX(page->paperLayout().ptWidth), zoom.zoomItY(page->paperLayout().ptHeight));
dlg.setInitialCustomSize(size);
if(dlg.exec() != QDialog::Accepted) {
return KoFilter::UserCancelled;
}
page = doc.map()->findPage(dlg.selectedPage());
if(!page) {
kDebug() <<"The page named" << dlg.selectedPage() <<" wasn't found!!";
return KoFilter::InternalError;
}
if(dlg.usePageBorders()) {
size = QSize(zoom.zoomItX(page->paperLayout().ptWidth), zoom.zoomItY(page->paperLayout().ptHeight));
} else {
size = zoom.zoomSize(page->getRectForAllStencils().size());
}
if(dlg.useCustomSize()) {
QSize customSize = dlg.customSize();
float zw = (float)customSize.width() / (float)size.width();
float zh = (float)customSize.height() / (float)size.height();
float z = qMin(zw, zh);
zoom.setZoomAndResolution(qRound(z * 100), KoGlobal::dpiX(), KoGlobal::dpiY());
size = customSize;
}
int border = dlg.margin();
size.setWidth(size.width() + (border * 2));
size.setHeight(size.height() + (border * 2));
QPixmap pixmap = QPixmap(size);
pixmap.fill(Qt::white);
KivioScreenPainter kpainter;
kpainter.start(&pixmap);
int translationX = border;
int translationY = border;
if(!dlg.usePageBorders()) {
QPoint point = zoom.zoomPoint(page->getRectForAllStencils().topLeft());
translationX += point.x();
translationY += point.y();
}
kpainter.setTranslation(-translationX, -translationY);
page->printContent(kpainter, &zoom);
if(!pixmap.save(m_chain->outputFile(), format.local8Bit())) {
return KoFilter::CreationError;
}
return KoFilter::OK;
}
/**
* Tests if we can start dragging a stencil.
*/
bool SelectTool::startDragging(const QPoint &pos, bool onlySelected)
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage *pPage = canvas->activePage();
KivioStencil *pStencil;
int colType;
// Figure out how big 4 pixels is in terms of points
double threshold = view()->zoomHandler()->unzoomItY(4);
KoPoint pagePoint = canvas->mapFromScreen( pos );
pStencil = pPage->checkForStencil( &pagePoint, &colType, threshold, onlySelected );
if( !pStencil )
return false;
canvas->setEnabled(false);
if( pStencil->isSelected() )
{
// If we are clicking an already selected stencil, and the control
// key down, then unselect this stencil
if( m_controlKey==true ) {
pPage->unselectStencil( pStencil );
}
// Otherwise, it means we are just moving
}
else
{
// Clicking a new stencil, and the control key is not down
if( !m_controlKey )
pPage->unselectAllStencils();
pPage->selectStencil( pStencil );
// Update the auto guidelines
view()->canvasWidget()->updateAutoGuideLines();
}
// Create a new painter object
canvas->beginUnclippedSpawnerPainter();
// Build the list of old geometry
KivioSelectDragData *pData;
m_lstOldGeometry.clear();
pStencil = canvas->activePage()->selectedStencils()->first();
while( pStencil )
{
pData = new KivioSelectDragData;
pData->rect = pStencil->rect();
m_lstOldGeometry.append(pData);
pStencil = canvas->activePage()->selectedStencils()->next();
}
m_selectedRect = view()->activePage()->getRectForAllSelectedStencils();
changeMouseCursor(pos);
// Set the mode
m_mode = stmDragging;
m_firstTime = true;
canvas->setEnabled(true);
return true;
}
