Esempio n. 1
0
/* Map G_LOG_LEVEL_INFO logs to the window's status bar. */
static void
ui_log_level_info (const gchar * log_domain, GLogLevelFlags log_level,
                   const char * message, gpointer user_data)
{
  static GtkWidget * statusbar;
  static guint context;
  static guint initialized = 0;
  if (!initialized)
    {
      statusbar = GET_OBJECT ("statusbar");
      context = gtk_statusbar_get_context_id(GTK_STATUSBAR (statusbar), "Game messages");
      initialized = 1;
    }
  gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context);
  gtk_statusbar_push (GTK_STATUSBAR (statusbar), context, message);
  gtk_main_iteration();
}
Esempio n. 2
0
void
say (char *fmt, ...)
{
  va_list ap;
  char buf[200];
  guint context_id;

  if (test_computer_play > 0) return;
  va_start (ap, fmt);
  g_vsnprintf (buf, 200, fmt, ap);
  va_end (ap);

  context_id =
    gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar), "message");
  gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context_id);
  gtk_statusbar_push (GTK_STATUSBAR (statusbar), context_id, buf);
}
Esempio n. 3
0
static void
selection_changed (Diagram* dia, int n, DDisplay* ddisp)
{
  GtkStatusbar *statusbar;
  guint context_id;

  /* nothing to do if there is no display with the diagram anymore */
  if (g_slist_length(dia->displays) < 1)
    return;

  statusbar = GTK_STATUSBAR (ddisp->modified_status);
  context_id = gtk_statusbar_get_context_id (statusbar, "Selection");

  if (n > 1)
  {
    gchar *msg;

    /* http://www.gnu.org/software/gettext/manual/html_chapter/gettext_10.html#SEC150 
     * Althoug the single objects wont get triggered here some languages have variations on the other numbers 
     */
    msg = g_strdup_printf (ngettext ("Selection of %d object", "Selection of %d objects", n), n);
    gtk_statusbar_pop (statusbar, context_id);
    gtk_statusbar_push (statusbar, context_id, msg);
    g_free (msg);
  }
  else if (n == 1)
  {
    /* find the selected objects name - and display it */
    DiaObject *object = (DiaObject *)ddisp->diagram->data->selected->data;
    gchar *name = object_get_displayname (object);
    gchar *msg = g_strdup_printf (_("Selected '%s'"), name);

    gtk_statusbar_pop (statusbar, context_id);
    gtk_statusbar_push (statusbar, context_id, msg);

    g_free (name);
    g_free (msg);
  }
  else
  {
    gtk_statusbar_pop (statusbar, context_id); 
  }
  /* selection-changed signal can also be emitted from outside of the dia core */
  ddisplay_do_update_menu_sensitivity (ddisp);
}
Esempio n. 4
0
void statusbar_puts(GtkStatusbar *statusbar, const gchar *str)
{
	gint cid;
	gchar *buf;
	gchar *tmp;

	tmp = g_strdup(str);
	strretchomp(tmp);
	buf = trim_string(tmp, 76);
	g_free(tmp);

	cid = gtk_statusbar_get_context_id(statusbar, "Standard Output");
	gtk_statusbar_pop(statusbar, cid);
	gtk_statusbar_push(statusbar, cid, buf);
	gtkut_widget_draw_now(GTK_WIDGET(statusbar));

	g_free(buf);
}
Esempio n. 5
0
static GtkWidget * dcc_gnome_make_load_bar (void)
{
  GtkWidget *bar;
  gint context_id;

  bar = gtk_statusbar_new ();
  context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR (bar), "load");

  gtk_statusbar_push(GTK_STATUSBAR (bar), context_id, "Load: ");

  g_timeout_add (2000,          /* ms */
                 dcc_gnome_load_update_cb,
                 bar);

  dcc_gnome_load_update_cb (bar);

  return bar;
}
Esempio n. 6
0
File: game.c Progetto: ralight/ggz
void game_message(const char *format, ...)
{
	int id;
	va_list ap;
	char *message;
	GtkWidget *status;

	va_start(ap, format);
	message = g_strdup_vprintf(format, ap);
	va_end(ap);

	status = lookup_widget(main_win, "statusbar");
	id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status), "Main");
	gtk_statusbar_pop(GTK_STATUSBAR(status), id);
	gtk_statusbar_push(GTK_STATUSBAR(status), id, message);

	g_free(message);
}
Esempio n. 7
0
orcaData orcaGtk::ex_set_text(orcaVM* vm, int n)/*{{{*/
{
	if (n < 1) vm->need_param();

	string str = vm->get_param(0).string_(vm);

	switch(type)
	{
	case GUI_WINDOW:
		gtk_window_set_title(GTK_WINDOW(handle), str.c_str());
		break;

	case GUI_BUTTON:
	case GUI_CHECK:
	case GUI_RADIO:
		gtk_button_set_label(GTK_BUTTON(handle), str.c_str());
		break;

	case GUI_LABEL:
		gtk_label_set_text(GTK_LABEL(handle), str.c_str());
		break;

	case GUI_TEXT:
	  {
		GtkTextBuffer *buffer;
		buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle));
		gtk_text_buffer_set_text(buffer, str.c_str(), -1);
		break;
	  }

	case GUI_STATUSBAR:
		gtk_statusbar_push(GTK_STATUSBAR(handle),
						   gtk_statusbar_get_context_id(GTK_STATUSBAR(handle), str.c_str()), 
						   str.c_str());
		break;

	case GUI_ENTRY:
		gtk_entry_set_text(GTK_ENTRY(handle), str.c_str());
		break;
	}

	text = str;
	return NIL;
}
Esempio n. 8
0
static void
profile_bar_new(void)
{
    GtkTooltips   *tooltips;

    tooltips = gtk_tooltips_new();

    profile_bar_event = gtk_event_box_new();
    profile_bar = gtk_statusbar_new();
    gtk_container_add(GTK_CONTAINER(profile_bar_event), profile_bar);
    g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(profile_show_popup_cb), NULL);
    profile_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(profile_bar), "profile");
    gtk_tooltips_set_tip (tooltips, profile_bar_event,
			  "Click to change configuration profile", NULL);
    profile_bar_update();

    gtk_widget_show(profile_bar);
    gtk_widget_show(profile_bar_event);
}
Esempio n. 9
0
static void
profile_bar_new(void)
{
    profile_bar_event = gtk_event_box_new();
    profile_bar = gtk_statusbar_new();
    gtk_container_add(GTK_CONTAINER(profile_bar_event), profile_bar);
    g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(profile_show_popup_cb), NULL);
    g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(popup_menu_handler),
                     g_object_get_data(G_OBJECT(popup_menu_object), PM_STATUSBAR_PROFILES_KEY));
    profile_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(profile_bar), "profile");
    gtk_widget_set_tooltip_text(profile_bar_event, "Click to change configuration profile");
    profile_bar_update();
