app_v3dcontrol.C

Go to the documentation of this file.

/* Gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 * 
 * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
 *
 * Authors: Percy Zahl <zahl@users.sf.net>
 * additional features: Andreas Klust <klust@users.sf.net>
 * WWW Home: http://gxsm.sf.net
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 02111-1307, USA.
 */

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */


#include <locale.h>
#include <libintl.h>

#include "gnome-res.h"

#include "gxsm_app.h"

#include "unit.h"
#include "pcs.h"
#include "xsmtypes.h"
#include "action_id.h"
#include "glbvars.h"

#include "app_profile.h"
#include "app_vobj.h"
#include "app_v3dcontrol.h"
#include "app_v3dpopupdef.h"

#include <gtk/gtk.h>
#include <gtk/gtkgl.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include <gdk/gdkkeysyms.h>


// V3dControl
// ========================================

void V3dControl::AppWidgetInit(gchar *title, int InWindow){
        XSM_DEBUG(DBG_L2, "V3dControl::WidgetInit" );
        InWindowFlg = InWindow;
        // we have our own window
        if(InWindowFlg){
                widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
                gtk_object_set_data (GTK_OBJECT (widget), "widget", widget);
                gtk_window_set_title (GTK_WINDOW (widget), title);
                gtk_window_set_policy (GTK_WINDOW (widget), TRUE, TRUE, FALSE);
                gtk_signal_connect(GTK_OBJECT(widget),
                                   "delete_event",
                                   GTK_SIGNAL_FUNC(App::close_scan_event_cb),
                                   this);
        }else{
                widget = NULL;
        }
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_object_set_data (GTK_OBJECT (widget), "vbox", vbox);
        gtk_widget_show (vbox);
  
        if(widget)
                gtk_container_add (GTK_CONTAINER (widget), vbox);
        else
                // we are only a pure widget
                widget=vbox;
        XSM_DEBUG(DBG_L2, "V3dControl::WidgetInit done." );
}

