Ejemplo n.º 1
0
Archivo: mug.c Proyecto: Chris00/mu
static GtkWidget *
mug_toolbar (MugData * mugdata)
{
	GtkWidget *toolbar;
	int i;
	struct {
		const char *stock_id;
		ToolAction action;
	} tools[] = {
		{"go-up", ACTION_PREV_MSG},
		{"go-down", ACTION_NEXT_MSG},
		{NULL, ACTION_SEPARATOR},
		{"view-refresh", ACTION_REINDEX},
		{NULL, ACTION_SEPARATOR},
		{"help-about", ACTION_ABOUT},
		{NULL, ACTION_SEPARATOR},
		{"application-exit", ACTION_DO_QUIT}};

	toolbar = gtk_toolbar_new ();
	for (i = 0; i != G_N_ELEMENTS (tools); ++i) {
		if (tools[i].action == ACTION_SEPARATOR) { /* separator? */
			gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
					    gtk_separator_tool_item_new (), i);
			continue;
		} else /* nope: a real item */
			gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
					    get_connected_tool_button
					    (tools[i].stock_id, tools[i].action,
					     mugdata), i);
	}

	return toolbar;
}
Ejemplo n.º 2
0
/** Inserts a toolbar item before the Quit button, or after the previous plugin toolbar item.
 * A separator is added on the first call to this function, and will be shown when @a item is
 * shown; hidden when @a item is hidden.
 * @note You should still destroy @a item yourself, usually in @ref plugin_cleanup().
 * @param plugin Must be @ref geany_plugin.
 * @param item The item to add. */
GEANY_API_SYMBOL
void plugin_add_toolbar_item(GeanyPlugin *plugin, GtkToolItem *item)
{
	GtkToolbar *toolbar = GTK_TOOLBAR(main_widgets.toolbar);
	gint pos;
	GeanyAutoSeparator *autosep;

	g_return_if_fail(plugin);
	autosep = &plugin->priv->toolbar_separator;

	if (!autosep->widget)
	{
		GtkToolItem *sep;

		pos = toolbar_get_insert_position();

		sep = gtk_separator_tool_item_new();
		gtk_toolbar_insert(toolbar, sep, pos);
		autosep->widget = GTK_WIDGET(sep);

		toolbar_item_ref(sep);
	}
	else
	{
		pos = gtk_toolbar_get_item_index(toolbar, GTK_TOOL_ITEM(autosep->widget));
		g_return_if_fail(pos >= 0);
	}

	gtk_toolbar_insert(toolbar, item, pos + autosep->item_count + 1);
	toolbar_item_ref(item);

	/* hide the separator widget if there are no toolbar items showing for the plugin */
	ui_auto_separator_add_ref(autosep, GTK_WIDGET(item));
}
Ejemplo n.º 3
0
static void remmina_main_create_quick_search(RemminaMain *remminamain)
{
	GtkWidget *widget;
	GValue val =
	{ 0 };

	remminamain->priv->quick_search_separator = gtk_separator_tool_item_new();
	gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_separator, -1);

	remminamain->priv->quick_search_item = gtk_tool_item_new();
	gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_item, -1);

	widget = gtk_entry_new();
	gtk_widget_show(widget);
	gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND);
	gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
	gtk_entry_set_width_chars(GTK_ENTRY(widget), 25);
	gtk_container_add(GTK_CONTAINER(remminamain->priv->quick_search_item), widget);

	g_value_init(&val, G_TYPE_BOOLEAN);
	g_value_set_boolean(&val, FALSE);
	g_object_set_property(G_OBJECT(widget), "primary-icon-activatable", &val);
	g_value_unset(&val);

	g_signal_connect(G_OBJECT(widget), "icon-press", G_CALLBACK(remmina_main_quick_search_on_icon_press), remminamain);
	g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_main_quick_search_on_changed), remminamain);

	remminamain->priv->quick_search_entry = widget;
}
Ejemplo n.º 4
0
void
nautilus_navigation_window_activate_spinner (NautilusNavigationWindow *window)
{
	GtkToolItem *item;
	GtkWidget *spinner;

	if (window->details->spinner != NULL) {
		return;
	}

	item = gtk_tool_item_new ();
	gtk_widget_show (GTK_WIDGET (item));
	gtk_tool_item_set_expand (item, TRUE);
	gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar),
			    item, -1);

	spinner = gtk_spinner_new ();
	gtk_widget_show (GTK_WIDGET (spinner));

	item = gtk_tool_item_new ();
	gtk_container_add (GTK_CONTAINER (item), spinner);
	gtk_widget_show (GTK_WIDGET (item));

	gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar),
			    item, -1);

	window->details->spinner = spinner;
}
Ejemplo n.º 5
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.º 6
0
/* Create a toolbar with cut, copy, paste and select all */
static void create_toolbar( GtkWidget *toolbar, GtkWidget *entry ) {
  GtkToolItem *cut = gtk_tool_button_new_from_stock( GTK_STOCK_CUT );
  GtkToolItem *copy = gtk_tool_button_new_from_stock( GTK_STOCK_COPY );
  GtkToolItem *paste = gtk_tool_button_new_from_stock( GTK_STOCK_PASTE );
  GtkToolItem *selectall = gtk_tool_button_new_from_stock( 
      GTK_STOCK_SELECT_ALL );
  GtkToolItem *separator = gtk_separator_tool_item_new();

  gtk_toolbar_set_show_arrow( GTK_TOOLBAR( toolbar ), TRUE );
  gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_BOTH );

  gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), cut, 0 );
  gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), copy, 1 );
  gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), paste, 2 );
  gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), separator, 3 );
  gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), selectall, 4 );

  g_signal_connect_swapped( G_OBJECT( cut ), "clicked",
      G_CALLBACK( gtk_editable_cut_clipboard ), entry );
  g_signal_connect_swapped( G_OBJECT( copy ), "clicked",
      G_CALLBACK( gtk_editable_copy_clipboard ), entry );
  g_signal_connect_swapped( G_OBJECT( paste ), "clicked",
      G_CALLBACK( gtk_editable_paste_clipboard ), entry );
  g_signal_connect_swapped( G_OBJECT( selectall ), "clicked",
      G_CALLBACK( select_all ), entry );
}
static GtkWidget* create_toolbar()
{
 GtkWidget* toolbar=gtk_toolbar_new();

 gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
 gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);

 GtkToolItem* item;

