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

/** * 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 =//.........这里部分代码省略.........

gbooleanplug_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 gbooleangst_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);//.........这里部分代码省略.........

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++,//.........这里部分代码省略.........

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 (&GTK_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 (&GTK_CHECK_BUTTON (				        gtk_builder_get_object (stickynotes->builder,					"sys_font_check"))->toggle_button);	stickynotes->w_prefs_sticky = GTK_WIDGET (&GTK_CHECK_BUTTON (				        gtk_builder_get_object (stickynotes->builder,					"sticky_check"))->toggle_button);	stickynotes->w_prefs_force = GTK_WIDGET (&GTK_CHECK_BUTTON (				        gtk_builder_get_object (stickynotes->builder,					"force_default_check"))->toggle_button);	stickynotes->w_prefs_desktop = GTK_WIDGET (&GTK_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 (//.........这里部分代码省略.........

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++;//.........这里部分代码省略.........

//.........这里部分代码省略.........		} 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", //.........这里部分代码省略.........

static voidset_state (GtkTextBuffer *buffer,           guint32 state){	g_object_set_data (G_OBJECT (buffer), E_BUFFER_TAGGER_DATA_STATE, GINT_TO_POINTER (state));}

static voidgimp_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 voidgegl_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  voidnautilus_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);        }//.........这里部分代码省略.........

/** * 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",//.........这里部分代码省略.........

//.........这里部分代码省略.........    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");//.........这里部分代码省略.........

static voidgom_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);//.........这里部分代码省略.........

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));//.........这里部分代码省略.........

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

boolMediaSinkImpl::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;}

voidmm_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);//.........这里部分代码省略.........

static voidstm_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 voidfinalize_miner (TrackerMiner *miner){	g_object_unref (G_OBJECT (miner));}