自学教程：C++ GTK_SPINNER函数代码示例

static voiddevice_busy_cb (NmaBtDevice *device, GParamSpec *pspec, WidgetInfo *info){	gboolean busy = nma_bt_device_get_busy (device);	if (info->pan_button)		gtk_widget_set_sensitive (info->pan_button, !busy);	if (info->dun_button)		set_dun_button_sensitive (info, !busy);	if (busy) {		if (!info->spinner) {			info->spinner = gtk_spinner_new ();			gtk_box_pack_start (GTK_BOX (info->hbox), info->spinner, FALSE, FALSE, 6);		}		gtk_spinner_start (GTK_SPINNER (info->spinner));		gtk_widget_show (info->spinner);	} else {		if (info->spinner) {			gtk_spinner_stop (GTK_SPINNER (info->spinner));			gtk_widget_destroy (info->spinner);			info->spinner = NULL;		}	}}

voidnautilus_notebook_sync_loading (NautilusNotebook *notebook,				NautilusWindowSlot *slot){	GtkWidget *tab_label, *spinner, *icon;	gboolean active;	g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook));	g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot));	tab_label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (notebook), 						GTK_WIDGET (slot));	g_return_if_fail (GTK_IS_WIDGET (tab_label));	spinner = GTK_WIDGET (g_object_get_data (G_OBJECT (tab_label), "spinner"));	icon = GTK_WIDGET (g_object_get_data (G_OBJECT (tab_label), "icon"));	g_return_if_fail (spinner != NULL && icon != NULL);	active = FALSE;	g_object_get (spinner, "active", &active, NULL);	if (active == slot->allow_stop)	{		return;	}	if (slot->allow_stop) {		gtk_widget_hide (icon);		gtk_widget_show (spinner);		gtk_spinner_start (GTK_SPINNER (spinner));	} else {		gtk_spinner_stop (GTK_SPINNER (spinner));		gtk_widget_hide (spinner);		gtk_widget_show (icon);	}}

static voidtoggle_spin (GtkWidget *checkbutton,             GtkWidget *spinner){  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)))    gtk_spinner_start (GTK_SPINNER (spinner));  else    gtk_spinner_stop (GTK_SPINNER (spinner));}

// Обработчик нажатия кнопки Конвертировать.void cMainWin::OnConvert(GtkWidget *widget, cMainWin *aMainWin){	// Проверим есть ли вообще что конвертировать.	if(aMainWin->mTracks.empty())	{		aMainWin->PrintNotification("Не выбрано ни одного трека для конвертации.", eNotifTypeError);		return;	}	// Проверим создан ли экземпляр конвертера в окне.	if(!aMainWin->mConvert)	{		aMainWin->PrintNotification("Ошибка конвертера. Перезапустите приложение.", eNotifTypeError);		return;	}	// Получим из комбо бокса формат файла в который будем конвертировать все аудио файлы.	aMainWin->mConvert->SetFormat(gtk_combo_box_text_get_active_text ((GtkComboBoxText *)aMainWin->mwFormat));	// Для разных форматов необходимо получить параметры конвертации.	// Например, получим качество файлов на выходе.	if(aMainWin->mConvert->GetFormat() == eFormat_MP3)	{		int adQualityMark = gtk_range_get_value ((GtkRange *)aMainWin->mMP3Widgets.mwQuality);		aMainWin->mConvert->SetQuality(asMP3Quality[adQualityMark]);	}	else if(aMainWin->mConvert->GetFormat() == eFormat_OGG)	{		int adQualityMark = gtk_range_get_value ((GtkRange *)aMainWin->mOGGWidgets.mwQuality);		aMainWin->mConvert->SetQuality(asOGGQuality[adQualityMark]);	}	else if(aMainWin->mConvert->GetFormat() == eFormat_WAV)	{	}	// Теперь-то покажем спиннер и запустим его.	gtk_widget_show(aMainWin->mwSpinner);	gtk_spinner_start (GTK_SPINNER (aMainWin->mwSpinner));	// Основная функция конвертации файлов.	if(!aMainWin->mConvert->Convert())	{		gtk_spinner_stop (GTK_SPINNER (aMainWin->mwSpinner));		aMainWin->PrintNotification("Что-то пошло не так при конвертации.", eNotifTypeError);	}	else	{		gtk_spinner_stop (GTK_SPINNER (aMainWin->mwSpinner));		aMainWin->PrintNotification("Конвертация прошла успешно!", eNotifTypeNotification);	}	gtk_widget_hide(aMainWin->mwSpinner);	// Спрячем спиннер до следующей конвертации.}

