Ejemplo n.º 1
0
static GtkWidget *
create_toolbar (void)
{
  GtkWidget *toolbar;
  GtkToolItem *item;

  toolbar = gtk_toolbar_new ();

  item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-new", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
  gtk_tool_item_set_tooltip_markup (item, "Open another one of these windows");
  gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.new");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
  gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks up the demo");
  gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.lock");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
  gtk_tool_item_set_tooltip_markup (item, "This is a demo button that toggles window decorations");
  gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.decorations");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
  gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks the aspect ratio using a hint");
  gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.ratio");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (gtk_image_new_from_icon_name ("gtk-quit", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
  gtk_tool_item_set_tooltip_markup (item, "This is a demo button with a 'quit' icon");
  gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.quit");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  return toolbar;
}
Ejemplo n.º 2
0
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE arg;
    GtkToolItem *item = NULL;

    rb_scan_args(argc, argv, "01", &arg);
    if (NIL_P(arg)) {
        item = gtk_tool_button_new(NULL, NULL);
    } else if (TYPE(arg) == T_HASH) {
        VALUE icon_widget, label, stock_id, buffer;
        rbg_scan_options(arg,
                         "icon_widget", &icon_widget,
                         "label", &label,
                         "stock_id", &stock_id,
                         NULL);

        if (!NIL_P(icon_widget))
            item = gtk_tool_button_new(RVAL2GTKWIDGET(icon_widget),
                                       RVAL2CSTR_ACCEPT_NIL(label));
        else if (!NIL_P(stock_id))
            item = gtk_tool_button_new_from_stock(RVAL2GLIBID(stock_id, buffer));
    }
    if (!item)
        rb_raise(rb_eArgError, "Invalid arguments.");

    RBGTK_INITIALIZE(self, item);

    return Qnil;
}
Ejemplo n.º 3
0
/* desktop_toolbar_create */
GtkWidget * desktop_toolbar_create(DesktopToolbar * toolbar,
		gpointer data, GtkAccelGroup * accel)
{
	GtkWidget * ret;
	size_t i;
	DesktopToolbar * p;
	GtkWidget * widget;

	ret = gtk_toolbar_new();
	for(i = 0; toolbar[i].name != NULL; i++)
	{
		p = &toolbar[i];
		if(p->name[0] == '\0')
		{
			p->widget = gtk_separator_tool_item_new();
			gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1);
			continue;
		}
#if !GTK_CHECK_VERSION(3, 10, 0)
		else if(strncmp(p->stock, "gtk-", 4) == 0) /* stock icon */
			p->widget = gtk_tool_button_new_from_stock(p->stock);
#endif
		else if(p->stock != NULL) /* icon name */
		{
			widget = gtk_image_new_from_icon_name(p->stock,
					GTK_ICON_SIZE_LARGE_TOOLBAR);
			p->widget = gtk_tool_button_new(widget, p->name);
		}
		else
			p->widget = gtk_tool_button_new(NULL, _(p->name));
		if(p->callback != NULL)
			g_signal_connect_swapped(G_OBJECT(p->widget), "clicked",
					G_CALLBACK(p->callback), data);
		else
			gtk_widget_set_sensitive(GTK_WIDGET(p->widget), FALSE);
		if(accel != NULL && p->accel != 0)
			gtk_widget_add_accelerator(GTK_WIDGET(p->widget),
					"clicked", accel, p->accel, p->modifier,
					GTK_ACCEL_VISIBLE);
#if 0 /* GTK_CHECK_VERSION(2, 12, 0) */
		/* XXX the default is returned instead of the configuration */
		if(gtk_toolbar_get_style(GTK_TOOLBAR(ret)) == GTK_TOOLBAR_ICONS)
			gtk_tool_item_set_tooltip_text(p->widget, p->name);
#endif
		gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1);
	}
	return ret;
}
Ejemplo n.º 4
0
void widgets_get_bottom_toolbar(GtkWidget **toolbar){
  GtkToolItem *new_tool_item;
  GtkWidget *new_tool_item_icon;

  *toolbar = gtk_toolbar_new();
  gtk_toolbar_set_style(GTK_TOOLBAR(*toolbar), GTK_TOOLBAR_ICONS);
  
  int i;
  int nicons = sizeof toolbar_item_icons / sizeof (*toolbar_item_icons);
  for (i = 0; i < nicons; i++){
    new_tool_item_icon = gtk_image_new_from_file(toolbar_item_icons[i].path_to_image);    
    new_tool_item = gtk_tool_button_new(new_tool_item_icon,toolbar_item_icons[i].name);
    
    FormShifterToolItemType tool_type = toolbar_item_icons[i].type;
    switch(tool_type){
      /*case XPainter_UNDO_TOOL:
	g_signal_connect(new_tool_item, "clicked", G_CALLBACK(undo), NULL);   
	break;
	case XPainter_REDO_TOOL:
	g_signal_connect(new_tool_item, "clicked", G_CALLBACK(redo), NULL);   
	break;*/
      default: 
	g_signal_connect(new_tool_item, "clicked", G_CALLBACK(assign_current_tool), (gpointer) tool_type);
	break;
    }
    gtk_toolbar_insert(GTK_TOOLBAR(*toolbar), new_tool_item, -1);
    gtk_widget_set_can_focus ((GtkWidget*) new_tool_item, TRUE);
  }
}
Ejemplo n.º 5
0
static void
tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model)
{
    gboolean style_is_both;
    gboolean make_two_line;
    GArray *current;
    guint j;
    GActionMap *action_map =
        g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP);

    style_is_both = (model->style == GTK_TOOLBAR_BOTH
                     || (model->style == (GtkToolbarStyle) - 1
                         && tm_default_style() == GTK_TOOLBAR_BOTH));
    make_two_line = style_is_both && tm_has_second_line(model);

    current = balsa_toolbar_model_get_current(model);
    for (j = 0; j < current->len; j++) {
        BalsaToolbarEntry *entry;
        GtkToolItem *item;

        entry = &g_array_index(current, BalsaToolbarEntry, j);

        if (!*entry->action) {
            item = gtk_separator_tool_item_new();
        } else {
            GtkWidget *icon;
            GAction *action;
            const GVariantType *type;
            gchar *prefixed_action;

            icon = gtk_image_new_from_icon_name
                (balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR);
            action = g_action_map_lookup_action(action_map, entry->action);
            if (action &&
                (type = g_action_get_state_type(action)) &&
                g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
                item = gtk_toggle_tool_button_new();
                g_object_set(G_OBJECT(item), "icon-widget", icon,
                             "label", entry->action, NULL);
            } else {
                item = gtk_tool_button_new(icon, entry->action);
            }
            tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon,
                                   make_two_line);

            prefixed_action =
                g_strconcat(action ? "win." : "app.", entry->action, NULL);
            gtk_actionable_set_action_name(GTK_ACTIONABLE(item),
                                           prefixed_action);
            g_free(prefixed_action);
        }
        gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1);
    }

    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),
                          model->style != (GtkToolbarStyle) (-1) ?
                          model->style : tm_default_style());

    gtk_widget_show_all(toolbar);
}
Ejemplo n.º 6
0
int
main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkToolbar *toolbar;
    GtkToolItem *item;

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (window, "delete-event", G_CALLBACK (on_window_delete), NULL);

    toolbar = GTK_TOOLBAR (gtk_toolbar_new ());
    gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_TEXT);
    item = gtk_tool_button_new (NULL, "Prompt");
    g_signal_connect (item, "clicked", G_CALLBACK (on_prompt_clicked), window);
    gtk_toolbar_insert (toolbar, item, 0);
    gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (toolbar));

    gtk_window_set_default_size (GTK_WINDOW (window), 400, 80);
    gtk_widget_show_all (window);

    gtk_main ();

    return 0;
}
Ejemplo n.º 7
0
GtkToolItem * ToolButton::newItem() {
	XOJ_CHECK_TYPE(ToolButton);

	GtkToolItem * it;

	if (!stock.isEmpty()) {
		if (popupMenu) {
			it = gtk_menu_tool_button_new_from_stock(stock.c_str());
			gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu);
		} else {
			it = gtk_tool_button_new_from_stock(stock.c_str());
		}
	} else if (group != GROUP_NOGROUP) {
		if (popupMenu) {
			it = gtk_menu_tool_toggle_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
			gtk_menu_tool_toggle_button_set_menu(GTK_MENU_TOOL_TOGGLE_BUTTON(it), popupMenu);
		} else {
			it = gtk_toggle_tool_button_new();
			gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->gui->loadIcon(iconName.c_str()));
		}
	} else {
		if (popupMenu) {
			it = gtk_menu_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
			gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu);
		} else {
			it = gtk_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
		}
	}
	gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), description.c_str());
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), description.c_str());

	return it;
}
Ejemplo n.º 8
0
GtkWidget *
gtk_utils_append_toolbar_button (GtkToolbar *toolbar,
				 GtkUtilsToolbarEntry *entry,
				 GtkUtilsToolbarButtonFlags flags,
				 gpointer user_data)
{
#if GTK_2_4_OR_LATER

  GtkToolItem *button;

  g_return_val_if_fail (entry, NULL);

  button = gtk_tool_button_new ((gtk_image_new_from_stock
				 (entry->icon_stock_id,
				  gtk_toolbar_get_icon_size (toolbar))),
				(entry->label_text
				 ? _(entry->label_text) : NULL));

  if (entry->tooltip_text) {
    gtk_tool_item_set_tooltip (button, toolbar->tooltips,
			       _(entry->tooltip_text), NULL);
  }

  gtk_tool_item_set_homogeneous (button, ((flags & GTK_UTILS_HOMOGENEOUS)
					  ? TRUE : FALSE));
  gtk_tool_item_set_is_important (button, ((flags & GTK_UTILS_IS_IMPORTANT)
					   ? TRUE : FALSE));

  g_signal_connect (button, "clicked",
		    G_CALLBACK (invoke_toolbar_button_callback), user_data);

  gtk_toolbar_insert (toolbar, button, -1);

#else

  GtkWidget *button;

  g_return_val_if_fail (entry, NULL);

  UNUSED (flags);

  button = (gtk_toolbar_append_item
	    (toolbar, (entry->label_text ? _(entry->label_text) : NULL),
	     _(entry->tooltip_text), NULL,
	     gtk_image_new_from_stock (entry->icon_stock_id,
				       gtk_toolbar_get_icon_size (toolbar)),
	     (GtkSignalFunc) invoke_toolbar_button_callback, user_data));

#endif

  if (!toolbar_button_entry_quark) {
    toolbar_button_entry_quark
      = g_quark_from_static_string ("quarry-toolbar-button-entry");
  }

  g_object_set_qdata (G_OBJECT (button), toolbar_button_entry_quark, entry);

  /* For GTK+ 2.4 and up.  It is certainly a widget. */
  return (GtkWidget *) button;
}
Ejemplo n.º 9
0
static void
schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header)
{
	g_print ("%s ()\n", __FUNCTION__);

	customization_data_init (G_OBJECT (perspective), toolbar, header);

	/* add perspective's actions */
	customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries));

	/* add to toolbar */
	GtkToolItem *titem;
	titem = gtk_toggle_tool_button_new ();
	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic");
	gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites"));
	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
	gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites");
	gtk_widget_show (GTK_WIDGET (titem));
	customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));