V3dControl::V3dControl (char *title, int ChNo, Scan *sc, 
                        GCallback realize,
                        GCallback configure_event,
                        GCallback expose_event,
                        void *vdata){
        GtkWidget *statusbar;
        GdkGLConfig *glconfig;
        gint major, minor;

        XSM_DEBUG(DBG_L2, "V3dControl::V3dControl" );

        WheelFkt = &Surf3d::Zoom;
        scan = sc;
        chno=ChNo;

        AppWidgetInit(title);
        gtk_object_set_data  (GTK_OBJECT (widget), "Ch", (void*)ChNo);
        gtk_object_set_data  (GTK_OBJECT (widget), "ChNo", (void*)(ChNo+1));
        gapp->configure_drop_on_widget(widget);

        gtk_window_set_default_size(GTK_WINDOW(widget), 300, 200);

        // Perform the resizes immediately
        gtk_container_set_resize_mode (GTK_CONTAINER (widget), GTK_RESIZE_IMMEDIATE);

        // Get automatically redrawn if any of their children changed allocation
        gtk_container_set_reallocate_redraws (GTK_CONTAINER (widget), TRUE);

        /*
         * Query OpenGL extension version.
         */
        
        gdk_gl_query_version (&major, &minor);
        XSM_DEBUG(DBG_L2, "OpenGL extension version - " << major << "." << minor);

        /*
         * Configure OpenGL-capable visual.
         */

        /* Try double-buffered visual */
        glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode) (GDK_GL_MODE_RGB    |
                                                                 GDK_GL_MODE_DEPTH  |
                                                                 GDK_GL_MODE_DOUBLE));

        if (glconfig == NULL)
        {
                XSM_DEBUG (DBG_L2, 
                           "*** Cannot find the double-buffered visual.\n"
                           "*** Trying single-buffered visual.");
                
                /* Try single-buffered visual */
                glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode) (GDK_GL_MODE_RGB   |
                                                                         GDK_GL_MODE_DEPTH));
                if (glconfig == NULL)
                {
                        XSM_DEBUG (DBG_L2, "*** No appropriate OpenGL-capable visual found.");
                        //                      glarea = gtk_label_new (gdk_gl_get_info ());
                        glarea = gtk_label_new ("No appropriate OpenGL-capable visual found.");
                }
        }

        if (glconfig){
                glarea = gtk_drawing_area_new ();

                gtk_widget_set_size_request (glarea, 300, 200);

                /* Set OpenGL-capability to the widget. */
                gtk_widget_set_gl_capability (glarea,
                                              glconfig,
                                              NULL,
                                              TRUE,
                                              GDK_GL_RGBA_TYPE);
                
                gtk_widget_add_events (glarea,
                                       GDK_BUTTON1_MOTION_MASK    |
                                       GDK_BUTTON2_MOTION_MASK    |
                                       GDK_BUTTON_PRESS_MASK      |
                                       GDK_VISIBILITY_NOTIFY_MASK);
                
                g_signal_connect_after (G_OBJECT (glarea), "realize",
                                        G_CALLBACK (realize), NULL);
                g_signal_connect (G_OBJECT (glarea), "configure_event",
                                  G_CALLBACK (configure_event), NULL);
                g_signal_connect (G_OBJECT (glarea), "expose_event",
                                  G_CALLBACK (expose_event), NULL);
                
        }
        
        // put glarea into window and show it all
        gtk_box_pack_start (GTK_BOX (vbox), glarea, TRUE, TRUE, 0);
        gtk_widget_show (GTK_WIDGET (glarea));
        
        gtk_signal_connect (GTK_OBJECT (glarea), "event",
                            (GtkSignalFunc) V3dControl::glarea_event_cb,
                            this);

        // New Statusbar
        statusbar = gtk_statusbar_new ();
        gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, TRUE, 0);
        gtk_widget_show (statusbar);

        // New PopUp Menu
        VPopup = gnome_popup_menu_new (scan_v3d_popup_menu);
        gnome_popup_menu_attach (VPopup, glarea, this);

        gtk_object_set_data (GTK_OBJECT (glarea), "vdata", vdata);
        gtk_object_set_data (GTK_OBJECT (glarea), "statusbar", statusbar);
        gtk_object_set_data (GTK_OBJECT (glarea), "Ch", (void*)ChNo);
        gtk_object_set_data (GTK_OBJECT (glarea), "V3dControl", this);
        gtk_object_set_data (GTK_OBJECT (glarea), "viewpopup", VPopup);

        gtk_widget_show (widget);
        XSM_DEBUG(DBG_L2, "V3dControl::V3dControl done." );
}

V3dControl::~V3dControl (){
        XSM_DEBUG(DBG_L2, "~V3dControl in" );
        gtk_widget_destroy (glarea);
        XSM_DEBUG(DBG_L2, "~V3dControl out" );
}

void V3dControl::SetTitle(char *title){
        gtk_window_set_title (GTK_WINDOW (widget), title);
        CheckOptions();
}

void V3dControl::SetActive(int flg){
        GtkWidget *statusbar = (GtkWidget*)gtk_object_get_data (GTK_OBJECT (glarea), "statusbar");
        gint statusid  = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "drag");

        if(flg){
                gtk_statusbar_push(GTK_STATUSBAR(statusbar), statusid, "channel is active now");
        }else{
                gtk_statusbar_push(GTK_STATUSBAR(statusbar), statusid, "inactive");
        }
}

