Пример #1
0
void
ide_workbench_set_visible_perspective (IdeWorkbench   *self,
                                       IdePerspective *perspective)
{
  GActionGroup *actions;
  GtkStack *stack;
  gchar *id;

  g_return_if_fail (IDE_IS_WORKBENCH (self));
  g_return_if_fail (IDE_IS_PERSPECTIVE (perspective));

  stack = GTK_STACK (gtk_widget_get_ancestor (GTK_WIDGET (perspective), GTK_TYPE_STACK));

  id = ide_perspective_get_id (perspective);

  if (!ide_str_equal0 (gtk_stack_get_visible_child_name (stack), id))
    {
      gtk_stack_set_visible_child_name (stack, id);
      gtk_stack_set_visible_child_name (self->titlebar_stack, id);
    }

  g_free (id);

  actions = ide_perspective_get_actions (perspective);
  gtk_widget_insert_action_group (GTK_WIDGET (self), "perspective", actions);

  if ((stack == self->perspectives_stack) &&
      !ide_str_equal0 (gtk_stack_get_visible_child_name (self->top_stack), "perspectives"))
    {
      gtk_stack_set_visible_child_name (self->top_stack, "perspectives");
      g_timeout_add (1000 + gtk_stack_get_transition_duration (self->top_stack),
                     remove_early_perspectives,
                     g_object_ref (self));
    }
}
Пример #2
0
static void
gb_slider_add_child (GtkBuildable *buildable,
                     GtkBuilder   *builder,
                     GObject      *child,
                     const gchar  *type)
{
  GbSliderPosition position = GB_SLIDER_NONE;

  g_assert (GTK_IS_BUILDABLE (buildable));
  g_assert (GTK_IS_BUILDER (builder));
  g_assert (G_IS_OBJECT (child));

  if (!GTK_IS_WIDGET (child))
    {
      g_warning ("Child \"%s\" must be of type GtkWidget.",
                 g_type_name (G_OBJECT_TYPE (child)));
      return;
    }

  if (ide_str_equal0 (type, "bottom"))
    position = GB_SLIDER_BOTTOM;
  else if (ide_str_equal0 (type, "top"))
    position = GB_SLIDER_TOP;
  else if (ide_str_equal0 (type, "left"))
    position = GB_SLIDER_LEFT;
  else if (ide_str_equal0 (type, "right"))
    position = GB_SLIDER_RIGHT;

  gtk_container_add_with_properties (GTK_CONTAINER (buildable), GTK_WIDGET (child),
                                     "position", position,
                                     NULL);
}
static gboolean
looks_like_makefile (IdeBuffer *buffer)
{
  GtkSourceLanguage *language;
  const gchar *path;
  IdeFile *file;

  g_assert (IDE_IS_BUFFER (buffer));

  file = ide_buffer_get_file (buffer);
  path = ide_file_get_path (file);

  if (path != NULL)
    {
      if (g_str_has_suffix (path, "Makefile.am") || g_str_has_suffix (path, ".mk"))
        return TRUE;
    }

  language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer));

  if (language != NULL)
    {
      const gchar *lang_id;

      lang_id = gtk_source_language_get_id (language);

      if (ide_str_equal0 (lang_id, "automake") || ide_str_equal0 (lang_id, "makefile"))
        return TRUE;
    }

  return FALSE;
}
Пример #4
0
void
ide_application_actions_update (IdeApplication *self)
{
  GList *windows;
  GAction *action;
  gboolean enabled;

  g_assert (IDE_IS_APPLICATION (self));

  /*
   * We only enable the preferences action if we have a workbench open
   * that is past the greeter.
   */
  action = g_action_map_lookup_action (G_ACTION_MAP (self), "preferences");
  enabled = FALSE;
  for (windows = gtk_application_get_windows (GTK_APPLICATION (self));
       windows != NULL;
       windows = windows->next)
    {
      GtkWindow *window = windows->data;

      if (IDE_IS_WORKBENCH (window) &&
          !ide_str_equal0 ("greeter",
                           ide_workbench_get_visible_perspective_name (IDE_WORKBENCH (window))))
        {
          enabled = TRUE;
          break;
        }
    }
  g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);
}
Пример #5
0
static gboolean
find_child_node (IdeTree     *tree,
                 IdeTreeNode *node,
                 IdeTreeNode *child,
                 gpointer    user_data)
{
  const gchar *name = user_data;
  GObject *item;

  g_assert (IDE_IS_TREE (tree));
  g_assert (IDE_IS_TREE_NODE (node));
  g_assert (IDE_IS_TREE_NODE (child));

  item = ide_tree_node_get_item (child);

  if (GB_IS_PROJECT_FILE (item))
    {
      const gchar *item_name;

      item_name = gb_project_file_get_display_name (GB_PROJECT_FILE (item));

      return ide_str_equal0 (item_name, name);
    }

  return FALSE;
}
static void
ide_preferences_builtin_register_languages (IdePreferences *preferences)
{
  GtkSourceLanguageManager *manager;
  const gchar * const *language_ids;
  g_autoptr(GHashTable) sections = NULL;
  guint section_count = 0;
  gint i;

  sections = g_hash_table_new (g_str_hash, g_str_equal);

  ide_preferences_add_page (preferences, "languages", _("Programming Languages"), 200);

  manager = gtk_source_language_manager_get_default ();
  language_ids = gtk_source_language_manager_get_language_ids (manager);

  for (i = 0; language_ids [i]; i++)
    {
      IdePreferencesLanguageRow *row;
      GtkSourceLanguage *language;
      const gchar *name;
      const gchar *section;

      if (ide_str_equal0 (language_ids [i], "def"))
        continue;

      language = gtk_source_language_manager_get_language (manager, language_ids [i]);
      name = gtk_source_language_get_name (language);
      section = gtk_source_language_get_section (language);

      if (!g_hash_table_contains (sections, section))
        {
          ide_preferences_add_list_group (preferences, "languages",
                                          section, section, section_count++);
          g_hash_table_insert (sections, (gchar *)section, NULL);
        }

      row = g_object_new (IDE_TYPE_PREFERENCES_LANGUAGE_ROW,
                          "id", language_ids [i],
                          "title", name,
                          "visible", TRUE,
                          NULL);
      ide_preferences_add_custom (preferences, "languages", section, GTK_WIDGET (row), NULL, 0);
    }

  ide_preferences_add_page (preferences, "languages.id", NULL, 0);

  ide_preferences_add_list_group (preferences, "languages.id", "basic", NULL, 0);
  ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "trim-trailing-whitespace", "/org/gnome/builder/editor/language/{id}/", NULL, _("Trim trailing whitespace"), _("Upon saving, trailing whitespace from modified lines will be trimmed."), NULL, 10);
  ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "overwrite-braces", "/org/gnome/builder/editor/language/{id}/", NULL, _("Overwrite Braces"), _("Overwrite closing braces"), NULL, 20);

  ide_preferences_add_list_group (preferences, "languages.id", "margin", _("Margins"), 0);
  ide_preferences_add_radio (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "show-right-margin", "/org/gnome/builder/editor/language/{id}/", NULL, _("Show right margin"), NULL, NULL, 0);
  ide_preferences_add_spin_button (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "right-margin-position", "/org/gnome/builder/editor/language/{id}/", _("Right margin position"), _("Position in spaces for the right margin"), NULL, 10);

  ide_preferences_add_list_group (preferences, "languages.id", "indentation", _("Indentation"), 100);
  ide_preferences_add_spin_button (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "tab-width", "/org/gnome/builder/editor/language/{id}/", _("Tab width"), _("Width of a tab character in spaces"), NULL, 10);
  ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "insert-spaces-instead-of-tabs", "/org/gnome/builder/editor/language/{id}/", NULL, _("Insert spaces instead of tabs"), _("Prefer spaces over use of tabs"), NULL, 20);
  ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "auto-indent", "/org/gnome/builder/editor/language/{id}/", NULL, _("Automatically indent"), _("Indent source code as you type"), NULL, 30);
}
static inline gboolean
too_similar (const IdeCtagsIndexEntry *a,
             const IdeCtagsIndexEntry *b)
{
  if (a->kind == b->kind)
    {
      if (ide_str_equal0 (a->name, b->name))
        return TRUE;
    }

  return FALSE;
}
Пример #8
0
static void
ide_doap_set_homepage (IdeDoap     *self,
                       const gchar *homepage)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->homepage, homepage))
    {
      g_free (self->homepage);
      self->homepage = g_strdup (homepage);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_HOMEPAGE]);
    }
}
Пример #9
0
static void
ide_doap_set_bug_database (IdeDoap     *self,
                           const gchar *bug_database)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->bug_database, bug_database))
    {
      g_free (self->bug_database);
      self->bug_database = g_strdup (bug_database);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_BUG_DATABASE]);
    }
}
Пример #10
0
static void
ide_doap_set_shortdesc (IdeDoap     *self,
                        const gchar *shortdesc)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->shortdesc, shortdesc))
    {
      g_free (self->shortdesc);
      self->shortdesc = g_strdelimit (g_strdup (shortdesc), "\n", ' ');
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHORTDESC]);
    }
}
Пример #11
0
void
ide_project_info_set_name (IdeProjectInfo *self,
                           const gchar    *name)
{
  g_return_if_fail (IDE_IS_PROJECT_INFO (self));

  if (!ide_str_equal0 (self->name, name))
    {
      g_free (self->name);
      self->name = g_strdup (name);
      g_object_notify_by_pspec (G_OBJECT (self), gParamSpecs [PROP_NAME]);
    }
}
Пример #12
0
static void
ide_doap_set_download_page (IdeDoap     *self,
                            const gchar *download_page)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->download_page, download_page))
    {
      g_free (self->download_page);
      self->download_page = g_strdup (download_page);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_DOWNLOAD_PAGE]);
    }
}
Пример #13
0
static void
ide_doap_set_name (IdeDoap     *self,
                   const gchar *name)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->name, name))
    {
      g_free (self->name);
      self->name = g_strdup (name);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_NAME]);
    }
}
Пример #14
0
static void
ide_doap_set_description (IdeDoap     *self,
                          const gchar *description)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->description, description))
    {
      g_free (self->description);
      self->description = g_strdup (description);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_DESCRIPTION]);
    }
}
Пример #15
0
static void
ide_doap_set_category (IdeDoap     *self,
                       const gchar *category)
{
  g_return_if_fail (IDE_IS_DOAP (self));

  if (!ide_str_equal0 (self->category, category))
    {
      g_free (self->category);
      self->category = g_strdup (category);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_CATEGORY]);
    }
}
Пример #16
0
void
ide_project_info_set_description (IdeProjectInfo *self,
                                  const gchar    *description)
{
  g_return_if_fail (IDE_IS_PROJECT_INFO (self));

  if (!ide_str_equal0 (self->description, description))
    {
      g_free (self->description);
      self->description = g_strdup (description);
      g_object_notify_by_pspec (G_OBJECT (self), gParamSpecs [PROP_DESCRIPTION]);
    }
}
Пример #17
0
static void
ide_settings_set_schema_id (IdeSettings *self,
                            const gchar *schema_id)
{
  g_assert (IDE_IS_SETTINGS (self));
  g_assert (schema_id != NULL);

  if (!ide_str_equal0 (schema_id, self->schema_id))
    {
      g_free (self->schema_id);
      self->schema_id = g_strdup (schema_id);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SCHEMA_ID]);
    }
}
Пример #18
0
static void
ide_application_actions_preferences (GSimpleAction *action,
                                     GVariant      *parameter,
                                     gpointer       user_data)
{
  IdeApplication *self = user_data;
  GList *windows;

  IDE_ENTRY;

  g_assert (IDE_IS_APPLICATION (self));

  /*
   * TODO: Make this work at the greeter screen too.
   */

  windows = gtk_application_get_windows (GTK_APPLICATION (self));

  for (; windows; windows = windows->next)
    {
      GtkWindow *window = windows->data;
      const gchar *name;

      if (!IDE_IS_WORKBENCH (window))
        continue;

      name = ide_workbench_get_visible_perspective_name (IDE_WORKBENCH (window));

      if (!ide_str_equal0 (name, "greeter") && !ide_str_equal0 (name, "genesis"))
        {
          ide_workbench_set_visible_perspective_name (IDE_WORKBENCH (window), "preferences");
          IDE_EXIT;
        }
    }

  IDE_EXIT;
}
static gboolean
is_allowed (const IdeCtagsIndexEntry *entry,
            const gchar * const      *allowed)
{
  if (allowed)
    {
      const gchar *dotptr = strrchr (entry->path, '.');
      gsize i;

      for (i = 0; allowed [i]; i++)
        if (ide_str_equal0 (dotptr, allowed [i]))
          return TRUE;
    }

  return FALSE;
}
Пример #20
0
static void
ide_settings_set_relative_path (IdeSettings *self,
                                const gchar *relative_path)
{
  g_assert (IDE_IS_SETTINGS (self));
  g_assert (relative_path != NULL);

  if (*relative_path == '/')
    relative_path++;

  if (!ide_str_equal0 (relative_path, self->relative_path))
    {
      g_free (self->relative_path);
      self->relative_path = g_strdup (relative_path);
      g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_RELATIVE_PATH]);
    }
}
static void
populate_cache_cb (EggTaskCache  *cache,
                   gconstpointer  key,
                   GTask         *task,
                   gpointer       user_data)
{
  IdeAutotoolsBuildSystem *self = user_data;

  IDE_ENTRY;

  g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
  g_assert (ide_str_equal0 (key, MAKECACHE_KEY));
  g_assert (G_IS_TASK (task));

  ide_autotools_build_system_get_local_makefile_async (self,
                                                       g_task_get_cancellable (task),
                                                       populate_cache__get_local_makefile_cb,
                                                       g_object_ref (task));

  IDE_EXIT;
}
Пример #22
0
void
ide_workbench_set_visible_perspective (IdeWorkbench   *self,
                                       IdePerspective *perspective)
{
  g_autofree gchar *id = NULL;
  GActionGroup *actions = NULL;
  const gchar *current_id;
  GtkWidget *titlebar;
  guint restore_duration = 0;

  g_return_if_fail (IDE_IS_WORKBENCH (self));
  g_return_if_fail (IDE_IS_PERSPECTIVE (perspective));

  /*
   * If we can detect that this is the first transition to the editor,
   * and that our window is not yet displayed, we can avoid the transition
   * duration altogether. This is handy when first opening a window with
   * a project loaded, as used by self->disable_greeter.
   */
  if (self->disable_greeter &&
      IDE_IS_EDITOR_PERSPECTIVE (perspective) &&
      !self->did_initial_editor_transition)
    {
      self->did_initial_editor_transition = TRUE;
      restore_duration = gtk_stack_get_transition_duration (self->perspectives_stack);
      gtk_stack_set_transition_duration (self->perspectives_stack, 0);
    }

  current_id = gtk_stack_get_visible_child_name (self->perspectives_stack);
  id = ide_perspective_get_id (perspective);

  if (!ide_str_equal0 (current_id, id))
    gtk_stack_set_visible_child_name (self->perspectives_stack, id);

  titlebar = gtk_stack_get_child_by_name (self->header_stack, id);

  if (titlebar != NULL)
    gtk_stack_set_visible_child (self->header_stack, titlebar);
  else
    gtk_stack_set_visible_child (self->header_stack, GTK_WIDGET (self->header_bar));

  actions = ide_perspective_get_actions (perspective);
  gtk_widget_insert_action_group (GTK_WIDGET (self), "perspective", actions);

  /*
   * If we are transitioning to the editor the first time, we can
   * remove the early perspectives (greeter, etc).
   */
  if (IDE_IS_EDITOR_PERSPECTIVE (perspective))
    remove_early_perspectives (self);

  gtk_widget_set_visible (GTK_WIDGET (self->perspective_menu_button),
                          !ide_perspective_is_early (perspective));

  if (self->addins != NULL)
    peas_extension_set_foreach (self->addins,
                                ide_workbench_notify_perspective_set,
                                perspective);

  g_clear_object (&actions);

  if (restore_duration != 0)
    gtk_stack_set_transition_duration (self->perspectives_stack, restore_duration);

  /* Notify the application to possibly update actions such
   * as the preferences state.
   */
  ide_application_actions_update (IDE_APPLICATION_DEFAULT);
}
static void
ide_ctags_completion_provider_populate (GtkSourceCompletionProvider *provider,
                                        GtkSourceCompletionContext  *context)
{
  IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider;
  const gchar * const *allowed;
  g_autofree gchar *casefold = NULL;
  gint word_len;
  guint i;
  guint j;

  IDE_ENTRY;

  g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self));
  g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));

  g_clear_pointer (&self->current_word, g_free);
  self->current_word = ide_completion_provider_context_current_word (context);

  allowed = get_allowed_suffixes (context);

  if (self->results != NULL)
    {
      if (ide_completion_results_replay (self->results, self->current_word))
        {
          ide_completion_results_present (self->results, provider, context);
          IDE_EXIT;
        }
      g_clear_pointer (&self->results, g_object_unref);
    }

  word_len = strlen (self->current_word);
  if (word_len < self->minimum_word_size)
    IDE_GOTO (word_too_small);

  casefold = g_utf8_casefold (self->current_word, -1);

  self->results = ide_completion_results_new (self->current_word);

  for (i = 0; i < self->indexes->len; i++)
    {
      g_autofree gchar *copy = g_strdup (self->current_word);
      IdeCtagsIndex *index = g_ptr_array_index (self->indexes, i);
      const IdeCtagsIndexEntry *entries = NULL;
      const gchar *last_name = NULL;
      guint tmp_len = word_len;
      gsize n_entries = 0;

      while (entries == NULL && *copy)
        {
          if (!(entries = ide_ctags_index_lookup_prefix (index, copy, &n_entries)))
            copy [--tmp_len] = '\0';
        }

      if ((entries == NULL) || (n_entries == 0))
        continue;

      for (j = 0; j < n_entries; j++)
        {
          const IdeCtagsIndexEntry *entry = &entries [j];
          IdeCtagsCompletionItem *item;

          if (ide_str_equal0 (entry->name, last_name))
            continue;

          last_name = entry->name;

          if (!ide_ctags_is_allowed (entry, allowed))
            continue;

          item = ide_ctags_completion_item_new (self, entry);

          if (!ide_completion_item_match (IDE_COMPLETION_ITEM (item), self->current_word, casefold))
            {
              g_object_unref (item);
              continue;
            }

          ide_completion_results_take_proposal (self->results, IDE_COMPLETION_ITEM (item));
        }
    }

  ide_completion_results_present (self->results, provider, context);

  IDE_EXIT;

