#include <Inventor/SbLinear.h>
#include <Inventor/Xt/viewers/SoXtFullViewer.h>

class simpleViewer : public SoXtFullViewer {
 public:
   // Constructor/destructor
   simpleViewer(
      Widget parent = NULL,
      const char *name = NULL, 
      SbBool buildInsideParent = TRUE, 
      SoXtFullViewer::BuildFlag flag = BUILD_ALL, 
      SoXtViewer::Type type = BROWSER);
   ~simpleViewer();
   
   // Redefine this to also change the cursor (viewerCursor)
   virtual void        setViewing(SbBool onOrOff);
   
 protected:
   // Redefine this to process the events
   virtual void        processEvent(XAnyEvent *anyevent);
   
   // Redefine this to also change the cursor (seekCursor)
   virtual void        setSeekMode(SbBool onOrOff);
   
   // Define these thumbwheels to translate in the viewer plane
   virtual void        bottomWheelMotion(float newVal);
   virtual void        leftWheelMotion(float newVal);
   virtual void        rightWheelMotion(float newVal);
   virtual void        bottomWheelStart();
   virtual void        leftWheelStart();
   
   // Redefine this to customize the preference sheet
   virtual void        createPrefSheet();
   
   // Define this to bring up the viewer help card
   virtual void        openViewerHelpCard();
   
 private:
   // Viewer state variables
   int             mode;
   SbBool          createdCursors;
   Cursor          vwrCursor, seekCursor;
   SbVec2s         locator; // mouse position
   
   // Camera translation variables
   SbVec3f         locator3D;
   SbPlane         focalplane;
   float           transXspeed, transYspeed;
   
   void            switchMode(int newMode);
   void            defineCursors();
   void            translateCamera();
   void            computeTranslateValues();
};

#include <math.h>

#include <X11/Intrinsic.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>

#include <Inventor/nodes/SoOrthographicCamera.h>
#include <Inventor/nodes/SoPerspectiveCamera.h>
#include <Inventor/Xt/SoXtCursors.h>
#include "simpleViewer.h"

enum ViewerModes {
   IDLE_MODE, 
   TRANS_MODE, 
   SEEK_MODE, 
};

// Constructor for the viewer
simpleViewer::simpleViewer(
   Widget parent,
   const char *name, 
   SbBool buildInsideParent, 
   SoXtFullViewer::BuildFlag b, 
   SoXtViewer::Type t)
      : SoXtFullViewer(
         parent,
         name, 
         buildInsideParent, 
         b, 
         t, 
         TRUE) // Tell base class to build (since we don't add
               // anything)
{
   // Init local vars
   mode = IDLE_MODE;
   createdCursors = FALSE;
   setSize(SbVec2s(520, 360)); //def size
   
   // assign decoration titles
   setPopupMenuString("Simple Viewer");
   setBottomWheelString("transX");
   setLeftWheelString("transY");
   setRightWheelString("Dolly");
   setPrefSheetString("Simple Viewer Preference Sheet");
   setTitle("Simple Viewer");
}

simpleViewer::~simpleViewer()
{
}

// Call the base class and set the correct cursor 
// on the window
void
simpleViewer::setViewing(SbBool flag)
{
   if (flag == viewingFlag || camera == NULL) {
      viewingFlag = flag;
      return;
   }
   
   // Call the base class
   SoXtFullViewer::setViewing(flag);
   
   // Set the right cursor
   Widget w = getRenderAreaWidget();
   if (w != NULL && XtWindow(w) != NULL) {
      if (isViewing()) {
         if (! createdCursors)
            defineCursors();
         XDefineCursor(XtDisplay(w), XtWindow(w), vwrCursor);
      }
      else
         XUndefineCursor(XtDisplay(w), XtWindow(w));
   }
}

// Process the given event to change the camera
void
simpleViewer::processEvent(XAnyEvent *xe)
{
   // Let the base class handle the common set of events
   if (processCommonEvents(xe))
      return;
   
   // Check if cursors need to be defined (they can only
   // be defined after the window has been mapped. 
   // Receiving events guarantees that the window has 
   // been mapped.
   if (! createdCursors) {
      defineCursors();
      Widget w = getRenderAreaWidget();
      XDefineCursor(XtDisplay(w), XtWindow(w), vwrCursor);
   }
   
   XButtonEvent    *be;
   XMotionEvent    *me;
   SbVec2s windowSize = getGlxSize();
   
   switch (xe->type) {
      case ButtonPress:
         be = (XButtonEvent *) xe;
         locator[0] = be->x;
         locator[1] = windowSize[1] - be->y;
         if (be->button == Button1) {
            switch (mode) {
               case IDLE_MODE: 
                  interactiveCountInc();
                  switchMode(TRANS_MODE);
                  break;
               case SEEK_MODE:
                  seekToPoint(locator);
                  break;
            }
         }
         break;
         
      case ButtonRelease:
         be = (XButtonEvent *) xe;
         if (be->button == Button1 && mode == TRANS_MODE) {
            switchMode(IDLE_MODE);
            interactiveCountDec();
         }
         break;
         
      case MotionNotify:
         me = (XMotionEvent *) xe;
         locator[0] = me->x;
         locator[1] = windowSize[1] - me->y;
         if (mode == TRANS_MODE)
            translateCamera();
         break;
   }
}

