//============================================================================
//
// KRotation screen saver for TDE
//
// The screen saver displays a physically realistic simulation of a force free
// rotating asymmetric body.  The equations of motion for such a rotation, the
// Euler equations, are integrated numerically by the Runge-Kutta method.
//
// Developed by Georg Drenkhahn, georg-d@users.sourceforge.net
//
// $Id$
//
/*
 * Copyright (C) 2004 Georg Drenkhahn
 *
 * KRotation is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 2 as published by the
 * Free Software Foundation.
 *
 * KRotation is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02110-1301 USA
 */
//============================================================================

// std. C++ headers
#include <cstdlib>
// STL
#include <deque>
// TQt headers
#include <tqcheckbox.h>
#include <tqlineedit.h>
#include <tqvalidator.h>
#include <tqtooltip.h>
// TDE headers
#include <tdelocale.h>
#include <tdeconfig.h>
#include <kdebug.h>
#include <tdemessagebox.h>

#include "sspreviewarea.h"

// rotation.moc includes rotation.h
#include "rotation.moc"

/** Version number of this screen saver */
#define KROTATION_VERSION "1.1"

// libtdescreensaver interface
extern "C"
{
   /** application name for the libtdescreensaver interface */
   KDE_EXPORT const char *kss_applicationName = "krotation.kss";
   /** application description for the libtdescreensaver interface */
   KDE_EXPORT const char *kss_description =
   I18N_NOOP("Simulation of a force free rotating asymmetric body");
   /** application version for the libtdescreensaver interface */
   KDE_EXPORT const char *kss_version = KROTATION_VERSION;

   /** function to create screen saver object */
   KDE_EXPORT  KScreenSaver* kss_create(WId id)
   {
      return new KRotationSaver(id);
   }

   /** function to create setup dialog for screen saver */
   KDE_EXPORT TQDialog* kss_setup()
   {
      return new KRotationSetup();
   }
}

//-----------------------------------------------------------------------------
// EulerOdeSolver implementation
//-----------------------------------------------------------------------------

EulerOdeSolver::EulerOdeSolver(
   const double &t_,
   const double &dt_,
   const double &A_,
   const double &B_,
   const double &C_,
   std::valarray<double> &y_,
   const double &eps_)
   : RkOdeSolver<double>(t_,y_,dt_,eps_),
     A(A_), B(B_), C(C_)
{
}