word_too_small:
  gtk_source_completion_context_add_proposals (context, provider, NULL, TRUE);

  IDE_EXIT;
}
Пример #24
0
gboolean
ide_doap_load_from_file (IdeDoap       *self,
                         GFile         *file,
                         GCancellable  *cancellable,
                         GError       **error)
{
  g_autoptr(XmlReader) reader = NULL;

  g_return_val_if_fail (IDE_IS_DOAP (self), FALSE);
  g_return_val_if_fail (G_IS_FILE (file), FALSE);
  g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);

  reader = xml_reader_new ();

  if (!xml_reader_load_from_file (reader, file, cancellable, error))
    return FALSE;

  if (!xml_reader_read_start_element (reader, "Project"))
    {
      g_set_error (error,
                   IDE_DOAP_ERROR,
                   IDE_DOAP_ERROR_INVALID_FORMAT,
                   "Project element is missing from doap.");
      return FALSE;
    }

  g_object_freeze_notify (G_OBJECT (self));

  xml_reader_read (reader);

  do
    {
      const gchar *element_name;

      element_name = xml_reader_get_local_name (reader);

      if (ide_str_equal0 (element_name, "name") ||
          ide_str_equal0 (element_name, "shortdesc") ||
          ide_str_equal0 (element_name, "description"))
        {
          gchar *str;

          str = xml_reader_read_string (reader);
          if (str != NULL)
            g_object_set (self, element_name, g_strstrip (str), NULL);
          g_free (str);
        }
      else if (ide_str_equal0 (element_name, "category") ||
               ide_str_equal0 (element_name, "homepage") ||
               ide_str_equal0 (element_name, "download-page") ||
               ide_str_equal0 (element_name, "bug-database"))
        {
          gchar *str;

          str = xml_reader_get_attribute (reader, "rdf:resource");
          if (str != NULL)
            g_object_set (self, element_name, g_strstrip (str), NULL);
          g_free (str);
        }
      else if (ide_str_equal0 (element_name, "programming-language"))
        {
          gchar *str;

          str = xml_reader_read_string (reader);
          if (!ide_str_empty0 (str))
            ide_doap_add_language (self, g_strstrip (str));
          g_free (str);
        }
      else if (ide_str_equal0 (element_name, "maintainer"))
        {
          if (!ide_doap_parse_maintainer (self, reader))
            break;
        }
    }
  while (xml_reader_read_to_next (reader));

  g_object_thaw_notify (G_OBJECT (self));

  return TRUE;
}
static void
vagrant_status_cb (GbpVagrantRuntimeProvider *self,
                   GAsyncResult              *result,
                   gpointer                   user_data)
{
  g_autoptr(GbpVagrantTable) table = NULL;
  g_autoptr(GbpVagrantRuntime) runtime = NULL;
  g_autoptr(IdeTask) task = user_data;
  g_autoptr(GError) error = NULL;
  GbpVagrantTableIter iter;

  g_assert (GBP_IS_VAGRANT_RUNTIME_PROVIDER (self));
  g_assert (G_IS_ASYNC_RESULT (result));
  g_assert (IDE_IS_TASK (task));

  if (!(table = gbp_vagrant_runtime_provider_command_finish (self, result, &error)))
    {
      ide_task_return_error (task, g_steal_pointer (&error));
      return;
    }

  gbp_vagrant_table_iter_init (&iter, table);

  while (gbp_vagrant_table_iter_next (&iter))
    {
      g_autofree gchar *id = NULL;
      g_autofree gchar *key = NULL;
      g_autofree gchar *val1 = NULL;

      id = gbp_vagrant_table_iter_get_column (&iter, 1);
      key = gbp_vagrant_table_iter_get_column (&iter, 2);
      val1 = gbp_vagrant_table_iter_get_column (&iter, 3);

      if (ide_str_empty0 (id))
        continue;

      if (runtime != NULL)
        {
          const gchar *prev_id = gbp_vagrant_runtime_get_vagrant_id (runtime);

          if (!ide_str_equal0 (id, prev_id))
            {
              gbp_vagrant_runtime_provider_add (self, runtime);
              g_clear_object (&runtime);
            }
        }
      else
        {
          g_autofree gchar *runtime_id = g_strdup_printf ("vagrant:%s", id);

          runtime = g_object_new (GBP_TYPE_VAGRANT_RUNTIME,
                                  "id", runtime_id,
                                  "category", _("Vagrant"),
                                  "name", id,
                                  "vagrant-id", id,
                                  NULL);
        }

      if (ide_str_equal0 (key, "provider-name"))
        gbp_vagrant_runtime_set_provider (runtime, val1);
      else if (ide_str_equal0 (key, "state"))
        gbp_vagrant_runtime_set_state (runtime, val1);
    }

  if (runtime != NULL)
    {
      gbp_vagrant_runtime_provider_add (self, runtime);
      g_clear_object (&runtime);
    }

  ide_task_return_boolean (task, TRUE);
}
static void
ide_preferences_spin_button_connect (IdePreferencesBin *bin,
                                     GSettings         *settings)
{
  IdePreferencesSpinButton *self = (IdePreferencesSpinButton *)bin;
  GSettingsSchema *schema = NULL;
  GSettingsSchemaKey *key = NULL;
  GVariant *range = NULL;
  GVariant *values = NULL;
  GVariant *lower = NULL;
  GVariant *upper = NULL;
  gchar *type = NULL;
  gchar *signal_detail = NULL;
  GtkAdjustment *adj;
  GVariantIter iter;

  g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self));

  self->settings = g_object_ref (settings);

  g_object_get (self->settings, "settings-schema", &schema, NULL);

  adj = gtk_spin_button_get_adjustment (self->spin_button);
  key = g_settings_schema_get_key (schema, self->key);
  range = g_settings_schema_key_get_range (key);

  g_variant_get (range, "(sv)", &type, &values);

  if (!ide_str_equal0 (type, "range") || (2 != g_variant_iter_init (&iter, values)))
    {
      gtk_widget_set_sensitive (GTK_WIDGET (self), FALSE);
      goto cleanup;
    }

  lower = g_variant_iter_next_value (&iter);
  upper = g_variant_iter_next_value (&iter);

  self->type = g_variant_get_type (lower);

  apply_value (adj, lower, "lower");
  apply_value (adj, upper, "upper");

  signal_detail = g_strdup_printf ("changed::%s", self->key);

  self->handler =
    g_signal_connect_object (self->settings,
                             signal_detail,
                             G_CALLBACK (ide_preferences_spin_button_setting_changed),
                             self,
                             G_CONNECT_SWAPPED);

  ide_preferences_spin_button_setting_changed (self, self->key, self->settings);

