static void
action_stop_enabled_changed (GActionGroup *action_group,
			     gchar *action_name,
			     gboolean enabled,
			     gpointer user_data)
{
	NautilusToolbar *self = user_data;
	gtk_widget_set_visible (self->priv->stop, enabled);
}
Example #2
0
File: main.c Project: macrat/rusk
void inSiteSearchToggle(RuskWindow *rusk)
{
	if(!gtk_widget_is_visible(GTK_WIDGET(rusk->insiteSearch)))
	{
		gtk_widget_set_visible(GTK_WIDGET(rusk->insiteSearch), TRUE);
		gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->insiteSearch));

		WebKitFindController *finder = webkit_web_view_get_find_controller(rusk->webview);
		runInSiteSearch(rusk, webkit_find_controller_get_search_text(finder), TRUE);

		webkit_find_controller_search_previous(finder);
	}else
	{
		webkit_find_controller_search_finish(webkit_web_view_get_find_controller(rusk->webview));
		gtk_widget_set_visible(GTK_WIDGET(rusk->insiteSearch), FALSE);
		gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->webview));
	}
}
/* Steals permissions and permissions_data references */
static void
update_perm_store (CcPrivacyPanel *self,
                   GVariant *permissions,
                   GVariant *permissions_data)
{
  CcPrivacyPanelPrivate *priv;
  GVariantIter iter;
  gchar *key;
  gchar **value;
  GList *children;

  priv = self->priv;

  g_clear_pointer (&priv->location_apps_perms, g_variant_unref);
  priv->location_apps_perms = permissions;
  g_clear_pointer (&priv->location_apps_data, g_variant_unref);
  priv->location_apps_data = permissions_data;

  g_variant_iter_init (&iter, permissions);
  while (g_variant_iter_loop (&iter, "{s^as}", &key, &value))
    {
      gboolean enabled;
      gint64 last_used;

      if (g_strv_length (value) < 2)
        {
          g_debug ("Permissions for %s in incorrect format, ignoring..", key);
          continue;
        }

      enabled = (g_strcmp0 (value[0], "NONE") != 0);
      last_used = g_ascii_strtoll (value[1], NULL, 10);

      add_location_app (self, key, enabled, last_used);
    }

  children = gtk_container_get_children (GTK_CONTAINER (priv->location_apps_list_box));
  if (g_list_length (children) > 0)
    {
      gtk_widget_set_visible (priv->location_apps_label, TRUE);
      gtk_widget_set_visible (priv->location_apps_frame, TRUE);
    }
  g_list_free (children);
}
Example #4
0
File: listbox.c Project: GNOME/gtk
static void
gtk_message_row_update (GtkMessageRow *row)
{
  GtkMessageRowPrivate *priv = row->priv;
  GDateTime *t;
  char *s;

  gtk_label_set_text (priv->source_name, priv->message->sender_name);
  gtk_label_set_text (priv->source_nick, priv->message->sender_nick);
  gtk_label_set_text (priv->content_label, priv->message->message);
  t = g_date_time_new_from_unix_utc (priv->message->time);
  s = g_date_time_format (t, "%e %b %y");
  gtk_label_set_text (priv->short_time_label, s);
  g_free (s);
  s = g_date_time_format (t, "%X - %e %b %Y");
  gtk_label_set_text (priv->detailed_time_label, s);
  g_free (s);
  g_date_time_unref (t);

  gtk_widget_set_visible (GTK_WIDGET(priv->n_favorites_label),
                          priv->message->n_favorites != 0);
  s = g_strdup_printf ("<b>%d</b>\nFavorites", priv->message->n_favorites);
  gtk_label_set_markup (priv->n_favorites_label, s);
  g_free (s);

  gtk_widget_set_visible (GTK_WIDGET(priv->n_reshares_label),
                          priv->message->n_reshares != 0);
  s = g_strdup_printf ("<b>%d</b>\nReshares", priv->message->n_reshares);
  gtk_label_set_markup (priv->n_reshares_label, s);
  g_free (s);

  gtk_widget_set_visible (GTK_WIDGET (priv->resent_box), priv->message->resent_by != NULL);
  if (priv->message->resent_by)
    gtk_button_set_label (GTK_BUTTON (priv->resent_by_button), priv->message->resent_by);

  if (strcmp (priv->message->sender_nick, "@GTKtoolkit") == 0)
    {
      gtk_image_set_from_icon_name (priv->avatar_image, "gtk3-demo");
      gtk_image_set_icon_size (priv->avatar_image, GTK_ICON_SIZE_LARGE);
    }
  else
    gtk_image_set_from_pixbuf (priv->avatar_image, avatar_pixbuf_other);

}
void
um_password_dialog_set_user (UmPasswordDialog *um,
                             ActUser          *user)
{
        gboolean visible;

        if (um->user) {
                g_object_unref (um->user);
                um->user = NULL;
        }
        if (user) {
                um->user = g_object_ref (user);

                gtk_entry_set_text (GTK_ENTRY (um->password_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->verify_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->old_password_entry), "");

                gtk_entry_set_visibility (GTK_ENTRY (um->password_entry), FALSE);
                gtk_entry_set_visibility (GTK_ENTRY (um->verify_entry), FALSE);

                if (act_user_get_uid (um->user) == getuid ()) {
                        mode_change (um, ACT_USER_PASSWORD_MODE_REGULAR);
                        gtk_widget_hide (um->action_radio_box);

                        visible = (act_user_get_password_mode (user) != ACT_USER_PASSWORD_MODE_NONE);
                        gtk_widget_set_visible (um->old_password_label, visible);
                        gtk_widget_set_visible (um->old_password_entry, visible);
                        um->old_password_ok = !visible;
                }
                else {
                        mode_change (um, ACT_USER_PASSWORD_MODE_SET_AT_LOGIN);
                        gtk_widget_show (um->action_radio_box);

                        gtk_widget_hide (um->old_password_label);
                        gtk_widget_hide (um->old_password_entry);
                        um->old_password_ok = TRUE;
                }
                if (act_user_get_uid (um->user) == getuid()) {
                        if (um->passwd_handler != NULL)
                                passwd_destroy (um->passwd_handler);
                        um->passwd_handler = passwd_init ();
                }
        }
}
Example #6
0
static void
gcm_picker_sensor_client_setup_ui (GcmPickerPrivate *priv)
{
	gboolean ret = FALSE;
	GtkWidget *widget;
	g_autoptr(GError) error = NULL;
	g_autoptr(GPtrArray) sensors;

	/* no present */
	sensors = cd_client_get_sensors_sync (priv->client, NULL, &error);
	if (sensors == NULL) {
		g_warning ("%s", error->message);
		goto out;
	}
	if (sensors->len == 0) {
		gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label),
				    /* TRANSLATORS: this is displayed the user has not got suitable hardware */
				    _("No colorimeter is attached."));
		goto out;
	}
	priv->sensor = g_object_ref (g_ptr_array_index (sensors, 0));

	/* connect to the profile */
	ret = cd_sensor_connect_sync (priv->sensor, NULL, &error);
	if (!ret) {
		g_warning ("failed to connect to sensor: %s",
			   error->message);
		goto out;
	}

	if (!cd_sensor_get_native (priv->sensor)) {
		gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label),
				     /* TRANSLATORS: this is displayed if VTE support is not enabled */
				     _("The sensor has no native driver."));
		goto out;
	}