static voidstatus_changed_cb(MathEquation *equation, GParamSpec *spec, MathDisplay *display){    gtk_text_buffer_set_text(display->priv->info_buffer, math_equation_get_status(equation), -1);    if (math_equation_in_solve(equation) && !gtk_widget_get_visible(display->priv->spinner)) {        gtk_widget_show(display->priv->spinner);        gtk_spinner_start(GTK_SPINNER(display->priv->spinner));    }    else if (!math_equation_in_solve(equation) && gtk_widget_get_visible(display->priv->spinner)) {        gtk_widget_hide(display->priv->spinner);        gtk_spinner_stop(GTK_SPINNER(display->priv->spinner));    }}

static voidstate_changed_cb (GtkWidget *widget,                  GParamSpec *pspec,                  EmerillonWindow *self){  ChamplainState state;  g_object_get (self->priv->view, "state", &state, NULL);  if (state == CHAMPLAIN_STATE_LOADING)    gtk_spinner_start (GTK_SPINNER (self->priv->throbber));  else    gtk_spinner_stop (GTK_SPINNER (self->priv->throbber));}

static voidrequest_contact_info_cb (GObject *object,    GAsyncResult *res,    gpointer user_data){  TpawUserInfo *self = user_data;  TpContact *contact = TP_CONTACT (object);  guint n_rows;  GError *error = NULL;  if (!tp_contact_request_contact_info_finish (contact, res, &error))    {      /* If the request got cancelled it could mean the contact widget is       * destroyed, so we should not dereference self */      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))        {          g_clear_error (&error);          return;        }      g_clear_error (&error);    }  n_rows = fill_contact_info_grid (self);  gtk_widget_set_visible (self->priv->details_label, n_rows > 0);  gtk_spinner_stop (GTK_SPINNER (self->priv->details_spinner));  gtk_widget_hide (self->priv->details_spinner);}

voidnautilus_navigation_window_set_spinner_active (NautilusNavigationWindow *window,					       gboolean allow){	if (( window->details->spinner_active &&  allow) ||	    (!window->details->spinner_active && !allow)) {		return;	}	window->details->spinner_active = allow;	if (allow) {		gtk_spinner_start (GTK_SPINNER (window->details->spinner));	} else {		gtk_spinner_stop (GTK_SPINNER (window->details->spinner));	}}

