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;
}
Exemple #2
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);
}
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);
}
Exemple #4
0
static GtkWidget *create_toolbar(void)
{
	GtkWidget *toolbar, *item;
	GtkToolItem *tool_item;

	toolbar = gtk_toolbar_new();
	gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

	tool_item = gtk_menu_tool_button_new(NULL, NULL);
	gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO);
	item = (GtkWidget*)tool_item;
	gtk_widget_set_tooltip_text(item, _("Show the current document"));
	gtk_container_add(GTK_CONTAINER(toolbar), item);
	g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL);

	item = gtk_menu_new();
	gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item);
	g_signal_connect(item, "show", G_CALLBACK(on_doc_menu_show), NULL);

	tool_item = gtk_tool_item_new();
	gtk_tool_item_set_expand(tool_item, TRUE);
	gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item));

	item = gtk_label_new(NULL);
	gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START);
	gtk_container_add(GTK_CONTAINER(tool_item), item);
	edit_window.name_label = item;

	item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL);
	gtk_container_add(GTK_CONTAINER(toolbar), item);
	g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL);

	return toolbar;
}
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;
}
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);
}
int
main                                            (int argc, 
                                                 char **args)
{
    gtk_init (&argc, &args);
    
    HildonProgram *program = hildon_program_get_instance ();

    GtkWidget *window = hildon_window_new ();
    hildon_program_add_window (program, HILDON_WINDOW (window));

    gtk_init (&argc, &args);
    
    HildonSeekbar *bar = HILDON_SEEKBAR (hildon_seekbar_new ());
    gtk_widget_set_size_request (GTK_WIDGET (bar), 400, -1);

    hildon_seekbar_set_total_time (bar, 100);
    hildon_seekbar_set_position (bar, 50);

    GtkToolbar *toolbar = gtk_toolbar_new ();
    GtkToolItem *item = gtk_tool_item_new ();
    gtk_container_add (GTK_CONTAINER (item), GTK_WIDGET (bar));
    gtk_toolbar_insert (toolbar, item , 0);

    hildon_window_add_toolbar (window, toolbar);

    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
    gtk_widget_show_all (GTK_WIDGET (window));
    
    gtk_main ();

    return 0;
}
Exemple #8
0
GtkWidget *tool_button(GtkWidget *bar, GdkDrawable *drawable,
    char **xpm, const char *tooltip,
    gboolean (*cb)(GtkWidget *widget, GdkEventButton *event, gpointer data),
    gpointer data)
{
	GtkWidget *image, *evbox;
	GtkToolItem *item;

	/*
	 * gtk_radio_tool_button_new_from_widget is *huge*. We try to do things
	 * in a
	 * more compact way.
	 */

	evbox = gtk_event_box_new();
	if (xpm) {
		image = make_image(drawable, xpm, tooltip);
		gtk_container_add(GTK_CONTAINER(evbox), image);
	}
	g_signal_connect(G_OBJECT(evbox), "button_press_event",
            G_CALLBACK(cb), data);

	item = gtk_tool_item_new();
	gtk_container_add(GTK_CONTAINER(item), evbox);

	gtk_container_set_border_width(GTK_CONTAINER(item), 0);

	gtk_toolbar_insert(GTK_TOOLBAR(bar), item, -1);

	return evbox;
}
Exemple #9
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);
}
Exemple #10
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);
}
Exemple #11
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;
}
Exemple #12
0
static void
nautilus_toolbar_constructed (GObject *obj)
{
	NautilusToolbar *self = NAUTILUS_TOOLBAR (obj);
	GtkToolItem *item;
	GtkWidget *hbox, *toolbar, *search;
	GtkStyleContext *context;
	const gchar *ui;

	G_OBJECT_CLASS (nautilus_toolbar_parent_class)->constructed (obj);

	gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)),
					      GTK_JUNCTION_BOTTOM);

	/* add the UI */
	ui = nautilus_ui_string_get ("nautilus-toolbar-ui.xml");
	self->priv->ui_manager = gtk_ui_manager_new ();
	gtk_ui_manager_add_ui_from_string (self->priv->ui_manager, ui, -1, NULL);
	gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0);

	toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar");
	self->priv->toolbar = toolbar;

	context = gtk_widget_get_style_context (toolbar);
	gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);

	search = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar/Search");
	gtk_style_context_add_class (gtk_widget_get_style_context (search), GTK_STYLE_CLASS_RAISED);

	gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0);
	gtk_widget_show_all (self->priv->toolbar);

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_widget_show (hbox);

	/* regular path bar */
	self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL);
	gtk_box_pack_start (GTK_BOX (hbox), self->priv->path_bar, TRUE, TRUE, 0);

	/* entry-like location bar */
	self->priv->location_bar = nautilus_location_bar_new ();
	gtk_box_pack_start (GTK_BOX (hbox), self->priv->location_bar, TRUE, TRUE, 0);

	item = gtk_tool_item_new ();
	gtk_tool_item_set_expand (item, TRUE);
	gtk_container_add (GTK_CONTAINER (item), hbox);
	gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), item, 0);
	gtk_widget_show (GTK_WIDGET (item));

	/* search bar */
	self->priv->search_bar = nautilus_search_bar_new ();
	gtk_box_pack_start (GTK_BOX (self), self->priv->search_bar, TRUE, TRUE, 0);

	g_signal_connect_swapped (nautilus_preferences,
				  "changed::" NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY,
				  G_CALLBACK (toolbar_update_appearance), self);

	toolbar_update_appearance (self);
}
Exemple #13
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);
}
Exemple #14
0
void wxToolBar::AddChildGTK(wxWindowGTK* child)
{
    GtkWidget* align = gtk_alignment_new(0.5, 0.5, 0, 0);
    gtk_widget_show(align);
    gtk_container_add(GTK_CONTAINER(align), child->m_widget);
    GtkToolItem* item = gtk_tool_item_new();
    gtk_container_add(GTK_CONTAINER(item), align);
    // position will be corrected in DoInsertTool if necessary
    gtk_toolbar_insert(GTK_TOOLBAR(GTK_BIN(m_widget)->child), item, -1);
}
Exemple #15
0
void ui_common_toolbar_insert_widget(GtkWidget * toolbar, GtkWidget * widget, const gchar * tooltip, gint position) {

  GtkToolItem * toolbar_item;

  toolbar_item = gtk_tool_item_new();
  gtk_container_add(GTK_CONTAINER(toolbar_item), widget);
  if (tooltip != NULL)
    gtk_tool_item_set_tooltip_text(toolbar_item,tooltip);
  gtk_tool_item_set_homogeneous(toolbar_item, FALSE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolbar_item, position);

  return;
}
Exemple #16
0
static void
gtk_tool_insert_generic_item(GtkToolbar *toolbar, GtkWidget *item)
{
	GtkWidget *align_box;
	GtkToolItem *boxitem;

	boxitem = gtk_tool_item_new ();

	align_box = gtk_alignment_new(0, 0.5, 0, 0);
	gtk_container_add(GTK_CONTAINER(align_box), item);

	gtk_container_add (GTK_CONTAINER(boxitem), align_box);
	gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(boxitem), -1);
}
Exemple #17
0
/**
 * Adds a widget to the toolbar making sure that it doesn't take any excess space, and
 * vertically centers it.
 * @param toolbar The toolbar to add the widget to.
 * @param w       The widget to add to the toolbar.
 */
