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 gboolean
gtk_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 void
schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header)
{
g_print ("%s ()\n", __FUNCTION__);
customization_data_init (G_OBJECT (perspective), toolbar, header);
/* add perspective's actions */
customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries));
/* add to toolbar */
GtkToolItem *titem;
titem = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#ifdef HAVE_GOOCANVAS
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#endif
}
gboolean
download_handle(WebKitDownload *download, gchar *suggested_filename, gpointer data)
{
gchar *sug_clean, *path, *path2 = NULL, *uri;
GtkToolItem *tb;
int suffix = 1;
size_t i;
sug_clean = g_strdup(suggested_filename);
for (i = 0; i < strlen(sug_clean); i++)
if (sug_clean[i] == G_DIR_SEPARATOR)
sug_clean[i] = '_';
path = g_build_filename(download_dir, sug_clean, NULL);
path2 = g_strdup(path);
while (g_file_test(path2, G_FILE_TEST_EXISTS) && suffix < 1000)
{
g_free(path2);
path2 = g_strdup_printf("%s.%d", path, suffix);
suffix++;
}
if (suffix == 1000)
{
fprintf(stderr, __NAME__": Suffix reached limit for download.\n");
webkit_download_cancel(download);
}
else
{
uri = g_filename_to_uri(path2, NULL, NULL);
webkit_download_set_destination(download, uri);
g_free(uri);
tb = gtk_tool_button_new(NULL, NULL);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(tb), "gtk-delete");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), sug_clean);
gtk_toolbar_insert(GTK_TOOLBAR(dm.toolbar), tb, 0);
gtk_widget_show_all(dm.win);
g_signal_connect(G_OBJECT(download), "notify::estimated-progress",
G_CALLBACK(changed_download_progress), tb);
g_object_ref(download);
g_signal_connect(G_OBJECT(tb), "clicked",
G_CALLBACK(downloadmanager_cancel), download);
}
g_free(sug_clean);
g_free(path);
g_free(path2);
/* Propagate -- to whom it may concern. */
return FALSE;
}
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;
}
GtkToolItem *hwidget_get_tool_button(const gchar *image_file,
const gchar *label,
const gchar *tooltips_string,
gpointer callback,
gpointer data,
guint type)
{
GtkToolItem *button;
GtkWidget *pixmap;
GtkTooltips *tooltips;
switch (type) {
case HWIDGET_TOGGLE_TOOL_BUTTON:
button = gtk_toggle_tool_button_new();
if (callback) {
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(callback), data);
}
break;
case HWIDGET_TOOL_BUTTON:
button = gtk_tool_button_new(NULL, NULL);
if (callback) {
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback), data);
}
break;
default:
return NULL;
}
if (image_file) {
pixmap = hutil_create_pixmap(image_file);
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button),
pixmap);
}
if (label) {
gtk_tool_button_set_label(GTK_TOOL_BUTTON(button), label);
}
if (tooltips_string) {
tooltips = gtk_tooltips_new();
gtk_tool_item_set_tooltip(button, tooltips, tooltips_string,
NULL);
}
return button;
}
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!?");
}
}
void
changed_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 void
connect_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 void
interactive_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 void
gtk_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 void
gtk_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 void
tab_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 void
update_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;
}
}
int
main(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 void
gtk_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 void
gtk_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 void
update_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");
}