std::valarray<double> EulerOdeSolver::f(
   const double &x,
   const std::valarray<double> &y) const
{
   // unused
   (void)x;

   // vec omega in body coor. sys.: omega_body = (p, q, r)
   const vec3<double> omega_body(y[std::slice(0,3,1)]);
   // body unit vectors in fixed frame coordinates
   const vec3<double> e1(y[std::slice(3,3,1)]);
   const vec3<double> e2(y[std::slice(6,3,1)]);
   const vec3<double> e3(y[std::slice(9,3,1)]);

   // don't use "const vec3<double>&" here because slice_array must be
   // value-copied to vec3<double>.

   // vec omega in global fixed coor. sys.
   vec3<double> omega(
      omega_body[0] * e1
      + omega_body[1] * e2
      + omega_body[2] * e3);

   // return vector y'
   std::valarray<double> ypr(y.size());

   // omega_body'
   ypr[0] = -(C-B)/A * omega_body[1] * omega_body[2]; // p'
   ypr[1] = -(A-C)/B * omega_body[2] * omega_body[0]; // q'
   ypr[2] = -(B-A)/C * omega_body[0] * omega_body[1]; // r'

   // e1', e2', e3'
   ypr[std::slice(3,3,1)] = std::valarray<double>(vec3<double>::crossprod(omega, e1));
   ypr[std::slice(6,3,1)] = std::valarray<double>(vec3<double>::crossprod(omega, e2));
   ypr[std::slice(9,3,1)] = std::valarray<double>(vec3<double>::crossprod(omega, e3));

   return ypr;
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Rotation: screen saver widget
//-----------------------------------------------------------------------------

RotationGLWidget::RotationGLWidget(
   TQWidget* parent, const char* name,
   const vec3<double>& _omega,
   const std::deque<vec3<double> >& e1_,
   const std::deque<vec3<double> >& e2_,
   const std::deque<vec3<double> >& e3_,
   const vec3<double>& J)
   : TQGLWidget(parent, name),
     eyeR(25), eyeTheta(1), eyePhi(M_PI*0.25),
     boxSize(1,1,1),
     fixedAxses(0),
     bodyAxses(0),
     lightR(10), lightTheta(M_PI/4), lightPhi(0),
     bodyAxsesLength(6),
     fixedAxsesLength(8),
     omega(_omega),
     e1(e1_),
     e2(e2_),
     e3(e3_)
{
   // set up initial rotation matrix as unit matrix, only non-constant elements
   // are set later on
   for (int i=0; i<16; i++)
      rotmat[i] = ((i%5)==0) ? 1:0;

   // Set the box sizes from the momenta of inertia.  J is the 3 vector with
   // momenta of inertia with respect to the 3 figure axes.

   // the default values must be valid so that w,h,d are real!
   GLfloat
      x2 = 6.0*(-J[0] + J[1] + J[2]),
      y2 = 6.0*( J[0] - J[1] + J[2]),
      z2 = 6.0*( J[0] + J[1] - J[2]);

   if (x2>=0 && y2>=0 && z2>=0)
   {
      boxSize = vec3<double>(sqrt(x2), sqrt(y2), sqrt(z2));
   }
   else
   {
      kdDebug() << "parameter error" << endl;
      boxSize = vec3<double>(1, 1, 1);
   }
}

/* --------- protected methods ----------- */

void RotationGLWidget::initializeGL(void)
{
   qglClearColor(TQColor(black)); // set color to clear the background

   glClearDepth(1);             // depth buffer setup
   glEnable(GL_DEPTH_TEST);     // depth testing
   glDepthFunc(GL_LEQUAL);      // type of depth test

   glShadeModel(GL_SMOOTH);     // smooth color shading in poygons

   // nice perspective calculation
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

   // set up the light
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   // set positon of light0
   GLfloat lightPos[4]=
      {lightR * sin(lightTheta) * sin(lightPhi),
       lightR * sin(lightTheta) * cos(lightPhi),
       lightR * cos(lightTheta), 1.};
   glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

   // enable setting the material colour by glColor()
   glEnable(GL_COLOR_MATERIAL);

   // set up display lists

   if (fixedAxses == 0)
      fixedAxses = glGenLists(1); // list to be returned
   glNewList(fixedAxses, GL_COMPILE);

   // fixed coordinate system axes

   glPushMatrix();
   glLoadIdentity();

   // z-axis, blue
   qglColor(TQColor(blue));
   myGlArrow(fixedAxsesLength, 0.5f, 0.03f, 0.1f);

   // x-axis, red
   qglColor(TQColor(red));
   glRotatef(90, 0, 1, 0);

   myGlArrow(fixedAxsesLength, 0.5f, 0.03f, 0.1f);

   // y-axis, green
   qglColor(TQColor(green));
   glLoadIdentity();
   glRotatef(-90, 1, 0, 0);
   myGlArrow(fixedAxsesLength, 0.5f, 0.03f, 0.1f);

   glPopMatrix();
   glEndList();
   // end of axes object list


   // box and box-axses
   if (bodyAxses == 0)
      bodyAxses = glGenLists(1); // list to be returned
   glNewList(bodyAxses, GL_COMPILE);

   // z-axis, blue
   qglColor(TQColor(blue));
   myGlArrow(bodyAxsesLength, 0.5f, 0.03f, 0.1f);

   // x-axis, red
   qglColor(TQColor(red));
   glPushMatrix();
   glRotatef(90, 0, 1, 0);
   myGlArrow(bodyAxsesLength, 0.5f, 0.03f, 0.1f);
   glPopMatrix();

   // y-axis, green
   qglColor(TQColor(green));
   glPushMatrix();
   glRotatef(-90, 1, 0, 0);
   myGlArrow(bodyAxsesLength, 0.5f, 0.03f, 0.1f);
   glPopMatrix();

   glEndList();
}

void RotationGLWidget::draw_traces(void)
{
   if (e1.size()==0 && e2.size()==0 && e3.size()==0)
      return;

   glPushMatrix();
   glScalef(bodyAxsesLength, bodyAxsesLength, bodyAxsesLength);

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   for (int j=0; j<3; ++j)
   {
      const std::deque<vec3<double> >& e =
         j==0 ? e1 : j==1 ? e2 : e3;

      // trace must contain at least 2 elements
      if (e.size() > 1)
      {
         // emission colour
         GLfloat em[4] = {0,0,0,1};
         em[j] = 1; // set either red, green, blue emission colour

         glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, em);
         glColor4fv(em);

         // set iterator of the tail part
         std::deque<vec3<double> >::const_iterator eit  = e.begin();
         std::deque<vec3<double> >::const_iterator tail =
            e.begin() +
            static_cast<std::deque<vec3<double> >::difference_type>
            (0.9*e.size());

         glBegin(GL_LINES);
         for (; eit < e.end()-1; ++eit)
         {
            glVertex3f((*eit)[0], (*eit)[1], (*eit)[2]);
            // decrease transparency for tail section
            if (eit > tail)
               em[3] =
                  static_cast<GLfloat>
                  (1.0 - double(eit-tail)/(0.1*e.size()));
            glColor4fv(em);
            glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, em);
            glVertex3f((*(eit+1))[0], (*(eit+1))[1], (*(eit+1))[2]);
         }
         glEnd();
      }
   }

   glDisable(GL_BLEND);

   glPopMatrix();
}

