G4OpenGLXmViewer Class Reference

#include <G4OpenGLXmViewer.hh>

Inheritance diagram for G4OpenGLXmViewer:

Public Member Functions
void	ClearView ()
void	ClearViewWithoutFlush ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
void	DrawText (const G4Text &)
virtual void	DrawView ()=0
virtual bool	exportImage (std::string name="", int width=-1, int height=-1)
virtual void	FinishView ()
	G4OpenGLXmViewer (G4OpenGLSceneHandler &scene)
const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const
const G4ViewParameters &	GetDefaultViewParameters () const
const G4String &	GetName () const
virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const
G4VSceneHandler *	GetSceneHandler () const
const G4String &	GetShortName () const
G4int	GetViewId () const
const G4ViewParameters &	GetViewParameters () const
virtual void	Initialise ()
void	NeedKernelVisit ()
void	ProcessView ()
void	RefreshView ()
void	SetDefaultViewParameters (const G4ViewParameters &vp)
bool	setExportImageFormat (std::string format, bool quiet=false)
void	SetName (const G4String &)
void	SetNeedKernelVisit (G4bool need)
void	SetView ()
void	SetViewParameters (const G4ViewParameters &vp)
virtual	~G4OpenGLXmViewer ()

Static Public Member Functions
static void	actions_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	Add_four_arrow_buttons (G4OpenGLXmViewer *pView, XtCallbackRec **arrow_callbacks, Widget *parent_widget)
static void	Add_radio_box (char *label_string, Widget *parent_frame_widget, XtCallbackRec *radio_box_cb, G4int num_buttons, G4int default_button, char *radio_box_name, char **button_names, G4OpenGLXmViewer *pView)
static void	Add_set_field (char *widget, char *widget_text, Widget *row_col_box, Widget *wid, G4double *val, G4OpenGLXmViewer *pView)
static void	Add_slider_box (char *label_string, G4int num_sliders, char **slider_name, G4OpenGLXmViewer *pView, G4double *min_array, G4double *max_array, G4double *value_array, G4bool *show, short *decimals, unsigned char *orientation, unsigned char *direction, XtCallbackRec **slider_box_cb, Widget *parent_frame_widget)
static void	antialias_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	aux_edge_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	background_color_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	dolly_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	drawing_style_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	expose_callback (Widget w, XtPointer clientData, XtPointer callData)
static G4bool	get_boolean_userData (Widget w)
static void	get_double_value_callback (Widget w, XtPointer clientData, XtPointer callData)
static G4int	get_int_userData (Widget w)
static void	get_text_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	haloing_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	left_right_pan_callback (XtPointer clientData, XtIntervalId *timer_id)
static void	misc_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	pan_left_right_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	pan_up_down_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	phi_rotation_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	print_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	projection_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	reset_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	resize_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	rotate_in_phi (XtPointer clientData, XtIntervalId *timer_id)
static void	rotate_in_theta (XtPointer clientData, XtIntervalId *timer_id)
static void	set_pan_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_print_colour_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_print_style_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_rot_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_rot_subject_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_wob_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	theta_rotation_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	transparency_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	up_down_pan_callback (XtPointer clientData, XtIntervalId *timer_id)
static void	update_panels_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	wobble_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	wobble_timer_callback (XtPointer clientData, XtIntervalId *timerid)
static void	zoom_callback (Widget w, XtPointer clientData, XtPointer callData)

Protected Member Functions
void	addExportImageFormat (std::string format)
void	ChangeLineWidth (G4double width)
void	ChangePointSize (G4double size)
virtual void	CreateFontLists ()
void	CreateGLXContext (XVisualInfo *vi)
virtual void	CreateMainWindow ()
void	g4GlFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
void	g4GlOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
void	g4GluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz)
void	g4GluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])
const std::vector< G4OpenGLViewerPickMap * > &	GetPickDetails (GLdouble x, GLdouble y)
std::string	getRealPrintFilename ()
GLdouble	getSceneDepth ()
GLdouble	getSceneFarWidth ()
GLdouble	getSceneNearWidth ()
unsigned int	getWinHeight () const
unsigned int	getWinWidth () const
void	GetXConnection ()
void	GetXmConnection ()
void	HaloingFirstPass ()
void	HaloingSecondPass ()
void	HLRFirstPass ()
void	HLRSecondPass ()
void	HLRThirdPass ()
void	InitializeGLView ()
G4bool	isFramebufferReady ()
G4bool	isGl2psWriting ()
virtual G4String	Pick (GLdouble x, GLdouble y)
void	ResetView ()
void	ResizeGLView ()
void	ResizeWindow (unsigned int, unsigned int)
void	rotateScene (G4double dx, G4double dy)
void	rotateSceneToggle (G4double dx, G4double dy)
bool	setExportFilename (G4String name, G4bool inc=true)
void	setExportSize (G4int, G4int)
void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)
virtual void	ShowView ()
G4bool	sizeHasChanged ()
void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)
void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)

Protected Attributes
Widget	actions_cascade
XmString	actions_str
XmString	anti_str
Widget	antialias_pullright
G4bool	antialiasing_enabled
XtAppContext	app
G4int *	attributeList
Widget	aux_edge_pullright
XmString	aux_edge_str
G4Colour	background
Widget	background_color_pullright
Pixel	bgnd
XmString	bgnd_str
XmString	black_str
Pixel	borcol
char	charViewName [100]
XClassHint *	class_hints
Colormap	cmap
GLXContext	cxMaster
G4double	dolly_high
G4double	dolly_low
Display *	dpy
XmString	draw_str
Widget	drawing_style_pullright
G4int	errorBase
XEvent	event
G4int	eventBase
XmString	exit_str
std::string	fDefaultExportImageFormat
G4ViewParameters	fDefaultVP
int	fExportFilenameIndex
std::string	fExportImageFormat
std::vector< std::string >	fExportImageFormatVector
G4OpenGL2PSAction *	fGL2PSAction
G4String	fName
G4bool	fNeedKernelVisit
G4OpenGLSceneHandler &	fOpenGLSceneHandler
G4double	fov
G4double	fPan_sens
G4OpenGLXmFramedBox *	fpdolly_box
G4OpenGLXmTextField *	fpdolly_lower
G4OpenGLXmSliderBar *	fpdolly_slider
G4OpenGLXmTextField *	fpdolly_upper
G4OpenGLXmTextField *	fpfov_text
G4OpenGLXmTopLevelShell *	fpmiscellany_top
G4OpenGLXmPushButton *	fpok_button
G4OpenGLXmRadioButton *	fporthogonal_button
G4OpenGLXmTextField *	fppan_set
G4OpenGLXmFourArrowButtons *	fppanning_arrows
G4OpenGLXmFramedBox *	fppanning_box
G4OpenGLXmSliderBar *	fppanning_slider
G4OpenGLXmTopLevelShell *	fppanning_top
G4OpenGLXmRadioButton *	fpperspective_button
G4OpenGLXmFramedBox *	fpprint_box
G4OpenGLXmPushButton *	fpprint_button
G4OpenGLXmFramedBox *	fpprint_col_box
G4OpenGLXmRadioButton *	fpprint_col_radio1
G4OpenGLXmRadioButton *	fpprint_col_radio2
G4OpenGLXmSeparator *	fpprint_line
G4OpenGLXmFramedBox *	fpprint_style_box
G4OpenGLXmRadioButton *	fpprint_style_radio1
G4OpenGLXmRadioButton *	fpprint_style_radio2
G4OpenGLXmTextField *	fpprint_text
G4OpenGLXmTopLevelShell *	fpprint_top
G4OpenGLXmFramedBox *	fpproj_style_box
G4OpenGLXmFramedBox *	fpreset_box
G4OpenGLXmPushButton *	fpreset_button
G4bool	fPrintColour
G4int	fPrintSizeX
G4int	fPrintSizeY
G4OpenGLXmTextField *	fprot_set
G4OpenGLXmFourArrowButtons *	fprotation_arrow
G4OpenGLXmBox *	fprotation_arrow_box
G4OpenGLXmRadioButton *	fprotation_button1
G4OpenGLXmRadioButton *	fprotation_button2
G4OpenGLXmBox *	fprotation_button_box
G4OpenGLXmSliderBar *	fprotation_slider
G4OpenGLXmBox *	fprotation_slider_box
G4OpenGLXmTopLevelShell *	fprotation_top
G4OpenGLXmFramedBox *	fpsetting_box
G4OpenGLXmTopLevelShell *	fpsetting_top
G4OpenGLXmFramedBox *	fpwobble_box
G4OpenGLXmPushButton *	fpwobble_button
G4OpenGLXmSliderBar *	fpwobble_slider
G4OpenGLXmFramedBox *	fpzoom_box
G4OpenGLXmTextField *	fpzoom_lower
G4OpenGLXmSliderBar *	fpzoom_slider
G4OpenGLXmTextField *	fpzoom_upper
Widget	frame
G4int	frameNo
G4double	fRot_sens
G4VSceneHandler &	fSceneHandler
G4String	fShortName
G4bool	fVectoredPs
G4int	fViewId
G4ViewParameters	fVP
unsigned int	fWinSize_x
unsigned int	fWinSize_y
Widget	glxarea
XmString	halo_str
G4bool	haloing_enabled
Widget	haloing_pullright
XmString	hlhsr_str
XmString	hlr_str
XmString	hsr_str
Pixmap	icon_pixmap
XTextProperty	iconName
Widget	main_win
G4int	major
Widget	menubar
G4int	minor
Widget	misc_cascade
XmString	misc_str
XSizeHints *	norm_hints
XmString	off_str
XmString	on_str
G4Vector3D	original_vp
G4double	pan_high
G4double	pan_low
G4bool	pan_right
G4double	pan_sens_limit
XmString	pan_str
XtIntervalId	pan_timer
G4bool	pan_up
XmString	polyhedron_str
XmString	print_str
XmString	quit_str
G4double	rot_sens_limit
XmString	rot_str
G4bool	rotate_right
G4bool	rotate_up
XtIntervalId	rotation_timer
XmString	set_str
Widget	shell
XSizeHints *	size_hints
Widget	spec_cascade
XmString	spec_str
Widget	style_cascade
XmString	style_str
XSetWindowAttributes	swa
Widget	toplevel
XmString	trans_str
G4bool	transparency_enabled
Widget	transparency_pullright
XVisualInfo *	vi
XVisualInfo *	vi_immediate
XVisualInfo *	vi_stored
XmString	white_str
GLXDrawable	win
XTextProperty	windowName
XmString	wireframe_str
XWMHints *	wm_hints
G4double	wob_high
G4double	wob_low
G4double	wob_sens
XtIntervalId	wobble_timer
XtWorkProcId	workId
Atom	Xatom
XWindowAttributes	xwa
G4double	zoom_high
G4double	zoom_low

Static Protected Attributes
static int	dblBuf_RGBA [13]
static int	snglBuf_RGBA [12]
static XVisualInfo *	vi_double_buffer = 0
static XVisualInfo *	vi_single_buffer = 0

Private Member Functions
	G4OpenGLXmViewer (const G4OpenGLXmViewer &)
G4int	getRealExportHeight ()
G4int	getRealExportWidth ()
GLubyte *	grabPixels (int inColor, unsigned int width, unsigned int height)
G4OpenGLXmViewer &	operator= (const G4OpenGLXmViewer &)
bool	printGl2PS ()
bool	printNonVectoredEPS ()
bool	printVectoredEPS ()
void	rotateSceneInViewDirection (G4double dx, G4double dy)
void	rotateSceneThetaPhi (G4double dx, G4double dy)
void	UpdateControlPanel ()

Private Attributes
G4String	fDefaultExportFilename
G4String	fExportFilename
int	fGl2psDefaultLineWith
int	fGl2psDefaultPointSize
bool	fGlViewInitialized
bool	fIsGettingPickInfos
G4float	fPointSize
G4bool	fSizeHasChanged
GLXContext	tmp_cx

Friends
class	G4OpenGLXmViewerMessenger
class	G4OpenGLXmVWidgetObject

Detailed Description

Definition at line 51 of file G4OpenGLXmViewer.hh.

Constructor & Destructor Documentation

G4OpenGLXmViewer() [1/2]

G4OpenGLXmViewer::G4OpenGLXmViewer

(

G4OpenGLSceneHandler &

scene

)

Definition at line 667 of file G4OpenGLXmViewer.cc.

                                                              :
G4VViewer (scene, -1),
G4OpenGLViewer (scene),
G4OpenGLXViewer (scene),
toplevel (0),
shell (0),
main_win (0),
menubar (0),
style_cascade (0),
actions_cascade (0),
misc_cascade (0),
spec_cascade (0),
drawing_style_pullright (0),
background_color_pullright (0),
transparency_pullright (0),
antialias_pullright (0),
haloing_pullright (0),
aux_edge_pullright (0),
frame (0),
glxarea (0),
style_str (0),
actions_str (0),
misc_str (0),
spec_str (0),
draw_str (0),
polyhedron_str (0),
wireframe_str (0),
hlr_str (0),
hsr_str (0),
hlhsr_str (0),
set_str (0),
rot_str (0),
pan_str (0),
exit_str (0),
quit_str (0),
print_str (0),
white_str (0),
black_str (0),
anti_str (0),
trans_str (0),
halo_str (0),
aux_edge_str (0),
bgnd_str (0),
off_str (0),
on_str (0),
zoom_high (0.0),
zoom_low (0.0),
pan_low (0.0),
pan_high (0.0),
dolly_low (0.0),
dolly_high (0.0),
fov (0.0),
rot_sens_limit (0.0),
pan_sens_limit (0.0),
wob_high (0.0),
wob_low (0.0),
wob_sens (0.0),
pan_right (false),
rotate_right (false),
pan_up (false),
rotate_up (false),
original_vp(fVP.GetViewpointDirection()),
frameNo (0),
fprotation_top (0),
fprotation_button_box (0),
fprotation_button1 (0),
fprotation_button2 (0),
fprotation_slider_box (0),
fprotation_slider (0),
fprotation_arrow_box (0),
fprotation_arrow (0),
fppanning_top (0),
fppanning_box (0),
fppanning_arrows (0),
fppanning_slider (0),
fpzoom_box (0),
fpzoom_slider (0),
fpdolly_box (0),
fpdolly_slider (0),
fpsetting_top (0),
fpsetting_box (0),
fppan_set (0),
fprot_set (0),
fpzoom_upper (0),
fpzoom_lower (0),
fpdolly_upper (0),
fpdolly_lower (0),
fpok_button (0),
fpmiscellany_top (0),
fpwobble_box (0),
fpwobble_button (0),
fpwobble_slider (0),
fpreset_box (0),
fpreset_button (0),
fpproj_style_box (0),
fporthogonal_button (0),
fpperspective_button (0),
fpfov_text (0),
fpprint_top (0),
fpprint_box (0),
fpprint_col_box (0),
fpprint_style_box (0),
fpprint_text (0),
fpprint_button (0),
fpprint_line (0),
fpprint_col_radio1 (0),
fpprint_col_radio2 (0),
fpprint_style_radio1 (0),
fpprint_style_radio2 (0)
{
  GetXmConnection ();
  ResetView();
  if (fViewId < 0) return;
}

References G4VViewer::fViewId, GetXmConnection(), and ResetView().

~G4OpenGLXmViewer()

G4OpenGLXmViewer::~G4OpenGLXmViewer ( )

virtual

Definition at line 839 of file G4OpenGLXmViewer.cc.

{
  XtDestroyWidget  (shell);
  win = 0; // ...to avoid XDestroyWindow in G4OpenGLXViewer base class
  // because XtDestroyWidget has already destroyed it.
  G4Xt::getInstance () ->RemoveShell (shell);
 
/******************************
  if (fprotation_top) {
    delete fprotation_top;
  }
 
  if (fppanning_top) {
    delete fppanning_top;
  }
 
  if (fpsetting_top) {
    delete fpsetting_top;
  }
 
  if (fpmiscellany_top) {
    delete fpmiscellany_top;
  }
******************************/
 
}

References G4Xt::getInstance(), G4VInteractorManager::RemoveShell(), shell, and G4OpenGLXViewer::win.

G4OpenGLXmViewer() [2/2]

G4OpenGLXmViewer::G4OpenGLXmViewer ( const G4OpenGLXmViewer &  )

private

Member Function Documentation

actions_callback()

void G4OpenGLXmViewer::actions_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 58 of file G4OpenGLXmMainMenubarCallbacks.cc.

{
  
  G4OpenGLXmViewer* pView;
  G4long choice = (G4long)clientData;
  
  
  XtVaGetValues (XtParent(w), 
         XmNuserData, &pView, 
         NULL);
  
  switch (choice) {
    
  case 0:
    
    {
      
      if (!pView->fprotation_top) {
    std::ostringstream rot_Name;
    rot_Name << pView->GetSceneHandler()->GetSceneHandlerId() << '-' << pView->fViewId;
    
    pView->fprotation_top = new G4OpenGLXmTopLevelShell (pView,
                                 (char*)rot_Name.str().c_str());
    pView->fprotation_button_box = new G4OpenGLXmBox ("Rotation button box", True);
    
    pView->fprotation_top->AddChild (pView->fprotation_button_box);
    
    XtCallbackRec* rot_cb_list = new XtCallbackRec[2];
    rot_cb_list[0].callback = set_rot_subject_callback;
    rot_cb_list[0].closure = pView; 
    rot_cb_list[1].callback = NULL;
    
    pView->fprotation_button1 = new G4OpenGLXmRadioButton
      ("Object",
       rot_cb_list,
       pView->GetViewParameters().GetLightsMoveWithCamera(),
       0);
    
    pView->fprotation_button2 = new G4OpenGLXmRadioButton
      ("Camera",
       rot_cb_list,
       !(pView->GetViewParameters().GetLightsMoveWithCamera()),
       1);
    
    pView->fprotation_button_box->AddChild (pView->fprotation_button1);
    pView->fprotation_button_box->AddChild (pView->fprotation_button2);
    
    pView->fprotation_slider_box = new G4OpenGLXmBox ("Rotation slider box", False);
    pView->fprotation_top->AddChild (pView->fprotation_slider_box);
    
    XtCallbackRec* rot_slider_list = new XtCallbackRec[2];
    rot_slider_list[0].callback = set_rot_sens_callback;
    rot_slider_list[0].closure = pView; 
    rot_slider_list[1].callback = NULL;
    
    pView->fprotation_slider = new G4OpenGLXmSliderBar ("Rotation slider",
                                rot_slider_list,
                                True,
                                2,
                                pView->fRot_sens,
                                pView->rot_sens_limit,
                                0);
    pView->fprotation_slider_box->AddChild (pView->fprotation_slider);
    
    pView->fprotation_arrow_box = new G4OpenGLXmBox ("Rotation arrow box", False);
    pView->fprotation_top->AddChild (pView->fprotation_arrow_box);
    
    XtCallbackRec** rotation_callbacks = new XtCallbackRec*[4];
    for (G4int i = 0; i < 4; i++) {
      rotation_callbacks[i] = new XtCallbackRec[2];
    }
    rotation_callbacks[0][0].callback = phi_rotation_callback;
    rotation_callbacks[0][0].closure =  pView;
    rotation_callbacks[0][1].callback   = NULL;
    
    rotation_callbacks[1][0].callback = phi_rotation_callback;
    rotation_callbacks[1][0].closure =  pView;
    rotation_callbacks[1][1].callback   = NULL;
    
    rotation_callbacks[2][0].callback = theta_rotation_callback;
    rotation_callbacks[2][0].closure =  pView;
    rotation_callbacks[2][1].callback   = NULL;
    
    rotation_callbacks[3][0].callback = theta_rotation_callback;
    rotation_callbacks[3][0].closure =  pView;
    rotation_callbacks[3][1].callback   = NULL;
    
    pView->fprotation_arrow = new G4OpenGLXmFourArrowButtons (rotation_callbacks);
    
    pView->fprotation_arrow_box->AddChild (pView->fprotation_arrow);
    
    pView->fprotation_top->Realize ();
      }
      break;
      
    }
  
  
  case 1:
    {
      if (!pView->GetSceneHandler()->GetScene()) {
        break;
      }
      if (!pView->fppanning_top) {
    std::ostringstream pan_Name;
    pan_Name << pView->GetSceneHandler()->GetSceneHandlerId() << '-' << pView->fViewId;
    
    pView->fppanning_top = new G4OpenGLXmTopLevelShell (pView, 
                                (char*)pan_Name.str().c_str());
    
    pView->fppanning_box = new G4OpenGLXmFramedBox ("Pan up-down-left-right", 
                            False);
    
    pView->fppanning_top->AddChild (pView->fppanning_box);
    
    XtCallbackRec** pan_callbacks = new XtCallbackRec*[4];
    for (G4int i = 0; i < 4; i++) {
      pan_callbacks[i] = new XtCallbackRec[2];
    }
    pan_callbacks[0][0].callback = pan_up_down_callback;
    pan_callbacks[0][0].closure = pView; 
    pan_callbacks[0][1].callback = NULL;
    
    pan_callbacks[1][0].callback = pan_up_down_callback;
    pan_callbacks[1][0].closure = pView; 
    pan_callbacks[1][1].callback = NULL;
    
    pan_callbacks[2][0].callback = pan_left_right_callback;
    pan_callbacks[2][0].closure = pView; 
    pan_callbacks[2][1].callback = NULL;
    
    pan_callbacks[3][0].callback = pan_left_right_callback;
    pan_callbacks[3][0].closure = pView; 
    pan_callbacks[3][1].callback = NULL;
    
    pView->fppanning_arrows = new G4OpenGLXmFourArrowButtons (pan_callbacks);
    
    pView->fppanning_box->AddChild (pView->fppanning_arrows);
    
    XtCallbackRec* pan_slider_list = new XtCallbackRec[2];
    pan_slider_list[0].callback = set_pan_sens_callback;
    pan_slider_list[0].closure = pView; 
    pan_slider_list[1].callback = NULL;
    
    pView->fppanning_slider = new G4OpenGLXmSliderBar ("Panning slider",
                               pan_slider_list,
                               True,
                               2,
                               pView->fPan_sens = pView->GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius() / 10.0,
                               pView->pan_sens_limit = pView->GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius(),
                               0);
    pView->fppanning_box->AddChild (pView->fppanning_slider);
    
    pView->fpzoom_box = new G4OpenGLXmFramedBox ("Zoom", 
                             False);      
    pView->fppanning_top->AddChild (pView->fpzoom_box);
    
    XtCallbackRec* zoom_slider_list = new XtCallbackRec[2];
    zoom_slider_list[0].callback = zoom_callback;
    zoom_slider_list[0].closure = pView; 
    zoom_slider_list[1].callback = NULL;
    
    pView->fpzoom_slider = new G4OpenGLXmSliderBar ("Zoom slider",
                            zoom_slider_list,
                            True,
                            2,
                            pView->fVP.GetZoomFactor(),
                            pView->zoom_high,
                            pView->zoom_low);
    pView->fpzoom_box->AddChild (pView->fpzoom_slider);
    
    pView->fpdolly_box = new G4OpenGLXmFramedBox ("Dolly", 
                              False);      
    pView->fppanning_top->AddChild (pView->fpdolly_box);
    
    XtCallbackRec* dolly_slider_list = new XtCallbackRec[2];
    dolly_slider_list[0].callback = dolly_callback;
    dolly_slider_list[0].closure = pView; 
    dolly_slider_list[1].callback = NULL;
    
    pView->fpdolly_slider = new G4OpenGLXmSliderBar ("Dolly slider",
                             dolly_slider_list,
                             True,
                             2,
                             pView->fVP.GetDolly(),
                             pView->dolly_high = pView->GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius(),
                             pView->dolly_low = -(pView->GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius()));
    //                           pView->dolly_high,
    //                           pView->dolly_low);
    pView->fpdolly_box->AddChild (pView->fpdolly_slider);
    
    pView->fppanning_top->Realize ();
        pView->UpdateControlPanel ();
      }
 
      break;
      
    }
  case 2:
    {
      
      if (!pView->fpsetting_top) {
    std::ostringstream set_Name;
    set_Name << pView->GetSceneHandler()->GetSceneHandlerId() << '-' << pView->fViewId;
    
    pView->fpsetting_top = new G4OpenGLXmTopLevelShell(pView,
                               (char*)set_Name.str().c_str());
    
    pView->fpsetting_box = new G4OpenGLXmFramedBox ("Set values for control panels",
                            False);
    pView->fpsetting_top->AddChild (pView->fpsetting_box);
    
    pView->fppan_set = new G4OpenGLXmTextField ("Upper limit of pan sensitivity",
                            &(pView->pan_sens_limit));
    
    pView->fprot_set = new G4OpenGLXmTextField ("Upper limit of rotation sensitivity",
                            &(pView->rot_sens_limit));
    
    pView->fpzoom_upper = new G4OpenGLXmTextField ("Upper limit of zoom",
                               &(pView->zoom_high));
    
    pView->fpzoom_lower = new G4OpenGLXmTextField ("Lower limit of zoom",
                               &(pView->zoom_low));
    
    pView->fpdolly_upper = new G4OpenGLXmTextField ("Upper limit of dolly",
                            &(pView->dolly_high));
    
    pView->fpdolly_lower = new G4OpenGLXmTextField ("Lower limit of dolly",
                            &(pView->dolly_low));
    
    XtCallbackRec* ok_list = new XtCallbackRec[2];
    ok_list[0].callback = update_panels_callback;
    ok_list[0].closure = pView; 
    ok_list[1].callback = NULL;
    
    
    pView->fpok_button = new G4OpenGLXmPushButton ("ok",
                               ok_list);
    
    pView->fpsetting_box->AddChild (pView->fppan_set);
    pView->fpsetting_box->AddChild (pView->fprot_set);
    pView->fpsetting_box->AddChild (pView->fpzoom_upper);
    pView->fpsetting_box->AddChild (pView->fpzoom_lower);
    pView->fpsetting_box->AddChild (pView->fpdolly_upper);
    pView->fpsetting_box->AddChild (pView->fpdolly_lower);
    pView->fpsetting_box->AddChild (pView->fpok_button);
    
    pView->fpsetting_top->Realize ();
    
      }
 
      break;
    }
  
  default:
    G4Exception
      ("G4OpenGLXmViewer::actions_callback",
       "opengl2001", FatalException,
       "Unrecognised widget child of control_callback");
  }
  
  return;
}

