G4OpenGLXmViewer Class Reference

#include <G4OpenGLXmViewer.hh>

Inheritance diagram for G4OpenGLXmViewer:

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

Static Public Member Functions
static void	expose_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	resize_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	actions_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	misc_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	Add_set_field (char *widget, char *widget_text, Widget *row_col_box, Widget *wid, G4double *val, G4OpenGLXmViewer *pView)
static void	zoom_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	dolly_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	pan_left_right_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	left_right_pan_callback (XtPointer clientData, XtIntervalId *timer_id)
static void	theta_rotation_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	phi_rotation_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	pan_up_down_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	up_down_pan_callback (XtPointer clientData, XtIntervalId *timer_id)
static void	drawing_style_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	background_color_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_rot_subject_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_rot_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_pan_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	set_wob_sens_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	projection_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	wobble_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	reset_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	update_panels_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	wobble_timer_callback (XtPointer clientData, XtIntervalId *timerid)
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_four_arrow_buttons (G4OpenGLXmViewer *pView, XtCallbackRec **arrow_callbacks, Widget *parent_widget)
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	rotate_in_theta (XtPointer clientData, XtIntervalId *timer_id)
static void	rotate_in_phi (XtPointer clientData, XtIntervalId *timer_id)
static void	get_double_value_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	get_text_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	transparency_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	antialias_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	haloing_callback (Widget w, XtPointer clientData, XtPointer callData)
static void	aux_edge_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	print_callback (Widget w, XtPointer clientData, XtPointer callData)
static G4bool	get_boolean_userData (Widget w)
static G4int	get_int_userData (Widget w)

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

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

Static Protected Attributes
static const G4String	e_str = ""
Static Protected Attributes inherited from G4OpenGLXViewer
static int	snglBuf_RGBA [12]
static int	dblBuf_RGBA [13]
static XVisualInfo *	vi_single_buffer = 0
static XVisualInfo *	vi_double_buffer = 0

Friends
class	G4OpenGLXmVWidgetObject
class	G4OpenGLXmViewerMessenger

Detailed Description

Definition at line 51 of file G4OpenGLXmViewer.hh.

Constructor & Destructor Documentation

G4OpenGLXmViewer()

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;
}

~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;
  }
******************************/
 
}

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;
}

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);
  
}

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*) e_str.c_str());
  // 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;
}  

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];
  snprintf (initial, sizeof 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);
}

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*) e_str.c_str());
  // 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;
 
}

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 ();
}

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 ();
}

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 ();
}

