First cleaning step in "dsp_files" directory.
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / draw / schema / blockSchema.cpp
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
23 #include "blockSchema.h"
24 #include <assert.h>
25
26 using namespace std;
27
28 static double quantize(int n)
29 {
30 int q = 3;
31 return dLetter * (q *((n+q-1)/q));
32 }
33
34 /**
35 * Build a simple colored blockSchema with a certain number of
36 * inputs and outputs, a text to be displayed, and an optional link.
37 * Computes the size of the box according to the length of the text
38 * and the maximum number of ports.
39 */
40 schema* makeBlockSchema ( unsigned int inputs,
41 unsigned int outputs,
42 const string& text,
43 const string& color,
44 const string& link )
45 {
46 // determine the optimal size of the box
47 double minimal = 3*dWire;
48 double w = 2*dHorz + max( minimal, quantize(text.size()) );
49 double h = 2*dVert + max( minimal, max(inputs, outputs) * dWire );
50
51 return new blockSchema(inputs, outputs, w, h, text, color, link);
52 }
53
54 /**
55 * Build a simple colored blockSchema with a certain number of
56 * inputs and outputs, a text to be displayed, and an optional link.
57 * The length of the text as well as th number of inputs and outputs
58 * are used to compute the size of the blockSchema
59 */
60 blockSchema::blockSchema ( unsigned int inputs,
61 unsigned int outputs,
62 double width,
63 double height,
64 const string& text,
65 const string& color,
66 const string& link )
67
68 : schema( inputs, outputs, width, height ),
69 fText(text),
70 fColor(color),
71 fLink(link)
72 {
73 for (unsigned int i=0; i<inputs; i++) fInputPoint.push_back(point(0,0));
74 for (unsigned int i=0; i<outputs; i++) fOutputPoint.push_back(point(0,0));
75 }
76
77 /**
78 * Define the graphic position of the blockSchema. Computes the graphic
79 * position of all the elements, in particular the inputs and outputs.
80 * This method must be called before draw(), otherwise draw is not allowed
81 */
82 void blockSchema::place(double x, double y, int orientation)
83 {
84 beginPlace(x, y, orientation);
85
86 placeInputPoints();
87 placeOutputPoints();
88
89 endPlace();
90 }
91
92 /**
93 * Returns an input point
94 */
95 point blockSchema::inputPoint(unsigned int i) const
96 {
97 assert (placed());
98 assert (i < inputs());
99 return fInputPoint[i];
100 }
101
102 /**
103 * Returns an output point
104 */
105 point blockSchema::outputPoint(unsigned int i) const
106 {
107 assert (placed());
108 assert (i < outputs());
109 return fOutputPoint[i];
110 }
111
112 /**
113 * Computes the input points according to the position and the
114 * orientation of the blockSchema
115 */
116 void blockSchema::placeInputPoints()
117 {
118 int N = inputs();
119
120 if (orientation() == kLeftRight) {
121
122 double px = x();
123 double py = y() + (height() - dWire*(N-1))/2;
124
125 for (int i=0; i<N; i++) {
126 fInputPoint[i] = point(px, py+i*dWire);
127 }
128
129 } else {
130
131 double px = x() + width();
132 double py = y() + height() - (height() - dWire*(N-1))/2;
133
134 for (int i=0; i<N; i++) {
135 fInputPoint[i] = point(px, py-i*dWire);
136 }
137 }
138 }
139
140
141 /**
142 * Computes the output points according to the position and the
143 * orientation of the blockSchema
144 */
145 void blockSchema::placeOutputPoints()
146 {
147 int N = outputs();
148
149 if (orientation() == kLeftRight) {
150
151 double px = x() + width();
152 double py = y() + (height() - dWire*(N-1))/2;
153
154 for (int i=0; i<N; i++) {
155 fOutputPoint[i] = point(px, py + i*dWire);
156 }
157
158 } else {
159
160 double px = x();
161 double py = y() + height() - (height() - dWire*(N-1))/2;
162
163 for (int i=0; i<N; i++) {
164 fOutputPoint[i] = point(px, py - i*dWire);
165 }
166 }
167 }
168
169
170 /**
171 * Draw the blockSchema on the device. This methos can only
172 * be called after the blockSchema have been placed
173 */
174 void blockSchema::draw(device& dev)
175 {
176 assert(placed());
177
178 drawRectangle(dev);
179 drawText(dev);
180 drawOrientationMark(dev);
181 drawInputWires(dev);
182 drawOutputWires(dev);
183 }
184
185 /**
186 * Draw the colored rectangle with the optional link
187 */
188 void blockSchema::drawRectangle(device& dev)
189 {
190 dev.rect( x() + dHorz,
191 y() + dVert,
192 width() - 2*dHorz,
193 height() - 2*dVert,
194 fColor.c_str(),
195 fLink.c_str()
196 );
197 }
198
199
200 /**
201 * Draw the text centered on the box
202 */
203 void blockSchema::drawText(device& dev)
204 {
205 dev.text( x() + width()/2,
206 y() + height()/2,
207 fText.c_str(),
208 fLink.c_str()
209 );
210 }
211
212
213 /**
214 * Draw the orientation mark, a small point that indicates
215 * the first input (like integrated circuits)
216 */
217 void blockSchema::drawOrientationMark(device& dev)
218 {
219 double px, py;
220
221 if (orientation() == kLeftRight) {
222 px = x() + dHorz;
223 py = y() + dVert;
224 } else {
225 px = x() + width() - dHorz;
226 py = y() + height() - dVert;
227 }
228
229 dev.markSens( px, py, orientation() );
230 }
231 #if 1
232 /**
233 * Draw horizontal arrows from the input points to the
234 * blockSchema rectangle
235 */
236 void blockSchema::drawInputWires(device& dev)
237 {
238 double dx = (orientation() == kLeftRight) ? dHorz : -dHorz;
239
240 for (unsigned int i=0; i<inputs(); i++) {
241 point p = fInputPoint[i];
242 //dev.trait(p.x, p.y, p.x+dx, p.y);
243 dev.fleche(p.x+dx, p.y, 0, orientation());
244 }
245 }
246
247 /**
248 * Draw horizontal line from the blockSchema rectangle to the
249 * output points
250 */
251 void blockSchema::drawOutputWires(device& dev)
252 {
253 //double dx = (orientation() == kLeftRight) ? dHorz : -dHorz;
254
255 for (unsigned int i=0; i<outputs(); i++) {
256 point p = fOutputPoint[i];
257 //dev.trait(p.x, p.y, p.x-dx, p.y);
258 }
259 }
260 #endif
261
262 /**
263 * Draw horizontal arrows from the input points to the
264 * blockSchema rectangle
265 */
266 void blockSchema::collectTraits(collector& c)
267 {
268 collectInputWires(c);
269 collectOutputWires(c);
270 }
271
272 /**
273 * Draw horizontal arrows from the input points to the
274 * blockSchema rectangle
275 */
276 void blockSchema::collectInputWires(collector& c)
277 {
278 double dx = (orientation() == kLeftRight) ? dHorz : -dHorz;
279
280 for (unsigned int i=0; i<inputs(); i++) {
281 point p = fInputPoint[i];
282 c.addTrait(trait(point(p.x, p.y), point(p.x+dx, p.y))); // in->out direction
283 c.addInput(point(p.x+dx, p.y));
284 }
285 }
286
287 /**
288 * Draw horizontal line from the blockSchema rectangle to the
289 * output points
290 */
291 void blockSchema::collectOutputWires(collector& c)
292 {
293 double dx = (orientation() == kLeftRight) ? dHorz : -dHorz;
294
295 for (unsigned int i=0; i<outputs(); i++) {
296 point p = fOutputPoint[i];
297 c.addTrait(trait(point(p.x-dx, p.y), point(p.x, p.y))); // in->out direction
298 c.addOutput(point(p.x-dx, p.y));
299 }
300 }
301
302