2003-09-29 Havoc Pennington <hp@pobox.com>

	* Merge dbus-object-names branch. To see the entire patch
	do cvs diff -r DBUS_OBJECT_NAMES_BRANCHPOINT -r dbus-object-names,
	it's huuuuge though.
	To revert, I tagged DBUS_BEFORE_OBJECT_NAMES_MERGE.

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* HACKING: update to reflect new server

2003-09-26  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:
	* python/examples/example-signals.py:

	Start implementing some notions of signals. The API
	is really terrible, but they sort of work (with the
	exception of being able to filter by service, and to
	transmit signals *as* a particular service). Need to
	figure out how to make messages come from the service
	we registered :-(

	* python/dbus_bindings.pyx.in:

	Removed duplicate message_handler callbacks.

2003-09-25  Havoc Pennington  <hp@redhat.com>

	* bus/session.conf.in: fix my mess

2003-09-25  Havoc Pennington  <hp@pobox.com>

	* bus/session.conf.in: fix security policy, reported by Seth Nickell

2003-09-25  Seth Nickell  <seth@gnome.org>

	* python/examples/example-service.py:

	Johan notices complete wrong code in example-service, but
	completely wrong in a way that works exactly the same (!).
	Johan is confused, how could this possibly work? Example
	code fails to serve purpose of making things clear.
	Seth fixes.

2003-09-25  Mark McLoughlin  <mark@skynet.ie>

	* doc/dbus-specification.sgml: don't require header fields
	to be 4-byte aligned and specify that fields should be
	distinguished from padding by the fact that zero is not
	a valid field name.

	* doc/TODO: remove re-alignment item and add item to doc
	the OBJECT_PATH type.

	* dbus/dbus-message.c:
	(HeaderField): rename the original member to value_offset
	and introduce a name_offset member to keep track of where
	the field actually begins.
	(adjust_field_offsets): remove.
	(append_int_field), (append_uint_field),
	(append_string_field): don't align the start of the header
	field to a 4-byte boundary.
	(get_next_field): impl finding the next marhsalled field
	after a given field.
	(re_align_field_recurse): impl re-aligning a number of
	already marshalled fields.
	(delete_field): impl deleting a field of any type and
	re-aligning any following fields.
	(delete_int_or_uint_field), (delete_string_field): remove.
	(set_int_field), (set_uint_field): no need to re-check
	that we have the correct type for the field.
	(set_string_field): ditto and impl re-aligning any
	following fields.
	(decode_header_data): update to take into account that
	the fields aren't 4-byte aligned any more and the new
	way to distinguish padding from header fields. Also,
	don't exit when there is too much header padding.
	(process_test_subdir): print the directory.
	(_dbus_message_test): add test to make sure a following
	field is re-aligned correctly after field deletion.

	* dbus/dbus-string.[ch]:
	(_dbus_string_insert_bytes): rename from insert_byte and
	allow the insert of multiple bytes.
	(_dbus_string_test): test inserting multiple bytes.

	* dbus/dbus-marshal.c: (_dbus_marshal_set_string): add
	warning note to docs about having to re-align any
	marshalled values following the string.

	* dbus/dbus-message-builder.c:
	(append_string_field), (_dbus_message_data_load):
	don't align the header field.

	* dbus/dbus-auth.c: (process_test_subdir): print the
	directory.

	* test/break-loader.c: (randomly_add_one_byte): upd. for
	insert_byte change.

	* test/data/invalid-messages/bad-header-field-alignment.message:
	new test case.

	* test/data/valid-messages/unknown-header-field.message: shove
	a dict in the unknown field.

2003-09-25  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:
	* python/dbus_bindings.pyx.in:

	Handle return values.

	* python/examples/example-client.py:
	* python/examples/example-service.py:

	Pass back return values from the service to the client.

2003-09-24  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:

	Connect Object methods (when you are sharing an object) up... pass
	in a list of methods to be shared. Sharing all the methods just
	worked out too weird. You can now create nice Services over the
	DBus in Python. :-)

	* python/dbus_bindings.pyx.in:

	Keep references to user_data tuples passed into C functions so
	Python doesn't garbage collect on us.

	Implement MethodReturn and Error subclasses of Message for creating
	DBusMessage's of those types.

	* python/examples/example-client.py:
	* python/examples/example-service.py:

	Simple example code showing both how create DBus services and objects,
	and how to use them.

2003-09-23  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_filter): implement

2003-09-23  Havoc Pennington  <hp@redhat.com>

	* glib/dbus-gproxy.c (dbus_gproxy_connect_signal): implement
	(dbus_gproxy_disconnect_signal): implement
	(dbus_gproxy_manager_remove_signal_match): implement
	(dbus_gproxy_manager_add_signal_match): implement
	(dbus_gproxy_oneway_call): implement

2003-09-23  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (struct DBusGProxy): convert to a GObject
	subclass. This means dropping the transparent thread safety of the
	proxy; you now need a separate proxy per-thread, or your own
	locking on the proxy. Probably right anyway.
	(dbus_gproxy_ref, dbus_gproxy_unref): nuke, just use g_object_ref

2003-09-22  Havoc Pennington  <hp@redhat.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_get): implement

2003-09-21  Seth Nickell  <seth@gnome.org>

        First checkin of the Python bindings.

	* python/.cvsignore:
	* python/Makefile.am:
	* python/dbus_bindings.pyx.in:
	* python/dbus_h_wrapper.h:

	Pieces for Pyrex to operate on, building a dbus_bindings.so
	python module for low-level access to the DBus APIs.

	* python/dbus.py:

	High-level Python module for accessing DBus objects.

	* configure.in:
	* Makefile.am:

	Build stuff for the python bindings.

	* acinclude.m4:

	Extra macro needed for finding the Python C header files.

2003-09-21  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_new): start
	implementing the proxy manager, didn't get very far.

	* dbus/dbus-bus.c (dbus_bus_add_match): new
	(dbus_bus_remove_match): new

	* glib/dbus-gproxy.c (dbus_gproxy_new_for_service): add a
	path_name argument; adjust the other not-yet-implemented
	gproxy constructors to be what I think they should be.

2003-09-21  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-bus.c (dbus_bus_get): set exit_on_disconnect to TRUE
	by default for message bus connections.

	* dbus/dbus-connection.c (dbus_connection_dispatch): exit if
	exit_on_disconnect flag is set and we process the disconnected
	signal.
	(dbus_connection_set_exit_on_disconnect): new function

