gtk_gui.cpp

彩信浏览器

	AM_DBG printf("gtk_gui::need_redraw(0x%x)-r=(0x%x)\n",
	(void *)this,r?r:0);
	g_signal_emit(GTK_OBJECT (m_toplevelcontainer), signal_need_redraw_id, 0, r, w, pt);
}

void 
gtk_gui::player_done() {
	AM_DBG printf("%s-%s\n", m_programfilename, "player_done");
	g_signal_emit(GTK_OBJECT (m_toplevelcontainer), signal_player_done_id, 0);
}

void
no_fileopen_infodisplay(gtk_gui* w, const char* caption) {
	GtkMessageDialog* dialog = 
	(GtkMessageDialog*) gtk_message_dialog_new (NULL,
         GTK_DIALOG_DESTROY_WITH_PARENT,
         GTK_MESSAGE_INFO,
         GTK_BUTTONS_OK,
	 caption);
	gtk_message_dialog_format_secondary_markup (dialog, "No file open: Please first select File->Open");
 	gtk_dialog_run (GTK_DIALOG (dialog));
 	gtk_widget_destroy (GTK_WIDGET (dialog));
}

void 
gtk_gui::do_play() {
	AM_DBG printf("%s-%s m_mainloop=0x%x\n", m_programfilename, "do_play", m_mainloop);
 	assert(m_mainloop);
 	m_mainloop->play();
 	_update_menus();
}

void 
gtk_gui::do_pause() {
	AM_DBG printf("%s-%s m_mainloop=0x%x\n", m_programfilename, "do_pause", m_mainloop);
 	assert(m_mainloop);
 	m_mainloop->pause();
 	_update_menus();
}

void 
gtk_gui::do_reload() {
	AM_DBG printf("%s-%s m_mainloop=0x%x\n", m_programfilename, "do_reload", m_mainloop);
     	assert(m_mainloop);
     	m_mainloop->restart(true);
     	_update_menus();
}

void 
gtk_gui::do_stop() {
	AM_DBG printf("%s-%s m_mainloop=0x%x\n", m_programfilename, "do_stop", m_mainloop);
 	assert(m_mainloop);
	if(m_mainloop)
		m_mainloop->stop();
 	_update_menus();
}

void 
gtk_gui::do_settings_select() {

	m_settings = new gtk_settings();
	gint result = gtk_dialog_run (GTK_DIALOG (m_settings->getWidget()));
  	switch (result){
      	case GTK_RESPONSE_ACCEPT:
		m_settings->settings_ok();
	       	break;
      	default:
         	break;
    	}
	gtk_widget_destroy (GTK_WIDGET (m_settings->getWidget()));
}

void
gtk_gui::do_quit() {
	AM_DBG printf("%s-%s\n", m_programfilename, "do_quit");
	if (m_mainloop)	{
		m_mainloop->stop();
		delete m_mainloop;
		m_mainloop = NULL;
	}
	g_main_loop_quit (main_loop);	
}

void
gtk_gui::do_resize(GdkEventConfigure *event) {
//	gtk_window_set_default_size(m_toplevelcontainer, event->width, menubar->allocation.height + event->height);
}


#ifndef QT_NO_FILEDIALOG	/* Assume plain Qt */
void
gtk_gui::unsetCursor() { //XXXX Hack
//	AM_DBG printf("%s-%s\n", m_programfilename, ":unsetCursor");
/**
	Qt::CursorShape cursor_shape = m_mainloop->get_cursor() ?
		Qt::PointingHandCursor : Qt::ArrowCursor;
	if (cursor_shape != m_cursor_shape) {
		m_cursor_shape = cursor_shape;
		setCursor(cursor_shape);
	}
#ifdef	QCURSOR_ON_ZAURUS
	bool pointinghand_cursor = m_mainloop->get_cursor();
	QCursor cursor_shape = pointinghand_cursor ?
		pointingHandCursor : arrowCursor;
	if (m_pointinghand_cursor != pointinghand_cursor) {
		m_pointinghand_cursor = pointinghand_cursor;
		setCursor(cursor_shape);
	}
#endif**//*QCURSOR_ON_ZAURUS*/
//	m_mainloop->set_cursor(0);
}
#endif/*QT_NO_FILEDIALOG*/

