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.
978 lines
25 KiB
978 lines
25 KiB
/***************************************************************************
|
|
* Copyright (C) 2003-2005 by David Saxton *
|
|
* david@bluehaze.org *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
***************************************************************************/
|
|
|
|
#include "canvasitemparts.h"
|
|
#include "connector.h"
|
|
#include "flowcodedocument.h"
|
|
#include "flowcode.h"
|
|
#include "flowpart.h"
|
|
#include "fpnode.h"
|
|
#include "itemdocument.h"
|
|
#include "itemdocumentdata.h"
|
|
#include "microsettings.h"
|
|
#include "micropackage.h"
|
|
#include "picinfo.h"
|
|
#include "pinmapping.h"
|
|
#include "variant.h"
|
|
|
|
#include <kdebug.h>
|
|
|
|
#include <tqbitarray.h>
|
|
#include <tqbitmap.h>
|
|
#include <tqpainter.h>
|
|
#include <tqpixmap.h>
|
|
#include <tqregexp.h>
|
|
|
|
#include <assert.h>
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
|
|
// The following arrays of numbers represent the positions of nodes in different configurations,
|
|
// with the numbers as NodeInfo::Position.
|
|
|
|
Node::node_dir diamondNodePositioning[8][3] = {
|
|
{Node::dir_up, Node::dir_down, Node::dir_right},
|
|
{Node::dir_up, Node::dir_down, Node::dir_left},
|
|
{Node::dir_up, Node::dir_right,Node::dir_down},
|
|
{Node::dir_up, Node::dir_right,Node::dir_left},
|
|
{Node::dir_left,Node::dir_right,Node::dir_down},
|
|
{Node::dir_left,Node::dir_right,Node::dir_up},
|
|
{Node::dir_left,Node::dir_down, Node::dir_right},
|
|
{Node::dir_left,Node::dir_down, Node::dir_up} };
|
|
|
|
Node::node_dir inOutNodePositioning[8][2] = {
|
|
{Node::dir_up,Node::dir_down},
|
|
{Node::dir_up,Node::dir_right},
|
|
{Node::dir_up,Node::dir_left},
|
|
{Node::dir_right,Node::dir_right}, // (invalid)
|
|
{Node::dir_left,Node::dir_right},
|
|
{Node::dir_left,Node::dir_down},
|
|
{Node::dir_left,Node::dir_up},
|
|
{Node::dir_right,Node::dir_right} }; // (invalid)
|
|
|
|
Node::node_dir inNodePositioning[4] = {Node::dir_up,Node::dir_right,Node::dir_down,Node::dir_left};
|
|
|
|
Node::node_dir outNodePositioning[4] = {Node::dir_down,Node::dir_left,Node::dir_up,Node::dir_right};
|
|
|
|
FlowPart::FlowPart( ICNDocument *icnDocument, bool newItem, const TQString &id )
|
|
: CNItem( icnDocument, newItem, id )
|
|
{
|
|
icnDocument->registerItem(this);
|
|
m_pFlowCodeDocument = dynamic_cast<FlowCodeDocument*>(icnDocument);
|
|
assert( m_pFlowCodeDocument );
|
|
|
|
m_flowSymbol = FlowPart::ps_other;
|
|
m_orientation = 0;
|
|
m_stdInput = 0l;
|
|
m_stdOutput = 0l;
|
|
m_altOutput = 0l;
|
|
|
|
connect( m_pFlowCodeDocument, TQT_SIGNAL(picTypeChanged()), this, TQT_SLOT(slotUpdateFlowPartVariables()) );
|
|
connect( m_pFlowCodeDocument, TQT_SIGNAL(pinMappingsChanged()), this, TQT_SLOT(slotUpdateFlowPartVariables()) );
|
|
}
|
|
|
|
|
|
FlowPart::~FlowPart()
|
|
{
|
|
// We have to check view, as if the item is deleted before the CNItem constructor
|
|
// is called, then there will be no view
|
|
if (m_pFlowCodeDocument)
|
|
{
|
|
const VariantDataMap::iterator end = m_variantData.end();
|
|
for ( VariantDataMap::iterator it = m_variantData.begin(); it != end; ++it )
|
|
{
|
|
Variant *v = it.data();
|
|
if (v)
|
|
m_pFlowCodeDocument->varNameChanged( "", v->value().toString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FlowPart::setCaption( const TQString &caption )
|
|
{
|
|
if ( m_flowSymbol == FlowPart::ps_other )
|
|
{
|
|
m_caption = caption;
|
|
return;
|
|
}
|
|
|
|
TQWidget *w = new TQWidget();
|
|
TQPainter p(w);
|
|
p.setFont( font() );
|
|
const int text_width = p.boundingRect( boundingRect(), (TQt::SingleLine | TQt::AlignHCenter | TQt::AlignVCenter), caption ).width();
|
|
p.end();
|
|
delete w;
|
|
int width = std::max( ((int)(text_width/16))*16, 48 );
|
|
|
|
switch(m_flowSymbol)
|
|
{
|
|
case FlowPart::ps_call:
|
|
{
|
|
width += 48;
|
|
break;
|
|
}
|
|
case FlowPart::ps_io:
|
|
case FlowPart::ps_round:
|
|
{
|
|
width += 32;
|
|
break;
|
|
}
|
|
case FlowPart::ps_decision:
|
|
{
|
|
width += 64;
|
|
break;
|
|
}
|
|
case FlowPart::ps_process:
|
|
default:
|
|
{
|
|
width += 32;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool hasSideConnectors = m_flowSymbol == FlowPart::ps_decision;
|
|
if ( hasSideConnectors && (width != this->width()) )
|
|
p_icnDocument->requestRerouteInvalidatedConnectors();
|
|
|
|
initSymbol( m_flowSymbol, width );
|
|
m_caption = caption;
|
|
}
|
|
void FlowPart::postResize()
|
|
{
|
|
updateNodePositions();
|
|
CNItem::postResize();
|
|
}
|
|
|
|
void FlowPart::createStdInput()
|
|
{
|
|
m_stdInput = (FPNode*)createNode( 0, 0, Node::dir_up, "stdinput", Node::fp_in );
|
|
updateNodePositions();
|
|
}
|
|
void FlowPart::createStdOutput()
|
|
{
|
|
m_stdOutput = (FPNode*)createNode( 0, 0, Node::dir_down, "stdoutput", Node::fp_out );
|
|
updateNodePositions();
|
|
}
|
|
void FlowPart::createAltOutput()
|
|
{
|
|
m_altOutput = (FPNode*)createNode( 0, 0, Node::dir_right, "altoutput", Node::fp_out );
|
|
updateNodePositions();
|
|
}
|
|
|
|
void FlowPart::initSymbol( FlowPart::FlowSymbol symbol, int width )
|
|
{
|
|
m_flowSymbol = symbol;
|
|
|
|
switch(symbol)
|
|
{
|
|
case FlowPart::ps_other:
|
|
{
|
|
return;
|
|
}
|
|
case FlowPart::ps_call:
|
|
case FlowPart::ps_process:
|
|
{
|
|
setItemPoints( TQRect( -width/2, -16, width, 24 ) );
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_io:
|
|
{
|
|
// define parallelogram shape
|
|
TQPointArray pa(4);
|
|
pa[0] = TQPoint( -(width-10)/2, -16 );
|
|
pa[1] = TQPoint( width/2, -16 );
|
|
pa[2] = TQPoint( (width-10)/2, 8 );
|
|
pa[3] = TQPoint( -width/2, 8 );
|
|
setItemPoints(pa);
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_round:
|
|
{
|
|
// define rounded rectangles as two semicricles with RP_NUM/2 points with gap inbetween
|
|
// These points are not used for drawing; merely for passing to qcanvaspolygonitem for collision detection
|
|
// If there is a better way for a rounder rectangle + collision detection, please let me know...
|
|
|
|
int halfHeight = 12;
|
|
|
|
// Draw semicircle
|
|
double x;
|
|
const int RP_NUM = 48;
|
|
TQPointArray pa(RP_NUM);
|
|
int point = 0;
|
|
for ( double y = -1.0; y <= 1.0; y+= 4.0/(RP_NUM-2) )
|
|
{
|
|
x = sqrt(1-y*y)*halfHeight;
|
|
pa[point] = TQPoint( (int)(width+x)-halfHeight, (int)(halfHeight*y) );
|
|
pa[RP_NUM-1-point] = TQPoint ( (int)(halfHeight-x), (int)(halfHeight*y) );
|
|
point++;
|
|
}
|
|
|
|
pa.translate( -width/2, 4 );
|
|
setItemPoints(pa);
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_decision:
|
|
{
|
|
// define rhombus
|
|
TQPointArray pa(6);
|
|
pa[0] = TQPoint( 0, -24 );
|
|
pa[1] = TQPoint( width/2, -6 );
|
|
pa[2] = TQPoint( width/2, 6 );
|
|
pa[3] = TQPoint( 0, 24 );
|
|
pa[4] = TQPoint( -width/2, 6 );
|
|
pa[5] = TQPoint( -width/2, -6 );
|
|
setItemPoints(pa);
|
|
break;
|
|
}
|
|
default: kdError() << k_funcinfo << "Unknown flowSymbol: "<<symbol<<endl;
|
|
}
|
|
}
|
|
|
|
void FlowPart::drawShape( TQPainter &p )
|
|
{
|
|
initPainter(p);
|
|
|
|
const double _x = int( x() + offsetX() );
|
|
const double _y = int( y() + offsetY() );
|
|
const double w = width();
|
|
double h = height();
|
|
|
|
switch (m_flowSymbol)
|
|
{
|
|
case FlowPart::ps_other:
|
|
{
|
|
CNItem::drawShape(p);
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_io:
|
|
{
|
|
h--;
|
|
double roundSize = 8;
|
|
double slantIndent = 5;
|
|
|
|
const double pi = 3.1415926536;
|
|
const double DPR = 180./pi;
|
|
// CNItem::drawShape(p);
|
|
double inner = std::atan(h/slantIndent);
|
|
double outer = pi-inner;
|
|
|
|
int inner16 = int(16*inner*DPR);
|
|
int outer16 = int(16*outer*DPR);
|
|
|
|
p.save();
|
|
p.setPen( TQt::NoPen );
|
|
p.drawPolygon( areaPoints() );
|
|
p.restore();
|
|
|
|
p.drawLine( int(_x+slantIndent+roundSize/2), int(_y), int(_x+w-roundSize/2), int(_y) );
|
|
p.drawLine( int(_x-slantIndent+w-roundSize/2), int(_y+h), int(_x+roundSize/2), int(_y+h) );
|
|
p.drawLine( int(_x+w+(std::sin(outer)-1)*(roundSize/2)), int(_y+(1-std::cos(outer))*(roundSize/2)),
|
|
int(_x+w-slantIndent+(std::sin(inner)-1)*(roundSize/2)), int(_y+h+(std::cos(inner)-1)*(roundSize/2)) );
|
|
p.drawLine( int(_x+(1-std::sin(outer))*(roundSize/2)), int(_y+h+(std::cos(outer)-1)*(roundSize/2)),
|
|
int(_x+slantIndent+(1-std::sin(inner))*(roundSize/2)), int(_y+(1-std::cos(inner))*(roundSize/2)) );
|
|
|
|
p.drawArc( int(_x+slantIndent), int(_y), int(roundSize), int(roundSize), 90*16, inner16 );
|
|
p.drawArc( int(_x+w-roundSize), int(_y), int(roundSize), int(roundSize), 270*16+inner16, outer16 );
|
|
p.drawArc( int(_x-slantIndent+w-roundSize), int(_y+h-roundSize), int(roundSize), int(roundSize), 270*16, inner16 );
|
|
p.drawArc( int(_x), int(_y+h-roundSize), int(roundSize), int(roundSize), 90*16+inner16, outer16) ;
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_decision:
|
|
{
|
|
// TODO Make the shape nice and pretty with rounded corners
|
|
CNItem::drawShape(p);
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_call:
|
|
{
|
|
p.drawRoundRect( int(_x), int(_y), int(w), int(h+1), int(1000./w), int(1000./h) );
|
|
p.drawLine( int(_x+8), int(_y), int(_x+8), int(_y+h) );
|
|
p.drawLine( int(_x+w-8), int(_y), int(_x+w-8), int(_y+h) );
|
|
break;
|
|
}
|
|
case FlowPart::ps_process:
|
|
{
|
|
p.drawRoundRect( int(_x), int(_y), int(w), int(h+1), int(1000./w), int(1000./h) );
|
|
break;
|
|
}
|
|
|
|
case FlowPart::ps_round:
|
|
{
|
|
p.drawRoundRect( int(_x), int(_y), int(w), int(h+1), 30, 100 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
p.setPen( TQt::black );
|
|
p.setFont( font() );
|
|
p.drawText( boundingRect(), (TQt::WordBreak | TQt::AlignHCenter | TQt::AlignVCenter), m_caption );
|
|
}
|
|
|
|
TQString FlowPart::gotoCode( const TQString& internalNodeId )
|
|
{
|
|
FlowPart *end = outputPart(internalNodeId);
|
|
if (!end) return "";
|
|
return "goto "+end->id();
|
|
}
|
|
|
|
FlowPart* FlowPart::outputPart( const TQString& internalNodeId )
|
|
{
|
|
Node *node = p_icnDocument->nodeWithID( nodeId(internalNodeId) );
|
|
|
|
FPNode *fpnode = dynamic_cast<FPNode*>(node);
|
|
if ( !fpnode || fpnode->type() == Node::fp_in )
|
|
return 0l;
|
|
|
|
return fpnode->outputFlowPart();
|
|
}
|
|
|
|
FlowPartList FlowPart::inputParts( const TQString& id )
|
|
{
|
|
Node *node = p_icnDocument->nodeWithID(id);
|
|
|
|
if ( FPNode *fpNode = dynamic_cast<FPNode*>(node) )
|
|
return fpNode->inputFlowParts();
|
|
|
|
return FlowPartList();
|
|
}
|
|
|
|
FlowPartList FlowPart::inputParts()
|
|
{
|
|
FlowPartList list;
|
|
|
|
const NodeMap::iterator nEnd = m_nodeMap.end();
|
|
for ( NodeMap::iterator it = m_nodeMap.begin(); it != nEnd; ++it )
|
|
{
|
|
Node *node = p_icnDocument->nodeWithID( it.data().id );
|
|
FlowPartList newList;
|
|
|
|
if ( FPNode *fpNode = dynamic_cast<FPNode*>(node) )
|
|
newList = fpNode->inputFlowParts();
|
|
|
|
const FlowPartList::iterator nlEnd = newList.end();
|
|
for ( FlowPartList::iterator it = newList.begin(); it != nlEnd; ++it )
|
|
{
|
|
if (*it) list.append(*it);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
FlowPartList FlowPart::outputParts()
|
|
{
|
|
FlowPartList list;
|
|
|
|
const NodeMap::iterator end = m_nodeMap.end();
|
|
for ( NodeMap::iterator it = m_nodeMap.begin(); it != end; ++it )
|
|
{
|
|
FlowPart *part = outputPart( it.key() );
|
|
if (part) list.append(part);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
|
|
FlowPart* FlowPart::endPart( TQStringList ids, FlowPartList *previousParts )
|
|
{
|
|
if ( ids.empty() )
|
|
{
|
|
const NodeMap::iterator end = m_nodeMap.end();
|
|
for ( NodeMap::iterator it = m_nodeMap.begin(); it != end; ++it )
|
|
{
|
|
ids.append( it.key() );
|
|
}
|
|
filterEndPartIDs( &ids );
|
|
}
|
|
|
|
const bool createdList = (!previousParts);
|
|
if (createdList) {
|
|
previousParts = new FlowPartList;
|
|
} else if ( previousParts->contains(this) ) {
|
|
return 0l;
|
|
}
|
|
previousParts->append(this);
|
|
|
|
if ( ids.empty() ) {
|
|
return 0l;
|
|
}
|
|
if ( ids.size() == 1 ) {
|
|
return outputPart( *(ids.begin()) );
|
|
}
|
|
|
|
typedef TQValueList<FlowPartList> ValidPartsList;
|
|
ValidPartsList validPartsList;
|
|
|
|
const TQStringList::iterator idsEnd = ids.end();
|
|
for ( TQStringList::iterator it = ids.begin(); it != idsEnd; ++it )
|
|
{
|
|
int prevLevel = level();
|
|
FlowPartList validParts;
|
|
FlowPart *part = outputPart(*it);
|
|
while (part)
|
|
{
|
|
if ( !validParts.contains(part) )
|
|
{
|
|
validParts.append(part);
|
|
// if ( part->level() >= level() ) {
|
|
const int _l = part->level();
|
|
part = part->endPart( TQStringList(), previousParts );
|
|
prevLevel = _l;
|
|
// } else {
|
|
// part = 0l;
|
|
// }
|
|
}
|
|
else {
|
|
part = 0l;
|
|
}
|
|
}
|
|
if ( !validParts.empty() ) {
|
|
validPartsList.append(validParts);
|
|
}
|
|
}
|
|
|
|
if (createdList)
|
|
{
|
|
delete previousParts;
|
|
previousParts = 0l;
|
|
}
|
|
|
|
if ( validPartsList.empty() ) return 0l;
|
|
|
|
FlowPartList firstList = *(validPartsList.begin());
|
|
const FlowPartList::iterator flEnd = firstList.end();
|
|
const ValidPartsList::iterator vplEnd = validPartsList.end();
|
|
for ( FlowPartList::iterator it = firstList.begin(); it != flEnd; ++it )
|
|
{
|
|
bool ok = true;
|
|
for ( ValidPartsList::iterator vplit = validPartsList.begin(); vplit != vplEnd; ++vplit )
|
|
{
|
|
if ( !(*vplit).contains(*it) ) ok = false;
|
|
}
|
|
if (ok) return *it;
|
|
}
|
|
|
|
return 0l;
|
|
}
|
|
|
|
|
|
void FlowPart::handleIfElse( FlowCode *code, const TQString &case1Statement, const TQString &case2Statement,
|
|
const TQString &case1, const TQString &case2 )
|
|
{
|
|
if (!code) return;
|
|
|
|
FlowPart *stop = 0l;
|
|
FlowPart *part1 = outputPart(case1);
|
|
FlowPart *part2 = outputPart(case2);
|
|
|
|
if ( part1 && part2 ) stop = endPart( TQStringList::split( ',', case1+","+case2 ) );
|
|
|
|
if ( (!part1 && !part2) || (part1 == stop && part2 == stop) ) return;
|
|
|
|
code->addStopPart(stop);
|
|
|
|
if ( part1 && part1 != stop && code->isValidBranch(part1) )
|
|
{
|
|
// Use the case1 statement
|
|
code->addCode( "if "+case1Statement+" then "+"\n{" );
|
|
code->addCodeBranch(part1);
|
|
code->addCode("}");
|
|
|
|
if ( part2 && part2 != stop && code->isValidBranch(part2) )
|
|
{
|
|
code->addCode( "else\n{" );
|
|
code->addCodeBranch(part2);
|
|
code->addCode("}");
|
|
}
|
|
}
|
|
else if ( code->isValidBranch(part2) )
|
|
{
|
|
// Use the case2 statement
|
|
code->addCode( "if "+case2Statement+" then "+"\n{" );
|
|
code->addCodeBranch(part2);
|
|
code->addCode("}");
|
|
}
|
|
|
|
code->removeStopPart(stop);
|
|
code->addCodeBranch(stop);
|
|
}
|
|
|
|
|
|
Variant * FlowPart::createProperty( const TQString & id, Variant::Type::Value type )
|
|
{
|
|
if ( type != Variant::Type::Port
|
|
&& type != Variant::Type::Pin
|
|
&& type != Variant::Type::VarName
|
|
&& type != Variant::Type::SevenSegment
|
|
&& type != Variant::Type::KeyPad )
|
|
return CNItem::createProperty( id, type );
|
|
|
|
Variant * v = createProperty( id, Variant::Type::String );
|
|
v->setType(type);
|
|
|
|
if ( type == Variant::Type::VarName )
|
|
{
|
|
if ( MicroSettings * settings = m_pFlowCodeDocument->microSettings() )
|
|
v->setAllowed( settings->variableNames() );
|
|
connect( property(id), TQT_SIGNAL(valueChanged(TQVariant, TQVariant )), this, TQT_SLOT(varNameChanged(TQVariant, TQVariant )) );
|
|
}
|
|
else
|
|
slotUpdateFlowPartVariables();
|
|
|
|
return v;
|
|
}
|
|
|
|
|
|
void FlowPart::slotUpdateFlowPartVariables()
|
|
{
|
|
if (!m_pFlowCodeDocument)
|
|
return;
|
|
|
|
MicroSettings *s = m_pFlowCodeDocument->microSettings();
|
|
if (!s)
|
|
return;
|
|
|
|
const PinMappingMap pinMappings = s->pinMappings();
|
|
TQStringList sevenSegMaps;
|
|
TQStringList keyPadMaps;
|
|
PinMappingMap::const_iterator pEnd = pinMappings.end();
|
|
for ( PinMappingMap::const_iterator it = pinMappings.begin(); it != pEnd; ++it )
|
|
{
|
|
switch ( it.data().type() )
|
|
{
|
|
case PinMapping::SevenSegment:
|
|
sevenSegMaps << it.key();
|
|
break;
|
|
|
|
case PinMapping::Keypad_4x3:
|
|
case PinMapping::Keypad_4x4:
|
|
keyPadMaps << it.key();
|
|
break;
|
|
|
|
case PinMapping::Invalid:
|
|
break;
|
|
}
|
|
}
|
|
|
|
TQStringList ports = s->microInfo()->package()->portNames();
|
|
ports.sort();
|
|
|
|
TQStringList pins = s->microInfo()->package()->pinIDs(PicPin::type_bidir | PicPin::type_input | PicPin::type_open);
|
|
pins.sort();
|
|
|
|
const VariantDataMap::iterator vEnd = m_variantData.end();
|
|
for ( VariantDataMap::iterator it = m_variantData.begin(); it != vEnd; ++it )
|
|
{
|
|
Variant * v = it.data();
|
|
if ( !v )
|
|
continue;
|
|
|
|
if ( v->type() == Variant::Type::Port )
|
|
v->setAllowed( ports );
|
|
|
|
else if ( v->type() == Variant::Type::Pin )
|
|
v->setAllowed( pins );
|
|
|
|
else if ( v->type() == Variant::Type::SevenSegment )
|
|
{
|
|
v->setAllowed( sevenSegMaps );
|
|
if ( !sevenSegMaps.isEmpty() && !sevenSegMaps.contains( v->value().toString() ) )
|
|
v->setValue( sevenSegMaps.first() );
|
|
}
|
|
|
|
else if ( v->type() == Variant::Type::KeyPad )
|
|
{
|
|
v->setAllowed( keyPadMaps );
|
|
if ( !keyPadMaps.isEmpty() && !keyPadMaps.contains( v->value().toString() ) )
|
|
v->setValue( keyPadMaps.first() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FlowPart::updateVarNames()
|
|
{
|
|
if (!m_pFlowCodeDocument)
|
|
return;
|
|
|
|
MicroSettings *s = m_pFlowCodeDocument->microSettings();
|
|
if (!s)
|
|
return;
|
|
|
|
const TQStringList names = s->variableNames();
|
|
const VariantDataMap::iterator end = m_variantData.end();
|
|
for ( VariantDataMap::iterator it = m_variantData.begin(); it != end; ++it )
|
|
{
|
|
Variant *v = it.data();
|
|
if ( v && v->type() == Variant::Type::VarName )
|
|
v->setAllowed(names);
|
|
}
|
|
}
|
|
|
|
|
|
void FlowPart::varNameChanged( TQVariant newValue, TQVariant oldValue )
|
|
{
|
|
if (!m_pFlowCodeDocument)
|
|
return;
|
|
m_pFlowCodeDocument->varNameChanged( newValue.asString(), oldValue.asString() );
|
|
}
|
|
|
|
|
|
inline int nodeDirToPos( Node::node_dir dir )
|
|
{
|
|
switch (dir)
|
|
{
|
|
case Node::dir_right:
|
|
return 0;
|
|
case Node::dir_up:
|
|
return 1;
|
|
case Node::dir_left:
|
|
return 2;
|
|
case Node::dir_down:
|
|
return 3;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void FlowPart::updateAttachedPositioning( )
|
|
{
|
|
if (b_deleted)
|
|
return;
|
|
|
|
//BEGIN Rearrange text if appropriate
|
|
const TQRect textPos[4] = {
|
|
TQRect( offsetX()+width(), 6, 40, 16 ),
|
|
TQRect( 0, offsetY()-16, 40, 16 ),
|
|
TQRect( offsetX()-40, 6, 40, 16 ),
|
|
TQRect( 0, offsetY()+height(), 40, 16 ) };
|
|
|
|
NodeInfo * stdOutputInfo = m_stdOutput ? &m_nodeMap["stdoutput"] : 0;
|
|
NodeInfo * altOutputInfo = m_altOutput ? &m_nodeMap["altoutput"] : 0l;
|
|
|
|
Text *outputTrueText = m_textMap.contains("output_true") ? m_textMap["output_true"] : 0l;
|
|
Text *outputFalseText = m_textMap.contains("output_false") ? m_textMap["output_false"] : 0l;
|
|
|
|
if ( stdOutputInfo && outputTrueText )
|
|
outputTrueText->setOriginalRect( textPos[ nodeDirToPos( (Node::node_dir)stdOutputInfo->orientation ) ] );
|
|
|
|
if ( altOutputInfo && outputFalseText )
|
|
outputFalseText->setOriginalRect( textPos[ nodeDirToPos( (Node::node_dir)altOutputInfo->orientation ) ] );
|
|
|
|
const TextMap::iterator textMapEnd = m_textMap.end();
|
|
for ( TextMap::iterator it = m_textMap.begin(); it != textMapEnd; ++it )
|
|
{
|
|
TQRect pos = it.data()->recommendedRect();
|
|
it.data()->move( pos.x() + x(), pos.y() + y() );
|
|
it.data()->setGuiPartSize( pos.width(), pos.height() );
|
|
}
|
|
//END Rearrange text if appropriate
|
|
|
|
const NodeMap::iterator end = m_nodeMap.end();
|
|
for ( NodeMap::iterator it = m_nodeMap.begin(); it != end; ++it )
|
|
{
|
|
if ( !it.data().node )
|
|
{
|
|
kdError() << k_funcinfo << "Node in nodemap is null" << endl;
|
|
continue;
|
|
}
|
|
|
|
double nx = it.data().x;
|
|
double ny = it.data().y;
|
|
|
|
#define round_8(x) (((x) > 0) ? int(((x)+4)/8)*8 : int(((x)-4)/8)*8)
|
|
nx = round_8(nx);
|
|
ny = round_8(ny);
|
|
#undef round_8
|
|
|
|
it.data().node->move( int(nx+x()), int(ny+y()) );
|
|
it.data().node->setOrientation( (Node::node_dir)it.data().orientation );
|
|
}
|
|
}
|
|
|
|
|
|
ItemData FlowPart::itemData( ) const
|
|
{
|
|
ItemData itemData = CNItem::itemData();
|
|
itemData.orientation = m_orientation;
|
|
return itemData;
|
|
}
|
|
|
|
|
|
void FlowPart::restoreFromItemData( const ItemData & itemData )
|
|
{
|
|
CNItem::restoreFromItemData(itemData);
|
|
if ( itemData.orientation >= 0 )
|
|
setOrientation( uint(itemData.orientation) );
|
|
}
|
|
|
|
|
|
void FlowPart::updateNodePositions()
|
|
{
|
|
if ( m_orientation > 7 )
|
|
{
|
|
kdWarning() << k_funcinfo << "Invalid orientation: "<<m_orientation<<endl;
|
|
return;
|
|
}
|
|
|
|
NodeInfo * stdInputInfo = m_stdInput ? &m_nodeMap["stdinput"] : 0l;
|
|
NodeInfo * stdOutputInfo = m_stdOutput ? &m_nodeMap["stdoutput"] : 0;
|
|
NodeInfo * altOutputInfo = m_altOutput ? &m_nodeMap["altoutput"] : 0l;
|
|
|
|
if ( m_stdInput && m_stdOutput && m_altOutput )
|
|
{
|
|
stdInputInfo->orientation = diamondNodePositioning[m_orientation][0];
|
|
stdOutputInfo->orientation = diamondNodePositioning[m_orientation][1];
|
|
altOutputInfo->orientation = diamondNodePositioning[m_orientation][2];
|
|
}
|
|
else if ( m_stdInput && m_stdOutput )
|
|
{
|
|
stdInputInfo->orientation = inOutNodePositioning[m_orientation][0];
|
|
stdOutputInfo->orientation = inOutNodePositioning[m_orientation][1];
|
|
}
|
|
else if ( m_orientation < 4 )
|
|
{
|
|
if (stdInputInfo)
|
|
stdInputInfo->orientation = inNodePositioning[m_orientation];
|
|
else if (stdOutputInfo)
|
|
stdOutputInfo->orientation = outNodePositioning[m_orientation];
|
|
}
|
|
else
|
|
{
|
|
kdWarning() << k_funcinfo << "Invalid orientation: "<<m_orientation<<endl;
|
|
return;
|
|
}
|
|
|
|
const NodeMap::iterator end = m_nodeMap.end();
|
|
for ( NodeMap::iterator it = m_nodeMap.begin(); it != end; ++it )
|
|
{
|
|
if ( !it.data().node )
|
|
kdError() << k_funcinfo << "Node in nodemap is null" << endl;
|
|
|
|
else
|
|
{
|
|
switch ( it.data().orientation )
|
|
{
|
|
case Node::dir_right:
|
|
it.data().x = offsetX()+width()+8;
|
|
it.data().y = 0;
|
|
break;
|
|
case Node::dir_up:
|
|
it.data().x = 0;
|
|
it.data().y = offsetY()-8;
|
|
break;
|
|
case Node::dir_left:
|
|
it.data().x = offsetX()-8;
|
|
it.data().y = 0;
|
|
break;
|
|
case Node::dir_down:
|
|
it.data().x = 0;
|
|
it.data().y = offsetY()+height()+8;;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateAttachedPositioning();
|
|
}
|
|
|
|
|
|
void FlowPart::setOrientation( uint orientation )
|
|
{
|
|
if ( orientation == m_orientation )
|
|
return;
|
|
|
|
m_orientation = orientation;
|
|
updateNodePositions();
|
|
p_icnDocument->requestRerouteInvalidatedConnectors();
|
|
}
|
|
|
|
|
|
uint FlowPart::allowedOrientations( ) const
|
|
{
|
|
// The bit positions shown here represent whether or not that orientation is allowed, the orientation being
|
|
// what is displayed in the i'th position (0 to 3 on top, 4 to 7 on bottom) of orientation widget
|
|
|
|
if ( m_stdInput && m_stdOutput && m_altOutput )
|
|
return 255;
|
|
|
|
if ( m_stdInput && m_stdOutput )
|
|
return 119;
|
|
|
|
if ( m_stdInput || m_stdOutput )
|
|
return 15;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void FlowPart::orientationPixmap( uint orientation, TQPixmap & pm ) const
|
|
{
|
|
const TQSize size = pm.size();
|
|
|
|
if ( ! ( allowedOrientations() & ( 1 << orientation ) ) )
|
|
{
|
|
kdWarning() << k_funcinfo << "Requesting invalid orientation of " << orientation << endl;
|
|
return;
|
|
}
|
|
|
|
TQBitmap mask( 50, 50 );
|
|
TQPainter maskPainter(&mask);
|
|
mask.fill( TQt::color0 );
|
|
maskPainter.setBrush(TQt::color1);
|
|
maskPainter.setPen(TQt::color1);
|
|
|
|
TQPainter p(&pm);
|
|
p.setBrush(m_brushCol);
|
|
p.setPen( TQt::black );
|
|
|
|
// In order: right corner, top corner, left corner, bottom corner
|
|
|
|
TQPoint c[4] = {
|
|
TQPoint( int(0.7*size.width()), int(0.5*size.height()) ),
|
|
TQPoint( int(0.5*size.width()), int(0.4*size.height()) ),
|
|
TQPoint( int(0.3*size.width()), int(0.5*size.height()) ),
|
|
TQPoint( int(0.5*size.width()), int(0.6*size.height()) ) };
|
|
|
|
TQPoint d[4];
|
|
d[0] = c[0] + TQPoint( 7, 0 );
|
|
d[1] = c[1] + TQPoint( 0, -7 );
|
|
d[2] = c[2] + TQPoint( -7, 0 );
|
|
d[3] = c[3] + TQPoint( 0, 7 );
|
|
|
|
if ( m_stdInput && m_stdOutput && m_altOutput )
|
|
{
|
|
//BEGIN Draw diamond outline
|
|
TQPointArray diamond(4);
|
|
for ( uint i=0; i<4; ++i )
|
|
diamond[i] = c[i];
|
|
|
|
p.drawPolygon(diamond);
|
|
maskPainter.drawPolygon(diamond);
|
|
//END Draw diamond outline
|
|
|
|
|
|
//BEGIN Draw input
|
|
int pos0 = nodeDirToPos( diamondNodePositioning[orientation][0] );
|
|
p.drawLine( c[pos0], d[pos0] );
|
|
maskPainter.drawLine( c[pos0], d[pos0] );
|
|
//END Draw input
|
|
|
|
|
|
//BEGIN Draw "true" output as a tick
|
|
TQPointArray tick(4);
|
|
tick[0] = TQPoint( -3, 0 );
|
|
tick[1] = TQPoint( 0, 2 );
|
|
tick[2] = TQPoint( 0, 2 );
|
|
tick[3] = TQPoint( 4, -2 );
|
|
|
|
int pos1 = nodeDirToPos( diamondNodePositioning[orientation][1] );
|
|
tick.translate( d[pos1].x(), d[pos1].y() );
|
|
p.drawLineSegments(tick);
|
|
maskPainter.drawLineSegments(tick);
|
|
//END Draw "true" output as a tick
|
|
|
|
|
|
//BEGIN Draw "false" output as a cross
|
|
TQPointArray cross(4);
|
|
cross[0] = TQPoint( -2, -2 );
|
|
cross[1] = TQPoint( 2, 2 );
|
|
cross[2] = TQPoint( -2, 2 );
|
|
cross[3] = TQPoint( 2, -2 );
|
|
|
|
int pos2 = nodeDirToPos( diamondNodePositioning[orientation][2] );
|
|
cross.translate( d[pos2].x(), d[pos2].y() );
|
|
p.drawLineSegments(cross);
|
|
maskPainter.drawLineSegments(cross);
|
|
//END Draw "false" output as a cross
|
|
}
|
|
|
|
else if ( m_stdInput || m_stdOutput )
|
|
{
|
|
p.drawRoundRect( int(0.3*size.width()), int(0.4*size.height()), int(0.4*size.width()), int(0.2*size.height()) );
|
|
maskPainter.drawRoundRect( int(0.3*size.width()), int(0.4*size.height()), int(0.4*size.width()), int(0.2*size.height()) );
|
|
|
|
int hal = 5; // half arrow length
|
|
int haw = 3; // half arrow width
|
|
|
|
TQPoint arrows[4][6] = {
|
|
{ TQPoint( hal, 0 ), TQPoint( 0, -haw ),
|
|
TQPoint( hal, 0 ), TQPoint( -hal, 0 ),
|
|
TQPoint( hal, 0 ), TQPoint( 0, haw ) },
|
|
|
|
{ TQPoint( 0, -hal ), TQPoint( -haw, 0 ),
|
|
TQPoint( 0, -hal ), TQPoint( 0, hal ),
|
|
TQPoint( 0, -hal ), TQPoint( haw, 0 ) },
|
|
|
|
{ TQPoint( -hal, 0 ), TQPoint( 0, -haw ),
|
|
TQPoint( -hal, 0 ), TQPoint( hal, 0 ),
|
|
TQPoint( -hal, 0 ), TQPoint( 0, haw ) },
|
|
|
|
{ TQPoint( 0, hal ), TQPoint( -haw, 0 ),
|
|
TQPoint( 0, hal ), TQPoint( 0, -hal ),
|
|
TQPoint( 0, hal ), TQPoint( haw, 0 ) } };
|
|
|
|
int inPos = -1;
|
|
int outPos = -1;
|
|
|
|
if ( m_stdInput && m_stdOutput )
|
|
{
|
|
inPos = nodeDirToPos( inOutNodePositioning[orientation][0] );
|
|
outPos = nodeDirToPos( inOutNodePositioning[orientation][1] );
|
|
}
|
|
else if ( m_stdInput )
|
|
{
|
|
inPos = nodeDirToPos( inNodePositioning[orientation] );
|
|
}
|
|
else if ( m_stdOutput )
|
|
{
|
|
outPos = nodeDirToPos( outNodePositioning[orientation] );
|
|
}
|
|
|
|
if ( inPos != -1 )
|
|
{
|
|
TQPointArray inArrow(6);
|
|
for ( int i=0; i<6; ++i )
|
|
{
|
|
inArrow[i] = arrows[(inPos+2)%4][i];
|
|
}
|
|
inArrow.translate( d[inPos].x(), d[inPos].y() );
|
|
p.drawPolygon(inArrow);
|
|
maskPainter.drawPolygon(inArrow);
|
|
}
|
|
|
|
if ( outPos != -1 )
|
|
{
|
|
TQPointArray outArrow(6);
|
|
for ( int i=0; i<6; ++i )
|
|
{
|
|
outArrow[i] = arrows[outPos][i];
|
|
}
|
|
outArrow.translate( d[outPos].x(), d[outPos].y() );
|
|
p.drawPolygon(outArrow);
|
|
maskPainter.drawPolygon(outArrow);
|
|
}
|
|
}
|
|
|
|
pm.setMask(mask);
|
|
}
|
|
|
|
|
|
#include "flowpart.moc"
|
|
|
|
|