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         Glib::signal_idle().connect (sigc::ptr_fun (idle_quit));
 257 }
 258
 259 void
 260 UI::touch_display (Touchable *display)
 261 {
 262         UIRequest *req = get_request (TouchDisplay);
 263
 264         if (req == 0) {
 265                 return;
 266         }
 267
 268         req->display = display;
 269
 270         send_request (req);
 271 }
 272
 273 void
 274 UI::set_tip (Widget *w, const gchar *tip, const gchar *hlp)
 275 {
 276         UIRequest *req = get_request (SetTip);
 277
 278         if (req == 0) {
 279                 return;
 280         }
 281
 282         req->widget = w;
 283         req->msg = tip;
 284         req->msg2 = hlp;
 285
 286         send_request (req);
 287 }
 288
 289 void
 290 UI::set_state (Widget *w, StateType state)
 291 {
 292         UIRequest *req = get_request (StateChange);
 293
 294         if (req == 0) {
 295                 return;
 296         }
 297
 298         req->new_state = state;
 299         req->widget = w;
 300
 301         send_request (req);
 302 }
 303
 304 void
 305 UI::idle_add (int (*func)(void *), void *arg)
 306 {
 307         UIRequest *req = get_request (AddIdle);
 308
 309         if (req == 0) {
 310                 return;
 311         }
 312
 313         req->function = func;
 314         req->arg = arg;
 315
 316         send_request (req);
 317 }
 318
 319 /* END abstract_ui interfaces */
 320
 321 void
 322 UI::signal_pipe_callback (void *arg, int fd, GdkInputCondition cond)
 323 {
 324         char buf[256];
 325
 326         /* flush (nonblocking) pipe */
 327
 328         while (read (fd, buf, 256) > 0);
 329
 330         ((UI *) arg)->handle_ui_requests ();
 331 }
 332
 333 void
 334 UI::do_request (UIRequest* req)
 335 {
 336         if (req->type == ErrorMessage) {
 337
 338                 process_error_message (req->chn, req->msg);
 339                 free (const_cast<char*>(req->msg)); /* it was strdup'ed */
 340                 req->msg = 0; /* don't free it again in the destructor */
 341
 342         } else if (req->type == Quit) {
 343
 344                 do_quit ();
 345
 346         } else if (req->type == CallSlot) {
 347
 348                 req->slot ();
 349
 350         } else if (req->type == TouchDisplay) {
 351
 352                 req->display->touch ();
 353                 if (req->display->delete_after_touch()) {
 354                         delete req->display;
 355                 }
 356
 357         } else if (req->type == StateChange) {
 358
 359                 req->widget->set_state (req->new_state);
 360
 361         } else if (req->type == SetTip) {
 362
 363                 /* XXX need to figure out how this works */
 364
 365         } else {
 366
 367                 error << "GtkUI: unknown request type "
 368                       << (int) req->type
 369                       << endmsg;
 370         }
 371 }
 372
 373 /*======================================================================
 374   Error Display
 375   ======================================================================*/
 376
 377 void
 378 UI::receive (Transmitter::Channel chn, const char *str)
 379 {
 380         if (caller_is_ui_thread()) {
 381                 process_error_message (chn, str);
 382         } else {
 383                 UIRequest* req = get_request (ErrorMessage);
 384
 385                 if (req == 0) {
 386                         return;
 387                 }
 388
 389                 req->chn = chn;
 390                 req->msg = strdup (str);
 391
 392                 send_request (req);
 393         }
 394 }
 395
 396 #define OLD_STYLE_ERRORS 1
 397
 398 void
 399 UI::process_error_message (Transmitter::Channel chn, const char *str)
 400 {
 401         RefPtr<Style> style;
 402         RefPtr<TextBuffer::Tag> ptag;
 403         RefPtr<TextBuffer::Tag> mtag;
 404         char *prefix;
 405         size_t prefix_len;
 406         bool fatal_received = false;
 407 #ifndef OLD_STYLE_ERRORS
 408         PopUp* popup = new PopUp (WIN_POS_CENTER, 0, true);
 409 #endif
 410
 411         switch (chn) {
 412         case Transmitter::Fatal:
 413                 prefix = "[FATAL]: ";
 414                 ptag = fatal_ptag;
 415                 mtag = fatal_mtag;
 416                 prefix_len = 9;
 417                 fatal_received = true;
 418                 break;
 419         case Transmitter::Error:
 420 #if OLD_STYLE_ERRORS
 421                 prefix = "[ERROR]: ";
 422                 ptag = error_ptag;
 423                 mtag = error_mtag;
 424                 prefix_len = 9;
 425 #else
 426                 popup->set_name ("ErrorMessage");
 427                 popup->set_text (str);
 428                 popup->touch ();
 429                 return;
 430 #endif
 431                 break;
 432         case Transmitter::Info:
 433 #if OLD_STYLE_ERRORS
 434                 prefix = "[INFO]: ";
 435                 ptag = info_ptag;
 436                 mtag = info_mtag;
 437                 prefix_len = 8;
 438 #else
 439                 popup->set_name ("InfoMessage");
 440                 popup->set_text (str);
 441                 popup->touch ();
 442                 return;
 443 #endif
 444
 445                 break;
 446         case Transmitter::Warning:
 447 #if OLD_STYLE_ERRORS
 448                 prefix = "[WARNING]: ";
 449                 ptag = warning_ptag;
 450                 mtag = warning_mtag;
 451                 prefix_len = 11;
 452 #else
 453                 popup->set_name ("WarningMessage");
 454                 popup->set_text (str);
 455                 popup->touch ();
 456                 return;
 457 #endif
 458                 break;
 459         default:
 460                 /* no choice but to use text/console output here */
 461                 cerr << "programmer error in UI::check_error_messages (channel = " << chn << ")\n";
 462                 ::exit (1);
 463         }
 464
 465         errors->text().get_buffer()->begin_user_action();
 466
 467         if (fatal_received) {
 468                 handle_fatal (str);
 469         } else {
 470
 471                 display_message (prefix, prefix_len, ptag, mtag, str);
 472
 473                 if (!errors->is_visible()) {
 474                         toggle_errors();
 475                 }
 476         }
 477
 478         errors->text().get_buffer()->end_user_action();
 479 }
 480
 481 void
 482 UI::toggle_errors ()
 483 {
 484         if (!errors->is_visible()) {
 485                 errors->set_position (WIN_POS_MOUSE);
 486                 errors->show ();
 487         } else {
 488                 errors->hide ();
 489         }
 490 }
 491
 492 void
 493 UI::display_message (const char *prefix, gint prefix_len, RefPtr<TextBuffer::Tag> ptag, RefPtr<TextBuffer::Tag> mtag, const char *msg)
 494 {
 495         RefPtr<TextBuffer> buffer (errors->text().get_buffer());
 496
 497         buffer->insert_with_tag(buffer->end(), prefix, ptag);
 498         buffer->insert_with_tag(buffer->end(), msg, mtag);
 499         buffer->insert_with_tag(buffer->end(), "\n", mtag);
 500
 501         errors->scroll_to_bottom ();
 502 }
 503
 504 void
 505 UI::handle_fatal (const char *message)
 506 {
 507         Window win (WINDOW_POPUP);
 508         VBox packer;
 509         Label label (message);
 510         Button quit (_("Press To Exit"));
 511
 512         win.set_default_size (400, 100);
 513
 514         string title;
 515         title = name();
 516         title += ": Fatal Error";
 517         win.set_title (title);
 518
 519         win.set_position (WIN_POS_MOUSE);
 520         win.add (packer);
 521
 522         packer.pack_start (label, true, true);
 523         packer.pack_start (quit, false, false);
 524         quit.signal_clicked().connect(mem_fun(*this,&UI::quit));
 525
 526         win.show_all ();
 527         win.set_modal (true);
 528
 529         theMain->run ();
 530
 531         exit (1);
 532 }
 533
 534 void
 535 UI::popup_error (const char *text)
 536 {
 537         PopUp *pup;
 538
 539         if (!caller_is_ui_thread()) {
 540                 error << "non-UI threads can't use UI::popup_error"
 541                       << endmsg;
 542                 return;
 543         }
 544
 545         pup = new PopUp (WIN_POS_MOUSE, 0, true);
 546         pup->set_text (text);
 547         pup->touch ();
 548 }
 549
 550
 551 void
 552 UI::flush_pending ()
 553 {
 554         if (!caller_is_ui_thread()) {
 555                 error << "non-UI threads cannot call UI::flush_pending()"
 556                       << endmsg;
 557                 return;
 558         }
 559
 560         gtk_main_iteration();
 561
 562         while (gtk_events_pending()) {
 563                 gtk_main_iteration();
 564         }
 565 }
 566
 567 bool
 568 UI::just_hide_it (GdkEventAny *ev, Window *win)
 569 {
 570         win->hide_all ();
 571         return true;
 572 }
 573
 574 Gdk::Color
 575 UI::get_color (const string& prompt, bool& picked, const Gdk::Color* initial)
 576 {
 577         Gdk::Color color;
 578
 579         ColorSelectionDialog color_dialog (prompt);
 580
 581         color_dialog.set_modal (true);
 582         color_dialog.get_cancel_button()->signal_clicked().connect (bind (mem_fun (*this, &UI::color_selection_done), false));
 583         color_dialog.get_ok_button()->signal_clicked().connect (bind (mem_fun (*this, &UI::color_selection_done), true));
 584         color_dialog.signal_delete_event().connect (mem_fun (*this, &UI::color_selection_deleted));
 585
 586         if (initial) {
 587                 color_dialog.get_colorsel()->set_current_color (*initial);
 588         }
 589
 590         color_dialog.show_all ();
 591         color_picked = false;
 592         picked = false;
 593
 594         Main::run();
 595
 596         color_dialog.hide_all ();
 597
 598         if (color_picked) {
 599                 Gdk::Color f_rgba = color_dialog.get_colorsel()->get_current_color ();
 600                 color.set_red(f_rgba.get_red());
 601                 color.set_green(f_rgba.get_green());
 602                 color.set_blue(f_rgba.get_blue());
 603
 604                 picked = true;
 605         }
 606
 607         return color;
 608 }
 609
 610 void
 611 UI::color_selection_done (bool status)
 612 {
 613         color_picked = status;
 614         Main::quit ();
 615 }
 616
 617 bool
 618 UI::color_selection_deleted (GdkEventAny *ev)
 619 {
 620         Main::quit ();
 621         return true;
 622 }