void
gtk_gui::do_internal_message(gtk_message_event* e) {
	char* msg = (char*)e->get_message();
	//std::string id("gtk_gui::do_internal_message");
	//std::cerr<<id<<std::endl;
	//std::cerr<<id+" type: "<<e->get_type()<<" msg:"<<msg<<std::endl;
	int level = e->get_type() - gtk_logger::CUSTOM_OFFSET;
	GtkMessageDialog* dialog; // just in case is needed
	switch (level) {
	case gtk_logger::CUSTOM_NEW_DOCUMENT:
		if (m_mainloop) {
			bool start = msg[0] == 'S' ? true : false;
			bool old = msg[2] == 'O' ? true : false;
			m_mainloop->player_start(&msg[4], start, old);
		}
		break;
	case gtk_logger::CUSTOM_LOGMESSAGE:
#ifdef	LOCK_MESSAGE
		if (pthread_mutex_lock(&m_lock_message) != 0){
			printf("pthread_mutex_lock(&m_lock_message) sets errno to %d.\n", errno);
			abort();
		}
#endif /*LOCK_MESSAGE*/
		/* mutex lcoking is required for calling gtk_text_buffer_insert_at_cursor()
		 * Otherwiser GTK+ may crash with a cd $Ecryptic message suck as:
		 * Gtk-WARNING **: Invalid text buffer iterator: either the iterator is
		 * uninitialized, or the characters/pixbufs/widgets in the buffer have been
		 * modified since the iterator was created.
		 */
		gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER (gtk_logger::get_gtk_logger()->get_logger_buffer()), msg, strlen(msg));
#ifdef	LOCK_MESSAGE
		pthread_mutex_unlock(&m_lock_message);
#endif /*LOCK_MESSAGE*/
		break;
	case ambulant::lib::logger::LEVEL_FATAL:
		dialog = (GtkMessageDialog*) gtk_message_dialog_new (NULL,
         	GTK_DIALOG_DESTROY_WITH_PARENT,
         	GTK_MESSAGE_ERROR,
         	GTK_BUTTONS_OK,
	 	msg);
 		gtk_dialog_run (GTK_DIALOG (dialog));
 		gtk_widget_destroy (GTK_WIDGET (dialog));
		break;
	case ambulant::lib::logger::LEVEL_ERROR:
		dialog = (GtkMessageDialog*) gtk_message_dialog_new (NULL,
         	GTK_DIALOG_DESTROY_WITH_PARENT,
         	GTK_MESSAGE_WARNING,
         	GTK_BUTTONS_OK,
	 	msg);
 		gtk_dialog_run (GTK_DIALOG (dialog));
 		gtk_widget_destroy (GTK_WIDGET (dialog));
		break;
	case ambulant::lib::logger::LEVEL_WARN:
	default:
		dialog = (GtkMessageDialog*) gtk_message_dialog_new (NULL,
         	GTK_DIALOG_DESTROY_WITH_PARENT,
         	GTK_MESSAGE_INFO,
         	GTK_BUTTONS_OK,
	 	msg);
 		gtk_dialog_run (GTK_DIALOG (dialog));
 		gtk_widget_destroy (GTK_WIDGET (dialog));
		break;
	}
#ifdef	LOCK_MESSAGE
	if (level >= ambulant::lib::logger::LEVEL_WARN) {
		pthread_mutex_lock(&m_lock_message);
		pthread_cond_signal(&m_cond_message);
		pthread_mutex_unlock(&m_lock_message);
	}
#endif/*LOCK_MESSAGE*/
	free(msg);
}

