自学教程：C++ GTK_TOOL_BUTTON函数代码示例

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

/* * Creates a new GtkWidget of class GtkToggleToolButton, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. */static GtkWidget*gb_toggle_tool_button_new (GbWidgetNewData *data){  GtkWidget *new_widget, *image;  GbWidget *pixmap_gbwidget;  /* Place the pixmap icon in the button initially (even when loading). */  pixmap_gbwidget = gb_widget_lookup_class ("GtkImage");  if (pixmap_gbwidget)    {      image = gtk_image_new_from_pixmap (pixmap_gbwidget->gdkpixmap,					 pixmap_gbwidget->mask);    }  else    {      image = gtk_image_new ();      g_warning ("Couldn't find GtkPixmap data");    }  gtk_widget_show (image);  new_widget = (GtkWidget*) gtk_toggle_tool_button_new ();  gtk_tool_button_set_label (GTK_TOOL_BUTTON (new_widget), "");  gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (new_widget), image);  return new_widget;}

/* Starts, pauses  and continues the timer */static void toggleTimer(){	if (prefs.timer_is_clock)		return;	switch (timerMode)	{		case 0:			timer = g_timer_new();			timerMode = 1;			gtk_widget_set_sensitive(GTK_WIDGET(resetButton), FALSE);			gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(startButton),					GTK_STOCK_MEDIA_PAUSE);			break;		case 1:			g_timer_stop(timer);			timerMode = 2;			gtk_widget_set_sensitive(GTK_WIDGET(resetButton), TRUE);			gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(startButton),					GTK_STOCK_MEDIA_PLAY);			break;		case 2:			g_timer_continue(timer);			timerMode = 1;			gtk_widget_set_sensitive(GTK_WIDGET(resetButton), FALSE);			gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(startButton),					GTK_STOCK_MEDIA_PAUSE);			break;	}}

void Sidebar::initPages(GtkWidget* sidebar, GladeGui* gui){	XOJ_CHECK_TYPE(Sidebar);	addPage(new SidebarIndexPage(this->control));	addPage(new SidebarPreviewPages(this->control));#ifdef UNSTABLE_LAYERS_SIDEBAR	addPage(new SidebarPreviewLayers(this->control));#endif //UNSTABLE_LAYERS_SIDEBAR	// Init toolbar with icons	int i = 0;	for (AbstractSidebarPage* p : this->pages)	{		GtkToolItem* it = gtk_toggle_tool_button_new();		p->tabButton = it;		gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), gui->loadIcon(p->getIconName().c_str()));		g_signal_connect(it, "clicked", G_CALLBACK(&buttonClicked), new SidebarPageButton(this, i, p));		gtk_tool_item_set_tooltip_text(it, p->getName().c_str());		gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), p->getName().c_str());		gtk_toolbar_insert(tbSelectPage, it, -1);		// Add widget to sidebar		gtk_box_pack_start(GTK_BOX(sidebar), p->getWidget(), TRUE, TRUE, 0);		i++;	}	gtk_widget_show_all(GTK_WIDGET(this->tbSelectPage));	updateEnableDisableButtons();}

static gbooleangtk_tool_button_create_menu_proxy (GtkToolItem *item){  GtkToolButton *button = GTK_TOOL_BUTTON (item);  GtkWidget *menu_item;  GtkWidget *menu_image = NULL;  GtkStockItem stock_item;  gboolean use_mnemonic = TRUE;  const char *label;  if (_gtk_tool_item_create_menu_proxy (item))    return TRUE;   if (GTK_IS_LABEL (button->priv->label_widget))    {      label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));      use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));    }  else if (button->priv->label_text)    {      label = button->priv->label_text;      use_mnemonic = button->priv->use_underline;    }  else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))    {      label = stock_item.label;    }  else    {      label = "";    }    if (use_mnemonic)    menu_item = gtk_image_menu_item_new_with_mnemonic (label);  else    menu_item = gtk_image_menu_item_new_with_label (label);  if (GTK_IS_IMAGE (button->priv->icon_widget))    {      menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),					  gtk_widget_get_settings (GTK_WIDGET (button)));    }  else if (button->priv->stock_id)    {      menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);    }  if (menu_image)    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);  g_signal_connect_closure_by_id (menu_item,				  g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,				  g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),							      G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),				  FALSE);  gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);    return TRUE;}

