/**
* create_bookmarks_window:
*
* Create a new bookmark-editing window.
* @list: The NautilusBookmarkList that this window will edit.
*
* Return value: A pointer to the new window.
**/
GtkWindow *
create_bookmarks_window (NautilusBookmarkList *list, GObject *undo_manager_source)
{
GtkWidget *window;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
GladeXML *gui;
bookmarks = list;
gui = eel_glade_get_file (GLADEDIR "/nautilus-bookmarks-window.glade",
NULL, NULL,
"bookmarks_dialog", &window,
"bookmark_tree_view", &bookmark_list_widget,
"bookmark_delete_button", &remove_button,
"bookmark_jump_button", &jump_button,
NULL);
if (!gui) {
return NULL;
}
application = NAUTILUS_WINDOW (undo_manager_source)->application;
if (NAUTILUS_IS_NAVIGATION_WINDOW (undo_manager_source)) {
parent_is_browser_window = TRUE;
} else {
parent_is_browser_window = FALSE;
}
set_up_close_accelerator (window);
nautilus_undo_share_undo_manager (G_OBJECT (window), undo_manager_source);
gtk_window_set_wmclass (GTK_WINDOW (window), "bookmarks", "Nautilus");
nautilus_bookmarks_window_restore_geometry (window);
g_object_weak_ref (G_OBJECT (undo_manager_source), edit_bookmarks_dialog_reset_signals,
undo_manager_source);
bookmark_list_widget = GTK_TREE_VIEW (glade_xml_get_widget (gui, "bookmark_tree_view"));
rend = gtk_cell_renderer_pixbuf_new ();
col = gtk_tree_view_column_new_with_attributes ("Icon",
rend,
"pixbuf",
BOOKMARK_LIST_COLUMN_ICON,
NULL);
gtk_tree_view_append_column (bookmark_list_widget,
GTK_TREE_VIEW_COLUMN (col));
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col),
NAUTILUS_ICON_SIZE_SMALLER);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Icon",
rend,
"text",
BOOKMARK_LIST_COLUMN_NAME,
"style",
BOOKMARK_LIST_COLUMN_STYLE,
NULL);
gtk_tree_view_append_column (bookmark_list_widget,
GTK_TREE_VIEW_COLUMN (col));
bookmark_list_store = create_bookmark_store ();
setup_empty_list ();
gtk_tree_view_set_model (bookmark_list_widget,
GTK_TREE_MODEL (bookmark_empty_list_store));
bookmark_selection =
GTK_TREE_SELECTION (gtk_tree_view_get_selection (bookmark_list_widget));
name_field = nautilus_entry_new ();
gtk_widget_show (name_field);
gtk_box_pack_start (GTK_BOX (glade_xml_get_widget (gui, "bookmark_name_placeholder")),
name_field, TRUE, TRUE, 0);
nautilus_undo_editable_set_undo_key (GTK_EDITABLE (name_field), TRUE);
gtk_label_set_mnemonic_widget (
GTK_LABEL (glade_xml_get_widget (gui, "bookmark_name_label")),
name_field);
uri_field = nautilus_entry_new ();
gtk_widget_show (uri_field);
gtk_box_pack_start (GTK_BOX (glade_xml_get_widget (gui, "bookmark_location_placeholder")),
uri_field, TRUE, TRUE, 0);
nautilus_undo_editable_set_undo_key (GTK_EDITABLE (uri_field), TRUE);
gtk_label_set_mnemonic_widget (
GTK_LABEL (glade_xml_get_widget (gui, "bookmark_location_label")),
uri_field);
bookmark_list_changed_signal_id =
g_signal_connect (bookmarks, "contents_changed",
G_CALLBACK (on_bookmark_list_changed), NULL);
row_changed_signal_id =
g_signal_connect (bookmark_list_store, "row_changed",
G_CALLBACK (on_row_changed), NULL);
row_deleted_signal_id =
g_signal_connect (bookmark_list_store, "row_deleted",
G_CALLBACK (on_row_deleted), NULL);
row_activated_signal_id =
g_signal_connect (bookmark_list_widget, "row_activated",
G_CALLBACK (on_row_activated), undo_manager_source);
button_pressed_signal_id =
g_signal_connect (bookmark_list_widget, "button_press_event",
G_CALLBACK (on_button_pressed), NULL);
key_pressed_signal_id =
g_signal_connect (bookmark_list_widget, "key_press_event",
G_CALLBACK (on_key_pressed), NULL);
selection_changed_id =
g_signal_connect (bookmark_selection, "changed",
G_CALLBACK (on_selection_changed), NULL);
g_signal_connect (window, "delete_event",
G_CALLBACK (on_window_delete_event), NULL);
g_signal_connect (window, "hide",
G_CALLBACK (on_window_hide_event), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (on_window_destroy_event), NULL);
g_signal_connect (window, "response",
G_CALLBACK (nautilus_bookmarks_window_response_callback), NULL);
name_field_changed_signal_id =
g_signal_connect (name_field, "changed",
G_CALLBACK (on_name_field_changed), NULL);
g_signal_connect (name_field, "focus_out_event",
G_CALLBACK (on_text_field_focus_out_event), NULL);
g_signal_connect (name_field, "activate",
G_CALLBACK (name_or_uri_field_activate), NULL);
uri_field_changed_signal_id =
g_signal_connect (uri_field, "changed",
G_CALLBACK (on_uri_field_changed), NULL);
g_signal_connect (uri_field, "focus_out_event",
G_CALLBACK (on_text_field_focus_out_event), NULL);
g_signal_connect (uri_field, "activate",
G_CALLBACK (name_or_uri_field_activate), NULL);
g_signal_connect (remove_button, "clicked",
G_CALLBACK (on_remove_button_clicked), NULL);
jump_button_signal_id =
g_signal_connect (jump_button, "clicked",
G_CALLBACK (on_jump_button_clicked), undo_manager_source);
gtk_tree_selection_set_mode (bookmark_selection, GTK_SELECTION_BROWSE);
/* Fill in list widget with bookmarks, must be after signals are wired up. */
repopulate();
g_object_unref (G_OBJECT (gui));
return GTK_WINDOW (window);
}
gboolean
plug_in_icc_profile_apply_rgb (GimpImage *image,
GimpContext *context,
GimpProgress *progress,
GimpRunMode run_mode,
GError **error)
{
Gimp *gimp;
GimpProcedure *procedure;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
gimp = image->gimp;
if (gimp_image_get_base_type (image) == GIMP_GRAY)
{
g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED,
_("Can't apply color profile to grayscale image (%s)"),
ICC_PROFILE_APPLY_RGB_PROC);
return FALSE;
}
procedure = gimp_pdb_lookup_procedure (gimp->pdb, ICC_PROFILE_APPLY_RGB_PROC);
if (procedure &&
procedure->num_args >= 2 &&
GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) &&
GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]))
{
GimpValueArray *return_vals;
GimpPDBStatusType status;
GimpColorProfilePolicy policy = GIMP_COLOR_PROFILE_POLICY_ASK;
gboolean success;
return_vals =
gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error,
ICC_PROFILE_APPLY_RGB_PROC,
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID,
gimp_image_get_ID (image),
G_TYPE_NONE);
status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
switch (status)
{
case GIMP_PDB_SUCCESS:
policy = GIMP_COLOR_PROFILE_POLICY_CONVERT;
success = TRUE;
break;
case GIMP_PDB_CANCEL:
policy = GIMP_COLOR_PROFILE_POLICY_KEEP;
success = TRUE;
break;
default:
if (error && *error == NULL)
g_set_error (error,
GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED,
_("Error running '%s'"), ICC_PROFILE_APPLY_RGB_PROC);
success = FALSE;
break;
}
if (success && gimp_value_array_length (return_vals) > 1)
{
GValue *value = gimp_value_array_index (return_vals, 1);
if (GIMP_VALUE_HOLDS_INT32 (value) && g_value_get_int (value))
{
g_object_set (G_OBJECT (gimp->config),
"color-profile-policy", policy,
NULL);
}
}
gimp_value_array_unref (return_vals);
return success;
}
g_set_error (error,
GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_NOT_FOUND,
_("Plug-In missing (%s)"), ICC_PROFILE_APPLY_RGB_PROC);
return FALSE;
}
/* create a socket for sending to remote machine */
static gboolean
gst_udpsrc_open (GstUDPSrc * src)
{
GInetAddress *addr, *bind_addr;
GSocketAddress *bind_saddr;
GError *err = NULL;
gst_udpsrc_create_cancellable (src);
if (src->socket == NULL) {
/* need to allocate a socket */
GST_DEBUG_OBJECT (src, "allocating socket for %s:%d", src->address,
src->port);
addr = gst_udpsrc_resolve (src, src->address);
if (!addr)
goto name_resolve;
if ((src->used_socket =
g_socket_new (g_inet_address_get_family (addr),
G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &err)) == NULL)
goto no_socket;
src->external_socket = FALSE;
GST_DEBUG_OBJECT (src, "got socket %p", src->used_socket);
if (src->addr)
g_object_unref (src->addr);
src->addr =
G_INET_SOCKET_ADDRESS (g_inet_socket_address_new (addr, src->port));
GST_DEBUG_OBJECT (src, "binding on port %d", src->port);
/* On Windows it's not possible to bind to a multicast address
* but the OS will make sure to filter out all packets that
* arrive not for the multicast address the socket joined.
*
* On Linux and others it is necessary to bind to a multicast
* address to let the OS filter out all packets that are received
* on the same port but for different addresses than the multicast
* address
*/
#ifdef G_OS_WIN32
if (g_inet_address_get_is_multicast (addr))
bind_addr = g_inet_address_new_any (g_inet_address_get_family (addr));
else
#endif
bind_addr = G_INET_ADDRESS (g_object_ref (addr));
g_object_unref (addr);
bind_saddr = g_inet_socket_address_new (bind_addr, src->port);
g_object_unref (bind_addr);
if (!g_socket_bind (src->used_socket, bind_saddr, src->reuse, &err))
goto bind_error;
g_object_unref (bind_saddr);
g_socket_set_multicast_loopback (src->used_socket, src->loop);
} else {
GInetSocketAddress *local_addr;
GST_DEBUG_OBJECT (src, "using provided socket %p", src->socket);
/* we use the configured socket, try to get some info about it */
src->used_socket = G_SOCKET (g_object_ref (src->socket));
src->external_socket = TRUE;
local_addr =
G_INET_SOCKET_ADDRESS (g_socket_get_local_address (src->used_socket,
&err));
if (!local_addr)
goto getsockname_error;
/* See above for the reasons. Without this we would behave different on
* Windows and Linux, joining multicast groups below for provided sockets
* on Linux but not on Windows
*/
#ifdef G_OS_WIN32
addr = gst_udpsrc_resolve (src, src->address);
if (!addr)
goto name_resolve;
if (!src->auto_multicast ||
!g_inet_address_get_is_any (g_inet_socket_address_get_address
(local_addr))
|| !g_inet_address_get_is_multicast (addr)) {
g_object_unref (addr);
#endif
if (src->addr)
g_object_unref (src->addr);
src->addr = local_addr;
#ifdef G_OS_WIN32
} else {
g_object_unref (local_addr);
if (src->addr)
g_object_unref (src->addr);
src->addr =
G_INET_SOCKET_ADDRESS (g_inet_socket_address_new (addr, src->port));
g_object_unref (addr);
}
#endif
}
{
gint val = 0;
if (src->buffer_size != 0) {
GError *opt_err = NULL;
GST_INFO_OBJECT (src, "setting udp buffer of %d bytes", src->buffer_size);
/* set buffer size, Note that on Linux this is typically limited to a
* maximum of around 100K. Also a minimum of 128 bytes is required on
* Linux. */
if (!g_socket_set_option (src->used_socket, SOL_SOCKET, SO_RCVBUF,
src->buffer_size, &opt_err)) {
GST_ELEMENT_WARNING (src, RESOURCE, SETTINGS, (NULL),
("Could not create a buffer of requested %d bytes: %s",
src->buffer_size, opt_err->message));
g_error_free (opt_err);
opt_err = NULL;
}
}
/* read the value of the receive buffer. Note that on linux this returns
* 2x the value we set because the kernel allocates extra memory for
* metadata. The default on Linux is about 100K (which is about 50K
* without metadata) */
if (g_socket_get_option (src->used_socket, SOL_SOCKET, SO_RCVBUF, &val,
NULL)) {
GST_INFO_OBJECT (src, "have udp buffer of %d bytes", val);
} else {
GST_DEBUG_OBJECT (src, "could not get udp buffer size");
}
}
g_socket_set_broadcast (src->used_socket, TRUE);
if (src->auto_multicast
&&
g_inet_address_get_is_multicast (g_inet_socket_address_get_address
(src->addr))) {
GST_DEBUG_OBJECT (src, "joining multicast group %s", src->address);
if (!g_socket_join_multicast_group (src->used_socket,
g_inet_socket_address_get_address (src->addr),
FALSE, src->multi_iface, &err))
goto membership;
}
/* NOTE: sockaddr_in.sin_port works for ipv4 and ipv6 because sin_port
* follows ss_family on both */
{
GInetSocketAddress *addr;
guint16 port;
addr =
G_INET_SOCKET_ADDRESS (g_socket_get_local_address (src->used_socket,
&err));
if (!addr)
goto getsockname_error;
port = g_inet_socket_address_get_port (addr);
GST_DEBUG_OBJECT (src, "bound, on port %d", port);
if (port != src->port) {
src->port = port;
GST_DEBUG_OBJECT (src, "notifying port %d", port);
g_object_notify (G_OBJECT (src), "port");
}
g_object_unref (addr);
}
src->allocator = NULL;
gst_allocation_params_init (&src->params);
src->max_size = 0;
return TRUE;
/* ERRORS */
name_resolve:
{
return FALSE;
}
no_socket:
{
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
("no socket error: %s", err->message));
g_clear_error (&err);
g_object_unref (addr);
return FALSE;
}
bind_error:
{
GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL),
("bind failed: %s", err->message));
g_clear_error (&err);
g_object_unref (bind_saddr);
gst_udpsrc_close (src);
return FALSE;
}
membership:
{
GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL),
("could add membership: %s", err->message));
g_clear_error (&err);
gst_udpsrc_close (src);
return FALSE;
}
getsockname_error:
{
GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL),
("getsockname failed: %s", err->message));
g_clear_error (&err);
gst_udpsrc_close (src);
return FALSE;
}
}
GtkWidget *
gimp_text_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GimpTextOptions *options = GIMP_TEXT_OPTIONS (tool_options);
GtkWidget *main_vbox = gimp_tool_options_gui (tool_options);
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *entry;
GtkWidget *box;
GtkWidget *spinbutton;
GtkWidget *combo;
GtkSizeGroup *size_group;
gint row = 0;
hbox = gimp_prop_font_box_new (NULL, GIMP_CONTEXT (tool_options),
_("Font"), 2,
"font-view-type", "font-view-size");
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
entry = gimp_prop_size_entry_new (config,
"font-size", FALSE, "font-size-unit", "%p",
GIMP_SIZE_ENTRY_UPDATE_SIZE, 72.0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Size:"), 0.0, 0.5,
entry, 2, FALSE);
options->size_entry = entry;
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
button = gimp_prop_check_button_new (config, "use-editor", _("Use editor"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gimp_prop_check_button_new (config, "antialias", _("Antialiasing"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
table = gtk_table_new (6, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
row = 0;
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
button = gimp_prop_enum_combo_box_new (config, "hint-style", -1, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Hinting:"), 0.0, 0.5,
button, 1, TRUE);
gtk_size_group_add_widget (size_group, button);
button = gimp_prop_color_button_new (config, "foreground", _("Text Color"),
40, 24, GIMP_COLOR_AREA_FLAT);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (button),
GIMP_CONTEXT (options));
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Color:"), 0.0, 0.5,
button, 1, TRUE);
gtk_size_group_add_widget (size_group, button);
box = gimp_prop_enum_stock_box_new (config, "justify", "gtk-justify", 0, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Justify:"), 0.0, 0.5,
box, 2, TRUE);
gtk_size_group_add_widget (size_group, box);
g_object_unref (size_group);
spinbutton = gimp_prop_spin_button_new (config, "indent", 1.0, 10.0, 1);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 5);
gimp_table_attach_stock (GTK_TABLE (table), row++,
GTK_STOCK_INDENT, spinbutton, 1, TRUE);
spinbutton = gimp_prop_spin_button_new (config, "line-spacing", 1.0, 10.0, 1);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 5);
gimp_table_attach_stock (GTK_TABLE (table), row++,
GIMP_STOCK_LINE_SPACING, spinbutton, 1, TRUE);
spinbutton = gimp_prop_spin_button_new (config,
"letter-spacing", 1.0, 10.0, 1);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 5);
gimp_table_attach_stock (GTK_TABLE (table), row++,
GIMP_STOCK_LETTER_SPACING, spinbutton, 1, TRUE);
combo = gimp_prop_enum_combo_box_new (config, "box-mode", 0, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Box:"), 0.0, 0.5,
combo, 1, TRUE);
/* Only add the language entry if the iso-codes package is available. */
#ifdef HAVE_ISO_CODES
{
GtkWidget *label;
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Language:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gimp_prop_language_entry_new (config, "language");
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_widget_show (entry);
}
#endif
return main_vbox;
}
void stickynotes_applet_init_prefs(void)
{
stickynotes->builder = gtk_builder_new ();
gtk_builder_add_from_file (stickynotes->builder, BUILDER_PATH, NULL);
stickynotes->w_prefs = GTK_WIDGET (gtk_builder_get_object (stickynotes->builder,
"preferences_dialog"));
stickynotes->w_prefs_width = gtk_spin_button_get_adjustment (
GTK_SPIN_BUTTON (gtk_builder_get_object (
stickynotes->builder, "width_spin")));
stickynotes->w_prefs_height = gtk_spin_button_get_adjustment (
GTK_SPIN_BUTTON (gtk_builder_get_object (
stickynotes->builder, "height_spin")));
stickynotes->w_prefs_color = GTK_WIDGET (gtk_builder_get_object (stickynotes->builder,
"default_color"));
stickynotes->w_prefs_font_color = GTK_WIDGET (gtk_builder_get_object (stickynotes->builder,
"prefs_font_color"));
stickynotes->w_prefs_sys_color = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (stickynotes->builder,
"sys_color_check"))->toggle_button);
stickynotes->w_prefs_font = GTK_WIDGET (gtk_builder_get_object (stickynotes->builder,
"default_font"));
stickynotes->w_prefs_sys_font = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (stickynotes->builder,
"sys_font_check"))->toggle_button);
stickynotes->w_prefs_sticky = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (stickynotes->builder,
"sticky_check"))->toggle_button);
stickynotes->w_prefs_force = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (stickynotes->builder,
"force_default_check"))->toggle_button);
stickynotes->w_prefs_desktop = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (stickynotes->builder,
"desktop_hide_check"))->toggle_button);
g_signal_connect (G_OBJECT (stickynotes->w_prefs), "response",
G_CALLBACK (preferences_response_cb), NULL);
g_signal_connect (G_OBJECT (stickynotes->w_prefs), "delete-event",
G_CALLBACK (preferences_delete_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_width),
"value-changed",
G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_height),
"value-changed",
G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_sys_color),
"toggled",
G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect_swapped (G_OBJECT(stickynotes->w_prefs_sys_font),
"toggled", G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect (G_OBJECT (stickynotes->w_prefs_color),
"color-set", G_CALLBACK (preferences_color_cb), NULL);
g_signal_connect (G_OBJECT (stickynotes->w_prefs_font_color),
"color-set", G_CALLBACK (preferences_color_cb), NULL);
g_signal_connect (G_OBJECT (stickynotes->w_prefs_font),
"font-set", G_CALLBACK (preferences_font_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_sticky),
"toggled", G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_force),
"toggled", G_CALLBACK (preferences_save_cb), NULL);
g_signal_connect_swapped (G_OBJECT (stickynotes->w_prefs_desktop),
"toggled", G_CALLBACK (preferences_save_cb), NULL);
{
GtkSizeGroup *group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget(group, GTK_WIDGET (gtk_builder_get_object (stickynotes->builder, "width_label")));
gtk_size_group_add_widget(group, GTK_WIDGET (gtk_builder_get_object (stickynotes->builder, "height_label")));
gtk_size_group_add_widget(group, GTK_WIDGET (gtk_builder_get_object (stickynotes->builder, "prefs_color_label")));
g_object_unref(group);
}
if (!gconf_client_key_is_writable(stickynotes->gconf,
GCONF_PATH "/defaults/width", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "width_label")),
FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "width_spin")),
FALSE);
}
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/height", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "height_label")),
FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "height_spin")),
FALSE);
}
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/color", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_color_label")),
FALSE);
gtk_widget_set_sensitive (stickynotes->w_prefs_color, FALSE);
}
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/font_color", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_font_color_label")),
FALSE);
gtk_widget_set_sensitive (stickynotes->w_prefs_font_color,
FALSE);
}
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/settings/use_system_color", NULL))
gtk_widget_set_sensitive (stickynotes->w_prefs_sys_color,
FALSE);
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/defaults/font", NULL))
{
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (
stickynotes->builder, "prefs_font_label")),
FALSE);
gtk_widget_set_sensitive (stickynotes->w_prefs_font, FALSE);
}
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/settings/use_system_font", NULL))
gtk_widget_set_sensitive (stickynotes->w_prefs_sys_font,
FALSE);
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/settings/sticky", NULL))
gtk_widget_set_sensitive (stickynotes->w_prefs_sticky, FALSE);
if (!gconf_client_key_is_writable (stickynotes->gconf,
GCONF_PATH "/settings/force_default", NULL))
gtk_widget_set_sensitive (stickynotes->w_prefs_force, FALSE);
stickynotes_applet_update_prefs();
}
GtkWidget*
gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
{
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkGrid * grid;
int row;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_default_size(GTK_WINDOW(d),
gtr_pref_int_get (TR_KEY_details_window_width),
gtr_pref_int_get (TR_KEY_details_window_height));
if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))
g_assert_not_reached ();
g_assert (str);
data = g_new0 (struct OpenData, 1);
data->core = core;
data->ctor = ctor;
data->filename = g_strdup (tr_ctorGetSourceFile (ctor));
data->downloadDir = g_strdup (str);
data->file_list = gtr_file_list_new (core, 0);
str = _("Mo_ve .torrent file to the trash");
data->trash_check = gtk_check_button_new_with_mnemonic (str);
str = _("_Start when added");
data->run_check = gtk_check_button_new_with_mnemonic (str);
w = data->priority_combo = gtr_priority_combo_new ();
gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);
g_signal_connect (G_OBJECT (d), "response",
G_CALLBACK (addResponseCB), data);
row = 0;
grid = GTK_GRID (gtk_grid_new ());
gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
gtk_grid_set_row_spacing (grid, GUI_PAD);
gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);
/* "torrent file" row */
l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Source File"),
GTK_FILE_CHOOSER_ACTION_OPEN);
source_chooser = w;
gtk_widget_set_hexpand (w, TRUE);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
addTorrentFilters (GTK_FILE_CHOOSER (w));
g_signal_connect (w, "selection-changed",
G_CALLBACK (sourceChanged), data);
/* "destination folder" row */
row++;
l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Destination Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),
data->downloadDir))
g_warning ("couldn't select '%s'", data->downloadDir);
list = get_recent_destinations ();
for (walk = list; walk; walk = walk->next)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);
g_slist_free (list);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
g_signal_connect (w, "selection-changed",
G_CALLBACK (downloadDirChanged), data);
row++;
l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);
gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);
gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 2, 1);
/* file list row */
row++;
w = data->file_list;
gtk_widget_set_vexpand (w, TRUE);
gtk_widget_set_size_request (w, 466u, 300u);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* torrent priority row */
row++;
l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = data->priority_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
/* torrent priority row */
row++;
w = data->run_check;
if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* "trash .torrent file" row */
row++;
w = data->trash_check;
if (!tr_ctorGetDeleteSource (ctor, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if (data->filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename);
else
sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data);
gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid));
w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
gtk_widget_grab_focus (w);
return d;
}
int main(int argc, char **argv) {
GOptionContext *context;
RoccatDevice *konextdoptical;
GError *local_error = NULL;
int retval = EXIT_SUCCESS;
KoneplusRmp *rmp = NULL;
roccat_secure();
roccat_textdomain();
context = commandline_parse(&argc, &argv);
if (parameter_just_print_version) {
g_print(VERSION_STRING "\n");
goto exit1;
}
#if !(GLIB_CHECK_VERSION(2, 36, 0))
g_type_init();
#endif
konextdoptical = konextdoptical_device_first();
if (konextdoptical == NULL) {
g_critical(_("No %s found."), KONEXTDOPTICAL_DEVICE_NAME);
retval = EXIT_FAILURE;
goto exit1;
}
if (parameter_just_activate_driver_state) {
if (!koneplus_device_state_write(konextdoptical, KONEPLUS_DEVICE_STATE_STATE_ON, &local_error)) {
g_critical(_("Could not activate driver state: %s"), local_error->message);
retval = EXIT_FAILURE;
}
goto exit2;
}
if (parameter_just_deactivate_driver_state) {
if (!koneplus_device_state_write(konextdoptical, KONEPLUS_DEVICE_STATE_STATE_OFF, &local_error)) {
g_critical(_("Could not deactivate driver state: %s"), local_error->message);
retval = EXIT_FAILURE;
}
goto exit2;
}
if (parameter_just_update_firmware) {
if (!update_firmware(konextdoptical, parameter_just_update_firmware, &local_error)) {
g_critical(_("Could not update firmware: %s"), local_error->message);
retval = EXIT_FAILURE;
} else
g_message(_("Firmware updated successfully. Please reconnect device."));
goto exit2;
}
if (parameter_just_print_actual_profile) {
if (!print_actual_profile(konextdoptical, &local_error)) {
g_critical(_("Could not print actual profile: %s"), local_error->message);
retval = EXIT_FAILURE;
}
goto exit2;
}
if (parameter_just_reset) {
if (!reset(konextdoptical, &local_error)) {
g_critical(_("Could not reset device: %s"), local_error->message);
retval = EXIT_FAILURE;
}
goto exit2;
}
if (parameter_read_firmware) {
if (!print_firmware(konextdoptical, &local_error)) {
g_critical(_("Could not print firmware version: %s"), local_error->message);
retval = EXIT_FAILURE;
goto exit2;
}
}
if (parameter_sensor_read) {
if (!print_sensor_value(konextdoptical, &local_error)) {
g_critical(_("Could not read sensor register: %s"), local_error->message);
retval = EXIT_FAILURE;
goto exit2;
}
}
if (parameter_sensor_write != -1) {
koneplus_sensor_write_register(konextdoptical, parameter_sensor_register, parameter_sensor_write, &local_error);
if (local_error) {
g_critical(_("Could not write sensor register: %s"), local_error->message);
retval = EXIT_FAILURE;
goto exit2;
}
}
if (parameter_load != -1) {
rmp = konextdoptical_rmp_load(konextdoptical, parameter_load - 1, &local_error);
if (!rmp) {
g_critical(_("Could not load profile %i: %s"), parameter_load, local_error->message);
retval = EXIT_FAILURE;
goto exit2;
}
} else if (parameter_in_rmp) {
rmp = koneplus_rmp_read_with_path(parameter_in_rmp, konextdoptical_rmp_defaults(), &local_error);
if (!rmp) {
g_critical(_("Could not read rmp %s: %s"), parameter_in_rmp, local_error->message);
retval = EXIT_FAILURE;
goto exit2;
}
} else
rmp = konextdoptical_default_rmp();
koneplus_rmp_set_modified(rmp);
if (parameter_save != -1) {
if (!konextdoptical_rmp_save(konextdoptical, rmp, parameter_save - 1, &local_error)) {
g_critical(_("Could not save profile %i: %s"), parameter_save, local_error->message);
retval = EXIT_FAILURE;
goto exit3;
}
konextdoptical_dbus_emit_profile_data_changed_outside_instant(parameter_save);
}
if (parameter_out_rmp) {
if (!koneplus_rmp_write_with_path(parameter_out_rmp, rmp, &local_error)) {
g_critical(_("Could not write rmp %s: %s"), parameter_out_rmp, local_error->message);
retval = EXIT_FAILURE;
goto exit3;
}
}
if (parameter_activate_profile != -1) {
if (!koneplus_actual_profile_write(konextdoptical, parameter_activate_profile -1, &local_error)) {
g_critical(_("Could not activate profile %i: %s"), parameter_activate_profile, local_error->message);
retval = EXIT_FAILURE;
goto exit3;
}
konextdoptical_dbus_emit_profile_changed_outside_instant(parameter_activate_profile);
}
exit3:
koneplus_rmp_free(rmp);
exit2:
g_object_unref(G_OBJECT(konextdoptical));
exit1:
commandline_free(context);
g_clear_error(&local_error);
exit(retval);
}
int main(int argc, char *argv[])
{
if (argc < 3) {
printf("Usage: %s <username> <password>\n", argv[0]);
return 1;
}
GtkWidget *vbox;
GtkWidget *swin;
GtkTreeSelection *selection;
/* Create needed variables - not anymore, use appdata instead
HildonProgram *program;
HildonWindow *window; */
/* Create AppData */
AppData *appdata=g_malloc( sizeof( *appdata ) );
/* Initialize the GTK. */
gtk_init(&argc, &argv);
/* Create the Hildon program and setup the title */
g_set_application_name("Maemify");
#ifdef MAEMO4
appdata->program = HILDON_PROGRAM(hildon_program_get_instance());
/* Create HildonWindow and set it to HildonProgram */
appdata->window = HILDON_WINDOW(hildon_window_new());
hildon_program_add_window(appdata->program, appdata->window);
#else
appdata->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appdata->window), "Maemify");
gtk_widget_set_usize( GTK_WIDGET ( appdata->window ) , 600 , 300 );
/* create our table */
appdata->table = gtk_table_new(3, 3, FALSE); //three rows, three columns, not homogenous
gtk_container_add(GTK_CONTAINER(appdata->window),appdata->table);
#endif
/* Create find toolbar, but keep it hidden */
create_find_toolbar(appdata);
#ifdef MAEMO4
gtk_widget_show_all(GTK_WIDGET(appdata->find_toolbar));
/* Create menu for the Window */
create_menu(appdata->window);
#else
gtk_table_attach_defaults(GTK_TABLE(appdata->table), GTK_WIDGET(appdata->entry), 1, 2, 2, 3);
gtk_widget_show_all(GTK_WIDGET(appdata->table));
#endif
/* Begin the main application */
gtk_widget_show_all(GTK_WIDGET(appdata->window));
/* Connect signal to X in the upper corner */
g_signal_connect(G_OBJECT(appdata->window), "delete_event",
G_CALLBACK(gtk_main_quit), NULL);
if (!despotify_init())
{
printf("despotify_init() failed\n");
return 1;
}
appdata->ds = despotify_init_client(callback, NULL, false);
if (!appdata->ds) {
printf("despotify_init_client() failed\n");
return 1;
}
if (!despotify_authenticate(appdata->ds, argv[1], argv[2])) {
printf( "Authentication failed: %s\n", despotify_get_error(appdata->ds));
despotify_exit(appdata->ds);
return 1;
}
/* Create a tree view and place it in a scrolled window */
appdata->list = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(appdata->list), TRUE);
swin = gtk_scrolled_window_new(NULL, NULL);
vbox = gtk_vbox_new(FALSE, 0);
/* add labels to the fields */
appdata->label = gtk_label_new("Search hits");
gtk_label_set_justify(GTK_LABEL(appdata->label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(vbox), appdata->label, FALSE, FALSE, 5);
gtk_container_add(GTK_CONTAINER(swin), appdata->list);
#ifdef MAEMO4
gtk_container_add(GTK_CONTAINER(appdata->window), swin);
#else
gtk_table_attach_defaults(GTK_TABLE(appdata->table), swin, 1, 2, 1, 2);
#endif
/* initialize a list to hold search hits */
init_list(appdata->list);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(appdata->list));
g_signal_connect(selection, "changed",
G_CALLBACK(on_changed), appdata);
gtk_widget_show_all(GTK_WIDGET(appdata->window));
gtk_main();
despotify_deinit(appdata);
/* Exit */
return 0;
}
static void
set_state (GtkTextBuffer *buffer,
guint32 state)
{
g_object_set_data (G_OBJECT (buffer), E_BUFFER_TAGGER_DATA_STATE, GINT_TO_POINTER (state));
}
static void
gimp_curve_calculate (GimpCurve *curve)
{
gint *points;
gint i;
gint num_pts;
gint p1, p2, p3, p4;
if (gimp_data_is_frozen (GIMP_DATA (curve)))
return;
points = g_newa (gint, curve->n_points);
switch (curve->curve_type)
{
case GIMP_CURVE_SMOOTH:
/* cycle through the curves */
num_pts = 0;
for (i = 0; i < curve->n_points; i++)
if (curve->points[i].x >= 0.0)
points[num_pts++] = i;
/* Initialize boundary curve points */
if (num_pts != 0)
{
GimpVector2 point;
gint boundary;
point = curve->points[points[0]];
boundary = ROUND (point.x * (gdouble) (curve->n_samples - 1));
for (i = 0; i < boundary; i++)
curve->samples[i] = point.y;
point = curve->points[points[num_pts - 1]];
boundary = ROUND (point.x * (gdouble) (curve->n_samples - 1));
for (i = boundary; i < curve->n_samples; i++)
curve->samples[i] = point.y;
}
for (i = 0; i < num_pts - 1; i++)
{
p1 = points[MAX (i - 1, 0)];
p2 = points[i];
p3 = points[i + 1];
p4 = points[MIN (i + 2, num_pts - 1)];
gimp_curve_plot (curve, p1, p2, p3, p4);
}
/* ensure that the control points are used exactly */
for (i = 0; i < num_pts; i++)
{
gdouble x = curve->points[points[i]].x;
gdouble y = curve->points[points[i]].y;
curve->samples[ROUND (x * (gdouble) (curve->n_samples - 1))] = y;
}
g_object_notify (G_OBJECT (curve), "samples");
break;
case GIMP_CURVE_FREE:
break;
}
}
bool gtkgui_init(int argc, char *argv[], Stream_mixer *mix)
{
GtkWidget *bbox = NULL;
bool isx = false;
/* FIXME: bisogan mettere l'enable_nls*/
/* i18n */
setlocale(LC_ALL, "");
bindtextdomain("muse", LOCALEDIR);
bind_textdomain_codeset("muse", "UTF-8");
textdomain("muse");
/* initialization */
state = true;
mixer = mix;
list_init(&listachan);
list_init(&lamelist);
list_init(&ogglist);
iceprof = lameprof = vorbisprof = NULL;
if(!profile_init())
error(_("profile initialization error"));
profile_ice_load();
/* profile_lame_load and profile_vorbis_load are into encoder.cpp */
pathfile = NULL;
/* signal to glib we're going to use threads */
g_thread_init(NULL);
isx = gtk_init_check(&argc,&argv);
if(!isx)
return false;
isx = mixer->set_lineout(true);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("MuSE-cvs Gtk+2"));
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(gcb_exit), NULL);
/* FIXME: gtk2 remove ? */
gtk_widget_realize(window);
vbox=gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
fix = gtk_fixed_new();
gtk_box_pack_start(GTK_BOX(vbox), fix, FALSE, FALSE, 0);
bbox = createbbox(bbox);
gtk_fixed_put(GTK_FIXED(fix), bbox, 0, 0);
if(isx)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speakout), TRUE);
pack_new();
createch();
putstatusbar();
/*let's show window */
gtk_widget_show_all(window);
gtk_widget_hide(pack1.hscale);
gtk_widget_hide(pack2.hscale);
gtk_widget_hide(pack3.hscale);
return true;
}
static void
gegl_node_set_props (GeglNode *node,
va_list var_args)
{
const char *property_name;
g_object_freeze_notify (G_OBJECT (node));
property_name = va_arg (var_args, gchar *);
while (property_name)
{
GValue value = { 0, };
GParamSpec *pspec = NULL;
gchar *error = NULL;
if (!strcmp (property_name, "name"))
{
pspec = g_object_class_find_property (
G_OBJECT_GET_CLASS (G_OBJECT (node)), property_name);
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
G_VALUE_COLLECT (&value, var_args, 0, &error);
if (error)
{
g_warning ("%s: %s", G_STRFUNC, error);
g_free (error);
g_value_unset (&value);
break;
}
g_object_set_property (G_OBJECT (node), property_name, &value);
g_value_unset (&value);
}
else
{
if (node->operation)
{
pspec = g_object_class_find_property (
G_OBJECT_GET_CLASS (G_OBJECT (node->operation)), property_name);
}
if (!pspec)
{
g_warning ("%s:%s has no property named: '%s'",
G_STRFUNC,
gegl_node_get_debug_name (node), property_name);
break;
}
if (!(pspec->flags & G_PARAM_WRITABLE))
{
g_warning ("%s: property (%s of operation class '%s' is not writable",
G_STRFUNC,
pspec->name,
G_OBJECT_TYPE_NAME (node->operation));
break;
}
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
G_VALUE_COLLECT (&value, var_args, 0, &error);
if (error)
{
g_warning ("%s: %s", G_STRFUNC, error);
g_free (error);
g_value_unset (&value);
break;
}
g_object_set_property (G_OBJECT (node->operation), property_name, &value);
g_value_unset (&value);
}
property_name = va_arg (var_args, gchar *);
}
g_object_thaw_notify (G_OBJECT (node));
}
static void
nautilus_file_management_properties_dialog_setup (GtkBuilder *builder, GtkWindow *window)
{
GtkWidget *dialog;
/* setup UI */
nautilus_file_management_properties_size_group_create (builder,
"views_label",
4);
nautilus_file_management_properties_size_group_create (builder,
"captions_label",
3);
nautilus_file_management_properties_size_group_create (builder,
"preview_label",
3);
/* setup preferences */
bind_builder_bool (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_FOLDERS_FIRST_WIDGET,
NAUTILUS_PREFERENCES_SORT_DIRECTORIES_FIRST);
bind_builder_bool (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_TRASH_CONFIRM_WIDGET,
NAUTILUS_PREFERENCES_CONFIRM_TRASH);
bind_builder_bool (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_TRASH_DELETE_WIDGET,
NAUTILUS_PREFERENCES_ENABLE_DELETE);
bind_builder_bool (builder, gtk_filechooser_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_SHOW_HIDDEN_WIDGET,
NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES);
bind_builder_bool (builder, nautilus_list_view_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_LIST_VIEW_USE_TREE_WIDGET,
NAUTILUS_PREFERENCES_LIST_VIEW_USE_TREE);
bind_builder_enum (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_DEFAULT_VIEW_WIDGET,
NAUTILUS_PREFERENCES_DEFAULT_FOLDER_VIEWER,
(const char **) default_view_values);
bind_builder_enum (builder, nautilus_icon_view_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_ICON_VIEW_ZOOM_WIDGET,
NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL,
(const char **) zoom_values);
bind_builder_enum (builder, nautilus_list_view_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_LIST_VIEW_ZOOM_WIDGET,
NAUTILUS_PREFERENCES_LIST_VIEW_DEFAULT_ZOOM_LEVEL,
(const char **) zoom_values);
bind_builder_enum (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_SORT_ORDER_WIDGET,
NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER,
(const char **) sort_order_values);
bind_builder_enum (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_PREVIEW_FILES_WIDGET,
NAUTILUS_PREFERENCES_SHOW_FILE_THUMBNAILS,
(const char **) preview_values);
bind_builder_enum (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_PREVIEW_FOLDER_WIDGET,
NAUTILUS_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS,
(const char **) preview_values);
bind_builder_radio (builder, nautilus_preferences,
(const char **) click_behavior_components,
NAUTILUS_PREFERENCES_CLICK_POLICY,
(const char **) click_behavior_values);
bind_builder_radio (builder, nautilus_preferences,
(const char **) executable_text_components,
NAUTILUS_PREFERENCES_EXECUTABLE_TEXT_ACTIVATION,
(const char **) executable_text_values);
bind_builder_uint_enum (builder, nautilus_preferences,
NAUTILUS_FILE_MANAGEMENT_PROPERTIES_THUMBNAIL_LIMIT_WIDGET,
NAUTILUS_PREFERENCES_FILE_THUMBNAIL_LIMIT,
thumbnail_limit_values,
G_N_ELEMENTS (thumbnail_limit_values));
nautilus_file_management_properties_dialog_setup_icon_caption_page (builder);
nautilus_file_management_properties_dialog_setup_list_column_page (builder);
/* UI callbacks */
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "file_management_dialog"));
g_signal_connect_data (dialog, "response",
G_CALLBACK (nautilus_file_management_properties_dialog_response_cb),
g_object_ref (builder),
(GClosureNotify)g_object_unref,
0);
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "system-file-manager");
if (window) {
gtk_window_set_screen (GTK_WINDOW (dialog), gtk_window_get_screen(window));
}
preferences_dialog = dialog;
g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer *) &preferences_dialog);
gtk_widget_show (dialog);
}
/**
* gegl_graph_process:
* @path: The traversal path
*
* Process the prepared request. This will return the
* resulting buffer from the final node, or NULL if
* that node is a sink.
*
* If gegl_graph_prepare_request has not been called
* the behavior of this function is undefined.
*
* Return value: (transfer full): The result of the graph, or NULL if
* there is no output pad.
*/
GeglBuffer *
gegl_graph_process (GeglGraphTraversal *path,
gint level)
{
GList *list_iter = NULL;
GeglBuffer *result = NULL;
GeglOperationContext *context = NULL;
GeglOperationContext *last_context = NULL;
GeglBuffer *operation_result = NULL;
for (list_iter = path->dfs_path; list_iter; list_iter = list_iter->next)
{
GeglNode *node = GEGL_NODE (list_iter->data);
GeglOperation *operation = node->operation;
g_return_val_if_fail (node, NULL);
g_return_val_if_fail (operation, NULL);
GEGL_INSTRUMENT_START();
operation_result = NULL;
if (last_context)
gegl_operation_context_purge (last_context);
context = g_hash_table_lookup (path->contexts, node);
g_return_val_if_fail (context, NULL);
GEGL_NOTE (GEGL_DEBUG_PROCESS,
"Will process %s result_rect = %d, %d %d×%d",
gegl_node_get_debug_name (node),
context->result_rect.x, context->result_rect.y, context->result_rect.width, context->result_rect.height);
if (context->need_rect.width > 0 && context->need_rect.height > 0)
{
if (context->cached)
{
GEGL_NOTE (GEGL_DEBUG_PROCESS,
"Using cached result for %s",
gegl_node_get_debug_name (node));
operation_result = GEGL_BUFFER (node->cache);
}
else
{
/* Guarantee input pad */
if (gegl_node_has_pad (node, "input") &&
!gegl_operation_context_get_object (context, "input"))
{
gegl_operation_context_set_object (context, "input", G_OBJECT (gegl_graph_get_shared_empty(path)));
}
context->level = level;
gegl_operation_process (operation, context, "output", &context->need_rect, context->level);
operation_result = GEGL_BUFFER (gegl_operation_context_get_object (context, "output"));
if (operation_result && operation_result == (GeglBuffer *)operation->node->cache)
gegl_cache_computed (operation->node->cache, &context->need_rect, level);
}
}
else
{
operation_result = NULL;
}
if (operation_result)
{
GeglPad *output_pad = gegl_node_get_pad (node, "output");
GList *targets = gegl_graph_get_connected_output_contexts (path, output_pad);
GList *targets_iter;
GEGL_NOTE (GEGL_DEBUG_PROCESS,
"Will deliver the results of %s:%s to %d targets",
gegl_node_get_debug_name (node),
"output",
g_list_length (targets));
if (g_list_length (targets) > 1)
gegl_object_set_has_forked (G_OBJECT (operation_result));
for (targets_iter = targets; targets_iter; targets_iter = g_list_next (targets_iter))
{
ContextConnection *target_con = targets_iter->data;
gegl_operation_context_set_object (target_con->context, target_con->name, G_OBJECT (operation_result));
}
g_list_free_full (targets, free_context_connection);
}
last_context = context;
GEGL_INSTRUMENT_END ("process", gegl_node_get_operation (node));
}
if (last_context)
{
if (operation_result)
result = g_object_ref (operation_result);
else if (gegl_node_has_pad (last_context->operation->node, "output"))
result = g_object_ref (gegl_graph_get_shared_empty (path));
gegl_operation_context_purge (last_context);
}
return result;
}
/**
* create the scheduled part : that widgets are created at the beginning
* and normally never destroyed, they are showed only for
* scheduled transactions
* Cela ne fonctionne pas : tous les widgets sont détruits par la
* fonction gsb_form_create_widgets ( )
*
* \param table a GtkTable with the dimension SCHEDULED_HEIGHT*SCHEDULED_WIDTH to be filled
*
* \return FALSE
* */
gboolean gsb_form_scheduler_create ( GtkWidget *table )
{
gint row, column;
struct_element *element;
devel_debug (NULL);
if (!table)
return FALSE;
/* just in case... be sure that not created */
if (scheduled_element_list)
gsb_form_scheduler_free_list ( );
/* check the dimensions,
* if problem give a warning message but continue the program with changing the values */
g_object_get ( G_OBJECT (table),
"n-columns", &column,
"n-rows", &row,
NULL );
if ( column != SCHEDULED_WIDTH
||
row != SCHEDULED_HEIGHT )
{
warning_debug ( _("gsb_form_scheduler_create is called with a bad table,\n"
"the number of rows or columns is not good.\n"
"The function will resize the table to the correct values but "
"should check that warning."));
gtk_table_resize ( GTK_TABLE (table), SCHEDULED_HEIGHT, SCHEDULED_WIDTH );
}
/* ok, now fill the form
* we play with height and width, but for now it's fix : 6 columns and 1 line */
for ( row=0 ; row < SCHEDULED_HEIGHT ; row++ )
for ( column=0 ; column < SCHEDULED_WIDTH ; column++ )
{
gint element_number;
GtkWidget *widget = NULL;
const gchar *tooltip_text = NULL;
gchar *text_auto [] = { _("Manual"), _("Automatic"), NULL };
gchar *text_frequency [] = { _("Once"), _("Weekly"), _("Monthly"), _("Bimonthly"),
_("Quarterly"), _("Yearly"), _("Custom"), NULL };
gchar *text_frequency_user [] = { _("Days"), _("Weeks"), _("Months"), _("Years"), NULL };
element_number = row*SCHEDULED_WIDTH + column;
switch ( element_number )
{
case SCHEDULED_FORM_ACCOUNT:
widget = gsb_account_create_combo_list ( G_CALLBACK ( gsb_form_scheduler_change_account ),
NULL, FALSE);
gtk_combo_box_set_active ( GTK_COMBO_BOX (widget), 0 );
tooltip_text = _("Choose the account");
break;
case SCHEDULED_FORM_AUTO:
widget = gsb_combo_box_new_with_index ( text_auto, NULL, NULL );
tooltip_text = _("Automatic/manual scheduled transaction");
break;
case SCHEDULED_FORM_FREQUENCY_BUTTON:
widget = gsb_combo_box_new_with_index ( text_frequency,
G_CALLBACK (gsb_form_scheduler_frequency_button_changed), NULL );
tooltip_text = _("Frequency");
break;
case SCHEDULED_FORM_LIMIT_DATE:
widget = gsb_calendar_entry_new (FALSE);
g_signal_connect ( G_OBJECT (widget),
"button-press-event",
G_CALLBACK (gsb_form_scheduler_button_press_event),
GINT_TO_POINTER (element_number));
g_signal_connect ( G_OBJECT (widget),
"focus-in-event",
G_CALLBACK (gsb_form_entry_get_focus),
GINT_TO_POINTER (element_number));
g_signal_connect_after ( G_OBJECT (widget),
"focus-out-event",
G_CALLBACK (gsb_form_scheduler_entry_lose_focus),
GINT_TO_POINTER (element_number));
tooltip_text = _("Limit date");
break;
case SCHEDULED_FORM_FREQUENCY_USER_ENTRY:
widget = gtk_entry_new ();
g_signal_connect ( G_OBJECT (widget),
"focus-in-event",
G_CALLBACK (gsb_form_entry_get_focus),
GINT_TO_POINTER (element_number));
g_signal_connect_after ( G_OBJECT (widget),
"focus-out-event",
G_CALLBACK (gsb_form_scheduler_entry_lose_focus),
GINT_TO_POINTER (element_number));
tooltip_text = _("Own frequency");
break;
case SCHEDULED_FORM_FREQUENCY_USER_BUTTON:
widget = gsb_combo_box_new_with_index ( text_frequency_user,
NULL, NULL );
tooltip_text = _("Custom frequency");
break;
}
if (!widget)
continue;
if (tooltip_text)
gtk_widget_set_tooltip_text ( GTK_WIDGET (widget),
tooltip_text);
/* save the element */
element = g_malloc0 (sizeof (struct_element));
element -> element_number = element_number;
element -> element_widget = widget;
scheduled_element_list = g_slist_append ( scheduled_element_list,
element );
/* set in the form */
gtk_table_attach ( GTK_TABLE (table),
widget,
column, column+1,
row, row+1,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL,
0, 0);
}
gsb_form_scheduler_clean ( );
return FALSE;
}
static gint
sxftd_init( SXFromTransInfo *sxfti )
{
GtkWidget *w;
const char *transName;
gint pos;
GList *schedule = NULL;
time64 start_tt;
GDate date, nextDate;
if ( ! sxfti->sx )
{
return -1;
}
if ( ! sxfti->trans )
{
return -2;
}
if ( xaccTransIsOpen( sxfti->trans ) )
{
return SXFTD_ERRNO_OPEN_XACTION;
}
/* Setup Widgets */
{
sxfti->ne_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "never_end_button"));
sxfti->ed_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "end_on_date_button"));
sxfti->oc_but = GTK_TOGGLE_BUTTON(gtk_builder_get_object(sxfti->builder, "n_occurrences_button"));
sxfti->n_occurences = GTK_ENTRY(gtk_builder_get_object(sxfti->builder, "n_occurrences_entry"));
}
/* Get the name from the transaction, try that as the initial SX name. */
transName = xaccTransGetDescription( sxfti->trans );
xaccSchedXactionSetName( sxfti->sx, transName );
sxfti->name = GTK_ENTRY(gtk_builder_get_object(sxfti->builder, "name_entry" ));
pos = 0;
gtk_editable_insert_text( GTK_EDITABLE(sxfti->name), transName,
(strlen(transName) * sizeof(char)), &pos );
sxfti_attach_callbacks(sxfti);
/* Setup the example calendar and related data structures. */
{
int num_marks = SXFTD_EXCAL_NUM_MONTHS * 31;
w = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "ex_cal_frame" ));
sxfti->dense_cal_model = gnc_dense_cal_store_new(num_marks);
sxfti->example_cal = GNC_DENSE_CAL(gnc_dense_cal_new_with_model(GNC_DENSE_CAL_MODEL(sxfti->dense_cal_model)));
g_object_ref_sink(sxfti->example_cal);
g_assert(sxfti->example_cal);
gnc_dense_cal_set_num_months( sxfti->example_cal, SXFTD_EXCAL_NUM_MONTHS );
gnc_dense_cal_set_months_per_col( sxfti->example_cal, SXFTD_EXCAL_MONTHS_PER_COL );
gtk_container_add( GTK_CONTAINER(w), GTK_WIDGET(sxfti->example_cal) );
}
/* Setup the start and end dates as GNCDateEdits */
{
GtkWidget *paramTable = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "param_table" ));
sxfti->startDateGDE = GNC_DATE_EDIT( gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE));
gtk_grid_attach (GTK_GRID(paramTable), GTK_WIDGET(sxfti->startDateGDE), 1, 2, 1, 1);
gtk_widget_set_halign (GTK_WIDGET(sxfti->startDateGDE), GTK_ALIGN_FILL);
gtk_widget_set_valign (GTK_WIDGET(sxfti->startDateGDE), GTK_ALIGN_FILL);
gtk_widget_set_hexpand (GTK_WIDGET(sxfti->startDateGDE), TRUE);
gtk_widget_set_vexpand (GTK_WIDGET(sxfti->startDateGDE), FALSE);
g_object_set (GTK_WIDGET(sxfti->startDateGDE), "margin", 0, NULL);
g_signal_connect( sxfti->startDateGDE, "date-changed",
G_CALLBACK( sxftd_update_excal_adapt ),
sxfti );
}
{
GtkWidget *endDateBox = GTK_WIDGET(gtk_builder_get_object(sxfti->builder, "end_date_hbox" ));
sxfti->endDateGDE =
GNC_DATE_EDIT( gnc_date_edit_new (gnc_time (NULL),
FALSE, FALSE));
gtk_box_pack_start( GTK_BOX( endDateBox ),
GTK_WIDGET( sxfti->endDateGDE ),
TRUE, TRUE, 0 );
g_signal_connect( sxfti->endDateGDE, "date-changed",
G_CALLBACK( sxftd_update_excal_adapt ),
sxfti );
}
/* Setup the initial start date for user display/confirmation */
/* compute good initial date. */
start_tt = xaccTransGetDate( sxfti->trans );
gnc_gdate_set_time64( &date, start_tt );
sxfti->freq_combo = GTK_COMBO_BOX(gtk_builder_get_object(sxfti->builder, "freq_combo_box"));
gtk_combo_box_set_active(GTK_COMBO_BOX(sxfti->freq_combo), 0);
g_signal_connect( sxfti->freq_combo, "changed",
G_CALLBACK(sxftd_freq_combo_changed),
sxfti );
sxftd_update_schedule( sxfti, &date, &schedule);
recurrenceListNextInstance(schedule, &date, &nextDate);
recurrenceListFree(&schedule);
start_tt = gnc_time64_get_day_start_gdate (&nextDate);
gnc_date_edit_set_time( sxfti->startDateGDE, start_tt );
g_signal_connect( G_OBJECT(sxfti->name), "destroy",
G_CALLBACK(sxftd_destroy),
sxfti );
sxftd_update_example_cal( sxfti );
return 0;
}
/**
* callback called when changing the account from the form's button
* re-fill the form but keep the values
*
* \param button
* \param null
*
* \return FALSE
* */
gboolean gsb_form_scheduler_change_account ( GtkWidget *button,
gpointer null )
{
gint save_transaction;
gint save_execute;
GSList *content_list;
gboolean is_split = FALSE;
GtkWidget *category_entry;
const gchar *tmp_str;
gint new_account_number;
devel_debug (NULL);
new_account_number = gsb_form_get_account_number ();
/* need to check first if split (see later) */
category_entry = gsb_form_widget_get_widget (TRANSACTION_FORM_CATEGORY);
if ( category_entry )
{
tmp_str = gtk_combofix_get_text ( GTK_COMBOFIX ( category_entry) );
if ( gsb_form_widget_check_empty (GTK_COMBOFIX (category_entry) -> entry)
&&
tmp_str
&& strlen ( tmp_str ) > 0
&&
!strcmp ( tmp_str, _("Split of transaction") ) )
/* ok it's a split */
is_split = TRUE;
}
/* problem here : when change account, the form can be changed, with new or less widgets
* so we fill again de form
* but il the user fill the form and want to change after the account, it's annoying because
* filling again the form will lose all the data
* so first save the data and after filling the form, set back the data
* may still a problem : if for example we set a note, go to an account without notes, and
* go back to an account with a note, the first content of the note will be lost but it should
* be very rare to do that and i think very difficult to code something to keep that... */
save_transaction = GPOINTER_TO_INT (g_object_get_data ( G_OBJECT ( gsb_form_get_form_widget () ),
"transaction_number_in_form" ));
save_execute = GPOINTER_TO_INT (g_object_get_data ( G_OBJECT (gsb_form_get_form_widget ()),
"execute_scheduled"));
content_list = gsb_form_scheduler_get_content_list ();
gsb_form_fill_from_account (new_account_number);
/* a problem now, fill_from_account will clean the form,
* and make unsensitive some part of the form (method of payment...)
* and make sensitive some other part wich could be unsensitive (for split for example)
* so we call gsb_form_set_sensitive, but 2 args, split or child.
* cannot be a child because child cannot access to the account button, so just to check
* if it's a split (done before)
*/
gsb_form_change_sensitive_buttons (TRUE);
gsb_form_set_sensitive (is_split, FALSE);
gsb_form_scheduler_set_content_list (content_list);
gsb_form_scheduler_free_content_list (content_list);
g_object_set_data ( G_OBJECT ( gsb_form_get_form_widget () ),
"transaction_number_in_form",
GINT_TO_POINTER (save_transaction));
g_object_set_data ( G_OBJECT ( gsb_form_get_form_widget () ),
"execute_scheduled",
GINT_TO_POINTER (save_execute));
last_account_number = new_account_number;
return FALSE;
}
/***
*** Creates the simple application window with one
*** drawing area that has an OpenGL-capable visual.
***/
static GtkWidget *
create_window (GdkGLConfig *glconfig)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *menu;
GtkWidget *button;
/*
* Top-level window.
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), DEFAULT_TITLE);
/* Get automatically redrawn if any of their children changed allocation. */
gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);
/* Connect signal handlers to the window */
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/*
* Drawing area to draw OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, DEFAULT_WIDTH, DEFAULT_HEIGHT);
/* Set OpenGL-capability to the widget */
gtk_widget_set_gl_capability (drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
gtk_widget_add_events (drawing_area,
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_VISIBILITY_NOTIFY_MASK);
/* Connect signal handlers to the drawing area */
g_signal_connect_after (G_OBJECT (drawing_area), "realize",
G_CALLBACK (realize), NULL);
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "draw",
G_CALLBACK (draw), NULL);
g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
G_CALLBACK (motion_notify_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
G_CALLBACK (button_press_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "unrealize",
G_CALLBACK (unrealize), NULL);
/* key_press_event handler for top-level window */
g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
G_CALLBACK (key_press_event), drawing_area);
/* For idle function. */
g_signal_connect (G_OBJECT (drawing_area), "map_event",
G_CALLBACK (map_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
G_CALLBACK (unmap_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
G_CALLBACK (visibility_notify_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Popup menu.
*/
menu = create_popup_menu (drawing_area);
g_signal_connect_swapped (G_OBJECT (drawing_area), "button_press_event",
G_CALLBACK (button_press_event_popup_menu), menu);
/*
* Simple quit button.
*/
button = gtk_button_new_with_label ("Quit");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_main_quit), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
return window;
}
static void
gom_resource_fetch_m2m_cb (GomAdapter *adapter,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
GomCommandBuilder *builder = NULL;
GomResourceGroup *group;
GomRepository *repository;
const gchar *m2m_table;
GomResource *resource;
GomCommand *command = NULL;
GomCursor *cursor = NULL;
GomFilter *filter = NULL;
GError *error = NULL;
guint count = 0;
GType resource_type;
g_return_if_fail(GOM_IS_ADAPTER(adapter));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
m2m_table = g_object_get_data(G_OBJECT(simple), "m2m-table");
resource_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(simple),
"resource-type"));
filter = g_object_get_data(G_OBJECT(simple), "filter");
resource = GOM_RESOURCE(g_async_result_get_source_object(G_ASYNC_RESULT(simple)));
repository = gom_resource_get_repository(resource);
g_assert(GOM_IS_RESOURCE(resource));
g_assert(m2m_table);
g_assert(g_type_is_a(resource_type, GOM_TYPE_RESOURCE));
g_assert(!filter || GOM_IS_FILTER(filter));
g_assert(GOM_IS_REPOSITORY(repository));
builder = g_object_new(GOM_TYPE_COMMAND_BUILDER,
"adapter", adapter,
"filter", filter,
"resource-type", resource_type,
"m2m-table", m2m_table,
"m2m-type", G_TYPE_FROM_INSTANCE(resource),
NULL);
command = gom_command_builder_build_count(builder);
if (!gom_command_execute(command, &cursor, &error)) {
g_simple_async_result_take_error(simple, error);
goto out;
}
if (!gom_cursor_next(cursor)) {
g_simple_async_result_set_error(simple, GOM_ERROR,
GOM_ERROR_RESOURCE_CURSOR,
_("No result was returned from the cursor."));
goto out;
}
count = gom_cursor_get_column_int64(cursor, 0);
group = g_object_new(GOM_TYPE_RESOURCE_GROUP,
"count", count,
"filter", filter,
"m2m-table", m2m_table,
"m2m-type", G_TYPE_FROM_INSTANCE(resource),
"repository", repository,
"resource-type", resource_type,
NULL);
g_simple_async_result_set_op_res_gpointer(simple, group, g_object_unref);
out:
g_object_unref(resource);
g_clear_object(&command);
g_clear_object(&cursor);
g_clear_object(&builder);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
}
bool nvxio::GStreamerVideoRenderImpl::InitializeGStreamerPipeline()
{
std::ostringstream stream;
pipeline = GST_PIPELINE(gst_pipeline_new(NULL));
if (pipeline == NULL)
{
NVXIO_PRINT("Cannot create Gstreamer pipeline");
return false;
}
bus = gst_pipeline_get_bus(GST_PIPELINE (pipeline));
// create appsrc
GstElement * appsrcelem = gst_element_factory_make("appsrc", NULL);
if (appsrcelem == NULL)
{
NVXIO_PRINT("Cannot create appsrc");
FinalizeGStreamerPipeline();
return false;
}
g_object_set(G_OBJECT(appsrcelem), "is-live", 0, NULL);
g_object_set(G_OBJECT(appsrcelem), "num-buffers", -1, NULL);
g_object_set(G_OBJECT(appsrcelem), "emit-signals", 0, NULL);
g_object_set(G_OBJECT(appsrcelem), "block", 1, NULL);
g_object_set(G_OBJECT(appsrcelem), "size", static_cast<guint64>(wndHeight_ * wndWidth_ * 4), NULL);
g_object_set(G_OBJECT(appsrcelem), "format", GST_FORMAT_TIME, NULL);
g_object_set(G_OBJECT(appsrcelem), "stream-type", GST_APP_STREAM_TYPE_STREAM, NULL);
appsrc = GST_APP_SRC_CAST(appsrcelem);
#if GST_VERSION_MAJOR == 0
GstCaps * caps = gst_caps_new_simple("video/x-raw-rgb",
"bpp", G_TYPE_INT, 32,
"endianness", G_TYPE_INT, 4321,
"red_mask", G_TYPE_INT, -16777216,
"green_mask", G_TYPE_INT, 16711680,
"blue_mask", G_TYPE_INT, 65280,
"alpha_mask", G_TYPE_INT, 255,
"width", G_TYPE_INT, wndWidth_,
"height", G_TYPE_INT, wndHeight_,
"framerate", GST_TYPE_FRACTION, GSTREAMER_DEFAULT_FPS, 1,
NULL);
if (caps == NULL)
{
NVXIO_PRINT("Failed to create caps");
FinalizeGStreamerPipeline();
return false;
}
#else
// support 4 channel 8 bit data
stream << "video/x-raw"
<< ", width=" << wndWidth_
<< ", height=" << wndHeight_
<< ", format=(string){RGBA}"
<< ", framerate=" << GSTREAMER_DEFAULT_FPS << "/1;";
GstCaps * caps = gst_caps_from_string(stream.str().c_str());
if (caps == NULL)
{
NVXIO_PRINT("Failed to create caps");
FinalizeGStreamerPipeline();
return false;
}
caps = gst_caps_fixate(caps);
#endif
gst_app_src_set_caps(appsrc, caps);
gst_caps_unref(caps);
gst_bin_add(GST_BIN(pipeline), appsrcelem);
// create color convert element
GstElement * color = gst_element_factory_make(COLOR_ELEM, NULL);
if (color == NULL)
{
NVXIO_PRINT("Cannot create " COLOR_ELEM " element");
FinalizeGStreamerPipeline();
return false;
}
gst_bin_add(GST_BIN(pipeline), color);
// create videoflip element
GstElement * videoflip = gst_element_factory_make("videoflip", NULL);
if (videoflip == NULL)
{
NVXIO_PRINT("Cannot create videoflip element");
FinalizeGStreamerPipeline();
return false;
}
g_object_set(G_OBJECT(videoflip), "method", 5, NULL);
gst_bin_add(GST_BIN(pipeline), videoflip);
// create encodelem element
GstElement * encodelem = gst_element_factory_make(ENCODE_ELEM, NULL);
if (encodelem == NULL)
{
NVXIO_PRINT("Cannot create " ENCODE_ELEM " element");
FinalizeGStreamerPipeline();
return false;
}
gst_bin_add(GST_BIN(pipeline), encodelem);
// create avimux element
GstElement * avimux = gst_element_factory_make("avimux", NULL);
if (avimux == NULL)
{
NVXIO_PRINT("Cannot create avimux element");
FinalizeGStreamerPipeline();
return false;
}
gst_bin_add(GST_BIN(pipeline), avimux);
// create filesink element
GstElement * filesink = gst_element_factory_make("filesink", NULL);
if (filesink == NULL)
{
NVXIO_PRINT("Cannot create filesink element");
FinalizeGStreamerPipeline();
return false;
}
g_object_set(G_OBJECT(filesink), "location", windowTitle_.c_str(), NULL);
g_object_set(G_OBJECT(filesink), "append", 0, NULL);
gst_bin_add(GST_BIN(pipeline), filesink);
// link elements
if (!gst_element_link_many(appsrcelem, color, videoflip,
encodelem, avimux, filesink, NULL))
{
NVXIO_PRINT("GStreamer: cannot link appsrc -> " COLOR_ELEM
" -> videoflip -> " ENCODE_ELEM " -> avimux -> filesink");
FinalizeGStreamerPipeline();
return false;
}
// Force pipeline to play video as fast as possible, ignoring system clock
gst_pipeline_use_clock(pipeline, NULL);
num_frames = 0;
GstStateChangeReturn status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);
if (status == GST_STATE_CHANGE_FAILURE)
{
NVXIO_PRINT("GStreamer: unable to start playback");
FinalizeGStreamerPipeline();
return false;
}
return true;
}
void onDownloadStarted(WebKitWebView *webview, WebKitDownload *download, RuskWindow *rusk)
{
g_signal_connect(G_OBJECT(download), "decide-destination", G_CALLBACK(decideDownloadDestination), rusk);
}
int main (int argc, char *argv[])
{
gst_init(&argc, &argv); // init gstreamer
char* serial = NULL; // the serial number of the camera we want to use
GError* err = NULL;
GstElement* pipeline = gst_parse_launch("tcambin name=bin"
" ! video/x-raw,format=BGRx,width=640,height=480,framerate=30/1"
" ! tee name=t"
" ! queue"
" ! videoconvert"
" ! ximagesink"
" t."
" ! queue"
" ! videoconvert"
" ! avimux"
" ! filesink name=fsink", &err);
/*
to save a video without live view reduce the pipeline to the following:
GstElement* pipeline = Gst.parse_launch("tcambin name=bin"
" ! video/x-raw,format=BGRx,width=640,height=480,framerate=30/1"
" ! videoconvert"
" ! avimux"
" ! filesink name=fsink", &err);
*/
if (serial != NULL)
{
GstElement* source = gst_bin_get_by_name(GST_BIN(pipeline), "bin");
GValue val = {};
g_value_init(&val, G_TYPE_STRING);
g_value_set_static_string(&val, serial);
g_object_set_property(G_OBJECT(source), "serial", &val);
gst_object_unref(source);
}
const char* file_location = "/tmp/tiscamera-save-stream.avi";
GstElement* fsink = gst_bin_get_by_name(GST_BIN(pipeline), "fsink");
g_object_set(G_OBJECT(fsink), "location", file_location, NULL);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
printf("Press Enter to stop the recording\n");
getchar();
// this stops the pipeline and frees all resources
gst_element_set_state(pipeline, GST_STATE_NULL);
/* the pipeline automatically handles all elements that have been added to it.
thus they do not have to be cleaned up manually */
gst_object_unref(pipeline);
return 0;
}
/**
* gdk_gl_pixmap_new:
* @glconfig: a #GdkGLConfig.
* @pixmap: the #GdkPixmap to be used as the rendering area.
* @attrib_list: this must be set to NULL or empty (first attribute of None).
*
* Creates an off-screen rendering area.
* attrib_list is currently unused. This must be set to NULL or empty
* (first attribute of None). See GLX 1.3 spec.
*
* Return value: the new #GdkGLPixmap.
**/
GdkGLPixmap *
gdk_gl_pixmap_new (GdkGLConfig *glconfig,
GdkPixmap *pixmap,
const int *attrib_list)
{
GdkGLPixmap *glpixmap;
GdkGLPixmapImplX11 *impl;
Display *xdisplay;
XVisualInfo *xvinfo;
Pixmap xpixmap;
GLXPixmap glxpixmap;
Window root_return;
int x_return, y_return;
unsigned int width_return, height_return;
unsigned int border_width_return;
unsigned int depth_return;
GdkGL_GLX_MESA_pixmap_colormap *mesa_ext;
GDK_GL_NOTE_FUNC ();
g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_X11 (glconfig), NULL);
g_return_val_if_fail (GDK_IS_PIXMAP (pixmap), NULL);
xdisplay = GDK_GL_CONFIG_XDISPLAY (glconfig);
xvinfo = GDK_GL_CONFIG_XVINFO (glconfig);
/*
* Get X Pixmap.
*/
xpixmap = GDK_DRAWABLE_XID (GDK_DRAWABLE (pixmap));
/*
* Check depth of the X pixmap.
*/
if (!XGetGeometry (xdisplay, xpixmap,
&root_return,
&x_return, &y_return,
&width_return, &height_return,
&border_width_return,
&depth_return))
return NULL;
if (depth_return != (unsigned int) xvinfo->depth)
return NULL;
/*
* Create GLXPixmap.
*/
mesa_ext = gdk_gl_get_GLX_MESA_pixmap_colormap (glconfig);
if (mesa_ext)
{
/* If GLX_MESA_pixmap_colormap is supported. */
GDK_GL_NOTE_FUNC_IMPL ("glXCreateGLXPixmapMESA");
glxpixmap = mesa_ext->glXCreateGLXPixmapMESA (xdisplay,
xvinfo,
xpixmap,
GDK_GL_CONFIG_XCOLORMAP (glconfig));
}
else
{
GDK_GL_NOTE_FUNC_IMPL ("glXCreateGLXPixmap");
glxpixmap = glXCreateGLXPixmap (xdisplay,
xvinfo,
xpixmap);
}
if (glxpixmap == None)
return NULL;
/*
* Instantiate the GdkGLPixmapImplX11 object.
*/
glpixmap = g_object_new (GDK_TYPE_GL_PIXMAP_IMPL_X11, NULL);
impl = GDK_GL_PIXMAP_IMPL_X11 (glpixmap);
glpixmap->drawable = GDK_DRAWABLE (pixmap);
g_object_add_weak_pointer (G_OBJECT (glpixmap->drawable),
(gpointer *) &(glpixmap->drawable));
impl->glxpixmap = glxpixmap;
impl->glconfig = glconfig;
g_object_ref (G_OBJECT (impl->glconfig));
impl->is_destroyed = FALSE;
return glpixmap;
}
int main( int argc, char *argv[] )
{
GtkWidget *window = NULL;
GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *label;
GtkStatusIcon *tray_icon;
GdkPixbuf *main_icon;
GtkWidget* array_widget[2];
g_type_init ();
connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (connection == NULL) {
DEBUG ("Failed to make connection to session bus: %s", error->message);
g_error_free (error);
exit(1);
}
proxy = dbus_g_proxy_new_for_name ( connection,
"org.opensplash.bot",
"/org/opensplash/bot/language/Parser",
"org.opensplash.bot.language" );
gtk_init (&argc, &argv);
x_grab_key_init();
main_icon = gdk_pixbuf_new_from_xpm_data((const char**)splashbox_xpm);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass (GTK_WINDOW(window), "splashbox-bot-frontend-gtk", "splashbox-bot-frontend-gtk");
//gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_widget_set_size_request( window, 400, -1);
gtk_window_set_has_frame(GTK_WINDOW(window), FALSE);
gtk_window_set_resizable (GTK_WINDOW(window), FALSE);
gtk_window_set_position (GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), entry, TRUE, TRUE, 0);
// gtk_entry_set_activates_default (GTK_ENTRY(entry), TRUE);
gtk_widget_show(entry);
label = gtk_label_new("Hi Master, what can I do for you?");
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
tray_icon = gtk_status_icon_new ();
gtk_status_icon_set_from_pixbuf(tray_icon, main_icon);
gtk_status_icon_set_tooltip(tray_icon, "Use right Alt key to show/hide the input box.");
/*
array_widget[0] = window;
array_widget[1] = label;
*/
g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK (entry_activated_cb), label);
g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(tray_icon_activated_cb), window);
gtk_widget_hide (window);
g_idle_add(grab_key, (gpointer)window);
gtk_main ();
return 0;
}
/* Create a Sticky Notes applet */
StickyNotesApplet * stickynotes_applet_new(PanelApplet *panel_applet)
{
AtkObject *atk_obj;
gchar *ui_path;
/* Create Sticky Notes Applet */
StickyNotesApplet *applet = g_new(StickyNotesApplet, 1);
/* Initialize Sticky Notes Applet */
applet->w_applet = GTK_WIDGET(panel_applet);
applet->w_image = gtk_image_new();
applet->destroy_all_dialog = NULL;
applet->prelighted = FALSE;
applet->pressed = FALSE;
applet->menu_tip = NULL;
/* Expand the applet for Fitts' law complience. */
panel_applet_set_flags(panel_applet, PANEL_APPLET_EXPAND_MINOR);
/* Add the applet icon */
gtk_container_add(GTK_CONTAINER(panel_applet), applet->w_image);
applet->panel_size = panel_applet_get_size (panel_applet);
applet->panel_orient = panel_applet_get_orient (panel_applet);
stickynotes_applet_update_icon(applet);
/* Add the popup menu */
applet->action_group = gtk_action_group_new ("StickyNotes Applet Actions");
gtk_action_group_set_translation_domain (applet->action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (applet->action_group,
stickynotes_applet_menu_actions,
G_N_ELEMENTS (stickynotes_applet_menu_actions),
applet);
gtk_action_group_add_toggle_actions (applet->action_group,
stickynotes_applet_menu_toggle_actions,
G_N_ELEMENTS (stickynotes_applet_menu_toggle_actions),
applet);
ui_path = g_build_filename (STICKYNOTES_MENU_UI_DIR, "stickynotes-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file(panel_applet, ui_path, applet->action_group);
g_free (ui_path);
if (panel_applet_get_locked_down (panel_applet)) {
GtkAction *action;
action = gtk_action_group_get_action (applet->action_group, "preferences");
gtk_action_set_visible (action, FALSE);
}
/* Connect all signals for applet management */
g_signal_connect(G_OBJECT(applet->w_applet), "button-press-event",
G_CALLBACK(applet_button_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "key-press-event",
G_CALLBACK(applet_key_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "focus-in-event",
G_CALLBACK(applet_focus_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "focus-out-event",
G_CALLBACK(applet_focus_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "enter-notify-event",
G_CALLBACK(applet_cross_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "leave-notify-event",
G_CALLBACK(applet_cross_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "size-allocate",
G_CALLBACK(applet_size_allocate_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "change-orient",
G_CALLBACK(applet_change_orient_cb), applet);
g_signal_connect(G_OBJECT(applet->w_applet), "destroy",
G_CALLBACK(applet_destroy_cb), applet);
panel_applet_set_background_widget (panel_applet, applet->w_applet);
atk_obj = gtk_widget_get_accessible (applet->w_applet);
atk_object_set_name (atk_obj, _("Sticky Notes"));
/* Show the applet */
gtk_widget_show_all(GTK_WIDGET(applet->w_applet));
return applet;
}
GtkWidget *
gimp_color_dialog_new (GimpViewable *viewable,
GimpContext *context,
const gchar *title,
const gchar *stock_id,
const gchar *desc,
GtkWidget *parent,
GimpDialogFactory *dialog_factory,
const gchar *dialog_identifier,
const GimpRGB *color,
gboolean wants_updates,
gboolean show_alpha)
{
GimpColorDialog *dialog;
const gchar *role;
g_return_val_if_fail (viewable == NULL || GIMP_IS_VIEWABLE (viewable), NULL);
g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
g_return_val_if_fail (dialog_factory == NULL ||
GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
g_return_val_if_fail (dialog_factory == NULL || dialog_identifier != NULL,
NULL);
g_return_val_if_fail (color != NULL, NULL);
if (! context)
g_warning ("gimp_color_dialog_new() called with a NULL context");
role = dialog_identifier ? dialog_identifier : "gimp-color-selector";
dialog = g_object_new (GIMP_TYPE_COLOR_DIALOG,
"title", title,
"role", role,
"help-func", gimp_color_dialog_help_func,
"help-id", GIMP_HELP_COLOR_DIALOG,
"stock-id", stock_id,
"description", desc,
"parent", parent,
NULL);
if (viewable)
{
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (dialog),
viewable, context);
}
else
{
GtkWidget *parent;
parent = gtk_widget_get_parent (GIMP_VIEWABLE_DIALOG (dialog)->icon);
parent = gtk_widget_get_parent (parent);
gtk_widget_hide (parent);
}
dialog->wants_updates = wants_updates;
if (dialog_factory)
gimp_dialog_factory_add_foreign (dialog_factory, dialog_identifier,
GTK_WIDGET (dialog));
gimp_color_selection_set_show_alpha (GIMP_COLOR_SELECTION (dialog->selection),
show_alpha);
if (context)
{
g_object_set_data (G_OBJECT (context->gimp->config->color_management),
"gimp-context", context);
gimp_color_selection_set_config (GIMP_COLOR_SELECTION (dialog->selection),
context->gimp->config->color_management);
g_object_set_data (G_OBJECT (context->gimp->config->color_management),
"gimp-context", NULL);
}
gimp_color_selection_set_color (GIMP_COLOR_SELECTION (dialog->selection),
color);
gimp_color_selection_set_old_color (GIMP_COLOR_SELECTION (dialog->selection),
color);
return GTK_WIDGET (dialog);
}
bool
MediaSinkImpl::linkPad (std::shared_ptr<MediaSourceImpl> mediaSrc, GstPad *src)
{
RecMutex::Lock lock (mutex);
std::shared_ptr<MediaSourceImpl> connectedSrcLocked;
GstPad *sink;
bool ret = false;
try {
connectedSrcLocked = connectedSrc.lock();
} catch (const std::bad_weak_ptr &e) {
}
if ( (sink = gst_element_get_static_pad (getGstreamerElement(),
getPadName().c_str() ) ) == NULL) {
sink = gst_element_get_request_pad (getGstreamerElement(),
getPadName().c_str() );
}
if (gst_pad_is_linked (sink) ) {
unlink (connectedSrcLocked, sink);
}
if (std::dynamic_pointer_cast<MediaObjectImpl> (mediaSrc)->getParent() ==
getParent() ) {
GstBin *container;
GstElement *filter, *parent;
GstPad *aux_sink, *aux_src;
GST_DEBUG ("Connecting loopback, adding a capsfilter to allow connection");
parent = GST_ELEMENT (GST_OBJECT_PARENT (sink) );
if (parent == NULL) {
goto end;
}
container = GST_BIN (GST_OBJECT_PARENT (parent) );
if (container == NULL) {
goto end;
}
filter = gst_element_factory_make ("capsfilter", NULL);
aux_sink = gst_element_get_static_pad (filter, "sink");
aux_src = gst_element_get_static_pad (filter, "src");
g_signal_connect (G_OBJECT (aux_sink), "unlinked", G_CALLBACK (sink_unlinked),
filter );
g_signal_connect (G_OBJECT (aux_src), "unlinked", G_CALLBACK (src_unlinked),
filter );
gst_bin_add (container, filter);
gst_element_sync_state_with_parent (filter);
if (gst_pad_link_full (aux_src, sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
if (gst_pad_link_full (src, aux_sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
ret = true;
} else {
gst_pad_unlink (aux_src, sink);
}
}
g_object_unref (aux_sink);
g_object_unref (aux_src);
gst_debug_bin_to_dot_file_with_ts (GST_BIN (container),
GST_DEBUG_GRAPH_SHOW_ALL, "loopback");
} else {
if (gst_pad_link_full (src, sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
ret = true;
}
}
if (ret == true) {
connectedSrc = std::weak_ptr<MediaSourceImpl> (mediaSrc);
} else {
gst_element_release_request_pad (getGstreamerElement(), sink);
}
end:
g_object_unref (sink);
return ret;
}
void
mm_plugin_supports_port (MMPlugin *self,
MMDevice *device,
GUdevDevice *port,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMPortProbe *probe;
GSimpleAsyncResult *async_result;
PortProbeRunContext *ctx;
gboolean need_vendor_probing;
gboolean need_product_probing;
MMPortProbeFlag probe_run_flags;
gchar *probe_list_str;
async_result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
mm_plugin_supports_port);
/* Apply filters before launching the probing */
if (apply_pre_probing_filters (self,
device,
port,
&need_vendor_probing,
&need_product_probing)) {
/* Filtered! */
g_simple_async_result_set_op_res_gpointer (async_result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED),
NULL);
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
/* Need to launch new probing */
probe = MM_PORT_PROBE (mm_device_get_port_probe (device, port));
if (!probe) {
/* This may happen if the ports get removed from the device while
* probing is ongoing */
g_simple_async_result_set_error (async_result,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"(%s) Missing port probe for port (%s/%s)",
self->priv->name,
g_udev_device_get_subsystem (port),
g_udev_device_get_name (port));
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
/* Before launching any probing, check if the port is a net device. */
if (g_str_equal (g_udev_device_get_subsystem (port), "net")) {
mm_dbg ("(%s) [%s] probing deferred until result suggested",
self->priv->name,
g_udev_device_get_name (port));
g_simple_async_result_set_op_res_gpointer (
async_result,
GUINT_TO_POINTER (MM_PLUGIN_SUPPORTS_PORT_DEFER_UNTIL_SUGGESTED),
NULL);
g_simple_async_result_complete_in_idle (async_result);
goto out;
}
/* Build flags depending on what probing needed */
if (!g_str_has_prefix (g_udev_device_get_name (port), "cdc-wdm")) {
/* Serial ports... */
probe_run_flags = MM_PORT_PROBE_NONE;
if (self->priv->at)
probe_run_flags |= MM_PORT_PROBE_AT;
else if (self->priv->single_at)
probe_run_flags |= MM_PORT_PROBE_AT;
if (need_vendor_probing)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_VENDOR);
if (need_product_probing)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_PRODUCT);
if (self->priv->qcdm)
probe_run_flags |= MM_PORT_PROBE_QCDM;
if (self->priv->icera_probe || self->priv->allowed_icera || self->priv->forbidden_icera)
probe_run_flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_ICERA);
} else {
/* cdc-wdm ports... */
probe_run_flags = MM_PORT_PROBE_QMI;
}
g_assert (probe_run_flags != MM_PORT_PROBE_NONE);
/* If a modem is already available and the plugin says that only one AT port is
* expected, check if we alredy got the single AT port. And if so, we know this
* port being probed won't be AT. */
if (self->priv->single_at &&
mm_port_probe_list_has_at_port (mm_device_peek_port_probe_list (device)) &&
!mm_port_probe_is_at (probe)) {
mm_dbg ("(%s) [%s] not setting up AT probing tasks: "
"modem already has the expected single AT port",
self->priv->name,
g_udev_device_get_name (port));
/* Assuming it won't be an AT port. We still run the probe anyway, in
* case we need to check for other port types (e.g. QCDM) */
mm_port_probe_set_result_at (probe, FALSE);
}
/* Setup async call context */
ctx = g_new (PortProbeRunContext, 1);
ctx->self = g_object_ref (self);
ctx->device = g_object_ref (device);
ctx->result = g_object_ref (async_result);
ctx->flags = probe_run_flags;
/* Launch the probe */
probe_list_str = mm_port_probe_flag_build_string_from_mask (ctx->flags);
mm_dbg ("(%s) [%s] probe required: '%s'",
self->priv->name,
g_udev_device_get_name (port),
probe_list_str);
g_free (probe_list_str);
mm_port_probe_run (probe,
ctx->flags,
self->priv->send_delay,
self->priv->remove_echo,
self->priv->custom_at_probe,
self->priv->custom_init,
(GAsyncReadyCallback)port_probe_run_ready,
ctx);
out:
g_object_unref (async_result);
}
static void
stm_new_transfer_window_ui (StmNewTransferWindow *self)
{
StmNewTransferWindowPrivate *priv = self->priv;
gtk_window_set_title (GTK_WINDOW (self), _("Add transfer"));
/* Buttons */
GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
g_signal_connect (G_OBJECT (close), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
/* Table */
GtkWidget *table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
GtkWidget *label;
/* Left column */
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>URL:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Save to:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK, 0, 0);
/* Right column */
GtkWidget *entry;
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->source = GTK_ENTRY (entry);
entry = gtk_file_chooser_button_new (_("Select destination"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->destination = GTK_FILE_CHOOSER_BUTTON (entry);
entry = gtk_check_button_new_with_label (_("Automatically start transfer"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), TRUE);
gtk_table_attach (GTK_TABLE (table), entry,
0, 2, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->auto_start = GTK_CHECK_BUTTON (entry);
gtk_widget_show_all (table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table,
FALSE, FALSE, 0);
/* Buttons */
GtkWidget *ok = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (ok), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
}
static void
finalize_miner (TrackerMiner *miner)
{
g_object_unref (G_OBJECT (miner));
}
