Window.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include "Window.h"
#include "Configuration.h"
#include "Opengl.h"
#include "Object.h"
#include "ObjectManager.h"
#include "Camera.h"
#include "Message.h"
#include "random.h"

//Zum Verzeichnis einlesen benoetigte Header:
#include <sys/types.h>
#include <dirent.h>

/*
 * Speicherort fuer Klassenvariablen:
 */
int Window::mainWindow;
GLUI* Window::optionWindow;
GLUI * Window::subWindow;
GLUI * Window::constructWindow;

GLUI_Listbox * Window::fileSelector;
GLUI_Listbox * Window::intSelector;
GLUI_Listbox * Window::objectSelector;
GLUI_Button * Window::bAnimationForward;
GLUI_Button * Window::bToggleConstructMode;
GLUI_Spinner * Window::sCameraSave ;
int Window::fileCount;
int Window::objectCount = 0;
GLUI_Translation * Window::tz;
GLUI_Translation * Window::txy;
GLUI_StaticText * Window::txtRenderDetails;
char * Window::txt = 0;
Window::CONSTRUCT_MODE Window::move_mode = NONE;

GLUI_Panel * Window::pSelectedObject;
GLUI_Spinner * Window::sSemimajor;
GLUI_Spinner * Window::sSemiminor;
GLUI_Spinner * Window::sMass;
GLUI_Spinner * Window::sRadius;
GLUI_Spinner * Window::sScaleFactor;

GLUI_Spinner * Window::sCSMaxMass;
GLUI_Spinner * Window::sCSMaxV;
GLUI_Spinner * Window::sCSMaxR;
GLUI_Spinner * Window::sCSMaxPos;
GLUI_Spinner * Window::sCSPlanets;
GLUI_Spinner * Window::sCSSuns;


int Window::count_mouse_buttons=0;
int Window::xlast=0, Window::ylast=0;
Vector Window::constructVectorBackup;


void Window::HandleKeyboard(unsigned char key, int x, int y) {
    switch (key) {
    case 'p':
        //Objekt Details auf Konsole ausgeben:
        ourObjectManager.viewDetailInformationForAllObjects();
        break;
    case '.':
        //Kamera um Z achse Drehen :
        ourCamera.rotateKeepViewPoint(0, 0,-1);
        //Szene neu Zeichnen damit �derungen wirksam werden:
        glutPostRedisplay();
        break;
    case ',':
        //Kamera um Z achse Drehen:
        ourCamera.rotateKeepViewPoint(0, 0,1);
        //Szene neu Zeichnen damit �derungen wirksam werden:
        glutPostRedisplay();
        break;
    case 's':
        //Animation einen Schritt weiterfhren:
        Opengl::singleStep();
        break;
    case 27:
        // Programm beenden wenn Escape gedrckt wurde:
        exit(0);
        break;
    }
}

void Window::HandlePassiveMouseMotion(int x, int y) {
    if(x < 10 && ! ourConfiguration.showMenu) {
        Window::showMenu();
    }
}

void Window::HandleMouse(int button, int state, int x, int y) {
    int modifier_ = glutGetModifiers();
    //Modifier (SHIFT, CTRL, ALT) ermitteln
    if (state == GLUT_DOWN) {
        // eine Maustaste wurde heruntergedrueckt
        count_mouse_buttons++;
        ourCamera.action = Camera::NONE;

        //Objekt ermitteln auf das geklickt wurde:
        uint objClickedPointer_=Opengl::getObjectID(x, y);

        if (count_mouse_buttons == 1) {
            // nur 1 Maustaste gedrueckt
            if( ourConfiguration.constructMode && objClickedPointer_ != 0 &&
                    button != GLUT_LEFT_BUTTON) {
                //Im Konstruktions Modus das Objekt anklicken und interaktiv
                // bewegen:
                Window::selectObject(reinterpret_cast<Object*>
                                     (objClickedPointer_));
                if(button == GLUT_RIGHT_BUTTON) {
                    if(modifier_ == GLUT_ACTIVE_SHIFT)
                        Window::setConstructMode(Window::MOVEZ);
                    else
                        Window::setConstructMode(Window::MOVEXY);
                    constructVectorBackup = ourConfiguration.clickedObject->pos;
                } else if(button == GLUT_MIDDLE_BUTTON) {
                    if(modifier_ == GLUT_ACTIVE_SHIFT)
                        Window::setConstructMode(Window::SPEEDZ);
                    else
                        Window::setConstructMode(Window::SPEEDXY);
                    constructVectorBackup = ourConfiguration.clickedObject->v;
                }

            } else {
                if (modifier_ == 0) {
                    if (button == GLUT_RIGHT_BUTTON)
                        ourCamera.action = Camera::ROTATEXY;
                    else if (button == GLUT_MIDDLE_BUTTON)
                        ourCamera.action = Camera::ROTATEZ;
                    else {
                        if (objClickedPointer_ != 0) {
                            //Falls ein Objekt angeklickt wurde auf das Objekt
                            // zoomen:
                            Window::selectObject(reinterpret_cast<Object*>
                                                 (objClickedPointer_));
                            ourCamera.setProjectionCenter(
                                ourConfiguration.clickedObject->getScaledPos() );
                            glutPostRedisplay();
                        }
                    }
                } else if(modifier_ == GLUT_ACTIVE_SHIFT) {
                    // BEWEGUNG WIE IM 3D Shooter durchfhren:
                    if (button == GLUT_MIDDLE_BUTTON)
                        ourCamera.action = Camera::FORWARD;
                    else if (button == GLUT_RIGHT_BUTTON)
                        ourCamera.action = Camera::ROTATEKEEPPOSXY;
                    else
                        ourCamera.action = Camera::MOVE;
                } else if(modifier_ == GLUT_ACTIVE_CTRL) {
                    if (button == GLUT_LEFT_BUTTON)
                        ourCamera.action = Camera::ZOOM;
                }
            }
        }
    } else if (state == GLUT_UP) {
        // eine Maustaste wurde losgelassen
        count_mouse_buttons--;
        //Aktionen zurcksetzen
        ourCamera.action = Camera::NONE;
        //es wird nicht mehr Interaktiv verschoben
        Window::setConstructMode(Window::NONE);
    }

    // gespeicherte Mausposition aktualisieren
    xlast = x;
    ylast = y;
}