Referenced by CreateMainWindow().

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*)menu_str[0].c_str());
  actions_str = XmStringCreateLocalized ((char*)menu_str[2].c_str());
  misc_str = XmStringCreateLocalized ((char*)menu_str[4].c_str());
  spec_str = XmStringCreateLocalized ((char*)menu_str[6].c_str());
 
  menubar = XmVaCreateSimpleMenuBar (main_win,
                     (char*)menu_str[8].c_str(),
                     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*)menu_str[9].c_str());
  bgnd_str = XmStringCreateLocalized ((char*)menu_str[10].c_str());
 
  style_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)menu_str[1].c_str(),
     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*)menu_str[11].c_str());
  hlr_str = XmStringCreateLocalized ((char*)menu_str[12].c_str());
  hsr_str = XmStringCreateLocalized ((char*)menu_str[13].c_str());
  hlhsr_str = XmStringCreateLocalized ((char*)menu_str[14].c_str());
 
  drawing_style_pullright = XmVaCreateSimplePulldownMenu 
    (style_cascade,
     (char*)menu_str[15].c_str(),
     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*)menu_str[16].c_str());
  black_str = XmStringCreateLocalized ((char*)menu_str[17].c_str());
 
  background_color_pullright = XmVaCreateSimplePulldownMenu 
    (style_cascade,
     (char*)menu_str[18].c_str(),
     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*)menu_str[19].c_str());
  pan_str = XmStringCreateLocalized ((char*)menu_str[20].c_str());
  set_str = XmStringCreateLocalized ((char*)menu_str[21].c_str());
 
  actions_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)menu_str[3].c_str(),
     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*)menu_str[22].c_str());
  exit_str = XmStringCreateLocalized ((char*)menu_str[23].c_str());
  print_str = XmStringCreateLocalized ((char*)menu_str[24].c_str());
 
  //*********Create miscellany pulldown menu on menubar*********
  misc_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)menu_str[5].c_str(),
     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*)menu_str[25].c_str());
  anti_str = XmStringCreateLocalized ((char*)menu_str[27].c_str());
  halo_str = XmStringCreateLocalized ((char*)menu_str[29].c_str());
  aux_edge_str = XmStringCreateLocalized ((char*)menu_str[31].c_str());
 
  //*********Create special pulldown menu on menubar*********
  spec_cascade = XmVaCreateSimplePulldownMenu
    (menubar,
     (char*)menu_str[7].c_str(),
     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*)menu_str[33].c_str());
  on_str = XmStringCreateLocalized ((char*)menu_str[34].c_str());
 
  transparency_pullright = XmVaCreateSimplePulldownMenu 
    (spec_cascade,
     (char*)menu_str[26].c_str(),
     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*)menu_str[28].c_str(),
     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*)menu_str[30].c_str(),
     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*)menu_str[32].c_str(),
     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*)menu_str[35].c_str(),
                   xmFrameWidgetClass, main_win,
                   XtNvisual, vi -> visual, 
                   XtNdepth, vi -> depth, 
                   XtNcolormap, cmap, 
                   XtNborderColor, borcol,
                   XtNbackground, bgnd,
                   NULL);
 
  glxarea = XtVaCreateManagedWidget ((char*)menu_str[36].c_str(), 
                     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);
 
}

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 ();
 
}  

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 ();
}

Referenced by CreateMainWindow().

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
}

Referenced by CreateMainWindow(), and resize_callback().

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);
}

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;
}

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().

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;
  }
}

Referenced by G4OpenGLXmViewer().

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 ();
}

Referenced by CreateMainWindow().

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);
}  

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 ();
 
      }
      
      ///ajw
      break;
    }
  
  default:
    G4Exception
      ("G4OpenGLXmViewer::misc_callback",
       "opengl2002", FatalException,
       "Unrecognised widget child of misc_callback.");
  }
  
  return;
  
}

Referenced by CreateMainWindow().

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);
  }
}

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);
  }
}

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);
  }
}

Referenced by actions_callback().

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();
}

Referenced by misc_callback().

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 ();
}  

Referenced by misc_callback().

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;
  
}

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...  
 
}

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);
}

Referenced by CreateMainWindow().

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);
}

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);
}  

Referenced by rotate_in_theta(), and theta_rotation_callback().

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);
}  

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;
  
}

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;
  
}

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;
}  

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"); 
    }
  }
}  

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;
}  

Referenced by misc_callback().

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 ();
 
}

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);
  }
}

Referenced by actions_callback().

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 ();
}

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);
}  

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);
  }
}

Referenced by actions_callback(), and misc_callback().

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);
}  

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);
  }
}

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 ();
}  

Referenced by actions_callback().

Friends And Related Symbol Documentation

G4OpenGLXmViewerMessenger

friend class G4OpenGLXmViewerMessenger

friend

Definition at line 379 of file G4OpenGLXmViewer.hh.

G4OpenGLXmVWidgetObject

friend class G4OpenGLXmVWidgetObject

friend

Definition at line 378 of file G4OpenGLXmViewer.hh.

Member Data 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().

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().

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_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().

dolly_high

G4double G4OpenGLXmViewer::dolly_high

protected

Definition at line 113 of file G4OpenGLXmViewer.hh.

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

dolly_low

G4double G4OpenGLXmViewer::dolly_low

protected

Definition at line 112 of file G4OpenGLXmViewer.hh.

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

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().

e_str

const G4String G4OpenGLXmViewer::e_str = ""

