Merge branch 'master' of https://scm.cri.ensmp.fr/git/Faustine
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / headers / schema.h
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22 #ifndef __SCHEMA__
23 #define __SCHEMA__
24
25
26 #include "device.h"
27 #include <vector>
28 #include <string>
29 #include <set>
30
31 using namespace std;
32
33 const double dWire = 8; ///< distance between two wires
34 //const double dLetter = 6; ///< width of a letter
35 const double dLetter = 4.3; ///< width of a letter
36 const double dHorz = 4; ///< marge horizontale
37 const double dVert = 4; ///< marge verticale
38
39
40 struct point
41 {
42 double x;
43 double y;
44
45 point(double u, double v) : x(u), y(v) {}
46 point(const point& p) : x(p.x), y(p.y) {}
47
48 bool operator<(const point& p) const {
49 if (x < p.x) return true;
50 else if (x > p.x) return false;
51 else if (y < p.y) return true;
52 else return false;
53 }
54 };
55
56 struct trait
57 {
58 point start;
59 point end;
60 bool hasRealInput;
61 bool hasRealOutput;
62
63 trait(const point& p1, const point& p2) : start(p1), end(p2) {}
64 void draw(device& dev) const { dev.trait(start.x, start.y, end.x, end.y); }
65
66 bool operator<(const trait& t) const {
67 if (start < t.start) return true;
68 else if (t.start < start) return false;
69 else if (end < t.end) return true;
70 else return false;
71 }
72 };
73
74 struct collector
75 {
76 set<point> fOutputs; // collect real outputs
77 set<point> fInputs; // collect real inputs
78 set<trait> fTraits; // collect traits to draw
79 set<trait> fWithInput; // collect traits with a real input
80 set<trait> fWithOutput; // collect traits with a real output
81
82 void addOutput(const point& p) { fOutputs.insert(p); }
83 void addInput(const point& p) { fInputs.insert(p); }
84 void addTrait(const trait& t) { fTraits.insert(t); }
85 void computeVisibleTraits();
86 bool isVisible(const trait& t);
87 void draw(device& dev);
88 };
89
90 enum { kLeftRight=1, kRightLeft=-1 };
91
92
93
94 /**
95 * An abstract block diagram schema
96 */
97 class schema
98 {
99 private:
100 const unsigned int fInputs;
101 const unsigned int fOutputs;
102 const double fWidth;
103 const double fHeight;
104
105 // fields only defined after place() is called
106 bool fPlaced; ///< false until place() is called
107 double fX;
108 double fY;
109 int fOrientation;
110
111 public:
112
113 schema(unsigned int inputs, unsigned int outputs, double width, double height)
114 : fInputs(inputs),
115 fOutputs(outputs),
116 fWidth(width),
117 fHeight(height),
118 fPlaced(false),
119 fX(0),
120 fY(0),
121 fOrientation(0)
122 {}
123 virtual ~schema() {}
124
125 // constant fields
126 double width() const { return fWidth; }
127 double height() const { return fHeight; }
128 unsigned int inputs() const { return fInputs; }
129 unsigned int outputs() const { return fOutputs; }
130
131 // starts and end placement
132 void beginPlace (double x, double y, int orientation)
133 { fX = x; fY = y; fOrientation = orientation; }
134 void endPlace () { fPlaced = true; }
135
136 // fields available after placement
137 bool placed() const { return fPlaced; }
138 double x() const { return fX; }
139 double y() const { return fY; }
140 int orientation() const { return fOrientation; }
141
142
143 // abstract interface for subclasses
144 virtual void place(double x, double y, int orientation) = 0;
145 virtual void draw(device& dev) = 0;
146 virtual void collectTraits(collector& c) = 0;
147 virtual point inputPoint(unsigned int i) const = 0;
148 virtual point outputPoint(unsigned int i)const = 0;
149 };
150
151 // various functions to create schemas
152
153 schema* makeBlockSchema (unsigned int inputs,
154 unsigned int outputs,
155 const string& name,
156 const string& color,
157 const string& link);
158
159 schema* makeCableSchema (unsigned int n=1);
160 schema* makeInverterSchema (const string& color);
161 schema* makeCutSchema ();
162 schema* makeEnlargedSchema (schema* s, double width);
163 schema* makeParSchema (schema* s1, schema* s2);
164 schema* makeSeqSchema (schema* s1, schema* s2);
165 schema* makeMergeSchema (schema* s1, schema* s2);
166 schema* makeSplitSchema (schema* s1, schema* s2);
167 schema* makeRecSchema (schema* s1, schema* s2);
168 schema* makeTopSchema (schema* s1, double margin, const string& text, const string& link);
169 schema* makeDecorateSchema (schema* s1, double margin, const string& text);
170
171
172
173
174
175
176
177
178
179 #endif
180
181