cleanup:
  g_clear_pointer (&key, g_settings_schema_key_unref);
  g_clear_pointer (&type, g_free);
  g_clear_pointer (&signal_detail, g_free);
  g_clear_pointer (&range, g_variant_unref);
  g_clear_pointer (&values, g_variant_unref);
  g_clear_pointer (&lower, g_variant_unref);
  g_clear_pointer (&upper, g_variant_unref);
  g_clear_pointer (&schema, g_settings_schema_unref);
}
Пример #27
0
static void
ide_editor_frame_update_ruler (IdeEditorFrame *self)
{
  const gchar *mode_display_name;
  const gchar *mode_name;
  GtkTextBuffer *buffer;
  gboolean visible = FALSE;

  g_assert (IDE_IS_EDITOR_FRAME (self));

  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));

  if (!IDE_IS_BUFFER (buffer))
    return;

  /* update line/column text */
  if (self->show_ruler)
    {
      g_autofree gchar *text = NULL;
      guint ln = 0;
      guint col = 0;

      ide_source_view_get_visual_position (self->source_view, &ln, &col);
      text = g_strdup_printf (_("Line %u, Column %u"), ln + 1, col + 1);
      nautilus_floating_bar_set_primary_label (self->floating_bar, text);

      visible = TRUE;
    }
  else
    {
      nautilus_floating_bar_set_primary_label (self->floating_bar, NULL);
    }

  /* update current mode */
  mode_display_name = ide_source_view_get_mode_display_name (self->source_view);
  gtk_label_set_label (self->mode_name_label, mode_display_name);
  gtk_widget_set_visible (GTK_WIDGET (self->mode_name_label), !!mode_display_name);
  if (mode_display_name != NULL)
    visible = TRUE;

  /*
   * Update overwrite label.
   *
   * XXX: Hack for 3.18 to ensure we don't have "OVR Replace" in vim mode.
   */
  mode_name = ide_source_view_get_mode_name (self->source_view);
  if (ide_source_view_get_overwrite (self->source_view) &&
      !ide_str_equal0 (mode_name, "vim-replace"))
    {
      gtk_widget_set_visible (GTK_WIDGET (self->overwrite_label), TRUE);
      visible = TRUE;
    }
  else
    {
      gtk_widget_set_visible (GTK_WIDGET (self->overwrite_label), FALSE);
    }

  if (gtk_widget_get_visible (GTK_WIDGET (self->mode_name_label)))
    visible = TRUE;

  if (ide_buffer_get_busy (IDE_BUFFER (buffer)))
    {
      nautilus_floating_bar_set_show_spinner (self->floating_bar, TRUE);
      visible = TRUE;
    }
  else
    {
      nautilus_floating_bar_set_show_spinner (self->floating_bar, FALSE);
    }

  /* we don't fade while hiding because we likely won't have
   * any text labels set anyway.
   */
  if (!visible && gtk_widget_get_visible (GTK_WIDGET (self->floating_bar)))
    gtk_widget_hide (GTK_WIDGET (self->floating_bar));
  else if (visible && !gtk_widget_get_visible (GTK_WIDGET (self->floating_bar)))
    gtk_widget_show (GTK_WIDGET (self->floating_bar));
}