void
gtk_gui::internal_message(int level, char* msg) {
	
	int msg_id = level+gtk_logger::CUSTOM_OFFSET;
	gtk_message_event* event = new gtk_message_event(msg_id, msg);
	g_signal_emit(GTK_OBJECT (m_toplevelcontainer), signal_internal_message_id, 0, event);

#ifdef	LOCK_MESSAGE
	if (level >= ambulant::lib::logger::LEVEL_WARN
	    && pthread_self() != m_gui_thread) {
	  // wait until the message as been OK'd by the user
		pthread_mutex_lock(&m_lock_message);
		pthread_cond_wait(&m_cond_message, &m_lock_message);
		pthread_mutex_unlock(&m_lock_message);
	}
#endif /*LOCK_MESSAGE*/
}

void
gtk_gui::_update_menus()
{
  AM_DBG if (m_mainloop) printf("gtk_gui::_update_menus(0x%x) play_enabled=%d play_active=%d pause_enabled=%d pause_active=%d stop_enabled=%d stop_active=%d \n", this, m_mainloop->is_play_enabled(), m_mainloop->is_play_active(), m_mainloop->is_pause_enabled(), m_mainloop->is_pause_active(), m_mainloop->is_stop_enabled(), m_mainloop->is_stop_active());
    gtk_action_set_sensitive(gtk_action_group_get_action (m_actions, "play"),
        m_mainloop && m_mainloop->is_play_enabled() && ! m_mainloop->is_play_active());
    gtk_action_set_sensitive(gtk_action_group_get_action (m_actions, "pause"),
        m_mainloop && m_mainloop->is_pause_enabled() && ! m_mainloop->is_pause_active());
    gtk_action_set_sensitive(gtk_action_group_get_action (m_actions, "stop"),
        m_mainloop && m_mainloop->is_stop_enabled() && ! m_mainloop->is_stop_active());
    gtk_action_set_sensitive(gtk_action_group_get_action (m_actions, "reload"),
        (m_mainloop != NULL));
}


#ifdef	WITH_NOKIA770
#include <libosso.h>

//KB XXXX FIXME #include "libAmbulantPlayer.h"

gint
dbus_callback (const gchar *interface, const gchar *method,
               GArray *arguments, gpointer data,
               osso_rpc_t *retval)
{
  printf ("AmbulantPlayer dbus: %s, %s\n", interface, method);

  if (!strcmp (method, "top_application"))
      gtk_window_present (GTK_WINDOW (data));

  retval->type = DBUS_TYPE_INVALID;
  return OSSO_OK;
}
#endif/*WITH_NOKIA770*/