void Window::HandleMouseMotion(int x, int y) {
    int dx, dy;
    //relative Mausposition ermitteln
    //die x-Achse aus Fenstersicht hat eine umgekehrte Orientierung
    dx = xlast -x;
    dy = y - ylast;

    //Falls keine verschiebung vorgenommen wurde beende die Methode
    if(dy==0 && dx == 0)
        return;

    //Interaktiven Konstruktionsmodus ermitteln:
    Window::CONSTRUCT_MODE cmodus=Window::getConstructMode();

    if(! cmodus == Window::NONE) {
        /* Falls ein Konstruktionsmodus angew�lt wurde mu�eine Interaktive
         * manipulation stattfinden. 
         *Je weiter das gew�lte objekt entfernt ist umso st�ker ist
         * diese Manipulation. 
         * constructVectorBackup enth�t den anfangswert der 
         * zu manipulierenden Komponente
         */
        switch(cmodus) {
        case Window::SPEEDZ: {
                Vector viewDirection =
                    ourCamera.getPosition()-ourConfiguration.clickedObject->pos;
                double length = viewDirection.length();

                ourConfiguration.clickedObject->v =  constructVectorBackup -
                                                     viewDirection * dy * length / ourCamera.getScreenHeight();

                ourConfiguration.clickedObject->refreshAttributes();
                return;
            }
        case Window::SPEEDXY: {
                Vector cupper = ourCamera.getUpper();
                Vector cviewDirectionOrthogonal =
                    ourCamera.getViewDirectionOrthogonal();

                double distance=(ourCamera.getPosition() -
                                 constructVectorBackup).length();
                ourConfiguration.clickedObject->v = constructVectorBackup -
                                                    cupper * dy * distance / ourCamera.getScreenHeight();

                ourConfiguration.clickedObject->v -= cviewDirectionOrthogonal *
                                                     dx * distance / ourCamera.getScreenWidth();

                ourConfiguration.clickedObject->refreshAttributes();
                return;
            }
        case Window::MOVEZ: {
                Vector viewDirection =
                    ourCamera.getPosition()-constructVectorBackup;
                double length = viewDirection.length();

                ourConfiguration.clickedObject->pos =  constructVectorBackup -
                                                       viewDirection * dy * length / ourCamera.getScreenHeight();

                ourConfiguration.clickedObject->refreshAttributes();
                return;
            }
        case Window::MOVEXY: {
                Vector cupper = ourCamera.getUpper();
                Vector cviewDirectionOrthogonal =
                    ourCamera.getViewDirectionOrthogonal();

                double distance=(ourCamera.getPosition() -
                                 constructVectorBackup).length();
                ourConfiguration.clickedObject->pos = constructVectorBackup -
                                                      cupper * dy * distance / ourCamera.getScreenHeight();

                ourConfiguration.clickedObject->pos -= cviewDirectionOrthogonal
                                                       * dx * distance / ourCamera.getScreenWidth();

                ourConfiguration.clickedObject->refreshAttributes();
                return;
            }
        default:
            cerr << "WARNING UNKNOWN CONSTRUCTION MODE" << endl;
        }

    } else {
        /*
         * Wir werden keine Interaktiven Manipulation eines Objektes durchfhren,
         * sondern uns im Raum bewegen:
         */
        switch(ourCamera.action) {
        case Camera::ROTATEXY: {
                ourCamera.rotateKeepViewPoint(dy, dx, 0);
                break;
            }
        case Camera::ROTATEZ: {
                ourCamera.rotateKeepViewPoint(0, 0, dx);
                break;
            }
        case Camera::ZOOM: {
                if(dy < 0)
                    // Zoome etwas n�er an Projektionszentrum heran
                    ourCamera.zoom(0.9);
                else
                    // Zoome etwas vom Projektionszentrum weg
                    ourCamera.zoom(1.11);
                break;
            }
        case Camera::FORWARD: {
                // Wie im 3 D shooter vorw�ts bewegen
                ourCamera.moveForward(dy);
                break;
            }
        case Camera::MOVE: {
                // Wie im 3 D shooter hoch / rechts bewegen
                ourCamera.move(-dy,-dx);
                break;
            }
        case Camera::ROTATEKEEPPOSXY: {
                // Wie im 3 D shooter auf der Stelle bewegen
                ourCamera.rotateKeepPosition(dy, -dx);
                break;
            }
        case Camera::NONE: {}

        }
    }

    // gespeicherte Mausposition aktualisieren
    xlast = x;
    ylast = y;

    //Bild neu aufbauen und ver�derung der Kameraposition / objekte darstellen
    glutPostRedisplay();
}