#if 0
	/* no support */
	ret = cd_sensor_supports_spot (priv->sensor);
	if (!ret) {
		/* TRANSLATORS: this is displayed the user has not got suitable hardware */
		gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label), _("The attached colorimeter is not capable of reading a spot color."));
		goto out;
	}
#else
	ret = TRUE;
#endif

out:
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_measure"));
	gtk_widget_set_sensitive (widget, ret);
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "expander_results"));
	gtk_widget_set_sensitive (widget, ret && priv->done_measure);
	gtk_widget_set_visible (priv->info_bar_hardware, !ret);
}
Example #7
0
static void
ch_assemble_set_color (ChAssemblePrivate *priv,
                       gdouble red,
                       gdouble green,
                       gdouble blue)
{
    CdColorRGB color;

    /* set color */
    color.R = red;
    color.G = green;
    color.B = blue;
    cd_sample_widget_set_color (priv->sample_widget, &color);

    /* force redraw */
    gtk_widget_set_visible (GTK_WIDGET (priv->sample_widget), FALSE);
    gtk_widget_set_visible (GTK_WIDGET (priv->sample_widget), TRUE);

}
Example #8
0
/**
 * gtk_search_bar_set_show_close_button:
 * @bar: a #GtkSearchBar
 * @visible: whether the close button will be shown or not
 *
 * Shows or hides the close button. Applications that
 * already have a "search" toggle button should not show a close
 * button in their search bar, as it duplicates the role of the
 * toggle button.
 *
 * Since: 3.10
 */