// botao para voltar
 item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
 g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// botao para ir para url que esta antes
 item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
 g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// form de entrada de url
 item = gtk_tool_item_new();
 gtk_tool_item_set_expand(item, TRUE);
 uri_entry = gtk_entry_new();
 gtk_container_add(GTK_CONTAINER (item), uri_entry);
 g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// botao bara ir e abrir
 item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
 g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

 return toolbar;
}
Ejemplo n.º 8
0
GtkWidget *hwidget_get_toolbar(HviewWidgetsT *w)
{
	GtkWidget		*tbar;
	GtkToolItem		*but;

	tbar = gtk_toolbar_new();
	gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_BOTH);

	but = hwidget_get_tool_button("close.png", "Close", "Close session",
		      		      hview_session_close_call, w,
				      HWIDGET_TOOL_BUTTON);
	gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);

	but = hwidget_get_tool_button("discover.png", "Discover",
				      "Discover domain", hview_discover_call,
				      w, HWIDGET_TOOL_BUTTON);
	gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);

	but = hwidget_get_tool_button("sub_events.png", "Subscribe",
				       "Subscribe events",
				       hview_subscribe_events_call,
				       w,
				       HWIDGET_TOOL_BUTTON);
	gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);
	w->subev_item = but;

	but = hwidget_get_tool_button("get_events.png", "Get event",
				      "Get event", hview_get_events_call,
				      w, HWIDGET_TOOL_BUTTON);
	gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);

	return tbar;
}
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
}
Ejemplo n.º 10
0
static void
add_section_toolbar (CEPageIP6 *page, GtkWidget *section, GCallback add_cb)
{
        GtkWidget *toolbar;
        GtkToolItem *item;
        GtkStyleContext *context;
        GtkWidget *box;
        GtkWidget *button;
        GtkWidget *image;

        toolbar = gtk_toolbar_new ();
        gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
        gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
        context = gtk_widget_get_style_context (toolbar);
        gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
        gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR);
        gtk_container_add (GTK_CONTAINER (section), toolbar);

        item = gtk_separator_tool_item_new ();
        gtk_tool_item_set_expand (item, TRUE);
        gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 0);

        box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
        item = gtk_tool_item_new ();
        gtk_container_add (GTK_CONTAINER (item), box);
        button = gtk_button_new ();
        g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_cb), page);
        image = gtk_image_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU);
        atk_object_set_name (gtk_widget_get_accessible (button), _("Add"));
        gtk_button_set_image (GTK_BUTTON (button), image);
        gtk_container_add (GTK_CONTAINER (box), button);
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 1);
}
SidebarToolbar::SidebarToolbar(Control* control)
{
	XOJ_INIT_TYPE(SidebarToolbar);

	this->control = control;
	this->toolbar = GTK_TOOLBAR(gtk_toolbar_new());

	gtk_toolbar_set_icon_size(this->toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);

	g_object_ref(this->toolbar);

	this->btUp = gtk_tool_button_new_from_stock(GTK_STOCK_GO_UP);
	gtk_toolbar_insert(this->toolbar, this->btUp, -1);
	g_signal_connect(this->btUp, "clicked", G_CALLBACK(&btUpClicked), this);

	this->btDown = gtk_tool_button_new_from_stock(GTK_STOCK_GO_DOWN);
	gtk_toolbar_insert(this->toolbar, this->btDown, -1);
	g_signal_connect(this->btDown, "clicked", G_CALLBACK(&btDownClicked), this);

	this->btCopy = gtk_tool_button_new_from_stock(GTK_STOCK_COPY);
	gtk_toolbar_insert(this->toolbar, this->btCopy, -1);
	g_signal_connect(this->btCopy, "clicked", G_CALLBACK(&btCopyClicked), this);

	this->btDelete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
	gtk_toolbar_insert(this->toolbar, this->btDelete, -1);
	g_signal_connect(this->btDelete, "clicked", G_CALLBACK(&btDeleteClicked), this);

	gtk_widget_show_all(GTK_WIDGET(this->toolbar));
}
Ejemplo n.º 12
0
static void create_toolbar() {
    browser->toolbar = gtk_toolbar_new();
#ifndef GTK_ORIENTABLE
    gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ);

    GtkToolItem* item;
    /* the back button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The forward button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The URL entry */
    item = gtk_tool_item_new();
    gtk_tool_item_set_expand(item, TRUE);

    browser->uri_entry = gtk_entry_new();
    gtk_container_add(GTK_CONTAINER (item), browser->uri_entry);
    g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The go button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
    g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
}
Ejemplo n.º 13
0
static GtkWidget *
mug_toolbar (MugData * mugdata)
{
	GtkWidget *toolbar;
	int i;
	struct {
		const char *stock_id;
		ToolAction action;
	} tools[] = {
		{GTK_STOCK_GO_UP, ACTION_PREV_MSG},
		{GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG},
		{NULL, ACTION_SEPARATOR},
		{GTK_STOCK_REFRESH, ACTION_REINDEX},
		{NULL, ACTION_SEPARATOR},
		{GTK_STOCK_ABOUT, ACTION_ABOUT},
		{NULL, ACTION_SEPARATOR},
		{GTK_STOCK_QUIT, ACTION_DO_QUIT}};

	toolbar = gtk_toolbar_new ();
	for (i = 0; i != G_N_ELEMENTS (tools); ++i) {
		if (tools[i].action == ACTION_SEPARATOR) { /* separator? */
			gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
					    gtk_separator_tool_item_new (), i);
			continue;
		} else /* nope: a real item */
			gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
					    get_connected_tool_button
					    (tools[i].stock_id, tools[i].action,
					     mugdata), i);
	}

	return toolbar;
}
Ejemplo n.º 14
0
GtkWidget *toolbar_init(GtkWindow *parent)
{
	GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
	GtkToolbar *toolbar;
	GtkActionGroup *ag = gtk_action_group_new("Actions");
	gtk_action_group_add_actions(ag, action_items,
					G_N_ELEMENTS(action_items), parent);
	gtk_action_group_add_toggle_actions(ag, toggle_items,
					G_N_ELEMENTS(toggle_items), parent);

	GtkUIManager *ui = gtk_ui_manager_new();
	g_object_set_data(G_OBJECT(parent), "ui_manager", ui);
	gtk_ui_manager_insert_action_group(ui, ag, 0);
	GtkAccelGroup *accel = gtk_ui_manager_get_accel_group(ui);
	gtk_window_add_accel_group(parent, accel);

	GError *error = NULL;
        if (!gtk_ui_manager_add_ui_from_string (ui, ui_xml, -1, &error)) {
                g_message ("building menus failed: %s", error->message);
                g_error_free (error);
                exit (-1);
        }

	GtkWidget *menubar = gtk_ui_manager_get_widget(ui, "/menubar");
	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menubar), FALSE, TRUE, 0);
	toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget(ui, "/toolbar"));
	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), FALSE, TRUE, 0);

	/* Device selection GtkComboBox */
	GtkToolItem *toolitem = gtk_tool_item_new();
	GtkWidget *dev = dev_select_combo_box_new(parent);

	gtk_container_add(GTK_CONTAINER(toolitem), dev);
	gtk_toolbar_insert(toolbar, toolitem, 0);

	/* Time/Samples entry */
	toolitem = gtk_tool_item_new();
	GtkWidget *timesamples = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(timesamples), "100");
	gtk_entry_set_alignment(GTK_ENTRY(timesamples), 1.0);
	gtk_widget_set_size_request(timesamples, 100, -1);
	gtk_container_add(GTK_CONTAINER(toolitem), timesamples);
	gtk_toolbar_insert(toolbar, toolitem, 7);

	/* Time unit combo box */
	toolitem = gtk_tool_item_new();
	GtkWidget *timeunit = gtk_combo_box_new_text();
	gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "samples");
	gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "ms");
	gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "s");
	gtk_combo_box_set_active(GTK_COMBO_BOX(timeunit), 0);
	gtk_container_add(GTK_CONTAINER(toolitem), timeunit);
	gtk_toolbar_insert(toolbar, toolitem, 8);

	g_object_set_data(G_OBJECT(parent), "timesamples", timesamples);
	g_object_set_data(G_OBJECT(parent), "timeunit", timeunit);

	return GTK_WIDGET(vbox);
}
Ejemplo n.º 15
0
void make_toolbar(Viewer *viewer, GtkWidget *parent)
{
    GtkWidget *toolbar = gtk_toolbar_new();
    gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, FALSE, 0);

    // add a recording button to the toolbar
    viewer->record_button = GTK_WIDGET(
        gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_RECORD));
    gtk_tool_item_set_is_important (GTK_TOOL_ITEM (viewer->record_button), 
            TRUE);
    gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (viewer->record_button), 
            viewer->tips,
            "Record an AVI of the viewport, saved in the current directory",
            NULL);

    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), 
            GTK_TOOL_ITEM (viewer->record_button), 0);
    gtk_widget_show (viewer->record_button);
    g_signal_connect (G_OBJECT (viewer->record_button), "toggled", 
            G_CALLBACK (on_record_toggled), viewer);

    // screenshot button
    GtkToolItem *ssbt = gtk_tool_button_new_from_stock (GTK_STOCK_FLOPPY);
    gtk_tool_button_set_label (GTK_TOOL_BUTTON (ssbt), "Screenshot");
    gtk_tool_item_set_is_important (GTK_TOOL_ITEM (ssbt), TRUE);
    gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (ssbt), viewer->tips,
            "Save a PPM screenshot of the viewport to the current directory",
            NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), ssbt, 1);
    gtk_widget_show (GTK_WIDGET (ssbt));
    g_signal_connect (G_OBJECT (ssbt), "clicked", 
            G_CALLBACK (on_screenshot_clicked), viewer);

    // quit button
    GtkToolItem *quitbt = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
    gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (quitbt), viewer->tips,
            "Quit", NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), quitbt, 2);
    gtk_widget_show (GTK_WIDGET (quitbt));
    g_signal_connect (G_OBJECT (quitbt), "clicked", gtk_main_quit, NULL);

    GtkToolItem * sep = gtk_separator_tool_item_new ();
    gtk_widget_show (GTK_WIDGET (sep));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), sep, 3);

    GtkWidget * hbox = gtk_hbox_new (FALSE, 5);
    GtkWidget * label = gtk_label_new ("Record FPS");
    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
    viewer->fps_spin = gtk_spin_button_new_with_range (0.1, 120.0, 1.0);
    gtk_spin_button_set_digits (GTK_SPIN_BUTTON (viewer->fps_spin), 1);
    gtk_spin_button_set_value (GTK_SPIN_BUTTON (viewer->fps_spin), 30);
    gtk_box_pack_start (GTK_BOX (hbox), viewer->fps_spin, FALSE, FALSE, 0);

    GtkToolItem * toolitem = gtk_tool_item_new ();
    gtk_container_add (GTK_CONTAINER (toolitem), hbox);
    gtk_widget_show_all (GTK_WIDGET (toolitem));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 4);
    viewer->toolbar = GTK_TOOLBAR (toolbar);
}
Ejemplo n.º 16
0
static void
populate_window (GtkWidget * win, ViewerCbInfo * info, int xid, gint win_width, gint win_height)
{
    GtkWidget *vbox;
    GtkWidget *scroll;
    gint img_width, img_height;

    vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (win), vbox);

    /* create a new image */
    info->image = gtk_image_new_from_pixbuf (info->pixbuf);

    /* pack the window with the image */
    img_width = gdk_pixbuf_get_width (info->pixbuf);
    img_height = gdk_pixbuf_get_height (info->pixbuf);

    if (xid <= 0) {
		GtkWidget *toolbar;
		GtkToolItem *toolitem;
		GtkRequisition requisition;

        toolbar = gtk_toolbar_new ();
        gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);

        toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_IN);
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 0);
        g_signal_connect (G_OBJECT (toolitem), "clicked", G_CALLBACK (zoom_in), info);

        toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_OUT);
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 1);
        g_signal_connect (G_OBJECT (toolitem), "clicked", G_CALLBACK (zoom_out), info);

		gtk_widget_size_request(toolbar, &requisition);

		/* HACK: adjust for frame width & height + packing borders */
		img_height += requisition.height + 30;
		win_height += requisition.height + 30;
		img_width  += 20;
		win_width  += 20;
    }

    if ((xid > 0 && (img_width > win_width || img_height > win_height))
        || (xid <= 0)) {
        gtk_window_set_default_size (GTK_WINDOW (win), MIN (img_width, win_width),
                                     MIN (img_height, win_height));

        scroll = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), info->image);
        gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
    } else {
        gtk_box_pack_start (GTK_BOX (vbox), info->image, TRUE, TRUE, 0);
        gtk_window_set_default_size (GTK_WINDOW (win), img_width, img_height);
    }
}
Ejemplo n.º 17
0
static void activate(GtkApplication *app, gpointer user_data) {

  GtkWidget *window;
  GtkWidget *grid;

  GtkWidget *toolbar;
  GtkToolItem *tool_item;

  GtkWidget *notes;


  int position = 0; // toolbar position

  // Create a window with a title, default size, and set border width
  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW(window), "GUI: notebook");
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_container_set_border_width (GTK_CONTAINER(window), 10);  

  // ------------- TOOLBAR ----------------
  // Create a basic toolbar
  toolbar = gtk_toolbar_new();
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH);

  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);

  tool_item = gtk_separator_tool_item_new();
  gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(tool_item), FALSE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);

  tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_CLOSE);
  // connect application quit callback here
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);


  // ------------- NOTEPAD -----------------

  notes = gtk_notebook_new();

  gtk_notebook_append_page(GTK_NOTEBOOK(notes), 
			   create_notepage_fileselect(), 
			   gtk_label_new("Config"));

  // Create a full-window grid to contain toolbar and the notebook
  grid = gtk_grid_new();
  gtk_grid_attach (GTK_GRID(grid), toolbar, 0, 0, 1, 1);
  gtk_grid_attach (GTK_GRID(grid), notes, 0, 1, 1, 1);

  gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(grid));


  gtk_widget_show_all (window);
}
Ejemplo n.º 18
0
static void
tenso_properties_dialog(GtkButton * CodecButt, struct ALL_DATA *all_data)
{
  struct GWIDGET *gwidget = all_data->gwidget;
  GtkTextIter start, end;
  GtkTextIter iter;

  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
      gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
      gtk_window_set_title(GTK_WINDOW(window), "Tenso incoming data");
      gtk_container_set_border_width(GTK_CONTAINER(window), 5);

  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);

  //-------------------------tool bar--------------------------------------------
  GtkWidget *toolbar = gtk_toolbar_new();
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  GtkToolItem *startBtn = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), startBtn, -1);

  GtkToolItem *stopBtn = gtk_tool_button_new_from_stock(GTK_STOCK_CANCEL);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stopBtn, -1);

  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);

  GtkWidget *view = gtk_text_view_new();
    gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0);

  gwidget->tenso_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "gap", "pixels_above_lines", 30, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "lmarg", "left_margin", 5, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "blue_fg", "foreground", "blue", NULL); 
    gtk_text_buffer_get_iter_at_offset(gwidget->tenso_buffer, &iter, 0);

    gtk_text_buffer_insert_with_tags_by_name(gwidget->tenso_buffer, &iter, "Tenso test output\n", -1, "blue_fg", "lmarg",  NULL);
    gtk_text_buffer_insert(gwidget->tenso_buffer, &iter, "Waiting...\n", -1);

  GtkWidget *statusbar = gtk_statusbar_new();
      gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
      update_statusbar(gwidget->tenso_buffer, GTK_STATUSBAR (statusbar));

  gtk_container_add(GTK_CONTAINER(window), vbox);

 
  g_signal_connect(G_OBJECT(startBtn), "clicked", 
        G_CALLBACK(tenso_startBtn_clicked), all_data);
  
  g_signal_connect(G_OBJECT(stopBtn), "clicked", 
        G_CALLBACK(tenso_stopBtn_clicked), all_data);
  
  gtk_widget_show_all(window);

}
Ejemplo n.º 19
0
static void
gcal_toolbar_constructed (GObject *object)
{
  GcalToolbarPrivate *priv;

  GtkStyleContext *context;
  GtkToolItem *spacer;
  GtkWidget *bin;

  priv = GCAL_TOOLBAR (object)->priv;
  if (G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed != NULL)
    G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed (object);

  priv->widget = gtk_toolbar_new ();
  gtk_widget_set_hexpand (priv->widget, TRUE);
  gtk_widget_set_vexpand (priv->widget, TRUE);
  gtk_toolbar_set_icon_size (GTK_TOOLBAR (priv->widget),
                             GTK_ICON_SIZE_BUTTON);

  context = gtk_widget_get_style_context (priv->widget);
  gtk_style_context_add_class (context, "main-toolbar");

  /* adding toolbar */
  bin = gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (object));
  gtk_container_add (GTK_CONTAINER (bin), priv->widget);

  /* adding sections */
  /* left */
  priv->left_item = gtk_tool_item_new ();
  gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->left_item, 0);

  /* spacer */
  spacer = gtk_tool_item_new ();
  gtk_tool_item_set_expand (spacer, TRUE);
  gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1);

  /* central */
  priv->central_item = gtk_tool_item_new ();
  gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->central_item, -1);

  /* spacer */
  spacer = gtk_tool_item_new ();
  gtk_tool_item_set_expand (spacer, TRUE);
  gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1);

  /* right */
  priv->right_item = gtk_tool_item_new ();
  gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->right_item, -1);

  gcal_toolbar_set_overview_mode (GCAL_TOOLBAR (object));
  gtk_widget_show_all (bin);
}
Ejemplo n.º 20
0
int main(int argc,char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;

    GtkWidget *toolbar;
    GtkWidget *undo;
    GtkWidget *redo;
    GtkWidget *sep;
    GtkWidget *exit;

    gtk_init(&argc,&argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window),250,200);
    gtk_window_set_title(GTK_WINDOW(window),"undoredo");

    vbox = gtk_vbox_new(FALSE,0);
    gtk_container_add(GTK_CONTAINER(window),vbox);

    toolbar = gtk_toolbar_new();
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),GTK_TOOLBAR_ICONS);
    gtk_container_set_border_width(GTK_CONTAINER(toolbar),2);

    undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
    gtk_widget_set_name(GTK_WIDGET(undo),"undo");
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar),undo,-1);

    redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar),redo,-1);

    sep = gtk_separator_tool_item_new();
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar),sep,-1);

    exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar),exit,-1);

    gtk_box_pack_start(GTK_BOX(vbox),toolbar,FALSE,FALSE,5);

    g_signal_connect(G_OBJECT(undo),"clicked",G_CALLBACK(undo_redo),redo);
    g_signal_connect(G_OBJECT(redo),"clicked",G_CALLBACK(undo_redo),undo);
    g_signal_connect(G_OBJECT(exit),"clicked",G_CALLBACK(gtk_main_quit),NULL);
    g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);

    gtk_widget_show_all(window);
    gtk_main();

    return 0;
}
Ejemplo n.º 21
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.º 22
0
static void
page_holder_app_add_browser_cb (MidoriApp*       app,
                                MidoriBrowser*   browser,
                                MidoriExtension* extension)
{
    GtkWidget* panel;
    GtkWidget* notebook;
    GtkWidget* toolbar;
    GtkToolItem* toolitem;

    panel = katze_object_get_object (browser, "panel");
    notebook = gtk_notebook_new ();
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT);
    gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
    gtk_widget_show (notebook);
    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);
    gtk_widget_show (toolbar);

    toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO);
    gtk_tool_item_set_is_important (toolitem, TRUE);
    g_signal_connect (toolitem, "clicked",
                      G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook);
    gtk_widget_show (GTK_WIDGET (toolitem));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);

    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);
    gtk_widget_show (GTK_WIDGET (toolitem));

    toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD);
    gtk_tool_item_set_is_important (toolitem, TRUE);
    g_signal_connect (toolitem, "clicked",
                      G_CALLBACK (page_holder_button_add_clicked_cb), notebook);
    gtk_widget_show (GTK_WIDGET (toolitem));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);

    midori_panel_append_widget (MIDORI_PANEL (panel), notebook,
                                /* i18n: A panel showing a user specified web page */
                                STOCK_PAGE_HOLDER, _("Pageholder"), toolbar);
    g_signal_connect (extension, "deactivate",
                      G_CALLBACK (page_holder_deactivate_cb), notebook);

    g_object_unref (panel);
}
Ejemplo n.º 23
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.º 24
0
static void
item_added_cb (EggToolbarsModel   *model,
	       int                 tpos,
	       int                 ipos,
	       EggEditableToolbar *etoolbar)
{
  GtkWidget *dock;
  GtkWidget *toolbar;
  GtkToolItem *item;

  toolbar = get_toolbar_nth (etoolbar, tpos);
  item = create_item_from_position (etoolbar, tpos, ipos);
  if (item == NULL) return;

  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, ipos);

  connect_widget_signals (GTK_WIDGET (item), etoolbar);
  configure_item_tooltip (item);
  configure_item_cursor (item, etoolbar);
  configure_item_sensitivity (item, etoolbar);

  dock = get_dock_nth (etoolbar, tpos);
  gtk_widget_set_size_request (dock, -1, -1);
  gtk_widget_queue_resize_no_redraw (dock);

  toolbar_visibility_refresh (etoolbar);
}
Ejemplo n.º 25
0
/**
 * physically add widgets to store window
 */
