Beispiel #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();
}
void
statusbar_clear_status(StatusBar_t *statusbar)
{
   if (statusbar->message_id)
      gtk_statusbar_remove(GTK_STATUSBAR(statusbar->status),
                           statusbar->status_id,
                           statusbar->message_id);
}
static void
mark_set_callback (GtkTextBuffer     *buffer,
                   const GtkTextIter *new_location,
                   GtkTextMark       *mark,
                   gpointer           data)
{
  update_statusbar (buffer, GTK_STATUSBAR (data));
}
Beispiel #4
0
/*
 * Pop a message referring to the current filter off the statusbar.
 */
void
statusbar_pop_filter_msg(void)
{
    if (status_levels[STATUS_LEVEL_FILTER] > 0) {
        status_levels[STATUS_LEVEL_FILTER]--;
    }
    gtk_statusbar_pop(GTK_STATUSBAR(info_bar), filter_ctx);
}
Beispiel #5
0
/*
 * Pop a message referring to the currently-selected field off the statusbar.
 */
void
statusbar_pop_field_msg(void)
{
    if (status_levels[STATUS_LEVEL_HELP] > 0) {
        status_levels[STATUS_LEVEL_HELP]--;
    }
    gtk_statusbar_pop(GTK_STATUSBAR(info_bar), help_ctx);
}
Beispiel #6
0
void clear_widgets()
{
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(chkLED1), FALSE);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(chkLED2), FALSE);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(chkLED3), FALSE);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(chkLED4), FALSE);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(chkRumble), FALSE);

	gtk_statusbar_push(GTK_STATUSBAR(statBattery), 0, "");
	gtk_statusbar_push(GTK_STATUSBAR(statExtension), 0, "");

	clear_acc_widgets();
	clear_ir_data();
	clear_nunchuk_widgets();
	clear_classic_widgets();
	clear_motionplus_widgets();
}
Beispiel #7
0
static void explorer_init(Explorer *self) {

    if (g_file_test (FYRE_DATADIR "/explorer.glade", G_FILE_TEST_EXISTS))
        self->xml = glade_xml_new (FYRE_DATADIR "/explorer.glade", NULL, NULL);
    if (!self->xml)
	self->xml = glade_xml_new(BR_DATADIR("/fyre/explorer.glade"), NULL, NULL);
    if (!self->xml) {
	GtkWidget *dialog;
	dialog = gtk_message_dialog_new_with_markup(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
						    "<b>Fyre can't find its data files.</b>\n\n"
						    "The main glade file could not be located.\n"
						    "We tried looking for it in the following places:\n"
						    "\n"
						    "    %s\n"
						    "    %s",
						    FYRE_DATADIR "/explorer.glade",
						    BR_DATADIR("/fyre/explorer.glade"));
	gtk_dialog_run(GTK_DIALOG(dialog));
	exit(0);
    }

    self->window = glade_xml_get_widget(self->xml, "explorer_window");
    fyre_set_icon_later(self->window);
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "animation_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "interactive_prefs"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "cluster_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "about_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "error dialog"));

    /* Connect signal handlers */
    glade_xml_signal_connect_data(self->xml, "on_randomize",                    G_CALLBACK(on_randomize),                    self);
    glade_xml_signal_connect_data(self->xml, "on_load_defaults",                G_CALLBACK(on_load_defaults),                self);
    glade_xml_signal_connect_data(self->xml, "on_save",                         G_CALLBACK(on_save),                         self);
    glade_xml_signal_connect_data(self->xml, "on_save_exr",                     G_CALLBACK(on_save_exr),                     self);
    glade_xml_signal_connect_data(self->xml, "on_quit",                         G_CALLBACK(on_quit),                         self);
    glade_xml_signal_connect_data(self->xml, "on_pause_rendering_toggle",       G_CALLBACK(on_pause_rendering_toggle),       self);
    glade_xml_signal_connect_data(self->xml, "on_load_from_image",              G_CALLBACK(on_load_from_image),              self);
    glade_xml_signal_connect_data(self->xml, "on_widget_toggle",                G_CALLBACK(on_widget_toggle),                self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_reset",                   G_CALLBACK(on_zoom_reset),                   self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_in",                      G_CALLBACK(on_zoom_in),                      self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_out",                     G_CALLBACK(on_zoom_out),                     self);
    glade_xml_signal_connect_data(self->xml, "on_render_time_changed",          G_CALLBACK(on_render_time_changed),          self);
    glade_xml_signal_connect_data(self->xml, "on_interactive_prefs_delete",     G_CALLBACK(on_interactive_prefs_delete),     self);

#ifndef HAVE_EXR
    /* If we don't have OpenEXR support, gray out the menu item
     * so it sits there taunting the user and not breaking HIG
     */
    gtk_widget_set_sensitive(glade_xml_get_widget(self->xml, "save_image_as_exr"), FALSE);
#endif

    /* Set up the statusbar */
    self->statusbar = GTK_STATUSBAR(glade_xml_get_widget(self->xml, "statusbar"));
    self->render_status_context = gtk_statusbar_get_context_id(self->statusbar, "Rendering status");
    self->speed_timer = g_timer_new();
    self->auto_update_rate_timer = g_timer_new();
    self->status_update_rate_timer = g_timer_new();
}
static void
eom_statusbar_init (EomStatusbar *statusbar)
{
	EomStatusbarPrivate *priv;
	GtkWidget *vbox;

	statusbar->priv = EOM_STATUSBAR_GET_PRIVATE (statusbar);
	priv = statusbar->priv;

	gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), TRUE);

	priv->img_num_statusbar = gtk_statusbar_new ();
	gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (priv->img_num_statusbar), FALSE);
	gtk_widget_set_size_request (priv->img_num_statusbar, 100, 10);
	gtk_widget_show (priv->img_num_statusbar);

	gtk_box_pack_end (GTK_BOX (statusbar),
			  priv->img_num_statusbar,
			  FALSE,
			  TRUE,
			  0);

	vbox = gtk_vbox_new (FALSE, 0);

	gtk_box_pack_end (GTK_BOX (statusbar),
			  vbox,
			  FALSE,
			  FALSE,
			  2);

	statusbar->priv->progressbar = gtk_progress_bar_new ();

	gtk_box_pack_end (GTK_BOX (vbox),
			  priv->progressbar,
			  TRUE,
			  TRUE,
			  2);

	gtk_widget_set_size_request (priv->progressbar, -1, 10);

	gtk_widget_show (vbox);

	gtk_widget_hide (statusbar->priv->progressbar);

}
Beispiel #9
0
static void
progress_update_display (TrackedTask *task)
{
	GtkProgressBar *progress = NULL;
	GtkStatusbar *status = NULL;
	GtkLabel *label = NULL;
	GtkWidget *widget;
	TrackedPart *part;
	gdouble fraction;
	guint id;

	if (task->builder == NULL)
		return;

	/* Dig out our progress display stuff */
	widget = GTK_WIDGET (gtk_builder_get_object (task->builder, "progress-bar"));
	if (widget == NULL)
		g_warning ("cannot display progress because seahorse window has no progress widget");
	else
		progress = GTK_PROGRESS_BAR (widget);
	widget = GTK_WIDGET (gtk_builder_get_object (task->builder, "status"));
	if (GTK_IS_STATUSBAR (widget)) {
		status = GTK_STATUSBAR (widget);
	} else {
		widget = GTK_WIDGET (gtk_builder_get_object (task->builder, "progress-details"));
		if (GTK_IS_LABEL (widget))
			label = GTK_LABEL (widget);
	}

	/* The details is the first on a begun part */
	part = tracked_part_find (task, find_part_begun_with_details, NULL);
	if (status) {
		id = gtk_statusbar_get_context_id (status, "operation-progress");
		gtk_statusbar_pop (status, id);
		if (part != NULL)
			gtk_statusbar_push (status, id, part->details);
	} else if (label) {
		gtk_label_set_text (label, part ? part->details : "");
	}

	/* If all parts are running simultaneously then indeterminate */
	if (task->parts_prepped == 0 && task->parts_ended == 0) {
		fraction = -1;
	} else {
		fraction = (gdouble)task->parts_ended /
		           (gdouble)task->parts->length;
	}

	if (progress) {
		if (fraction >= 0.0) {
			stop_pulse (progress);
			gtk_progress_bar_set_fraction (progress, fraction);
		} else {
			start_pulse (progress);
		}
	}
}
Beispiel #10
0
void gtkgui_set_statustext(char *testo) 
{
  //  gdk_threads_enter();

  contextid=gtk_statusbar_push(GTK_STATUSBAR(statusbar), 
			       contextid, (gchar *) testo);
  
  //  gdk_threads_leave();
}
Beispiel #11
0
void
gnac_ui_push_status(const gchar *message)
{
  GtkStatusbar *status_bar = GTK_STATUSBAR(gnac_ui_get_widget("statusbar"));
  g_free(status_msg);
  status_msg = g_strdup(message);
  gtk_statusbar_pop(status_bar, 0);
  gtk_statusbar_push(status_bar, 0, status_msg);
}
Beispiel #12
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;
}
Beispiel #13
0
static void
create_status_bar (EtStatusBar *self)
{
    EtStatusBarPrivate *priv;

    priv = et_status_bar_get_instance_private (self);

    /* Specify a size to avoid statubar resizing if the message is too long */
    gtk_widget_set_size_request (GTK_WIDGET (self), 200, -1);

    /* Create serie */
    priv->message_context = gtk_statusbar_get_context_id (GTK_STATUSBAR (self),
                                                          "messages");
    priv->timer_context = gtk_statusbar_get_context_id (GTK_STATUSBAR (self),
                                                        "timer");

    et_status_bar_message (self, _("Ready to start"), TRUE);
}
Beispiel #14
0
void
statusbar_set_zoom(StatusBar_t *statusbar, gint factor)
{
   char scratch[16];

   sprintf(scratch, "1:%d", factor);
   gtk_statusbar_push(GTK_STATUSBAR(statusbar->zoom), statusbar->zoom_id,
                      scratch);
}
Beispiel #15
0
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);
}
Beispiel #16
0
/*
 * Timeout callbacks for statusbar_push_temporary_msg
 */
