libs/gtkmm2ext/gtk_ui.cc

   1 /*
   2     Copyright (C) 1999-2005 Paul Barton-Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id$
  19 */
  20
  21 #include <cmath>
  22 #include <fcntl.h>
  23 #include <signal.h>
  24 #include <unistd.h>
  25 #include <cerrno>
  26 #include <climits>
  27 #include <cctype>
  28
  29 #include <gtkmm.h>
  30 #include <pbd/error.h>
  31 #include <pbd/touchable.h>
  32 #include <pbd/failed_constructor.h>
  33 #include <pbd/pthread_utils.h>
  34 #include <pbd/stacktrace.h>
  35
  36 #include <gtkmm2ext/gtk_ui.h>
  37 #include <gtkmm2ext/textviewer.h>
  38 #include <gtkmm2ext/popup.h>
  39 #include <gtkmm2ext/utils.h>
  40
  41 #include "i18n.h"
  42
  43 using namespace Gtkmm2ext;
  44 using namespace Gtk;
  45 using namespace Glib;
  46 using namespace PBD;
  47 using std::map;
  48
  49 pthread_t UI::gui_thread;
  50 UI       *UI::theGtkUI = 0;
  51
  52 BaseUI::RequestType Gtkmm2ext::ErrorMessage = BaseUI::new_request_type();
  53 BaseUI::RequestType Gtkmm2ext::Quit = BaseUI::new_request_type();
  54 BaseUI::RequestType Gtkmm2ext::TouchDisplay = BaseUI::new_request_type();
  55 BaseUI::RequestType Gtkmm2ext::StateChange = BaseUI::new_request_type();
  56 BaseUI::RequestType Gtkmm2ext::SetTip = BaseUI::new_request_type();
  57 BaseUI::RequestType Gtkmm2ext::AddIdle = BaseUI::new_request_type();
  58 BaseUI::RequestType Gtkmm2ext::AddTimeout = BaseUI::new_request_type();
  59
  60 #include <pbd/abstract_ui.cc>  /* instantiate the template */
  61
  62
  63 UI::UI (string namestr, int *argc, char ***argv, string rcfile)
  64         : AbstractUI<UIRequest> (namestr, true)
  65 {
  66         theMain = new Main (argc, argv);
  67         tips = new Tooltips;
  68
  69         _active = false;
  70
  71         if (!theGtkUI) {
  72                 theGtkUI = this;
  73                 gui_thread = pthread_self ();
  74         } else {
  75                 fatal << "duplicate UI requested" << endmsg;
  76                 /* NOTREACHED */
  77         }
  78
  79         /* add the pipe to the select/poll loop that GDK does */
  80
  81         gdk_input_add (signal_pipe[0],
  82                        GDK_INPUT_READ,
  83                        UI::signal_pipe_callback,
  84                        this);
  85
  86         errors = new TextViewer (850,100);
  87         errors->text().set_editable (false);
  88         errors->text().set_name ("ErrorText");
  89
  90         string title;
  91         title = namestr;
  92         title += ": Log";
  93         errors->set_title (title);
  94
  95         errors->dismiss_button().set_name ("ErrorLogCloseButton");
  96         errors->signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), (Window *) errors));
  97
  98         register_thread (pthread_self(), X_("GUI"));
  99
 100         load_rcfile (rcfile);
 101 }
 102
 103 UI::~UI ()
 104 {
 105 }
 106
 107
 108 bool
 109 UI::caller_is_ui_thread ()
 110 {
 111         return pthread_equal (gui_thread, pthread_self());
 112 }
 113
 114 int
 115 UI::load_rcfile (string path)
 116 {
 117         if (path.length() == 0) {
 118                 return -1;
 119         }
 120
 121         if (access (path.c_str(), R_OK)) {
 122                 error << "UI: couldn't find rc file \""
 123                       << path
 124                       << '"'
 125                       << endmsg;
 126                 return -1;
 127         }
 128
 129         RC rc (path.c_str());
 130
 131         /* have to pack widgets into a toplevel window so that styles will stick */
 132
 133         Window temp_window (WINDOW_TOPLEVEL);
 134         HBox box;
 135         Label a_widget1;
 136         Label a_widget2;
 137         Label a_widget3;
 138         Label a_widget4;
 139         RefPtr<Gtk::Style> style;
 140         RefPtr<TextBuffer> buffer (errors->text().get_buffer());
 141
 142         box.pack_start (a_widget1);
 143         box.pack_start (a_widget2);
 144         box.pack_start (a_widget3);
 145         box.pack_start (a_widget4);
 146
 147         error_ptag = buffer->create_tag();
 148         error_mtag = buffer->create_tag();
 149         fatal_ptag = buffer->create_tag();
 150         fatal_mtag = buffer->create_tag();
 151         warning_ptag = buffer->create_tag();
 152         warning_mtag = buffer->create_tag();
 153         info_ptag = buffer->create_tag();
 154         info_mtag = buffer->create_tag();
 155
 156         a_widget1.set_name ("FatalMessage");
 157         a_widget1.ensure_style ();
 158         style = a_widget1.get_style();
 159
 160         fatal_ptag->property_font_desc().set_value(style->get_font());
 161         fatal_ptag->property_foreground_gdk().set_value(style->get_fg(STATE_ACTIVE));
 162         fatal_ptag->property_background_gdk().set_value(style->get_bg(STATE_ACTIVE));
 163         fatal_mtag->property_font_desc().set_value(style->get_font());
 164         fatal_mtag->property_foreground_gdk().set_value(style->get_fg(STATE_NORMAL));
 165         fatal_mtag->property_background_gdk().set_value(style->get_bg(STATE_NORMAL));
 166
 167         a_widget2.set_name ("ErrorMessage");
 168         a_widget2.ensure_style ();
 169         style = a_widget2.get_style();
 170
 171         error_ptag->property_font_desc().set_value(style->get_font());
 172         error_ptag->property_foreground_gdk().set_value(style->get_fg(STATE_ACTIVE));
 173         error_ptag->property_background_gdk().set_value(style->get_bg(STATE_ACTIVE));
 174         error_mtag->property_font_desc().set_value(style->get_font());
 175         error_mtag->property_foreground_gdk().set_value(style->get_fg(STATE_NORMAL));
 176         error_mtag->property_background_gdk().set_value(style->get_bg(STATE_NORMAL));
 177
 178         a_widget3.set_name ("WarningMessage");
 179         a_widget3.ensure_style ();
 180         style = a_widget3.get_style();
 181
 182         warning_ptag->property_font_desc().set_value(style->get_font());
 183         warning_ptag->property_foreground_gdk().set_value(style->get_fg(STATE_ACTIVE));
 184         warning_ptag->property_background_gdk().set_value(style->get_bg(STATE_ACTIVE));
 185         warning_mtag->property_font_desc().set_value(style->get_font());
 186         warning_mtag->property_foreground_gdk().set_value(style->get_fg(STATE_NORMAL));
 187         warning_mtag->property_background_gdk().set_value(style->get_bg(STATE_NORMAL));
 188
 189         a_widget4.set_name ("InfoMessage");
 190         a_widget4.ensure_style ();
 191         style = a_widget4.get_style();
 192
 193         info_ptag->property_font_desc().set_value(style->get_font());
 194         info_ptag->property_foreground_gdk().set_value(style->get_fg(STATE_ACTIVE));
 195         info_ptag->property_background_gdk().set_value(style->get_bg(STATE_ACTIVE));
 196         info_mtag->property_font_desc().set_value(style->get_font());
 197         info_mtag->property_foreground_gdk().set_value(style->get_fg(STATE_NORMAL));
 198         info_mtag->property_background_gdk().set_value(style->get_bg(STATE_NORMAL));
 199
 200         return 0;
 201 }
 202
 203 void
 204 UI::run (Receiver &old_receiver)
 205 {
 206         listen_to (error);
 207         listen_to (info);
 208         listen_to (warning);
 209         listen_to (fatal);
 210
 211         old_receiver.hangup ();
 212         starting ();
 213         _active = true;
 214         theMain->run ();
 215         _active = false;
 216         stopping ();
 217         hangup ();
 218         return;
 219 }
 220
 221 bool
 222 UI::running ()
 223 {
 224         return _active;
 225 }
 226
 227 void
 228 UI::kill ()
 229 {
 230         if (_active) {
 231                 pthread_kill (gui_thread, SIGKILL);
 232         }
 233 }
 234
 235 void
 236 UI::quit ()
 237 {
 238         UIRequest *req = get_request (Quit);
 239
 240         if (req == 0) {
 241                 return;
 242         }
 243
 244         send_request (req);
 245 }
 246
 247 static bool idle_quit ()
 248 {
 249         Main::quit ();
 250         return true;
 251 }
 252
 253 void
 254 UI::do_quit ()
 255 {
 256         Main::quit ();
 257         // Glib::signal_idle().connect (sigc::ptr_fun (idle_quit));
 258 }
 259
 260 void
 261 UI::touch_display (Touchable *display)
 262 {
 263         UIRequest *req = get_request (TouchDisplay);
 264
 265         if (req == 0) {
 266                 return;
 267         }
 268
 269         req->display = display;
 270
 271         send_request (req);
 272 }
 273
 274 void
 275 UI::set_tip (Widget *w, const gchar *tip, const gchar *hlp)
 276 {
 277         UIRequest *req = get_request (SetTip);
 278
 279         if (req == 0) {
 280                 return;
 281         }
 282
 283         req->widget = w;
 284         req->msg = tip;
 285         req->msg2 = hlp;
 286
 287         send_request (req);
 288 }
 289
 290 void
 291 UI::set_state (Widget *w, StateType state)
 292 {
 293         UIRequest *req = get_request (StateChange);
 294
 295         if (req == 0) {
 296                 return;
 297         }
 298
 299         req->new_state = state;
 300         req->widget = w;
 301
 302         send_request (req);
 303 }
 304
 305 void
 306 UI::idle_add (int (*func)(void *), void *arg)
 307 {
 308         UIRequest *req = get_request (AddIdle);
 309
 310         if (req == 0) {
 311                 return;
 312         }
 313
 314         req->function = func;
 315         req->arg = arg;
 316
 317         send_request (req);
 318 }
 319
 320 /* END abstract_ui interfaces */
 321
 322 void
 323 UI::signal_pipe_callback (void *arg, int fd, GdkInputCondition cond)
 324 {
 325         char buf[256];
 326
 327         /* flush (nonblocking) pipe */
 328
 329         while (read (fd, buf, 256) > 0);
 330
 331         ((UI *) arg)->handle_ui_requests ();
 332 }
 333
 334 void
 335 UI::do_request (UIRequest* req)
 336 {
 337         if (req->type == ErrorMessage) {
 338
 339                 process_error_message (req->chn, req->msg);
 340                 free (const_cast<char*>(req->msg)); /* it was strdup'ed */
 341                 req->msg = 0; /* don't free it again in the destructor */
 342
 343         } else if (req->type == Quit) {
 344
 345                 do_quit ();
 346
 347         } else if (req->type == CallSlot) {
 348
 349                 req->slot ();
 350
 351         } else if (req->type == TouchDisplay) {
 352
 353                 req->display->touch ();
 354                 if (req->display->delete_after_touch()) {
 355                         delete req->display;
 356                 }
 357
 358         } else if (req->type == StateChange) {
 359
 360                 req->widget->set_state (req->new_state);
 361
 362         } else if (req->type == SetTip) {
 363
 364                 /* XXX need to figure out how this works */
 365
 366         } else {
 367
 368                 error << "GtkUI: unknown request type "
 369                       << (int) req->type
 370                       << endmsg;
 371         }
 372 }
 373
 374 /*======================================================================
 375   Error Display
 376   ======================================================================*/
 377
 378 void
 379 UI::receive (Transmitter::Channel chn, const char *str)
 380 {
 381         if (caller_is_ui_thread()) {
 382                 process_error_message (chn, str);
 383         } else {
 384                 UIRequest* req = get_request (ErrorMessage);
 385
 386                 if (req == 0) {
 387                         return;
 388                 }
 389
 390                 req->chn = chn;
 391                 req->msg = strdup (str);
 392
 393                 send_request (req);
 394         }
 395 }
 396
 397 #define OLD_STYLE_ERRORS 1
 398
 399 void
 400 UI::process_error_message (Transmitter::Channel chn, const char *str)
 401 {
 402         RefPtr<Style> style;
 403         RefPtr<TextBuffer::Tag> ptag;
 404         RefPtr<TextBuffer::Tag> mtag;
 405         char *prefix;
 406         size_t prefix_len;
 407         bool fatal_received = false;
 408 #ifndef OLD_STYLE_ERRORS
 409         PopUp* popup = new PopUp (WIN_POS_CENTER, 0, true);
 410 #endif
 411
 412         switch (chn) {
 413         case Transmitter::Fatal:
 414                 prefix = "[FATAL]: ";
 415                 ptag = fatal_ptag;
 416                 mtag = fatal_mtag;
 417                 prefix_len = 9;
 418                 fatal_received = true;
 419                 break;
 420         case Transmitter::Error:
 421 #if OLD_STYLE_ERRORS
 422                 prefix = "[ERROR]: ";
 423                 ptag = error_ptag;
 424                 mtag = error_mtag;
 425                 prefix_len = 9;
 426 #else
 427                 popup->set_name ("ErrorMessage");
 428                 popup->set_text (str);
 429                 popup->touch ();
 430                 return;
 431 #endif
 432                 break;
 433         case Transmitter::Info:
 434 #if OLD_STYLE_ERRORS
 435                 prefix = "[INFO]: ";
 436                 ptag = info_ptag;
 437                 mtag = info_mtag;
 438                 prefix_len = 8;
 439 #else
 440                 popup->set_name ("InfoMessage");
 441                 popup->set_text (str);
 442                 popup->touch ();
 443                 return;
 444 #endif
 445
 446                 break;
 447         case Transmitter::Warning:
 448 #if OLD_STYLE_ERRORS
 449                 prefix = "[WARNING]: ";
 450                 ptag = warning_ptag;
 451                 mtag = warning_mtag;
 452                 prefix_len = 11;
 453 #else
 454                 popup->set_name ("WarningMessage");
 455                 popup->set_text (str);
 456                 popup->touch ();
 457                 return;
 458 #endif
 459                 break;
 460         default:
 461                 /* no choice but to use text/console output here */
 462                 cerr << "programmer error in UI::check_error_messages (channel = " << chn << ")\n";
 463                 ::exit (1);
 464         }
 465
 466         errors->text().get_buffer()->begin_user_action();
 467
 468         if (fatal_received) {
 469                 handle_fatal (str);
 470         } else {
 471
 472                 display_message (prefix, prefix_len, ptag, mtag, str);
 473
 474                 if (!errors->is_visible()) {
 475                         toggle_errors();
 476                 }
 477         }
 478
 479         errors->text().get_buffer()->end_user_action();
 480 }
 481
 482 void
 483 UI::toggle_errors ()
 484 {
 485         if (!errors->is_visible()) {
 486                 errors->set_position (WIN_POS_MOUSE);
 487                 errors->show ();
 488         } else {
 489                 errors->hide ();
 490         }
 491 }
 492
 493 void
 494 UI::display_message (const char *prefix, gint prefix_len, RefPtr<TextBuffer::Tag> ptag, RefPtr<TextBuffer::Tag> mtag, const char *msg)
 495 {
 496         RefPtr<TextBuffer> buffer (errors->text().get_buffer());
 497
 498         buffer->insert_with_tag(buffer->end(), prefix, ptag);
 499         buffer->insert_with_tag(buffer->end(), msg, mtag);
 500         buffer->insert_with_tag(buffer->end(), "\n", mtag);
 501
 502         errors->scroll_to_bottom ();
 503 }
 504
 505 void
 506 UI::handle_fatal (const char *message)
 507 {
 508         Window win (WINDOW_POPUP);
 509         VBox packer;
 510         Label label (message);
 511         Button quit (_("Press To Exit"));
 512
 513         win.set_default_size (400, 100);
 514
 515         string title;
 516         title = name();
 517         title += ": Fatal Error";
 518         win.set_title (title);
 519
 520         win.set_position (WIN_POS_MOUSE);
 521         win.add (packer);
 522
 523         packer.pack_start (label, true, true);
 524         packer.pack_start (quit, false, false);
 525         quit.signal_clicked().connect(mem_fun(*this,&UI::quit));
 526
 527         win.show_all ();
 528         win.set_modal (true);
 529
 530         theMain->run ();
 531
 532         exit (1);
 533 }
 534
 535 void
 536 UI::popup_error (const char *text)
 537 {
 538         PopUp *pup;
 539
 540         if (!caller_is_ui_thread()) {
 541                 error << "non-UI threads can't use UI::popup_error"
 542                       << endmsg;
 543                 return;
 544         }
 545
 546         pup = new PopUp (WIN_POS_MOUSE, 0, true);
 547         pup->set_text (text);
 548         pup->touch ();
 549 }
 550
 551
 552 void
 553 UI::flush_pending ()
 554 {
 555         if (!caller_is_ui_thread()) {
 556                 error << "non-UI threads cannot call UI::flush_pending()"
 557                       << endmsg;
 558                 return;
 559         }
 560
 561         gtk_main_iteration();
 562
 563         while (gtk_events_pending()) {
 564                 gtk_main_iteration();
 565         }
 566 }
 567
 568 bool
 569 UI::just_hide_it (GdkEventAny *ev, Window *win)
 570 {
 571         win->hide_all ();
 572         return true;
 573 }
 574
 575 Gdk::Color
 576 UI::get_color (const string& prompt, bool& picked, const Gdk::Color* initial)
 577 {
 578         Gdk::Color color;
 579
 580         ColorSelectionDialog color_dialog (prompt);
 581
 582         color_dialog.set_modal (true);
 583         color_dialog.get_cancel_button()->signal_clicked().connect (bind (mem_fun (*this, &UI::color_selection_done), false));
 584         color_dialog.get_ok_button()->signal_clicked().connect (bind (mem_fun (*this, &UI::color_selection_done), true));
 585         color_dialog.signal_delete_event().connect (mem_fun (*this, &UI::color_selection_deleted));
 586
 587         if (initial) {
 588                 color_dialog.get_colorsel()->set_current_color (*initial);
 589         }
 590
 591         color_dialog.show_all ();
 592         color_picked = false;
 593         picked = false;
 594
 595         Main::run();
 596
 597         color_dialog.hide_all ();
 598
 599         if (color_picked) {
 600                 Gdk::Color f_rgba = color_dialog.get_colorsel()->get_current_color ();
 601                 color.set_red(f_rgba.get_red());
 602                 color.set_green(f_rgba.get_green());
 603                 color.set_blue(f_rgba.get_blue());
 604
 605                 picked = true;
 606         }
 607
 608         return color;
 609 }
 610
 611 void
 612 UI::color_selection_done (bool status)
 613 {
 614         color_picked = status;
 615         Main::quit ();
 616 }
 617
 618 bool
 619 UI::color_selection_deleted (GdkEventAny *ev)
 620 {
 621         Main::quit ();
 622         return true;
 623 }