void V3dControl::CheckOptions(){
        GtkWidget *menushell;
        GtkWidget *menuitem;
        gint pos;
        gchar *vmode=NULL;

        switch(scan->GetVM()){
        case SCAN_V_DIRECT: vmode=g_strconcat(_("View"),"/Direct", NULL); break;
        case SCAN_V_QUICK:  vmode=g_strconcat(_("View"),"/Quick", NULL); break;
        case SCAN_V_LOG:    vmode=g_strconcat(_("View"),"/Logarithmic", NULL); break;
        case SCAN_V_DIFFERENTIAL:    vmode=g_strconcat(_("View"),"/Differential", NULL); break;
        case SCAN_V_PERIODIC:    vmode=g_strconcat(_("View"),"/Periodic", NULL); break;
        }
        if(vmode){
                menushell = (GtkWidget*)gnome_app_find_menu_pos 
                        (
                                (GtkWidget*)gtk_object_get_data (GTK_OBJECT (glarea), "viewpopup"), 
                                vmode, 
                                &pos
                                );
                g_free(vmode);
                if(menushell){
                        menuitem = (GtkWidget*)g_list_nth_data(GTK_MENU_SHELL (menushell) -> children, --pos);
                        if(menuitem)
                                //      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
                                ; // crshed. :=(
                }
        }
}

gint V3dControl::glarea_event_cb(GtkWidget *glarea, GdkEvent *event, V3dControl *vc){
        static int dragging=FALSE;
        static int busy=0;
        static double xs,ys;
        //  gchar *mld;
        //  GdkCursor *fleur;
        double x,y;
        x = event->button.x;
        y = event->button.y;
        switch (event->type) 
        {
        case GDK_BUTTON_PRESS:
                switch(event->button.button) 
                {
                case 1: 
                        dragging=TRUE;
                        xs=x; ys=y;
                        break;
                case 2:
                        dragging=TRUE;
                        xs=x; ys=y;
                        break;
                case 3: 
                        break;
                case 4:
                        (((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->*(vc->WheelFkt))(1.0);
                        break;
                case 5:
                        (((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->*(vc->WheelFkt))(-1.0);
                        break;
                }
                break;

        case GDK_MOTION_NOTIFY:
                if(!busy){
                        busy=1;
                        if (dragging && (event->motion.state & GDK_BUTTON1_MASK)){
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->Rotate(1, xs-x);
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->Rotate(2, y-ys);
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->GLdrawscene(); 
                                xs=x; ys=y;
                        }
                        if (dragging && (event->motion.state & GDK_BUTTON2_MASK)){
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->Translate(0, x-xs);
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->Translate(1, ys-y);
                                ((Surf3d*)gtk_object_get_data (GTK_OBJECT (glarea), "vdata"))->GLdrawscene(); 
                                xs=x; ys=y;
                        }
                        busy=0;
                }
                break;

        case GDK_BUTTON_RELEASE:
                switch(event->button.button){
                case 1:
                        dragging=FALSE;
                        break;
                case 2:
                        dragging=FALSE;
                        break;
                }
                break;
        default: break;
        }
        return FALSE;
}

void V3dControl::Activate_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->ActivateChannel(vc->chno);
}
void V3dControl::SetOff_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->SetMode(vc->chno, ID_CH_M_OFF);
}
void V3dControl::SetOn_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->SetMode(vc->chno, ID_CH_M_ON);
}
void V3dControl::SetMath_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->SetMode(vc->chno, ID_CH_M_MATH);
}
void V3dControl::SetX_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->SetMode(vc->chno, ID_CH_M_X);
}

void V3dControl::AutoDisp_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->ActivateChannel(vc->chno);
        gapp->xsm->AutoDisplay();
}

void V3dControl::apply_all_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))
                ->GLupdate(gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"));
}

void V3dControl::view_file_openhere_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->ActivateChannel(vc->chno);
        gapp->xsm->load();
}

void V3dControl::view_file_save_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->save(TRUE, NULL, vc->chno);
}

void V3dControl::view_file_save_as_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->save(FALSE, NULL, vc->chno);
}

void V3dControl::view_file_save_image_callback (GtkWidget *widget, V3dControl *vc){
        XSM_DEBUG(DBG_L2, "Sorry, I'm working on!" );
//      ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
//              save_to_image(imagename);
}

void V3dControl::view_file_print_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->ActivateChannel(vc->chno);
        gapp->file_print_callback(widget, NULL);
}