void
gtk_search_bar_set_show_close_button (GtkSearchBar *bar,
                                      gboolean      visible)
{
  GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);

  g_return_if_fail (GTK_IS_SEARCH_BAR (bar));

  gtk_widget_set_visible (priv->close_button, visible);
}
Example #9
0
static void
toolbar_update_appearance (NautilusToolbar *self)
{
	gboolean show_location_entry;

	show_location_entry = self->priv->show_location_entry ||
		g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY);

	gtk_widget_set_visible (self->priv->toolbar,
				self->priv->show_main_bar);

	gtk_widget_set_visible (self->priv->location_bar,
				show_location_entry);
	gtk_widget_set_visible (self->priv->path_bar,
				!show_location_entry);

	gtk_widget_set_visible (self->priv->search_bar,
				self->priv->show_search_bar);
}
static void
_list_preferences_dialog_hide_failure(GtkWidget *dialog)
{
	_ListPreferencesWindowData *windata;

	g_assert(GTK_IS_DELETABLE_DIALOG(dialog));

	windata = (_ListPreferencesWindowData *)g_object_get_data(G_OBJECT(dialog), "windata");
	gtk_widget_set_visible(windata->label_failure, FALSE);
}
Example #11
0
void linphone_gtk_enable_hold_button(LinphoneCall *call, gboolean sensitive, gboolean holdon) {
    GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer (call);
    GtkWidget *button;
    g_return_if_fail(callview!=NULL);
    linphone_gtk_call_update_tab_header(call,!holdon);
    button=linphone_gtk_get_widget(callview,"hold_call");
    gtk_widget_set_sensitive(GTK_WIDGET(button),sensitive);
    gtk_widget_set_visible(GTK_WIDGET(button),sensitive);
    linphone_gtk_draw_hold_button(GTK_BUTTON(button),!holdon);
}
Example #12
0
void MainWindow::setSidebarVisible(bool visible) {
	XOJ_CHECK_TYPE(MainWindow);

	GtkWidget * sidebar = get("sidebarContents");
	gtk_widget_set_visible(sidebar, visible);
	control->getSettings()->setSidebarVisible(visible);

	GtkWidget * w = get("menuViewSidebarVisible");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), visible);
}
Example #13
0
void
gimp_toggle_button_set_visible (GtkToggleButton *toggle,
                                GtkWidget       *widget)
{
  g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle));
  g_return_if_fail (GTK_IS_WIDGET (widget));

  gtk_widget_set_visible (widget,
                          gtk_toggle_button_get_active (toggle));
}
static void
update_preview (CcBackgroundPanelPrivate *priv,
                GSettings                *settings,
                CcBackgroundItem         *item)
{
  gboolean changes_with_time;
  CcBackgroundItem *current_background;

  current_background = CURRENT_BG;

  if (item && current_background)
    {
      g_object_unref (current_background);
      current_background = cc_background_item_copy (item);
      if (settings == priv->settings)
        priv->current_background = current_background;
      else
        priv->current_lock_background = current_background;
      cc_background_item_load (current_background, NULL);
    }

  changes_with_time = FALSE;

  if (current_background)
    {
      changes_with_time = cc_background_item_changes_with_time (current_background);
    }

  if (settings == priv->settings)
    {
      gtk_widget_set_visible (WID ("slide_image"), changes_with_time);
      gtk_widget_set_visible (WID ("slide-label"), changes_with_time);

      gtk_widget_queue_draw (WID ("background-desktop-drawingarea"));
    }
  else
    {
      gtk_widget_set_visible (WID ("slide_image1"), changes_with_time);
      gtk_widget_set_visible (WID ("slide-label1"), changes_with_time);

      gtk_widget_queue_draw (WID ("background-lock-drawingarea"));
    }
}
Example #15
0
static void operator_callback(GtkWidget *combobox, gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  dt_iop_global_tonemap_gui_data_t *g = (dt_iop_global_tonemap_gui_data_t *)self->gui_data;
  if(self->dt->gui->reset) return;
  dt_iop_global_tonemap_params_t *p = (dt_iop_global_tonemap_params_t *)self->params;
  p->operator= dt_bauhaus_combobox_get(combobox);

  gtk_widget_set_visible(g->drago.bias, FALSE);
  gtk_widget_set_visible(g->drago.max_light, FALSE);
  /* show ui for selected operator */
  if(p->operator== OPERATOR_DRAGO)
  {
    gtk_widget_set_visible(g->drago.bias, TRUE);
    gtk_widget_set_visible(g->drago.max_light, TRUE);
  }

  dt_dev_add_history_item(darktable.develop, self, TRUE);
}
Example #16
0
void
on_selection_toggle_button_toggled (GtkToggleButton *togglebutton,
                                    gpointer         user_data)
{
    return;

    FsearchApplicationWindow *self = (FsearchApplicationWindow *)user_data;
    g_assert (FSEARCH_WINDOW_IS_WINDOW (self));
    gtk_widget_set_visible (self->selection_popover,
                            gtk_toggle_button_get_active (togglebutton));
}
Example #17
0
static void
gtk_color_editor_set_use_alpha (GtkColorEditor *editor,
                                gboolean        use_alpha)
{
  if (editor->priv->use_alpha != use_alpha)
    {
      editor->priv->use_alpha = use_alpha;
      gtk_widget_set_visible (editor->priv->a_slider, use_alpha);
      gtk_color_swatch_set_use_alpha (GTK_COLOR_SWATCH (editor->priv->swatch), use_alpha);
    }
}
Example #18
0
void
egg_search_bar_set_show_close_button (EggSearchBar *self,
                                      gboolean      show_close_button)
{
  EggSearchBarPrivate *priv = egg_search_bar_get_instance_private (self);

  g_return_if_fail (EGG_IS_SEARCH_BAR (self));

  gtk_widget_set_visible (GTK_WIDGET (priv->close_button), show_close_button);
  g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_CLOSE_BUTTON]);
}
/*
 *	helpers:
 */