#ifdef HAVE_GOOCANVAS
	titem = gtk_tool_button_new (NULL, NULL);
	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic");
	gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram"));
	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
	gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new");
	gtk_widget_show (GTK_WIDGET (titem));
	customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#endif
}
static int
filter_button_add(const char *label, const char *expr, struct filter_expression *newfe)
{
	struct filter_expression *fe;

	/* No duplicate buttons when adding a new one  */
	if (newfe == NULL)
		fe = filter_expression_new(label, expr, TRUE);
	else
		fe = newfe;

	if (fe->enabled == FALSE)
		return(0);

	/* Create the "Label" button */
	fe->button = gtk_tool_button_new(NULL, fe->label);
	g_signal_connect(fe->button, "clicked", G_CALLBACK(filter_button_cb),
	    NULL);
	gtk_widget_set_sensitive(GTK_WIDGET(fe->button), FALSE);
	gtk_widget_show(GTK_WIDGET(fe->button));

	gtk_toolbar_insert(GTK_TOOLBAR(_filter_tb), (GtkToolItem *)fe->button, -1);
	gtk_widget_set_sensitive(GTK_WIDGET(fe->button), TRUE);
	gtk_widget_set_tooltip_text(GTK_WIDGET(fe->button), fe->expression);

	return(0);
}
Ejemplo n.º 11
0
static GtkToolItem * toolbar_button_add (GtkWidget * toolbar,
 void (* callback) (void), const char * icon)
{
    GtkToolItem * item = gtk_tool_button_new (NULL, NULL);
    gtk_tool_button_set_icon_name ((GtkToolButton *) item, icon);
    gtk_toolbar_insert ((GtkToolbar *) toolbar, item, -1);
    g_signal_connect (item, "clicked", callback, NULL);
    return item;
}
Ejemplo n.º 12
0
static void
load_icon_items (GtkToolPalette *palette)
{
  GList *contexts;
  GList *l;
  GtkIconTheme *icon_theme;

  icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (palette)));

  contexts = gtk_icon_theme_list_contexts (icon_theme);
  for (l = contexts; l; l = g_list_next (l))
    {
      gchar *context = l->data;
      GList *icon_names;
      GList *ll;
      const guint max_icons = 10;
      guint icons_count = 0;

      GtkWidget *group = gtk_tool_item_group_new (context);
      gtk_container_add (GTK_CONTAINER (palette), group);

      if (g_strcmp0 (context, "Animations") == 0)
        continue;

      g_message ("Got context '%s'", context);
      icon_names = gtk_icon_theme_list_icons (icon_theme, context);
      icon_names = g_list_sort (icon_names, (GCompareFunc) strcmp);

      for (ll = icon_names; ll; ll = g_list_next (ll))
        {
          GtkToolItem *item;
          gchar *id = ll->data;

          if (g_str_equal (id, "emblem-desktop"))
            continue;

          if (g_str_has_suffix (id, "-symbolic"))
            continue;

          g_message ("Got id '%s'", id);

          item = gtk_tool_button_new (NULL, NULL);
          gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), id);
          gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id);
          gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);

          /* Prevent us having an insane number of icons: */
          ++icons_count;
          if(icons_count >= max_icons)
            break;
        }

      g_list_free_full (icon_names, g_free);
    }

  g_list_free_full (contexts, g_free);
}
Ejemplo n.º 13
0
static void
tab_panel_browser_add_tab_cb (MidoriBrowser*   browser,
                              GtkWidget*       view,
                              MidoriExtension* extension)
{
    GtkWidget* notebook = katze_object_get_object (browser, "notebook");
    gint page = gtk_notebook_page_num (GTK_NOTEBOOK (notebook), view);
    MidoriWebSettings* settings = midori_browser_get_settings (browser);
    gboolean minimized = katze_object_get_boolean (view, "minimized");
    GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view));
    const gchar* title = midori_view_get_display_title (MIDORI_VIEW (view));
    GtkTreeModel* model = tab_panel_get_model_for_browser (browser);

    if (minimized)
    {
        GtkWidget* toolbar = tab_panel_get_toolbar_for_browser (browser);
        GtkWidget* image = gtk_image_new_from_pixbuf (
            midori_view_get_icon (MIDORI_VIEW (view)));
        GtkToolItem* toolitem = gtk_tool_button_new (image, NULL);
        gtk_tool_item_set_tooltip_text (toolitem, title);
        gtk_widget_show (image);
        g_object_set_data (G_OBJECT (view), "tab-panel-ext-toolitem", toolitem);
        gtk_widget_show (GTK_WIDGET (toolitem));
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
        tab_panel_toggle_toolbook (toolbar);
        g_signal_connect (toolitem, "clicked",
            G_CALLBACK (tab_panel_toolitem_clicked_cb), view);
        g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)), "button-press-event",
            G_CALLBACK (tab_panel_toolitem_button_press_event_cb), view);
    }
    else
    {
        GtkTreeIter iter;
        gboolean buttons = katze_object_get_boolean (settings, "close-buttons-on-tabs");
        gint ellipsize = midori_view_get_label_ellipsize (MIDORI_VIEW (view));

        gtk_tree_store_insert_with_values (GTK_TREE_STORE (model),
            &iter, NULL, page, 0, view, 1, GTK_STOCK_CLOSE, 2, buttons,
            3, icon, 4, title, 5, ellipsize, 6, NULL, -1);
    }

    if (!g_signal_handler_find (view, G_SIGNAL_MATCH_FUNC,
        g_signal_lookup ("notify", MIDORI_TYPE_VIEW), 0, NULL,
        tab_panel_view_notify_minimized_cb, extension))
    {
        g_signal_connect (settings, "notify::close-buttons-on-tabs",
            G_CALLBACK (tab_panel_settings_notify_cb), model);
        g_signal_connect (view, "notify::minimized",
            G_CALLBACK (tab_panel_view_notify_minimized_cb), extension);
        g_signal_connect (view, "notify::icon",
            G_CALLBACK (tab_panel_view_notify_icon_cb), extension);
        g_signal_connect (view, "notify::title",
            G_CALLBACK (tab_panel_view_notify_title_cb), extension);
    }

    g_object_unref (notebook);
}
Ejemplo n.º 14
0
static void gigolo_bookmark_panel_init(GigoloBookmarkPanel *self)
{
	GtkWidget *swin, *toolbar;
	GtkToolItem *toolitem;
	GigoloBookmarkPanelPrivate *priv = gigolo_bookmark_panel_get_instance_private(self);

	gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
	toolbar = gtk_toolbar_new();
	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
	gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_BUTTON);

	toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-connect",
			gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
	gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Connect to the selected bookmark"));
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
	g_signal_connect(toolitem, "clicked", G_CALLBACK(button_connect_click_cb), self);
	priv->button_connect = GTK_WIDGET(toolitem);

	toolitem = gtk_separator_tool_item_new();
	gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
	gtk_tool_item_set_expand(toolitem, TRUE);
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);

	toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-close",
			gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
	gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Close panel"));
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
	g_signal_connect(toolitem, "clicked", G_CALLBACK(button_close_click_cb), self);

	tree_prepare(self);

	swin = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_IN);
	gtk_container_add(GTK_CONTAINER(swin), priv->tree);

	gtk_box_pack_start(GTK_BOX(self), toolbar, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(self), swin, TRUE, TRUE, 0);

	gtk_widget_show_all(toolbar);
	gtk_widget_show_all(swin);
}
Ejemplo n.º 15
0
gboolean
download_handle(WebKitDownload *download, gchar *suggested_filename, gpointer data)
{
    gchar *sug_clean, *path, *path2 = NULL, *uri;
    GtkToolItem *tb;
    int suffix = 1;
    size_t i;

    sug_clean = g_strdup(suggested_filename);
    for (i = 0; i < strlen(sug_clean); i++)
        if (sug_clean[i] == G_DIR_SEPARATOR)
            sug_clean[i] = '_';

    path = g_build_filename(download_dir, sug_clean, NULL);
    path2 = g_strdup(path);
    while (g_file_test(path2, G_FILE_TEST_EXISTS) && suffix < 1000)
    {
        g_free(path2);

        path2 = g_strdup_printf("%s.%d", path, suffix);
        suffix++;
    }

    if (suffix == 1000)
    {
        fprintf(stderr, __NAME__": Suffix reached limit for download.\n");
        webkit_download_cancel(download);
    }
    else
    {
        uri = g_filename_to_uri(path2, NULL, NULL);
        webkit_download_set_destination(download, uri);
        g_free(uri);

        tb = gtk_tool_button_new(NULL, NULL);
        gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(tb), "gtk-delete");
        gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), sug_clean);
        gtk_toolbar_insert(GTK_TOOLBAR(dm.toolbar), tb, 0);
        gtk_widget_show_all(dm.win);

        g_signal_connect(G_OBJECT(download), "notify::estimated-progress",
                         G_CALLBACK(changed_download_progress), tb);

        g_object_ref(download);
        g_signal_connect(G_OBJECT(tb), "clicked",
                         G_CALLBACK(downloadmanager_cancel), download);
    }

    g_free(sug_clean);
    g_free(path);
    g_free(path2);

    /* Propagate -- to whom it may concern. */
    return FALSE;
}
Ejemplo n.º 16
0
	/* Checks the passed xmlNode for a recognized item (ToolButton, ToggleToolButton, Separator)
	 * Returns the widget or NULL if nothing useful is found
	 */
	GtkWidget* ToolbarCreator::createToolItem(xml::Node& node, GtkToolbar* toolbar) {
		const std::string nodeName = node.getName();
		GtkWidget* toolItem;

		if (nodeName == "separator") {
			toolItem = GTK_WIDGET(gtk_separator_tool_item_new());
		}
		else if (nodeName == "toolbutton" || nodeName == "toggletoolbutton") {
			// Found a button, load the values that are shared by both types
			const std::string name 		= node.getAttributeValue("name");
			const std::string icon 		= node.getAttributeValue("icon");
			const std::string tooltip 	= _(node.getAttributeValue("tooltip").c_str());
			const std::string action 	= node.getAttributeValue("action");

			if (nodeName == "toolbutton") {
				// Create a new GtkToolButton and assign the right callback
				toolItem = GTK_WIDGET(gtk_tool_button_new(NULL, name.c_str()));

			}
			else {
				// Create a new GtkToggleToolButton and assign the right callback
				toolItem = GTK_WIDGET(gtk_toggle_tool_button_new());

			}

			IEvent* event = GlobalEventManager().findEvent(action);
			if (event != NULL) {
				event->connectWidget(GTK_WIDGET(toolItem));

				// Tell the event to update the state of this button
				event->updateWidgets();
			} else {
				globalErrorStream() << "ToolbarCreator: Failed to lookup command " << action << "\n";
			}

			// Set the tooltip, if not empty
			if (!tooltip.empty()) {
				gtk_tooltips_set_tip(_tooltips, GTK_WIDGET(toolItem), tooltip.c_str(), "");
				//gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(toolItem), _tooltips, tooltip.c_str(), "");
			}

			// Load and assign the icon, if specified
			if (icon != "") {
				GtkWidget* image = gtk_image_new_from_pixbuf(gtkutil::getLocalPixbufWithMask(icon));
				gtk_widget_show(image);
				gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toolItem), image);
			}
		}
		else {
			return NULL;
		}

		gtk_widget_show(toolItem);
		return toolItem;
	}