static void integrated_ui_toolbar_add_custom_item (GtkToolbar *toolbar, GtkWidget *w)
{
    GtkToolItem *tool_item;
    GtkWidget   *c; /* container */

    tool_item = gtk_tool_item_new ();
    c = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (tool_item), c);
    gtk_box_set_homogeneous (GTK_BOX (c), TRUE);            /* Centers the button */
    gtk_box_pack_start (GTK_BOX (c), w, FALSE, FALSE, 0);
    gtk_toolbar_insert (toolbar, tool_item, -1);
    gtk_widget_show (GTK_WIDGET (tool_item));
    gtk_widget_show (c);
    gtk_widget_show (w);
}
static GtkToolItem *
create_entry_item (const char *text)
{
  GtkToolItem *item;
  GtkWidget *entry;

  entry = gtk_entry_new ();
  gtk_entry_set_text (GTK_ENTRY (entry), text);
  gtk_entry_set_width_chars (GTK_ENTRY (entry), 5);

  item = gtk_tool_item_new ();
  gtk_container_add (GTK_CONTAINER (item), entry);

  return item;
}
GtkToolItem* ToolPageLayer::newItem()
{
	XOJ_CHECK_TYPE(ToolPageLayer);

	GtkToolItem* it = gtk_tool_item_new();

	GtkWidget* hbox = gtk_hbox_new(false, 1);
	gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_C("Layer")), false, false, 7);

	gtk_box_pack_start(GTK_BOX(hbox), this->layerComboBox, false, false, 0);

	gtk_container_add(GTK_CONTAINER(it), hbox);

	return it;
}
Exemple #20
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);
}
Exemple #21
0
GtkToolItem * FontButton::createTmpItem(bool horizontal) {
	GtkWidget * fontButton = newFontButton();

	GtkToolItem * it = gtk_tool_item_new();

	gtk_container_add(GTK_CONTAINER(it), fontButton);
	gtk_tool_item_set_tooltip_text(it, this->description.c_str());
	gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(it), false);

	if (!this->font.getName().isEmpty()) {
		setFontFontButton(fontButton, this->font);
	}

	gtk_widget_show_all(GTK_WIDGET(it));
	return it;
}
Exemple #22
0
GtkToolItem * ToolPageSpinner::newItem() {
	XOJ_CHECK_TYPE(ToolPageSpinner);

	GtkToolItem * it = gtk_tool_item_new();

	GtkWidget * hbox = gtk_hbox_new(false, 1);
	gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Page")), false, false, 7);

	gtk_box_pack_start(GTK_BOX(hbox), this->pageSpinner->getWidget(), false, false, 0);

	this->lbPageNo = gtk_label_new("");
	gtk_box_pack_start(GTK_BOX(hbox), this->lbPageNo, false, false, 0);

	gtk_container_add(GTK_CONTAINER(it), hbox);

	return it;
}
Exemple #23
0
static void
photos_searchbar_constructed (GObject *object)
{
  PhotosSearchbar *self = PHOTOS_SEARCHBAR (object);
  PhotosSearchbarPrivate *priv;
  GApplication *app;
  GtkToolItem *item;
  GVariant *state;

  priv = photos_searchbar_get_instance_private (self);

  G_OBJECT_CLASS (photos_searchbar_parent_class)->constructed (object);

  PHOTOS_SEARCHBAR_GET_CLASS (self)->create_search_widgets (self);

  item = gtk_tool_item_new ();
  gtk_tool_item_set_expand (item, TRUE);
  gtk_container_add (GTK_CONTAINER (item), priv->search_container);
  gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), item, 0);

  g_signal_connect_swapped (priv->search_entry,
                            "search-changed",
                            G_CALLBACK (photos_searchbar_search_changed),
                            self);


  app = g_application_get_default ();
  priv->search = g_action_map_lookup_action (G_ACTION_MAP (app), "search");

  /* g_signal_connect_object will not be able to disconnect the
   * handler in time because we change the state of the action during
   * dispose.
   */
  priv->search_state_id = g_signal_connect_swapped (priv->search,
                                                    "change-state",
                                                    G_CALLBACK (photos_searchbar_change_state),
                                                    self);
  state = g_action_get_state (priv->search);
  photos_searchbar_change_state (self, state);
  g_variant_unref (state);

  gtk_widget_show_all (GTK_WIDGET (self));
}
Exemple #24
0
GtkToolItem * FontButton::newItem() {
	XOJ_CHECK_TYPE(FontButton);

	if (this->fontButton) {
		g_object_unref(this->fontButton);
	}
	GtkToolItem * it = gtk_tool_item_new();

	this->fontButton = newFontButton();
	gtk_container_add(GTK_CONTAINER(it), this->fontButton);
	gtk_tool_item_set_tooltip_text(it, this->description.c_str());
	gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(it), false);

	if (!this->font.getName().isEmpty()) {
		setFont(this->font);
	}

	return it;
}
Exemple #25
0
create_statusbar ()void *GtkMain(void * argument)
{
    printf("%s:%d\n", __func__, __LINE__);

    int argc = 0;
    char**argv = NULL;

    unsigned char haveUrl = 0;
    int argCount = 0;
{
    g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ());
    gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false);
    status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover");
    
    return (GtkWidget*)g_main_statusbar;
}