void Window::HandleSpecialKeyboard(int key, int x, int y) {
    int modifier_ = glutGetModifiers();
    //Modifier (SHIFT, CTRL, ALT) ermitteln

    if(modifier_ == 0) {
        /*
         * Falls kein Modifier gedrckt wird Kamera bewegen, 
         * bzw. wie ein Shortcut Sonderfunktionen ausfhren...
         */

        switch (key) {
        case GLUT_KEY_LEFT:
            ourCamera.rotateKeepViewPoint(0,1,0);
            break;
        case GLUT_KEY_RIGHT:
            ourCamera.rotateKeepViewPoint(0,-1,0);
            break;
        case GLUT_KEY_UP:
            ourCamera.rotateKeepViewPoint(1,0,0);
            break;
        case GLUT_KEY_DOWN:
            ourCamera.rotateKeepViewPoint(-1,0, 0);
            break;
        case GLUT_KEY_PAGE_DOWN:
            ourCamera.zoom(2);
            break;
        case GLUT_KEY_PAGE_UP:
            ourCamera.zoom(0.5);
            break;
        case GLUT_KEY_END:
            //Auf weitestes Entferntes Objekt Zoomen
            ourCamera.setAllToViewObject(
                ourObjectManager.getFarthestAwayObject());
            break;
        case GLUT_KEY_HOME:
            ourCamera.home();
            break;
        case GLUT_KEY_F9:
            ourCamera.saveAktuallCameraPosition(ourConfiguration.cameraSaveSlot);
            break;
        case GLUT_KEY_F10:
            ourCamera.loadAktuallCameraPosition(ourConfiguration.cameraSaveSlot);
            break;
        case GLUT_KEY_F11:
            //Aktuellen Zustand des Sonnensystems speichern
            ourConfiguration.saveWorld(ourConfiguration.filename,true);
            break;
        case GLUT_KEY_F12:
            //Zustand des Sonnensystems laden
            ourConfiguration.loadWorld(ourConfiguration.filename,true);
            break;
        }
    } else if(modifier_ == GLUT_ACTIVE_SHIFT ) {
        //3d shooter bewegung:
        switch (key) {
        case GLUT_KEY_LEFT:
            ourCamera.move(0, -1);
            break;
        case GLUT_KEY_RIGHT:
            ourCamera.move(0, 1);
            break;
        case GLUT_KEY_UP:
            ourCamera.move(1,0);
            break;
        case GLUT_KEY_DOWN:
            ourCamera.move(-1, 0);
            break;
        case GLUT_KEY_PAGE_DOWN:
            ourCamera.moveForward(-1);
            break;
        case GLUT_KEY_PAGE_UP:
            ourCamera.moveForward(1);
            break;
        }

    } else if(modifier_ == GLUT_ACTIVE_ALT ) {
        //Auf der Stelle drehen:
        switch (key) {
        case GLUT_KEY_LEFT:
            ourCamera.rotateKeepPosition(0, -1);
            break;
        case GLUT_KEY_RIGHT:
            ourCamera.rotateKeepPosition(0, 1);
            break;
        case GLUT_KEY_UP:
            ourCamera.rotateKeepPosition(-1, 0);
            break;
        case GLUT_KEY_DOWN:
            ourCamera.rotateKeepPosition(1, 0);
            break;
        }
    }

    //Bild neu aufbauen und ver�derung der Kameraposition / objekte darstellen
    glutPostRedisplay();
}


void Window::setRenderDetails(const string & s) {
    if(txt != 0)
        delete(txt);
    txt= new char[s.length()+1];
    strncpy(txt,s.c_str(), s.length()+1);

    //Text der GLUI Komponente zuweisen:
    txtRenderDetails->set_text(txt);
}


Window::CONSTRUCT_MODE Window::getConstructMode() {
    if ( ourConfiguration.constructMode )
        return move_mode;
    return NONE;
}


void Window::reloadObjectSelector() {
    loadObjectSelector(true);

    objectSelector->do_selection(0);
    //aktuell Ausgew�ltes Object ausw�len im Objekt Selector
    selectObject(ourConfiguration.clickedObject);
}


void Window::setSatelliteProperties() {
    if(ourConfiguration.clickedObject == NULL)
        return;
    sSemiminor->set_double_limits( 1e-100, 1e100 );
    sSemimajor->set_double_limits( 1e-100, 1e100 );
    sMass->set_double_limits( 1e-100, ourConfiguration.clickedObject->mass );
    sRadius->set_double_limits( 1e-100, ourConfiguration.clickedObject->radius*4);

    sSemimajor->set_double_val(ourConfiguration.clickedObject->radius*150);
    sSemiminor->set_double_val(ourConfiguration.clickedObject->radius*100);
    sMass->set_double_val(ourConfiguration.clickedObject->mass/1e12);
    sRadius->set_double_val(ourConfiguration.clickedObject->radius/4);
}


void Window::selectObject( Object * obj ) {
    //Attribut fenster des alten Objekts schlie�n:
    if ( obj == NULL && ourConfiguration.clickedObject != NULL )
        ourConfiguration.clickedObject->closeAttributeWindow();


    ourConfiguration.clickedObject = obj;
    if( ourConfiguration.constructMode ) {
        if ( ourConfiguration.clickedObject == NULL ) {
            pSelectedObject->disable();
        } else {
            pSelectedObject->enable();
            setSatelliteProperties();
        }
        if(obj != NULL)
            obj->createAttributeWindow();
    }

    if(obj == NULL) {
        objectSelector->do_selection(0);
    } else if ( ! objectSelector->active ) {
        //Ausgew�ltes Objekt im Object selector richtig anzeigen:
        objectList * oList = ourObjectManager.getObjectList();
        objectCount = oList->size();

        int id = 0;
        int select = 0;
        for ( objectList::iterator it = oList->begin() ; it != oList->end();
                it ++ ) {
            if ( *it == ourConfiguration.clickedObject )
                select = id;
            id++;
        }
        objectSelector->do_selection( select + 1 );
    }

}

void Window::setAnimationControls( bool disable ) {
    if ( disable ) {
        //Konstruktions Modus wechsel und Auswahl der Objekte ber
        //Object Selector verbieten
        bToggleConstructMode->disable();
        loadObjectSelector( false );
    } else {
        //Konstruktions Modus wechsel und Auswahl der Objekte ber
        //Object Selector erlauben
        bToggleConstructMode->enable();
        loadObjectSelector( true );
    }

}

void Window::load() {
    Window::showConstructMenu( ourConfiguration.constructMode );
    Window::setAnimationControls( false );
    Window::selectObject(ourConfiguration.clickedObject);

    //Integrator festlegen:
    intSelector->do_selection( Integrator::TypeToInt(
                                   ourConfiguration.integrator->getName() ) );

    //Werte fuer Add Satellite festlegen
    setSatelliteProperties();

    sCameraSave->set_int_val( ourConfiguration.cameraSaveSlot );
    sScaleFactor->set_double_val( ourConfiguration.linearScaleFactor);
    subWindow->sync_live();
    optionWindow->sync_live();
    constructWindow->sync_live();
}