// Switches to the specified viewer mode. The correct
// cursor is also set on the window.
void
simpleViewer::switchMode(int newMode)
{
   // needed to define new cursors
   Widget w = getRenderAreaWidget();
   Display *display = XtDisplay(w);
   Window window = XtWindow(w);
   if (! createdCursors)
      defineCursors();
   
   // Switch to new viewer mode
   mode = newMode;
   switch (mode) {
      case IDLE_MODE:
         if (window != 0)
            XDefineCursor(display, window, vwrCursor);
         break;
         
      case TRANS_MODE:
         {
            // Figure out the focal plane
            SbMatrix mx;
            mx = camera->orientation.getValue();
            SbVec3f forward(-mx[2][0], -mx[2][1], -mx[2][2]);
            SbVec3f fp = camera->position.getValue() + 
               forward * camera->focalDistance.getValue();
            focalplane = SbPlane(forward, fp);
            
            // Map mouse position onto the viewing plane
            SbVec2s windowSize = getGlxSize();
            SbLine line;
            SbViewVolume cameraVolume = camera->getViewVolume();
            cameraVolume.projectPointToLine(
                  SbVec2f( locator[0] / float(windowSize[0]), 
                  locator[1] / float(windowSize[1])), line);
            focalplane.intersect(line, locator3D);
         }
         if (window != 0)
            XDefineCursor(display, window, vwrCursor);
         break;
      
      case SEEK_MODE:
         if (window != 0)
            XDefineCursor(display, window, seekCursor);
         break;
   }
}

// Call the base class and set the correct cursor 
// on the window.
void
simpleViewer::setSeekMode(SbBool flag)
{
   if (! isViewing())
      return;
   
   // Call the base class
   SoXtFullViewer::setSeekMode(flag);
   
   // Switch to the right mode
   switchMode(isSeekMode() ? SEEK_MODE : IDLE_MODE);
}

// Redefine this routine to customize the preference sheet
void
simpleViewer::createPrefSheet()
{
   // Create the preference sheet shell and form widget
   Widget shell, form;
   createPrefSheetShellAndForm(shell, form);
   
   // Create most of the default parts
   Widget widgetList[10];
   int num = 0;
   widgetList[num++] = createSeekPrefSheetGuts(form);
   widgetList[num++] = createZoomPrefSheetGuts(form);
   widgetList[num++] = createClippingPrefSheetGuts(form);
   
   layoutPartsAndMapPrefSheet(widgetList, num, form, shell);
}

// Bring up the viewer help card (called by "?" push button)
void
simpleViewer::openViewerHelpCard()
{
   // Tell the component to open the file for us
   openHelpCard("simpleViewer.help");
}

// Translate the camera right/left (called by thumbwheel).
void
simpleViewer::bottomWheelMotion(float newVal)
{
   if (camera == NULL)
      return;
   
   // Get camera right vector and translate by wheel 
   // delta rotation
   SbMatrix mx;
   mx = camera->orientation.getValue();
   SbVec3f rightVector(mx[0][0], mx[0][1], mx[0][2]);
   float dist = transXspeed * (bottomWheelVal - newVal);
   camera->position = camera->position.getValue() + 
      dist * rightVector;
   
   bottomWheelVal = newVal;
}

// Translate the camera up/down (called by thumbwheel).
void
simpleViewer::leftWheelMotion(float newVal)
{
   if (camera == NULL)
      return;
   
   // Get camera up vector and translate by wheel 
   // delta rotation
   SbMatrix mx;
   mx = camera->orientation.getValue();
   SbVec3f upVector(mx[1][0], mx[1][1], mx[1][2]);
   float dist = transYspeed * (leftWheelVal - newVal);
   camera->position = camera->position.getValue() + 
      dist * upVector;
   
   leftWheelVal = newVal;
}

// Moves the camera closer/further away from the plane 
// of interest, which is defined by the viewing normal 
// and the camera focalDistance field value.
void
simpleViewer::rightWheelMotion(float newVal)
{
   if (camera == NULL)
      return;
   
   // Shorten/grow the focal distance given the wheel rotation
   float focalDistance = camera->focalDistance.getValue();
   float newFocalDist = focalDistance / 
                     pow(2.0, newVal - rightWheelVal);
   
   // Finally, reposition the camera
   SbMatrix mx;
   mx = camera->orientation.getValue();
   SbVec3f forward(-mx[2][0], -mx[2][1], -mx[2][2]);
   camera->position = camera->position.getValue() + 
                  (focalDistance - newFocalDist) * forward;
   camera->focalDistance = newFocalDist;
   
   rightWheelVal = newVal;
}

