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;
}
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 spd_display()
{
gtk_spinner_start(scanningSpinner);
gtk_label_set_text(lab_scan_progress, "0\n0");
gtk_revealer_set_reveal_child(revealer_scan_progress, TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(p_innerPaned), FALSE);
}
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
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));
}
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
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));
}
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
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
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 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
athena_floating_bar_show (GtkWidget *widget)
{
AthenaFloatingBar *self = ATHENA_FLOATING_BAR (widget);
GTK_WIDGET_CLASS (athena_floating_bar_parent_class)->show (widget);
if (self->priv->show_spinner) {
gtk_spinner_start (GTK_SPINNER (self->priv->spinner));
}
}
static void
begin_action (UmAccountDialog *self)
{
g_debug ("Beginning action, disabling dialog controls");
gtk_widget_set_sensitive (self->container_widget, FALSE);
gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE);
gtk_widget_show (GTK_WIDGET (self->spinner));
gtk_spinner_start (self->spinner);
}
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->priv->show_spinner) {
gtk_spinner_start (GTK_SPINNER (self->priv->spinner));
}
}
void source_spinner_item_start (SourceSpinnerItem* self) {
#line 39 "source-spinner-item.vala"
g_return_if_fail (self != NULL);
#line 41 "source-spinner-item.vala"
gtk_spinner_start (self->priv->spinner);
#line 42 "source-spinner-item.vala"
if (gtk_widget_get_parent ((GtkWidget*) self->priv->spinner) != GTK_WIDGET (((SourceItem*) self)->right_align)) {
#line 42 "source-spinner-item.vala"
gtk_container_add ((GtkContainer*) ((SourceItem*) self)->right_align, (GtkWidget*) self->priv->spinner);
#line 140 "source-spinner-item.c"
}
}
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 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
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
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);
}
void source_spinner_item_set_spinning (SourceSpinnerItem* self, gboolean value) {
g_return_if_fail (self != NULL);
#line 53 "source-spinner-item.vala"
gtk_widget_set_visible ((GtkWidget*) self->priv->spinner, value);
#line 54 "source-spinner-item.vala"
if (value) {
#line 54 "source-spinner-item.vala"
gtk_spinner_start (self->priv->spinner);
#line 384 "source-spinner-item.c"
} else {
#line 55 "source-spinner-item.vala"
gtk_spinner_stop (self->priv->spinner);
#line 388 "source-spinner-item.c"
}
g_object_notify ((GObject *) self, "spinning");
}
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));
}
}
static gboolean
start_spinning (gpointer data)
{
GtkWidget *spinner = data;
guint id;
gtk_widget_set_opacity (spinner, 0);
gtk_spinner_start (GTK_SPINNER (spinner));
id = g_timeout_add (100, fade_in, spinner);
g_object_set_data_full (G_OBJECT (spinner), "fade-timeout",
GUINT_TO_POINTER (id), remove_source);
/* don't try to remove this source in the future */
g_object_steal_data (G_OBJECT (spinner), "start-timeout");
return G_SOURCE_REMOVE;
}
/*!
* \brief Cree une instance CalculateUI
*/
void calculate_ui_create (PtrCalculateUI *calculate_ui, PtrSimulation simulation)
{
assert (*calculate_ui == NULL);
assert (simulation != NULL);
*calculate_ui = (PtrCalculateUI) malloc ( sizeof (CalculateUI));
if (*calculate_ui == NULL)
{
g_error ("CalculateUI memory allocation failed");
}
memset (*calculate_ui, 0, sizeof (CalculateUI));
// Chargement de l'interface
GError* error = NULL;
GtkBuilder* builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, "ui/calculate.glade", &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
// Chargement des objets
(*calculate_ui) -> window = GTK_WINDOW (gtk_builder_get_object (builder, "window"));
(*calculate_ui) -> progress_bar = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "progress_bar"));
(*calculate_ui) -> cancel_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_button"));
(*calculate_ui) -> progression_label = GTK_LABEL (gtk_builder_get_object (builder, "progression_label"));
(*calculate_ui) -> spinner = GTK_SPINNER (gtk_builder_get_object (builder, "spinner"));
gtk_label_set_text ((*calculate_ui) -> progression_label, "");
gtk_spinner_start ((*calculate_ui) -> spinner);
(*calculate_ui) -> simulation = simulation;
// Creation de calculate worker
PtrCalculateWorker calculate_worker = NULL;
calculate_worker_create (&calculate_worker, simulation);
(*calculate_ui) -> calculate_worker = calculate_worker;
gtk_builder_connect_signals (builder, (*calculate_ui));
calculate_ui_refresh_ihm_states ((*calculate_ui ));
// Instanciation de la fonction timeout pour rafraichir l'IHM pendant le traitement
(*calculate_ui) -> timeout_refresh_id = g_timeout_add (500, calculate_ui_timeout, (*calculate_ui ));
assert ((*calculate_ui )-> window != NULL);
}
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
cheese_widget_realize (GtkWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
GTK_WIDGET_CLASS (cheese_widget_parent_class)->realize (widget);
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_widget_realize (priv->screen);
setup_camera (CHEESE_WIDGET (widget));
gtk_widget_set_app_paintable (priv->problem, TRUE);
gtk_widget_realize (priv->problem);
return;
}
static void
nautilus_floating_bar_constructed (GObject *obj)
{
NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (obj);
GtkWidget *w, *box, *labels_box;
G_OBJECT_CLASS (nautilus_floating_bar_parent_class)->constructed (obj);
box = GTK_WIDGET (obj);
w = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
gtk_widget_set_visible (w, self->show_spinner);
gtk_spinner_start (GTK_SPINNER (w));
self->spinner = w;
gtk_widget_set_size_request (w, 16, 16);
gtk_widget_set_margin_start (w, 8);
labels_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), labels_box, TRUE, TRUE, 0);
g_object_set (labels_box,
"margin-top", 2,
"margin-bottom", 2,
"margin-start", 12,
"margin-end", 12,
NULL);
gtk_widget_show (labels_box);
w = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (w), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
gtk_container_add (GTK_CONTAINER (labels_box), w);
self->primary_label_widget = w;
gtk_widget_show (w);
w = gtk_label_new (NULL);
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
gtk_container_add (GTK_CONTAINER (labels_box), w);
self->details_label_widget = w;
gtk_widget_show (w);
}
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
connection_dialog_unlock(gboolean value)
{
gtk_widget_set_sensitive(r_serial, value);
gtk_widget_set_sensitive(c_serial, value);
gtk_widget_set_sensitive(r_tcp, value);
gtk_widget_set_sensitive(e_host, value);
gtk_widget_set_sensitive(e_port, value);
gtk_widget_set_sensitive(e_password, value);
gtk_widget_set_sensitive(c_password, value);
gtk_widget_set_sensitive(b_connect, value);
if(!value)
{
gtk_widget_show(spinner);
gtk_spinner_start(GTK_SPINNER(spinner));
}
else
{
gtk_widget_hide(spinner);
}
}
void cw_picture_window_set_store_item(GtkWidget* window,
CWStoreItem* store_item)
{
CWPictureWindowPrivate *priv = CW_PICTURE_WINDOW_GET_PRIVATE(window);
if (NULL == priv)
return ;
CWStoreItem* old = priv->store_item;
priv->store_item = store_item;
if (old == store_item)
return;
if (NULL == store_item) {
gtk_widget_hide(window);
return;
}
if ((NULL != old) && (priv->connect_id > 0)) {
g_signal_handler_disconnect(old, priv->connect_id);
priv->connect_id = 0;
}
GdkPixbuf* pix = cw_store_item_get_pixbuf(store_item);
if (NULL == pix) {
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_widget_show(priv->spinner);
//gtk_widget_show_all (GTK_WIDGET (window));
priv->connect_id = g_signal_connect(store_item,
"load_complete",
G_CALLBACK(cw_picture_window_on_image_load_complete),
window);
cw_store_item_load_large_image(store_item);
} else {
cw_picture_window_show_image(window, priv);
}
if (old)
cw_store_item_clean_pixbuf(old);
//return old;
}
static void cui_popup_left_menu(GtkStatusIcon *trayicon,
gpointer user_data)
{
GtkSpinner *spin;
spin = (GtkSpinner *)gtk_bin_get_child(GTK_BIN(cui_scan_spinner));
gtk_widget_hide(GTK_WIDGET(cui_list_more_item));
gtk_widget_show((GtkWidget *)cui_scan_spinner);
gtk_widget_show((GtkWidget *)spin);
gtk_spinner_start(spin);
connman_service_set_removed_callback(remove_service_cb);
connman_service_refresh_services_list(get_services_cb,
scanning_cb, user_data);
gtk_widget_set_size_request(cui_left_menu, -1, 150);
gtk_menu_popup(cui_left_menu, NULL, NULL, NULL, NULL, 1, 0);
}