static GtkWidget* ink_radio_action_create_tool_item( GtkAction* action ){    InkRadioAction* act = INK_RADIO_ACTION( action );    GtkWidget* item = GTK_RADIO_ACTION_CLASS(ink_radio_action_parent_class)->parent_class.parent_class.create_tool_item(action);    if ( act->private_data->iconId ) {        if ( GTK_IS_TOOL_BUTTON(item) ) {            GtkToolButton* button = GTK_TOOL_BUTTON(item);            GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );            GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 );            gtk_container_add( GTK_CONTAINER(align), child );            gtk_tool_button_set_icon_widget( button, align );        } else {            // For now trigger a warning but don't do anything else            GtkToolButton* button = GTK_TOOL_BUTTON(item);            (void)button;        }    }    // TODO investigate if needed    gtk_widget_show_all( item );    return item;}

static GtkWidget* ink_toggle_action_create_tool_item( GtkAction* action ){    InkToggleAction* act = INK_TOGGLE_ACTION( action );    GtkWidget* item = GTK_TOGGLE_ACTION_CLASS(ink_toggle_action_parent_class)->parent_class.create_tool_item(action);    if ( GTK_IS_TOOL_BUTTON(item) ) {        GtkToolButton* button = GTK_TOOL_BUTTON(item);        if ( act->private_data->iconId ) {            GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );            GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 );            gtk_container_add( GTK_CONTAINER(align), child );            gtk_tool_button_set_icon_widget( button, align );        } else {            gchar *label = 0;            g_object_get( G_OBJECT(action), "short_label", &label, NULL );            gtk_tool_button_set_label( button, label );            g_free( label );            label = 0;        }    } else {        // For now trigger a warning but don't do anything else        GtkToolButton* button = GTK_TOOL_BUTTON(item);        (void)button;    }    gtk_widget_show_all( item );    return item;}

static voidschema_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}

gbooleandownload_handle(WebKitDownload *download, gchar *suggested_filename, gpointer data){    gchar *sug_clean, *path, *path2 = NULL, *uri;    GtkToolItem *tb;    int suffix = 1;    size_t i;    sug_clean = g_strdup(suggested_filename);    for (i = 0; i < strlen(sug_clean); i++)        if (sug_clean[i] == G_DIR_SEPARATOR)            sug_clean[i] = '_';    path = g_build_filename(download_dir, sug_clean, NULL);    path2 = g_strdup(path);    while (g_file_test(path2, G_FILE_TEST_EXISTS) && suffix < 1000)    {        g_free(path2);        path2 = g_strdup_printf("%s.%d", path, suffix);        suffix++;    }    if (suffix == 1000)    {        fprintf(stderr, __NAME__": Suffix reached limit for download./n");        webkit_download_cancel(download);    }    else    {        uri = g_filename_to_uri(path2, NULL, NULL);        webkit_download_set_destination(download, uri);        g_free(uri);        tb = gtk_tool_button_new(NULL, NULL);        gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(tb), "gtk-delete");        gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), sug_clean);        gtk_toolbar_insert(GTK_TOOLBAR(dm.toolbar), tb, 0);        gtk_widget_show_all(dm.win);        g_signal_connect(G_OBJECT(download), "notify::estimated-progress",                         G_CALLBACK(changed_download_progress), tb);        g_object_ref(download);        g_signal_connect(G_OBJECT(tb), "clicked",                         G_CALLBACK(downloadmanager_cancel), download);    }    g_free(sug_clean);    g_free(path);    g_free(path2);    /* Propagate -- to whom it may concern. */    return FALSE;}

static inline GtkToolItem *_add_category_button (GtkWidget *pToolBar, const gchar *cLabel, const gchar *cIconName, int pos, GtkToolItem *group){	GtkToolItem *pCategoryButton;	if (group)		pCategoryButton= gtk_radio_tool_button_new_from_widget (GTK_RADIO_TOOL_BUTTON (group));	else		pCategoryButton = gtk_radio_tool_button_new (NULL);	gtk_tool_button_set_label (GTK_TOOL_BUTTON (pCategoryButton), cLabel);	gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (pCategoryButton), cIconName);	g_signal_connect (G_OBJECT (pCategoryButton), "toggled", G_CALLBACK(on_click_category_button), GINT_TO_POINTER (pos));	gtk_toolbar_insert (GTK_TOOLBAR (pToolBar) , pCategoryButton, -1);	return pCategoryButton;}