/* * Display a web page from a HTML string in memory, rather than from a URL */voidload_webkit_string(struct tab *t, const char *str, gchar *title){	char			file[PATH_MAX];	int			i;	/* we set this to indicate we want to manually do navaction */	if (t->bfl)		t->item = webkit_web_back_forward_list_get_current_item(t->bfl);	t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;	if (title) {		/* set t->xtp_meaning */		for (i = 0; i < LENGTH(about_list); i++)			if (!strcmp(title, about_list[i].name)) {				t->xtp_meaning = i;				break;			}		webkit_web_view_load_string(t->wv, str, NULL, encoding,		    "file://");#if GTK_CHECK_VERSION(2, 20, 0)		gtk_spinner_stop(GTK_SPINNER(t->spinner));		gtk_widget_hide(t->spinner);#endif		snprintf(file, sizeof file, "%s" PS "%s", resource_dir, icons[0]);		xt_icon_from_file(t, file);	}}

static voidon_import_button_clicked (GtkButton *import_button, gpointer user_data){    SeahorseKeyserverResultsRow *row = user_data;    g_autoptr(GtkWidget) spinner = NULL;    g_autoptr(GList) keys = NULL;    g_autoptr(GCancellable) cancellable = NULL;    SeahorsePgpBackend *backend;    SeahorseGpgmeKeyring *keyring;    /* Let the button show a spinner while importing */    gtk_widget_set_sensitive (GTK_WIDGET (import_button), FALSE);    spinner = gtk_spinner_new ();    gtk_spinner_start (GTK_SPINNER (spinner));    gtk_button_set_image (import_button, g_steal_pointer (&spinner));    /* Now import the key */    keys = g_list_append (keys, row->key);    cancellable = g_cancellable_new ();    backend = seahorse_pgp_backend_get ();    keyring = seahorse_pgp_backend_get_default_keyring (backend);    seahorse_pgp_backend_transfer_async (backend, keys,                                         SEAHORSE_PLACE (keyring),                                         cancellable, on_import_complete,                                         g_object_ref (row));}

static voidupdated_database_cb (gpointer data, gpointer user_data){    FsearchApplicationWindow *win = (FsearchApplicationWindow *) user_data;    g_assert (FSEARCH_WINDOW_IS_WINDOW (win));    hide_overlays (win);    update_statusbar (win, "");    fsearch_application_window_update_search (win);    gtk_spinner_stop (GTK_SPINNER (win->database_spinner));    gtk_stack_set_visible_child (GTK_STACK (win->database_stack), win->database_box2);    Database *db = fsearch_application_get_db (FSEARCH_APPLICATION_DEFAULT);    uint32_t num_items = db_get_num_entries (db);    gchar db_text[100] = "";    snprintf (db_text, sizeof (db_text), _("%'d Items"), num_items);    gtk_label_set_text (GTK_LABEL (win->database_label), db_text);    time_t timestamp = db_get_timestamp (db);    strftime (db_text, sizeof(db_text),             "Last Updated: %Y-%m-%d %H:%M", //"%Y-%m-%d %H:%M",             localtime (&timestamp));    gtk_widget_set_tooltip_text (win->database_toggle_button, db_text);}

int main (int argc, char *argv[]){	GtkBuilder *builder;	tMainWindow mainWindow;	gpointer pMainWindow = &mainWindow;	gtk_init (&argc, &argv);	builder = gtk_builder_new ();	gtk_builder_add_from_file (builder, "ui.glade", NULL);	/* References to Window1 */	((tMainWindow*)pMainWindow)->window1 = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));	((tMainWindow*)pMainWindow)->textview_address = GTK_TEXT_VIEW (gtk_builder_get_object (builder, "textview_address"));	((tMainWindow*)pMainWindow)->entry_subject = GTK_ENTRY (gtk_builder_get_object (builder, "entry_subject"));	((tMainWindow*)pMainWindow)->entry_opening = GTK_ENTRY (gtk_builder_get_object (builder, "entry_opening"));	((tMainWindow*)pMainWindow)->textview_letter = GTK_TEXT_VIEW (gtk_builder_get_object (builder, "textview_letter"));	((tMainWindow*)pMainWindow)->entry_enclosure = GTK_ENTRY (gtk_builder_get_object (builder, "entry_supplement"));	((tMainWindow*)pMainWindow)->spinner = GTK_SPINNER (gtk_builder_get_object (builder, "spinner"));		gtk_builder_connect_signals (builder, pMainWindow);	g_object_unref (G_OBJECT (builder));	gtk_widget_show (mainWindow.window1);	gtk_main ();	return 0;}

static GtkWidget *autoenc_processing_dialog_create(void){	GtkWidget *dialog;	GtkWidget *hbox;	GtkWidget *spinner;	GtkWidget *label;	dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);	gtk_container_set_border_width(GTK_CONTAINER(dialog), 16);	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);	gtk_window_set_title(GTK_WINDOW(dialog), _("Encrypting attachments"));	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);	gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);	syl_plugin_manage_window_set_transient(GTK_WINDOW(dialog));	//g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_true), NULL);	hbox = gtk_hbox_new(FALSE, 12);	gtk_container_add(GTK_CONTAINER(dialog), hbox);	gtk_widget_show(hbox);	spinner = gtk_spinner_new();	gtk_widget_set_size_request(spinner, 16, 16);	gtk_box_pack_start(GTK_BOX(hbox), spinner, FALSE, FALSE, 0);	gtk_widget_show(spinner);	label = gtk_label_new(_("Encrypting attachments..."));	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);	gtk_widget_show(label);	gtk_widget_show(dialog);	gtk_spinner_start(GTK_SPINNER(spinner));	return dialog;}

