static gboolean exo_tree_view_button_release_event (GtkWidget *widget, GdkEventButton *event) { GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkTreePath *path; ExoTreeView *tree_view = EXO_TREE_VIEW (widget); /* verify that the release event is for the internal tree view window */ if (G_LIKELY (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (tree_view)))) { /* check if we're in single-click mode and the button-release-event should emit a "row-activate" */ if (G_UNLIKELY (tree_view->priv->single_click && tree_view->priv->button_release_activates)) { /* reset the "release-activates" flag */ tree_view->priv->button_release_activates = FALSE; /* determine the path to the row that should be activated */ if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &column, NULL, NULL)) { /* emit row-activated for the determined row */ if( ! tree_view->priv->activable_column || tree_view->priv->activable_column == column ) gtk_tree_view_row_activated (GTK_TREE_VIEW (tree_view), path, column); /* cleanup */ gtk_tree_path_free (path); } } else if ((event->state & gtk_accelerator_get_default_mod_mask ()) == 0 && !tree_view->priv->button_release_unblocks_dnd) { /* determine the path on which the button was released and select only this row, this way * the user is still able to alter the selection easily if all rows are selected. */ if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &column, NULL, NULL)) { /* check if the path is selected */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); if (gtk_tree_selection_path_is_selected (selection, path)) { /* unselect all rows */ gtk_tree_selection_unselect_all (selection); /* select the row and place the cursor on it */ gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), path, column, FALSE); } /* cleanup */ gtk_tree_path_free (path); } } } /* check if we need to re-enable drag and drop */ if (G_LIKELY (tree_view->priv->button_release_unblocks_dnd)) { gpointer drag_data = g_object_get_data (G_OBJECT (tree_view), I_("gtk-site-data")); if (G_LIKELY (drag_data != NULL)) { g_signal_handlers_unblock_matched (G_OBJECT (tree_view), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, drag_data); } tree_view->priv->button_release_unblocks_dnd = FALSE; } /* check if we need to re-enable rubberbanding */ if (G_UNLIKELY (tree_view->priv->button_release_enables_rubber_banding)) { gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (tree_view), TRUE); tree_view->priv->button_release_enables_rubber_banding = FALSE; } /* call the parent's button release handler */ return (*GTK_WIDGET_CLASS (exo_tree_view_parent_class)->button_release_event) (widget, event); }
{ /* * The Tx interrupt is always requested if the number of data in the * transmit FIFO is smaller than the trigger level. */ if (s->reg[I_(UFCON)] & UFCON_FIFO_ENABLE) { uint32_t count = (s->reg[I_(UFSTAT)] & UFSTAT_Tx_FIFO_COUNT) >> UFSTAT_Tx_FIFO_COUNT_SHIFT; if (count <= exynos4210_uart_Tx_FIFO_trigger_level(s)) { s->reg[I_(UINTSP)] |= UINTSP_TXD; } } s->reg[I_(UINTP)] = s->reg[I_(UINTSP)] & ~s->reg[I_(UINTM)]; if (s->reg[I_(UINTP)]) { qemu_irq_raise(s->irq); #if DEBUG_IRQ fprintf(stderr, "UART%d: IRQ has been raised: %08x\n", s->channel, s->reg[I_(UINTP)]); #endif } else { qemu_irq_lower(s->irq); } } static void exynos4210_uart_update_parameters(Exynos4210UartState *s)
static guint tree_selection_signals [LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE (GtkTreeSelection, gtk_tree_selection, G_TYPE_OBJECT) static void gtk_tree_selection_class_init (GtkTreeSelectionClass *class) { GObjectClass *object_class; object_class = (GObjectClass*) class; object_class->finalize = gtk_tree_selection_finalize; class->changed = NULL; tree_selection_signals[CHANGED] = g_signal_new (I_("changed"), G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkTreeSelectionClass, changed), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); } static void gtk_tree_selection_init (GtkTreeSelection *selection) { selection->type = GTK_SELECTION_SINGLE; } static void
static void gtk_tool_item_class_init (GtkToolItemClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; object_class = (GObjectClass *)klass; widget_class = (GtkWidgetClass *)klass; object_class->set_property = gtk_tool_item_set_property; object_class->get_property = gtk_tool_item_get_property; object_class->finalize = gtk_tool_item_finalize; object_class->dispose = gtk_tool_item_dispose; object_class->notify = gtk_tool_item_property_notify; widget_class->realize = gtk_tool_item_realize; widget_class->unrealize = gtk_tool_item_unrealize; widget_class->map = gtk_tool_item_map; widget_class->unmap = gtk_tool_item_unmap; widget_class->size_request = gtk_tool_item_size_request; widget_class->size_allocate = gtk_tool_item_size_allocate; widget_class->parent_set = gtk_tool_item_parent_set; klass->create_menu_proxy = _gtk_tool_item_create_menu_proxy; klass->set_tooltip = gtk_tool_item_real_set_tooltip; g_object_class_install_property (object_class, PROP_VISIBLE_HORIZONTAL, g_param_spec_boolean ("visible-horizontal", P_("Visible when horizontal"), P_("Whether the toolbar item is visible when the toolbar is in a horizontal orientation."), TRUE, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_VISIBLE_VERTICAL, g_param_spec_boolean ("visible-vertical", P_("Visible when vertical"), P_("Whether the toolbar item is visible when the toolbar is in a vertical orientation."), TRUE, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_IS_IMPORTANT, g_param_spec_boolean ("is-important", P_("Is important"), P_("Whether the toolbar item is considered important. When TRUE, toolbar buttons show text in GTK_TOOLBAR_BOTH_HORIZ mode"), FALSE, GTK_PARAM_READWRITE)); g_object_class_override_property (object_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action"); g_object_class_override_property (object_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance"); /** * GtkToolItem::create-menu-proxy: * @tool_item: the object the signal was emitted on * * This signal is emitted when the toolbar needs information from @tool_item * about whether the item should appear in the toolbar overflow menu. In * response the tool item should either * <itemizedlist> * <listitem>call gtk_tool_item_set_proxy_menu_item() with a %NULL * pointer and return %TRUE to indicate that the item should not appear * in the overflow menu * </listitem> * <listitem> call gtk_tool_item_set_proxy_menu_item() with a new menu * item and return %TRUE, or * </listitem> * <listitem> return %FALSE to indicate that the signal was not * handled by the item. This means that * the item will not appear in the overflow menu unless a later handler * installs a menu item. * </listitem> * </itemizedlist> * * The toolbar may cache the result of this signal. When the tool item changes * how it will respond to this signal it must call gtk_tool_item_rebuild_menu() * to invalidate the cache and ensure that the toolbar rebuilds its overflow * menu. * * Return value: %TRUE if the signal was handled, %FALSE if not **/ toolitem_signals[CREATE_MENU_PROXY] = g_signal_new (I_("create-menu-proxy"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkToolItemClass, create_menu_proxy), _gtk_boolean_handled_accumulator, NULL, _gtk_marshal_BOOLEAN__VOID, G_TYPE_BOOLEAN, 0); /** * GtkToolItem::toolbar-reconfigured: * @tool_item: the object the signal was emitted on * * This signal is emitted when some property of the toolbar that the * item is a child of changes. For custom subclasses of #GtkToolItem, * the default handler of this signal use the functions * <itemizedlist> * <listitem>gtk_tool_shell_get_orientation()</listitem> * <listitem>gtk_tool_shell_get_style()</listitem> * <listitem>gtk_tool_shell_get_icon_size()</listitem> * <listitem>gtk_tool_shell_get_relief_style()</listitem> * </itemizedlist> * to find out what the toolbar should look like and change * themselves accordingly. **/ toolitem_signals[TOOLBAR_RECONFIGURED] = g_signal_new (I_("toolbar-reconfigured"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkToolItemClass, toolbar_reconfigured), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GtkToolItem::set-tooltip: * @tool_item: the object the signal was emitted on * @tooltips: the #GtkTooltips * @tip_text: the tooltip text * @tip_private: the tooltip private text * * This signal is emitted when the toolitem's tooltip changes. * Application developers can use gtk_tool_item_set_tooltip() to * set the item's tooltip. * * Return value: %TRUE if the signal was handled, %FALSE if not * * Deprecated: 2.12: With the new tooltip API, there is no * need to use this signal anymore. **/ toolitem_signals[SET_TOOLTIP] = g_signal_new (I_("set-tooltip"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkToolItemClass, set_tooltip), _gtk_boolean_handled_accumulator, NULL, _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING, G_TYPE_BOOLEAN, 3, GTK_TYPE_TOOLTIPS, G_TYPE_STRING, G_TYPE_STRING); g_type_class_add_private (object_class, sizeof (GtkToolItemPrivate)); }
static void g_tls_connection_class_init (GTlsConnectionClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->get_property = g_tls_connection_get_property; gobject_class->set_property = g_tls_connection_set_property; /** * GTlsConnection:base-io-stream: * * The #GIOStream that the connection wraps * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_BASE_IO_STREAM, g_param_spec_object ("base-io-stream", P_("Base IOStream"), P_("The GIOStream that the connection wraps"), G_TYPE_IO_STREAM, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:use-system-certdb: * * Whether or not the system certificate database will be used to * verify peer certificates. See * g_tls_connection_set_use_system_certdb(). * * Deprecated: 2.30: Use GTlsConnection:database instead */ g_object_class_install_property (gobject_class, PROP_USE_SYSTEM_CERTDB, g_param_spec_boolean ("use-system-certdb", P_("Use system certificate database"), P_("Whether to verify peer certificates against the system certificate database"), TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:database: * * The certificate database to use when verifying this TLS connection. * If no cerificate database is set, then the default database will be * used. See g_tls_backend_get_default_database(). * * Since: 2.30 */ g_object_class_install_property (gobject_class, PROP_DATABASE, g_param_spec_object ("database", P_("Database"), P_("Certificate database to use for looking up or verifying certificates"), G_TYPE_TLS_DATABASE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:interaction: * * A #GTlsInteraction object to be used when the connection or certificate * database need to interact with the user. This will be used to prompt the * user for passwords where necessary. * * Since: 2.30 */ g_object_class_install_property (gobject_class, PROP_INTERACTION, g_param_spec_object ("interaction", P_("Interaction"), P_("Optional object for user interaction"), G_TYPE_TLS_INTERACTION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:require-close-notify: * * Whether or not proper TLS close notification is required. * See g_tls_connection_set_require_close_notify(). * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_REQUIRE_CLOSE_NOTIFY, g_param_spec_boolean ("require-close-notify", P_("Require close notify"), P_("Whether to require proper TLS close notification"), TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:rehandshake-mode: * * The rehandshaking mode. See * g_tls_connection_set_rehandshake_mode(). * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_REHANDSHAKE_MODE, g_param_spec_enum ("rehandshake-mode", P_("Rehandshake mode"), P_("When to allow rehandshaking"), G_TYPE_TLS_REHANDSHAKE_MODE, G_TLS_REHANDSHAKE_SAFELY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:certificate: * * The connection's certificate; see * g_tls_connection_set_certificate(). * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_CERTIFICATE, g_param_spec_object ("certificate", P_("Certificate"), P_("The connection's certificate"), G_TYPE_TLS_CERTIFICATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:peer-certificate: * * The connection's peer's certificate, after the TLS handshake has * completed and the certificate has been accepted. Note in * particular that this is not yet set during the emission of * #GTlsConnection::accept-certificate. * * (You can watch for a #GObject::notify signal on this property to * detect when a handshake has occurred.) * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_PEER_CERTIFICATE, g_param_spec_object ("peer-certificate", P_("Peer Certificate"), P_("The connection's peer's certificate"), G_TYPE_TLS_CERTIFICATE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection:peer-certificate-errors: * * The errors noticed-and-ignored while verifying * #GTlsConnection:peer-certificate. Normally this should be 0, but * it may not be if #GTlsClientConnection:validation-flags is not * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if * #GTlsConnection::accept-certificate overrode the default * behavior. * * Since: 2.28 */ g_object_class_install_property (gobject_class, PROP_PEER_CERTIFICATE_ERRORS, g_param_spec_flags ("peer-certificate-errors", P_("Peer Certificate Errors"), P_("Errors found with the peer's certificate"), G_TYPE_TLS_CERTIFICATE_FLAGS, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GTlsConnection::accept-certificate: * @conn: a #GTlsConnection * @peer_cert: the peer's #GTlsCertificate * @errors: the problems with @peer_cert. * * Emitted during the TLS handshake after the peer certificate has * been received. You can examine @peer_cert's certification path by * calling g_tls_certificate_get_issuer() on it. * * For a client-side connection, @peer_cert is the server's * certificate, and the signal will only be emitted if the * certificate was not acceptable according to @conn's * #GTlsClientConnection:validation_flags. If you would like the * certificate to be accepted despite @errors, return %TRUE from the * signal handler. Otherwise, if no handler accepts the certificate, * the handshake will fail with %G_TLS_ERROR_BAD_CERTIFICATE. * * For a server-side connection, @peer_cert is the certificate * presented by the client, if this was requested via the server's * #GTlsServerConnection:authentication_mode. On the server side, * the signal is always emitted when the client presents a * certificate, and the certificate will only be accepted if a * handler returns %TRUE. * * Note that if this signal is emitted as part of asynchronous I/O * in the main thread, then you should not attempt to interact with * the user before returning from the signal handler. If you want to * let the user decide whether or not to accept the certificate, you * would have to return %FALSE from the signal handler on the first * attempt, and then after the connection attempt returns a * %G_TLS_ERROR_HANDSHAKE, you can interact with the user, and if * the user decides to accept the certificate, remember that fact, * create a new connection, and return %TRUE from the signal handler * the next time. * * If you are doing I/O in another thread, you do not * need to worry about this, and can simply block in the signal * handler until the UI thread returns an answer. * * Return value: %TRUE to accept @peer_cert (which will also * immediately end the signal emission). %FALSE to allow the signal * emission to continue, which will cause the handshake to fail if * no one else overrides it. * * Since: 2.28 */ signals[ACCEPT_CERTIFICATE] = g_signal_new (I_("accept-certificate"), G_TYPE_TLS_CONNECTION, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTlsConnectionClass, accept_certificate), g_signal_accumulator_true_handled, NULL, NULL, G_TYPE_BOOLEAN, 2, G_TYPE_TLS_CERTIFICATE, G_TYPE_TLS_CERTIFICATE_FLAGS); }
static void g_mount_operation_class_init (GMountOperationClass *klass) { GObjectClass *object_class; g_type_class_add_private (klass, sizeof (GMountOperationPrivate)); object_class = G_OBJECT_CLASS (klass); object_class->finalize = g_mount_operation_finalize; object_class->get_property = g_mount_operation_get_property; object_class->set_property = g_mount_operation_set_property; klass->ask_password = ask_password; klass->ask_question = ask_question; klass->show_processes = show_processes; klass->show_unmount_progress = show_unmount_progress; /** * GMountOperation::ask-password: * @op: a #GMountOperation requesting a password. * @message: string containing a message to display to the user. * @default_user: string containing the default user name. * @default_domain: string containing the default domain. * @flags: a set of #GAskPasswordFlags. * * Emitted when a mount operation asks the user for a password. * * If the message contains a line break, the first line should be * presented as a heading. For example, it may be used as the * primary text in a #GtkMessageDialog. */ signals[ASK_PASSWORD] = g_signal_new (I_("ask-password"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, ask_password), NULL, NULL, NULL, G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ASK_PASSWORD_FLAGS); /** * GMountOperation::ask-question: * @op: a #GMountOperation asking a question. * @message: string containing a message to display to the user. * @choices: an array of strings for each possible choice. * * Emitted when asking the user a question and gives a list of * choices for the user to choose from. * * If the message contains a line break, the first line should be * presented as a heading. For example, it may be used as the * primary text in a #GtkMessageDialog. */ signals[ASK_QUESTION] = g_signal_new (I_("ask-question"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, ask_question), NULL, NULL, NULL, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRV); /** * GMountOperation::reply: * @op: a #GMountOperation. * @result: a #GMountOperationResult indicating how the request was handled * * Emitted when the user has replied to the mount operation. */ signals[REPLY] = g_signal_new (I_("reply"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, reply), NULL, NULL, g_cclosure_marshal_VOID__ENUM, G_TYPE_NONE, 1, G_TYPE_MOUNT_OPERATION_RESULT); /** * GMountOperation::aborted: * * Emitted by the backend when e.g. a device becomes unavailable * while a mount operation is in progress. * * Implementations of GMountOperation should handle this signal * by dismissing open password dialogs. * * Since: 2.20 */ signals[ABORTED] = g_signal_new (I_("aborted"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, aborted), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GMountOperation::show-processes: * @op: a #GMountOperation. * @message: string containing a message to display to the user. * @processes: (element-type GPid): an array of #GPid for processes * blocking the operation. * @choices: an array of strings for each possible choice. * * Emitted when one or more processes are blocking an operation * e.g. unmounting/ejecting a #GMount or stopping a #GDrive. * * Note that this signal may be emitted several times to update the * list of blocking processes as processes close files. The * application should only respond with g_mount_operation_reply() to * the latest signal (setting #GMountOperation:choice to the choice * the user made). * * If the message contains a line break, the first line should be * presented as a heading. For example, it may be used as the * primary text in a #GtkMessageDialog. * * Since: 2.22 */ signals[SHOW_PROCESSES] = g_signal_new (I_("show-processes"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, show_processes), NULL, NULL, NULL, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_ARRAY, G_TYPE_STRV); /** * GMountOperation::show-unmount-progress: * @op: a #GMountOperation: * @message: string containing a mesage to display to the user * @time_left: the estimated time left before the operation completes, or -1 * @bytes_left: the amount of bytes to be written before the operation * completes (or -1 if such amount is not known), or zero if the operation * is completed * * Emitted when an unmount operation has been busy for more than some time * (typically 1.5 seconds). * * When unmounting or ejecting a volume, the kernel might need to flush * pending data in its buffers to the volume stable storage, and this operation * can take a considerable amount of time. This signal may be emitted several * times as long as the unmount operation is outstanding, and then one * last time when the operation is completed, with @bytes_left set to zero. * * Implementations of GMountOperation should handle this signal by * showing an UI notification, and then dismiss it, or show another notification * of completion, when @bytes_left reaches zero. * * If the message contains a line break, the first line should be * presented as a heading. For example, it may be used as the * primary text in a #GtkMessageDialog. * * Since: 2.34 */ signals[SHOW_UNMOUNT_PROGRESS] = g_signal_new (I_("show-unmount-progress"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GMountOperationClass, show_unmount_progress), NULL, NULL, NULL, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64); /** * GMountOperation:username: * * The user name that is used for authentication when carrying out * the mount operation. */ g_object_class_install_property (object_class, PROP_USERNAME, g_param_spec_string ("username", P_("Username"), P_("The user name"), NULL, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); /** * GMountOperation:password: * * The password that is used for authentication when carrying out * the mount operation. */ g_object_class_install_property (object_class, PROP_PASSWORD, g_param_spec_string ("password", P_("Password"), P_("The password"), NULL, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); /** * GMountOperation:anonymous: * * Whether to use an anonymous user when authenticating. */ g_object_class_install_property (object_class, PROP_ANONYMOUS, g_param_spec_boolean ("anonymous", P_("Anonymous"), P_("Whether to use an anonymous user"), FALSE, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); /** * GMountOperation:domain: * * The domain to use for the mount operation. */ g_object_class_install_property (object_class, PROP_DOMAIN, g_param_spec_string ("domain", P_("Domain"), P_("The domain of the mount operation"), NULL, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); /** * GMountOperation:password-save: * * Determines if and how the password information should be saved. */ g_object_class_install_property (object_class, PROP_PASSWORD_SAVE, g_param_spec_enum ("password-save", P_("Password save"), P_("How passwords should be saved"), G_TYPE_PASSWORD_SAVE, G_PASSWORD_SAVE_NEVER, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); /** * GMountOperation:choice: * * The index of the user's choice when a question is asked during the * mount operation. See the #GMountOperation::ask-question signal. */ g_object_class_install_property (object_class, PROP_CHOICE, g_param_spec_int ("choice", P_("Choice"), P_("The users choice"), 0, G_MAXINT, 0, G_PARAM_READWRITE| G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB)); }
static int wcf_handle_file_snapshot_delete(void) { tstring *msg = NULL; uint32 code = 0; int err = 0; tstring *file_snapshot_path = NULL; const tstring *file = NULL; bn_binding_array *bindings = NULL; tstring *dump_path = NULL, *dump_name = NULL, *dump_dir = NULL; tbool simple = false, archived = false; err = web_get_request_param_str(g_web_data, "f_file", ps_post_data, &file); bail_error_null(err, file); /* * First make sure the filename doesn't do anything crazy like * trying to reference another directory. */ err = lf_path_component_is_simple(ts_str(file), &simple); bail_error(err); /* XXX/EMT: would be better to return friendly error page */ bail_require_msg(simple, I_("Filename \"%s\" required for download " "was invalid"), ts_str(file)); /* Now generate the absolute file path */ err = lf_path_from_dir_file(snapshot_download_prefix, ts_str(file), &file_snapshot_path); err = web_get_msg_result(g_web_data, &code, NULL); bail_error(err); if (code) { goto bail; } if (file_snapshot_path) { err = lf_path_last(ts_str(file_snapshot_path), &dump_name); bail_error_null(err, dump_name); err = lf_path_parent(ts_str(file_snapshot_path), &dump_dir); bail_error(err); lc_log_basic(LOG_NOTICE, _("Deleting snapshot File:%s\n"), ts_str(dump_name)); err = mdc_send_action_with_bindings_str_va (web_mcc, NULL, NULL, "/file/delete", 2, "local_dir", bt_string, ts_str(dump_dir), "local_filename", bt_string, ts_str(dump_name)); if (err ) { err = ts_new_sprintf(&msg, _("Could not delete snapshot %s" ), ts_str(dump_name)); code = 1; bail_error(err); } } err = web_set_msg_result(g_web_data, code, msg); bail_error(err); bail: bn_binding_array_free(&bindings); ts_free(&dump_path); ts_free(&dump_name); ts_free(&dump_dir); ts_free(&msg); if (err) { return(war_error); } else { return(war_ok); } }
class->group_changed = NULL; /** * GtkRadioButton::group-changed: * @style: the object which received the signal * * Emitted when the group of radio buttons that a radio button belongs * to changes. This is emitted when a radio button switches from * being alone to being part of a group of 2 or more buttons, or * vice-versa, and when a button is moved from one group of 2 or * more buttons to a different one, but not when the composition * of the group that a button belongs to changes. * * Since: 2.4 */ group_changed_signal = g_signal_new (I_("group-changed"), G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkRadioButtonClass, group_changed), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); } static void gtk_radio_button_init (GtkRadioButton *radio_button) { gtk_widget_set_has_window (GTK_WIDGET (radio_button), FALSE); gtk_widget_set_receives_default (GTK_WIDGET (radio_button), FALSE); GTK_TOGGLE_BUTTON (radio_button)->active = TRUE;
static int wlog_get_publishlog_lines(Tcl_Interp *interpreter, int fd, uint32 start, uint32 end, Tcl_Obj **ret_list) { Tcl_Obj *list = NULL; Tcl_Obj *line_obj = NULL; tstring *line_buf = NULL; char buf[wlog_log_buf_size]; uint32 cur_line = 0; uint32 seg_start = 0; uint32 i = 0; int count = 0; int err = 0; char *cp; bail_null(ret_list); list = Tcl_NewListObj(0, NULL); bail_null(list); do { if (cur_line + 1 >= end) { break; } errno = 0; count = read(fd, buf, wlog_log_buf_size); if (count == -1 && errno == EINTR) { continue; } bail_require_errno(count >= 0, I_("Reading log file '%s'"), file_publishlog_path); while (( cp = memchr(buf, '\0' , count )) != NULL ) *cp = ' '; while (( cp = memchr(buf, '<' , count )) != NULL ) *cp = '['; while (( cp = memchr(buf, '>' , count )) != NULL ) *cp = ']'; /* look for a newline inside the buffer */ seg_start = 0; for (i = 0; i < (uint32)count; ++i) { if (buf[i] == '\n') { if (cur_line + 1 >= start && cur_line + 1 < end) { if (!line_buf) { err = ts_new(&line_buf); bail_error(err); } err = ts_append_str_frag(line_buf, buf, seg_start, i - seg_start); bail_error(err); line_obj = Tcl_NewStringObj(ts_str(line_buf), ts_length(line_buf)); bail_null(line_obj); err = Tcl_ListObjAppendElement(interpreter, list, line_obj); bail_require(err == TCL_OK); err = 0; ts_free(&line_buf); } seg_start = i + 1; ++cur_line; } } if (seg_start < (uint32)count) { if (cur_line + 1 >= start && cur_line + 1 < end) { if (!line_buf) { err = ts_new(&line_buf); bail_error(err); } err = ts_append_str_frag(line_buf, buf, seg_start, (uint32)count - seg_start); bail_error(err); } } } while (count > 0); *ret_list = list; list = NULL; bail: if (list) { Tcl_DecrRefCount(list); } ts_free(&line_buf); return(err); }
static void clutter_text_buffer_class_init (ClutterTextBufferClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->finalize = clutter_text_buffer_finalize; gobject_class->set_property = clutter_text_buffer_set_property; gobject_class->get_property = clutter_text_buffer_get_property; klass->get_text = clutter_text_buffer_normal_get_text; klass->get_length = clutter_text_buffer_normal_get_length; klass->insert_text = clutter_text_buffer_normal_insert_text; klass->delete_text = clutter_text_buffer_normal_delete_text; klass->inserted_text = clutter_text_buffer_real_inserted_text; klass->deleted_text = clutter_text_buffer_real_deleted_text; g_type_class_add_private (gobject_class, sizeof (ClutterTextBufferPrivate)); /** * ClutterTextBuffer:text: * * The contents of the buffer. * * */ obj_props[PROP_TEXT] = g_param_spec_string ("text", P_("Text"), P_("The contents of the buffer"), "", G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); /** * ClutterTextBuffer:length: * * The length (in characters) of the text in buffer. * * */ obj_props[PROP_LENGTH] = g_param_spec_uint ("length", P_("Text length"), P_("Length of the text currently in the buffer"), 0, CLUTTER_TEXT_BUFFER_MAX_SIZE, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); /** * ClutterTextBuffer:max-length: * * The maximum length (in characters) of the text in the buffer. * * */ obj_props[PROP_MAX_LENGTH] = g_param_spec_int ("max-length", P_("Maximum length"), P_("Maximum number of characters for this entry. Zero if no maximum"), 0, CLUTTER_TEXT_BUFFER_MAX_SIZE, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (gobject_class, PROP_LAST, obj_props); /** * ClutterTextBuffer::inserted-text: * @buffer: a #ClutterTextBuffer * @position: the position the text was inserted at. * @chars: The text that was inserted. * @n_chars: The number of characters that were inserted. * * This signal is emitted after text is inserted into the buffer. * * */ signals[INSERTED_TEXT] = g_signal_new (I_("inserted-text"), CLUTTER_TYPE_TEXT_BUFFER, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterTextBufferClass, inserted_text), NULL, NULL, _clutter_marshal_VOID__UINT_STRING_UINT, G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT); /** * ClutterTextBuffer::deleted-text: * @buffer: a #ClutterTextBuffer * @position: the position the text was deleted at. * @n_chars: The number of characters that were deleted. * * This signal is emitted after text is deleted from the buffer. * * */ signals[DELETED_TEXT] = g_signal_new (I_("deleted-text"), CLUTTER_TYPE_TEXT_BUFFER, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterTextBufferClass, deleted_text), NULL, NULL, _clutter_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT); }
static void gtk_gesture_multi_press_class_init (GtkGestureMultiPressClass *klass) { GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkGestureClass *gesture_class = GTK_GESTURE_CLASS (klass); object_class->finalize = gtk_gesture_multi_press_finalize; gesture_class->check = gtk_gesture_multi_press_check; gesture_class->begin = gtk_gesture_multi_press_begin; gesture_class->update = gtk_gesture_multi_press_update; gesture_class->end = gtk_gesture_multi_press_end; gesture_class->cancel = gtk_gesture_multi_press_cancel; controller_class->reset = gtk_gesture_multi_press_reset; /** * GtkGestureMultiPress::pressed: * @gesture: the object which received the signal * @n_press: how many touch/button presses happened with this one * @x: The X coordinate, in widget allocation coordinates * @y: The Y coordinate, in widget allocation coordinates * * This signal is emitted whenever a button or touch press happens. * * Since: 3.14 */ signals[PRESSED] = g_signal_new (I_("pressed"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkGestureMultiPressClass, pressed), NULL, NULL, NULL, G_TYPE_NONE, 3, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE); /** * GtkGestureMultiPress::released: * @gesture: the object which received the signal * @n_press: number of press that is paired with this release * @x: The X coordinate, in widget allocation coordinates * @y: The Y coordinate, in widget allocation coordinates * * This signal is emitted when a button or touch is released. @n_press * will report the number of press that is paired to this event, note * that #GtkGestureMultiPress::stopped may have been emitted between the * press and its release, @n_press will only start over at the next press. * * Since: 3.14 */ signals[RELEASED] = g_signal_new (I_("released"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkGestureMultiPressClass, released), NULL, NULL, NULL, G_TYPE_NONE, 3, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE); /** * GtkGestureMultiPress::stopped: * @gesture: the object which received the signal * * This signal is emitted whenever any time/distance threshold has * been exceeded. * * Since: 3.14 */ signals[STOPPED] = g_signal_new (I_("stopped"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkGestureMultiPressClass, stopped), NULL, NULL, NULL, G_TYPE_NONE, 0); }
static void gtk_tool_button_class_init (GtkToolButtonClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; GtkToolItemClass *tool_item_class; parent_class = g_type_class_peek_parent (klass); object_class = (GObjectClass *)klass; widget_class = (GtkWidgetClass *)klass; tool_item_class = (GtkToolItemClass *)klass; object_class->set_property = gtk_tool_button_set_property; object_class->get_property = gtk_tool_button_get_property; object_class->notify = gtk_tool_button_property_notify; object_class->finalize = gtk_tool_button_finalize; widget_class->style_set = gtk_tool_button_style_set; tool_item_class->create_menu_proxy = gtk_tool_button_create_menu_proxy; tool_item_class->toolbar_reconfigured = gtk_tool_button_toolbar_reconfigured; klass->button_type = GTK_TYPE_BUTTON; /* Properties are interpreted like this: * * - if the tool button has an icon_widget, then that widget * will be used as the icon. Otherwise, if the tool button * has a stock id, the corresponding stock icon will be * used. Otherwise, if the tool button has an icon name, * the corresponding icon from the theme will be used. * Otherwise, the tool button will not have an icon. * * - if the tool button has a label_widget then that widget * will be used as the label. Otherwise, if the tool button * has a label text, that text will be used as label. Otherwise, * if the toolbutton has a stock id, the corresponding text * will be used as label. Otherwise, if the tool button has * an icon name, the corresponding icon name from the theme will * be used. Otherwise, the toolbutton will have an empty label. * * - The use_underline property only has an effect when the label * on the toolbutton comes from the label property (ie. not from * label_widget or from stock_id). * * In that case, if use_underline is set, * * - underscores are removed from the label text before * the label is shown on the toolbutton unless the * underscore is followed by another underscore * * - an underscore indicates that the next character when * used in the overflow menu should be used as a * mnemonic. * * In short: use_underline = TRUE means that the label text has * the form "_Open" and the toolbar should take appropriate * action. */ g_object_class_install_property (object_class, PROP_LABEL, g_param_spec_string ("label", P_("Label"), P_("Text to show in the item."), NULL, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_USE_UNDERLINE, g_param_spec_boolean ("use-underline", P_("Use underline"), P_("If set, an underline in the label property indicates that the next character should be used for the mnemonic accelerator key in the overflow menu"), FALSE, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_LABEL_WIDGET, g_param_spec_object ("label-widget", P_("Label widget"), P_("Widget to use as the item label"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_STOCK_ID, g_param_spec_string ("stock-id", P_("Stock Id"), P_("The stock icon displayed on the item"), NULL, GTK_PARAM_READWRITE)); /** * GtkToolButton:icon-name: * * The name of the themed icon displayed on the item. * This property only has an effect if not overridden by "label", * "icon_widget" or "stock_id" properties. * * Since: 2.8 */ g_object_class_install_property (object_class, PROP_ICON_NAME, g_param_spec_string ("icon-name", P_("Icon name"), P_("The name of the themed icon displayed on the item"), NULL, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_ICON_WIDGET, g_param_spec_object ("icon-widget", P_("Icon widget"), P_("Icon widget to display in the item"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); /** * GtkButton:icon-spacing: * * Spacing in pixels between the icon and label. * * Since: 2.10 */ gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("icon-spacing", P_("Icon spacing"), P_("Spacing in pixels between the icon and label"), 0, G_MAXINT, 3, GTK_PARAM_READWRITE)); /** * GtkToolButton::clicked: * @toolbutton: the object that emitted the signal * * This signal is emitted when the tool button is clicked with the mouse * or activated with the keyboard. **/ toolbutton_signals[CLICKED] = g_signal_new (I_("clicked"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkToolButtonClass, clicked), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); g_type_class_add_private (object_class, sizeof (GtkToolButtonPrivate)); }
static void clutter_path_constraint_class_init (ClutterPathConstraintClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass); ClutterConstraintClass *constraint_class = CLUTTER_CONSTRAINT_CLASS (klass); /** * ClutterPathConstraint:path: * * The #ClutterPath used to constrain the position of an actor. * * */ path_properties[PROP_PATH] = g_param_spec_object ("path", P_("Path"), P_("The path used to constrain an actor"), CLUTTER_TYPE_PATH, CLUTTER_PARAM_READWRITE); /** * ClutterPathConstraint:offset: * * The offset along the #ClutterPathConstraint:path, between -1.0 and 2.0. * * */ path_properties[PROP_OFFSET] = g_param_spec_float ("offset", P_("Offset"), P_("The offset along the path, between -1.0 and 2.0"), -1.0, 2.0, 0.0, CLUTTER_PARAM_READWRITE); gobject_class->set_property = clutter_path_constraint_set_property; gobject_class->get_property = clutter_path_constraint_get_property; gobject_class->dispose = clutter_path_constraint_dispose; g_object_class_install_properties (gobject_class, LAST_PROPERTY, path_properties); meta_class->set_actor = clutter_path_constraint_set_actor; constraint_class->update_allocation = clutter_path_constraint_update_allocation; /** * ClutterPathConstraint::node-reached: * @constraint: the #ClutterPathConstraint that emitted the signal * @actor: the #ClutterActor using the @constraint * @index: the index of the node that has been reached * * The ::node-reached signal is emitted each time a * #ClutterPathConstraint:offset value results in the actor * passing a #ClutterPathNode * * */ path_signals[NODE_REACHED] = g_signal_new (I_("node-reached"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, _clutter_marshal_VOID__OBJECT_UINT, G_TYPE_NONE, 2, CLUTTER_TYPE_ACTOR, G_TYPE_UINT); }
TerminalProfile * _terminal_profile_clone (TerminalProfile *base_profile, const char *visible_name) { TerminalApp *app = terminal_app_get (); GObject *base_object = G_OBJECT (base_profile); TerminalProfilePrivate *new_priv; char profile_name[32]; GParameter *params; GParamSpec **pspecs; guint n_pspecs, i, n_params, profile_num; TerminalProfile *new_profile; g_object_ref (base_profile); profile_num = 0; do { g_snprintf (profile_name, sizeof (profile_name), "profile%u", profile_num++); } while (terminal_app_get_profile_by_name (app, profile_name) != NULL); /* Now we have an unused profile name */ pspecs = g_object_class_list_properties (G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (base_profile)), &n_pspecs); params = g_newa (GParameter, n_pspecs); n_params = 0; for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; GValue *value; if (pspec->owner_type != TERMINAL_TYPE_PROFILE || (pspec->flags & G_PARAM_WRITABLE) == 0) continue; params[n_params].name = pspec->name; value = ¶ms[n_params].value; G_VALUE_TYPE (value) = 0; g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec)); if (pspec->name == I_(TERMINAL_PROFILE_NAME)) g_value_set_static_string (value, profile_name); else if (pspec->name == I_(TERMINAL_PROFILE_VISIBLE_NAME)) g_value_set_static_string (value, visible_name); else g_object_get_property (base_object, pspec->name, value); ++n_params; } new_profile = g_object_newv (TERMINAL_TYPE_PROFILE, n_params, params); g_object_unref (base_profile); for (i = 0; i < n_params; ++i) g_value_unset (¶ms[i].value); /* Flush the new profile to GSettings */ new_priv = new_profile->priv; g_slist_free (new_priv->dirty_pspecs); new_priv->dirty_pspecs = NULL; if (new_priv->save_idle_id != 0) { g_source_remove (new_priv->save_idle_id); new_priv->save_idle_id = 0; } for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; if (pspec->owner_type != TERMINAL_TYPE_PROFILE || (pspec->flags & G_PARAM_WRITABLE) == 0) continue; new_priv->dirty_pspecs = g_slist_prepend (new_priv->dirty_pspecs, pspec); } g_free (pspecs); terminal_profile_save (new_profile); return new_profile; }
P_("Draw Indicator"), P_("If the indicator part of the button is displayed"), TRUE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); props[PROP_INCONSISTENT] = g_param_spec_boolean ("inconsistent", P_("Inconsistent"), P_("If the check button is in an “in between” state"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_properties (object_class, NUM_PROPERTIES, props); gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_CHECK_BOX); gtk_widget_class_set_css_name (widget_class, I_("checkbutton")); } static void draw_indicator_changed (GtkCheckButton *check_button) { GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (check_button); GtkCssNode *widget_node; widget_node = gtk_widget_get_css_node (GTK_WIDGET (check_button)); if (priv->draw_indicator) { priv->indicator_widget = gtk_icon_new ("check"); gtk_widget_set_halign (priv->indicator_widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (priv->indicator_widget, GTK_ALIGN_CENTER);
static void gtk_app_chooser_widget_class_init (GtkAppChooserWidgetClass *klass) { GtkWidgetClass *widget_class; GObjectClass *gobject_class; GParamSpec *pspec; gobject_class = G_OBJECT_CLASS (klass); gobject_class->dispose = gtk_app_chooser_widget_dispose; gobject_class->finalize = gtk_app_chooser_widget_finalize; gobject_class->set_property = gtk_app_chooser_widget_set_property; gobject_class->get_property = gtk_app_chooser_widget_get_property; gobject_class->constructed = gtk_app_chooser_widget_constructed; widget_class = GTK_WIDGET_CLASS (klass); widget_class->measure = gtk_app_chooser_widget_measure; widget_class->size_allocate = gtk_app_chooser_widget_size_allocate; widget_class->snapshot = gtk_app_chooser_widget_snapshot; g_object_class_override_property (gobject_class, PROP_CONTENT_TYPE, "content-type"); /** * GtkAppChooserWidget:show-default: * * The ::show-default property determines whether the app chooser * should show the default handler for the content type in a * separate section. If %FALSE, the default handler is listed * among the recommended applications. */ pspec = g_param_spec_boolean ("show-default", P_("Show default app"), P_("Whether the widget should show the default application"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_SHOW_DEFAULT, pspec); /** * GtkAppChooserWidget:show-recommended: * * The #GtkAppChooserWidget:show-recommended property determines * whether the app chooser should show a section for recommended * applications. If %FALSE, the recommended applications are listed * among the other applications. */ pspec = g_param_spec_boolean ("show-recommended", P_("Show recommended apps"), P_("Whether the widget should show recommended applications"), TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_SHOW_RECOMMENDED, pspec); /** * GtkAppChooserWidget:show-fallback: * * The #GtkAppChooserWidget:show-fallback property determines whether * the app chooser should show a section for fallback applications. * If %FALSE, the fallback applications are listed among the other * applications. */ pspec = g_param_spec_boolean ("show-fallback", P_("Show fallback apps"), P_("Whether the widget should show fallback applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_SHOW_FALLBACK, pspec); /** * GtkAppChooserWidget:show-other: * * The #GtkAppChooserWidget:show-other property determines whether * the app chooser should show a section for other applications. */ pspec = g_param_spec_boolean ("show-other", P_("Show other apps"), P_("Whether the widget should show other applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_SHOW_OTHER, pspec); /** * GtkAppChooserWidget:show-all: * * If the #GtkAppChooserWidget:show-all property is %TRUE, the app * chooser presents all applications in a single list, without * subsections for default, recommended or related applications. */ pspec = g_param_spec_boolean ("show-all", P_("Show all apps"), P_("Whether the widget should show all applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_SHOW_ALL, pspec); /** * GtkAppChooserWidget:default-text: * * The #GtkAppChooserWidget:default-text property determines the text * that appears in the widget when there are no applications for the * given content type. * See also gtk_app_chooser_widget_set_default_text(). */ pspec = g_param_spec_string ("default-text", P_("Widget’s default text"), P_("The default text appearing when there are no applications"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (gobject_class, PROP_DEFAULT_TEXT, pspec); /** * GtkAppChooserWidget::application-selected: * @self: the object which received the signal * @application: the selected #GAppInfo * * Emitted when an application item is selected from the widget's list. */ signals[SIGNAL_APPLICATION_SELECTED] = g_signal_new (I_("application-selected"), GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, application_selected), NULL, NULL, NULL, G_TYPE_NONE, 1, G_TYPE_APP_INFO); /** * GtkAppChooserWidget::application-activated: * @self: the object which received the signal * @application: the activated #GAppInfo * * Emitted when an application item is activated from the widget's list. * * This usually happens when the user double clicks an item, or an item * is selected and the user presses one of the keys Space, Shift+Space, * Return or Enter. */ signals[SIGNAL_APPLICATION_ACTIVATED] = g_signal_new (I_("application-activated"), GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, application_activated), NULL, NULL, NULL, G_TYPE_NONE, 1, G_TYPE_APP_INFO); /** * GtkAppChooserWidget::populate-popup: * @self: the object which received the signal * @menu: the #GtkMenu to populate * @application: the current #GAppInfo * * Emitted when a context menu is about to popup over an application item. * Clients can insert menu items into the provided #GtkMenu object in the * callback of this signal; the context menu will be shown over the item * if at least one item has been added to the menu. */ signals[SIGNAL_POPULATE_POPUP] = g_signal_new (I_("populate-popup"), GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, populate_popup), NULL, NULL, _gtk_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, GTK_TYPE_MENU, G_TYPE_APP_INFO); /* Bind class to template */ gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/ui/gtkappchooserwidget.ui"); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, program_list); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, program_list_store); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, column); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, padding_renderer); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, secondary_padding); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, no_apps_label); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, no_apps); gtk_widget_class_bind_template_child_private (widget_class, GtkAppChooserWidget, overlay); gtk_widget_class_bind_template_callback (widget_class, refresh_and_emit_app_selected); gtk_widget_class_bind_template_callback (widget_class, program_list_selection_activated); gtk_widget_class_set_css_name (widget_class, I_("appchooser")); }
static void gtk_toggle_action_class_init (GtkToggleActionClass *klass) { GObjectClass *gobject_class; GtkActionClass *action_class; parent_class = g_type_class_peek_parent (klass); gobject_class = G_OBJECT_CLASS (klass); action_class = GTK_ACTION_CLASS (klass); gobject_class->set_property = set_property; gobject_class->get_property = get_property; action_class->activate = gtk_toggle_action_activate; action_class->menu_item_type = GTK_TYPE_CHECK_MENU_ITEM; action_class->toolbar_item_type = GTK_TYPE_TOGGLE_TOOL_BUTTON; action_class->create_menu_item = create_menu_item; klass->toggled = NULL; /** * GtkToggleAction:draw-as-radio: * * Whether the proxies for this action look like radio action proxies. * * This is an appearance property and thus only applies if * #GtkActivatable:use-action-appearance is %TRUE. */ g_object_class_install_property (gobject_class, PROP_DRAW_AS_RADIO, g_param_spec_boolean ("draw-as-radio", P_("Create the same proxies as a radio action"), P_("Whether the proxies for this action look like radio action proxies"), FALSE, GTK_PARAM_READWRITE)); /** * GtkToggleAction:active: * * Whether the toggle action should be active. * * Since: 2.10 */ g_object_class_install_property (gobject_class, PROP_ACTIVE, g_param_spec_boolean ("active", P_("Active"), P_("Whether the toggle action should be active"), FALSE, GTK_PARAM_READWRITE)); /** * GtkToggleAction::toggled: * @toggleaction: the object which received the signal. * * Should be connected if you wish to perform an action * whenever the #GtkToggleAction state is changed. */ action_signals[TOGGLED] = g_signal_new (I_("toggled"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkToggleActionClass, toggled), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); g_type_class_add_private (gobject_class, sizeof (GtkToggleActionPrivate)); }
static void gtk_cell_renderer_accel_class_init (GtkCellRendererAccelClass *cell_accel_class) { GObjectClass *object_class; GtkCellRendererClass *cell_renderer_class; object_class = G_OBJECT_CLASS (cell_accel_class); cell_renderer_class = GTK_CELL_RENDERER_CLASS (cell_accel_class); object_class->set_property = gtk_cell_renderer_accel_set_property; object_class->get_property = gtk_cell_renderer_accel_get_property; cell_renderer_class->get_size = gtk_cell_renderer_accel_get_size; cell_renderer_class->start_editing = gtk_cell_renderer_accel_start_editing; /** * GtkCellRendererAccel:accel-key: * * The keyval of the accelerator. * * Since: 2.10 */ g_object_class_install_property (object_class, PROP_ACCEL_KEY, g_param_spec_uint ("accel-key", P_("Accelerator key"), P_("The keyval of the accelerator"), 0, G_MAXINT, 0, GTK_PARAM_READWRITE)); /** * GtkCellRendererAccel:accel-mods: * * The modifier mask of the accelerator. * * Since: 2.10 */ g_object_class_install_property (object_class, PROP_ACCEL_MODS, g_param_spec_flags ("accel-mods", P_("Accelerator modifiers"), P_("The modifier mask of the accelerator"), GDK_TYPE_MODIFIER_TYPE, 0, GTK_PARAM_READWRITE)); /** * GtkCellRendererAccel:keycode: * * The hardware keycode of the accelerator. Note that the hardware keycode is * only relevant if the key does not have a keyval. Normally, the keyboard * configuration should assign keyvals to all keys. * * Since: 2.10 */ g_object_class_install_property (object_class, PROP_KEYCODE, g_param_spec_uint ("keycode", P_("Accelerator keycode"), P_("The hardware keycode of the accelerator"), 0, G_MAXINT, 0, GTK_PARAM_READWRITE)); /** * GtkCellRendererAccel:accel-mode: * * Determines if the edited accelerators are GTK+ accelerators. If * they are, consumed modifiers are suppressed, only accelerators * accepted by GTK+ are allowed, and the accelerators are rendered * in the same way as they are in menus. * * Since: 2.10 */ g_object_class_install_property (object_class, PROP_ACCEL_MODE, g_param_spec_enum ("accel-mode", P_("Accelerator Mode"), P_("The type of accelerators"), GTK_TYPE_CELL_RENDERER_ACCEL_MODE, GTK_CELL_RENDERER_ACCEL_MODE_GTK, GTK_PARAM_READWRITE)); /** * GtkCellRendererAccel::accel-edited: * @accel: the object reveiving the signal * @path_string: the path identifying the row of the edited cell * @accel_key: the new accelerator keyval * @accel_mods: the new acclerator modifier mask * @hardware_keycode: the keycode of the new accelerator * * Gets emitted when the user has selected a new accelerator. * * Since: 2.10 */ signals[ACCEL_EDITED] = g_signal_new (I_("accel-edited"), GTK_TYPE_CELL_RENDERER_ACCEL, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkCellRendererAccelClass, accel_edited), NULL, NULL, _gtk_marshal_VOID__STRING_UINT_FLAGS_UINT, G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_UINT, GDK_TYPE_MODIFIER_TYPE, G_TYPE_UINT); /** * GtkCellRendererAccel::accel-cleared: * @accel: the object reveiving the signal * @path_string: the path identifying the row of the edited cell * * Gets emitted when the user has removed the accelerator. * * Since: 2.10 */ signals[ACCEL_CLEARED] = g_signal_new (I_("accel-cleared"), GTK_TYPE_CELL_RENDERER_ACCEL, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkCellRendererAccelClass, accel_cleared), NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); }
static void gtk_css_node_class_init (GtkCssNodeClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); quark_global_cache = g_quark_from_static_string ("gtk-global-cache"); object_class->get_property = gtk_css_node_get_property; object_class->set_property = gtk_css_node_set_property; object_class->dispose = gtk_css_node_dispose; object_class->finalize = gtk_css_node_finalize; klass->update_style = gtk_css_node_real_update_style; klass->invalidate = gtk_css_node_real_invalidate; klass->validate = gtk_css_node_real_validate; klass->queue_validate = gtk_css_node_real_queue_validate; klass->dequeue_validate = gtk_css_node_real_dequeue_validate; klass->init_matcher = gtk_css_node_real_init_matcher; klass->create_widget_path = gtk_css_node_real_create_widget_path; klass->get_widget_path = gtk_css_node_real_get_widget_path; klass->get_style_provider = gtk_css_node_real_get_style_provider; klass->get_frame_clock = gtk_css_node_real_get_frame_clock; klass->node_added = gtk_css_node_real_node_added; klass->node_removed = gtk_css_node_real_node_removed; klass->style_changed = gtk_css_node_real_style_changed; cssnode_signals[NODE_ADDED] = g_signal_new (I_("node-added"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkCssNodeClass, node_added), NULL, NULL, _gtk_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, GTK_TYPE_CSS_NODE, GTK_TYPE_CSS_NODE); cssnode_signals[NODE_REMOVED] = g_signal_new (I_("node-removed"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkCssNodeClass, node_removed), NULL, NULL, _gtk_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, GTK_TYPE_CSS_NODE, GTK_TYPE_CSS_NODE); cssnode_signals[STYLE_CHANGED] = g_signal_new (I_("style-changed"), G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkCssNodeClass, style_changed), NULL, NULL, _gtk_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER); cssnode_properties[PROP_CLASSES] = g_param_spec_boxed ("classes", "Classes", "List of classes", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); cssnode_properties[PROP_ID] = g_param_spec_string ("id", "ID", "Unique ID", NULL, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); cssnode_properties[PROP_NAME] = g_param_spec_string ("name", "Name", "Name identifying the type of node", NULL, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); cssnode_properties[PROP_STATE] = g_param_spec_flags ("state", "State", "State flags", GTK_TYPE_STATE_FLAGS, 0, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); cssnode_properties[PROP_VISIBLE] = g_param_spec_boolean ("visible", "Visible", "If other nodes can see this node", TRUE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); cssnode_properties[PROP_WIDGET_TYPE] = g_param_spec_gtype ("widget-type", "Widget type", "GType of the widget", G_TYPE_NONE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, NUM_PROPERTIES, cssnode_properties); }
g_object_class_install_property (gobject_class, PROP_SOCKET_WINDOW, g_param_spec_object ("socket-window", P_("Socket Window"), P_("The window of the socket the plug is embedded in"), GDK_TYPE_WINDOW, GTK_PARAM_READABLE)); /** * GtkPlug::embedded: * @plug: the object on which the signal was emitted * * Gets emitted when the plug becomes embedded in a socket. */ plug_signals[EMBEDDED] = g_signal_new (I_("embedded"), G_OBJECT_CLASS_TYPE (class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkPlugClass, embedded), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); } static void gtk_plug_init (GtkPlug *plug) { plug->priv = gtk_plug_get_instance_private (plug); } /**
/* ------------------------------------------------------------------------- */ static int wcf_handle_file_snapshot_upload(void) { tstring *msg = NULL; uint32 code = 0; int err = 0; tstring *file_snapshot_path = NULL; const tstring *file = NULL; bn_binding_array *bindings = NULL; tstring *dump_path = NULL, *dump_name = NULL, *dump_dir = NULL; tbool simple = false, archived = false; err = web_get_request_param_str(g_web_data, "f_file", ps_post_data, &file); bail_error_null(err, file); /* * First make sure the filename doesn't do anything crazy like * trying to reference another directory. */ err = lf_path_component_is_simple(ts_str(file), &simple); bail_error(err); /* XXX/EMT: would be better to return friendly error page */ bail_require_msg(simple, I_("Filename \"%s\" required for download " "was invalid"), ts_str(file)); /* Now generate the absolute file path */ err = lf_path_from_dir_file(snapshot_download_prefix, ts_str(file), &file_snapshot_path); err = web_get_msg_result(g_web_data, &code, NULL); bail_error(err); if (code) { goto bail; } if (file_snapshot_path) { err = lf_path_last(ts_str(file_snapshot_path), &dump_name); bail_error_null(err, dump_name); err = lf_path_parent(ts_str(file_snapshot_path), &dump_dir); bail_error(err); err = web_send_raw_file_with_fileinfo (ts_str(file_snapshot_path), "application/octet-stream", ts_str(dump_name), 0); if (err ) { err = ts_new_sprintf(&msg, _("Could not download snapshot %s" ), ts_str(dump_name)); code = 1; bail_error(err); } } err = web_set_msg_result(g_web_data, code, msg); bail_error(err); if (!code) { err = web_process_form_buttons(g_web_data); bail_error(err); } bail: bn_binding_array_free(&bindings); ts_free(&dump_path); ts_free(&dump_name); ts_free(&dump_dir); ts_free(&msg); if (err) { return(war_error); } else { return(war_ok); } }
static void gtk_shortcuts_window_class_init (GtkShortcutsWindowClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); GtkBindingSet *binding_set = gtk_binding_set_by_class (klass); object_class->constructed = gtk_shortcuts_window_constructed; object_class->finalize = gtk_shortcuts_window_finalize; object_class->get_property = gtk_shortcuts_window_get_property; object_class->set_property = gtk_shortcuts_window_set_property; object_class->dispose = gtk_shortcuts_window_dispose; widget_class->unmap = gtk_shortcuts_window_unmap; container_class->add = gtk_shortcuts_window_add; container_class->remove = gtk_shortcuts_window_remove; container_class->child_type = gtk_shortcuts_window_child_type; container_class->forall = gtk_shortcuts_window_forall; klass->close = gtk_shortcuts_window_close; klass->search = gtk_shortcuts_window_search; /** * GtkShortcutsWindow:section-name: * * The name of the section to show. * * This should be the section-name of one of the #GtkShortcutsSection * objects that are in this shortcuts window. */ properties[PROP_SECTION_NAME] = g_param_spec_string ("section-name", P_("Section Name"), P_("Section Name"), "internal-search", (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GtkShortcutsWindow:view-name: * * The view name by which to filter the contents. * * This should correspond to the #GtkShortcutsGroup:view property of some of * the #GtkShortcutsGroup objects that are inside this shortcuts window. * * Set this to %NULL to show all groups. */ properties[PROP_VIEW_NAME] = g_param_spec_string ("view-name", P_("View Name"), P_("View Name"), NULL, (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_properties (object_class, LAST_PROP, properties); /** * GtkShortcutsWindow::close: * * The ::close signal is a * [keybinding signal][GtkBindingSignal] * which gets emitted when the user uses a keybinding to close * the window. * * The default binding for this signal is the Escape key. */ signals[CLOSE] = g_signal_new (I_("close"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkShortcutsWindowClass, close), NULL, NULL, NULL, G_TYPE_NONE, 0); /** * GtkShortcutsWindow::search: * * The ::search signal is a * [keybinding signal][GtkBindingSignal] * which gets emitted when the user uses a keybinding to start a search. * * The default binding for this signal is Control-F. */ signals[SEARCH] = g_signal_new (I_("search"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkShortcutsWindowClass, search), NULL, NULL, NULL, G_TYPE_NONE, 0); gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0, "close", 0); gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "search", 0); g_type_ensure (GTK_TYPE_SHORTCUTS_GROUP); g_type_ensure (GTK_TYPE_SHORTCUTS_SHORTCUT); }
static void ibus_bus_class_init (IBusBusClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); g_type_class_add_private (klass, sizeof (IBusBusPrivate)); gobject_class->constructor = ibus_bus_constructor; ibus_object_class->destroy = ibus_bus_destroy; // install signals /** * IBusBus::connected: * * Emitted when IBusBus is connected. * * <note><para>Argument @user_data is ignored in this function.</para></note> */ bus_signals[CONNECTED] = g_signal_new (I_("connected"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, ibus_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * IBusBus::disconnected: * * Emitted when IBusBus is disconnected. * * <note><para>Argument @user_data is ignored in this function.</para></note> */ bus_signals[DISCONNECTED] = g_signal_new (I_("disconnected"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, ibus_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * IBusBus::global-engine-changed: * * Emitted when global engine is changed. * * <note><para>Argument @user_data is ignored in this function.</para></note> */ bus_signals[GLOBAL_ENGINE_CHANGED] = g_signal_new (I_("global-engine-changed"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, ibus_marshal_VOID__VOID, G_TYPE_NONE, 0); }
static void g_drive_default_init (GDriveInterface *iface) { /** * GDrive::changed: * @drive: a #GDrive. * * Emitted when the drive's state has changed. **/ g_signal_new (I_("changed"), G_TYPE_DRIVE, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GDriveIface, changed), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GDrive::disconnected: * @drive: a #GDrive. * * This signal is emitted when the #GDrive have been * disconnected. If the recipient is holding references to the * object they should release them so the object can be * finalized. **/ g_signal_new (I_("disconnected"), G_TYPE_DRIVE, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GDriveIface, disconnected), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GDrive::eject-button: * @drive: a #GDrive. * * Emitted when the physical eject button (if any) of a drive has * been pressed. **/ g_signal_new (I_("eject-button"), G_TYPE_DRIVE, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GDriveIface, eject_button), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GDrive::stop-button: * @drive: a #GDrive. * * Emitted when the physical stop button (if any) of a drive has * been pressed. * * Since: 2.22 **/ g_signal_new (I_("stop-button"), G_TYPE_DRIVE, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GDriveIface, stop_button), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); }
/** * GtkIMContextClass: * @preedit_start: Default handler of the #GtkIMContext::preedit-start signal. * @preedit_end: Default handler of the #GtkIMContext::preedit-end signal. * @preedit_changed: Default handler of the #GtkIMContext::preedit-changed * signal. * @commit: Default handler of the #GtkIMContext::commit signal. * @retrieve_surrounding: Default handler of the * #GtkIMContext::retrieve-surrounding signal. * @delete_surrounding: Default handler of the * #GtkIMContext::delete-surrounding signal. * @set_client_window: Called via gtk_im_context_set_client_window() when the * input window where the entered text will appear changes. Override this to * keep track of the current input window, for instance for the purpose of * positioning a status display of your input method. * @get_preedit_string: Called via gtk_im_context_get_preedit_string() to * retrieve the text currently being preedited for display at the cursor * position. Any input method which composes complex characters or any * other compositions from multiple sequential key presses should override * this method to provide feedback. * @filter_keypress: Called via gtk_im_context_filter_keypress() on every * key press or release event. Every non-trivial input method needs to * override this in order to implement the mapping from key events to text. * A return value of %TRUE indicates to the caller that the event was * consumed by the input method. In that case, the #GtkIMContext::commit * signal should be emitted upon completion of a key sequence to pass the * resulting text back to the input widget. Alternatively, %FALSE may be * returned to indicate that the event wasn't handled by the input method. * If a builtin mapping exists for the key, it is used to produce a * character. * @focus_in: Called via gtk_im_context_focus_in() when the input widget * has gained focus. May be overridden to keep track of the current focus. * @focus_out: Called via gtk_im_context_focus_out() when the input widget * has lost focus. May be overridden to keep track of the current focus. * @reset: Called via gtk_im_context_reset() to signal a change such as a * change in cursor position. An input method that implements preediting * should override this method to clear the preedit state on reset. * @set_cursor_location: Called via gtk_im_context_set_cursor_location() * to inform the input method of the current cursor location relative to * the client window. May be overridden to implement the display of popup * windows at the cursor position. * @set_use_preedit: Called via gtk_im_context_set_use_preedit() to control * the use of the preedit string. Override this to display feedback by some * other means if turned off. * @set_surrounding: Called via gtk_im_context_set_surrounding() in response * to signal #GtkIMContext::retrieve-surrounding to update the input * method's idea of the context around the cursor. It is not necessary to * override this method even with input methods which implement * context-dependent behavior. The base implementation is sufficient for * gtk_im_context_get_surrounding() to work. * @get_surrounding: Called via gtk_im_context_get_surrounding() to update * the context around the cursor location. It is not necessary to override * this method even with input methods which implement context-dependent * behavior. The base implementation emits * #GtkIMContext::retrieve-surrounding and records the context received * by the subsequent invocation of @get_surrounding. */ static void gtk_im_context_class_init (GtkIMContextClass *klass) { klass->get_preedit_string = gtk_im_context_real_get_preedit_string; klass->filter_keypress = gtk_im_context_real_filter_keypress; klass->get_surrounding = gtk_im_context_real_get_surrounding; klass->set_surrounding = gtk_im_context_real_set_surrounding; /** * GtkIMContext::preedit-start: * @context: the object on which the signal is emitted * * The ::preedit-start signal is emitted when a new preediting sequence * starts. */ im_context_signals[PREEDIT_START] = g_signal_new (I_("preedit-start"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, preedit_start), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GtkIMContext::preedit-end: * @context: the object on which the signal is emitted * * The ::preedit-end signal is emitted when a preediting sequence * has been completed or canceled. */ im_context_signals[PREEDIT_END] = g_signal_new (I_("preedit-end"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, preedit_end), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GtkIMContext::preedit-changed: * @context: the object on which the signal is emitted * * The ::preedit-changed signal is emitted whenever the preedit sequence * currently being entered has changed. It is also emitted at the end of * a preedit sequence, in which case * gtk_im_context_get_preedit_string() returns the empty string. */ im_context_signals[PREEDIT_CHANGED] = g_signal_new (I_("preedit-changed"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, preedit_changed), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GtkIMContext::commit: * @context: the object on which the signal is emitted * @str: the completed character(s) entered by the user * * The ::commit signal is emitted when a complete input sequence * has been entered by the user. This can be a single character * immediately after a key press or the final result of preediting. */ im_context_signals[COMMIT] = g_signal_new (I_("commit"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, commit), NULL, NULL, _gtk_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); /** * GtkIMContext::retrieve-surrounding: * @context: the object on which the signal is emitted * * The ::retrieve-surrounding signal is emitted when the input method * requires the context surrounding the cursor. The callback should set * the input method surrounding context by calling the * gtk_im_context_set_surrounding() method. * * Return value: %TRUE if the signal was handled. */ im_context_signals[RETRIEVE_SURROUNDING] = g_signal_new (I_("retrieve-surrounding"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, retrieve_surrounding), _gtk_boolean_handled_accumulator, NULL, _gtk_marshal_BOOLEAN__VOID, G_TYPE_BOOLEAN, 0); /** * GtkIMContext::delete-surrounding: * @context: the object on which the signal is emitted * @offset: the character offset from the cursor position of the text * to be deleted. A negative value indicates a position before * the cursor. * @n_chars: the number of characters to be deleted * * The ::delete-surrounding signal is emitted when the input method * needs to delete all or part of the context surrounding the cursor. * * Return value: %TRUE if the signal was handled. */ im_context_signals[DELETE_SURROUNDING] = g_signal_new (I_("delete-surrounding"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkIMContextClass, delete_surrounding), _gtk_boolean_handled_accumulator, NULL, _gtk_marshal_BOOLEAN__INT_INT, G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT); }
static void gtk_scale_button_class_init (GtkScaleButtonClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GtkBindingSet *binding_set; g_type_class_add_private (klass, sizeof (GtkScaleButtonPrivate)); gobject_class->constructor = gtk_scale_button_constructor; gobject_class->finalize = gtk_scale_button_finalize; gobject_class->dispose = gtk_scale_button_dispose; gobject_class->set_property = gtk_scale_button_set_property; gobject_class->get_property = gtk_scale_button_get_property; widget_class->button_press_event = gtk_scale_button_press; widget_class->key_release_event = gtk_scale_button_key_release; widget_class->scroll_event = gtk_scale_button_scroll; widget_class->screen_changed = gtk_scale_button_screen_changed; /** * GtkScaleButton:orientation: * * The orientation of the #GtkScaleButton's popup window. * * Since: 2.14 **/ g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation"); g_object_class_install_property (gobject_class, PROP_VALUE, g_param_spec_double ("value", P_("Value"), P_("The value of the scale"), -G_MAXDOUBLE, G_MAXDOUBLE, 0, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_SIZE, g_param_spec_enum ("size", P_("Icon size"), P_("The icon size"), GTK_TYPE_ICON_SIZE, GTK_ICON_SIZE_SMALL_TOOLBAR, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_ADJUSTMENT, g_param_spec_object ("adjustment", P_("Adjustment"), P_("The GtkAdjustment that contains the current value of this scale button object"), GTK_TYPE_ADJUSTMENT, GTK_PARAM_READWRITE)); /** * GtkScaleButton:icons: * * The names of the icons to be used by the scale button. * The first item in the array will be used in the button * when the current value is the lowest value, the second * item for the highest value. All the subsequent icons will * be used for all the other values, spread evenly over the * range of values. * * If there's only one icon name in the @icons array, it will * be used for all the values. If only two icon names are in * the @icons array, the first one will be used for the bottom * 50% of the scale, and the second one for the top 50%. * * It is recommended to use at least 3 icons so that the * #GtkScaleButton reflects the current value of the scale * better for the users. * * Since: 2.12 */ g_object_class_install_property (gobject_class, PROP_ICONS, g_param_spec_boxed ("icons", P_("Icons"), P_("List of icon names"), G_TYPE_STRV, GTK_PARAM_READWRITE)); /** * GtkScaleButton::value-changed: * @button: the object which received the signal * @value: the new value * * The ::value-changed signal is emitted when the value field has * changed. * * Since: 2.12 */ signals[VALUE_CHANGED] = g_signal_new (I_("value-changed"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkScaleButtonClass, value_changed), NULL, NULL, _gtk_marshal_VOID__DOUBLE, G_TYPE_NONE, 1, G_TYPE_DOUBLE); /** * GtkScaleButton::popup: * @button: the object which received the signal * * The ::popup signal is a * <link linkend="keybinding-signals">keybinding signal</link> * which gets emitted to popup the scale widget. * * The default bindings for this signal are Space, Enter and Return. * * Since: 2.12 */ signals[POPUP] = g_signal_new_class_handler (I_("popup"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_CALLBACK (gtk_scale_button_popup), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** * GtkScaleButton::popdown: * @button: the object which received the signal * * The ::popdown signal is a * <link linkend="keybinding-signals">keybinding signal</link> * which gets emitted to popdown the scale widget. * * The default binding for this signal is Escape. * * Since: 2.12 */ signals[POPDOWN] = g_signal_new_class_handler (I_("popdown"), G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_CALLBACK (gtk_scale_button_popdown), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /* Key bindings */ binding_set = gtk_binding_set_by_class (widget_class); gtk_binding_entry_add_signal (binding_set, GDK_space, 0, "popup", 0); gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0, "popup", 0); gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "popup", 0); gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0, "popup", 0); gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "popup", 0); gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0, "popdown", 0); }
static void clutter_container_default_init (ClutterContainerInterface *iface) { GType iface_type = G_TYPE_FROM_INTERFACE (iface); quark_child_meta = g_quark_from_static_string ("clutter-container-child-data"); /** * ClutterContainer::actor-added: * @container: the actor which received the signal * @actor: the new child that has been added to @container * * The ::actor-added signal is emitted each time an actor * has been added to @container. * * Since: 0.4 */ container_signals[ACTOR_ADDED] = g_signal_new (I_("actor-added"), iface_type, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterContainerIface, actor_added), NULL, NULL, _clutter_marshal_VOID__OBJECT, G_TYPE_NONE, 1, CLUTTER_TYPE_ACTOR); /** * ClutterContainer::actor-removed: * @container: the actor which received the signal * @actor: the child that has been removed from @container * * The ::actor-removed signal is emitted each time an actor * is removed from @container. * * Since: 0.4 */ container_signals[ACTOR_REMOVED] = g_signal_new (I_("actor-removed"), iface_type, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterContainerIface, actor_removed), NULL, NULL, _clutter_marshal_VOID__OBJECT, G_TYPE_NONE, 1, CLUTTER_TYPE_ACTOR); /** * ClutterContainer::child-notify: * @container: the container which received the signal * @actor: the child that has had a property set * @pspec: (type GParamSpec): the #GParamSpec of the property set * * The ::child-notify signal is emitted each time a property is * being set through the clutter_container_child_set() and * clutter_container_child_set_property() calls. * * Since: 0.8 */ container_signals[CHILD_NOTIFY] = g_signal_new (I_("child-notify"), iface_type, G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED, G_STRUCT_OFFSET (ClutterContainerIface, child_notify), NULL, NULL, _clutter_marshal_VOID__OBJECT_PARAM, G_TYPE_NONE, 2, CLUTTER_TYPE_ACTOR, G_TYPE_PARAM); iface->add = container_real_add; iface->remove = container_real_remove; iface->foreach = container_real_foreach; iface->raise = container_real_raise; iface->lower = container_real_lower; iface->sort_depth_order = container_real_sort_depth_order; iface->child_meta_type = G_TYPE_INVALID; iface->create_child_meta = create_child_meta; iface->destroy_child_meta = destroy_child_meta; iface->get_child_meta = get_child_meta; iface->child_notify = child_notify; }
widget_class->unmap = gtk_hsv_unmap; widget_class->realize = gtk_hsv_realize; widget_class->unrealize = gtk_hsv_unrealize; widget_class->size_request = gtk_hsv_size_request; widget_class->size_allocate = gtk_hsv_size_allocate; widget_class->button_press_event = gtk_hsv_button_press; widget_class->button_release_event = gtk_hsv_button_release; widget_class->motion_notify_event = gtk_hsv_motion; widget_class->expose_event = gtk_hsv_expose; widget_class->focus = gtk_hsv_focus; widget_class->grab_broken_event = gtk_hsv_grab_broken; hsv_class->move = gtk_hsv_move; hsv_signals[CHANGED] = g_signal_new (I_("changed"), G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkHSVClass, changed), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); hsv_signals[MOVE] = g_signal_new (I_("move"), G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkHSVClass, move), NULL, NULL, _gtk_marshal_VOID__ENUM, G_TYPE_NONE, 1,
static void g_cancellable_class_init (GCancellableClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->finalize = g_cancellable_finalize; /** * GCancellable::cancelled: * @cancellable: a #GCancellable. * * Emitted when the operation has been cancelled. * * Can be used by implementations of cancellable operations. If the * operation is cancelled from another thread, the signal will be * emitted in the thread that cancelled the operation, not the * thread that is running the operation. * * Note that disconnecting from this signal (or any signal) in a * multi-threaded program is prone to race conditions. For instance * it is possible that a signal handler may be invoked even * <emphasis>after</emphasis> a call to * g_signal_handler_disconnect() for that handler has already * returned. * * There is also a problem when cancellation happen * right before connecting to the signal. If this happens the * signal will unexpectedly not be emitted, and checking before * connecting to the signal leaves a race condition where this is * still happening. * * In order to make it safe and easy to connect handlers there * are two helper functions: g_cancellable_connect() and * g_cancellable_disconnect() which protect against problems * like this. * * An example of how to us this: * |[ * /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/ * if (g_cancellable_set_error_if_cancelled (cancellable)) * return; * * /<!-- -->* Set up all the data needed to be able to * * handle cancellation of the operation *<!-- -->/ * my_data = my_data_new (...); * * id = 0; * if (cancellable) * id = g_cancellable_connect (cancellable, * G_CALLBACK (cancelled_handler) * data, NULL); * * /<!-- -->* cancellable operation here... *<!-- -->/ * * g_cancellable_disconnect (cancellable, id); * * /<!-- -->* cancelled_handler is never called after this, it * * is now safe to free the data *<!-- -->/ * my_data_free (my_data); * ]| * * Note that the cancelled signal is emitted in the thread that * the user cancelled from, which may be the main thread. So, the * cancellable signal should not do something that can block. */ signals[CANCELLED] = g_signal_new (I_("cancelled"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GCancellableClass, cancelled), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); }
static gboolean exo_tree_view_button_press_event (GtkWidget *widget, GdkEventButton *event) { GtkTreeSelection *selection; ExoTreeView *tree_view = EXO_TREE_VIEW (widget); GtkTreePath *path = NULL; gboolean result; GList *selected_paths = NULL; GList *lp; GtkTreeViewColumn* col; gboolean treat_as_blank = FALSE; /* by default we won't emit "row-activated" on button-release-events */ tree_view->priv->button_release_activates = FALSE; /* grab the tree selection */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); /* be sure to cancel any pending single-click timeout */ if (G_UNLIKELY (tree_view->priv->single_click_timeout_id >= 0)) g_source_remove (tree_view->priv->single_click_timeout_id); /* check if the button press was on the internal tree view window */ if (G_LIKELY (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (tree_view)))) { /* determine the path at the event coordinates */ if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &col, NULL, NULL)) path = NULL; if( tree_view->priv->activable_column && col != tree_view->priv->activable_column ) { treat_as_blank = TRUE; if( path ) { gtk_tree_path_free( path ); path = NULL; } gtk_tree_selection_unselect_all (selection); } /* we unselect all selected items if the user clicks on an empty * area of the tree view and no modifier key is active. */ if (path == NULL && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0) gtk_tree_selection_unselect_all (selection); /* completely ignore double-clicks in single-click mode */ if (tree_view->priv->single_click && event->type == GDK_2BUTTON_PRESS) { /* make sure we ignore the GDK_BUTTON_RELEASE * event for this GDK_2BUTTON_PRESS event. */ gtk_tree_path_free (path); return TRUE; } /* check if the next button-release-event should activate the selected row (single click support) */ tree_view->priv->button_release_activates = (tree_view->priv->single_click && event->type == GDK_BUTTON_PRESS && event->button == 1 && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0); } /* unfortunately GtkTreeView will unselect rows except the clicked one, * which makes dragging from a GtkTreeView problematic. That's why we * remember the selected paths here and restore them later. */ if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0 && path != NULL && gtk_tree_selection_path_is_selected (selection, path)) { /* if no custom select function is set, we simply use exo_noop_false here, * to tell the tree view that it may not alter the selection. */ //MOD disabled exo_noop_false due to GTK 2.20 bug https://bugzilla.gnome.org/show_bug.cgi?id=612802 /* if (G_LIKELY (selection->user_func == NULL)) gtk_tree_selection_set_select_function (selection, (GtkTreeSelectionFunc) exo_noop_false, NULL, NULL); else */ selected_paths = gtk_tree_selection_get_selected_rows (selection, NULL); } /* Rubberbanding in GtkTreeView 2.9.0 and above is rather buggy, unfortunately, and * doesn't interact properly with GTKs own DnD mechanism. So we need to block all * dragging here when pressing the mouse button on a not yet selected row if * rubberbanding is active, or disable rubberbanding when starting a drag. */ if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE && gtk_tree_view_get_rubber_banding (GTK_TREE_VIEW (tree_view)) && event->button == 1 && event->type == GDK_BUTTON_PRESS) { /* check if clicked on empty area or on a not yet selected row */ if (G_LIKELY (path == NULL || !gtk_tree_selection_path_is_selected (selection, path))) { /* need to disable drag and drop because we're rubberbanding now */ gpointer drag_data = g_object_get_data (G_OBJECT (tree_view), I_("gtk-site-data")); if (G_LIKELY (drag_data != NULL)) { g_signal_handlers_block_matched (G_OBJECT (tree_view), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, drag_data); } /* remember to re-enable drag and drop later */ tree_view->priv->button_release_unblocks_dnd = TRUE; } else { /* need to disable rubberbanding because we're dragging now */ gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (tree_view), FALSE); /* remember to re-enable rubberbanding later */ tree_view->priv->button_release_enables_rubber_banding = TRUE; } } /* call the parent's button press handler */ result = (*GTK_WIDGET_CLASS (exo_tree_view_parent_class)->button_press_event) (widget, event); if( treat_as_blank ) gtk_tree_selection_unselect_all( selection ); /* restore previous selection if the path is still selected */ if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0 && path != NULL && gtk_tree_selection_path_is_selected (selection, path)) { /* check if we have to restore paths */ if (G_LIKELY (gtk_tree_selection_get_select_function (selection) == (GtkTreeSelectionFunc) exo_noop_false)) { /* just reset the select function (previously set to exo_noop_false), * there's no clean way to do this, so what the heck. */ gtk_tree_selection_set_select_function (selection, NULL, NULL, NULL); } else { /* select all previously selected paths */ for (lp = selected_paths; lp != NULL; lp = lp->next) gtk_tree_selection_select_path (selection, lp->data); } } /* release the path (if any) */ if (G_LIKELY (path != NULL)) gtk_tree_path_free (path); /* release the selected paths list */ g_list_foreach (selected_paths, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected_paths); return result; }