Ejemplo n.º 17
0
GTKToolButton::GTKToolButton(const char *Text, bool Stock) : GTKToolItem(), Icon(NULL)
{
	g_object_unref(Widget);
	if (Stock)
		ToolItem = gtk_tool_button_new_from_stock(Text);
	else
		ToolItem = gtk_tool_button_new(NULL, Text);
	Widget = GTK_WIDGET(ToolItem);
	Container = GTK_CONTAINER(Widget);
	ToolButton = GTK_TOOL_BUTTON(ToolItem);
}
Ejemplo n.º 18
0
static void add_button(gpointer compose)
{
	GtkWidget *toolbar;
	PrefsCommon *prefs;
	gint n = 0;
	GtkToolItem *item;
	GtkWidget *icon;
	GdkPixbuf *pixbuf;

	if (!config.enable_autoenc) {
		debug_print("autoenc: autoenc is disabled\n");
		return;
	}

	toolbar = syl_plugin_compose_get_toolbar(compose);
	//n = gtk_toolbar_get_n_items(GTK_TOOLBAR(toolbar));

	prefs = prefs_common_get();
	if (prefs->compose_toolbar_setting) {
		gint i;
		gchar **namev;

		namev = g_strsplit(prefs->compose_toolbar_setting, ",", -1);
		for (i = 0; namev[i] != NULL; i++) {
			if (!strcmp(namev[i], "send")) {
				debug_print("send pos: %d\n", i);
				n = i + 1;
				break;
			}
		}
		g_strfreev(namev);
	} else {
		/* send,send-later,draft,... */
		n = 1;
	}

	//icon = stock_pixbuf_widget_for_toolbar(STOCK_PIXMAP_MAIL_SEND);
	pixbuf = gdk_pixbuf_new_from_inline(sizeof(send_enc), send_enc,
					    FALSE, NULL);
	icon = gtk_image_new_from_pixbuf(pixbuf);
	item = gtk_tool_button_new(icon, _("Send with encryption"));
	gtk_tool_item_set_is_important(item, TRUE);
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, n);
	//gtk_widget_show_all(GTK_WIDGET(toolbar));
	gtk_widget_show_all(GTK_WIDGET(item));

	g_object_set_data(G_OBJECT(toolbar), "send-enc-button", item);

	g_signal_connect(G_OBJECT(item), "clicked",
			 G_CALLBACK(send_encryption_clicked), compose);

	change_button_sensitive(compose, GTK_WIDGET(item));
}
Ejemplo n.º 19
0
GtkToolItem* makeNewToolItem(const char* stock,const char* label)
{
	GtkToolItem*				button;
	GtkWidget*					image;
#ifdef _USEGTK3_
	image=gtk_image_new_from_icon_name(stock,GTK_ICON_SIZE_LARGE_TOOLBAR);
	button=gtk_tool_button_new(image,label);
#else
	button=gtk_tool_button_new_from_stock(stock);
#endif

	return(button);
}
Ejemplo n.º 20
0
/**
 * called when hovering an item above the toolbar
 */
