+++ /dev/null
-/************************************************************************
- ************************************************************************
- FAUST compiler
- Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
- ---------------------------------------------------------------------
- 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.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- ************************************************************************
- ************************************************************************/
-
-
-#include "seqSchema.h"
-#include <iostream>
-#include <assert.h>
-
-using namespace std;
-
-enum {kHorDir, kUpDir, kDownDir}; ///< directions of connections
-
-static double computeHorzGap(schema* a, schema* b);
-static int direction(const point& a, const point& b);
-
-
-//----------------------------INTERFACE--------------------------------
-
-/**
- * Make a sequential schema. May add cables to ensure the internal
- * connections are between the same number of outputs and inputs.
- * Compute an horizontal gap based on the number of upward and
- * downward connections.
- */
-schema * makeSeqSchema (schema* s1, schema* s2)
-{
- unsigned int o = s1->outputs();
- unsigned int i = s2->inputs();
-
- schema* a = (o < i) ? makeParSchema(s1, makeCableSchema(i-o)) : s1;
- schema* b = (o > i) ? makeParSchema(s2, makeCableSchema(o-i)) : s2;
-
- return new seqSchema(a, b, computeHorzGap(a,b));
-}
-
-
-
-//-----------------------IMPLEMENTATION------------------------------
-
-/**
- * Constructor for a sequential schema (s1:s2). The components s1 and s2
- * are supposed to be "compatible" (s1 : n->m and s2 : m->q)
- */
-seqSchema::seqSchema (schema* s1, schema* s2, double hgap)
- : schema( s1->inputs(),
- s2->outputs(),
- s1->width() + hgap + s2->width(),
- max(s1->height(), s2->height()) ),
- fSchema1(s1),
- fSchema2(s2),
- fHorzGap(hgap)
-{
- assert(s1->outputs() == s2->inputs());
-}
-
-
-//-----------------------placement------------------------------
-
-
-/**
- * Place the two components horizontally with enough space
- * for the connections
- */
-void seqSchema::place(double ox, double oy, int orientation)
-{
- beginPlace(ox, oy, orientation);
-
- double y1 = max(0.0, 0.5*(fSchema2->height() - fSchema1->height()));
- double y2 = max(0.0, 0.5*(fSchema1->height() - fSchema2->height()));
-
- if (orientation == kLeftRight) {
- fSchema1->place(ox, oy+y1, orientation);
- fSchema2->place(ox+fSchema1->width()+fHorzGap, oy+y2, orientation);
- } else {
- fSchema2->place(ox, oy+y2, orientation);
- fSchema1->place(ox+fSchema2->width()+fHorzGap, oy+y1, orientation);
- }
- endPlace();
-}
-
-
-/**
- * The input points are the input points of the first component
- */
-point seqSchema::inputPoint(unsigned int i) const
-{
- return fSchema1->inputPoint(i);
-}
-
-
-/**
- * The output points are the output points of the second component
- */
-point seqSchema::outputPoint(unsigned int i) const
-{
- return fSchema2->outputPoint(i);
-}
-
-
-
-//--------------------------drawing------------------------------
-
-
-/**
- * Draw the two components as well as the internal wires
- */
-void seqSchema::draw(device& dev)
-{
- assert(placed());
- assert(fSchema1->outputs() == fSchema2->inputs());
-
- fSchema1->draw(dev);
- fSchema2->draw(dev);
- //drawInternalWires(dev);
-}
-
-/**
- * Draw the two components as well as the internal wires
- */
-void seqSchema::collectTraits(collector& c)
-{
- assert(placed());
- assert(fSchema1->outputs() == fSchema2->inputs());
-
- fSchema1->collectTraits(c);
- fSchema2->collectTraits(c);
- collectInternalWires(c);
-}
-
-
-/**
- * Draw the internal wires aligning the vertical segments in
- * a symetric way when possible.
- */
-
-void seqSchema::drawInternalWires(device& dev)
-{
- assert (fSchema1->outputs() == fSchema2->inputs());
-
- const int N = fSchema1->outputs();
- double dx = 0;
- double mx = 0;
- int dir =-1;
-
- if (orientation() == kLeftRight) {
- // draw left right cables
- for (int i=0; i<N; i++) {
- point src = fSchema1->outputPoint(i);
- point dst = fSchema2->inputPoint(i);
-
- int d = direction(src,dst);
- if (d != dir) {
- // compute attributes of new direction
- switch (d) {
- case kUpDir : mx = 0; dx = dWire; break;
- case kDownDir : mx = fHorzGap; dx = -dWire; break;
- default : mx = 0; dx = 0; break;
- }
- dir = d;
- } else {
- // move in same direction
- mx = mx +dx;
- }
- if (src.y == dst.y) {
- // draw straight cable
- dev.trait(src.x, src.y, dst.x, dst.y);
- } else {
- // draw zizag cable
- dev.trait(src.x, src.y, src.x+mx, src.y);
- dev.trait(src.x+mx, src.y, src.x+mx, dst.y);
- dev.trait(src.x+mx, dst.y, dst.x, dst.y);
- }
-
- }
- } else {
- // draw right left cables
- for (int i=0; i<N; i++) {
- point src = fSchema1->outputPoint(i);
- point dst = fSchema2->inputPoint(i);
-
- int d = direction(src,dst);
- if (d != dir) {
- // compute attributes of new direction
- switch (d) {
- case kUpDir : mx = -fHorzGap; dx = dWire; break;
- case kDownDir : mx = 0; dx = -dWire; break;
- default : mx = 0; dx = 0; break;
- }
- dir = d;
- } else {
- // move in same direction
- mx = mx +dx;
- }
- if (src.y == dst.y) {
- // draw straight cable
- dev.trait(src.x, src.y, dst.x, dst.y);
- } else {
- // draw zizag cable
- dev.trait(src.x, src.y, src.x+mx, src.y);
- dev.trait(src.x+mx, src.y, src.x+mx, dst.y);
- dev.trait(src.x+mx, dst.y, dst.x, dst.y);
- }
-
- }
- }
-}
-
-
-
-/**
- * Draw the internal wires aligning the vertical segments in
- * a symetric way when possible.
- */
-
-void seqSchema::collectInternalWires(collector& c)
-{
- assert (fSchema1->outputs() == fSchema2->inputs());
-
- const int N = fSchema1->outputs();
- double dx = 0;
- double mx = 0;
- int dir =-1;
-
- if (orientation() == kLeftRight) {
- // draw left right cables
- for (int i=0; i<N; i++) {
- point src = fSchema1->outputPoint(i);
- point dst = fSchema2->inputPoint(i);
-
- int d = direction(src,dst);
- if (d != dir) {
- // compute attributes of new direction
- switch (d) {
- case kUpDir : mx = 0; dx = dWire; break;
- case kDownDir : mx = fHorzGap; dx = -dWire; break;
- default : mx = 0; dx = 0; break;
- }
- dir = d;
- } else {
- // move in same direction
- mx = mx +dx;
- }
- if (src.y == dst.y) {
- // draw straight cable
- c.addTrait(trait(point(src.x, src.y), point(dst.x, dst.y)));
- } else {
- // draw zizag cable
- c.addTrait(trait(point(src.x, src.y), point(src.x+mx, src.y)));
- c.addTrait(trait(point(src.x+mx, src.y), point(src.x+mx, dst.y)));
- c.addTrait(trait(point(src.x+mx, dst.y), point(dst.x, dst.y)));
- }
-
- }
- } else {
- // draw right left cables
- for (int i=0; i<N; i++) {
- point src = fSchema1->outputPoint(i);
- point dst = fSchema2->inputPoint(i);
-
- int d = direction(src,dst);
- if (d != dir) {
- // compute attributes of new direction
- switch (d) {
- case kUpDir : mx = -fHorzGap; dx = dWire; break;
- case kDownDir : mx = 0; dx = -dWire; break;
- default : mx = 0; dx = 0; break;
- }
- dir = d;
- } else {
- // move in same direction
- mx = mx +dx;
- }
- if (src.y == dst.y) {
- // draw straight cable
- c.addTrait(trait(point(src.x, src.y), point(dst.x, dst.y)));
- } else {
- // draw zizag cable
- c.addTrait(trait(point(src.x, src.y), point(src.x+mx, src.y)));
- c.addTrait(trait(point(src.x+mx, src.y), point(src.x+mx, dst.y)));
- c.addTrait(trait(point(src.x+mx, dst.y), point(dst.x, dst.y)));
- }
-
- }
- }
-}
-
-//--------------------------helpers------------------------------
-
-
-
-/**
- * Compute the direction of a connection. Note that
- * Y axis goes from top to bottom
- */
-static int direction(const point& a, const point& b)
-{
- if (a.y > b.y) return kUpDir; // upward connections
- if (a.y < b.y) return kDownDir; // downward connection
- return kHorDir; // horizontal connections
-}
-
-/**
- * Compute the horizontal gap needed to draw the internal wires.
- * It depends on the largest group of connections that go in the same
- * direction.
- */
-static double computeHorzGap(schema* a, schema* b)
-{
- assert(a->outputs() == b->inputs());
-
- if (a->outputs() == 0) {
- return 0;
- } else {
- // store here the size of the largest group for each direction
- int MaxGroupSize[3]; for(int i=0; i<3; i++) MaxGroupSize[i]=0;
-
- // place a and b to have valid connection points
- double ya = max(0.0, 0.5*(b->height() - a->height()));
- double yb = max(0.0, 0.5*(a->height() - b->height()));
- a->place(0,ya,kLeftRight);
- b->place(0,yb,kLeftRight);
-
- // init current group direction and size
- int gdir = direction(a->outputPoint(0), b->inputPoint(0));
- int gsize = 1;
-
- // analyze direction of remaining points
- for (unsigned int i=1; i<a->outputs(); i++) {
- int d = direction(a->outputPoint(i), b->inputPoint(i));
- if (d == gdir) {
- gsize++;
- } else {
- if (gsize > MaxGroupSize[gdir]) MaxGroupSize[gdir]=gsize;
- gsize = 1;
- gdir = d;
- }
- }
-
- // update for last group
- if (gsize > MaxGroupSize[gdir]) MaxGroupSize[gdir]=gsize;
-
- // the gap required for the connections
- return dWire * max(MaxGroupSize[kUpDir],MaxGroupSize[kDownDir]);
- }
-}
projects / Faustine.git / blobdiff