GtkToolItem * ColorToolItem::newItem() {	XOJ_CHECK_TYPE(ColorToolItem);	this->iconWidget = selectcolor_new(this->color);	selectcolor_set_circle(this->iconWidget, !isSelector());	GtkToolItem * it = gtk_toggle_tool_button_new();	gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), this->name.c_str());	gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), this->name.c_str());	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->iconWidget);	return it;}

void toolbar_connect_click(gpointer data){    GtkToolButton *toolbar_connect = GTK_TOOL_BUTTON(data);    if (!c_core->GetSession()->IsConnected())    {        INFO("debug", "connect button pressed/n");        if(!request_auth(gres.window))        {            push_status_bar("Insert valid credentials!");        }        else            if(!c_core->Connect())                push_status_bar("Connection failed!");        return;    }    if(c_core->GetSession()->IsConnected())    {        INFO("debug", "disconnect button pressed/n");        c_core->GetSession()->ClearPassword();        if(!c_core->Disconnect())            push_status_bar("Disconnection failed!?");    }}

voidchanged_download_progress(GObject *obj, GParamSpec *pspec, gpointer data){    WebKitDownload *download = WEBKIT_DOWNLOAD(obj);    WebKitURIResponse *resp;    GtkToolItem *tb = GTK_TOOL_ITEM(data);    gdouble p, size_mb;    const gchar *uri;    gchar *t, *filename, *base;    p = webkit_download_get_estimated_progress(download) * 100;    resp = webkit_download_get_response(download);    size_mb = webkit_uri_response_get_content_length(resp) / 1e6;    uri = webkit_download_get_destination(download);    filename = g_filename_from_uri(uri, NULL, NULL);    if (filename == NULL)    {        /* This really should not happen because WebKit uses that URI to         * write to a file... */        fprintf(stderr, __NAME__": Could not construct file name from URI!/n");        t = g_strdup_printf("%s (%.0f%% of %.1f MB)",                            webkit_uri_response_get_uri(resp), p, size_mb);    }    else    {        base = g_path_get_basename(filename);        t = g_strdup_printf("%s (%.0f%% of %.1f MB)", base, p, size_mb);        g_free(filename);        g_free(base);    }    gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), t);    g_free(t);}

static voidconnect_proxy_cb (GtkUIManager *manager,                  GtkAction *action,                  GtkWidget *proxy,                  NautilusWindow *window){    GdkPixbuf *icon;    GtkWidget *widget;    if (GTK_IS_MENU_ITEM (proxy)) {        g_signal_connect (proxy, "select",                          G_CALLBACK (menu_item_select_cb), window);        g_signal_connect (proxy, "deselect",                          G_CALLBACK (menu_item_deselect_cb), window);        /* This is a way to easily get pixbufs into the menu items */        icon = g_object_get_data (G_OBJECT (action), "menu-icon");        if (icon != NULL) {            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy),                                           gtk_image_new_from_pixbuf (icon));        }    }    if (GTK_IS_TOOL_BUTTON (proxy)) {        icon = g_object_get_data (G_OBJECT (action), "toolbar-icon");        if (icon != NULL) {            widget = gtk_image_new_from_pixbuf (icon);            gtk_widget_show (widget);            gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (proxy),                                             widget);        }    }}

static voidinteractive_canvas_drag_data_received (GtkWidget        *widget,                                       GdkDragContext   *context,                                       gint              x,                                       gint              y,                                       GtkSelectionData *selection,                                       guint             info,                                       guint             time,                                       gpointer          data){  /* find the tool button which is the source of this DnD operation */  GtkWidget *palette = gtk_drag_get_source_widget (context);  GtkWidget *tool_item = NULL;  while (palette && !GTK_IS_TOOL_PALETTE (palette))    palette = gtk_widget_get_parent (palette);  if (palette)    tool_item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),                                                selection);  /* create a drop indicator when a tool button was found */  g_assert (NULL == drop_item);  if (GTK_IS_TOOL_ITEM (tool_item))    {      drop_item = canvas_item_new (widget, GTK_TOOL_BUTTON (tool_item), x, y);      gdk_drag_status (context, GDK_ACTION_COPY, time);      gtk_widget_queue_draw (widget);    }}