void RotationGLWidget::paintGL(void)
{
   // clear color and depth buffer
   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

   glMatrixMode(GL_MODELVIEW);           // select modelview matrix

   glLoadIdentity();
   GLfloat const em[] = {0,0,0,1};
   glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, em);

   // omega vector
   vec3<double> rotvec =
      vec3<double>::crossprod(vec3<double>(0,0,1), omega).normalize();
   GLfloat rotdeg =
      180./M_PI * vec3<double>::angle(vec3<double>(0,0,1), omega);
   glPushMatrix();
   glRotatef(rotdeg, rotvec[0], rotvec[1], rotvec[2]);
   qglColor(TQColor(white));
   myGlArrow(7, .5f, .1f, 0.2f);
   glPopMatrix();

   // fixed axes
   glCallList(fixedAxses);

   glPushMatrix();

   // set up variable part of rotation matrix for body
   // set gl body rotation matrix from e1,e2,e3
   const vec3<double>& e1b = e1.front();
   const vec3<double>& e2b = e2.front();
   const vec3<double>& e3b = e3.front();

   rotmat[0]  = e1b[0];
   rotmat[1]  = e1b[1];
   rotmat[2]  = e1b[2];
   rotmat[4]  = e2b[0];
   rotmat[5]  = e2b[1];
   rotmat[6]  = e2b[2];
   rotmat[8]  = e3b[0];
   rotmat[9]  = e3b[1];
   rotmat[10] = e3b[2];

   glMultMatrixf(rotmat);

   glCallList(bodyAxses);

   glScalef(boxSize[0]/2, boxSize[1]/2, boxSize[2]/2);

   // paint box
   glBegin(GL_QUADS);
   // front (z)
   qglColor(TQColor(blue));
   glNormal3f( 0,0,1);
   glVertex3f( 1,  1,  1);
   glVertex3f(-1,  1,  1);
   glVertex3f(-1, -1,  1);
   glVertex3f( 1, -1,  1);
   // back (-z)
   glNormal3f( 0,0,-1);
   glVertex3f( 1,  1, -1);
   glVertex3f(-1,  1, -1);
   glVertex3f(-1, -1, -1);
   glVertex3f( 1, -1, -1);
   // top (y)
   qglColor(TQColor(green));
   glNormal3f( 0,1,0);
   glVertex3f( 1,  1,  1);
   glVertex3f( 1,  1, -1);
   glVertex3f(-1,  1, -1);
   glVertex3f(-1,  1,  1);
   // bottom (-y)
   glNormal3f( 0,-1,0);
   glVertex3f( 1, -1,  1);

   glVertex3f( 1, -1, -1);
   glVertex3f(-1, -1, -1);
   glVertex3f(-1, -1,  1);
   // left (-x)
   qglColor(TQColor(red));
   glNormal3f( -1,0,0);
   glVertex3f(-1,  1,  1);
   glVertex3f(-1,  1, -1);
   glVertex3f(-1, -1, -1);
   glVertex3f(-1, -1,  1);
   // right (x)
   glNormal3f( 1,0,0);
   glVertex3f( 1,  1,  1);
   glVertex3f( 1,  1, -1);
   glVertex3f( 1, -1, -1);
   glVertex3f( 1, -1,  1);
   glEnd();

   // traces
   glPopMatrix();
   draw_traces ();

   glFlush();
}