void Window::loadObjectSelector( bool load ) {
    if ( load ) {
        //Alte Eintr�e des Object Selectors l�chen
        for ( int i = 1; i <= objectCount; i++ )
            objectSelector->delete_item( i );

        objectSelector->enable();

        //Aktuelle Objekte ermitteln
        objectList * oList = ourObjectManager.getObjectList();
        objectCount = oList->size();

        //und anw�lbare Liste fr Object Selector erzeugen
        int id = 1;
        int select = 0;
        for ( objectList::iterator it = oList->begin() ; it != oList->end();
                it ++ ) {
            objectSelector->add_item( id, ( *it ) ->getName() );
            if ( *it == ourConfiguration.clickedObject )
                select = id;
            id++;
        }
        objectSelector->do_selection( select );

    } else {
        //Alte Eintr�e des Object Selectors l�chen
        objectSelector->disable();
        for ( int i = 1; i <= objectCount; i++ )
            objectSelector->delete_item( i );
        objectCount = 0;
    }
}


void Window::showMenu() {
    ourConfiguration.showMenu = true;
    subWindow->show();
    Opengl::reloadWindow();
}

void Window::showConstructMenu( bool show ) {
    if ( show ) {
        bAnimationForward->disable();
        constructWindow->show();
    } else {
        Object::closeAttributeWindow();
        constructWindow->hide();
        bAnimationForward->enable();
    }
}

void Window::CreateWindows( int mainWin ) {
    mainWindow = mainWin;

    //Callback fuer Mousbewegung ohne gedrueckte Tasten....
    glutPassiveMotionFunc(& Window::HandlePassiveMouseMotion);

    // Setzt die Keyboard-Callback-Funktion fuer das Hauptfenster.
    GLUI_Master.set_glutKeyboardFunc(& Window::HandleKeyboard);

    // Setzt die Special-Keyboard-Callback-Funktion fuer das Hauptfenster.
    GLUI_Master.set_glutSpecialFunc(& Window::HandleSpecialKeyboard);

    // Setzt die Mouse-Callback-Funktion fuer das Hauptfenster
    GLUI_Master.set_glutMouseFunc(& Window::HandleMouse);

    // Setzt die MouseMotion-Callback-Funktion fuer das Hauptfenster
    glutMotionFunc(& Window::HandleMouseMotion);

    //Alle Fenster nacheinander erzeugen:
    CreateMainWindow(mainWin);
    CreateConstructWindow();
    CreateOptionWindow();
    Message::CreateWindow(mainWin);
}

void Window::CreateOptionWindow() {
    //Callback zwischenspeichern (einfacherer Zugriff)
    const GLUI_Update_CB mc = ( GLUI_Update_CB ) Window::MenuOptionCallback;

    //erzeugen des Fensters:
    optionWindow = GLUI_Master.create_glui( "Options" );

    //Kontrollen hinzu fgen:
    GLUI_Panel * pLoadSave = optionWindow->add_panel( "Files" );
    GLUI_EditText * etSave=  optionWindow->add_edittext_to_panel( pLoadSave,
                             "Filename", GLUI_EDITTEXT_TEXT, & ourConfiguration.filename );
    //breite setzen:
    etSave->set_w(300);

    fileSelector = optionWindow->add_listbox_to_panel( pLoadSave, "Files",
                   NULL , FILE_SELECTOR_LIST, mc );
    fileSelector->set_w(300);
    optionWindow->add_column_to_panel( pLoadSave, false );
    optionWindow->add_button_to_panel( pLoadSave, "Save", SAVE, mc );
    optionWindow->add_button_to_panel( pLoadSave, "Load", LOAD, mc );


    //Panel Display Options:
    GLUI_Panel * pDisplayOptions = optionWindow->add_panel( "Display Options" );

    GLUI_Panel * pModelView = optionWindow->add_panel_to_panel( pDisplayOptions,
                              "Model View" );
    GLUI_RadioGroup * rgModel = optionWindow->add_radiogroup_to_panel(
                                    pModelView, & ourConfiguration.viewModel );
    optionWindow->add_radiobutton_to_group( rgModel, "Points" );
    optionWindow->add_radiobutton_to_group( rgModel, "Grid" );
    optionWindow->add_radiobutton_to_group( rgModel, "Solid" );

    GLUI_Panel * pLight = optionWindow->add_panel_to_panel( pDisplayOptions,
                          "Light" );
    optionWindow->add_checkbox_to_panel( pLight, "Show", ( &
                                         ourConfiguration.showLighting ) );

    GLUI_Panel * pTexture = optionWindow->add_panel_to_panel( pDisplayOptions,
                            "Texture" );
    optionWindow->add_checkbox_to_panel( pTexture, "Show", (
                                             &ourConfiguration.showTextures ) );

    optionWindow->add_column_to_panel( pDisplayOptions, true );

    GLUI_Spinner * sphereDetail = optionWindow->add_spinner_to_panel(
                                      pDisplayOptions, "Sphere Detail", GLUI_SPINNER_INT,
                                      & ourConfiguration.sphereDetaillevel );
    sphereDetail->set_int_limits( 2, 200 );

    GLUI_Spinner * radiusAdaption = optionWindow->add_spinner_to_panel(
                                        pDisplayOptions, "Radius adaption",
                                        GLUI_SPINNER_INT,
                                        & ourConfiguration.radiusAdaption );
    radiusAdaption->set_int_limits( 1, 300000 );
    radiusAdaption->set_w(250);

    sScaleFactor = optionWindow->add_spinner_to_panel( pDisplayOptions,
                   "Scale Factor", GLUI_SPINNER_DOUBLE, NULL, CHANGE_SCALEFAKTOR  , mc );
    sScaleFactor->set_double_limits( 1e-300, 1e300 );
    sScaleFactor->set_w(250);
    sScaleFactor->set_double_val(1.0);

    optionWindow->add_button_to_panel(pDisplayOptions, "Autoscaling",
                                      AUTOSCALING , mc);
    optionWindow->add_checkbox_to_panel( pDisplayOptions, "Auto adaption", (
                                             & ourConfiguration.autoAdaption ) , AUTOADAPTION,mc);
    optionWindow->add_checkbox_to_panel( pDisplayOptions, "View Vector", (
                                             & ourConfiguration.viewVectors ) );
    optionWindow->add_checkbox_to_panel( pDisplayOptions, "Draw Old Positions",(
                                             & ourConfiguration.drawOldPositions ) );

    GLUI_Spinner * sTimeSteps = optionWindow->add_spinner_to_panel( pDisplayOptions,
                                "Draw Old Steps", GLUI_SPINNER_INT,
                                & ourConfiguration.drawOldPositionsTimeSteps);
    sTimeSteps->set_int_limits( 0, 300000 );
    sTimeSteps->set_w(200);



    //Panel Inegrator:
    GLUI_Panel * pInt = optionWindow->add_panel( "Integrator" );
    intSelector = optionWindow->add_listbox_to_panel( pInt, "Type", NULL,
                  INTEGRATOR, mc );

    for ( int i = 0; i < Integrator::getTypeCount(); i++ ) {
        intSelector->add_item( i, Integrator::NumToType( i ) );
    }
    optionWindow->add_button_to_panel( pInt, "Options", INTEGRATOROPTION, mc );


    // Fenster das Aktualisiert wird wenn "LiveVariables" ver�dert werden setzen:
    optionWindow->set_main_gfx_window( getMainWindow() );

    //verbergen des Fensters zu beginn:
    optionWindow->hide();
}