gboolean nsgtk_toolbar_action(GtkWidget *widget, GdkDragContext *gdc, gint x,
		gint y, guint time, gpointer data)
{
	nsgtk_scaffolding *g = (nsgtk_scaffolding *)data;
	GtkToolItem *item = gtk_tool_button_new(NULL, NULL);
	if (item != NULL)
		gtk_toolbar_set_drop_highlight_item(
				nsgtk_scaffolding_toolbar(g),
				GTK_TOOL_ITEM(item),
				gtk_toolbar_get_drop_index(
				nsgtk_scaffolding_toolbar(g), x, y));
	return FALSE;
}
Ejemplo n.º 21
0
GtkWidget *
create_toolbar (void)
{
  GtkWidget *toolbar;
  GtkToolItem *item;

  toolbar = gtk_toolbar_new ();
  gtk_widget_set_valign (toolbar, GTK_ALIGN_CENTER);

  item = gtk_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (NULL, "Hello World");
  gtk_tool_item_set_is_important (item, TRUE);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  return toolbar;
}
Ejemplo n.º 22
0
GtkToolItem *hwidget_get_tool_button(const gchar *image_file,
				     const gchar *label,
				     const gchar *tooltips_string,
				     gpointer callback,
				     gpointer data,
				     guint type)
{
	GtkToolItem	*button;
	GtkWidget	*pixmap;
	GtkTooltips	*tooltips;

	switch (type) {
		case HWIDGET_TOGGLE_TOOL_BUTTON:
			button = gtk_toggle_tool_button_new();
			if (callback) {
				g_signal_connect(G_OBJECT(button), "toggled",
						 G_CALLBACK(callback), data);
			}
			break;
		case HWIDGET_TOOL_BUTTON:
			button = gtk_tool_button_new(NULL, NULL);
			if (callback) {
				g_signal_connect(G_OBJECT(button), "clicked",
						 G_CALLBACK(callback), data);
			}
			break;
		default:
			return NULL;
	}

	if (image_file) {
		pixmap = hutil_create_pixmap(image_file);
		gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button),
						pixmap);
	}

	if (label) {
		gtk_tool_button_set_label(GTK_TOOL_BUTTON(button), label);
	}

	if (tooltips_string) {
		tooltips = gtk_tooltips_new();
		gtk_tool_item_set_tooltip(button, tooltips, tooltips_string,
					  NULL);
	}

	return button;
}
Ejemplo n.º 23
0
SelectionSetToolmenu::SelectionSetToolmenu() :
	_toolItem(gtk_tool_item_new()),
	_listStore(gtk_list_store_new(1, G_TYPE_STRING)),
	_clearSetsButton(NULL),
	_entry(gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(_listStore), 0))
{
	// Hbox containing all our items
	GtkWidget* hbox = gtk_hbox_new(FALSE, 3);
	gtk_container_add(GTK_CONTAINER(_toolItem), hbox);

	// Pack Label
	gtk_box_pack_start(GTK_BOX(hbox), 
		gtkutil::LeftAlignedLabel(_("Selection Set: ")), FALSE, FALSE, 0);

	// Pack Combo Box
	gtk_box_pack_start(GTK_BOX(hbox), _entry, TRUE, TRUE, 0);

	// Add tooltip
	gtk_widget_set_tooltip_markup(_entry, _(ENTRY_TOOLTIP));

	// Add clear button
	{
		GtkWidget* image = gtk_image_new_from_pixbuf(GlobalUIManager().getLocalPixbufWithMask("delete.png"));
		gtk_widget_show(image);

		_clearSetsButton = gtk_tool_button_new(image, _("Clear Selection Sets"));
		
		// Set tooltip
		gtk_tool_item_set_tooltip_text(_clearSetsButton, _("Clear Selection Sets"));

		// Connect event
		g_signal_connect(G_OBJECT(_clearSetsButton), "clicked", G_CALLBACK(onDeleteAllSetsClicked), this);

		gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(_clearSetsButton), FALSE, FALSE, 0);
	}

	// Connect the signals
	GtkWidget* childEntry = gtk_bin_get_child(GTK_BIN(_entry));
	g_signal_connect(G_OBJECT(childEntry), "activate", G_CALLBACK(onEntryActivated), this); 

	g_signal_connect(G_OBJECT(_entry), "changed", G_CALLBACK(onSelectionChanged), this);

	// Populate the list
	update();

	// Add self as observer
	GlobalSelectionSetManager().addObserver(*this);
}
Ejemplo n.º 24
0
/*#
    @class GtkToolButton
    @brief A GtkToolItem subclass that displays buttons
    @param icon_widget a GtkMisc widget that will be used as icon widget, or NULL.
    @param label a string that will be used as label, or NULL.

    GtkToolButtons are GtkToolItems containing buttons.

    The label of a GtkToolButton is determined by the properties "label-widget",
    "label", and "stock-id". If "label-widget" is non-NULL, then that widget is
    used as the label. Otherwise, if "label" is non-NULL, that string is used as
    the label. Otherwise, if "stock-id" is non-NULL, the label is determined by
    the stock item. Otherwise, the button does not have a label.

    The icon of a GtkToolButton is determined by the properties "icon-widget" and
    "stock-id". If "icon-widget" is non-NULL, then that widget is used as the icon.
    Otherwise, if "stock-id" is non-NULL, the icon is determined by the stock item.
    Otherwise, the button does not have a icon.
 */