void RotationGLWidget::resizeGL(int w, int h)
{
   // Prevent a divide by zero
   if (h == 0) h = 1;

   // set the new view port
   glViewport(0, 0, (GLint)w, (GLint)h);

   // set up projection matrix
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   // Perspective view
   gluPerspective(40.0f, (GLdouble)w/(GLdouble)h, 1.0, 100.0f);

   // Viewing transformation, position for better view
   // Theta is polar angle 0<Theta<Pi
   gluLookAt(
      eyeR * sin(eyeTheta) * sin(eyePhi),
      eyeR * sin(eyeTheta) * cos(eyePhi),
      eyeR * cos(eyeTheta),
      0,0,0,
      0,0,1);
}

/* --------- privat methods ----------- */

void RotationGLWidget::myGlArrow(
   GLfloat total_length, GLfloat head_length,
   GLfloat base_width,   GLfloat head_width)
{
   GLUquadricObj* quadAx = gluNewQuadric();
   glPushMatrix();
   gluCylinder(quadAx, base_width, base_width,
               total_length-head_length, 10, 1);
   glTranslatef(0, 0, total_length-head_length);
   gluCylinder(quadAx, head_width, 0, head_length, 10, 1);
   glPopMatrix();
   gluDeleteQuadric(quadAx);
}


//-----------------------------------------------------------------------------
// KRotationSaver: screen saver class
//-----------------------------------------------------------------------------

KRotationSaver::KRotationSaver(WId id)
   : KScreenSaver(id),
     J(4,2,3),                  // fixed box sizes!
     initEulerPhi(0),
     initEulerPsi(0),
     solver(0),
     glArea(0),
     timer(0),
     m_traceLengthSeconds(traceLengthSecondsDefault),
     m_Lz(LzDefault),
     m_initEulerTheta(initEulerThetaDefault)
{
   readSettings();              // read global settings
   initData();                  // init e1,e2,e3,omega,solver

   setEraseColor(black);
   erase();                     // erase area
   glArea = new RotationGLWidget(
      this, 0, omega, e1, e2, e3, J); // create gl widget
   embed(glArea);               // embed gl widget and resize it
   glArea->show();              // show gl widget

   timer = new TQTimer(this);
   timer->start(deltaT, TRUE);
   connect(timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(doTimeStep()));
}

KRotationSaver::~KRotationSaver()
{
   // time, rotation are automatically deleted with parent KRotationSaver
   delete solver;
}