void Window::CreateMainWindow(int mainWindow) {
    //Callback zwischenspeichern (einfacherer Zugriff)
    const GLUI_Update_CB mc = ( GLUI_Update_CB ) Window::MenuMainCallback;
    //erzeugen eines Unter Fensters des Hauptfensters:
    subWindow = GLUI_Master.create_glui_subwindow( mainWindow,
                GLUI_SUBWINDOW_LEFT );

    //Panel Position:
    GLUI_Panel * pPosition = subWindow->add_panel( "Position" );
    subWindow->add_checkbox_to_panel( pPosition, "3D shooter like", (
                                          & ourConfiguration.movelike3Dshooter ) );
    txy = subWindow->add_translation_to_panel( pPosition, "XY",
            GLUI_TRANSLATION_XY, NULL, TRANSLATION_XY, mc );
    tz = subWindow->add_translation_to_panel( pPosition, "Z",
            GLUI_TRANSLATION_Z, NULL, TRANSLATION_Z, mc );

    //Panel Object:
    GLUI_Panel * pObject = subWindow->add_panel( "Object" );
    subWindow->add_checkbox_to_panel( pObject, "Follow",
                                      & ourConfiguration.followObject );
    subWindow->add_checkbox_to_panel( pObject, "View Flight",
                                      & ourConfiguration.viewToObjectsFlightDirection );
    objectSelector = subWindow->add_listbox_to_panel( pObject, "Object", NULL,
                     OBJECT_SELECT, mc );
    objectSelector->add_item( 0, "NONE" );
    subWindow->add_button_to_panel(pObject,"Zoom", ZOOM_OBJECT,mc );

    //Panel Control:
    GLUI_Panel * pControl = subWindow->add_panel( "Control" );
    GLUI_Panel * pControlAnimation = subWindow->add_panel_to_panel( pControl,
                                     "", 0 );
    GLUI_Button * b = subWindow->add_button_to_panel( pControlAnimation, "||",
                      PAUSE, mc );
    subWindow->add_column_to_panel( pControlAnimation, false );
    b = subWindow->add_button_to_panel( pControlAnimation, "+", SINGLESTEP, mc );
    subWindow->add_column_to_panel( pControlAnimation, false );
    bAnimationForward = subWindow->add_button_to_panel( pControlAnimation, ">",
                        CONTINUE, mc );

    GLUI_EditText *  sspeed = subWindow->add_edittext_to_panel( pControl, "time",
                              GLUI_EDITTEXT_DOUBLE, & ourConfiguration.speed );
    sspeed->set_double_limits( 1e-3, 1e20 );
    sspeed->set_w(30);
    subWindow->add_column_to_panel(pControl,true);

    GLUI_RadioGroup * rgTime = subWindow->add_radiogroup_to_panel( pControl,
                               & ourConfiguration.speedType );
    subWindow->add_radiobutton_to_group( rgTime, "s" );
    subWindow->add_radiobutton_to_group( rgTime, "h" );
    subWindow->add_radiobutton_to_group( rgTime, "d" );
    subWindow->add_radiobutton_to_group( rgTime, "m" );
    subWindow->add_radiobutton_to_group( rgTime, "y" );


    //Panel Camera:
    GLUI_Panel * pCamera = subWindow->add_panel( "Camera", true );
    sCameraSave = subWindow->add_spinner_to_panel( pCamera, "Slot",
                  GLUI_SPINNER_INT,
                  & ourConfiguration.cameraSaveSlot );
    sCameraSave->set_int_limits( 0, Camera::CAMERA_SAVES-1 );
    GLUI_Panel * pCameraLS = subWindow->add_panel_to_panel( pCamera, "", 0 );
    b = subWindow->add_button_to_panel( pCameraLS, "Save", SAVECAMERA, mc );
    subWindow->add_column_to_panel( pCameraLS, false );
    b = subWindow->add_button_to_panel( pCameraLS, "Load", LOADCAMERA, mc );
    b=subWindow->add_button( "Optionen", TOGGLE_VIEW_OPTIONS , mc );
    bToggleConstructMode = subWindow->add_button( "Construct Mode",
                           TOGGLE_CONSTRUCT_MODE , mc );
    b=subWindow->add_button( "Hide Menu", HIDE_MENU , mc );

    //Render Detail Text einfgen
    txtRenderDetails = subWindow->add_statictext( "fps:" );

    // Fenster das Aktualisiert wird wenn "LiveVariables" ver�dert werden setzen:
    subWindow->set_main_gfx_window( mainWindow );
}