/* public functions */void spd_init(GtkBuilder *builder){	/* widgets and icons */	revealer_scan_progress = GTK_REVEALER(gtk_builder_get_object(builder, "revealer_scan_progress"));	lab_scan_progress = GTK_LABEL(gtk_builder_get_object(builder, "lab_scan_progress"));	scanningSpinner = GTK_SPINNER(gtk_builder_get_object(builder, "scanningSpinner"));  	p_innerPaned = GTK_PANED(gtk_builder_get_object(builder, "p_innerPaned")) ;}

PpPPDSelectionDialog *pp_ppd_selection_dialog_new (GtkWindow            *parent,                             PPDList              *ppd_list,                             gchar                *manufacturer,                             UserResponseCallback  user_callback,                             gpointer              user_data){  PpPPDSelectionDialog *dialog;  GtkWidget            *widget;  GError               *error = NULL;  gchar                *objects[] = { "ppd-selection-dialog", NULL };  guint                 builder_result;  dialog = g_new0 (PpPPDSelectionDialog, 1);  dialog->builder = gtk_builder_new ();  dialog->parent = GTK_WIDGET (parent);  builder_result = gtk_builder_add_objects_from_file (dialog->builder,                                                      DATADIR"/ppd-selection-dialog.ui",                                                      objects, &error);  if (builder_result == 0)    {      g_warning ("Could not load ui: %s", error->message);      g_error_free (error);      return NULL;    }  dialog->dialog = (GtkWidget *) gtk_builder_get_object (dialog->builder, "ppd-selection-dialog");  dialog->user_callback = user_callback;  dialog->user_data = user_data;  dialog->response = GTK_RESPONSE_NONE;  dialog->list = ppd_list_copy (ppd_list);  dialog->manufacturer = get_standard_manufacturers_name (manufacturer);  /* connect signals */  g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);  g_signal_connect (dialog->dialog, "response", G_CALLBACK (ppd_selection_dialog_response_cb), dialog);  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "content-alignment");  g_signal_connect (widget, "size-allocate", G_CALLBACK (update_alignment_padding), dialog);  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "ppd-spinner");  gtk_spinner_start (GTK_SPINNER (widget));  populate_dialog (dialog);  gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent));  gtk_window_present (GTK_WINDOW (dialog->dialog));  gtk_widget_show_all (GTK_WIDGET (dialog->dialog));  return dialog;}