2003-09-21  Havoc Pennington  <hp@pobox.com>

	Get matching rules mostly working in the bus; only actually
	parsing the rule text remains. However, the client side of
	"signal connections" hasn't been started, this patch is only the
	bus side.

	* dbus/dispatch.c: fix for the matching rules changes

	* bus/driver.c (bus_driver_handle_remove_match)
	(bus_driver_handle_add_match): send an ack reply from these
	method calls

	* glib/dbus-gproxy.c (dbus_gproxy_begin_call): fix order of
	arguments, reported by Seth Nickell

	* bus/config-parser.c (append_rule_from_element): support
	eavesdrop=true|false attribute on policies so match rules
	can be prevented from snooping on the system bus.

	* bus/dbus-daemon-1.1.in: consistently use terminology "sender"
	and "destination" in attribute names; fix some docs bugs;
	add eavesdrop=true|false attribute

	* bus/driver.c (bus_driver_handle_add_match)
	(bus_driver_handle_remove_match): handle AddMatch, RemoveMatch
	messages

	* dbus/dbus-protocol.h (DBUS_SERVICE_ORG_FREEDESKTOP_BROADCAST): get
	rid of broadcast service concept, signals are just always broadcast

	* bus/signals.c, bus/dispatch.c, bus/connection.c, bus/bus.c:
	mostly implement matching rules stuff (currently only exposed as signal
	connections)