void Window::CreateConstructWindow() {
    //Callback zwischenspeichern (einfacherer Zugriff)
    GLUI_Update_CB mc = ( GLUI_Update_CB ) Window::MenuConstructionCallback;
    //erzeugen eines Unter Fensters des Hauptfensters:
    constructWindow = GLUI_Master.create_glui( "Constructor" );

    //Panel create hinzufgen:
    GLUI_Panel * pCreate = constructWindow->add_panel( "Create" );

    /*
     * Fr jedes Astronomische Objekt das existiert und somit erzeugt werden kann
     * einen Button einfgen.
     * dies ist unabh�gig von der Anzahl der verschiedenen Objekttypen die
     * existieren.
     */
    for ( int i = 0; i < ObjectManager::getTypeCount(); i++ ) {
        GLUI_Button * b = constructWindow->add_button_to_panel( pCreate,
                          ObjectManager::NumToType( i ), i ,mc );
        b->set_w(100);
    }

    //Panel "selected Object" fr manipulation des Aktuellen Objekts erzeugen
    pSelectedObject = constructWindow->add_rollout( "Selected Object" );
    pSelectedObject->disable();

    constructWindow->add_button_to_panel( pSelectedObject,"Delete", DELETE, mc );
    constructWindow->add_separator_to_panel(pSelectedObject);
    GLUI_Panel * pAddMoon =
        constructWindow->add_rollout_to_panel(pSelectedObject, "Add Satellite" );
    sSemimajor =  constructWindow->add_spinner_to_panel( pAddMoon,
                  "semimajor axis",GLUI_SPINNER_DOUBLE);
    sSemimajor->set_w(200);
    sSemiminor =  constructWindow->add_spinner_to_panel( pAddMoon,
                  "semiminor axis",GLUI_SPINNER_DOUBLE);
    sSemiminor->set_w(200);
    sMass =  constructWindow->add_spinner_to_panel( pAddMoon,
             "mass",GLUI_SPINNER_DOUBLE);
    sMass->set_w(200);
    sMass->set_double_limits(1.0,1e80);
    sRadius =  constructWindow->add_spinner_to_panel( pAddMoon,
               "radius",GLUI_SPINNER_DOUBLE);
    sRadius->set_w(200);
    constructWindow->add_button_to_panel( pAddMoon,"Add", ADD_MOON, mc );

    //Panel "Construct System" zur automatischen Konstruktion eines
    // Zufallssternsystems:
    GLUI_Panel * pConstructSystem= constructWindow->add_rollout(
                                       "Construct System",false);
    sCSMaxMass =  constructWindow->add_spinner_to_panel( pConstructSystem,
                  "mass max",GLUI_SPINNER_INT);
    sCSMaxMass->set_int_limits(1,70);
    sCSMaxMass->set_int_val(30);

    sCSMaxV =  constructWindow->add_spinner_to_panel( pConstructSystem,
               "v max",GLUI_SPINNER_INT);
    sCSMaxV->set_int_limits(0,9);
    sCSMaxV->set_int_val(2);

    sCSMaxR =  constructWindow->add_spinner_to_panel( pConstructSystem,
               "r max",GLUI_SPINNER_INT);
    sCSMaxR->set_int_limits(1,30);
    sCSMaxR->set_int_val(7);

    sCSMaxPos =  constructWindow->add_spinner_to_panel( pConstructSystem,
                 "pos max",GLUI_SPINNER_INT);
    sCSMaxPos->set_int_limits(3,30);
    sCSMaxPos->set_int_val(10);

    constructWindow->add_separator_to_panel(pConstructSystem);

    sCSPlanets =  constructWindow->add_spinner_to_panel( pConstructSystem,
                  "Planets",GLUI_SPINNER_INT);
    sCSPlanets->set_int_limits(0,100);
    sCSPlanets->set_int_val(10);

    sCSSuns =  constructWindow->add_spinner_to_panel( pConstructSystem,
               "Suns",GLUI_SPINNER_INT);
    sCSSuns->set_int_limits(0,10);
    sCSSuns->set_int_val(2);

    constructWindow->add_button_to_panel( pConstructSystem,"Create System",
                                          CREATE_SYSTEM, mc );
    constructWindow->add_button_to_panel( pConstructSystem,"CLEAR SYSTEM",
                                          CLEAR_SYSTEM, mc );

    // Fenster das Aktualisiert wird wenn "LiveVariables" ver�dert werden setzen:
    constructWindow->set_main_gfx_window( getMainWindow() );
    //verbergen des Fensters zu beginn:
    constructWindow->hide();
}

void Window::FillFileSelector() {
    //Datei auswahl leeren
    ClearFileSelector();
    //Verzeichnis inhalt laden:
    DIR * dir = opendir( "save" );
    if ( dir == 0 ) {
        cerr << "WARNUNG: Directory save does not exist!" << endl;
        return ;
    }
    dirent * dentry;
    while ( ( dentry = readdir( dir ) ) ) {
        if ( dentry->d_reclen < 300 ) {
            string s( dentry->d_name );
            uint pos = s.find( FILE_EXTENSION );

            if ( pos != string::npos ) {
                dentry->d_name[ pos ] = 0; // erweiterung abschneiden !
                fileSelector->add_item( fileCount, dentry->d_name );
                fileCount ++;
            }
        } else
            cerr << "WARNING save/" << dentry->d_name <<
            " name is longer than 300" << endl;
    }
    closedir( dir );
}

void Window::ClearFileSelector() {
    for ( int i = 0; i < fileCount; i++ )
        fileSelector->delete_item( i );
    fileCount = 0;
}

