コード例 #1
1
static GtkWidget *
cc_sharing_panel_new_media_sharing_row (const char     *uri_or_path,
                                        CcSharingPanel *self)
{
  GtkWidget *row, *box, *w;
  GUserDirectory dir = G_USER_N_DIRECTORIES;
  GIcon *icon;
  guint i;
  char *basename, *path;
  GFile *file;

  file = g_file_new_for_commandline_arg (uri_or_path);
  path = g_file_get_path (file);
  g_object_unref (file);

  row = gtk_list_box_row_new ();
  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_container_set_border_width (GTK_CONTAINER (box), 12);
  gtk_container_add (GTK_CONTAINER (row), box);

  /* Find the icon and create it */
  for (i = 0; i < G_USER_N_DIRECTORIES; i++)
    {
      if (g_strcmp0 (path, g_get_user_special_dir (i)) == 0)
        {
          dir = i;
          break;
        }
    }

  icon = special_directory_get_gicon (dir);
  w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU);
  gtk_widget_set_margin_end (w, 12);
  gtk_container_add (GTK_CONTAINER (box), w);
  g_object_unref (icon);

  /* Label */
  basename = g_filename_display_basename (path);
  w = gtk_label_new (basename);
  g_free (basename);
  gtk_container_add (GTK_CONTAINER (box), w);

  /* Remove button */
  w = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE);
  gtk_widget_set_margin_top (w, 3);
  gtk_widget_set_margin_bottom (w, 3);
  gtk_widget_set_margin_end (w, 12);
  gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
  gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
  g_signal_connect (G_OBJECT (w), "clicked",
                    G_CALLBACK (cc_sharing_panel_remove_folder), self);
  g_object_set_data (G_OBJECT (w), "row", row);

  g_object_set_data_full (G_OBJECT (row), "path", g_strdup (path), g_free);

  gtk_widget_show_all (row);

  return row;
}
コード例 #2
0
ファイル: strv-editor.c プロジェクト: GYGit/gtk
static void
add_string (GtkInspectorStrvEditor *editor,
            const gchar            *str)
{
  GtkWidget *box;
  GtkWidget *entry;
  GtkWidget *button;

  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_style_context_add_class (gtk_widget_get_style_context (box), "linked");
  gtk_widget_show (box);

  entry = gtk_entry_new ();
  gtk_entry_set_text (GTK_ENTRY (entry), str);
  gtk_widget_show (entry);
  gtk_box_pack_start (GTK_BOX (box), entry, FALSE, TRUE, 0);
  g_object_set_data (G_OBJECT (box), "entry", entry);
  g_signal_connect_swapped (entry, "notify::text", G_CALLBACK (emit_changed), editor);

  button = gtk_button_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU);
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button");
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (remove_string), editor);

  gtk_box_pack_start (GTK_BOX (editor->box), box, FALSE, FALSE, 0);

  gtk_widget_grab_focus (entry);

  emit_changed (editor);
}
コード例 #3
0
GtkWidget *cd_screenshot_build_options_widget (void)
{
    GtkWidget *pHBox;
    const gchar *cTooltip;
    GtkWidget *pBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, CAIRO_DOCK_GUI_MARGIN);

    cTooltip = D_("in seconds.");
    pHBox = _add_label_in_new_hbox (D_("Delay"), cTooltip, pBox);

    GtkWidget *pScale;
    GtkAdjustment *pAdjustment = gtk_adjustment_new (0,
                                 0,  // min
                                 10,  // max
                                 1,  // step
                                 1,  // step
                                 0);
    pScale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (pAdjustment));
    gtk_scale_set_digits (GTK_SCALE (pScale), 0);
    g_object_set (pScale, "width-request", 100, NULL);
    gldi_dialog_set_widget_text_color (pScale);
    gtk_box_pack_end (GTK_BOX (pHBox), pScale, FALSE, FALSE, _MARGIN);
    g_object_set_data (G_OBJECT (pBox), "delay", pScale);
    gtk_widget_set_tooltip_text (pScale, cTooltip);


    cTooltip = D_("Grab the current window instead of the all screen");
    pHBox = _add_label_in_new_hbox (D_("Grab the current window"), cTooltip, pBox);

    GtkWidget *pCheckButton = gtk_check_button_new ();
    gtk_box_pack_end (GTK_BOX (pHBox), pCheckButton, FALSE, FALSE, _MARGIN);
    g_object_set_data (G_OBJECT (pBox), "current", pCheckButton);
    gtk_widget_set_tooltip_text (pCheckButton, cTooltip);


    cTooltip = D_("Let empty to use the default one.");
    pHBox = _add_label_in_new_hbox (D_("File name"), cTooltip, pBox);

    GtkWidget *pEntry = gtk_entry_new ();
    gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
    g_object_set_data (G_OBJECT (pBox), "name", pEntry);
    gtk_widget_set_tooltip_text (pEntry, cTooltip);


    cTooltip = D_("Let empty to use the default one.");
    pHBox = _add_label_in_new_hbox (D_("Directory"), cTooltip, pBox);

    pEntry = gtk_entry_new ();
    gtk_entry_set_text (GTK_ENTRY (pEntry), myConfig.cDirPath ? myConfig.cDirPath : g_getenv ("HOME"));
    g_object_set_data (G_OBJECT (pBox), "dir", pEntry);
    GtkWidget *pButtonFileChooser = gtk_button_new_from_icon_name (GLDI_ICON_NAME_OPEN, GTK_ICON_SIZE_BUTTON);
    g_signal_connect (G_OBJECT (pButtonFileChooser),
                      "clicked",
                      G_CALLBACK (_cairo_dock_pick_a_file),
                      pEntry);
    gtk_box_pack_end (GTK_BOX (pHBox), pButtonFileChooser, FALSE, FALSE, _MARGIN);
    gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
    gtk_widget_set_tooltip_text (pEntry, cTooltip);

    return pBox;
}
コード例 #4
0
void
nautilus_floating_bar_add_action (NautilusFloatingBar *self,
				  const gchar *icon_name,
				  gint action_id)
{
	GtkWidget *button;
	GtkStyleContext *context;

	button = gtk_button_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
	context = gtk_widget_get_style_context (button);
	gtk_button_set_relief (button, GTK_RELIEF_NONE);
	gtk_style_context_add_class (context, "circular");
	gtk_style_context_add_class (context, "flat");
	gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
	gtk_box_pack_end (GTK_BOX (self), button, FALSE, FALSE, 0);
	gtk_widget_show (button);

	g_object_set_data (G_OBJECT (button), "action-id",
			   GINT_TO_POINTER (action_id));

	g_signal_connect (button, "clicked",
			  G_CALLBACK (action_button_clicked_cb), self);

	self->priv->is_interactive = TRUE;
}
コード例 #5
0
ファイル: window.c プロジェクト: alexlarsson/gtk
static void
gtk_inspector_window_init (GtkInspectorWindow *iw)
{
  GIOExtensionPoint *extension_point;
  GList *l, *extensions;

  gtk_widget_init_template (GTK_WIDGET (iw));

  gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw));

  extension_point = g_io_extension_point_lookup ("gtk-inspector-page");
  extensions = g_io_extension_point_get_extensions (extension_point);

  for (l = extensions; l != NULL; l = l->next)
    {
      GIOExtension *extension = l->data;
      GType type;
      GtkWidget *widget;
      const char *name;
      char *title;
      GtkWidget *button;
      gboolean use_picker;

      type = g_io_extension_get_type (extension);

      widget = g_object_new (type, NULL);

      iw->extra_pages = g_list_prepend (iw->extra_pages, widget);

      name = g_io_extension_get_name (extension);
      g_object_get (widget, "title", &title, NULL);

      if (g_object_class_find_property (G_OBJECT_GET_CLASS (widget), "use-picker"))
        g_object_get (widget, "use-picker", &use_picker, NULL);
      else
        use_picker = FALSE;

      if (use_picker)
        {
          button = gtk_button_new_from_icon_name ("find-location-symbolic",
                                                  GTK_ICON_SIZE_MENU);
          gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
          gtk_widget_set_halign (button, GTK_ALIGN_START);
          gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
          g_signal_connect (button, "clicked",
                            G_CALLBACK (gtk_inspector_on_inspect), iw);
        }
      else
        button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

      gtk_stack_add_titled (GTK_STACK (iw->top_stack), widget, name, title);
      gtk_stack_add_named (GTK_STACK (iw->button_stack), button, name);
      gtk_widget_show (widget);
      gtk_widget_show (button);

      g_free (title);
    }

}
コード例 #6
0
ファイル: gtk-utils.c プロジェクト: Distrotech/file-roller
GtkWidget *
_gtk_image_button_new_for_header_bar (const char *icon_name)
{
	GtkWidget *button;

	button = gtk_button_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
	_gtk_menu_button_set_style_for_header_bar (button);

	return button;
}
コード例 #7
0
static void
example_app_window_init (ExampleAppWindow *win)
{
        gtk_widget_init_template (GTK_WIDGET (win));

        ExampleAppWindowPrivate *priv = example_app_window_get_instance_private (win);
        gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (priv->header), ":");


        priv->open_button = gtk_button_new_from_icon_name ("document-open-symbolic", GTK_ICON_SIZE_BUTTON);
        gtk_widget_set_valign (priv->open_button, GTK_ALIGN_CENTER);

        gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->open_button);
        gtk_widget_show (priv->open_button);
        g_signal_connect (priv->open_button, "clicked", (GCallback) on_open_clicked, win);


        priv->save_button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON);
        gtk_widget_set_valign (priv->save_button, GTK_ALIGN_CENTER);

        gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->save_button);
        gtk_widget_show (priv->save_button);
        g_signal_connect (priv->save_button, "clicked", (GCallback) on_save_clicked, win);


        priv->cancel_button = gtk_button_new_from_icon_name ("process-error-symbolic", GTK_ICON_SIZE_BUTTON);
        gtk_widget_set_valign (priv->cancel_button, GTK_ALIGN_CENTER);

        gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->cancel_button);
        gtk_widget_show (priv->cancel_button);
        g_signal_connect (priv->cancel_button, "clicked", (GCallback) on_cancel_clicked, win);


        priv->destroy_button = gtk_button_new_from_icon_name ("edit-delete-symbolic", GTK_ICON_SIZE_BUTTON);
        gtk_widget_set_valign (priv->destroy_button, GTK_ALIGN_CENTER);

        gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->destroy_button);
        gtk_widget_show (priv->destroy_button);
        g_signal_connect (priv->destroy_button, "clicked", (GCallback) on_destroy_clicked, win);
}
コード例 #8
0
static void
setup_header_bar (GtkWidget   *window,
                  VteTerminal *vtterm,
                  gboolean     show_maximized_title)
{
    /*
     * Using the default GtkHeaderBar title/subtitle widget makes the bar
     * too thick to look nice for a terminal, so set a custom widget.
     */
    GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
    const gchar *title = gtk_window_get_title (GTK_WINDOW (window));
    GtkWidget *label = gtk_label_new (title ? title : "dwt");
    g_object_bind_property (G_OBJECT (vtterm), "window-title",
                            G_OBJECT (label), "label",
                            G_BINDING_DEFAULT);

    GtkWidget *header = gtk_header_bar_new ();
    gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE);
    gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
    gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label);

    GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic",
                                                       GTK_ICON_SIZE_BUTTON);
    gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
    gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal");
    gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);

    GtkWidget *revealer = gtk_revealer_new ();
    gtk_container_add (GTK_CONTAINER (revealer),
                       gtk_image_new_from_icon_name ("software-update-urgent-symbolic",
                                                     GTK_ICON_SIZE_BUTTON));
    gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500);
    gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
                                      GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
    gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer);

    g_signal_connect (G_OBJECT (vtterm), "bell",
                      G_CALLBACK (header_bar_term_beeped), revealer);
    g_object_bind_property (G_OBJECT (window), "urgency-hint",
                            G_OBJECT (revealer), "reveal-child",
                            G_BINDING_DEFAULT);

    gtk_window_set_titlebar (GTK_WINDOW (window), header);

    /* Hide the header bar when the window is maximized. */
    if (!show_maximized_title) {
        g_object_bind_property (G_OBJECT (window), "is-maximized",
                                G_OBJECT (header), "visible",
                                G_BINDING_INVERT_BOOLEAN);
    }
}
コード例 #9
0
static void agreement_app_window_init(AgreementAppWindow *win)
{
    gtk_window_set_title(GTK_WINDOW(win), "Agreement");
    gtk_window_set_default_size(GTK_WINDOW(win), 800, 500);

    GtkWidget* grid;
    grid = gtk_grid_new();
    gtk_container_add(GTK_CONTAINER(win), grid);

    GtkWidget *view;
    view = gtk_text_view_new();
    gtk_widget_set_hexpand(view, true);
    gtk_widget_set_vexpand(view, true);
    gtk_grid_attach(GTK_GRID(grid), view, 0, 0, 1, 1);

    agreement_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
    gtk_text_buffer_set_text(agreement_text_buffer, "No file loaded", -1);

    GtkWidget *flow_box;
    flow_box = gtk_flow_box_new();
    gtk_flow_box_set_min_children_per_line(GTK_FLOW_BOX(flow_box), 2);
    gtk_widget_set_halign(flow_box, GTK_ALIGN_CENTER);
    gtk_grid_attach(GTK_GRID(grid), flow_box, 0, 1, 1, 1);

    GtkWidget *no_button;
    no_button = gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON);
    gtk_button_set_always_show_image(GTK_BUTTON(no_button), true);
    gtk_button_set_label(GTK_BUTTON(no_button), "No, I do not agree");
    gtk_container_add(GTK_CONTAINER(flow_box), no_button);

    GtkWidget *yes_button;
    yes_button = gtk_button_new_from_icon_name("go-next", GTK_ICON_SIZE_BUTTON);
    gtk_button_set_always_show_image(GTK_BUTTON(yes_button), true);
    gtk_button_set_label(GTK_BUTTON(yes_button), "Yes, I agree");
    gtk_container_add(GTK_CONTAINER(flow_box), yes_button);

    gtk_widget_show_all(GTK_WIDGET(win));
}
コード例 #10
0
static SeahorseKeyserverResultsRow*
seahorse_keyserver_results_row_new (GObject *item)
{
    g_autoptr(SeahorseKeyserverResultsRow) row = NULL;
    g_autoptr(GtkWidget) grid = NULL;
    g_autoptr(GtkWidget) label = NULL;
    g_autoptr(GtkWidget) import_button = NULL;
    gchar *item_label;
    gboolean item_exportable;

    g_object_get (item, "markup", &item_label, "exportable", &item_exportable,
                  NULL);

    row = g_object_new (SEAHORSE_TYPE_KEYSERVER_RESULTS_ROW, NULL);
    gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE);
    gtk_widget_set_sensitive (GTK_WIDGET (row), item_exportable);
    gtk_widget_show (GTK_WIDGET (row));
    row->key = item;

    grid = gtk_grid_new ();
    g_object_set (grid, "margin", 6, NULL);
    gtk_widget_show (grid);

    label = gtk_label_new (item_label);
    gtk_widget_set_hexpand (label, TRUE);
    gtk_label_set_xalign (GTK_LABEL (label), 0);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_widget_show (label);
    gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&label), 0, 0, 1, 1);

    import_button = gtk_button_new_from_icon_name ("document-save-symbolic",
                                                   GTK_ICON_SIZE_BUTTON);
    row->import_button = GTK_BUTTON (import_button);
    g_signal_connect_object (import_button, "clicked",
                             G_CALLBACK (on_import_button_clicked), row, 0);
    gtk_widget_set_visible (import_button, TRUE);
    gtk_widget_set_valign (import_button, GTK_ALIGN_START);
    gtk_widget_set_halign (import_button, GTK_ALIGN_END);
    gtk_style_context_add_class (gtk_widget_get_style_context (import_button),
                                 "flat");
    if (item_exportable)
        gtk_widget_set_tooltip_text (import_button, _("Import"));
    else
        gtk_widget_set_tooltip_text (import_button, _("Can’t import key"));
    gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&import_button), 1, 0, 1, 1);

    gtk_container_add (GTK_CONTAINER (row), g_steal_pointer (&grid));

    return g_steal_pointer (&row);
}
コード例 #11
0
ファイル: testnotebookdnd.c プロジェクト: GYGit/gtk
static GtkWidget*
create_notebook_non_dragable_content (gchar           **labels,
                                      const gchar      *group,
                                      GtkPositionType   pos)
{
  GtkWidget *notebook, *title, *page, *action_widget;

  notebook = gtk_notebook_new ();
  gtk_widget_set_vexpand (notebook, TRUE);
  gtk_widget_set_hexpand (notebook, TRUE);

  action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON);
  g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook);
  gtk_widget_show (action_widget);
  gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END);

  g_signal_connect (notebook, "create-window",
                    G_CALLBACK (window_creation_function), NULL);

  gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos);
  gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
  gtk_container_set_border_width (GTK_CONTAINER (notebook), 6);
  gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group);

  while (*labels)
    {
      GtkWidget *button;
      button = gtk_button_new_with_label (*labels);
      /* Use GtkListBox since it bubbles up motion notify event, which can
       * experience more issues than GtkBox. */
      page = gtk_list_box_new ();
      gtk_container_add (GTK_CONTAINER (page), button);

      title = gtk_label_new (*labels);

      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title);
      gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE);
      gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE);

      labels++;
    }

  g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered",
                    G_CALLBACK (on_page_reordered), NULL);
  g_signal_connect_after (G_OBJECT (notebook), "drag-begin",
                          G_CALLBACK (on_notebook_drag_begin), NULL);
  return notebook;
}
コード例 #12
0
ファイル: strv-editor.c プロジェクト: davidyang5405/gtk
static void
gtk_inspector_strv_editor_init (GtkInspectorStrvEditor *editor)
{
  gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), GTK_ORIENTATION_VERTICAL);
  editor->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_widget_show (editor->box);

  editor->button = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU);
  gtk_widget_set_focus_on_click (editor->button, FALSE);
  gtk_widget_set_halign (editor->button, GTK_ALIGN_END);
  gtk_widget_show (editor->button);
  g_signal_connect (editor->button, "clicked", G_CALLBACK (add_cb), editor);

  gtk_box_pack_start (GTK_BOX (editor), editor->box, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (editor), editor->button, FALSE, FALSE, 0);
}
コード例 #13
0
void
cb_compose_images_load_image (CbComposeImages *self,
                              const char      *image_path)
{
  GFile *file;
  GError *error = NULL;
  GdkTexture *texture;
  Image *image;

#if DEBUG
  g_assert (!cb_compose_images_is_full (self));
#endif

  file = g_file_new_for_path (image_path);
  texture = gdk_texture_new_from_file (file, &error);

  if (error != NULL)
    {
      g_warning (G_STRLOC ": Couldn't load image %s: %s",
                 image_path, error->message);
      g_object_unref (file);
      return;
    }

  g_array_set_size (self->images, self->images->len + 1);
  image = &g_array_index (self->images, Image, self->images->len - 1);
  image->path = g_strdup (image_path);
  image->fraction = 0.0;
  image->deleted = FALSE;

  image->image = gtk_image_new_from_paintable (GDK_PAINTABLE (g_steal_pointer (&texture)));
  gtk_image_set_can_shrink (GTK_IMAGE (image->image), TRUE);
  gtk_widget_set_size_request (image->image, -1, MIN_IMAGE_HEIGHT);
  gtk_widget_set_parent (image->image, GTK_WIDGET (self));

  image->delete_button = gtk_button_new_from_icon_name ("window-close-symbolic");
  gtk_style_context_add_class (gtk_widget_get_style_context (image->delete_button), "close-button");
  g_signal_connect (image->delete_button, "clicked", G_CALLBACK (delete_button_clicked_cb), self);
  gtk_widget_set_parent (image->delete_button, GTK_WIDGET (self));

  image->progressbar = gtk_progress_bar_new ();
  gtk_widget_hide (image->progressbar);
  gtk_widget_set_parent (image->progressbar, GTK_WIDGET (self));

  g_object_unref (file);
}
コード例 #14
0
ファイル: testnotebookdnd.c プロジェクト: GYGit/gtk
static GtkWidget*
create_notebook (gchar           **labels,
                 const gchar      *group,
                 GtkPositionType   pos)
{
  GtkWidget *notebook, *title, *page, *action_widget;

  notebook = gtk_notebook_new ();
  gtk_widget_set_vexpand (notebook, TRUE);
  gtk_widget_set_hexpand (notebook, TRUE);

  action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON);
  g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook);
  gtk_widget_show (action_widget);
  gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END);

  g_signal_connect (notebook, "create-window",
                    G_CALLBACK (window_creation_function), NULL);

  gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos);
  gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
  gtk_container_set_border_width (GTK_CONTAINER (notebook), 6);
  gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group);

  while (*labels)
    {
      page = gtk_entry_new ();
      gtk_entry_set_text (GTK_ENTRY (page), *labels);

      title = gtk_label_new (*labels);

      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title);
      gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE);
      gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE);

      labels++;
    }

  g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered",
                    G_CALLBACK (on_page_reordered), NULL);
  g_signal_connect_after (G_OBJECT (notebook), "drag-begin",
                          G_CALLBACK (on_notebook_drag_begin), NULL);
  return notebook;
}
コード例 #15
0
static RemminaPluginSpiceXferWidgets * remmina_plugin_spice_xfer_widgets_new(SpiceFileTransferTask *task)
{
	TRACE_CALL(__func__);

	gchar *filename;
	RemminaPluginSpiceXferWidgets *widgets = g_new0(RemminaPluginSpiceXferWidgets, 1);

	widgets->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
	widgets->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);

	filename = spice_file_transfer_task_get_filename(task);
	widgets->label = gtk_label_new(filename);
	gtk_widget_set_halign(widgets->label, GTK_ALIGN_START);
	gtk_widget_set_valign(widgets->label, GTK_ALIGN_BASELINE);

	widgets->progress = gtk_progress_bar_new();
	gtk_widget_set_hexpand(widgets->progress, TRUE);
	gtk_widget_set_valign(widgets->progress, GTK_ALIGN_CENTER);

	widgets->cancel = gtk_button_new_from_icon_name("gtk-cancel", GTK_ICON_SIZE_SMALL_TOOLBAR);
	g_signal_connect(widgets->cancel,
		"clicked",
		G_CALLBACK(remmina_plugin_spice_file_transfer_cancel_cb),
		task);
	gtk_widget_set_hexpand(widgets->cancel, FALSE);
	gtk_widget_set_valign(widgets->cancel, GTK_ALIGN_CENTER);

	gtk_box_pack_start(GTK_BOX(widgets->hbox), widgets->progress,
		TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(widgets->hbox), widgets->cancel,
		FALSE, TRUE, 0);

	gtk_box_pack_start(GTK_BOX(widgets->vbox), widgets->label,
		TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(widgets->vbox), widgets->hbox,
		TRUE, TRUE, 0);

	gtk_widget_show_all(widgets->vbox);

	g_free(filename);

	return widgets;
}
コード例 #16
0
static void
nemo_action_config_widget_init (NemoActionConfigWidget *self)
{
    self->actions = NULL;

    self->bl_handler = g_signal_connect (nemo_plugin_preferences, 
                                         "changed::" NEMO_PLUGIN_PREFERENCES_DISABLED_ACTIONS,
                                         G_CALLBACK (on_settings_changed), self);

    GtkWidget *label = nemo_config_base_widget_get_label (NEMO_CONFIG_BASE_WIDGET (self));

    gchar *title = g_strdup (_("Actions"));
    gchar *markup = g_strdup_printf ("<b>%s</b>", title);

    gtk_label_set_markup (GTK_LABEL (label), markup);

    g_free (title);
    g_free (markup);

    GtkWidget *widget = gtk_button_new_from_icon_name ("folder", GTK_ICON_SIZE_BUTTON);

    GtkWidget *bb = nemo_config_base_widget_get_buttonbox (NEMO_CONFIG_BASE_WIDGET (self));
    gtk_box_pack_end (GTK_BOX (bb),
                      widget,
                      FALSE, FALSE, 0);
    gtk_widget_show (widget);

    g_signal_connect (widget, "clicked", G_CALLBACK (on_open_folder_clicked), self);

    g_signal_connect (nemo_config_base_widget_get_enable_button (NEMO_CONFIG_BASE_WIDGET (self)), "clicked",
                                                                 G_CALLBACK (on_enable_clicked), self);

    g_signal_connect (nemo_config_base_widget_get_disable_button (NEMO_CONFIG_BASE_WIDGET (self)), "clicked",
                                                                  G_CALLBACK (on_disable_clicked), self);

    g_signal_connect (NEMO_CONFIG_BASE_WIDGET (self)->listbox, "row-activated", G_CALLBACK (on_row_activated), self);

    refresh_widget (self);

    setup_dir_monitors (self);
}
コード例 #17
0
static GtkWidget *
dict_create_word_row (IdeEditorSpellWidget *self,
                      const gchar          *word)
{
  GtkWidget *row;
  GtkWidget *box;
  GtkWidget *label;
  GtkWidget *button;
  GtkStyleContext *style_context;

  g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self));
  g_assert (!ide_str_empty0 (word));

  label = g_object_new (GTK_TYPE_LABEL,
                       "label", word,
                       "halign", GTK_ALIGN_START,
                       NULL);

  button = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_BUTTON);
  gtk_widget_set_can_focus (button, FALSE);
  g_signal_connect_swapped (button,
                            "clicked",
                            G_CALLBACK (dict_close_button_clicked_cb),
                            self);

  style_context = gtk_widget_get_style_context (button);
  gtk_style_context_add_class (style_context, "close");

  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
  gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
  gtk_box_pack_end (GTK_BOX (box), button, FALSE, FALSE, 0);

  row = gtk_list_box_row_new ();
  gtk_container_add (GTK_CONTAINER (row), box);
  g_object_set_data_full (G_OBJECT (row), "word", g_strdup (word), g_free);
  gtk_widget_show_all (row);

  return row;
}
コード例 #18
0
ファイル: aufnehmer.c プロジェクト: Ed-von-Schleck/aufnehmer
static void update_recordings_list(Data* data) {
	GList *children, *iter;
	children = gtk_container_get_children(GTK_CONTAINER(data->recordings_list_box));
	for(iter = children; iter != NULL; iter = g_list_next(iter)) {
		gtk_widget_destroy(GTK_WIDGET(iter->data));
	}
	g_list_free(children);

	if (!g_file_test(data->recordings_dir_path, G_FILE_TEST_IS_DIR)) {
		g_mkdir_with_parents(data->recordings_dir_path, 0666);
	}
	GDir* dir = g_dir_open(data->recordings_dir_path, 0, NULL);
	data->index = 0;
	GtkWidget* inner_box;
	GtkWidget* play_button;

	for (const gchar* filename = g_dir_read_name(dir); filename != NULL; filename = g_dir_read_name(dir)) {
		// only display .mp3 files
		if (strcmp(strrchr(filename, '.'), ".mp3") != 0) {
			continue;
		}
		data->index++;
		inner_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
		play_button = gtk_button_new_from_icon_name("media-playback-start", GTK_ICON_SIZE_BUTTON);
		gtk_button_set_relief(GTK_BUTTON(play_button), GTK_RELIEF_NONE);
		char* full_filename = (char*) malloc((strlen(data->recordings_dir_path) + 1 + strlen(filename)) * sizeof(char));
		sprintf(full_filename, "%s/%s", data->recordings_dir_path, filename);
		g_object_set_data(G_OBJECT(play_button), "full_filename", full_filename);
		g_signal_connect(GTK_BUTTON(play_button), "clicked", G_CALLBACK(on_play_button_clicked), data);

		gtk_box_pack_start(GTK_BOX(inner_box), gtk_label_new(filename), TRUE, TRUE, 0);
		gtk_box_pack_start(GTK_BOX(inner_box), play_button, FALSE, FALSE, 0);
		gtk_container_add(GTK_CONTAINER(data->recordings_list_box), inner_box);
	}
	g_dir_close(dir);
	gtk_widget_show_all(data->recordings_list_box);
}
コード例 #19
0
ファイル: main.c プロジェクト: jetspace/Pilot
int main(int argc, char **argv)
{
  gtk_init(&argc, &argv);

  GtkWidget *win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_container_set_border_width(GTK_CONTAINER(win), 10);
  gtk_window_set_title(GTK_WINDOW(win), "JetSpace Pilot");

  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);

  GtkWidget *inp = gtk_entry_new();
  GtkWidget *button = gtk_button_new_with_label(">");
  v = gtk_button_new_from_icon_name("audio-input-microphone", GTK_ICON_SIZE_BUTTON);

  gtk_box_pack_start(GTK_BOX(box), v, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(box), inp, TRUE, TRUE, 0);
  gtk_box_pack_end(GTK_BOX(box), button, FALSE, FALSE,0);


  mainbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
  gtk_box_pack_start(GTK_BOX(mainbox), box, FALSE, FALSE, 0);



  gtk_container_add(GTK_CONTAINER(win), mainbox);

  gtk_widget_show_all(win);

  //SIGNALS
  g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(quit), NULL);
  g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(trigger), inp);
  g_signal_connect(G_OBJECT(v), "clicked", G_CALLBACK(trigger_voice), inp);


  gtk_main();
  return 0;
}
コード例 #20
0
ファイル: parallel_dialog.c プロジェクト: crosswire/xiphos
/******************************************************************************
 * Name
 *   create_parallel_dialog
 *
 * Synopsis
 *   #include "parallel_dialog.h"
 *
 *   GtkWidget *create_parallel_dialog(void)
 *
 * Description
 *
 *
 *
 * Return value
 *   GtkWidget *
 */