void KRotationSaver::initData()
{
   // reset coordiante system
   vec3<double> e1t(1,0,0), e2t(0,1,0), e3t(0,0,1);
   // rotation by phi around z = zhat axis
   e1t.rotate(initEulerPhi*e3t);
   e2t.rotate(initEulerPhi*e3t);
   // rotation by theta around new x axis
   e2t.rotate(m_initEulerTheta*e1t);
   e3t.rotate(m_initEulerTheta*e1t);
   // rotation by psi around new z axis
   e1t.rotate(initEulerPsi*e3t);
   e2t.rotate(initEulerPsi*e3t);
   // set first vector in deque
   e1.clear(); e1.push_front(e1t);
   e2.clear(); e2.push_front(e2t);
   e3.clear(); e3.push_front(e3t);

   // calc L in body frame: 1. determine z-axis of fixed frame in body
   // coordinates, undo the transformations for unit z vector of the body frame

   // calc omega_body from ...
   vec3<double> e1_body(1,0,0), e3_body(0,0,1);
   // rotation by -psi along z axis
   e1_body.rotate(-initEulerPsi*e3_body);
   // rotation by -theta along new x axis
   e3_body.rotate(-m_initEulerTheta*e1_body);
   // omega_body = L_body * J_body^(-1)
   vec3<double> omega_body = e3_body * m_Lz;
   std::valarray<double> &omega_body_ = omega_body;
   std::valarray<double> &J_ = J;
   omega_body_ /= J_;

   // assemble initial y for solver
   std::valarray<double> y(12);
   y[std::slice(0,3,1)] = std::valarray<double>(omega_body);
   // 3 basis vectors of body system in fixed coordinates
   y[std::slice(3,3,1)] = std::valarray<double>(e1t);
   y[std::slice(6,3,1)] = std::valarray<double>(e2t);
   y[std::slice(9,3,1)] = std::valarray<double>(e3t);

   // initial rotation vector
   omega
      = omega_body[0]*e1t
      + omega_body[1]*e2t
      + omega_body[2]*e3t;

   if (solver!=0) delete solver;
   // init solver
   solver = new EulerOdeSolver(
      0.0,      // t
      0.01,     // first dt step size estimation
      J[0], J[1], J[2], // A,B,C
      y,        // omega_body,e1,e2,e3
      1e-5);    // eps
}

void KRotationSaver::readSettings()
{
   // read configuration settings from config file
   TDEConfig *config = TDEGlobal::config();
   config->setGroup("Settings");

   // internal saver parameters are set to stored values or left at their
   // default values if stored values are out of range
   setTraceFlag(0, config->readBoolEntry("x trace", traceFlagDefault[0]));
   setTraceFlag(1, config->readBoolEntry("y trace", traceFlagDefault[1]));
   setTraceFlag(2, config->readBoolEntry("z trace", traceFlagDefault[2]));
   setRandomTraces(config->readBoolEntry("random traces", randomTracesDefault));
   setTraceLengthSeconds(
      config->readDoubleNumEntry("length", traceLengthSecondsDefault));
   setLz(
      config->readDoubleNumEntry("Lz",     LzDefault));
   setInitEulerTheta(
      config->readDoubleNumEntry("theta",  initEulerThetaDefault));
}

void KRotationSaver::setTraceLengthSeconds(const double& t)
{
   if (t >= traceLengthSecondsLimitLower
       && t <= traceLengthSecondsLimitUpper)
   {
      m_traceLengthSeconds = t;
   }
}

const double KRotationSaver::traceLengthSecondsLimitLower = 0.0;
const double KRotationSaver::traceLengthSecondsLimitUpper = 99.0;
const double KRotationSaver::traceLengthSecondsDefault = 3.0;

const bool KRotationSaver::traceFlagDefault[3] = {false, false, true};

void KRotationSaver::setLz(const double& Lz)
{
   if (Lz >= LzLimitLower && Lz <= LzLimitUpper)
   {
      m_Lz = Lz;
   }
}

const double KRotationSaver::LzLimitLower =   0.0;
const double KRotationSaver::LzLimitUpper = 500.0;
const double KRotationSaver::LzDefault    =  10.0;

