static void print_connectable_sockaddr (GSocketAddress *sockaddr, GError *error) { char *phys; if (error) { printf ("Error: %s\n", error->message); g_error_free (error); } else if (!G_IS_INET_SOCKET_ADDRESS (sockaddr)) { printf ("Error: Unexpected sockaddr type '%s'\n", g_type_name_from_instance ((GTypeInstance *)sockaddr)); g_object_unref (sockaddr); } else { GInetSocketAddress *isa = G_INET_SOCKET_ADDRESS (sockaddr); phys = g_inet_address_to_string (g_inet_socket_address_get_address (isa)); printf ("Address: %s%s%s:%d\n", strchr (phys, ':') ? "[" : "", phys, strchr (phys, ':') ? "]" : "", g_inet_socket_address_get_port (isa)); g_free (phys); g_object_unref (sockaddr); } }
static GailTextUtil * get_simple_text (gpointer object) { GObject *gobject; EelAccessibleTextIface *aif; if (GTK_IS_ACCESSIBLE (object)) { gobject = G_OBJECT (gtk_accessible_get_widget (GTK_ACCESSIBLE (object))); } else { gobject = eel_accessibility_get_gobject (object); } if (!gobject) { return NULL; } aif = EEL_ACCESSIBLE_TEXT_GET_IFACE (gobject); if (!aif) { g_warning ("No accessible text inferface on '%s'", g_type_name_from_instance ((gpointer) gobject)); } else if (aif->get_text) { return aif->get_text (gobject); } return NULL; }
static void destroy_cb (GObject *object, Test *text) { dbgprintf ("destroy %s %p\n", g_type_name_from_instance ( (GTypeInstance *) object), object); }
static GtkWidget * action_editor (GObject *object, GtkInspectorPropEditor *editor) { GtkWidget *vbox; GtkWidget *label; GtkWidget *box; GtkWidget *button; GObject *owner; gchar *text; owner = find_action_owner (GTK_ACTIONABLE (object)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); if (owner) { label = gtk_label_new (_("Action")); gtk_widget_set_margin_top (label, 10); gtk_container_add (GTK_CONTAINER (vbox), label); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); text = g_strdup_printf (_("Defined at: %p (%s)"), owner, g_type_name_from_instance ((GTypeInstance *)owner)); gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text)); g_free (text); button = gtk_button_new_with_label (_("Properties")); g_object_set_data (G_OBJECT (button), "owner", owner); g_signal_connect (button, "clicked", G_CALLBACK (show_action_owner), editor); gtk_container_add (GTK_CONTAINER (box), button); gtk_container_add (GTK_CONTAINER (vbox), box); gtk_widget_show_all (vbox); } return vbox; }
/* * _g_file_attribute_value_as_string: * @attr: a #GFileAttributeValue. * * Converts a #GFileAttributeValue to a string for display. * The returned string should be freed when no longer needed. * * Returns: a string from the @attr, %NULL on error, or "<invalid>" * if @attr is of type %G_FILE_ATTRIBUTE_TYPE_INVALID. */ char * _g_file_attribute_value_as_string (const GFileAttributeValue *attr) { GString *s; int i; char *str; g_return_val_if_fail (attr != NULL, NULL); switch (attr->type) { case G_FILE_ATTRIBUTE_TYPE_STRING: str = g_strdup (attr->u.string); break; case G_FILE_ATTRIBUTE_TYPE_STRINGV: s = g_string_new ("["); for (i = 0; attr->u.stringv[i] != NULL; i++) { g_string_append (s, attr->u.stringv[i]); if (attr->u.stringv[i+1] != NULL) g_string_append (s, ", "); } g_string_append (s, "]"); str = g_string_free (s, FALSE); break; case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING: str = escape_byte_string (attr->u.string); break; case G_FILE_ATTRIBUTE_TYPE_BOOLEAN: str = g_strdup_printf ("%s", attr->u.boolean?"TRUE":"FALSE"); break; case G_FILE_ATTRIBUTE_TYPE_UINT32: str = g_strdup_printf ("%u", (unsigned int)attr->u.uint32); break; case G_FILE_ATTRIBUTE_TYPE_INT32: str = g_strdup_printf ("%i", (int)attr->u.int32); break; case G_FILE_ATTRIBUTE_TYPE_UINT64: str = g_strdup_printf ("%"G_GUINT64_FORMAT, attr->u.uint64); break; case G_FILE_ATTRIBUTE_TYPE_INT64: str = g_strdup_printf ("%"G_GINT64_FORMAT, attr->u.int64); break; case G_FILE_ATTRIBUTE_TYPE_OBJECT: str = g_strdup_printf ("%s:%p", g_type_name_from_instance ((GTypeInstance *) attr->u.obj), attr->u.obj); break; case G_FILE_ATTRIBUTE_TYPE_INVALID: str = g_strdup ("<unset>"); break; default: g_warning ("Invalid type in GFileInfo attribute"); str = g_strdup ("<invalid>"); break; } return str; }
static gboolean builder_source_real_download (BuilderSource *self, gboolean update_vcs, BuilderContext *context, GError **error) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Download not implemented for type %s", g_type_name_from_instance ((GTypeInstance *) self)); return FALSE; }
static gboolean builder_source_real_extract (BuilderSource *self, GFile *dest, BuilderOptions *build_options, BuilderContext *context, GError **error) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Extract not implemented for type %s", g_type_name_from_instance ((GTypeInstance *) self)); return FALSE; }
static gboolean clicked_icon (GtkTreeView *tv, gint x, gint y, GtkTreePath **path) { GtkTreeViewColumn *col; gint cell_x, cell_y; gint cell_pos, cell_width; GList *cells, *l; gint depth; gint level_indentation; gint expander_size; gint indent; if (gtk_tree_view_get_path_at_pos (tv, x, y, path, &col, &cell_x, &cell_y)) { cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); #if 1 /* ugly workaround to fix the problem: * manually calculate the indent for the row */ depth = gtk_tree_path_get_depth (*path); level_indentation = gtk_tree_view_get_level_indentation (tv); gtk_widget_style_get (GTK_WIDGET (tv), "expander-size", &expander_size, NULL); expander_size += 4; indent = (depth - 1) * level_indentation + depth * expander_size; #else indent = 0; #endif for (l = cells; l; l = l->next) { gtk_tree_view_column_cell_get_position (col, l->data, &cell_pos, &cell_width); if (cell_pos + indent <= cell_x && cell_x <= cell_pos + indent + cell_width) { g_print ("clicked in %s\n", g_type_name_from_instance (l->data)); if (GTK_IS_CELL_RENDERER_PIXBUF (l->data)) { g_list_free (cells); return TRUE; } } } g_list_free (cells); } return FALSE; }
static void webProcessTestRunnerFinalize(JSObjectRef object) { g_object_unref(JSObjectGetPrivate(object)); if (s_watchedObjects.isEmpty()) return; g_print("Leaked objects in WebProcess:"); for (const auto object : s_watchedObjects) g_print(" %s(%p)", g_type_name_from_instance(reinterpret_cast<GTypeInstance*>(object)), object); g_print("\n"); g_assert(s_watchedObjects.isEmpty()); }
void hippo_canvas_item_emit_request_changed(HippoCanvasItem *canvas_item) { if (!hippo_canvas_item_get_needs_request(canvas_item)) { #if 0 g_debug("Item %s %p now needs resize, emitting request-changed", g_type_name_from_instance((GTypeInstance*) canvas_item), canvas_item); #endif g_signal_emit(canvas_item, signals[REQUEST_CHANGED], 0); if (!hippo_canvas_item_get_needs_request(canvas_item)) g_warning("Item %s %p does not need resize after emitting request-changed", g_type_name_from_instance((GTypeInstance*) canvas_item), canvas_item); } else { #if 0 g_debug("Item %s %p already needs resize, not emitting request-changed", g_type_name_from_instance((GTypeInstance*) canvas_item), canvas_item); #endif } }
static void matecomponent_plug_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { dbgprintf ("matecomponent_plug_size_allocate %p: (%d, %d), (%d, %d) %d! %s\n", widget, allocation->x, allocation->y, allocation->width, allocation->height, GTK_WIDGET_TOPLEVEL (widget), GTK_BIN (widget)->child ? g_type_name_from_instance ((gpointer)GTK_BIN (widget)->child): "No child!"); GTK_WIDGET_CLASS (matecomponent_plug_parent_class)->size_allocate (widget, allocation); }
static void print_response (SoupLogger *logger, SoupMessage *msg) { SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger); SoupLoggerLogLevel log_level; SoupMessageHeadersIter iter; const char *name, *value; if (priv->response_filter) { log_level = priv->response_filter (logger, msg, priv->response_filter_data); } else log_level = priv->level; if (log_level == SOUP_LOGGER_LOG_NONE) return; soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "HTTP/1.%d %u %s\n", soup_message_get_http_version (msg), msg->status_code, msg->reason_phrase); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "Soup-Debug-Timestamp: %lu", (unsigned long)time (0)); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "Soup-Debug: %s %u (%p)", g_type_name_from_instance ((GTypeInstance *)msg), soup_logger_get_id (logger, msg), msg); if (log_level == SOUP_LOGGER_LOG_MINIMAL) return; soup_message_headers_iter_init (&iter, msg->response_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '<', "%s: %s", name, value); } if (log_level == SOUP_LOGGER_LOG_HEADERS) return; if (msg->response_body->data) { soup_logger_print (logger, SOUP_LOGGER_LOG_BODY, '<', "\n%s", msg->response_body->data); } }
/* * _g_file_attribute_value_as_string: * @attr: a #GFileAttributeValue. * * Converts a #GFileAttributeValue to a string for display. * The returned string should be freed when no longer needed. * * Returns: a string from the @attr, %NULL on error, or "<invalid>" * if @attr is of type %G_FILE_ATTRIBUTE_TYPE_INVALID. */ char * _g_file_attribute_value_as_string (const GFileAttributeValue *attr) { char *str; g_return_val_if_fail (attr != NULL, NULL); switch (attr->type) { case G_FILE_ATTRIBUTE_TYPE_STRING: str = g_strdup (attr->u.string); break; case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING: str = escape_byte_string (attr->u.string); break; case G_FILE_ATTRIBUTE_TYPE_BOOLEAN: str = g_strdup_printf ("%s", attr->u.boolean?"TRUE":"FALSE"); break; case G_FILE_ATTRIBUTE_TYPE_UINT32: str = g_strdup_printf ("%u", (unsigned int)attr->u.uint32); break; case G_FILE_ATTRIBUTE_TYPE_INT32: str = g_strdup_printf ("%i", (int)attr->u.int32); break; case G_FILE_ATTRIBUTE_TYPE_UINT64: str = g_strdup_printf ("%"G_GUINT64_FORMAT, attr->u.uint64); break; case G_FILE_ATTRIBUTE_TYPE_INT64: str = g_strdup_printf ("%"G_GINT64_FORMAT, attr->u.int64); break; case G_FILE_ATTRIBUTE_TYPE_OBJECT: str = g_strdup_printf ("%s:%p", g_type_name_from_instance ((GTypeInstance *) attr->u.obj), attr->u.obj); break; default: g_warning ("Invalid type in GFileInfo attribute"); str = g_strdup ("<invalid>"); break; } return str; }
/** * g_dbus_interface_dup_object: * @interface_: An exported D-Bus interface. * * Gets the #GDBusObject that @interface_ belongs to, if any. * * Returns: (transfer full): A #GDBusObject or %NULL. The returned * reference should be freed with g_object_unref(). * * Since: 2.32 * * Rename to: g_dbus_interface_get_object */ GDBusObject * g_dbus_interface_dup_object (GDBusInterface *interface_) { GDBusObject *ret; g_return_val_if_fail (G_IS_DBUS_INTERFACE (interface_), NULL); if (G_LIKELY (G_DBUS_INTERFACE_GET_IFACE (interface_)->dup_object != NULL)) { ret = G_DBUS_INTERFACE_GET_IFACE (interface_)->dup_object (interface_); } else { g_warning ("No dup_object() vfunc on type %s - using get_object() in a way that is not thread-safe.", g_type_name_from_instance ((GTypeInstance *) interface_)); ret = G_DBUS_INTERFACE_GET_IFACE (interface_)->get_object (interface_); if (ret != NULL) g_object_ref (ret); } return ret; }
void go_gtk_widget_replace (GtkWidget *victim, GtkWidget *replacement) { GtkContainer *parent = GTK_CONTAINER (gtk_widget_get_parent (victim)); if (GTK_IS_GRID (parent)) { int col, row, width, height; gtk_container_child_get (parent, victim, "left-attach", &col, "top-attach", &row, "width", &width, "height", &height, NULL); gtk_container_remove (parent, victim); gtk_grid_attach (GTK_GRID (parent), replacement, col, row, width, height); } else if (GTK_IS_BOX (parent)) { GtkBox *box = GTK_BOX (parent); gboolean expand, fill; guint padding; GtkPackType pack_type; int pos; gtk_box_query_child_packing (box, victim, &expand, &fill, &padding, &pack_type); gtk_container_child_get (parent, victim, "position", &pos, NULL); gtk_container_remove (parent, victim); gtk_container_add (parent, replacement); gtk_box_set_child_packing (box, replacement, expand, fill, padding, pack_type); gtk_box_reorder_child (box, replacement, pos); } else { g_error ("Unsupported container: %s", g_type_name_from_instance ((gpointer)parent)); } }
void glade_gtk_header_bar_child_set_property (GladeWidgetAdaptor *adaptor, GObject *container, GObject *child, const gchar *property_name, const GValue *value) { GladeWidget *gbox; gint size; d(g_message ("Set child prop %s %s\n", g_type_name_from_instance (child), property_name)); gtk_container_child_set_property (GTK_CONTAINER (container), GTK_WIDGET (child), property_name, value); gbox = glade_widget_get_from_gobject (container); if (!glade_widget_superuser ()) { glade_widget_property_get (gbox, "size", &size); glade_widget_property_set (gbox, "size", size); } }
static void hippo_canvas_block_set_block_impl(HippoCanvasBlock *canvas_block, HippoBlock *new_block) { #if 0 g_debug("setting block on canvas block to %s", new_block ? hippo_block_get_guid(new_block) : "null"); #endif if (new_block != canvas_block->block) { if (new_block) { if (canvas_block->required_type != HIPPO_BLOCK_TYPE_UNKNOWN && hippo_block_get_block_type(new_block) != canvas_block->required_type) { g_warning("Trying to set block type %d on canvas block type %s", hippo_block_get_block_type(new_block), g_type_name_from_instance((GTypeInstance*)canvas_block)); return; } g_object_ref(new_block); g_signal_connect(G_OBJECT(new_block), "notify::timestamp", G_CALLBACK(on_block_timestamp_changed), canvas_block); g_signal_connect(G_OBJECT(new_block), "notify::significant-clicked-count", G_CALLBACK(on_block_significant_clicked_count_changed), canvas_block); g_signal_connect(G_OBJECT(new_block), "notify::ignored", G_CALLBACK(on_block_ignored_changed), canvas_block); g_signal_connect(G_OBJECT(new_block), "notify::stack-reason", G_CALLBACK(on_block_stack_reason_changed), canvas_block); g_signal_connect(G_OBJECT(new_block), "notify::icon-url", G_CALLBACK(on_block_icon_url_changed), canvas_block); } if (canvas_block->block) { g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block), G_CALLBACK(on_block_timestamp_changed), canvas_block); g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block), G_CALLBACK(on_block_significant_clicked_count_changed), canvas_block); g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block), G_CALLBACK(on_block_ignored_changed), canvas_block); g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block), G_CALLBACK(on_block_stack_reason_changed), canvas_block); g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block), G_CALLBACK(on_block_icon_url_changed), canvas_block); g_object_unref(canvas_block->block); } canvas_block->block = new_block; if (new_block) { on_block_timestamp_changed(new_block, NULL, canvas_block); on_block_significant_clicked_count_changed(new_block, NULL, canvas_block); on_block_ignored_changed(new_block, NULL, canvas_block); on_block_stack_reason_changed(new_block, NULL, canvas_block); on_block_icon_url_changed(new_block, NULL, canvas_block); if (canvas_block->heading_lock_item) hippo_canvas_item_set_visible(canvas_block->heading_lock_item, !hippo_block_is_public(canvas_block->block)); } g_object_notify(G_OBJECT(canvas_block), "block"); hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(canvas_block)); } }
static void print_request (SoupLogger *logger, SoupMessage *msg, SoupSession *session, SoupSocket *socket, gboolean restarted) { SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger); SoupLoggerLogLevel log_level; SoupMessageHeadersIter iter; const char *name, *value; SoupURI *uri; if (priv->request_filter) { log_level = priv->request_filter (logger, msg, priv->request_filter_data); } else log_level = priv->level; if (log_level == SOUP_LOGGER_LOG_NONE) return; uri = soup_message_get_uri (msg); if (msg->method == SOUP_METHOD_CONNECT) { soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "CONNECT %s:%u HTTP/1.%d", uri->host, uri->port, soup_message_get_http_version (msg)); } else { soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "%s %s%s%s HTTP/1.%d", msg->method, uri->path, uri->query ? "?" : "", uri->query ? uri->query : "", soup_message_get_http_version (msg)); } soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "Soup-Debug-Timestamp: %lu", (unsigned long)time (0)); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "Soup-Debug: %s %u (%p), %s %u (%p), %s %u (%p)%s", g_type_name_from_instance ((GTypeInstance *)session), soup_logger_get_id (logger, session), session, g_type_name_from_instance ((GTypeInstance *)msg), soup_logger_get_id (logger, msg), msg, g_type_name_from_instance ((GTypeInstance *)socket), soup_logger_get_id (logger, socket), socket, restarted ? ", restarted" : ""); if (log_level == SOUP_LOGGER_LOG_MINIMAL) return; if (!soup_message_headers_get_one (msg->request_headers, "Host")) { char *uri_host; if (strchr (uri->host, ':')) uri_host = g_strdup_printf ("[%s]", uri->host); else if (g_hostname_is_non_ascii (uri->host)) uri_host = g_hostname_to_ascii (uri->host); else uri_host = uri->host; soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>', "Host: %s%c%u", uri_host, soup_uri_uses_default_port (uri) ? '\0' : ':', uri->port); if (uri_host != uri->host) g_free (uri_host); } soup_message_headers_iter_init (&iter, msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { if (!g_ascii_strcasecmp (name, "Authorization") && !g_ascii_strncasecmp (value, "Basic ", 6)) soup_logger_print_basic_auth (logger, value); else { soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>', "%s: %s", name, value); } } if (log_level == SOUP_LOGGER_LOG_HEADERS) return; if (msg->request_body->length && soup_message_body_get_accumulate (msg->request_body)) { SoupBuffer *request; request = soup_message_body_flatten (msg->request_body); g_return_if_fail (request != NULL); soup_buffer_free (request); if (soup_message_headers_get_expectations (msg->request_headers) != SOUP_EXPECTATION_CONTINUE) { soup_logger_print (logger, SOUP_LOGGER_LOG_BODY, '>', "\n%s", msg->request_body->data); } } }
char * gvfs_file_info_marshal (GFileInfo *info, gsize *size) { GOutputStream *memstream; GDataOutputStream *out; GFileAttributeType type; GFileAttributeStatus status; GObject *obj; char **attrs, *attr; char *data; int i; memstream = g_memory_output_stream_new (NULL, 0, g_realloc, NULL); out = g_data_output_stream_new (memstream); g_object_unref (memstream); attrs = g_file_info_list_attributes (info, NULL); g_data_output_stream_put_uint32 (out, g_strv_length (attrs), NULL, NULL); for (i = 0; attrs[i] != NULL; i++) { attr = attrs[i]; type = g_file_info_get_attribute_type (info, attr); status = g_file_info_get_attribute_status (info, attr); put_string (out, attr); g_data_output_stream_put_byte (out, type, NULL, NULL); g_data_output_stream_put_byte (out, status, NULL, NULL); switch (type) { case G_FILE_ATTRIBUTE_TYPE_STRING: put_string (out, g_file_info_get_attribute_string (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING: put_string (out, g_file_info_get_attribute_byte_string (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_STRINGV: put_stringv (out, g_file_info_get_attribute_stringv (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_BOOLEAN: g_data_output_stream_put_byte (out, g_file_info_get_attribute_boolean (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_UINT32: g_data_output_stream_put_uint32 (out, g_file_info_get_attribute_uint32 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_INT32: g_data_output_stream_put_int32 (out, g_file_info_get_attribute_int32 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_UINT64: g_data_output_stream_put_uint64 (out, g_file_info_get_attribute_uint64 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_INT64: g_data_output_stream_put_int64 (out, g_file_info_get_attribute_int64 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_OBJECT: obj = g_file_info_get_attribute_object (info, attr); if (obj == NULL) { g_data_output_stream_put_byte (out, 0, NULL, NULL); } else if (G_IS_ICON (obj)) { char *icon_str; icon_str = g_icon_to_string (G_ICON (obj)); g_data_output_stream_put_byte (out, 1, NULL, NULL); put_string (out, icon_str); g_free (icon_str); } else { g_warning ("Unsupported GFileInfo object type %s\n", g_type_name_from_instance ((GTypeInstance *)obj)); g_data_output_stream_put_byte (out, 0, NULL, NULL); } break; case G_FILE_ATTRIBUTE_TYPE_INVALID: default: break; } } data = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (memstream)); *size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (memstream)); g_object_unref (out); g_strfreev (attrs); return data; }