static gboolean
statusbar_remove_temporary_msg(gpointer data)
{
    guint msg_id = GPOINTER_TO_UINT(data);

    gtk_statusbar_remove(GTK_STATUSBAR(info_bar), main_ctx, msg_id);

    return FALSE;
}
Beispiel #17
0
/*
 * Pop a message referring to file access off the statusbar.
 */
static void
statusbar_pop_file_msg(void)
{
    /*g_warning("statusbar_pop");*/
    if (status_levels[STATUS_LEVEL_FILE] > 0) {
        status_levels[STATUS_LEVEL_FILE]--;
    }
    gtk_statusbar_pop(GTK_STATUSBAR(info_bar), file_ctx);
}
Beispiel #18
0
static void push_button_clicked(GtkWidget *widget, gpointer data)
{
    static int count = 1;
    gchar *buffer;

    buffer = g_strdup_printf("Item %d", count++);
    gtk_statusbar_push(GTK_STATUSBAR(statusbar), GPOINTER_TO_INT(data), buffer);
    g_free(buffer);
}
Beispiel #19
0
static void _set_admin_mode(GtkToggleAction *action)
{
//	GtkAction *admin_action = NULL;
	if (action)
		working_sview_config.admin_mode
			= gtk_toggle_action_get_active(action);
	if (!working_sview_config.admin_mode)
		gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar),
				  STATUS_ADMIN_MODE);
	else
		gtk_statusbar_push(GTK_STATUSBAR(main_statusbar),
				   STATUS_ADMIN_MODE,
				   "Admin mode activated! "
				   "Think before you alter anything.");

	gtk_action_group_set_sensitive(admin_action_group,
				       working_sview_config.admin_mode);
}
Beispiel #20
0
static GtkWidget* createStatusbar()
{
    GtkStatusbar *statusbar = GTK_STATUSBAR(gtk_statusbar_new());
    guint statusContextId = gtk_statusbar_get_context_id(statusbar, "Link Hover");
    g_object_set_data(G_OBJECT(statusbar), "link-hover-context",
        GUINT_TO_POINTER(statusContextId));

    return GTK_WIDGET(statusbar);
}
Beispiel #21
0
/**
 * gva_main_statusbar_pop:
 * @context_id: a context identifier
 *
 * Thin wrapper for gtk_statusbar_pop() that uses the main window's
 * status bar.
 *
 * Removes the first message in the status bar's stack with the given
 * context id.
 *
 * Note that this may not change the displayed message, if the message
 * at the top of the stack has a different context id.
 **/
