source: filezilla/trunk/fuentes/src/dbus/wxdbusmessage.cpp @ 130

Last change on this file since 130 was 130, checked in by jrpelegrina, 4 years ago

First release to xenial

File size: 7.8 KB
Line 
1/****************************************************************************
2
3Copyright (c) 2007 Andrei Borovsky <anb@symmetrica.net>
4
5Permission is hereby granted, free of charge, to any person obtaining a
6copy of this software and associated documentation files (the "Software"),
7to deal in the Software without restriction, including without limitation
8the rights to use, copy, modify, merge, publish, distribute, sublicense,
9and/or sell copies of the Software, and to permit persons to whom the
10Software is furnished to do so, subject to the following conditions:
11
12The above copyright notice and this permission notice shall be included in
13all copies or substantial portions of the Software.
14
15THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21DEALINGS IN THE SOFTWARE.
22
23****************************************************************************/
24
25
26#include "wxdbusmessage.h"
27#include <string.h>
28
29wxDBusMessage::wxDBusMessage(DBusMessage * message)
30        : m_message(message)
31{
32}
33
34wxDBusMessage::~wxDBusMessage()
35{
36        dbus_message_unref(m_message);
37}
38
39wxDBusMessage * wxDBusMessage::ExtractFromEvent(wxDBusConnectionEvent * event)
40{
41        return new wxDBusMessage(event->GetMessage());
42}
43
44unsigned int wxDBusMessage::GetSerial()
45{
46        return dbus_message_get_serial(m_message);
47}
48
49unsigned int wxDBusMessage::GetReplySerial()
50{
51        return dbus_message_get_reply_serial(m_message);
52}
53
54void wxDBusMessage::SetReplySerial(unsigned int serial)
55{
56        dbus_message_set_reply_serial(m_message, serial);
57}
58
59const char * wxDBusMessage::GetPath()
60{
61        return dbus_message_get_path(m_message);
62}
63
64const char * wxDBusMessage::GetMember()
65{
66         return dbus_message_get_member(m_message);
67}
68
69int wxDBusMessage::GetType()
70{
71         return dbus_message_get_type(m_message);
72}
73
74const char * wxDBusMessage::GetInterface()
75{
76        return dbus_message_get_interface(m_message);
77}
78
79DBusMessage * wxDBusMessage::GetMessage()
80{
81        return m_message;
82}
83
84bool wxDBusMessage::MoveToNextArg()
85{
86        if (!m_get_iter_initialized){
87                if (!dbus_message_iter_init(m_message, &m_iter))
88                        return false;
89                m_get_iter_initialized = true;
90                m_add_iter_initialized = false;
91                return true;
92        }
93        return (bool) dbus_message_iter_next(&m_iter);
94}
95
96int wxDBusMessage::GetAgrType()
97{
98        if (!m_get_iter_initialized)
99                MoveToNextArg();
100        return dbus_message_iter_get_arg_type(&m_iter);
101}
102
103void wxDBusMessage::GetArgValue(void * value)
104{
105        if (!m_get_iter_initialized)
106                MoveToNextArg();
107        dbus_message_iter_get_basic(&m_iter, value);
108}
109
110bool wxDBusMessage::GetUInt(wxUint32& u)
111{
112        return dbus_message_get_args(m_message, 0, DBUS_TYPE_UINT32, &u, DBUS_TYPE_INVALID);
113}
114
115const char * wxDBusMessage::GetString()
116{
117        const char * result;
118        if (!dbus_message_get_args(m_message, 0, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID))
119                return 0;
120
121        return result;
122}
123
124const char * wxDBusMessage::GetObjectPath()
125{
126        const char * result;
127        if (!dbus_message_get_args(m_message, 0, DBUS_TYPE_OBJECT_PATH, &result, DBUS_TYPE_INVALID))
128                return 0;
129
130        return result;
131}
132
133int wxDBusMessage::GetArrayElementType()
134{
135        return dbus_message_iter_get_element_type(&m_iter);
136}
137
138/*
139int wxDBusMessage::GetArrayLength()
140{
141        dbus_message_iter_get_array_len(&m_iter);
142}
143*/
144
145void wxDBusMessage::GetFixedArray(void * value, int * n_elements)
146{
147        DBusMessageIter sub;
148        dbus_message_iter_recurse(&m_iter, &sub);
149        dbus_message_iter_get_fixed_array(&sub, value, n_elements);
150}
151
152void wxDBusMessage::init_add_iter()
153{
154        if (!m_add_iter_initialized){
155                dbus_message_iter_init_append(m_message, &m_iter);
156                m_add_iter_initialized = true;
157                m_get_iter_initialized = false;
158        }
159}
160
161bool wxDBusMessage::AddArg(int type, void * value)
162{
163        init_add_iter();
164        return (bool) dbus_message_iter_append_basic(&m_iter, type, value);
165}
166
167bool wxDBusMessage::AddArrayOfString(const char **value, int n_elements)
168{
169        init_add_iter();
170        DBusMessageIter sub;
171        dbus_message_iter_open_container(&m_iter, DBUS_TYPE_ARRAY, "s", &sub);
172        for (int i = 0; i < n_elements; i++)
173        {
174                if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &(value[i])))
175                        return false;
176        }
177        dbus_message_iter_close_container(&m_iter, &sub);
178
179        return true;
180}
181
182bool wxDBusMessage::AddArrayOfByte(int element_type, const void *value, int n_elements)
183{
184        init_add_iter();
185        DBusMessageIter sub;
186        dbus_message_iter_open_container(&m_iter, DBUS_TYPE_ARRAY, "y", &sub);
187        if (!dbus_message_iter_append_fixed_array(&sub, element_type, value, n_elements))
188                return false;
189        dbus_message_iter_close_container(&m_iter, &sub);
190
191        return true;
192}
193
194bool wxDBusMessage::AddDict(const char **value, int n_elements)
195{
196        init_add_iter();
197        DBusMessageIter sub;
198        dbus_message_iter_open_container(&m_iter, DBUS_TYPE_ARRAY,
199                DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
200                &sub);
201        for (int i = 0; i < n_elements; i += 2)
202        {
203                DBusMessageIter dict_iter;
204                dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &dict_iter);
205                if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &(value[i])))
206                        return false;
207                DBusMessageIter variant;
208                dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant);
209                if (!dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &(value[i + 1])))
210                        return false;
211                dbus_message_iter_close_container(&dict_iter, &variant);
212                dbus_message_iter_close_container(&sub, &dict_iter);
213        }
214        dbus_message_iter_close_container(&m_iter, &sub);
215
216        return true;
217}
218
219bool wxDBusMessage::AddString(const char * value)
220{
221        init_add_iter();
222        return (bool) dbus_message_iter_append_basic(&m_iter, DBUS_TYPE_STRING, &value);
223}
224
225bool wxDBusMessage::AddInt(int value)
226{
227        init_add_iter();
228        return (bool) dbus_message_iter_append_basic(&m_iter, DBUS_TYPE_INT32, &value);
229}
230
231bool wxDBusMessage::AddUnsignedInt(unsigned int value)
232{
233        init_add_iter();
234        return (bool) dbus_message_iter_append_basic(&m_iter, DBUS_TYPE_UINT32, &value);
235}
236
237bool wxDBusMessage::AddBool(bool value)
238{
239        init_add_iter();
240        return (bool) dbus_message_iter_append_basic(&m_iter, DBUS_TYPE_BOOLEAN, &value);
241}
242
243bool wxDBusMessage::AddObjectPath(const char* value)
244{
245        init_add_iter();
246        return (bool) dbus_message_iter_append_basic(&m_iter, DBUS_TYPE_OBJECT_PATH, &value);
247}
248
249
250bool wxDBusMessage::Send(wxDBusConnection * connection, unsigned int * serial)
251{
252        return (bool) connection->Send(m_message, serial);
253}
254
255
256wxDBusMethodCall::wxDBusMethodCall(const char *destination, const char *path, const char *interface, const char *method):
257        wxDBusMessage(dbus_message_new_method_call(destination, path, interface, method))
258{
259}
260
261wxDBusMessage * wxDBusMethodCall::Call(wxDBusConnection * connection, int timeout)
262{
263        DBusMessage * result = connection->SendWithReplyAndBlock(GetMessage(), timeout);
264        return result != NULL ? new wxDBusMessage(result) : NULL;
265}
266
267bool wxDBusMethodCall::CallAsync(wxDBusConnection * connection, int timeout)
268{
269        return connection->SendWithReply(GetMessage(), timeout);
270}
271
272wxDBusSignal::wxDBusSignal(const char *path, const char *interface, const char *name) :
273        wxDBusMessage(dbus_message_new_signal(path, interface, name))
274{
275}
276
277wxDBusMethodReturn::wxDBusMethodReturn(wxDBusMessage * method_call) :
278        wxDBusMessage(dbus_message_new_method_return(method_call->GetMessage()))
279{
280}
281
282bool wxDBusMethodReturn::Return(wxDBusConnection * connection, unsigned int * serial)
283{
284        dbus_message_set_no_reply(GetMessage(), TRUE);
285        return (bool) connection->Send(GetMessage(), serial);
286}
287
288wxDBusErrorMessage::wxDBusErrorMessage(wxDBusMessage * reply_to, const char * error_name, const char * error_message) :
289        wxDBusMessage(dbus_message_new_error(reply_to->GetMessage(), error_name, error_message))
290{
291}
Note: See TracBrowser for help on using the repository browser.