staticprotected

Definition at line 136 of file G4OpenGLXmViewer.hh.

Referenced by Add_radio_box(), and Add_slider_box().

exit_str

XmString G4OpenGLXmViewer::exit_str

protected

Definition at line 95 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

fov

G4double G4OpenGLXmViewer::fov

protected

Definition at line 114 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback(), and projection_callback().

fpdolly_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpdolly_box

protected

Definition at line 171 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpdolly_lower

G4OpenGLXmTextField* G4OpenGLXmViewer::fpdolly_lower

protected

Definition at line 181 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpdolly_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpdolly_slider

protected

Definition at line 172 of file G4OpenGLXmViewer.hh.

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

fpdolly_upper

G4OpenGLXmTextField* G4OpenGLXmViewer::fpdolly_upper

protected

Definition at line 180 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpfov_text

G4OpenGLXmTextField* G4OpenGLXmViewer::fpfov_text

protected

Definition at line 193 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpmiscellany_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpmiscellany_top

protected

Definition at line 184 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpok_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpok_button

protected

Definition at line 182 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fporthogonal_button

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fporthogonal_button

protected

Definition at line 191 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fppan_set

G4OpenGLXmTextField* G4OpenGLXmViewer::fppan_set

protected

Definition at line 176 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fppanning_arrows

G4OpenGLXmFourArrowButtons* G4OpenGLXmViewer::fppanning_arrows

protected

Definition at line 167 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fppanning_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fppanning_box

protected

Definition at line 166 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fppanning_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fppanning_slider

protected

Definition at line 168 of file G4OpenGLXmViewer.hh.

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

fppanning_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fppanning_top

protected

Definition at line 165 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpperspective_button

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpperspective_button

protected

Definition at line 192 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_box

protected

Definition at line 196 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpprint_button

protected

Definition at line 200 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_col_box

protected

Definition at line 197 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_radio1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_col_radio1

protected

Definition at line 202 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_col_radio2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_col_radio2

protected

Definition at line 203 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_line

G4OpenGLXmSeparator* G4OpenGLXmViewer::fpprint_line

protected

Definition at line 201 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpprint_style_box

protected

Definition at line 198 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_radio1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_style_radio1

protected

Definition at line 204 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_style_radio2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fpprint_style_radio2

protected

Definition at line 205 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_text

G4OpenGLXmTextField* G4OpenGLXmViewer::fpprint_text

protected

Definition at line 199 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpprint_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpprint_top

protected

Definition at line 195 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpproj_style_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpproj_style_box

protected

Definition at line 190 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpreset_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpreset_box

protected

Definition at line 188 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpreset_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpreset_button

protected

Definition at line 189 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fprot_set

G4OpenGLXmTextField* G4OpenGLXmViewer::fprot_set

protected

Definition at line 177 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_arrow

G4OpenGLXmFourArrowButtons* G4OpenGLXmViewer::fprotation_arrow

protected

Definition at line 163 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_arrow_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_arrow_box

protected

Definition at line 162 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button1

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fprotation_button1

protected

Definition at line 158 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button2

G4OpenGLXmRadioButton* G4OpenGLXmViewer::fprotation_button2

protected

Definition at line 159 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_button_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_button_box

protected

Definition at line 157 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fprotation_slider

protected

Definition at line 161 of file G4OpenGLXmViewer.hh.

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

fprotation_slider_box

G4OpenGLXmBox* G4OpenGLXmViewer::fprotation_slider_box

protected

Definition at line 160 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fprotation_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fprotation_top

protected

Definition at line 156 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpsetting_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpsetting_box

protected

Definition at line 175 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpsetting_top

G4OpenGLXmTopLevelShell* G4OpenGLXmViewer::fpsetting_top

protected

Definition at line 174 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpwobble_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpwobble_box

protected

Definition at line 185 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpwobble_button

G4OpenGLXmPushButton* G4OpenGLXmViewer::fpwobble_button

protected

Definition at line 186 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpwobble_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpwobble_slider