#if !GTK_CHECK_VERSION(3,0,0)
    gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(profile_bar), FALSE);
#endif

    gtk_widget_show(profile_bar);
    gtk_widget_show(profile_bar_event);
}
Esempio n. 10
0
/* Helper function for uistatus() */
static gboolean realstatus(gpointer data) {
	GtkStatusbar* sb = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar"));
	GtkSpinner* spinner = GTK_SPINNER(gtk_builder_get_object(builder, "busy_spinner"));
	struct statusupdate *update = (struct statusupdate*)data;

	if(G_UNLIKELY(!statusbar_context)) {
		statusbar_context = gtk_statusbar_get_context_id(sb, "useless");
	}
	gtk_statusbar_remove_all(sb, statusbar_context);
	gtk_widget_set_visible(GTK_WIDGET(spinner), update->spin);
	g_object_set(G_OBJECT(spinner), "active", update->spin, NULL);
	if(update->text) {
		gtk_statusbar_push(sb, statusbar_context, update->text);
		g_free(update->text);
	}
	g_free(update);

	return FALSE;
}
Esempio n. 11
0
static void
menu_item_select_cb (GtkWidget * widget, GtkStatusbar * statusbar)
{
  GtkAction *action;
  gchar *tooltip;
  guint context_id;

  context_id = gtk_statusbar_get_context_id (statusbar, "games-tooltip");

  action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget));
  g_return_if_fail (action != NULL);

  g_object_get (action, "tooltip", &tooltip, NULL);

  if (tooltip) {
    gtk_statusbar_push (statusbar, context_id, tooltip);
    g_free (tooltip);
  }
}
Esempio n. 12
0
static GGZHookReturn ggz_num_players_changed(GGZServerEvent id,
					     const void *event_data,
					     const void *user_data)
{
	GtkWidget *serverbar = ggz_lookup_widget(ggz_gtk.win_main, "serverbar");
	guint context;
	int players = ggzcore_server_get_num_players(ggz_gtk.server);
	char *buf;

	buf = g_strdup_printf(_("Players on server: %d"), players);
	context = gtk_statusbar_get_context_id(GTK_STATUSBAR(serverbar),
					       "players");
	gtk_statusbar_pop(GTK_STATUSBAR(serverbar), context);
	gtk_statusbar_push(GTK_STATUSBAR(serverbar), context, buf);

	g_free(buf);

	return GGZ_HOOK_OK;
}
Esempio n. 13
0
create_statusbar ()void *GtkMain(void * argument)
{
    printf("%s:%d\n", __func__, __LINE__);

    int argc = 0;
    char**argv = NULL;

    unsigned char haveUrl = 0;
    int argCount = 0;
{
    g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ());
    gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false);
    status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover");
    
    return (GtkWidget*)g_main_statusbar;
}

