Bug#955873: artha: Depends on deprecated dbus-glib
Yavor Doganov
yavor at gnu.org
Thu Mar 7 22:53:06 GMT 2024
Control: tags -1 + patch
Please find attached a patch.
-------------- next part --------------
>From 6c94fcfbf0dc45114602312c8bc6f1bededbf840 Mon Sep 17 00:00:00 2001
From: Yavor Doganov <yavor at 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 <yavor at 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 <yavor at 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
More information about the debian-science-maintainers
mailing list