static GtkWidget*
create_toolbar ()
{
    g_toolbar = gtk_toolbar_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false);

#if GTK_CHECK_VERSION(2,15,0)
    gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ);


    /* The URL entry */
    itemUrl = gtk_tool_item_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false);
    gtk_tool_item_set_expand (itemUrl, TRUE);
    uri_entry = gtk_entry_new ();
    gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry);
    g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1);

    return g_toolbar;
}
static void
photos_searchbar_constructed (GObject *object)
{
  PhotosSearchbar *self = PHOTOS_SEARCHBAR (object);
  PhotosSearchbarPrivate *priv = self->priv;
  GtkToolItem *item;
  GVariant *state;

  G_OBJECT_CLASS (photos_searchbar_parent_class)->constructed (object);

  PHOTOS_SEARCHBAR_GET_CLASS (self)->create_search_widgets (self);

  item = gtk_tool_item_new ();
  gtk_tool_item_set_expand (item, TRUE);
  gtk_container_add (GTK_CONTAINER (item), priv->search_container);
  gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), item, 0);

  g_signal_connect_swapped (priv->search_entry,
                            "key-press-event",
                            G_CALLBACK (photos_searchbar_key_press_event),
                            self);
  g_signal_connect_swapped (priv->search_entry,
                            "search-changed",
                            G_CALLBACK (photos_searchbar_search_changed),
                            self);


  /* g_signal_connect_object will not be able to disconnect the
   * handler in time because we change the state of the action during
   * dispose.
   */
  priv->search_state_id = g_signal_connect_swapped (priv->app,
                                                    "action-state-changed::search",
                                                    G_CALLBACK (photos_searchbar_action_state_changed),
                                                    self);
  state = g_action_group_get_action_state (G_ACTION_GROUP (priv->app), "search");
  photos_searchbar_action_state_changed (self, "search", state);
  g_variant_unref (state);

  gtk_widget_show_all (GTK_WIDGET (self));
}
Exemple #27
0
static GtkWidget *create_toolbar(void)
{
    GtkWidget *toolbar, *item;
    GtkToolItem *tool_item;

    toolbar = gtk_toolbar_new();
    gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

    tool_item = gtk_menu_tool_button_new(NULL, NULL);
    gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO);
    item = (GtkWidget*)tool_item;
    gtk_widget_set_tooltip_text(item, _("Show the current document"));
    gtk_container_add(GTK_CONTAINER(toolbar), item);
    g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL);

    item = gtk_menu_new();
    gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item);