static GtkWidget*
create_toolbar ()
{
    g_toolbar = gtk_toolbar_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false);

#if GTK_CHECK_VERSION(2,15,0)
    gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ);


    /* The URL entry */
    itemUrl = gtk_tool_item_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false);
    gtk_tool_item_set_expand (itemUrl, TRUE);
    uri_entry = gtk_entry_new ();
    gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry);
    g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1);

    return g_toolbar;
}
Esempio n. 14
0
static gboolean
status_bar_refresh(gpointer data)
{
    gdk_threads_enter();

    if (balsa_app.main_window) {
        GtkStatusbar *statusbar;
        guint context_id;

        statusbar = GTK_STATUSBAR(balsa_app.main_window->statusbar);
        context_id = gtk_statusbar_get_context_id(statusbar, "Information bar");
        gtk_statusbar_pop(statusbar, context_id);
    }

    bar_timeout_id = 0;

    gdk_threads_leave();

    return FALSE;
}
Esempio n. 15
0
static void widget_statusbar_update(variable *var, gchar *text)
{
	guint             context_id;

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Entering.\n", __func__);
#endif

	/* A context ID is required to push and pop the messages */
	context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(var->Widget),
		"General");

	gtk_statusbar_pop(GTK_STATUSBAR(var->Widget), context_id);
	gtk_statusbar_push(GTK_STATUSBAR(var->Widget), context_id, text);
	g_object_set_data(G_OBJECT(var->Widget), "_last_push", g_strdup(text));

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
Esempio n. 16
0
GtkWidget *
gu_statusbar_add(gu_window_t *gw, GtkWidget *parent)
{

  statusbar_t *sb = calloc(1, sizeof(statusbar_t));
  
  sb->bar = gtk_statusbar_new();
  gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(sb->bar), TRUE);
  gtk_box_pack_start(GTK_BOX(parent), sb->bar, FALSE, TRUE, 0);

  sb->ctxid =  gtk_statusbar_get_context_id(GTK_STATUSBAR(sb->bar),
					    "notifications");

  prop_subscribe(0,
		 PROP_TAG_NAME("global", "notifications", "nodes"),
		 PROP_TAG_CALLBACK, notifications_update, sb,
		 PROP_TAG_COURIER, gw->gw_gu->gu_pc, 
		 NULL);
  return sb->bar;
}
Esempio n. 17
0
static void set_status(char const * format, ...)
{
	va_list ap;
	guint id;
	gchar *status;

	va_start(ap, format);
	if (vnc != NULL) {
		id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "");
		status = g_strdup_vprintf(format, ap);
		gtk_statusbar_pop(GTK_STATUSBAR(statusbar), id);
		gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, status);
		g_free(status);
	} else {
	    fputs(PROGNAME ": ", stderr);
		vfprintf(stderr, format, ap);
	    fputc('\n', stderr);
	}
	va_end(ap);
}
Esempio n. 18
0
static void
hovering_over_link (WebKitWebView *web_view,
                    const gchar   *title,
                    const gchar   *uri,
                    gpointer       user_data)
{
  MarinaWindow *window;
  static guint cid = 0;
  
  g_return_if_fail (WEBKIT_IS_WEB_VIEW (web_view));
  
  window = MARINA_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (web_view)));

  if (!cid)
    cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (window->priv->statusbar), "html-link");
  
  gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar), cid);
  
  if (uri)
    gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar), cid, uri);
}
Esempio n. 19
0
static void test_grf_imagewidget_show(void**state){
  (void) state;
  gtk_init(NULL, NULL);
  pressed            = 0;
  char* filenames[3]     = {"../data/trekkie-nerdbw.png",           // Gray
                            "../data/distance_transform_input.pgm", // Gray
                            "../data/trekkie-nerd.jpg"};            // Color
  GrfArray*  array_gray  = grf_image_read(filenames[0]);
  GtkWidget* imagewidget = grf_imagewidget_new();
  GtkWidget* window      = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  GtkWidget* box         = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
  lbl_color              = gtk_label_new("");
  statusbar              = gtk_statusbar_new();
  context = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar),"example");

  gtk_widget_set_size_request(statusbar,-1,30);
  gtk_widget_add_events(imagewidget, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
  gtk_widget_add_events(imagewidget,GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);

  grf_imagewidget_set_image(GRF_IMAGEWIDGET(imagewidget),array_gray, TRUE);

  gtk_box_pack_start (GTK_BOX(box),imagewidget,TRUE,TRUE,0);
  gtk_box_pack_start (GTK_BOX(box),statusbar,FALSE,TRUE,0);
  gtk_box_pack_end(GTK_BOX(statusbar),lbl_color,FALSE,FALSE,0);
  gtk_container_add  (GTK_CONTAINER(window), box);
  // Mouse events
  g_signal_connect   (imagewidget, "button-press-event"  , G_CALLBACK(helper_test_imagewidget_press_event), NULL);
  g_signal_connect   (imagewidget, "button-release-event", G_CALLBACK(helper_test_imagewidget_release_event)    , NULL);
  g_signal_connect   (imagewidget, "motion-notify-event" , G_CALLBACK(helper_test_imagewidget_move_event)    , array_gray);
  g_signal_connect   (imagewidget, "scroll-event"        , G_CALLBACK(helper_test_imagewidget_scroll_event)    , NULL);
  // Keyboard events
  g_signal_connect   (imagewidget, "key-press-event"     , G_CALLBACK(window_key_press_event), NULL);
  g_signal_connect   (imagewidget, "key-release-event"   , G_CALLBACK(window_key_release_event), NULL);
  // Other events
  g_signal_connect   (window     , "destroy"             , G_CALLBACK(gtk_main_quit),NULL);

  // Show window
  gtk_widget_show_all(window);
  gtk_main();
}
Esempio n. 20
0
void ui_init()
{
  GtkWidget *window = NULL;
  GtkBuilder *builder;
  GError *err = NULL;
  gchar *exec_name = NULL;
  gchar *tmp = NULL;
  gchar exe_path[MAX_PATH];
  GtkEntry *entry;

  gtk_init(NULL, NULL);

  builder = gtk_builder_new();
  exec_name = g_file_read_link("/proc/self/exe", NULL);
  tmp = g_strrstr(exec_name, "/");
  *tmp = 0;
  g_strlcpy(exe_path, exec_name, MAX_PATH);
  g_strlcat(exe_path, "/audio_player.glade", MAX_PATH);
  g_free(exec_name);

  gtk_builder_add_from_file(builder, exe_path, &err);

  gtk_builder_connect_signals(builder, NULL);
  window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));

  main_window_sub_widget.statusbar = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar1"));

  main_window_sub_widget.contextId = gtk_statusbar_get_context_id(
                   GTK_STATUSBAR(main_window_sub_widget.statusbar), "Editor Messages");

  entry = GTK_ENTRY(gtk_builder_get_object(builder, "entry1"));
  main_window_sub_widget.entry1 = entry;

  g_signal_connect(window, "destroy",
		   G_CALLBACK (gtk_main_quit), &window);

  g_object_unref(G_OBJECT(builder));

  gtk_widget_show_all(window);
}
Esempio n. 21
0
/**
 * gwy_statusbar_set_markup:
 * @statusbar: A statusbar.
 * @markup: Text message to display in the statusbar.  It can contain Pango
 *          markup.
 *
 * Sets the text to display in a status bar.
 *
 * This method is intended for simple status bars that do not have stacks and
 * do not need contexts.  It does not mix with gtk_status_bar_push().  You can
 * use either this simple interface or the full stacks-and-contexts API with
 * #GwyStatusbar, but not both in the same status bar.
 **/
