static void
device_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;
}
}
}
void
nautilus_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 void
toggle_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 void
status_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 void
state_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 void
request_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);
}
void
nautilus_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
*/
void
load_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 void
on_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 void
updated_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 (×tamp));
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 void
fill_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 void
nemo_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 void
new_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 void
athena_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 void
populate_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 void
photos_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 void
nautilus_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 void
populate_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);
}
void
setup_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 void
set_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 void
nautilus_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 void
update_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 void
sw_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));
}
}