static voidfill_ppds_list (PpPPDSelectionDialog *dialog){  GtkTreeSelection *selection;  GtkListStore     *store;  GtkTreePath      *path;  GtkTreeView      *treeview;  GtkTreeIter       iter;  GtkTreeIter      *preselect_iter = NULL;  GtkWidget        *widget;  gint              i;  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "ppd-spinner");  gtk_widget_hide (widget);  gtk_spinner_stop (GTK_SPINNER (widget));  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "progress-label");  gtk_widget_hide (widget);  treeview = (GtkTreeView*)    gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview");  if (dialog->list)    {      store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);      for (i = 0; i < dialog->list->num_of_manufacturers; i++)        {          gtk_list_store_append (store, &iter);          gtk_list_store_set (store, &iter,                              PPD_MANUFACTURERS_NAMES_COLUMN, dialog->list->manufacturers[i]->manufacturer_name,                              PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, dialog->list->manufacturers[i]->manufacturer_display_name,                              -1);          if (g_strcmp0 (dialog->manufacturer,                         dialog->list->manufacturers[i]->manufacturer_display_name) == 0)            {              preselect_iter = gtk_tree_iter_copy (&iter);            }        }      gtk_tree_view_set_model (treeview, GTK_TREE_MODEL (store));      if (preselect_iter &&          (selection = gtk_tree_view_get_selection (treeview)) != NULL)        {          gtk_tree_selection_select_iter (selection, preselect_iter);          path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), preselect_iter);          gtk_tree_view_scroll_to_cell (treeview, path, NULL, TRUE, 0.5, 0.0);          gtk_tree_path_free (path);          gtk_tree_iter_free (preselect_iter);        }      g_object_unref (store);    }}

static voidnemo_floating_bar_hide (GtkWidget *widget){	NemoFloatingBar *self = NEMO_FLOATING_BAR (widget);	GTK_WIDGET_CLASS (nemo_floating_bar_parent_class)->hide (widget);	gtk_spinner_stop (GTK_SPINNER (self->priv->spinner));}

static voidnew_chatroom_dialog_listing_cb (EmpathyTpRoomlist        *room_list,				gpointer                  unused,				EmpathyNewChatroomDialog *dialog){	gboolean listing;	listing = empathy_tp_roomlist_is_listing (room_list);	/* Update the throbber */	if (listing) {		gtk_spinner_start (GTK_SPINNER (dialog->throbber));		gtk_widget_show (dialog->throbber);	} else {		gtk_spinner_stop (GTK_SPINNER (dialog->throbber));		gtk_widget_hide (dialog->throbber);	}}

static voidathena_floating_bar_hide (GtkWidget *widget){	AthenaFloatingBar *self = ATHENA_FLOATING_BAR (widget);	GTK_WIDGET_CLASS (athena_floating_bar_parent_class)->hide (widget);	gtk_spinner_stop (GTK_SPINNER (self->priv->spinner));}

