radiant/dialog.cpp

   1 /*
   2 Copyright (C) 1999-2006 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 // Base dialog class, provides a way to run modal dialogs and
  24 // set/get the widget values in member variables.
  25 //
  26 // Leonardo Zide (leo@lokigames.com)
  27 //
  28
  29 #include "dialog.h"
  30
  31 #include "debugging/debugging.h"
  32
  33
  34 #include "mainframe.h"
  35
  36 #include <stdlib.h>
  37
  38 #include <gtk/gtkmain.h>
  39 #include <gtk/gtkvbox.h>
  40 #include <gtk/gtkhbox.h>
  41 #include <gtk/gtktogglebutton.h>
  42 #include <gtk/gtkspinbutton.h>
  43 #include <gtk/gtkradiobutton.h>
  44 #include <gtk/gtkentry.h>
  45 #include <gtk/gtkcombobox.h>
  46 #include <gtk/gtklabel.h>
  47 #include <gtk/gtktable.h>
  48 #include <gtk/gtkhscale.h>
  49 #include <gtk/gtkalignment.h>
  50
  51 #include "stream/stringstream.h"
  52 #include "convert.h"
  53 #include "gtkutil/dialog.h"
  54 #include "gtkutil/button.h"
  55 #include "gtkutil/entry.h"
  56 #include "gtkutil/image.h"
  57
  58 #include "gtkmisc.h"
  59
  60
  61 GtkEntry* DialogEntry_new()
  62 {
  63   GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
  64   gtk_widget_show(GTK_WIDGET(entry));
  65   gtk_widget_set_size_request(GTK_WIDGET(entry), 64, -1);
  66   return entry;
  67 }
  68
  69 class DialogEntryRow
  70 {
  71 public:
  72   DialogEntryRow(GtkWidget* row, GtkEntry* entry) : m_row(row), m_entry(entry)
  73   {
  74   }
  75   GtkWidget* m_row;
  76   GtkEntry* m_entry;
  77 };
  78
  79 DialogEntryRow DialogEntryRow_new(const char* name)
  80 {
  81   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
  82   gtk_widget_show(alignment);
  83
  84   GtkEntry* entry = DialogEntry_new();
  85   gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(entry));
  86
  87   return DialogEntryRow(GTK_WIDGET(DialogRow_new(name, alignment)), entry);
  88 }
  89
  90
  91 GtkSpinButton* DialogSpinner_new(double value, double lower, double upper, int fraction)
  92 {
  93   double step = 1.0 / double(fraction);
  94   unsigned int digits = 0;
  95   for(;fraction > 1; fraction /= 10)
  96   {
  97     ++digits;
  98   }
  99   GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(value, lower, upper, step, 10, 10)), step, digits));
 100   gtk_widget_show(GTK_WIDGET(spin));
 101   gtk_widget_set_size_request(GTK_WIDGET(spin), 64, -1);
 102   return spin;
 103 }
 104
 105 class DialogSpinnerRow
 106 {
 107 public:
 108   DialogSpinnerRow(GtkWidget* row, GtkSpinButton* spin) : m_row(row), m_spin(spin)
 109   {
 110   }
 111   GtkWidget* m_row;
 112   GtkSpinButton* m_spin;
 113 };
 114
 115 DialogSpinnerRow DialogSpinnerRow_new(const char* name, double value, double lower, double upper, int fraction)
 116 {
 117   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
 118   gtk_widget_show(alignment);
 119
 120   GtkSpinButton* spin = DialogSpinner_new(value, lower, upper, fraction);
 121   gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(spin));
 122
 123   return DialogSpinnerRow(GTK_WIDGET(DialogRow_new(name, alignment)), spin);
 124 }
 125
 126
 127
 128 template<
 129   typename Type_,
 130   typename Other_,
 131   void(*Import)(Type_&, Other_),
 132   void(*Export)(Type_&, const Callback1<Other_>&)
 133 >
 134 class ImportExport
 135 {
 136 public:
 137   typedef Type_ Type;
 138   typedef Other_ Other;
 139
 140   typedef ReferenceCaller1<Type, Other, Import> ImportCaller;
 141   typedef ReferenceCaller1<Type, const Callback1<Other>&, Export> ExportCaller;
 142 };
 143
 144 typedef ImportExport<bool, bool, BoolImport, BoolExport> BoolImportExport;
 145 typedef ImportExport<int, int, IntImport, IntExport> IntImportExport;
 146 typedef ImportExport<std::size_t, std::size_t, SizeImport, SizeExport> SizeImportExport;
 147 typedef ImportExport<float, float, FloatImport, FloatExport> FloatImportExport;
 148 typedef ImportExport<CopiedString, const char*, StringImport, StringExport> StringImportExport;
 149
 150
 151
 152 void BoolToggleImport(GtkToggleButton& widget, bool value)
 153 {
 154   gtk_toggle_button_set_active(&widget, value);
 155 }
 156 void BoolToggleExport(GtkToggleButton& widget, const BoolImportCallback& importCallback)
 157 {
 158   importCallback(gtk_toggle_button_get_active(&widget) != FALSE);
 159 }
 160 typedef ImportExport<GtkToggleButton, bool, BoolToggleImport, BoolToggleExport> BoolToggleImportExport;
 161
 162
 163 void IntRadioImport(GtkRadioButton& widget, int index)
 164 {
 165   radio_button_set_active(&widget, index);
 166 }
 167 void IntRadioExport(GtkRadioButton& widget, const IntImportCallback& importCallback)
 168 {
 169   importCallback(radio_button_get_active(&widget));
 170 }
 171 typedef ImportExport<GtkRadioButton, int, IntRadioImport, IntRadioExport> IntRadioImportExport;
 172
 173
 174 void TextEntryImport(GtkEntry& widget, const char* text)
 175 {
 176   StringOutputStream value(64);
 177   value << ConvertLocaleToUTF8(text);
 178   gtk_entry_set_text(&widget, value.c_str());
 179 }
 180 void TextEntryExport(GtkEntry& widget, const StringImportCallback& importCallback)
 181 {
 182   StringOutputStream value(64);
 183   value << ConvertUTF8ToLocale(gtk_entry_get_text(&widget));
 184   importCallback(value.c_str());
 185 }
 186 typedef ImportExport<GtkEntry, const char*, TextEntryImport, TextEntryExport> TextEntryImportExport;
 187
 188
 189 void IntEntryImport(GtkEntry& widget, int value)
 190 {
 191   entry_set_int(&widget, value);
 192 }
 193 void IntEntryExport(GtkEntry& widget, const IntImportCallback& importCallback)
 194 {
 195   importCallback(atoi(gtk_entry_get_text (&widget)));
 196 }
 197 typedef ImportExport<GtkEntry, int, IntEntryImport, IntEntryExport> IntEntryImportExport;
 198
 199
 200 void SizeEntryImport(GtkEntry& widget, std::size_t value)
 201 {
 202   entry_set_int(&widget, int(value));
 203 }
 204 void SizeEntryExport(GtkEntry& widget, const SizeImportCallback& importCallback)
 205 {
 206   int value = atoi(gtk_entry_get_text(&widget));
 207   if(value < 0)
 208   {
 209     value = 0;
 210   }
 211   importCallback(value);
 212 }
 213 typedef ImportExport<GtkEntry, std::size_t, SizeEntryImport, SizeEntryExport> SizeEntryImportExport;
 214
 215
 216 void FloatEntryImport(GtkEntry& widget, float value)
 217 {
 218   entry_set_float(&widget, value);
 219 }
 220 void FloatEntryExport(GtkEntry& widget, const FloatImportCallback& importCallback)
 221 {
 222   importCallback((float)atof(gtk_entry_get_text(&widget)));
 223 }
 224 typedef ImportExport<GtkEntry, float, FloatEntryImport, FloatEntryExport> FloatEntryImportExport;
 225
 226
 227 void FloatSpinnerImport(GtkSpinButton& widget, float value)
 228 {
 229   gtk_spin_button_set_value(&widget, value);
 230 }
 231 void FloatSpinnerExport(GtkSpinButton& widget, const FloatImportCallback& importCallback)
 232 {
 233   importCallback(float(gtk_spin_button_get_value_as_float(&widget)));
 234 }
 235 typedef ImportExport<GtkSpinButton, float, FloatSpinnerImport, FloatSpinnerExport> FloatSpinnerImportExport;
 236
 237
 238 void IntSpinnerImport(GtkSpinButton& widget, int value)
 239 {
 240   gtk_spin_button_set_value(&widget, value);
 241 }
 242 void IntSpinnerExport(GtkSpinButton& widget, const IntImportCallback& importCallback)
 243 {
 244   importCallback(gtk_spin_button_get_value_as_int(&widget));
 245 }
 246 typedef ImportExport<GtkSpinButton, int, IntSpinnerImport, IntSpinnerExport> IntSpinnerImportExport;
 247
 248
 249 void IntAdjustmentImport(GtkAdjustment& widget, int value)
 250 {
 251   gtk_adjustment_set_value(&widget, value);
 252 }
 253 void IntAdjustmentExport(GtkAdjustment& widget, const IntImportCallback& importCallback)
 254 {
 255   importCallback((int)gtk_adjustment_get_value(&widget));
 256 }
 257 typedef ImportExport<GtkAdjustment, int, IntAdjustmentImport, IntAdjustmentExport> IntAdjustmentImportExport;
 258
 259
 260 void IntComboImport(GtkComboBox& widget, int value)
 261 {
 262   gtk_combo_box_set_active(&widget, value);
 263 }
 264 void IntComboExport(GtkComboBox& widget, const IntImportCallback& importCallback)
 265 {
 266   importCallback(gtk_combo_box_get_active(&widget));
 267 }
 268 typedef ImportExport<GtkComboBox, int, IntComboImport, IntComboExport> IntComboImportExport;
 269
 270
 271 template<typename FirstArgument>
 272 class CallbackDialogData : public DLG_DATA
 273 {
 274 public:
 275   typedef Callback1<FirstArgument> ImportCallback;
 276   typedef Callback1<const ImportCallback&> ExportCallback;
 277
 278 private:
 279   ImportCallback m_importWidget;
 280   ExportCallback m_exportWidget;
 281   ImportCallback m_importViewer;
 282   ExportCallback m_exportViewer;
 283
 284 public:
 285   CallbackDialogData(const ImportCallback& importWidget, const ExportCallback& exportWidget, const ImportCallback& importViewer, const ExportCallback& exportViewer)
 286     : m_importWidget(importWidget), m_exportWidget(exportWidget), m_importViewer(importViewer), m_exportViewer(exportViewer)
 287   {
 288   }
 289   void release()
 290   {
 291     delete this;
 292   }
 293   void importData() const
 294   {
 295     m_exportViewer(m_importWidget);
 296   }
 297   void exportData() const
 298   {
 299     m_exportWidget(m_importViewer);
 300   }
 301 };
 302
 303 template<typename Widget, typename Viewer>
 304 class AddData
 305 {
 306   DialogDataList& m_data;
 307 public:
 308   AddData(DialogDataList& data) : m_data(data)
 309   {
 310   }
 311   void apply(typename Widget::Type& widget, typename Viewer::Type& viewer) const
 312   {
 313     m_data.push_back(
 314       new CallbackDialogData<typename Widget::Other>(
 315         typename Widget::ImportCaller(widget),
 316         typename Widget::ExportCaller(widget),
 317         typename Viewer::ImportCaller(viewer),
 318         typename Viewer::ExportCaller(viewer)
 319       )
 320     );
 321   }
 322 };
 323
 324 template<typename Widget>
 325 class AddCustomData
 326 {
 327   DialogDataList& m_data;
 328 public:
 329   AddCustomData(DialogDataList& data) : m_data(data)
 330   {
 331   }
 332   void apply(
 333     typename Widget::Type& widget,
 334     const Callback1<typename Widget::Other>& importViewer,
 335     const Callback1<const Callback1<typename Widget::Other>&>& exportViewer
 336   ) const
 337   {
 338     m_data.push_back(
 339       new CallbackDialogData<typename Widget::Other>(
 340         typename Widget::ImportCaller(widget),
 341         typename Widget::ExportCaller(widget),
 342         importViewer,
 343         exportViewer
 344       )
 345     );
 346   }
 347 };
 348
 349 // =============================================================================
 350 // Dialog class
 351
 352 Dialog::Dialog() : m_window(0), m_parent(0)
 353 {
 354 }
 355
 356 Dialog::~Dialog()
 357 {
 358   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 359   {
 360     (*i)->release();
 361   }
 362
 363   ASSERT_MESSAGE(m_window == 0, "dialog window not destroyed");
 364 }
 365
 366 void Dialog::ShowDlg()
 367 {
 368   ASSERT_MESSAGE(m_window != 0, "dialog was not constructed")
 369   importData();
 370   gtk_widget_show(GTK_WIDGET(m_window));
 371 }
 372
 373 void Dialog::HideDlg()
 374 {
 375   ASSERT_MESSAGE(m_window != 0, "dialog was not constructed")
 376   exportData();
 377   gtk_widget_hide(GTK_WIDGET(m_window));
 378 }
 379
 380 static gint delete_event_callback(GtkWidget *widget, GdkEvent* event, gpointer data)
 381 {
 382   reinterpret_cast<Dialog*>(data)->HideDlg();
 383   reinterpret_cast<Dialog*>(data)->EndModal(eIDCANCEL);
 384   return TRUE;
 385 }
 386
 387 void Dialog::Create()
 388 {
 389   ASSERT_MESSAGE(m_window == 0, "dialog cannot be constructed")
 390
 391   m_window = BuildDialog();
 392   g_signal_connect(G_OBJECT(m_window), "delete_event", G_CALLBACK(delete_event_callback), this);
 393 }
 394
 395 void Dialog::Destroy()
 396 {
 397   ASSERT_MESSAGE(m_window != 0, "dialog cannot be destroyed");
 398
 399   gtk_widget_destroy(GTK_WIDGET(m_window));
 400   m_window = 0;
 401 }
 402
 403
 404 void Dialog::AddBoolToggleData(GtkToggleButton& widget, const BoolImportCallback& importViewer, const BoolExportCallback& exportViewer)
 405 {
 406   AddCustomData<BoolToggleImportExport>(m_data).apply(widget, importViewer, exportViewer);
 407 }
 408
 409 void Dialog::AddIntRadioData(GtkRadioButton& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 410 {
 411   AddCustomData<IntRadioImportExport>(m_data).apply(widget, importViewer, exportViewer);
 412 }
 413
 414 void Dialog::AddTextEntryData(GtkEntry& widget, const StringImportCallback& importViewer, const StringExportCallback& exportViewer)
 415 {
 416   AddCustomData<TextEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 417 }
 418
 419 void Dialog::AddIntEntryData(GtkEntry& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 420 {
 421   AddCustomData<IntEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 422 }
 423
 424 void Dialog::AddSizeEntryData(GtkEntry& widget, const SizeImportCallback& importViewer, const SizeExportCallback& exportViewer)
 425 {
 426   AddCustomData<SizeEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 427 }
 428
 429 void Dialog::AddFloatEntryData(GtkEntry& widget, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 430 {
 431   AddCustomData<FloatEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 432 }
 433
 434 void Dialog::AddFloatSpinnerData(GtkSpinButton& widget, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 435 {
 436   AddCustomData<FloatSpinnerImportExport>(m_data).apply(widget, importViewer, exportViewer);
 437 }
 438
 439 void Dialog::AddIntSpinnerData(GtkSpinButton& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 440 {
 441   AddCustomData<IntSpinnerImportExport>(m_data).apply(widget, importViewer, exportViewer);
 442 }
 443
 444 void Dialog::AddIntAdjustmentData(GtkAdjustment& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 445 {
 446   AddCustomData<IntAdjustmentImportExport>(m_data).apply(widget, importViewer, exportViewer);
 447 }
 448
 449 void Dialog::AddIntComboData(GtkComboBox& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 450 {
 451   AddCustomData<IntComboImportExport>(m_data).apply(widget, importViewer, exportViewer);
 452 }
 453
 454
 455 void Dialog::AddDialogData(GtkToggleButton& widget, bool& data)
 456 {
 457   AddData<BoolToggleImportExport, BoolImportExport>(m_data).apply(widget, data);
 458 }
 459 void Dialog::AddDialogData(GtkRadioButton& widget, int& data)
 460 {
 461   AddData<IntRadioImportExport, IntImportExport>(m_data).apply(widget, data);
 462 }
 463 void Dialog::AddDialogData(GtkEntry& widget, CopiedString& data)
 464 {
 465   AddData<TextEntryImportExport, StringImportExport>(m_data).apply(widget, data);
 466 }
 467 void Dialog::AddDialogData(GtkEntry& widget, int& data)
 468 {
 469   AddData<IntEntryImportExport, IntImportExport>(m_data).apply(widget, data);
 470 }
 471 void Dialog::AddDialogData(GtkEntry& widget, std::size_t& data)
 472 {
 473   AddData<SizeEntryImportExport, SizeImportExport>(m_data).apply(widget, data);
 474 }
 475 void Dialog::AddDialogData(GtkEntry& widget, float& data)
 476 {
 477   AddData<FloatEntryImportExport, FloatImportExport>(m_data).apply(widget, data);
 478 }
 479 void Dialog::AddDialogData(GtkSpinButton& widget, float& data)
 480 {
 481   AddData<FloatSpinnerImportExport, FloatImportExport>(m_data).apply(widget, data);
 482 }
 483 void Dialog::AddDialogData(GtkSpinButton& widget, int& data)
 484 {
 485   AddData<IntSpinnerImportExport, IntImportExport>(m_data).apply(widget, data);
 486 }
 487 void Dialog::AddDialogData(GtkAdjustment& widget, int& data)
 488 {
 489   AddData<IntAdjustmentImportExport, IntImportExport>(m_data).apply(widget, data);
 490 }
 491 void Dialog::AddDialogData(GtkComboBox& widget, int& data)
 492 {
 493   AddData<IntComboImportExport, IntImportExport>(m_data).apply(widget, data);
 494 }
 495
 496 void Dialog::exportData()
 497 {
 498   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 499   {
 500     (*i)->exportData();
 501   }
 502 }
 503
 504 void Dialog::importData()
 505 {
 506   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 507   {
 508     (*i)->importData();
 509   }
 510 }
 511
 512 void Dialog::EndModal (EMessageBoxReturn code)
 513 {
 514   m_modal.loop = 0;
 515   m_modal.ret = code;
 516 }
 517
 518 EMessageBoxReturn Dialog::DoModal()
 519 {
 520   importData();
 521
 522   PreModal();
 523
 524   EMessageBoxReturn ret = modal_dialog_show(m_window, m_modal);
 525   ASSERT_NOTNULL(m_window);
 526   if(ret == eIDOK)
 527   {
 528     exportData();
 529   }
 530
 531   gtk_widget_hide(GTK_WIDGET(m_window));
 532
 533   PostModal(m_modal.ret);
 534
 535   return m_modal.ret;
 536 }
 537
 538
 539 GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const char* name, const char* flag, const BoolImportCallback& importViewer, const BoolExportCallback& exportViewer)
 540 {
 541   GtkWidget* check = gtk_check_button_new_with_label(flag);
 542   gtk_widget_show(check);
 543   AddBoolToggleData(*GTK_TOGGLE_BUTTON(check), importViewer, exportViewer);
 544
 545   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, check)));
 546   return check;
 547 }
 548
 549 GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const char* name, const char* flag, bool& data)
 550 {
 551   return addCheckBox(vbox, name, flag, BoolImportCaller(data), BoolExportCaller(data));
 552 }
 553
 554 void Dialog::addCombo(GtkWidget* vbox, const char* name, StringArrayRange values, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 555 {
 556   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
 557   gtk_widget_show(alignment);
 558   {
 559     GtkWidget* combo = gtk_combo_box_new_text();
 560
 561     for(StringArrayRange::Iterator i = values.first; i != values.last; ++i)
 562     {
 563       gtk_combo_box_append_text(GTK_COMBO_BOX(combo), *i);
 564     }
 565
 566     AddIntComboData(*GTK_COMBO_BOX(combo), importViewer, exportViewer);
 567
 568     gtk_widget_show (combo);
 569     gtk_container_add(GTK_CONTAINER(alignment), combo);
 570   }
 571
 572   GtkTable* row = DialogRow_new(name, alignment);
 573   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 574 }
 575
 576 void Dialog::addCombo(GtkWidget* vbox, const char* name, int& data, StringArrayRange values)
 577 {
 578   addCombo(vbox, name, values, IntImportCaller(data), IntExportCaller(data));
 579 }
 580
 581 void Dialog::addSlider(GtkWidget* vbox, const char* name, int& data, gboolean draw_value, const char* low, const char* high, double value, double lower, double upper, double step_increment, double page_increment, double page_size)
 582 {
 583 #if 0
 584   if(draw_value == FALSE)
 585   {
 586     GtkWidget* hbox2 = gtk_hbox_new (FALSE, 0);
 587     gtk_widget_show (hbox2);
 588     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
 589     {
 590       GtkWidget* label = gtk_label_new (low);
 591       gtk_widget_show (label);
 592       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 593     }
 594     {
 595       GtkWidget* label = gtk_label_new (high);
 596       gtk_widget_show (label);
 597       gtk_box_pack_end (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 598     }
 599   }
 600 #endif
 601
 602   // adjustment
 603   GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
 604   AddIntAdjustmentData(*GTK_ADJUSTMENT(adj), IntImportCaller(data), IntExportCaller(data));
 605
 606   // scale
 607   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
 608   gtk_widget_show(alignment);
 609
 610   GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
 611   gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
 612   gtk_widget_show(scale);
 613   gtk_container_add(GTK_CONTAINER(alignment), scale);
 614
 615   gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
 616   gtk_scale_set_digits(GTK_SCALE (scale), 0);
 617
 618   GtkTable* row = DialogRow_new(name, alignment);
 619   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 620 }
 621
 622 void Dialog::addRadio(GtkWidget* vbox, const char* name, StringArrayRange names, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 623 {
 624   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
 625   gtk_widget_show(alignment);
 626   {
 627     RadioHBox radioBox = RadioHBox_new(names);
 628     gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(radioBox.m_hbox));
 629     AddIntRadioData(*GTK_RADIO_BUTTON(radioBox.m_radio), importViewer, exportViewer);
 630   }
 631
 632   GtkTable* row = DialogRow_new(name, alignment);
 633   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 634 }
 635
 636 void Dialog::addRadio(GtkWidget* vbox, const char* name, int& data, StringArrayRange names)
 637 {
 638   addRadio(vbox, name, names, IntImportCaller(data), IntExportCaller(data));
 639 }
 640
 641 void Dialog::addRadioIcons(GtkWidget* vbox, const char* name, StringArrayRange icons, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 642 {
 643   GtkWidget* table = gtk_table_new (2, static_cast<guint>(icons.last - icons.first), FALSE);
 644   gtk_widget_show (table);
 645
 646   gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 647   gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 648
 649   GSList* group = 0;
 650   GtkWidget* radio = 0;
 651   for(StringArrayRange::Iterator icon = icons.first; icon != icons.last; ++icon)
 652   {
 653     guint pos = static_cast<guint>(icon - icons.first);
 654     GtkImage* image = new_local_image(*icon);
 655     gtk_widget_show(GTK_WIDGET(image));
 656     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(image), pos, pos+1, 0, 1,
 657                       (GtkAttachOptions) (0),
 658                       (GtkAttachOptions) (0), 0, 0);
 659
 660     radio = gtk_radio_button_new(group);
 661     gtk_widget_show (radio);
 662     gtk_table_attach (GTK_TABLE (table), radio, pos, pos+1, 1, 2,
 663                       (GtkAttachOptions) (0),
 664                       (GtkAttachOptions) (0), 0, 0);
 665
 666     group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
 667   }
 668
 669   AddIntRadioData(*GTK_RADIO_BUTTON(radio), importViewer, exportViewer);
 670
 671   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, table)));
 672 }
 673
 674 void Dialog::addRadioIcons(GtkWidget* vbox, const char* name, int& data, StringArrayRange icons)
 675 {
 676   addRadioIcons(vbox, name, icons, IntImportCaller(data), IntExportCaller(data));
 677 }
 678
 679 GtkWidget* Dialog::addIntEntry(GtkWidget* vbox, const char* name, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 680 {
 681   DialogEntryRow row(DialogEntryRow_new(name));
 682   AddIntEntryData(*row.m_entry, importViewer, exportViewer);
 683   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 684   return row.m_row;
 685 }
 686
 687 GtkWidget* Dialog::addSizeEntry(GtkWidget* vbox, const char* name, const SizeImportCallback& importViewer, const SizeExportCallback& exportViewer)
 688 {
 689   DialogEntryRow row(DialogEntryRow_new(name));
 690   AddSizeEntryData(*row.m_entry, importViewer, exportViewer);
 691   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 692   return row.m_row;
 693 }
 694
 695 GtkWidget* Dialog::addFloatEntry(GtkWidget* vbox, const char* name, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 696 {
 697   DialogEntryRow row(DialogEntryRow_new(name));
 698   AddFloatEntryData(*row.m_entry, importViewer, exportViewer);
 699   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 700   return row.m_row;
 701 }
 702
 703 GtkWidget* Dialog::addPathEntry(GtkWidget* vbox, const char* name, bool browse_directory, const StringImportCallback& importViewer, const StringExportCallback& exportViewer)
 704 {
 705   PathEntry pathEntry = PathEntry_new();
 706   g_signal_connect(G_OBJECT(pathEntry.m_button), "clicked", G_CALLBACK(browse_directory ? button_clicked_entry_browse_directory : button_clicked_entry_browse_file), pathEntry.m_entry);
 707
 708   AddTextEntryData(*GTK_ENTRY(pathEntry.m_entry), importViewer, exportViewer);
 709
 710   GtkTable* row = DialogRow_new(name, GTK_WIDGET(pathEntry.m_frame));
 711   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 712
 713   return GTK_WIDGET(row);
 714 }
 715
 716 GtkWidget* Dialog::addPathEntry(GtkWidget* vbox, const char* name, CopiedString& data, bool browse_directory)
 717 {
 718   return addPathEntry(vbox, name, browse_directory, StringImportCallback(StringImportCaller(data)), StringExportCallback(StringExportCaller(data)));
 719 }
 720
 721 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, double value, double lower, double upper, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 722 {
 723   DialogSpinnerRow row(DialogSpinnerRow_new(name, value, lower, upper, 1));
 724   AddIntSpinnerData(*row.m_spin, importViewer, exportViewer);
 725   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 726   return row.m_row;
 727 }
 728
 729 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, int& data, double value, double lower, double upper)
 730 {
 731   return addSpinner(vbox, name, value, lower, upper, IntImportCallback(IntImportCaller(data)), IntExportCallback(IntExportCaller(data)));
 732 }
 733
 734 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, double value, double lower, double upper, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 735 {
 736   DialogSpinnerRow row(DialogSpinnerRow_new(name, value, lower, upper, 10));
 737   AddFloatSpinnerData(*row.m_spin, importViewer, exportViewer);
 738   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 739   return row.m_row;
 740 }