static void
_list_preferences_dialog_show_failure(GtkWidget *dialog, const gchar *message)
{
	_ListPreferencesWindowData *windata;

	g_assert(GTK_IS_DELETABLE_DIALOG(dialog));

	windata = (_ListPreferencesWindowData *)g_object_get_data(G_OBJECT(dialog), "windata");
	gtk_widget_set_visible(windata->label_failure, TRUE);
	gtk_label_set_text(GTK_LABEL(windata->label_failure), message);
}
static void
glade_recent_chooser_editor_load (GladeEditable *editable,
				  GladeWidget   *gwidget)
{
  GladeRecentChooserEditor *recent_editor = GLADE_RECENT_CHOOSER_EDITOR (editable);
  GladeRecentChooserEditorPrivate *priv = recent_editor->priv;

  /* Chain up to default implementation */
  parent_editable_iface->load (editable, gwidget);

  if (gwidget)
    {
      GObject *object = glade_widget_get_object (gwidget);
      gboolean has_show_numbers = (GTK_IS_RECENT_ACTION (object) || GTK_IS_RECENT_CHOOSER_MENU (object));

      /* Update subclass specific editor visibility */
      gtk_widget_set_visible (priv->select_multiple_editor, !has_show_numbers);
      gtk_widget_set_visible (priv->show_numbers_editor, has_show_numbers);
    }
}
Example #21
0
void ghb_show_hide_advanced_video( signal_user_data_t *ud )
{
    gboolean hide;

    hide = ghb_settings_get_boolean(ud->prefs, "HideAdvancedVideoSettings");
    if (hide)
    {
        ghb_ui_update(ud, "x264UseAdvancedOptions", ghb_boolean_value(FALSE));
    }

    GtkWidget *widget;
    GtkWidget *nb = GHB_WIDGET(ud->builder, "SettingsNotebook");
    GtkWidget *at = GHB_WIDGET(ud->builder, "advanced_tab");
    int pgn = gtk_notebook_page_num(GTK_NOTEBOOK(nb), at);

    widget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb), pgn);
    gtk_widget_set_visible(widget, !hide);
    widget = GHB_WIDGET(ud->builder, "x264UseAdvancedOptions");
    gtk_widget_set_visible(widget, !hide);
}
Example #22
0
void gui_update(dt_iop_module_t *self)
{
  self->request_color_pick = DT_REQUEST_COLORPICK_OFF;

  dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;

  gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE);
  dtgtk_reset_label_set_text(g->label, _("color of film material"));

  gui_update_from_coeffs(self);
}
Example #23
0
static void
gcal_event_widget_set_event_internal (GcalEventWidget *self,
                                      GcalEvent       *event)
{
  g_autofree gchar *hour_str = NULL;

  /*
   * This function is called only once, since the property is
   * set as CONSTRUCT_ONLY. Any other attempt to set an event
   * will be ignored.
   *
   * Because of that condition, we don't really have to care about
   * disconnecting functions or cleaning up the previous event.
   */

  /* The event spawns with a floating reference, and we take it's ownership */
  g_set_object (&self->event, event);

  /*
   * Initially, the widget's start and end dates are the same
   * of the event's ones. We may change it afterwards.
   */
  gcal_event_widget_set_date_start (self, gcal_event_get_date_start (event));
  gcal_event_widget_set_date_end (self, gcal_event_get_date_end (event));

  /* Update color */
  update_color (self);

  g_signal_connect_swapped (event,
                            "notify::color",
                            G_CALLBACK (update_color),
                            self);

  g_signal_connect_swapped (event,
                            "notify::summary",
                            G_CALLBACK (gtk_widget_queue_draw),
                            self);

  /* Tooltip */
  gcal_event_widget_set_event_tooltip (self, event);

  /* Hour label */
  hour_str = get_hour_label (self);

  gtk_widget_set_visible (self->hour_label, !gcal_event_get_all_day (event));
  gtk_label_set_label (GTK_LABEL (self->hour_label), hour_str);

  /* Summary label */
  g_object_bind_property (event,
                          "summary",
                          self->summary_label,
                          "label",
                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
}
static void
device_changed (GsdDeviceManager *device_manager,
		GsdDevice *device,
		CcMousePropertiesPrivate *d)
{
	d->have_touchpad = have_device_type (d->device_manager, GSD_DEVICE_TYPE_TOUCHPAD);
	gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad);

	if (d->have_touchpad) {
		d->changing_scroll = TRUE;
		synaptics_check_capabilities (d);
		setup_scrollmethod_radios (d);
		d->changing_scroll = FALSE;
	}

	d->have_mouse = have_device_type (d->device_manager, GSD_DEVICE_TYPE_MOUSE);
	gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse);
	gtk_widget_set_visible (WID ("touchpad_enabled_switch"), 
				show_touchpad_enabling_switch (d));
}
static void
device_changed (GdkDeviceManager *device_manager,
		GdkDevice        *device,
		GtkBuilder       *dialog)
{
	gboolean present;

	present = touchpad_is_present ();
	gtk_widget_set_visible (WID ("touchpad_vbox"), present);

	if (present) {
		changing_scroll = TRUE;
		synaptics_check_capabilities (dialog);
		setup_scrollmethod_radios (dialog);
		changing_scroll = FALSE;
	}

	present = mouse_is_present ();
	gtk_widget_set_visible (WID ("mouse_vbox"), present);
}
Example #26
0
void infoscreengui_set_message (GuInfoscreenGui *is, const gchar *msg) {
    gtk_widget_set_visible (GTK_WIDGET(is->image), TRUE);
    if (STR_EQU (msg, "compile_error")) {
        gtk_label_set_text (is->header, get_infoheader(1));
        gtk_label_set_text (is->details, get_infodetails(1));
    }
    else if (STR_EQU (msg, "document_error")) {
        gtk_label_set_text (is->header, get_infoheader(2));
        gtk_label_set_text (is->details, get_infodetails(2));
    }
    else if (STR_EQU (msg, "program_error")) {
        gtk_label_set_text (is->header, get_infoheader(3));
        gtk_label_set_text (is->details, get_infodetails(3));
    }
    else {
        gtk_label_set_text (is->header, get_infoheader(4));
        gtk_label_set_text (is->details, get_infodetails(4));
        gtk_widget_set_visible (GTK_WIDGET(is->image), FALSE);
    }
}
Example #27
0
void
gd_notification_set_show_close_button (GdNotification *notification,
                                       gboolean show_close_button)
{
  GdNotificationPrivate *priv = notification->priv;

  priv->show_close_button = show_close_button;

  gtk_widget_set_visible (priv->close_button, show_close_button);
  gtk_widget_queue_resize (GTK_WIDGET (notification));
}
/**
 * mcm_calibrate_dialog_pop:
 **/