static GVariant *gtk_tool_button_get_action_target_value (GtkActionable *actionable){  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);  return gtk_actionable_get_action_target_value (GTK_ACTIONABLE (button->priv->button));}

static const gchar *gtk_tool_button_get_action_name (GtkActionable *actionable){  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);  return gtk_actionable_get_action_name (GTK_ACTIONABLE (button->priv->button));}

static voidgtk_tool_button_style_updated (GtkWidget *widget){  GTK_WIDGET_CLASS (gtk_tool_button_parent_class)->style_updated (widget);  gtk_tool_button_update_icon_spacing (GTK_TOOL_BUTTON (widget));}

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 voidgtk_tool_button_get_property (GObject         *object,			      guint            prop_id,			      GValue          *value,			      GParamSpec      *pspec){  GtkToolButton *button = GTK_TOOL_BUTTON (object);  switch (prop_id)    {    case PROP_LABEL:      g_value_set_string (value, gtk_tool_button_get_label (button));      break;    case PROP_LABEL_WIDGET:      g_value_set_object (value, gtk_tool_button_get_label_widget (button));      break;    case PROP_USE_UNDERLINE:      g_value_set_boolean (value, gtk_tool_button_get_use_underline (button));      break;    case PROP_STOCK_ID:      g_value_set_string (value, button->priv->stock_id);      break;    case PROP_ICON_NAME:      g_value_set_string (value, button->priv->icon_name);      break;    case PROP_ICON_WIDGET:      g_value_set_object (value, button->priv->icon_widget);      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;    }}

static voidtab_panel_view_notify_icon_cb (GtkWidget*       view,                               GParamSpec*      pspec,                               MidoriExtension* extension){    MidoriBrowser* browser = midori_browser_get_for_widget (view);    gboolean minimized = katze_object_get_boolean (view, "minimized");    GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view));    if (minimized)    {        GtkToolItem* toolitem = tab_panel_get_toolitem_for_view (view);        GtkWidget* image = gtk_tool_button_get_icon_widget (GTK_TOOL_BUTTON (toolitem));        gtk_image_set_from_pixbuf (GTK_IMAGE (image), icon);    }    else    {        GtkTreeModel* model = tab_panel_get_model_for_browser (browser);        GtkTreeIter iter;        GtkWidget* label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));        GtkStyle* style = gtk_widget_get_style (label);        if (tab_panel_get_iter_for_view (model, &iter, view))            gtk_tree_store_set (GTK_TREE_STORE (model), &iter,                3, icon,                6, &style->bg[GTK_STATE_NORMAL],                7, &style->fg[GTK_STATE_NORMAL],                -1);    }}

void attach_icon(const char *toolbutton_name, const char *filename){     GtkWidget *img, *button = lookup_widget ( main_window, toolbutton_name );     GdkPixbuf *pixbuf;     GError *error = NULL;     if (!button)     {        Publisher::warn ( std::string("Code bug:/nattach_icon() called with an invalid widget name/n")+toolbutton_name );        return;     }     pixbuf = gdk_pixbuf_new_from_file(filename,&error);     if (!pixbuf)     {        Publisher::warn ( std::string("Pixmap problem:/nCould not create a pixmap from/n")                        + filename                        + ",/nerror message:/n"                        + error->message );        return;     }     img = gtk_image_new_from_pixbuf(pixbuf);     if (!img)     {        Publisher::warn ( "Unknown origin bug:/nCould not create an image from a pixmap" );        return;     }     gtk_widget_show(img);     gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (button), img);}