static GtkWidget *create_parallel_dialog(void)
{
	GtkWidget *box_parallel_labels;
	GtkWidget *dialog_vbox25;
	GtkWidget *toolbar29;
	GtkWidget *dialog_action_area25;
	GtkWidget *hbuttonbox4;
	GtkWidget *btnDockInt;
#ifndef USE_WEBKIT2
	GtkWidget *scrolled_window;
#endif
	gchar title[256];

	sprintf(title, "%s - %s", settings.program_title, _("Parallel"));

	dialog_parallel = gtk_dialog_new();
	gtk_window_set_title(GTK_WINDOW(dialog_parallel), title);

	g_object_set_data(G_OBJECT(dialog_parallel),
			  "dialog_parallel", dialog_parallel);
	gtk_window_resize(GTK_WINDOW(dialog_parallel),
			  settings.parallel_width,
			  settings.parallel_height);
	gtk_window_set_resizable(GTK_WINDOW(dialog_parallel), TRUE);

	dialog_vbox25 =
	    gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel));
	g_object_set_data(G_OBJECT(dialog_parallel), "dialog_vbox25",
			  dialog_vbox25);
	gtk_widget_show(dialog_vbox25);

	UI_VBOX(vboxInt, FALSE, 0);
	gtk_widget_show(vboxInt);
	gtk_box_pack_start(GTK_BOX(dialog_vbox25), vboxInt, TRUE, TRUE, 0);
	toolbar29 = create_nav_toolbar();
	gtk_widget_show(toolbar29);
	gtk_box_pack_start(GTK_BOX(vboxInt), toolbar29, FALSE, FALSE, 0);

	UI_HBOX(box_parallel_labels, TRUE, 2);
	gtk_widget_show(box_parallel_labels);
	gtk_box_pack_start(GTK_BOX(vboxInt), box_parallel_labels, FALSE,
			   TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(box_parallel_labels),
				       2);