bool nsgtk_toolbar_add_store_widget(GtkWidget *widget)
{
	if (window->numberh >= NSGTK_STORE_WIDTH) {
		window->currentbar = gtk_toolbar_new();
		if (window->currentbar == NULL) {
			warn_user("NoMemory", 0);
			return false;
		}
		gtk_toolbar_set_style(GTK_TOOLBAR(window->currentbar),
				GTK_TOOLBAR_BOTH);
		gtk_toolbar_set_icon_size(GTK_TOOLBAR(window->currentbar),
				GTK_ICON_SIZE_LARGE_TOOLBAR);
		gtk_box_pack_start(GTK_BOX(window->widgetvbox),
			window->currentbar, FALSE, FALSE, 0);
		window->numberh = 0;
	}
	gtk_widget_set_size_request(widget, NSGTK_BUTTON_WIDTH,
			NSGTK_BUTTON_HEIGHT);
	gtk_toolbar_insert(GTK_TOOLBAR(window->currentbar), GTK_TOOL_ITEM(
			widget), window->numberh++);
	gtk_tool_item_set_use_drag_window(GTK_TOOL_ITEM(widget), TRUE);
	gtk_drag_source_set(widget, GDK_BUTTON1_MASK, &entry, 1,
			GDK_ACTION_COPY);
	gtk_widget_show_all(window->window);
	return true;
}
Ejemplo n.º 26
0
/*	Creates a toolbar based on the data found in the passed xmlNode
 * 	Returns the fully populated GtkToolbar 	
 */