void
gwy_statusbar_set_markup(GwyStatusbar *statusbar,
                         const gchar *markup)
{
    GtkStatusbar *sbar;
    guint id;

    sbar = GTK_STATUSBAR(statusbar);
    if (!statusbar->context_id) {
        if (sbar->keys)
            g_warning("gwy_statusbar_set_markup() does not mix with "
                      "full stacks-and-context GwyStatusbar API");
        statusbar->context_id
            = gtk_statusbar_get_context_id(sbar, "GwyStatusbar-global-context");
    }

    id = gtk_statusbar_push(sbar, statusbar->context_id, markup);
    if (statusbar->message_id)
        gtk_statusbar_remove(sbar, statusbar->context_id,
                             statusbar->message_id);
    statusbar->message_id = id;
}
Esempio n. 22
0
void
parts_enter_button_clicked(GtkWidget *widget, GrmGui *gui)
{
  /* face node data push to stack flow *
   * 
   1 drawingarea1 clicked by leftbutton
   *
   2 get coordinate and set to gui (drawingarea1_clicked())
   *
   3 if gui->tmp_node_data and gui->face_node_data is NULL
   * get memory and initialize them (set_clicked_point_data_drawarea_clicked())
   *
   4 when parts_button clicked, gui->tmp_node_data memcpy to
   * same button's parts_name gui->face_node_data[n] (parts_button_clicked())
   *
   5 when enter button clicked, gui->face_node_data addressing data move to stack
   * and new memory give for gui->face_node_data; (parts_enter_button_clicked(), here!)
   *
   6 goto 1 or 4(sometime)
  */

  gaborrg_maker_face_node_data_stack_push(&gui->face_node_data_stack,
					  gui->face_node_data);
  gui->face_node_data= gaborrg_maker_face_node_data_new_from_gui(gui);
 
  /* indicator and messages */
  {
    gaborrg_maker_all_parts_buttons_indicator_appear_or_not(gui,0);
  
    gchar* message= "all parts data save to buffer. restart click on drawarea by right button";
    guint context_id= gtk_statusbar_get_context_id( GTK_STATUSBAR(gui->statusbar1),
						   "parts_enter_button message");
    gtk_statusbar_push( GTK_STATUSBAR(gui->statusbar1),context_id,message);

    g_print("parts_enter_button_clicked!\n");
  }
  return;
}
Esempio n. 23
0
static gint dcc_gnome_load_update_cb (gpointer data)
{
  gchar message[200];
  double loadavg[3];
  guint context_id;

  if (getloadavg (loadavg, 3) == -1)
    {
      rs_log_error ("getloadavg failed: %s", strerror (errno));
      return FALSE;             /* give up */
    }

  snprintf (message, sizeof message,
            "Load average: %.2f, %.2f, %.2f",
            loadavg[0], loadavg[1], loadavg[2]);

  context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR (data), "load");

  gtk_statusbar_pop(GTK_STATUSBAR (data), context_id);
  gtk_statusbar_push(GTK_STATUSBAR (data), context_id, message);

  return TRUE;                  /* please call again */
}
Esempio n. 24
0
void statusbar_init(GUIData *ltrgui)
{
  GtkWidget *hbox;
  gchar msg[BUFSIZ];
  gint id;

  ltrgui->statusbar = gtk_statusbar_new();
  ltrgui->progressbar = gtk_progress_bar_new();

  hbox = gtk_hbox_new(TRUE, 1);
  gtk_box_pack_start(GTK_BOX(hbox), ltrgui->statusbar, FALSE, TRUE, 1);
  gtk_box_pack_start(GTK_BOX(hbox), ltrgui->progressbar, TRUE, TRUE, 1);
  gtk_widget_show_all(hbox);

  id = gtk_statusbar_get_context_id(GTK_STATUSBAR(ltrgui->statusbar),
                                    STATUSBAR_CONTEXT);

  ltrgui->statusbar_context_id = id;
  g_snprintf(msg, BUFSIZ, STATUSBAR_MSG_WELCOME, GUI_NAME);
  gtk_statusbar_push(GTK_STATUSBAR(ltrgui->statusbar),
                     ltrgui->statusbar_context_id, msg);
  gtk_box_pack_end(GTK_BOX(ltrgui->vbox), hbox, FALSE, FALSE, 0);
}
Esempio n. 25
0
static void
gedit_spell_plugin_activate (GeditWindowActivatable *activatable)
{
	GeditSpellPlugin *plugin;
	GeditSpellPluginPrivate *priv;
	GList *views, *l;

	gedit_debug (DEBUG_PLUGINS);

	plugin = GEDIT_SPELL_PLUGIN (activatable);
	priv = plugin->priv;

	g_action_map_add_action_entries (G_ACTION_MAP (priv->window),
	                                 action_entries,
	                                 G_N_ELEMENTS (action_entries),
	                                 activatable);

	priv->message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (gedit_window_get_statusbar (priv->window)),
	                                                  "spell_plugin_message");

	update_ui (plugin);

	views = gedit_window_get_views (priv->window);
	for (l = views; l != NULL; l = g_list_next (l))
	{
		GeditView *view = GEDIT_VIEW (l->data);

		set_auto_spell_from_metadata (plugin, view);
	}

	priv->tab_added_id =
		g_signal_connect (priv->window, "tab-added",
				  G_CALLBACK (tab_added_cb), activatable);
	priv->tab_removed_id =
		g_signal_connect (priv->window, "tab-removed",
				  G_CALLBACK (tab_removed_cb), activatable);
}
Esempio n. 26
0
GtkWidget *widget_statusbar_create(
	AttributeSet *Attr, tag_attr *attr, gint Type)
{
	GtkWidget        *widget;
	guint             context_id;

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Entering.\n", __func__);
#endif

	widget = gtk_statusbar_new();

	/* A context ID is required to push and pop the messages */
	context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(widget),
		"General");

