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