Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenInventor/src/SoGL2PSAction.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenInventor/src/SoGL2PSAction.cc (Version 11.3.0) and /visualization/OpenInventor/src/SoGL2PSAction.cc (Version 8.2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 #ifdef G4VIS_BUILD_OI_DRIVER
 26                                                    27 
 27 /*----------------------------HEPVis----------     28 /*----------------------------HEPVis----------------------------------------*/
 28 /*                                                 29 /*                                                                          */
 29 /* Node:             SoGL2PSAction                 30 /* Node:             SoGL2PSAction                                          */
 30 /* Author:           Guy Barrand                   31 /* Author:           Guy Barrand                                            */
 31 /*                                                 32 /*                                                                          */
 32 /*--------------------------------------------     33 /*--------------------------------------------------------------------------*/
 33                                                    34 
 34 // this :                                          35 // this :
 35 #include <HEPVis/actions/SoGL2PSAction.h>          36 #include <HEPVis/actions/SoGL2PSAction.h>
 36                                                    37 
 37 // Inventor :                                      38 // Inventor :
 38 #include <Inventor/elements/SoViewportRegionEl     39 #include <Inventor/elements/SoViewportRegionElement.h>
 39 #include <Inventor/errors/SoDebugError.h>          40 #include <Inventor/errors/SoDebugError.h>
 40                                                    41 
 41 #include <Inventor/system/gl.h>                <<  42 #include "Geant4_gl2ps.h"
 42                                                    43 
 43 #include <stdio.h>                                 44 #include <stdio.h>
 44                                                    45 
 45 SO_ACTION_SOURCE(SoGL2PSAction)                    46 SO_ACTION_SOURCE(SoGL2PSAction)
 46 //////////////////////////////////////////////     47 //////////////////////////////////////////////////////////////////////////////
 47 void SoGL2PSAction::initClass(                     48 void SoGL2PSAction::initClass(
 48 )                                                  49 )
 49 //////////////////////////////////////////////     50 //////////////////////////////////////////////////////////////////////////////
 50 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     51 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 51 {                                                  52 {
 52   static bool first = true;                    <<  53   SO_ACTION_INIT_CLASS(SoGL2PSAction,SoGLRenderAction);
 53   if (first) {                                 << 
 54     first = false;                             << 
 55     SO_ACTION_INIT_CLASS(SoGL2PSAction,SoGLRen << 
 56   }                                            << 
 57 }                                                  54 }
 58 //////////////////////////////////////////////     55 //////////////////////////////////////////////////////////////////////////////
 59 SoGL2PSAction::SoGL2PSAction(                      56 SoGL2PSAction::SoGL2PSAction(
 60  const SbViewportRegion& aViewPortRegion           57  const SbViewportRegion& aViewPortRegion
 61 )                                                  58 )
 62 :SoGLRenderAction(aViewPortRegion)                 59 :SoGLRenderAction(aViewPortRegion)
 63 ,fContext(0)                                   <<  60 ,fFileName("out.ps")
 64 ,fFile(0)                                          61 ,fFile(0)
 65 ,fFileName("out.pdf")                          << 
 66 ,fTitle("title")                               << 
 67 ,fProducer("HEPVis::SoGL2PSAction")            << 
 68 ,fFormat(TOOLS_GL2PS_PDF)                      << 
 69 //////////////////////////////////////////////     62 //////////////////////////////////////////////////////////////////////////////
 70 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     63 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 71 {                                                  64 {
 72   SO_ACTION_CONSTRUCTOR(SoGL2PSAction);            65   SO_ACTION_CONSTRUCTOR(SoGL2PSAction);
 73 }                                                  66 }
 74                                                << 
 75 ////////////////////////////////////////////// << 
 76 SoGL2PSAction::~SoGL2PSAction()                << 
 77 ////////////////////////////////////////////// << 
 78 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
 79 {                                              << 
 80   closeFile();                                 << 
 81 }                                              << 
 82                                                << 
 83 //////////////////////////////////////////////     67 //////////////////////////////////////////////////////////////////////////////
 84 void SoGL2PSAction::setFileName(const std::str <<  68 void SoGL2PSAction::setFileName(
                                                   >>  69  const char* aFileName
                                                   >>  70 )
 85 //////////////////////////////////////////////     71 //////////////////////////////////////////////////////////////////////////////
 86 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     72 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
 87 {                                                  73 {
 88   fFileName = aFileName;                           74   fFileName = aFileName;
 89 }                                                  75 }
 90                                                << 
 91 ////////////////////////////////////////////// << 
 92 void SoGL2PSAction::setTitleAndProducer(const  << 
 93 ////////////////////////////////////////////// << 
 94 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
 95 {                                              << 
 96   fTitle = aTitle;                             << 
 97   fProducer = aProducer;                       << 
 98 }                                              << 
 99                                                << 
100 void SoGL2PSAction::setExportImageFormat_PS()  << 
101 void SoGL2PSAction::setExportImageFormat_EPS() << 
102 void SoGL2PSAction::setExportImageFormat_TEX() << 
103 void SoGL2PSAction::setExportImageFormat_PDF() << 
104 void SoGL2PSAction::setExportImageFormat_SVG() << 
105 void SoGL2PSAction::setExportImageFormat_PGF() << 
106                                                << 
107 //////////////////////////////////////////////     76 //////////////////////////////////////////////////////////////////////////////
108 bool SoGL2PSAction::enableFileWriting()        <<  77 void SoGL2PSAction::enableFileWriting(
                                                   >>  78 )
109 //////////////////////////////////////////////     79 //////////////////////////////////////////////////////////////////////////////
110 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     80 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
111 {                                                  81 {
112   if(!openFile()) {                            <<  82   fFile = ::fopen(fFileName.getString(),"w");
                                                   >>  83   if(!fFile) {
113     SoDebugError::post("SoGL2PSAction::enableF     84     SoDebugError::post("SoGL2PSAction::enableFileWriting",
114                        "openFile() failed for  <<  85                        "Cannot open file %s",fFileName.getString());
115                        fFileName.c_str());     <<  86     return;
116     return false;                              << 
117   }                                                87   }
118 #ifdef __COIN__                                    88 #ifdef __COIN__
119 #else //SGI                                        89 #else //SGI
120   const SbViewportRegion& vpr = getViewportReg     90   const SbViewportRegion& vpr = getViewportRegion();
121   SoViewportRegionElement::set(getState(),vpr)     91   SoViewportRegionElement::set(getState(),vpr);
122   SbVec2s origin = vpr.getViewportOriginPixels <<  92   gl2psBegin();
123   SbVec2s size = vpr.getViewportSizePixels();  << 
124   if(!beginPage(origin[0],origin[1],size[0],si << 
125     SoDebugError::post("SoGL2PSAction::enableF << 
126     return false;                              << 
127   }                                            << 
128 #endif                                             93 #endif
129   return true;                                 << 
130 }                                                  94 }
131 //////////////////////////////////////////////     95 //////////////////////////////////////////////////////////////////////////////
132 void SoGL2PSAction::disableFileWriting(            96 void SoGL2PSAction::disableFileWriting(
133 )                                                  97 )
134 //////////////////////////////////////////////     98 //////////////////////////////////////////////////////////////////////////////
135 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!     99 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
136 {                                                 100 {
137 #ifdef __COIN__                                   101 #ifdef __COIN__
138 #else //SGI                                       102 #else //SGI
139   endPage();                                   << 103   gl2psEndPage();        
140 #endif                                            104 #endif
141   closeFile();                                 << 105   ::fclose(fFile);
142 }                                              << 106   fFile = 0;
143                                                << 
144 ////////////////////////////////////////////// << 
145 void SoGL2PSAction::beginTraversal(            << 
146  SoNode* aNode                                 << 
147 )                                              << 
148 ////////////////////////////////////////////// << 
149 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
150 {                                              << 
151   if(fContext && fFile) {                      << 
152 #ifdef __COIN__                                << 
153     const SbViewportRegion& vpr = getViewportR << 
154     SoViewportRegionElement::set(getState(),vp << 
155     SbVec2s origin = vpr.getViewportOriginPixe << 
156     SbVec2s size = vpr.getViewportSizePixels() << 
157     if(!beginPage(origin[0],origin[1],size[0], << 
158       SoDebugError::post("SoGL2PSAction::begin << 
159       return;                                  << 
160     }                                          << 
161     traverse(aNode);                           << 
162     if(!endPage()) {                           << 
163       SoDebugError::post("SoGL2PSAction::begin << 
164       return;                                  << 
165     }                                          << 
166 #else //SGI                                    << 
167     SoGLRenderAction::beginTraversal(aNode);   << 
168 #endif                                         << 
169   } else {                                     << 
170     SoGLRenderAction::beginTraversal(aNode);   << 
171   }                                            << 
172 }                                              << 
173                                                << 
174 #include <tools/gl2ps>                         << 
175                                                << 
176 ////////////////////////////////////////////// << 
177 bool SoGL2PSAction::openFile()                 << 
178 ////////////////////////////////////////////// << 
179 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
180 {                                              << 
181   if(fFile) {                                  << 
182     ::fclose(fFile);                           << 
183     fFile = 0;                                 << 
184   }                                            << 
185   if(fContext) {                               << 
186     ::tools_gl2psDeleteContext(fContext);      << 
187     fContext = 0;                              << 
188   }                                            << 
189                                                << 
190   fContext = ::tools_gl2psCreateContext();     << 
191   if(!fContext) return false;                  << 
192                                                << 
193   tools_gl2ps_gl_funcs_t _funcs = {            << 
194     (tools_glIsEnabled_func)glIsEnabled,       << 
195     (tools_glBegin_func)glBegin,               << 
196     (tools_glEnd_func)glEnd,                   << 
197     (tools_glGetFloatv_func)glGetFloatv,       << 
198     (tools_glVertex3f_func)glVertex3f,         << 
199     (tools_glGetBooleanv_func)glGetBooleanv,   << 
200     (tools_glGetIntegerv_func)glGetIntegerv,   << 
201     (tools_glRenderMode_func)glRenderMode,     << 
202     (tools_glFeedbackBuffer_func)glFeedbackBuf << 
203     (tools_glPassThrough_func)glPassThrough    << 
204   };                                           << 
205   ::tools_gl2ps_set_gl_funcs(fContext,&_funcs) << 
206                                                << 
207   fFile = ::fopen(fFileName.c_str(),"wb");     << 
208   if(!fFile) {                                 << 
209     ::tools_gl2psDeleteContext(fContext);      << 
210     fContext = 0;                              << 
211     return false;                              << 
212   }                                            << 
213                                                << 
214   return true;                                 << 
215 }                                              << 
216                                                << 
217 ////////////////////////////////////////////// << 
218 void SoGL2PSAction::closeFile()                << 
219 ////////////////////////////////////////////// << 
220 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
221 {                                              << 
222   if(fFile) {                                  << 
223     ::fclose(fFile);                           << 
224     fFile = 0;                                 << 
225   }                                            << 
226   if(fContext) {                               << 
227     ::tools_gl2psDeleteContext(fContext);      << 
228     fContext = 0;                              << 
229   }                                            << 
230 }                                                 107 }
231                                                << 
232 ////////////////////////////////////////////// << 
233 bool SoGL2PSAction::beginPage(int a_x,int a_y, << 
234 ////////////////////////////////////////////// << 
235 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 
236 {                                              << 
237   if(!fContext) return false;                  << 
238   if(!fFile) return false;                     << 
239                                                << 
240   if( (a_w<=0) || (a_h<=0) ) return false;     << 
241                                                << 
242   int options =                                << 
243     TOOLS_GL2PS_BEST_ROOT |                    << 
244     TOOLS_GL2PS_DRAW_BACKGROUND |              << 
245     TOOLS_GL2PS_USE_CURRENT_VIEWPORT;          << 
246   int sort = TOOLS_GL2PS_BSP_SORT;             << 
247                                                << 
248   int vp[4];                                   << 
249   vp[0] = a_x;                                 << 
250   vp[1] = a_y;                                 << 
251   vp[2] = a_w;                                 << 
252   vp[3] = a_h;                                 << 
253                                                << 
254   int bufferSize = 0;                          << 
255                                                << 
256   tools_GLint res = ::tools_gl2psBeginPage     << 
257     (fContext,fTitle.c_str(),fProducer.c_str() << 
258      vp,fFormat,sort,options,TOOLS_GL_RGBA,0,  << 
259      bufferSize,fFile,fFileName.c_str());      << 
260   if (res == TOOLS_GL2PS_ERROR) return false;  << 
261                                                << 
262   // enable blending for all                   << 
263   ::tools_gl2psEnable(fContext,TOOLS_GL2PS_BLE << 
264                                                << 
265   return true;                                 << 
266 }                                              << 
267                                                << 
268 //////////////////////////////////////////////    108 //////////////////////////////////////////////////////////////////////////////
269 bool SoGL2PSAction::endPage()                  << 109 SbBool SoGL2PSAction::fileWritingEnabled(
                                                   >> 110 ) const
270 //////////////////////////////////////////////    111 //////////////////////////////////////////////////////////////////////////////
271 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    112 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
272 {                                                 113 {
273   int _status = 0;                             << 114   return (fFile?TRUE:FALSE);
274   if(fContext) {                               << 
275     _status = ::tools_gl2psEndPage(fContext);  << 
276   }                                            << 
277   if (_status == TOOLS_GL2PS_OVERFLOW) return  << 
278   return true;                                 << 
279 }                                                 115 }
280                                                << 
281 //////////////////////////////////////////////    116 //////////////////////////////////////////////////////////////////////////////
282 bool SoGL2PSAction::addBitmap(                 << 117 SbBool SoGL2PSAction::addBitmap(
283  int aWidth                                       118  int aWidth
284 ,int aHeight                                      119 ,int aHeight
285 ,float aXorig                                     120 ,float aXorig
286 ,float aYorig                                     121 ,float aYorig
287 ,float aXmove                                     122 ,float aXmove
288 ,float aYmove                                     123 ,float aYmove
289 )                                                 124 )
290 //////////////////////////////////////////////    125 /////////////////////////////////////////////////////////////////////////////
291 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!    126 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
292 {                                                 127 {
293   if(!fContext) return false;                  << 128   if(!fFile) return FALSE;
294   GLboolean valid;                                129   GLboolean valid;
295   ::glGetBooleanv(GL_CURRENT_RASTER_POSITION_V << 130   glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID,&valid);
296   if(!valid) return false;                     << 131   if(valid==GL_FALSE) return FALSE;
297   float pos[4];                                   132   float pos[4];
298   ::glGetFloatv(GL_CURRENT_RASTER_POSITION,pos << 133   glGetFloatv(GL_CURRENT_RASTER_POSITION,pos);
299   int xoff = -(int)(aXmove + aXorig);             134   int xoff = -(int)(aXmove + aXorig);
300   int yoff = -(int)(aYmove + aYorig);             135   int yoff = -(int)(aYmove + aYorig);
301   int x = (int)(pos[0] + xoff);                   136   int x = (int)(pos[0] + xoff);
302   int y = (int)(pos[1] + yoff);                   137   int y = (int)(pos[1] + yoff);
303   // Should clip against viewport area :          138   // Should clip against viewport area :
304   GLint vp[4];                                    139   GLint vp[4];
305   ::glGetIntegerv(GL_VIEWPORT,vp);             << 140   glGetIntegerv(GL_VIEWPORT,vp);
306   GLsizei w = aWidth;                             141   GLsizei w = aWidth;
307   GLsizei h = aHeight;                            142   GLsizei h = aHeight;
308   if(x+w>(vp[0]+vp[2])) w = vp[0]+vp[2]-x;        143   if(x+w>(vp[0]+vp[2])) w = vp[0]+vp[2]-x;
309   if(y+h>(vp[1]+vp[3])) h = vp[1]+vp[3]-y;        144   if(y+h>(vp[1]+vp[3])) h = vp[1]+vp[3]-y;
310   int s = 3 * w * h;                              145   int s = 3 * w * h;
311   if(s<=0) return false;                       << 146   if(s<=0) return FALSE;
312   float* image = (float*)::malloc(s * sizeof(f    147   float* image = (float*)::malloc(s * sizeof(float));
313   if(!image) return false;                     << 148   if(!image) return FALSE;
314   ::glReadPixels(x,y,w,h,GL_RGB,GL_FLOAT,image << 149   glReadPixels(x,y,w,h,GL_RGB,GL_FLOAT,image);
315   GLint status = ::tools_gl2psDrawPixels(fCont << 150   GLint status = gl2psDrawPixels(w,h,xoff,yoff,GL_RGB,GL_FLOAT,image);
316   ::free(image);                                  151   ::free(image);
317   return (status!=TOOLS_GL2PS_SUCCESS ? false  << 152   return (status!=GL2PS_SUCCESS ? FALSE : TRUE);
                                                   >> 153 }
                                                   >> 154 //////////////////////////////////////////////////////////////////////////////
                                                   >> 155 void SoGL2PSAction::beginViewport(
                                                   >> 156 )
                                                   >> 157 /////////////////////////////////////////////////////////////////////////////
                                                   >> 158 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
                                                   >> 159 {
                                                   >> 160   if(!fFile) return;
                                                   >> 161   GLint vp[4];
                                                   >> 162   glGetIntegerv(GL_VIEWPORT,vp);
                                                   >> 163   gl2psBeginViewport(vp);
                                                   >> 164 }
                                                   >> 165 //////////////////////////////////////////////////////////////////////////////
                                                   >> 166 void SoGL2PSAction::endViewport(
                                                   >> 167 )
                                                   >> 168 /////////////////////////////////////////////////////////////////////////////
                                                   >> 169 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
                                                   >> 170 {
                                                   >> 171   if(!fFile) return;
                                                   >> 172   gl2psEndViewport();
                                                   >> 173 }
                                                   >> 174 //////////////////////////////////////////////////////////////////////////////
                                                   >> 175 void SoGL2PSAction::beginTraversal(
                                                   >> 176  SoNode* aNode
                                                   >> 177 )
                                                   >> 178 //////////////////////////////////////////////////////////////////////////////
                                                   >> 179 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
                                                   >> 180 {
                                                   >> 181   if(fFile) {
                                                   >> 182 #ifdef __COIN__
                                                   >> 183     const SbViewportRegion& vpr = getViewportRegion();
                                                   >> 184     SoViewportRegionElement::set(getState(),vpr);
                                                   >> 185     gl2psBegin();
                                                   >> 186     traverse(aNode);
                                                   >> 187     gl2psEndPage();        
                                                   >> 188 #else //SGI
                                                   >> 189     SoGLRenderAction::beginTraversal(aNode);
                                                   >> 190 #endif
                                                   >> 191   } else {
                                                   >> 192     SoGLRenderAction::beginTraversal(aNode);
                                                   >> 193   }
                                                   >> 194 }
                                                   >> 195 //////////////////////////////////////////////////////////////////////////////
                                                   >> 196 void SoGL2PSAction::gl2psBegin(
                                                   >> 197 )
                                                   >> 198 //////////////////////////////////////////////////////////////////////////////
                                                   >> 199 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
                                                   >> 200 {
                                                   >> 201   if(!fFile) return;
                                                   >> 202   int options = GL2PS_OCCLUSION_CULL | 
                                                   >> 203      GL2PS_BEST_ROOT | GL2PS_SILENT | GL2PS_DRAW_BACKGROUND;
                                                   >> 204   int sort = GL2PS_BSP_SORT;
                                                   >> 205   //int sort = GL2PS_SIMPLE_SORT;
                                                   >> 206     
                                                   >> 207   const SbViewportRegion& vpr = getViewportRegion();
                                                   >> 208   SoViewportRegionElement::set(getState(),vpr);
                                                   >> 209  
                                                   >> 210   const SbVec2s& win = vpr.getWindowSize();
                                                   >> 211   GLint vp[4];
                                                   >> 212   vp[0] = 0;
                                                   >> 213   vp[1] = 0;
                                                   >> 214   vp[2] = win[0];
                                                   >> 215   vp[3] = win[1];
                                                   >> 216 
                                                   >> 217   int bufsize = 0;
                                                   >> 218   gl2psBeginPage("title","HEPVis::SoGL2PSAction", 
                                                   >> 219                  vp,
                                                   >> 220                  GL2PS_EPS, 
                                                   >> 221                  sort, 
                                                   >> 222                  options, 
                                                   >> 223                  GL_RGBA,0, NULL,0,0,0,
                                                   >> 224                  bufsize, 
                                                   >> 225                  fFile,fFileName.getString());    
318 }                                                 226 }
319                                                   227 
                                                   >> 228 #endif
320                                                   229