static void ink_toggle_action_update_icon( InkToggleAction* action ){    if ( action ) {        GSList* proxies = gtk_action_get_proxies( GTK_ACTION(action) );        while ( proxies ) {            if ( GTK_IS_TOOL_ITEM(proxies->data) ) {                if ( GTK_IS_TOOL_BUTTON(proxies->data) ) {                    GtkToolButton* button = GTK_TOOL_BUTTON(proxies->data);                    GtkWidget* child = sp_icon_new( action->private_data->iconSize, action->private_data->iconId );#if GTK_CHECK_VERSION(3,0,0)		    gtk_widget_set_hexpand(child, FALSE);		    gtk_widget_set_vexpand(child, FALSE);		    gtk_widget_show_all(child);		    gtk_tool_button_set_icon_widget(button, child);#else                    GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 );                    gtk_container_add( GTK_CONTAINER(align), child );                    gtk_widget_show_all( align );                    gtk_tool_button_set_icon_widget( button, align );#endif                }            }            proxies = g_slist_next( proxies );        }    }}

static voidupdate_playstatus(void *opaque, prop_event_t event, ...){  playdeck_t *pd = opaque;  const char *status;  va_list ap;  va_start(ap, event);  switch(event) {  default:  case PROP_SET_VOID:    bar_sensitivity(pd, FALSE);    break;  case PROP_SET_CSTRING:    status = va_arg(ap, const char *);    if(0)  case PROP_SET_RSTRING:      status = rstr_get(va_arg(ap, const rstr_t *));    bar_sensitivity(pd, TRUE);    gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(pd->playpause), 				 !strcmp(status, "play") ? 				 GTK_STOCK_MEDIA_PAUSE:				 GTK_STOCK_MEDIA_PLAY);    pd->pp_action = !strcmp(status, "play") ? ACTION_PAUSE : ACTION_PLAY;    break;  }}

intmain(int argc, char *argv[]) {    gtk_init(&argc, &argv);    gst_init(&argc, &argv);	GMutex* lock;	GList *list;    builder = gtk_builder_new();    if (!gtk_builder_add_from_file(builder, "UI.glade", NULL)) {        g_print("Error opening file");        return 0;    }    window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));    vBox = GTK_WIDGET(gtk_builder_get_object(builder, "vbox"));    vBoxBottom = GTK_WIDGET(gtk_builder_get_object(builder, "vboxBottom"));    hBoxToolbar = GTK_WIDGET(gtk_builder_get_object(builder, "hboxToolbar"));    hBoxMain = GTK_WIDGET(gtk_builder_get_object(builder, "hboxMain"));    // hBox = GTK_WIDGET (gtk_builder_get_object (builder, "hbox"));    menu = GTK_MENU_BAR(gtk_builder_get_object(builder, "menubar"));    FileItem = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menuitemFile"));    MenuFile = GTK_MENU(gtk_builder_get_object(builder, "menuFile"));    video_output = GTK_WIDGET(gtk_builder_get_object(builder, "drawingarea"));    hScale = GTK_HSCALE(gtk_builder_get_object(builder, "hscale"));    hScaleAdjustment = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "adjustment"));    // button = GTK_WIDGET (gtk_builder_get_object (builder, "button" ));    openMenu = GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "imagemenuitemOpen"));    quitMenu = GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "imagemenuitemQuit"));    toolBar = GTK_TOOLBAR(gtk_builder_get_object(builder, "toolbar"));    buttonPlay = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonPlay"));    buttonPause = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonPause"));    buttonStop = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonStop"));    volumeButton = GTK_VOLUME_BUTTON(gtk_builder_get_object(builder, "volumebutton"));    seek_cb_signal = g_signal_connect (G_OBJECT (hScale), "value-changed", G_CALLBACK (seek_cb), NULL);    g_signal_connect (G_OBJECT (hScale), "button-press-event", G_CALLBACK (slider_button_press_cb), NULL);    g_signal_connect (G_OBJECT (hScale), "button-release-event", G_CALLBACK (slider_button_release_cb), NULL);    gtk_builder_connect_signals(builder, NULL);    g_object_unref(G_OBJECT(builder));    gtk_widget_show_all(window);  //  g_timeout_add(1, changeScroll, NULL);   duration = GST_CLOCK_TIME_NONE;    gtk_main();    gst_element_set_state (pipeline, GST_STATE_NULL);    gst_object_unref (pipeline);    return 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 voidgtk_tool_button_set_action_name (GtkActionable *actionable,                                 const gchar   *action_name){  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);  gtk_actionable_set_action_name (GTK_ACTIONABLE (button->priv->button), action_name);}

static voidgtk_tool_button_set_action_target_value (GtkActionable *actionable,                                         GVariant      *action_target){  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);  gtk_actionable_set_action_target_value (GTK_ACTIONABLE (button->priv->button), action_target);}

static voidupdate_preview_labels(signal_user_data_t *ud, gboolean active){    GtkToolButton *button;    button   = GTK_TOOL_BUTTON(GHB_WIDGET(ud->builder, "show_preview"));    gtk_tool_button_set_label(button, "Preview");}