FALCON_FUNC ToolButton::init( VMARG )
{
    MYSELF;
    if ( self->getObject() )
        return;

    const char* spec = "[GtkWidget,S]";
    Gtk::ArgCheck1 args( vm, spec );
    CoreGObject* o_ico = args.getCoreGObject( 0, false );
    const gchar* lbl = args.getCString( 1, false );
#ifndef NO_PARAMETER_CHECK
    if ( o_ico && !CoreObject_IS_DERIVED( o_ico, GtkWidget ) )
        throw_inv_params( spec );
#endif
    GtkWidget* ico = o_ico ? (GtkWidget*) o_ico->getObject() : NULL;
    self->setObject( (GObject*) gtk_tool_button_new( ico, lbl ) );
}
Ejemplo n.º 25
0
static void
add_toolbutton (GtkToolbar *toolbar)
{
  GtkWidget* button;
  char *text;

  text = g_strdup_printf ("Remove %d", ++count);
  button = (GtkWidget *)gtk_tool_button_new (NULL, text);
  g_free (text);
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "play");
  g_signal_connect_swapped (button,
                            "clicked",
                            G_CALLBACK (remove_widget),
                            button);
  gtk_widget_show (button);
  gtk_container_add (GTK_CONTAINER (toolbar), button);
}
Ejemplo n.º 26
0
/**
 * Création d'un GtkToolButton à partir d'une image et d'un label
 *
 * \param image_name    filename
 * \param label_name    label for button
 *
 * \return a GtkToolItem or NULL
 * */