2003-09-21  Mark McLoughlin  <mark@skynet.ie>

	* doc/dbus-specification.sgml: Change the header field name
	to be an enum and update the rest of the spec to reference
	the fields using the conventinal name.

	* dbus/dbus-protocol.h: update to reflect the spec.

	* doc/TODO: add item to remove the 4 byte alignment requirement.

	* dbus/dbus-message.c: Remove the code to generalise the
	header/body length and serial number header fields as named
	header fields so we can reference field names using the
	protocol values.
	(append_int_field), (append_uint_field), (append_string_field):
	Append the field name as a byte rather than four chars.
	(delete_int_or_uint_field), (delete_string_field): reflect the
	fact that the field name and typecode now occupy 4 bytes instead
	of 8.
	(decode_string_field), (decode_header_data): update to reflect
	protocol changes and move the field specific encoding from
	decode_string_field() back into decode_header_data().

	* dbus/dbus-internals.[ch]: (_dbus_header_field_to_string):
	Add utility to aid debugging.

	* dbus/dbus-message-builder.c:
	(append_string_field), (_dbus_message_data_load): Update to
	reflect protocol changes; Change the FIELD_NAME directive
	to HEADER_FIELD and allow it to take the field's conventional
	name rather than the actual value.

	* test/data/*/*.message: Update to use HEADER_FIELD instead
	of FIELD_NAME; Always align the header on an 8 byte boundary
	*before* updating the header length.

2003-09-15  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-pending-call.c: add the get/set object data
	boilerplate as for DBusConnection, etc. Use generic object data
	for the notify callback.

	* glib/dbus-gparser.c (parse_node): parse child nodes

	* tools/dbus-viewer.c: more hacking on the dbus-viewer

	* glib/dbus-gutils.c (_dbus_gutils_split_path): add a file to
	contain functions shared between the convenience lib and the
	installed lib

	* glib/Makefile.am (libdbus_glib_1_la_LDFLAGS): add
	-export-symbols-regex to the GLib library

	* dbus/dbus-object-tree.c (_dbus_object_tree_dispatch_and_unlock):
	fix the locking in here, and add a default handler for
	Introspect() that just returns sub-nodes.

2003-09-14  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gthread.c (dbus_g_thread_init): rename to make g_foo
	rather than gfoo consistent

	* glib/dbus-gproxy.h: delete for now, move contents to
	dbus-glib.h, because the include files don't work right since we
	aren't in the dbus/ subdir.

	* glib/dbus-gproxy.c (dbus_gproxy_send): finish implementing
	(dbus_gproxy_end_call): finish
	(dbus_gproxy_begin_call): finish

	* glib/dbus-gmain.c (dbus_set_g_error): new

	* glib/dbus-gobject.c (handle_introspect): include information
	about child nodes in the introspection

	* dbus/dbus-connection.c (dbus_connection_list_registered): new
	function to help in implementation of introspection

	* dbus/dbus-object-tree.c
	(_dbus_object_tree_list_registered_and_unlock): new function

2003-09-12  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gidl.h: add common base class for all the foo_info
	types

        * tools/dbus-viewer.c: add GTK-based introspection UI thingy
	similar to kdcop

	* test/Makefile.am: try test srcdir -ef . in addition to test
	srcdir = ., one of them should work (yeah lame)

        * glib/Makefile.am: build the "idl" parser stuff as a convenience
	library

	* glib/dbus-gparser.h: make description_load routines return
	NodeInfo* not Parser*

	* Makefile.am (SUBDIRS): build test dir after all library dirs

	* configure.in: add GTK+ detection

2003-09-07  Havoc Pennington  <hp@pobox.com>

	* Make Doxygen contented.

2003-09-07  Havoc Pennington  <hp@pobox.com>

	* doc/dbus-specification.sgml: more updates

2003-09-06  Havoc Pennington  <hp@pobox.com>

	* doc/dbus-specification.sgml: partial updates

	* bus/dbus-daemon-1.1.in: fix the config file docs for the
	zillionth time; hopefully I edited the right file this time.

	* bus/config-parser.c (append_rule_from_element): support
	send_type, send_path, receive_type, receive_path

	* bus/policy.c: add message type and path to the list of things
	that can be "firewalled"

2003-09-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c (dbus_connection_register_fallback): add this
	(dbus_connection_register_object_path): make this not handle
	messages to paths below the given path

2003-09-03  Havoc Pennington  <hp@pobox.com>

	* test/glib/Makefile.am: add this with random glib-linked test
	programs

	* glib/Makefile.am: remove the random test programs from here,
	leave only the unit tests

	* glib/dbus-gobject.c (_dbus_gobject_test): add test for
	uscore/javacaps conversion, and fix
	(get_object_property, set_object_property): change to .NET
	convention for mapping props to methods, set_FooBar/get_FooBar,
	since one language has such a convention we may as well copy it.
	Plus real methods in either getFooBar or get_foo_bar style won't
	collide with this convention.

2003-09-01  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gparser.c: implement

	* glib/dbus-gobject.c: start implementing skeletons support

	* configure.in: when disabling checks/assert, also define
	G_DISABLE_ASSERT and G_DISABLE_CHECKS

2003-09-01  Havoc Pennington  <hp@pobox.com>

	* glib/Makefile.am: rearrange a bunch of files and get "make
	check" framework set up

2003-08-31  Havoc Pennington  <hp@pobox.com>

	* fix build with --disable-tests

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c: purge DBusMessageHandler

	* dbus/dbus-message-handler.c: remove DBusMessageHandler, just
	use callbacks everywhere

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* test/data/valid-config-files/system.d/test.conf: change to
	root for the user so warnings don't get printed

	* dbus/dbus-message.c: add dbus_message_get_path,
	dbus_message_set_path

	* dbus/dbus-object-tree.c (do_test_dispatch): add test of
	dispatching to a path

	* dbus/dbus-string.c (_dbus_string_validate_path): add

	* dbus/dbus-marshal.c (_dbus_demarshal_object_path): implement
	(_dbus_marshal_object_path): implement

	* dbus/dbus-protocol.h (DBUS_HEADER_FIELD_PATH): new header field
	to contain the path to the target object
	(DBUS_HEADER_FIELD_SENDER_SERVICE): rename
	DBUS_HEADER_FIELD_SENDER to explicitly say it's the sender service

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-tree.c: write tests and fix the discovered bugs

2003-08-29  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-tree.c: modify to allow overlapping paths to be
	registered
	(struct DBusObjectSubtree): shrink this
	a lot, since we may have a lot of them
	(_dbus_object_tree_free_all_unlocked): implement
	(_dbus_object_tree_dispatch_and_unlock): implement

2003-08-29  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-internals.h: fix _DBUS_N_GLOBAL_LOCKS

2003-08-28  Havoc Pennington  <hp@pobox.com>

	purge DBusObjectID

	* dbus/dbus-connection.c: port to no ObjectID, create a
	DBusObjectTree, rename ObjectTree to ObjectPath in public API

	* dbus/dbus-connection.h (struct DBusObjectTreeVTable): delete
	everything except UnregisterFunction and MessageFunction

	* dbus/dbus-marshal.c: port away from DBusObjectID,
	add DBUS_TYPE_OBJECT_PATH

	* dbus/dbus-object-registry.[hc], dbus/dbus-object.[hc],
	dbus/dbus-objectid.[hc]: remove these, we are moving to
	path-based object IDs

2003-08-25  Havoc Pennington  <hp@pobox.com>

        Just noticed that dbus_message_test is hosed, I wonder when I
	broke that. I thought make check was passing earlier...

	* dbus/dbus-object-tree.c: add new "object tree" to match DCOP
	container tree, will replace most of dbus-object-registry

	* dbus/dbus-string.c (_dbus_string_append_printf_valist): fix C99
	screwup

2003-08-19  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (decode_string_field): support FIELD_SENDER
	(dbus_message_is_error): fix this function

	* bus/dbus-daemon-1.1: clarify logic on when <deny>/<allow> rules
	match

	* bus/policy.c (bus_client_policy_check_can_receive): fix code to
	reflect clarified man page
	(bus_client_policy_check_can_send): ditto

	* bus/session.conf.in: fixup

	* bus/system.conf.in: fixup

2003-08-18  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-hash.c (_dbus_hash_table_insert_two_strings): fix

	* dbus/dbus-message.c (_dbus_message_loader_queue_messages): fix
	dumb bug created earlier (wrong order of args to
	decode_header_data())

	* tools/dbus-send.c: port

	* tools/dbus-print-message.c (print_message): port

        * test/data/*messages: port all messages over

        * dbus/dbus-message-builder.c: support including
	message type

        * bus/driver.c: port over

	* bus/dispatch.c: port over to new stuff

	* dbus/dbus-connection.c (_dbus_connection_new_for_transport):
	rename disconnect signal to "Disconnected"

2003-08-17  Havoc Pennington  <hp@pobox.com>

	This doesn't compile yet, but syncing up so I can hack on it from
	work. What are branches for if not broken code? ;-)

	* dbus/dbus-protocol.h: remove DBUS_HEADER_FIELD_NAME, add
	DBUS_HEADER_FIELD_INTERFACE, DBUS_HEADER_FIELD_MEMBER,
	DBUS_HEADER_FIELD_ERROR_NAME

	* dbus/dbus-hash.c: Introduce DBUS_HASH_TWO_STRINGS as hack to use
	for the interface+member pairs
	(string_hash): change to use g_str_hash algorithm
	(find_direct_function, find_string_function): refactor these to
	share most code.

	* dbus/dbus-message.c: port all of this over to support
	interface/member fields instead of name field

	* dbus/dbus-object-registry.c: port over

	* dbus/dbus-string.c (_dbus_string_validate_interface): rename
	from _dbus_string_validate_name

	* bus/dbus-daemon-1.1: change file format for the
	<deny>/<allow> stuff to match new message naming scheme

	* bus/policy.c: port over

	* bus/config-parser.c: parse new format

2003-08-16  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c (add_and_remove_objects): remove
	broken assertion

	* glib/dbus-gproxy.c: some hacking

2003-08-15  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-pending-call.c (dbus_pending_call_block): implement

	* dbus/dbus-connection.c
	(dbus_connection_send_with_reply_and_block): factor out internals;
	change to convert any error replies to DBusError instead of
	returning them as a message

2003-08-15  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c,
	dbus/dbus-pending-call.c: Finish the pending call stuff

2003-08-14  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-pending-call.c: start on new object that will replace
	DBusMessageHandler and ReplyHandlerData for tracking outstanding
	replies

	* dbus/dbus-gproxy.c: start on proxy object used to communicate
	with remote interfaces

	* dbus/dbus-gidl.c: do the boring boilerplate in here

2003-08-12  Havoc Pennington  <hp@pobox.com>

	* bus/dispatch.c (bus_dispatch): make this return proper
	DBusHandlerResult to avoid DBUS_ERROR_UNKNOWN_METHOD

	* dbus/dbus-errors.c (dbus_set_error): use
	_dbus_string_append_printf_valist

	* dbus/dbus-string.c (_dbus_string_append_printf_valist)
	(_dbus_string_append_printf): new

	* dbus/dbus-errors.h (DBUS_ERROR_UNKNOWN_MESSAGE): change to
	UNKNOWN_METHOD

	* dbus/dbus-connection.c (dbus_connection_dispatch): handle
	DBUS_HANDLER_RESULT_NEED_MEMORY; send default error reply if a
	message is unhandled.

2003-08-11  Havoc Pennington  <hp@pobox.com>

	* bus/test.c (client_disconnect_handler): change to return
	HANDLED (would have been REMOVE_MESSAGE)

	* dbus/dbus-object.h (enum DBusHandlerResult): rename to
	HANDLED/NOT_YET_HANDLED instead of
	REMOVE_MESSAGE/ALLOW_MORE_HANDLERS to make it clearer how it
	should be used.

2003-08-10  Havoc Pennington  <hp@pobox.com>

	* tools/dbus-send.c (main): add --type argument, for now
	supporting only method_call and signal types.

	* tools/dbus-print-message.c: print message type

	* dbus/dbus-connection.c (_dbus_connection_new_for_transport):
	init connection->objects

	* doc/dbus-specification.sgml: fix sgml

	* bus/*.c: port over to object-instance API changes

	* test/test-service.c: ditto

	* dbus/dbus-message.c (dbus_message_create_header): allow #NULL
	name, we will have to fix up the rest of the code to also handle
	this
	(dbus_message_new): generic message-creation call
	(set_string_field): allow appending name field

2003-08-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c: implement signal connection
	and dispatch

	* dbus/dbus-connection.c (_dbus_connection_unref_unlocked): new

	* dbus/dbus-internals.c (_dbus_memdup): new function

2003-08-02  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (dbus_message_get_no_reply)
	(dbus_message_set_no_reply): add these and remove
	set_is_error/get_is_error

	* dbus/dbus-protocol.h, doc/dbus-specification.sgml:
	remove the ERROR flag, since there's now an ERROR type

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c (_dbus_object_registry_handle_and_unlock):
	implement

	* dbus/dbus-message.c (dbus_message_get_type): new function

	* doc/dbus-specification.sgml: add "type" byte to messages

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-protocol.h (DBUS_MESSAGE_TYPE_*): introduce
	a message type enum to distinguish kinds of message
	(DBUS_HEADER_FLAG_NO_REPLY_EXPECTED): flag for a message
	that need not be replied to

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-marshal.c: adapt to DBusObjectID changes
	(unpack_8_octets): fix no-64-bit-int bug

	* dbus/dbus-object-registry.c (validate_id): validate the
	connection ID bits, not just the instance ID.

	* dbus/dbus-connection.c (_dbus_connection_init_id): initialize
	the connection-global 33 bits of the object ID

	* dbus/dbus-object-registry.c (info_from_entry): fill in
	object ID in the new way

	* dbus/dbus-objectid.h: rather than high/low bits, specifically
	define server/client/instance bits.

2003-07-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c (dbus_connection_register_object): fix
	build

2003-07-13  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.h (struct DBusObjectVTable): add padding
	fields to DBusObjectVTable and DBusObjectInfo

2003-07-12  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c: implement unit test,
	fix bugs discovered in process

	* dbus/dbus-connection.c: remove handler_table and
	register_handler(), add DBusObjectRegistry usage

	* dbus/dbus-objectid.c (dbus_object_id_is_null)
	(dbus_object_id_set_null): new functions

2003-07-08  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.c: implement some of this

	* dbus/dbus-object-registry.c
	(_dbus_object_registry_add_and_unlock): fill in the object_id out
	param
	(_dbus_object_registry_new): handle OOM

2003-07-08  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.h: sketch out an API for registering objects
	with a connection, that allows us to use as little as 24 bytes
	per object and lets application code represent an object in
	any conceivable way.

	* dbus/dbus-object-registry.c: implement the hard bits of the
	DBusConnection aspect of object API. Not yet wired up.

2003-07-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-marshal.c (_dbus_marshal_set_object_id): new function
	(_dbus_marshal_object_id): new
	(_dbus_demarshal_object_id): new
	(_dbus_marshal_get_arg_end_pos): support object ID type, and
	consolidate identical switch cases. Don't conditionalize handling
	of DBUS_TYPE_UINT64, need to handle the type always.
	(_dbus_marshal_validate_arg): consolidate identical cases, and
	handle DBUS_TYPE_OBJECT_ID

	* dbus/dbus-objectid.c: new file with DBusObjectID data type.

	* dbus/dbus-protocol.h: add DBUS_TYPE_OBJECT_ID

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* real 0.13 release

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* doc/Makefile.am (dbus-specification.html): testing a funky hack
	to work with Debian db2html

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* configure.in: 0.13

	* doc/Makefile.am (dbus-test-plan.html): accept nonexistence of
	stylesheet-images for benefit of Debian

	Change back to using filesystem-linked sockets for the system
	bus, so only root can create the default system bus address.

	* bus/system.conf.in: change to use
	DBUS_SYSTEM_BUS_DEFAULT_ADDRESS

	* dbus/Makefile.am (INCLUDES): remove DBUS_SYSTEM_BUS_PATH define
	from here.

	* configure.in: define DBUS_SYSTEM_BUS_DEFAULT_ADDRESS
	here, and AC_DEFINE DBUS_SYSTEM_PATH

2003-08-09  Anders Carlsson  <andersca@codefactory.se>

	* doc/TODO:
	* doc/busconfig.dtd:
	Add busconfig DTD.

2003-08-09  Anders Carlsson  <andersca@codefactory.se>

	* doc/dbus-specification.sgml:
	Add activation reply values.

2003-08-05  Havoc Pennington  <hp@redhat.com>

	* configure.in: 0.12

2003-08-05  Anders Carlsson  <andersca@codefactory.se>

	* glib/dbus-gmain.c: (watch_fd_new), (watch_fd_ref),
	(watch_fd_unref), (dbus_gsource_check), (dbus_gsource_dispatch),
	(add_watch), (remove_watch), (create_source):
	Refcount fds, fixes some reentrancy issues.

2003-07-30  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-bus.c (init_connections_unlocked): fix default system
	bus address to be abstract if we have abstract sockets

	* NEWS: update

2003-07-28  Havoc Pennington  <hp@redhat.com>

	* bus/messagebus.in: fix to avoid processname/servicename
	confusion, from Michael Kearey
	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=100965

2003-07-23  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (dbus_message_iter_get_named):
	fix from Andy Hanton to remove broken "+1"

2003-07-16  Havoc Pennington  <hp@pobox.com>

	* tools/dbus-launch.c (babysit): close stdout/stderr in the
	babysitter process, as suggested by Thomas Leonard, so
	an "eval `dbus-launch --exit-with-session`" will actually
	return

2003-07-16  Havoc Pennington  <hp@pobox.com>

	* configure.in: print out EXPANDED_* variables in the summary at
	the end; clean up the code that computes EXPANDED_ variables and
	get the ones using exec_prefix right. Should make things work
	when you build without --prefix

8 files changed, 898 insertions, 33 deletions

diff --git a/tools/Makefile.am b/tools/Makefile.am
index 80957854..a6a38a97 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -1,4 +1,4 @@
-INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) $(DBUS_X_CFLAGS)
+INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) $(DBUS_X_CFLAGS) $(DBUS_GTK_CFLAGS) -DDBUS_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\"
 
 if HAVE_GLIB
 GLIB_TOOLS=dbus-monitor
@@ -6,7 +6,13 @@ else
 GLIB_TOOLS=
 endif
 
-bin_PROGRAMS=dbus-send $(GLIB_TOOLS) dbus-launch dbus-cleanup-sockets
+if HAVE_GTK
+GTK_TOOLS=dbus-viewer
+else
+GTK_TOOLS=
+endif
+
+bin_PROGRAMS=dbus-send $(GLIB_TOOLS) dbus-launch dbus-cleanup-sockets $(GTK_TOOLS)
 
 dbus_send_SOURCES=				\
 	dbus-print-message.c			\
@@ -24,9 +30,17 @@ dbus_launch_SOURCES=				\
 dbus_cleanup_sockets_SOURCES=			\
 	dbus-cleanup-sockets.c
 
+dbus_viewer_SOURCES=				\
+	dbus-tree-view.c			\
+	dbus-tree-view.h			\
+	dbus-viewer.c
+
 dbus_send_LDADD= $(top_builddir)/dbus/libdbus-1.la
 dbus_monitor_LDADD= $(top_builddir)/glib/libdbus-glib-1.la
 dbus_launch_LDADD= $(DBUS_X_LIBS)
+dbus_viewer_LDADD= $(top_builddir)/glib/libdbus-gtool.la $(DBUS_GTK_LIBS)
 
 man_MANS = dbus-send.1 dbus-monitor.1 dbus-launch.1 dbus-cleanup-sockets.1
 EXTRA_DIST = $(man_MANS)
+
+
diff --git a/tools/dbus-monitor.c b/tools/dbus-monitor.c
index dac15292..23ee346a 100644
--- a/tools/dbus-monitor.c
+++ b/tools/dbus-monitor.c
@@ -30,17 +30,18 @@
 #include "dbus-print-message.h"
 
 static DBusHandlerResult
-handler_func (DBusMessageHandler *handler,
- 	      DBusConnection     *connection,
-	      DBusMessage        *message,
-	      void               *user_data)
+filter_func (DBusConnection     *connection,
+             DBusMessage        *message,
+             void               *user_data)
 {
   print_message (message);
   
-  if (dbus_message_has_name (message, DBUS_MESSAGE_LOCAL_DISCONNECT))
+  if (dbus_message_is_signal (message,
+                              DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
+                              "Disconnected"))
     exit (0);
   
-  return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 static void
@@ -56,7 +57,6 @@ main (int argc, char *argv[])
   DBusConnection *connection;
   DBusError error;
   DBusBusType type = DBUS_BUS_SESSION;
-  DBusMessageHandler *handler;
   GMainLoop *loop;
   int i;
 
@@ -94,8 +94,7 @@ main (int argc, char *argv[])
 
   dbus_connection_setup_with_g_main (connection, NULL);
 
-  handler = dbus_message_handler_new (handler_func, NULL, NULL);
-  dbus_connection_add_filter (connection, handler);
+  dbus_connection_add_filter (connection, filter_func, NULL, NULL);
 
   g_main_loop_run (loop);
 
diff --git a/tools/dbus-print-message.c b/tools/dbus-print-message.c
index bb380ce5..43c41c73 100644
--- a/tools/dbus-print-message.c
+++ b/tools/dbus-print-message.c
@@ -21,18 +21,64 @@
  */
 #include "dbus-print-message.h"
 