void Window::MenuConstructionCallback( callbackConstruction b ) {
    if ( b < 1000 ) {
        //erzeuge neues Objekt so in Raum das es gesehen wird:
        string type =ObjectManager::NumToType( b );
        Object * newObject = ourObjectManager.createObject( type );
        newObject->pos = ourCamera.getProjectionCenter();
        newObject->radius = ( ourCamera.getPosition() -
                              ourCamera.getProjectionCenter() ).length() * 0.1;
        selectObject(newObject);
        newObject->createAttributeWindow();

        //Object Selector neu laden:
        loadObjectSelector( true );
        return ;
    }

    //Normaler Button ausgew�lt:
    switch ( b ) {
    case ( ADD_MOON ) : {
            //TODO BERECHNUNG ERLAEUTERN

            //Fge Satellit hinzu, die lage im Raum wird zuf�lig ermittelt
            if ( ourConfiguration.clickedObject == 0 ) {
                cerr << "WARNING No Basis Object selected" << endl;
                return ;
            }
            //Objekt erzeugen
            Object * newObject = ourObjectManager.createObject( "planet" );
            Object * basisObject = ourConfiguration.clickedObject;

            double a = sSemimajor->get_double_val();
            double b = sSemiminor->get_double_val();
            if(a<b) {
                double z=a;
                a=b;
                b=z;
            }
            //Wichtige Variablen fuer die Berechnung festlegen:
            double perigaeumLength = a - sqrt( sqr( a ) - sqr( b ) );
            double apogaeumLength = 2 * a - perigaeumLength;
            double numericalExcentricity = ( apogaeumLength - perigaeumLength )
                                           / ( apogaeumLength + perigaeumLength );
            double formParameter = a * ( 1 - sqr( numericalExcentricity ) );
            double vLength = ( sqrt( GAMMA * basisObject->mass * formParameter )
                               / perigaeumLength );

            newObject->radius = sRadius->get_double_val();
            newObject->mass = sMass->get_double_val();
            //NORMIERE Vector bitte vorher bsp 1,0,0

            Vector randv( drand( -1, 1 ), drand( -1, 1 ), drand( -1, 1 ) );
            while ( randv.length() == 0 )
                randv = Vector( drand( -1, 1 ), drand( -1, 1 ), drand( -1, 1 ) );
            newObject->pos = basisObject->pos + randv.getNormalised() *
                             perigaeumLength;

            //bestimme v orthogonal zu verbindung neues object zu altem:
            randv = Vector( drand( -1, 1 ), drand( -1, 1 ), drand( -1, 1 ) );
            Vector diff = basisObject->pos - newObject->pos;

            //Die vektoren duerfen nicht Linear abhaengig sein, dies wird
            // ueberprueft und abgefangen
            while ( randv.length() == 0 || randv.x / diff.x ==
                    randv.y / diff.y ) {
                randv = Vector( drand( -1, 1 ), drand( -1, 1 ), drand( -1, 1 ) );
            }

            Vector flight = randv.getNormalised().crossProduct(
                                diff ).getNormalised();
            newObject->v = basisObject->v + flight * vLength;
            break;
        }
    case ( DELETE ) : {
            //Objekt l�chen
            if ( ourConfiguration.clickedObject != 0 ) {
                ourConfiguration.clickedObject->closeAttributeWindow();
                ourObjectManager.deleteObject( ourConfiguration.clickedObject );
                selectObject(NULL);
            } else {
                cerr << "No Valid Object Selected !" << endl;
            }
            break;
        }
    case(CLEAR_SYSTEM): {
            //Loesche alle Objekte
            ourObjectManager.deleteAllObjects();
            break;
        }
    case(CREATE_SYSTEM): {
            //erzeuge eine anzahl von Planeten und sonnen:
            for(int i=0; i < sCSPlanets->get_int_val() ;i++) {
                ourObjectManager.createRandomObject("planet",
                                                    sCSMaxMass->get_int_val(),
                                                    sCSMaxPos->get_int_val(),
                                                    sCSMaxR->get_int_val(),
                                                    sCSMaxV->get_int_val());
            }

            for(int i=0; i < sCSSuns->get_int_val() ;i++) {
                ourObjectManager.createRandomObject("sun",
                                                    sCSMaxMass->get_int_val(),
                                                    sCSMaxPos->get_int_val(),
                                                    sCSMaxR->get_int_val(),
                                                    sCSMaxV->get_int_val());
            }

            //Weitestes Entfernte Objekt anzeigen
            ourCamera.setAllToViewObject(
                ourObjectManager.getFarthestAwayObject());
            break;
        }
    default:
        cerr << "WARNING Unknown CREATE BUTTON PRESSED: " << b << endl;
    }

    //Objektanzahl hat sich veraendert, also den Objekt Selector neu laden.
    loadObjectSelector( true );
}

