Control: tags -1 + patch Please find attached a patch.
>From 6c94fcfbf0dc45114602312c8bc6f1bededbf840 Mon Sep 17 00:00:00 2001 From: Yavor Doganov <ya...@gnu.org> Date: Mon, 4 Mar 2024 16:56:28 +0200 Subject: [PATCH] Drop dbus-glib dependency (#955873)
--- debian/changelog | 10 + debian/control | 2 +- debian/patches/no-dbus-glib.patch | 810 ++++++++++++++++++++++++++++++ debian/patches/series | 1 + 4 files changed, 822 insertions(+), 1 deletion(-) create mode 100644 debian/patches/no-dbus-glib.patch diff --git a/debian/changelog b/debian/changelog index 9ae7a98..abf4b48 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,13 @@ +artha (1.0.5-4) UNRELEASED; urgency=medium + + * Team upload. + * debian/patches/no-dbus-glib.patch: New; stop using dbus-glib in favor + of dbus-gmain as recommended (Closes: #955873). + * debian/control (Build-Depends): Replace libdbus-glib-1-dev with + libdbus-1-dev. + + -- Yavor Doganov <ya...@gnu.org> Mon, 04 Mar 2024 16:53:11 +0200 + artha (1.0.5-3) unstable; urgency=medium * DEP5 copyright diff --git a/debian/control b/debian/control index 780d311..83103fa 100644 --- a/debian/control +++ b/debian/control @@ -7,7 +7,7 @@ Priority: optional Build-Depends: debhelper-compat (= 13), wordnet-dev, libgtk2.0-dev, - libdbus-glib-1-dev + libdbus-1-dev Standards-Version: 4.6.0 Vcs-Browser: https://salsa.debian.org/science-team/artha Vcs-Git: https://salsa.debian.org/science-team/artha.git diff --git a/debian/patches/no-dbus-glib.patch b/debian/patches/no-dbus-glib.patch new file mode 100644 index 0000000..11e36d9 --- /dev/null +++ b/debian/patches/no-dbus-glib.patch @@ -0,0 +1,810 @@ +Description: Stop using dbus-glib. +Bug-Debian: https://bugs.debian.org/955873 +Author: Yavor Doganov <ya...@gnu.org> +Forwarded: no +Last-Update: 2024-03-08 +--- + +--- artha.orig/configure.ac ++++ artha/configure.ac +@@ -57,10 +57,10 @@ + + # GtkComboBox with entry only since 2.24 only, hence check for GTK+-2.0 >= 2.24 + # check for GTK+ and GLib +-PKG_CHECK_MODULES([GTK], [gtk+-2.0 >= 2.24 glib-2.0 >= 2.22], , [ ++PKG_CHECK_MODULES([GTK], [gtk+-2.0 >= 2.24 glib-2.0 >= 2.40], , [ + AC_MSG_RESULT(no) + AC_MSG_ERROR([ +-You must have GTK+ 2.0 (version 2.24 or above) and GLib 2.0 (version 2.22 ++You must have GTK+ 2.0 (version 2.24 or above) and GLib 2.0 (version 2.40 + or above) development headers installed to build. + + If you have these installed already you may need to install pkg-config so +@@ -97,12 +97,12 @@ + # begin of POSIX specific config + if test "$build_mach" = "posix"; then + +-# check if dbus-1 alone is enough or dbus-glib-1 alone is enough +-PKG_CHECK_MODULES([libdbus], [dbus-1 >= 0.60 dbus-glib-1 >= 0.60], ++# check if dbus-1 alone is enough ++PKG_CHECK_MODULES([libdbus], [dbus-1 >= 1.8], + [AC_DEFINE([DBUS_AVAILABLE], [], [Dbus dev. headers are present])], [ + AC_MSG_RESULT(no) + AC_MSG_ERROR([ +-You must have the dbus and dbus-glib-1 (version 0.60 or above) ++You must have the dbus (version 1.8 or above) + development headers installed! + + If it is installed already, you may need to install pkg-config so +--- artha.orig/src/Makefile.am ++++ artha/src/Makefile.am +@@ -9,7 +9,7 @@ + libwni_a_SOURCES = wni.c wni.h + + artha_DEPENDENCIES = libwni.a +-artha_SOURCES = mod_notify.c mod_notify.h \ ++artha_SOURCES = dbus-gmain.c dbus-gmain.h mod_notify.c mod_notify.h \ + suggestions.c suggestions.h \ + hotkey_editor.c hotkey_editor.h \ + gui.c gui.h addons.h +@@ -38,7 +38,7 @@ + + if POSIX + AM_CFLAGS += @libdbus_CFLAGS@ +-artha_LDADD += -lX11 -ldbus-1 -ldbus-glib-1 -lgtk-x11-2.0 -lgdk-x11-2.0 \ ++artha_LDADD += -lX11 -ldbus-1 -lgtk-x11-2.0 -lgdk-x11-2.0 \ + -lgio-2.0 -lgmodule-2.0 -lgobject-2.0 -lglib-2.0 + else + artha_LDADD += @GTK_LIBS@ +--- /dev/null ++++ artha/src/dbus-gmain.c +@@ -0,0 +1,666 @@ ++/* -*- mode: C; c-file-style: "gnu" -*- */ ++/* dbus-gmain.c GLib main loop integration ++ * ++ * Copyright © 2002-2003 CodeFactory AB ++ * Copyright © 2002-2010 Red Hat, Inc. ++ * Copyright © 2003 James Willcox ++ * Copyright © 2006 Marc-Andre Lureau ++ * Copyright © 2006-2018 Collabora Ltd. ++ * Copyright © 2010-2012 Mike Gorse ++ * ++ * SPDX-License-Identifier: AFL-2.1 OR GPL-2.0-or-later ++ * ++ * Licensed under the Academic Free License version 2.1 ++ * ++ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ * ++ */ ++ ++#ifdef HAVE_CONFIG_H ++#include <config.h> ++#endif ++ ++#include "dbus-gmain.h" ++ ++/* ++ * DBusGMessageQueue: ++ * ++ * A GSource subclass for dispatching DBusConnection messages. ++ * We need this on top of the IO handlers, because sometimes ++ * there are messages to dispatch queued up but no IO pending. ++ */ ++typedef struct ++{ ++ GSource source; /**< the parent GSource */ ++ DBusConnection *connection; /**< the connection to dispatch */ ++} DBusGMessageQueue; ++ ++static gboolean message_queue_prepare (GSource *source, ++ gint *timeout); ++static gboolean message_queue_check (GSource *source); ++static gboolean message_queue_dispatch (GSource *source, ++ GSourceFunc callback, ++ gpointer user_data); ++ ++static const GSourceFuncs message_queue_funcs = { ++ message_queue_prepare, ++ message_queue_check, ++ message_queue_dispatch, ++ NULL ++}; ++ ++static gboolean ++message_queue_prepare (GSource *source, ++ gint *timeout) ++{ ++ DBusConnection *connection = ((DBusGMessageQueue *)source)->connection; ++ ++ *timeout = -1; ++ ++ return (dbus_connection_get_dispatch_status (connection) == DBUS_DISPATCH_DATA_REMAINS); ++} ++ ++static gboolean ++message_queue_check (G_GNUC_UNUSED GSource *source) ++{ ++ return FALSE; ++} ++ ++static gboolean ++message_queue_dispatch (GSource *source, ++ G_GNUC_UNUSED GSourceFunc callback, ++ G_GNUC_UNUSED gpointer user_data) ++{ ++ DBusConnection *connection = ((DBusGMessageQueue *)source)->connection; ++ ++ dbus_connection_ref (connection); ++ ++ /* Only dispatch once - we don't want to starve other GSource */ ++ dbus_connection_dispatch (connection); ++ ++ dbus_connection_unref (connection); ++ ++ return TRUE; ++} ++ ++typedef struct ++{ ++ GMainContext *context; /**< the main context */ ++ GSList *ios; /**< all IOHandler */ ++ GSList *timeouts; /**< all TimeoutHandler */ ++ DBusConnection *connection; /**< NULL if this is really for a server not a connection */ ++ GSource *message_queue_source; /**< DBusGMessageQueue */ ++} ConnectionSetup; ++ ++ ++typedef struct ++{ ++ ConnectionSetup *cs; ++ GSource *source; ++ DBusWatch *watch; ++} IOHandler; ++ ++typedef struct ++{ ++ ConnectionSetup *cs; ++ GSource *source; ++ DBusTimeout *timeout; ++} TimeoutHandler; ++ ++dbus_int32_t _dbus_gmain_connection_slot = -1; ++static dbus_int32_t server_slot = -1; ++ ++static ConnectionSetup* ++connection_setup_new (GMainContext *context, ++ DBusConnection *connection) ++{ ++ ConnectionSetup *cs; ++ ++ cs = g_new0 (ConnectionSetup, 1); ++ ++ g_assert (context != NULL); ++ ++ cs->context = context; ++ g_main_context_ref (cs->context); ++ ++ if (connection) ++ { ++ cs->connection = connection; ++ ++ cs->message_queue_source = g_source_new ((GSourceFuncs *) &message_queue_funcs, ++ sizeof (DBusGMessageQueue)); ++ ((DBusGMessageQueue*)cs->message_queue_source)->connection = connection; ++ g_source_attach (cs->message_queue_source, cs->context); ++ } ++ ++ return cs; ++} ++ ++static void ++io_handler_source_finalized (gpointer data) ++{ ++ IOHandler *handler; ++ ++ handler = data; ++ ++ if (handler->watch) ++ dbus_watch_set_data (handler->watch, NULL, NULL); ++ ++ g_free (handler); ++} ++ ++static void ++io_handler_destroy_source (void *data) ++{ ++ IOHandler *handler; ++ ++ handler = data; ++ ++ if (handler->source) ++ { ++ GSource *source = handler->source; ++ handler->source = NULL; ++ handler->cs->ios = g_slist_remove (handler->cs->ios, handler); ++ g_source_destroy (source); ++ g_source_unref (source); ++ } ++} ++ ++static void ++io_handler_watch_freed (void *data) ++{ ++ IOHandler *handler; ++ ++ handler = data; ++ ++ handler->watch = NULL; ++ ++ io_handler_destroy_source (handler); ++} ++ ++static gboolean ++io_handler_dispatch (G_GNUC_UNUSED GIOChannel *source, ++ GIOCondition condition, ++ gpointer data) ++{ ++ IOHandler *handler; ++ guint dbus_condition = 0; ++ DBusConnection *connection; ++ ++ handler = data; ++ ++ connection = handler->cs->connection; ++ ++ if (connection) ++ dbus_connection_ref (connection); ++ ++ if (condition & G_IO_IN) ++ dbus_condition |= DBUS_WATCH_READABLE; ++ if (condition & G_IO_OUT) ++ dbus_condition |= DBUS_WATCH_WRITABLE; ++ if (condition & G_IO_ERR) ++ dbus_condition |= DBUS_WATCH_ERROR; ++ if (condition & G_IO_HUP) ++ dbus_condition |= DBUS_WATCH_HANGUP; ++ ++ /* Note that we don't touch the handler after this, because ++ * dbus may have disabled the watch and thus killed the ++ * handler. ++ */ ++ dbus_watch_handle (handler->watch, dbus_condition); ++ handler = NULL; ++ ++ if (connection) ++ dbus_connection_unref (connection); ++ ++ return TRUE; ++} ++ ++/* Attach the connection setup to the given watch, removing any ++ * previously-attached connection setup. ++ */ ++static void ++connection_setup_add_watch (ConnectionSetup *cs, ++ DBusWatch *watch) ++{ ++ guint flags; ++ GIOCondition condition; ++ GIOChannel *channel; ++ IOHandler *handler; ++ ++ if (!dbus_watch_get_enabled (watch)) ++ return; ++ ++ flags = dbus_watch_get_flags (watch); ++ ++ condition = G_IO_ERR | G_IO_HUP; ++ if (flags & DBUS_WATCH_READABLE) ++ condition |= G_IO_IN; ++ if (flags & DBUS_WATCH_WRITABLE) ++ condition |= G_IO_OUT; ++ ++ handler = g_new0 (IOHandler, 1); ++ handler->cs = cs; ++ handler->watch = watch; ++ ++ channel = g_io_channel_unix_new (dbus_watch_get_unix_fd (watch)); ++ ++ handler->source = g_io_create_watch (channel, condition); ++ g_source_set_callback (handler->source, ++ (GSourceFunc) (void (*) (void)) io_handler_dispatch, ++ handler, io_handler_source_finalized); ++ g_source_attach (handler->source, cs->context); ++ ++ cs->ios = g_slist_prepend (cs->ios, handler); ++ ++ dbus_watch_set_data (watch, handler, io_handler_watch_freed); ++ g_io_channel_unref (channel); ++} ++ ++static void ++connection_setup_remove_watch (ConnectionSetup *cs, ++ DBusWatch *watch) ++{ ++ IOHandler *handler; ++ ++ handler = dbus_watch_get_data (watch); ++ ++ if (handler == NULL || handler->cs != cs) ++ return; ++ ++ io_handler_destroy_source (handler); ++} ++ ++static void ++timeout_handler_source_finalized (gpointer data) ++{ ++ TimeoutHandler *handler; ++ ++ handler = data; ++ ++ if (handler->timeout) ++ dbus_timeout_set_data (handler->timeout, NULL, NULL); ++ ++ g_free (handler); ++} ++ ++static void ++timeout_handler_destroy_source (void *data) ++{ ++ TimeoutHandler *handler; ++ ++ handler = data; ++ ++ if (handler->source) ++ { ++ GSource *source = handler->source; ++ handler->source = NULL; ++ handler->cs->timeouts = g_slist_remove (handler->cs->timeouts, handler); ++ g_source_destroy (source); ++ g_source_unref (source); ++ } ++} ++ ++static void ++timeout_handler_timeout_freed (void *data) ++{ ++ TimeoutHandler *handler; ++ ++ handler = data; ++ ++ handler->timeout = NULL; ++ ++ timeout_handler_destroy_source (handler); ++} ++ ++static gboolean ++timeout_handler_dispatch (gpointer data) ++{ ++ TimeoutHandler *handler; ++ ++ handler = data; ++ ++ dbus_timeout_handle (handler->timeout); ++ ++ return TRUE; ++} ++ ++static void ++connection_setup_add_timeout (ConnectionSetup *cs, ++ DBusTimeout *timeout) ++{ ++ TimeoutHandler *handler; ++ ++ if (!dbus_timeout_get_enabled (timeout)) ++ return; ++ ++ handler = g_new0 (TimeoutHandler, 1); ++ handler->cs = cs; ++ handler->timeout = timeout; ++ ++ handler->source = g_timeout_source_new (dbus_timeout_get_interval (timeout)); ++ g_source_set_callback (handler->source, timeout_handler_dispatch, handler, ++ timeout_handler_source_finalized); ++ g_source_attach (handler->source, handler->cs->context); ++ ++ cs->timeouts = g_slist_prepend (cs->timeouts, handler); ++ ++ dbus_timeout_set_data (timeout, handler, timeout_handler_timeout_freed); ++} ++ ++static void ++connection_setup_remove_timeout (G_GNUC_UNUSED ConnectionSetup *cs, ++ DBusTimeout *timeout) ++{ ++ TimeoutHandler *handler; ++ ++ handler = dbus_timeout_get_data (timeout); ++ ++ if (handler == NULL) ++ return; ++ ++ timeout_handler_destroy_source (handler); ++} ++ ++static void ++connection_setup_free (ConnectionSetup *cs) ++{ ++ while (cs->ios) ++ io_handler_destroy_source (cs->ios->data); ++ ++ while (cs->timeouts) ++ timeout_handler_destroy_source (cs->timeouts->data); ++ ++ if (cs->message_queue_source) ++ { ++ GSource *source; ++ ++ source = cs->message_queue_source; ++ cs->message_queue_source = NULL; ++ ++ g_source_destroy (source); ++ g_source_unref (source); ++ } ++ ++ g_main_context_unref (cs->context); ++ g_free (cs); ++} ++ ++static dbus_bool_t ++add_watch (DBusWatch *watch, ++ gpointer data) ++{ ++ ConnectionSetup *cs; ++ ++ cs = data; ++ ++ connection_setup_add_watch (cs, watch); ++ ++ return TRUE; ++} ++ ++static void ++remove_watch (DBusWatch *watch, ++ gpointer data) ++{ ++ ConnectionSetup *cs; ++ ++ cs = data; ++ ++ connection_setup_remove_watch (cs, watch); ++} ++ ++static void ++watch_toggled (DBusWatch *watch, ++ void *data) ++{ ++ /* Because we just exit on OOM, enable/disable is ++ * no different from add/remove ++ */ ++ if (dbus_watch_get_enabled (watch)) ++ add_watch (watch, data); ++ else ++ remove_watch (watch, data); ++} ++ ++static dbus_bool_t ++add_timeout (DBusTimeout *timeout, ++ void *data) ++{ ++ ConnectionSetup *cs; ++ ++ cs = data; ++ ++ if (!dbus_timeout_get_enabled (timeout)) ++ return TRUE; ++ ++ connection_setup_add_timeout (cs, timeout); ++ ++ return TRUE; ++} ++ ++static void ++remove_timeout (DBusTimeout *timeout, ++ void *data) ++{ ++ ConnectionSetup *cs; ++ ++ cs = data; ++ ++ connection_setup_remove_timeout (cs, timeout); ++} ++ ++static void ++timeout_toggled (DBusTimeout *timeout, ++ void *data) ++{ ++ /* Because we just exit on OOM, enable/disable is ++ * no different from add/remove ++ */ ++ if (dbus_timeout_get_enabled (timeout)) ++ add_timeout (timeout, data); ++ else ++ remove_timeout (timeout, data); ++} ++ ++static void ++wakeup_main (void *data) ++{ ++ ConnectionSetup *cs = data; ++ ++ g_main_context_wakeup (cs->context); ++} ++ ++ ++/* Move to a new context */ ++static ConnectionSetup* ++connection_setup_new_from_old (GMainContext *context, ++ ConnectionSetup *old) ++{ ++ ConnectionSetup *cs; ++ ++ g_assert (old->context != context); ++ ++ cs = connection_setup_new (context, old->connection); ++ ++ while (old->ios != NULL) ++ { ++ IOHandler *handler = old->ios->data; ++ ++ connection_setup_add_watch (cs, handler->watch); ++ /* The old handler will be removed from old->ios as a side-effect */ ++ } ++ ++ while (old->timeouts != NULL) ++ { ++ TimeoutHandler *handler = old->timeouts->data; ++ ++ connection_setup_add_timeout (cs, handler->timeout); ++ } ++ ++ return cs; ++} ++ ++/** ++ * dbus_gmain_set_up_connection: ++ * @connection: the connection ++ * @context: the #GMainContext or %NULL for default context ++ * ++ * Sets the watch and timeout functions of a #DBusConnection ++ * to integrate the connection with the GLib main loop. ++ * Pass in %NULL for the #GMainContext unless you're ++ * doing something specialized. ++ * ++ * If called twice for the same context, does nothing the second ++ * time. If called once with context A and once with context B, ++ * context B replaces context A as the context monitoring the ++ * connection. ++ */ ++DBUS_GMAIN_FUNCTION (void, ++set_up_connection, DBusConnection *connection, ++ GMainContext *context) ++{ ++ ConnectionSetup *old_setup; ++ ConnectionSetup *cs; ++ ++ /* FIXME we never free the slot, so its refcount just keeps growing, ++ * which is kind of broken. ++ */ ++ dbus_connection_allocate_data_slot (&_dbus_gmain_connection_slot); ++ if (_dbus_gmain_connection_slot < 0) ++ goto nomem; ++ ++ if (context == NULL) ++ context = g_main_context_default (); ++ ++ cs = NULL; ++ ++ old_setup = dbus_connection_get_data (connection, _dbus_gmain_connection_slot); ++ if (old_setup != NULL) ++ { ++ if (old_setup->context == context) ++ return; /* nothing to do */ ++ ++ cs = connection_setup_new_from_old (context, old_setup); ++ ++ /* Nuke the old setup */ ++ dbus_connection_set_data (connection, _dbus_gmain_connection_slot, NULL, NULL); ++ old_setup = NULL; ++ } ++ ++ if (cs == NULL) ++ cs = connection_setup_new (context, connection); ++ ++ if (!dbus_connection_set_data (connection, _dbus_gmain_connection_slot, cs, ++ (DBusFreeFunction)connection_setup_free)) ++ goto nomem; ++ ++ if (!dbus_connection_set_watch_functions (connection, ++ add_watch, ++ remove_watch, ++ watch_toggled, ++ cs, NULL)) ++ goto nomem; ++ ++ if (!dbus_connection_set_timeout_functions (connection, ++ add_timeout, ++ remove_timeout, ++ timeout_toggled, ++ cs, NULL)) ++ goto nomem; ++ ++ dbus_connection_set_wakeup_main_function (connection, ++ wakeup_main, ++ cs, NULL); ++ ++ return; ++ ++ nomem: ++ g_error ("Not enough memory to set up DBusConnection for use with GLib"); ++} ++ ++/** ++ * dbus_gmain_set_up_server: ++ * @server: the server ++ * @context: the #GMainContext or %NULL for default ++ * ++ * Sets the watch and timeout functions of a #DBusServer ++ * to integrate the server with the GLib main loop. ++ * In most cases the context argument should be %NULL. ++ * ++ * If called twice for the same context, does nothing the second ++ * time. If called once with context A and once with context B, ++ * context B replaces context A as the context monitoring the ++ * connection. ++ */ ++DBUS_GMAIN_FUNCTION (void, ++set_up_server, DBusServer *server, ++ GMainContext *context) ++{ ++ ConnectionSetup *old_setup; ++ ConnectionSetup *cs; ++ ++ /* FIXME we never free the slot, so its refcount just keeps growing, ++ * which is kind of broken. ++ */ ++ dbus_server_allocate_data_slot (&server_slot); ++ if (server_slot < 0) ++ goto nomem; ++ ++ if (context == NULL) ++ context = g_main_context_default (); ++ ++ cs = NULL; ++ ++ old_setup = dbus_server_get_data (server, server_slot); ++ if (old_setup != NULL) ++ { ++ if (old_setup->context == context) ++ return; /* nothing to do */ ++ ++ cs = connection_setup_new_from_old (context, old_setup); ++ ++ /* Nuke the old setup */ ++ if (!dbus_server_set_data (server, server_slot, NULL, NULL)) ++ goto nomem; ++ old_setup = NULL; ++ } ++ ++ if (cs == NULL) ++ cs = connection_setup_new (context, NULL); ++ ++ if (!dbus_server_set_data (server, server_slot, cs, ++ (DBusFreeFunction)connection_setup_free)) ++ goto nomem; ++ ++ if (!dbus_server_set_watch_functions (server, ++ add_watch, ++ remove_watch, ++ watch_toggled, ++ cs, NULL)) ++ goto nomem; ++ ++ if (!dbus_server_set_timeout_functions (server, ++ add_timeout, ++ remove_timeout, ++ timeout_toggled, ++ cs, NULL)) ++ goto nomem; ++ ++ return; ++ ++ nomem: ++ g_error ("Not enough memory to set up DBusServer for use with GLib"); ++} +--- /dev/null ++++ artha/src/dbus-gmain.h +@@ -0,0 +1,60 @@ ++/* -*- mode: C; c-file-style: "gnu" -*- */ ++/* dbus-gmain.h — GLib main loop integration for libdbus ++ * ++ * Copyright (C) 2002, 2003 CodeFactory AB ++ * Copyright (C) 2003, 2004 Red Hat, Inc. ++ * ++ * SPDX-License-Identifier: AFL-2.1 OR GPL-2.0-or-later ++ * ++ * Licensed under the Academic Free License version 2.1 ++ * ++ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ * ++ */ ++#ifndef DBUS_GMAIN_H ++#define DBUS_GMAIN_H ++ ++#ifdef HAVE_CONFIG_H ++#include <config.h> ++#endif ++ ++#include <dbus/dbus.h> ++#include <glib.h> ++ ++#ifndef DBUS_GMAIN_FUNCTION_NAME ++# define DBUS_GMAIN_FUNCTION_NAME(name) dbus_gmain_ ## name ++#endif ++ ++#ifndef DBUS_GMAIN_FUNCTION ++# define DBUS_GMAIN_FUNCTION(ret, name, ...) \ ++ G_GNUC_INTERNAL ret DBUS_GMAIN_FUNCTION_NAME (name) (__VA_ARGS__) ++#endif ++ ++G_BEGIN_DECLS ++ ++DBUS_GMAIN_FUNCTION (void, set_up_connection, ++ DBusConnection *connection, ++ GMainContext *context); ++DBUS_GMAIN_FUNCTION (void, set_up_server, ++ DBusServer *server, ++ GMainContext *context); ++ ++G_END_DECLS ++ ++#endif /* DBUS_GMAIN_H */ ++ ++ ++ ++ +--- artha.orig/src/instance_handler.c ++++ artha/src/instance_handler.c +@@ -31,7 +31,7 @@ + #ifdef DBUS_AVAILABLE + + #include <dbus/dbus.h> +-#include <dbus/dbus-glib-lowlevel.h> ++#include "dbus-gmain.h" + #include <gtk/gtk.h> + + #include "tomboyutil.h" +@@ -80,7 +80,7 @@ + if(dbus_error_is_set(&err)) + goto free_error_and_quit; + +- dbus_connection_setup_with_g_main(bus, NULL); ++ dbus_gmain_set_up_connection(bus, NULL); + + ret_code = dbus_bus_request_name(bus, STR_UNIQUE_BUS_NAME, DBUS_NAME_FLAG_DO_NOT_QUEUE, &err); + if(dbus_error_is_set(&err)) diff --git a/debian/patches/series b/debian/patches/series index f0b7177..c81ab8d 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1,2 +1,3 @@ make_sure_we_really_use_GTK_LIBS.patch spelling.patch +no-dbus-glib.patch -- 2.43.0