#if 0
	if (settings.parallel_list) {
		GtkWidget *plabel;
		gchar *label;
		gint modidx;

		for (modidx = 0; settings.parallel_list[modidx]; ++modidx) {
			plabel = gtk_label_new(NULL);
			gtk_widget_show(plabel);
			gtk_box_pack_start(GTK_BOX(box_parallel_labels),
					   plabel, FALSE, FALSE, 0);
			gtk_label_set_use_markup(GTK_LABEL(plabel), TRUE);

			label =
			    g_strdup_printf
			    ("<span color='%s' weight='bold'>%s</span>",
			     settings.bible_verse_num_color,
			     settings.parallel_list[modidx]);
			gtk_label_set_markup(GTK_LABEL(plabel), label);
			g_free(label);
		}
	}
#endif /* 0 */

#ifndef USE_WEBKIT2
	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolled_window);
	gtk_box_pack_start(GTK_BOX(vboxInt), scrolled_window, TRUE, TRUE,
			   0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_ALWAYS);
	gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
					    scrolled_window,
					    settings.shadow_type);
#endif

	widgets.html_parallel_dialog =
	    GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, PARALLEL_TYPE));
	gtk_widget_show(widgets.html_parallel_dialog);
#ifdef USE_WEBKIT2
	gtk_box_pack_start(GTK_BOX(vboxInt), widgets.html_parallel_dialog, TRUE, TRUE, 0);
#else
	gtk_container_add(GTK_CONTAINER(scrolled_window),
			  widgets.html_parallel_dialog);
#endif

	g_signal_connect((gpointer)widgets.html_parallel_dialog,
			 "popupmenu_requested",
			 G_CALLBACK(_popupmenu_requested_cb), NULL);

	dialog_action_area25 =
#ifdef HAVE_GTK_312
	    gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel));