+static const char*
+type_to_name (int message_type)
+{
+  switch (message_type)
+    {
+    case DBUS_MESSAGE_TYPE_SIGNAL:
+      return "signal";
+    case DBUS_MESSAGE_TYPE_METHOD_CALL:
+      return "method call";
+    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+      return "method return";
+    case DBUS_MESSAGE_TYPE_ERROR:
+      return "error";
+    default:
+      return "(unknown message type)";
+    }
+}
+
 void
 print_message (DBusMessage *message)
 {
   DBusMessageIter iter;
   const char *sender;
+  int message_type;
 
+  message_type = dbus_message_get_type (message);
   sender = dbus_message_get_sender (message); 
-  
-  printf ("message name=%s; sender=%s\n",
-          dbus_message_get_name (message),
-          sender ? sender : "(no sender)");
-  
+
+  switch (message_type)
+    {
+    case DBUS_MESSAGE_TYPE_METHOD_CALL:
+    case DBUS_MESSAGE_TYPE_SIGNAL:
+      printf ("%s interface=%s; member=%s; sender=%s\n",
+              type_to_name (message_type),
+              dbus_message_get_interface (message),
+              dbus_message_get_member (message),
+              sender ? sender : "(no sender)");
+      break;
+      
+    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+      printf ("%s; sender=%s\n",
+              type_to_name (message_type),
+              sender ? sender : "(no sender)");
+      break;
+
+    case DBUS_MESSAGE_TYPE_ERROR:
+      printf ("%s name=%s; sender=%s\n",
+              type_to_name (message_type),
+              dbus_message_get_error_name (message),
+              sender ? sender : "(no sender)");
+      break;
+
+    default:
+      printf ("Message of unknown type %d received\n",
+              message_type);
+      break;
+    }
+      
   dbus_message_iter_init (message, &iter);
 
   do
diff --git a/tools/dbus-send.1 b/tools/dbus-send.1
index 08ea1335..725507c0 100644
--- a/tools/dbus-send.1
+++ b/tools/dbus-send.1
@@ -8,7 +8,8 @@ dbus-send \- Send a message to a message bus
 .SH SYNOPSIS
 .PP
 .B dbus-send
-[\-\-system | \-\-session] [\-\-dest=SERVICE] [\-\-print-reply] <message name> [contents ...]
+[\-\-system | \-\-session] [\-\-dest=SERVICE] [\-\-print-reply]
+[\-\-type=TYPE] <destination object path> <message name> [contents ...]
 
 .SH DESCRIPTION
 
@@ -28,26 +29,31 @@ specified, \fIdbus-send\fP sends to the session bus.
 Nearly all uses of \fIdbus-send\fP must provide the \-\-dest argument
 which is the name of a service on the bus to send the message to. If
 \-\-dest is omitted, a default service name of
-"org.freedesktop.DBus.Broadcast" is used.  
+"org.freedesktop.Broadcast" is used.  
 
 .PP
-The name of the message to send must always be specified. Following
-arguments, if any, are the message contents (message arguments).
-These are given as a type name, a colon, and then the value of the
-argument. The possible type names are: string, int32, uint32, double,
-byte, boolean.  (D-BUS supports more types than these, but
-\fIdbus-send\fP currently does not.)
+The object path and the name of the message to send must always be
+specified. Following arguments, if any, are the message contents
+(message arguments).  These are given as a type name, a colon, and
+then the value of the argument. The possible type names are: string,
+int32, uint32, double, byte, boolean.  (D-BUS supports more types than
+these, but \fIdbus-send\fP currently does not.)
 
 .PP
 Here is an example invocation:
 .nf
 
-  dbus-send \-\-dest='org.freedesktop.ExampleService'     \\
-            org.freedesktop.ExampleMessage              \\
+  dbus-send \-\-dest='org.freedesktop.ExampleService'        \\
+            /org/freedesktop/sample/object/name              \\
+            org.freedesktop.ExampleInterface.ExampleMethod   \\
             int32:47 string:'hello world' double:65.32
 
 .fi
 
+Note that the interface is separated from a method or signal 
+name by a dot, though in the actual protocol the interface
+and the interface member are separate fields.
+
 .SH OPTIONS
 The following options are supported:
 .TP
@@ -62,6 +68,9 @@ Send to the system message bus.
 .TP
 .I "--session"
 Send to the session message bus.  (This is the default.)
+.TP
+.I "--type=TYPE"
+Specify "method_call" or "signal" (defaults to "signal").
 
 .SH AUTHOR
 dbus-send was written by Philip Blundell.
diff --git a/tools/dbus-send.c b/tools/dbus-send.c
index 12ad5c8c..06a87adb 100644
--- a/tools/dbus-send.c
+++ b/tools/dbus-send.c
@@ -30,7 +30,7 @@
 static void
 usage (char *name, int ecode)
 {
-  fprintf (stderr, "Usage: %s [--help] [--system | --session] [--dest=SERVICE] [--print-reply] <message type> [contents ...]\n", name);
+  fprintf (stderr, "Usage: %s [--help] [--system | --session] [--dest=SERVICE] [--type=TYPE] [--print-reply] <destination object path> <message name> [contents ...]\n", name);
   exit (ecode);
 }
 
@@ -44,10 +44,13 @@ main (int argc, char *argv[])
   DBusMessageIter iter;
   int i;
   DBusBusType type = DBUS_BUS_SESSION;
-  char *dest = DBUS_SERVICE_BROADCAST;
-  char *name = NULL;
-
-  if (argc < 2)
+  const char *dest = NULL;
+  const char *name = NULL;
+  const char *path = NULL;
+  int message_type = DBUS_MESSAGE_TYPE_SIGNAL;
+  const char *type_str = NULL;
+  
+  if (argc < 3)
     usage (argv[0], 1);
 
   print_reply = FALSE;
@@ -64,17 +67,37 @@ main (int argc, char *argv[])
         print_reply = TRUE;
       else if (strstr (arg, "--dest=") == arg)
 	dest = strchr (arg, '=') + 1;
+      else if (strstr (arg, "--type=") == arg)
+	type_str = strchr (arg, '=') + 1;
       else if (!strcmp(arg, "--help"))
 	usage (argv[0], 0);
       else if (arg[0] == '-')
 	usage (argv[0], 1);
+      else if (path == NULL)
+        path = arg;
+      else if (name == NULL)
+        name = arg;
       else
-	name = arg;
+        usage (argv[0], 1);
     }
 
   if (name == NULL)
     usage (argv[0], 1);
 