static voidpopulate_dialog (PpPPDSelectionDialog *dialog){  GtkTreeViewColumn *column;  GtkCellRenderer   *renderer;  GtkTreeView       *manufacturers_treeview;  GtkTreeView       *models_treeview;  GtkWidget         *widget;  manufacturers_treeview = (GtkTreeView*)    gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview");  renderer = gtk_cell_renderer_text_new ();  /* Translators: Name of column showing printer manufacturers */  column = gtk_tree_view_column_new_with_attributes (_("Manufacturers"), renderer,                                                     "text", PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, NULL);  gtk_tree_view_column_set_expand (column, TRUE);  gtk_tree_view_append_column (manufacturers_treeview, column);  models_treeview = (GtkTreeView*)    gtk_builder_get_object (dialog->builder, "ppd-selection-models-treeview");  renderer = gtk_cell_renderer_text_new ();  /* Translators: Name of column showing printer drivers */  column = gtk_tree_view_column_new_with_attributes (_("Drivers"), renderer,                                                     "text", PPD_DISPLAY_NAMES_COLUMN, NULL);  gtk_tree_view_column_set_expand (column, TRUE);  gtk_tree_view_append_column (models_treeview, column);  g_signal_connect (gtk_tree_view_get_selection (models_treeview),                    "changed", G_CALLBACK (model_selection_changed_cb), dialog);  g_signal_connect (gtk_tree_view_get_selection (manufacturers_treeview),                    "changed", G_CALLBACK (manufacturer_selection_changed_cb), dialog);  gtk_widget_show_all (dialog->dialog);  if (!dialog->list)    {      widget = (GtkWidget*)        gtk_builder_get_object (dialog->builder, "ppd-spinner");      gtk_widget_show (widget);      gtk_spinner_start (GTK_SPINNER (widget));      widget = (GtkWidget*)        gtk_builder_get_object (dialog->builder, "progress-label");      gtk_widget_show (widget);    }  else    {      fill_ppds_list (dialog);    }}

static voidphotos_print_notification_begin_print (PhotosPrintNotification *self){  PhotosPrintNotificationPrivate *priv = self->priv;  photos_notification_manager_add_notification (PHOTOS_NOTIFICATION_MANAGER (priv->ntfctn_mngr),                                                GTK_WIDGET (self));  gtk_spinner_start (GTK_SPINNER (priv->spinner));}

static voidnautilus_floating_bar_hide (GtkWidget *widget){	NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (widget);	GTK_WIDGET_CLASS (nautilus_floating_bar_parent_class)->hide (widget);	gtk_spinner_stop (GTK_SPINNER (self->priv->spinner));}

static voidpopulate_options (PpOptionsDialog *dialog){  GtkTreeViewColumn  *column;  GtkCellRenderer    *renderer;  GtkTreeView        *treeview;  GtkWidget          *widget;  /*   * Options which we need to obtain through an IPP request   * to be able to fill the options dialog.   * *-supported - possible values of the option   * *-default - actual value of the option   */  const gchar        *attributes[] =    { "number-up-supported",      "number-up-default",      "sides-supported",      "sides-default",      "orientation-requested-supported",      "orientation-requested-default",      NULL};  treeview = (GtkTreeView *)    gtk_builder_get_object (dialog->builder, "options-categories-treeview");  renderer = gtk_cell_renderer_text_new ();  column = gtk_tree_view_column_new_with_attributes ("Categories", renderer,                                                     "text", CATEGORY_NAMES_COLUMN, NULL);  gtk_tree_view_column_set_expand (column, TRUE);  gtk_tree_view_append_column (treeview, column);  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "options-spinner");  gtk_widget_show (widget);  gtk_spinner_start (GTK_SPINNER (widget));  widget = (GtkWidget*)    gtk_builder_get_object (dialog->builder, "progress-label");  gtk_widget_show (widget);  printer_get_ppd_async (dialog->printer_name,                         NULL,                         0,                         printer_get_ppd_cb,                         dialog);  get_named_dest_async (dialog->printer_name,                        get_named_dest_cb,                        dialog);  get_ipp_attributes_async (dialog->printer_name,                            (gchar **) attributes,                            get_ipp_attributes_cb,                            dialog);}

voidsetup_camera (CheeseWidget *widget){  CheeseWidgetPrivate *priv          = CHEESE_WIDGET_GET_PRIVATE (widget);  char                *webcam_device = NULL;  int                  x_resolution;  int                  y_resolution;  gdouble              brightness;  gdouble              contrast;  gdouble              saturation;  gdouble              hue;  g_settings_get (priv->settings, "photo-x-resolution", "i", &x_resolution);  g_settings_get (priv->settings, "photo-y-resolution", "i", &y_resolution);  g_settings_get (priv->settings, "camera",       "s", &webcam_device);  g_settings_get (priv->settings, "brightness",   "d", &brightness);  g_settings_get (priv->settings, "contrast",     "d", &contrast);  g_settings_get (priv->settings, "saturation",   "d", &saturation);  g_settings_get (priv->settings, "hue",          "d", &hue);  gdk_threads_enter ();  priv->webcam = cheese_camera_new (CLUTTER_TEXTURE (priv->texture),                                    webcam_device,                                    x_resolution,                                    y_resolution);  gdk_threads_leave ();  g_free (webcam_device);  cheese_camera_setup (priv->webcam, NULL, &priv->error);  gdk_threads_enter ();  gtk_spinner_stop (GTK_SPINNER (priv->spinner));  if (priv->error != NULL)  {    priv->state = CHEESE_WIDGET_STATE_ERROR;    g_object_notify (G_OBJECT (widget), "state");    cheese_widget_set_problem_page (CHEESE_WIDGET (widget), "error");  }  else  {    cheese_camera_set_balance_property (priv->webcam, "brightness", brightness);    cheese_camera_set_balance_property (priv->webcam, "contrast", contrast);    cheese_camera_set_balance_property (priv->webcam, "saturation", saturation);    cheese_camera_set_balance_property (priv->webcam, "hue", hue);    priv->state = CHEESE_WIDGET_STATE_READY;    g_object_notify (G_OBJECT (widget), "state");    cheese_camera_play (priv->webcam);    gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), WEBCAM_PAGE);  }  gdk_threads_leave ();}