#else
	    gtk_dialog_get_action_area(GTK_DIALOG(dialog_parallel));
#endif
	g_object_set_data(G_OBJECT(dialog_parallel),
			  "dialog_action_area25", dialog_action_area25);
	gtk_widget_show(dialog_action_area25);
	gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area25), 10);

#ifdef USE_GTK_3
	hbuttonbox4 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
	hbuttonbox4 = gtk_hbutton_box_new();
#endif
	gtk_widget_show(hbuttonbox4);

#ifdef HAVE_GTK_312
	gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4,
			   FALSE, TRUE, 3);
#else
	gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4,
			   TRUE, TRUE, 0);
#endif

	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox4),
				  GTK_BUTTONBOX_END);
	btnDockInt =
#ifdef HAVE_GTK_310
	    gtk_button_new_from_icon_name("window-close",
					  GTK_ICON_SIZE_BUTTON);
#else
	    gtk_button_new_from_stock(GTK_STOCK_CLOSE);
#endif
	gtk_widget_show(btnDockInt);
	gtk_container_add(GTK_CONTAINER(hbuttonbox4), btnDockInt);
	gtk_widget_set_can_default(btnDockInt, 1);

	g_signal_connect(G_OBJECT(dialog_parallel), "destroy",
			 G_CALLBACK(on_dlgparallel_destroy), NULL);
	g_signal_connect(G_OBJECT(btnDockInt), "clicked",
			 G_CALLBACK(gui_btnDockInt_clicked), NULL);

	g_signal_connect((gpointer)dialog_parallel,
			 "configure_event",
			 G_CALLBACK(on_parallel_configure_event), NULL);

	settings.display_parallel = 1;
	xml_set_value("Xiphos", "layout", "parallelopen", "1");

	set_window_icon(GTK_WINDOW(dialog_parallel));

	/*
	 * (from xiphos.c)
	 * a little paranoia:
	 * clamp geometry values to a reasonable bound.
	 * sometimes xiphos gets insane reconfig events as it dies,
	 * especially if it's due to just shutting linux down.
	 */
	if ((settings.parallel_x < 0) || (settings.parallel_x > 2000))
		settings.parallel_x = 40;
	if ((settings.parallel_y < 0) || (settings.parallel_y > 2000))
		settings.parallel_y = 40;

	gtk_window_move(GTK_WINDOW(dialog_parallel), settings.parallel_x,
			settings.parallel_y);

	return dialog_parallel;
}
コード例 #21
0
ファイル: nimf-settings.c プロジェクト: inureyes/nimf
static GtkWidget *
nimf_settings_page_key_build_string_array (NimfSettingsPageKey *page_key)
{
  GtkListStore      *store;
  GtkWidget         *treeview;
  GtkCellRenderer   *renderer;
  GtkTreeViewColumn *column;
  GtkWidget         *scrolled_w;
  GtkWidget         *hbox;
  GtkWidget         *vbox;
  GtkWidget         *button1;
  GtkWidget         *button2;
  gchar            **strv;
  gchar             *detailed_signal;
  GtkTreeIter        iter;
  gint               j;

  button1 = gtk_button_new_from_icon_name ("list-add",    GTK_ICON_SIZE_SMALL_TOOLBAR);
  button2 = gtk_button_new_from_icon_name ("list-remove", GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_button_set_relief (GTK_BUTTON (button1), GTK_RELIEF_NONE);
  gtk_button_set_relief (GTK_BUTTON (button2), GTK_RELIEF_NONE);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

#if GTK_CHECK_VERSION (3, 12, 0)
  gtk_widget_set_margin_end   (page_key->label, 15);
#else
  gtk_widget_set_margin_right (page_key->label, 15);
#endif

  gtk_box_pack_start (GTK_BOX (hbox), page_key->label,   FALSE, FALSE, 0);
  gtk_box_pack_end   (GTK_BOX (hbox), button2, FALSE, FALSE, 0);
  gtk_box_pack_end   (GTK_BOX (hbox), button1, FALSE, FALSE, 0);

  store = gtk_list_store_new (1, G_TYPE_STRING);
  strv = g_settings_get_strv (page_key->gsettings, page_key->key);

  for (j = 0; strv[j] != NULL; j++)
  {
    gtk_list_store_append (store, &iter);
    gtk_list_store_set    (store, &iter, 0, strv[j], -1);
  }

  treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
  g_object_unref (store);
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("Hotkeys", renderer,
                                                     "text", 0, NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);

  scrolled_w = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_w),
                                       GTK_SHADOW_ETCHED_IN);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_w),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  gtk_container_add (GTK_CONTAINER (scrolled_w), treeview);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox,       FALSE, FALSE, 0);
  gtk_box_pack_end   (GTK_BOX (vbox), scrolled_w, FALSE, FALSE, 0);

  page_key->treeview = treeview;
  detailed_signal = g_strdup_printf ("changed::%s", page_key->key);

  g_signal_connect (treeview, "realize",
                    G_CALLBACK (on_tree_view_realize), scrolled_w);
  g_signal_connect (button1, "clicked", G_CALLBACK (on_button_clicked_add), page_key);
  g_signal_connect (button2, "clicked", G_CALLBACK (on_button_clicked_remove), page_key);
  g_signal_connect (page_key->gsettings, detailed_signal,
                    G_CALLBACK (on_gsettings_changed), page_key->treeview);
  g_strfreev (strv);
  g_free (detailed_signal);

  return vbox;
}
コード例 #22
0
PocketvoxSetup* pocketvox_setup_new()
{
	PocketvoxSetup *setup = (PocketvoxSetup *)g_object_new(TYPE_POCKETVOX_SETUP, NULL);

	setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
			TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
	PocketvoxSetupPrivate *priv = setup->priv;

	bindtextdomain (GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);

	priv->settings = g_settings_new("org.pocketvox.config");

    //Build the window
    priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(priv->window), GTK_WIN_POS_CENTER_ALWAYS);
    gtk_window_set_title(GTK_WINDOW(priv->window), "pocketvox-gtk");
    gtk_window_set_default_size(GTK_WINDOW(priv->window), 500, 350);
    gtk_window_set_icon_name(GTK_WINDOW(priv->window), "pocketvox");
    gtk_container_set_border_width(GTK_CONTAINER(priv->window), 5);

	g_signal_connect_swapped(priv->window, "delete-event", G_CALLBACK(pocketvox_setup_save_and_quit), setup);

    GtkWidget *bar = gtk_header_bar_new();
    gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
    gtk_window_set_titlebar(GTK_WINDOW(priv->window), bar);

    //add a vertical box
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    gtk_container_add(GTK_CONTAINER(priv->window), box);

    //a button for all
    GtkWidget* button_notification 	= gtk_button_new_with_label(_("Notifications"));
    GtkWidget* button_user 			= gtk_button_new_with_label(_("Users"));
    GtkWidget* button_pocketsphinx 	= gtk_button_new_with_label(_("Pocketsphinx"));
    GtkWidget* button_gstreamer		= gtk_button_new_with_label(_("Gstreamer"));

    gtk_widget_set_tooltip_text(button_notification, _("Display notifications parameters"));
    gtk_widget_set_tooltip_text(button_user, _("Display user parameters"));
    gtk_widget_set_tooltip_text(button_pocketsphinx, _("Display pocketsphinx parameters"));
    gtk_widget_set_tooltip_text(button_gstreamer, _("Display gstreamer parameters"));

    gtk_button_set_relief(GTK_BUTTON(button_notification), 	GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(button_user), 			GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(button_pocketsphinx), 	GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(button_gstreamer), 	GTK_RELIEF_NONE);

    GtkWidget *grid_button	= gtk_grid_new();
    gtk_grid_attach(GTK_GRID(grid_button), button_user, 		0, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(grid_button), button_notification, 0, 1, 1, 1);
    gtk_grid_attach(GTK_GRID(grid_button), button_pocketsphinx, 0, 2, 1, 1);
    gtk_grid_attach(GTK_GRID(grid_button), button_gstreamer,	0, 3, 1, 1);

    GtkWidget* grid_notification 	= pocketvox_setup_get_notification_grid(setup);
    GtkWidget* grid_user			= pocketvox_setup_get_user_grid(setup);
    GtkWidget* grid_pocketsphinx	= pocketvox_setup_get_pocketsphinx_grid(setup);
    GtkWidget* grid_gstreamer		= pocketvox_setup_get_gstreamer_grid(setup);

    //connect all signals (TODO)
    g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_show), grid_notification);
    g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
    g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide),  grid_pocketsphinx);
    g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);

    g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
    g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
    g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_show),  grid_pocketsphinx);
    g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);

    g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
    g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_show), grid_user);
    g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide),  grid_pocketsphinx);
    g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);

    g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
    g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
    g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide),  grid_pocketsphinx);
    g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_show), grid_gstreamer);

    //add
    GtkWidget* gridBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_pack_start(GTK_BOX(gridBox), grid_user, 		TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(gridBox), grid_notification, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(gridBox), grid_pocketsphinx, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(gridBox), grid_gstreamer, 	TRUE, TRUE, 0);

    GtkWidget* separator =  gtk_separator_new(GTK_ORIENTATION_VERTICAL);
    gtk_widget_show(separator);

    GtkWidget *hgridBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
    gtk_box_pack_start(GTK_BOX(hgridBox), grid_button, 	FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hgridBox), separator, 	FALSE, FALSE, 5);
    gtk_box_pack_start(GTK_BOX(hgridBox), gridBox, 		TRUE, TRUE, 0);

    GtkWidget *stack = gtk_stack_new();
    gtk_stack_set_transition_type(GTK_STACK(stack) , GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
    gtk_stack_set_transition_duration(GTK_STACK(stack), 1000);

    gtk_stack_add_titled(GTK_STACK(stack), hgridBox, "Setup", _("Configuration"));

	GtkWidget* scrolledWindow  = gtk_scrolled_window_new(NULL, NULL);

    //return void
    pocketvox_setup_get_modules_grid(setup);
    gtk_container_add(GTK_CONTAINER(scrolledWindow), priv->listBox);
    gtk_widget_show_all(scrolledWindow);

    gtk_stack_add_titled(GTK_STACK(stack), scrolledWindow, "Modules", _("Modules"));

    //adding a task switcher
    GtkWidget* stackSwitcher = gtk_stack_switcher_new();
    gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stackSwitcher), GTK_STACK(stack));

    gtk_header_bar_set_custom_title(GTK_HEADER_BAR(bar), stackSwitcher);

	GtkWidget *add_module_button 	= gtk_button_new_from_icon_name("gtk-new", GTK_ICON_SIZE_MENU);
	GtkWidget *remove_module_button = gtk_button_new_from_icon_name("gtk-delete", GTK_ICON_SIZE_MENU);
	gtk_button_set_relief(GTK_BUTTON(add_module_button), GTK_RELIEF_NONE);
	gtk_button_set_relief(GTK_BUTTON(remove_module_button), GTK_RELIEF_NONE);

	gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), add_module_button);
	gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), remove_module_button);

	g_signal_connect_swapped(remove_module_button, 	"clicked", 					G_CALLBACK(pocketvox_setup_remove_module), 			setup);
	g_signal_connect_swapped(add_module_button, 	"clicked", 					G_CALLBACK(pocketvox_setup_add_module_callback),    setup);
	g_signal_connect_swapped(stack, 				"notify::visible-child", 	G_CALLBACK(pocketvox_stack_child_changed), 			add_module_button);
	g_signal_connect_swapped(stack, 				"notify::visible-child", 	G_CALLBACK(pocketvox_stack_child_changed), 			remove_module_button);

    //add them to the vbox
    gtk_box_pack_start(GTK_BOX(box), stack, TRUE, TRUE, 0);

    gtk_widget_show(grid_user);
    gtk_widget_hide(grid_notification);
    gtk_widget_hide(grid_pocketsphinx);
    gtk_widget_hide(grid_gstreamer);
    gtk_widget_show(gridBox);

    gtk_widget_show_all(grid_button);
    gtk_widget_show(hgridBox);
    gtk_widget_show(box);
	gtk_widget_show(stack);
	gtk_widget_show(stackSwitcher);
	gtk_widget_show_all(bar);

    //get the setup
	return setup;
}
コード例 #23
0
ファイル: tabbed_browser.c プロジェクト: elijahdorman/Xiphos
static GtkWidget *tab_widget_new(PASSAGE_TAB_INFO *tbinf,
				 const gchar *label_text)
{
	GtkWidget *box;
#ifdef USE_GTK_3
//	GdkRGBA color;
#else
	GdkColor color;
#endif

	g_return_val_if_fail(label_text != NULL, NULL);
#ifdef HAVE_GTK_310
	tbinf->button_close =
	    gtk_button_new_from_icon_name("window-close-symbolic",
					  GTK_ICON_SIZE_MENU);
#else
	GtkWidget *tmp_toolbar_icon =
		gtk_image_new_from_stock(GTK_STOCK_CLOSE,
					 GTK_ICON_SIZE_MENU);
	tbinf->button_close = gtk_button_new();
	gtk_button_set_image(GTK_BUTTON(tbinf->button_close),
			     tmp_toolbar_icon);
	gtk_button_set_relief(GTK_BUTTON(tbinf->button_close),
			      GTK_RELIEF_NONE);
#endif

#ifndef USE_GTK_3
	gtk_rc_parse_string("style \"tab-button-style\"\n"
			    "{\n"
			    "    GtkWidget::focus-padding = 0\n"
			    "    GtkWidget::focus-line-width = 0\n"
			    "    xthickness = 0\n"
			    "    ythickness = 0\n"
			    "    GtkButton::internal-border = {0, 0, 0, 0}\n"
			    "    GtkButton::default-border = {0, 0, 0, 0}\n"
			    "    GtkButton::default-outside-border = {0, 0, 0, 0}\n"
			    "}\n"
			    "widget \"*.button-close\" style \"tab-button-style\"");
	gtk_widget_set_name(GTK_WIDGET(tbinf->button_close),
			    "button-close");
#else
	gtk_widget_set_size_request(tbinf->button_close, 18, 16);
#endif

#ifndef USE_GTK_3
	GtkRequisition r;
	gtk_widget_size_request(tbinf->button_close, &r);
#endif

	gtk_widget_set_sensitive(tbinf->button_close, FALSE);
	gtk_widget_show(tbinf->button_close);
	tbinf->tab_label = GTK_LABEL(gtk_label_new(label_text));
	gtk_widget_show(GTK_WIDGET(tbinf->tab_label));

#ifdef USE_GTK_3
#else
	color.red = 0;
	color.green = 0;
	color.blue = 0;

	gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_NORMAL,
			     &color);
	gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_INSENSITIVE,
			     &color);
	gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_ACTIVE,
			     &color);
	gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_PRELIGHT,
			     &color);
	gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_SELECTED,
			     &color);