int
main (int argc, char*argv[]) {
#ifdef	WITH_NOKIA770
	osso_context_t *ctxt;
	osso_return_t ret;
	GtkWindow *window;
	HildonProgram* hildon_program;
	HildonWindow* hildon_window;
#endif/*WITH_NOKIA770*/
	
	printf ("AmbulantPlayer: starting up\n");
	
#ifdef	WITH_NOKIA770
	ctxt = osso_initialize ("ambulantplayer_app", PACKAGE_VERSION, TRUE, NULL);
	if (ctxt == NULL){
		fprintf (stderr, "osso_initialize failed.\n");
		exit (1);
	}
	if (chdir(AMBULANT_DATADIR) < 0) {
		fprintf(stderr, "AmbulantPlayer: cannot chdir(%s) errno=%d\n", AMBULANT_DATADIR, errno);
		return -1;
	}
#endif/*WITH_NOKIA770*/

#ifdef	WITH_GSTREAMER
	/* initialize GStreamer */
	AM_DBG fprintf(stderr, "initialize GStreamer\n");
	gstreamer_player_initialize (&argc, &argv);
#endif/*WITH_GSTREAMER*/

//	g_thread_init(NULL);
//	gdk_threads_init ();
	
	gtk_init(&argc,&argv);

//#undef	ENABLE_NLS
#ifdef	ENABLE_NLS
	// Load localisation database
	bool private_locale = false;
	char *home = getenv("HOME");
	if (home) {
		std::string localedir = std::string(home) + "/.ambulant/locale";
		if (access(localedir.c_str(), 0) >= 0) {
			private_locale = true;
			bindtextdomain(PACKAGE, localedir.c_str());
		}
	}
	if (!private_locale)
		bindtextdomain (PACKAGE, LOCALEDIR);
	textdomain (PACKAGE);
#endif /*ENABLE_NLS*/

	// Load preferences, initialize app and logger
	unix_preferences unix_prefs;
	unix_prefs.load_preferences();
	FILE* DBG = stdout;
	
	/* Setup widget */
	gtk_gui *mywidget = new gtk_gui(argv[0], argc > 1 ? argv[1] : "AmbulantPlayer");

#ifdef	WITH_HILDON
	/* Hildonize AmbulantPlayer */
	hildon_program = HILDON_PROGRAM(hildon_program_get_instance());
	g_set_application_name("AmbulantPlayer");
	hildon_window = HILDON_WINDOW(hildon_window_new());
	hildon_program_add_window(hildon_program, hildon_window);
	/*XXX
	gtk_container_add (GTK_CONTAINER(hildon_window),
			   GTK_WIDGET(gtk_label_new("HildonAmbulantPlayer")));
	gtk_widget_show_all(GTK_WIDGET(hildon_window));
	g_signal_connect(G_OBJECT(hildon_window), "delete_event", 
			 G_CALLBACK(g_main_loop_quit), &mywidget->main_loop);
	*/
#endif/*WITH_HILDON*/
	
	// take log level from preferences	
	gtk_logger::set_gtk_logger_gui(mywidget);
	gtk_logger* gtk_logger = gtk_logger::get_gtk_logger();
	lib::logger::get_logger()->debug("Ambulant Player: now logging to a window");
	// Print welcome banner
	lib::logger::get_logger()->debug(gettext("Ambulant Player: compile time version %s, runtime version %s"), AMBULANT_VERSION, ambulant::get_version());
	lib::logger::get_logger()->debug(gettext("Ambulant Player: built on %s for Unix/GTK"), __DATE__);
#if ENABLE_NLS
	lib::logger::get_logger()->debug(gettext("Ambulant Player: localization enabled (english)"));
#endif
	AM_DBG fprintf(DBG, "argc=%d argv[0]=%s\n", argc, argv[0]);
	AM_DBG for (int i=1;i<argc;i++){fprintf(DBG,"%s\n", argv[i]);}
	
	bool exec_flag = false;

	if (argc > 1) {
		char last[6];
		char* str = argv[argc-1];
		int len = strlen(str);
		strcpy(last, &str[len-5]);
		AM_DBG fprintf(DBG, "%s %s %x\n", str, last);
		if (strcmp(last, ".smil") == 0
		|| strcmp(&last[1], ".smi") == 0
	  	|| strcmp(&last[1], ".sml") == 0) {
 			if (mywidget->openSMILfile(argv[argc-1],
						   0, true)
			    && (exec_flag = true)){
				mywidget->do_play();
			}
		}
	} else {
		preferences* prefs = preferences::get_preferences();
		if ( ! prefs->m_welcome_seen) {
			const char *welcome_doc = find_datafile(welcome_locations);
			if (welcome_doc
			&& mywidget->openSMILfile(welcome_doc,
						  0, true)) {
				mywidget->do_play();
				prefs->m_welcome_seen = true;
			}
		}
		exec_flag = true;
	}	
	g_timeout_add(100, (GSourceFunc) gtk_C_callback_timer, NULL);
	g_main_loop_run(mywidget->main_loop);

	unix_prefs.save_preferences();
	delete gtk_logger::get_gtk_logger();
	mywidget->do_quit();
	delete mywidget;
	gdk_threads_leave ();
#ifdef	WITH_GSTREAMER
	/* finalize GStreamer */
	AM_DBG fprintf(stderr, "finalize GStreamer\n");
	gstreamer_player_finalize();
#endif/*WITH_GSTREAMER*/
	
#ifdef	WITH_NOKIA770
	if (ctxt) osso_deinitialize (ctxt);
#endif/*WITH_NOKIA770*/
	std::cout << "Exiting program" << std::endl;
	return exec_flag ? 0 : -1;
}