void V3dControl::view_file_kill_callback (GtkWidget *widget, V3dControl *vc){
        gapp->xsm->SetMode(vc->chno, ID_CH_M_OFF);
}

// ---------------

void V3dControl::view_view_direct_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active){
                //    vc->scan->SetVM(SCAN_V_DIRECT);
                gapp->xsm->ActivateChannel(vc->chno);
                gapp->xsm->SetVM(SCAN_V_DIRECT);
        }
}

void V3dControl::view_view_quick_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active){
                //    vc->scan->SetVM(SCAN_V_QUICK);
                gapp->xsm->ActivateChannel(vc->chno);    
                gapp->xsm->SetVM(SCAN_V_QUICK);
        }
}

void V3dControl::view_view_log_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active){
                //    vc->scan->SetVM(SCAN_V_LOG);
                gapp->xsm->ActivateChannel(vc->chno);
                gapp->xsm->SetVM(SCAN_V_LOG);
        }
}

void V3dControl::view_view_horizont_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active){
                //    vc->scan->SetVM(SCAN_V_HORIZONTAL);
                gapp->xsm->ActivateChannel(vc->chno);
                gapp->xsm->SetVM(SCAN_V_HORIZONTAL);
        }
}

void V3dControl::view_view_periodic_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active)
                //    vc->scan->SetVM(SCAN_V_PERIODIC);
                gapp->xsm->ActivateChannel(vc->chno);
        gapp->xsm->SetVM(SCAN_V_PERIODIC);
}

void V3dControl::view_view_differential_callback (GtkWidget *widget, V3dControl *vc){
        if (GTK_CHECK_MENU_ITEM (widget)->active)
                //    vc->scan->SetVM(SCAN_V_DIFFERENTIAL);
                gapp->xsm->ActivateChannel(vc->chno);
        gapp->xsm->SetVM(SCAN_V_DIFFERENTIAL);
}

void V3dControl::view_GL_Mesh_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
                GLModes(ID_GL_Mesh, (GTK_CHECK_MENU_ITEM (widget)->active));
}
void V3dControl::view_GL_Ticks_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
                GLModes(ID_GL_Ticks, (GTK_CHECK_MENU_ITEM (widget)->active));
}
void V3dControl::view_GL_Smooth_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
                GLModes(ID_GL_Smooth, (GTK_CHECK_MENU_ITEM (widget)->active));
}
void V3dControl::view_GL_nZP_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
                GLModes(ID_GL_nZP, (GTK_CHECK_MENU_ITEM (widget)->active));
}

void V3dControl::view_GL_Wh_zoom_callback (GtkWidget *widget, V3dControl *vc){
        if( GTK_CHECK_MENU_ITEM (widget)->active )
                vc->WheelFkt = &Surf3d::Zoom; 
}
void V3dControl::view_GL_Wh_rotX_callback (GtkWidget *widget, V3dControl *vc){
        if( GTK_CHECK_MENU_ITEM (widget)->active )
                vc->WheelFkt = &Surf3d::RotateX;
}
void V3dControl::view_GL_Wh_rotY_callback (GtkWidget *widget, V3dControl *vc){
        if( GTK_CHECK_MENU_ITEM (widget)->active )
                vc->WheelFkt = &Surf3d::RotateY;
}
void V3dControl::view_GL_Wh_rotZ_callback (GtkWidget *widget, V3dControl *vc){
        if( GTK_CHECK_MENU_ITEM (widget)->active )
                vc->WheelFkt = &Surf3d::RotateZ;
}
void V3dControl::view_GL_Wh_Zskl_callback (GtkWidget *widget, V3dControl *vc){
        if( GTK_CHECK_MENU_ITEM (widget)->active )
                vc->WheelFkt = &Surf3d::HeightSkl; 
}

void V3dControl::preferences_callback (GtkWidget *widget, V3dControl *vc){
        ((Surf3d*)gtk_object_get_data (GTK_OBJECT (vc->glarea), "vdata"))->
                preferences();
}

---