#ifdef DEBUG_CONTENT
	fprintf(stderr, "%s(): context_id=%i\n", __func__, context_id);
#endif

	/* Push an initial empty message and from hereon in, everytime a
	 * new message is set we will first pop the existing message and
	 * then push the new one */
	gtk_statusbar_push(GTK_STATUSBAR(widget), context_id, "");

	/* Record the current message because otherwise it'll have to be
	 * dug out from the label inside the box that is the statusbar */
	g_object_set_data(G_OBJECT(widget), "_last_push", g_strdup(""));
	

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif

	return widget;
}
Esempio n. 27
0
void game_status(const char *format, ...)
{
	int id;
	va_list ap;
	char *message;
	gpointer tmp;

	va_start(ap, format);
	message = g_strdup_vprintf(format, ap);
	va_end(ap);

	/* ggz_debug("main", "Game status message: %s", message); */

	tmp = g_object_get_data(G_OBJECT(main_win), "statusbar");

	id = gtk_statusbar_get_context_id(GTK_STATUSBAR(tmp), "Main");

	gtk_statusbar_pop(GTK_STATUSBAR(tmp), id);
	gtk_statusbar_push(GTK_STATUSBAR(tmp), id, message);


	g_free(message);

}
Esempio n. 28
0
/**
 * Create main dialog decorations (excluding notebook pages).
 */
