Delete svn tags. We don't need them in git
[synfig.git] / synfig-core / trunk / src / synfig / renddesc.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file synfig/renddesc.cpp
3 **      \brief RendDesc
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **      Copyright (c) 2008 Chris Moore
10 **
11 **      This package is free software; you can redistribute it and/or
12 **      modify it under the terms of the GNU General Public License as
13 **      published by the Free Software Foundation; either version 2 of
14 **      the License, or (at your option) any later version.
15 **
16 **      This package is distributed in the hope that it will be useful,
17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 **      General Public License for more details.
20 **      \endlegal
21 */
22 /* ========================================================================= */
23
24 /* === H E A D E R S ======================================================= */
25
26 #ifdef USING_PCH
27 #       include "pch.h"
28 #else
29 #ifdef HAVE_CONFIG_H
30 #       include <config.h>
31 #endif
32
33 #include "renddesc.h"
34 #include <ETL/misc>
35
36 #endif
37
38 /* === U S I N G =========================================================== */
39
40 using namespace std;
41 using namespace etl;
42 using namespace synfig;
43
44 /* === M A C R O S ========================================================= */
45
46 #undef FLAGS
47 #define FLAGS(x,y)              (((x)&(y))==(y))
48
49 /* === G L O B A L S ======================================================= */
50
51 /* === M E T H O D S ======================================================= */
52
53 RendDesc &
54 RendDesc::apply(const RendDesc &x)
55 {
56         operator=(x);
57         return *this;
58 }
59
60 const Color &
61 RendDesc::get_bg_color()const
62 {
63         return background;
64 }
65
66 RendDesc &
67 RendDesc::set_bg_color(const Color &bg)
68 {
69         background=bg; return *this;
70 }
71
72 Real
73 RendDesc::get_physical_w()const
74 {
75         return (Real)get_w()/get_x_res();
76 }
77
78 Real
79 RendDesc::get_physical_h()const
80 {
81         return (Real)get_h()/get_y_res();
82 }
83
84 RendDesc&
85 RendDesc::set_physical_w(Real w)
86 {
87         set_w(round_to_int(w*get_x_res()));
88         return *this;
89 }
90
91 RendDesc&
92 RendDesc::set_physical_h(Real h)
93 {
94         set_h(round_to_int(h*get_y_res()));
95         return *this;
96 }
97
98 int
99 RendDesc::get_w()const
100 {
101         return w_;
102 }
103
104 RendDesc &
105 RendDesc::set_w(int x)
106 {
107         if(FLAGS(flags,LINK_PX_ASPECT)) // never set
108         {
109                 h_=h_*x/w_;
110                 w_=x;
111         }
112         else if(FLAGS(flags,LINK_PX_AREA)) // never set
113         {
114                 //! \writeme
115                 w_=x;
116         }
117         else if(FLAGS(flags,PX_ASPECT)) // "Pixel Aspect"
118         {
119                 Vector d=br_-tl_;
120                 float old_span=get_span();
121
122                 // If we should preserve image width
123                 if(             FLAGS(flags,IM_W)                                                       // "Image Width"
124                         || (FLAGS(flags,IM_ZOOMIN) && d[1]>d[1]/x*w_)   // never set
125                         || (FLAGS(flags,IM_ZOOMOUT) && d[1]<d[1]/x*w_)) // never set
126                 {
127                         br_[1]-=focus[1];
128                         br_[1]=br_[1]/x*w_;
129                         br_[1]+=focus[1];
130                         tl_[1]-=focus[1];
131                         tl_[1]=tl_[1]/x*w_;
132                         tl_[1]+=focus[1];
133                 } else
134                 {
135                         br_[0]-=focus[0];
136                         br_[0]=br_[0]/w_*x;
137                         br_[0]+=focus[0];
138                         tl_[0]-=focus[0];
139                         tl_[0]=tl_[0]/w_*x;
140                         tl_[0]+=focus[0];
141                 }
142
143                 w_=x;
144
145                 if(FLAGS(flags,IM_SPAN)) // "Image Span"
146                         set_span(old_span);
147         }
148         else if(FLAGS(flags,PX_AREA)) // never set
149         {
150                 //! \writeme
151                 w_=x;
152         }
153         else
154                 w_=x;
155
156         return *this;
157 }
158
159 int
160 RendDesc::get_h()const
161 {
162         return h_;
163 }
164
165 RendDesc &
166 RendDesc::set_h(int y)
167 {
168         if(FLAGS(flags,LINK_PX_ASPECT)) // never set
169         {
170                 w_=w_*y/h_;
171                 h_=y;
172         }
173         else if(FLAGS(flags,LINK_PX_AREA)) // never set
174         {
175                 //! \writeme
176                 h_=y;
177         }
178         else if(FLAGS(flags,PX_ASPECT)) // "Pixel Aspect"
179         {
180                 Vector d=br_-tl_;
181                 float old_span=get_span();
182
183                 // If we should preserve image width
184                 if(             FLAGS(flags,IM_W)                                                       // "Image Width"
185                         || (FLAGS(flags,IM_ZOOMIN) && d[0]>d[0]/y*h_)   // never set
186                         || (FLAGS(flags,IM_ZOOMOUT) && d[0]<d[0]/y*h_)) // never set
187                 {
188                         br_[0]-=focus[0];
189                         br_[0]=br_[0]/y*h_;
190                         br_[0]+=focus[0];
191                         tl_[0]-=focus[0];
192                         tl_[0]=tl_[0]/y*h_;
193                         tl_[0]+=focus[0];
194                 } else
195                 {
196                         br_[1]-=focus[1];
197                         br_[1]=br_[1]/h_*y;
198                         br_[1]+=focus[1];
199                         tl_[1]-=focus[1];
200                         tl_[1]=tl_[1]/h_*y;
201                         tl_[1]+=focus[1];
202                 }
203
204                 h_=y;
205
206                 if(FLAGS(flags,IM_SPAN)) // "Image Span"
207                         set_span(old_span);
208         }
209         else if(FLAGS(flags,PX_AREA)) // never set
210         {
211                 //! \writeme
212                 h_=y;
213         }
214         else
215                 h_=y;
216
217         return *this;
218 }
219
220 RendDesc &
221 RendDesc::set_wh(int x, int y)
222 {
223         // FIXME: This is a working hack...
224         set_w(x);
225         set_h(y);
226
227         return *this;
228 }
229
230 Real
231 RendDesc::get_x_res()const
232 {
233         return x_res;
234 }
235
236 RendDesc &
237 RendDesc::set_x_res(Real x)
238 {
239         x_res=x; return *this;
240 }
241
242 Real
243 RendDesc::get_y_res()const
244 {
245         return y_res;
246 }
247
248 RendDesc &
249 RendDesc::set_y_res(Real y)
250 {
251         y_res=y; return *this;
252 }
253
254 int
255 RendDesc::get_frame_start()const
256 {
257         return round_to_int(time_begin*frame_rate);
258 }
259
260 RendDesc &
261 RendDesc::set_frame_start(int x)
262 {
263         return set_time_start(Time(x)/frame_rate);
264 }
265
266 int
267 RendDesc::get_frame_end()const
268 {
269         return round_to_int(time_end*frame_rate);
270 }
271
272 RendDesc &
273 RendDesc::set_frame_end(int x)
274 {
275         return set_time_end(Time(x)/frame_rate);
276 }
277
278
279 const Time
280 RendDesc::get_time_start()const
281 {
282         return time_begin;
283 }
284
285 RendDesc &
286 RendDesc::set_time_start(Time x)
287 {
288         if(x>time_end)
289                 time_begin=time_end=x;
290         else
291                 time_begin=x;
292         return *this;
293 }
294
295
296 const Time
297 RendDesc::get_time_end()const
298 {
299         return time_end;
300 }
301
302 RendDesc &
303 RendDesc::set_time_end(Time x)
304 {
305         if(x<time_begin)
306                 time_end=time_begin=x;
307         else
308                 time_end=x;
309         return *this;
310 }
311
312 RendDesc &
313 RendDesc::set_time(Time x)
314 {
315         time_end=time_begin=x;
316         return *this;
317 }
318
319 RendDesc &
320 RendDesc::set_frame(int x)
321 {
322         return set_time(Time(x)/frame_rate);
323 }
324
325 const float &
326 RendDesc::get_frame_rate()const
327 {
328         return frame_rate;
329 }
330
331 RendDesc &
332 RendDesc::set_frame_rate(float x)
333 {
334         frame_rate=x;
335         return *this;
336 }
337
338 const bool &
339 RendDesc::get_interlaced()const
340 {
341         return interlaced;
342 }
343
344 RendDesc &
345 RendDesc::set_interlaced(bool x)
346 { interlaced=x; return *this; }
347
348 //! Return the status of the clamp flag
349 const bool &
350 RendDesc::get_clamp()const
351 { return clamp; }
352
353 //! Set the clamp flag
354 RendDesc &
355 RendDesc::set_clamp(bool x)
356 { clamp=x; return *this; }
357
358 //! Set constraint flags
359 RendDesc &
360 RendDesc::set_flags(const int &x)
361 { flags=x; return *this; }
362
363 //! Clear constraint flags
364 RendDesc &
365 RendDesc::clear_flags()
366 { flags=0; return *this; }
367
368 int
369 RendDesc::get_flags()const
370 { return flags; }
371
372
373 //!     Return the aspect ratio of a single pixel
374 Real
375 RendDesc::get_pixel_aspect()const
376 {
377         Vector tmp=br_-tl_;
378         tmp[0]/=w_;
379         tmp[1]/=h_;
380         tmp[0]/=tmp[1];
381         if(tmp[0]<0.0)
382                 return -tmp[0];
383         return tmp[0];
384 }
385
386 //!     Return the aspect ratio of the entire image
387 Real
388 RendDesc::get_image_aspect()const
389 {
390         Point tmp=br_-tl_;
391         tmp[0]/=tmp[1];
392         if(tmp[0]<0.0)
393                 return -tmp[0];
394         return tmp[0];
395 }
396
397
398 //! Return the antialias amount
399 const int &
400 RendDesc::get_antialias()const
401 { return a; }
402
403 //! Set the antialias amount
404 RendDesc &
405 RendDesc::set_antialias(const int &x)
406 { a=x; return *this; }
407
408
409 //! Return the distance from the bottom-right to the top-left
410 Real
411 RendDesc::get_span()const
412 {
413         return (br_-tl_).mag();
414 }
415
416 //! Set the span distance
417 RendDesc &
418 RendDesc::set_span(const Real &x)
419 {
420         Vector::value_type ratio=x/get_span();
421
422         //! \todo this looks wrong.  I suspect the intention was to check
423         //                "(not IM_W) AND (not IM_H)", ie "not(IM_W OR IM_H)" but
424         //                this check does "not(IM_W AND IM_H)"
425         if(!FLAGS(flags,IM_W|IM_H) || FLAGS(flags,IM_ASPECT)) // (not "Image Width") or (not "Image Height") or "Image Aspect"
426         {
427                 br_-=focus;
428                 br_=br_*ratio;
429                 br_+=focus;
430                 tl_-=focus;
431                 tl_=tl_*ratio;
432                 tl_+=focus;
433         }
434         else if(FLAGS(flags,IM_W))      // "Image Width"
435         {
436                 //! \writeme or fix me
437                 br_-=focus;
438                 br_=br_*ratio;
439                 br_+=focus;
440                 tl_-=focus;
441                 tl_=tl_*ratio;
442                 tl_+=focus;
443         }else // IM_H                           // "Image Height"
444         {
445                 //! \writeme or fix me
446                 br_-=focus;
447                 br_=br_*ratio;
448                 br_+=focus;
449                 tl_-=focus;
450                 tl_=tl_*ratio;
451                 tl_+=focus;
452         }
453
454         return *this;
455 }
456
457
458 /*
459 const Gamma &
460 RendDesc::get_gamma()const
461 { return gamma; }
462
463 RendDesc &
464 RendDesc::set_gamma(const Gamma &x)
465 { gamma=x; return *this;  }
466 */
467
468 const Point &
469 RendDesc::get_focus()const
470 { return focus; }
471
472 RendDesc &
473 RendDesc::set_focus(const Point &x)
474 { focus=x; return *this; }
475
476
477 const Point &
478 RendDesc::get_tl()const
479 { return tl_; }
480
481 const Point &
482 RendDesc::get_br()const
483 { return br_; }
484
485 RendDesc &
486 RendDesc::set_tl(const Point &x)
487 {
488         if(FLAGS(flags,PX_ASPECT)) // "Pixel Aspect"
489         {
490                 Vector new_size(x-br_);
491                 new_size[0]=abs(new_size[0]);
492                 new_size[1]=abs(new_size[1]);
493
494                 Vector old_size(tl_-br_);
495                 old_size[0]=abs(old_size[0]);
496                 old_size[1]=abs(old_size[1]);
497
498                 if(new_size[0]!=old_size[0])
499                         w_=round_to_int(new_size[0]*w_/old_size[0]);
500
501                 if(new_size[1]!=old_size[1])
502                         h_=round_to_int(new_size[1]*h_/old_size[1]);
503         }
504
505         tl_=x; return *this;
506 }
507
508 RendDesc &
509 RendDesc::set_br(const Point &x)
510 {
511         if(FLAGS(flags,PX_ASPECT)) // "Pixel Aspect"
512         {
513                 Vector new_size(x-tl_);
514                 new_size[0]=abs(new_size[0]);
515                 new_size[1]=abs(new_size[1]);
516
517                 Vector old_size(tl_-br_);
518                 old_size[0]=abs(old_size[0]);
519                 old_size[1]=abs(old_size[1]);
520
521                 if(new_size[0]!=old_size[0])
522                         w_=round_to_int(new_size[0]*w_/old_size[0]);
523
524                 if(new_size[1]!=old_size[1])
525                         h_=round_to_int(new_size[1]*h_/old_size[1]);
526         }
527         br_=x; return *this;
528 }
529
530 RendDesc &
531 RendDesc::set_viewport(const Point &__tl, const Point &__br)
532 { tl_=__tl; br_=__br; return *this; }
533
534 RendDesc &
535 RendDesc::set_viewport(Vector::value_type a, Vector::value_type b, Vector::value_type c, Vector::value_type d)
536 { tl_=Point(a,b); br_=Point(c,d); return *this; }
537
538 Real
539 RendDesc::get_pw()const
540 {
541         return (br_[0] - tl_[0]) / w_;
542 }
543
544 Real
545 RendDesc::get_ph()const
546 {
547         return (br_[1] - tl_[1]) / h_;
548 }
549
550 RendDesc &
551 RendDesc::set_subwindow(int x, int y, int w, int h)
552 {
553         const Real pw(get_pw());
554         const Real ph(get_ph());
555
556         tl_[0]+=pw*x;
557         tl_[1]+=ph*y;
558
559         br_[0]-=pw*(w_-(x+w));
560         br_[1]-=ph*(h_-(y+h));
561
562         w_=w;
563         h_=h;
564
565         return *this;
566 }