GtkToolbar* ToolbarManager::createToolbar(xml::Node& node) {
	// Get all action children elements 
	xml::NodeList toolItemList = node.getChildren();
	GtkWidget* toolbar;
		
	if (!toolItemList.empty()) {
		// Create a new toolbar
		toolbar = gtk_toolbar_new();
		gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
		
		// Try to set the alignment, if the attribute is properly set
		std::string align = node.getAttributeValue("align");
		GtkOrientation orientation = (align == "vertical") ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
		gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), orientation);
		
		for (std::size_t i = 0; i < toolItemList.size(); i++) {
			// Create and get the toolItem with the parsing 
			GtkWidget* toolItem = createToolItem(toolItemList[i]);
			
			// It is possible that no toolItem is returned, only add it if it's safe to do so
			if (toolItem != NULL) {    				
				gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(toolItem), -1);    				
			}
		}
	}
	else {
		throw std::runtime_error("No elements in toolbar.");
	}
	
	return GTK_TOOLBAR(toolbar);
}
Ejemplo n.º 27
0
void ui_common_toolbar_append_separator(GtkWidget * toolbar) {
  GtkToolItem * toolbar_item;
  toolbar_item =  gtk_separator_tool_item_new();
  gtk_tool_item_set_homogeneous(toolbar_item, FALSE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolbar_item, -1);
  return;
}
Ejemplo n.º 28
0
/*********************************************************************************************************
* gui functions
*/
void create_filter()
{
    GtkToolItem* toolitem;
    GtkWidget* label;
    GtkWidget* hbox;

    hbox = gtk_hbox_new(FALSE, 0);
    toolitem = gtk_tool_item_new(); /* This is how gtk does more complex toolbar items. */
    gtk_tool_item_set_expand(toolitem, TRUE);

    g_MainWindow.filterBar = gtk_toolbar_new();
    gtk_toolbar_set_orientation(GTK_TOOLBAR(g_MainWindow.filterBar), GTK_ORIENTATION_HORIZONTAL);

    label = gtk_label_new_with_mnemonic(tr("F_ilter:"));
    g_MainWindow.filter = gtk_entry_new();
    gtk_label_set_mnemonic_widget(GTK_LABEL(label), g_MainWindow.filter);
    gtk_entry_set_text(GTK_ENTRY(g_MainWindow.filter), "");

    g_signal_connect(g_MainWindow.filter, "changed", G_CALLBACK(callback_apply_filter), NULL);
    g_signal_connect(g_MainWindow.filter, "activate", G_CALLBACK(callback_apply_filter), NULL);
    g_signal_connect(g_MainWindow.filter, "focus-in-event", G_CALLBACK(callback_filter_selected), NULL);
    g_signal_connect(g_MainWindow.filter, "focus-out-event", G_CALLBACK(callback_filter_unselected), NULL);
    g_signal_connect(g_MainWindow.filter, "grab-notify", G_CALLBACK(callback_filter_grab_unselected), NULL);

    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
    gtk_box_pack_start(GTK_BOX(hbox), g_MainWindow.filter, TRUE, TRUE, 5);

    gtk_container_add(GTK_CONTAINER(toolitem), hbox);
    gtk_toolbar_insert(GTK_TOOLBAR(g_MainWindow.filterBar), toolitem, 0);

    gtk_box_pack_start(GTK_BOX(g_MainWindow.toplevelVBox), g_MainWindow.filterBar, FALSE, FALSE, 0);
}
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.º 30
0
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkToolbar_gtk_1toolbar_1insert
(
	JNIEnv* env,
	jclass cls,
	jlong _self,
	jlong _item,
	jint _pos
)
{
	GtkToolbar* self;
	GtkToolItem* item;
	gint pos;

	// convert parameter self
	self = (GtkToolbar*) _self;

	// convert parameter item
	item = (GtkToolItem*) _item;

	// convert parameter pos
	pos = (gint) _pos;

	// call function
	gtk_toolbar_insert(self, item, pos);

	// cleanup parameter self

	// cleanup parameter item

	// cleanup parameter pos
}