GtkToolItem *utils_buttons_new_from_image_label ( const gchar *image_name,
                        const gchar *label_name )
{
    GtkToolItem *button = NULL;
    gchar *filename;

    filename = g_build_filename ( gsb_dirs_get_pixmaps_dir (), image_name, NULL );
    if ( filename )
    {
        GtkWidget *image;

        image = gtk_image_new_from_file ( filename );
        g_free ( filename );
        button = gtk_tool_button_new ( image, label_name );
    }

    return button;
}
Ejemplo n.º 27
0
static void collecturiCallback(BrowserWindow *window, GtkEntryIconPosition iconPosition, GdkEvent *event)
{
    if (iconPosition == GTK_ENTRY_ICON_SECONDARY) { 
		 g_print("add bookmarkbutton\n");
		/*
		GtkWidget *bookmarkbtn = gtk_button_new();
		GtkBox *hBox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));`
		
        GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon);
		GtkWidget *lab = gtk_label_new(webkit_web_view_get_title(window->webView));
		gtk_box_pack_start(hBox, image, FALSE, FALSE, 0);
		gtk_box_pack_start(hBox, lab, FALSE, FALSE, 0);
		gtk_container_add(GTK_CONTAINER(bookmarkbtn), hBox);
		gtk_box_pack_start(window->bookmarkbox, bookmarkbtn, FALSE, FALSE, 0);
		
		gtk_widget_show_all(bookmarkbtn);
		*/
		
		 GtkToolItem *item = gtk_tool_button_new(NULL, "");
    GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon);
    cairo_surface_t* fivacon = webkit_web_view_get_favicon(window->webView);
    gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), fivacon);

    GtkWidget* label = gtk_label_new (webkit_web_view_get_title(window->webView));
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
    gtk_label_set_max_width_chars (GTK_LABEL (label), 25);
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
    gtk_widget_show (label);
    gtk_tool_button_set_label_widget (GTK_TOOL_BUTTON (item), label);
    //        g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
    gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1);
    gtk_widget_show_all(GTK_WIDGET(item));

		/*
        GtkToolItem *item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME);
//        g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
        gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1);
        gtk_widget_show(GTK_WIDGET(item));
        */
        
