ecore-integration.cpp
Go to the documentation of this file.
1/*
2 *
3 * D-Bus++ - C++ bindings for D-Bus
4 *
5 * Copyright (C) 2005-2007 Paolo Durante <shackan@gmail.com>
6 *
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24#ifdef HAVE_CONFIG_H
25#include <config.h>
26#endif
27
29
30#include <dbus/dbus.h> // for DBUS_WATCH_*
31
32using namespace DBus;
33
35
36Ecore::BusTimeout::BusTimeout(Timeout::Internal *ti)
37 : Timeout(ti)
38{
39 if (Timeout::enabled())
40 {
41 _enable();
42 }
43}
44
46{
47 _disable();
48}
49
51{
52 debug_log("ecore: timeout %p toggled (%s)", this, Timeout::enabled() ? "on" : "off");
53
54 if (Timeout::enabled())
55 {
56 _enable();
57 }
58 else
59 {
60 _disable();
61 }
62}
63
65{
66 Ecore::BusTimeout *t = reinterpret_cast<Ecore::BusTimeout *>(data);
67
68 debug_log("Ecore::BusTimeout::timeout_handler( void *data )");
69
70 t->handle();
71
72 return ECORE_CALLBACK_RENEW;
73}
74
76{
77 debug_log("Ecore::BusTimeout::_enable()");
78
79 _etimer = ecore_timer_add(((double)Timeout::interval()) / 1000, timeout_handler, this);
80}
81
83{
84 debug_log("Ecore::BusTimeout::_disable()");
85
86 ecore_timer_del(_etimer);
87}
88
89Ecore::BusWatch::BusWatch(Watch::Internal *wi)
90 : Watch(wi), fd_handler(NULL), _bd(NULL)
91{
92 if (Watch::enabled())
93 {
94 _enable();
95 }
96}
97
99{
100 _disable();
101}
102
104{
105 debug_log("ecore: watch %p toggled (%s)", this, Watch::enabled() ? "on" : "off");
106
107 if (Watch::enabled()) _enable();
108 else _disable();
109}
110
111Eina_Bool Ecore::BusWatch::watch_dispatch(void *data, Ecore_Fd_Handler *fdh)
112{
113 Ecore::BusWatch *w = reinterpret_cast<Ecore::BusWatch *>(data);
114
115 debug_log("Ecore::BusWatch watch_handler");
116
117 int flags = w->flags();
118
119 if (w->flags() & DBUS_WATCH_READABLE)
120 ecore_main_fd_handler_active_set(w->fd_handler, ECORE_FD_READ);
121 if (w->flags() & DBUS_WATCH_WRITABLE)
122 ecore_main_fd_handler_active_set(w->fd_handler, ECORE_FD_WRITE);
123
124 w->handle(flags);
125 w->_bd->dispatch_pending();
126
127 return 1;
128}
129
131{
132 debug_log("Ecore::BusWatch::_enable()");
133
134 fd_handler = ecore_main_fd_handler_add(descriptor(),
135 (Ecore_Fd_Handler_Flags)(ECORE_FD_READ | ECORE_FD_WRITE),
136 watch_dispatch, this,
137 NULL, NULL);
138}
139
141{
142 if (fd_handler)
143 {
144 ecore_main_fd_handler_del(fd_handler);
145 fd_handler = NULL;
146 }
147}
148
150{
151 _bd = bd;
152}
153
157
158Eina_Bool Ecore::BusDispatcher::check(void *data, Ecore_Fd_Handler *fdh)
159{
160 return 0;
161}
162
164{
165 Timeout *t = new Ecore::BusTimeout(wi);
166
167 debug_log("ecore: added timeout %p (%s)", t, t->enabled() ? "on" : "off");
168
169 return t;
170}
171
173{
174 debug_log("ecore: removed timeout %p", t);
175
176 delete t;
177}
178
180{
181 Ecore::BusWatch *w = new Ecore::BusWatch(wi);
182 w->data(this);
183
184 debug_log("ecore: added watch %p (%s) fd=%d flags=%d",
185 w, w->enabled() ? "on" : "off", w->descriptor(), w->flags()
186 );
187 return w;
188}
189
191{
192 debug_log("ecore: removed watch %p", w);
193
194 delete w;
195}
static Eina_Bool check(void *data, Ecore_Fd_Handler *fdh)
Timeout * add_timeout(Timeout::Internal *)
Watch * add_watch(Watch::Internal *)
BusTimeout(Timeout::Internal *)
static Eina_Bool timeout_handler(void *)
void data(Ecore::BusDispatcher *bd)
Ecore::BusDispatcher * _bd
BusWatch(Watch::Internal *)
static Eina_Bool watch_dispatch(void *data, Ecore_Fd_Handler *fdh)
Ecore_Fd_Handler * fd_handler
bool enabled() const
int interval() const
Gets the timeout interval.
bool handle()
Calls the timeout handler for this timeout.
bool enabled() const
int flags() const
Gets flags from DBusWatchFlags indicating what conditions should be monitored on the file descriptor.
bool handle(int flags)
Called to notify the D-Bus library when a previously-added watch is ready for reading or writing,...
int descriptor() const
A main loop could poll this descriptor to integrate dbus-c++.
Dispatcher * gdispatcher
static gboolean watch_dispatch(GSource *source, GSourceFunc callback, gpointer data)
DXXAPI LogFunction debug_log
Definition debug.cpp:55