void KRotationSaver::setInitEulerTheta(const double& theta)
{
   if (theta >= initEulerThetaLimitLower
       && theta <= initEulerThetaLimitUpper)
   {
      m_initEulerTheta = theta;
   }
}

const double KRotationSaver::initEulerThetaLimitLower =   0.0;
const double KRotationSaver::initEulerThetaLimitUpper = 180.0;
const double KRotationSaver::initEulerThetaDefault    =   0.03;

//   public slots

void KRotationSaver::doTimeStep()
{
   // integrate a step ahead
   solver->integrate(0.001*deltaT);

   // read new y
   std::valarray<double> y = solver->Y();

   std::deque<vec3<double> >::size_type
      max_vec_length =
      static_cast<std::deque<vec3<double> >::size_type>
      ( m_traceLengthSeconds/(0.001*deltaT) );

   for (int j=0; j<3; ++j)
   {
      std::deque<vec3<double> >& e =
         j==0 ? e1 :
         j==1 ? e2 : e3;

      // read out new body coordinate system
      if (m_traceFlag[j] == true
          && max_vec_length > 0)
      {
         e.push_front(y[std::slice(3*j+3, 3, 1)]);
         while (e.size() > max_vec_length)
         {
            e.pop_back();
         }
      }
      else
      {
         // only set the 1. element
         e.front() = y[std::slice(3*j+3, 3, 1)];
         // and delete all other emements
         if (e.size() > 1)
            e.resize(1);
      }
   }

   // current rotation vector omega
   omega = y[0]*e1.front() + y[1]*e2.front() + y[2]*e3.front();

   // set new random traces every 10 seconds
   if (m_randomTraces==true)
   {
      static unsigned int counter=0;
      ++counter;
      if (counter > unsigned(10.0/(0.001*deltaT)))
      {
         counter=0;
         for (int i=0; i<3; ++i)
            m_traceFlag[i] = rand()%2==1 ? true : false;
      }
   }

   glArea->updateGL();
   timer->start(deltaT, TRUE); // restart timer
}

// public slot of KRotationSaver, forward resize event to public slot of glArea
// to allow the resizing of the gl area withing the setup dialog
void KRotationSaver::resizeGlArea(TQResizeEvent* e)
{
   glArea->resize(e->size());
}

//-----------------------------------------------------------------------------
// KRotationSetup: dialog to setup screen saver parameters
//-----------------------------------------------------------------------------