// This routine is used to define cursors, which can 
// only be called after the window has been realized.
void
simpleViewer::defineCursors()
{
   XColor foreground;
   Pixmap source;
   Display *display = getDisplay();
   Drawable d = DefaultRootWindow(display);
   
   // Set a red color
   foreground.red = 65535;
   foreground.green = foreground.blue = 0;
   
   // View plane translate cursor
   source = XCreateBitmapFromData(display, d, 
            so_xt_flat_hand_bits, so_xt_flat_hand_width,
            so_xt_flat_hand_height);
   vwrCursor = XCreatePixmapCursor(display, source, source, 
               &foreground, &foreground, so_xt_flat_hand_x_hot, 
               so_xt_flat_hand_y_hot);
   XFreePixmap(display, source);
   
   // Seek cursor
   source = XCreateBitmapFromData(display, d,
            so_xt_target_bits, so_xt_target_width,
            so_xt_target_height);
   seekCursor = XCreatePixmapCursor(display, source, source, 
                &foreground, &foreground, so_xt_target_x_hot,
                so_xt_target_y_hot);
   XFreePixmap(display, source);
   
   createdCursors = TRUE;
}

// Moves the camera into the plane defined by the camera 
// forward vector and the focal point (using the camera
// focalDistance field) to follow the new mouse location.
void
simpleViewer::translateCamera()
{
   if (camera == NULL)
      return;
   
   SbVec2s windowSize = getGlxSize();
   SbVec2f newLocator(locator[0] / float(windowSize[0]), 
      locator[1] / float(windowSize[1]));
   
   // Map new mouse location into the camera focal plane
   SbLine          line;
   SbVec3f         newLocator3D;
   SbViewVolume cameraVolume = camera->getViewVolume();
   cameraVolume.projectPointToLine(newLocator, line);
   focalplane.intersect(line, newLocator3D);
   
   // Move the camera by the delta 3D position amount
   camera->position = camera->position.getValue() + 
      (locator3D - newLocator3D);
   
   // You would think we would have to set locator3D to
   // newLocator3D here.  But we don't, because moving 
   // the camera essentially makes locator3D equal to 
   // newLocator3D in the transformed space, and we will 
   // project the next newLocator3D in this transformed space.
}

// Called by the bottom and left thumbwheels to compute 
// the translation factors (how fast should we translate 
// given a wheel rotation).
void
simpleViewer::computeTranslateValues()
{
   if (camera == NULL)
      return;
   
   float height;
   
   if (camera->isOfType( 
      SoPerspectiveCamera::getClassTypeId())) {
      float angle = ((SoPerspectiveCamera *) 
                    camera)->heightAngle.getValue() / 2;
      float dist = camera->focalDistance.getValue();
      height = dist * ftan(angle);
   }
   else if (camera->isOfType( 
      SoOrthographicCamera::getClassTypeId()))
      height = ((SoOrthographicCamera *) 
               camera)->height.getValue() / 2;
   
   // Given the size of the viewing plane, figure out 
   // the up/down and right/left speeds for the thumb wheels.
   transYspeed = height / 2;
   transXspeed = transYspeed * camera->aspectRatio.getValue();
}

// Thumbwheels start callbacks
void
simpleViewer::bottomWheelStart()
{
   computeTranslateValues();
   
   // call parent class
   SoXtFullViewer::bottomWheelStart();
}

void
simpleViewer::leftWheelStart()
{
   computeTranslateValues();
   
   // call parent class
   SoXtFullViewer::leftWheelStart();
}

// Build the render area and the decoration trim within the
// given parent widget.
Widget
SoXtFullViewer::buildWidget(Widget parent)
{
   // Create a form to hold everything together
   mgrWidget = XtCreateWidget(getWidgetName(),
                              xmFormWidgetClass, parent, 
                              args, n);
    
   // Build the render area and the decoration
   raWidget = SoXtRenderArea::buildWidget(mgrWidget);
   if (decorationFlag)
      	buildDecoration(mgrWidget);
    
   // Lay out and manage the render area and decoration
   ...
    
   return mgrWidget;
}

// Build the viewer decoration (left, right and bottom trim)
void
SoXtFullViewer::buildDecoration(Widget parent)
{
   // Build the trim sides
   leftTrimForm = buildLeftTrim(parent);
   bottomTrimForm = buildBottomTrim(parent);
   rightTrimForm = buildRightTrim(parent);
    
   // Lay out the trims but let the buildWidget() manage them
   ...
}

// Build the left trim decoration
Widget
SoXtFullViewer::buildLeftTrim(Widget parent)
{
   // Create a form to hold all the parts
   Widget form = XtCreateWidget("LeftTrimForm",
                                 xmFormWidgetClass, parent,
                                 NULL, 0);
    
   // Create all the parts
   buildLeftWheel(form);
   Widget butForm = buildAppButtons(form);
   
   // Lay out and manage the parts
   ...
    
   return form;
}