You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
653 lines
14 KiB
653 lines
14 KiB
#include "mwidget.h"
|
|
#include "autorouter.h"
|
|
|
|
#include <arts/debug.h>
|
|
|
|
//#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
#include <tdemessagebox.h>
|
|
|
|
#include <tqtimer.h>
|
|
#include <tqpainter.h>
|
|
#include <tqevent.h>
|
|
|
|
#include "createtool.h"
|
|
|
|
Structure *ModuleWidget::theStructure()
|
|
{
|
|
return structure;
|
|
}
|
|
|
|
void ModuleWidget::addInterface ( const Arts::ModuleInfo& minfo )
|
|
{
|
|
delete activeTool;
|
|
activeTool = new CreateInterfaceTool(this, minfo);
|
|
}
|
|
|
|
void ModuleWidget::addModule ( const Arts::ModuleInfo& minfo )
|
|
{
|
|
delete activeTool;
|
|
activeTool = new CreateModuleTool(this, minfo);
|
|
}
|
|
|
|
void ModuleWidget::addPort ( const Arts::PortType& type )
|
|
{
|
|
delete activeTool;
|
|
activeTool = new CreatePortTool(this, type);
|
|
}
|
|
|
|
StructurePort *ModuleWidget::insertPort( const Arts::PortType& type, int x, int y )
|
|
{
|
|
StructurePort *port = structure->createStructurePort(type);
|
|
unselectAll();
|
|
port->move(x, y);
|
|
port->setSelected(true);
|
|
port->show();
|
|
|
|
return port;
|
|
}
|
|
|
|
void ModuleWidget::leaveTool(MWidgetTool *tool, bool wasModified)
|
|
{
|
|
assert(tool == activeTool);
|
|
delete tool;
|
|
activeTool = 0;
|
|
if(wasModified)
|
|
emit modified(wasModified);
|
|
}
|
|
|
|
TQPoint ModuleWidget::componentPos(const StructureComponent *component) const
|
|
{
|
|
int cellx = 0, celly = 0;
|
|
colXPos(component->x(), &cellx);
|
|
rowYPos(component->y(), &celly);
|
|
|
|
return TQPoint(cellx, celly);
|
|
}
|
|
|
|
TQPoint ModuleWidget::portPos(const ModulePort *port) const
|
|
{
|
|
int cellx = 0, celly = 0;
|
|
colXPos(port->owner->x() + port->drawsegment, &cellx);
|
|
rowYPos(port->owner->y(), &celly);
|
|
|
|
return TQPoint(cellx, celly);
|
|
}
|
|
|
|
bool ModuleWidget::insertModule( Module *newModule )
|
|
{
|
|
if(hasSpace(newModule, newModule->x(), newModule->y(), true))
|
|
{
|
|
newModule->show();
|
|
reRoute();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ModuleWidget::findAt(int windowX, int windowY,
|
|
StructureComponent *&component, ModulePort *&port)
|
|
{
|
|
int x = findCol(windowX);
|
|
int y = findRow(windowY);
|
|
|
|
component = structure->componentAt(x, y, false);
|
|
|
|
if(component)
|
|
{
|
|
int cellx = 0, celly = 0;
|
|
colXPos(x, &cellx);
|
|
rowYPos(y, &celly);
|
|
|
|
port = component->portAt(x - (component->x()),
|
|
windowX - cellx, windowY - celly);
|
|
}
|
|
else
|
|
port = 0L;
|
|
}
|
|
|
|
void ModuleWidget::selectComponent( StructureComponent *component, bool onlyThis )
|
|
{
|
|
beginUpdate();
|
|
if(onlyThis)
|
|
unselectAll();
|
|
|
|
if(!(component->selected()))
|
|
{
|
|
component->setSelected(true);
|
|
emit componentSelected(component);
|
|
} else
|
|
if(!onlyThis)
|
|
{
|
|
component->setSelected(false);
|
|
emit componentSelected(0L);
|
|
}
|
|
endUpdate();
|
|
}
|
|
|
|
void ModuleWidget::mousePressEvent( TQMouseEvent *e )
|
|
{
|
|
if(activeTool)
|
|
{
|
|
activeTool->mousePressEvent(e);
|
|
return;
|
|
}
|
|
|
|
if( e->button() == TQt::LeftButton )
|
|
{
|
|
StructureComponent *component;
|
|
ModulePort *port;
|
|
findAt(e->x(), e->y(), component, port);
|
|
|
|
if(component)
|
|
{
|
|
if(port)
|
|
{
|
|
// user clicked in port
|
|
selectPort(port);
|
|
|
|
delete activeTool;
|
|
activeTool = new ConnectPortsTool(this, port);
|
|
}
|
|
else
|
|
{
|
|
// user clicked in component
|
|
activeTool = new MoveComponentsTool(this, e);
|
|
|
|
// maintain selected group when pressing the shift or control button
|
|
selectComponent(component, !((e->state() & ControlButton)
|
|
|| (e->state() & ShiftButton)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// unselect all if user clicks on background (without shift)
|
|
if(!(e->state() & ShiftButton))
|
|
{
|
|
beginUpdate();
|
|
unselectAll();
|
|
endUpdate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::mouseMoveEvent( TQMouseEvent *e )
|
|
{
|
|
if(activeTool)
|
|
{
|
|
activeTool->mouseMoveEvent(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::mouseReleaseEvent( TQMouseEvent *e )
|
|
{
|
|
if(activeTool)
|
|
{
|
|
activeTool->mouseReleaseEvent(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// may be called with port == 0
|
|
void ModuleWidget::selectPort( ModulePort *port, bool newMode )
|
|
{
|
|
beginUpdate();
|
|
|
|
if(selectedPort && (selectedPort!= port))
|
|
{
|
|
// unselect previous
|
|
selectedPort->selected = false;
|
|
selectedPort->owner->redraw();
|
|
if(selectedPort->owner->selected())
|
|
emit componentSelected(selectedPort->owner);
|
|
else
|
|
emit portSelected(0L);
|
|
selectedPort = 0L;
|
|
}
|
|
|
|
if(port)
|
|
{
|
|
port->selected = newMode;
|
|
selectedPort = port;
|
|
selectComponent(selectedPort->owner);
|
|
selectedPort->owner->redraw();
|
|
}
|
|
emit portSelected(port); // FIXME: should be "portSelectionChanged"
|
|
|
|
endUpdate();
|
|
}
|
|
|
|
void ModuleWidget::startConnection( ModulePort *port )
|
|
{
|
|
delete activeTool;
|
|
activeTool = new ConnectPortsTool(this, port);
|
|
}
|
|
|
|
void ModuleWidget::portPropertiesChanged( ModulePort *port )
|
|
{
|
|
reRoute();
|
|
}
|
|
|
|
bool ModuleWidget::hasSpace(StructureComponent *c, int destx, int desty,
|
|
bool ignore_selected)
|
|
{
|
|
if((destx < 0) || (desty < 0))
|
|
return false;
|
|
if((destx + c->width() > numCols()) || (desty + c->height() > numRows()))
|
|
return false;
|
|
|
|
for(int ddx = 0; ddx < c->width(); ddx++)
|
|
{
|
|
for(int ddy = 0; ddy < c->height(); ddy++)
|
|
{
|
|
if(structure->componentAt(destx + ddx, desty + ddy, ignore_selected))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ModuleWidget::paintCellBackground(TQPainter *p, int y, int x)
|
|
{
|
|
TQColor bgcolor;
|
|
|
|
if((y & 1) == 1)
|
|
bgcolor = TQColor(168, 168, 168);
|
|
else
|
|
bgcolor = TQColor(146, 168, 146);
|
|
|
|
p->fillRect(0, 0, cellsize, cellsize, TQBrush(bgcolor));
|
|
|
|
p->setPen(bgcolor.dark(115));
|
|
p->drawLine(0, 0, 0, cellsize - 1);
|
|
p->drawLine(0, 0, cellsize - 1, 0);
|
|
|
|
if(x == (numCols() - 1))
|
|
p->drawLine(cellsize - 1, 0, cellsize - 1, cellsize - 1);
|
|
if(y == (numRows() - 1))
|
|
p->drawLine(0, cellsize - 1, cellsize - 1, cellsize - 1);
|
|
}
|
|
|
|
void ModuleWidget::unselectAll()
|
|
{
|
|
setSelectAll(false);
|
|
}
|
|
|
|
void ModuleWidget::setSelectAll(bool newstate)
|
|
{
|
|
std::list<StructureComponent *>::iterator module;
|
|
|
|
for(module = structure->getComponentList()->begin();
|
|
module != structure->getComponentList()->end(); module++)
|
|
{
|
|
(*module)->setSelected(newstate);
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::beginUpdate()
|
|
{
|
|
updateDepth++;
|
|
}
|
|
|
|
void ModuleWidget::endUpdate()
|
|
{
|
|
if(!--updateDepth)
|
|
{
|
|
std::list<TQRect>::iterator i;
|
|
|
|
for(i = UpdateList.begin(); i != UpdateList.end(); i++)
|
|
{
|
|
redrawCells(*i);
|
|
}
|
|
|
|
UpdateList.clear();
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::redrawRect(int x, int y, int width, int height)
|
|
{
|
|
TQRect r = TQRect(x, y, width, height);
|
|
|
|
if(!updateDepth)
|
|
{
|
|
redrawCells(r);
|
|
}
|
|
else
|
|
{
|
|
UpdateList.push_back(r);
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::redrawCells(TQRect &r)
|
|
{
|
|
int x, y;
|
|
|
|
for(x = r.left(); x <= r.right(); x++)
|
|
{
|
|
for(y = r.top(); y <= r.bottom(); y++)
|
|
{
|
|
updateCell(y, x, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ModuleWidget::reRoute()
|
|
{
|
|
// clear everything
|
|
autorouter->clear();
|
|
|
|
// add structure components (external ports/modules) to the router, so that
|
|
// cables won't be drawn over them
|
|
|
|
std::list<StructureComponent *>::iterator c;
|
|
std::list<ModulePort *> portlist;
|
|
|
|
for(c = structure->getComponentList()->begin();
|
|
c != structure->getComponentList()->end(); c++)
|
|
{
|
|
StructureComponent *sc = *c;
|
|
autorouter->set(sc->x()*2, sc->y()*2,
|
|
(sc->x() + sc->width())*2 - 1,
|
|
(sc->y() + sc->height())*2 - 1, AutoRouter::solid);
|
|
|
|
sc->dumpPorts(portlist);
|
|
}
|
|
|
|
std::list<ModulePort *>::iterator pi;
|
|
|
|
// build a map with all input ports to find corresponding ports of connections
|
|
|
|
std::map<long, ModulePort *> portmap;
|
|
|
|
for(pi = portlist.begin(); pi != portlist.end(); ++pi)
|
|
{
|
|
ModulePort *port = *pi;
|
|
|
|
if(port->direction == ModulePort::in) portmap[port->pdID] = port;
|
|
}
|
|
|
|
// add connections to the router
|
|
|
|
/*
|
|
* assign colors after the following algorithm:
|
|
*
|
|
* - initialize assuming that each port has its own color
|
|
* - if two ports are connected, they must have the same color, that
|
|
* is, all references to the two colors must be made the same
|
|
*
|
|
* these colors are not used for drawing, but for making lines of
|
|
* different groups of ports not collide in the autorouter (ownership)
|
|
*/
|
|
std::map<ModulePort *, long> color;
|
|
vector<long> owner(portlist.size());
|
|
|
|
long maxcolor = 0;
|
|
for(pi = portlist.begin(); pi != portlist.end(); ++pi)
|
|
color[*pi] = maxcolor++;
|
|
|
|
for(pi = portlist.begin(); pi != portlist.end(); ++pi)
|
|
{
|
|
ModulePort *src = *pi;
|
|
unsigned long c;
|
|
if(src->direction == ModulePort::out && src->PortDesc.isConnected())
|
|
{
|
|
vector<Arts::PortDesc> *conn = src->PortDesc.connections();
|
|
|
|
for(c = 0; c < conn->size(); c++)
|
|
{
|
|
ModulePort *dest = portmap[(*conn)[c].ID()];
|
|
long color_src = color[src];
|
|
long color_dest = color[dest];
|
|
|
|
if(color_src != color_dest)
|
|
{
|
|
std::list<ModulePort *>::iterator pi2;
|
|
|
|
for(pi2 = portlist.begin(); pi2 != portlist.end(); pi2++)
|
|
{
|
|
ModulePort *p = *pi2;
|
|
|
|
if(color[p] == color_dest) color[p] = color_src;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for(pi = portlist.begin(); pi != portlist.end(); ++pi)
|
|
{
|
|
ModulePort *p = *pi;
|
|
|
|
if(p->direction == ModulePort::out && p->PortDesc.isConnected())
|
|
{
|
|
ModulePort *src = p, *dest;
|
|
long& route_owner = owner[color[src]];
|
|
unsigned long c;
|
|
|
|
vector<Arts::PortDesc> *conn = p->PortDesc.connections();
|
|
|
|
for(c = 0; c < conn->size(); c++)
|
|
{
|
|
dest = portmap[(*conn)[c].ID()];
|
|
if(dest) // otherwise something bad has happend?
|
|
{
|
|
/*
|
|
arts_debug("autoroute add connection port %s.%s to %s.%s",
|
|
src->owner->type.local8Bit().data(),src->description.local8Bit().data(),
|
|
dest->owner->type.local8Bit().data(),dest->description.local8Bit().data());
|
|
*/
|
|
|
|
int x1 = (src->owner->x() + src->drawsegment)*2;
|
|
int y1 = src->owner->y()*2 + 1;
|
|
|
|
int x2 = (dest->owner->x() + dest->drawsegment)*2;
|
|
int y2 = dest->owner->y()*2;
|
|
|
|
route_owner = autorouter->connect(x1, y1, x2, y2, route_owner);
|
|
}
|
|
}
|
|
|
|
delete conn;
|
|
}
|
|
}
|
|
|
|
autorouter->sync();
|
|
}
|
|
|
|
void ModuleWidget::redrawAll()
|
|
{
|
|
// redraw everything
|
|
TQRect updaterect(0, 0, cols, rows);
|
|
redrawCells(updaterect);
|
|
}
|
|
|
|
void ModuleWidget::paintConnection(TQPainter *p, int x, int y, int arx, int ary)
|
|
{
|
|
long linetype = autorouter->get(arx, ary);
|
|
long ud_owner = -1, lr_owner = -1, lr_break = 0, ud_break = 0;
|
|
|
|
autorouter->getowners(arx, ary, ud_owner, lr_owner);
|
|
|
|
p->setPen(TQColor(255, 255, 255));
|
|
|
|
/*
|
|
if(linetype == AutoRouter::none)
|
|
{
|
|
p->drawPoint(x + cellsize/4, y + cellsize/4);
|
|
}
|
|
if(linetype & AutoRouter::solid)
|
|
{
|
|
TQBrush whitefill(TQColor(255, 255, 255));
|
|
|
|
p->fillRect(x + cellsize/6, y + cellsize/6, cellsize/6, cellsize/6, whitefill);
|
|
}
|
|
*/
|
|
x += cellsize/4;
|
|
y += cellsize/4;
|
|
|
|
// both used?
|
|
if(ud_owner != -1 && lr_owner != -1)
|
|
{
|
|
// and not of the same owner?
|
|
if(ud_owner != lr_owner)
|
|
{
|
|
// then we'll have to paint one of them broken
|
|
if(ud_owner > lr_owner)
|
|
lr_break = cellsize/8;
|
|
else
|
|
ud_break = cellsize/8;
|
|
}
|
|
}
|
|
|
|
if(linetype & AutoRouter::left)
|
|
p->drawLine(x - cellsize/4, y, x - lr_break, y);
|
|
if(linetype & AutoRouter::right)
|
|
p->drawLine(x + cellsize/4, y, x + lr_break, y);
|
|
if(linetype & AutoRouter::up)
|
|
p->drawLine(x, y - cellsize/4, x, y - ud_break);
|
|
if(linetype & AutoRouter::down)
|
|
p->drawLine(x, y + cellsize/4, x, y + ud_break);
|
|
}
|
|
|
|
void ModuleWidget::paintConnections(TQPainter *p, int y, int x)
|
|
{
|
|
// paints connections in the given 2x2-autorouter-block being a 1x1 block to the user
|
|
for(int dx = 0; dx < 2; dx++)
|
|
for(int dy = 0; dy < 2; dy++)
|
|
paintConnection(p, (cellsize*dx)/2, (cellsize*dy)/2, x*2 + dx, y*2 + dy);
|
|
}
|
|
|
|
void ModuleWidget::paintCell(TQPainter *p, int y, int x)
|
|
{
|
|
#if 0 /* PORT */
|
|
if(theArtsBuilderApp->eventStackDepth() > 1)
|
|
{
|
|
// FIXME: set some redraw flag or something like that
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
std::list<StructureComponent *>::iterator c;
|
|
for(c = structure->getComponentList()->begin();
|
|
c != structure->getComponentList()->end(); c++)
|
|
{
|
|
StructureComponent *mwc = *c;
|
|
if(y == mwc->y() && mwc->visible())
|
|
{
|
|
int xoffset = x - mwc->x();
|
|
|
|
if(xoffset >= 0 && xoffset < mwc->width())
|
|
{
|
|
if(mwc->drawNeedsBackground(xoffset))
|
|
paintCellBackground(p, y, x);
|
|
|
|
mwc->drawSegment(p, cellsize, xoffset);
|
|
paintConnections(p, y, x);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
paintCellBackground(p, y, x);
|
|
paintConnections(p, y, x);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// public part of modulewidget
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void ModuleWidget::setZoom(int zoom)
|
|
{
|
|
cellsize = (int)(50.0 * (float)zoom/100);
|
|
|
|
setCellHeight(cellsize);
|
|
setCellWidth(cellsize);
|
|
updateTableSize();
|
|
resize(cellsize*cols, cellsize*rows);
|
|
}
|
|
|
|
void ModuleWidget::selectAll()
|
|
{
|
|
setSelectAll(true);
|
|
}
|
|
|
|
void ModuleWidget::reInit()
|
|
{
|
|
emit componentSelected(0);
|
|
selectedPort = 0L;
|
|
|
|
delete activeTool;
|
|
activeTool = 0L;
|
|
|
|
reRoute();
|
|
}
|
|
|
|
void ModuleWidget::delModule()
|
|
{
|
|
int numSelected = structure->countSelected();
|
|
|
|
if(!numSelected) return;
|
|
|
|
if(KMessageBox::warningContinueCancel(0,
|
|
i18n("Delete %n selected module, port or connection? (No undo possible.)",
|
|
"Delete %n selected modules, ports and connections? (No undo possible.)",
|
|
numSelected), TQString(), i18n("&Delete")) == KMessageBox::Continue)
|
|
{
|
|
selectPort(0L);
|
|
emit componentSelected(0);
|
|
structure->deleteSelected();
|
|
reRoute();
|
|
}
|
|
}
|
|
|
|
void ModuleWidget::autoRedrawRouter()
|
|
{
|
|
if(autorouter->needRedraw()) redrawAll();
|
|
}
|
|
|
|
ModuleWidget::ModuleWidget(Structure *structure, TQWidget *parent, const char *name, WFlags f)
|
|
: QtTableView( parent, name, f),
|
|
updateDepth( 0 ),
|
|
activeTool( 0L ),
|
|
structure( structure ),
|
|
selectedPort( 0L )
|
|
{
|
|
arts_debug("PORT: mw; getmodulelist");
|
|
this->ModuleList = structure->getModuleList();
|
|
arts_debug("PORT: mw; cols&rows");
|
|
|
|
cols = 24;
|
|
rows = 32;
|
|
|
|
setNumCols(cols);
|
|
setNumRows(rows);
|
|
setTableFlags(Tbl_autoScrollBars);
|
|
setZoom(100);
|
|
|
|
setFocusPolicy( TQWidget::NoFocus );
|
|
|
|
arts_debug("PORT: mw; bgmode");
|
|
setBackgroundMode(NoBackground);
|
|
|
|
arts_debug("PORT: mw; new ar %d,%d", cols, rows);
|
|
autorouter = new AutoRouter(cols*2, rows*2);
|
|
|
|
arts_debug("PORT: mw; new ar ok - qtimer");
|
|
TQTimer *timer = new TQTimer( this );
|
|
connect( timer, TQ_SIGNAL(timeout()),
|
|
this, TQ_SLOT(autoRedrawRouter()) );
|
|
|
|
arts_debug("PORT: mw; tstart");
|
|
timer->start( 100, FALSE ); // 100 ms reoccurring check
|
|
}
|
|
|
|
ModuleWidget::~ModuleWidget()
|
|
{
|
|
delete autorouter;
|
|
}
|
|
|
|
#include "mwidget.moc"
|