static voidset_search_label (BluetoothChooser *self, gboolean state){	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);	if (priv->show_searching == FALSE) {		/* Just making sure */		gtk_spinner_stop (GTK_SPINNER (priv->spinner));		return;	}	if (state == FALSE) {		gtk_spinner_stop (GTK_SPINNER (priv->spinner));		gtk_widget_hide (priv->spinner);		gtk_label_set_text (GTK_LABEL (priv->search_label), _("No adapters available"));	} else {		gtk_widget_show (priv->spinner);		gtk_spinner_start (GTK_SPINNER (priv->spinner));		gtk_label_set_text (GTK_LABEL (priv->search_label), _("Searching for devices…"));	}}

static voidnautilus_floating_bar_show (GtkWidget *widget){	NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (widget);	GTK_WIDGET_CLASS (nautilus_floating_bar_parent_class)->show (widget);	if (self->show_spinner) {		gtk_spinner_start (GTK_SPINNER (self->spinner));	}}

static void linphone_gtk_in_call_set_animation_spinner(GtkWidget *callview) {#if GTK_CHECK_VERSION(2,20,0)    GtkWidget *container=linphone_gtk_get_widget(callview,"in_call_animation");    GList *elem=gtk_container_get_children(GTK_CONTAINER(container));    GtkWidget *spinner=gtk_spinner_new();    if (elem)        gtk_widget_destroy((GtkWidget*)elem->data);    gtk_widget_show(spinner);    gtk_container_add(GTK_CONTAINER(container),spinner);    gtk_widget_set_size_request(spinner, 20,20);    gtk_spinner_start(GTK_SPINNER(spinner));#endif}

static void wait_for_child(GPid pid, gint script_retval, gpointer data){	PCon_Spinner *pcspinner = (PCon_Spinner*)data;	gtk_spinner_stop(GTK_SPINNER(pcspinner->spinner));	gtk_widget_destroy(GTK_WIDGET(pcspinner->dialog));	g_spawn_close_pid(pid);	/* TODO At the moment background processes will fail to start before the	 * remmina connection.	 * Adding a delay here could be a (not good) solution, or we should	 * monitor each child opened, but it could be quit tricky and messy */	g_free(pcspinner);}

static voidupdate_database_cb (gpointer data, gpointer user_data){    FsearchApplicationWindow *win = (FsearchApplicationWindow *) user_data;    g_assert (FSEARCH_WINDOW_IS_WINDOW (win));    show_overlay (win, DATABASE_UPDATING_OVERLAY);    gtk_stack_set_visible_child (GTK_STACK (win->database_stack), win->database_box1);    gtk_spinner_start (GTK_SPINNER (win->database_spinner));    gchar db_text[100] = "";    snprintf (db_text, sizeof (db_text), _("Loading Database..."));    gtk_label_set_text (GTK_LABEL (win->database_label), db_text);}

static voidsw_delay_notify (GObject *obj, GParamSpec *pspec, gpointer data){  GtkWidget *spinner = data;  gboolean active;  gboolean state;  g_object_get (obj,                "active", &active,                "state", &state,                NULL);  if (active != state)    {      gtk_spinner_start (GTK_SPINNER (spinner));      gtk_widget_set_opacity (spinner, 1.0);    }  else    {      gtk_widget_set_opacity (spinner, 0.0);      gtk_spinner_stop (GTK_SPINNER (spinner));    }}