1 /**************************************************************************\
2  * Copyright (c) Kongsberg Oil & Gas Technologies AS
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  * Redistributions of source code must retain the above copyright notice,
10  * this list of conditions and the following disclaimer.
11  *
12  * Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * Neither the name of the copyright holder nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 \**************************************************************************/
32 
33 /*!
34   \class SoVectorizeAction SoVectorizeAction.h Inventor/annex/HardCopy/SoVectorizeAction.h
35   \brief The SoVectorizeAction class is the base class for vectorizing Coin scene graphs.
36 
37   \ingroup hardcopy
38 
39   SoVectorizeAction will traverse the scene graph and convert all
40   supported geometry into vectorized data. Subclasses can then use
41   this data to produce vector files of different formats.
42 
43   Currently supported geometry:
44 
45   \li Triangles (polygons will be tessellated)
46   \li Line segments
47   \li Points (can be drawn as circles or squares)
48   \li 2D text
49   \li 3D text (will be converted to triangles)
50   \li Images (from the SoImage node)
51 
52   The geometry will be shaded based on the OpenGL shading model, so
53   lights and material will affect the geometry in the same way as in a
54   standard Coin viewer. Please note that neither transparency nor
55   texture mapping is supported yet.
56 
57   \since Coin 2.1
58   \since TGS provides HardCopy support as a separate extension for TGS Inventor.
59 */
60 
61 /*!
62   \enum SoVectorizeAction::DimensionUnit
63 
64   The unit used by the scene graph.
65 */
66 
67 /*!
68   \var SoVectorizeAction::DimensionUnit SoVectorizeAction::INCH
69 */
70 
71 /*!
72   \var SoVectorizeAction::DimensionUnit SoVectorizeAction::MM
73 */
74 
75 /*!
76   \var SoVectorizeAction::DimensionUnit SoVectorizeAction::METER
77 */
78 
79 
80 /*!
81   \enum SoVectorizeAction::Orientation
82 
83   The drawing orientation.
84 */
85 
86 /*!
87   \var SoVectorizeAction::Orientation SoVectorizeAction::PORTRAIT
88 */
89 /*!
90   \var SoVectorizeAction::Orientation SoVectorizeAction::LANDSCAPE
91 */
92 
93 /*!
94   \enum SoVectorizeAction::PageSize
95 
96   The size of the destination page.
97 */
98 
99 
100 /*!
101   \var SoVectorizeAction::PageSize SoVectorizeAction::A0
102   841 x 1189 mm.
103 */
104 
105 /*!
106   \var SoVectorizeAction::PageSize SoVectorizeAction::A1
107   594 x 841 mm.
108 */
109 
110 /*!
111   \var SoVectorizeAction::PageSize SoVectorizeAction::A2
112   420 x 594 mm.
113 */
114 
115 /*!
116   \var SoVectorizeAction::PageSize SoVectorizeAction::A3
117   297 x 420 mm.
118 */
119 
120 /*!
121   \var SoVectorizeAction::PageSize SoVectorizeAction::A4
122   210 x 297 mm.
123 */
124 
125 /*!
126   \var SoVectorizeAction::PageSize SoVectorizeAction::A5
127   148 x 210 mm.
128 */
129 
130 /*!
131   \var SoVectorizeAction::PageSize SoVectorizeAction::A6
132   105 x 148 mm.
133 */
134 
135 /*!
136   \var SoVectorizeAction::PageSize SoVectorizeAction::A7
137   74 x 105 mm.
138 */
139 
140 /*!
141   \var SoVectorizeAction::PageSize SoVectorizeAction::A8
142   52 x 74 mm.
143 */
144 
145 /*!
146   \var SoVectorizeAction::PageSize SoVectorizeAction::A9
147   37 x 52 mm.
148 */
149 
150 /*!
151   \var SoVectorizeAction::PageSize SoVectorizeAction::A10
152   26 x 37 mm.
153 */
154 
155 /*!
156   \enum SoVectorizeAction::PointStyle
157   Enumerates point rendering styles.
158 */
159 
160 /*!
161   \var SoVectorizeAction::PointStyle SoVectorizeAction::CIRCLE
162 
163   Render points as circles.
164 */
165 
166 /*!
167   \var SoVectorizeAction::PointStyle SoVectorizeAction::SQUARE
168 
169   Render points as squares.
170 */
171 
172 /*!
173   \fn void SoVectorizeAction::printHeader(void) const
174   \COININTERNAL
175 */
176 
177 // *************************************************************************
178 
179 #include <Inventor/annex/HardCopy/SoVectorizeAction.h>
180 #include "coindefs.h"
181 
182 #include <Inventor/SbViewportRegion.h>
183 
184 #include "hardcopy/VectorizeActionP.h"
185 #include "actions/SoSubActionP.h"
186 
187 // *************************************************************************
188 
189 #define PRIVATE(p) (p->pimpl)
190 #define PUBLIC(p) (p->publ)
191 
192 // *************************************************************************
193 
194 SO_ACTION_SOURCE(SoVectorizeAction);
195 
196 // *************************************************************************
197 
198 // Doc in parent
199 void
initClass(void)200 SoVectorizeAction::initClass(void)
201 {
202    SO_ACTION_INTERNAL_INIT_CLASS(SoVectorizeAction, SoCallbackAction);
203 }
204 
205 /*!
206   Default constructor.
207 */
SoVectorizeAction(void)208 SoVectorizeAction::SoVectorizeAction(void)
209 {
210   PRIVATE(this) = new SoVectorizeActionP(this);
211   SO_ACTION_CONSTRUCTOR(SoVectorizeAction);
212 }
213 
214 /*!
215   Destructor.
216 */
~SoVectorizeAction()217 SoVectorizeAction::~SoVectorizeAction()
218 {
219   delete PRIVATE(this);
220 }
221 
222 // *************************************************************************
223 
224 /*!
225   Returns the SoVectorOutput class used by this action. The output
226   is written to stdout by default, but you can change this by using
227   SoVectorOutput::openFile().
228 */
229 SoVectorOutput *
getOutput(void) const230 SoVectorizeAction::getOutput(void) const
231 {
232   if (PRIVATE(this)->output == NULL) {
233     PRIVATE(this)->output = new SoVectorOutput;
234   }
235   return PRIVATE(this)->output;
236 }
237 
238 // doc in parent
239 void
apply(SoNode * node)240 SoVectorizeAction::apply(SoNode * node)
241 {
242   inherited::apply(node);
243 }
244 
245 // doc in parent
246 void
apply(SoPath * path)247 SoVectorizeAction::apply(SoPath * path)
248 {
249   inherited::apply(path);
250 }
251 
252 // doc in parent
253 void
apply(const SoPathList & pathlist,SbBool obeysrules)254 SoVectorizeAction::apply(const SoPathList & pathlist, SbBool obeysrules)
255 {
256   inherited::apply(pathlist, obeysrules);
257 }
258 
259 /*!
260 
261   Begin writing a page. This will write file header information and
262   print background (if enabled) and border.
263 
264 */
265 void
beginPage(const SbVec2f & startpagepos,const SbVec2f & pagesize,DimensionUnit u)266 SoVectorizeAction::beginPage(const SbVec2f & startpagepos,
267                              const SbVec2f & pagesize,
268                              DimensionUnit u)
269 {
270   PRIVATE(this)->page.startpos = to_mm(startpagepos, u);
271   PRIVATE(this)->page.size = to_mm(pagesize, u);
272 
273   PRIVATE(this)->viewport.startpos = to_mm(startpagepos, u);
274   PRIVATE(this)->viewport.size = to_mm(pagesize, u);
275 
276   // set up a viewport so that the aspect ratio will match the page
277   SbVec2f s = this->getRotatedViewportSize();
278   float m = SbMax(s[0], s[1]);
279 
280   SbVec2s ss;
281   ss[0] = (short) ((s[0] / m) * 32767.0f);
282   ss[1] = (short) ((s[1] / m) * 32767.0f);
283   this->setViewportRegion(SbViewportRegion(ss));
284 
285   // print header and page information
286   this->printHeader();
287   this->beginViewport(startpagepos, pagesize, u);
288   if (PRIVATE(this)->background.on) this->printBackground();
289 }
290 
291 /*!
292   End page. This will write all remaining geometry, and write the file footer.
293 */
294 
295 void
endPage(void)296 SoVectorizeAction::endPage(void)
297 {
298   this->endViewport();
299   this->printFooter();
300 }
301 
302 /*!
303   Begin writing a viewport inside the current page.
304 
305   \sa beginPage(), endViewport()
306 */
307 void
beginViewport(const SbVec2f & start,const SbVec2f & size,DimensionUnit u)308 SoVectorizeAction::beginViewport(const SbVec2f & start, const SbVec2f & size,
309                                  DimensionUnit u)
310 {
311   if (start[0] < 0.0f || start[1] < 0.0f) {
312     PRIVATE(this)->viewport.startpos = PRIVATE(this)->page.startpos;
313   }
314   else {
315     PRIVATE(this)->viewport.startpos = to_mm(start, u);
316   }
317   if (size[0] <= 0.0f || size[1] <= 0.0f) {
318     PRIVATE(this)->viewport.size = PRIVATE(this)->page.size;
319   }
320   else {
321     PRIVATE(this)->viewport.size = to_mm(size, u);
322   }
323   PRIVATE(this)->reset();
324 
325   // this will set up clipping (for postscript, at least)
326   this->printViewport();
327 
328   // set up a SbViewportRegion (used by SoCallbackAction) so that the
329   // aspect ratio will match the page
330   SbVec2f s = this->getRotatedViewportSize();
331   float m = SbMax(s[0], s[1]);
332 
333   SbVec2s ss;
334   ss[0] = (short) ((s[0] / m) * 32767.0f);
335   ss[1] = (short) ((s[1] / m) * 32767.0f);
336   this->setViewportRegion(SbViewportRegion(ss));
337 }
338 
339 /*!
340   End writing a viewport. This will flush all vector items.
341 */
342 void
endViewport(void)343 SoVectorizeAction::endViewport(void)
344 {
345   if (PRIVATE(this)->itemlist.getLength()) {
346     PRIVATE(this)->outputItems();
347     PRIVATE(this)->reset();
348   }
349 }
350 
351 /*!
352   Will calibrate pixel based attributes (font size, line width,
353   points size, etc) so that it will match OpenGL rendering done in
354   \a vp.
355 
356   \sa setPixelSize()
357   \sa setNominalWidth()
358 */
359 void
calibrate(const SbViewportRegion & vp)360 SoVectorizeAction::calibrate(const SbViewportRegion & vp)
361 {
362   SbVec2s vpsize = vp.getViewportSizePixels();
363   PRIVATE(this)->pixelimagesize = this->getPageSize()[1] / float(vpsize[1]);
364   PRIVATE(this)->nominalwidth = this->getPageSize()[1] / float(vpsize[1]);
365 }
366 
367 /*!
368   Sets the orientation to \a o.
369 */
370 void
setOrientation(Orientation o)371 SoVectorizeAction::setOrientation(Orientation o)
372 {
373   PRIVATE(this)->orientation = o;
374 }
375 
376 /*!
377   Returns the current orientation.
378 
379   \sa setOrientation()
380 */
381 
382 SoVectorizeAction::Orientation
getOrientation(void) const383 SoVectorizeAction::getOrientation(void) const
384 {
385   return PRIVATE(this)->orientation;
386 }
387 
388 /*!
389   Sets the background color. If \a bg is \e FALSE, the background will
390   not be cleared before rendering. If \a bg is \e TRUE, the background
391   will be cleared to \a col before in beginPage().
392 */
393 void
setBackgroundColor(SbBool bg,const SbColor & col)394 SoVectorizeAction::setBackgroundColor(SbBool bg, const SbColor & col)
395 {
396   PRIVATE(this)->background.on = bg;
397   PRIVATE(this)->background.color = col;
398 }
399 
400 /*!
401   Returns if the background will be cleared or not. When this function
402   returns \e TRUE, \a col will be set to the background color.
403 */
404 SbBool
getBackgroundColor(SbColor & col) const405 SoVectorizeAction::getBackgroundColor(SbColor & col) const
406 {
407   col = PRIVATE(this)->background.color;
408   return PRIVATE(this)->background.on;
409 }
410 
411 /*!
412   Sets how to convert pixel based attributes (line width and point
413   size) to vector sizes. By default 1 pixel equals 0.35 mm.
414 
415   \sa calibrate()
416 */
417 void
setNominalWidth(float w,DimensionUnit u)418 SoVectorizeAction::setNominalWidth(float w, DimensionUnit u)
419 {
420   PRIVATE(this)->nominalwidth = to_mm(w, u);
421 }
422 
423 float
getNominalWidth(DimensionUnit u) const424 SoVectorizeAction::getNominalWidth(DimensionUnit u) const
425 {
426   return from_mm(PRIVATE(this)->nominalwidth, u);
427 }
428 
429 /*!
430   Sets how the images and 2D fonts are converted. By default 1
431   pixel equals 0.35 mm.
432 
433 
434   \sa calibrate()
435 */
436 void
setPixelImageSize(float w,DimensionUnit u)437 SoVectorizeAction::setPixelImageSize(float w, DimensionUnit u)
438 {
439   PRIVATE(this)->pixelimagesize = to_mm(w, u);
440 }
441 
442 /*!
443   Returns the pixel image size.
444 
445   \sa setPixelImageSize()
446 */
447 float
getPixelImageSize(DimensionUnit u) const448 SoVectorizeAction::getPixelImageSize(DimensionUnit u) const
449 {
450   return from_mm(PRIVATE(this)->pixelimagesize, u);
451 }
452 
453 /*!
454   Sets the points rendering style. Default style is CIRCLE.
455 */
456 void
setPointStyle(const PointStyle & style)457 SoVectorizeAction::setPointStyle(const PointStyle & style)
458 {
459   PRIVATE(this)->pointstyle = style;
460 }
461 
462 /*!
463   Returns the points rendering style.
464 */
465 SoVectorizeAction::PointStyle
getPointStyle(void) const466 SoVectorizeAction::getPointStyle(void) const
467 {
468   return PRIVATE(this)->pointstyle;
469 }
470 
471 
472 /*!
473   \COININTERNAL
474 
475   Should be overridden by subclasses to print file footer data.
476  */
477 void
printFooter(void) const478 SoVectorizeAction::printFooter(void) const
479 {
480 }
481 
482 /*!
483   \COININTERNAL
484 
485   Should be overridden by subclasses to print background data.
486 */
487 void
printBackground(void) const488 SoVectorizeAction::printBackground(void) const
489 {
490 }
491 
492 /*!
493   \COININTERNAL
494 
495   Should be overridden by subclasses to set up the current page viewport.
496 */
497 void
printViewport(void) const498 SoVectorizeAction::printViewport(void) const
499 {
500 
501 }
502 
503 /*!
504   \COININTERNAL
505 
506   Should be overridden by subclasses to print an item.
507 */
508 void
printItem(const SoVectorizeItem * COIN_UNUSED_ARG (item)) const509 SoVectorizeAction::printItem(const SoVectorizeItem * COIN_UNUSED_ARG(item)) const
510 {
511 }
512 
513 /*!
514   Convenience method for subclasses. Will return the viewport startpos,
515   taking the orientation into account
516 */
517 SbVec2f
getRotatedViewportStartpos(void) const518 SoVectorizeAction::getRotatedViewportStartpos(void) const
519 {
520   SbVec2f p = PRIVATE(this)->viewport.startpos;
521 
522   if (this->getOrientation() == LANDSCAPE) SbSwap(p[0], p[1]);
523   return p;
524 }
525 
526 
527 /*!
528   Convenience method for subclasses. Will return the viewport size,
529   taking the orientation into account
530 */
531 SbVec2f
getRotatedViewportSize(void) const532 SoVectorizeAction::getRotatedViewportSize(void) const
533 {
534   SbVec2f p = PRIVATE(this)->viewport.size;
535 
536   if (this->getOrientation() == LANDSCAPE) SbSwap(p[0], p[1]);
537   return p;
538 }
539 
540 /*!
541   Should be used by subclasses to set the SoVectorOutput
542   instance that should be used.
543 */
544 void
setOutput(SoVectorOutput * output)545 SoVectorizeAction::setOutput(SoVectorOutput * output)
546 {
547   if (PRIVATE(this)->output) {
548     delete PRIVATE(this)->output;
549   }
550   PRIVATE(this)->output = output;
551 }
552 
553 /*!
554   Converts pixels to normalized units.
555  */
556 float
pixelsToUnits(const int pixels)557 SoVectorizeAction::pixelsToUnits(const int pixels)
558 {
559   float mm = this->getPixelImageSize() * pixels;
560   float ps = this->getPageSize()[1];
561   return mm / ps;
562 }
563 
564 /*!
565   Returns the current page startpos.
566 */
567 const SbVec2f &
getPageStartpos(void) const568 SoVectorizeAction::getPageStartpos(void) const
569 {
570   return PRIVATE(this)->page.startpos;
571 }
572 
573 /*!
574   Returns the current page size.
575 */
576 const SbVec2f &
getPageSize(void) const577 SoVectorizeAction::getPageSize(void) const
578 {
579   return PRIVATE(this)->page.size;
580 }
581 
582 /*!
583   Returns the bps tree used to store triangle and line vertices.
584 */
585 const SbBSPTree &
getBSPTree(void) const586 SoVectorizeAction::getBSPTree(void) const
587 {
588   return PRIVATE(this)->bsp;
589 }
590 
591 void
beginStandardPage(const PageSize & pagesize,const float border)592 SoVectorizeAction::beginStandardPage(const PageSize & pagesize, const float border)
593 {
594   static int a_table[] = {
595     // A0 - A10
596     841, 1189,
597     594, 841,
598     420, 594,
599     297, 420,
600     210, 297,
601     148, 210,
602     105, 148,
603     74, 105,
604     52, 74,
605     37, 52,
606     26, 37,
607     // B0 - B10 (might add later)
608   };
609 
610   int idx = (int) pagesize;
611   assert(idx >=0 && idx <= 10);
612 
613   float xdim = (float) a_table[idx*2];
614   float ydim = (float) a_table[idx*2+1];
615 
616   this->beginPage(SbVec2f(border, border), SbVec2f(xdim-2.0f*border, ydim-2.0f*border), MM);
617 }
618 
619 /*!
620   Sets the drawing dimensions. You can use this and setStartPosition() instead
621   of using beginViewport(). Provided for TGS OIV compatibility.
622 
623   \sa beginViewport()
624 */
625 void
setDrawingDimensions(const SbVec2f & d,DimensionUnit u)626 SoVectorizeAction::setDrawingDimensions(const SbVec2f & d, DimensionUnit u)
627 {
628   PRIVATE(this)->viewport.size = to_mm(d, u);
629 }
630 
631 /*!
632   Returns the current drawing dimensions.
633 */
634 SbVec2f
getDrawingDimensions(DimensionUnit u) const635 SoVectorizeAction::getDrawingDimensions(DimensionUnit u) const
636 {
637   return from_mm(PRIVATE(this)->viewport.size, u);
638 }
639 
640 /*!
641   Sets the drawing staring position. You can use this and setDrawingDimensions() instead
642   of using beginViewport(). Provided for TGS OIV compatibility.
643 */
644 void
setStartPosition(const SbVec2f & p,DimensionUnit u)645 SoVectorizeAction::setStartPosition(const SbVec2f & p, DimensionUnit u)
646 {
647   PRIVATE(this)->viewport.startpos = to_mm(p, u);
648 
649 }
650 
651 /*!
652   Returns the current drawing starting position.
653 */
654 SbVec2f
getStartPosition(DimensionUnit u) const655 SoVectorizeAction::getStartPosition(DimensionUnit u) const
656 {
657   return from_mm(PRIVATE(this)->viewport.startpos, u);
658 }
659 
660 /*!
661   Not implemented yet. Provided for TGS OIV compatibility.
662 */
663 void
setColorTranslationMethod(ColorTranslationMethod COIN_UNUSED_ARG (method))664 SoVectorizeAction::setColorTranslationMethod(ColorTranslationMethod COIN_UNUSED_ARG(method))
665 {
666 }
667 
668 /*!
669   Not implemented yet. Provided for TGS OIV compatibility.
670 */
671 SoVectorizeAction::ColorTranslationMethod
getColorTranslationMethod(void) const672 SoVectorizeAction::getColorTranslationMethod(void) const
673 {
674   return AS_IS;
675 }
676 
677 /*!
678   Not implemented yet. Provided for TGS OIV compatibility.
679 */
680 void
setLineEndStyle(EndLineStyle COIN_UNUSED_ARG (style))681 SoVectorizeAction::setLineEndStyle(EndLineStyle COIN_UNUSED_ARG(style))
682 {
683 }
684 
685 /*!
686   Not implemented yet. Provided for TGS OIV compatibility.
687 */
688 SoVectorizeAction::EndLineStyle
getLineEndStyle(void) const689 SoVectorizeAction::getLineEndStyle(void) const
690 {
691   return BUTT_END;
692 }
693 
694 /*!
695   Not implemented yet. Provided for TGS OIV compatibility.
696 */
697 void
setLineJoinsStyle(JoinLineStyle COIN_UNUSED_ARG (style))698 SoVectorizeAction::setLineJoinsStyle(JoinLineStyle COIN_UNUSED_ARG(style))
699 {
700 }
701 
702 /*!
703   Not implemented yet. Provided for TGS OIV compatibility.
704 */
705 SoVectorizeAction::JoinLineStyle
getLineJoinsStyle(void) const706 SoVectorizeAction::getLineJoinsStyle(void) const
707 {
708   return NO_JOIN;
709 }
710 
711 /*!
712   Not implemented yet. Provided for TGS OIV compatibility.
713 */
714 void
setHLHSRMode(HLHSRMode COIN_UNUSED_ARG (mode))715 SoVectorizeAction::setHLHSRMode(HLHSRMode COIN_UNUSED_ARG(mode))
716 {
717 }
718 
719 /*!
720   Not implemented yet. Provided for TGS OIV compatibility.
721 */
722 SoVectorizeAction::HLHSRMode
getHLHSRMode(void) const723 SoVectorizeAction::getHLHSRMode(void) const
724 {
725   return HLHSR_PAINTER;
726 }
727 
728 /*!
729   Not implemented yet. Provided for TGS OIV compatibility.
730 */
731 void
setBorder(float COIN_UNUSED_ARG (width))732 SoVectorizeAction::setBorder(float COIN_UNUSED_ARG(width))
733 {
734 }
735 
736 /*!
737   Not implemented yet. Provided for TGS OIV compatibility.
738 */
739 void
setBorder(float COIN_UNUSED_ARG (width),SbColor COIN_UNUSED_ARG (color))740 SoVectorizeAction::setBorder(float COIN_UNUSED_ARG(width), SbColor COIN_UNUSED_ARG(color))
741 {
742 }
743 
744 /*!
745   Not implemented yet. Provided for TGS OIV compatibility.
746 */
747 void
setMiterLimit(float COIN_UNUSED_ARG (limit))748 SoVectorizeAction::setMiterLimit(float COIN_UNUSED_ARG(limit))
749 {
750 }
751 
752 float
getMiterLimit(void) const753 SoVectorizeAction::getMiterLimit(void) const
754 {
755   return 0.0f;
756 }
757 
758 /*!
759   Not implemented yet. Provided for TGS OIV compatibility.
760 */
761 void
setPenDescription(int COIN_UNUSED_ARG (num_pens),const SbColor * COIN_UNUSED_ARG (colors),const float * COIN_UNUSED_ARG (widths),DimensionUnit COIN_UNUSED_ARG (u))762 SoVectorizeAction::setPenDescription(int COIN_UNUSED_ARG(num_pens),
763                                      const SbColor * COIN_UNUSED_ARG(colors),
764                                      const float * COIN_UNUSED_ARG(widths),
765                                      DimensionUnit COIN_UNUSED_ARG(u))
766 {
767 }
768 
769 /*!
770   Not implemented yet. Provided for TGS OIV compatibility.
771 */
772 void
getPenDescription(SbColor * COIN_UNUSED_ARG (colors),float * COIN_UNUSED_ARG (widths),DimensionUnit COIN_UNUSED_ARG (u)) const773 SoVectorizeAction::getPenDescription(SbColor * COIN_UNUSED_ARG(colors),
774                                      float * COIN_UNUSED_ARG(widths),
775                                      DimensionUnit COIN_UNUSED_ARG(u)) const
776 {
777 }
778 
779 /*!
780   Not implemented yet. Provided for TGS OIV compatibility.
781 */
782 int
getPenNum(void) const783 SoVectorizeAction::getPenNum(void) const
784 {
785   return 0;
786 }
787 
788 /*!
789   Not implemented yet. Provided for TGS OIV compatibility.
790 */
791 void
setColorPriority(SbBool COIN_UNUSED_ARG (priority))792 SoVectorizeAction::setColorPriority(SbBool COIN_UNUSED_ARG(priority))
793 {
794 }
795 
796 /*!
797   Not implemented yet. Provided for TGS OIV compatibility.
798 */
799 SbBool
getColorPriority(void) const800 SoVectorizeAction::getColorPriority(void) const
801 {
802   return FALSE;
803 }
804 
805 /*!
806   Not implemented yet. Provided for TGS OIV compatibility.
807 */
808 void
enableLighting(SbBool COIN_UNUSED_ARG (flag))809 SoVectorizeAction::enableLighting(SbBool COIN_UNUSED_ARG(flag))
810 {
811 }
812 /*!
813   Not implemented yet. Provided for TGS OIV compatibility.
814 */
815 SbBool
isLightingEnabled(void) const816 SoVectorizeAction::isLightingEnabled(void) const
817 {
818   return TRUE;
819 }
820 
821 
822 #undef PRIVATE
823 #undef PUBLIC
824 
825 // *************************************************************************
826