void
gva_main_statusbar_pop (guint context_id)
{
        GtkStatusbar *statusbar;

        statusbar = GTK_STATUSBAR (GVA_WIDGET_MAIN_STATUSBAR);

        gtk_statusbar_pop (statusbar, context_id);
}
Beispiel #22
0
void on_menu_options_macspoofing_toggle (GtkCheckMenuItem *menu, struct term_node *node)
{
   GtkWidget *notebook, *main_statusbar;
   u_int8_t mode;

   notebook = lookup_widget(GTK_WIDGET(menu), "main_vhv2_notebook");
   mode = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
   main_statusbar = lookup_widget(GTK_WIDGET(notebook), "main_statusbar");
   if (node->mac_spoofing) {
      node->mac_spoofing = 0;
      gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), 0, "MAC Spoofing set to OFF");
      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(menu), FALSE);
   } else {
      node->mac_spoofing = 1;
      gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), 0, "MAC Spoofing set to ON");
      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(menu), TRUE);
   }
}
Beispiel #23
0
void gtk_c_on_file_quit_activate(GtkMenuItem *menuitem, gpointer user_data)
{
   struct gtk_s_helper *helper;

   helper = (struct gtk_s_helper *)user_data;
   gtk_statusbar_push(GTK_STATUSBAR(helper->statusbar), 0, "Exiting... be patient");
   
   gtk_main_quit();
}
Beispiel #24
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;
}
Beispiel #25
0
/*
 * Update the packets statusbar to the current values
 */