References G4OpenGLXmBox::AddChild(), G4OpenGLXmFramedBox::AddChild(), G4OpenGLXmTopLevelShell::AddChild(), dolly_callback(), dolly_high, dolly_low, FatalException, G4OpenGLViewer::fPan_sens, fpdolly_box, fpdolly_lower, fpdolly_slider, fpdolly_upper, fpok_button, fppan_set, fppanning_arrows, fppanning_box, fppanning_slider, fppanning_top, fprot_set, fprotation_arrow, fprotation_arrow_box, fprotation_button1, fprotation_button2, fprotation_button_box, fprotation_slider, fprotation_slider_box, fprotation_top, fpsetting_box, fpsetting_top, fpzoom_box, fpzoom_lower, fpzoom_slider, fpzoom_upper, G4OpenGLViewer::fRot_sens, G4VViewer::fViewId, G4VViewer::fVP, G4Exception(), G4ViewParameters::GetDolly(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetLightsMoveWithCamera(), G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4VSceneHandler::GetSceneHandlerId(), G4VViewer::GetViewParameters(), G4ViewParameters::GetZoomFactor(), pan_left_right_callback(), pan_sens_limit, pan_up_down_callback(), phi_rotation_callback(), G4OpenGLXmTopLevelShell::Realize(), rot_sens_limit, set_pan_sens_callback(), set_rot_sens_callback(), set_rot_subject_callback(), theta_rotation_callback(), update_panels_callback(), UpdateControlPanel(), zoom_callback(), zoom_high, and zoom_low.

Referenced by CreateMainWindow().

Add_four_arrow_buttons()

void G4OpenGLXmViewer::Add_four_arrow_buttons ( G4OpenGLXmViewer *  pView, XtCallbackRec **  arrow_callbacks, Widget *  parent_widget  )

static

Definition at line 49 of file G4OpenGLXmConvenienceRoutines.cc.

                                                {
  
  Widget arrow_form = XtVaCreateWidget 
    ("arrow_form",
     xmFormWidgetClass,
     *parent_widget,
     XmNfractionBase, 3,
     XtNvisual, pView->vi->visual, 
     XtNdepth, pView->vi->depth, 
     XtNcolormap, pView->cmap, 
     XtNborderColor, pView->borcol,
     XtNbackground, pView->bgnd,
     NULL);
  
  Widget arrow = XtVaCreateManagedWidget 
    ("up_arrow",
     xmArrowButtonGadgetClass, 
     arrow_form,
     XmNtopAttachment, XmATTACH_POSITION,
     XmNtopPosition, 0,
     XmNbottomAttachment, XmATTACH_POSITION,
     XmNbottomPosition, 1,
     XmNleftAttachment, XmATTACH_POSITION,
     XmNleftPosition, 1,
     XmNrightAttachment, XmATTACH_POSITION,
     XmNrightPosition, 2,
     XmNarrowDirection, XmARROW_UP,
     NULL);
  
  XtVaSetValues (arrow,
         XmNuserData, True,
         NULL);
  
  XtAddCallbacks (arrow, 
         XmNactivateCallback, 
         arrow_callbacks[0]);
  
  XtAddCallbacks (arrow, 
         XmNarmCallback, 
         arrow_callbacks[0]);
  
  XtAddCallbacks (arrow, 
         XmNdisarmCallback, 
         arrow_callbacks[0]);
  
  arrow = XtVaCreateManagedWidget 
    ("down_arrow",
     xmArrowButtonGadgetClass, 
     arrow_form,
     XmNtopAttachment, XmATTACH_POSITION,
     XmNtopPosition, 2,
     XmNbottomAttachment, XmATTACH_POSITION,
     XmNbottomPosition, 3,
     XmNleftAttachment, XmATTACH_POSITION,
     XmNleftPosition, 1,
     XmNrightAttachment, XmATTACH_POSITION,
     XmNrightPosition, 2,
     XmNarrowDirection, XmARROW_DOWN,
     NULL);
  
  XtVaSetValues (arrow,
         XmNuserData, False,
         NULL);
  
  XtAddCallbacks (arrow, 
         XmNactivateCallback, 
         arrow_callbacks[1]);
  
  XtAddCallbacks (arrow, 
         XmNarmCallback,
         arrow_callbacks[1]);
  
  XtAddCallbacks (arrow, 
         XmNdisarmCallback, 
         arrow_callbacks[1]);
  
  arrow = XtVaCreateManagedWidget 
    ("left_arrow",
     xmArrowButtonGadgetClass, 
     arrow_form,
     XmNtopAttachment, XmATTACH_POSITION,
     XmNtopPosition, 1,
     XmNbottomAttachment, XmATTACH_POSITION,
     XmNbottomPosition, 2,
     XmNleftAttachment, XmATTACH_POSITION,
     XmNleftPosition, 0,
     XmNrightAttachment, XmATTACH_POSITION,
     XmNrightPosition, 1,
     XmNarrowDirection, XmARROW_LEFT,
     NULL);
  
  XtVaSetValues (arrow,
         XmNuserData, False,
         NULL);
 
  XtAddCallbacks (arrow, 
         XmNactivateCallback, 
         arrow_callbacks[2]);
 
  XtAddCallbacks (arrow, 
         XmNarmCallback, 
         arrow_callbacks[2]);
  
  XtAddCallbacks (arrow, 
         XmNdisarmCallback, 
         arrow_callbacks[2]);
      
  arrow = XtVaCreateManagedWidget 
    ("right_arrow",
     xmArrowButtonGadgetClass, 
     arrow_form,
     XmNtopAttachment, XmATTACH_POSITION,
     XmNtopPosition, 1,
     XmNbottomAttachment, XmATTACH_POSITION,
     XmNbottomPosition, 2,
     XmNleftAttachment, XmATTACH_POSITION,
     XmNleftPosition, 2,
     XmNrightAttachment, XmATTACH_POSITION,
     XmNrightPosition, 3,
     XmNarrowDirection, XmARROW_RIGHT,
     NULL);
  
  XtVaSetValues (arrow,
         XmNuserData, True,
         NULL);
  
  XtAddCallbacks (arrow, 
         XmNactivateCallback, 
         arrow_callbacks[3]);
  
  XtAddCallbacks (arrow, 
         XmNarmCallback, 
         arrow_callbacks[3]);
 
  XtAddCallbacks (arrow, 
         XmNdisarmCallback, 
         arrow_callbacks[3]);
  
  XtManageChild (arrow_form);
  
}

References bgnd, borcol, G4OpenGLXViewer::cmap, and G4OpenGLXViewer::vi.

Add_radio_box()

void G4OpenGLXmViewer::Add_radio_box ( char *  label_string, Widget *  parent_frame_widget, XtCallbackRec *  radio_box_cb, G4int  num_buttons, G4int  default_button, char *  radio_box_name, char **  button_names, G4OpenGLXmViewer *  pView  )

static

Definition at line 193 of file G4OpenGLXmConvenienceRoutines.cc.

{
  XmString button_str = XmStringCreateLocalized((char*) ""); // ...to
  // initialise to something to avoid pedantic warning.
  Arg** args;
  args = new Arg* [num_buttons];
  Widget button;
 
  G4int i;
  for (i = 0; i < num_buttons; i++) {
 
    args[i] = new Arg[7];
    button_str = XmStringCreateLocalized (button_names[i]);
 
    XtSetArg (args[i][0], XtNvisual, pView->vi->visual);
    XtSetArg (args[i][1], XtNdepth, pView->vi->depth);
    XtSetArg (args[i][2], XtNcolormap, pView->cmap);
    XtSetArg (args[i][3], XtNborderColor, pView->borcol);
    XtSetArg (args[i][4], XtNbackground, pView->bgnd);
    XtSetArg (args[i][5], XmNlabelString, button_str); 
 
    if (i == default_button) {
      XtSetArg (args[i][6], XmNset, True);
    } else {
      XtSetArg (args[i][6], XmNset, False);
    }
  }
  
  Widget radio_box = XtVaCreateWidget (radio_box_name,
                       xmRowColumnWidgetClass,
                       *parent_widget,
                       XmNisHomogeneous, False,
                       XmNradioBehavior, True,
                       XmNradioAlwaysOne, True,
                       XmNuserData, pView,
                       XtNvisual, pView->vi->visual,
                       XtNdepth, pView->vi->depth,
                       XtNcolormap, pView->cmap,
                       XtNborderColor, pView->borcol,
                       XtNbackground, pView->bgnd,
                       NULL);
 
  XmString lab = XmStringCreateLocalized (label_string);
 
  // Unused!
  //Widget label = XtVaCreateManagedWidget ("radio_label",
  //                  xmLabelWidgetClass,
  //                  radio_box,
  //                  XmNalignment, XmALIGNMENT_CENTER,
  //                  XmNlabelString, lab,
  //                  XtNvisual, pView->vi->visual,
  //                  XtNdepth, pView->vi->depth,
  //                  XtNcolormap, pView->cmap,
  //                  XtNborderColor, pView->borcol,
  //                  XtNbackground, pView->bgnd,
  //                  NULL);
 
  XmStringFree (lab);
 
  for (i = 0; i < num_buttons; i++) {
    button = XtCreateManagedWidget (button_names[i],
                    xmToggleButtonWidgetClass,
                    radio_box,
                    args[i],
                    7);
    XtVaSetValues (button,
           XmNuserData, i,
           NULL);
    
    XtAddCallbacks (button,
           XmNarmCallback,
           radio_box_callback);
  }
 
  XtManageChild (radio_box);
 
  XmStringFree (button_str);
  
  for (i = 0; i < num_buttons; i++) {
 
    delete[] args[i];
 
  }
 
  delete[] args;
}  

References args, bgnd, borcol, G4OpenGLXViewer::cmap, and G4OpenGLXViewer::vi.

Add_set_field()

void G4OpenGLXmViewer::Add_set_field ( char *  widget, char *  widget_text, Widget *  row_col_box, Widget *  wid, G4double *  val, G4OpenGLXmViewer *  pView  )

static

Definition at line 287 of file G4OpenGLXmConvenienceRoutines.cc.

{
 
  char local_w_text[50];
  strcpy (local_w_text, w_text);
 
  char label_name[50];
  strcpy (label_name, w_name);
  strcat (label_name, "_label");
  
  char text_field_name[50];
  strcpy (text_field_name, w_name);
  strcat (text_field_name, "_text_field");
  
  XmString local_text = XmStringCreateLocalized (local_w_text);
 
  // Unused!
  //  Widget label = XtVaCreateManagedWidget (label_name, 
  //                  xmLabelWidgetClass,
  //                  *row_col_box,
  //                  XmNlabelString, local_text,
  //                  XtNvisual, pView->vi->visual, 
  //                  XtNdepth, pView->vi->depth, 
  //                  XtNcolormap, pView->cmap, 
  //                  XtNborderColor, pView->borcol,
  //                  XtNbackground, pView->bgnd,
  //                  NULL);
 
  XmStringFree (local_text);
 
  char initial[50];
  sprintf (initial, "%6.2f", *val);
  
  *wid = XtVaCreateManagedWidget (text_field_name,
                  xmTextFieldWidgetClass,
                  *row_col_box,
                  XmNvalue, (String)initial,
                  XtNvisual, pView->vi->visual, 
                  XtNdepth, pView->vi->depth, 
                  XtNcolormap, pView->cmap, 
                  XtNborderColor, pView->borcol,
                  XtNbackground, pView->bgnd,
                  NULL);
 
  XtAddCallback (*wid, 
         XmNvalueChangedCallback,
         get_double_value_callback,
         val);
 
  /* Not actually used - comment out to prevent compiler warnings.
     Instead, just in case it matters, just invoke
     XtVaCreateManagedWidget (JA)
  Widget sep = XtVaCreateManagedWidget ("sep",
                    xmSeparatorWidgetClass,
                    *row_col_box,
                    XmNorientation, XmHORIZONTAL,
                    XtNvisual, pView->vi->visual, 
                    XtNdepth, pView->vi->depth, 
                    XtNcolormap, pView->cmap, 
                    XtNborderColor, pView->borcol,
                    XtNbackground, pView->bgnd,
                    NULL);
  sep = XtVaCreateManagedWidget ("sep",
                 xmSeparatorWidgetClass,
                 *row_col_box,
                 XmNseparatorType, XmNO_LINE,
                 XmNmargin, 1,
                 XmNorientation, XmHORIZONTAL,
                 XtNvisual, pView->vi->visual, 
                 XtNdepth, pView->vi->depth, 
                 XtNcolormap, pView->cmap, 
                 XtNborderColor, pView->borcol,
                 XtNbackground, pView->bgnd,
                 NULL);
  */
  XtVaCreateManagedWidget ("sep",
                 xmSeparatorWidgetClass,
                 *row_col_box,
                 XmNseparatorType, XmNO_LINE,
                 XmNmargin, 1,
                 XmNorientation, XmHORIZONTAL,
                 XtNvisual, pView->vi->visual, 
                 XtNdepth, pView->vi->depth, 
                 XtNcolormap, pView->cmap, 
                 XtNborderColor, pView->borcol,
                 XtNbackground, pView->bgnd,
                 NULL);
}

References bgnd, borcol, G4OpenGLXViewer::cmap, get_double_value_callback(), initial, and G4OpenGLXViewer::vi.

Add_slider_box()

void G4OpenGLXmViewer::Add_slider_box ( char *  label_string, G4int  num_sliders, char **  slider_name, G4OpenGLXmViewer *  pView, G4double *  min_array, G4double *  max_array, G4double *  value_array, G4bool *  show, short *  decimals, unsigned char *  orientation, unsigned char *  direction, XtCallbackRec **  slider_box_cb, Widget *  parent_frame_widget  )

static

Definition at line 381 of file G4OpenGLXmConvenienceRoutines.cc.

{
  XmString slider_name_str = XmStringCreateLocalized((char*) ""); // ...to
  // initialise to something to avoid pedantic warning.
  Arg** slider_args;
  slider_args = new Arg*[num_sliders];
  Widget slider;
  G4int j = 0;
 
  G4int i;
  for (i = 0; i < num_sliders; i++) {
    j = 0; 
    slider_args[i] = new Arg[13];
    slider_name_str = XmStringCreateLtoR (slider_names[i], 
                      XmFONTLIST_DEFAULT_TAG);
    
    XtSetArg (slider_args[i][j], 
          XtNvisual, pView->vi->visual); j++;
    XtSetArg (slider_args[i][j], 
          XtNdepth, pView->vi->depth); j++;
    XtSetArg (slider_args[i][j], 
          XtNcolormap, pView->cmap); j++;
    XtSetArg (slider_args[i][j], 
          XtNborderColor, pView->borcol); j++;
    XtSetArg (slider_args[i][j], 
          XtNbackground, pView->bgnd); j++;
    
    XtSetArg (slider_args[i][j], 
          XmNtitleString, slider_name_str);  j++;
    
    XtSetArg (slider_args[i][j], 
          XmNmaximum, G4int(max_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
    XtSetArg (slider_args[i][j], 
          XmNminimum, G4int(min_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
    XtSetArg (slider_args[i][j], 
          XmNvalue, G4int(value_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
    XtSetArg (slider_args[i][j], 
          XmNshowValue, show[i]); j++;
    XtSetArg (slider_args[i][j], 
          XmNdecimalPoints, decimals[i]); j++;
    
    XtSetArg (slider_args[i][j], 
          XmNorientation, orientation[i]);  j++;
    XtSetArg (slider_args[i][j], 
          XmNprocessingDirection, direction[i]); j++;
 
  }
 
  Widget slider_box = XtVaCreateWidget ("slider_box",
                    xmRowColumnWidgetClass,
                    *parent_widget,
                    XmNisHomogeneous, False,
                    XtNvisual, pView->vi->visual,
                    XtNdepth, pView->vi->depth,
                    XtNcolormap, pView->cmap,
                    XtNborderColor, pView->borcol,
                    XtNbackground, pView->bgnd,
                    NULL);
 
  XmString lab = XmStringCreateLocalized (label_string);
 
  // Unused!
  //Widget label = XtVaCreateManagedWidget ("slider_label",
  //                  xmLabelWidgetClass,
  //                  slider_box,
  //                  XmNlabelString, lab,
  //                  XmNalignment, XmALIGNMENT_CENTER,
  //                  XtNvisual, pView->vi->visual,
  //                  XtNdepth, pView->vi->depth,
  //                  XtNcolormap, pView->cmap,
  //                  XtNborderColor, pView->borcol,
  //                  XtNbackground, pView->bgnd,
  //                  NULL);
 
  XmStringFree (lab);
  
  for (i = 0; i < num_sliders; i++) {
    
    slider = XtCreateManagedWidget (slider_names[i],
                    xmScaleWidgetClass,
                    slider_box,
                    slider_args[i],
                    j);
 
    XtAddCallbacks (slider,
           XmNvalueChangedCallback,
           slider_box_callbacks[i]);
    
    XtAddCallbacks (slider,
           XmNdragCallback,
           slider_box_callbacks[i]);
    
  }
 
  XtManageChild (slider_box);
  XmStringFree (slider_name_str);
 
  for (i = 0; i < num_sliders; i++) {
 
    delete[] slider_args[i];
 
  }
 
  delete[] slider_args;
 
}

References bgnd, borcol, G4OpenGLXViewer::cmap, and G4OpenGLXViewer::vi.

addExportImageFormat()

void G4OpenGLViewer::addExportImageFormat ( std::string  format )

protectedinherited

Definition at line 1288 of file G4OpenGLViewer.cc.

                                                          {
  fExportImageFormatVector.push_back(format);
}

References G4OpenGLViewer::fExportImageFormatVector.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLViewer::G4OpenGLViewer().

antialias_callback()

void G4OpenGLXmViewer::antialias_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 155 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
 
  switch (choice) {
    
  case 0:
    pView->antialiasing_enabled = false;
    glDisable (GL_LINE_SMOOTH);
    glDisable (GL_POLYGON_SMOOTH);
    break;
 
  case 1:
    pView->antialiasing_enabled = true;
    glEnable (GL_LINE_SMOOTH);
    glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
    glEnable (GL_POLYGON_SMOOTH);
    glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    break;
 
  default:
    G4Exception
      ("G4OpenGLXmViewer::antialias_callback",
       "opengl2010", FatalException,
       "Unrecognised case in antialiasing_callback.");
  }
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::antialiasing_enabled, G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4Exception(), and G4OpenGLXViewer::SetView().

Referenced by CreateMainWindow().

aux_edge_callback()

void G4OpenGLXmViewer::aux_edge_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 225 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
 
  switch (choice) {
    
  case 0:
    pView->fVP.SetAuxEdgeVisible(false);
    break;
 
  case 1:
    pView->fVP.SetAuxEdgeVisible(true);
    break;
 
  default:
    G4Exception
      ("G4OpenGLXmViewer::aux_edge_callback",
       "opengl2012", FatalException,
       "Unrecognised case in aux_edge_callback.");
  }
 
  pView->SetNeedKernelVisit (true);
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4VViewer::fVP, G4Exception(), G4ViewParameters::SetAuxEdgeVisible(), G4VViewer::SetNeedKernelVisit(), and G4OpenGLXViewer::SetView().

Referenced by CreateMainWindow().

background_color_callback()

void G4OpenGLXmViewer::background_color_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 82 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
 
 
  //I need to revisit the kernel if the background colour changes and
  //hidden line removal is enabled, because hlr drawing utilises the
  //background colour in its drawing...
  // (Note added by JA 13/9/2005) Background now handled in view
  // parameters.  A kernel visit is triggered on change of background.
  switch (choice) {
    
  case 0:
    ((G4ViewParameters&)pView->GetViewParameters()).
      SetBackgroundColour(G4Colour(1.,1.,1.));  // White
    break;
 
  case 1:
    ((G4ViewParameters&)pView->GetViewParameters()).
      SetBackgroundColour(G4Colour(0.,0.,0.));  // Black
    break;
 
  default:
    G4Exception
      ("G4OpenGLXmViewer::background_color_callback",
       "opengl2008", FatalException,
       "Unrecognised case in background_color_callback.");
  }
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4Exception(), G4VViewer::GetViewParameters(), and G4OpenGLXViewer::SetView().

Referenced by CreateMainWindow().

ChangeLineWidth()

void G4OpenGLViewer::ChangeLineWidth ( G4double  width )

protectedinherited

Change LineSize on gl2ps if needed

Definition at line 810 of file G4OpenGLViewer.cc.

                                                   {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setLineWidth(int(width));
  } else {
    glLineWidth (width);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLViewer::HaloingFirstPass(), and G4OpenGLViewer::HaloingSecondPass().

ChangePointSize()

void G4OpenGLViewer::ChangePointSize ( G4double  size )

protectedinherited

Change PointSize on gl2ps if needed

Definition at line 798 of file G4OpenGLViewer.cc.

                                                  {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setPointSize(int(size));
  } else {
    glPointSize (size);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setPointSize().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

ClearView()

void G4OpenGLViewer::ClearView ( void  )

virtualinherited

Implements G4VViewer.

Definition at line 203 of file G4OpenGLViewer.cc.

                                {
  ClearViewWithoutFlush();
 
  if(!isFramebufferReady()) {
    return;
  }
 
  glFlush();
}

References G4OpenGLViewer::ClearViewWithoutFlush(), and G4OpenGLViewer::isFramebufferReady().

Referenced by antialias_callback(), aux_edge_callback(), background_color_callback(), G4OpenGLStoredQtViewer::ComputeView(), dolly_callback(), drawing_style_callback(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), haloing_callback(), G4OpenGLImmediateWin32Viewer::Initialise(), G4OpenGLStoredWin32Viewer::Initialise(), G4OpenGLViewer::InitializeGLView(), left_right_pan_callback(), G4OpenGLImmediateQtViewer::paintGL(), G4OpenGLStoredQtViewer::paintGL(), projection_callback(), reset_callback(), rotate_in_phi(), rotate_in_theta(), transparency_callback(), up_down_pan_callback(), wobble_timer_callback(), and zoom_callback().

ClearViewWithoutFlush()

void G4OpenGLViewer::ClearViewWithoutFlush ( )

inherited

Definition at line 214 of file G4OpenGLViewer.cc.

                                            {
  // Ready for clear ?
  // See : http://lists.apple.com/archives/mac-opengl/2012/Jul/msg00038.html
  if(!isFramebufferReady()) {
    return;
  }
  
  glClearColor (background.GetRed(),
                background.GetGreen(),
                background.GetBlue(),
                1.);
  glClearDepth (1.0);
  //Below line does not compile with Mesa includes.
  //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glClear (GL_COLOR_BUFFER_BIT);
  glClear (GL_DEPTH_BUFFER_BIT);
  glClear (GL_STENCIL_BUFFER_BIT);
}

References G4OpenGLViewer::background, G4Colour::GetBlue(), G4Colour::GetGreen(), G4Colour::GetRed(), and G4OpenGLViewer::isFramebufferReady().

Referenced by G4OpenGLViewer::ClearView().

ComputeFlyThrough()

std::vector< G4ThreeVector > G4VViewer::ComputeFlyThrough ( G4Vector3D *  )

inherited

Definition at line 215 of file G4VViewer.cc.

{
    enum CurveType {
        Bezier,
        G4SplineTest};
    
    // Choose a curve type (for testing)
//    int myCurveType = Bezier;
 
    // number if step points
    int stepPoints = 500;
 
    
    G4Spline spline;
 
    
    // At the moment we don't use the aVect parameters, but build it here :
    // Good step points for exampleB5
    spline.AddSplinePoint(G4Vector3D(0,1000,-14000));
    spline.AddSplinePoint(G4Vector3D(0,1000,0));
    spline.AddSplinePoint(G4Vector3D(-4000,1000,4000));
 
    
    std::vector <G4ThreeVector> viewVect;
 
//    if(myCurveType == Bezier) {
 
        
        // Draw the spline
        
        for (int i = 0; i < stepPoints; i++) {
            float t = (float)i / (float)stepPoints;
            G4Vector3D cameraPosition = spline.GetInterpolatedSplinePoint(t);
            //        G4Vector3D targetPoint = spline.GetInterpolatedSplinePoint(t);
            
            //        viewParam->SetViewAndLights(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
            //        viewParam->SetCurrentTargetPoint(targetPoint);
            G4cout << "FLY CR("<< i << "):" << cameraPosition << G4endl;
            viewVect.push_back(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
        }
        
//    } else if (myCurveType == G4SplineTest) {
        /*
         This method is a inspire from a Bezier curve. The problem of the Bezier curve is that the path does not go straight between two waypoints.
         This method add "stay straight" parameter which could be between 0 and 1 where the pass will follow exactly the line between the waypoints
         Ex : stay straight = 50%
         m1 = 3*(P1+P0)/2
         
         Ex : stay straight = 0%
         m1 = (P1+P0)/2
         
         P1
         /  \
         /    \
         a--x--b
         /  °  °  \
         / °      ° \
         m1           m2
         /              \
         /                \
         /                  \
         /                    \
         P0                     P2
         
         */
//        G4Vector3D a;
//        G4Vector3D b;
//        G4Vector3D m1;
//        G4Vector3D m2;
//        G4Vector3D P0;
//        G4Vector3D P1;
//        G4Vector3D P2;
//        G4double stayStraight = 0;
//        G4double bezierSpeed = 0.4; // Spend 40% time in bezier curve (time between m1-m2 is 40% of time between P0-P1)
//        
//        G4Vector3D firstPoint;
//        G4Vector3D lastPoint;
//        
//        float nbBezierSteps = (stepPoints * bezierSpeed*(1-stayStraight)) * (2./spline.GetNumPoints());
//        float nbFirstSteps = ((stepPoints/2-nbBezierSteps/2) /(1+stayStraight)) * (2./spline.GetNumPoints());
//        
//        // First points
//        firstPoint = spline.GetPoint(0);
//        lastPoint = (firstPoint + spline.GetPoint(1))/2;
//        
//        for( float j=0; j<1; j+= 1/nbFirstSteps) {
//            G4ThreeVector pt = firstPoint + (lastPoint - firstPoint) * j;
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier A1("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//        
//        for (int i = 0; i < spline.GetNumPoints()-2; i++) {
//            P0 = spline.GetPoint(i);
//            P1 = spline.GetPoint(i+1);
//            P2 = spline.GetPoint(i+2);
//            
//            m1 = P1 - (P1-P0)*(1-stayStraight)/2;
//            m2 = P1 + (P2-P1)*(1-stayStraight)/2;
//            
//            // We have to get straight path from (middile of P0-P1) to (middile of P0-P1 + (dist P0-P1) * stayStraight/2)
//            if (stayStraight >0) {
//                
//                firstPoint = (P0 + P1)/2;
//                lastPoint = (P0 + P1)/2 + (P1-P0)*stayStraight/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier A2("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//            // Compute Bezier curve
//            for( float delta = 0 ; delta < 1 ; delta += 1/nbBezierSteps)
//            {
//                // The Green Line
//                a = m1 + ( (P1 - m1) * delta );
//                b = P1 + ( (m2 - P1) * delta );
//                
//                // Final point
//                G4ThreeVector pt = a + ((b-a) * delta );
//                viewVect.push_back(pt);
//                G4cout << "FLY Bezier("<< viewVect.size()<< "):" << pt << G4endl;
//            }
//            
//            // We have to get straight path
//            if (stayStraight >0) {
//                firstPoint = (P1 + P2)/2 - (P2-P1)*stayStraight/2;
//                lastPoint = (P1 + P2)/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier B1("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//        }
//        
//        // last points
//        firstPoint = spline.GetPoint(spline.GetNumPoints()-2);
//        lastPoint = spline.GetPoint(spline.GetNumPoints()-1);
//        for( float j=1; j>0; j-= 1/nbFirstSteps) {
//            G4ThreeVector pt = lastPoint - ((lastPoint-firstPoint)*((1-stayStraight)/2) * j );
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier B2("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//    }
    return viewVect;
}

References G4VViewer::G4Spline::AddSplinePoint(), G4cout, G4endl, G4VViewer::G4Spline::GetInterpolatedSplinePoint(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

CreateFontLists()

void G4OpenGLXViewer::CreateFontLists ( )

protectedvirtualinherited

Reimplemented from G4OpenGLViewer.

Definition at line 356 of file G4OpenGLXViewer.cc.

{
  std::map<G4double,G4String> fonts;  // G4VMarker screen size and font name.
  fonts[10.] = "-adobe-courier-bold-r-normal--10-100-75-75-m-60-iso8859-1";
  fonts[11.] = "-adobe-courier-bold-r-normal--11-80-100-100-m-60-iso8859-1";
  fonts[12.] = "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1";
  fonts[13.] = "fixed";
  fonts[14.] = "-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1";
  fonts[17.] = "-adobe-courier-bold-r-normal--17-120-100-100-m-100-iso8859-1";
  fonts[18.] = "-adobe-courier-bold-r-normal--18-180-75-75-m-110-iso8859-1";
  fonts[20.] = "-adobe-courier-bold-r-normal--20-140-100-100-m-110-iso8859-1";
  fonts[24.] = "-adobe-courier-bold-r-normal--24-240-75-75-m-150-iso8859-1";
  fonts[25.] = "-adobe-courier-bold-r-normal--25-180-100-100-m-150-iso8859-1";
  fonts[34.] = "-adobe-courier-bold-r-normal--34-240-100-100-m-200-iso8859-1";
  std::map<G4double,G4String>::const_iterator i;
  for (i = fonts.begin(); i != fonts.end(); ++i) {
    XFontStruct* font_info = XLoadQueryFont(dpy, i->second);
    if (!font_info) {
      G4cerr <<
    "G4OpenGLXViewer::CreateFontLists XLoadQueryFont failed for font\n  "
         << i->second
         << G4endl;
      continue;
    }
    G4int font_base = glGenLists(256);
    if (!font_base) {
      G4cerr <<
    "G4OpenGLXViewer::CreateFontLists out of display lists for fonts." 
         << G4endl;
      continue;
    }
    G4int first = font_info->min_char_or_byte2;
    G4int last  = font_info->max_char_or_byte2;
    glXUseXFont(font_info->fid, first, last-first+1, font_base + first);
    G4int width = font_info->max_bounds.width;
    G4OpenGLFontBaseStore::AddFontBase
      (this, font_base, i->first, i->second, width);
  }
}

References G4OpenGLFontBaseStore::AddFontBase(), G4OpenGLXViewer::dpy, G4cerr, and G4endl.

Referenced by G4OpenGLImmediateXViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

CreateGLXContext()

void G4OpenGLXViewer::CreateGLXContext ( XVisualInfo *  vi )

protectedinherited

Definition at line 172 of file G4OpenGLXViewer.cc.

                                                      {
 
  vi = v;
// get window's attributes
  if (!XGetWindowAttributes(dpy, XRootWindow (dpy, vi -> screen), &xwa)) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't return window attributes"
     << G4endl;
    return;
  }
  
// create the master GLX context
  cxMaster = glXCreateContext (dpy, vi, 0, true);
  if (!cxMaster) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't create context."
     << G4endl;
    return;
  }
 
// New stab at getting a colormap
 
  Status status;
  int i, numCmaps;
 
  status = XmuLookupStandardColormap (dpy, 
                      vi -> screen, 
                      vi -> visualid, 
                      vi -> depth, 
                      XA_RGB_BEST_MAP,
                      False, 
                      True);
 
  if (status == 1) {
    cmap = 0;
    XStandardColormap* standardCmaps = XAllocStandardColormap ();
    status = XGetRGBColormaps (dpy, 
                   XRootWindow (dpy, vi -> screen),
                   &standardCmaps, 
                   &numCmaps, 
                   XA_RGB_BEST_MAP);
    if (status == 1) {
      for (i = 0; i < numCmaps; i++) {
    if (standardCmaps[i].visualid == vi -> visualid) {
      cmap = standardCmaps[i].colormap;
      break;
    }
      }
    }
    XFree (standardCmaps);
    if(cmap) {
      if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
        G4cout << "Got standard cmap" << G4endl;
    } else {
      //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      //    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a standard colormap."
      //           << G4endl;
      cmap = XCreateColormap (dpy, 
                              XRootWindow(dpy, vi -> screen), 
                              vi -> visual, 
                              AllocNone);
      if(cmap) {
        if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
          G4cout << "Created own cmap" << G4endl;
      }
      //G.Barrand : at end, we should do a XFreeColormap(dpy,cmap) when cmap is no more used.
    }
  } else {
    cmap = XCreateColormap (dpy, 
                XRootWindow(dpy, vi -> screen), 
                vi -> visual, 
                AllocNone);
    if(cmap) {
      if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
        G4cout << "Created own cmap" << G4endl;
    }
    //G.Barrand : at end, we should do a XFreeColormap(dpy,cmap) when cmap is no more used.
  }
 
  if (!cmap) {
    fViewId = -1;  // This flags an error.
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a Colormap."
         << G4endl;
    return;
  }
 
}

References G4OpenGLXViewer::cmap, G4VisManager::confirmations, G4OpenGLXViewer::cxMaster, G4OpenGLXViewer::dpy, G4VisManager::errors, G4VViewer::fViewId, G4cerr, G4cout, G4endl, G4VisManager::GetVerbosity(), Status(), G4OpenGLXViewer::vi, and G4OpenGLXViewer::xwa.

Referenced by G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLImmediateXViewer::Initialise(), G4OpenGLStoredXmViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

CreateMainWindow()

void G4OpenGLXmViewer::CreateMainWindow ( )

protectedvirtual

Reimplemented from G4OpenGLXViewer.

Definition at line 173 of file G4OpenGLXmViewer.cc.

                                         {
 
  bgnd = XWhitePixelOfScreen (XtScreen(shell));
  borcol = XBlackPixelOfScreen (XtScreen(shell));
  
  ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
 
  G4int x_origin = fVP.GetWindowAbsoluteLocationHintX(DisplayWidth(dpy, vi -> screen));
 
  // FIXME,  screen size != window size on MAC, but I don't know have to get the menuBar
  // size on MAC. L.Garnier 01/2009
  G4int y_origin = fVP.GetWindowAbsoluteLocationHintY(DisplayHeight(dpy, vi -> screen));
 
  if (fVP.IsWindowSizeHintX () && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
    XtVaSetValues (shell, 
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth,
                   XtNcolormap, cmap, 
                   XtNwidth, getWinWidth(),
                   XtNheight, getWinHeight(),
                   XtNx, x_origin,
                   XtNy, y_origin,
                   XtNborderColor, &borcol,
                   XtNbackground, &bgnd,
                   XmNtitle, fName.data(),
                   NULL);
  } else if (fVP.IsWindowSizeHintX () && !(fVP.IsWindowLocationHintX () || fVP.IsWindowLocationHintY ())) {
    XtVaSetValues (shell, 
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth,
                   XtNcolormap, cmap, 
                   XtNwidth, getWinWidth(),
                   XtNheight, getWinHeight(),
                   XtNborderColor, &borcol,
                   XtNbackground, &bgnd,
                   XmNtitle, fName.data(),
                   NULL);
  } else if ((!fVP.IsWindowSizeHintX ()) && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
    XtVaSetValues (shell, 
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth,
                   XtNcolormap, cmap, 
                   XtNx, x_origin,
                   XtNy, y_origin,
                   XtNborderColor, &borcol,
                   XtNbackground, &bgnd,
                   XmNtitle, fName.data(),
                   NULL);
  } else {
    XtVaSetValues (shell, 
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth,
                   XtNcolormap, cmap, 
                   XtNborderColor, &borcol,
                   XtNbackground, &bgnd,
                   XmNtitle, fName.data(),
                   NULL);
  }
 
 
  main_win = XtVaCreateManagedWidget ("main_win", 
                      xmMainWindowWidgetClass,
                      shell,
                      XtNvisual, vi -> visual, 
                      XtNdepth, vi -> depth, 
                      XtNcolormap, cmap, 
                      XtNborderColor, borcol,
                      XtNbackground, bgnd,
                      NULL);
 
  //*********Create a menu bar for the window********
  style_str = XmStringCreateLocalized ((char*)"Style");
  actions_str = XmStringCreateLocalized ((char*)"Actions");
  misc_str = XmStringCreateLocalized ((char*)"Miscellany");
  spec_str = XmStringCreateLocalized ((char*)"Special");
 
  menubar = XmVaCreateSimpleMenuBar (main_win,
                     (char*)"menubar",
                     XmVaCASCADEBUTTON, style_str,   (KeySym)XK_S,  /*G.Barrand : cast to KeySym and use XK_*/
                     XmVaCASCADEBUTTON, actions_str, (KeySym)XK_A,
                     XmVaCASCADEBUTTON, misc_str,    (KeySym)XK_M,
                     XmVaCASCADEBUTTON, spec_str,    (KeySym)XK_p,
                     XtNvisual, vi -> visual, 
                     XtNdepth, vi -> depth, 
                     XtNcolormap, cmap, 
                     XtNborderColor, borcol,
                     XtNbackground, bgnd,
                     NULL);
 
  XmStringFree (style_str);
  XmStringFree (actions_str);
  XmStringFree (misc_str);
  XmStringFree (spec_str);
 
  G4cout << "Created menubar" << G4endl;
 
 
  //*********Create style pulldown menu on menubar*********
  draw_str = XmStringCreateLocalized ((char*)"Drawing");
  bgnd_str = XmStringCreateLocalized ((char*)"Background color");
 
  style_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)"style",
     0,
     NULL,
     XmVaCASCADEBUTTON, draw_str, (KeySym)XK_D,
     XmVaCASCADEBUTTON, bgnd_str, (KeySym)XK_B,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  XmStringFree (draw_str);
  XmStringFree (bgnd_str);
 
  //  G4cout << "Created Style pulldown menu" << G4endl;
 
  //Add Drawing pullright menu to style cascade...
  wireframe_str = XmStringCreateLocalized ((char*)"Wireframe");
  hlr_str = XmStringCreateLocalized ((char*)"Hidden line removal");
  hsr_str = XmStringCreateLocalized ((char*)"Hidden surface removal");
  hlhsr_str = XmStringCreateLocalized ((char*)"Hidden line and surface removal");
 
  drawing_style_pullright = XmVaCreateSimplePulldownMenu 
    (style_cascade,
     (char*)"drawing_style",
     1,
     drawing_style_callback,
     XmVaRADIOBUTTON, wireframe_str, (KeySym)XK_W, NULL, NULL,
     XmVaRADIOBUTTON, hlr_str,       (KeySym)XK_L, NULL, NULL,
     XmVaRADIOBUTTON, hsr_str,       (KeySym)XK_S, NULL, NULL,
     XmVaRADIOBUTTON, hlhsr_str,     (KeySym)XK_H, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  Widget special_widget;
 
  G4ViewParameters::DrawingStyle d_style;
  d_style = fVP.GetDrawingStyle();
  
  if (d_style == G4ViewParameters::wireframe) {
    special_widget = XtNameToWidget(drawing_style_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (d_style == G4ViewParameters::hlr) {
    special_widget = XtNameToWidget(drawing_style_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (d_style == G4ViewParameters::hsr) {
    special_widget = XtNameToWidget(drawing_style_pullright, "button_2");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (d_style == G4ViewParameters::hlhsr) {
    special_widget = XtNameToWidget(drawing_style_pullright, "button_3");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::CreateMainWindow",
       "opengl2015", FatalException,
       "Invalid Drawing style in G4OpenGLXmViewer::CreateContext");
  }
 
  XmStringFree (wireframe_str);
  XmStringFree (hlr_str);
  XmStringFree (hsr_str);
  XmStringFree (hlhsr_str);
 
  //  G4cout << "Created Drawing pullright menu" << G4endl;
 
  //Add Drawing pullright menu to style cascade...
  white_str = XmStringCreateLocalized ((char*)"White");
  black_str = XmStringCreateLocalized ((char*)"Black");
 
  background_color_pullright = XmVaCreateSimplePulldownMenu 
    (style_cascade,
     (char*)"background_color",
     2,
     background_color_callback,
     XmVaRADIOBUTTON, white_str, (KeySym)XK_W, NULL, NULL,
     XmVaRADIOBUTTON, black_str, (KeySym)XK_B, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  if (background.GetRed() == 1. &&
      background.GetGreen() == 1. &&
      background.GetBlue() == 1.) {
    special_widget = XtNameToWidget(background_color_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    special_widget = XtNameToWidget(background_color_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  }
 
  XmStringFree (white_str);
  XmStringFree (black_str);
 
  //  G4cout << "Created Background color pullright menu" << G4endl;
 
  //*********Create actions pulldown menu on menubar*********
  rot_str = XmStringCreateLocalized ((char*)"Rotation control panel");
  pan_str = XmStringCreateLocalized ((char*)"Panning control panel");
  set_str = XmStringCreateLocalized ((char*)"Set control panel limits");
 
  actions_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)"actions",
     1,
     actions_callback,
     XmVaPUSHBUTTON, rot_str, (KeySym)XK_R, NULL, NULL,
     XmVaPUSHBUTTON, pan_str, (KeySym)XK_P, NULL, NULL,
     XmVaPUSHBUTTON, set_str, (KeySym)XK_S, NULL, NULL,
     XmNuserData, this, 
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  XmStringFree (rot_str);
  XmStringFree (pan_str);
  XmStringFree (set_str);
  G4cout << "Created Actions pulldown menu" << G4endl;
 
  misc_str = XmStringCreateLocalized ((char*)"Miscellany control panel");
  exit_str = XmStringCreateLocalized ((char*)"Exit to G4Vis>");
  print_str = XmStringCreateLocalized ((char*)"Create .eps file");
 
  //*********Create miscellany pulldown menu on menubar*********
  misc_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)"miscellany",
     2,
     misc_callback,
     XmVaPUSHBUTTON, misc_str,  (KeySym)XK_M, NULL, NULL,
     XmVaPUSHBUTTON, exit_str,  (KeySym)XK_E, NULL, NULL,
     XmVaPUSHBUTTON, print_str, (KeySym)XK_P, NULL, NULL,
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  XmStringFree (misc_str);
  XmStringFree (exit_str);
  XmStringFree (print_str);
  G4cout << "Created Miscellany pulldown menu" << G4endl;
 
  trans_str = XmStringCreateLocalized ((char*)"Transparency");
  anti_str = XmStringCreateLocalized ((char*)"Antialiasing");
  halo_str = XmStringCreateLocalized ((char*)"Haloing");
  aux_edge_str = XmStringCreateLocalized ((char*)"Auxiliary edges");
 
  //*********Create special pulldown menu on menubar*********
  spec_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)"special",
     3,
     NULL,
     XmVaCASCADEBUTTON, trans_str,    (KeySym)XK_T,
     XmVaCASCADEBUTTON, anti_str,     (KeySym)XK_A,
     XmVaCASCADEBUTTON, halo_str,     (KeySym)XK_H,
     XmVaCASCADEBUTTON, aux_edge_str, (KeySym)XK_E,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  XmStringFree (trans_str);
  XmStringFree (anti_str);
  XmStringFree (halo_str);
  XmStringFree (aux_edge_str);
 
  //  G4cout << "Created Special pulldown menu" << G4endl;
 
  //Add Transparency pullright menu to special cascade...
  off_str = XmStringCreateLocalized ((char*)"Off");
  on_str = XmStringCreateLocalized ((char*)"On");
 
  transparency_pullright = XmVaCreateSimplePulldownMenu 
    (spec_cascade,
     (char*)"transparency",
     0,
     transparency_callback,
     XmVaRADIOBUTTON, off_str, (KeySym)XK_f, NULL, NULL,
     XmVaRADIOBUTTON, on_str,  (KeySym)XK_n, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  if (transparency_enabled == false) {
    special_widget = XtNameToWidget(transparency_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (transparency_enabled == true) {
    special_widget = XtNameToWidget(transparency_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::CreateMainWindow",
       "opengl2016", FatalException,
       "transparency_enabled in G4OpenGLXmViewer is neither true nor false!!");
  }
 
  //Add antialias pullright menu to special cascade...
  antialias_pullright = XmVaCreateSimplePulldownMenu 
    (spec_cascade,
     (char*)"antialias",
     1,
     antialias_callback,
     XmVaRADIOBUTTON, off_str, (KeySym)XK_f, NULL, NULL,
     XmVaRADIOBUTTON, on_str,  (KeySym)XK_n, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  if (antialiasing_enabled == false) {
    special_widget = XtNameToWidget(antialias_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (antialiasing_enabled == true) {
    special_widget = XtNameToWidget(antialias_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::CreateMainWindow",
       "opengl2017", FatalException,
       "antialiasing_enabled in G4OpenGLXmViewer is neither true nor false!!");
  }
 
  //Add Haloing pullright menu to special cascade...
  haloing_pullright = XmVaCreateSimplePulldownMenu 
    (spec_cascade,
     (char*)"haloing",
     2,
     haloing_callback,
     XmVaRADIOBUTTON, off_str, (KeySym)XK_f, NULL, NULL,
     XmVaRADIOBUTTON, on_str,  (KeySym)XK_n, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  if (haloing_enabled == false) {
    special_widget = XtNameToWidget(haloing_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else if (haloing_enabled == true) {
    special_widget = XtNameToWidget(haloing_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::CreateMainWindow",
       "opengl2018", FatalException,
       "haloing_enabled in G4OpenGLXmViewer is neither true nor false!!");
  }
 
  //Add Aux_Edge pullright menu to special cascade...
  aux_edge_pullright = XmVaCreateSimplePulldownMenu 
    (spec_cascade,
     (char*)"aux_edge",
     3,
     aux_edge_callback,
     XmVaRADIOBUTTON, off_str, (KeySym)XK_f, NULL, NULL,
     XmVaRADIOBUTTON, on_str,  (KeySym)XK_n, NULL, NULL,
     XmNradioBehavior, True, 
     XmNradioAlwaysOne, True, 
     XmNuserData, this,
     XtNvisual, vi -> visual, 
     XtNdepth, vi -> depth, 
     XtNcolormap, cmap, 
     XtNborderColor, borcol,
     XtNbackground, bgnd,
     NULL);
  
  if (!fVP.IsAuxEdgeVisible()) {
    special_widget = XtNameToWidget(aux_edge_pullright, "button_0");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  } else {
    special_widget = XtNameToWidget(aux_edge_pullright, "button_1");
    if(special_widget) {
      XtVaSetValues (special_widget, XmNset, True, NULL);
    }
  }
 
  XtManageChild (menubar);
  frame = XtVaCreateManagedWidget ((char*)"frame",
                   xmFrameWidgetClass, main_win,
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth, 
                   XtNcolormap, cmap, 
                   XtNborderColor, borcol,
                   XtNbackground, bgnd,
                   NULL);
 
  glxarea = XtVaCreateManagedWidget ((char*)"glxarea", 
                     xmDrawingAreaWidgetClass,
                     frame,
                     XtNvisual, vi -> visual, 
                     XtNdepth, vi -> depth, 
                     XtNcolormap, cmap, 
                     XtNborderColor, borcol,
                     XtNbackground, bgnd,
                     NULL);
  
 
  XmMainWindowSetAreas (main_win,  // main widget, children are specified 
            menubar,   // widget to use as menu bar
            NULL,      // widget to use as command window
            NULL,      // widget for horizontal scroll bar
            NULL,      // widget for vertical scroll bar
            frame      // widget to be used for work window
            );
 
  XtRealizeWidget(shell);
  
  // Once widget is realized (ie, associated with a created X window), we
  // can bind the OpenGL rendering context to the window.
 
  win = XtWindow (glxarea);
 
  glXMakeCurrent (dpy, win, cxMaster);
 
  // This should be add AFTER glXMakeCurrent done because it will fire a resizeCallback
  XtAddCallback (glxarea, 
         XmNresizeCallback, 
         resize_callback, 
         this);
 
  XtAddCallback (glxarea, 
         XmNexposeCallback, 
         expose_callback, 
         this);
 
}

References actions_callback(), actions_cascade, actions_str, anti_str, antialias_callback(), antialias_pullright, G4OpenGLViewer::antialiasing_enabled, aux_edge_callback(), aux_edge_pullright, aux_edge_str, G4OpenGLViewer::background, background_color_callback(), background_color_pullright, bgnd, bgnd_str, black_str, borcol, G4OpenGLXViewer::cmap, G4OpenGLXViewer::cxMaster, G4OpenGLXViewer::dpy, draw_str, drawing_style_callback(), drawing_style_pullright, exit_str, expose_callback(), FatalException, G4VViewer::fName, frame, G4VViewer::fVP, G4cout, G4endl, G4Exception(), G4Colour::GetBlue(), G4ViewParameters::GetDrawingStyle(), G4Colour::GetGreen(), G4Colour::GetRed(), G4ViewParameters::GetWindowAbsoluteLocationHintX(), G4ViewParameters::GetWindowAbsoluteLocationHintY(), G4ViewParameters::GetWindowSizeHintX(), G4ViewParameters::GetWindowSizeHintY(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), glxarea, halo_str, haloing_callback(), G4OpenGLViewer::haloing_enabled, haloing_pullright, G4ViewParameters::hlhsr, hlhsr_str, G4ViewParameters::hlr, hlr_str, G4ViewParameters::hsr, hsr_str, G4ViewParameters::IsAuxEdgeVisible(), G4ViewParameters::IsWindowLocationHintX(), G4ViewParameters::IsWindowLocationHintY(), G4ViewParameters::IsWindowSizeHintX(), main_win, menubar, misc_callback(), misc_cascade, misc_str, off_str, on_str, pan_str, print_str, resize_callback(), G4OpenGLViewer::ResizeWindow(), rot_str, set_str, shell, spec_cascade, spec_str, style_cascade, style_str, trans_str, transparency_callback(), G4OpenGLViewer::transparency_enabled, transparency_pullright, G4OpenGLXViewer::vi, white_str, G4OpenGLXViewer::win, G4ViewParameters::wireframe, and wireframe_str.

Referenced by G4OpenGLImmediateXmViewer::Initialise(), and G4OpenGLStoredXmViewer::Initialise().

dolly_callback()

void G4OpenGLXmViewer::dolly_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 79 of file G4OpenGLXmPanningCallbacks.cc.

{
  XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  short dp = -1;
  G4float ten_to_the_dp = 10.;
 
  XtVaGetValues (w, 
         XmNdecimalPoints, &dp,
         NULL);
 
  if (dp == 0) {
    ten_to_the_dp = 1.;
  } else if ( dp > 0) {
    for (G4int i = 1; i < (G4int)dp; i++) {
      ten_to_the_dp *= 10.;
    }
  } else {
    G4cout << "dp is " << dp << G4endl;
    return;
  }
 
  G4double dolly = (G4double)(cbs->value) / ten_to_the_dp;
 
  pView->fVP.SetDolly (dolly);
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
 
}  

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), G4VViewer::fVP, G4cout, G4endl, G4ViewParameters::SetDolly(), and G4OpenGLXViewer::SetView().

Referenced by actions_callback().

drawing_style_callback()

void G4OpenGLXmViewer::drawing_style_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 38 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
  G4ViewParameters::DrawingStyle style;
 
  switch (choice) {
    
  case 0:
    style = G4ViewParameters::wireframe;
    break;
 
  case 1:
    style = G4ViewParameters::hlr;
    break;
 
  case 2:
    style = G4ViewParameters::hsr;
    break;
 
  case 3:
    style = G4ViewParameters::hlhsr;
    break;
 
  default:
    style = G4ViewParameters::wireframe;
    G4Exception
      ("G4OpenGLXmViewer::drawing_style_callback",
       "opengl2006", FatalException,
       "Unrecognised case in drawing_style_callback.");
  }
 
  pView->fVP.SetDrawingStyle (style);
  
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4VViewer::fVP, G4Exception(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4ViewParameters::SetDrawingStyle(), G4OpenGLXViewer::SetView(), and G4ViewParameters::wireframe.

Referenced by CreateMainWindow().

DrawText()

void G4OpenGLXViewer::DrawText ( const G4Text &  g4text )

virtualinherited

Reimplemented from G4OpenGLViewer.

Definition at line 396 of file G4OpenGLXViewer.cc.

{
  if (isGl2psWriting()) {
 
    G4OpenGLViewer::DrawText(g4text);
 
  } else {
 
    G4VSceneHandler::MarkerSizeType sizeType;
    G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
 
    const G4OpenGLFontBaseStore::FontInfo& fontInfo =
      G4OpenGLFontBaseStore::GetFontInfo(this,(int)size);
    if (fontInfo.fFontBase < 0) {
      static G4int callCount = 0;
      ++callCount;
      //if (callCount <= 10 || callCount%100 == 0) {
      if (callCount <= 1) {
        G4cout <<
      "G4OpenGLXViewer::DrawText: No fonts available for \""
           << fName <<
          "\"\n  Called with "
               << g4text
               << G4endl;
      }
      return;
    }
 
    const G4Colour& c = fSceneHandler.GetTextColour(g4text);
    glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
 
    G4Point3D position = g4text.GetPosition();
 
    G4String textString = g4text.GetText();
    const char* textCString = textString.c_str();
  
    // Set position for raster-style drawers (X, Xm)
    glRasterPos3d(position.x(),position.y(),position.z());
 
    glPushAttrib(GL_LIST_BIT);
 
    // Calculate move for centre and right adjustment
    G4double span = textString.size() * fontInfo.fWidth;
    G4double xmove = 0., ymove = 0.;
    switch (g4text.GetLayout()) {
    case G4Text::left: break;
    case G4Text::centre: xmove -= span / 2.; break;
    case G4Text::right: xmove -= span;
    }
 
    //Add offsets
    xmove += g4text.GetXOffset();
    ymove += g4text.GetYOffset();
 
    // Do move
    glBitmap(0,0,0,0,xmove,ymove,0);
 
    // Write characters
    glListBase(fontInfo.fFontBase);
    glCallLists(strlen(textCString),GL_UNSIGNED_BYTE,(GLubyte*)textCString);
    glPopAttrib();
  }
}

References G4Text::centre, G4OpenGLViewer::DrawText(), G4OpenGLFontBaseStore::FontInfo::fFontBase, G4VViewer::fName, G4VViewer::fSceneHandler, G4OpenGLFontBaseStore::FontInfo::fWidth, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4OpenGLFontBaseStore::GetFontInfo(), G4Colour::GetGreen(), G4Text::GetLayout(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4Colour::GetRed(), G4Text::GetText(), G4VSceneHandler::GetTextColour(), G4Text::GetXOffset(), G4Text::GetYOffset(), G4OpenGLViewer::isGl2psWriting(), G4Text::left, and G4Text::right.

DrawView()

virtual void G4VViewer::DrawView ( )

pure virtualinherited

Implemented in G4DAWNFILEViewer, G4GMocrenFileViewer, G4HepRepFileViewer, G4OpenGLImmediateQtViewer, G4OpenGLImmediateWin32Viewer, G4OpenGLImmediateXmViewer, G4OpenGLImmediateXViewer, G4OpenGLStoredQtViewer, G4OpenGLStoredWin32Viewer, G4OpenGLStoredXmViewer, G4OpenGLStoredXViewer, G4OpenInventorViewer, G4Qt3DViewer, G4RayTracerViewer, G4ToolsSGViewer< SG_SESSION, SG_VIEWER >, G4ToolsSGViewer< tools::Qt::session, tools::Qt::sg_viewer >, G4VTreeViewer, G4VRML2FileViewer, and G4VtkViewer.

Referenced by antialias_callback(), aux_edge_callback(), background_color_callback(), G4HepRepFileSceneHandler::ClearTransientStore(), dolly_callback(), drawing_style_callback(), G4OpenGLViewer::GetPickDetails(), haloing_callback(), left_right_pan_callback(), G4OpenGLViewer::printGl2PS(), projection_callback(), reset_callback(), rotate_in_phi(), rotate_in_theta(), G4VisCommandViewerRebuild::SetNewValue(), transparency_callback(), up_down_pan_callback(), wobble_timer_callback(), and zoom_callback().

exportImage()

bool G4OpenGLViewer::exportImage ( std::string  name = "", int  width = -1, int  height = -1  )

virtualinherited

Export image with the given name with width and height Several cases : If name is "", filename will have the default value If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). Will also add an incremented suffix at the end of the file

Reimplemented in G4OpenGLQtViewer.

Definition at line 827 of file G4OpenGLViewer.cc.

                                                                      {
 
  if (! setExportFilename(name)) {
    return false;
  }
 
  if ((width != -1) && (height != -1)) {
    setExportSize(width, height);
  }
 
  if (fExportImageFormat == "eps") {
    fGL2PSAction->setExportImageFormat(GL2PS_EPS);
  } else if (fExportImageFormat == "ps") {
    fGL2PSAction->setExportImageFormat(GL2PS_PS);
  } else if (fExportImageFormat == "svg") {
    fGL2PSAction->setExportImageFormat(GL2PS_SVG);
  } else if (fExportImageFormat == "pdf") {
    fGL2PSAction->setExportImageFormat(GL2PS_PDF);
  } else {
    setExportImageFormat(fExportImageFormat,true); // will display a message if this format is not correct for the current viewer
    return false;
  }
 
  bool res;
 
  // Change the LC_NUMERIC value in order to have "." separtor and not ","
  // This case is only useful for French, Canadien...
  size_t len = strlen(setlocale(LC_NUMERIC,NULL));
  char* oldLocale = (char*)(malloc(len+1));
  if(oldLocale!=NULL) strncpy(oldLocale,setlocale(LC_NUMERIC,NULL),len);
  setlocale(LC_NUMERIC,"C");
 
  if (((fExportImageFormat == "eps") || (fExportImageFormat == "ps")) && (!fVectoredPs)) {
    res = printNonVectoredEPS();
  } else {
    res = printVectoredEPS();
  }
 
  // restore the local
  if (oldLocale) {
    setlocale(LC_NUMERIC,oldLocale);
    free(oldLocale);
  }
 
  if (res == false) {
    G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
  } else {
    G4cout << "File " << getRealPrintFilename().c_str() << " size: " << getRealExportWidth() << "x" << getRealExportHeight() << " has been saved " << G4endl;
 
    // increment index if necessary
    if ( fExportFilenameIndex != -1) {
      fExportFilenameIndex++;
    }
  }
 
  return res;
}

References G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fGL2PSAction, free, G4OpenGLViewer::fVectoredPs, G4cerr, G4cout, G4endl, G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), GL2PS_EPS, GL2PS_PDF, GL2PS_PS, GL2PS_SVG, G4InuclParticleNames::name(), G4OpenGLViewer::printNonVectoredEPS(), G4OpenGLViewer::printVectoredEPS(), G4OpenGLViewer::setExportFilename(), G4OpenGLViewer::setExportImageFormat(), G4OpenGL2PSAction::setExportImageFormat(), and G4OpenGLViewer::setExportSize().

Referenced by G4OpenGLQtViewer::exportImage(), print_callback(), and G4OpenGLViewerMessenger::SetNewValue().

expose_callback()

void G4OpenGLXmViewer::expose_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 45 of file G4OpenGLXmWindowHandlingCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  Dimension width, height;
 
  XtVaGetValues (w, 
         XmNwidth, &width, 
         XmNheight, &height, 
         NULL);
 
  pView->ResizeWindow(width,height);
 
//??????????????????????????? This might be a problem in MT mode.
//  glXMakeCurrent (pView->dpy, XtWindow(pView->glxarea), pView->cxMaster);
//  pView->SetView ();
//  pView->ClearView ();
//  pView->DrawView ();
//???????????????????????????? Commented out 14/06/16  JA
}

References G4OpenGLViewer::ResizeWindow().

Referenced by CreateMainWindow(), and resize_callback().

FinishView()

void G4VViewer::FinishView ( void  )

virtualinherited

Reimplemented in G4OpenGLImmediateWin32Viewer, G4OpenGLImmediateXmViewer, G4OpenGLImmediateXViewer, G4OpenGLQtViewer, G4OpenGLStoredWin32Viewer, G4OpenGLStoredXmViewer, G4OpenGLStoredXViewer, G4OpenInventorQtViewer, G4OpenInventorWinViewer, G4OpenInventorXtExtendedViewer, G4OpenInventorXtViewer, G4Qt3DViewer, G4ToolsSGViewer< SG_SESSION, SG_VIEWER >, G4ToolsSGViewer< tools::Qt::session, tools::Qt::sg_viewer >, G4VRML2FileViewer, G4VtkQtViewer, and G4VtkViewer.

Definition at line 101 of file G4VViewer.cc.

{}

Referenced by G4OpenInventorViewer::DrawView(), G4VisManager::GeometryHasChanged(), G4OpenGLViewer::InitializeGLView(), G4VisManager::NotifyHandlers(), and G4VisCommandViewerClear::SetNewValue().

g4GlFrustum()

void G4OpenGLViewer::g4GlFrustum ( GLdouble  left, GLdouble  right, GLdouble  bottom, GLdouble  top, GLdouble  near, GLdouble  far  )

protectedinherited

Definition at line 1467 of file G4OpenGLViewer.cc.

                                                                                                                             {
  //  glFrustum (left, right, bottom, top, near, far);
  
  GLdouble deltaX = right - left;
  GLdouble deltaY = top - bottom;
  GLdouble deltaZ = zFar - zNear;
  
  GLdouble a = 2.0f * zNear / deltaX;
  GLdouble b = 2.0f * zNear / deltaY;
  GLdouble c = (right + left) / deltaX;
  GLdouble d = (top + bottom) / deltaY;
  GLdouble e = -(zFar + zNear) / (zFar - zNear);
  GLdouble f = -2.0f * zFar * zNear / deltaZ;
  
  GLdouble proj[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    c, d, e, -1.0f,
    0, 0, f, 0
  };
  
  glMultMatrixd(proj);
  
}

Referenced by G4OpenGLViewer::SetView().

g4GlOrtho()

void G4OpenGLViewer::g4GlOrtho ( GLdouble  left, GLdouble  right, GLdouble  bottom, GLdouble  top, GLdouble  near, GLdouble  far  )

protectedinherited

Definition at line 1445 of file G4OpenGLViewer.cc.

                                                                                                                           {
  //  glOrtho (left, right, bottom, top, near, far);
  
  GLdouble a = 2.0 / (right - left);
  GLdouble b = 2.0 / (top - bottom);
  GLdouble c = -2.0 / (zFar - zNear);
  
  GLdouble tx = - (right + left)/(right - left);
  GLdouble ty = - (top + bottom)/(top - bottom);
  GLdouble tz = - (zFar + zNear)/(zFar - zNear);
  
  GLdouble ortho[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    0, 0, c, 0,
    tx, ty, tz, 1
  };
  glMultMatrixd(ortho);
  
}

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredViewer::DrawDisplayLists(), and G4OpenGLViewer::SetView().

g4GluLookAt()

void G4OpenGLViewer::g4GluLookAt ( GLdouble  eyex, GLdouble  eyey, GLdouble  eyez, GLdouble  centerx, GLdouble  centery, GLdouble  centerz, GLdouble  upx, GLdouble  upy, GLdouble  upz  )

protectedinherited

Definition at line 1365 of file G4OpenGLViewer.cc.

{
    GLdouble mat[16];
    GLdouble x[3], y[3], z[3];
    GLdouble mag;
  
    /* Make rotation matrix */
  
    /* Z vector */
    z[0] = eyex - centerx;
    z[1] = eyey - centery;
    z[2] = eyez - centerz;
    mag = std::sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
    if (mag) {          /* mpichler, 19950515 */
        z[0] /= mag;
        z[1] /= mag;
        z[2] /= mag;
    }
  
    /* Y vector */
    y[0] = upx;
    y[1] = upy;
    y[2] = upz;
  
    /* X vector = Y cross Z */
    x[0] = y[1] * z[2] - y[2] * z[1];
    x[1] = -y[0] * z[2] + y[2] * z[0];
    x[2] = y[0] * z[1] - y[1] * z[0];
  
    /* Recompute Y = Z cross X */
    y[0] = z[1] * x[2] - z[2] * x[1];
    y[1] = -z[0] * x[2] + z[2] * x[0];
    y[2] = z[0] * x[1] - z[1] * x[0];
  
    /* mpichler, 19950515 */
    /* cross product gives area of parallelogram, which is < 1.0 for
     * non-perpendicular unit-length vectors; so normalize x, y here
     */
  
    mag = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
    if (mag) {
        x[0] /= mag;
        x[1] /= mag;
        x[2] /= mag;
    }
  
    mag = std::sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
    if (mag) {
        y[0] /= mag;
        y[1] /= mag;
        y[2] /= mag;
    }
  
#define M(row,col)  mat[col*4+row]
    M(0, 0) = x[0];
    M(0, 1) = x[1];
    M(0, 2) = x[2];
    M(0, 3) = 0.0;
    M(1, 0) = y[0];
    M(1, 1) = y[1];
    M(1, 2) = y[2];
    M(1, 3) = 0.0;
    M(2, 0) = z[0];
    M(2, 1) = z[1];
    M(2, 2) = z[2];
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    glMultMatrixd(mat);
  
    /* Translate Eye to Origin */
    glTranslated(-eyex, -eyey, -eyez);
}

References M.

Referenced by G4OpenGLViewer::SetView().

g4GluPickMatrix()

void G4OpenGLViewer::g4GluPickMatrix ( GLdouble  x, GLdouble  y, GLdouble  width, GLdouble  height, GLint  viewport[4]  )

protectedinherited

Definition at line 1323 of file G4OpenGLViewer.cc.

  {
    GLdouble mat[16];
    GLdouble sx, sy;
    GLdouble tx, ty;
    
    sx = viewport[2] / width;
    sy = viewport[3] / height;
    tx = (viewport[2] + 2.0 * (viewport[0] - x)) / width;
    ty = (viewport[3] + 2.0 * (viewport[1] - y)) / height;
    
#define M(row, col) mat[col*4+row]
    M(0, 0) = sx;
    M(0, 1) = 0.0;
    M(0, 2) = 0.0;
    M(0, 3) = tx;
    M(1, 0) = 0.0;
    M(1, 1) = sy;
    M(1, 2) = 0.0;
    M(1, 3) = ty;
    M(2, 0) = 0.0;
    M(2, 1) = 0.0;
    M(2, 2) = 1.0;
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    
    glMultMatrixd(mat);
}

References M.

Referenced by G4OpenGLViewer::GetPickDetails().

get_boolean_userData()

G4bool G4OpenGLXmViewer::get_boolean_userData ( Widget  w )

static

Definition at line 530 of file G4OpenGLXmConvenienceRoutines.cc.

{
  XtPointer userData;
  XtVaGetValues (w,XmNuserData,&userData,NULL);
  return (G4bool)(((unsigned long)userData)&0xffff);
}

References userData.

Referenced by pan_left_right_callback(), pan_up_down_callback(), phi_rotation_callback(), and theta_rotation_callback().

get_double_value_callback()

void G4OpenGLXmViewer::get_double_value_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 500 of file G4OpenGLXmConvenienceRoutines.cc.

{
  G4double* val = (G4double*) clientData;
  String string;
 
  XtVaGetValues (w,
         XmNvalue, &string,
         NULL);
 
//  sscanf (string, "%lg", val);
  std::istringstream iss(string);
  iss >> *val;
}

Referenced by Add_set_field(), and G4OpenGLXmTextField::AddYourselfTo().

get_int_userData()

G4int G4OpenGLXmViewer::get_int_userData ( Widget  w )

static

Definition at line 537 of file G4OpenGLXmConvenienceRoutines.cc.

{
  XtPointer userData;
  XtVaGetValues (w,XmNuserData,&userData,NULL);
  return (G4int)(unsigned long)userData;
}

References userData.

Referenced by projection_callback(), set_print_colour_callback(), set_print_style_callback(), and set_rot_subject_callback().

get_text_callback()

void G4OpenGLXmViewer::get_text_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 516 of file G4OpenGLXmConvenienceRoutines.cc.

{
  char* txt = (char*)clientData;
  String string;
 
  XtVaGetValues (w,
         XmNvalue, &string,
         NULL);
 
  strcpy(txt, string);
}

Referenced by G4OpenGLXmTextField::AddYourselfTo().

GetApplicableVisAttributes()

const G4VisAttributes * G4VViewer::GetApplicableVisAttributes ( const G4VisAttributes *  ) const

inherited

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4VtkSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), and G4GMocrenFileSceneHandler::IsVisible().

GetDefaultViewParameters()

const G4ViewParameters & G4VViewer::GetDefaultViewParameters ( ) const

inherited

Referenced by G4VisCommandsViewerSet::SetNewValue().

GetName()

const G4String & G4VViewer::GetName ( ) const

inherited

Referenced by G4OpenGLQtViewer::createSceneTreeComponent(), G4OpenGLQtViewer::createSceneTreeWidget(), G4OpenGLQtViewer::createViewerPropertiesWidget(), G4OpenGLQtViewer::currentTabActivated(), G4OpenGLImmediateQtViewer::Initialise(), G4OpenGLStoredQtViewer::Initialise(), G4ToolsSGQtViewer::Initialise(), G4VtkQtViewer::Initialise(), G4VVisCommand::InterpolateViews(), G4OpenGLQtViewer::isCurrentWidget(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerAddCutawayPlane::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerChangeCutawayPlane::SetNewValue(), G4VisCommandViewerClearCutawayPlanes::SetNewValue(), G4VisCommandViewerClearVisAttributesModifiers::SetNewValue(), G4VisCommandViewerClone::SetNewValue(), G4VisCommandViewerColourByDensity::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4VtkMessenger::SetNewValue(), and G4OpenGLQtViewer::updatePickInfosWidget().

GetPickDetails()

const std::vector< G4OpenGLViewerPickMap * > & G4OpenGLViewer::GetPickDetails ( GLdouble  x, GLdouble  y  )

protectedinherited

Definition at line 488 of file G4OpenGLViewer.cc.

{
  static std::vector < G4OpenGLViewerPickMap* > pickMapVector;
  for (auto pickMap: pickMapVector) {
    delete pickMap;
  }
  pickMapVector.clear();
  
  const G4int BUFSIZE = 512;
  GLuint selectBuffer[BUFSIZE];
  glSelectBuffer(BUFSIZE, selectBuffer);
  glRenderMode(GL_SELECT);
  glInitNames();
  glPushName(0);
  glMatrixMode(GL_PROJECTION);
  G4double currentProjectionMatrix[16];
  glGetDoublev(GL_PROJECTION_MATRIX, currentProjectionMatrix);
  glPushMatrix();
  glLoadIdentity();
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
/*  G4cout
  << "viewport, x,y: "
  << viewport[0] << ',' << viewport[1] << ',' << viewport[2] << ',' << viewport[3]
  << ", " << x << ',' << y
  << G4endl;
*/
  fIsGettingPickInfos = true;
  // Define 5x5 pixel pick area
  g4GluPickMatrix(x, viewport[3] - y, 5., 5., viewport);
  glMultMatrixd(currentProjectionMatrix);
  glMatrixMode(GL_MODELVIEW);
  DrawView();
  GLint hits = glRenderMode(GL_RENDER);
  fIsGettingPickInfos = false;
  if (hits < 0) {
    G4cout << "Too many hits.  Zoom in to reduce overlaps." << G4endl;
    goto restoreMatrices;
  }
  if (hits > 0) {
    GLuint* p = selectBuffer;
    for (GLint i = 0; i < hits; ++i) {
      GLuint nnames = *p++;
      // This bit of debug code or...
      //GLuint zmin = *p++;
      //GLuint zmax = *p++;
      //G4cout << "Hit " << i << ": " << nnames << " names"
      //       << "\nzmin: " << zmin << ", zmax: " << zmax << G4endl;
      // ...just increment the pointer
      p++;
      p++;
      for (GLuint j = 0; j < nnames; ++j) {
        GLuint name = *p++;
    std::map<GLuint, G4AttHolder*>::iterator iter =
      fOpenGLSceneHandler.fPickMap.find(name);
    if (iter != fOpenGLSceneHandler.fPickMap.end()) {
      G4AttHolder* attHolder = iter->second;
      if(attHolder && attHolder->GetAttDefs().size()) {
        for (size_t iAtt = 0;
         iAtt < attHolder->GetAttDefs().size(); ++iAtt) {
              std::ostringstream oss;
          oss << G4AttCheck(attHolder->GetAttValues()[iAtt],
                                attHolder->GetAttDefs()[iAtt]);
              G4OpenGLViewerPickMap* pickMap = new G4OpenGLViewerPickMap();
//              G4cout
//              << "i,j, attHolder->GetAttDefs().size(): "
//              << i << ',' << j
//              << ", " << attHolder->GetAttDefs().size()
//              << G4endl;
//              G4cout << "G4OpenGLViewer::GetPickDetails: " << oss.str() << G4endl;
              pickMap->addAttributes(oss.str());
              pickMap->setHitNumber(i);
              pickMap->setSubHitNumber(j);
              pickMap->setPickName(name);
              pickMapVector.push_back(pickMap);
            }
          }
        }
      }
    }
  }
 
restoreMatrices:
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
 
  return pickMapVector;
}

References G4OpenGLViewerPickMap::addAttributes(), BUFSIZE, G4VViewer::DrawView(), G4OpenGLViewer::fIsGettingPickInfos, G4OpenGLViewer::fOpenGLSceneHandler, G4OpenGLSceneHandler::fPickMap, G4cout, G4endl, G4OpenGLViewer::g4GluPickMatrix(), G4AttHolder::GetAttDefs(), G4AttHolder::GetAttValues(), G4InuclParticleNames::name(), G4OpenGLViewerPickMap::setHitNumber(), G4OpenGLViewerPickMap::setPickName(), and G4OpenGLViewerPickMap::setSubHitNumber().

Referenced by G4OpenGLViewer::Pick(), and G4OpenGLQtViewer::updatePickInfosWidget().

GetPrivateVisAttributesModifiers()

virtual const std::vector< G4ModelingParameters::VisAttributesModifier > * G4VViewer::GetPrivateVisAttributesModifiers ( ) const

virtualinherited

Reimplemented in G4OpenGLQtViewer.

Referenced by G4VisCommandViewerSave::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

getRealExportHeight()

G4int G4OpenGLViewer::getRealExportHeight ( )

privateinherited

Definition at line 1004 of file G4OpenGLViewer.cc.

                                          {
  if (fPrintSizeY == -1) {
    return fWinSize_y;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeY > dims[1]){
      return dims[1];
    }
  }
  if (fPrintSizeY < -1){
    return 0;
  }
  return fPrintSizeY;
}

References G4OpenGLViewer::fPrintSizeY, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

getRealExportWidth()

G4int G4OpenGLViewer::getRealExportWidth ( )

privateinherited

Definition at line 985 of file G4OpenGLViewer.cc.

                                         {
  if (fPrintSizeX == -1) {
    return fWinSize_x;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeX > dims[0]){
      return dims[0];
    }
  }
  if (fPrintSizeX < -1){
    return 0;
  }
  return fPrintSizeX;
}

References G4OpenGLViewer::fPrintSizeX, and G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

getRealPrintFilename()

std::string G4OpenGLViewer::getRealPrintFilename ( )

protectedinherited

Definition at line 1066 of file G4OpenGLViewer.cc.

                                               {
  std::string temp = fExportFilename;
  if (fExportFilenameIndex != -1) {
    temp += std::string("_");
    std::ostringstream os;
    os << std::setw(4) << std::setfill('0') << fExportFilenameIndex;
    std::string nb_str = os.str();
    temp += nb_str;
  }
  temp += "."+fExportImageFormat;
  return temp;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, and G4OpenGLViewer::fExportImageFormat.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), misc_callback(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::printNonVectoredEPS(), and G4OpenGLViewer::setExportFilename().

getSceneDepth()

GLdouble G4OpenGLViewer::getSceneDepth ( )

protectedinherited

Definition at line 1111 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return fVP.GetFarDistance  (cameraDistance, pnear, radius)- pnear;
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::moveScene().

getSceneFarWidth()

GLdouble G4OpenGLViewer::getSceneFarWidth ( )

protectedinherited

Definition at line 1094 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar    = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  return 2 * fVP.GetFrontHalfHeight (pfar, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

GetSceneHandler()

G4VSceneHandler * G4VViewer::GetSceneHandler ( ) const

inherited

Referenced by actions_callback(), left_right_pan_callback(), misc_callback(), G4VVisCommand::RefreshIfRequired(), ResetView(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), and up_down_pan_callback().

getSceneNearWidth()

GLdouble G4OpenGLViewer::getSceneNearWidth ( )

protectedinherited

Definition at line 1079 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return 2 * fVP.GetFrontHalfHeight (pnear, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::moveScene().

GetShortName()

const G4String & G4VViewer::GetShortName ( ) const

inherited

Referenced by G4OpenGLViewer::G4OpenGLViewer().

GetViewId()

G4int G4VViewer::GetViewId ( ) const

inherited

Referenced by G4RayTracer::CreateViewer(), G4RayTracerX::CreateViewer(), G4HepRepFile::CreateViewer(), G4Qt3D::CreateViewer(), G4ToolsSGQtGLES::CreateViewer(), G4ToolsSGWindowsGLES::CreateViewer(), G4ToolsSGX11GLES::CreateViewer(), G4ToolsSGXtGLES::CreateViewer(), G4Vtk::CreateViewer(), and G4VtkQt::CreateViewer().

GetViewParameters()

const G4ViewParameters & G4VViewer::GetViewParameters ( ) const

inherited

Referenced by actions_callback(), G4OpenInventorSceneHandler::AddCircleSquare(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenInventorSceneHandler::AddTransform(), background_color_callback(), G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), G4VSceneHandler::CreateSectionSolid(), G4VisManager::CreateViewer(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLStoredSceneHandler::EndModeling(), G4VisManager::EndOfRun(), G4VSceneHandler::GetAuxEdgeVisible(), G4VSceneHandler::GetColour(), G4VSceneHandler::GetDrawingStyle(), G4VSceneHandler::GetNoOfSides(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSceneHandler::GetTextColour(), G4VVisCommand::RefreshIfRequired(), G4VSceneHandler::RequestPrimitives(), G4VisCommandDrawView::SetNewValue(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandGeometrySetDaughtersInvisible::SetNewValue(), G4VisCommandGeometrySetVisibility::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneHandlerCreate::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandsTouchableSet::SetNewValue(), G4VisCommandViewerAddCutawayPlane::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerChangeCutawayPlane::SetNewValue(), G4VisCommandViewerClearCutawayPlanes::SetNewValue(), G4VisCommandViewerClearVisAttributesModifiers::SetNewValue(), G4VisCommandViewerClone::SetNewValue(), G4VisCommandViewerColourByDensity::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerDolly::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandViewerPan::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerScale::SetNewValue(), G4VisCommandViewerZoom::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandGeometrySetVisibility::SetNewValueOnLV(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), and G4OpenInventorViewer::SetWireFrame().

getWinHeight()

unsigned int G4OpenGLViewer::getWinHeight ( ) const

protectedinherited

Definition at line 977 of file G4OpenGLViewer.cc.

                                               {
  return fWinSize_y;
}

References G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

getWinWidth()

unsigned int G4OpenGLViewer::getWinWidth ( ) const

protectedinherited

Definition at line 973 of file G4OpenGLViewer.cc.

                                              {
  return fWinSize_x;
}

References G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

GetXConnection()

void G4OpenGLXViewer::GetXConnection ( )

protectedinherited

Definition at line 153 of file G4OpenGLXViewer.cc.

                                      {
// get a connection.
  dpy = XOpenDisplay (0);  // Uses DISPLAY environment variable.
  if (!dpy) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't open display." << G4endl;
    return;
  }
 
// make sure OpenGL is supported and installed properly.
  if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer X Server has no GLX extension." 
     << G4endl;
    return;
  }
 
}

References G4OpenGLXViewer::dpy, G4OpenGLXViewer::errorBase, G4OpenGLXViewer::eventBase, G4VViewer::fViewId, G4cerr, and G4endl.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

GetXmConnection()

void G4OpenGLXmViewer::GetXmConnection ( )

protected

Definition at line 110 of file G4OpenGLXmViewer.cc.

                                        {
  
  G4Xt* interactorManager = G4Xt::getInstance ();
  toplevel = (Widget)interactorManager->GetMainInteractor();
  app      = XtWidgetToApplicationContext(toplevel);
 
  if (!toplevel) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXmViewer::GetXmConnection unable to Initialize"
      " application context." << G4endl;
    return;
  }
 
  // Better to put this in an X11 resource file !!!
  std::ostringstream oss;
  oss <<
    "*glxarea*width: " << fVP.GetWindowSizeHintX() << "\n"
    "*glxarea*height: " << fVP.GetWindowSizeHintY() << "\n"
    /*
    // Tried this as a replacement for the above two lines, but
    // sub-windows (rotation, etc.) came same size!!
    "*geometry: " << fVP.GetXGeometryString() << "\n"
    */
    "*frame*x: 10\n"
    "*frame*y: 10\n"
    "*frame*topOffset: 10\n"
    "*frame*bottomOffset: 10\n"
    "*frame*rightOffset: 10\n"
    "*frame*leftOffset: 10\n"
    "*frame*shadowType: SHADOW_IN\n"
    "*frame*useColorObj: False\n"
    "*frame*primaryColorSetId: 3\n"
    "*frame*secondaryColorSetId: 3\n"
    "*menubar*useColorObj: False\n"
    "*menubar*primaryColorSetId: 3\n"
    "*menubar*secondaryColorSetId: 3\n"
    "*toplevel*useColorObj: False\n"
    "*toplevel*primaryColorSetId: 3\n"
    "*toplevel*secondaryColorSetId: 3\n";
  interactorManager->PutStringInResourceDatabase ((char*)oss.str().c_str());
 
  //  interactorManager->AddSecondaryLoopPostAction ((G4SecondaryLoopAction)G4OpenGLXmViewerSecondaryLoopPostAction);
  
  shell = XtAppCreateShell ((String)fName.data(),(String)fName.data(),topLevelShellWidgetClass,XtDisplay(toplevel),NULL,0); 
  interactorManager->AddShell (shell);
 
  dpy = XtDisplay (shell);
 
  if (!dpy) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXmViewer::GetXmConnection unable to connect to display."
     << G4endl;
    return;
  }
 
  if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXmViewer::GetXmConnection. X Server has no GLX extension."
     << G4endl;;
    return;
  }
}

References G4VInteractorManager::AddShell(), app, G4OpenGLXViewer::dpy, G4OpenGLXViewer::errorBase, G4OpenGLXViewer::eventBase, G4VViewer::fName, G4VViewer::fViewId, G4VViewer::fVP, G4cerr, G4endl, G4Xt::getInstance(), G4VInteractorManager::GetMainInteractor(), G4ViewParameters::GetWindowSizeHintX(), G4ViewParameters::GetWindowSizeHintY(), G4Xt::PutStringInResourceDatabase(), shell, and toplevel.

Referenced by G4OpenGLXmViewer().

grabPixels()

GLubyte * G4OpenGLViewer::grabPixels ( int  inColor, unsigned int  width, unsigned int  height  )

privateinherited

Definition at line 578 of file G4OpenGLViewer.cc.

                                                       {
  
  GLubyte* buffer;
  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;
  GLenum format;
  int size;
 
  if (inColor) {
    format = GL_RGB;
    size = width*height*3;
  } else {
    format = GL_LUMINANCE;
    size = width*height*1;
  }
 
  buffer = new GLubyte[size];
  if (buffer == NULL)
    return NULL;
 
  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
  glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
  glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
 
  glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
  glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
  glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
  glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
 
  glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 
  glReadBuffer(GL_FRONT);
  glReadPixels (0, 0, (GLsizei)width, (GLsizei)height, format, GL_UNSIGNED_BYTE, (GLvoid*) buffer);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
  glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
  
  glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
  glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
  
  return buffer;
}

References buffer.

Referenced by G4OpenGLViewer::printNonVectoredEPS().

haloing_callback()

void G4OpenGLXmViewer::haloing_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 193 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
 
  switch (choice) {
    
  case 0:
    pView->haloing_enabled = false;
    break;
 
  case 1:
    pView->haloing_enabled = true;
    break;
 
  default:
    G4Exception
      ("G4OpenGLXmViewer::haloing_callback",
       "opengl2011", FatalException,
       "Unrecognised case in haloing_callback.");
  }
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4Exception(), G4OpenGLViewer::haloing_enabled, and G4OpenGLXViewer::SetView().

Referenced by CreateMainWindow().

HaloingFirstPass()

void G4OpenGLViewer::HaloingFirstPass ( )

protectedinherited

Definition at line 441 of file G4OpenGLViewer.cc.

                                       {
  
  //To perform haloing, first Draw all information to the depth buffer
  //alone, using a chunky line width, and then Draw all info again, to
  //the colour buffer, setting a thinner line width an the depth testing 
  //function to less than or equal, so if two lines cross, the one 
  //passing behind the other will not pass the depth test, and so not
  //get rendered either side of the infront line for a short distance.
 
  //First, disable writing to the colo(u)r buffer...
  glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
  //Now enable writing to the depth buffer...
  glDepthMask (GL_TRUE);
  glDepthFunc (GL_LESS);
  glClearDepth (1.0);
 
  //Finally, set the line width to something wide...
  ChangeLineWidth(3.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

HaloingSecondPass()

void G4OpenGLViewer::HaloingSecondPass ( )

protectedinherited

Definition at line 463 of file G4OpenGLViewer.cc.

                                        {
 
  //And finally, turn the colour buffer back on with a sesible line width...
  glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthFunc (GL_LEQUAL);
  ChangeLineWidth(1.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

HLRFirstPass()

void G4OpenGLViewer::HLRFirstPass ( )

protectedinherited

HLRSecondPass()

void G4OpenGLViewer::HLRSecondPass ( )

protectedinherited

HLRThirdPass()

void G4OpenGLViewer::HLRThirdPass ( )

protectedinherited

Initialise()

virtual void G4VViewer::Initialise ( )

virtualinherited

Reimplemented in G4OpenGLImmediateQtViewer, G4OpenGLImmediateWin32Viewer, G4OpenGLImmediateXmViewer, G4OpenGLImmediateXViewer, G4OpenGLStoredQtViewer, G4OpenGLStoredWin32Viewer, G4OpenGLStoredXmViewer, G4OpenGLStoredXViewer, G4OpenInventorQtViewer, G4OpenInventorWinViewer, G4OpenInventorXtExtendedViewer, G4OpenInventorXtViewer, G4Qt3DViewer, G4RayTracerViewer, G4RayTracerXViewer, G4ToolsSGQtViewer, G4ToolsSGViewer< SG_SESSION, SG_VIEWER >, G4ToolsSGViewer< tools::Qt::session, tools::Qt::sg_viewer >, G4VtkQtViewer, and G4VtkViewer.

InitializeGLView()

void G4OpenGLViewer::InitializeGLView ( )

protectedinherited

Definition at line 127 of file G4OpenGLViewer.cc.

{
#ifdef G4OPENGL_VERSION_2
  if (fVboDrawer) {
    
    // First, load a simple shader
    fShaderProgram = glCreateProgram();
    Shader vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const char * vSrc = fVboDrawer->getVertexShaderSrc();
    glShaderSource(vertexShader, 1, &vSrc, NULL);
    glCompileShader(vertexShader);
    glAttachShader(fShaderProgram, vertexShader);
    
    Shader fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const char * fSrc = fVboDrawer->getFragmentShaderSrc();
    glShaderSource(fragmentShader, 1, &fSrc, NULL);
    glCompileShader(fragmentShader);
    
    glAttachShader(fShaderProgram, fragmentShader);
    glLinkProgram(fShaderProgram);
    glUseProgram(fShaderProgram);
    
    //   UniformLocation uColor = getUniformLocation(fShaderProgram, "uColor");
    //   uniform4fv(uColor, [0.0, 0.3, 0.0, 1.0]);
    
    // Extract the references to the attributes from the shader.
    
    fVertexPositionAttribute =
    glGetAttribLocation(fShaderProgram, "aVertexPosition");
    
    
    glEnableVertexAttribArray(fVertexPositionAttribute);
    
    // Extract the references the uniforms from the shader
    fpMatrixUniform  = glGetUniformLocation(fShaderProgram, "uPMatrix");
    fcMatrixUniform  = glGetUniformLocation(fShaderProgram, "uCMatrix");
    fmvMatrixUniform = glGetUniformLocation(fShaderProgram, "uMVMatrix");
    fnMatrixUniform  = glGetUniformLocation(fShaderProgram, "uNMatrix");
    ftMatrixUniform  = glGetUniformLocation(fShaderProgram, "uTMatrix");
    
    /*    glUniformMatrix4fv(fcMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fpMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(ftMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fmvMatrixUniform, 1, 0, identity);
     */
    // We have to set that in order to avoid calls on opengl commands before all is ready
    fGlViewInitialized = true;
  }
#endif
  
  if (fWinSize_x == 0) {
    fWinSize_x = fVP.GetWindowSizeHintX();
  }
  if (fWinSize_y == 0) {
    fWinSize_y = fVP.GetWindowSizeHintY();
  }
 
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glClearDepth (1.0);
#ifndef G4OPENGL_VERSION_2
  glDisable (GL_LINE_SMOOTH);
  glDisable (GL_POLYGON_SMOOTH);
#endif
 
// clear the buffers and window?
  ClearView ();
  FinishView ();
  
  glDepthFunc (GL_LEQUAL);
  glDepthMask (GL_TRUE);
  
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
}

References G4OpenGLViewer::ClearView(), G4OpenGLViewer::fGlViewInitialized, G4VViewer::FinishView(), G4VViewer::fVP, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4ViewParameters::GetWindowSizeHintX(), and G4ViewParameters::GetWindowSizeHintY().

Referenced by G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLImmediateXViewer::Initialise(), G4OpenGLStoredXmViewer::Initialise(), G4OpenGLStoredXViewer::Initialise(), G4OpenGLImmediateQtViewer::initializeGL(), and G4OpenGLStoredQtViewer::initializeGL().

isFramebufferReady()

G4bool G4OpenGLViewer::isFramebufferReady ( )

protectedinherited

Definition at line 730 of file G4OpenGLViewer.cc.

                                          {
  bool check = false;
#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
  check = true;
#endif
#ifdef G4VIS_BUILD_OPENGLX_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLXM_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
  check = false;
#endif
 
#if GL_ARB_framebuffer_object
  if (check) {
//    if ( glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNDEFINED) {
//      return false;
//    }
  }
#endif
    return true;
}

Referenced by G4OpenGLViewer::ClearView(), G4OpenGLViewer::ClearViewWithoutFlush(), G4OpenGLImmediateQtViewer::paintEvent(), and G4OpenGLStoredQtViewer::paintEvent().

isGl2psWriting()

bool G4OpenGLViewer::isGl2psWriting ( )

protectedinherited

Return if gl2ps is currently writing

Definition at line 720 of file G4OpenGLViewer.cc.

                                    {
 
  if (!fGL2PSAction) return false;
  if (fGL2PSAction->fileWritingEnabled()) {
    return true;
  }
  return false;
}

References G4OpenGLViewer::fGL2PSAction, and G4OpenGL2PSAction::fileWritingEnabled().

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

left_right_pan_callback()

void G4OpenGLXmViewer::left_right_pan_callback ( XtPointer  clientData, XtIntervalId *  timer_id  )

static

Definition at line 128 of file G4OpenGLXmPanningCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  G4double delta;
  
  if (pView->pan_right) {
    delta = pView->fPan_sens;
  } else {
    delta = -pView->fPan_sens;
  }
  
  G4Point3D stp
    = pView -> GetSceneHandler()->GetScene()->GetStandardTargetPoint();
 
  G4Point3D tp = stp + pView -> fVP.GetCurrentTargetPoint ();
  
  const G4Vector3D& upVector = pView->fVP.GetUpVector ();
  const G4Vector3D& vpVector = pView->fVP.GetViewpointDirection ();
  
  G4Vector3D unitRight = (upVector.cross (vpVector)).unit();
  G4Vector3D unitUp    = (vpVector.cross (unitRight)).unit();
  
  tp += delta * unitRight;
  pView->fVP.SetCurrentTargetPoint (tp - stp);
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
 
  pView->pan_timer = XtAppAddTimeOut 
    (pView->app,
     timer_id == NULL ? 500 : 1,
     left_right_pan_callback,
     pView);
}  

References app, G4OpenGLViewer::ClearView(), HepGeom::BasicVector3D< T >::cross(), G4VViewer::DrawView(), G4OpenGLViewer::fPan_sens, G4VViewer::fVP, G4ViewParameters::GetCurrentTargetPoint(), G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4Scene::GetStandardTargetPoint(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), left_right_pan_callback(), pan_right, pan_timer, G4ViewParameters::SetCurrentTargetPoint(), G4OpenGLXViewer::SetView(), and G4InuclParticleNames::tp.

Referenced by left_right_pan_callback(), and pan_left_right_callback().

misc_callback()

void G4OpenGLXmViewer::misc_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

ajw

Definition at line 326 of file G4OpenGLXmMainMenubarCallbacks.cc.

{
  G4OpenGLXmViewer* pView;
  G4long choice = (G4long)clientData;
  XtVaGetValues (XtParent(w), 
         XmNuserData, &pView, 
         NULL);
  
  switch (choice) {
    
  case 0:
    {
 
      if (!pView->fpmiscellany_top) {
    
    std::ostringstream misc_Name;
    misc_Name << pView->GetSceneHandler()->GetSceneHandlerId() << '-' << pView->fViewId;
    
    pView->fpmiscellany_top = new G4OpenGLXmTopLevelShell (pView, 
                                   (char*)misc_Name.str().c_str());
    pView->fpwobble_box = new G4OpenGLXmFramedBox ("Wobble view",
                               True);
    pView->fpmiscellany_top->AddChild (pView->fpwobble_box);
    
    XtCallbackRec* wob_cb_list = new XtCallbackRec[2];
    wob_cb_list[0].callback = wobble_callback;
    wob_cb_list[0].closure = pView; 
    wob_cb_list[1].callback = NULL;
    
    
    pView->fpwobble_button = new G4OpenGLXmPushButton ("Wobble",
                               wob_cb_list);
    
    XtCallbackRec* wobble_slider_list = new XtCallbackRec[2];
    wobble_slider_list[0].callback = set_wob_sens_callback;
    wobble_slider_list[0].closure = pView; 
    wobble_slider_list[1].callback = NULL;
    
    pView->fpwobble_slider = new G4OpenGLXmSliderBar ("Wobble slider",
                              wobble_slider_list,
                              True,
                              0,
                              pView->wob_sens,
                              pView->wob_high,
                              pView->wob_low);
    pView->fpwobble_box->AddChild (pView->fpwobble_button);
    pView->fpwobble_box->AddChild (pView->fpwobble_slider);
    
    pView->fpreset_box = new G4OpenGLXmFramedBox ("Reset view",
                              True);
    pView->fpmiscellany_top->AddChild (pView->fpreset_box);
    
    XtCallbackRec* rst_cb_list = new XtCallbackRec[3];
    rst_cb_list[0].callback = reset_callback;
    rst_cb_list[0].closure = pView; 
    rst_cb_list[1].callback = update_panels_callback;
    rst_cb_list[1].closure = pView; 
    rst_cb_list[2].callback = NULL;
    
    pView->fpreset_button = new G4OpenGLXmPushButton ("Reset",
                              rst_cb_list);
    
    pView->fpreset_box->AddChild (pView->fpreset_button);
    
    pView->fpproj_style_box = new G4OpenGLXmFramedBox ("Projection style",
                               True);
    pView->fpmiscellany_top->AddChild (pView->fpproj_style_box);
    
    XtCallbackRec* proj_cb_list = new XtCallbackRec[2];
    proj_cb_list[0].callback = projection_callback;
    proj_cb_list[0].closure = pView; 
    proj_cb_list[1].callback = NULL;
    
    pView->fporthogonal_button = new G4OpenGLXmRadioButton ("Orthographic",
                                proj_cb_list,
                                pView->fVP.GetFieldHalfAngle() > 0. ? False : True,
                                0);
    
    pView->fpperspective_button = new G4OpenGLXmRadioButton ("Perspective",
                                 proj_cb_list,
                                 pView->fVP.GetFieldHalfAngle() > 0. ? True : False,
                                 1);
    
    pView->fpfov_text = new G4OpenGLXmTextField ("Field of view 0.1 -> 89.5 degrees.",
                             &(pView->fov));
    
    pView->fpproj_style_box->AddChild (pView->fpperspective_button);
    pView->fpproj_style_box->AddChild (pView->fporthogonal_button);
    pView->fpproj_style_box->AddChild (pView->fpfov_text);
    
    pView->fpmiscellany_top->Realize ();
 
      }
      
      break;
    }
  
  case 1:
    {
      G4Xt::getInstance () -> RequireExitSecondaryLoop (OGL_EXIT_CODE);
      break;
    }
  
  case 2:
    {
      if (!pView->fpprint_top) {
    
    std::ostringstream print_Name;
    print_Name << pView->GetSceneHandler()->GetSceneHandlerId() << '-' << pView->fViewId;
    
    pView->fpprint_top = new G4OpenGLXmTopLevelShell (pView, 
                              (char*)print_Name.str().c_str());
 
    pView->fpprint_box = new G4OpenGLXmFramedBox ("Create EPS file of current view",
                               False);
 
    pView->fpprint_top->AddChild (pView->fpprint_box);
    
    pView->fpprint_col_box = new G4OpenGLXmFramedBox ("Colour choice",
                              True);
    pView->fpprint_top->AddChild (pView->fpprint_col_box);
 
    XtCallbackRec* prcol_cb_list = new XtCallbackRec[2];
    prcol_cb_list[0].callback = set_print_colour_callback;
    prcol_cb_list[0].closure = pView; 
    prcol_cb_list[1].callback = NULL;
    
    pView->fpprint_col_radio1 = new G4OpenGLXmRadioButton ("Black and white",
                                   prcol_cb_list,
                                   pView->fPrintColour==false ? True : False,
                                   0);
    
    pView->fpprint_col_radio2 = new G4OpenGLXmRadioButton ("Colour",
                                   prcol_cb_list,
                                   pView->fPrintColour==true ? True : False,
                                   1);
    
    pView->fpprint_col_box->AddChild (pView->fpprint_col_radio1);
    pView->fpprint_col_box->AddChild (pView->fpprint_col_radio2);
 
    pView->fpprint_style_box = new G4OpenGLXmFramedBox ("File type",
                                True);
    pView->fpprint_top->AddChild (pView->fpprint_style_box);
 
    XtCallbackRec* prsty_cb_list = new XtCallbackRec[2];
    prsty_cb_list[0].callback = set_print_style_callback;
    prsty_cb_list[0].closure = pView; 
    prsty_cb_list[1].callback = NULL;
    
    pView->fpprint_style_radio1 = new G4OpenGLXmRadioButton ("Screen dump (pixmap)",
                                 prsty_cb_list,
                                 pView->fVectoredPs==false ? True : False,
                                 0);
    
    pView->fpprint_style_radio2 = new G4OpenGLXmRadioButton ("PostScript",
                                 prsty_cb_list,
                                 pView->fVectoredPs==true ? True : False,
                                 1);
    
    pView->fpprint_style_box->AddChild (pView->fpprint_style_radio1);
    pView->fpprint_style_box->AddChild (pView->fpprint_style_radio2);
    
    pView->fpprint_text = new G4OpenGLXmTextField ("Name of .eps file to save",
                               (pView->getRealPrintFilename().c_str()));
    pView->fpprint_box->AddChild (pView->fpprint_text); 
    
    pView->fpprint_line = new G4OpenGLXmSeparator ();
    pView->fpprint_box->AddChild (pView->fpprint_line);
 
    XtCallbackRec* pri_cb_list = new XtCallbackRec[2];
    pri_cb_list[0].callback = print_callback;
    pri_cb_list[0].closure = pView; 
    pri_cb_list[1].callback = NULL;
    
    
    pView->fpprint_button = new G4OpenGLXmPushButton ("Create EPS file",
                              pri_cb_list);
    
    pView->fpprint_box->AddChild (pView->fpprint_button);
    pView->fpprint_top->Realize ();
 
      }
      
      break;
    }
  
  default:
    G4Exception
      ("G4OpenGLXmViewer::misc_callback",
       "opengl2002", FatalException,
       "Unrecognised widget child of misc_callback.");
  }
  
  return;
  
}

References G4OpenGLXmFramedBox::AddChild(), G4OpenGLXmTopLevelShell::AddChild(), FatalException, fov, fpfov_text, fpmiscellany_top, fporthogonal_button, fpperspective_button, fpprint_box, fpprint_button, fpprint_col_box, fpprint_col_radio1, fpprint_col_radio2, fpprint_line, fpprint_style_box, fpprint_style_radio1, fpprint_style_radio2, fpprint_text, fpprint_top, fpproj_style_box, fpreset_box, fpreset_button, G4OpenGLViewer::fPrintColour, fpwobble_box, fpwobble_button, fpwobble_slider, G4OpenGLViewer::fVectoredPs, G4VViewer::fViewId, G4VViewer::fVP, G4Exception(), G4ViewParameters::GetFieldHalfAngle(), G4Xt::getInstance(), G4OpenGLViewer::getRealPrintFilename(), G4VViewer::GetSceneHandler(), G4VSceneHandler::GetSceneHandlerId(), OGL_EXIT_CODE, print_callback(), projection_callback(), G4OpenGLXmTopLevelShell::Realize(), reset_callback(), set_print_colour_callback(), set_print_style_callback(), set_wob_sens_callback(), update_panels_callback(), wob_high, wob_low, wob_sens, and wobble_callback().

Referenced by CreateMainWindow().

NeedKernelVisit()

void G4VViewer::NeedKernelVisit ( )

inherited

Definition at line 78 of file G4VViewer.cc.

                                 {
 
  fNeedKernelVisit = true;
 
  // At one time I thought we'd better notify all viewers.  But I guess
  // each viewer can take care of itself, so the following code is
  // redundant (but keep it commented out for now).   (John Allison)
  // Notify all viewers that a kernel visit is required.
  // const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  // G4ViewerListConstIterator i;
  // for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //   (*i) -> SetNeedKernelVisit ();
  // }
  // ??...but, there's a problem in OpenGL Stored which seems to
  // require *all* viewers to revisit the kernel, so...
  //  const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  //  G4ViewerListConstIterator i;
  //  for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //    (*i) -> SetNeedKernelVisit (true);
  //  }
  // Feb 2005 - commented out.  Let's fix OpenGL if necessary.
}

References G4VViewer::fNeedKernelVisit.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4DAWNFILEViewer::DrawView(), G4GMocrenFileViewer::DrawView(), G4HepRepFileViewer::DrawView(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4VTreeViewer::DrawView(), G4VRML2FileViewer::DrawView(), G4VtkViewer::DrawView(), G4VisManager::GeometryHasChanged(), G4OpenGLStoredViewer::KernelVisitDecision(), G4OpenInventorViewer::KernelVisitDecision(), G4Qt3DViewer::KernelVisitDecision(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::KernelVisitDecision(), G4VisManager::NotifyHandlers(), G4OpenGLImmediateViewer::ProcessView(), G4VisCommandViewerRebuild::SetNewValue(), G4OpenInventorViewer::SetPreview(), G4OpenInventorViewer::SetPreviewAndFull(), G4OpenInventorViewer::SetReducedWireFrame(), and G4OpenInventorViewer::UpdateScene().

operator=()

G4OpenGLXmViewer & G4OpenGLXmViewer::operator= ( const G4OpenGLXmViewer &  )

private

pan_left_right_callback()

void G4OpenGLXmViewer::pan_left_right_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 112 of file G4OpenGLXmPanningCallbacks.cc.

{
  XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  pView->pan_right = get_boolean_userData (w);
 
  if (cbs->reason == XmCR_ARM) {
    left_right_pan_callback (pView,NULL);
  } else if (cbs->reason == XmCR_DISARM) {
    XtRemoveTimeOut (pView->pan_timer);
  }
}

References get_boolean_userData(), left_right_pan_callback(), pan_right, and pan_timer.

Referenced by actions_callback().

pan_up_down_callback()

void G4OpenGLXmViewer::pan_up_down_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 166 of file G4OpenGLXmPanningCallbacks.cc.

{
  XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  pView->pan_up = get_boolean_userData (w);
 
  if (cbs->reason == XmCR_ARM) {
    up_down_pan_callback (pView,NULL);
  } else if (cbs->reason == XmCR_DISARM) {
    XtRemoveTimeOut (pView->pan_timer);
  }
}

References get_boolean_userData(), pan_timer, pan_up, and up_down_pan_callback().

Referenced by actions_callback().

phi_rotation_callback()

void G4OpenGLXmViewer::phi_rotation_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 119 of file G4OpenGLXmRotationCallbacks.cc.

{
  XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  pView->rotate_up = get_boolean_userData (w);
 
  if (cbs->reason == XmCR_ARM) {
    rotate_in_phi (pView, NULL);
  } else if (cbs->reason == XmCR_DISARM) {
    XtRemoveTimeOut (pView->rotation_timer);
  }
}

References get_boolean_userData(), rotate_in_phi(), rotate_up, and rotation_timer.

Referenced by actions_callback().

Pick()

G4String G4OpenGLViewer::Pick ( GLdouble  x, GLdouble  y  )

protectedvirtualinherited

Definition at line 472 of file G4OpenGLViewer.cc.

{
  const std::vector < G4OpenGLViewerPickMap* > & pickMap = GetPickDetails(x,y);
  G4String txt = "";
  if (pickMap.size() == 0) {
//        txt += "No hits recorded.";;
  } else {
    for (unsigned int a=0; a < pickMap.size(); a++) {
      if (pickMap[a]->getAttributes().size() > 0) {
        txt += pickMap[a]->print();
      }
    }
  }
  return txt;
}

References G4OpenGLViewer::GetPickDetails().

Referenced by G4OpenGLXViewer::ShowView().

print_callback()

void G4OpenGLXmViewer::print_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 67 of file G4OpenGLXmWindowHandlingCallbacks.cc.

{
  G4OpenGLXViewer* pView = (G4OpenGLXmViewer*) clientData;
  pView->exportImage();
}

References G4OpenGLViewer::exportImage().

Referenced by misc_callback().

printGl2PS()

bool G4OpenGLViewer::printGl2PS ( )

privateinherited

Definition at line 886 of file G4OpenGLViewer.cc.

                                {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
  bool res = true;
 
  // no need to redraw at each new primitive for printgl2PS
  G4OpenGLSceneHandler& oglSceneHandler = dynamic_cast<G4OpenGLSceneHandler&>(fSceneHandler);
  G4OpenGLSceneHandler::FlushAction originalFlushAction = oglSceneHandler.GetFlushAction();
  oglSceneHandler.SetFlushAction(G4OpenGLSceneHandler::never);
 
  if (!fGL2PSAction) return false;
 
  fGL2PSAction->setFileName(getRealPrintFilename().c_str());
  // try to resize
  int X = fWinSize_x;
  int Y = fWinSize_y;
 
  fWinSize_x = width;
  fWinSize_y = height;
  // Laurent G. 16/03/10 : Not the good way to do. 
  // We should draw in a new offscreen context instead of
  // resizing and drawing in current window...
  // This should be solve when we will do an offscreen method
  // to render OpenGL
  // See : 
  // http://developer.apple.com/Mac/library/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_offscreen/opengl_offscreen.html
  // http://www.songho.ca/opengl/gl_fbo.html
 
   ResizeGLView();
   bool extendBuffer = true;
   bool endWriteAction = false;
   bool beginWriteAction = true;
   bool filePointerOk = true;
   while ((extendBuffer) && (! endWriteAction) && (filePointerOk)) {
     
     beginWriteAction = fGL2PSAction->enableFileWriting();
     // 3 cases :
     // - true
     // - false && ! fGL2PSAction->fileWritingEnabled() => bad file name
     // - false && fGL2PSAction->fileWritingEnabled() => buffer size problem ?
 
     filePointerOk = fGL2PSAction->fileWritingEnabled();
       
     if (beginWriteAction) {
       
       // Set the viewport
       // By default, we choose the line width (trajectories...)
       fGL2PSAction->setLineWidth(fGl2psDefaultLineWith);
       // By default, we choose the point size (markers...)
       fGL2PSAction->setPointSize(fGl2psDefaultPointSize);
       
       DrawView ();
       endWriteAction = fGL2PSAction->disableFileWriting();
     }
     if (filePointerOk) {
       if ((! endWriteAction) || (! beginWriteAction)) {
         extendBuffer = fGL2PSAction->extendBufferSize();
       }
     }
   }
   fGL2PSAction->resetBufferSizeParameters();
 
   if (!extendBuffer ) {
     G4cerr << "ERROR: gl2ps buffer size is not big enough to print this geometry. Try to extend it. No output produced"<< G4endl;
     res = false;
   }
   if (!beginWriteAction ) {
     G4cerr << "ERROR: saving file "<<getRealPrintFilename().c_str()<<". Check read/write access. No output produced" << G4endl;
     res = false;
   }
   if (!endWriteAction ) {
     G4cerr << "gl2ps error. No output produced" << G4endl;
     res = false;
   }
  fWinSize_x = X;
  fWinSize_y = Y;
 
  oglSceneHandler.SetFlushAction(originalFlushAction);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = 0;
  //  fPrintSizeY = 0;
 
  return res;
}

References G4OpenGL2PSAction::disableFileWriting(), G4VViewer::DrawView(), G4OpenGL2PSAction::enableFileWriting(), G4OpenGL2PSAction::extendBufferSize(), G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::fGl2psDefaultLineWith, G4OpenGLViewer::fGl2psDefaultPointSize, G4OpenGL2PSAction::fileWritingEnabled(), G4VViewer::fSceneHandler, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, G4endl, G4OpenGLSceneHandler::GetFlushAction(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLSceneHandler::never, G4OpenGL2PSAction::resetBufferSizeParameters(), G4OpenGLViewer::ResizeGLView(), G4OpenGL2PSAction::setFileName(), G4OpenGLSceneHandler::SetFlushAction(), G4OpenGL2PSAction::setLineWidth(), G4OpenGL2PSAction::setPointSize(), and Y().

Referenced by G4OpenGLViewer::printVectoredEPS().

printNonVectoredEPS()

bool G4OpenGLViewer::printNonVectoredEPS ( )

privateinherited

Definition at line 633 of file G4OpenGLViewer.cc.

                                          {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
 
  FILE* fp;
  GLubyte* pixels;
  GLubyte* curpix;
  int components, pos, i;
 
  pixels = grabPixels (fPrintColour, width, height);
 
  if (pixels == NULL) {
      G4cerr << "Failed to get pixels from OpenGl viewport" << G4endl;
    return false;
  }
  if (fPrintColour) {
    components = 3;
  } else {
    components = 1;
  }
  std::string name = getRealPrintFilename();
  fp = fopen (name.c_str(), "w");
  if (fp == NULL) {
    G4cerr << "Can't open filename " << name.c_str() << G4endl;
    return false;
  }
  
  fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
  fprintf (fp, "%%%%Title: %s\n", name.c_str());
  fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
  fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
  fprintf (fp, "%%%%EndComments\n");
  fprintf (fp, "gsave\n");
  fprintf (fp, "/bwproc {\n");
  fprintf (fp, "    rgbproc\n");
  fprintf (fp, "    dup length 3 idiv string 0 3 0 \n");
  fprintf (fp, "    5 -1 roll {\n");
  fprintf (fp, "    add 2 1 roll 1 sub dup 0 eq\n");
  fprintf (fp, "    { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
  fprintf (fp, "       3 1 roll 5 -1 roll } put 1 add 3 0 \n");
  fprintf (fp, "    { 2 1 roll } ifelse\n");
  fprintf (fp, "    }forall\n");
  fprintf (fp, "    pop pop pop\n");
  fprintf (fp, "} def\n");
  fprintf (fp, "systemdict /colorimage known not {\n");
  fprintf (fp, "   /colorimage {\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       /rgbproc exch def\n");
  fprintf (fp, "       { bwproc } image\n");
  fprintf (fp, "   }  def\n");
  fprintf (fp, "} if\n");
  fprintf (fp, "/picstr %d string def\n", width * components);
  fprintf (fp, "%d %d scale\n", width, height);
  fprintf (fp, "%d %d %d\n", width, height, 8);
  fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
  fprintf (fp, "{currentfile picstr readhexstring pop}\n");
  fprintf (fp, "false %d\n", components);
  fprintf (fp, "colorimage\n");
  
  curpix = (GLubyte*) pixels;
  pos = 0;
  for (i = width*height*components; i>0; i--) {
    fprintf (fp, "%02hx ", (unsigned short)(*(curpix++)));
    if (++pos >= 32) {
      fprintf (fp, "\n");
      pos = 0; 
    }
  }
  if (pos)
    fprintf (fp, "\n");
 
  fprintf (fp, "grestore\n");
  fprintf (fp, "showpage\n");
  delete [] pixels;
  fclose (fp);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = -1;
  //  fPrintSizeY = -1;
 
  return true;
}

References G4OpenGLViewer::fPrintColour, G4cerr, G4endl, G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::grabPixels(), G4InuclParticleNames::name(), and pos.

Referenced by G4OpenGLViewer::exportImage().

printVectoredEPS()

bool G4OpenGLViewer::printVectoredEPS ( )

privateinherited

Definition at line 629 of file G4OpenGLViewer.cc.

                                      {
  return printGl2PS();
}

References G4OpenGLViewer::printGl2PS().

Referenced by G4OpenGLViewer::exportImage().

ProcessView()

void G4VViewer::ProcessView ( )

inherited

Definition at line 105 of file G4VViewer.cc.

{
  // If the scene has changed, or if the concrete viewer has decided
  // that it necessary to visit the kernel, perhaps because the view
  // parameters have changed significantly (this should be done in the
  // concrete viewer's DrawView)...
  if (fNeedKernelVisit) {
    // Reset flag.  This must be done before ProcessScene to prevent
    // recursive calls when recomputing transients...
    fNeedKernelVisit = false;
    fSceneHandler.ClearStore ();
    fSceneHandler.ProcessScene ();
  }
}

References G4VSceneHandler::ClearStore(), G4VViewer::fNeedKernelVisit, G4VViewer::fSceneHandler, and G4VSceneHandler::ProcessScene().

Referenced by G4OpenGLStoredQtViewer::ComputeView(), G4DAWNFILEViewer::DrawView(), G4GMocrenFileViewer::DrawView(), G4HepRepFileViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenInventorViewer::DrawView(), G4Qt3DViewer::DrawView(), G4RayTracerViewer::DrawView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView(), G4VTreeViewer::DrawView(), G4VRML2FileViewer::DrawView(), G4VtkViewer::DrawView(), and G4OpenGLImmediateViewer::ProcessView().

projection_callback()

void G4OpenGLXmViewer::projection_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 258 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
 
  G4int choice = get_int_userData (w);
 
  switch (choice) {
  case 0:
    {
      pView->fVP.SetFieldHalfAngle (0.);
      break;
    }
 
  case 1:
    {
      if (pView->fov > 89.5 || pView->fov <= 0.0) {
    G4cout << "Field half angle should be 0 < angle <= 89.5 degrees.";
    G4cout << G4endl;
      }
      else {
    pView->fVP.SetFieldHalfAngle (pView->fov * deg);
      }
      break;
    }
  default:
    {
      G4Exception
    ("G4OpenGLXmViewer::projection_callback",
     "opengl2013", FatalException,
     "Unrecognised choice made in projection_callback");
    }
  }
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}  

References G4OpenGLViewer::ClearView(), deg, G4VViewer::DrawView(), FatalException, fov, G4VViewer::fVP, G4cout, G4endl, G4Exception(), get_int_userData(), G4ViewParameters::SetFieldHalfAngle(), and G4OpenGLXViewer::SetView().

Referenced by misc_callback().

RefreshView()

void G4VViewer::RefreshView ( )

inherited

Referenced by G4VisManager::EndOfRun(), G4VVisCommand::InterpolateViews(), and G4VisCommandViewerInterpolate::SetNewValue().

reset_callback()

void G4OpenGLXmViewer::reset_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 302 of file G4OpenGLXmRotationCallbacks.cc.

{
  
  G4OpenGLXmViewer* pView;
  
  XtVaGetValues (w,
         XmNuserData, &pView,
         NULL);
  
  pView->fVP.SetCurrentTargetPoint(G4Point3D());
  pView->fVP.SetZoomFactor(1.0);
  pView->fVP.SetDolly(0.0);
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
  pView->zoom_low = 0.1;
  pView->zoom_high = 10.0;
  
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), G4VViewer::fVP, G4ViewParameters::SetCurrentTargetPoint(), G4ViewParameters::SetDolly(), G4OpenGLXViewer::SetView(), G4ViewParameters::SetZoomFactor(), zoom_high, and zoom_low.

Referenced by misc_callback().

ResetView()

void G4OpenGLXmViewer::ResetView ( )

protectedvirtual

Reimplemented from G4OpenGLViewer.

Definition at line 70 of file G4OpenGLXmViewer.cc.

                                  {
  // reset global parameters
  G4OpenGLViewer::ResetView();
 
  //reset Xm parameteres
  zoom_high  = fVP.GetZoomFactor() * 10.0;
  zoom_low = fVP.GetZoomFactor() / 10.0;
  rot_sens_limit = 90.;
  wob_low = 0.;
  wob_high = 50.;
  wob_sens = 20.;
  
  bool firstInit = true;
  if (GetSceneHandler() != NULL) {
    if (GetSceneHandler()->GetScene() != NULL) {
      firstInit = false;
    }
  }
  if (firstInit) {
    pan_sens_limit = 100.;
    fPan_sens = pan_sens_limit / 10.0;
    dolly_low  = fVP.GetDolly() - 1000.0;
    dolly_high = fVP.GetDolly() + 1000.0;
  } else {
    fPan_sens = GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius() / 10.0;
    pan_sens_limit = GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius();
    
    dolly_high = GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius();
    dolly_low = -(GetSceneHandler()->GetScene()->GetExtent().GetExtentRadius());
  }
 
  UpdateControlPanel ();
 
 
  // FIXME : L.Garnier 12 Oct 2011
  // Has also to change the Camera/Object, but tricky to do...  
 
}

References dolly_high, dolly_low, G4OpenGLViewer::fPan_sens, G4VViewer::fVP, G4ViewParameters::GetDolly(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4ViewParameters::GetZoomFactor(), pan_sens_limit, G4OpenGLViewer::ResetView(), rot_sens_limit, UpdateControlPanel(), wob_high, wob_low, wob_sens, zoom_high, and zoom_low.

Referenced by G4OpenGLXmViewer().

resize_callback()

void G4OpenGLXmViewer::resize_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 36 of file G4OpenGLXmWindowHandlingCallbacks.cc.

{
  expose_callback(w,clientData,x);
}

References expose_callback().

Referenced by CreateMainWindow().

ResizeGLView()

void G4OpenGLViewer::ResizeGLView ( )

protectedinherited

Set the viewport of the scene MAXIMUM SIZE is : GLint dims[2]; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);

Definition at line 250 of file G4OpenGLViewer.cc.

{
  // Check size
  GLint dims[2];
  dims[0] = 0;
  dims[1] = 0;
 
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
 
    if (fWinSize_x > (unsigned)dims[0]) {
      G4cerr << "Try to resize view greater than max X viewport dimension. Desired size "<<fWinSize_x <<" is resize to "<<  dims[0] << G4endl;
      fWinSize_x = dims[0];
    }
    if (fWinSize_y > (unsigned)dims[1]) {
      G4cerr << "Try to resize view greater than max Y viewport dimension. Desired size "<<fWinSize_y <<" is resize to "<<  dims[1] << G4endl;
      fWinSize_y = dims[1];
    }
  }
    
  glViewport(0, 0, fWinSize_x,fWinSize_y);   
 
 
}

References G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, and G4endl.

Referenced by G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::SetView().

ResizeWindow()

void G4OpenGLViewer::ResizeWindow ( unsigned int  aWidth, unsigned int  aHeight  )

protectedinherited

Definition at line 234 of file G4OpenGLViewer.cc.

                                                                           {
  if ((fWinSize_x != aWidth) || (fWinSize_y != aHeight)) {
    fWinSize_x = aWidth;
    fWinSize_y = aHeight;
    fSizeHasChanged = true;
  } else {
    fSizeHasChanged = false;
  }
}

References G4OpenGLViewer::fSizeHasChanged, G4OpenGLViewer::fWinSize_x, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), expose_callback(), G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

rotate_in_phi()

void G4OpenGLXmViewer::rotate_in_phi ( XtPointer  clientData, XtIntervalId *  timer_id  )

static

Definition at line 135 of file G4OpenGLXmRotationCallbacks.cc.

{
  //phi spin stuff here
  //  G4double delta_alpha;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  if (pView -> rotate_up) {
    pView->rotateScene(0,-1);
  } else {
    pView->rotateScene(0,1);
  }
  /*
  if (pView->fVP.GetLightsMoveWithCamera()) {
    if (pView -> rotate_up) {
      delta_alpha = -(pView->fRot_sens);
    } else {
      delta_alpha = pView->fRot_sens;
    }
  } else {
    if (pView -> rotate_up) {
      delta_alpha = pView->fRot_sens;
    } else {
      delta_alpha = -(pView->fRot_sens);
    }
  }    
 
  delta_alpha *= deg;
 
  const G4Vector3D& vp = pView->fVP.GetViewpointDirection ().unit ();
  const G4Vector3D& up = pView->fVP.GetUpVector ().unit ();
 
  const G4Vector3D& xprime = vp;
  G4Vector3D yprime = (up.cross(xprime)).unit();
  G4Vector3D zprime = (xprime.cross(yprime)).unit();
 
  G4Vector3D new_vp = std::cos(delta_alpha) * xprime + std::sin(delta_alpha) * zprime;
 
  pView->fVP.SetViewAndLights (new_vp.unit());
 
  if (pView->fVP.GetLightsMoveWithCamera()) {
    G4Vector3D new_up = (new_vp.cross(yprime)).unit();
    pView->fVP.SetUpVector(new_up);
  }
 
  */
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
  
  pView->rotation_timer = XtAppAddTimeOut 
    (pView->app,
     timer_id == NULL ? 500 : 1,
     rotate_in_phi,
     pView);
}

References app, G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), rotate_in_phi(), rotate_up, G4OpenGLViewer::rotateScene(), rotation_timer, and G4OpenGLXViewer::SetView().

Referenced by phi_rotation_callback(), and rotate_in_phi().

rotate_in_theta()

void G4OpenGLXmViewer::rotate_in_theta ( XtPointer  clientData, XtIntervalId *  timer_id  )

static

Definition at line 58 of file G4OpenGLXmRotationCallbacks.cc.

{
  //theta spin stuff here
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  if (pView->rotate_right) {
    pView->rotateScene(1,0);
  } else {
    pView->rotateScene(-1,0);
  }
  /*
  G4double delta_theta;
 
  if (pView->fVP.GetLightsMoveWithCamera()) {
    if (pView->rotate_right) {
      delta_theta = -(pView->fRot_sens);
    } else {
      delta_theta = pView->fRot_sens;
    }
  } else {
    if (pView->rotate_right) {
      delta_theta = pView->fRot_sens;
    } else {
      delta_theta = -(pView->fRot_sens);
    }
  }    
  delta_theta *= deg;
  // Rotates by fixed azimuthal angle delta_theta.
 
  const G4Vector3D& vp = pView->fVP.GetViewpointDirection ().unit ();
  const G4Vector3D& up = pView->fVP.GetUpVector ().unit ();
  const G4Vector3D& zprime = up;
  G4double cosalpha = up.dot (vp);
  G4double sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
  G4Vector3D yprime = (zprime.cross (vp)).unit ();
  G4Vector3D xprime = yprime.cross (zprime);
  // Projection of vp on plane perpendicular to up...
  G4Vector3D a1 = sinalpha * xprime;
  // Required new projection...
  G4Vector3D a2 =
    sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
  // Required Increment vector...
  G4Vector3D delta = a2 - a1;
  // So new viewpoint is...
  G4Vector3D viewPoint = vp + delta;
 
  pView->fVP.SetViewAndLights (viewPoint);  
  */
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
 
  pView->rotation_timer = XtAppAddTimeOut 
    (pView->app,
     timer_id == NULL ? 500 : 1,
     rotate_in_theta,
     pView);
}  

References app, G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), rotate_in_theta(), rotate_right, G4OpenGLViewer::rotateScene(), rotation_timer, and G4OpenGLXViewer::SetView().

Referenced by rotate_in_theta(), and theta_rotation_callback().

rotateScene()

void G4OpenGLViewer::rotateScene ( G4double  dx, G4double  dy  )

protectedinherited

Definition at line 1128 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by rotate_in_phi(), rotate_in_theta(), and G4OpenGLQtViewer::rotateQtScene().

rotateSceneInViewDirection()

void G4OpenGLViewer::rotateSceneInViewDirection ( G4double  dx, G4double  dy  )

privateinherited

Definition at line 1241 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
  dx = dx/100;
  dy = dy/100;
 
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit();
  up = fVP.GetUpVector ().unit();
 
  G4Vector3D zPrimeVector = G4Vector3D(up.y()*vp.z()-up.z()*vp.y(),
                             up.z()*vp.x()-up.x()*vp.z(),
                             up.x()*vp.y()-up.y()*vp.x());
 
  viewPoint = vp/fRot_sens + (zPrimeVector*dx - up*dy) ;
  new_up = G4Vector3D(viewPoint.y()*zPrimeVector.z()-viewPoint.z()*zPrimeVector.y(),
                       viewPoint.z()*zPrimeVector.x()-viewPoint.x()*zPrimeVector.z(),
                       viewPoint.x()*zPrimeVector.y()-viewPoint.y()*zPrimeVector.x());
 
  G4Vector3D new_upUnit = new_up.unit();
  
  
 
   fVP.SetUpVector(new_upUnit);
   fVP.SetViewAndLights (viewPoint);
}

References G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

rotateSceneThetaPhi()

void G4OpenGLViewer::rotateSceneThetaPhi ( G4double  dx, G4double  dy  )

privateinherited

Definition at line 1157 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4double delta_alpha;
  G4double delta_theta;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4double cosalpha;
  G4double sinalpha;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
    
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit ();
  up = fVP.GetUpVector ().unit ();
  
  yprime = (up.cross(vp)).unit();
  zprime = (vp.cross(yprime)).unit();
  
  if (fVP.GetLightsMoveWithCamera()) {
    delta_alpha = dy * fRot_sens;
    delta_theta = -dx * fRot_sens;
  } else {
    delta_alpha = -dy * fRot_sens;
    delta_theta = dx * fRot_sens;
  }    
  
  delta_alpha *= CLHEP::deg;
  delta_theta *= CLHEP::deg;
  
  new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
  
  // to avoid z rotation flipping
  // to allow more than 360∞ rotation
 
  if (fVP.GetLightsMoveWithCamera()) {
    new_up = (new_vp.cross(yprime)).unit();
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  } else {
    new_up = up;
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  }
  fVP.SetUpVector(new_up);
  // Rotates by fixed azimuthal angle delta_theta.
  
  cosalpha = new_up.dot (new_vp.unit());
  sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
  yprime = (new_up.cross (new_vp.unit())).unit ();
  xprime = yprime.cross (new_up);
  // Projection of vp on plane perpendicular to up...
  a1 = sinalpha * xprime;
  // Required new projection...
  a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
  // Required Increment vector...
  delta = a2 - a1;
  // So new viewpoint is...
  viewPoint = new_vp.unit() + delta;
  
  fVP.SetViewAndLights (viewPoint);
}

References HepGeom::BasicVector3D< T >::cross(), CLHEP::deg, HepGeom::BasicVector3D< T >::dot(), G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetLightsMoveWithCamera(), G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), HepGeom::BasicVector3D< T >::set(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

rotateSceneToggle()

void G4OpenGLViewer::rotateSceneToggle ( G4double  dx, G4double  dy  )

protectedinherited

Definition at line 1143 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() != G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by G4OpenGLQtViewer::rotateQtSceneToggle().

set_pan_sens_callback()

void G4OpenGLXmViewer::set_pan_sens_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 216 of file G4OpenGLXmPanningCallbacks.cc.

{
  XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  short dp = -1;
  G4float ten_to_the_dp = 10.;
 
  XtVaGetValues (w, 
         XmNdecimalPoints, &dp,
         NULL);
 
  if (dp == 0) {
    ten_to_the_dp = 1.;
  } else if ( dp > 0) {
    for (G4int i = 1; i < (G4int)dp; i++) {
      ten_to_the_dp *= 10.;
    }
  } else {
    G4cout << "dp is " << dp << G4endl;
    return;
  }
  
  pView->fPan_sens = (G4double)((cbs->value) / ten_to_the_dp);
}  

References G4OpenGLViewer::fPan_sens, G4cout, and G4endl.

Referenced by actions_callback().

set_print_colour_callback()

void G4OpenGLXmViewer::set_print_colour_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 75 of file G4OpenGLXmWindowHandlingCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
  
  G4int choice = get_int_userData (w);
  
  pView->fPrintColour=(G4bool)choice;
  G4cout << "Print colour set to " << pView->fPrintColour;
  
}

References G4OpenGLViewer::fPrintColour, G4cout, and get_int_userData().

Referenced by misc_callback().

set_print_style_callback()

void G4OpenGLXmViewer::set_print_style_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 88 of file G4OpenGLXmWindowHandlingCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
  
  G4int choice = get_int_userData (w);
  
  pView->fVectoredPs=(G4bool)choice;
  G4cout << "`Produce vectored PostScript ?' set to : " << pView->fPrintColour;
  
}

References G4OpenGLViewer::fPrintColour, G4OpenGLViewer::fVectoredPs, G4cout, and get_int_userData().

Referenced by misc_callback().

set_rot_sens_callback()

void G4OpenGLXmViewer::set_rot_sens_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 192 of file G4OpenGLXmRotationCallbacks.cc.

{
  XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  short dp = -1;
  G4float ten_to_the_dp = 10.;
 
  XtVaGetValues (w, 
         XmNdecimalPoints, &dp,
         NULL);
 
  if (dp == 0) {
    ten_to_the_dp = 1.;
  } else if ( dp > 0) {
    for (G4int i = 1; i < (G4int)dp; i++) {
      ten_to_the_dp *= 10.;
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::set_rot_sens_callback",
       "opengl2004", FatalException,
       "Bad value returned for dp in set_rot_sens_callback");
  }
 
  pView->fRot_sens = (G4float)(cbs->value) / ten_to_the_dp;
}  

References FatalException, G4OpenGLViewer::fRot_sens, and G4Exception().

Referenced by actions_callback().

set_rot_subject_callback()

void G4OpenGLXmViewer::set_rot_subject_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 221 of file G4OpenGLXmRotationCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
  
  G4int choice = get_int_userData (w);
  
  switch (choice) {
  case 0: 
    {
      pView->fVP.SetLightsMoveWithCamera (true);
      break;
    }
  case 1:
    {
      pView->fVP.SetLightsMoveWithCamera (false);
      break;
    }
  default:
    {
      G4Exception
    ("G4OpenGLXmViewer::set_rot_subject_callback",
     "opengl2005", FatalException,
     "Unrecognised choice made in set_rot_subject_callback"); 
    }
  }
}  

References FatalException, G4VViewer::fVP, G4Exception(), get_int_userData(), and G4ViewParameters::SetLightsMoveWithCamera().

Referenced by actions_callback().

set_wob_sens_callback()

void G4OpenGLXmViewer::set_wob_sens_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 526 of file G4OpenGLXmMainMenubarCallbacks.cc.

{
  XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  short dp = -1;
  G4float ten_to_the_dp = 10.;
  
  XtVaGetValues (w, 
         XmNdecimalPoints, &dp,
         NULL);
  
  if (dp == 0) {
    ten_to_the_dp = 1.;
  } else if ( dp > 0) {
    for (G4int i = 1; i < (G4int)dp; i++) {
      ten_to_the_dp *= 10.;
    }
  } else {
    G4Exception
      ("G4OpenGLXmViewer::set_wob_sens_callback",
       "opengl2003", FatalException,
       "Bad value returned for dp in set_rot_sens_callback");
  }
  
  pView->wob_sens = (G4float)(cbs->value) / ten_to_the_dp;
}  

References FatalException, G4Exception(), and wob_sens.

Referenced by misc_callback().

SetDefaultViewParameters()

void G4VViewer::SetDefaultViewParameters ( const G4ViewParameters &  vp )

inherited

setExportFilename()

bool G4OpenGLViewer::setExportFilename ( G4String  name, G4bool  inc = true  )

protectedinherited

If name is "" or "!", filename and extension will have the default value. If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). If name is the same as previous, do not reset incremented suffix.

Definition at line 1034 of file G4OpenGLViewer.cc.

                                                               {
  if (name == "!") {
    name = "";
  }
 
  if (inc) {
    if ((name != "") && (fExportFilename != name)) {
      fExportFilenameIndex=0;
    }
  } else {
    fExportFilenameIndex=-1;
  }
 
  if (name.size() == 0) {
    name = getRealPrintFilename().c_str();
  } else {
    // guess format by extention
    std::string extension = name.substr(name.find_last_of(".") + 1);
    // If there is a dot in the name the above might find rubbish, so...
    if (extension.size() >= 3 && extension.size() <= 4) {  // Possible extension
      if (setExportImageFormat(extension, false)) {  // Extension found
        fExportFilename = name.substr(0,name.find_last_of("."));
      } else {  // No viable extension found
        return false;
      }
    } else {  // Assume name is already the required without-extension part
        fExportFilename = name;
    }
  }
  return true;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::getRealPrintFilename(), G4InuclParticleNames::name(), and G4OpenGLViewer::setExportImageFormat().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

setExportImageFormat()

bool G4OpenGLViewer::setExportImageFormat ( std::string  format, bool  quiet = false  )

inherited

Definition at line 1292 of file G4OpenGLViewer.cc.

                                                                      {
  bool found = false;
  std::string list;
  for (unsigned int a=0; a<fExportImageFormatVector.size(); a++) {
    list +=fExportImageFormatVector.at(a) + " ";
 
    if (fExportImageFormatVector.at(a) == format) {
      if (! quiet) {
        G4cout << " Changing export format to \"" << format << "\"" << G4endl;
      }
      if (format != fExportImageFormat) {
        fExportFilenameIndex = 0;
        fExportImageFormat = format;
      }
      return true;
    }
  }
  if (! found) {
    if (format.size() == 0) {
      G4cout << " Current formats availables are : " << list << G4endl;
    } else {
      G4cerr << " Format \"" << format << "\" is not available for the selected viewer. Current formats availables are : " << list << G4endl;
    }
  }
  return false;
}

References G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fExportImageFormatVector, G4cerr, G4cout, and G4endl.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewerMessenger::SetNewValue().

setExportSize()

void G4OpenGLViewer::setExportSize ( G4int  X, G4int  Y  )

protectedinherited

Definition at line 1023 of file G4OpenGLViewer.cc.

                                                   {
  fPrintSizeX = X;
  fPrintSizeY = Y;
}

References G4OpenGLViewer::fPrintSizeX, G4OpenGLViewer::fPrintSizeY, and Y().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

SetName()

void G4VViewer::SetName ( const G4String &  name )

inherited

Definition at line 72 of file G4VViewer.cc.

                                             {
  fName = name;
  fShortName = fName.substr(0, fName.find (' '));
  G4StrUtil::strip(fShortName);
}

References G4VViewer::fName, G4VViewer::fShortName, G4InuclParticleNames::name(), and G4StrUtil::strip().

SetNeedKernelVisit()

void G4VViewer::SetNeedKernelVisit ( G4bool  need )

inherited

Referenced by aux_edge_callback(), G4OpenGLQtViewer::toggleAux(), G4OpenGLQtViewer::toggleTransparency(), and transparency_callback().

SetTouchable()

void G4VViewer::SetTouchable ( const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &  fullPath )

protectedinherited

Definition at line 124 of file G4VViewer.cc.

{
  // Set the touchable for /vis/touchable/set/... commands.
  std::ostringstream oss;
  const auto& pvStore = G4PhysicalVolumeStore::GetInstance();
  for (const auto& pvNodeId: fullPath) {
    const auto& pv = pvNodeId.GetPhysicalVolume();
    auto iterator = find(pvStore->begin(),pvStore->end(),pv);
    if (iterator == pvStore->end()) {
      G4ExceptionDescription ed;
      ed << "Volume no longer in physical volume store.";
      G4Exception("G4VViewer::SetTouchable", "visman0501", JustWarning, ed);
    } else {
      oss
      << ' ' << pvNodeId.GetPhysicalVolume()->GetName()
      << ' ' << pvNodeId.GetCopyNo();
    }
  }
  G4UImanager::GetUIpointer()->ApplyCommand("/vis/set/touchable" + oss.str());
}

References G4UImanager::ApplyCommand(), G4Exception(), G4PhysicalVolumeStore::GetInstance(), G4UImanager::GetUIpointer(), and JustWarning.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), and G4OpenGLQtViewer::setCheckComponent().

SetView()

void G4OpenGLXViewer::SetView ( )

virtualinherited

Reimplemented from G4OpenGLViewer.

Definition at line 91 of file G4OpenGLXViewer.cc.

                               {
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread()) {
    glXMakeCurrent (dpy, win, cxMaster);
  } else {
    glXMakeCurrent (dpy, win, cxVisSubThread);
  }
#else
  glXMakeCurrent (dpy, win, cxMaster);
#endif
  G4OpenGLViewer::SetView ();
}

References G4OpenGLXViewer::cxMaster, G4OpenGLXViewer::dpy, G4Threading::IsMasterThread(), G4OpenGLViewer::SetView(), and G4OpenGLXViewer::win.

Referenced by antialias_callback(), aux_edge_callback(), background_color_callback(), dolly_callback(), drawing_style_callback(), haloing_callback(), left_right_pan_callback(), projection_callback(), reset_callback(), rotate_in_phi(), rotate_in_theta(), transparency_callback(), up_down_pan_callback(), wobble_timer_callback(), and zoom_callback().

SetViewParameters()

void G4VViewer::SetViewParameters ( const G4ViewParameters &  vp )

inherited

Definition at line 120 of file G4VViewer.cc.

                                                             {
  fVP = vp;
}

References G4VViewer::fVP.

Referenced by G4VVisCommand::InterpolateViews(), G4VisCommandDrawView::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), G4VVisCommand::SetViewParameters(), and G4OpenInventorViewer::SetWireFrame().

ShowView()

void G4OpenGLXmViewer::ShowView ( void  )

protectedvirtual

Reimplemented from G4VViewer.

Definition at line 57 of file G4OpenGLXmViewer.cc.

                                 {
 
//  glXWaitGL (); //Wait for effects of all previous OpenGL commands to
                //be propagated before progressing.
// JA: Commented out July 2021 - slows rendering down in some cases and I
// don't see any adverse effects.
 
  glFlush ();
 
  G4Xt::getInstance () -> SecondaryLoop ();
 
}

References G4Xt::getInstance().

sizeHasChanged()

G4bool G4OpenGLViewer::sizeHasChanged ( )

protectedinherited

Definition at line 981 of file G4OpenGLViewer.cc.

                                      {
  return fSizeHasChanged;
}

References G4OpenGLViewer::fSizeHasChanged.

Referenced by G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

theta_rotation_callback()

void G4OpenGLXmViewer::theta_rotation_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 42 of file G4OpenGLXmRotationCallbacks.cc.

{
  XmArrowButtonCallbackStruct *cbs = (XmArrowButtonCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
 
  pView->rotate_right = get_boolean_userData (w);
 
  if (cbs->reason == XmCR_ARM) {
    rotate_in_theta (pView, NULL);
  } else if (cbs->reason == XmCR_DISARM) {
    XtRemoveTimeOut (pView->rotation_timer);
  }
}

References get_boolean_userData(), rotate_in_theta(), rotate_right, and rotation_timer.

Referenced by actions_callback().

TouchableSetColour()

void G4VViewer::TouchableSetColour ( const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &  fullPath, const G4Colour &  colour  )

protectedinherited

Definition at line 180 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/colour "
  << colour.GetRed() << ' ' << colour.GetGreen()
  << ' ' << colour.GetBlue() << ' ' << colour.GetAlpha();
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the colour.
  workingVisAtts.SetColour(colour);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASColour,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASColour (VAS = Vis Attribute Signifier)
  // signifies that it is the colour that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetGreen(), G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4Colour::GetRed(), G4UImanager::GetUIpointer(), G4VisAttributes::SetColour(), and G4ModelingParameters::VASColour.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency().

TouchableSetVisibility()

void G4VViewer::TouchableSetVisibility ( const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &  fullPath, G4bool  visibility  )

protectedinherited

Definition at line 146 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/visibility ";
  if (visibiity) oss << "true"; else oss << "false";
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the visibility.
  workingVisAtts.SetVisibility(visibiity);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASVisibility,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASVisibility (VAS = Vis Attribute Signifier)
  // signifies that it is the visibility that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4UImanager::GetUIpointer(), G4VisAttributes::SetVisibility(), and G4ModelingParameters::VASVisibility.

Referenced by G4OpenGLQtViewer::setCheckComponent().

transparency_callback()

void G4OpenGLXmViewer::transparency_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 122 of file G4OpenGLXmStyleCallbacks.cc.

{
  G4long choice = (G4long)clientData;
  G4OpenGLXmViewer* pView;
  XtVaGetValues (XtParent(w),
         XmNuserData, &pView,
         NULL);
 
  switch (choice) {
    
  case 0:
    pView->transparency_enabled = false;
    break;
 
  case 1:
    pView->transparency_enabled = true;
    break;
 
  default:
    G4Exception
      ("G4OpenGLXmViewer::transparency_callback",
       "opengl2009", FatalException,
       "Unrecognised case in transparency_callback.");
  }
 
  pView->SetNeedKernelVisit (true);
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
}

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), FatalException, G4Exception(), G4VViewer::SetNeedKernelVisit(), G4OpenGLXViewer::SetView(), and G4OpenGLViewer::transparency_enabled.

Referenced by CreateMainWindow().

up_down_pan_callback()

void G4OpenGLXmViewer::up_down_pan_callback ( XtPointer  clientData, XtIntervalId *  timer_id  )

static

Definition at line 182 of file G4OpenGLXmPanningCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  G4double delta;
  
  if (pView->pan_up) {
    delta = pView->fPan_sens;
  } else {
    delta = -(pView->fPan_sens);
  }
  
  G4Point3D stp
    = pView -> GetSceneHandler()->GetScene()->GetStandardTargetPoint();
  G4Point3D tp = stp + pView -> fVP.GetCurrentTargetPoint ();
  const G4Vector3D& upVector = pView->fVP.GetUpVector ();
  const G4Vector3D& vpVector = pView->fVP.GetViewpointDirection ();
  
  G4Vector3D unitRight = (upVector.cross (vpVector)).unit();
  G4Vector3D unitUp    = (vpVector.cross (unitRight)).unit();
  tp += delta * unitUp;
  pView->fVP.SetCurrentTargetPoint (tp - stp);
  
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
 
  pView->pan_timer = XtAppAddTimeOut 
    (pView->app,
     timer_id == NULL ? 500 : 1,
     up_down_pan_callback,
     pView);
}  

References app, G4OpenGLViewer::ClearView(), HepGeom::BasicVector3D< T >::cross(), G4VViewer::DrawView(), G4OpenGLViewer::fPan_sens, G4VViewer::fVP, G4ViewParameters::GetCurrentTargetPoint(), G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4Scene::GetStandardTargetPoint(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), pan_timer, pan_up, G4ViewParameters::SetCurrentTargetPoint(), G4OpenGLXViewer::SetView(), G4InuclParticleNames::tp, and up_down_pan_callback().

Referenced by pan_up_down_callback(), and up_down_pan_callback().

update_panels_callback()

void G4OpenGLXmViewer::update_panels_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 555 of file G4OpenGLXmMainMenubarCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  
  if (pView->fppanning_slider) {
    pView->fppanning_slider->SetMaxValue (pView->pan_sens_limit);
  }
  if (pView->fprotation_slider) {
    pView->fprotation_slider->SetMaxValue (pView->rot_sens_limit);
  }
  
  if (pView->fpzoom_slider) {
    pView->fpzoom_slider->SetMaxValue (pView->zoom_high);
    pView->fpzoom_slider->SetMinValue (pView->zoom_low);
    pView->fpzoom_slider->SetInitialValue (pView->fVP.GetZoomFactor());
  }
  
  if (pView->fpdolly_slider) {
    pView->fpdolly_slider->SetMaxValue (pView->dolly_high);
    pView->fpdolly_slider->SetMinValue (pView->dolly_low);
  }
}

References dolly_high, dolly_low, fpdolly_slider, fppanning_slider, fprotation_slider, fpzoom_slider, G4VViewer::fVP, G4ViewParameters::GetZoomFactor(), pan_sens_limit, rot_sens_limit, G4OpenGLXmSliderBar::SetInitialValue(), G4OpenGLXmSliderBar::SetMaxValue(), G4OpenGLXmSliderBar::SetMinValue(), zoom_high, and zoom_low.

Referenced by actions_callback(), and misc_callback().

UpdateControlPanel()

void G4OpenGLXmViewer::UpdateControlPanel ( )

private

Definition at line 783 of file G4OpenGLXmViewer.cc.

                                           {
 
  // set new values
 
  if (fprotation_slider) {
    fprotation_slider->SetInitialValue(fRot_sens);
    fprotation_slider->SetMaxValue(rot_sens_limit);
    fprotation_slider->SetMinValue(0);
  }
  if (fppanning_slider) {
    fppanning_slider->SetInitialValue(fPan_sens);
    fppanning_slider->SetMaxValue(pan_sens_limit);
    fppanning_slider->SetMinValue(0);
  }
  if (fpzoom_slider) {
    fpzoom_slider->SetInitialValue(fVP.GetZoomFactor());
    fpzoom_slider->SetMinValue(zoom_low);
    fpzoom_slider->SetMaxValue(zoom_high);
  }
  if (fpdolly_slider) {
    fpdolly_slider->SetInitialValue(fVP.GetDolly());
    fpdolly_slider->SetMinValue(dolly_low);
    fpdolly_slider->SetMaxValue(dolly_high);
  }
 
  if (fpwobble_slider) {
    fpwobble_slider->SetInitialValue(fVP.GetDolly());
  }
 
  if (fppan_set) {
    fppan_set->SetValue(pan_sens_limit);
  }
 
  if (fprot_set) {
    fprot_set->SetValue(rot_sens_limit);
  }
 
  if (fpzoom_upper) {
    fpzoom_upper->SetValue(zoom_high);
  }
 
  if (fpzoom_lower) {
    fpzoom_lower->SetValue(zoom_low);
  }
  if (fpdolly_upper) {
    fpdolly_upper->SetValue(dolly_high);
  }
 
  if (fpdolly_lower) {
    fpdolly_lower->SetValue(dolly_low);
  }
 
 
}

References dolly_high, dolly_low, G4OpenGLViewer::fPan_sens, fpdolly_lower, fpdolly_slider, fpdolly_upper, fppan_set, fppanning_slider, fprot_set, fprotation_slider, fpwobble_slider, fpzoom_lower, fpzoom_slider, fpzoom_upper, G4OpenGLViewer::fRot_sens, G4VViewer::fVP, G4ViewParameters::GetDolly(), G4ViewParameters::GetZoomFactor(), pan_sens_limit, rot_sens_limit, G4OpenGLXmSliderBar::SetInitialValue(), G4OpenGLXmSliderBar::SetMaxValue(), G4OpenGLXmSliderBar::SetMinValue(), G4OpenGLXmTextField::SetValue(), zoom_high, and zoom_low.

Referenced by actions_callback(), and ResetView().

wobble_callback()

void G4OpenGLXmViewer::wobble_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 250 of file G4OpenGLXmRotationCallbacks.cc.

{
  G4OpenGLXmViewer* pView;
  
  XtVaGetValues (w,
         XmNuserData, &pView,
         NULL);
  
  pView->original_vp = pView->fVP.GetViewpointDirection();
  pView->wobble_timer = XtAppAddTimeOut
    (pView->app,
     (long unsigned int) (1000. * (1. / pView->wob_sens)),
     wobble_timer_callback,
     pView);
}  

References app, G4VViewer::fVP, G4ViewParameters::GetViewpointDirection(), original_vp, wob_sens, wobble_timer, and wobble_timer_callback().

Referenced by misc_callback().

wobble_timer_callback()

void G4OpenGLXmViewer::wobble_timer_callback ( XtPointer  clientData, XtIntervalId *  timerid  )

static

Definition at line 268 of file G4OpenGLXmRotationCallbacks.cc.

{
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
  const G4Vector3D& up = pView->fVP.GetUpVector();
  G4Vector3D third_axis = up.cross(pView->original_vp);
  G4double pi_div_by_ten = pi / 10.0;
  G4Vector3D d_up = 0.1 * (std::sin ((G4double)pView->frameNo * pi_div_by_ten * 2.)) * up;
  G4Vector3D d_third_axis = 0.1 * (std::sin ((G4double)pView->frameNo * (pi_div_by_ten))) * third_axis;
 
  pView->fVP.SetViewAndLights (pView->original_vp + d_up + d_third_axis);
 
  pView->SetView ();
  pView->ClearView ();
  pView->DrawView ();
  
  if (pView->frameNo++ == 20) {
    if (pView->wobble_timer) {
      XtRemoveTimeOut (pView->wobble_timer);
      pView->frameNo = 0;
      pView->fVP.SetViewAndLights (pView->original_vp);
      pView->SetView ();
      pView->ClearView ();
      pView->DrawView ();
   }
  } else {
    pView->wobble_timer = XtAppAddTimeOut
      (pView->app,
       (long unsigned int) (1000. * (1. / pView->wob_sens)),
       wobble_timer_callback,
       pView);
  }
}

References app, G4OpenGLViewer::ClearView(), HepGeom::BasicVector3D< T >::cross(), G4VViewer::DrawView(), frameNo, G4VViewer::fVP, G4ViewParameters::GetUpVector(), original_vp, pi, G4OpenGLXViewer::SetView(), G4ViewParameters::SetViewAndLights(), wob_sens, wobble_timer, and wobble_timer_callback().

Referenced by wobble_callback(), and wobble_timer_callback().

zoom_callback()

void G4OpenGLXmViewer::zoom_callback ( Widget  w, XtPointer  clientData, XtPointer  callData  )

static

Definition at line 43 of file G4OpenGLXmPanningCallbacks.cc.

{
  XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct*) callData;
  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
  short dp = -1;
  G4float ten_to_the_dp = 10.;
 
  XtVaGetValues (w, 
         XmNdecimalPoints, &dp,
         NULL);
 
  if (dp == 0) {
    ten_to_the_dp = 1.;
  } else if ( dp > 0) {
    for (G4int i = 1; i < (G4int)dp; i++) {
      ten_to_the_dp *= 10.;
    }
  } else {
    G4cout << "dp is " << dp << G4endl;
    return;
  }
 
 
  G4double zoomBy = (G4double)(cbs->value) / ten_to_the_dp;
  if (zoomBy <= 0.01) {
    zoomBy = 0.01;
  }
 
  pView->fVP.SetZoomFactor (zoomBy);
  pView->SetView ();
  pView->ClearView ();
  pView -> DrawView ();
}  

References G4OpenGLViewer::ClearView(), G4VViewer::DrawView(), G4VViewer::fVP, G4cout, G4endl, G4OpenGLXViewer::SetView(), and G4ViewParameters::SetZoomFactor().

Referenced by actions_callback().

Friends And Related Function Documentation

G4OpenGLXmViewerMessenger

friend class G4OpenGLXmViewerMessenger

friend

Definition at line 360 of file G4OpenGLXmViewer.hh.

G4OpenGLXmVWidgetObject

friend class G4OpenGLXmVWidgetObject

friend

Definition at line 359 of file G4OpenGLXmViewer.hh.

Field Documentation

actions_cascade

Widget G4OpenGLXmViewer::actions_cascade

protected

Definition at line 70 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

actions_str

XmString G4OpenGLXmViewer::actions_str

protected

Definition at line 83 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

anti_str

XmString G4OpenGLXmViewer::anti_str

protected

Definition at line 100 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

antialias_pullright

Widget G4OpenGLXmViewer::antialias_pullright

protected

Definition at line 76 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

antialiasing_enabled

G4bool G4OpenGLViewer::antialiasing_enabled

protectedinherited

Definition at line 201 of file G4OpenGLViewer.hh.

Referenced by antialias_callback(), CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::toggleAntialiasing().

app

XtAppContext G4OpenGLXmViewer::app

protected

Definition at line 63 of file G4OpenGLXmViewer.hh.

Referenced by GetXmConnection(), left_right_pan_callback(), rotate_in_phi(), rotate_in_theta(), up_down_pan_callback(), wobble_callback(), and wobble_timer_callback().

attributeList

G4int* G4OpenGLXViewer::attributeList

protectedinherited

Definition at line 89 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

aux_edge_pullright

Widget G4OpenGLXmViewer::aux_edge_pullright

protected

Definition at line 78 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

aux_edge_str

XmString G4OpenGLXmViewer::aux_edge_str

protected

Definition at line 103 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

background

G4Colour G4OpenGLViewer::background

protectedinherited

Definition at line 198 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ClearViewWithoutFlush(), CreateMainWindow(), and G4OpenGLViewer::SetView().

background_color_pullright

Widget G4OpenGLXmViewer::background_color_pullright

protected

Definition at line 74 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

bgnd

Pixel G4OpenGLXmViewer::bgnd

protected

Definition at line 121 of file G4OpenGLXmViewer.hh.

Referenced by Add_four_arrow_buttons(), Add_radio_box(), Add_set_field(), Add_slider_box(), CreateMainWindow(), and G4OpenGLXmVWidgetObject::ProcesspView().

bgnd_str

XmString G4OpenGLXmViewer::bgnd_str

protected

Definition at line 104 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

black_str

XmString G4OpenGLXmViewer::black_str

protected

Definition at line 99 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

borcol

Pixel G4OpenGLXmViewer::borcol

protected

Definition at line 122 of file G4OpenGLXmViewer.hh.

Referenced by Add_four_arrow_buttons(), Add_radio_box(), Add_set_field(), Add_slider_box(), CreateMainWindow(), and G4OpenGLXmVWidgetObject::ProcesspView().

charViewName

char G4OpenGLXViewer::charViewName[100]

protectedinherited

Definition at line 102 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

class_hints

XClassHint* G4OpenGLXViewer::class_hints

protectedinherited

Definition at line 96 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

cmap

Colormap G4OpenGLXViewer::cmap

protectedinherited

Definition at line 81 of file G4OpenGLXViewer.hh.

Referenced by Add_four_arrow_buttons(), Add_radio_box(), Add_set_field(), Add_slider_box(), G4OpenGLXViewer::CreateGLXContext(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), and G4OpenGLXmVWidgetObject::ProcesspView().

cxMaster

GLXContext G4OpenGLXViewer::cxMaster

protectedinherited

Definition at line 84 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateGLXContext(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLXViewer::SetView(), and G4OpenGLXViewer::~G4OpenGLXViewer().

dblBuf_RGBA

int G4OpenGLXViewer::dblBuf_RGBA

staticprotectedinherited

Initial value:

=
{ GLX_RGBA,
  GLX_RED_SIZE, 1,
  GLX_GREEN_SIZE, 1,
  GLX_BLUE_SIZE, 1,
  GLX_DOUBLEBUFFER,
  GLX_DEPTH_SIZE, 1,
  GLX_STENCIL_SIZE, 1,
  None }

Definition at line 70 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

dolly_high

G4double G4OpenGLXmViewer::dolly_high

protected

Definition at line 113 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

dolly_low

G4double G4OpenGLXmViewer::dolly_low

protected

Definition at line 112 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

dpy

Display* G4OpenGLXViewer::dpy

protectedinherited

Definition at line 75 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateFontLists(), G4OpenGLXViewer::CreateGLXContext(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLStoredXmViewer::FinishView(), G4OpenGLStoredXViewer::FinishView(), G4OpenGLXViewer::G4OpenGLXViewer(), G4OpenGLXViewer::GetXConnection(), GetXmConnection(), G4OpenGLXViewer::SetView(), G4OpenGLXViewer::ShowView(), and G4OpenGLXViewer::~G4OpenGLXViewer().

draw_str

XmString G4OpenGLXmViewer::draw_str

protected

Definition at line 86 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

drawing_style_pullright

Widget G4OpenGLXmViewer::drawing_style_pullright

protected

Definition at line 73 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

errorBase

G4int G4OpenGLXViewer::errorBase

protectedinherited

Definition at line 90 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::GetXConnection(), and GetXmConnection().

event

XEvent G4OpenGLXViewer::event

protectedinherited

Definition at line 88 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow(), and G4OpenGLXViewer::ShowView().

eventBase

G4int G4OpenGLXViewer::eventBase

protectedinherited

Definition at line 91 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::GetXConnection(), and GetXmConnection().

exit_str

XmString G4OpenGLXmViewer::exit_str

protected

Definition at line 95 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

fDefaultExportFilename

G4String G4OpenGLViewer::fDefaultExportFilename

privateinherited

Definition at line 220 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer().

fDefaultExportImageFormat

std::string G4OpenGLViewer::fDefaultExportImageFormat

protectedinherited

Definition at line 210 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage().

fDefaultVP

G4ViewParameters G4VViewer::fDefaultVP

protectedinherited

Definition at line 220 of file G4VViewer.hh.

Referenced by G4ASCIITreeViewer::G4ASCIITreeViewer(), G4HepRepFileViewer::G4HepRepFileViewer(), G4OpenGLStoredViewer::G4OpenGLStoredViewer(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenInventorViewer::G4OpenInventorViewer(), G4VtkViewer::G4VtkViewer(), G4VViewer::G4VViewer(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise().

fExportFilename

G4String G4OpenGLViewer::fExportFilename

privateinherited

Definition at line 219 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportFilename().

fExportFilenameIndex

int G4OpenGLViewer::fExportFilenameIndex

protectedinherited

Definition at line 212 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewer::setExportImageFormat().

fExportImageFormat

std::string G4OpenGLViewer::fExportImageFormat

protectedinherited

Definition at line 211 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportImageFormat().

fExportImageFormatVector

std::vector< std::string > G4OpenGLViewer::fExportImageFormatVector

protectedinherited

Definition at line 209 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::addExportImageFormat(), and G4OpenGLViewer::setExportImageFormat().

fGL2PSAction

G4OpenGL2PSAction* G4OpenGLViewer::fGL2PSAction

protectedinherited

Definition at line 203 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::isGl2psWriting(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::~G4OpenGLViewer().

fGl2psDefaultLineWith

int G4OpenGLViewer::fGl2psDefaultLineWith

privateinherited

Definition at line 222 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

fGl2psDefaultPointSize

int G4OpenGLViewer::fGl2psDefaultPointSize

privateinherited

Definition at line 223 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

fGlViewInitialized

bool G4OpenGLViewer::fGlViewInitialized

privateinherited

Definition at line 224 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::InitializeGLView().

fIsGettingPickInfos

bool G4OpenGLViewer::fIsGettingPickInfos

privateinherited

Definition at line 241 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails(), and G4OpenGLViewer::SetView().

fName

G4String G4VViewer::fName

protectedinherited

Definition at line 217 of file G4VViewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4OpenInventorQtViewer::G4OpenInventorQtViewer(), G4OpenInventorWinViewer::G4OpenInventorWinViewer(), G4OpenInventorXtExtendedViewer::G4OpenInventorXtExtendedViewer(), G4OpenInventorXtViewer::G4OpenInventorXtViewer(), G4VViewer::G4VViewer(), GetXmConnection(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VViewer::SetName(), and G4Qt3DViewer::SetView().

fNeedKernelVisit

G4bool G4VViewer::fNeedKernelVisit

protectedinherited

Definition at line 224 of file G4VViewer.hh.

Referenced by G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenInventorViewer::DrawView(), G4Qt3DViewer::DrawView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView(), G4VViewer::NeedKernelVisit(), and G4VViewer::ProcessView().

fOpenGLSceneHandler

G4OpenGLSceneHandler& G4OpenGLViewer::fOpenGLSceneHandler

protectedinherited

Definition at line 197 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails().

fov

G4double G4OpenGLXmViewer::fov

protected

Definition at line 114 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), and projection_callback().

fPan_sens

G4double G4OpenGLViewer::fPan_sens

protectedinherited

Definition at line 206 of file G4OpenGLViewer.hh.

Referenced by actions_callback(), left_right_pan_callback(), G4OpenGLQtViewer::moveScene(), G4OpenGLViewer::ResetView(), ResetView(), set_pan_sens_callback(), up_down_pan_callback(), and UpdateControlPanel().

fpdolly_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpdolly_box

protected

Definition at line 152 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpdolly_lower

G4OpenGLXmTextField* G4OpenGLXmViewer::fpdolly_lower

protected

Definition at line 162 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

fpdolly_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpdolly_slider

protected

Definition at line 153 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

fpdolly_upper

G4OpenGLXmTextField* G4OpenGLXmViewer::fpdolly_upper

protected

Definition at line 161 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

fpfov_text

G4OpenGLXmTextField* G4OpenGLXmViewer::fpfov_text

protected

Definition at line 174 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpmiscellany_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpmiscellany_top

protected

Definition at line 165 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fPointSize

G4float G4OpenGLViewer::fPointSize

privateinherited

Definition at line 218 of file G4OpenGLViewer.hh.

fpok_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpok_button

protected

Definition at line 163 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fporthogonal_button

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fporthogonal_button

protected

Definition at line 172 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fppan_set

G4OpenGLXmTextField* G4OpenGLXmViewer::fppan_set

protected

Definition at line 157 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

fppanning_arrows

G4OpenGLXmFourArrowButtons* G4OpenGLXmViewer::fppanning_arrows

protected

Definition at line 148 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fppanning_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fppanning_box

protected

Definition at line 147 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fppanning_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fppanning_slider

protected

Definition at line 149 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

fppanning_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fppanning_top

protected

Definition at line 146 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpperspective_button

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpperspective_button

protected

Definition at line 173 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_box

protected

Definition at line 177 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpprint_button

protected

Definition at line 181 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_col_box

protected

Definition at line 178 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_radio1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_col_radio1

protected

Definition at line 183 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_radio2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_col_radio2

protected

Definition at line 184 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_line

G4OpenGLXmSeparator* G4OpenGLXmViewer::fpprint_line

protected

Definition at line 182 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_style_box

protected

Definition at line 179 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_radio1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_style_radio1

protected

Definition at line 185 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_radio2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_style_radio2

protected

Definition at line 186 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_text

G4OpenGLXmTextField* G4OpenGLXmViewer::fpprint_text

protected

Definition at line 180 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpprint_top

protected

Definition at line 176 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpproj_style_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpproj_style_box

protected

Definition at line 171 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpreset_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpreset_box

protected

Definition at line 169 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpreset_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpreset_button

protected

Definition at line 170 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fPrintColour

G4bool G4OpenGLViewer::fPrintColour

protectedinherited

Definition at line 194 of file G4OpenGLViewer.hh.

Referenced by misc_callback(), G4OpenGLViewer::printNonVectoredEPS(), set_print_colour_callback(), and set_print_style_callback().

fPrintSizeX

G4int G4OpenGLViewer::fPrintSizeX

protectedinherited

Definition at line 213 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportWidth(), and G4OpenGLViewer::setExportSize().

fPrintSizeY

G4int G4OpenGLViewer::fPrintSizeY

protectedinherited

Definition at line 214 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportHeight(), and G4OpenGLViewer::setExportSize().

fprot_set

G4OpenGLXmTextField* G4OpenGLXmViewer::fprot_set

protected

Definition at line 158 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

fprotation_arrow

G4OpenGLXmFourArrowButtons* G4OpenGLXmViewer::fprotation_arrow

protected

Definition at line 144 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_arrow_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_arrow_box

protected

Definition at line 143 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fprotation_button1

protected

Definition at line 139 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fprotation_button2

protected

Definition at line 140 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_button_box

protected

Definition at line 138 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fprotation_slider

protected

Definition at line 142 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

fprotation_slider_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_slider_box

protected

Definition at line 141 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fprotation_top

protected

Definition at line 137 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpsetting_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpsetting_box

protected

Definition at line 156 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpsetting_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpsetting_top

protected

Definition at line 155 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpwobble_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpwobble_box

protected

Definition at line 166 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpwobble_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpwobble_button

protected

Definition at line 167 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpwobble_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpwobble_slider

protected

Definition at line 168 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), and UpdateControlPanel().

fpzoom_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpzoom_box

protected

Definition at line 150 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpzoom_lower

G4OpenGLXmTextField* G4OpenGLXmViewer::fpzoom_lower

protected

Definition at line 160 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

fpzoom_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpzoom_slider

protected

Definition at line 151 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

fpzoom_upper

G4OpenGLXmTextField* G4OpenGLXmViewer::fpzoom_upper

protected

Definition at line 159 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), and UpdateControlPanel().

frame

Widget G4OpenGLXmViewer::frame

protected

Definition at line 79 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

frameNo

G4int G4OpenGLXmViewer::frameNo

protected

Definition at line 135 of file G4OpenGLXmViewer.hh.

Referenced by wobble_timer_callback().

fRot_sens

G4double G4OpenGLViewer::fRot_sens

protectedinherited

Definition at line 205 of file G4OpenGLViewer.hh.

Referenced by actions_callback(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLViewer::ResetView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), set_rot_sens_callback(), and UpdateControlPanel().

fSceneHandler

G4VSceneHandler& G4VViewer::fSceneHandler

protectedinherited

Definition at line 215 of file G4VViewer.hh.

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VtkViewer::ClearView(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4VtkViewer::FinishView(), G4VViewer::G4VViewer(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), G4OpenGLViewer::printGl2PS(), G4VViewer::ProcessView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4VtkViewer::ShowView(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4VViewer::~G4VViewer().

fShortName

G4String G4VViewer::fShortName

protectedinherited

Definition at line 218 of file G4VViewer.hh.

Referenced by G4RayTracerViewer::DrawView(), G4VViewer::G4VViewer(), and G4VViewer::SetName().

fSizeHasChanged

G4bool G4OpenGLViewer::fSizeHasChanged

privateinherited

Definition at line 221 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::sizeHasChanged().

fVectoredPs

G4bool G4OpenGLViewer::fVectoredPs

protectedinherited

Definition at line 195 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), misc_callback(), set_print_style_callback(), and G4OpenGLViewerMessenger::SetNewValue().

fViewId

G4int G4VViewer::fViewId

protectedinherited

Definition at line 216 of file G4VViewer.hh.

Referenced by actions_callback(), G4OpenGLXViewer::CreateGLXContext(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLImmediateWin32Viewer::G4OpenGLImmediateWin32Viewer(), G4OpenGLImmediateXmViewer::G4OpenGLImmediateXmViewer(), G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer(), G4OpenGLStoredWin32Viewer::G4OpenGLStoredWin32Viewer(), G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXmViewer(), G4OpenGLXViewer::G4OpenGLXViewer(), G4RayTracerViewer::G4RayTracerViewer(), G4VViewer::G4VViewer(), G4OpenGLXViewer::GetXConnection(), GetXmConnection(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), misc_callback(), G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer(), and G4OpenGLXViewer::~G4OpenGLXViewer().

fVP

G4ViewParameters G4VViewer::fVP

protectedinherited

Definition at line 219 of file G4VViewer.hh.

Referenced by G4OpenGLQtViewer::actionChangeBackgroundColor(), G4OpenGLQtViewer::actionChangeDefaultColor(), G4OpenGLQtViewer::actionChangeTextColor(), actions_callback(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), aux_edge_callback(), G4OpenGLQtViewer::changeDepthInSceneTree(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLWin32Viewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), dolly_callback(), G4OpenGLStoredViewer::DrawDisplayLists(), drawing_style_callback(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenInventorViewer::DrawView(), G4Qt3DViewer::DrawView(), G4RayTracerViewer::DrawView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView(), G4VtkViewer::DrawViewHUD(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Export(), G4ASCIITreeViewer::G4ASCIITreeViewer(), G4HepRepFileViewer::G4HepRepFileViewer(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenInventorViewer::G4OpenInventorViewer(), G4VtkViewer::G4VtkViewer(), G4VViewer::G4VViewer(), G4OpenGLQtViewer::G4wheelEvent(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), GetXmConnection(), G4OpenInventorViewer::GroupCameraSensorCB(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), G4Qt3DViewer::Initialise(), G4RayTracerViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VtkQtViewer::Initialise(), G4VtkViewer::Initialise(), G4OpenGLViewer::InitializeGLView(), left_right_pan_callback(), misc_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateViewer::ProcessView(), projection_callback(), reset_callback(), ResetView(), G4OpenGLViewer::rotateScene(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLViewer::rotateSceneToggle(), G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI(), G4DAWNFILEViewer::SendViewParameters(), G4VRML2FileViewer::SendViewParameters(), set_rot_subject_callback(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLXmViewerMessenger::SetNewValue(), G4OpenGLWin32Viewer::SetRotation(), G4OpenGLWin32Viewer::SetShift(), G4OpenGLViewer::SetView(), G4OpenInventorQtViewer::SetView(), G4OpenInventorViewer::SetView(), G4OpenInventorWinViewer::SetView(), G4OpenInventorXtExtendedViewer::SetView(), G4OpenInventorXtViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGQtViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4VViewer::SetViewParameters(), G4OpenGLWin32Viewer::SetZoom(), G4OpenGLXViewer::ShowView(), G4VtkViewer::ShowView(), G4OpenGLQtViewer::toggleAux(), G4OpenGLQtViewer::toggleHiddenMarkers(), G4OpenGLQtViewer::togglePicking(), G4OpenGLQtViewer::toggleProjection(), G4OpenGLQtViewer::toggleSurfaceAction(), G4VViewer::TouchableSetColour(), G4VViewer::TouchableSetVisibility(), up_down_pan_callback(), update_panels_callback(), UpdateControlPanel(), G4OpenGLQtViewer::updateToolbarAndMouseContextMenu(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), G4Qt3DViewer::wheelEvent(), wobble_callback(), wobble_timer_callback(), and zoom_callback().

fWinSize_x

unsigned int G4OpenGLViewer::fWinSize_x

protectedinherited

Definition at line 207 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

fWinSize_y

unsigned int G4OpenGLViewer::fWinSize_y

protectedinherited

Definition at line 208 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

glxarea

Widget G4OpenGLXmViewer::glxarea

protected

Definition at line 80 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

halo_str

XmString G4OpenGLXmViewer::halo_str

protected

Definition at line 102 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

haloing_enabled

G4bool G4OpenGLViewer::haloing_enabled

protectedinherited

Definition at line 202 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), haloing_callback(), and G4OpenGLQtViewer::toggleHaloing().

haloing_pullright

Widget G4OpenGLXmViewer::haloing_pullright

protected

Definition at line 77 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

hlhsr_str

XmString G4OpenGLXmViewer::hlhsr_str

protected

Definition at line 91 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

hlr_str

XmString G4OpenGLXmViewer::hlr_str

protected

Definition at line 89 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

hsr_str

XmString G4OpenGLXmViewer::hsr_str

protected

Definition at line 90 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

icon_pixmap

Pixmap G4OpenGLXViewer::icon_pixmap

protectedinherited

Definition at line 97 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

iconName

XTextProperty G4OpenGLXViewer::iconName

protectedinherited

Definition at line 101 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow(), and G4OpenGLXViewer::G4OpenGLXViewer().

main_win

Widget G4OpenGLXmViewer::main_win

protected

Definition at line 67 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

major

G4int G4OpenGLXViewer::major

protectedinherited

Definition at line 92 of file G4OpenGLXViewer.hh.

menubar

Widget G4OpenGLXmViewer::menubar

protected

Definition at line 68 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

minor

G4int G4OpenGLXViewer::minor

protectedinherited

Definition at line 93 of file G4OpenGLXViewer.hh.

misc_cascade

Widget G4OpenGLXmViewer::misc_cascade

protected

Definition at line 71 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

misc_str

XmString G4OpenGLXmViewer::misc_str

protected

Definition at line 84 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

norm_hints

XSizeHints* G4OpenGLXViewer::norm_hints

protectedinherited

Definition at line 94 of file G4OpenGLXViewer.hh.

off_str

XmString G4OpenGLXmViewer::off_str

protected

Definition at line 105 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

on_str

XmString G4OpenGLXmViewer::on_str

protected

Definition at line 106 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

original_vp

G4Vector3D G4OpenGLXmViewer::original_vp

protected

Definition at line 133 of file G4OpenGLXmViewer.hh.

Referenced by wobble_callback(), and wobble_timer_callback().

pan_high

G4double G4OpenGLXmViewer::pan_high

protected

Definition at line 111 of file G4OpenGLXmViewer.hh.

pan_low

G4double G4OpenGLXmViewer::pan_low

protected

Definition at line 110 of file G4OpenGLXmViewer.hh.

pan_right

G4bool G4OpenGLXmViewer::pan_right

protected

Definition at line 124 of file G4OpenGLXmViewer.hh.

Referenced by left_right_pan_callback(), and pan_left_right_callback().

pan_sens_limit

G4double G4OpenGLXmViewer::pan_sens_limit

protected

Definition at line 116 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

pan_str

XmString G4OpenGLXmViewer::pan_str

protected

Definition at line 94 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

pan_timer

XtIntervalId G4OpenGLXmViewer::pan_timer

protected

Definition at line 130 of file G4OpenGLXmViewer.hh.

Referenced by left_right_pan_callback(), pan_left_right_callback(), pan_up_down_callback(), and up_down_pan_callback().

pan_up

G4bool G4OpenGLXmViewer::pan_up

protected

Definition at line 126 of file G4OpenGLXmViewer.hh.

Referenced by pan_up_down_callback(), and up_down_pan_callback().

polyhedron_str

XmString G4OpenGLXmViewer::polyhedron_str

protected

Definition at line 87 of file G4OpenGLXmViewer.hh.

print_str

XmString G4OpenGLXmViewer::print_str

protected

Definition at line 97 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

quit_str

XmString G4OpenGLXmViewer::quit_str

protected

Definition at line 96 of file G4OpenGLXmViewer.hh.

rot_sens_limit

G4double G4OpenGLXmViewer::rot_sens_limit

protected

Definition at line 115 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

rot_str

XmString G4OpenGLXmViewer::rot_str

protected

Definition at line 93 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

rotate_right

G4bool G4OpenGLXmViewer::rotate_right

protected

Definition at line 125 of file G4OpenGLXmViewer.hh.

Referenced by rotate_in_theta(), and theta_rotation_callback().

rotate_up

G4bool G4OpenGLXmViewer::rotate_up

protected

Definition at line 127 of file G4OpenGLXmViewer.hh.

Referenced by phi_rotation_callback(), and rotate_in_phi().

rotation_timer

XtIntervalId G4OpenGLXmViewer::rotation_timer

protected

Definition at line 129 of file G4OpenGLXmViewer.hh.

Referenced by phi_rotation_callback(), rotate_in_phi(), rotate_in_theta(), and theta_rotation_callback().

set_str

XmString G4OpenGLXmViewer::set_str

protected

Definition at line 92 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

shell

Widget G4OpenGLXmViewer::shell

protected

Definition at line 66 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow(), GetXmConnection(), and ~G4OpenGLXmViewer().

size_hints

XSizeHints* G4OpenGLXViewer::size_hints

protectedinherited

Definition at line 98 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

snglBuf_RGBA

int G4OpenGLXViewer::snglBuf_RGBA

staticprotectedinherited

Initial value:

=
{ GLX_RGBA,
  GLX_RED_SIZE, 1,
  GLX_GREEN_SIZE, 1, 
  GLX_BLUE_SIZE, 1,
  GLX_DEPTH_SIZE, 1,
  GLX_STENCIL_SIZE, 1,
  None }

Definition at line 69 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

spec_cascade

Widget G4OpenGLXmViewer::spec_cascade

protected

Definition at line 72 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

spec_str

XmString G4OpenGLXmViewer::spec_str

protected

Definition at line 85 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

style_cascade

Widget G4OpenGLXmViewer::style_cascade

protected

Definition at line 69 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

style_str

XmString G4OpenGLXmViewer::style_str

protected

Definition at line 82 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

swa

XSetWindowAttributes G4OpenGLXViewer::swa

protectedinherited

Definition at line 82 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

tmp_cx

GLXContext G4OpenGLXViewer::tmp_cx

privateinherited

Definition at line 108 of file G4OpenGLXViewer.hh.

toplevel

Widget G4OpenGLXmViewer::toplevel

protected

Definition at line 65 of file G4OpenGLXmViewer.hh.

Referenced by GetXmConnection(), and G4OpenGLXmVWidgetObject::ProcesspView().

trans_str

XmString G4OpenGLXmViewer::trans_str

protected

Definition at line 101 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

transparency_enabled

G4bool G4OpenGLViewer::transparency_enabled

protectedinherited

Definition at line 200 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLQtViewer::toggleTransparency(), and transparency_callback().

transparency_pullright

Widget G4OpenGLXmViewer::transparency_pullright

protected

Definition at line 75 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

vi

XVisualInfo * G4OpenGLXViewer::vi

protectedinherited

Definition at line 80 of file G4OpenGLXViewer.hh.

Referenced by Add_four_arrow_buttons(), Add_radio_box(), Add_set_field(), Add_slider_box(), G4OpenGLXViewer::CreateGLXContext(), CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), and G4OpenGLXmVWidgetObject::ProcesspView().

vi_double_buffer

XVisualInfo * G4OpenGLXViewer::vi_double_buffer = 0

staticprotectedinherited

Definition at line 77 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

vi_immediate

XVisualInfo* G4OpenGLXViewer::vi_immediate

protectedinherited

Definition at line 78 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLImmediateXmViewer::G4OpenGLImmediateXmViewer(), G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLXViewer::G4OpenGLXViewer(), G4OpenGLImmediateXmViewer::Initialise(), and G4OpenGLImmediateXViewer::Initialise().

vi_single_buffer

XVisualInfo * G4OpenGLXViewer::vi_single_buffer = 0

staticprotectedinherited

Definition at line 76 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::G4OpenGLXViewer().

vi_stored

XVisualInfo * G4OpenGLXViewer::vi_stored

protectedinherited

Definition at line 79 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXViewer::G4OpenGLXViewer(), G4OpenGLStoredXmViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

white_str

XmString G4OpenGLXmViewer::white_str

protected

Definition at line 98 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

win

GLXDrawable G4OpenGLXViewer::win

protectedinherited

Definition at line 83 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLStoredXmViewer::FinishView(), G4OpenGLStoredXViewer::FinishView(), G4OpenGLXViewer::SetView(), ~G4OpenGLXmViewer(), and G4OpenGLXViewer::~G4OpenGLXViewer().

windowName

XTextProperty G4OpenGLXViewer::windowName

protectedinherited

Definition at line 100 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow(), and G4OpenGLXViewer::G4OpenGLXViewer().

wireframe_str

XmString G4OpenGLXmViewer::wireframe_str

protected

Definition at line 88 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

wm_hints

XWMHints* G4OpenGLXViewer::wm_hints

protectedinherited

Definition at line 95 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateMainWindow().

wob_high

G4double G4OpenGLXmViewer::wob_high

protected

Definition at line 117 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), and ResetView().

wob_low

G4double G4OpenGLXmViewer::wob_low

protected

Definition at line 118 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), and ResetView().

wob_sens

G4double G4OpenGLXmViewer::wob_sens

protected

Definition at line 119 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), ResetView(), set_wob_sens_callback(), wobble_callback(), and wobble_timer_callback().

wobble_timer

XtIntervalId G4OpenGLXmViewer::wobble_timer

protected

Definition at line 131 of file G4OpenGLXmViewer.hh.

Referenced by wobble_callback(), and wobble_timer_callback().

workId

XtWorkProcId G4OpenGLXmViewer::workId

protected

Definition at line 64 of file G4OpenGLXmViewer.hh.

Xatom

Atom G4OpenGLXViewer::Xatom

protectedinherited

Definition at line 99 of file G4OpenGLXViewer.hh.

xwa

XWindowAttributes G4OpenGLXViewer::xwa

protectedinherited

Definition at line 74 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer::CreateGLXContext(), and G4OpenGLXViewer::G4OpenGLXViewer().

zoom_high

G4double G4OpenGLXmViewer::zoom_high

protected

Definition at line 108 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), reset_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

zoom_low

G4double G4OpenGLXmViewer::zoom_low

protected

Definition at line 109 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback(), reset_callback(), ResetView(), G4OpenGLXmViewerMessenger::SetNewValue(), update_panels_callback(), and UpdateControlPanel().

---

The documentation for this class was generated from the following files:

• source/visualization/OpenGL/include/G4OpenGLXmViewer.hh
• source/visualization/OpenGL/src/G4OpenGLXmConvenienceRoutines.cc
• source/visualization/OpenGL/src/G4OpenGLXmMainMenubarCallbacks.cc
• source/visualization/OpenGL/src/G4OpenGLXmPanningCallbacks.cc
• source/visualization/OpenGL/src/G4OpenGLXmRotationCallbacks.cc
• source/visualization/OpenGL/src/G4OpenGLXmStyleCallbacks.cc
• source/visualization/OpenGL/src/G4OpenGLXmViewer.cc
• source/visualization/OpenGL/src/G4OpenGLXmWindowHandlingCallbacks.cc