void Window::MenuMainCallback( callbackMain b ) {
    switch ( b ) {
    case ( PAUSE ) : {
            //Animation anhalten
            Opengl::setAnimation( false );
            break;
        }
    case ( CONTINUE ) : {
            //Animation weiterfuehren
            Opengl::setAnimation( true );
            break;
        }
    case ( SINGLESTEP ) : {
            // Die Animation einen schritt vorantreiben (Zeit verstreichen
            // lassen)
            Opengl::singleStep();
            break;
        }
    case ( TRANSLATION_XY ) : {
            //Bewegung im Raum
            static double oldx = txy->get_x();
            static double oldy = txy->get_y();
            int diffx = int( oldx - txy->get_x() );
            int diffy = int( oldy - txy->get_y() );

            if ( ourConfiguration.movelike3Dshooter )
                ourCamera.move( -diffy, -diffx );
            else
                ourCamera.rotateKeepViewPoint( -diffy, diffx, 0 );

            oldx = txy->get_x();
            oldy = txy->get_y();
            break;
        }
    case ( TRANSLATION_Z ) : {
            //Bewegung im Raum
            static double oldz = tz->get_z();
            double diffz = ( oldz - tz->get_z() );

            if ( ourConfiguration.movelike3Dshooter )
                ourCamera.moveForward( -diffz );
            else {
                if ( diffz > 0 )
                    diffz = 1.11;
                else
                    diffz = 0.9;
                ourCamera.zoom( diffz );
            }

            oldz = tz->get_z();
            break;
        }
    case(SAVECAMERA) : {
            ourCamera.saveAktuallCameraPosition(
                ourConfiguration.cameraSaveSlot );
            break;
        }
    case(LOADCAMERA) : {
            ourCamera.loadAktuallCameraPosition(
                ourConfiguration.cameraSaveSlot );
            break;
        }
    case( OBJECT_SELECT ) : {
            //Im Object Selector wurde ein Objekt ausgewaehlt
            int sel = objectSelector->get_int_val();
            if ( sel == 0 ) {
                selectObject(NULL) ;
                return ;
            }

            //Es muss das gewaehlte Objekt ermittelt werden, da der Object
            // Selector nur einen
            // Integer zurueck gibt, allerdings ein Objekt benoetigt wird.
            objectList * oList = ourObjectManager.getObjectList();
            objectCount = oList->size();
            objectList::iterator it = oList->begin();
            for ( int c = 1 ; c < sel;c ++ )
                it++;

            //Objekt wurde gefunden:
            Object * obj_ = *it;
            Vector pos_=obj_->getScaledPos();
            //Auf Objekt zoomen
            ourCamera.zoomTo( pos_, obj_->getScaledRadius()  * 10 );
            ourCamera.setProjectionCenter( pos_ );
            //Objekt anwaehlen:
            selectObject(obj_);

            if( ourConfiguration.constructMode )
                obj_->createAttributeWindow();
            break;
        }
    case(ZOOM_OBJECT): {
            //Auf gegenwaertig gewaehltes Objekt zoomen falls eines angewaehlt
            if(ourConfiguration.clickedObject == NULL)
                break;

            Vector pos_=ourConfiguration.clickedObject->getScaledPos();
            if (ourConfiguration.autoAdaption  )
                ourCamera.zoomTo( pos_, ourConfiguration.clickedObject->radius *
                                  ourConfiguration.linearScaleFactor  * 10 );
            else
                ourCamera.zoomTo( pos_,
                                  ourConfiguration.clickedObject->getScaledRadius()  * 10 );
            ourCamera.setProjectionCenter( pos_ );
            break;
        }
    case ( HIDE_MENU ) : {
            //Menue verbergen:
            ourConfiguration.showMenu = false;
            subWindow->hide();
            Opengl::reloadWindow();

            break;
        }
    case( TOGGLE_CONSTRUCT_MODE ) : {
            //Konstruktionsmodus <=> Simulationsmodus wechseln
            ourConfiguration.constructMode = !ourConfiguration.constructMode;
            showConstructMenu( ourConfiguration.constructMode );
            break;
        }
    case( TOGGLE_VIEW_OPTIONS ) : {
            //Anzeige des OptionenFensters wechseln
            ourConfiguration.showOptionMenu = !ourConfiguration.showOptionMenu;
            if ( ourConfiguration.showOptionMenu ) {
                FillFileSelector();
                optionWindow->show();
            } else {
                ClearFileSelector();
                optionWindow->hide();
            }
            break;
        }
    default:
        cout << "KEY " << b << " nicht definiert !" << endl;
    }

    //Fenster neu zeichen:
    Opengl::redraw();
}


void Window::MenuOptionCallback( callbackOption b ) {
    switch ( b ) {
    case(CHANGE_SCALEFAKTOR): {
            // Linearen Skalierungsfaktor so �dern das Kamera Position relativ
            // dazu gleich bleibt:
            double oldLSF =  ourConfiguration.linearScaleFactor;
            double newLSF = sScaleFactor->get_double_val();
            ourConfiguration.linearScaleFactor = newLSF;
            ourCamera.changeLinearScaleFactor(newLSF/oldLSF);
            break;
        }
    case(AUTOADAPTION): {
            // Automatische Adaptionswerte neu laden und somit Kamera Position
            // veraendern:
            ourCamera.reloadAutomaticAdaption();
            optionWindow->sync_live();
            break;
        }
    case (AUTOSCALING): {
            //Automatisch auf weitest Entferntes Objekt so Skalieren das dieses
            // innerhalb von 100 einheiten liegt:
            double old_ = ourConfiguration.linearScaleFactor;
            double maxdist =
                ourObjectManager.getFarthestAwayObject()->pos.length();
            if(maxdist == 0) maxdist = 1;
            ourConfiguration.linearScaleFactor = 100.0 / maxdist;
            ourCamera.changeLinearScaleFactor(
                ourConfiguration.linearScaleFactor / old_);
            
            sScaleFactor->set_double_val(ourConfiguration.linearScaleFactor);
            break;
        }
    case( INTEGRATOROPTION ) : {
            //Fenster zum �dern der Integrator Optionen �fnen:
            ourConfiguration.integrator->createAttributeWindow();
            break;
        }
    case( INTEGRATOR ) : {
            //Der Aktuelle Integrator soll ver�dert werden, alten L�chen und
            // neuen Erzeugen:
            Integrator::closeAttributeWindow();
            delete( ourConfiguration.integrator );
            ourConfiguration.integrator = Integrator::createIntegrator(
                                              ( char * ) intSelector->curr_text );
            break;
        }
    case( SAVE ) : {
            //Speichern des aktuellen Sonnensystems
            ourConfiguration.saveWorld( ourConfiguration.filename, true );
            //Evtl. wurde neue Datei erzeugt, diese zur auswahl hinzufuegen:
            FillFileSelector();
            break;
        }
    case( LOAD ) : {
            //Laden des aktuellen Sonnensystems
            ourConfiguration.loadWorld( ourConfiguration.filename, true );
            break;
        }
    case( FILE_SELECTOR_LIST ) : {
            //Es wurde eine andere Datei im Dateiselektor ausgewaehlt:
            strncpy( ourConfiguration.filename, fileSelector->curr_text,
                     SIZEOFGLUISTRING );
            optionWindow->sync_live();
            break;
        }
    default:
        cout << "KEY " << b << " nicht definiert !" << endl;
    }

}

void Window::setConstructMode(CONSTRUCT_MODE m) {
    move_mode = m;
}

int Window::getMainWindow()  {
    return mainWindow;
}

---