protected

Definition at line 187 of file G4OpenGLXmViewer.hh.

Referenced by misc_callback().

fpzoom_box

G4OpenGLXmFramedBox* G4OpenGLXmViewer::fpzoom_box

protected

Definition at line 169 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpzoom_lower

G4OpenGLXmTextField* G4OpenGLXmViewer::fpzoom_lower

protected

Definition at line 179 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

fpzoom_slider

G4OpenGLXmSliderBar* G4OpenGLXmViewer::fpzoom_slider

protected

Definition at line 170 of file G4OpenGLXmViewer.hh.

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

fpzoom_upper

G4OpenGLXmTextField* G4OpenGLXmViewer::fpzoom_upper

protected

Definition at line 178 of file G4OpenGLXmViewer.hh.

Referenced by actions_callback().

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().

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_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().

main_win

Widget G4OpenGLXmViewer::main_win

protected

Definition at line 67 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

menu_str

G4String G4OpenGLXmViewer::menu_str[37]

protected

Initial value:

= { "Style", "style",
                            "Actions", "actions",
                            "Miscellany", "miscellany",
                            "Special", "special",
                            "menubar", "Drawing",
                            "Background color", "Wireframe",
                            "Hidden line removal", "Hidden surface removal",
                            "Hidden line and surface removal", "drawing_style",
                            "White", "Black",
                            "background_color", "Rotation control panel",
                            "Panning control panel", "Set control panel limits",
                            "Miscellany control panel",
                            "Exit to G4Vis>", "Create .eps file",
                            "Transparency", "transparency",
                            "Antialiasing", "antialias",
                            "Haloing", "haloing",
                            "Auxiliary edges", "aux_edge",
                            "Off", "On", "frame", "glxarea" }

Definition at line 137 of file G4OpenGLXmViewer.hh.

                          { "Style", "style",
                            "Actions", "actions",
                            "Miscellany", "miscellany",
                            "Special", "special",
                            "menubar", "Drawing",
                            "Background color", "Wireframe",
                            "Hidden line removal", "Hidden surface removal",
                            "Hidden line and surface removal", "drawing_style",
                            "White", "Black",
                            "background_color", "Rotation control panel",
                            "Panning control panel", "Set control panel limits",
                            "Miscellany control panel",
                            "Exit to G4Vis>", "Create .eps file",
                            "Transparency", "transparency",
                            "Antialiasing", "antialias",
                            "Haloing", "haloing",
                            "Auxiliary edges", "aux_edge",
                            "Off", "On", "frame", "glxarea" };

Referenced by CreateMainWindow().

menubar

Widget G4OpenGLXmViewer::menubar

protected

Definition at line 68 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

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().

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(), and update_panels_callback().

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(), and update_panels_callback().

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().

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().

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_pullright

Widget G4OpenGLXmViewer::transparency_pullright

protected

Definition at line 75 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

white_str

XmString G4OpenGLXmViewer::white_str

protected

Definition at line 98 of file G4OpenGLXmViewer.hh.

Referenced by CreateMainWindow().

wireframe_str

XmString G4OpenGLXmViewer::wireframe_str

protected

Definition at line 88 of file G4OpenGLXmViewer.hh.

Referenced by 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.

zoom_high

G4double G4OpenGLXmViewer::zoom_high

protected

Definition at line 108 of file G4OpenGLXmViewer.hh.

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

zoom_low

G4double G4OpenGLXmViewer::zoom_low

protected

Definition at line 109 of file G4OpenGLXmViewer.hh.

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

---

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

• G4OpenGLXmViewer.hh
• G4OpenGLXmConvenienceRoutines.cc
• G4OpenGLXmMainMenubarCallbacks.cc
• G4OpenGLXmPanningCallbacks.cc
• G4OpenGLXmRotationCallbacks.cc
• G4OpenGLXmStyleCallbacks.cc
• G4OpenGLXmViewer.cc
• G4OpenGLXmWindowHandlingCallbacks.cc