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, 0)), 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 void TextEntryImport(GtkEntry& widget, const char* text)
 174 {
 175   gtk_entry_set_text(&widget, text);
 176 }
 177 void TextEntryExport(GtkEntry& widget, const StringImportCallback& importCallback)
 178 {
 179   importCallback(gtk_entry_get_text(&widget));
 180 }
 181 typedef ImportExport<GtkEntry, const char*, TextEntryImport, TextEntryExport> TextEntryImportExport;
 182
 183
 184 void IntEntryImport(GtkEntry& widget, int value)
 185 {
 186   entry_set_int(&widget, value);
 187 }
 188 void IntEntryExport(GtkEntry& widget, const IntImportCallback& importCallback)
 189 {
 190   importCallback(atoi(gtk_entry_get_text (&widget)));
 191 }
 192 typedef ImportExport<GtkEntry, int, IntEntryImport, IntEntryExport> IntEntryImportExport;
 193
 194
 195 void SizeEntryImport(GtkEntry& widget, std::size_t value)
 196 {
 197   entry_set_int(&widget, int(value));
 198 }
 199 void SizeEntryExport(GtkEntry& widget, const SizeImportCallback& importCallback)
 200 {
 201   int value = atoi(gtk_entry_get_text(&widget));
 202   if(value < 0)
 203   {
 204     value = 0;
 205   }
 206   importCallback(value);
 207 }
 208 typedef ImportExport<GtkEntry, std::size_t, SizeEntryImport, SizeEntryExport> SizeEntryImportExport;
 209
 210
 211 void FloatEntryImport(GtkEntry& widget, float value)
 212 {
 213   entry_set_float(&widget, value);
 214 }
 215 void FloatEntryExport(GtkEntry& widget, const FloatImportCallback& importCallback)
 216 {
 217   importCallback((float)atof(gtk_entry_get_text(&widget)));
 218 }
 219 typedef ImportExport<GtkEntry, float, FloatEntryImport, FloatEntryExport> FloatEntryImportExport;
 220
 221
 222 void FloatSpinnerImport(GtkSpinButton& widget, float value)
 223 {
 224   gtk_spin_button_set_value(&widget, value);
 225 }
 226 void FloatSpinnerExport(GtkSpinButton& widget, const FloatImportCallback& importCallback)
 227 {
 228   importCallback(float(gtk_spin_button_get_value_as_float(&widget)));
 229 }
 230 typedef ImportExport<GtkSpinButton, float, FloatSpinnerImport, FloatSpinnerExport> FloatSpinnerImportExport;
 231
 232
 233 void IntSpinnerImport(GtkSpinButton& widget, int value)
 234 {
 235   gtk_spin_button_set_value(&widget, value);
 236 }
 237 void IntSpinnerExport(GtkSpinButton& widget, const IntImportCallback& importCallback)
 238 {
 239   importCallback(gtk_spin_button_get_value_as_int(&widget));
 240 }
 241 typedef ImportExport<GtkSpinButton, int, IntSpinnerImport, IntSpinnerExport> IntSpinnerImportExport;
 242
 243
 244 void IntAdjustmentImport(GtkAdjustment& widget, int value)
 245 {
 246   gtk_adjustment_set_value(&widget, value);
 247 }
 248 void IntAdjustmentExport(GtkAdjustment& widget, const IntImportCallback& importCallback)
 249 {
 250   importCallback((int)gtk_adjustment_get_value(&widget));
 251 }
 252 typedef ImportExport<GtkAdjustment, int, IntAdjustmentImport, IntAdjustmentExport> IntAdjustmentImportExport;
 253
 254
 255 void IntComboImport(GtkComboBox& widget, int value)
 256 {
 257   gtk_combo_box_set_active(&widget, value);
 258 }
 259 void IntComboExport(GtkComboBox& widget, const IntImportCallback& importCallback)
 260 {
 261   importCallback(gtk_combo_box_get_active(&widget));
 262 }
 263 typedef ImportExport<GtkComboBox, int, IntComboImport, IntComboExport> IntComboImportExport;
 264
 265
 266 template<typename FirstArgument>
 267 class CallbackDialogData : public DLG_DATA
 268 {
 269 public:
 270   typedef Callback1<FirstArgument> ImportCallback;
 271   typedef Callback1<const ImportCallback&> ExportCallback;
 272
 273 private:
 274   ImportCallback m_importWidget;
 275   ExportCallback m_exportWidget;
 276   ImportCallback m_importViewer;
 277   ExportCallback m_exportViewer;
 278
 279 public:
 280   CallbackDialogData(const ImportCallback& importWidget, const ExportCallback& exportWidget, const ImportCallback& importViewer, const ExportCallback& exportViewer)
 281     : m_importWidget(importWidget), m_exportWidget(exportWidget), m_importViewer(importViewer), m_exportViewer(exportViewer)
 282   {
 283   }
 284   void release()
 285   {
 286     delete this;
 287   }
 288   void importData() const
 289   {
 290     m_exportViewer(m_importWidget);
 291   }
 292   void exportData() const
 293   {
 294     m_exportWidget(m_importViewer);
 295   }
 296 };
 297
 298 template<typename Widget, typename Viewer>
 299 class AddData
 300 {
 301   DialogDataList& m_data;
 302 public:
 303   AddData(DialogDataList& data) : m_data(data)
 304   {
 305   }
 306   void apply(typename Widget::Type& widget, typename Viewer::Type& viewer) const
 307   {
 308     m_data.push_back(
 309       new CallbackDialogData<typename Widget::Other>(
 310         typename Widget::ImportCaller(widget),
 311         typename Widget::ExportCaller(widget),
 312         typename Viewer::ImportCaller(viewer),
 313         typename Viewer::ExportCaller(viewer)
 314       )
 315     );
 316   }
 317 };
 318
 319 template<typename Widget>
 320 class AddCustomData
 321 {
 322   DialogDataList& m_data;
 323 public:
 324   AddCustomData(DialogDataList& data) : m_data(data)
 325   {
 326   }
 327   void apply(
 328     typename Widget::Type& widget,
 329     const Callback1<typename Widget::Other>& importViewer,
 330     const Callback1<const Callback1<typename Widget::Other>&>& exportViewer
 331   ) const
 332   {
 333     m_data.push_back(
 334       new CallbackDialogData<typename Widget::Other>(
 335         typename Widget::ImportCaller(widget),
 336         typename Widget::ExportCaller(widget),
 337         importViewer,
 338         exportViewer
 339       )
 340     );
 341   }
 342 };
 343
 344 // =============================================================================
 345 // Dialog class
 346
 347 Dialog::Dialog() : m_window(0), m_parent(0)
 348 {
 349 }
 350
 351 Dialog::~Dialog()
 352 {
 353   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 354   {
 355     (*i)->release();
 356   }
 357
 358   ASSERT_MESSAGE(m_window == 0, "dialog window not destroyed");
 359 }
 360
 361 void Dialog::ShowDlg()
 362 {
 363   ASSERT_MESSAGE(m_window != 0, "dialog was not constructed");
 364   importData();
 365   gtk_widget_show(GTK_WIDGET(m_window));
 366 }
 367
 368 void Dialog::HideDlg()
 369 {
 370   ASSERT_MESSAGE(m_window != 0, "dialog was not constructed");
 371   exportData();
 372   gtk_widget_hide(GTK_WIDGET(m_window));
 373 }
 374
 375 static gint delete_event_callback(GtkWidget *widget, GdkEvent* event, gpointer data)
 376 {
 377   reinterpret_cast<Dialog*>(data)->HideDlg();
 378   reinterpret_cast<Dialog*>(data)->EndModal(eIDCANCEL);
 379   return TRUE;
 380 }
 381
 382 void Dialog::Create()
 383 {
 384   ASSERT_MESSAGE(m_window == 0, "dialog cannot be constructed");
 385
 386   m_window = BuildDialog();
 387   g_signal_connect(G_OBJECT(m_window), "delete_event", G_CALLBACK(delete_event_callback), this);
 388 }
 389
 390 void Dialog::Destroy()
 391 {
 392   ASSERT_MESSAGE(m_window != 0, "dialog cannot be destroyed");
 393
 394   gtk_widget_destroy(GTK_WIDGET(m_window));
 395   m_window = 0;
 396 }
 397
 398
 399 void Dialog::AddBoolToggleData(GtkToggleButton& widget, const BoolImportCallback& importViewer, const BoolExportCallback& exportViewer)
 400 {
 401   AddCustomData<BoolToggleImportExport>(m_data).apply(widget, importViewer, exportViewer);
 402 }
 403
 404 void Dialog::AddIntRadioData(GtkRadioButton& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 405 {
 406   AddCustomData<IntRadioImportExport>(m_data).apply(widget, importViewer, exportViewer);
 407 }
 408
 409 void Dialog::AddTextEntryData(GtkEntry& widget, const StringImportCallback& importViewer, const StringExportCallback& exportViewer)
 410 {
 411   AddCustomData<TextEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 412 }
 413
 414 void Dialog::AddIntEntryData(GtkEntry& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 415 {
 416   AddCustomData<IntEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 417 }
 418
 419 void Dialog::AddSizeEntryData(GtkEntry& widget, const SizeImportCallback& importViewer, const SizeExportCallback& exportViewer)
 420 {
 421   AddCustomData<SizeEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 422 }
 423
 424 void Dialog::AddFloatEntryData(GtkEntry& widget, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 425 {
 426   AddCustomData<FloatEntryImportExport>(m_data).apply(widget, importViewer, exportViewer);
 427 }
 428
 429 void Dialog::AddFloatSpinnerData(GtkSpinButton& widget, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 430 {
 431   AddCustomData<FloatSpinnerImportExport>(m_data).apply(widget, importViewer, exportViewer);
 432 }
 433
 434 void Dialog::AddIntSpinnerData(GtkSpinButton& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 435 {
 436   AddCustomData<IntSpinnerImportExport>(m_data).apply(widget, importViewer, exportViewer);
 437 }
 438
 439 void Dialog::AddIntAdjustmentData(GtkAdjustment& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 440 {
 441   AddCustomData<IntAdjustmentImportExport>(m_data).apply(widget, importViewer, exportViewer);
 442 }
 443
 444 void Dialog::AddIntComboData(GtkComboBox& widget, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 445 {
 446   AddCustomData<IntComboImportExport>(m_data).apply(widget, importViewer, exportViewer);
 447 }
 448
 449
 450 void Dialog::AddDialogData(GtkToggleButton& widget, bool& data)
 451 {
 452   AddData<BoolToggleImportExport, BoolImportExport>(m_data).apply(widget, data);
 453 }
 454 void Dialog::AddDialogData(GtkRadioButton& widget, int& data)
 455 {
 456   AddData<IntRadioImportExport, IntImportExport>(m_data).apply(widget, data);
 457 }
 458 void Dialog::AddDialogData(GtkEntry& widget, CopiedString& data)
 459 {
 460   AddData<TextEntryImportExport, StringImportExport>(m_data).apply(widget, data);
 461 }
 462 void Dialog::AddDialogData(GtkEntry& widget, int& data)
 463 {
 464   AddData<IntEntryImportExport, IntImportExport>(m_data).apply(widget, data);
 465 }
 466 void Dialog::AddDialogData(GtkEntry& widget, std::size_t& data)
 467 {
 468   AddData<SizeEntryImportExport, SizeImportExport>(m_data).apply(widget, data);
 469 }
 470 void Dialog::AddDialogData(GtkEntry& widget, float& data)
 471 {
 472   AddData<FloatEntryImportExport, FloatImportExport>(m_data).apply(widget, data);
 473 }
 474 void Dialog::AddDialogData(GtkSpinButton& widget, float& data)
 475 {
 476   AddData<FloatSpinnerImportExport, FloatImportExport>(m_data).apply(widget, data);
 477 }
 478 void Dialog::AddDialogData(GtkSpinButton& widget, int& data)
 479 {
 480   AddData<IntSpinnerImportExport, IntImportExport>(m_data).apply(widget, data);
 481 }
 482 void Dialog::AddDialogData(GtkAdjustment& widget, int& data)
 483 {
 484   AddData<IntAdjustmentImportExport, IntImportExport>(m_data).apply(widget, data);
 485 }
 486 void Dialog::AddDialogData(GtkComboBox& widget, int& data)
 487 {
 488   AddData<IntComboImportExport, IntImportExport>(m_data).apply(widget, data);
 489 }
 490
 491 void Dialog::exportData()
 492 {
 493   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 494   {
 495     (*i)->exportData();
 496   }
 497 }
 498
 499 void Dialog::importData()
 500 {
 501   for(DialogDataList::iterator i = m_data.begin(); i != m_data.end(); ++i)
 502   {
 503     (*i)->importData();
 504   }
 505 }
 506
 507 void Dialog::EndModal (EMessageBoxReturn code)
 508 {
 509   m_modal.loop = 0;
 510   m_modal.ret = code;
 511 }
 512
 513 EMessageBoxReturn Dialog::DoModal()
 514 {
 515   importData();
 516
 517   PreModal();
 518
 519   EMessageBoxReturn ret = modal_dialog_show(m_window, m_modal);
 520   ASSERT_NOTNULL(m_window);
 521   if(ret == eIDOK)
 522   {
 523     exportData();
 524   }
 525
 526   gtk_widget_hide(GTK_WIDGET(m_window));
 527
 528   PostModal(m_modal.ret);
 529
 530   return m_modal.ret;
 531 }
 532
 533
 534 GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const char* name, const char* flag, const BoolImportCallback& importViewer, const BoolExportCallback& exportViewer)
 535 {
 536   GtkWidget* check = gtk_check_button_new_with_label(flag);
 537   gtk_widget_show(check);
 538   AddBoolToggleData(*GTK_TOGGLE_BUTTON(check), importViewer, exportViewer);
 539
 540   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, check)));
 541   return check;
 542 }
 543
 544 GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const char* name, const char* flag, bool& data)
 545 {
 546   return addCheckBox(vbox, name, flag, BoolImportCaller(data), BoolExportCaller(data));
 547 }
 548
 549 void Dialog::addCombo(GtkWidget* vbox, const char* name, StringArrayRange values, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 550 {
 551   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
 552   gtk_widget_show(alignment);
 553   {
 554     GtkWidget* combo = gtk_combo_box_new_text();
 555
 556     for(StringArrayRange::Iterator i = values.first; i != values.last; ++i)
 557     {
 558       gtk_combo_box_append_text(GTK_COMBO_BOX(combo), *i);
 559     }
 560
 561     AddIntComboData(*GTK_COMBO_BOX(combo), importViewer, exportViewer);
 562
 563     gtk_widget_show (combo);
 564     gtk_container_add(GTK_CONTAINER(alignment), combo);
 565   }
 566
 567   GtkTable* row = DialogRow_new(name, alignment);
 568   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 569 }
 570
 571 void Dialog::addCombo(GtkWidget* vbox, const char* name, int& data, StringArrayRange values)
 572 {
 573   addCombo(vbox, name, values, IntImportCaller(data), IntExportCaller(data));
 574 }
 575
 576 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)
 577 {
 578 #if 0
 579   if(draw_value == FALSE)
 580   {
 581     GtkWidget* hbox2 = gtk_hbox_new (FALSE, 0);
 582     gtk_widget_show (hbox2);
 583     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
 584     {
 585       GtkWidget* label = gtk_label_new (low);
 586       gtk_widget_show (label);
 587       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 588     }
 589     {
 590       GtkWidget* label = gtk_label_new (high);
 591       gtk_widget_show (label);
 592       gtk_box_pack_end (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 593     }
 594   }
 595 #endif
 596
 597   // adjustment
 598   GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, 0);
 599   AddIntAdjustmentData(*GTK_ADJUSTMENT(adj), IntImportCaller(data), IntExportCaller(data));
 600
 601   // scale
 602   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
 603   gtk_widget_show(alignment);
 604
 605   GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
 606   gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
 607   gtk_widget_show(scale);
 608   gtk_container_add(GTK_CONTAINER(alignment), scale);
 609
 610   gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
 611   gtk_scale_set_digits(GTK_SCALE (scale), 0);
 612
 613   GtkTable* row = DialogRow_new(name, alignment);
 614   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 615 }
 616
 617 void Dialog::addRadio(GtkWidget* vbox, const char* name, StringArrayRange names, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 618 {
 619   GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
 620   gtk_widget_show(alignment);
 621   {
 622     RadioHBox radioBox = RadioHBox_new(names);
 623     gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(radioBox.m_hbox));
 624     AddIntRadioData(*GTK_RADIO_BUTTON(radioBox.m_radio), importViewer, exportViewer);
 625   }
 626
 627   GtkTable* row = DialogRow_new(name, alignment);
 628   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 629 }
 630
 631 void Dialog::addRadio(GtkWidget* vbox, const char* name, int& data, StringArrayRange names)
 632 {
 633   addRadio(vbox, name, names, IntImportCaller(data), IntExportCaller(data));
 634 }
 635
 636 void Dialog::addRadioIcons(GtkWidget* vbox, const char* name, StringArrayRange icons, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 637 {
 638   GtkWidget* table = gtk_table_new (2, static_cast<guint>(icons.last - icons.first), FALSE);
 639   gtk_widget_show (table);
 640
 641   gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 642   gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 643
 644   GSList* group = 0;
 645   GtkWidget* radio = 0;
 646   for(StringArrayRange::Iterator icon = icons.first; icon != icons.last; ++icon)
 647   {
 648     guint pos = static_cast<guint>(icon - icons.first);
 649     GtkImage* image = new_local_image(*icon);
 650     gtk_widget_show(GTK_WIDGET(image));
 651     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(image), pos, pos+1, 0, 1,
 652                       (GtkAttachOptions) (0),
 653                       (GtkAttachOptions) (0), 0, 0);
 654
 655     radio = gtk_radio_button_new(group);
 656     gtk_widget_show (radio);
 657     gtk_table_attach (GTK_TABLE (table), radio, pos, pos+1, 1, 2,
 658                       (GtkAttachOptions) (0),
 659                       (GtkAttachOptions) (0), 0, 0);
 660
 661     group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
 662   }
 663
 664   AddIntRadioData(*GTK_RADIO_BUTTON(radio), importViewer, exportViewer);
 665
 666   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, table)));
 667 }
 668
 669 void Dialog::addRadioIcons(GtkWidget* vbox, const char* name, int& data, StringArrayRange icons)
 670 {
 671   addRadioIcons(vbox, name, icons, IntImportCaller(data), IntExportCaller(data));
 672 }
 673
 674 GtkWidget* Dialog::addIntEntry(GtkWidget* vbox, const char* name, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 675 {
 676   DialogEntryRow row(DialogEntryRow_new(name));
 677   AddIntEntryData(*row.m_entry, importViewer, exportViewer);
 678   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 679   return row.m_row;
 680 }
 681
 682 GtkWidget* Dialog::addSizeEntry(GtkWidget* vbox, const char* name, const SizeImportCallback& importViewer, const SizeExportCallback& exportViewer)
 683 {
 684   DialogEntryRow row(DialogEntryRow_new(name));
 685   AddSizeEntryData(*row.m_entry, importViewer, exportViewer);
 686   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 687   return row.m_row;
 688 }
 689
 690 GtkWidget* Dialog::addFloatEntry(GtkWidget* vbox, const char* name, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 691 {
 692   DialogEntryRow row(DialogEntryRow_new(name));
 693   AddFloatEntryData(*row.m_entry, importViewer, exportViewer);
 694   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 695   return row.m_row;
 696 }
 697
 698 GtkWidget* Dialog::addPathEntry(GtkWidget* vbox, const char* name, bool browse_directory, const StringImportCallback& importViewer, const StringExportCallback& exportViewer)
 699 {
 700   PathEntry pathEntry = PathEntry_new();
 701   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);
 702
 703   AddTextEntryData(*GTK_ENTRY(pathEntry.m_entry), importViewer, exportViewer);
 704
 705   GtkTable* row = DialogRow_new(name, GTK_WIDGET(pathEntry.m_frame));
 706   DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
 707
 708   return GTK_WIDGET(row);
 709 }
 710
 711 GtkWidget* Dialog::addPathEntry(GtkWidget* vbox, const char* name, CopiedString& data, bool browse_directory)
 712 {
 713   return addPathEntry(vbox, name, browse_directory, StringImportCallback(StringImportCaller(data)), StringExportCallback(StringExportCaller(data)));
 714 }
 715
 716 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, double value, double lower, double upper, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
 717 {
 718   DialogSpinnerRow row(DialogSpinnerRow_new(name, value, lower, upper, 1));
 719   AddIntSpinnerData(*row.m_spin, importViewer, exportViewer);
 720   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 721   return row.m_row;
 722 }
 723
 724 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, int& data, double value, double lower, double upper)
 725 {
 726   return addSpinner(vbox, name, value, lower, upper, IntImportCallback(IntImportCaller(data)), IntExportCallback(IntExportCaller(data)));
 727 }
 728
 729 GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, double value, double lower, double upper, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
 730 {
 731   DialogSpinnerRow row(DialogSpinnerRow_new(name, value, lower, upper, 10));
 732   AddFloatSpinnerData(*row.m_spin, importViewer, exportViewer);
 733   DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
 734   return row.m_row;
 735 }