#endif

	UI_HBOX(box, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(tbinf->tab_label),
			   TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(box), tbinf->button_close, FALSE, FALSE,
			   0);

	gtk_widget_show(box);

	g_signal_connect(G_OBJECT(tbinf->button_close), "clicked",
			 G_CALLBACK(on_notebook_main_close_page), tbinf);

	return box;
}
コード例 #24
0
ファイル: display_info.c プロジェクト: elijahdorman/Xiphos
GtkWidget *gui_create_display_informtion_dialog(void)
{

	GtkWidget *dialog_vbox23;
	GtkWidget *hbox;
	GtkWidget *dialog_action_area23;
	GtkWidget *hbuttonbox2;
	GtkWidget *button_close;
	GtkWidget *image;

	dialog_display_info = gtk_dialog_new();
	gtk_container_set_border_width(GTK_CONTAINER(dialog_display_info),
				       6);
	g_object_set_data(G_OBJECT(dialog_display_info),
			  "dialog_display_info", dialog_display_info);
	gtk_window_set_title(GTK_WINDOW(dialog_display_info), " ");
	//GTK_WINDOW(dialog_display_info)->type = GTK_WINDOW_TOPLEVEL;
	gtk_window_set_default_size(GTK_WINDOW(dialog_display_info), 350, 200);
	gtk_window_set_resizable(GTK_WINDOW(dialog_display_info), TRUE);

#ifndef USE_GTK_3
	gtk_dialog_set_has_separator(GTK_DIALOG(dialog_display_info),
				     FALSE);
#endif

	dialog_vbox23 = gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info)); //GTK_DIALOG(dialog_display_info)->vbox;
	g_object_set_data(G_OBJECT(dialog_display_info),
			  "dialog_vbox23", dialog_vbox23);
	gtk_widget_show(dialog_vbox23);

	UI_HBOX(hbox, FALSE, 12);
	gtk_widget_show(hbox);
	gtk_box_pack_start(GTK_BOX(dialog_vbox23), hbox, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);

	image =
#ifdef HAVE_GTK_310
	    gtk_image_new_from_icon_name("dialog-information",
					 GTK_ICON_SIZE_DIALOG);
#else
	    gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO,
				     GTK_ICON_SIZE_DIALOG);
#endif
	gtk_widget_show(image);
	gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, TRUE, 0);
#ifndef HAVE_GTK_310
	gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0);
#endif
	html_widget = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, 30)); //gtk_html_new();
	gtk_widget_show(html_widget);
	gtk_box_pack_start(GTK_BOX(hbox), html_widget, TRUE, TRUE, 0);
	//gtk_container_add(GTK_CONTAINER(scrolledwindow70), html_widget);

	dialog_action_area23 =
#ifdef HAVE_GTK_312
	    gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info));
#else
	    gtk_dialog_get_action_area(GTK_DIALOG(dialog_display_info));
#endif
	g_object_set_data(G_OBJECT(dialog_display_info),
			  "dialog_action_area23", dialog_action_area23);
	gtk_widget_show(dialog_action_area23);
	gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area23), 10);

#ifdef USE_GTK_3
	hbuttonbox2 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
	hbuttonbox2 = gtk_hbutton_box_new();
#endif
	gtk_widget_show(hbuttonbox2);
	gtk_box_pack_start(GTK_BOX(dialog_action_area23), hbuttonbox2,
			   TRUE, TRUE, 0);
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox2),
				  GTK_BUTTONBOX_END);

	button_close =
#ifdef HAVE_GTK_310
	    gtk_button_new_from_icon_name("window-close",
					  GTK_ICON_SIZE_BUTTON);
#else
	    gtk_button_new_from_stock(GTK_STOCK_CLOSE);
#endif

	gtk_widget_show(button_close);
	gtk_container_add(GTK_CONTAINER(hbuttonbox2), button_close);
	gtk_widget_set_can_default(button_close, 1);

	g_signal_connect(G_OBJECT(button_close), "clicked",
			 G_CALLBACK(button_close_clicked), NULL);

	g_signal_connect(G_OBJECT(dialog_display_info),
			 "destroy",
			 G_CALLBACK(on_dlgInformation_destroy), NULL);

	gtk_widget_show(dialog_display_info);
	gsI_isrunning = TRUE;
	return dialog_display_info;
}
コード例 #25
0
ファイル: dsn-config.c プロジェクト: GNOME/libgda
GtkWidget *
dsn_config_new (void)
{
	DsnConfigPrivate *priv;
	GtkWidget *dsn;
	GtkWidget *label;
	GtkWidget *sw;
	gchar *title;
	GdaDataModel *model;

	priv = g_new0 (DsnConfigPrivate, 1);
	dsn = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
	gtk_widget_show (dsn);
        gtk_container_set_border_width (GTK_CONTAINER (dsn), 6);
	g_object_set_data_full (G_OBJECT (dsn), DSN_CONFIG_DATA, priv,
				(GDestroyNotify) free_private_data);

	/* title */
	title = g_strdup_printf ("<b>%s</b>\n%s", _("Data Sources"),
				 _("Data sources are the means by which database "
				 "connections are identified: all "
				 "the information needed to open a connection to "
				 "a specific database using a 'provider' is referenced using "
				 "a unique name."));
	priv->title = gdaui_bar_new (title);
	g_free (title);

	gdaui_bar_set_icon_from_resource (GDAUI_BAR (priv->title), "/images/gdaui-generic.png");

	gtk_box_pack_start (GTK_BOX (dsn), priv->title, FALSE, FALSE, 0);
	gtk_widget_show (priv->title);

	/* horizontal box for the provider list and its properties */
	GtkWidget *hbox;
	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_box_pack_start (GTK_BOX (dsn), hbox, TRUE, TRUE, 0);

	/* left part */
	GtkWidget *vbox;
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_widget_set_size_request (vbox, 150, -1);
	gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);

	/* create the data source list */
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
	gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);

	model = gda_config_list_dsn ();
	priv->dsn_list = gdaui_raw_grid_new (model);
	gtk_tree_view_move_column_after (GTK_TREE_VIEW (priv->dsn_list),
					 gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 1),
					 gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 2));

	g_object_unref (model);
	g_object_set_data (G_OBJECT (dsn), "grid", priv->dsn_list);
	gdaui_data_proxy_column_set_editable (GDAUI_DATA_PROXY (priv->dsn_list), 0, FALSE);
	gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), -1, FALSE);
	gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), 0, TRUE);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->dsn_list), FALSE);
	g_object_set (priv->dsn_list, "info-cell-visible", FALSE, NULL);

	gtk_container_add (GTK_CONTAINER (sw), priv->dsn_list);

	g_signal_connect (priv->dsn_list, "selection-changed",
			  G_CALLBACK (list_selection_changed_cb), dsn);
	g_signal_connect (priv->dsn_list, "populate-popup",
			  G_CALLBACK (list_popup_cb), dsn);

	/* add/delete buttons */
	GtkWidget *toolbar;
	toolbar = gtk_toolbar_new ();
	gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
	gtk_style_context_add_class (gtk_widget_get_style_context (toolbar), "inline-toolbar");
	gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
	GtkToolItem *titem;
	titem = gtk_tool_button_new (NULL, NULL);
	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-add-symbolic");
	gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceNew");
	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
	titem = gtk_tool_button_new (NULL, NULL);
	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-remove-symbolic");
	gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceDelete");
	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);

	/* create the data source's properties */
	GtkWidget *stack;
	stack = gtk_stack_new ();
	priv->stack = stack;
	gtk_box_pack_start (GTK_BOX (hbox), stack, TRUE, TRUE, 10);

	label = gtk_label_new (_("No data source selected."));
	gtk_stack_add_named (GTK_STACK (stack), label, ST_NOPROP);

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_stack_add_named (GTK_STACK (stack), vbox, ST_PROP);

	GtkWidget *form;
	form = gdaui_dsn_editor_new ();
	priv->dsn_editor = GDAUI_DSN_EDITOR (form);
	gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
	g_signal_connect (priv->dsn_editor, "changed",
			  G_CALLBACK (dsn_editor_changed_cb), dsn);

	/* action buttons */
	GtkWidget *hbox2;
	hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
	gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6);

	GtkWidget *bbox;
	bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_widget_set_hexpand (bbox, TRUE);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_CENTER);
	gtk_box_pack_start (GTK_BOX (hbox2), bbox, FALSE, FALSE, 6);

	GtkWidget *button;
	button = gtk_toggle_button_new_with_label (_("Definition"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	priv->view_buttons [GDAUI_DSN_EDITOR_PANE_DEFINITION] = GTK_TOGGLE_BUTTON (button);
	g_signal_connect (button, "toggled",
			  G_CALLBACK (view_toggled_cb), dsn);

	button = gtk_toggle_button_new_with_label (_("Parameters"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	priv->view_buttons [GDAUI_DSN_EDITOR_PANE_PARAMS] = GTK_TOGGLE_BUTTON (button);
	g_signal_connect (button, "toggled",
			  G_CALLBACK (view_toggled_cb), dsn);

	button = gtk_toggle_button_new_with_label (_("Authentication"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH] = GTK_TOGGLE_BUTTON (button);
	g_signal_connect (button, "toggled",
			  G_CALLBACK (view_toggled_cb), dsn);

	button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON);
	gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
	priv->commit_button = button;
	gtk_widget_set_sensitive (button, FALSE);
	gtk_widget_set_tooltip_text (button, _("Write changes made to the DSN"));
	g_signal_connect (button, "clicked",
			  G_CALLBACK (save_cb), dsn);

	gtk_widget_show_all (hbox);
	return dsn;
}
コード例 #26
0
ファイル: search_sidebar.c プロジェクト: acli/xiphos
void gui_create_search_sidebar(void)
{
	GtkWidget *vbox1;
	GtkWidget *vbox90;
	GtkWidget *vbox5;
	GtkWidget *frame2;
	GtkWidget *vbox2;
	GtkWidget *frame3;
	GtkWidget *vbox3;
	GtkWidget *frame4;
	GtkWidget *vbox4;
	GtkWidget *table1;
	GtkWidget *label1;
	GtkWidget *label2;
	GtkWidget *scrolledwindow_search;
	GtkWidget *viewport_search;
	gchar *header;
	//GtkListStore *store;

	//ss = &sss;

	scrolledwindow_search = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolledwindow_search);
	gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar),
			  scrolledwindow_search);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_search),
					    settings.shadow_type);
	gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_search), 2);

	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_search),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	viewport_search = gtk_viewport_new(NULL, NULL);
	gtk_widget_show(viewport_search);
	gtk_container_add(GTK_CONTAINER(scrolledwindow_search),
			  viewport_search);

	UI_VBOX(vbox1, FALSE, 4);
	gtk_widget_show(vbox1);
	gtk_container_add(GTK_CONTAINER(viewport_search), vbox1);

	UI_VBOX(vbox5, FALSE, 0);
	gtk_widget_show(vbox5);
	gtk_box_pack_start(GTK_BOX(vbox1), vbox5, FALSE, TRUE, 0);

	/* text entry */
	ss.entrySearch = gtk_entry_new();
	gtk_widget_show(ss.entrySearch);
	gtk_box_pack_start(GTK_BOX(vbox5), ss.entrySearch, TRUE, TRUE, 0);
	gtk_widget_set_size_request(ss.entrySearch, 130, -1);
	;