//        GdkEventButton *eventButton = (GdkEventButton *)event;
//todo 弹出对话框
    }
}
Ejemplo n.º 28
0
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE obj, label;
    GtkToolItem* item;

    rb_scan_args(argc, argv, "02", &obj, &label);

    if (TYPE(obj) == T_SYMBOL){
        item = gtk_tool_button_new_from_stock(rb_id2name(SYM2ID(obj)));
    } else if (TYPE(obj) == T_STRING){
        item = gtk_tool_button_new_from_stock(RVAL2CSTR(obj));
    } else {
        item = gtk_tool_button_new(GTK_WIDGET(RVAL2GOBJ(obj)), 
                                   NIL_P(label) ? NULL : RVAL2CSTR(label));
    }
    RBGTK_INITIALIZE(self, item);
    return Qnil;
}
Ejemplo n.º 29
0
static void
relations_diagram_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header)
{
    g_print ("%s ()\n", __FUNCTION__);

    customization_data_init (G_OBJECT (page), toolbar, header);

    /* add perspective's actions */
    customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries));

    /* add to toolbar */
    GtkToolItem *titem;
    titem = gtk_tool_button_new (NULL, NULL);
    gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "go-jump-symbolic");
    gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Manage data in selected tables"));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
    gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ViewContents");
    gtk_widget_show (GTK_WIDGET (titem));
    customization_data_add_part (G_OBJECT (page), G_OBJECT (titem));
}
Ejemplo n.º 30
0
static void
query_console_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header)
{
	g_print ("%s ()\n", __FUNCTION__);

	customization_data_init (G_OBJECT (page), toolbar, header);

	/* add perspective's actions */
	customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries));

	/* add to toolbar */
	GtkToolItem *titem;
	titem = gtk_tool_button_new (NULL, NULL);
	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "system-run-symbolic");
	gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Execute query"));
	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
	gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ExecuteQuery");
	gtk_widget_show (GTK_WIDGET (titem));
	customization_data_add_part (G_OBJECT (page), G_OBJECT (titem));
}