static void export_ldif_dialog_create( void ) {
	GtkWidget *window;
	GtkWidget *vbox;
	GtkWidget *vnbox;
	GtkWidget *notebook;
	GtkWidget *hbbox;
	GtkWidget *btnPrev;
	GtkWidget *btnNext;
	GtkWidget *btnCancel;
	GtkWidget *hsbox;
	GtkWidget *statusbar;

	window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "expldifdlg");
	gtk_widget_set_size_request(window, EXPORTLDIF_WIDTH, EXPORTLDIF_HEIGHT );
	gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
	gtk_window_set_title( GTK_WINDOW(window),
		_("Export Address Book to LDIF File") );
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(export_ldif_delete_event),
			 NULL );
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(export_ldif_key_pressed),
			 NULL );

	vbox = gtk_vbox_new(FALSE, 4);
	gtk_widget_show(vbox);
	gtk_container_add(GTK_CONTAINER(window), vbox);

	vnbox = gtk_vbox_new(FALSE, 4);
	gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
	gtk_widget_show(vnbox);
	gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);

	/* Notebook */
	notebook = gtk_notebook_new();
	gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE ); /* Hide */
	/* gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), TRUE ); */
	gtk_widget_show(notebook);
	gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);

	/* Status line */
	hsbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
	statusbar = gtk_statusbar_new();
	gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);

	/* Button panel */
	gtkut_stock_button_set_create(&hbbox, &btnPrev, GTK_STOCK_GO_BACK,
				      &btnNext, GTK_STOCK_GO_FORWARD,
				      &btnCancel, GTK_STOCK_CANCEL);
	gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2);
	gtk_widget_grab_default(btnNext);

	/* Button handlers */
	g_signal_connect(G_OBJECT(btnPrev), "clicked",
			 G_CALLBACK(export_ldif_prev), NULL);
	g_signal_connect(G_OBJECT(btnNext), "clicked",
			 G_CALLBACK(export_ldif_next), NULL);
	g_signal_connect(G_OBJECT(btnCancel), "clicked",
			 G_CALLBACK(export_ldif_cancel), NULL);

	gtk_widget_show_all(vbox);

	expldif_dlg.window     = window;
	expldif_dlg.notebook   = notebook;
	expldif_dlg.btnPrev    = btnPrev;
	expldif_dlg.btnNext    = btnNext;
	expldif_dlg.btnCancel  = btnCancel;
	expldif_dlg.statusbar  = statusbar;
	expldif_dlg.status_cid = gtk_statusbar_get_context_id(
			GTK_STATUSBAR(statusbar), "Export LDIF Dialog" );
}
Esempio n. 29
0
MessageView *messageview_create_with_new_window(void)
{
	MessageView *msgview;
	GtkWidget *window;
	GtkWidget *window_vbox;
	GtkWidget *body_vbox;
	GtkWidget *vspacer;
	GtkWidget *menubar;
	GtkItemFactory *ifactory;
	GtkWidget *statusbar;
	guint n_menu_entries;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), _("Message View - Sylpheed"));
	gtk_window_set_wmclass(GTK_WINDOW(window), "message_view", "Sylpheed");
	gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
	gtk_widget_set_size_request(window, prefs_common.msgwin_width,
				    prefs_common.msgwin_height);

	msgview = messageview_create();

	window_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window), window_vbox);

	g_signal_connect(G_OBJECT(window), "size_allocate",
			 G_CALLBACK(messageview_size_allocate_cb),
			 msgview);
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(messageview_delete_cb), msgview);
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(key_pressed), msgview);
	MANAGE_WINDOW_SIGNALS_CONNECT(window);

	n_menu_entries = sizeof(msgview_entries) / sizeof (msgview_entries[0]);
	menubar = menubar_create(window, msgview_entries, n_menu_entries,
				 "<MessageView>", msgview);