/* find button */
#ifdef HAVE_GTK_310
	remember_search =
	    gtk_button_new_from_icon_name("edit-find-symbolic",
					  GTK_ICON_SIZE_BUTTON);
#else
	remember_search = gtk_button_new_from_stock(GTK_STOCK_FIND);
#endif
	gtk_widget_show(remember_search);
	gtk_box_pack_start(GTK_BOX(vbox5), remember_search, TRUE, FALSE,
			   0);
	gtk_widget_set_tooltip_text(remember_search,
				    _("This is an inclusive (\"AND\") search:\nFind matches showing all words."));
	gtk_button_set_relief(GTK_BUTTON(remember_search),
			      GTK_RELIEF_HALF);

	/* progress bar */
	ss.progressbar_search = gtk_progress_bar_new();
	gtk_widget_show(ss.progressbar_search);
	gtk_box_pack_start(GTK_BOX(vbox5), ss.progressbar_search, FALSE,
			   TRUE, 0);

	/* button to open advanced search */
	ss.advanced_search =
	    gtk_button_new_with_mnemonic(_("_Open Advanced Search"));
	gtk_widget_show(ss.advanced_search);
	gtk_box_pack_start(GTK_BOX(vbox5), ss.advanced_search, TRUE, FALSE,
			   0);
	gtk_widget_set_tooltip_text(ss.advanced_search,
				    _("Open the separate Advanced Search dialog."));
	gtk_button_set_relief(GTK_BUTTON(ss.advanced_search),
			      GTK_RELIEF_HALF);

	ss.frame_module = gtk_frame_new(NULL);
	gtk_widget_show(ss.frame_module);
	gtk_box_pack_start(GTK_BOX(vbox1), ss.frame_module, FALSE, FALSE,
			   0);
	gtk_container_set_border_width(GTK_CONTAINER(ss.frame_module), 2);
	gtk_frame_set_shadow_type(GTK_FRAME(ss.frame_module),
				  GTK_SHADOW_NONE);

	label1 = gtk_label_new(NULL);

	header =
	    g_strdup_printf("<span weight=\"bold\">%s</span>",
			    _("Search Module"));
	gtk_label_set_markup(GTK_LABEL(label1), header);
	g_free(header);

	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(ss.frame_module), label1);

	UI_VBOX(vbox90, FALSE, 0);
	gtk_widget_show(vbox90);
	gtk_container_add(GTK_CONTAINER(ss.frame_module), vbox90);
	gtk_container_set_border_width(GTK_CONTAINER(vbox90), 4);

	ss.radiobutton_search_text =
	    gtk_radio_button_new_with_label(NULL, _("Bible"));
	gtk_widget_show(ss.radiobutton_search_text);
	gtk_widget_set_size_request(ss.radiobutton_search_text, -1, 20);
	gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_text,
			   FALSE, FALSE, 0);

	ss.radiobutton_search_comm =
	    gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.radiobutton_search_text),
							_("Commentary"));
	gtk_widget_show(ss.radiobutton_search_comm);
	gtk_widget_set_size_request(ss.radiobutton_search_comm, -1, 20);
	gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_comm,
			   FALSE, FALSE, 0);

	frame2 = gtk_frame_new(NULL);
	gtk_widget_show(frame2);
	gtk_box_pack_start(GTK_BOX(vbox1), frame2, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame2), 2);
	gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_NONE);

	label1 = gtk_label_new(NULL);

	header =
	    g_strdup_printf("<span weight=\"bold\">%s</span>",
			    _("Search Type"));
	gtk_label_set_markup(GTK_LABEL(label1), header);
	g_free(header);

	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(frame2), label1);

	UI_VBOX(vbox2, TRUE, 0);
	gtk_widget_show(vbox2);
	gtk_container_add(GTK_CONTAINER(frame2), vbox2);
	gtk_container_set_border_width(GTK_CONTAINER(vbox2), 4);

	ss.rbMultiword =
	    gtk_radio_button_new_with_label(NULL, _("Optimized (\"Lucene\")"));
	gtk_widget_show(ss.rbMultiword);
	gtk_box_pack_start(GTK_BOX(vbox2), ss.rbMultiword, FALSE,
			   FALSE, 0);
	gtk_widget_set_size_request(ss.rbMultiword, -1, 20);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbMultiword), TRUE);

	ss.rbRegExp =
	    gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword),
							_("Regular expression"));
	gtk_widget_show(ss.rbRegExp);
	gtk_box_pack_start(GTK_BOX(vbox2), ss.rbRegExp, FALSE, FALSE, 0);
	gtk_widget_set_size_request(ss.rbRegExp, -1, 20);

	ss.rbPhraseSearch =
	    gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword),
							_("Exact phrase"));
	gtk_widget_show(ss.rbPhraseSearch);
	gtk_box_pack_start(GTK_BOX(vbox2), ss.rbPhraseSearch,
			   FALSE, FALSE, 0);
	gtk_widget_set_size_request(ss.rbPhraseSearch, -1, 20);

	frame3 = gtk_frame_new(NULL);
	gtk_widget_show(frame3);
	gtk_box_pack_start(GTK_BOX(vbox1), frame3, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame3), 2);
	gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_NONE);

	label1 = gtk_label_new(NULL);

	header =
	    g_strdup_printf("<span weight=\"bold\">%s</span>",
			    _("Search Options"));
	gtk_label_set_markup(GTK_LABEL(label1), header);
	g_free(header);

	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(frame3), label1);

	UI_VBOX(vbox3, FALSE, 0);
	gtk_widget_show(vbox3);
	gtk_container_add(GTK_CONTAINER(frame3), vbox3);
	gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);

	ss.ckbCaseSensitive =
	    gtk_check_button_new_with_label(_("Match case"));
	gtk_widget_show(ss.ckbCaseSensitive);
	gtk_box_pack_start(GTK_BOX(vbox3), ss.ckbCaseSensitive, FALSE,
			   FALSE, 0);
	gtk_widget_set_size_request(ss.ckbCaseSensitive, -1, 20);

	frame4 = gtk_frame_new(NULL);
	gtk_widget_show(frame4);
	gtk_box_pack_start(GTK_BOX(vbox1), frame4, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame4), 2);
	gtk_frame_set_shadow_type(GTK_FRAME(frame4), GTK_SHADOW_NONE);

	label1 = gtk_label_new(NULL);

	header =
	    g_strdup_printf("<span weight=\"bold\">%s</span>",
			    _("Search Scope"));
	gtk_label_set_markup(GTK_LABEL(label1), header);
	g_free(header);

	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(frame4), label1);

	UI_VBOX(vbox4, TRUE, 0);
	gtk_widget_show(vbox4);
	gtk_container_add(GTK_CONTAINER(frame4), vbox4);
	gtk_container_set_border_width(GTK_CONTAINER(vbox4), 4);

	ss.rbNoScope =
	    gtk_radio_button_new_with_label(NULL, _("No scope"));
	gtk_widget_show(ss.rbNoScope);
	gtk_box_pack_start(GTK_BOX(vbox4), ss.rbNoScope, FALSE, FALSE, 0);
	gtk_widget_set_size_request(ss.rbNoScope, -1, 20);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbNoScope),
				     TRUE);

	ss.rrbUseBounds =
	    gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope),
							_("Use bounds"));
	gtk_widget_show(ss.rrbUseBounds);
	gtk_box_pack_start(GTK_BOX(vbox4), ss.rrbUseBounds, FALSE,
			   FALSE, 0);
	gtk_widget_set_size_request(ss.rrbUseBounds, -1, 20);

	ss.rbLastSearch =
	    gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope),
							_("Last search"));
	gtk_widget_show(ss.rbLastSearch);
	gtk_box_pack_start(GTK_BOX(vbox4), ss.rbLastSearch, FALSE,
			   FALSE, 0);
	gtk_widget_set_size_request(ss.rbLastSearch, -1, 20);

	ss.frame5 = gtk_frame_new(NULL);
	gtk_widget_show(ss.frame5);
	gtk_box_pack_start(GTK_BOX(vbox1), ss.frame5, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(ss.frame5), 2);
	gtk_widget_hide(ss.frame5);
	gtk_frame_set_shadow_type(GTK_FRAME(ss.frame5), GTK_SHADOW_NONE);

	label1 = gtk_label_new(NULL);

	header =
	    g_strdup_printf("<span weight=\"bold\">%s</span>",
			    _("Bounds"));
	gtk_label_set_markup(GTK_LABEL(label1), header);
	g_free(header);

	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(ss.frame5), label1);