+  if (type_str != NULL)
+    {
+      if (strcmp (type_str, "method_call") == 0)
+        message_type = DBUS_MESSAGE_TYPE_METHOD_CALL;
+      else if (strcmp (type_str, "signal") == 0)
+        message_type = DBUS_MESSAGE_TYPE_SIGNAL;
+      else
+        {
+          fprintf (stderr, "Message type \"%s\" is not supported\n",
+                   type_str);
+          exit (1);
+        }
+    }
+  
   dbus_error_init (&error);
   connection = dbus_bus_get (type, &error);
   if (connection == NULL)
@@ -86,13 +109,57 @@ main (int argc, char *argv[])
       exit (1);
     }
 
-  message = dbus_message_new (name, dest);
+  if (message_type == DBUS_MESSAGE_TYPE_METHOD_CALL)
+    {
+      char *last_dot;
+
+      last_dot = strrchr (name, '.');
+      if (last_dot == NULL)
+        {
+          fprintf (stderr, "Must use org.mydomain.Interface.Method notation, no dot in \"%s\"\n",
+                   name);
+          exit (1);
+        }
+      *last_dot = '\0';
+      
+      message = dbus_message_new_method_call (NULL,
+                                              path,
+                                              name,
+                                              last_dot + 1);
+    }
+  else if (message_type == DBUS_MESSAGE_TYPE_SIGNAL)
+    {
+      char *last_dot;
+
+      last_dot = strrchr (name, '.');
+      if (last_dot == NULL)
+        {
+          fprintf (stderr, "Must use org.mydomain.Interface.Signal notation, no dot in \"%s\"\n",
+                   name);
+          exit (1);
+        }
+      *last_dot = '\0';
+      
+      message = dbus_message_new_signal (path, name, last_dot + 1);
+    }
+  else
+    {
+      fprintf (stderr, "Internal error, unknown message type\n");
+      exit (1);
+    }
+
   if (message == NULL)
     {
       fprintf (stderr, "Couldn't allocate D-BUS message\n");
       exit (1);
     }
 