#if 0
	menu_factory_copy_rc("<Main>", "<MessageView>");
#endif
	gtk_box_pack_start(GTK_BOX(window_vbox), menubar, FALSE, TRUE, 0);

	vspacer = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(window_vbox), vspacer, FALSE, TRUE,
			   BORDER_WIDTH);

	body_vbox = gtk_vbox_new(FALSE, BORDER_WIDTH);
	gtk_box_pack_start(GTK_BOX(window_vbox), body_vbox, TRUE, TRUE, 0);

	gtk_box_pack_start(GTK_BOX(body_vbox), GTK_WIDGET_PTR(msgview),
			   TRUE, TRUE, 0);
	gtk_widget_grab_focus(msgview->textview->text);

	statusbar = gtk_statusbar_new();
	gtk_box_pack_end(GTK_BOX(body_vbox), statusbar, FALSE, FALSE, 0);
	msgview->statusbar = statusbar;
	msgview->statusbar_cid = gtk_statusbar_get_context_id
		(GTK_STATUSBAR(statusbar), "Message View");

	msgview->new_window = TRUE;
	msgview->window = window;
	msgview->window_vbox = window_vbox;
	msgview->body_vbox = body_vbox;
	msgview->menubar = menubar;
	msgview->menu_locked = FALSE;
	msgview->visible = TRUE;

	gtk_widget_show_all(window);

	messageview_init(msgview);

	messageview_set_encoding_menu(msgview);

	ifactory = gtk_item_factory_from_widget(menubar);
#ifndef G_OS_WIN32
	action_update_msgview_menu(ifactory, msgview);
#endif

	messageview_list = g_list_append(messageview_list, msgview);

	return msgview;
}
Esempio n. 30
0
int main (int argc, char *argv[])
{
	int i;
	
	const char *commandLine_File = NULL;
	GtkWidget *pVBox;
	GtkWidget *pMenuBar;
	GtkWidget *pMenu, *pSubMenu;
	GtkWidget *pMenuItem, *pSubMenuItem;
	GtkAccelGroup * accel_group;
       
	if(argc == 2) commandLine_File = argv[1];
	
#ifdef DEBUG
        LogStart();
#endif
	
	gtk_init(&argc, &argv);
	SDL_Init(SDL_INIT_VIDEO);
	desmume_init();
	
 	dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size);
	for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE;
	
	CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL);
	Read_ConfigFile();
	
	/* Creation de la fenetre */
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume");
	gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE);
	gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm));
	
	g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL);
	g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL);

	/* Creation de la GtkVBox */
	pVBox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

	accel_group = gtk_accel_group_new();
	action_group = gtk_action_group_new("dui");
	gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow);
        {
                GList * list = gtk_action_group_list_actions(action_group);
                g_list_foreach(list, dui_set_accel_group, accel_group);
        }
	gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE);

	/**** Creation du menu ****/

	pMenuBar = gtk_menu_bar_new();
	
	/** Menu "Fichier" **/

	pMenu = gtk_menu_new();

	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open")));
	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen")));
	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit")));
	
	pMenuItem = gtk_menu_item_new_with_label("File");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

	/** Menu "Emulation" **/
	GtkWidget *mEmulation;
		GtkWidget *mFrameskip;
			GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP];
		GtkWidget *mGraphics;
			GtkWidget *mSize;
				GtkWidget *mSize_Radio[MAX_SCREENCOEFF];
			GtkWidget *mLayers;
				GtkWidget *mLayers_Radio[10];
	
	
	mEmulation = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Emulation");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run")));
	
	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause")));

	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset")));
	
		mFrameskip = gtk_menu_new();
		pMenuItem = gtk_menu_item_new_with_label("Frameskip");
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip);
		gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
		
		for(i = 0; i < MAX_FRAMESKIP; i++) {
			char frameskipRadio_buf[16];
			sprintf(frameskipRadio_buf, "%d", i);
			if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf);
			else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf);
			g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i));
			gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]);
		}
		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
		
		mGraphics = gtk_menu_new();
		pMenuItem = gtk_menu_item_new_with_label("Graphics");
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics);
		gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
			