void
mcm_calibrate_dialog_pop (McmCalibrateDialog *calibrate_dialog)
{
	McmCalibrateDialogPrivate *priv = calibrate_dialog->priv;
	GtkWidget *widget;
	gchar *text;
	guint len;
	McmCalibrateDialogItem *dialog;

	/* save in case we need to reuse */
	len = priv->cached_dialogs->len;
	if (len < 2) {
		egg_warning ("cannot pop dialog as nothing to recover");
		return;
	}
	dialog = g_ptr_array_index (priv->cached_dialogs, len-2);

	/* set the text */
	text = g_strdup_printf ("<big><b>%s</b></big>", dialog->title);
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "label_title"));
	gtk_label_set_markup (GTK_LABEL(widget), text);
	g_free (text);

	/* set the text */
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "label_message"));
	gtk_label_set_markup (GTK_LABEL(widget), dialog->message);

	/* show the okay button */
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_ok"));
	gtk_widget_set_visible (widget, dialog->show_okay);

	/* show the expander */
	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "expander_details"));
	gtk_widget_set_visible (widget, dialog->show_expander);

	/* show the correct image */
	mcm_calibrate_dialog_set_image_filename_private (calibrate_dialog, dialog->image_filename);

	/* remove from the stack */
	g_ptr_array_remove_index (priv->cached_dialogs, len-1);
}
Example #29
0
static void
subtitle_update_pref_lang(signal_user_data_t *ud, const iso639_lang_t *lang)
{
    GtkLabel *label;
    GtkButton *button;
    gchar *str;
    const char * name = _("None");
    const char * code = "und";

    label = GTK_LABEL(GHB_WIDGET(ud->builder, "subtitle_preferred_language"));
    if (lang != NULL)
    {
        code = lang->iso639_2;
        if (strncmp(code, "und", 4))
        {
            name = lang->native_name && lang->native_name[0] ?
                                lang->native_name : lang->eng_name;
        }
    }

    str = g_strdup_printf(_("Preferred Language: %s"), name);
    gtk_label_set_text(label, str);
    g_free(str);

    ghb_settings_set_string(ud->settings, "PreferredLanguage", code);

    button = GTK_BUTTON(GHB_WIDGET(ud->builder,
                                  "SubtitleAddForeignAudioSubtitle"));
    str = g_strdup_printf(_("Add %s subtitle track if default audio is not %s"),
                          name, name);
    gtk_button_set_label(button, str);
    g_free(str);

    // If there is no preferred language, hide options that require
    // a preferred language to be set.
    gboolean visible = !(lang == NULL || !strncmp(code, "und", 4));
    gtk_widget_set_visible(GTK_WIDGET(button), visible);
    button = GTK_BUTTON(GHB_WIDGET(ud->builder,
                                  "SubtitleAddForeignAudioSearch"));
    gtk_widget_set_visible(GTK_WIDGET(button), visible);
}
Example #30
0
/**
 * show alert/error message
 *
 * @param message printable text that will be presented to the user
 */
void ui_log_alert_show(
        char *message,
        ...)
{
        /* just hide when message is NULL */
        if(!message)
        {
                gtk_widget_set_visible(GTK_WIDGET(UI("alert_dialog")), FALSE);
                return;
        }

        /* allocate mem to build message */
        char *tmp;
        if(!(tmp = alloca(MAX_MSG_SIZE)))
        {
                NFT_LOG_PERROR("alloca");
                return;
        }

        /* build message */
        va_list ap;
        va_start(ap, message);

        /* print log-string */
        if(vsnprintf((char *) tmp, MAX_MSG_SIZE, message, ap) < 0)
        {
                NFT_LOG_PERROR("vsnprintf");
                return;
        }

        va_end(ap);

        /* putout message through niftyled log mechanism also */
        NFT_LOG(L_ERROR, "%s", tmp);

        /* set message */
        gtk_label_set_text(GTK_LABEL(UI("alert_label")), tmp);

        /* show dialog */
        gtk_widget_set_visible(GTK_WIDGET(UI("alert_dialog")), TRUE);
}