contrib/camera/dialogs.cpp

   1 /*
   2    Copyright (C) 1999-2007 id Software, Inc. and contributors.
   3    For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 /*
  23    Camera plugin for GtkRadiant
  24    Copyright (C) 2002 Splash Damage Ltd.
  25  */
  26
  27 #include "camera.h"
  28
  29 #include <glib.h>
  30 #include <glib/gi18n.h>
  31
  32 static GSList *g_pEditTypeRadio = NULL;
  33 static GtkWidget *g_pEditModeEditRadioButton = NULL;
  34 GtkWidget *g_pEditModeAddRadioButton = NULL;
  35 static GtkWidget *g_pSecondsEntry = NULL;
  36 static GtkWidget *g_pEventsList = NULL;
  37 static GtkLabel *g_pCurrentTime = NULL;
  38 static GtkLabel *g_pTotalTime = NULL;
  39 static GtkAdjustment *g_pTimeLine = NULL;
  40 static GtkWidget *g_pTrackCamera = NULL;
  41 static GtkWidget *g_pCamName = NULL;
  42 static char *g_cNull = '\0';
  43
  44 static gint ci_editmode_edit( GtkWidget *widget, gpointer data ){
  45         g_iEditMode = 0;
  46
  47         return TRUE;
  48 }
  49
  50 static gint ci_editmode_add( GtkWidget *widget, gpointer data ){
  51         g_iEditMode = 1;
  52
  53         return TRUE;
  54 }
  55
  56 /*static gint ci_delete_selected( GtkWidget *widget, gpointer data )
  57    {
  58    return TRUE;
  59    }
  60
  61    static gint ci_select_all( GtkWidget *widget, gpointer data )
  62    {
  63    return TRUE;
  64    }*/
  65
  66 static gint ci_new( GtkWidget *widget, gpointer data ){
  67         GtkWidget *window, *w, *vbox, *vbox2, *hbox, *frame; //, *name;
  68         GtkWidget *fixed, *interpolated, *spline;
  69         int ret, loop = 1;
  70         GSList *targetTypeRadio = NULL;
  71 //      char buf[128];
  72
  73         // create the window
  74         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
  75         gtk_window_set_title( GTK_WINDOW( window ), "New Camera" );
  76         gtk_signal_connect( GTK_OBJECT( window ), "delete_event", GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
  77         gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
  78         gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pCameraInspectorWnd ) );
  79
  80         g_object_set_data( G_OBJECT( window ), "loop", &loop );
  81         g_object_set_data( G_OBJECT( window ), "ret", &ret );
  82
  83         gtk_widget_realize( window );
  84
  85         // fill the window
  86         vbox = gtk_vbox_new( FALSE, 5 );
  87         gtk_container_add( GTK_CONTAINER( window ), vbox );
  88         gtk_widget_show( vbox );
  89
  90         // -------------------------- //
  91
  92         hbox = gtk_hbox_new( FALSE, 5 );
  93         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
  94         gtk_widget_show( hbox );
  95
  96         frame = gtk_frame_new( _( "Type" ) );
  97         gtk_box_pack_start( GTK_BOX( hbox ), frame, TRUE, TRUE, 0 );
  98         gtk_widget_show( frame );
  99
 100         vbox2 = gtk_vbox_new( FALSE, 5 );
 101         gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
 102         gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 );
 103         gtk_widget_show( vbox2 );
 104
 105         // -------------------------- //
 106
 107         fixed = gtk_radio_button_new_with_label( targetTypeRadio, "Fixed" );
 108         gtk_box_pack_start( GTK_BOX( vbox2 ), fixed, FALSE, FALSE, 3 );
 109         gtk_widget_show( fixed );
 110         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( fixed ) );
 111
 112         interpolated = gtk_radio_button_new_with_label( targetTypeRadio, "Interpolated" );
 113         gtk_box_pack_start( GTK_BOX( vbox2 ), interpolated, FALSE, FALSE, 3 );
 114         gtk_widget_show( interpolated );
 115         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( interpolated ) );
 116
 117         spline = gtk_radio_button_new_with_label( targetTypeRadio, "Spline" );
 118         gtk_box_pack_start( GTK_BOX( vbox2 ), spline, FALSE, FALSE, 3 );
 119         gtk_widget_show( spline );
 120         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( spline ) );
 121
 122         // -------------------------- //
 123
 124         w = gtk_hseparator_new();
 125         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
 126         gtk_widget_show( w );
 127
 128         // -------------------------- //
 129
 130         hbox = gtk_hbox_new( FALSE, 5 );
 131         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 132         gtk_widget_show( hbox );
 133
 134         w = gtk_button_new_with_label( "Ok" );
 135         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 136         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
 137         gtk_widget_show( w );
 138
 139         GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
 140         gtk_widget_grab_default( w );
 141
 142         w = gtk_button_new_with_label( "Cancel" );
 143         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 144         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
 145         gtk_widget_show( w );
 146         ret = IDCANCEL;
 147
 148         // -------------------------- //
 149
 150         gtk_window_set_position( GTK_WINDOW( window ),GTK_WIN_POS_CENTER );
 151         gtk_widget_show( window );
 152         gtk_grab_add( window );
 153
 154         bool dialogError = TRUE;
 155         while ( dialogError ) {
 156                 loop = 1;
 157                 while ( loop )
 158                         gtk_main_iteration();
 159
 160                 dialogError = FALSE;
 161
 162                 if ( ret == IDOK ) {
 163                         if ( gtk_toggle_button_get_active( (GtkToggleButton*)fixed ) ) {
 164                                 DoNewFixedCamera();
 165                         }
 166                         else if ( gtk_toggle_button_get_active( (GtkToggleButton*)interpolated ) ) {
 167                                 DoNewInterpolatedCamera();
 168                         }
 169                         else if ( gtk_toggle_button_get_active( (GtkToggleButton*)spline ) ) {
 170                                 DoNewSplineCamera();
 171                         }
 172                 }
 173         }
 174
 175         gtk_grab_remove( window );
 176         gtk_widget_destroy( window );
 177
 178         return TRUE;
 179 }
 180
 181 static gint ci_load( GtkWidget *widget, gpointer data ){
 182         DoLoadCamera();
 183
 184         return TRUE;
 185 }
 186
 187 static gint ci_save( GtkWidget *widget, gpointer data ){
 188         DoSaveCamera();
 189
 190         return TRUE;
 191 }
 192
 193 static gint ci_unload( GtkWidget *widget, gpointer data ){
 194         DoUnloadCamera();
 195
 196         return TRUE;
 197 }
 198
 199 static gint ci_apply( GtkWidget *widget, gpointer data ){
 200         if ( GetCurrentCam() ) {
 201                 const char *str;
 202                 char buf[128];
 203                 bool build = false;
 204
 205                 str = gtk_entry_get_text( GTK_ENTRY( g_pCamName ) );
 206
 207                 if ( str ) {
 208                         GetCurrentCam()->GetCam()->setName( str );
 209                         build = true;
 210                 }
 211
 212                 str = gtk_entry_get_text( GTK_ENTRY( g_pSecondsEntry ) );
 213
 214                 if ( str ) {
 215                         GetCurrentCam()->GetCam()->setBaseTime( atof( str ) );
 216                         build = true;
 217                 }
 218
 219                 if ( build ) {
 220                         GetCurrentCam()->GetCam()->buildCamera();
 221                 }
 222
 223                 sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getBaseTime() );
 224                 gtk_entry_set_text( GTK_ENTRY( g_pSecondsEntry ), buf );
 225
 226                 sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getTotalTime() );
 227                 gtk_label_set_text( g_pCurrentTime, "0.00" );
 228                 gtk_label_set_text( g_pTotalTime, buf );
 229
 230                 gtk_adjustment_set_value( g_pTimeLine, 0.f );
 231                 g_pTimeLine->upper = GetCurrentCam()->GetCam()->getTotalTime() * 1000;
 232
 233                 GetCurrentCam()->HasBeenModified();
 234         }
 235
 236         return TRUE;
 237 }
 238
 239 static gint ci_preview( GtkWidget *widget, gpointer data ){
 240         if ( GetCurrentCam() ) {
 241                 g_iPreviewRunning = 1;
 242                 g_FuncTable.m_pfnSysUpdateWindows( W_XY_OVERLAY | W_CAMERA );
 243         }
 244
 245         return TRUE;
 246 }
 247
 248 static gint ci_expose( GtkWidget *widget, gpointer data ){
 249         // start edit mode
 250         DoStartEdit( GetCurrentCam() );
 251
 252         return FALSE;
 253 }
 254
 255 static gint ci_close( GtkWidget *widget, gpointer data ){
 256         gtk_widget_hide( g_pCameraInspectorWnd );
 257
 258         // exit edit mode
 259         DoStopEdit();
 260
 261         return TRUE;
 262 }
 263
 264 static GtkWidget *g_pPathListCombo = NULL;
 265 static GtkLabel *g_pPathType = NULL;
 266
 267 static void RefreshPathListCombo( void ){
 268         if ( !g_pPathListCombo ) {
 269                 return;
 270         }
 271
 272         GList *combo_list = (GList*)NULL;
 273
 274         if ( GetCurrentCam() ) {
 275                 combo_list = g_list_append( combo_list, (void *)GetCurrentCam()->GetCam()->getPositionObj()->getName() );
 276                 for ( int i = 0; i < GetCurrentCam()->GetCam()->numTargets(); i++ ) {
 277                         combo_list = g_list_append( combo_list, (void *)GetCurrentCam()->GetCam()->getActiveTarget( i )->getName() );
 278                 }
 279         }
 280         else {
 281                 // add one empty string make gtk be quiet
 282                 combo_list = g_list_append( combo_list, (gpointer)g_cNull );
 283         }
 284
 285         gtk_combo_set_popdown_strings( GTK_COMBO( g_pPathListCombo ), combo_list );
 286         g_list_free( combo_list );
 287 }
 288
 289 static gint ci_pathlist_changed( GtkWidget *widget, gpointer data ){
 290         const char *str = gtk_entry_get_text( GTK_ENTRY( widget ) );
 291
 292         if ( !str || !GetCurrentCam() ) {
 293                 return TRUE;
 294         }
 295
 296         int i;
 297         for ( i = 0; i < GetCurrentCam()->GetCam()->numTargets(); i++ ) {
 298                 if ( !strcmp( str, GetCurrentCam()->GetCam()->getActiveTarget( i )->getName() ) ) {
 299                         break;
 300                 }
 301         }
 302
 303         if ( i >= 0 && i < GetCurrentCam()->GetCam()->numTargets() ) {
 304                 GetCurrentCam()->GetCam()->setActiveTarget( i );
 305
 306                 g_iActiveTarget = i;
 307                 if ( g_pPathType ) {
 308                         gtk_label_set_text( g_pPathType, GetCurrentCam()->GetCam()->getActiveTarget( g_iActiveTarget )->typeStr() );
 309                 }
 310         }
 311         else {
 312                 g_iActiveTarget = -1;
 313                 if ( g_pPathType ) {
 314                         gtk_label_set_text( g_pPathType, GetCurrentCam()->GetCam()->getPositionObj()->typeStr() );
 315                 }
 316         }
 317
 318         // start edit mode
 319         if ( g_pCameraInspectorWnd && GTK_WIDGET_VISIBLE( g_pCameraInspectorWnd ) ) {
 320                 DoStartEdit( GetCurrentCam() );
 321         }
 322
 323         return TRUE;
 324 }
 325
 326 static void RefreshEventList( void ){
 327         int i;
 328         char buf[128];
 329
 330         // Clear events list
 331         gtk_clist_freeze( GTK_CLIST( g_pEventsList ) );
 332         gtk_clist_clear( GTK_CLIST( g_pEventsList ) );
 333
 334         if ( GetCurrentCam() ) {
 335                 // Fill events list
 336                 for ( i = 0; i < GetCurrentCam()->GetCam()->numEvents(); i++ ) {
 337                         char rowbuf[3][128], *row[3];
 338                         // FIXME: sort by time?
 339                         sprintf( rowbuf[0], "%li", GetCurrentCam()->GetCam()->getEvent( i )->getTime() );                 row[0] = rowbuf[0];
 340                         strncpy( rowbuf[1], GetCurrentCam()->GetCam()->getEvent( i )->typeStr(), sizeof( rowbuf[0] ) );     row[1] = rowbuf[1];
 341                         strncpy( rowbuf[2], GetCurrentCam()->GetCam()->getEvent( i )->getParam(), sizeof( rowbuf[1] ) );    row[2] = rowbuf[2];
 342                         gtk_clist_append( GTK_CLIST( g_pEventsList ), row );
 343                 }
 344
 345                 // Total duration might have changed
 346                 sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getTotalTime() );
 347                 gtk_label_set_text( g_pCurrentTime, "0.00" );
 348                 gtk_label_set_text( g_pTotalTime, buf );
 349
 350                 gtk_adjustment_set_value( g_pTimeLine, 0.f );
 351                 g_pTimeLine->upper = ( GetCurrentCam()->GetCam()->getTotalTime() * 1000 );
 352         }
 353
 354         gtk_clist_thaw( GTK_CLIST( g_pEventsList ) );
 355 }
 356
 357 static gint ci_rename( GtkWidget *widget, gpointer data ){
 358         GtkWidget *window, *w, *vbox, *hbox, *name;
 359         int ret, loop = 1;
 360
 361         if ( !GetCurrentCam() ) {
 362                 return TRUE;
 363         }
 364
 365         // create the window
 366         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 367         gtk_window_set_title( GTK_WINDOW( window ), "Rename Path" );
 368         gtk_signal_connect( GTK_OBJECT( window ), "delete_event", GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
 369         gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
 370         gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pCameraInspectorWnd ) );
 371
 372         g_object_set_data( G_OBJECT( window ), "loop", &loop );
 373         g_object_set_data( G_OBJECT( window ), "ret", &ret );
 374
 375         gtk_widget_realize( window );
 376
 377         // fill the window
 378         vbox = gtk_vbox_new( FALSE, 5 );
 379         gtk_container_add( GTK_CONTAINER( window ), vbox );
 380         gtk_widget_show( vbox );
 381
 382         // -------------------------- //
 383
 384         hbox = gtk_hbox_new( FALSE, 5 );
 385         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 386         gtk_widget_show( hbox );
 387
 388         w = gtk_label_new( "Name:" );
 389         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
 390         gtk_widget_show( w );
 391
 392         name = gtk_entry_new();
 393         gtk_box_pack_start( GTK_BOX( hbox ), name, FALSE, FALSE, 0 );
 394         gtk_widget_show( name );
 395
 396         if ( g_iActiveTarget < 0 ) {
 397                 gtk_entry_set_text( GTK_ENTRY( name ), GetCurrentCam()->GetCam()->getPositionObj()->getName() );
 398         }
 399         else{
 400                 gtk_entry_set_text( GTK_ENTRY( name ), GetCurrentCam()->GetCam()->getActiveTarget( g_iActiveTarget )->getName() );
 401         }
 402
 403         // -------------------------- //
 404
 405         w = gtk_hseparator_new();
 406         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
 407         gtk_widget_show( w );
 408
 409         // -------------------------- //
 410
 411         hbox = gtk_hbox_new( FALSE, 5 );
 412         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 413         gtk_widget_show( hbox );
 414
 415         w = gtk_button_new_with_label( "Ok" );
 416         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 417         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
 418         gtk_widget_show( w );
 419
 420         GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
 421         gtk_widget_grab_default( w );
 422
 423         w = gtk_button_new_with_label( "Cancel" );
 424         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 425         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
 426         gtk_widget_show( w );
 427         ret = IDCANCEL;
 428
 429         // -------------------------- //
 430
 431         gtk_window_set_position( GTK_WINDOW( window ),GTK_WIN_POS_CENTER );
 432         gtk_widget_show( window );
 433         gtk_grab_add( window );
 434
 435         bool dialogError = TRUE;
 436         while ( dialogError ) {
 437                 loop = 1;
 438                 while ( loop )
 439                         gtk_main_iteration();
 440
 441                 dialogError = FALSE;
 442
 443                 if ( ret == IDOK ) {
 444                         const char *str = gtk_entry_get_text( GTK_ENTRY( name ) );
 445
 446                         if ( str && str[0] ) {
 447                                 // Update the path
 448                                 if ( g_iActiveTarget < 0 ) {
 449                                         GetCurrentCam()->GetCam()->getPositionObj()->setName( str );
 450                                 }
 451                                 else{
 452                                         GetCurrentCam()->GetCam()->getActiveTarget( g_iActiveTarget )->setName( str );
 453                                 }
 454
 455                                 GetCurrentCam()->GetCam()->buildCamera();
 456
 457                                 // Rebuild the listbox
 458                                 RefreshPathListCombo();
 459                         }
 460                         else {
 461                                 dialogError = TRUE;
 462                         }
 463                 }
 464         }
 465
 466         gtk_grab_remove( window );
 467         gtk_widget_destroy( window );
 468
 469         return TRUE;
 470 }
 471
 472 static gint ci_add_target( GtkWidget *widget, gpointer data ){
 473         GtkWidget *window, *w, *vbox, *vbox2, *hbox, *frame, *name;
 474         GtkWidget *fixed, *interpolated, *spline;
 475         int ret, loop = 1;
 476         GSList *targetTypeRadio = NULL;
 477         char buf[128];
 478
 479         if ( !GetCurrentCam() ) {
 480                 return TRUE;
 481         }
 482
 483         // create the window
 484         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 485         gtk_window_set_title( GTK_WINDOW( window ), "Add Target" );
 486         gtk_signal_connect( GTK_OBJECT( window ), "delete_event", GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
 487         gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
 488         gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pCameraInspectorWnd ) );
 489
 490         g_object_set_data( G_OBJECT( window ), "loop", &loop );
 491         g_object_set_data( G_OBJECT( window ), "ret", &ret );
 492
 493         gtk_widget_realize( window );
 494
 495         // fill the window
 496         vbox = gtk_vbox_new( FALSE, 5 );
 497         gtk_container_add( GTK_CONTAINER( window ), vbox );
 498         gtk_widget_show( vbox );
 499
 500         // -------------------------- //
 501
 502         hbox = gtk_hbox_new( FALSE, 5 );
 503         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 504         gtk_widget_show( hbox );
 505
 506         w = gtk_label_new( "Name:" );
 507         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
 508         gtk_widget_show( w );
 509
 510         name = gtk_entry_new();
 511         gtk_box_pack_start( GTK_BOX( hbox ), name, TRUE, TRUE, 0 );
 512         gtk_widget_show( name );
 513
 514         sprintf( buf, "target%i", GetCurrentCam()->GetCam()->numTargets() + 1 );
 515         gtk_entry_set_text( GTK_ENTRY( name ), buf );
 516
 517         // -------------------------- //
 518
 519         hbox = gtk_hbox_new( FALSE, 5 );
 520         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 521         gtk_widget_show( hbox );
 522
 523         frame = gtk_frame_new( _( "Type" ) );
 524         gtk_box_pack_start( GTK_BOX( hbox ), frame, TRUE, TRUE, 0 );
 525         gtk_widget_show( frame );
 526
 527         vbox2 = gtk_vbox_new( FALSE, 5 );
 528         gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
 529         gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 );
 530         gtk_widget_show( vbox2 );
 531
 532         // -------------------------- //
 533
 534         fixed = gtk_radio_button_new_with_label( targetTypeRadio, _( "Fixed" ) );
 535         gtk_box_pack_start( GTK_BOX( vbox2 ), fixed, FALSE, FALSE, 3 );
 536         gtk_widget_show( fixed );
 537         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( fixed ) );
 538
 539         interpolated = gtk_radio_button_new_with_label( targetTypeRadio, _( "Interpolated" ) );
 540         gtk_box_pack_start( GTK_BOX( vbox2 ), interpolated, FALSE, FALSE, 3 );
 541         gtk_widget_show( interpolated );
 542         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( interpolated ) );
 543
 544         spline = gtk_radio_button_new_with_label( targetTypeRadio, _( "Spline" ) );
 545         gtk_box_pack_start( GTK_BOX( vbox2 ), spline, FALSE, FALSE, 3 );
 546         gtk_widget_show( spline );
 547         targetTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( spline ) );
 548
 549         // -------------------------- //
 550
 551         w = gtk_hseparator_new();
 552         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
 553         gtk_widget_show( w );
 554
 555         // -------------------------- //
 556
 557         hbox = gtk_hbox_new( FALSE, 5 );
 558         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 559         gtk_widget_show( hbox );
 560
 561         w = gtk_button_new_with_label( _( "Ok" ) );
 562         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 563         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
 564         gtk_widget_show( w );
 565
 566         GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
 567         gtk_widget_grab_default( w );
 568
 569         w = gtk_button_new_with_label( _( "Cancel" ) );
 570         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 571         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
 572         gtk_widget_show( w );
 573         ret = IDCANCEL;
 574
 575         // -------------------------- //
 576
 577         gtk_window_set_position( GTK_WINDOW( window ),GTK_WIN_POS_CENTER );
 578         gtk_widget_show( window );
 579         gtk_grab_add( window );
 580
 581         bool dialogError = TRUE;
 582         while ( dialogError ) {
 583                 loop = 1;
 584                 while ( loop )
 585                         gtk_main_iteration();
 586
 587                 dialogError = FALSE;
 588
 589                 if ( ret == IDOK ) {
 590                         const char *str = gtk_entry_get_text( GTK_ENTRY( name ) );
 591
 592                         if ( str && str[0] ) {
 593                                 int type;
 594                                 GList *li;
 595
 596                                 if ( gtk_toggle_button_get_active( (GtkToggleButton*)fixed ) ) {
 597                                         type = 0;
 598                                 }
 599                                 else if ( gtk_toggle_button_get_active( (GtkToggleButton*)interpolated ) ) {
 600                                         type = 1;
 601                                 }
 602                                 else if ( gtk_toggle_button_get_active( (GtkToggleButton*)spline ) ) {
 603                                         type = 2;
 604                                 }
 605
 606                                 // Add the target
 607                                 GetCurrentCam()->GetCam()->addTarget( str, static_cast<idCameraPosition::positionType>( type ) );
 608
 609                                 // Rebuild the listbox
 610                                 RefreshPathListCombo();
 611
 612                                 // Select the last item in the listbox
 613                                 li = g_list_last( GTK_LIST( GTK_COMBO( g_pPathListCombo )->list )->children );
 614                                 gtk_list_select_child( GTK_LIST( GTK_COMBO( g_pPathListCombo )->list ), GTK_WIDGET( li->data ) );
 615
 616                                 // If this was the first one, refresh the event list
 617                                 if ( GetCurrentCam()->GetCam()->numTargets() == 1 ) {
 618                                         RefreshEventList();
 619                                 }
 620
 621                                 // Go to editmode Add
 622                                 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( g_pEditModeAddRadioButton ), TRUE );
 623
 624                         }
 625                         else {
 626                                 dialogError = TRUE;
 627                         }
 628                 }
 629         }
 630
 631         gtk_grab_remove( window );
 632         gtk_widget_destroy( window );
 633
 634         return TRUE;
 635 }
 636
 637 static GtkWidget *g_pCamListCombo = NULL;
 638 static GtkLabel *g_pCamType = NULL;
 639
 640 void RefreshCamListCombo( void ){
 641         if ( !g_pCamListCombo ) {
 642                 return;
 643         }
 644
 645         GList *combo_list = (GList*)NULL;
 646         CCamera *combo_cam = firstCam;
 647         if ( combo_cam ) {
 648                 while ( combo_cam ) {
 649                         //combo_list = g_list_append( combo_list, (void *)combo_cam->GetCam()->getName() );
 650                         //if( combo_cam->HasBeenSaved() ) {
 651                         combo_list = g_list_append( combo_list, (void *)combo_cam->GetFileName() );
 652                         /*} else {
 653                             char buf[128];
 654                             sprintf( buf, "Unsaved Camera %i", combo_cam->GetCamNum() );
 655                             combo_list = g_list_append( combo_list, (void *)buf );
 656
 657                             //combo_list = g_list_append( combo_list, (void *)combo_cam->GetCam()->getName() ); // FIXME: this requires camera.dll to create unique names for new cams
 658                            }*/
 659                         combo_cam = combo_cam->GetNext();
 660                 }
 661         }
 662         else {
 663                 // add one empty string make gtk be quiet
 664                 combo_list = g_list_append( combo_list, (gpointer)g_cNull );
 665         }
 666         gtk_combo_set_popdown_strings( GTK_COMBO( g_pCamListCombo ), combo_list );
 667         g_list_free( combo_list );
 668
 669         // select our current entry in the list
 670         if ( GetCurrentCam() ) {
 671                 // stop editing on the current cam
 672                 //GetCurrentCam()->GetCam()->stopEdit();        // FIXME: this crashed on creating new cameras, why is it here?
 673
 674                 GList *li = GTK_LIST( GTK_COMBO( g_pCamListCombo )->list )->children;
 675                 combo_cam = firstCam;
 676                 while ( li && combo_cam ) {
 677                         if ( combo_cam == GetCurrentCam() ) {
 678                                 gtk_list_select_child( GTK_LIST( GTK_COMBO( g_pCamListCombo )->list ), GTK_WIDGET( li->data ) );
 679                                 break;
 680                         }
 681                         li = li->next;
 682                         combo_cam = combo_cam->GetNext();
 683                 }
 684         }
 685
 686         RefreshPathListCombo();
 687 }
 688
 689 static gint ci_camlist_changed( GtkWidget *widget, gpointer data ){
 690         const char *str = gtk_entry_get_text( GTK_ENTRY( widget ) );
 691
 692         CCamera *combo_cam = firstCam;
 693         while ( str && combo_cam ) {
 694                 //if( !strcmp( str, combo_cam->GetCam()->getName() ) )
 695                 //if( combo_cam->HasBeenSaved() ) {
 696                 if ( !strcmp( str, combo_cam->GetFileName() ) ) {
 697                         break;
 698                 }
 699                 /*} else {
 700                     char buf[128];
 701                     sprintf( buf, "Unsaved Camera %i", combo_cam->GetCamNum() );
 702                     if( !strcmp( str, buf ) )
 703                     //if( !strcmp( str, combo_cam->GetCam()->getName() ) )
 704                         break;
 705                    }*/
 706
 707                 combo_cam = combo_cam->GetNext();
 708         }
 709
 710         SetCurrentCam( combo_cam );
 711
 712         if ( g_pCamType ) {
 713                 if ( GetCurrentCam() ) {
 714                         // Fill in our widgets fields for this camera
 715                         char buf[128];
 716
 717                         // Set Name
 718                         gtk_entry_set_text( GTK_ENTRY( g_pCamName ), GetCurrentCam()->GetCam()->getName() );
 719
 720                         // Set type
 721                         gtk_label_set_text( g_pCamType, GetCurrentCam()->GetCam()->getPositionObj()->typeStr() );
 722
 723                         // Set duration
 724                         sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getBaseTime() );
 725                         gtk_entry_set_text( GTK_ENTRY( g_pSecondsEntry ), buf );
 726
 727                         sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getTotalTime() );
 728                         gtk_label_set_text( g_pCurrentTime, "0.00" );
 729                         gtk_label_set_text( g_pTotalTime, buf );
 730
 731                         gtk_adjustment_set_value( g_pTimeLine, 0.f );
 732                         g_pTimeLine->upper = GetCurrentCam()->GetCam()->getTotalTime() * 1000;
 733                 }
 734                 else {
 735                         // Set Name
 736                         gtk_entry_set_text( GTK_ENTRY( g_pCamName ), "" );
 737
 738                         // Set type
 739                         gtk_label_set_text( g_pCamType, "" );
 740
 741                         // Set duration
 742                         gtk_entry_set_text( GTK_ENTRY( g_pSecondsEntry ), "30.00" );
 743
 744                         gtk_label_set_text( g_pCurrentTime, "0.00" );
 745                         gtk_label_set_text( g_pTotalTime, "30.00" );
 746
 747                         gtk_adjustment_set_value( g_pTimeLine, 0.f );
 748                         g_pTimeLine->upper = 30000;
 749                 }
 750
 751                 // Refresh event list
 752                 RefreshEventList();
 753         }
 754
 755         RefreshPathListCombo();
 756
 757         // start edit mode
 758         g_iActiveTarget = -1;
 759         if ( g_pCameraInspectorWnd && GTK_WIDGET_VISIBLE( g_pCameraInspectorWnd ) ) {
 760                 DoStartEdit( GetCurrentCam() );
 761         }
 762
 763         return TRUE;
 764 }
 765
 766 enum camEventType {
 767         EVENT_NA = 0x00,
 768         EVENT_WAIT,             //
 769         EVENT_TARGETWAIT,   //
 770         EVENT_SPEED,            //
 771         EVENT_TARGET,           // char(name)
 772         EVENT_SNAPTARGET,   //
 773         EVENT_FOV,              // int(time), int(targetfov)
 774         EVENT_CMD,              //
 775         EVENT_TRIGGER,      //
 776         EVENT_STOP,             //
 777         EVENT_CAMERA,           //
 778         EVENT_FADEOUT,      // int(time)
 779         EVENT_FADEIN,           // int(time)
 780         EVENT_FEATHER,      //
 781         EVENT_COUNT
 782 };
 783
 784 // { requires parameters, enabled }
 785 const bool camEventFlags[][2] = {
 786         { false, false },
 787         { false, true },
 788         { false, false },
 789         { false, false },
 790         { true, true },
 791         { false, false },
 792         { true, true },
 793         { false, false },
 794         { false, false },
 795         { false, true },
 796         { true, true },
 797         { true, true },
 798         { true, true },
 799         { false, true },
 800 };
 801
 802 const char *camEventStr[] = {
 803         N_( "n/a" ),
 804         N_( "Wait" ),
 805         N_( "Target wait" ),
 806         N_( "Speed" ),
 807         N_( "Change Target <string:name>" ),
 808         N_( "Snap Target" ),
 809         N_( "FOV <int:duration> <int:targetfov>" ),
 810         N_( "Run Script" ),
 811         N_( "Trigger" ),
 812         N_( "Stop" ),
 813         N_( "Change to Camera <string:camera> (or <int:cameranum> <string:camera>" ),
 814         N_( "Fade Out <int:duration>" ),
 815         N_( "Fade In <int:duration>" ),
 816         N_( "Feather" )
 817 };
 818
 819 static gint ci_add( GtkWidget *widget, gpointer data ){
 820         GtkWidget *window, *w, *vbox, *vbox2, *hbox, *frame, *parameters;
 821         GtkWidget *eventWidget[EVENT_COUNT];
 822         int i, ret, loop = 1;
 823         GSList *eventTypeRadio = NULL;
 824 //      char buf[128];
 825
 826         if ( !GetCurrentCam() ) {
 827                 return TRUE;
 828         }
 829
 830         // create the window
 831         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 832         gtk_window_set_title( GTK_WINDOW( window ), _( "Add Event" ) );
 833         gtk_signal_connect( GTK_OBJECT( window ), "delete_event", GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
 834         gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
 835         gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pCameraInspectorWnd ) );
 836
 837         g_object_set_data( G_OBJECT( window ), "loop", &loop );
 838         g_object_set_data( G_OBJECT( window ), "ret", &ret );
 839
 840         gtk_widget_realize( window );
 841
 842         // fill the window
 843         vbox = gtk_vbox_new( FALSE, 5 );
 844         gtk_container_add( GTK_CONTAINER( window ), vbox );
 845         gtk_widget_show( vbox );
 846
 847         // -------------------------- //
 848
 849         hbox = gtk_hbox_new( FALSE, 5 );
 850         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 851         gtk_widget_show( hbox );
 852
 853         frame = gtk_frame_new( _( "Type" ) );
 854         gtk_box_pack_start( GTK_BOX( hbox ), frame, TRUE, TRUE, 0 );
 855         gtk_widget_show( frame );
 856
 857         vbox2 = gtk_vbox_new( FALSE, 5 );
 858         gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
 859         gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 );
 860         gtk_widget_show( vbox2 );
 861
 862         // -------------------------- //
 863
 864         for ( i = 1; i < EVENT_COUNT; i++ ) {
 865                 eventWidget[i] = gtk_radio_button_new_with_label( eventTypeRadio, camEventStr[i] );
 866                 gtk_box_pack_start( GTK_BOX( vbox2 ), eventWidget[i], FALSE, FALSE, 3 );
 867                 gtk_widget_show( eventWidget[i] );
 868                 eventTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( eventWidget[i] ) );
 869                 if ( camEventFlags[i][1] == false ) {
 870                         gtk_widget_set_sensitive( eventWidget[i], FALSE );
 871                 }
 872         }
 873
 874         // -------------------------- //
 875
 876         hbox = gtk_hbox_new( FALSE, 5 );
 877         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 878         gtk_widget_show( hbox );
 879
 880         w = gtk_label_new( _( "Parameters:" ) );
 881         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
 882         gtk_widget_show( w );
 883
 884         parameters = gtk_entry_new();
 885         gtk_box_pack_start( GTK_BOX( hbox ), parameters, TRUE, TRUE, 0 );
 886         gtk_widget_show( parameters );
 887
 888         // -------------------------- //
 889
 890         w = gtk_hseparator_new();
 891         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
 892         gtk_widget_show( w );
 893
 894         // -------------------------- //
 895
 896         hbox = gtk_hbox_new( FALSE, 5 );
 897         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
 898         gtk_widget_show( hbox );
 899
 900         w = gtk_button_new_with_label( _( "Ok" ) );
 901         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 902         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
 903         gtk_widget_show( w );
 904
 905         GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
 906         gtk_widget_grab_default( w );
 907
 908         w = gtk_button_new_with_label( _( "Cancel" ) );
 909         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
 910         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
 911         gtk_widget_show( w );
 912         ret = IDCANCEL;
 913
 914         // -------------------------- //
 915
 916         gtk_window_set_position( GTK_WINDOW( window ),GTK_WIN_POS_CENTER );
 917         gtk_widget_show( window );
 918         gtk_grab_add( window );
 919
 920         bool dialogError = TRUE;
 921         while ( dialogError ) {
 922                 loop = 1;
 923                 while ( loop )
 924                         gtk_main_iteration();
 925
 926                 dialogError = FALSE;
 927
 928                 if ( ret == IDOK ) {
 929                         const char *str = gtk_entry_get_text( GTK_ENTRY( parameters ) );
 930
 931                         if ( !camEventFlags[i][0] || ( str && str[0] ) ) {
 932                                 int type = 0;
 933 //                              GList *li;
 934
 935                                 for ( type = 1; type < EVENT_COUNT; type++ ) {
 936                                         if ( gtk_toggle_button_get_active( (GtkToggleButton*)eventWidget[type] ) ) {
 937                                                 break;
 938                                         }
 939                                 }
 940
 941                                 // Add the event
 942                                 GetCurrentCam()->GetCam()->addEvent( static_cast<idCameraEvent::eventType>( type ), str, (long)( g_pTimeLine->value ) );
 943
 944                                 // Refresh event list
 945                                 RefreshEventList();
 946                         }
 947                         else {
 948                                 dialogError = TRUE;
 949                         }
 950                 }
 951         }
 952
 953         gtk_grab_remove( window );
 954         gtk_widget_destroy( window );
 955
 956         return TRUE;
 957 }
 958
 959 static gint ci_del( GtkWidget *widget, gpointer data ){
 960         // TODO: add support to splines lib
 961         if ( GetCurrentCam() && GTK_CLIST( g_pEventsList )->focus_row >= 0 ) {
 962                 GetCurrentCam()->GetCam()->removeEvent( GTK_CLIST( g_pEventsList )->focus_row );
 963                 // Refresh event list
 964                 RefreshEventList();
 965         }
 966
 967         return TRUE;
 968 }
 969
 970 static gint ci_timeline_changed( GtkAdjustment *adjustment ){
 971         char buf[128];
 972
 973         sprintf( buf, "%.2f", adjustment->value / 1000.f );
 974         gtk_label_set_text( g_pCurrentTime, buf );
 975
 976         // FIXME: this will never work completely perfect. Startcamera calls buildcamera, which sets all events to 'nottriggered'.
 977         // So if you have a wait at the end of the path, this will go to nontriggered immediately when you go over it and the camera
 978         // will have no idea where on the track it should be.
 979         if ( GetCurrentCam() && gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( g_pTrackCamera ) ) ) {
 980                 float fov;
 981                 vec3_t origin = { 0.0f, 0.0f, 0.0f }, dir = { 0.0f, 0.0f, 0.0f}, angles;
 982
 983                 GetCurrentCam()->GetCam()->startCamera( 0 );
 984
 985                 GetCurrentCam()->GetCam()->getCameraInfo( (long)( adjustment->value ), &origin[0], &dir[0], &fov );
 986                 VectorSet( angles, asin( dir[2] ) * 180 / 3.14159, atan2( dir[1], dir[0] ) * 180 / 3.14159, 0 );
 987                 g_CameraTable.m_pfnSetCamera( origin, angles );
 988         }
 989
 990         return TRUE;
 991 }
 992
 993 GtkWidget *CreateCameraInspectorDialog( void ){
 994         GtkWidget *window, *w, *vbox, *hbox, *table, *frame;
 995
 996         // create the window
 997         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 998         gtk_window_set_title( GTK_WINDOW( window ), _( "Camera Inspector" ) );
 999         gtk_signal_connect( GTK_OBJECT( window ), "delete_event", GTK_SIGNAL_FUNC( ci_close ), NULL );
1000         gtk_signal_connect( GTK_OBJECT( window ), "expose_event", GTK_SIGNAL_FUNC( ci_expose ), NULL );
1001         //  gtk_signal_connect( GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
1002         gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pRadiantWnd ) );
1003
1004         // don't use show, as you don't want to have it displayed on startup ;-)
1005         gtk_widget_realize( window );
1006
1007         // fill the window
1008
1009         // the table
1010         // -------------------------- //
1011
1012         table = gtk_table_new( 3, 2, FALSE );
1013         gtk_widget_show( table );
1014         gtk_container_add( GTK_CONTAINER( window ), table );
1015         gtk_container_set_border_width( GTK_CONTAINER( table ), 5 );
1016         gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
1017         gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
1018
1019         // the properties column
1020         // -------------------------- //
1021
1022         vbox = gtk_vbox_new( FALSE, 5 );
1023         gtk_widget_show( vbox );
1024         gtk_table_attach( GTK_TABLE( table ), vbox, 0, 1, 0, 1,
1025                                           (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
1026                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1027
1028         // -------------------------- //
1029
1030         hbox = gtk_hbox_new( FALSE, 5 );
1031         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1032         gtk_widget_show( hbox );
1033
1034         w = gtk_label_new( _( "File:" ) );
1035         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1036         gtk_widget_show( w );
1037
1038         g_pCamListCombo = gtk_combo_new();
1039         gtk_box_pack_start( GTK_BOX( hbox ), g_pCamListCombo, TRUE, TRUE, 0 );
1040         gtk_widget_show( g_pCamListCombo );
1041
1042         // -------------------------- //
1043
1044         hbox = gtk_hbox_new( FALSE, 5 );
1045         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1046         gtk_widget_show( hbox );
1047
1048         w = gtk_label_new( _( "Name:" ) );
1049         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1050         gtk_widget_show( w );
1051
1052         g_pCamName = gtk_entry_new();
1053         gtk_box_pack_start( GTK_BOX( hbox ), g_pCamName, FALSE, FALSE, 0 );
1054         gtk_widget_show( g_pCamName );
1055
1056         w = gtk_label_new( _( "Type:" ) );
1057         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1058         gtk_widget_show( w );
1059
1060         w = gtk_label_new( "" );
1061         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1062         gtk_widget_show( w );
1063         g_pCamType = GTK_LABEL( w );
1064
1065         RefreshCamListCombo();
1066
1067         gtk_entry_set_editable( GTK_ENTRY( GTK_COMBO( g_pCamListCombo )->entry ), FALSE );
1068         gtk_signal_connect( GTK_OBJECT( GTK_COMBO( g_pCamListCombo )->entry ), "changed", GTK_SIGNAL_FUNC( ci_camlist_changed ), NULL );
1069
1070         // -------------------------- //
1071
1072         frame = gtk_frame_new( _( "Path and Target editing" ) );
1073         gtk_widget_show( frame );
1074         gtk_table_attach( GTK_TABLE( table ), frame, 0, 1, 1, 2,
1075                                           (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
1076                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1077
1078         vbox = gtk_vbox_new( FALSE, 5 );
1079         gtk_container_add( GTK_CONTAINER( frame ), vbox );
1080         gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
1081         gtk_widget_show( vbox );
1082
1083         // -------------------------- //
1084
1085         hbox = gtk_hbox_new( FALSE, 5 );
1086         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1087         gtk_widget_show( hbox );
1088
1089         w = gtk_label_new( _( "Edit:" ) );
1090         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1091         gtk_widget_show( w );
1092
1093         g_pPathListCombo = gtk_combo_new();
1094         gtk_box_pack_start( GTK_BOX( hbox ), g_pPathListCombo, TRUE, TRUE, 0 );
1095         gtk_widget_show( g_pPathListCombo );
1096
1097         RefreshPathListCombo();
1098
1099         gtk_entry_set_editable( GTK_ENTRY( GTK_COMBO( g_pPathListCombo )->entry ), FALSE );
1100         gtk_signal_connect( GTK_OBJECT( GTK_COMBO( g_pPathListCombo )->entry ), "changed", GTK_SIGNAL_FUNC( ci_pathlist_changed ), NULL );
1101
1102         // -------------------------- //
1103
1104         hbox = gtk_hbox_new( FALSE, 5 );
1105         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1106         gtk_widget_show( hbox );
1107
1108         g_pEditModeEditRadioButton = gtk_radio_button_new_with_label( g_pEditTypeRadio, _( "Edit Points" ) );
1109         gtk_box_pack_start( GTK_BOX( hbox ), g_pEditModeEditRadioButton, FALSE, FALSE, 3 );
1110         gtk_widget_show( g_pEditModeEditRadioButton );
1111         g_pEditTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( g_pEditModeEditRadioButton ) );
1112
1113         gtk_signal_connect( GTK_OBJECT( g_pEditModeEditRadioButton ), "clicked", GTK_SIGNAL_FUNC( ci_editmode_edit ), NULL );
1114
1115         g_pEditModeAddRadioButton = gtk_radio_button_new_with_label( g_pEditTypeRadio, _( "Add Points" ) );
1116         gtk_box_pack_start( GTK_BOX( hbox ), g_pEditModeAddRadioButton, FALSE, FALSE, 3 );
1117         gtk_widget_show( g_pEditModeAddRadioButton );
1118         g_pEditTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( g_pEditModeAddRadioButton ) );
1119
1120         gtk_signal_connect( GTK_OBJECT( g_pEditModeAddRadioButton ), "clicked", GTK_SIGNAL_FUNC( ci_editmode_add ), NULL );
1121
1122         // see if we should use a different default
1123         if ( g_iEditMode == 1 ) {
1124                 // Go to editmode Add
1125                 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( g_pEditModeAddRadioButton ), TRUE );
1126         }
1127
1128         w = gtk_label_new( _( "Type:" ) );
1129         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1130         gtk_widget_show( w );
1131
1132         w = gtk_label_new( "" );
1133         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1134         gtk_widget_show( w );
1135         g_pPathType = GTK_LABEL( w );
1136
1137         // -------------------------- //
1138
1139         hbox = gtk_hbox_new( FALSE, 5 );
1140         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1141         gtk_widget_show( hbox );
1142
1143         w = gtk_button_new_with_label( _( "Rename..." ) );
1144         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, TRUE, 0 );
1145         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_rename ), NULL );
1146         gtk_widget_show( w );
1147
1148         w = gtk_button_new_with_label( _( "Add Target..." ) );
1149         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, TRUE, 0 );
1150         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_add_target ), NULL );
1151         gtk_widget_show( w );
1152
1153         // not available in splines library
1154         /*w = gtk_button_new_with_label( "Delete Selected" );
1155            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, TRUE, 0);
1156            gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_delete_selected ), NULL );
1157            gtk_widget_show( w );
1158
1159            w = gtk_button_new_with_label( "Select All" );
1160            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, TRUE, 0);
1161            gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_select_all ), NULL );
1162            gtk_widget_show( w );*/
1163
1164         // -------------------------- //
1165
1166         frame = gtk_frame_new( _( "Time" ) );
1167         gtk_widget_show( frame );
1168         gtk_table_attach( GTK_TABLE( table ), frame, 0, 1, 2, 3,
1169                                           (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
1170                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1171
1172         vbox = gtk_vbox_new( FALSE, 5 );
1173         gtk_container_add( GTK_CONTAINER( frame ), vbox );
1174         gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
1175         gtk_widget_show( vbox );
1176
1177         // -------------------------- //
1178
1179         hbox = gtk_hbox_new( FALSE, 5 );
1180         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1181         gtk_widget_show( hbox );
1182
1183         w = gtk_label_new( _( "Length (seconds):" ) );
1184         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1185         gtk_widget_show( w );
1186
1187         g_pSecondsEntry = gtk_entry_new();
1188         gtk_box_pack_start( GTK_BOX( hbox ), g_pSecondsEntry, FALSE, FALSE, 0 );
1189         gtk_widget_show( g_pSecondsEntry );
1190
1191         // -------------------------- //
1192
1193         hbox = gtk_hbox_new( FALSE, 5 );
1194         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1195         gtk_widget_show( hbox );
1196
1197         w = gtk_label_new( _( "Current Time:" ) );
1198         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1199         gtk_widget_show( w );
1200
1201         w = gtk_label_new( _( "0.00" ) );
1202         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1203         gtk_widget_show( w );
1204         g_pCurrentTime = GTK_LABEL( w );
1205
1206         w = gtk_label_new( _( " of " ) );
1207         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1208         gtk_widget_show( w );
1209
1210         w = gtk_label_new( _( "0.00" ) );
1211         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1212         gtk_widget_show( w );
1213         g_pTotalTime = GTK_LABEL( w );
1214
1215         // -------------------------- //
1216
1217         hbox = gtk_hbox_new( FALSE, 5 );
1218         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1219         gtk_widget_show( hbox );
1220
1221         g_pTimeLine = GTK_ADJUSTMENT( gtk_adjustment_new( 0, 0, 30000, 100, 250, 0 ) );
1222         gtk_signal_connect( GTK_OBJECT( g_pTimeLine ), "value_changed", GTK_SIGNAL_FUNC( ci_timeline_changed ), NULL );
1223         w = gtk_hscale_new( g_pTimeLine );
1224         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
1225         gtk_widget_show( w );
1226         gtk_scale_set_draw_value( GTK_SCALE( w ), FALSE );
1227
1228         // -------------------------- //
1229
1230         hbox = gtk_hbox_new( FALSE, 5 );
1231         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1232         gtk_widget_show( hbox );
1233
1234         g_pTrackCamera = gtk_check_button_new_with_label( _( "Track Camera" ) );
1235         gtk_box_pack_start( GTK_BOX( hbox ), g_pTrackCamera, FALSE, FALSE, 0 );
1236         gtk_widget_show( g_pTrackCamera );
1237
1238         // -------------------------- //
1239
1240         hbox = gtk_hbox_new( FALSE, 5 );
1241         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1242         gtk_widget_show( hbox );
1243
1244         w = gtk_label_new( _( "Events:" ) );
1245         gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
1246         gtk_widget_show( w );
1247
1248         // -------------------------- //
1249
1250         hbox = gtk_hbox_new( FALSE, 5 );
1251         gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
1252         gtk_widget_show( hbox );
1253
1254         w = gtk_scrolled_window_new( NULL, NULL );
1255         gtk_widget_set_usize( w, 0, 150 );
1256         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1257         gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
1258         gtk_widget_show( w );
1259
1260         g_pEventsList = gtk_clist_new( 3 );
1261         gtk_container_add( GTK_CONTAINER( w ), g_pEventsList );
1262         //gtk_signal_connect( GTK_OBJECT(g_pEventsList), "select_row", GTK_SIGNAL_FUNC (proplist_select_row), NULL);
1263         gtk_clist_set_selection_mode( GTK_CLIST( g_pEventsList ), GTK_SELECTION_BROWSE );
1264         gtk_clist_column_titles_hide( GTK_CLIST( g_pEventsList ) );
1265         gtk_clist_set_column_auto_resize( GTK_CLIST( g_pEventsList ), 0, TRUE );
1266         gtk_clist_set_column_auto_resize( GTK_CLIST( g_pEventsList ), 1, TRUE );
1267         gtk_clist_set_column_auto_resize( GTK_CLIST( g_pEventsList ), 2, TRUE );
1268         gtk_widget_show( g_pEventsList );
1269
1270         vbox = gtk_vbox_new( FALSE, 5 );
1271         gtk_box_pack_start( GTK_BOX( hbox ), vbox, FALSE, FALSE, 0 );
1272         gtk_widget_show( vbox );
1273
1274         w = gtk_button_new_with_label( _( "Add..." ) );
1275         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1276         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_add ), NULL );
1277         gtk_widget_show( w );
1278
1279         w = gtk_button_new_with_label( _( "Del" ) );
1280         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1281         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_del ), NULL );
1282         gtk_widget_show( w );
1283
1284         // -------------------------- //
1285         // the buttons column
1286         // -------------------------- //
1287
1288         vbox = gtk_vbox_new( FALSE, 5 );
1289         gtk_widget_show( vbox );
1290         gtk_table_attach( GTK_TABLE( table ), vbox, 1, 2, 0, 1,
1291                                           (GtkAttachOptions) ( GTK_FILL ),
1292                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1293
1294         w = gtk_button_new_with_label( _( "New..." ) );
1295         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1296         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_new ), NULL );
1297         gtk_widget_show( w );
1298
1299         w = gtk_button_new_with_label( _( "Load..." ) );
1300         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1301         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_load ), NULL );
1302         gtk_widget_show( w );
1303
1304         // -------------------------- //
1305
1306         vbox = gtk_vbox_new( FALSE, 5 );
1307         gtk_widget_show( vbox );
1308         gtk_table_attach( GTK_TABLE( table ), vbox, 1, 2, 1, 2,
1309                                           (GtkAttachOptions) ( GTK_FILL ),
1310                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1311
1312         w = gtk_button_new_with_label( _( "Save..." ) );
1313         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1314         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_save ), NULL );
1315         gtk_widget_show( w );
1316
1317         w = gtk_button_new_with_label( _( "Unload" ) );
1318         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1319         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_unload ), NULL );
1320         gtk_widget_show( w );
1321
1322         hbox = gtk_hbox_new( FALSE, 5 );
1323         gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 0 );
1324         gtk_widget_show( hbox );
1325
1326         w = gtk_button_new_with_label( _( "Apply" ) );
1327         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1328         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_apply ), NULL );
1329         gtk_widget_show( w );
1330
1331         w = gtk_button_new_with_label( _( "Preview" ) );
1332         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1333         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_preview ), NULL );
1334         gtk_widget_show( w );
1335
1336         // -------------------------- //
1337
1338         vbox = gtk_vbox_new( FALSE, 5 );
1339         gtk_widget_show( vbox );
1340         gtk_table_attach( GTK_TABLE( table ), vbox, 1, 2, 2, 3,
1341                                           (GtkAttachOptions) ( GTK_FILL ),
1342                                           (GtkAttachOptions) ( GTK_FILL ), 0, 0 );
1343
1344         hbox = gtk_hbox_new( FALSE, 5 );
1345         gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 0 );
1346         gtk_widget_show( hbox );
1347
1348         w = gtk_button_new_with_label( _( "Close" ) );
1349         gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1350         gtk_signal_connect( GTK_OBJECT( w ), "clicked", GTK_SIGNAL_FUNC( ci_close ), NULL );
1351         GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
1352         gtk_widget_grab_default( w );
1353         gtk_widget_show( w );
1354
1355         // -------------------------- //
1356
1357         return window;
1358 }