Beispiel #1
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;
}
Beispiel #2
0
void GTKMusicBrowser::CreateToolbar(GtkWidget *vbox)
{
    toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
                                         GTK_TOOLBAR_BOTH);
    gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolbar), GTK_RELIEF_NONE);
    gtk_toolbar_set_space_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_SPACE_LINE);

    gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "New Playlist",
                            "Start Editing a new Playlist",
                            "Toolbar/New", NewPixmap(new_pic),
                            GTK_SIGNAL_FUNC(new_plist_tool), this);

    gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Save Playlist",
                            "Save the Current Playlist to Disk",
                            "Toolbar/Save", NewPixmap(save_pic),
                            GTK_SIGNAL_FUNC(save_list_tool), this);

    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

    gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Import Items",
                            "Import a Playlist or Track into My Music",
                            "Toolbar/Import", NewPixmap(import_pic),
                            GTK_SIGNAL_FUNC(import_tool), this);

    toolRemove = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Remove Track",
                                         "Remove a Track from the Playlist",
                                         "Toolbar/Remove", NewPixmap(trash_pic),
                                         GTK_SIGNAL_FUNC(remove_tool), this);

    gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Edit",
                            "Edit a Track or Playlist",
                            "Toolbar/Edit", NewPixmap(edit_pic),
                            GTK_SIGNAL_FUNC(edit_tool), this);

    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

    addTrack = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add Items",
                            "Add Music from My Music to the Playlist",
                            "Toolbar/AddItem", NewPixmap(add_track_pic),
                            GTK_SIGNAL_FUNC(add_track_tool), this);

    addFile = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add File",
                            "Add a File to the Playlist",
                            "Toolbar/Add", NewPixmap(add_file),
                            GTK_SIGNAL_FUNC(add_tool), this);

    toolUp = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Up",
                            "Move The Currently Selected Track in the Playlist Up",
                            "Toolbar/Up", NewPixmap(up_pic),
                            GTK_SIGNAL_FUNC(move_up_tool), this);

    toolDown = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Down",
                            "Move the Currently Selected Track in the Playlist Down",
                            "Toolbar/Down", NewPixmap(down_pic),
                            GTK_SIGNAL_FUNC(move_down_tool), this);

    gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
    SetToolbarType();
    gtk_widget_show(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;
}
Beispiel #4
0
GtkWidget *balsa_toolbar_new(BalsaToolbarModel * model,
                             GActionMap        * action_map)
{
    toolbar_info *info;
    GtkWidget *toolbar;

    info = g_new(toolbar_info, 1);
    info->model = model;
    info->menu = NULL;

    toolbar = gtk_toolbar_new();
    g_object_set_data_full(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP,
                           g_object_ref(action_map),
                           (GDestroyNotify) g_object_unref);
    tm_populate(toolbar, model);

    g_signal_connect(model, "changed", G_CALLBACK(tm_changed_cb), toolbar);
    g_signal_connect(toolbar, "realize", G_CALLBACK(tm_realize_cb), model);
    g_object_weak_ref(G_OBJECT(toolbar),
                      (GWeakNotify) tm_toolbar_weak_notify, info);

    g_signal_connect(toolbar, "button-press-event",
                     G_CALLBACK(tm_button_press_cb), info);
    g_signal_connect(toolbar, "popup-menu", G_CALLBACK(tm_popup_menu_cb),
                     info);

    gtk_widget_show_all(toolbar);

    return toolbar;
}
Beispiel #5
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);
}
Beispiel #6
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;
}
Beispiel #7
0
/* 
 * Create the find toolbar
*/
void create_find_toolbar(AppData * view)
{
#ifdef MAEMO4
    view->find_toolbar = HILDON_FIND_TOOLBAR
        (hildon_find_toolbar_new("Find String: "));

    /* Add signal listers to "Search" and "Close" buttons */
    g_signal_connect(G_OBJECT(view->find_toolbar), "search",
                     G_CALLBACK(find_tb_search), view);
    g_signal_connect(G_OBJECT(view->find_toolbar), "close",
                     G_CALLBACK(find_tb_close), view);
    hildon_window_add_toolbar(view->window, GTK_TOOLBAR(view->find_toolbar));

    /* Set variables to AppData */
    view->find_visible = FALSE;
#else
    view->find_toolbar = gtk_toolbar_new();
    view->entry = GTK_ENTRY(gtk_entry_new ());
  
    g_signal_connect(GTK_WIDGET(view->entry), "key-press-event",
                   G_CALLBACK(on_insert_text), (gpointer)view);

    gtk_widget_show ( GTK_WIDGET(view->entry) );
#endif

}
Beispiel #8
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;
}
static GtkWidget *
create_dock (EggEditableToolbar *etoolbar)
{
  GtkWidget *toolbar, *hbox;

  hbox = gtk_hbox_new (0, FALSE);

  toolbar = gtk_toolbar_new ();
  gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE);
  gtk_widget_show (toolbar);
  gtk_box_pack_start (GTK_BOX (hbox), toolbar, TRUE, TRUE, 0);

  g_signal_connect (toolbar, "drag_drop",
		    G_CALLBACK (toolbar_drag_drop_cb), etoolbar);
  g_signal_connect (toolbar, "drag_motion",
		    G_CALLBACK (toolbar_drag_motion_cb), etoolbar);
  g_signal_connect (toolbar, "drag_leave",
		    G_CALLBACK (toolbar_drag_leave_cb), etoolbar);

  g_signal_connect (toolbar, "drag_data_received",
		    G_CALLBACK (toolbar_drag_data_received_cb), etoolbar);
  g_signal_connect (toolbar, "popup_context_menu",
		    G_CALLBACK (popup_context_menu_cb), etoolbar);

  configure_drag_dest (etoolbar, GTK_TOOLBAR (toolbar));

  return hbox;
}
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;
}
Beispiel #12
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;
}
Beispiel #13
0
void
downloadmanager_setup(void)
{
    dm.win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_type_hint(GTK_WINDOW(dm.win), GDK_WINDOW_TYPE_HINT_DIALOG);
    gtk_window_set_default_size(GTK_WINDOW(dm.win), 500, 250);
    gtk_window_set_title(GTK_WINDOW(dm.win), __NAME__" - Download Manager");
    g_signal_connect(G_OBJECT(dm.win), "delete-event",
                     G_CALLBACK(gtk_widget_hide_on_delete), NULL);
    g_signal_connect(G_OBJECT(dm.win), "key-press-event",
                     G_CALLBACK(key_downloadmanager), NULL);

    dm.toolbar = gtk_toolbar_new();
    gtk_orientable_set_orientation(GTK_ORIENTABLE(dm.toolbar),
                                   GTK_ORIENTATION_VERTICAL);
    gtk_toolbar_set_style(GTK_TOOLBAR(dm.toolbar), GTK_TOOLBAR_BOTH_HORIZ);
    gtk_toolbar_set_show_arrow(GTK_TOOLBAR(dm.toolbar), FALSE);

    dm.scroll = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dm.scroll),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(dm.scroll), dm.toolbar);

    gtk_container_add(GTK_CONTAINER(dm.win), dm.scroll);
}
Beispiel #14
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;
}
Beispiel #15
0
void roadmap_main_add_tool (const char *label,
                            const char *icon,
                            const char *tip,
                            RoadMapCallback callback) {

   if (RoadMapMainToolbar == NULL) {

      RoadMapMainToolbar = gtk_toolbar_new ();
      gtk_box_pack_start (GTK_BOX(RoadMapMainBox),
                          RoadMapMainToolbar, FALSE, FALSE, 0);
   }

   gtk_toolbar_append_item (GTK_TOOLBAR(RoadMapMainToolbar),
                            label, tip, NULL,
                            roadmap_main_toolbar_icon (icon),
                            (GtkSignalFunc) roadmap_main_activate, callback);

   if (gdk_screen_height() < 550)
   {
      /* When using a small screen, we want either the labels or the icons,
       * but not both (small screens are typical with PDAs).
       */
      gtk_toolbar_set_style
         (GTK_TOOLBAR(RoadMapMainToolbar),
          GtkIconsInitialized?GTK_TOOLBAR_ICONS:GTK_TOOLBAR_TEXT);
   }
}
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));
}
static void create_toolbar_menu()
{
	GtkWidget *iconw;
	GtkWidget *close_button;

	bdk_window.toolbar = gtk_toolbar_new ();
	gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH);

	/* our first item is <close> button */
	iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR)  ; // ("gtk.xpm"); /* icon widget */
	close_button = 
	gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
							 "Open",               /* button label */
							 "Open a file",     /* this button's tooltip */
							 "Private",             /* tooltip private info */
							 iconw,                 /* icon widget */
							 GTK_SIGNAL_FUNC (open_event), /* a signal */
							 NULL);
	gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */
	/* our first item is <close> button */
	iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR)  ; // ("gtk.xpm"); /* icon widget */
	close_button = 
	gtk_toolbar_append_item(	GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
								 "Close",               /* button label */
								 "Closes this app",     /* this button's tooltip */
								 "Private",             /* tooltip private info */
								 iconw,                 /* icon widget */
								 GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */
								 NULL);
	gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0);
}
Beispiel #18
0
Datei: mug.c Projekt: 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;
}
Beispiel #19
0
static GtkWidget *
alleyoop_toolbar_new (Alleyoop *grind)
{
	GtkWidget *toolbar, *image;
	GtkToolbarChild *child;
	
	toolbar = gtk_toolbar_new ();
	
	image = gtk_image_new_from_stock (GTK_STOCK_EXECUTE, GTK_ICON_SIZE_LARGE_TOOLBAR);
	gtk_widget_show (image);
	gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Run"), _("Run Program"), NULL,
				 image, G_CALLBACK (file_run_cb), grind);
	
	image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_LARGE_TOOLBAR);
	gtk_widget_show (image);
	gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Kill"), _("Kill Program"), NULL,
				 image, G_CALLBACK (file_kill_cb), grind);
	
	gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_OPEN, _("Open Log File"),
				  NULL, G_CALLBACK (file_open_cb), grind, 2);
	gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_SAVE, _("Save Log File"),
				  NULL, G_CALLBACK (file_save_cb), grind, 3);
	
	gtk_widget_show (toolbar);
	
	child = ((GtkToolbar *) toolbar)->children->data;
	grind->toolbar_run = child->widget;
	
	child = ((GtkToolbar *) toolbar)->children->next->data;
	grind->toolbar_kill = child->widget;
	
	return toolbar;
}
Beispiel #20
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);
}
Beispiel #21
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);
}
Beispiel #22
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;
}
Beispiel #23
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);
  }
}
ZLGtkApplicationWindow::ZLGtkApplicationWindow(ZLApplication *application) :
	ZLApplicationWindow(application),
	KeyActionOnReleaseNotOnPressOption(ZLCategoryKey::CONFIG, "KeyAction", "OnRelease", false),
	myFullScreen(false) {
	myProgram = HILDON_PROGRAM(hildon_program_get_instance());
	g_set_application_name("");

	myWindow = HILDON_WINDOW(hildon_window_new());

	((ZLMaemoCommunicationManager&)ZLCommunicationManager::Instance()).init();

	myToolbar = GTK_TOOLBAR(gtk_toolbar_new());
	gtk_toolbar_set_show_arrow(myToolbar, false);
	gtk_toolbar_set_orientation(myToolbar, GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style(myToolbar, GTK_TOOLBAR_ICONS);

	myMenu = GTK_MENU(gtk_menu_new());
	hildon_window_set_menu(myWindow, myMenu);
	gtk_widget_show_all(GTK_WIDGET(myMenu));

	hildon_window_add_toolbar(myWindow, myToolbar);
	hildon_program_add_window(myProgram, myWindow);
	gtk_widget_show_all(GTK_WIDGET(myWindow));

	myViewWidget = 0;

	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "delete_event", GTK_SIGNAL_FUNC(applicationQuit), this);
	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_press_event", GTK_SIGNAL_FUNC(handleKeyPress), this);
	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_release_event", GTK_SIGNAL_FUNC(handleKeyRelease), this);
}
Beispiel #25
0
int main( int argc, char *argv[])
{

    GtkWidget *window;
    GtkWidget *vbox;

    GtkWidget *toolbar;
    GtkWidget *view;
    GtkWidget *statusbar;
    GtkToolItem *exit;
    GtkTextBuffer *buffer;

    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), "lines & cols");

    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);

    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);

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

    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));

    statusbar = gtk_statusbar_new();
    gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);

    g_signal_connect(G_OBJECT(exit), "clicked", 
            G_CALLBACK(gtk_main_quit), NULL);

    g_signal_connect(buffer, "changed",
            G_CALLBACK(update_statusbar), statusbar);

    g_signal_connect_object(buffer, "mark_set", 
            G_CALLBACK(mark_set_callback), statusbar, 0);

    g_signal_connect_swapped(G_OBJECT(window), "destroy",
            G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);

    update_statusbar(buffer, GTK_STATUSBAR (statusbar));

    gtk_main();

    return 0;
}
Beispiel #26
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);
}
static gboolean
stress_test_old_api (gpointer data)
{
  typedef enum {
    ADD_RANDOM,
    REMOVE_RANDOM,
    LAST_ACTION
  } Action;
      
  Info *info = data;
  Action action;
  
  if (info->counter++ == 200)
    {
      gtk_main_quit ();
      return FALSE;
    }

  if (!info->toolbar)
    {
      info->toolbar = GTK_TOOLBAR (gtk_toolbar_new ());
      gtk_container_add (GTK_CONTAINER (info->window),
			 GTK_WIDGET (info->toolbar));
      gtk_widget_show (GTK_WIDGET (info->toolbar));
    }

  if (!info->toolbar->children)
    {
      add_random (info->toolbar, info->counter);
      return TRUE;
    }
  else if (g_list_length (info->toolbar->children) > 50)
    {
      int i;
      for (i = 0; i < 25; i++)
	remove_random (info->toolbar);
      return TRUE;
    }
  
  action = g_random_int_range (0, LAST_ACTION);

  switch (action)
    {
    case ADD_RANDOM:
      add_random (info->toolbar, info->counter);
      break;

    case REMOVE_RANDOM:
      remove_random (info->toolbar);
      break;
      
    default:
      g_assert_not_reached();
      break;
    }
  
  return TRUE;
}
Beispiel #28
0
bool wxToolBar::Create( wxWindow *parent,
                        wxWindowID id,
                        const wxPoint& pos,
                        const wxSize& size,
                        long style,
                        const wxString& name )
{
    if ( !PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
    {
        wxFAIL_MSG( wxT("wxToolBar creation failed") );

        return false;
    }

    FixupStyle();

    m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
    if (gtk_check_version(2, 12, 0))
    {
        m_tooltips = gtk_tooltips_new();
        g_object_ref(m_tooltips);
        gtk_object_sink(GTK_OBJECT(m_tooltips));
    }
#endif
    GtkSetStyle();

    if (style & wxTB_DOCKABLE)
    {
        m_widget = gtk_handle_box_new();

        g_signal_connect(m_widget, "child_detached",
            G_CALLBACK(child_detached), NULL);
        g_signal_connect(m_widget, "child_attached",
            G_CALLBACK(child_attached), NULL);

        if (style & wxTB_FLAT)
            gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
    }
    else
    {
        m_widget = gtk_event_box_new();
        ConnectWidget( m_widget );
    }
    g_object_ref(m_widget);
    gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar));
    gtk_widget_show(GTK_WIDGET(m_toolbar));

    m_parent->DoAddChild( this );

    PostCreation(size);

    g_signal_connect_after(m_toolbar, "size_request",
        G_CALLBACK(size_request), this);

    return true;
}
Beispiel #29
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);
    }
}
Beispiel #30
0
// static
wxVisualAttributes
wxToolBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
    wxVisualAttributes attr;
    GtkWidget* widget = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
    attr = GetDefaultAttributesFromGTKWidget(widget);
    gtk_widget_destroy(widget);
    return attr;
}