KRotationSetup::KRotationSetup(TQWidget* parent, const char* name)
   : KRotationSetupUi(parent, name),
     // create ssaver and give it the WinID of the preview area
     saver(new KRotationSaver(preview->winId()))
{
   // the dialog should block, no other control center input should be possible
   // until the dialog is closed
   setModal(TRUE);

   lengthEdit->setValidator(
      new TQDoubleValidator(
         KRotationSaver::traceLengthSecondsLimitLower,
         KRotationSaver::traceLengthSecondsLimitUpper,
         3, lengthEdit));
   LzEdit->setValidator(
      new TQDoubleValidator(
         KRotationSaver::LzLimitLower,
         KRotationSaver::LzLimitUpper,
         3, LzEdit));
   thetaEdit->setValidator(
      new TQDoubleValidator(
         KRotationSaver::initEulerThetaLimitLower,
         KRotationSaver::initEulerThetaLimitUpper,
         3, thetaEdit));

   // set tool tips of editable fields
   TQToolTip::add(
      lengthEdit,
      i18n("Length of traces in seconds of visibility.\nValid values from %1 to %2.")
      .arg(KRotationSaver::traceLengthSecondsLimitLower, 0, 'f', 2)
      .arg(KRotationSaver::traceLengthSecondsLimitUpper, 0, 'f', 2));
   TQToolTip::add(
      LzEdit,
      i18n("Angular momentum in z direction in arbitrary units.\nValid values from %1 to %2.")
      .arg(KRotationSaver::LzLimitLower, 0, 'f', 2)
      .arg(KRotationSaver::LzLimitUpper, 0, 'f', 2));
   TQToolTip::add(
      thetaEdit,
      i18n("Gravitational constant in arbitrary units.\nValid values from %1 to %2.")
      .arg(KRotationSaver::initEulerThetaLimitLower, 0, 'f', 2)
      .arg(KRotationSaver::initEulerThetaLimitUpper, 0, 'f', 2));

   // init preview area
   preview->setBackgroundColor(black);
   preview->show();    // otherwise saver does not get correct size

   // read settings from saver and update GUI elements with these values, saver
   // has read settings in its constructor

   // set editable fields with stored values as defaults
   xTrace->setChecked(saver->traceFlag(0));
   yTrace->setChecked(saver->traceFlag(1));
   zTrace->setChecked(saver->traceFlag(2));
   randTraces->setChecked(saver->randomTraces());
   TQString text;
   text.setNum(saver->traceLengthSeconds());
   lengthEdit->validateAndSet(text,0,0,0);
   text.setNum(saver->Lz());
   LzEdit->validateAndSet(text,0,0,0);
   text.setNum(saver->initEulerTheta());
   thetaEdit->validateAndSet(text,0,0,0);

   // if the preview area is resized it emmits the resized() event which is
   // caught by the saver.  The embedded GlArea is resized to fit into the
   // preview area.
   connect(preview, TQT_SIGNAL(resized(TQResizeEvent*)),
           saver,   TQT_SLOT(resizeGlArea(TQResizeEvent*)));
}

KRotationSetup::~KRotationSetup()
{
   delete saver;
}

// Ok pressed - save settings and exit
void KRotationSetup::okButtonClickedSlot(void)
{
   TDEConfig* config = TDEGlobal::config();
   config->setGroup("Settings");
   config->writeEntry("x trace",       saver->traceFlag(0));
   config->writeEntry("y trace",       saver->traceFlag(1));
   config->writeEntry("z trace",       saver->traceFlag(2));
   config->writeEntry("random traces", saver->randomTraces());
   config->writeEntry("length",        saver->traceLengthSeconds());
   config->writeEntry("Lz",            saver->Lz());
   config->writeEntry("theta",         saver->initEulerTheta());
   config->sync();
   accept();
}

void KRotationSetup::aboutButtonClickedSlot(void)
{
   KMessageBox::about(this, i18n("\
<h3>KRotation Screen Saver for TDE</h3>\
<p>Simulation of a force free rotating asymmetric body</p>\
<p>Copyright (c) Georg&nbsp;Drenkhahn 2004</p>\
<p><tt>georg-d@users.sourceforge.net</tt></p>"));
}

void KRotationSetup::xTraceToggled(bool state)
{
   saver->setTraceFlag(0, state);
}
void KRotationSetup::yTraceToggled(bool state)
{
   saver->setTraceFlag(1, state);
}
void KRotationSetup::zTraceToggled(bool state)
{
   saver->setTraceFlag(2, state);
}
void KRotationSetup::randomTracesToggled(bool state)
{
   saver->setRandomTraces(state);
   if (state==false)
   {
      // restore settings from gui if random traces are turned off
      saver->setTraceFlag(0, xTrace->isChecked());
      saver->setTraceFlag(1, yTrace->isChecked());
      saver->setTraceFlag(2, zTrace->isChecked());
   }
}
void KRotationSetup::lengthEnteredSlot(const TQString& s)
{
   saver->setTraceLengthSeconds(s.toDouble());
}
void KRotationSetup::LzEnteredSlot(const TQString& s)
{
   saver->setLz(s.toDouble());
   if (saver!=0) saver->initData();
}
void KRotationSetup::thetaEnteredSlot(const TQString& s)
{
   saver->setInitEulerTheta(s.toDouble());
   if (saver!=0) saver->initData();
}