#if GTK_CHECK_VERSION (3, 0, 0)
    /* hack for https://bugzilla.gnome.org/show_bug.cgi?id=769287 */
    if (! gtk_check_version(3, 15, 9) && gtk_check_version(3, 21, 4+1))
        g_signal_connect(tool_item, "show-menu", G_CALLBACK(show_menu_gtk316_fix), NULL);
#endif
    g_signal_connect(tool_item, "show-menu", G_CALLBACK(on_doc_show_menu), item);

    tool_item = gtk_tool_item_new();
    gtk_tool_item_set_expand(tool_item, TRUE);
    gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item));

    item = gtk_label_new(NULL);
    gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START);
    gtk_container_add(GTK_CONTAINER(tool_item), item);
    edit_window.name_label = item;

    item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL);
    gtk_container_add(GTK_CONTAINER(toolbar), item);
    g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL);

    return toolbar;
}
GtkWidget* create_tool_item( GtkAction* action )
{
    GtkWidget* item = 0;

    if ( IS_EGE_OUTPUT_ACTION(action) )
    {
        GValue value;
        GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
        GtkWidget* lbl = 0;
        memset( &value, 0, sizeof(value) );

        g_value_init( &value, G_TYPE_STRING );
        g_object_get_property( G_OBJECT(action), "short_label", &value );
        const gchar* sss = g_value_get_string( &value );

        item = GTK_WIDGET( gtk_tool_item_new() );

        lbl = gtk_label_new( " " );
        gtk_container_add( GTK_CONTAINER(hb), lbl );

        if ( EGE_OUTPUT_ACTION(action)->private_data->useMarkup ) {
            lbl = gtk_label_new(NULL);
            gtk_label_set_markup( GTK_LABEL(lbl), sss ? sss : " " );
        } else {
            lbl = gtk_label_new( sss ? sss : " " );
        }
        gtk_container_add( GTK_CONTAINER(hb), lbl );

        lbl = gtk_label_new( " " );
        gtk_container_add( GTK_CONTAINER(hb), lbl );

        gtk_container_add( GTK_CONTAINER(item), hb );

        gtk_widget_show_all( item );
    } else {
        item = gParentClass->create_tool_item( action );
    }

    return item;
}
static void
gt_settings_dlg_init(GtSettingsDlg* self)
{
    GtSettingsDlgPrivate* priv = gt_settings_dlg_get_instance_private(self);

    //So it's not optimised away
    volatile gpointer type = (gpointer) PEAS_GTK_TYPE_PLUGIN_MANAGER;

    gtk_widget_init_template(GTK_WIDGET(self));

    gtk_widget_show_all(priv->players_view);

    GtkWidget* header_bar = gtk_dialog_get_header_bar(GTK_DIALOG(self));
    gtk_header_bar_set_custom_title(GTK_HEADER_BAR(header_bar), priv->settings_switcher);

    /* NOTE: This is a hack to show a label at the bottom of the dialogue*/
    GList* children = gtk_container_get_children(GTK_CONTAINER(priv->players_view));
    GtkToolbar* toolbar = GTK_TOOLBAR(g_list_nth(children, 1)->data);
    GtkToolItem* item = gtk_tool_item_new();
    gtk_container_add(GTK_CONTAINER(item), gtk_link_button_new_with_label(
            "https://github.com/vinszent/gnome-twitch/wiki/How-to-install-player-backends",
            _("How to install player backends")));
    gtk_widget_show_all(GTK_WIDGET(item));
    gtk_toolbar_insert(toolbar, item, 0);
    g_list_free(children);

    g_settings_bind(main_app->settings, "prefer-dark-theme",
        priv->prefer_dark_theme_button, "active",
        G_SETTINGS_BIND_DEFAULT);
    g_settings_bind(main_app->settings, "default-quality",
        priv->quality_combo, "active-id",
        G_SETTINGS_BIND_DEFAULT);
    g_settings_bind(main_app->settings, "language-filter",
        priv->language_filter_combo, "active-id",
        G_SETTINGS_BIND_DEFAULT);
    g_settings_bind(main_app->settings, "show-notifications",
        priv->notifications_switch, "active",
        G_SETTINGS_BIND_DEFAULT);
}
Exemple #30
0
static GtkWidget*
create_toolbar ()
{
    GtkWidget* toolbar = gtk_toolbar_new ();

#if GTK_CHECK_VERSION(2,15,0)
    gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style (GTK_TOOLBAR (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), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (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), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    /* The URL entry */
    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_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (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)uri_entry);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    return toolbar;
}