void
packets_bar_update(void)
{
    if(packets_bar) {
        /* Remove old status */
        if(packets_str) {
            gtk_statusbar_pop(GTK_STATUSBAR(packets_bar), packets_ctx);
        } else {
            packets_str = g_string_new ("");
        }

        /* Do we have any packets? */
        if(cfile.count) {
            g_string_printf(packets_str, " Packets: %u " UTF8_MIDDLE_DOT
                            " Displayed: %u (%.1f%%) ",
                            cfile.count,
                            cfile.displayed_count,
                            (100.0 * cfile.displayed_count)/cfile.count);
            if(cfile.marked_count) {
                g_string_append_printf(packets_str, " " UTF8_MIDDLE_DOT " Marked: %u (%.1f%%)",
                                       cfile.marked_count, (100.0 * cfile.marked_count)/cfile.count);
            }
            if(cfile.drops_known) {
                g_string_append_printf(packets_str, " " UTF8_MIDDLE_DOT " Dropped: %u (%.1f%%)",
                                       cfile.drops, (100.0 * cfile.drops)/cfile.count);
            }
            if(cfile.ignored_count) {
                g_string_append_printf(packets_str, " " UTF8_MIDDLE_DOT " Ignored: %u (%.1f%%)",
                                       cfile.ignored_count, (100.0 * cfile.ignored_count)/cfile.count);
            }
            if(!cfile.is_tempfile){
                /* Loading an existing file */
                gulong computed_elapsed = cf_get_computed_elapsed(&cfile);
                g_string_append_printf(packets_str, " " UTF8_MIDDLE_DOT " Load time: %lu:%02lu.%03lu",
                                       computed_elapsed/60000,
                                       computed_elapsed%60000/1000,
                                       computed_elapsed%1000);
            }
        } else {
            g_string_printf(packets_str, " No Packets");
        }
        gtk_statusbar_push(GTK_STATUSBAR(packets_bar), packets_ctx, packets_str->str);
    }
}
Beispiel #26
0
void load_hashtable_list( ){

		char *word = NULL, *entry_word = NULL;
	
		entry_word = gtk_entry_get_text ( mydata.input_word );	
		//	word = g_strchomp( g_strchug( g_strdown( entry_word ) ) );
		//  it has caused a Pango: index out of bound bug so use instead
		word = g_strdown( entry_word );
	
	//
		if( ! isalpha( word[0] ) ){
			//g_print("on_input_word_changed(): enter proper word\n");
			// ************** show proper warning to enter proper word *****************
//
			gtk_statusbar_pop ( mydata.statusbar, mydata.statusbar_context_id );
			gtk_statusbar_push (GTK_STATUSBAR (mydata.statusbar), mydata.statusbar_context_id, "Please enter/select proper english word");
//
			return;
		}								
		//check if hash table is created for word[0] of not
		g_sprintf( file_loaded_name, APP_DBS"%c.db", g_ascii_tolower( word[0] ) );
		//g_print("on_input_word_changed(): filename = %s\n",file_loaded_name);
		
		if( mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){
			//remove the prev word entries
			//remove_all_from_list ();
			//g_print("on_input_word_changed(): generating hash table\n");
			mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] = generate_hash_table( file_loaded_name );
			mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ] = mydata.list_store;
			list_loaded = g_ascii_toupper(word[0]) - 'A';
			//check if hash table is created or not by generate_hash_table() func call				 
			if( mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){
				g_print("on_input_word_changed():\nafter trying to generate_hash_table\nfile: %s could not be located and loaded\n", file_loaded_name );
			}						 
		}else{
			//g_print("on_input_word_changed(): %d", list_loaded );
			if( list_loaded != (g_ascii_toupper(word[0]) - 'A') ){
				//remove_all_from_list ();
//************   we have change here to fasten************ -------------->>>>>>>>>
//load list from pointer else populate it			
				if( mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){
					populate_list_only( file_loaded_name );
					//g_print("on_input_word_changed(): list populated from file\n" );
				}else{					
					mydata.list_store = mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ];
//					following may be necessary		  
					gtk_tree_view_set_model ( mydata.treeview, GTK_TREE_MODEL(mydata.list_store) );
					//g_print("on_input_word_changed(): list used from previous list\n" );
				}
				
				list_loaded = (g_ascii_toupper(word[0]) - 'A');
			}
		}	
	//
	
}
Beispiel #27
0
void setStatusText_strdup(gchar *msg)
{
	static gchar *curMsg = NULL;

	if (mainStatusbar == NULL)
		return;

	/* Remove current message with context id 0. */
	gtk_statusbar_pop(GTK_STATUSBAR(mainStatusbar), 0);

	/* Free last message if any -- and store pointer to new message. */
	if (curMsg != NULL)
		g_free(curMsg);

	curMsg = g_strdup(msg);

	/* Set new message. */
	gtk_statusbar_push(GTK_STATUSBAR(mainStatusbar), 0, curMsg);
}
Beispiel #28
0
void ctk_statusbar_message(CtkStatusBar *status_bar,
                           const gchar *str)
{

    if ((!status_bar->enabled) ||
        (!status_bar->widget)) {
        return;
    }

    if (status_bar->prev_message_id) {
        gtk_statusbar_remove(GTK_STATUSBAR(status_bar->widget),
                             1, status_bar->prev_message_id);
    }

    status_bar->prev_message_id =
        gtk_statusbar_push
        (GTK_STATUSBAR(status_bar->widget), 1, str);

} /* ctk_config_statusbar_message() */
void cairo_dock_set_status_message (GtkWidget *pWindow, const gchar *cMessage)
{
	cd_debug ("%s (%s)", __func__, cMessage);
	GtkWidget *pStatusBar;
	if (pWindow != NULL)
	{
		pStatusBar = g_object_get_data (G_OBJECT (pWindow), "status-bar");
		if (pStatusBar == NULL)
			return ;
		//g_print ("%s (%s sur %x/%x)\n", __func__, cMessage, pWindow, pStatusBar);
		gtk_statusbar_pop (GTK_STATUSBAR (pStatusBar), 0);  // clear any previous message, underflow is allowed.
		gtk_statusbar_push (GTK_STATUSBAR (pStatusBar), 0, cMessage);
	}
	else
	{
		if (s_pGuiBackend && s_pGuiBackend->set_status_message_on_gui)
			s_pGuiBackend->set_status_message_on_gui (cMessage);
	}
}
Beispiel #30
0
/**
 * gva_main_statusbar_remove:
 * @context_id: a context identifier
 * @message_id: a message identifier
 *
 * Thin wrapper for gtk_statusbar_remove() that uses the main window's
 * status bar.
 *
 * Forces the removal of a message from a status bar's stack.  The exact
 * @context_id and @message_id must be specified.
 **/
void
gva_main_statusbar_remove (guint context_id,
                           guint message_id)
{
        GtkStatusbar *statusbar;

        statusbar = GTK_STATUSBAR (GVA_WIDGET_MAIN_STATUSBAR);

        gtk_statusbar_remove (statusbar, context_id, message_id);
}