#ifdef HAVE_GTK_34
	table1 = gtk_grid_new();
	gtk_widget_show(table1);
	gtk_container_add(GTK_CONTAINER(ss.frame5), table1);
	gtk_grid_set_row_spacing(GTK_GRID(table1), 3);
	gtk_grid_set_column_spacing(GTK_GRID(table1), 3);
	gtk_container_set_border_width(GTK_CONTAINER(table1), 8);

	label1 = gtk_label_new(_("Lower"));
	gtk_widget_show(label1);
	gtk_grid_attach(GTK_GRID(table1), label1, 0, 0, 1, 1);
#ifndef HAVE_GTK_310
	gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5);
#endif

	ss.entryLower = gtk_combo_box_text_new_with_entry();
	gtk_widget_show(ss.entryLower);
	gtk_grid_attach(GTK_GRID(table1), ss.entryLower, 1, 0, 1, 1);
	gtk_widget_set_size_request(ss.entryLower, 114, 22);

	label2 = gtk_label_new(_("Upper"));
	gtk_widget_show(label2);
	gtk_grid_attach(GTK_GRID(table1), label2, 0, 1, 1, 1);
#ifndef HAVE_GTK_310
	gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5);
#endif

	ss.entryUpper = gtk_combo_box_text_new_with_entry();
	gtk_widget_show(ss.entryUpper);
	gtk_grid_attach(GTK_GRID(table1), ss.entryUpper, 1, 1, 1, 1);
	gtk_widget_set_size_request(ss.entryUpper, 114, 22);

#else
	table1 = gtk_table_new(2, 2, FALSE);
	gtk_widget_show(table1);
	gtk_container_add(GTK_CONTAINER(ss.frame5), table1);
	gtk_table_set_row_spacings(GTK_TABLE(table1), 3);
	gtk_table_set_col_spacings(GTK_TABLE(table1), 3);
	gtk_container_set_border_width(GTK_CONTAINER(table1), 8);

	label1 = gtk_label_new(_("Lower"));
	gtk_widget_show(label1);
	gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1,
			 (GtkAttachOptions)(GTK_FILL),
			 (GtkAttachOptions)(0), 0, 0);
	gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5);

	label2 = gtk_label_new(_("Upper"));
	gtk_widget_show(label2);
	gtk_table_attach(GTK_TABLE(table1), label2, 0, 1, 1, 2,
			 (GtkAttachOptions)(GTK_FILL),
			 (GtkAttachOptions)(0), 0, 0);
	gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5);

#ifdef HAVE_GTK_224
	ss.entryLower = gtk_combo_box_text_new_with_entry();
#else
	ss.entryLower = gtk_combo_box_entry_new_text();
#endif
	gtk_widget_show(ss.entryLower);
	gtk_table_attach(GTK_TABLE(table1), ss.entryLower, 1, 2, 0, 1,
			 (GtkAttachOptions)(GTK_FILL),
			 (GtkAttachOptions)(0), 0, 0);
	gtk_widget_set_size_request(ss.entryLower, 114, 22);

#ifdef HAVE_GTK_224
	ss.entryUpper = gtk_combo_box_text_new_with_entry();
#else
	ss.entryUpper = gtk_combo_box_entry_new_text();
#endif
	gtk_widget_show(ss.entryUpper);
	gtk_table_attach(GTK_TABLE(table1), ss.entryUpper, 1, 2, 1, 2,
			 (GtkAttachOptions)(GTK_FILL),
			 (GtkAttachOptions)(0), 0, 0);
	gtk_widget_set_size_request(ss.entryUpper, 114, 22);
#endif

	g_signal_connect(G_OBJECT(ss.rrbUseBounds),
			 "toggled",
			 G_CALLBACK(on_rrbUseBounds_toggled), NULL);
	g_signal_connect(G_OBJECT(remember_search), "clicked",
			 G_CALLBACK(on_search_button_clicked), NULL);

	g_signal_connect(G_OBJECT(ss.entrySearch), "activate",
			 G_CALLBACK(on_search_button_clicked), NULL);

	g_signal_connect(G_OBJECT(ss.advanced_search), "clicked",
			 G_CALLBACK(main_open_search_dialog), NULL);

	/* prep for toggle case sensitive availability per optimized */
	g_signal_connect(ss.rbMultiword, "toggled",
			 G_CALLBACK(sidebar_optimized_toggled), NULL);
	/* initialize it off */
	gtk_widget_set_sensitive(ss.ckbCaseSensitive, FALSE);
}
コード例 #27
0
static void
ephy_find_toolbar_init (EphyFindToolbar *toolbar)
{
	GtkWidget *box;
	GtkSizeGroup *size_group;

	size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);

	box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_style_context_add_class (gtk_widget_get_style_context (box),
				     GTK_STYLE_CLASS_RAISED);
	gtk_style_context_add_class (gtk_widget_get_style_context (box),
				     GTK_STYLE_CLASS_LINKED);
	gtk_container_add (GTK_CONTAINER (toolbar), box);

	toolbar->entry = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (toolbar->entry), 32);
	gtk_entry_set_max_length (GTK_ENTRY (toolbar->entry), 512);
	gtk_entry_set_placeholder_text (GTK_ENTRY (toolbar->entry), _("Type to search…"));
	gtk_container_add (GTK_CONTAINER (box), toolbar->entry);

	/* Prev */
	toolbar->prev = gtk_button_new_from_icon_name ("go-up-symbolic", GTK_ICON_SIZE_MENU);
	gtk_widget_set_tooltip_text (toolbar->prev,
				     _("Find previous occurrence of the search string"));
	gtk_container_add (GTK_CONTAINER (box), toolbar->prev);
	gtk_widget_show_all (toolbar->prev);
	gtk_widget_set_sensitive (toolbar->prev, FALSE);

	/* Next */
	toolbar->next = gtk_button_new_from_icon_name ("go-down-symbolic", GTK_ICON_SIZE_MENU);
	gtk_widget_set_tooltip_text (toolbar->next,
				     _("Find next occurrence of the search string"));
	gtk_container_add (GTK_CONTAINER (box), toolbar->next);
	gtk_widget_set_sensitive (toolbar->next, FALSE);

	gtk_size_group_add_widget (size_group, toolbar->entry);
	gtk_size_group_add_widget (size_group, toolbar->next);
	gtk_size_group_add_widget (size_group, toolbar->prev);
	g_object_unref (size_group);

	/* connect signals */
	g_signal_connect (toolbar->entry, "icon-release",
			  G_CALLBACK (search_entry_clear_cb), toolbar);
	g_signal_connect (toolbar->entry, "key-press-event",
			  G_CALLBACK (entry_key_press_event_cb), toolbar);
	g_signal_connect_after (toolbar->entry, "changed",
				G_CALLBACK (search_entry_changed_cb), toolbar);
	g_signal_connect (toolbar->entry, "activate",
			  G_CALLBACK (entry_activate_cb), toolbar);
	g_signal_connect_swapped (toolbar->next, "clicked",
				  G_CALLBACK (ephy_find_toolbar_find_next), toolbar);
	g_signal_connect_swapped (toolbar->prev, "clicked",
				  G_CALLBACK (ephy_find_toolbar_find_previous), toolbar);
	gtk_search_bar_connect_entry (GTK_SEARCH_BAR (toolbar),
				      GTK_ENTRY (toolbar->entry));

	search_entry_changed_cb (GTK_ENTRY (toolbar->entry), toolbar);

	gtk_widget_show_all (GTK_WIDGET (toolbar));
}
コード例 #28
0
/* Create a page for the main notebook.
 */