+  if (dest && !dbus_message_set_destination (message, dest))
+    {
+      fprintf (stderr, "Not enough memory\n");
+      exit (1);
+    }
+  
   dbus_message_append_iter_init (message, &iter);
 
   while (i < argc)
@@ -135,6 +202,7 @@ main (int argc, char *argv[])
 	  exit (1);
 	}
 
+      /* FIXME - we are ignoring OOM returns on all these functions */
       switch (type)
 	{
 	case DBUS_TYPE_BYTE:
diff --git a/tools/dbus-tree-view.c b/tools/dbus-tree-view.c
new file mode 100644
index 00000000..863ad1e0
--- /dev/null
+++ b/tools/dbus-tree-view.c
@@ -0,0 +1,373 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-tree-view.c GtkTreeView for a D-BUS interface description
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#include <string.h>
+#include <config.h>
+#include "dbus-tree-view.h"
+
+#include <libintl.h>
+#define _(x) dgettext (GETTEXT_PACKAGE, x)
+#define N_(x) x
+
+enum
+{
+  MODEL_COLUMN_INFO,
+
+  MODEL_COLUMN_LAST
+};
+
+enum
+{
+  VIEW_COLUMN_NAME,
+
+  VIEW_COLUMN_LAST
+};
+
+/* We stuff the node tree into a GtkTreeStore, rather
+ * than bothering to write a custom model
+ */
+static GtkTreeModel*
+model_new (void)
+{
+  GtkTreeModel *model;
+  GtkTreeStore *store;
+
+  store = gtk_tree_store_new (MODEL_COLUMN_LAST,
+                              G_TYPE_POINTER);
+  /* FIXME, BASE_INFO_TYPE doesn't work right (crashes),
+   * G_TYPE_POINTER has a memleak. BASE_INFO_TYPE problem maybe just a
+   * bad GTK build on my laptop.
+   */
+  /* BASE_INFO_TYPE); */
+
+  model = GTK_TREE_MODEL (store);
+
+  return model;
+}
+
+static void set_info (GtkTreeModel *model,
+                      GtkTreeIter  *root,
+                      BaseInfo     *info);
+
+static void
+append_child_list (GtkTreeModel *model,
+                   GtkTreeIter  *parent,
+                   GSList       *children)
+{
+  GSList *tmp;
+  GtkTreeStore *store;
+
+  store = GTK_TREE_STORE (model);
+
+  /* parent may be NULL for root */
+
+  tmp = children;
+  while (tmp != NULL)
+    {
+      GtkTreeIter iter;
+
+      gtk_tree_store_append (store, &iter, parent);
+
+      set_info (model, &iter, tmp->data);
+
+      tmp = tmp->next;
+    }
+}
+
+static void
+set_info (GtkTreeModel *model,
+          GtkTreeIter  *root,
+          BaseInfo     *info)
+{
+  GtkTreeStore *store;
+  GtkTreeIter child;
+
+  store = GTK_TREE_STORE (model);
+
+  /* Remeber that root is NULL for "/" path */
+
+  /* Clear existing children */
+  while (gtk_tree_model_iter_children (model, &child, root))
+    gtk_tree_store_remove (store, &child);
+
+  /* Set our new value; we simply discard NodeInfo for "/" at the
+   * moment.
+   */
+  if (root != NULL)
+    {
+      base_info_ref (info); /* FIXME once boxed types are working */
+      gtk_tree_store_set (store, root,
+                          MODEL_COLUMN_INFO, info,
+                          -1);
+    }
+
+  /* Fill in new children */
+  switch (base_info_get_type (info))
+    {
+    case INFO_TYPE_NODE:
+      append_child_list (model, root,
+                         node_info_get_interfaces ((NodeInfo*)info));
+      append_child_list (model, root,
+                         node_info_get_nodes ((NodeInfo*)info));
+      break;
+    case INFO_TYPE_INTERFACE:
+      append_child_list (model, root,
+                         interface_info_get_methods ((InterfaceInfo*)info));
+      append_child_list (model, root,
+                         interface_info_get_signals ((InterfaceInfo*)info));
+      break;
+    case INFO_TYPE_METHOD:
+      append_child_list (model, root,
+                         method_info_get_args ((MethodInfo*)info));
+      break;
+    case INFO_TYPE_SIGNAL:
+      append_child_list (model, root,
+                         signal_info_get_args ((SignalInfo*)info));
+      break;
+    case INFO_TYPE_ARG:
+      /* no children */
+      break;
+    }
+}
+
+static void
+ensure_tree_node (GtkTreeModel  *model,
+                  const char   **path,
+                  GtkTreeIter   *iter)
+{
+  GtkTreeStore *store;
+  int i;
+  GtkTreeIter child;
+  GtkTreeIter *parent;
+  GtkTreeIter prev;
+
+  store = GTK_TREE_STORE (model);
+
+  /* The path[0] == NULL case for path "/" can't happen since no tree
+   * node is created for that
+   */
+  g_assert (path[0] != NULL);
+
+  parent = NULL;
+
+  i = 0;
+  while (path[i] != NULL)
+    {
+      gboolean found;
+
+      found = FALSE;
+
+      if (gtk_tree_model_iter_children (model, &child, parent))
+        {
+          /* Scan for the right path */
+          do
+            {
+              BaseInfo *info;
+
+              info = NULL;
+              gtk_tree_model_get (model, &child,
+                                  MODEL_COLUMN_INFO, &info,
+                                  -1);
+
+              if (info != NULL &&
+                  base_info_get_type (info) == INFO_TYPE_NODE &&
+                  strcmp (base_info_get_name (info), path[i]) == 0)
+                {
+                  /* Found it */
+                  found = TRUE;
+                  break;
+                }
+            }
+          while (gtk_tree_model_iter_next (model, &child));
+        }
+
+      if (!found)
+        {
+          NodeInfo *node;
+
+          node = node_info_new (path[i]);
+
+          gtk_tree_store_append (store, &child, parent);
+          gtk_tree_store_set (store, &child,
+                              MODEL_COLUMN_INFO, node,
+                              -1);
+        }
+
+      prev = child;
+      parent = &prev;
+
+      ++i;
+    }
+
+  g_assert (parent == &prev);
+  *iter = prev;
+}
+
+static void
+model_update (GtkTreeModel  *model,
+              const char   **path,
+              NodeInfo      *node)
+{
+  GtkTreeStore *store;
+
+  store = GTK_TREE_STORE (model);
+
+  if (path[0] == NULL)
+    {
+      /* Setting '/' */
+
+      set_info (model, NULL, (BaseInfo*) node);
+    }
+  else
+    {
+      GtkTreeIter iter;
+      BaseInfo *old;
+
+      /* Be sure we have the parent node */
+      ensure_tree_node (model, path, &iter);
+
+      /* Force the canonical relative path name on the node */
+      old = NULL;
+      gtk_tree_model_get (model, &iter,
+                          MODEL_COLUMN_INFO, &old,
+                          -1);
+      base_info_set_name ((BaseInfo*) node,
+                          base_info_get_name (old));
+
+      /* Fill in the new children */
+      set_info (model, &iter, (BaseInfo*) node);
+    }
+}
+
+static void
+info_set_func_text (GtkTreeViewColumn *tree_column,
+                    GtkCellRenderer   *cell,
+                    GtkTreeModel      *model,
+                    GtkTreeIter       *iter,
+                    gpointer           data)
+{
+  BaseInfo *info;
+  GString *str;
+
+  info = NULL;
+  gtk_tree_model_get (model, iter,
+                      MODEL_COLUMN_INFO, &info,
+                      -1);
+
+  if (info == NULL)
+    return;
+
+  str = g_string_new (NULL);
+
+  switch (base_info_get_type (info))
+    {
+    case INFO_TYPE_NODE:
+      g_string_append (str, "<i>path</i>");
+      break;
+    case INFO_TYPE_INTERFACE:
+      g_string_append (str, "<i>interface</i>");
+      break;
+    case INFO_TYPE_METHOD:
+      g_string_append (str, "<i>method</i>");
+      break;
+    case INFO_TYPE_SIGNAL:
+      g_string_append (str, "<i>signal</i>");
+      break;
+    case INFO_TYPE_ARG:
+      g_string_append (str, "<i>arg</i>");
+      break;
+    }
+
+  g_string_append (str, " ");
+  g_string_append (str, base_info_get_name (info));
+
+  g_object_set (GTK_CELL_RENDERER (cell),
+                "markup", str->str,
+                NULL);
+
+  g_string_free (str, TRUE);
+
+  /* base_info_unref (info); */
+}
+
+GtkWidget*
+dbus_tree_view_new (void)
+{
+  GtkWidget *treeview;
+  GtkCellRenderer *cell_renderer;
+  GtkTreeViewColumn *column;
+
+  treeview = gtk_tree_view_new ();
+
+  column = gtk_tree_view_column_new ();
+  gtk_tree_view_column_set_title (column, _("Name"));
+
+  cell_renderer = gtk_cell_renderer_text_new ();
+  gtk_tree_view_column_pack_start (column,
+                                   cell_renderer,
+                                   TRUE);
+  gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
+                                           info_set_func_text, NULL, NULL);
+
+  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview),
+                               column);
+
+  return treeview;
+}
+
+void
+dbus_tree_view_update (GtkTreeView *view,
+                       const char **path,
+                       NodeInfo    *node)
+{
+  GtkTreeModel *model;
+
+  g_return_if_fail (GTK_IS_TREE_VIEW (view));
+
+  model = gtk_tree_view_get_model (view);
+
+  if (model == NULL)
+    {
+      model = model_new ();
+      model_update (model, path, node);
+      gtk_tree_view_set_model (view, model);
+      g_object_unref (G_OBJECT (model));
+    }
+  else
+    {
+      model_update (model, path, node);
+    }
+}
+
+void
+dbus_tree_view_clear (GtkTreeView  *view)
+{
+  GtkTreeModel *model;
+
+  g_return_if_fail (GTK_IS_TREE_VIEW (view));
+
+  model = gtk_tree_view_get_model (view);
+
+  if (model != NULL)
+    gtk_tree_store_clear (GTK_TREE_STORE (model));
+}
+
diff --git a/tools/dbus-tree-view.h b/tools/dbus-tree-view.h
new file mode 100644
index 00000000..3377ac88
--- /dev/null
+++ b/tools/dbus-tree-view.h
@@ -0,0 +1,36 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-tree-view.h GtkTreeView for a D-BUS interface description
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#ifndef DBUS_TREE_VIEW_H
+#define DBUS_TREE_VIEW_H
+
+#include <gtk/gtk.h>
+#include <glib/dbus-glib.h>
+#include <glib/dbus-gidl.h>
+
+GtkWidget*   dbus_tree_view_new    (void);
+void         dbus_tree_view_update (GtkTreeView  *view,
+                                    const char  **path,
+                                    NodeInfo     *info);
+void         dbus_tree_view_clear  (GtkTreeView  *view);
+
+#endif /* DBUS_TREE_VIEW_H */
diff --git a/tools/dbus-viewer.c b/tools/dbus-viewer.c
new file mode 100644
index 00000000..561a65af
--- /dev/null
+++ b/tools/dbus-viewer.c
@@ -0,0 +1,320 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-viewer.c Graphical D-BUS frontend utility
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#include <config.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <gtk/gtk.h>
+#include "dbus-tree-view.h"
+#include <glib/dbus-gparser.h>
+#include <glib/dbus-gutils.h>
+
+#include <libintl.h>
+#define _(x) dgettext (GETTEXT_PACKAGE, x)
+#define N_(x) x
+
+typedef struct
+{
+  int refcount;
+  char *name;
+
+} ServiceData;
+
+static ServiceData*
+service_data_new (const char *name)
+{
+  ServiceData *sd;
+
+  sd = g_new0 (ServiceData, 1);
+
+  sd->refcount = 1;
+  sd->name = g_strdup (name);
+
+  return sd;
+}
+
+static void
+service_data_ref (ServiceData *sd)
+{
+  sd->refcount += 1;
+}
+
+static void
+service_data_unref (ServiceData *sd)
+{
+  sd->refcount -= 1;
+  if (sd->refcount == 0)
+    {
+      g_free (sd->name);
+      g_free (sd);
+    }
+}
+
+typedef struct
+{
+  GtkWidget *window;
+  GtkWidget *treeview;
+  GtkWidget *service_menu;
+
+  GSList *services;
+  
+} TreeWindow;
+
+static void
+window_closed_callback (GtkWidget  *window,
+                        TreeWindow *w)
+{
+  g_assert (window == w->window);
+  w->window = NULL;
+  gtk_main_quit ();
+}
+
+static TreeWindow*
+tree_window_new (void)
+{
+  TreeWindow *w;
+  GtkWidget *sw;
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+
+  /* Should use glade, blah */
+  
+  w = g_new0 (TreeWindow, 1);
+  w->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+  gtk_window_set_title (GTK_WINDOW (w->window), "D-BUS Viewer");
+  gtk_window_set_default_size (GTK_WINDOW (w->window), 400, 500);
+
+  g_signal_connect (w->window, "destroy", G_CALLBACK (window_closed_callback),
+                    w);
+  gtk_container_set_border_width (GTK_CONTAINER (w->window), 6);
+
+  vbox = gtk_vbox_new (FALSE, 6);
+  gtk_container_add (GTK_CONTAINER (w->window), vbox);
+  
+  hbox = gtk_hbox_new (FALSE, 6);
+  gtk_container_add (GTK_CONTAINER (vbox), hbox);
+
+  /* Create tree view */
+  
+  sw = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+
+  gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
+
+  w->treeview = dbus_tree_view_new ();
+
+  gtk_container_add (GTK_CONTAINER (sw), w->treeview);
+
+  /* Create services option menu */
+
+  
+
+  /* Show everything */
+  gtk_widget_show_all (w->window);
+
+  return w;
+}
+
+static void
+show_error_dialog (GtkWindow *transient_parent,
+                   GtkWidget **weak_ptr,
+                   const char *message_format,
+                   ...)
+{
+  char *message;
+  va_list args;
+
+  if (message_format)
+    {
+      va_start (args, message_format);
+      message = g_strdup_vprintf (message_format, args);
+      va_end (args);
+    }
+  else
+    message = NULL;
+
+  if (weak_ptr == NULL || *weak_ptr == NULL)
+    {
+      GtkWidget *dialog;
+      dialog = gtk_message_dialog_new (transient_parent,
+                                       GTK_DIALOG_DESTROY_WITH_PARENT,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_CLOSE,
+                                       message);
+
+      g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
+
+      if (weak_ptr != NULL)
+        {
+          *weak_ptr = dialog;
+          g_object_add_weak_pointer (G_OBJECT (dialog), (void**)weak_ptr);
+        }
+
+      gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+      
+      gtk_widget_show_all (dialog);
+    }
+  else 
+    {
+      g_return_if_fail (GTK_IS_MESSAGE_DIALOG (*weak_ptr));
+
+      gtk_label_set_text (GTK_LABEL (GTK_MESSAGE_DIALOG (*weak_ptr)->label), message);
+
+      gtk_window_present (GTK_WINDOW (*weak_ptr));
+    }
+}
+
+static void
+usage (int ecode)
+{
+  fprintf (stderr, "dbus-viewer [--version] [--help]\n");
+  exit (ecode);
+}
+
+static void
+version (void)
+{
+  printf ("D-BUS Message Bus Viewer %s\n"
+          "Copyright (C) 2003 Red Hat, Inc.\n"
+          "This is free software; see the source for copying conditions.\n"
+          "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
+          VERSION);
+  exit (0);
+}
+
+int
+main (int argc, char **argv)
+{
+  const char *prev_arg;
+  int i;
+  GSList *files;
+  gboolean end_of_args;
+  GSList *tmp;
+  
+  bindtextdomain (GETTEXT_PACKAGE, DBUS_LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE); 
+  
+  gtk_init (&argc, &argv);
+
+  end_of_args = FALSE;
+  files = NULL;
+  prev_arg = NULL;
+  i = 1;
+  while (i < argc)
+    {
+      const char *arg = argv[i];
+
+      if (!end_of_args)
+        {
+          if (strcmp (arg, "--help") == 0 ||
+              strcmp (arg, "-h") == 0 ||
+              strcmp (arg, "-?") == 0)
+            usage (0);
+          else if (strcmp (arg, "--version") == 0)
+            version ();
+          else if (arg[0] == '-' &&
+                   arg[1] == '-' &&
+                   arg[2] == '\0')
+            end_of_args = TRUE;
+          else if (arg[0] == '-')
+            {
+              usage (1);
+            }
+          else
+            {
+              files = g_slist_prepend (files, (char*) arg);
+            }
+        }
+      else
+        files = g_slist_prepend (files, (char*) arg);
+      
+      prev_arg = arg;
+      
+      ++i;
+    }
+
+  files = g_slist_reverse (files);
+
+  tmp = files;
+  while (tmp != NULL)
+    {
+      NodeInfo *node;
+      GError *error;
+      const char *filename;
+
+      filename = tmp->data;
+
+      error = NULL;
+      node = description_load_from_file (filename,
+                                         &error);
+      if (node == NULL)
+        {
+          g_assert (error != NULL);
+          show_error_dialog (NULL, NULL,
+                             _("Unable to load \"%s\": %s\n"),
+                             filename, error->message);
+          g_error_free (error);
+        }
+      else
+        {
+          TreeWindow *w;
+          char **path;
+          const char *name;
+
+          name = node_info_get_name (node);
+          if (name == NULL ||
+              name[0] != '/')
+            {
+              g_printerr (_("Assuming root node of \"%s\" is at path /, since no absolute path is specified"), filename);
+              name = "/";
+            }
+
+          path = _dbus_gutils_split_path (name);
+          
+          w = tree_window_new ();          
+          dbus_tree_view_update (GTK_TREE_VIEW (w->treeview),
+                                 (const char**) path,
+                                 node);
+          node_info_unref (node);
+
+          g_strfreev (path);
+        }
+      
+      tmp = tmp->next;
+    }
+
+  gtk_main ();
+  
+  return 0;
+}
+
+
+
+
+
+