// TODO: Un jour, peut être... ><
			mSize = gtk_menu_new();
			pMenuItem = gtk_menu_item_new_with_label("Size");
			gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize);
			gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
			
			for(i = 1; i < MAX_SCREENCOEFF; i++) {
				char sizeRadio_buf[16];
				sprintf(sizeRadio_buf, "x%d", i);
				if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf);
				else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf);
				g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i));
				gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]);
			}
			gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
		
			mLayers = gtk_menu_new();
			pMenuItem = gtk_menu_item_new_with_label("Layers");
			gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers);
			gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
		
			for(i = 0; i < 10; i++) {
				mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]);
				g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]);
				gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]);
				gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE);
			}
			
	
	/** Menu "Options" **/
	GtkWidget *mConfig = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Config");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	pMenuItem = gtk_menu_item_new_with_label("Edit controls");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
	
#if 0
	
	GtkWidget *mFirmware;
	
	mFirmware = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Firmware");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware);
	gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
	
	pMenuItem = gtk_menu_item_new_with_label("Select...");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0);
	gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem);
		
	pMenuItem = gtk_menu_item_new_with_label("Config");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
#endif
	
	/** Menu "Outils" **/
	
	pMenu = gtk_menu_new();
	
	for(i = 0; i < dTools_list_size; i++)
	{
		pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name);
		g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i));
		gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
	}
		
	pMenuItem = gtk_menu_item_new_with_label("Tools");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	/** Menu "?" **/

	pMenu = gtk_menu_new();

#if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6))
	pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
#else
	pMenuItem = gtk_menu_item_new_with_label("About");
#endif
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

	pMenuItem = gtk_menu_item_new_with_label("?");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

	/* Ajout du menu a la fenetre */
	gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);

	/* Création de la Toolbar */
	
	pToolbar = gtk_toolbar_new();
	gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);

	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1);

	/* Création de l'endroit pour l'affichage des écrans */
	
	pDrawingArea= gtk_drawing_area_new();
	
	gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384);
	gtk_widget_set_usize (pDrawingArea, 256, 384);
			
	gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK );
	
	g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL);
	g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL);
	g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL);
	
	
	g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ;
	g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ;
	
	gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0);
	
	/* Création de la barre d'état */
	
	pStatusBar = gtk_statusbar_new();
	
	pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global");
	
	pStatusBar_Change("Desmume");

	gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0);
	
	gtk_widget_show_all(pWindow);
	
	//LoadFirmware("fw.bin");
	
	/* Vérifie la ligne de commandes */
	if(commandLine_File)
	{
		if(Open(commandLine_File) >= 0)
		{
			Launch();
		}
		else
		{
			GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow),
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_INFO,
					GTK_BUTTONS_OK,
					"Unable to load :\n%s", commandLine_File);
			gtk_dialog_run(GTK_DIALOG(pDialog));
			gtk_widget_destroy(pDialog);
		}
	}
	
	/* Boucle principale */
	
//	gtk_idle_add(&EmuLoop, pWindow);
//	g_idle_add(&EmuLoop, pWindow);
	
	gtk_main();
	
	desmume_free();

#ifdef DEBUG
        LogStop();
#endif

	SDL_Quit();
	
	Write_ConfigFile();
	
	return EXIT_SUCCESS;
}