static GtkWidget*
create_toolbar_page(BalsaToolbarModel * model, GActionMap * map)
{
    GtkWidget *outer_box;
    GtkWidget *toolbar_frame, *toolbar_scroll;
    GtkWidget *toolbar_ctlbox;
    GtkWidget *lower_ctlbox, *button_box, *move_button_box, *center_button_box;
    GtkWidget *list_frame, *list_scroll;
    GtkWidget *destination_frame, *destination_scroll;
    GtkWidget *style_button;
    ToolbarPage *page;
    GtkTreeSelection *selection;

    page = g_new(ToolbarPage, 1);
    page->model = model;

    /* The "window itself" */
    outer_box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    g_object_set_data_full(G_OBJECT(outer_box), BALSA_KEY_TOOLBAR_PAGE,
                           page, g_free);

    /* Preview display */
    toolbar_frame=gtk_frame_new(_("Preview"));
    gtk_container_set_border_width(GTK_CONTAINER(toolbar_frame), 5);
    gtk_box_pack_start(GTK_BOX(outer_box), toolbar_frame, FALSE, FALSE, 0);

    toolbar_ctlbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    gtk_container_add(GTK_CONTAINER(toolbar_frame), toolbar_ctlbox);
    gtk_container_set_border_width(GTK_CONTAINER(toolbar_ctlbox), 5);

    /* The preview is an actual, fully functional toolbar */
    page->toolbar = balsa_toolbar_new(model, map);
    gtk_widget_set_sensitive(page->toolbar, FALSE);

    /* embedded in a scrolled_window */
    toolbar_scroll=gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(toolbar_scroll),
				   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_NEVER);

    gtk_box_pack_start(GTK_BOX(toolbar_ctlbox), toolbar_scroll,
                       TRUE, TRUE, 0);

    gtk_container_add(GTK_CONTAINER(toolbar_scroll), page->toolbar);

    /* Button box */
    button_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_box_set_spacing(GTK_BOX(button_box), 5);
    gtk_box_pack_start(GTK_BOX(toolbar_ctlbox), button_box, FALSE, FALSE, 0);

    /* Standard button */
    page->standard_button =
        gtk_button_new_with_mnemonic(_("_Restore toolbar to standard buttons"));
    gtk_container_add(GTK_CONTAINER(button_box), page->standard_button);

    /* Style button */
    style_button = gtk_button_new_with_mnemonic(_("Toolbar _style…"));
    gtk_container_add(GTK_CONTAINER(button_box), style_button);

    /* Done with preview */

    /* Box for lower half of window */
    lower_ctlbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
    gtk_container_set_border_width(GTK_CONTAINER(lower_ctlbox), 5);

    gtk_box_pack_start(GTK_BOX(outer_box), lower_ctlbox, TRUE, TRUE, 0);

    /* A list to show the available items */
    list_scroll=gtk_scrolled_window_new(NULL, NULL);

    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(list_scroll),
				   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

    list_frame=gtk_frame_new(_("Available buttons"));
    page->available = tp_list_new();

    gtk_box_pack_start(GTK_BOX(lower_ctlbox), list_frame,
		       TRUE, TRUE, 0);
    gtk_container_add(GTK_CONTAINER(list_frame), list_scroll);
    gtk_container_add(GTK_CONTAINER(list_scroll), page->available);

    /* Done with available list */

    /* Another list to show the current tools */
    destination_scroll=gtk_scrolled_window_new(NULL, NULL);

    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(destination_scroll),
				   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

    destination_frame=gtk_frame_new(_("Current toolbar"));
    page->current = tp_list_new();

    /* Done with destination list */

    /* Button box */
    center_button_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_set_homogeneous(GTK_BOX(center_button_box), TRUE);

    button_box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);

    gtk_box_pack_start(GTK_BOX(lower_ctlbox), center_button_box,
		       FALSE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(center_button_box), button_box,
		       FALSE, FALSE, 0);

    page->back_button =
        gtk_button_new_from_icon_name("go-up-symbolic",
                                      GTK_ICON_SIZE_BUTTON);
    gtk_widget_set_tooltip_text(page->back_button,
                                _("Move selected item up"));
    gtk_box_pack_start(GTK_BOX(button_box), page->back_button, FALSE, FALSE, 0);

    move_button_box=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
    gtk_box_pack_start(GTK_BOX(button_box), move_button_box, FALSE, FALSE, 0);

    page->remove_button =
        gtk_button_new_from_icon_name("go-previous-symbolic",
                                      GTK_ICON_SIZE_BUTTON);
    gtk_widget_set_tooltip_text(page->remove_button,
                                _("Remove selected item from toolbar"));
    gtk_box_pack_start(GTK_BOX(move_button_box), page->remove_button,
                       FALSE, FALSE, 0);

    page->add_button =
        gtk_button_new_from_icon_name("go-next-symbolic",
                                      GTK_ICON_SIZE_BUTTON);
    gtk_widget_set_tooltip_text(page->add_button,
                                _("Add selected item to toolbar"));
    gtk_box_pack_start(GTK_BOX(move_button_box), page->add_button, FALSE, FALSE, 0);

    page->forward_button =
        gtk_button_new_from_icon_name("go-down-symbolic",
                                      GTK_ICON_SIZE_BUTTON);
    gtk_widget_set_tooltip_text(page->forward_button,
                                _("Move selected item down"));
    gtk_box_pack_start(GTK_BOX(button_box), page->forward_button, FALSE, FALSE, 0);

    /* Pack destination list */
    gtk_box_pack_start(GTK_BOX(lower_ctlbox), destination_frame, TRUE, TRUE, 0);
    gtk_container_add(GTK_CONTAINER(destination_frame), destination_scroll);
    gtk_container_add(GTK_CONTAINER(destination_scroll), page->current);

    /* UI signals */
    g_signal_connect(G_OBJECT(page->available), "row-activated",
                     G_CALLBACK(available_row_activated_cb), page);
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->available));
    g_signal_connect(G_OBJECT(selection), "changed",
		       G_CALLBACK(available_selection_changed_cb), page);

    g_signal_connect(G_OBJECT(page->current), "row-activated",
                     G_CALLBACK(current_row_activated_cb), page);
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->current));
    g_signal_connect(G_OBJECT(selection), "changed",
		       G_CALLBACK(current_selection_changed_cb), page);

    g_signal_connect(G_OBJECT(page->add_button), "clicked",
		       G_CALLBACK(add_button_cb), page);
    g_signal_connect(G_OBJECT(page->remove_button), "clicked",
		       G_CALLBACK(remove_button_cb), page);
    g_signal_connect(G_OBJECT(page->forward_button), "clicked",
		       G_CALLBACK(forward_button_cb), page);
    g_signal_connect(G_OBJECT(page->back_button), "clicked",
		       G_CALLBACK(back_button_cb), page);

    g_signal_connect(G_OBJECT(page->standard_button), "clicked",
		       G_CALLBACK(standard_button_cb), page);
    g_signal_connect(G_OBJECT(style_button), "clicked",
		       G_CALLBACK(style_button_cb), page);

    gtk_widget_set_sensitive(page->add_button, FALSE);
    gtk_widget_set_sensitive(page->remove_button, FALSE);
    gtk_widget_set_sensitive(page->back_button, FALSE);
    gtk_widget_set_sensitive(page->forward_button, FALSE);
    gtk_widget_set_sensitive(page->standard_button,
                             !balsa_toolbar_model_is_standard(model));

#ifndef BALSA_TOOLBAR_DEBUG_ACTIONS
    tp_page_refresh_available(page);
#else /* BALSA_TOOLBAR_DEBUG_ACTIONS */
    tp_page_refresh_available(page, map);
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
    tp_page_refresh_current(page);

    return outer_box;
}
コード例 #29
0
ファイル: gyahtzee.c プロジェクト: GNOME/tali
static void
GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data)
{
  GtkWidget *hbox, *vbox;
  GtkWidget *toolbar;
  GtkWidget *tmp;
  GtkWidget *dicebox;
  GtkWidget *undo_button;
  GtkWidget *menu_button;
  GtkWidget *icon;
  GtkBuilder *builder;
  GMenuModel *appmenu;
  int i, j;

  window = gtk_application_window_new (application);
  gtk_window_set_application (GTK_WINDOW (window), application);
  gtk_window_set_title (GTK_WINDOW (window), _(appName));
  gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE);
  gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali");

  //games_conf_add_window (GTK_WINDOW (window), NULL);

  g_signal_connect (GTK_WIDGET (window), "key_press_event",
		    G_CALLBACK (key_press), NULL);

  g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
  const gchar *vaccels_help[] = {"F1", NULL};
  const gchar *vaccels_new[] = {"<Primary>n", NULL};
  const gchar *vaccels_roll[] = {"<Primary>r", NULL};
  const gchar *vaccels_undo[] = {"<Primary>z", NULL};

  gtk_application_set_accels_for_action (application, "app.help", vaccels_help);
  gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new);
  gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll);
  gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo);

  scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores");
  undo_action   = g_action_map_lookup_action (G_ACTION_MAP (application), "undo");
  update_undo_sensitivity ();

        /*--- Headerbar ---*/
  hbar = gtk_header_bar_new ();
  gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE);
  gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName));
  gtk_widget_show (hbar);
  gtk_window_set_titlebar (GTK_WINDOW (window), hbar);

  if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
    undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON);
  else
    undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON);
  gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER);
  gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo");
  gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move"));
  gtk_widget_show (undo_button);
  gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button);

  builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui");
  appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu");

  menu_button = gtk_menu_button_new();
  icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON);
  gtk_button_set_image (GTK_BUTTON (menu_button), icon);
  gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu);
  gtk_widget_show (menu_button);
  gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button);

	/*---- Content ----*/

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

  gtk_container_add (GTK_CONTAINER (window), vbox);

  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);

  /* Retreive dice pixmaps from memory or files */
  LoadDicePixmaps ();

  /* Put all the dice in a vertical column */
  dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
  gtk_widget_show (dicebox);

  rollLabel = gtk_label_new (NULL);
  gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
  gtk_widget_show (rollLabel);
  gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);

  mbutton = gtk_button_new_with_label (_("Roll!"));
  gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
  g_signal_connect (GTK_BUTTON (mbutton), "clicked",
		    G_CALLBACK (roll_button_pressed_cb), NULL);
  gtk_widget_show (GTK_WIDGET (mbutton));

  toolbar = gtk_toolbar_new ();
  gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
			       GTK_ORIENTATION_VERTICAL);
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
  gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
  gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);

  for (i = 0; i < NUMBER_OF_DICE; i++) {
    tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

    for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
      gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
      gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
    }

    diceBox[i] = gtk_toggle_tool_button_new ();
    gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
    g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked",
		      G_CALLBACK (modify_dice), &DiceValues[i]);

    gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
			GTK_TOOL_ITEM (diceBox[i]), -1);

    gtk_widget_show (GTK_WIDGET (diceBox[i]));
    gtk_widget_show (tmp);
  /*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
  }
  gtk_widget_show (toolbar);

  /* Scores displayed in score list */
  ScoreList = create_score_list ();
  gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
  setup_score_list (ScoreList);
  gtk_widget_show (ScoreList);

  gtk_widget_show (hbox);
  gtk_widget_show (vbox);
}
コード例 #30
0
static GtkWidget *
create_listbox_row (gpointer item,
                    gpointer user_data)
{
  PpJob     *job = (PpJob *)item;
  GtkWidget *box;
  GtkWidget *widget;
  gchar     *title;
  gchar     *state_string = NULL;
  gint       job_state;

  g_object_get (job, "title", &title, "state", &job_state, NULL);

  switch (job_state)
    {
      case IPP_JOB_PENDING:
        /* Translators: Job's state (job is waiting to be printed) */
        state_string = g_strdup (C_("print job", "Pending"));
        break;
      case IPP_JOB_HELD:
        /* Translators: Job's state (job is held for printing) */
        state_string = g_strdup (C_("print job", "Paused"));
        break;
      case IPP_JOB_PROCESSING:
        /* Translators: Job's state (job is currently printing) */
        state_string = g_strdup (C_("print job", "Processing"));
        break;
      case IPP_JOB_STOPPED:
        /* Translators: Job's state (job has been stopped) */
        state_string = g_strdup (C_("print job", "Stopped"));
        break;
      case IPP_JOB_CANCELED:
        /* Translators: Job's state (job has been canceled) */
        state_string = g_strdup (C_("print job", "Canceled"));
        break;
      case IPP_JOB_ABORTED:
        /* Translators: Job's state (job has aborted due to error) */
        state_string = g_strdup (C_("print job", "Aborted"));
        break;
      case IPP_JOB_COMPLETED:
        /* Translators: Job's state (job has completed successfully) */
        state_string = g_strdup (C_("print job", "Completed"));
        break;
    }

  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  g_object_set (box, "margin", 6, NULL);
  gtk_container_set_border_width (GTK_CONTAINER (box), 2);

  widget = gtk_label_new (title);
  gtk_widget_set_halign (widget, GTK_ALIGN_START);
  gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 10);

  widget = gtk_label_new (state_string);
  gtk_widget_set_halign (widget, GTK_ALIGN_END);
  gtk_widget_set_margin_end (widget, 64);
  gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 10);

  widget = gtk_button_new_from_icon_name (job_state == IPP_JOB_HELD ? "media-playback-start-symbolic" : "media-playback-pause-symbolic",
                                          GTK_ICON_SIZE_SMALL_TOOLBAR);
  g_signal_connect (widget, "clicked", G_CALLBACK (job_pause_cb), item);
  gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4);

  widget = gtk_button_new_from_icon_name ("edit-delete-symbolic",
                                          GTK_ICON_SIZE_SMALL_TOOLBAR);
  g_signal_connect (widget, "clicked", G_CALLBACK (job_stop_cb), item);
  gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4);

  gtk_widget_show_all (box);

  return box;
}